Patching patched patches

patches/server/0014-Starlight.patch

@@ -5091,7 +5091,7 @@ index 92a64c49b1c7227a5b34488ea15d3d8adb0f9c80..0b67858f8d6689b34816f9556f3424af
          this.fluidTicks = fluidTickScheduler;
      }
 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 6fdd5c92ab069896e3921faa042cbdb3c29d0538..942f8db571cf87d0e9614bdc7dd9525068cf1001 100644
+index 6fdd5c92ab069896e3921faa042cbdb3c29d0538..a3c14a470ac7055abd00ac6f4f1c02065a485d3b 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
 @@ -84,6 +84,14 @@ public class ChunkSerializer {
@@ -5120,8 +5120,7 @@ index 6fdd5c92ab069896e3921faa042cbdb3c29d0538..942f8db571cf87d0e9614bdc7dd95250
          LevelChunkSection[] achunksection = new LevelChunkSection[i];
          boolean flag1 = world.dimensionType().hasSkyLight();
          ServerChunkCache chunkproviderserver = world.getChunkSource();
--        LevelLightEngine lightengine = chunkproviderserver.getLightEngine();
-+        LevelLightEngine lightengine = chunkproviderserver.getLightEngine();;
+         LevelLightEngine lightengine = chunkproviderserver.getLightEngine();
 +        // Paper start
 +        ca.spottedleaf.starlight.common.light.SWMRNibbleArray[] blockNibbles = ca.spottedleaf.starlight.common.light.StarLightEngine.getFilledEmptyLight(world);
 +        ca.spottedleaf.starlight.common.light.SWMRNibbleArray[] skyNibbles = ca.spottedleaf.starlight.common.light.StarLightEngine.getFilledEmptyLight(world);

patches/server/0233-AnvilDamageEvent.patch

@@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Fri, 20 Jul 2018 23:37:03 -0500
+Subject: [PATCH] AnvilDamageEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/inventory/AnvilMenu.java b/src/main/java/net/minecraft/world/inventory/AnvilMenu.java
+index c5f1076a758b396a9d5726754cbfb470ff912f8b..eb22059fe008c3d3fc0364a7f85f91b4cca8b328 100644
+--- a/src/main/java/net/minecraft/world/inventory/AnvilMenu.java
++++ b/src/main/java/net/minecraft/world/inventory/AnvilMenu.java
+@@ -89,6 +89,16 @@ public class AnvilMenu extends ItemCombinerMenu {
+             if (!player.getAbilities().instabuild && iblockdata.is(BlockTags.ANVIL) && player.getRandom().nextFloat() < 0.12F) {
+                 BlockState iblockdata1 = AnvilBlock.damage(iblockdata);
+ 
++                // Paper start
++                com.destroystokyo.paper.event.block.AnvilDamagedEvent event = new com.destroystokyo.paper.event.block.AnvilDamagedEvent(getBukkitView(), iblockdata1 != null ? org.bukkit.craftbukkit.block.data.CraftBlockData.fromData(iblockdata1) : null);
++                if (!event.callEvent()) {
++                    return;
++                } else if (event.getDamageState() == com.destroystokyo.paper.event.block.AnvilDamagedEvent.DamageState.BROKEN) {
++                    iblockdata1 = null;
++                } else {
++                    iblockdata1 = ((org.bukkit.craftbukkit.block.data.CraftBlockData) event.getDamageState().getMaterial().createBlockData()).getState().setValue(AnvilBlock.FACING, iblockdata.getValue(AnvilBlock.FACING));
++                }
++                // Paper end
+                 if (iblockdata1 == null) {
+                     world.removeBlock(blockposition, false);
+                     world.levelEvent(1029, blockposition, 0);

patches/server/0234-Add-TNTPrimeEvent.patch

@@ -0,0 +1,113 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mark Vainomaa <mikroskeem@mikroskeem.eu>
+Date: Mon, 16 Jul 2018 00:05:05 +0300
+Subject: [PATCH] Add TNTPrimeEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
+index a889be9dd2a94b531a227ff69a5e761e103067be..d8c9beab9163820df949f6002bbb9224a044c6f3 100644
+--- a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
++++ b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
+@@ -532,6 +532,11 @@ public class EnderDragon extends Mob implements Enemy {
+                     });
+                     craftBlock.getNMS().spawnAfterBreak((ServerLevel) level, blockposition, ItemStack.EMPTY, false);
+                 }
++                // Paper start - TNTPrimeEvent
++                org.bukkit.block.Block tntBlock = level.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
++                if(!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.EXPLOSION, explosionSource.getSourceMob().getBukkitEntity()).callEvent())
++                    continue;
++                // Paper end
+                 nmsBlock.wasExploded(level, blockposition, explosionSource);
+ 
+                 this.level.removeBlock(blockposition, false);
+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 e725168ebce3d1b2548a1bc5baa612a6e718e337..7e48326b6dc847a84e0aff2d393cadf9bace7979 100644
+--- a/src/main/java/net/minecraft/world/level/block/FireBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/FireBlock.java
+@@ -290,12 +290,19 @@ public class FireBlock extends BaseFireBlock {
+ 
+                 world.setBlock(blockposition, this.getStateWithAge(world, blockposition, l), 3);
+             } else {
+-                world.removeBlock(blockposition, false);
++                if(iblockdata.getBlock() != Blocks.TNT) world.removeBlock(blockposition, false); // Paper - TNTPrimeEvent - We might be cancelling it below, move the setAir down
+             }
+ 
+             Block block = iblockdata.getBlock();
+ 
+             if (block instanceof TntBlock) {
++                // Paper start - TNTPrimeEvent
++                org.bukkit.block.Block tntBlock = io.papermc.paper.util.MCUtil.toBukkitBlock(world, blockposition);
++                if (!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.FIRE, null).callEvent()) {
++                    return;
++                }
++                world.removeBlock(blockposition, false);
++                // Paper end
+                 TntBlock.explode(world, blockposition);
+             }
+         }
+diff --git a/src/main/java/net/minecraft/world/level/block/TntBlock.java b/src/main/java/net/minecraft/world/level/block/TntBlock.java
+index f5b685cb678f523c1c07d72b818ada93af64840a..ade39e877edbb07082bb2d87e00ae4bfb6ab1c8f 100644
+--- a/src/main/java/net/minecraft/world/level/block/TntBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/TntBlock.java
+@@ -38,6 +38,11 @@ public class TntBlock extends Block {
+     public void onPlace(BlockState state, Level world, BlockPos pos, BlockState oldState, boolean notify) {
+         if (!oldState.is(state.getBlock())) {
+             if (world.hasNeighborSignal(pos)) {
++                // Paper start - TNTPrimeEvent
++                org.bukkit.block.Block tntBlock = io.papermc.paper.util.MCUtil.toBukkitBlock(world, pos);;
++                if(!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.REDSTONE, null).callEvent())
++                    return;
++                // Paper end
+                 TntBlock.explode(world, pos);
+                 world.removeBlock(pos, false);
+             }
+@@ -48,6 +53,11 @@ public class TntBlock extends Block {
+     @Override
+     public void neighborChanged(BlockState state, Level world, BlockPos pos, Block sourceBlock, BlockPos sourcePos, boolean notify) {
+         if (world.hasNeighborSignal(pos)) {
++            // Paper start - TNTPrimeEvent
++            org.bukkit.block.Block tntBlock = io.papermc.paper.util.MCUtil.toBukkitBlock(world, pos);;
++            if(!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.REDSTONE, null).callEvent())
++                return;
++            // Paper end
+             TntBlock.explode(world, pos);
+             world.removeBlock(pos, false);
+         }
+@@ -66,6 +76,12 @@ public class TntBlock extends Block {
+     @Override
+     public void wasExploded(Level world, BlockPos pos, Explosion explosion) {
+         if (!world.isClientSide) {
++            // Paper start - TNTPrimeEvent
++            org.bukkit.block.Block tntBlock = io.papermc.paper.util.MCUtil.toBukkitBlock(world, pos);
++            org.bukkit.entity.Entity source = explosion.source != null ? explosion.source.getBukkitEntity() : null;
++            if(!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.EXPLOSION, source).callEvent())
++                return;
++            // Paper end
+             PrimedTnt entitytntprimed = new PrimedTnt(world, (double) pos.getX() + 0.5D, (double) pos.getY(), (double) pos.getZ() + 0.5D, explosion.getIndirectSourceEntity());
+             int i = entitytntprimed.getFuse();
+ 
+@@ -95,6 +111,11 @@ public class TntBlock extends Block {
+         if (!itemstack.is(Items.FLINT_AND_STEEL) && !itemstack.is(Items.FIRE_CHARGE)) {
+             return super.use(state, world, pos, player, hand, hit);
+         } else {
++            // Paper start - TNTPrimeEvent
++            org.bukkit.block.Block tntBlock = io.papermc.paper.util.MCUtil.toBukkitBlock(world, pos);
++            if(!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.ITEM, player.getBukkitEntity()).callEvent())
++                return InteractionResult.FAIL;
++            // Paper end
+             TntBlock.explode(world, pos, player);
+             world.setBlock(pos, Blocks.AIR.defaultBlockState(), 11);
+             Item item = itemstack.getItem();
+@@ -126,6 +147,12 @@ public class TntBlock extends Block {
+                     return;
+                 }
+                 // CraftBukkit end
++                // Paper start - TNTPrimeEvent
++                org.bukkit.block.Block tntBlock = io.papermc.paper.util.MCUtil.toBukkitBlock(world, blockposition);
++                if (!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.PROJECTILE, projectile.getBukkitEntity()).callEvent()) {
++                    return;
++                }
++                // Paper end
+                 TntBlock.explode(world, blockposition, entity instanceof LivingEntity ? (LivingEntity) entity : null);
+                 world.removeBlock(blockposition, false);
+             }

patches/server/0235-Break-up-and-make-tab-spam-limits-configurable.patch

@@ -0,0 +1,52 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Sun, 29 Jul 2018 05:02:15 +0100
+Subject: [PATCH] Break up and make tab spam limits configurable
+
+Due to the changes in 1.13, clients will send a tab completion request
+for all bukkit commands in order to factor in the lack of support for
+brigadier and provide backwards support in the API.
+
+Craftbukkit, however; has moved the chat spam limiter to also interact
+with the tab completion request, which while good for avoiding abuse,
+causes 1.13 clients to easilly be kicked from a server in bukkit due
+to this. Removing the spam limit could cause issues for servers, however,
+there is no way for servers to manipulate this without blindly cancelling
+kick events, which only causes additional complications. This also causes
+issues in that the tab spam limit and chat share the same field but different
+limits, meaning that a player having typed a long command may be kicked from
+the server.
+
+Splitting the field up and making it configurable allows for server owners
+to take the burden of this into their own hand without having to rely on
+plugins doing unsafe things.
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 867478671d3223338bf01a36da0361a5ae1f38be..c5ad4d8a08f03a6f75241f4e4913d84bcb0fdf0b 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -261,6 +261,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+     private long keepAliveChallenge;
+     // CraftBukkit start - multithreaded fields
+     private final AtomicInteger chatSpamTickCount = new AtomicInteger();
++    private final java.util.concurrent.atomic.AtomicInteger tabSpamLimiter = new java.util.concurrent.atomic.AtomicInteger(); // Paper - configurable tab spam limits
+     // CraftBukkit end
+     private int dropSpamTickCount;
+     private double firstGoodX;
+@@ -409,6 +410,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+         this.server.getProfiler().pop();
+         // CraftBukkit start
+         for (int spam; (spam = this.chatSpamTickCount.get()) > 0 && !this.chatSpamTickCount.compareAndSet(spam, spam - 1); ) ;
++        if (tabSpamLimiter.get() > 0) tabSpamLimiter.getAndDecrement(); // Paper - split to seperate variable
+         /* Use thread-safe field access instead
+         if (this.chatSpamTickCount > 0) {
+             --this.chatSpamTickCount;
+@@ -785,7 +787,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+     public void handleCustomCommandSuggestions(ServerboundCommandSuggestionPacket packet) {
+         // PacketUtils.ensureRunningOnSameThread(packet, this, this.player.getLevel()); // Paper - run this async
+         // CraftBukkit start
+-        if (this.chatSpamTickCount.addAndGet(1) > 500 && !this.server.getPlayerList().isOp(this.player.getGameProfile())) {
++        if (this.chatSpamTickCount.addAndGet(io.papermc.paper.configuration.GlobalConfiguration.get().spamLimiter.tabSpamIncrement) > io.papermc.paper.configuration.GlobalConfiguration.get().spamLimiter.tabSpamLimit && !this.server.getPlayerList().isOp(this.player.getGameProfile())) { // Paper start - split and make configurable
+             server.scheduleOnMain(() -> this.disconnect(Component.translatable("disconnect.spam", new Object[0]))); // Paper
+             return;
+         }

patches/server/0236-Fix-NBT-type-issues.patch

@@ -0,0 +1,44 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Fri, 3 Aug 2018 00:04:54 -0400
+Subject: [PATCH] Fix NBT type issues
+
+Addresses two issues:
+- MC-135506: Experience should save as Integers
+- Allay duplication cooldown is saved and exposed as a long, but loaded as an int
+
+diff --git a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+index cc3c1d6b76f66cd0f511c5fd57ffa606eba0d387..cf5c7e8557b0084039a94ef881a36aa9e3f58daf 100644
+--- a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
++++ b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+@@ -287,7 +287,7 @@ public class ExperienceOrb extends Entity {
+     public void addAdditionalSaveData(CompoundTag nbt) {
+         nbt.putShort("Health", (short) this.health);
+         nbt.putShort("Age", (short) this.age);
+-        nbt.putShort("Value", (short) this.value);
++        nbt.putInt("Value", this.value); // Paper - save as Integer
+         nbt.putInt("Count", this.count);
+         this.savePaperNBT(nbt); // Paper
+     }
+@@ -296,7 +296,7 @@ public class ExperienceOrb extends Entity {
+     public void readAdditionalSaveData(CompoundTag nbt) {
+         this.health = nbt.getShort("Health");
+         this.age = nbt.getShort("Age");
+-        this.value = nbt.getShort("Value");
++        this.value = nbt.getInt("Value"); // Paper - load as Integer
+         this.count = Math.max(nbt.getInt("Count"), 1);
+         this.loadPaperNBT(nbt); // Paper
+     }
+diff --git a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java
+index fec05f88720fa09ed9361fd24f5abfa134013d6c..c0084b1f146a4697194c421519537e612ff737c0 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java
++++ b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java
+@@ -521,7 +521,7 @@ public class Allay extends PathfinderMob implements InventoryCarrier {
+             });
+         }
+ 
+-        this.duplicationCooldown = (long) nbt.getInt("DuplicationCooldown");
++        this.duplicationCooldown = nbt.getLong("DuplicationCooldown"); // Paper - Load as long
+         this.entityData.set(Allay.DATA_CAN_DUPLICATE, nbt.getBoolean("CanDuplicate"));
+     }
+ 

patches/server/0237-Remove-unnecessary-itemmeta-handling.patch

@@ -0,0 +1,28 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 22 Nov 2016 00:40:42 -0500
+Subject: [PATCH] Remove unnecessary itemmeta handling
+
+
+diff --git a/src/main/java/net/minecraft/network/FriendlyByteBuf.java b/src/main/java/net/minecraft/network/FriendlyByteBuf.java
+index 76914b08c17a62a117319d458a6693070fc46348..32ee4ed11aefd82dca2e3e78b3108f041fdc3695 100644
+--- a/src/main/java/net/minecraft/network/FriendlyByteBuf.java
++++ b/src/main/java/net/minecraft/network/FriendlyByteBuf.java
+@@ -641,7 +641,7 @@ public class FriendlyByteBuf extends ByteBuf {
+             if (item.canBeDepleted() || item.shouldOverrideMultiplayerNbt()) {
+                 // Spigot start - filter
+                 stack = stack.copy();
+-                CraftItemStack.setItemMeta(stack, CraftItemStack.getItemMeta(stack));
++                // CraftItemStack.setItemMeta(stack, CraftItemStack.getItemMeta(stack)); // Paper - This is no longer with raw NBT being handled in metadata
+                 // Spigot end
+                 nbttagcompound = stack.getTag();
+             }
+@@ -662,7 +662,7 @@ public class FriendlyByteBuf extends ByteBuf {
+ 
+             itemstack.setTag(this.readNbt());
+             // CraftBukkit start
+-            if (itemstack.getTag() != null) {
++            if (false && itemstack.getTag() != null) { // Paper - This is no longer needed with raw NBT being handled in metadata
+                 CraftItemStack.setItemMeta(itemstack, CraftItemStack.getItemMeta(itemstack));
+             }
+             // CraftBukkit end

patches/server/0238-Add-Debug-Entities-option-to-debug-dupe-uuid-issues.patch

@@ -0,0 +1,129 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sat, 21 Jul 2018 08:25:40 -0400
+Subject: [PATCH] Add Debug Entities option to debug dupe uuid issues
+
+Add -Ddebug.entities=true to your JVM flags to gain more information
+
+1.17: Needs to be reworked for new entity storage system
+
+diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
+index c6706c3d7841869134be89dd09ea723820d306a2..23bbd70dd2dd487caf972c2b1a6c85a1caa3fbcd 100644
+--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
++++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
+@@ -896,6 +896,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+                 } else {
+                     ChunkMap.TrackedEntity playerchunkmap_entitytracker = new ChunkMap.TrackedEntity(entity, i, j, entitytypes.trackDeltas());
+ 
++                    entity.tracker = playerchunkmap_entitytracker; // Paper - Fast access to tracker
+                     this.entityMap.put(entity.getId(), playerchunkmap_entitytracker);
+                     playerchunkmap_entitytracker.updatePlayers(this.level.players());
+                     if (entity instanceof ServerPlayer) {
+@@ -938,7 +939,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+         if (playerchunkmap_entitytracker1 != null) {
+             playerchunkmap_entitytracker1.broadcastRemoved();
+         }
+-
++        entity.tracker = null; // Paper - We're no longer tracked
+     }
+ 
+     protected void tick() {
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index c27ceaf1b9685f1433799d50bacc361db793c1d5..f2b20fe0770b519756342c7b900919c6a9d93bdb 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -219,6 +219,9 @@ public class ServerLevel extends Level implements WorldGenLevel {
+     public final LevelStorageSource.LevelStorageAccess convertable;
+     public final UUID uuid;
+     public boolean hasPhysicsEvent = true; // Paper
++    public static Throwable getAddToWorldStackTrace(Entity entity) {
++        return new Throwable(entity + " Added to world at " + new java.util.Date());
++    }
+ 
+     @Override public LevelChunk getChunkIfLoaded(int x, int z) { // Paper - this was added in world too but keeping here for NMS ABI
+         return this.chunkSource.getChunk(x, z, false);
+@@ -1272,7 +1275,28 @@ public class ServerLevel extends Level implements WorldGenLevel {
+     // CraftBukkit start
+     private boolean addEntity(Entity entity, CreatureSpawnEvent.SpawnReason spawnReason) {
+         org.spigotmc.AsyncCatcher.catchOp("entity add"); // Spigot
++        // Paper start
++        if (entity.valid) {
++            MinecraftServer.LOGGER.error("Attempted Double World add on " + entity, new Throwable());
++
++            if (DEBUG_ENTITIES) {
++                Throwable thr = entity.addedToWorldStack;
++                if (thr == null) {
++                    MinecraftServer.LOGGER.error("Double add entity has no add stacktrace");
++                } else {
++                    MinecraftServer.LOGGER.error("Double add stacktrace: ", thr);
++                }
++            }
++            return true;
++        }
++        // Paper end
+         if (entity.isRemoved()) {
++            // Paper start
++            if (DEBUG_ENTITIES) {
++                new Throwable("Tried to add entity " + entity + " but it was marked as removed already").printStackTrace(); // CraftBukkit
++                getAddToWorldStackTrace(entity).printStackTrace();
++            }
++            // Paper end
+             // WorldServer.LOGGER.warn("Tried to add entity {} but it was marked as removed already", EntityTypes.getKey(entity.getType())); // CraftBukkit
+             return false;
+         } else {
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index ac6bd21798192c4c07737a2320c3626caebc7e22..b8257959acd2b38243fd259f367564080aff951e 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -235,6 +235,8 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+     public com.destroystokyo.paper.loottable.PaperLootableInventoryData lootableData; // Paper
+     private CraftEntity bukkitEntity;
+ 
++    public @org.jetbrains.annotations.Nullable net.minecraft.server.level.ChunkMap.TrackedEntity tracker; // Paper
++    public @Nullable Throwable addedToWorldStack; // Paper - entity debug
+     public CraftEntity getBukkitEntity() {
+         if (this.bukkitEntity == null) {
+             this.bukkitEntity = CraftEntity.getEntity(this.level.getCraftServer(), this);
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 808a025548fd390ef4d657c53eb9bf73e73dbc93..638a77d3ea65b509b9fcdd3c1e3ea0abe5b7566f 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
++++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -147,6 +147,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+     public boolean pvpMode;
+     public boolean keepSpawnInMemory = true;
+     public org.bukkit.generator.ChunkGenerator generator;
++    public static final boolean DEBUG_ENTITIES = Boolean.getBoolean("debug.entities"); // Paper
+ 
+     public boolean preventPoiUpdated = false; // CraftBukkit - SPIGOT-5710
+     public boolean captureBlockStates = false;
+diff --git a/src/main/java/net/minecraft/world/level/entity/EntityLookup.java b/src/main/java/net/minecraft/world/level/entity/EntityLookup.java
+index 21a2800db22f287b9c6a8290326fdf3b94ae94b1..d45d832232be5017dde53816191c2b1830a0da32 100644
+--- a/src/main/java/net/minecraft/world/level/entity/EntityLookup.java
++++ b/src/main/java/net/minecraft/world/level/entity/EntityLookup.java
+@@ -34,6 +34,26 @@ public class EntityLookup<T extends EntityAccess> {
+         UUID uUID = entity.getUUID();
+         if (this.byUuid.containsKey(uUID)) {
+             LOGGER.warn("Duplicate entity UUID {}: {}", uUID, entity);
++            // Paper start - extra debug info
++            if (entity instanceof net.minecraft.world.entity.Entity entityCast) {
++                if (net.minecraft.server.level.ServerLevel.DEBUG_ENTITIES) {
++                    entityCast.addedToWorldStack = net.minecraft.server.level.ServerLevel.getAddToWorldStackTrace(entityCast);
++                }
++
++                T old = this.byUuid.get(entity.getUUID());
++                if (old instanceof net.minecraft.world.entity.Entity oldCast && old != null && oldCast.getId() != entity.getId() && oldCast.valid) {
++                    LOGGER.error("Overwrote an existing entity " + oldCast + " with " + entity);
++                    if (net.minecraft.server.level.ServerLevel.DEBUG_ENTITIES) {
++                        if (oldCast.addedToWorldStack != null) {
++                            oldCast.addedToWorldStack.printStackTrace();
++                        } else {
++                            LOGGER.error("Oddly, the old entity was not added to the world in the normal way. Plugins?");
++                        }
++                        entityCast.addedToWorldStack.printStackTrace();
++                    }
++                }
++            }
++            // Paper end
+         } else {
+             this.byUuid.put(uUID, entity);
+             this.byId.put(entity.getId(), entity);

patches/server/0239-Add-Early-Warning-Feature-to-WatchDog.patch

@@ -0,0 +1,160 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: miclebrick <miclebrick@outlook.com>
+Date: Wed, 8 Aug 2018 15:30:52 -0400
+Subject: [PATCH] Add Early Warning Feature to WatchDog
+
+Detect when the server has been hung for a long duration, and start printing
+thread dumps at an interval until the point of crash.
+
+This will help diagnose what was going on in that time before the crash.
+
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 2b55df58684a19519335666858bc79de8067faf7..6026a2da9645a5f22aa18c74e35d8b76a3f29352 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1051,6 +1051,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             this.updateStatusIcon(this.status);
+ 
+             // Spigot start
++            org.spigotmc.WatchdogThread.hasStarted = true; // Paper
+             Arrays.fill( recentTps, 20 );
+             long start = System.nanoTime(), curTime, tickSection = start; // Paper - Further improve server tick loop
+             lastTick = start - TICK_TIME; // Paper
+diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+index e6826cd0a596f063e8737dcde3c8c6c5b3f71970..1a2607d1b257cea65c82c661a6b3d46c1526a775 100644
+--- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
++++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -197,6 +197,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+         // Paper start
+         paperConfigurations.initializeGlobalConfiguration();
+         paperConfigurations.initializeWorldDefaultsConfiguration();
++        org.spigotmc.WatchdogThread.doStart(org.spigotmc.SpigotConfig.timeoutTime, org.spigotmc.SpigotConfig.restartOnCrash);
+         io.papermc.paper.command.PaperCommands.registerCommands(this);
+         com.destroystokyo.paper.Metrics.PaperMetrics.startMetrics();
+         com.destroystokyo.paper.VersionHistoryManager.INSTANCE.getClass(); // load version history now
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 1c8a103d70ddb7d178057d48abddf75c69f789b7..dc9fce11cb5b76b9e29c0f50c90c96fdf0b830ce 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -924,6 +924,7 @@ public final class CraftServer implements Server {
+ 
+     @Override
+     public void reload() {
++        org.spigotmc.WatchdogThread.hasStarted = false; // Paper - Disable watchdog early timeout on reload
+         this.reloadCount++;
+         this.configuration = YamlConfiguration.loadConfiguration(this.getConfigFile());
+         this.commandsConfiguration = YamlConfiguration.loadConfiguration(this.getCommandsConfigFile());
+@@ -1012,6 +1013,7 @@ public final class CraftServer implements Server {
+         this.enablePlugins(PluginLoadOrder.STARTUP);
+         this.enablePlugins(PluginLoadOrder.POSTWORLD);
+         this.getPluginManager().callEvent(new ServerLoadEvent(ServerLoadEvent.LoadType.RELOAD));
++        org.spigotmc.WatchdogThread.hasStarted = true; // Paper - Disable watchdog early timeout on reload
+     }
+ 
+     @Override
+diff --git a/src/main/java/org/spigotmc/SpigotConfig.java b/src/main/java/org/spigotmc/SpigotConfig.java
+index ddc5f2d9aa7dda6aff132392927e3d7e3674dbff..3ac48dafe2300ff4cf4591569fec9ce4916503cd 100644
+--- a/src/main/java/org/spigotmc/SpigotConfig.java
++++ b/src/main/java/org/spigotmc/SpigotConfig.java
+@@ -229,7 +229,7 @@ public class SpigotConfig
+         SpigotConfig.restartScript = SpigotConfig.getString( "settings.restart-script", SpigotConfig.restartScript );
+         SpigotConfig.restartMessage = SpigotConfig.transform( SpigotConfig.getString( "messages.restart", "Server is restarting" ) );
+         SpigotConfig.commands.put( "restart", new RestartCommand( "restart" ) );
+-        WatchdogThread.doStart( timeoutTime, restartOnCrash );
++        // WatchdogThread.doStart( timeoutTime, restartOnCrash ); // Paper - moved to after paper config initialization
+     }
+ 
+     public static boolean bungee;
+diff --git a/src/main/java/org/spigotmc/WatchdogThread.java b/src/main/java/org/spigotmc/WatchdogThread.java
+index a9897c494b3dc56d900356d74030359832febbaa..b47d043144c499b1499f6b4be5a16a3f75c9fcb8 100644
+--- a/src/main/java/org/spigotmc/WatchdogThread.java
++++ b/src/main/java/org/spigotmc/WatchdogThread.java
+@@ -14,6 +14,10 @@ public final class WatchdogThread extends io.papermc.paper.util.TickThread // Pa
+     private static WatchdogThread instance;
+     private long timeoutTime;
+     private boolean restart;
++    private final long earlyWarningEvery; // Paper - Timeout time for just printing a dump but not restarting
++    private final long earlyWarningDelay; // Paper
++    public static volatile boolean hasStarted; // Paper
++    private long lastEarlyWarning; // Paper - Keep track of short dump times to avoid spamming console with short dumps
+     private volatile long lastTick;
+     private volatile boolean stopping;
+ 
+@@ -22,6 +26,8 @@ public final class WatchdogThread extends io.papermc.paper.util.TickThread // Pa
+         super( "Paper Watchdog Thread" );
+         this.timeoutTime = timeoutTime;
+         this.restart = restart;
++        earlyWarningEvery = Math.min(io.papermc.paper.configuration.GlobalConfiguration.get().watchdog.earlyWarningEvery, timeoutTime); // Paper
++        earlyWarningDelay = Math.min(io.papermc.paper.configuration.GlobalConfiguration.get().watchdog.earlyWarningDelay, timeoutTime); // Paper
+     }
+ 
+     private static long monotonicMillis()
+@@ -61,9 +67,18 @@ public final class WatchdogThread extends io.papermc.paper.util.TickThread // Pa
+         while ( !this.stopping )
+         {
+             //
+-            if ( this.lastTick != 0 && this.timeoutTime > 0 && WatchdogThread.monotonicMillis() > this.lastTick + this.timeoutTime && !Boolean.getBoolean("disable.watchdog")) // Paper - Add property to disable
++            // Paper start
++            Logger log = Bukkit.getServer().getLogger();
++            long currentTime = WatchdogThread.monotonicMillis();
++            if ( this.lastTick != 0 && this.timeoutTime > 0 && currentTime > this.lastTick + this.earlyWarningEvery && !Boolean.getBoolean("disable.watchdog")) // Paper - Add property to disable
+             {
+-                Logger log = Bukkit.getServer().getLogger();
++                boolean isLongTimeout = currentTime > lastTick + timeoutTime;
++                // Don't spam early warning dumps
++                if ( !isLongTimeout && (earlyWarningEvery <= 0 || !hasStarted || currentTime < lastEarlyWarning + earlyWarningEvery || currentTime < lastTick + earlyWarningDelay)) continue;
++                if ( !isLongTimeout && MinecraftServer.getServer().hasStopped()) continue; // Don't spam early watchdog warnings during shutdown, we'll come back to this...
++                lastEarlyWarning = currentTime;
++                if (isLongTimeout) {
++                // Paper end
+                 log.log( Level.SEVERE, "------------------------------" );
+                 log.log( Level.SEVERE, "The server has stopped responding! This is (probably) not a Paper bug." ); // Paper
+                 log.log( Level.SEVERE, "If you see a plugin in the Server thread dump below, then please report it to that author" );
+@@ -93,30 +108,46 @@ public final class WatchdogThread extends io.papermc.paper.util.TickThread // Pa
+                     }
+                 }
+                 // Paper end
++                } else
++                {
++                    log.log(Level.SEVERE, "--- DO NOT REPORT THIS TO PAPER - THIS IS NOT A BUG OR A CRASH  - " + Bukkit.getServer().getVersion() + " ---");
++                    log.log(Level.SEVERE, "The server has not responded for " + (currentTime - lastTick) / 1000 + " seconds! Creating thread dump");
++                }
++                // Paper end - Different message for short timeout
+                 log.log( Level.SEVERE, "------------------------------" );
+                 log.log( Level.SEVERE, "Server thread dump (Look for plugins here before reporting to Paper!):" ); // Paper
+                 io.papermc.paper.chunk.system.scheduling.ChunkTaskScheduler.dumpAllChunkLoadInfo(isLongTimeout); // Paper // Paper - rewrite chunk system
+                 WatchdogThread.dumpThread( ManagementFactory.getThreadMXBean().getThreadInfo( MinecraftServer.getServer().serverThread.getId(), Integer.MAX_VALUE ), log );
+                 log.log( Level.SEVERE, "------------------------------" );
+                 //
++                // Paper start - Only print full dump on long timeouts
++                if ( isLongTimeout )
++                {
+                 log.log( Level.SEVERE, "Entire Thread Dump:" );
+                 ThreadInfo[] threads = ManagementFactory.getThreadMXBean().dumpAllThreads( true, true );
+                 for ( ThreadInfo thread : threads )
+                 {
+                     WatchdogThread.dumpThread( thread, log );
+                 }
++                } else {
++                    log.log(Level.SEVERE, "--- DO NOT REPORT THIS TO PAPER - THIS IS NOT A BUG OR A CRASH ---");
++                }
++
+                 log.log( Level.SEVERE, "------------------------------" );
+ 
++                if ( isLongTimeout )
++                {
+                 if ( this.restart && !MinecraftServer.getServer().hasStopped() )
+                 {
+                     RestartCommand.restart();
+                 }
+                 break;
++                } // Paper end
+             }
+ 
+             try
+             {
+-                sleep( 10000 );
++                sleep( 1000 ); // Paper - Reduce check time to every second instead of every ten seconds, more consistent and allows for short timeout
+             } catch ( InterruptedException ex )
+             {
+                 interrupt();

patches/server/0240-Use-ConcurrentHashMap-in-JsonList.patch

@@ -0,0 +1,140 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: egg82 <phantom_zero@ymail.com>
+Date: Tue, 7 Aug 2018 01:24:23 -0600
+Subject: [PATCH] Use ConcurrentHashMap in JsonList
+
+This is specifically aimed at fixing #471
+
+Using a ConcurrentHashMap because thread safety
+The performance benefit of Map over ConcurrentMap is negligabe at best in this scenaio, as most operations will be get and not add or remove
+Even without considering the use-case the benefits are still negligable
+
+Original ideas for the system included an expiration policy and/or handler
+The simpler solution was to use a computeIfPresent in the get method
+This will simultaneously have an O(1) lookup time and automatically expire any values
+Since the get method (nor other similar methods) don't seem to have a critical need to flush the map to disk at any of these points further processing is simply wasteful
+Meaning the original function expired values unrelated to the current value without actually having any explicit need to
+
+The h method was heavily modified to be much more efficient in its processing
+Also instead of being called on every get, it's now called just before a save
+This will eliminate stale values being flushed to disk
+
+Modified isEmpty to use the isEmpty() method instead of the slightly confusing size() < 1
+The point of this is readability, but does have a side-benefit of a small microptimization
+
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 0f33c4bf3cb52f192d5dfe8b55a72c7a5a2f9311..52708bcdc046cc0a7f3798bfef06e49a6215acfd 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
++++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -632,7 +632,7 @@ public abstract class PlayerList {
+         } else if (!this.isWhiteListed(gameprofile, event)) { // Paper
+             //ichatmutablecomponent = Component.translatable("multiplayer.disconnect.not_whitelisted"); // Paper
+             //event.disallow(PlayerLoginEvent.Result.KICK_WHITELIST, net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(org.spigotmc.SpigotConfig.whitelistMessage)); // Spigot // Paper - Adventure - moved to isWhitelisted
+-        } else if (this.getIpBans().isBanned(socketaddress) && !this.getIpBans().get(socketaddress).hasExpired()) {
++        } else if (this.getIpBans().isBanned(socketaddress) && getIpBans().get(socketaddress) != null && !this.getIpBans().get(socketaddress).hasExpired()) { // Paper - fix NPE with temp ip bans
+             IpBanListEntry ipbanentry = this.ipBans.get(socketaddress);
+ 
+             ichatmutablecomponent = Component.translatable("multiplayer.disconnect.banned_ip.reason", ipbanentry.getReason());
+diff --git a/src/main/java/net/minecraft/server/players/StoredUserList.java b/src/main/java/net/minecraft/server/players/StoredUserList.java
+index 097a25fd4ae5438161158a1018c707886cfbb959..91899909abd83611ac63633fef701be542cf64bf 100644
+--- a/src/main/java/net/minecraft/server/players/StoredUserList.java
++++ b/src/main/java/net/minecraft/server/players/StoredUserList.java
+@@ -13,6 +13,8 @@ import java.io.BufferedReader;
+ import java.io.BufferedWriter;
+ import java.io.File;
+ import java.io.IOException;
++import java.lang.reflect.ParameterizedType; // Paper
++import java.lang.reflect.Type; // Paper
+ import java.nio.charset.StandardCharsets;
+ import java.util.Collection;
+ import java.util.Iterator;
+@@ -30,7 +32,22 @@ public abstract class StoredUserList<K, V extends StoredUserEntry<K>> {
+     private static final Logger LOGGER = LogUtils.getLogger();
+     private static final Gson GSON = (new GsonBuilder()).setPrettyPrinting().create();
+     private final File file;
+-    private final Map<String, V> map = Maps.newHashMap();
++    // Paper - replace HashMap is ConcurrentHashMap
++    private final Map<String, V> map = Maps.newConcurrentMap();
++    private boolean e = true;
++    private static final ParameterizedType f = new ParameterizedType() {
++        public Type[] getActualTypeArguments() {
++            return new Type[]{StoredUserEntry.class};
++        }
++
++        public Type getRawType() {
++            return List.class;
++        }
++
++        public Type getOwnerType() {
++            return null;
++        }
++    };
+ 
+     public StoredUserList(File file) {
+         this.file = file;
+@@ -53,8 +70,13 @@ public abstract class StoredUserList<K, V extends StoredUserEntry<K>> {
+ 
+     @Nullable
+     public V get(K key) {
+-        this.removeExpired();
+-        return (V) this.map.get(this.getKeyForUser(key)); // CraftBukkit - fix decompile error
++        // Paper start
++        // this.g();
++        // return (V) this.d.get(this.a(k0)); // CraftBukkit - fix decompile error
++        return (V) this.map.computeIfPresent(this.getKeyForUser(key), (k, v) -> {
++            return v.hasExpired() ? null : v;
++        });
++        // Paper end
+     }
+ 
+     public void remove(K key) {
+@@ -83,7 +105,8 @@ public abstract class StoredUserList<K, V extends StoredUserEntry<K>> {
+     // CraftBukkit end
+ 
+     public boolean isEmpty() {
+-        return this.map.size() < 1;
++        // return this.d.size() < 1; // Paper
++        return this.map.isEmpty(); // Paper - readability is the goal. As an aside, isEmpty() uses only sumCount() and a comparison. size() uses sumCount(), casts, and boolean logic
+     }
+ 
+     protected String getKeyForUser(K profile) {
+@@ -95,14 +118,14 @@ public abstract class StoredUserList<K, V extends StoredUserEntry<K>> {
+     }
+ 
+     private void removeExpired() {
+-        List<K> list = Lists.newArrayList();
+-        Iterator iterator = this.map.values().iterator();
++        /*List<K> list = Lists.newArrayList();
++        Iterator iterator = this.d.values().iterator();
+ 
+         while (iterator.hasNext()) {
+             V v0 = (V) iterator.next(); // CraftBukkit - decompile error
+ 
+             if (v0.hasExpired()) {
+-                list.add(v0.getUser());
++                list.add(v0.getKey());
+             }
+         }
+ 
+@@ -111,9 +134,11 @@ public abstract class StoredUserList<K, V extends StoredUserEntry<K>> {
+         while (iterator.hasNext()) {
+             K k0 = (K) iterator.next(); // CraftBukkit - decompile error
+ 
+-            this.map.remove(this.getKeyForUser(k0));
+-        }
++            this.d.remove(this.a(k0));
++        }*/
+ 
++        this.map.values().removeIf(StoredUserEntry::hasExpired);
++        // Paper end
+     }
+ 
+     protected abstract StoredUserEntry<K> createEntry(JsonObject json);
+@@ -123,6 +148,7 @@ public abstract class StoredUserList<K, V extends StoredUserEntry<K>> {
+     }
+ 
+     public void save() throws IOException {
++        this.removeExpired(); // Paper - remove expired values before saving
+         JsonArray jsonarray = new JsonArray();
+         Stream<JsonObject> stream = this.map.values().stream().map((jsonlistentry) -> { // CraftBukkit - decompile error
+             JsonObject jsonobject = new JsonObject();

patches/server/0241-Use-a-Queue-for-Queueing-Commands.patch

@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sun, 12 Aug 2018 02:33:39 -0400
+Subject: [PATCH] Use a Queue for Queueing Commands
+
+Lists are bad as Queues mmmkay.
+
+diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+index 1a2607d1b257cea65c82c661a6b3d46c1526a775..338841804a92bea5ca074300eaea9374d1b77020 100644
+--- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
++++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -69,7 +69,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+     static final Logger LOGGER = LogUtils.getLogger();
+     private static final int CONVERSION_RETRY_DELAY_MS = 5000;
+     private static final int CONVERSION_RETRIES = 2;
+-    private final List<ConsoleInput> consoleInput = Collections.synchronizedList(Lists.newArrayList());
++    private final java.util.Queue<ConsoleInput> serverCommandQueue = new java.util.concurrent.ConcurrentLinkedQueue<>(); // Paper - use a proper queuemmands
+     @Nullable
+     private QueryThreadGs4 queryThreadGs4;
+     public final RconConsoleSource rconConsoleSource;
+@@ -440,13 +440,15 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+             return;
+         }
+         // Paper end - rewrite chunk system
+-        this.consoleInput.add(new ConsoleInput(command, commandSource));
++        this.serverCommandQueue.add(new ConsoleInput(command, commandSource)); // Paper - use proper queue
+     }
+ 
+     public void handleConsoleInputs() {
+         MinecraftTimings.serverCommandTimer.startTiming(); // Spigot
+-        while (!this.consoleInput.isEmpty()) {
+-            ConsoleInput servercommand = (ConsoleInput) this.consoleInput.remove(0);
++        // Paper start - use proper queue
++        ConsoleInput servercommand;
++        while ((servercommand = this.serverCommandQueue.poll()) != null) {
++            // Paper end
+ 
+             // CraftBukkit start - ServerCommand for preprocessing
+             ServerCommandEvent event = new ServerCommandEvent(console, servercommand.msg);

patches/server/0242-Ability-to-get-Tile-Entities-from-a-chunk-without-sn.patch

@@ -0,0 +1,66 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Wed, 15 Aug 2018 01:16:34 -0400
+Subject: [PATCH] Ability to get Tile Entities from a chunk without snapshots
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
+index 46b1cce7d482adea911b71f3e3623ac0574a85ae..6772b7e6ebded67f656dfb1af99e4d516aca67c5 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
+@@ -4,8 +4,10 @@ import com.google.common.base.Preconditions;
+ import com.google.common.base.Predicates;
+ import com.mojang.serialization.Codec;
+ import java.lang.ref.WeakReference;
++import java.util.ArrayList;
+ import java.util.Arrays;
+ import java.util.Collection;
++import java.util.List;
+ import java.util.Objects;
+ import java.util.concurrent.locks.LockSupport;
+ import java.util.function.BooleanSupplier;
+@@ -134,6 +136,13 @@ public class CraftChunk implements Chunk {
+ 
+     @Override
+     public BlockState[] getTileEntities() {
++        // Paper start
++        return getTileEntities(true);
++    }
++
++    @Override
++    public BlockState[] getTileEntities(boolean useSnapshot) {
++        // Paper end
+         if (!this.isLoaded()) {
+             this.getWorld().getChunkAt(x, z); // Transient load for this tick
+         }
+@@ -148,7 +157,29 @@ public class CraftChunk implements Chunk {
+             }
+ 
+             BlockPos position = (BlockPos) obj;
+-            entities[index++] = this.worldServer.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ()).getState();
++            // Paper start
++            entities[index++] = this.worldServer.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ()).getState(useSnapshot);
++        }
++
++        return entities;
++    }
++
++    @Override
++    public Collection<BlockState> getTileEntities(Predicate<Block> blockPredicate, boolean useSnapshot) {
++        Preconditions.checkNotNull(blockPredicate, "blockPredicate");
++        if (!isLoaded()) {
++            getWorld().getChunkAt(x, z); // Transient load for this tick
++        }
++        net.minecraft.world.level.chunk.LevelChunk chunk = getHandle();
++
++        List<BlockState> entities = new ArrayList<>();
++
++        for (BlockPos position : chunk.blockEntities.keySet()) {
++            Block block = worldServer.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ());
++            if (blockPredicate.test(block)) {
++                entities.add(block.getState(useSnapshot));
++            }
++            // Paper end
+         }
+ 
+         return entities;

patches/server/0243-Optimize-BlockPosition-helper-methods.patch

@@ -0,0 +1,108 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Wed, 15 Aug 2018 12:05:12 -0700
+Subject: [PATCH] Optimize BlockPosition helper methods
+
+Resolves #1338
+
+diff --git a/src/main/java/net/minecraft/core/BlockPos.java b/src/main/java/net/minecraft/core/BlockPos.java
+index a72dfbfa2aa636ac8bac07a62777126cf2696241..f35cc28b1fde73e9eae077f597c2822842a282ce 100644
+--- a/src/main/java/net/minecraft/core/BlockPos.java
++++ b/src/main/java/net/minecraft/core/BlockPos.java
+@@ -134,67 +134,84 @@ public class BlockPos extends Vec3i {
+ 
+     @Override
+     public BlockPos above() {
+-        return this.relative(Direction.UP);
++        return new BlockPos(this.getX(), this.getY() + 1, this.getZ()); // Paper - Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos above(int distance) {
+-        return this.relative(Direction.UP, distance);
++        return distance == 0 ? this : new BlockPos(this.getX(), this.getY() + distance, this.getZ()); // Paper - Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos below() {
+-        return this.relative(Direction.DOWN);
++        return new BlockPos(this.getX(), this.getY() - 1, this.getZ()); // Paper - Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos below(int i) {
+-        return this.relative(Direction.DOWN, i);
++        return i == 0 ? this : new BlockPos(this.getX(), this.getY() - i, this.getZ()); // Paper - Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos north() {
+-        return this.relative(Direction.NORTH);
++        return new BlockPos(this.getX(), this.getY(), this.getZ() - 1); // Paper - Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos north(int distance) {
+-        return this.relative(Direction.NORTH, distance);
++        return distance == 0 ? this : new BlockPos(this.getX(), this.getY(), this.getZ() - distance); // Paper - Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos south() {
+-        return this.relative(Direction.SOUTH);
++        return new BlockPos(this.getX(), this.getY(), this.getZ() + 1); // Paper - Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos south(int distance) {
+-        return this.relative(Direction.SOUTH, distance);
++        return distance == 0 ? this : new BlockPos(this.getX(), this.getY(), this.getZ() + distance); // Paper - Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos west() {
+-        return this.relative(Direction.WEST);
++        return new BlockPos(this.getX() - 1, this.getY(), this.getZ()); // Paper - Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos west(int distance) {
+-        return this.relative(Direction.WEST, distance);
++        return distance == 0 ? this : new BlockPos(this.getX() - distance, this.getY(), this.getZ()); // Paper - Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos east() {
+-        return this.relative(Direction.EAST);
++        return new BlockPos(this.getX() + 1, this.getY(), this.getZ()); // Paper - Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos east(int distance) {
+-        return this.relative(Direction.EAST, distance);
++        return distance == 0 ? this : new BlockPos(this.getX() + distance, this.getY(), this.getZ()); // Paper - Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos relative(Direction direction) {
++        // Paper Start - Optimize BlockPosition
++        switch(direction) {
++            case UP:
++                return new BlockPos(this.getX(), this.getY() + 1, this.getZ());
++            case DOWN:
++                return new BlockPos(this.getX(), this.getY() - 1, this.getZ());
++            case NORTH:
++                return new BlockPos(this.getX(), this.getY(), this.getZ() - 1);
++            case SOUTH:
++                return new BlockPos(this.getX(), this.getY(), this.getZ() + 1);
++            case WEST:
++                return new BlockPos(this.getX() - 1, this.getY(), this.getZ());
++            case EAST:
++                return new BlockPos(this.getX() + 1, this.getY(), this.getZ());
++            default:
+         return new BlockPos(this.getX() + direction.getStepX(), this.getY() + direction.getStepY(), this.getZ() + direction.getStepZ());
++        }
++        // Paper End
+     }
+ 
+     @Override

patches/server/0244-Restore-vanilla-default-mob-spawn-range-and-water-an.patch

@@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sat, 18 Aug 2018 12:43:16 -0400
+Subject: [PATCH] Restore vanilla default mob-spawn-range and water animals
+ limit
+
+
+diff --git a/src/main/java/org/spigotmc/SpigotWorldConfig.java b/src/main/java/org/spigotmc/SpigotWorldConfig.java
+index 3b7724a8ad8b9df0bbbca7fd2f8328e9885c5a73..70b3ff4a6a9aea24e28d99997a936e850d46b05e 100644
+--- a/src/main/java/org/spigotmc/SpigotWorldConfig.java
++++ b/src/main/java/org/spigotmc/SpigotWorldConfig.java
+@@ -190,7 +190,7 @@ public class SpigotWorldConfig
+     public byte mobSpawnRange;
+     private void mobSpawnRange()
+     {
+-        this.mobSpawnRange = (byte) this.getInt( "mob-spawn-range", 6 );
++        this.mobSpawnRange = (byte) getInt( "mob-spawn-range", 8 ); // Paper - Vanilla
+         this.log( "Mob Spawn Range: " + this.mobSpawnRange );
+     }
+ 

patches/server/0245-Slime-Pathfinder-Events.patch

@@ -0,0 +1,167 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Fri, 24 Aug 2018 08:18:42 -0500
+Subject: [PATCH] Slime Pathfinder Events
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Slime.java b/src/main/java/net/minecraft/world/entity/monster/Slime.java
+index 85abd62434cbe3beb63f61262504372b971d9684..058ba40491f3e566c4c159978c677ceb87fa8383 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Slime.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Slime.java
+@@ -41,6 +41,12 @@ import net.minecraft.world.level.ServerLevelAccessor;
+ import net.minecraft.world.level.WorldGenLevel;
+ import net.minecraft.world.level.levelgen.WorldgenRandom;
+ import net.minecraft.world.phys.Vec3;
++// Paper start
++import com.destroystokyo.paper.event.entity.SlimeChangeDirectionEvent;
++import com.destroystokyo.paper.event.entity.SlimeSwimEvent;
++import com.destroystokyo.paper.event.entity.SlimeTargetLivingEntityEvent;
++import com.destroystokyo.paper.event.entity.SlimeWanderEvent;
++// Paper end
+ // CraftBukkit start
+ import java.util.ArrayList;
+ import java.util.List;
+@@ -107,6 +113,7 @@ public class Slime extends Mob implements Enemy {
+     @Override
+     public void addAdditionalSaveData(CompoundTag nbt) {
+         super.addAdditionalSaveData(nbt);
++        nbt.putBoolean("Paper.canWander", this.canWander); // Paper
+         nbt.putInt("Size", this.getSize() - 1);
+         nbt.putBoolean("wasOnGround", this.wasOnGround);
+     }
+@@ -115,6 +122,11 @@ public class Slime extends Mob implements Enemy {
+     public void readAdditionalSaveData(CompoundTag nbt) {
+         this.setSize(nbt.getInt("Size") + 1, false);
+         super.readAdditionalSaveData(nbt);
++        // Paper start - check exists before loading or this will be loaded as false
++        if (nbt.contains("Paper.canWander")) {
++            this.canWander = nbt.getBoolean("Paper.canWander");
++        }
++        // Paper end
+         this.wasOnGround = nbt.getBoolean("wasOnGround");
+     }
+ 
+@@ -450,7 +462,7 @@ public class Slime extends Mob implements Enemy {
+ 
+         @Override
+         public boolean canUse() {
+-            return (this.slime.isInWater() || this.slime.isInLava()) && this.slime.getMoveControl() instanceof Slime.SlimeMoveControl;
++            return (this.slime.isInWater() || this.slime.isInLava()) && this.slime.getMoveControl() instanceof Slime.SlimeMoveControl && this.slime.canWander && new SlimeSwimEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity()).callEvent(); // Paper
+         }
+ 
+         @Override
+@@ -482,7 +494,15 @@ public class Slime extends Mob implements Enemy {
+         public boolean canUse() {
+             LivingEntity entityliving = this.slime.getTarget();
+ 
+-            return entityliving == null ? false : (!this.slime.canAttack(entityliving) ? false : this.slime.getMoveControl() instanceof Slime.SlimeMoveControl);
++            // Paper start
++            if (entityliving == null || !entityliving.isAlive()) {
++                return false;
++            }
++            if (!this.slime.canAttack(entityliving)) {
++                return false;
++            }
++            return this.slime.getMoveControl() instanceof Slime.SlimeMoveControl && this.slime.canWander && new SlimeTargetLivingEntityEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity(), (org.bukkit.entity.LivingEntity) entityliving.getBukkitEntity()).callEvent();
++            // Paper end
+         }
+ 
+         @Override
+@@ -495,7 +515,15 @@ public class Slime extends Mob implements Enemy {
+         public boolean canContinueToUse() {
+             LivingEntity entityliving = this.slime.getTarget();
+ 
+-            return entityliving == null ? false : (!this.slime.canAttack(entityliving) ? false : --this.growTiredTimer > 0);
++            // Paper start
++            if (entityliving == null || !entityliving.isAlive()) {
++                return false;
++            }
++            if (!this.slime.canAttack(entityliving)) {
++                return false;
++            }
++            return --this.growTiredTimer > 0 && this.slime.canWander && new SlimeTargetLivingEntityEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity(), (org.bukkit.entity.LivingEntity) entityliving.getBukkitEntity()).callEvent();
++            // Paper end
+         }
+ 
+         @Override
+@@ -513,6 +541,13 @@ public class Slime extends Mob implements Enemy {
+ 
+             ((Slime.SlimeMoveControl) this.slime.getMoveControl()).setDirection(this.slime.getYRot(), this.slime.isDealsDamage());
+         }
++
++        // Paper start - clear timer and target when goal resets
++        public void stop() {
++            this.growTiredTimer = 0;
++            this.slime.setTarget(null);
++        }
++        // Paper end
+     }
+ 
+     private static class SlimeRandomDirectionGoal extends Goal {
+@@ -528,7 +563,7 @@ public class Slime extends Mob implements Enemy {
+ 
+         @Override
+         public boolean canUse() {
+-            return this.slime.getTarget() == null && (this.slime.onGround || this.slime.isInWater() || this.slime.isInLava() || this.slime.hasEffect(MobEffects.LEVITATION)) && this.slime.getMoveControl() instanceof Slime.SlimeMoveControl;
++            return this.slime.getTarget() == null && (this.slime.onGround || this.slime.isInWater() || this.slime.isInLava() || this.slime.hasEffect(MobEffects.LEVITATION)) && this.slime.getMoveControl() instanceof Slime.SlimeMoveControl && this.slime.canWander; // Paper - add canWander
+         }
+ 
+         @Override
+@@ -536,6 +571,11 @@ public class Slime extends Mob implements Enemy {
+             if (--this.nextRandomizeTime <= 0) {
+                 this.nextRandomizeTime = this.adjustedTickDelay(40 + this.slime.getRandom().nextInt(60));
+                 this.chosenDegrees = (float) this.slime.getRandom().nextInt(360);
++                // Paper start
++                SlimeChangeDirectionEvent event = new SlimeChangeDirectionEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity(), this.chosenDegrees);
++                if (!this.slime.canWander || !event.callEvent()) return;
++                this.chosenDegrees = event.getNewYaw();
++                // Paper end
+             }
+ 
+             ((Slime.SlimeMoveControl) this.slime.getMoveControl()).setDirection(this.chosenDegrees, false);
+@@ -553,7 +593,7 @@ public class Slime extends Mob implements Enemy {
+ 
+         @Override
+         public boolean canUse() {
+-            return !this.slime.isPassenger();
++            return !this.slime.isPassenger() && this.slime.canWander && new SlimeWanderEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity()).callEvent(); // Paper
+         }
+ 
+         @Override
+@@ -561,4 +601,15 @@ public class Slime extends Mob implements Enemy {
+             ((Slime.SlimeMoveControl) this.slime.getMoveControl()).setWantedMovement(1.0D);
+         }
+     }
++
++    // Paper start
++    private boolean canWander = true;
++    public boolean canWander() {
++        return canWander;
++    }
++
++    public void setWander(boolean canWander) {
++        this.canWander = canWander;
++    }
++    // Paper end
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftSlime.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftSlime.java
+index 67fc37f909639e1effe6034526990f10d575d14d..4d401403de2399919043651345eed91c11ac986f 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftSlime.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftSlime.java
+@@ -34,4 +34,16 @@ public class CraftSlime extends CraftMob implements Slime {
+     public EntityType getType() {
+         return EntityType.SLIME;
+     }
++
++    // Paper start
++    @Override
++    public boolean canWander() {
++        return getHandle().canWander();
++    }
++
++    @Override
++    public void setWander(boolean canWander) {
++        getHandle().setWander(canWander);
++    }
++    // Paper end
+ }

patches/server/0246-Configurable-speed-for-water-flowing-over-lava.patch

@@ -0,0 +1,48 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Byteflux <byte@byteflux.net>
+Date: Wed, 8 Aug 2018 16:33:21 -0600
+Subject: [PATCH] Configurable speed for water flowing over lava
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/LiquidBlock.java b/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
+index 7d180d71d5b23319b26735e0d2fe187512a14842..43e8ef1d6a65d4fd3fe53a587639ffb814368217 100644
+--- a/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
+@@ -106,11 +106,27 @@ public class LiquidBlock extends Block implements BucketPickup {
+     @Override
+     public void onPlace(BlockState state, Level world, BlockPos pos, BlockState oldState, boolean notify) {
+         if (this.shouldSpreadLiquid(world, pos, state)) {
+-            world.scheduleTick(pos, state.getFluidState().getType(), this.fluid.getTickDelay(world));
++            world.scheduleTick(pos, state.getFluidState().getType(), this.getFlowSpeed(world, pos)); // Paper
+         }
+ 
+     }
+ 
++    // Paper start - Get flow speed. Throttle if its water and flowing adjacent to lava
++    public int getFlowSpeed(Level world, BlockPos blockposition) {
++        if (this.material == net.minecraft.world.level.material.Material.WATER) {
++            if (
++                world.getMaterialIfLoaded(blockposition.north(1)) == net.minecraft.world.level.material.Material.LAVA ||
++                world.getMaterialIfLoaded(blockposition.south(1)) == net.minecraft.world.level.material.Material.LAVA ||
++                world.getMaterialIfLoaded(blockposition.west(1)) == net.minecraft.world.level.material.Material.LAVA ||
++                world.getMaterialIfLoaded(blockposition.east(1)) == net.minecraft.world.level.material.Material.LAVA
++            ) {
++                return world.paperConfig().environment.waterOverLavaFlowSpeed;
++            }
++        }
++        return this.fluid.getTickDelay(world);
++    }
++    // Paper end
++
+     @Override
+     public BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
+         if (state.getFluidState().isSource() || neighborState.getFluidState().isSource()) {
+@@ -123,7 +139,7 @@ public class LiquidBlock extends Block implements BucketPickup {
+     @Override
+     public void neighborChanged(BlockState state, Level world, BlockPos pos, Block sourceBlock, BlockPos sourcePos, boolean notify) {
+         if (this.shouldSpreadLiquid(world, pos, state)) {
+-            world.scheduleTick(pos, state.getFluidState().getType(), this.fluid.getTickDelay(world));
++            world.scheduleTick(pos, state.getFluidState().getType(), this.getFlowSpeed(world, pos)); // Paper
+         }
+ 
+     }

patches/server/0247-Optimize-CraftBlockData-Creation.patch

@@ -0,0 +1,49 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: miclebrick <miclebrick@outlook.com>
+Date: Thu, 23 Aug 2018 11:45:32 -0400
+Subject: [PATCH] Optimize CraftBlockData Creation
+
+Avoids a hashmap lookup by cacheing a reference to the CraftBlockData
+and cloning it when one is needed.
+
+diff --git a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+index 5bba39a066ede470cebc92724735c86ecfd4239d..c53b80cba9ea658d20e527a9bfcd6b5d7d9f51fc 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
++++ b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+@@ -728,6 +728,14 @@ public abstract class BlockBehaviour implements FeatureElement {
+             this.spawnParticlesOnBreak = blockbase_info.spawnParticlesOnBreak;
+             this.conditionallyFullOpaque = this.isOpaque() & this.isTransparentOnSomeFaces(); // Paper
+         }
++        // Paper start - impl cached craft block data, lazy load to fix issue with loading at the wrong time
++        private org.bukkit.craftbukkit.block.data.CraftBlockData cachedCraftBlockData;
++
++        public org.bukkit.craftbukkit.block.data.CraftBlockData createCraftBlockData() {
++            if (cachedCraftBlockData == null) cachedCraftBlockData = org.bukkit.craftbukkit.block.data.CraftBlockData.createData(asState());
++            return (org.bukkit.craftbukkit.block.data.CraftBlockData) cachedCraftBlockData.clone();
++        }
++        // Paper end
+ 
+         // Paper start
+         protected boolean shapeExceedsCube = true;
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/data/CraftBlockData.java b/src/main/java/org/bukkit/craftbukkit/block/data/CraftBlockData.java
+index 953fe30e445885809caa16161262089a7786057b..6182ce8c32a334d3488c03f42bf3befcc0b80503 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/data/CraftBlockData.java
++++ b/src/main/java/org/bukkit/craftbukkit/block/data/CraftBlockData.java
+@@ -542,7 +542,17 @@ public class CraftBlockData implements BlockData {
+         return craft;
+     }
+ 
++    // Paper start - optimize creating BlockData to not need a map lookup
++    static {
++        // Initialize cached data for all IBlockData instances after registration
++        Block.BLOCK_STATE_REGISTRY.iterator().forEachRemaining(BlockState::createCraftBlockData);
++    }
+     public static CraftBlockData fromData(BlockState data) {
++        return data.createCraftBlockData();
++    }
++
++    public static CraftBlockData createData(BlockState data) {
++        // Paper end
+         return CraftBlockData.MAP.getOrDefault(data.getBlock().getClass(), CraftBlockData::new).apply(data);
+     }
+ 

patches/server/0248-Optimize-MappedRegistry.patch

@@ -0,0 +1,42 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sun, 26 Aug 2018 20:49:50 -0400
+Subject: [PATCH] Optimize MappedRegistry
+
+Use larger initial sizes to increase bucket capacity on the BiMap
+
+BiMap.get was seen to be using a good bit of CPU time.
+
+diff --git a/src/main/java/net/minecraft/core/MappedRegistry.java b/src/main/java/net/minecraft/core/MappedRegistry.java
+index 300e009abbc41961d59d55d965e9a99d44c21e32..38a4c1d355e74dbe0cf7f5040d00423209aca0d1 100644
+--- a/src/main/java/net/minecraft/core/MappedRegistry.java
++++ b/src/main/java/net/minecraft/core/MappedRegistry.java
+@@ -36,14 +36,12 @@ public class MappedRegistry<T> implements WritableRegistry<T> {
+     private static final Logger LOGGER = LogUtils.getLogger();
+     final ResourceKey<? extends Registry<T>> key;
+     private final ObjectList<Holder.Reference<T>> byId = new ObjectArrayList<>(256);
+-    private final Object2IntMap<T> toId = Util.make(new Object2IntOpenCustomHashMap<>(Util.identityStrategy()), (map) -> {
+-        map.defaultReturnValue(-1);
+-    });
+-    private final Map<ResourceLocation, Holder.Reference<T>> byLocation = new HashMap<>();
+-    private final Map<ResourceKey<T>, Holder.Reference<T>> byKey = new HashMap<>();
+-    private final Map<T, Holder.Reference<T>> byValue = new IdentityHashMap<>();
+-    private final Map<T, Lifecycle> lifecycles = new IdentityHashMap<>();
+-    private Lifecycle registryLifecycle;
++    private final it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap<T> toId = new it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap<T>(2048);// Paper - use bigger expected size to reduce collisions and direct intent for FastUtil to be identity map
++    private final Map<ResourceLocation, Holder.Reference<T>> byLocation = new HashMap<>(2048); // Paper - use bigger expected size to reduce collisions
++    private final Map<ResourceKey<T>, Holder.Reference<T>> byKey = new HashMap<>(2048); // Paper - use bigger expected size to reduce collisions
++    private final Map<T, Holder.Reference<T>> byValue = new IdentityHashMap<>(2048); // Paper - use bigger expected size to reduce collisions
++    private final Map<T, Lifecycle> lifecycles = new IdentityHashMap<>(2048); // Paper - use bigger expected size to reduce collisions
++    private Lifecycle elementsLifecycle;
+     private volatile Map<TagKey<T>, HolderSet.Named<T>> tags = new IdentityHashMap<>();
+     private boolean frozen;
+     @Nullable
+@@ -88,6 +86,7 @@ public class MappedRegistry<T> implements WritableRegistry<T> {
+     }
+ 
+     public MappedRegistry(ResourceKey<? extends Registry<T>> key, Lifecycle lifecycle, boolean intrusive) {
++        this.toId.defaultReturnValue(-1); // Paper
+         Bootstrap.checkBootstrapCalled(() -> {
+             return "registry " + key;
+         });

patches/server/0249-Add-PhantomPreSpawnEvent.patch

@@ -0,0 +1,97 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Sat, 25 Aug 2018 19:56:51 -0500
+Subject: [PATCH] Add PhantomPreSpawnEvent
+
+
+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 c068eddb08898681735e483df5b9c36f5fef3878..0e96e9d7e4d636f4222f60cec556663f506c3906 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Phantom.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Phantom.java
+@@ -171,6 +171,11 @@ public class Phantom extends FlyingMob implements Enemy {
+         }
+ 
+         this.setPhantomSize(nbt.getInt("Size"));
++        // Paper start
++        if (nbt.hasUUID("Paper.SpawningEntity")) {
++            this.spawningEntity = nbt.getUUID("Paper.SpawningEntity");
++        }
++        // Paper end
+     }
+ 
+     @Override
+@@ -180,6 +185,11 @@ public class Phantom extends FlyingMob implements Enemy {
+         nbt.putInt("AY", this.anchorPoint.getY());
+         nbt.putInt("AZ", this.anchorPoint.getZ());
+         nbt.putInt("Size", this.getPhantomSize());
++        // Paper start
++        if (this.spawningEntity != null) {
++            nbt.putUUID("Paper.SpawningEntity", this.spawningEntity);
++        }
++        // Paper end
+     }
+ 
+     @Override
+@@ -231,6 +241,14 @@ public class Phantom extends FlyingMob implements Enemy {
+         return entitysize.scale(f);
+     }
+ 
++    // Paper start
++    java.util.UUID spawningEntity;
++
++    public java.util.UUID getSpawningEntity() {
++        return spawningEntity;
++    }
++    public void setSpawningEntity(java.util.UUID entity) { this.spawningEntity = entity; }
++    // Paper end
+     private static enum AttackPhase {
+ 
+         CIRCLE, SWOOP;
+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 42d88ce2e15477482a814a79aefd4abfcbcb5462..900a66fc7eb817509df904b71ccc3bd3976f3b35 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
++++ b/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
+@@ -3,6 +3,7 @@ package net.minecraft.world.level.levelgen;
+ import java.util.Iterator;
+ import net.minecraft.core.BlockPos;
+ import net.minecraft.nbt.CompoundTag;
++import io.papermc.paper.util.MCUtil;
+ import net.minecraft.server.level.ServerLevel;
+ import net.minecraft.server.level.ServerPlayer;
+ import net.minecraft.stats.ServerStatsCounter;
+@@ -71,9 +72,19 @@ public class PhantomSpawner implements CustomSpawner {
+                                             int k = 1 + randomsource.nextInt(difficultydamagescaler.getDifficulty().getId() + 1);
+ 
+                                             for (int l = 0; l < k; ++l) {
++                                                // Paper start
++                                                com.destroystokyo.paper.event.entity.PhantomPreSpawnEvent event = new com.destroystokyo.paper.event.entity.PhantomPreSpawnEvent(MCUtil.toLocation(world, blockposition1), ((ServerPlayer) entityhuman).getBukkitEntity(), org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL);
++                                                if (!event.callEvent()) {
++                                                    if (event.shouldAbortSpawn()) {
++                                                        break;
++                                                    }
++                                                    continue;
++                                                }
++                                                // Paper end
+                                                 Phantom entityphantom = (Phantom) EntityType.PHANTOM.create(world);
+ 
+                                                 if (entityphantom != null) {
++                                                    entityphantom.setSpawningEntity(entityhuman.getUUID()); // Paper
+                                                     entityphantom.moveTo(blockposition1, 0.0F, 0.0F);
+                                                     groupdataentity = entityphantom.finalizeSpawn(world, difficultydamagescaler, MobSpawnType.NATURAL, groupdataentity, (CompoundTag) null);
+                                                     world.addFreshEntityWithPassengers(entityphantom, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL); // CraftBukkit
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPhantom.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPhantom.java
+index f77b83bee6eb739220b55793a0807f0267cfc8a9..c9dab70b0b284fe1c1daafd3c1f5bd08b14fa35d 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPhantom.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPhantom.java
+@@ -34,4 +34,11 @@ public class CraftPhantom extends CraftFlying implements Phantom {
+     public EntityType getType() {
+         return EntityType.PHANTOM;
+     }
++
++    // Paper start
++    @Override
++    public java.util.UUID getSpawningEntity() {
++        return getHandle().getSpawningEntity();
++    }
++    // Paper end
+ }

patches/server/0250-Add-More-Creeper-API.patch

@@ -0,0 +1,60 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Fri, 24 Aug 2018 11:50:26 -0500
+Subject: [PATCH] Add More Creeper API
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Creeper.java b/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+index 802a46ae9f18e0b58a7e0c38c18b367edd6b7a76..805e267090285d625dbeb75b06f8c5ad141a75a4 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Creeper.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+@@ -132,7 +132,7 @@ public class Creeper extends Monster implements PowerableMob {
+         }
+ 
+         if (nbt.getBoolean("ignited")) {
+-            this.ignite();
++            this.entityData.set(Creeper.DATA_IS_IGNITED, true); // Paper - set directly to avoid firing event
+         }
+ 
+     }
+@@ -309,7 +309,18 @@ public class Creeper extends Monster implements PowerableMob {
+     }
+ 
+     public void ignite() {
+-        this.entityData.set(Creeper.DATA_IS_IGNITED, true);
++        // Paper start
++        setIgnited(true);
++    }
++
++    public void setIgnited(boolean ignited) {
++        if (isIgnited() != ignited) {
++            com.destroystokyo.paper.event.entity.CreeperIgniteEvent event = new com.destroystokyo.paper.event.entity.CreeperIgniteEvent((org.bukkit.entity.Creeper) getBukkitEntity(), ignited);
++            if (event.callEvent()) {
++                this.entityData.set(Creeper.DATA_IS_IGNITED, event.isIgnited());
++            }
++        }
++        // Paper end
+     }
+ 
+     public boolean canDropMobsSkull() {
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java
+index ea9dc2219cdff3976796e4848b0faa278656be63..63a8188010f045d5c17a1ecb63e8081ec86c2960 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java
+@@ -94,4 +94,16 @@ public class CraftCreeper extends CraftMonster implements Creeper {
+     public EntityType getType() {
+         return EntityType.CREEPER;
+     }
++
++    // Paper start
++    @Override
++    public void setIgnited(boolean ignited) {
++        getHandle().setIgnited(ignited);
++    }
++
++    @Override
++    public boolean isIgnited() {
++        return getHandle().isIgnited();
++    }
++    // Paper end
+ }

patches/server/0251-Inventory-removeItemAnySlot.patch

@@ -0,0 +1,58 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach.brown@destroystokyo.com>
+Date: Tue, 28 Aug 2018 23:04:15 -0400
+Subject: [PATCH] Inventory#removeItemAnySlot
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
+index efa6b34261e3f4ad0d58a0c7d85df30f33a14d62..ce70a77ec6da41b59660f5923d30eaebf24c4cc2 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
+@@ -224,10 +224,16 @@ public class CraftInventory implements Inventory {
+     }
+ 
+     private int first(ItemStack item, boolean withAmount) {
++        // Paper start
++        return first(item, withAmount, getStorageContents());
++    }
++
++    private int first(ItemStack item, boolean withAmount, ItemStack[] inventory) {
++        // Paper end
+         if (item == null) {
+             return -1;
+         }
+-        ItemStack[] inventory = this.getStorageContents();
++        // ItemStack[] inventory = this.getStorageContents(); // Paper - let param deal
+         for (int i = 0; i < inventory.length; i++) {
+             if (inventory[i] == null) continue;
+ 
+@@ -350,6 +356,17 @@ public class CraftInventory implements Inventory {
+ 
+     @Override
+     public HashMap<Integer, ItemStack> removeItem(ItemStack... items) {
++        // Paper start
++        return removeItem(false, items);
++    }
++
++    @Override
++    public HashMap<Integer, ItemStack> removeItemAnySlot(ItemStack... items) {
++        return removeItem(true, items);
++    }
++
++    private HashMap<Integer, ItemStack> removeItem(boolean searchEntire, ItemStack... items) {
++        // Paper end
+         Validate.notNull(items, "Items cannot be null");
+         HashMap<Integer, ItemStack> leftover = new HashMap<Integer, ItemStack>();
+ 
+@@ -360,7 +377,10 @@ public class CraftInventory implements Inventory {
+             int toDelete = item.getAmount();
+ 
+             while (true) {
+-                int first = this.first(item, false);
++                // Paper start - Allow searching entire contents
++                ItemStack[] toSearch = searchEntire ? getContents() : getStorageContents();
++                int first = this.first(item, false, toSearch);
++                // Paper end
+ 
+                 // Drat! we don't have this type in the inventory
+                 if (first == -1) {

patches/server/0252-Make-CraftWorld-loadChunk-int-int-false-load-unconve.patch

@@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Sun, 2 Sep 2018 19:34:33 -0700
+Subject: [PATCH] Make CraftWorld#loadChunk(int, int, false) load unconverted
+ chunks
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index b10f4e4bb39f4de1aba4f6949843fa3786cedc62..a21797af9f90235835919c395d2ea77a980b2768 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -391,7 +391,7 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+     @Override
+     public boolean loadChunk(int x, int z, boolean generate) {
+         org.spigotmc.AsyncCatcher.catchOp("chunk load"); // Spigot
+-        ChunkAccess chunk = this.world.getChunkSource().getChunk(x, z, generate ? ChunkStatus.FULL : ChunkStatus.EMPTY, true);
++        ChunkAccess chunk = this.world.getChunkSource().getChunk(x, z, generate || isChunkGenerated(x, z) ? ChunkStatus.FULL : ChunkStatus.EMPTY, true); // Paper
+ 
+         // If generate = false, but the chunk already exists, we will get this back.
+         if (chunk instanceof ImposterProtoChunk) {

patches/server/0253-Add-ray-tracing-methods-to-LivingEntity.patch

@@ -0,0 +1,90 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Mon, 3 Sep 2018 18:20:03 -0500
+Subject: [PATCH] Add ray tracing methods to LivingEntity
+
+
+diff --git a/src/main/java/io/papermc/paper/util/MCUtil.java b/src/main/java/io/papermc/paper/util/MCUtil.java
+index b19850ae31f6c796cb3491dd5070d28e0ffd242c..30a5484d0209e7b99e81b70f654f525103471eb8 100644
+--- a/src/main/java/io/papermc/paper/util/MCUtil.java
++++ b/src/main/java/io/papermc/paper/util/MCUtil.java
+@@ -510,6 +510,18 @@ public final class MCUtil {
+         return getNMSWorld(entity.getWorld());
+     }
+ 
++    public static ClipContext.Fluid getNMSFluidCollisionOption(com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode) {
++        switch (fluidMode) {
++            case NEVER:
++                return ClipContext.Fluid.NONE;
++            case SOURCE_ONLY:
++                return ClipContext.Fluid.SOURCE_ONLY;
++            case ALWAYS:
++                return ClipContext.Fluid.ANY;
++        }
++        return null;
++    }
++
+     public static BlockFace toBukkitBlockFace(Direction enumDirection) {
+         switch (enumDirection) {
+             case DOWN:
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 677ba704c32e590f3298575b1cc060bb69414ca4..d825dd9a990f52e378755e86c02c6a35f3bb3659 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -3772,6 +3772,23 @@ public abstract class LivingEntity extends Entity {
+     }
+ 
+     // Paper start
++    public HitResult getRayTrace(int maxDistance) {
++        return getRayTrace(maxDistance, ClipContext.Fluid.NONE);
++    }
++
++    public HitResult getRayTrace(int maxDistance, ClipContext.Fluid fluidCollisionOption) {
++        if (maxDistance < 1 || maxDistance > 120) {
++            throw new IllegalArgumentException("maxDistance must be between 1-120");
++        }
++
++        Vec3 start = new Vec3(getX(), getY() + getEyeHeight(), getZ());
++        org.bukkit.util.Vector dir = getBukkitEntity().getLocation().getDirection().multiply(maxDistance);
++        Vec3 end = new Vec3(start.x + dir.getX(), start.y + dir.getY(), start.z + dir.getZ());
++        ClipContext raytrace = new ClipContext(start, end, ClipContext.Block.OUTLINE, fluidCollisionOption, this);
++
++        return level.clip(raytrace);
++    }
++
+     public int shieldBlockingDelay = level.paperConfig().misc.shieldBlockingDelay;
+ 
+     public int getShieldBlockingDelay() {
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index 04829ced2048b07aa4b2dcf98a601d1fdd9431fb..6c5cb2e5fb1f5bb7eb05a465a24d62e1dad57b93 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -200,6 +200,28 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+         return blocks.get(0);
+     }
+ 
++    // Paper start
++    @Override
++    public Block getTargetBlock(int maxDistance, com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode) {
++        net.minecraft.world.phys.HitResult rayTrace = getHandle().getRayTrace(maxDistance, io.papermc.paper.util.MCUtil.getNMSFluidCollisionOption(fluidMode));
++        return !(rayTrace instanceof net.minecraft.world.phys.BlockHitResult) ? null : org.bukkit.craftbukkit.block.CraftBlock.at(getHandle().level, ((net.minecraft.world.phys.BlockHitResult)rayTrace).getBlockPos());
++    }
++
++    @Override
++    public org.bukkit.block.BlockFace getTargetBlockFace(int maxDistance, com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode) {
++        net.minecraft.world.phys.HitResult rayTrace = getHandle().getRayTrace(maxDistance, io.papermc.paper.util.MCUtil.getNMSFluidCollisionOption(fluidMode));
++        return !(rayTrace instanceof net.minecraft.world.phys.BlockHitResult) ? null : io.papermc.paper.util.MCUtil.toBukkitBlockFace(((net.minecraft.world.phys.BlockHitResult)rayTrace).getDirection());
++    }
++
++    @Override
++    public com.destroystokyo.paper.block.TargetBlockInfo getTargetBlockInfo(int maxDistance, com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode) {
++        net.minecraft.world.phys.HitResult rayTrace = getHandle().getRayTrace(maxDistance, io.papermc.paper.util.MCUtil.getNMSFluidCollisionOption(fluidMode));
++        return !(rayTrace instanceof net.minecraft.world.phys.BlockHitResult) ? null :
++            new com.destroystokyo.paper.block.TargetBlockInfo(org.bukkit.craftbukkit.block.CraftBlock.at(getHandle().level, ((net.minecraft.world.phys.BlockHitResult)rayTrace).getBlockPos()),
++                io.papermc.paper.util.MCUtil.toBukkitBlockFace(((net.minecraft.world.phys.BlockHitResult)rayTrace).getDirection()));
++    }
++    // Paper end
++
+     @Override
+     public List<Block> getLastTwoTargetBlocks(Set<Material> transparent, int maxDistance) {
+         return this.getLineOfSight(transparent, maxDistance, 2);

patches/server/0254-Expose-attack-cooldown-methods-for-Player.patch

@@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Tue, 4 Sep 2018 15:02:00 -0500
+Subject: [PATCH] Expose attack cooldown methods for Player
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index e5b32af97f045f52c92dcd8f56af1508c54db490..8c528f32ef3a5e97ff14bd299a1f6e93b1a8a9af 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -2591,6 +2591,21 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+ 
+         return this.adventure$pointers;
+     }
++
++    @Override
++    public float getCooldownPeriod() {
++        return getHandle().getCurrentItemAttackStrengthDelay();
++    }
++
++    @Override
++    public float getCooledAttackStrength(float adjustTicks) {
++        return getHandle().getAttackStrengthScale(adjustTicks);
++    }
++
++    @Override
++    public void resetCooldown() {
++        getHandle().resetAttackStrengthTicker();
++    }
+     // Paper end
+     // Spigot start
+     private final Player.Spigot spigot = new Player.Spigot()

patches/server/0255-Improve-death-events.patch

@@ -0,0 +1,404 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Phoenix616 <mail@moep.tv>
+Date: Tue, 21 Aug 2018 01:39:35 +0100
+Subject: [PATCH] Improve death events
+
+This adds the ability to cancel the death events and to modify the sound
+an entity makes when dying. (In cases were no sound should it will be
+called with shouldPlaySound set to false allowing unsilencing of silent
+entities)
+
+It makes handling of entity deaths a lot nicer as you no longer need
+to listen on the damage event and calculate if the entity dies yourself
+to cancel the death which has the benefit of also receiving the dropped
+items and experience which is otherwise only properly possible by using
+internal code.
+
+TODO 1.17: this needs to be checked (actually get off your lazy ass and cancel the events) for the following entities,
+maybe more (please check patch overrides for drops for more):
+- players, armor stands, foxes, chested donkeys/llamas
+
+== AT ==
+public net.minecraft.world.entity.LivingEntity getDeathSound()Lnet/minecraft/sounds/SoundEvent;
+public net.minecraft.world.entity.LivingEntity getSoundVolume()F
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index b3fa1f28405ddebdd616bcc31db42d73697f2d79..05e72945da26295fbc5f0d243ba48a8649244b3b 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -235,6 +235,10 @@ public class ServerPlayer extends Player {
+     public int latency;
+     public boolean wonGame;
+     private int containerUpdateDelay; // Paper
++    // Paper start - cancellable death event
++    public boolean queueHealthUpdatePacket = false;
++    public net.minecraft.network.protocol.game.ClientboundSetHealthPacket queuedHealthUpdatePacket;
++    // Paper end
+ 
+     // CraftBukkit start
+     public String displayName;
+@@ -823,6 +827,15 @@ public class ServerPlayer extends Player {
+         String deathmessage = defaultMessage.getString();
+         this.keepLevel = keepInventory; // SPIGOT-2222: pre-set keepLevel
+         org.bukkit.event.entity.PlayerDeathEvent event = CraftEventFactory.callPlayerDeathEvent(this, loot, PaperAdventure.asAdventure(defaultMessage), defaultMessage.getString(), keepInventory); // Paper - Adventure
++        // Paper start - cancellable death event
++        if (event.isCancelled()) {
++            // make compatible with plugins that might have already set the health in an event listener
++            if (this.getHealth() <= 0) {
++                this.setHealth((float) event.getReviveHealth());
++            }
++            return;
++        }
++        // Paper end
+ 
+         // SPIGOT-943 - only call if they have an inventory open
+         if (this.containerMenu != this.inventoryMenu) {
+@@ -968,8 +981,17 @@ public class ServerPlayer extends Player {
+                         }
+                     }
+                 }
+-
+-                return super.hurt(source, amount);
++                // Paper start - cancellable death events
++                //return super.hurt(source, amount);
++                this.queueHealthUpdatePacket = true;
++                boolean damaged = super.hurt(source, amount);
++                this.queueHealthUpdatePacket = false;
++                if (this.queuedHealthUpdatePacket != null) {
++                    this.connection.send(this.queuedHealthUpdatePacket);
++                    this.queuedHealthUpdatePacket = null;
++                }
++                return damaged;
++                // Paper end
+             }
+         }
+     }
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index d825dd9a990f52e378755e86c02c6a35f3bb3659..785d5196c7e6de95e0507c959352ba57fb50d1c4 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -263,6 +263,7 @@ public abstract class LivingEntity extends Entity {
+     public Set<UUID> collidableExemptions = new HashSet<>();
+     public boolean bukkitPickUpLoot;
+     public org.bukkit.craftbukkit.entity.CraftLivingEntity getBukkitLivingEntity() { return (org.bukkit.craftbukkit.entity.CraftLivingEntity) super.getBukkitEntity(); } // Paper
++    public boolean silentDeath = false; // Paper - mark entity as dying silently for cancellable death event
+ 
+     @Override
+     public float getBukkitYaw() {
+@@ -1466,13 +1467,12 @@ public abstract class LivingEntity extends Entity {
+             if (knockbackCancelled) this.level.broadcastEntityEvent(this, (byte) 2); // Paper - Disable explosion knockback
+             if (this.isDeadOrDying()) {
+                 if (!this.checkTotemDeathProtection(source)) {
+-                    SoundEvent soundeffect = this.getDeathSound();
+-
+-                    if (flag1 && soundeffect != null) {
+-                        this.playSound(soundeffect, this.getSoundVolume(), this.getVoicePitch());
+-                    }
++                    // Paper start - moved into CraftEventFactory event caller for cancellable death event
++                    this.silentDeath = !flag1; // mark entity as dying silently
++                    // Paper end
+ 
+                     this.die(source);
++                    this.silentDeath = false; // Paper - cancellable death event - reset to default
+                 }
+             } else if (flag1) {
+                 this.playHurtSound(source);
+@@ -1624,7 +1624,7 @@ public abstract class LivingEntity extends Entity {
+         if (!this.isRemoved() && !this.dead) {
+             Entity entity = damageSource.getEntity();
+             LivingEntity entityliving = this.getKillCredit();
+-
++            /* // Paper - move down to make death event cancellable - this is the awardKillScore below
+             if (this.deathScore >= 0 && entityliving != null) {
+                 entityliving.awardKillScore(this, this.deathScore, damageSource);
+             }
+@@ -1636,20 +1636,53 @@ public abstract class LivingEntity extends Entity {
+             if (!this.level.isClientSide && this.hasCustomName()) {
+                 if (org.spigotmc.SpigotConfig.logNamedDeaths) LivingEntity.LOGGER.info("Named entity {} died: {}", this, this.getCombatTracker().getDeathMessage().getString()); // Spigot
+             }
++             */ // Paper - move down to make death event cancellable - this is the awardKillScore below
+ 
+             this.dead = true;
+-            this.getCombatTracker().recheckStatus();
++            // Paper - moved into if below
+             if (this.level instanceof ServerLevel) {
+-                if (entity == null || entity.wasKilled((ServerLevel) this.level, this)) {
++                // Paper - move below into if for onKill
++
++                // 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);
++                    }
++                    // Paper start - clear equipment if event is not cancelled
++                    if (this instanceof Mob) {
++                        for (EquipmentSlot slot : this.clearedEquipmentSlots) {
++                            this.setItemSlot(slot, ItemStack.EMPTY);
++                        }
++                        this.clearedEquipmentSlots.clear();
++                    }
++                    // Paper end
++
++                    if (this.isSleeping()) {
++                        this.stopSleeping();
++                    }
++
++                    if (!this.level.isClientSide && this.hasCustomName()) {
++                        if (org.spigotmc.SpigotConfig.logNamedDeaths) LivingEntity.LOGGER.info("Named entity {} died: {}", this, this.getCombatTracker().getDeathMessage().getString()); // Spigot
++                    }
++
++                    this.getCombatTracker().recheckStatus();
++                    if (entity != null) {
++                        entity.wasKilled((ServerLevel) this.level, this);
++                    }
+                     this.gameEvent(GameEvent.ENTITY_DIE);
+-                    this.dropAllDeathLoot(damageSource);
+-                    this.createWitherRose(entityliving);
++                } else {
++                    this.dead = false;
++                    this.setHealth((float) deathEvent.getReviveHealth());
+                 }
+-
+-                this.level.broadcastEntityEvent(this, (byte) 3);
++                // Paper end
++                this.createWitherRose(entityliving);
+             }
+ 
++            if (this.dead) { // Paper
++            this.level.broadcastEntityEvent(this, (byte) 3);
+             this.setPose(Pose.DYING);
++            } // Paper
+         }
+     }
+ 
+@@ -1657,7 +1690,7 @@ public abstract class LivingEntity extends Entity {
+         if (!this.level.isClientSide) {
+             boolean flag = false;
+ 
+-            if (adversary instanceof WitherBoss) {
++            if (this.dead && adversary instanceof WitherBoss) { // Paper
+                 if (this.level.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
+                     BlockPos blockposition = this.blockPosition();
+                     BlockState iblockdata = Blocks.WITHER_ROSE.defaultBlockState();
+@@ -1686,7 +1719,11 @@ public abstract class LivingEntity extends Entity {
+         }
+     }
+ 
+-    protected void dropAllDeathLoot(DamageSource source) {
++    // Paper start
++    protected boolean clearEquipmentSlots = true;
++    protected Set<EquipmentSlot> clearedEquipmentSlots = new java.util.HashSet<>();
++    protected org.bukkit.event.entity.EntityDeathEvent dropAllDeathLoot(DamageSource source) {
++    // Paper end
+         Entity entity = source.getEntity();
+         int i;
+ 
+@@ -1701,18 +1738,27 @@ public abstract class LivingEntity extends Entity {
+         this.dropEquipment(); // CraftBukkit - from below
+         if (this.shouldDropLoot() && this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
+             this.dropFromLootTable(source, flag);
++            // Paper start
++            final boolean prev = this.clearEquipmentSlots;
++            this.clearEquipmentSlots = false;
++            this.clearedEquipmentSlots.clear();
++            // Paper end
+             this.dropCustomDeathLoot(source, i, flag);
++            this.clearEquipmentSlots = prev; // Paper
+         }
+         // CraftBukkit start - Call death event
+-        CraftEventFactory.callEntityDeathEvent(this, this.drops);
++        org.bukkit.event.entity.EntityDeathEvent deathEvent = CraftEventFactory.callEntityDeathEvent(this, this.drops); // Paper
++        this.postDeathDropItems(deathEvent); // Paper
+         this.drops = new ArrayList<>();
+         // CraftBukkit end
+ 
+         // this.dropInventory();// CraftBukkit - moved up
+         this.dropExperience();
++        return deathEvent; // Paper
+     }
+ 
+     protected void dropEquipment() {}
++    protected void postDeathDropItems(org.bukkit.event.entity.EntityDeathEvent event) {} // Paper - method for post death logic that cannot be ran before the event is potentially cancelled
+ 
+     // CraftBukkit start
+     public int getExpReward() {
+diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
+index 6f728231a7b326e605d6ddb8e4cd6f0f0aec820b..f61a4409ebb5ed89e5a5cfe0488498a52faa2346 100644
+--- a/src/main/java/net/minecraft/world/entity/Mob.java
++++ b/src/main/java/net/minecraft/world/entity/Mob.java
+@@ -1036,7 +1036,13 @@ public abstract class Mob extends LivingEntity {
+                 }
+ 
+                 this.spawnAtLocation(itemstack);
++                if (this.clearEquipmentSlots) { // Paper
+                 this.setItemSlot(enumitemslot, ItemStack.EMPTY);
++                // Paper start
++                } else {
++                    this.clearedEquipmentSlots.add(enumitemslot);
++                }
++                // Paper end
+             }
+         }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Fox.java b/src/main/java/net/minecraft/world/entity/animal/Fox.java
+index dd124ccbdc7efe0e41b3a04abddcb328cac44948..f4cfefd72704b3423392ffeb57e78c5d6410ff6f 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Fox.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Fox.java
+@@ -705,15 +705,25 @@ public class Fox extends Animal implements VariantHolder<Fox.Type> {
+     }
+ 
+     @Override
+-    protected void dropAllDeathLoot(DamageSource source) {
+-        ItemStack itemstack = this.getItemBySlot(EquipmentSlot.MAINHAND);
++    // Paper start - Cancellable death event
++    protected org.bukkit.event.entity.EntityDeathEvent dropAllDeathLoot(DamageSource source) {
++        ItemStack itemstack = this.getItemBySlot(EquipmentSlot.MAINHAND).copy(); // Paper - modified by supercall
++
++        org.bukkit.event.entity.EntityDeathEvent deathEvent = super.dropAllDeathLoot(source);
++
++        // Below is code to drop
++
++        if (deathEvent == null || deathEvent.isCancelled()) {
++            return deathEvent;
++        }
++        // Paper end
+ 
+         if (!itemstack.isEmpty()) {
+             this.spawnAtLocation(itemstack);
+             this.setItemSlot(EquipmentSlot.MAINHAND, ItemStack.EMPTY);
+         }
+ 
+-        super.dropAllDeathLoot(source);
++        return deathEvent; // Paper
+     }
+ 
+     public static boolean isPathClear(Fox fox, LivingEntity chasedEntity) {
+diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/AbstractChestedHorse.java b/src/main/java/net/minecraft/world/entity/animal/horse/AbstractChestedHorse.java
+index 65dd844b9b38730a819158e1023c4abd829b52bb..170411b42aeef69c796d1409b59c3eb69f78c710 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/horse/AbstractChestedHorse.java
++++ b/src/main/java/net/minecraft/world/entity/animal/horse/AbstractChestedHorse.java
+@@ -69,11 +69,19 @@ public abstract class AbstractChestedHorse extends AbstractHorse {
+                 this.spawnAtLocation(Blocks.CHEST);
+             }
+ 
+-            this.setChest(false);
++            //this.setCarryingChest(false); // Paper - moved to post death logic
+         }
+ 
+     }
+ 
++    // Paper start
++    protected void postDeathDropItems(org.bukkit.event.entity.EntityDeathEvent event) {
++        if (this.hasChest() && (event == null || !event.isCancelled())) {
++            this.setChest(false);
++        }
++    }
++    // Paper end
++
+     @Override
+     public void addAdditionalSaveData(CompoundTag nbt) {
+         super.addAdditionalSaveData(nbt);
+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 f70f75867a8f03d42f240a0d007d2221269f2fdb..e463ae13ce6f65675c2b6d553ecf91db5a047dbc 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
++++ b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+@@ -753,7 +753,8 @@ public class ArmorStand extends LivingEntity {
+ 
+     @Override
+     public void kill() {
+-        org.bukkit.craftbukkit.event.CraftEventFactory.callEntityDeathEvent(this, drops); // CraftBukkit - call event
++        org.bukkit.event.entity.EntityDeathEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityDeathEvent(this, drops); // CraftBukkit - call event // Paper - make cancellable
++        if (event.isCancelled()) return; // Paper - make cancellable
+         this.remove(Entity.RemovalReason.KILLED);
+         this.gameEvent(GameEvent.ENTITY_DIE);
+     }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 8c528f32ef3a5e97ff14bd299a1f6e93b1a8a9af..15da4358e46547fa979dd5023ec6eb5d1358bcb5 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -2155,7 +2155,14 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     }
+ 
+     public void sendHealthUpdate() {
+-        this.getHandle().connection.send(new ClientboundSetHealthPacket(this.getScaledHealth(), this.getHandle().getFoodData().getFoodLevel(), this.getHandle().getFoodData().getSaturationLevel()));
++        // Paper start - cancellable death event
++        ClientboundSetHealthPacket packet = new ClientboundSetHealthPacket(this.getScaledHealth(), this.getHandle().getFoodData().getFoodLevel(), this.getHandle().getFoodData().getSaturationLevel());
++        if (this.getHandle().queueHealthUpdatePacket) {
++            this.getHandle().queuedHealthUpdatePacket = packet;
++        } else {
++            this.getHandle().connection.send(packet);
++        }
++        // Paper end
+     }
+ 
+     public void injectScaledMaxHealth(Collection<AttributeInstance> collection, boolean force) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+index 99b5db683591b42cf6c88dcd6b9a4aa0cf769ce4..2dfade8cc1e5e7e774d876d1e60c692aca0ef739 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
++++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -806,9 +806,16 @@ public class CraftEventFactory {
+     public static EntityDeathEvent callEntityDeathEvent(net.minecraft.world.entity.LivingEntity victim, List<org.bukkit.inventory.ItemStack> drops) {
+         CraftLivingEntity entity = (CraftLivingEntity) victim.getBukkitEntity();
+         EntityDeathEvent event = new EntityDeathEvent(entity, drops, victim.getExpReward());
++        populateFields(victim, event); // Paper - make cancellable
+         CraftWorld world = (CraftWorld) entity.getWorld();
+         Bukkit.getServer().getPluginManager().callEvent(event);
+ 
++        // Paper start - make cancellable
++        if (event.isCancelled()) {
++            return event;
++        }
++        playDeathSound(victim, event);
++        // Paper end
+         victim.expToDrop = event.getDroppedExp();
+ 
+         for (org.bukkit.inventory.ItemStack stack : event.getDrops()) {
+@@ -825,8 +832,15 @@ public class CraftEventFactory {
+         PlayerDeathEvent event = new PlayerDeathEvent(entity, drops, victim.getExpReward(), 0, deathMessage, stringDeathMessage); // Paper - Adventure
+         event.setKeepInventory(keepInventory);
+         event.setKeepLevel(victim.keepLevel); // SPIGOT-2222: pre-set keepLevel
++        populateFields(victim, event); // Paper - make cancellable
+         org.bukkit.World world = entity.getWorld();
+         Bukkit.getServer().getPluginManager().callEvent(event);
++        // Paper start - make cancellable
++        if (event.isCancelled()) {
++            return event;
++        }
++        playDeathSound(victim, event);
++        // Paper end
+ 
+         victim.keepLevel = event.getKeepLevel();
+         victim.newLevel = event.getNewLevel();
+@@ -843,6 +857,31 @@ public class CraftEventFactory {
+         return event;
+     }
+ 
++    // Paper start - helper methods for making death event cancellable
++    // Add information to death event
++    private static void populateFields(net.minecraft.world.entity.LivingEntity victim, EntityDeathEvent event) {
++        event.setReviveHealth(event.getEntity().getAttribute(org.bukkit.attribute.Attribute.GENERIC_MAX_HEALTH).getValue());
++        event.setShouldPlayDeathSound(!victim.silentDeath && !victim.isSilent());
++        net.minecraft.sounds.SoundEvent soundEffect = victim.getDeathSound();
++        event.setDeathSound(soundEffect != null ? org.bukkit.craftbukkit.CraftSound.getBukkit(soundEffect) : null);
++        event.setDeathSoundCategory(org.bukkit.SoundCategory.valueOf(victim.getSoundSource().name()));
++        event.setDeathSoundVolume(victim.getSoundVolume());
++        event.setDeathSoundPitch(victim.getVoicePitch());
++    }
++
++    // Play death sound manually
++    private static void playDeathSound(net.minecraft.world.entity.LivingEntity victim, EntityDeathEvent event) {
++        if (event.shouldPlayDeathSound() && event.getDeathSound() != null && event.getDeathSoundCategory() != null) {
++            net.minecraft.world.entity.player.Player source = victim instanceof net.minecraft.world.entity.player.Player ? (net.minecraft.world.entity.player.Player) victim : null;
++            double x = event.getEntity().getLocation().getX();
++            double y = event.getEntity().getLocation().getY();
++            double z = event.getEntity().getLocation().getZ();
++            net.minecraft.sounds.SoundEvent soundEffect = org.bukkit.craftbukkit.CraftSound.getSoundEffect(event.getDeathSound());
++            net.minecraft.sounds.SoundSource soundCategory = net.minecraft.sounds.SoundSource.valueOf(event.getDeathSoundCategory().name());
++            victim.level.playSound(source, x, y, z, soundEffect, soundCategory, event.getDeathSoundVolume(), event.getDeathSoundPitch());
++        }
++    }
++    // Paper end
+     /**
+      * Server methods
+      */

patches/server/0256-Allow-chests-to-be-placed-with-NBT-data.patch

@@ -0,0 +1,31 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Sat, 8 Sep 2018 18:43:31 -0500
+Subject: [PATCH] Allow chests to be placed with NBT data
+
+
+diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
+index 504a56fb2f2901c67ed22b9f0a57eb8db10ca4df..7d1e41272d05a8cb8d1adbcd2e9bc00f1a6f95fe 100644
+--- a/src/main/java/net/minecraft/world/item/ItemStack.java
++++ b/src/main/java/net/minecraft/world/item/ItemStack.java
+@@ -368,6 +368,7 @@ public final class ItemStack {
+                     enuminteractionresult = InteractionResult.FAIL; // cancel placement
+                     // PAIL: Remove this when MC-99075 fixed
+                     placeEvent.getPlayer().updateInventory();
++                    world.capturedTileEntities.clear(); // Paper - clear out tile entities as chests and such will pop loot
+                     // revert back all captured blocks
+                     world.preventPoiUpdated = true; // CraftBukkit - SPIGOT-5710
+                     for (BlockState blockstate : blocks) {
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/ChestBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/ChestBlockEntity.java
+index d4f5af759bbb6208432ad7b5002af5455dc7958c..a71414397bd45ee7bcacfeef0041d80dfa25f114 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/ChestBlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/ChestBlockEntity.java
+@@ -237,7 +237,7 @@ public class ChestBlockEntity extends RandomizableContainerBlockEntity implement
+     // CraftBukkit start
+     @Override
+     public boolean onlyOpCanSetNbt() {
+-        return true;
++        return false; // Paper
+     }
+     // CraftBukkit end
+ }

patches/server/0257-Mob-Pathfinding-API.patch

@@ -0,0 +1,204 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sun, 9 Sep 2018 13:30:00 -0400
+Subject: [PATCH] Mob Pathfinding API
+
+Implements Pathfinding API for mobs
+
+== AT ==
+public net.minecraft.world.entity.ai.navigation.PathNavigation pathFinder
+public net.minecraft.world.level.pathfinder.PathFinder nodeEvaluator
+public net.minecraft.world.level.pathfinder.Path nodes
+
+diff --git a/src/main/java/com/destroystokyo/paper/entity/PaperPathfinder.java b/src/main/java/com/destroystokyo/paper/entity/PaperPathfinder.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..2d799fec40afe7dade649a294761d272c83157f0
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/entity/PaperPathfinder.java
+@@ -0,0 +1,143 @@
++package com.destroystokyo.paper.entity;
++
++import org.apache.commons.lang.Validate;
++import org.bukkit.Location;
++import org.bukkit.craftbukkit.entity.CraftLivingEntity;
++import org.bukkit.entity.LivingEntity;
++import org.bukkit.entity.Mob;
++import javax.annotation.Nonnull;
++import javax.annotation.Nullable;
++import net.minecraft.world.level.pathfinder.Node;
++import net.minecraft.world.level.pathfinder.Path;
++import java.util.ArrayList;
++import java.util.List;
++
++public class PaperPathfinder implements com.destroystokyo.paper.entity.Pathfinder {
++
++    private net.minecraft.world.entity.Mob entity;
++
++    public PaperPathfinder(net.minecraft.world.entity.Mob entity) {
++        this.entity = entity;
++    }
++
++    @Override
++    public Mob getEntity() {
++        return entity.getBukkitMob();
++    }
++
++    public void setHandle(net.minecraft.world.entity.Mob entity) {
++        this.entity = entity;
++    }
++
++    @Override
++    public void stopPathfinding() {
++        entity.getNavigation().stop();
++    }
++
++    @Override
++    public boolean hasPath() {
++        return entity.getNavigation().getPath() != null;
++    }
++
++    @Nullable
++    @Override
++    public PathResult getCurrentPath() {
++        Path path = entity.getNavigation().getPath();
++        return path != null ? new PaperPathResult(path) : null;
++    }
++
++    @Nullable
++    @Override
++    public PathResult findPath(Location loc) {
++        Validate.notNull(loc, "Location can not be null");
++        Path path = entity.getNavigation().createPath(loc.getX(), loc.getY(), loc.getZ(), 0);
++        return path != null ? new PaperPathResult(path) : null;
++    }
++
++    @Nullable
++    @Override
++    public PathResult findPath(LivingEntity target) {
++        Validate.notNull(target, "Target can not be null");
++        Path path = entity.getNavigation().createPath(((CraftLivingEntity) target).getHandle(), 0);
++        return path != null ? new PaperPathResult(path) : null;
++    }
++
++    @Override
++    public boolean moveTo(@Nonnull PathResult path, double speed) {
++        Validate.notNull(path, "PathResult can not be null");
++        Path pathEntity = ((PaperPathResult) path).path;
++        return entity.getNavigation().moveTo(pathEntity, speed);
++    }
++
++    @Override
++    public boolean canOpenDoors() {
++        return entity.getNavigation().pathFinder.nodeEvaluator.canOpenDoors();
++    }
++
++    @Override
++    public void setCanOpenDoors(boolean canOpenDoors) {
++        entity.getNavigation().pathFinder.nodeEvaluator.setCanOpenDoors(canOpenDoors);
++    }
++
++    @Override
++    public boolean canPassDoors() {
++        return entity.getNavigation().pathFinder.nodeEvaluator.canPassDoors();
++    }
++
++    @Override
++    public void setCanPassDoors(boolean canPassDoors) {
++        entity.getNavigation().pathFinder.nodeEvaluator.setCanPassDoors(canPassDoors);
++    }
++
++    @Override
++    public boolean canFloat() {
++        return entity.getNavigation().pathFinder.nodeEvaluator.canFloat();
++    }
++
++    @Override
++    public void setCanFloat(boolean canFloat) {
++        entity.getNavigation().pathFinder.nodeEvaluator.setCanFloat(canFloat);
++    }
++
++    public class PaperPathResult implements com.destroystokyo.paper.entity.PaperPathfinder.PathResult {
++
++        private final Path path;
++        PaperPathResult(Path path) {
++            this.path = path;
++        }
++
++        @Nullable
++        @Override
++        public Location getFinalPoint() {
++            Node point = path.getEndNode();
++            return point != null ? toLoc(point) : null;
++        }
++
++        @Override
++        public List<Location> getPoints() {
++            List<Location> points = new ArrayList<>();
++            for (Node point : path.nodes) {
++                points.add(toLoc(point));
++            }
++            return points;
++        }
++
++        @Override
++        public int getNextPointIndex() {
++            return path.getNextNodeIndex();
++        }
++
++        @Nullable
++        @Override
++        public Location getNextPoint() {
++            if (!path.hasNext()) {
++                return null;
++            }
++            return toLoc(path.nodes.get(path.getNextNodeIndex()));
++        }
++    }
++
++    private Location toLoc(Node point) {
++        return new Location(entity.level.getWorld(), point.x, point.y, point.z);
++    }
++}
+diff --git a/src/main/java/net/minecraft/world/level/pathfinder/Path.java b/src/main/java/net/minecraft/world/level/pathfinder/Path.java
+index 4ad2ac8d1e9111933fa58c47442fa1f5e8173fd3..2a335f277bd0e4b8ad0f60d8226eb8aaa80a871f 100644
+--- a/src/main/java/net/minecraft/world/level/pathfinder/Path.java
++++ b/src/main/java/net/minecraft/world/level/pathfinder/Path.java
+@@ -21,6 +21,7 @@ public class Path {
+     private final BlockPos target;
+     private final float distToTarget;
+     private final boolean reached;
++    public boolean hasNext() { return getNextNodeIndex() < this.nodes.size(); } // Paper
+ 
+     public Path(List<Node> nodes, BlockPos target, boolean reachesTarget) {
+         this.nodes = nodes;
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftMob.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftMob.java
+index 659ccb6532506b2a8c9feb55dc5aee962f6da795..f36713771598ac5afdae5d94db10a5790949611d 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftMob.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftMob.java
+@@ -15,8 +15,11 @@ import org.bukkit.loot.LootTable;
+ public abstract class CraftMob extends CraftLivingEntity implements Mob {
+     public CraftMob(CraftServer server, net.minecraft.world.entity.Mob entity) {
+         super(server, entity);
++         paperPathfinder = new com.destroystokyo.paper.entity.PaperPathfinder(entity); // Paper
+     }
+ 
++    private final com.destroystokyo.paper.entity.PaperPathfinder paperPathfinder; // Paper
++    @Override public com.destroystokyo.paper.entity.Pathfinder getPathfinder() { return paperPathfinder; } // Paper
+     @Override
+     public void setTarget(LivingEntity target) {
+         Preconditions.checkState(!this.getHandle().generation, "Cannot set target during world generation");
+@@ -57,6 +60,14 @@ public abstract class CraftMob extends CraftLivingEntity implements Mob {
+         return (net.minecraft.world.entity.Mob) entity;
+     }
+ 
++    // Paper start
++    @Override
++    public void setHandle(net.minecraft.world.entity.Entity entity) {
++        super.setHandle(entity);
++        paperPathfinder.setHandle(getHandle());
++    }
++    // Paper end
++
+     @Override
+     public String toString() {
+         return "CraftMob";

patches/server/0258-Implement-an-API-for-CanPlaceOn-and-CanDestroy-NBT-v.patch

@@ -0,0 +1,402 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mark Vainomaa <mikroskeem@mikroskeem.eu>
+Date: Wed, 12 Sep 2018 18:53:55 +0300
+Subject: [PATCH] Implement an API for CanPlaceOn and CanDestroy NBT values
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
+index 01ceb8de8411193fa407bf19bbd25a4bf44765d3..4304ee35a9bd912c2ae4058febf22f0eea25adbd 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
+@@ -83,6 +83,12 @@ import org.bukkit.persistence.PersistentDataContainer;
+ import static org.spigotmc.ValidateUtils.*;
+ // Spigot end
+ 
++// Paper start
++import com.destroystokyo.paper.Namespaced;
++import com.destroystokyo.paper.NamespacedTag;
++import java.util.Collections;
++// Paper end
++
+ /**
+  * Children must include the following:
+  *
+@@ -268,6 +274,10 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+     @Specific(Specific.To.NBT)
+     static final ItemMetaKey BLOCK_DATA = new ItemMetaKey("BlockStateTag");
+     static final ItemMetaKey BUKKIT_CUSTOM_TAG = new ItemMetaKey("PublicBukkitValues");
++    // Paper start - Implement an API for CanPlaceOn and CanDestroy NBT values
++    static final ItemMetaKey CAN_DESTROY = new ItemMetaKey("CanDestroy");
++    static final ItemMetaKey CAN_PLACE_ON = new ItemMetaKey("CanPlaceOn");
++    // Paper end
+ 
+     // We store the raw original JSON representation of all text data. See SPIGOT-5063, SPIGOT-5656, SPIGOT-5304
+     private String displayName;
+@@ -281,6 +291,10 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+     private int hideFlag;
+     private boolean unbreakable;
+     private int damage;
++    // Paper start - Implement an API for CanPlaceOn and CanDestroy NBT values
++    private Set<Namespaced> placeableKeys = Sets.newHashSet();
++    private Set<Namespaced> destroyableKeys = Sets.newHashSet();
++    // Paper end
+ 
+     private static final Set<String> HANDLED_TAGS = Sets.newHashSet();
+     private static final CraftPersistentDataTypeRegistry DATA_TYPE_REGISTRY = new CraftPersistentDataTypeRegistry();
+@@ -318,6 +332,15 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+         this.hideFlag = meta.hideFlag;
+         this.unbreakable = meta.unbreakable;
+         this.damage = meta.damage;
++        // Paper start - Implement an API for CanPlaceOn and CanDestroy NBT values
++        if (meta.hasPlaceableKeys()) {
++            this.placeableKeys = new java.util.HashSet<>(meta.placeableKeys);
++        }
++
++        if (meta.hasDestroyableKeys()) {
++            this.destroyableKeys = new java.util.HashSet<>(meta.destroyableKeys);
++        }
++        // Paper end
+         this.unhandledTags.putAll(meta.unhandledTags);
+         this.persistentDataContainer.putAll(meta.persistentDataContainer.getRaw());
+ 
+@@ -381,6 +404,31 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+                 this.persistentDataContainer.put(key, compound.get(key).copy());
+             }
+         }
++        // Paper start - Implement an API for CanPlaceOn and CanDestroy NBT values
++        if (tag.contains(CAN_DESTROY.NBT)) {
++            ListTag list = tag.getList(CAN_DESTROY.NBT, CraftMagicNumbers.NBT.TAG_STRING);
++            for (int i = 0; i < list.size(); i++) {
++                Namespaced namespaced = this.deserializeNamespaced(list.getString(i));
++                if (namespaced == null) {
++                    continue;
++                }
++
++                this.destroyableKeys.add(namespaced);
++            }
++        }
++
++        if (tag.contains(CAN_PLACE_ON.NBT)) {
++            ListTag list = tag.getList(CAN_PLACE_ON.NBT, CraftMagicNumbers.NBT.TAG_STRING);
++            for (int i = 0; i < list.size(); i++) {
++                Namespaced namespaced = this.deserializeNamespaced(list.getString(i));
++                if (namespaced == null) {
++                    continue;
++                }
++
++                this.placeableKeys.add(namespaced);
++            }
++        }
++        // Paper end
+ 
+         Set<String> keys = tag.getAllKeys();
+         for (String key : keys) {
+@@ -519,6 +567,34 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+             this.setDamage(damage);
+         }
+ 
++        // Paper start - Implement an API for CanPlaceOn and CanDestroy NBT values
++        Iterable<?> canPlaceOnSerialized = SerializableMeta.getObject(Iterable.class, map, CAN_PLACE_ON.BUKKIT, true);
++        if (canPlaceOnSerialized != null) {
++            for (Object canPlaceOnElement : canPlaceOnSerialized) {
++                String canPlaceOnRaw = (String) canPlaceOnElement;
++                Namespaced value = this.deserializeNamespaced(canPlaceOnRaw);
++                if (value == null) {
++                    continue;
++                }
++
++                this.placeableKeys.add(value);
++            }
++        }
++
++        Iterable<?> canDestroySerialized = SerializableMeta.getObject(Iterable.class, map, CAN_DESTROY.BUKKIT, true);
++        if (canDestroySerialized != null) {
++            for (Object canDestroyElement : canDestroySerialized) {
++                String canDestroyRaw = (String) canDestroyElement;
++                Namespaced value = this.deserializeNamespaced(canDestroyRaw);
++                if (value == null) {
++                    continue;
++                }
++
++                this.destroyableKeys.add(value);
++            }
++        }
++        // Paper end
++
+         String internal = SerializableMeta.getString(map, "internal", true);
+         if (internal != null) {
+             ByteArrayInputStream buf = new ByteArrayInputStream(Base64.getDecoder().decode(internal));
+@@ -647,6 +723,23 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+         if (this.hasDamage()) {
+             itemTag.putInt(DAMAGE.NBT, damage);
+         }
++        // Paper start - Implement an API for CanPlaceOn and CanDestroy NBT values
++        if (hasPlaceableKeys()) {
++            List<String> items = this.placeableKeys.stream()
++                .map(this::serializeNamespaced)
++                .collect(java.util.stream.Collectors.toList());
++
++            itemTag.put(CAN_PLACE_ON.NBT, createNonComponentStringList(items));
++        }
++
++        if (hasDestroyableKeys()) {
++            List<String> items = this.destroyableKeys.stream()
++                .map(this::serializeNamespaced)
++                .collect(java.util.stream.Collectors.toList());
++
++            itemTag.put(CAN_DESTROY.NBT, createNonComponentStringList(items));
++        }
++        // Paper end
+ 
+         for (Map.Entry<String, Tag> e : this.unhandledTags.entrySet()) {
+             itemTag.put(e.getKey(), e.getValue());
+@@ -663,6 +756,21 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+         }
+     }
+ 
++    // Paper start
++    static ListTag createNonComponentStringList(List<String> list) {
++        if (list == null || list.isEmpty()) {
++            return null;
++        }
++
++        ListTag tagList = new ListTag();
++        for (String value : list) {
++            tagList.add(StringTag.valueOf(value)); // Paper - NBTTagString.of(String str)
++        }
++
++        return tagList;
++    }
++    // Paper end
++
+     ListTag createStringList(List<String> list) {
+         if (list == null) {
+             return null;
+@@ -746,7 +854,7 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+ 
+     @Overridden
+     boolean isEmpty() {
+-        return !(this.hasDisplayName() || this.hasLocalizedName() || this.hasEnchants() || (this.lore != null) || this.hasCustomModelData() || this.hasBlockData() || this.hasRepairCost() || !this.unhandledTags.isEmpty() || !this.persistentDataContainer.isEmpty() || this.hideFlag != 0 || this.isUnbreakable() || this.hasDamage() || this.hasAttributeModifiers());
++        return !(this.hasDisplayName() || this.hasLocalizedName() || this.hasEnchants() || (this.lore != null) || this.hasCustomModelData() || this.hasBlockData() || this.hasRepairCost() || !this.unhandledTags.isEmpty() || !this.persistentDataContainer.isEmpty() || this.hideFlag != 0 || this.isUnbreakable() || this.hasDamage() || this.hasAttributeModifiers() || this.hasPlaceableKeys() || this.hasDestroyableKeys()); // Paper - Implement an API for CanPlaceOn and CanDestroy NBT values
+     }
+ 
+     // Paper start
+@@ -1177,7 +1285,11 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+                 && (this.hideFlag == that.hideFlag)
+                 && (this.isUnbreakable() == that.isUnbreakable())
+                 && (this.hasDamage() ? that.hasDamage() && this.damage == that.damage : !that.hasDamage())
+-                && (this.version == that.version);
++                && (this.version == that.version)
++                // Paper start - Implement an API for CanPlaceOn and CanDestroy NBT values
++                && (this.hasPlaceableKeys() ? that.hasPlaceableKeys() && this.placeableKeys.equals(that.placeableKeys) : !that.hasPlaceableKeys())
++                && (this.hasDestroyableKeys() ? that.hasDestroyableKeys() && this.destroyableKeys.equals(that.destroyableKeys) : !that.hasDestroyableKeys());
++                // Paper end
+     }
+ 
+     /**
+@@ -1212,6 +1324,10 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+         hash = 61 * hash + (this.hasDamage() ? this.damage : 0);
+         hash = 61 * hash + (this.hasAttributeModifiers() ? this.attributeModifiers.hashCode() : 0);
+         hash = 61 * hash + this.version;
++        // Paper start - Implement an API for CanPlaceOn and CanDestroy NBT values
++        hash = 61 * hash + (this.hasPlaceableKeys() ? this.placeableKeys.hashCode() : 0);
++        hash = 61 * hash + (this.hasDestroyableKeys() ? this.destroyableKeys.hashCode() : 0);
++        // Paper end
+         return hash;
+     }
+ 
+@@ -1236,6 +1352,14 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+             clone.unbreakable = this.unbreakable;
+             clone.damage = this.damage;
+             clone.version = this.version;
++            // Paper start - Implement an API for CanPlaceOn and CanDestroy NBT values
++            if (this.placeableKeys != null) {
++                clone.placeableKeys = Sets.newHashSet(this.placeableKeys);
++            }
++            if (this.destroyableKeys != null) {
++                clone.destroyableKeys = Sets.newHashSet(this.destroyableKeys);
++            }
++            // Paper end
+             return clone;
+         } catch (CloneNotSupportedException e) {
+             throw new Error(e);
+@@ -1293,6 +1417,23 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+             builder.put(DAMAGE.BUKKIT, damage);
+         }
+ 
++        // Paper start - Implement an API for CanPlaceOn and CanDestroy NBT values
++        if (this.hasPlaceableKeys()) {
++            List<String> cerealPlaceable = this.placeableKeys.stream()
++                .map(this::serializeNamespaced)
++                .collect(java.util.stream.Collectors.toList());
++
++            builder.put(CAN_PLACE_ON.BUKKIT, cerealPlaceable);
++        }
++
++        if (this.hasDestroyableKeys()) {
++            List<String> cerealDestroyable = this.destroyableKeys.stream()
++                .map(this::serializeNamespaced)
++                .collect(java.util.stream.Collectors.toList());
++
++            builder.put(CAN_DESTROY.BUKKIT, cerealDestroyable);
++        }
++        // Paper end
+         final Map<String, Tag> internalTags = new HashMap<String, Tag>(this.unhandledTags);
+         this.serializeInternal(internalTags);
+         if (!internalTags.isEmpty()) {
+@@ -1459,6 +1600,8 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+                         CraftMetaArmorStand.SHOW_ARMS.NBT,
+                         CraftMetaArmorStand.SMALL.NBT,
+                         CraftMetaArmorStand.MARKER.NBT,
++                        CAN_DESTROY.NBT,
++                        CAN_PLACE_ON.NBT,
+                         // Paper end
+                         CraftMetaCompass.LODESTONE_DIMENSION.NBT,
+                         CraftMetaCompass.LODESTONE_POS.NBT,
+@@ -1487,4 +1630,146 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+     }
+     // Paper end
+ 
++    // Paper start - Implement an API for CanPlaceOn and CanDestroy NBT values
++    @Override
++    @SuppressWarnings("deprecation")
++    public Set<Material> getCanDestroy() {
++        return !hasDestroyableKeys() ? Collections.emptySet() : legacyGetMatsFromKeys(this.destroyableKeys);
++    }
++
++    @Override
++    @SuppressWarnings("deprecation")
++    public void setCanDestroy(Set<Material> canDestroy) {
++        Validate.notNull(canDestroy, "Cannot replace with null set!");
++        legacyClearAndReplaceKeys(this.destroyableKeys, canDestroy);
++    }
++
++    @Override
++    @SuppressWarnings("deprecation")
++    public Set<Material> getCanPlaceOn() {
++        return !hasPlaceableKeys() ? Collections.emptySet() : legacyGetMatsFromKeys(this.placeableKeys);
++    }
++
++    @Override
++    @SuppressWarnings("deprecation")
++    public void setCanPlaceOn(Set<Material> canPlaceOn) {
++        Validate.notNull(canPlaceOn, "Cannot replace with null set!");
++        legacyClearAndReplaceKeys(this.placeableKeys, canPlaceOn);
++    }
++
++    @Override
++    public Set<Namespaced> getDestroyableKeys() {
++        return !hasDestroyableKeys() ? Collections.emptySet() : Sets.newHashSet(this.destroyableKeys);
++    }
++
++    @Override
++    public void setDestroyableKeys(Collection<Namespaced> canDestroy) {
++        Validate.notNull(canDestroy, "Cannot replace with null collection!");
++        Validate.isTrue(ofAcceptableType(canDestroy), "Can only use NamespacedKey or NamespacedTag objects!");
++        this.destroyableKeys.clear();
++        this.destroyableKeys.addAll(canDestroy);
++    }
++
++    @Override
++    public Set<Namespaced> getPlaceableKeys() {
++        return !hasPlaceableKeys() ? Collections.emptySet() : Sets.newHashSet(this.placeableKeys);
++    }
++
++    @Override
++    public void setPlaceableKeys(Collection<Namespaced> canPlaceOn) {
++        Validate.notNull(canPlaceOn, "Cannot replace with null collection!");
++        Validate.isTrue(ofAcceptableType(canPlaceOn), "Can only use NamespacedKey or NamespacedTag objects!");
++        this.placeableKeys.clear();
++        this.placeableKeys.addAll(canPlaceOn);
++    }
++
++    @Override
++    public boolean hasPlaceableKeys() {
++        return this.placeableKeys != null && !this.placeableKeys.isEmpty();
++    }
++
++    @Override
++    public boolean hasDestroyableKeys() {
++        return this.destroyableKeys != null && !this.destroyableKeys.isEmpty();
++    }
++
++    @Deprecated
++    private void legacyClearAndReplaceKeys(Collection<Namespaced> toUpdate, Collection<Material> beingSet) {
++        if (beingSet.stream().anyMatch(Material::isLegacy)) {
++            throw new IllegalArgumentException("Set must not contain any legacy materials!");
++        }
++
++        toUpdate.clear();
++        toUpdate.addAll(beingSet.stream().map(Material::getKey).collect(java.util.stream.Collectors.toSet()));
++    }
++
++    @Deprecated
++    private Set<Material> legacyGetMatsFromKeys(Collection<Namespaced> names) {
++        Set<Material> mats = Sets.newHashSet();
++        for (Namespaced key : names) {
++            if (!(key instanceof org.bukkit.NamespacedKey)) {
++                continue;
++            }
++
++            Material material = Material.matchMaterial(key.toString(), false);
++            if (material != null) {
++                mats.add(material);
++            }
++        }
++
++        return mats;
++    }
++
++    private @Nullable Namespaced deserializeNamespaced(String raw) {
++        boolean isTag = raw.length() > 0 && raw.codePointAt(0) == '#';
++        com.mojang.datafixers.util.Either<net.minecraft.commands.arguments.blocks.BlockStateParser.BlockResult, net.minecraft.commands.arguments.blocks.BlockStateParser.TagResult> result;
++        try {
++            result = net.minecraft.commands.arguments.blocks.BlockStateParser.parseForTesting(net.minecraft.core.Registry.BLOCK, raw, false);
++        } catch (com.mojang.brigadier.exceptions.CommandSyntaxException e) {
++            return null;
++        }
++
++        net.minecraft.resources.ResourceLocation key = null;
++        if (isTag && result.right().isPresent() && result.right().get().tag() instanceof net.minecraft.core.HolderSet.Named<net.minecraft.world.level.block.Block> namedSet) {
++            key = namedSet.key().location();
++        } else if (result.left().isPresent()) {
++            key = net.minecraft.core.Registry.BLOCK.getKey(result.left().get().blockState().getBlock());
++        }
++
++        if (key == null) {
++            return null;
++        }
++
++        // don't DC the player if something slips through somehow
++        Namespaced resource = null;
++        try {
++            if (isTag) {
++                resource = new NamespacedTag(key.getNamespace(), key.getPath());
++            } else {
++                resource = CraftNamespacedKey.fromMinecraft(key);
++            }
++        } catch (IllegalArgumentException ex) {
++            org.bukkit.Bukkit.getLogger().warning("Namespaced resource does not validate: " + key.toString());
++            ex.printStackTrace();
++        }
++
++        return resource;
++    }
++
++    private @Nonnull String serializeNamespaced(Namespaced resource) {
++        return resource.toString();
++    }
++
++    // not a fan of this
++    private boolean ofAcceptableType(Collection<Namespaced> namespacedResources) {
++        
++        for (Namespaced resource : namespacedResources) {
++            if (!(resource instanceof org.bukkit.NamespacedKey || resource instanceof com.destroystokyo.paper.NamespacedTag)) {
++                return false;
++            }
++        }
++
++        return true;
++    }
++    // Paper end
+ }

patches/server/0259-Prevent-chunk-loading-from-Fluid-Flowing.patch

@@ -0,0 +1,76 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 10 Sep 2018 23:36:16 -0400
+Subject: [PATCH] Prevent chunk loading from Fluid Flowing
+
+
+diff --git a/src/main/java/net/minecraft/world/level/material/FlowingFluid.java b/src/main/java/net/minecraft/world/level/material/FlowingFluid.java
+index 6f6358b3b24686cd8995cd71b6f7209b4227fc48..fb0784c8a4950776bd270bec3c80a8c5856c2655 100644
+--- a/src/main/java/net/minecraft/world/level/material/FlowingFluid.java
++++ b/src/main/java/net/minecraft/world/level/material/FlowingFluid.java
+@@ -174,7 +174,8 @@ public abstract class FlowingFluid extends Fluid {
+                 Direction enumdirection = (Direction) entry.getKey();
+                 FluidState fluid1 = (FluidState) entry.getValue();
+                 BlockPos blockposition1 = pos.relative(enumdirection);
+-                BlockState iblockdata1 = world.getBlockState(blockposition1);
++                BlockState iblockdata1 = world.getBlockStateIfLoaded(blockposition1); // Paper
++                if (iblockdata1 == null) continue; // Paper
+ 
+                 if (this.canSpreadTo(world, pos, blockState, enumdirection, blockposition1, iblockdata1, world.getFluidState(blockposition1), fluid1.getType())) {
+                     // CraftBukkit start
+@@ -201,7 +202,9 @@ public abstract class FlowingFluid extends Fluid {
+         while (iterator.hasNext()) {
+             Direction enumdirection = (Direction) iterator.next();
+             BlockPos blockposition1 = pos.relative(enumdirection);
+-            BlockState iblockdata1 = world.getBlockState(blockposition1);
++
++            BlockState iblockdata1 = world.getBlockStateIfLoaded(blockposition1); // Paper
++            if (iblockdata1 == null) continue; // Paper
+             FluidState fluid = iblockdata1.getFluidState();
+ 
+             if (fluid.getType().isSame(this) && this.canPassThroughWall(enumdirection, world, pos, state, blockposition1, iblockdata1)) {
+@@ -318,11 +321,18 @@ public abstract class FlowingFluid extends Fluid {
+             if (enumdirection1 != enumdirection) {
+                 BlockPos blockposition2 = blockposition.relative(enumdirection1);
+                 short short0 = FlowingFluid.getCacheKey(blockposition1, blockposition2);
+-                Pair<BlockState, FluidState> pair = (Pair) short2objectmap.computeIfAbsent(short0, (short1) -> {
+-                    BlockState iblockdata1 = world.getBlockState(blockposition2);
++                // Paper start - avoid loading chunks
++                Pair<BlockState, FluidState> pair = short2objectmap.get(short0);
++                if (pair == null) {
++                    BlockState iblockdatax = world.getBlockStateIfLoaded(blockposition2);
++                    if (iblockdatax == null) {
++                        continue;
++                    }
+ 
+-                    return Pair.of(iblockdata1, iblockdata1.getFluidState());
+-                });
++                    pair = Pair.of(iblockdatax, iblockdatax.getFluidState());
++                    short2objectmap.put(short0, pair);
++                }
++                // Paper end
+                 BlockState iblockdata1 = (BlockState) pair.getFirst();
+                 FluidState fluid = (FluidState) pair.getSecond();
+ 
+@@ -394,11 +404,16 @@ public abstract class FlowingFluid extends Fluid {
+             Direction enumdirection = (Direction) iterator.next();
+             BlockPos blockposition1 = pos.relative(enumdirection);
+             short short0 = FlowingFluid.getCacheKey(pos, blockposition1);
+-            Pair<BlockState, FluidState> pair = (Pair) short2objectmap.computeIfAbsent(short0, (short1) -> {
+-                BlockState iblockdata1 = world.getBlockState(blockposition1);
+-
+-                return Pair.of(iblockdata1, iblockdata1.getFluidState());
+-            });
++            // Paper start
++            Pair pair = (Pair) short2objectmap.get(short0);
++            if (pair == null) {
++                BlockState iblockdatax = world.getBlockStateIfLoaded(blockposition1);
++                if (iblockdatax == null) continue;
++
++                pair = Pair.of(iblockdatax, iblockdatax.getFluidState());
++                short2objectmap.put(short0, pair);
++            }
++            // Paper end
+             BlockState iblockdata1 = (BlockState) pair.getFirst();
+             FluidState fluid = (FluidState) pair.getSecond();
+             FluidState fluid1 = this.getNewLiquid(world, blockposition1, iblockdata1);

patches/server/0260-Prevent-Mob-AI-Rules-from-Loading-Chunks.patch

@@ -0,0 +1,40 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 10 Sep 2018 23:56:36 -0400
+Subject: [PATCH] Prevent Mob AI Rules from Loading Chunks
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/RemoveBlockGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/RemoveBlockGoal.java
+index 238c4225bbd4b12bd866603c6eb33182bc9dc89f..bd0cbf4390fc7d00b4bd5008cdf8f6f49df4f69b 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/RemoveBlockGoal.java
++++ b/src/main/java/net/minecraft/world/entity/ai/goal/RemoveBlockGoal.java
+@@ -133,7 +133,9 @@ public class RemoveBlockGoal extends MoveToBlockGoal {
+ 
+     @Nullable
+     private BlockPos getPosWithBlock(BlockPos pos, BlockGetter world) {
+-        if (world.getBlockState(pos).is(this.blockToRemove)) {
++        net.minecraft.world.level.block.state.BlockState block = world.getBlockStateIfLoaded(pos); // Paper
++        if (block == null) return null; // Paper
++        if (block.is(this.blockToRemove)) { // Paper
+             return pos;
+         } else {
+             BlockPos[] ablockposition = new BlockPos[]{pos.below(), pos.west(), pos.east(), pos.north(), pos.south(), pos.below().below()};
+@@ -143,7 +145,8 @@ public class RemoveBlockGoal extends MoveToBlockGoal {
+             for (int j = 0; j < i; ++j) {
+                 BlockPos blockposition1 = ablockposition1[j];
+ 
+-                if (world.getBlockState(blockposition1).is(this.blockToRemove)) {
++                net.minecraft.world.level.block.state.BlockState block2 = world.getBlockStateIfLoaded(blockposition1); // Paper
++                if (block2 != null && block2.is(this.blockToRemove)) { // Paper
+                     return blockposition1;
+                 }
+             }
+@@ -154,7 +157,7 @@ public class RemoveBlockGoal extends MoveToBlockGoal {
+ 
+     @Override
+     protected boolean isValidTarget(LevelReader world, BlockPos pos) {
+-        ChunkAccess ichunkaccess = world.getChunk(SectionPos.blockToSectionCoord(pos.getX()), SectionPos.blockToSectionCoord(pos.getZ()), ChunkStatus.FULL, false);
++        ChunkAccess ichunkaccess = world.getChunkIfLoadedImmediately(pos.getX() >> 4, pos.getZ() >> 4); // Paper
+ 
+         return ichunkaccess == null ? false : ichunkaccess.getBlockState(pos).is(this.blockToRemove) && ichunkaccess.getBlockState(pos.above()).isAir() && ichunkaccess.getBlockState(pos.above(2)).isAir();
+     }

patches/server/0261-Prevent-mob-spawning-from-loading-generating-chunks.patch

@@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Wed, 12 Sep 2018 21:12:57 -0400
+Subject: [PATCH] Prevent mob spawning from loading/generating chunks
+
+also prevents if out of world border bounds
+
+diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
+index 608be2b8bfff1b89855fc0bd181430d3a29a4cbb..c3d6b904f1310c93a3d5c1e5e3fab2f3476f5a48 100644
+--- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java
++++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
+@@ -170,9 +170,9 @@ public final class NaturalSpawner {
+         StructureManager structuremanager = world.structureManager();
+         ChunkGenerator chunkgenerator = world.getChunkSource().getGenerator();
+         int i = pos.getY();
+-        BlockState iblockdata = chunk.getBlockState(pos);
++        BlockState iblockdata = world.getBlockStateIfLoadedAndInBounds(pos); // Paper - don't load chunks for mob spawn
+ 
+-        if (!iblockdata.isRedstoneConductor(chunk, pos)) {
++        if (iblockdata != null && !iblockdata.isRedstoneConductor(chunk, pos)) { // Paper - don't load chunks for mob spawn
+             BlockPos.MutableBlockPos blockposition_mutableblockposition = new BlockPos.MutableBlockPos();
+             int j = 0;
+             int k = 0;
+@@ -201,7 +201,7 @@ public final class NaturalSpawner {
+                             if (entityhuman != null) {
+                                 double d2 = entityhuman.distanceToSqr(d0, (double) i, d1);
+ 
+-                                if (NaturalSpawner.isRightDistanceToPlayerAndSpawnPoint(world, chunk, blockposition_mutableblockposition, d2)) {
++                                if (world.isLoadedAndInBounds(blockposition_mutableblockposition) && NaturalSpawner.isRightDistanceToPlayerAndSpawnPoint(world, chunk, blockposition_mutableblockposition, d2)) { // Paper - don't load chunks for mob spawn
+                                     if (biomesettingsmobs_c == null) {
+                                         Optional<MobSpawnSettings.SpawnerData> optional = NaturalSpawner.getRandomSpawnMobAt(world, structuremanager, chunkgenerator, group, world.random, blockposition_mutableblockposition);
+ 

patches/server/0262-Implement-furnace-cook-speed-multiplier-API.patch

@@ -0,0 +1,129 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Tassu <git@tassu.me>
+Date: Thu, 13 Sep 2018 08:45:21 +0300
+Subject: [PATCH] Implement furnace cook speed multiplier API
+
+Signed-off-by: Tassu <git@tassu.me>
+
+Fixed an issue where a furnace's cook-speed multiplier rounds down
+to the nearest Integer when updating its current cook time.
+
+Modified by: Eric Su <ericsu@alumni.usc.edu>
+
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
+index 8137682be60eb617738f7b257780a49182ef970c..196c99a2802c0bcaf93be287c404fc4f0f23eadd 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
+@@ -76,11 +76,13 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
+     protected NonNullList<ItemStack> items;
+     public int litTime;
+     int litDuration;
++    public double cookSpeedMultiplier = 1.0; // Paper - cook speed multiplier API
+     public int cookingProgress;
+     public int cookingTotalTime;
+     protected final ContainerData dataAccess;
+     public final Object2IntOpenHashMap<ResourceLocation> recipesUsed;
+     private final RecipeManager.CachedCheck<Container, ? extends AbstractCookingRecipe> quickCheck;
++    public final RecipeType<? extends AbstractCookingRecipe> recipeType; // Paper
+ 
+     protected AbstractFurnaceBlockEntity(BlockEntityType<?> blockEntityType, BlockPos pos, BlockState state, RecipeType<? extends AbstractCookingRecipe> recipeType) {
+         super(blockEntityType, pos, state);
+@@ -127,6 +129,7 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
+         };
+         this.recipesUsed = new Object2IntOpenHashMap();
+         this.quickCheck = RecipeManager.createCheck((RecipeType<AbstractCookingRecipe>) recipeType); // CraftBukkit - decompile error // Eclipse fail
++        this.recipeType = recipeType; // Paper
+     }
+ 
+     public static Map<Item, Integer> getFuel() {
+@@ -279,6 +282,11 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
+             this.recipesUsed.put(new ResourceLocation(s), nbttagcompound1.getInt(s));
+         }
+ 
++        // Paper start - cook speed API
++        if (nbt.contains("Paper.CookSpeedMultiplier")) {
++            this.cookSpeedMultiplier = nbt.getDouble("Paper.CookSpeedMultiplier");
++        }
++        // Paper end
+     }
+ 
+     @Override
+@@ -287,6 +295,7 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
+         nbt.putShort("BurnTime", (short) this.litTime);
+         nbt.putShort("CookTime", (short) this.cookingProgress);
+         nbt.putShort("CookTimeTotal", (short) this.cookingTotalTime);
++        nbt.putDouble("Paper.CookSpeedMultiplier", this.cookSpeedMultiplier); // Paper - cook speed multiplier API
+         ContainerHelper.saveAllItems(nbt, this.items);
+         CompoundTag nbttagcompound1 = new CompoundTag();
+ 
+@@ -358,7 +367,7 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
+                     CraftItemStack source = CraftItemStack.asCraftMirror(blockEntity.items.get(0));
+                     CookingRecipe<?> recipe = (CookingRecipe<?>) irecipe.toBukkitRecipe();
+ 
+-                    FurnaceStartSmeltEvent event = new FurnaceStartSmeltEvent(CraftBlock.at(world, pos), source, recipe);
++                    FurnaceStartSmeltEvent event = new FurnaceStartSmeltEvent(CraftBlock.at(world, pos), source, recipe, AbstractFurnaceBlockEntity.getTotalCookTime(world, blockEntity.recipeType, blockEntity, blockEntity.cookSpeedMultiplier)); // Paper - cook speed multiplier API
+                     world.getCraftServer().getPluginManager().callEvent(event);
+ 
+                     blockEntity.cookingTotalTime = event.getTotalCookTime();
+@@ -366,9 +375,9 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
+                 // CraftBukkit end
+ 
+                 ++blockEntity.cookingProgress;
+-                if (blockEntity.cookingProgress == blockEntity.cookingTotalTime) {
++                if (blockEntity.cookingProgress >= blockEntity.cookingTotalTime) { // Paper - cook speed multiplier API
+                     blockEntity.cookingProgress = 0;
+-                    blockEntity.cookingTotalTime = AbstractFurnaceBlockEntity.getTotalCookTime(world, blockEntity);
++                    blockEntity.cookingTotalTime = AbstractFurnaceBlockEntity.getTotalCookTime(world, blockEntity.recipeType, blockEntity, blockEntity.cookSpeedMultiplier); // Paper
+                     if (AbstractFurnaceBlockEntity.burn(blockEntity.level, blockEntity.worldPosition, irecipe, blockEntity.items, i)) { // CraftBukkit
+                         blockEntity.setRecipeUsed(irecipe);
+                     }
+@@ -468,9 +477,13 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
+         }
+     }
+ 
+-    private static int getTotalCookTime(Level world, AbstractFurnaceBlockEntity furnace) {
+-        return (world != null) ? (Integer) furnace.quickCheck.getRecipeFor(furnace, world).map(AbstractCookingRecipe::getCookingTime).orElse(200) : 200; // CraftBukkit - SPIGOT-4302
++    // Paper start
++    public static int getTotalCookTime(@Nullable Level world, RecipeType<? extends AbstractCookingRecipe> recipeType, AbstractFurnaceBlockEntity furnace, double cookSpeedMultiplier) {
++        /* Scale the recipe's cooking time to the current cookSpeedMultiplier */
++        int cookTime = world != null ? furnace.quickCheck.getRecipeFor(furnace, world).map(AbstractCookingRecipe::getCookingTime).orElse(200) : (net.minecraft.server.MinecraftServer.getServer().getRecipeManager().getRecipeFor(recipeType, furnace, world /* passing a null level here is safe. world is only used for map extending recipes which won't happen here */).map(AbstractCookingRecipe::getCookingTime).orElse(200));
++        return (int) Math.ceil (cookTime / cookSpeedMultiplier);
+     }
++    // Paper end
+ 
+     public static boolean isFuel(ItemStack stack) {
+         return AbstractFurnaceBlockEntity.getFuel().containsKey(stack.getItem());
+@@ -539,7 +552,7 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
+         }
+ 
+         if (slot == 0 && !flag) {
+-            this.cookingTotalTime = AbstractFurnaceBlockEntity.getTotalCookTime(this.level, this);
++            this.cookingTotalTime = AbstractFurnaceBlockEntity.getTotalCookTime(this.level, this.recipeType, this, this.cookSpeedMultiplier); // Paper
+             this.cookingProgress = 0;
+             this.setChanged();
+         }
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftFurnace.java b/src/main/java/org/bukkit/craftbukkit/block/CraftFurnace.java
+index facf95a44b5d3a63fda156c6afc8cabe50b21d32..3da4616c904d47bbecae0d4cb6970496fbec9a8b 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftFurnace.java
++++ b/src/main/java/org/bukkit/craftbukkit/block/CraftFurnace.java
+@@ -78,4 +78,20 @@ public abstract class CraftFurnace<T extends AbstractFurnaceBlockEntity> extends
+ 
+         return recipesUsed.build();
+     }
++
++    // Paper start - cook speed multiplier API
++    @Override
++    public double getCookSpeedMultiplier() {
++        return this.getSnapshot().cookSpeedMultiplier;
++    }
++
++    @Override
++    public void setCookSpeedMultiplier(double multiplier) {
++        com.google.common.base.Preconditions.checkArgument(multiplier >= 0, "Furnace speed multiplier cannot be negative");
++        com.google.common.base.Preconditions.checkArgument(multiplier <= 200, "Furnace speed multiplier cannot more than 200");
++        T snapshot = this.getSnapshot();
++        snapshot.cookSpeedMultiplier = multiplier;
++        snapshot.cookingTotalTime = AbstractFurnaceBlockEntity.getTotalCookTime(this.isPlaced() ? this.world.getHandle() : null, snapshot.recipeType, snapshot, snapshot.cookSpeedMultiplier); // Update the snapshot's current total cook time to scale with the newly set multiplier
++    }
++    // Paper end
+ }

patches/server/0263-Catch-JsonParseException-in-Entity-and-TE-names.patch

@@ -0,0 +1,114 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach.brown@destroystokyo.com>
+Date: Sat, 22 Sep 2018 15:56:59 -0400
+Subject: [PATCH] Catch JsonParseException in Entity and TE names
+
+As a result, data that no longer parses correctly will not crash the server
+instead just logging the exception and continuing (and in most cases should
+fix the data)
+
+Player data is fixed pretty much immediately but some block data (like
+Shulkers) may need to be changed in order for it to re-save properly
+
+No more crashing though.
+
+diff --git a/src/main/java/io/papermc/paper/util/MCUtil.java b/src/main/java/io/papermc/paper/util/MCUtil.java
+index 30a5484d0209e7b99e81b70f654f525103471eb8..dacb00c7cb2702ae8e9c6be61ca08e41bd6009e4 100644
+--- a/src/main/java/io/papermc/paper/util/MCUtil.java
++++ b/src/main/java/io/papermc/paper/util/MCUtil.java
+@@ -14,6 +14,8 @@ import it.unimi.dsi.fastutil.objects.ReferenceArrayList;
+ import net.minecraft.core.BlockPos;
+ import net.minecraft.core.Direction;
+ import net.minecraft.server.MinecraftServer;
++import net.minecraft.nbt.CompoundTag;
++import net.minecraft.network.chat.Component;
+ import net.minecraft.server.level.ChunkHolder;
+ import net.minecraft.server.level.ChunkMap;
+ import net.minecraft.server.level.DistanceManager;
+@@ -541,6 +543,21 @@ public final class MCUtil {
+         }
+     }
+ 
++    @Nullable
++    public static Component getBaseComponentFromNbt(String key, CompoundTag compound) {
++        if (!compound.contains(key)) {
++            return null;
++        }
++        String string = compound.getString(key);
++        try {
++            return Component.Serializer.fromJson(string);
++        } catch (com.google.gson.JsonParseException e) {
++            org.bukkit.Bukkit.getLogger().warning("Unable to parse " + key + " from " + compound +": " + e.getMessage());
++        }
++
++        return null;
++    }
++
+     public static ChunkStatus getChunkStatus(ChunkHolder chunk) {
+         return chunk.getChunkHolderStatus();
+     }
+diff --git a/src/main/java/net/minecraft/world/level/BaseCommandBlock.java b/src/main/java/net/minecraft/world/level/BaseCommandBlock.java
+index a0728e95251e8110bcecd00512c7a266fe120794..7dac559fd35e7ba646b84bb28315001375723643 100644
+--- a/src/main/java/net/minecraft/world/level/BaseCommandBlock.java
++++ b/src/main/java/net/minecraft/world/level/BaseCommandBlock.java
+@@ -72,7 +72,7 @@ public abstract class BaseCommandBlock implements CommandSource {
+         this.command = nbt.getString("Command");
+         this.successCount = nbt.getInt("SuccessCount");
+         if (nbt.contains("CustomName", 8)) {
+-            this.setName(Component.Serializer.fromJson(nbt.getString("CustomName")));
++            this.setName(io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt)); // Paper - Catch ParseException
+         }
+ 
+         if (nbt.contains("TrackOutput", 1)) {
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/BannerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BannerBlockEntity.java
+index 6b983e3e867bdd8cdffaf4575bbf67ad96b57ec7..66e2137f9379e885294f2b9f67f7e35296792770 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BannerBlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/BannerBlockEntity.java
+@@ -98,7 +98,7 @@ public class BannerBlockEntity extends BlockEntity implements Nameable {
+     public void load(CompoundTag nbt) {
+         super.load(nbt);
+         if (nbt.contains("CustomName", 8)) {
+-            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"));
++            this.name = io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt); // Paper - Catch ParseException
+         }
+ 
+         this.itemPatterns = nbt.getList("Patterns", 10);
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
+index 084e26de66c8204cb9aaad51bad3270228889ea3..a782994e2e53f2c4212c2d59ce740ebf00a826b0 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
+@@ -31,7 +31,7 @@ public abstract class BaseContainerBlockEntity extends BlockEntity implements Co
+         super.load(nbt);
+         this.lockKey = LockCode.fromTag(nbt);
+         if (nbt.contains("CustomName", 8)) {
+-            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"));
++            this.name = io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt); // Paper - Catch ParseException
+         }
+ 
+     }
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
+index 3a17c143de499d81109ae7d6e9fe18718139c5b7..04c2872e2a492adef5aec98289a8cf2af6611757 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
+@@ -367,7 +367,7 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider, Name
+         this.levels = nbt.getInt("Levels"); // SPIGOT-5053, use where available
+         // CraftBukkit end
+         if (nbt.contains("CustomName", 8)) {
+-            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"));
++            this.name = io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt); // Paper - Catch ParseException
+         }
+ 
+         this.lockKey = LockCode.fromTag(nbt);
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/EnchantmentTableBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/EnchantmentTableBlockEntity.java
+index 3a8bdb788b07b0a8cda3d4b872ede52ca9a005c4..65e1381bb2d10bd212463feb602c60f8fdb9ade1 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/EnchantmentTableBlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/EnchantmentTableBlockEntity.java
+@@ -42,7 +42,7 @@ public class EnchantmentTableBlockEntity extends BlockEntity implements Nameable
+     public void load(CompoundTag nbt) {
+         super.load(nbt);
+         if (nbt.contains("CustomName", 8)) {
+-            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"));
++            this.name = io.papermc.paper.util.MCUtil.getBaseComponentFromNbt("CustomName", nbt); // Paper - Catch ParseException
+         }
+ 
+     }

patches/server/0264-Honor-EntityAgeable.ageLock.patch

@@ -0,0 +1,38 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Sun, 23 Sep 2018 20:59:53 -0500
+Subject: [PATCH] Honor EntityAgeable.ageLock
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/AgeableMob.java b/src/main/java/net/minecraft/world/entity/AgeableMob.java
+index 6113e05a0636cc4895bccfbf87eef306138bcd33..22ba53d9f8866327752b0c33b517adb02c50b684 100644
+--- a/src/main/java/net/minecraft/world/entity/AgeableMob.java
++++ b/src/main/java/net/minecraft/world/entity/AgeableMob.java
+@@ -84,6 +84,7 @@ public abstract class AgeableMob extends PathfinderMob {
+     }
+ 
+     public void ageUp(int age, boolean overGrow) {
++        if (this.ageLocked) return; // Paper - GH-1459
+         int j = this.getAge();
+         int k = j;
+ 
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java
+index bd70aa9448a429f813f494c02d09432532985152..ea63802f2644bc2b5b3b0c72d7d09813cb68139d 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java
+@@ -299,6 +299,7 @@ public class BeehiveBlockEntity extends BlockEntity {
+     }
+ 
+     private static void setBeeReleaseData(int ticks, Bee bee) {
++        if (!bee.ageLocked) { // Paper - respect age lock
+         int j = bee.getAge();
+ 
+         if (j < 0) {
+@@ -306,6 +307,7 @@ public class BeehiveBlockEntity extends BlockEntity {
+         } else if (j > 0) {
+             bee.setAge(Math.max(0, j - ticks));
+         }
++        } // Paper - respect age lock
+ 
+         bee.setInLoveTime(Math.max(0, bee.getInLoveTime() - ticks));
+     }

patches/server/0265-Configurable-connection-throttle-kick-message.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Tue, 2 Oct 2018 09:57:50 +0100
+Subject: [PATCH] Configurable connection throttle kick message
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
+index a738b79e775a0a4abed1a05e12495d85f3de14bb..34e4d00ede62be50808a2782e54da987cc62c9af 100644
+--- a/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
+@@ -50,7 +50,7 @@ public class ServerHandshakePacketListenerImpl implements ServerHandshakePacketL
+                     synchronized (ServerHandshakePacketListenerImpl.throttleTracker) {
+                         if (ServerHandshakePacketListenerImpl.throttleTracker.containsKey(address) && !"127.0.0.1".equals(address.getHostAddress()) && currentTime - ServerHandshakePacketListenerImpl.throttleTracker.get(address) < connectionThrottle) {
+                             ServerHandshakePacketListenerImpl.throttleTracker.put(address, currentTime);
+-                            MutableComponent chatmessage = Component.literal("Connection throttled! Please wait before reconnecting.");
++                            Component chatmessage = io.papermc.paper.adventure.PaperAdventure.asVanilla(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.connectionThrottle); // Paper - Configurable connection throttle kick message
+                             this.connection.send(new ClientboundLoginDisconnectPacket(chatmessage));
+                             this.connection.disconnect(chatmessage);
+                             return;

patches/server/0266-Hook-into-CB-plugin-rewrites.patch

@@ -0,0 +1,197 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach@zachbr.io>
+Date: Wed, 3 Oct 2018 20:09:18 -0400
+Subject: [PATCH] Hook into CB plugin rewrites
+
+Allows us to do fun stuff like rewrite the OBC util fastutil location to
+our own relocation. Also lets us rewrite NMS calls for when we're
+debugging in an IDE pre-relocate.
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/util/Commodore.java b/src/main/java/org/bukkit/craftbukkit/util/Commodore.java
+index a679133a3de51e26eb19932ece9ade292879aefd..2c537a80951ddf98d3135ca19a34a238484c2d88 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/Commodore.java
++++ b/src/main/java/org/bukkit/craftbukkit/util/Commodore.java
+@@ -6,7 +6,9 @@ import java.io.FileOutputStream;
+ import java.io.InputStream;
+ import java.util.Arrays;
+ import java.util.Enumeration;
++import java.util.HashMap;
+ import java.util.HashSet;
++import java.util.Map;
+ import java.util.Set;
+ import java.util.jar.JarEntry;
+ import java.util.jar.JarFile;
+@@ -20,10 +22,15 @@ import org.bukkit.plugin.AuthorNagException;
+ import org.objectweb.asm.ClassReader;
+ import org.objectweb.asm.ClassVisitor;
+ import org.objectweb.asm.ClassWriter;
++import org.objectweb.asm.FieldVisitor;
++import org.objectweb.asm.Handle;
++import org.objectweb.asm.Label;
+ import org.objectweb.asm.MethodVisitor;
+ import org.objectweb.asm.Opcodes;
+ import org.objectweb.asm.Type;
+ 
++import javax.annotation.Nonnull;
++
+ /**
+  * This file is imported from Commodore.
+  *
+@@ -46,6 +53,41 @@ public class Commodore
+             "org/bukkit/inventory/ItemStack (I)V setTypeId"
+     ) );
+ 
++    // Paper start - Plugin rewrites
++    private static final Map<String, String> SEARCH_AND_REMOVE = initReplacementsMap();
++    private static Map<String, String> initReplacementsMap()
++    {
++        Map<String, String> getAndRemove = new HashMap<>();
++        // Be wary of maven shade's relocations
++
++        final java.util.jar.Manifest manifest = io.papermc.paper.util.JarManifests.manifest(Commodore.class);
++        if ( Boolean.getBoolean( "debug.rewriteForIde" ) && manifest != null)
++        {
++            // unversion incoming calls for pre-relocate debug work
++            final String NMS_REVISION_PACKAGE = "v" + manifest.getMainAttributes().getValue("CraftBukkit-Package-Version") + "/";
++
++            getAndRemove.put( "org/bukkit/".concat( "craftbukkit/" + NMS_REVISION_PACKAGE ), NMS_REVISION_PACKAGE );
++        }
++
++        return getAndRemove;
++    }
++
++    @Nonnull
++    private static String getOriginalOrRewrite(@Nonnull String original)
++    {
++        String rewrite = null;
++        for ( Map.Entry<String, String> entry : SEARCH_AND_REMOVE.entrySet() )
++        {
++            if ( original.contains( entry.getKey() ) )
++            {
++                rewrite = original.replace( entry.getValue(), "" );
++            }
++        }
++
++        return rewrite != null ? rewrite : original;
++    }
++    // Paper end
++
+     public static void main(String[] args)
+     {
+         OptionParser parser = new OptionParser();
+@@ -130,15 +172,86 @@ public class Commodore
+ 
+         cr.accept( new ClassVisitor( Opcodes.ASM9, cw )
+         {
++            // Paper start - Rewrite plugins
++            @Override
++            public FieldVisitor visitField(int access, String name, String desc, String signature, Object value)
++            {
++                desc = getOriginalOrRewrite( desc );
++                if ( signature != null ) {
++                    signature = getOriginalOrRewrite( signature );
++                }
++
++                return super.visitField( access, name, desc, signature, value) ;
++            }
++            // Paper end
++
+             @Override
+             public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions)
+             {
+                 return new MethodVisitor( api, super.visitMethod( access, name, desc, signature, exceptions ) )
+                 {
++                    // Paper start - Plugin rewrites
++                    @Override
++                    public void visitInvokeDynamicInsn(String name, String desc, Handle bootstrapMethodHandle, Object... bootstrapMethodArguments)
++                    {
++                        // Paper start - Rewrite plugins
++                        name = getOriginalOrRewrite( name );
++                        if ( desc != null )
++                        {
++                            desc = getOriginalOrRewrite( desc );
++                        }
++                        // Paper end
++
++                        super.visitInvokeDynamicInsn( name, desc, bootstrapMethodHandle, bootstrapMethodArguments );
++                    }
++
++                    @Override
++                    public void visitTypeInsn(int opcode, String type)
++                    {
++                        type = getOriginalOrRewrite( type );
++
++                        super.visitTypeInsn( opcode, type );
++                    }
++
++                    @Override
++                    public void visitFrame(int type, int nLocal, Object[] local, int nStack, Object[] stack) {
++                        for ( int i = 0; i < local.length; i++ )
++                        {
++                            if ( !( local[i] instanceof String ) ) { continue; }
++
++                            local[i] = getOriginalOrRewrite( (String) local[i] );
++                        }
++
++                        for ( int i = 0; i < stack.length; i++ )
++                        {
++                            if ( !( stack[i] instanceof String ) ) { continue; }
++
++                            stack[i] = getOriginalOrRewrite( (String) stack[i] );
++                        }
++
++                        super.visitFrame( type, nLocal, local, nStack, stack );
++                    }
++
++                    @Override
++                    public void visitLocalVariable(String name, String descriptor, String signature, Label start, Label end, int index)
++                    {
++                        descriptor = getOriginalOrRewrite( descriptor );
++
++                        super.visitLocalVariable( name, descriptor, signature, start, end, index );
++                    }
++                    // Paper end
+ 
+                     @Override
+                     public void visitFieldInsn(int opcode, String owner, String name, String desc)
+                     {
++                        // Paper start - Rewrite plugins
++                        owner = getOriginalOrRewrite( owner );
++                        if ( desc != null )
++                        {
++                            desc = getOriginalOrRewrite( desc );
++                        }
++                        // Paper end
++
+                         if ( owner.equals( "org/bukkit/block/Biome" ) )
+                         {
+                             switch ( name )
+@@ -306,6 +419,14 @@ public class Commodore
+                             return;
+                         }
+ 
++                        // Paper start - Rewrite plugins
++                        owner = getOriginalOrRewrite( owner) ;
++                        if (desc != null)
++                        {
++                            desc = getOriginalOrRewrite(desc);
++                        }
++                        // Paper end
++
+                         if ( modern )
+                         {
+                             if ( owner.equals( "org/bukkit/Material" ) )
+@@ -395,6 +516,13 @@ public class Commodore
+                     @Override
+                     public void visitLdcInsn(Object value)
+                     {
++                        // Paper start
++                        if (value instanceof Type type) {
++                            if (type.getSort() == Type.OBJECT || type.getSort() == Type.ARRAY) {
++                                value = Type.getType(getOriginalOrRewrite(type.getDescriptor()));
++                            }
++                        }
++                        // Paper end
+                         if ( value instanceof String && ( (String) value ).equals( "com.mysql.jdbc.Driver" ) )
+                         {
+                             super.visitLdcInsn( "com.mysql.cj.jdbc.Driver" );

patches/server/0267-PreSpawnerSpawnEvent.patch

@@ -0,0 +1,29 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Phoenix616 <mail@moep.tv>
+Date: Tue, 18 Sep 2018 23:53:23 +0100
+Subject: [PATCH] PreSpawnerSpawnEvent
+
+This adds a separate event before an entity is spawned by a spawner
+which contains the location of the spawner too similarly to how the
+SpawnerSpawnEvent gets called instead of the CreatureSpawnEvent for
+spawners.
+
+diff --git a/src/main/java/net/minecraft/world/level/BaseSpawner.java b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+index 23cecd12f064f70d314393971312d881cace043a..a985364e5dd4a592e282ad16f0555f842a1d5048 100644
+--- a/src/main/java/net/minecraft/world/level/BaseSpawner.java
++++ b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+@@ -134,11 +134,11 @@ public abstract class BaseSpawner {
+ 
+                         org.bukkit.entity.EntityType type = org.bukkit.entity.EntityType.fromName(key);
+                         if (type != null) {
+-                            com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent event;
+-                            event = new com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent(
++                            com.destroystokyo.paper.event.entity.PreSpawnerSpawnEvent event;
++                            event = new com.destroystokyo.paper.event.entity.PreSpawnerSpawnEvent(
+                                 io.papermc.paper.util.MCUtil.toLocation(world, d0, d1, d2),
+                                 type,
+-                                org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.SPAWNER
++                                io.papermc.paper.util.MCUtil.toLocation(world, pos)
+                             );
+                             if (!event.callEvent()) {
+                                 flag = true;

patches/server/0268-Add-LivingEntity-getTargetEntity.patch

@@ -0,0 +1,102 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Sat, 22 Sep 2018 00:33:08 -0500
+Subject: [PATCH] Add LivingEntity#getTargetEntity
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 785d5196c7e6de95e0507c959352ba57fb50d1c4..2c804ef89d910f706c449b4ce540ed1be3ac242a 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -117,6 +117,7 @@ import net.minecraft.world.level.storage.loot.LootTable;
+ import net.minecraft.world.level.storage.loot.parameters.LootContextParamSets;
+ import net.minecraft.world.level.storage.loot.parameters.LootContextParams;
+ import net.minecraft.world.phys.AABB;
++import net.minecraft.world.phys.EntityHitResult;
+ import net.minecraft.world.phys.HitResult;
+ import net.minecraft.world.phys.Vec3;
+ import net.minecraft.world.scores.PlayerTeam;
+@@ -3835,6 +3836,38 @@ public abstract class LivingEntity extends Entity {
+         return level.clip(raytrace);
+     }
+ 
++    public EntityHitResult getTargetEntity(int maxDistance) {
++        if (maxDistance < 1 || maxDistance > 120) {
++            throw new IllegalArgumentException("maxDistance must be between 1-120");
++        }
++
++        Vec3 start = this.getEyePosition(1.0F);
++        Vec3 direction = this.getLookAngle();
++        Vec3 end = start.add(direction.x * maxDistance, direction.y * maxDistance, direction.z * maxDistance);
++
++        List<Entity> entityList = level.getEntities(this, getBoundingBox().expandTowards(direction.x * maxDistance, direction.y * maxDistance, direction.z * maxDistance).inflate(1.0D, 1.0D, 1.0D), EntitySelector.NO_CREATIVE_OR_SPECTATOR.and(Entity::isPickable));
++
++        double distance = 0.0D;
++        EntityHitResult result = null;
++
++        for (Entity entity : entityList) {
++            final double inflationAmount = (double) entity.getPickRadius();
++            AABB aabb = entity.getBoundingBox().inflate(inflationAmount, inflationAmount, inflationAmount);
++            Optional<Vec3> rayTraceResult = aabb.clip(start, end);
++
++            if (rayTraceResult.isPresent()) {
++                Vec3 rayTrace = rayTraceResult.get();
++                double distanceTo = start.distanceToSqr(rayTrace);
++                if (distanceTo < distance || distance == 0.0D) {
++                    result = new EntityHitResult(entity, rayTrace);
++                    distance = distanceTo;
++                }
++            }
++        }
++
++        return result;
++    }
++
+     public int shieldBlockingDelay = level.paperConfig().misc.shieldBlockingDelay;
+ 
+     public int getShieldBlockingDelay() {
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index 6c5cb2e5fb1f5bb7eb05a465a24d62e1dad57b93..bfa6b088f87117015791dc4ab25d8e8cf4c4cf28 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -1,5 +1,6 @@
+ package org.bukkit.craftbukkit.entity;
+ 
++import com.destroystokyo.paper.entity.TargetEntityInfo;
+ import com.google.common.base.Preconditions;
+ import com.google.common.collect.Sets;
+ import java.util.ArrayList;
+@@ -220,6 +221,33 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+             new com.destroystokyo.paper.block.TargetBlockInfo(org.bukkit.craftbukkit.block.CraftBlock.at(getHandle().level, ((net.minecraft.world.phys.BlockHitResult)rayTrace).getBlockPos()),
+                 io.papermc.paper.util.MCUtil.toBukkitBlockFace(((net.minecraft.world.phys.BlockHitResult)rayTrace).getDirection()));
+     }
++
++    public Entity getTargetEntity(int maxDistance, boolean ignoreBlocks) {
++        net.minecraft.world.phys.EntityHitResult rayTrace = rayTraceEntity(maxDistance, ignoreBlocks);
++        return rayTrace == null ? null : rayTrace.getEntity().getBukkitEntity();
++    }
++
++    public TargetEntityInfo getTargetEntityInfo(int maxDistance, boolean ignoreBlocks) {
++        net.minecraft.world.phys.EntityHitResult rayTrace = rayTraceEntity(maxDistance, ignoreBlocks);
++        return rayTrace == null ? null : new TargetEntityInfo(rayTrace.getEntity().getBukkitEntity(), new org.bukkit.util.Vector(rayTrace.getLocation().x, rayTrace.getLocation().y, rayTrace.getLocation().z));
++    }
++
++    public net.minecraft.world.phys.EntityHitResult rayTraceEntity(int maxDistance, boolean ignoreBlocks) {
++        net.minecraft.world.phys.EntityHitResult rayTrace = getHandle().getTargetEntity(maxDistance);
++        if (rayTrace == null) {
++            return null;
++        }
++        if (!ignoreBlocks) {
++            net.minecraft.world.phys.HitResult rayTraceBlocks = getHandle().getRayTrace(maxDistance, net.minecraft.world.level.ClipContext.Fluid.NONE);
++            if (rayTraceBlocks != null) {
++                net.minecraft.world.phys.Vec3 eye = getHandle().getEyePosition(1.0F);
++                if (eye.distanceToSqr(rayTraceBlocks.getLocation()) <= eye.distanceToSqr(rayTrace.getLocation())) {
++                    return null;
++                }
++            }
++        }
++        return rayTrace;
++    }
+     // Paper end
+ 
+     @Override

patches/server/0269-Add-sun-related-API.patch

@@ -0,0 +1,42 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Sun, 7 Oct 2018 00:54:21 -0500
+Subject: [PATCH] Add sun related API
+
+== AT ==
+public net.minecraft.world.entity.Mob isSunBurnTick()Z
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index a21797af9f90235835919c395d2ea77a980b2768..00cfc9abb31c7fada8a7e4a99850d5c9f5b71c96 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -678,6 +678,13 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+         }
+     }
+ 
++    // Paper start
++    @Override
++    public boolean isDayTime() {
++        return getHandle().isDay();
++    }
++    // Paper end
++
+     @Override
+     public long getGameTime() {
+         return world.levelData.getGameTime();
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftMob.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftMob.java
+index f36713771598ac5afdae5d94db10a5790949611d..c92f7f31c3bf96f22fb1d2e783b14b80512448a0 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftMob.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftMob.java
+@@ -93,4 +93,11 @@ public abstract class CraftMob extends CraftLivingEntity implements Mob {
+     public long getSeed() {
+         return this.getHandle().lootTableSeed;
+     }
++
++    // Paper start
++    @Override
++    public boolean isInDaylight() {
++        return getHandle().isSunBurnTick();
++    }
++    // Paper end
+ }

patches/server/0270-Turtle-API.patch

@@ -0,0 +1,96 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Sat, 29 Sep 2018 16:08:23 -0500
+Subject: [PATCH] Turtle API
+
+== AT ==
+public net.minecraft.world.entity.animal.Turtle getHomePos()Lnet/minecraft/core/BlockPos;
+public net.minecraft.world.entity.animal.Turtle setHasEgg(Z)V
+public net.minecraft.world.entity.animal.Turtle isGoingHome()Z
+public net.minecraft.world.entity.animal.Turtle setGoingHome(Z)V
+public net.minecraft.world.entity.animal.Turtle isTravelling()Z
+public net.minecraft.world.entity.animal.Turtle setTravelling(Z)V
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/MoveToBlockGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/MoveToBlockGoal.java
+index e3983370c09e3e3445c4557fcca50dd25f29cba0..6efba52c2e5d7811ee329ed22c1c76f75d7ddbe1 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/MoveToBlockGoal.java
++++ b/src/main/java/net/minecraft/world/entity/ai/goal/MoveToBlockGoal.java
+@@ -14,7 +14,7 @@ public abstract class MoveToBlockGoal extends Goal {
+     protected int nextStartTick;
+     protected int tryTicks;
+     private int maxStayTicks;
+-    protected BlockPos blockPos = BlockPos.ZERO;
++    protected BlockPos blockPos = BlockPos.ZERO; @Deprecated public final BlockPos getTargetPosition() { return this.blockPos; } // Paper - OBFHELPER
+     private boolean reachedTarget;
+     private final int searchRange;
+     private final int verticalSearchRange;
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Turtle.java b/src/main/java/net/minecraft/world/entity/animal/Turtle.java
+index ab4e8ff5fe4f53bfda1d7b152aa89e6772bc3a16..30663713e198bfe40b95c48524b71ea65f39965e 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Turtle.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Turtle.java
+@@ -482,14 +482,17 @@ public class Turtle extends Animal {
+ 
+             if (!this.turtle.isInWater() && this.isReachedTarget()) {
+                 if (this.turtle.layEggCounter < 1) {
+-                    this.turtle.setLayingEgg(true);
++                    this.turtle.setLayingEgg(new com.destroystokyo.paper.event.entity.TurtleStartDiggingEvent((org.bukkit.entity.Turtle) this.turtle.getBukkitEntity(), io.papermc.paper.util.MCUtil.toLocation(this.turtle.level, this.getTargetPosition())).callEvent()); // Paper
+                 } else if (this.turtle.layEggCounter > this.adjustedTickDelay(200)) {
+                     Level world = this.turtle.level;
+ 
+                     // CraftBukkit start
+-                    if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(this.turtle, this.blockPos.above(), (BlockState) Blocks.TURTLE_EGG.defaultBlockState().setValue(TurtleEggBlock.EGGS, this.turtle.random.nextInt(4) + 1)).isCancelled()) {
++                    // Paper start
++                    int eggCount = this.turtle.random.nextInt(4) + 1;
++                    com.destroystokyo.paper.event.entity.TurtleLayEggEvent layEggEvent = new com.destroystokyo.paper.event.entity.TurtleLayEggEvent((org.bukkit.entity.Turtle) this.turtle.getBukkitEntity(), io.papermc.paper.util.MCUtil.toLocation(this.turtle.level, this.blockPos.above()), eggCount);
++                    if (layEggEvent.callEvent() && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(this.turtle, this.blockPos.above(), Blocks.TURTLE_EGG.defaultBlockState().setValue(TurtleEggBlock.EGGS, layEggEvent.getEggCount())).isCancelled()) {
+                     world.playSound((Player) null, blockposition, SoundEvents.TURTLE_LAY_EGG, SoundSource.BLOCKS, 0.3F, 0.9F + world.random.nextFloat() * 0.2F);
+-                    world.setBlock(this.blockPos.above(), (BlockState) Blocks.TURTLE_EGG.defaultBlockState().setValue(TurtleEggBlock.EGGS, this.turtle.random.nextInt(4) + 1), 3);
++                    world.setBlock(this.blockPos.above(), (BlockState) Blocks.TURTLE_EGG.defaultBlockState().setValue(TurtleEggBlock.EGGS, layEggEvent.getEggCount()), 3);
+                     }
+                     // CraftBukkit end
+                     this.turtle.setHasEgg(false);
+@@ -557,7 +560,7 @@ public class Turtle extends Animal {
+ 
+         @Override
+         public boolean canUse() {
+-            return this.turtle.isBaby() ? false : (this.turtle.hasEgg() ? true : (this.turtle.getRandom().nextInt(reducedTickDelay(700)) != 0 ? false : !this.turtle.getHomePos().closerToCenterThan(this.turtle.position(), 64.0D)));
++            return this.turtle.isBaby() ? false : (this.turtle.hasEgg() ? true : (this.turtle.getRandom().nextInt(reducedTickDelay(700)) != 0 ? false : !this.turtle.getHomePos().closerToCenterThan(this.turtle.position(), 64.0D))) && new com.destroystokyo.paper.event.entity.TurtleGoHomeEvent((org.bukkit.entity.Turtle) this.turtle.getBukkitEntity()).callEvent(); // Paper
+         }
+ 
+         @Override
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftTurtle.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftTurtle.java
+index 96462a29551c301d3c80029cab2bec3839914237..a14d0a688b9054988b5c86c94738e4aaca9f9cfd 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftTurtle.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftTurtle.java
+@@ -34,4 +34,31 @@ public class CraftTurtle extends CraftAnimals implements Turtle {
+     public boolean isLayingEgg() {
+         return this.getHandle().isLayingEgg();
+     }
++
++    // Paper start
++    @Override
++    public org.bukkit.Location getHome() {
++        return io.papermc.paper.util.MCUtil.toLocation(getHandle().getLevel(), getHandle().getHomePos());
++    }
++
++    @Override
++    public void setHome(org.bukkit.Location location) {
++        getHandle().setHomePos(io.papermc.paper.util.MCUtil.toBlockPosition(location));
++    }
++
++    @Override
++    public boolean isGoingHome() {
++        return getHandle().isGoingHome();
++    }
++
++    @Override
++    public boolean isDigging() {
++        return getHandle().isLayingEgg();
++    }
++
++    @Override
++    public void setHasEgg(boolean hasEgg) {
++        getHandle().setHasEgg(hasEgg);
++    }
++    // Paper end
+ }

patches/server/0271-Call-player-spectator-target-events-and-improve-impl.patch

@@ -0,0 +1,89 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Caleb Bassham <caleb.bassham@gmail.com>
+Date: Fri, 28 Sep 2018 02:32:19 -0500
+Subject: [PATCH] Call player spectator target events and improve
+ implementation
+
+Use a proper teleport for teleporting to entities in different
+worlds.
+
+Implementation improvements authored by Spottedleaf <Spottedleaf@users.noreply.github.com>
+Validate that the target entity is valid and deny spectate
+requests from frozen players.
+
+Also, make sure the entity is spawned to the client before
+sending the camera packet. If the entity isn't spawned clientside
+when it receives the camera packet, then the client will not
+spectate the target entity.
+
+Co-authored-by: Spottedleaf <Spottedleaf@users.noreply.github.com>
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 05e72945da26295fbc5f0d243ba48a8649244b3b..572dc30729a4511dcc7002434017edf8b0ce5a89 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -1908,15 +1908,59 @@ public class ServerPlayer extends Player {
+     }
+ 
+     public void setCamera(@Nullable Entity entity) {
++        // Paper start - Add PlayerStartSpectatingEntityEvent and PlayerStopSpectatingEntity Event and improve implementation
+         Entity entity1 = this.getCamera();
+ 
+-        this.camera = (Entity) (entity == null ? this : entity);
+-        if (entity1 != this.camera) {
+-            this.connection.send(new ClientboundSetCameraPacket(this.camera));
+-            this.connection.teleport(this.camera.getX(), this.camera.getY(), this.camera.getZ(), this.getYRot(), this.getXRot(), TeleportCause.SPECTATE); // CraftBukkit
+-            this.connection.resetPosition();
++        if (entity == null) {
++            entity = this;
+         }
+ 
++        if (entity1 == entity) return; // new spec target is the current spec target
++
++        if (entity == this) {
++            com.destroystokyo.paper.event.player.PlayerStopSpectatingEntityEvent playerStopSpectatingEntityEvent = new com.destroystokyo.paper.event.player.PlayerStopSpectatingEntityEvent(this.getBukkitEntity(), entity1.getBukkitEntity());
++
++            if (!playerStopSpectatingEntityEvent.callEvent()) {
++                return;
++            }
++        } else {
++            com.destroystokyo.paper.event.player.PlayerStartSpectatingEntityEvent playerStartSpectatingEntityEvent = new com.destroystokyo.paper.event.player.PlayerStartSpectatingEntityEvent(this.getBukkitEntity(), entity1.getBukkitEntity(), entity.getBukkitEntity());
++
++            if (!playerStartSpectatingEntityEvent.callEvent()) {
++                return;
++            }
++        }
++        // Validate
++        if (entity != this) {
++            if (entity.isRemoved() || !entity.valid || entity.level == null) {
++                MinecraftServer.LOGGER.info("Blocking player " + this + " from spectating invalid entity " + entity);
++                return;
++            }
++            if (this.isImmobile()) {
++                // use debug: clients might maliciously spam this
++                MinecraftServer.LOGGER.debug("Blocking frozen player " + this + " from spectating entity " + entity);
++                return;
++            }
++        }
++
++        this.camera = entity; // only set after validating state
++
++        if (entity != this) {
++            // Make sure we're in the right place
++            this.ejectPassengers(); // teleport can fail if we have passengers...
++            this.getBukkitEntity().teleport(new Location(entity.getCommandSenderWorld().getWorld(), entity.getX(), entity.getY(), entity.getZ(), this.getYRot(), this.getXRot()), TeleportCause.SPECTATE); // Correctly handle cross-world entities from api calls by using CB teleport
++
++            // Make sure we're tracking the entity before sending
++            ChunkMap.TrackedEntity tracker = ((ServerLevel)entity.level).getChunkSource().chunkMap.entityMap.get(entity.getId());
++            if (tracker != null) { // dumb plugins...
++                tracker.updatePlayer(this);
++            }
++        } else {
++            this.connection.teleport(this.camera.getX(), this.camera.getY(), this.camera.getZ(), this.getYRot(), this.getXRot(), TeleportCause.SPECTATE); // CraftBukkit
++        }
++        this.connection.send(new ClientboundSetCameraPacket(entity));
++        this.connection.resetPosition();
++        // Paper end
+     }
+ 
+     @Override

patches/server/0272-MC-50319-Check-other-worlds-for-shooter-of-projectil.patch

@@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Wed, 17 Oct 2018 19:17:27 -0400
+Subject: [PATCH] MC-50319: Check other worlds for shooter of projectiles
+
+Say a player shoots an arrow through a nether portal, the game
+would lose the shooter for determining things such as Player Kills,
+because the entity is in another world.
+
+If the projectile fails to find the shooter in the current world, check
+other worlds.
+
+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 11cfe63c101f5d76d3481a3163dbaec22685ccce..b0caf14a196cd8c3a02d8e931a08857173ffb4da 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
++++ b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
+@@ -58,6 +58,18 @@ public abstract class Projectile extends Entity {
+             return this.cachedOwner;
+         } else if (this.ownerUUID != null && this.level instanceof ServerLevel) {
+             this.cachedOwner = ((ServerLevel) this.level).getEntity(this.ownerUUID);
++            // Paper start - check all worlds
++            if (this.cachedOwner == null) {
++                for (final ServerLevel level : this.level.getServer().getAllLevels()) {
++                    if (level == this.level) continue;
++                    final Entity entity = level.getEntity(this.ownerUUID);
++                    if (entity != null) {
++                        this.cachedOwner = entity;
++                        break;
++                    }
++                }
++            }
++            // Paper end
+             return this.cachedOwner;
+         } else {
+             return null;

patches/server/0273-Add-more-Witch-API.patch

@@ -0,0 +1,116 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Fri, 12 Oct 2018 14:10:46 -0500
+Subject: [PATCH] Add more Witch API
+
+== AT ==
+public net.minecraft.world.entity.monster.Witch usingTime
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Witch.java b/src/main/java/net/minecraft/world/entity/monster/Witch.java
+index 1ee8fec8f9f581fa68497ebf4f90aad9d425ec71..b7bc64818387288955d0723cd071d4203bd2f121 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Witch.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Witch.java
+@@ -156,21 +156,24 @@ public class Witch extends Raider implements RangedAttackMob {
+                 }
+ 
+                 if (potionregistry != null) {
+-                    // Paper start
+                     ItemStack potion = PotionUtils.setPotion(new ItemStack(Items.POTION), potionregistry);
+-                    org.bukkit.inventory.ItemStack bukkitStack = com.destroystokyo.paper.event.entity.WitchReadyPotionEvent.process((org.bukkit.entity.Witch) this.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(potion));
+-                    this.setItemSlot(EquipmentSlot.MAINHAND, org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(bukkitStack));
++                    // Paper start - logic moved into setDrinkingPotion, copy exact impl into the method and then comment out
++                    this.setDrinkingPotion(potion);
++//                    org.bukkit.inventory.ItemStack bukkitStack = com.destroystokyo.paper.event.entity.WitchReadyPotionEvent.process((org.bukkit.entity.Witch) this.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(potion));
++//                    this.setSlot(EnumItemSlot.MAINHAND, org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(bukkitStack));
++//                    // Paper end
++//                    this.bq = this.getItemInMainHand().k();
++//                    this.v(true);
++//                    if (!this.isSilent()) {
++//                        this.world.playSound((EntityHuman) null, this.locX(), this.locY(), this.locZ(), SoundEffects.ENTITY_WITCH_DRINK, this.getSoundCategory(), 1.0F, 0.8F + this.random.nextFloat() * 0.4F);
++//                    }
++//
++//                    AttributeModifiable attributemodifiable = this.getAttributeInstance(GenericAttributes.MOVEMENT_SPEED);
++//
++//                    attributemodifiable.removeModifier(EntityWitch.bo);
++//                    attributemodifiable.b(EntityWitch.bo);
+                     // Paper end
+-                    this.usingTime = this.getMainHandItem().getUseDuration();
+-                    this.setUsingItem(true);
+-                    if (!this.isSilent()) {
+-                        this.level.playSound((Player) null, this.getX(), this.getY(), this.getZ(), SoundEvents.WITCH_DRINK, this.getSoundSource(), 1.0F, 0.8F + this.random.nextFloat() * 0.4F);
+-                    }
+-
+-                    AttributeInstance attributemodifiable = this.getAttribute(Attributes.MOVEMENT_SPEED);
+ 
+-                    attributemodifiable.removeModifier(Witch.SPEED_MODIFIER_DRINKING);
+-                    attributemodifiable.addTransientModifier(Witch.SPEED_MODIFIER_DRINKING);
+                 }
+             }
+ 
+@@ -182,6 +185,24 @@ public class Witch extends Raider implements RangedAttackMob {
+         super.aiStep();
+     }
+ 
++    // Paper start - moved to its own method
++    public void setDrinkingPotion(ItemStack potion) {
++        org.bukkit.inventory.ItemStack bukkitStack = com.destroystokyo.paper.event.entity.WitchReadyPotionEvent.process((org.bukkit.entity.Witch) this.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(potion));
++        this.setItemSlot(EquipmentSlot.MAINHAND, org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(bukkitStack));
++        // Paper end
++        this.usingTime = this.getMainHandItem().getUseDuration();
++        this.setUsingItem(true);
++        if (!this.isSilent()) {
++            this.level.playSound((Player) null, this.getX(), this.getY(), this.getZ(), SoundEvents.WITCH_DRINK, this.getSoundSource(), 1.0F, 0.8F + this.random.nextFloat() * 0.4F);
++        }
++
++        AttributeInstance attributemodifiable = this.getAttribute(Attributes.MOVEMENT_SPEED);
++
++        attributemodifiable.removeModifier(Witch.SPEED_MODIFIER_DRINKING);
++        attributemodifiable.addTransientModifier(Witch.SPEED_MODIFIER_DRINKING);
++    }
++    // Paper end
++
+     @Override
+     public SoundEvent getCelebrateSound() {
+         return SoundEvents.WITCH_CELEBRATE;
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java
+index eada1f0ff10d4c00f82a6f4411fe18b7184e9901..9039db1a72009342063d4db08e18e6aee18836e8 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java
+@@ -3,6 +3,13 @@ package org.bukkit.craftbukkit.entity;
+ import org.bukkit.craftbukkit.CraftServer;
+ import org.bukkit.entity.EntityType;
+ import org.bukkit.entity.Witch;
++// Paper start
++import com.destroystokyo.paper.entity.CraftRangedEntity;
++import com.google.common.base.Preconditions;
++import org.bukkit.Material;
++import org.bukkit.craftbukkit.inventory.CraftItemStack;
++import org.bukkit.inventory.ItemStack;
++// Paper end
+ 
+ public class CraftWitch extends CraftRaider implements Witch, com.destroystokyo.paper.entity.CraftRangedEntity<net.minecraft.world.entity.monster.Witch> { // Paper
+     public CraftWitch(CraftServer server, net.minecraft.world.entity.monster.Witch entity) {
+@@ -28,4 +35,23 @@ public class CraftWitch extends CraftRaider implements Witch, com.destroystokyo.
+     public boolean isDrinkingPotion() {
+         return this.getHandle().isDrinkingPotion();
+     }
++    // Paper start
++    public int getPotionUseTimeLeft() {
++        return getHandle().usingTime;
++    }
++
++    @Override
++    public void setPotionUseTimeLeft(int ticks) {
++        getHandle().usingTime = ticks;
++    }
++
++    public ItemStack getDrinkingPotion() {
++        return CraftItemStack.asCraftMirror(getHandle().getMainHandItem());
++    }
++
++    public void setDrinkingPotion(ItemStack potion) {
++        Preconditions.checkArgument(potion == null || potion.getType().isEmpty() || potion.getType() == Material.POTION, "must be potion, air, or null");
++        getHandle().setDrinkingPotion(CraftItemStack.asNMSCopy(potion));
++    }
++    // Paper end
+ }

patches/server/0274-Check-Drowned-for-Villager-Aggression-Config.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Wed, 10 Oct 2018 21:22:44 -0500
+Subject: [PATCH] Check Drowned for Villager Aggression Config
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Drowned.java b/src/main/java/net/minecraft/world/entity/monster/Drowned.java
+index 2a3e9d3b847c155ba1d18c0711210c3e41bc3eac..1b1305f5eaf5710b72c57ab4c3953e703a23f1e0 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Drowned.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Drowned.java
+@@ -78,7 +78,7 @@ public class Drowned extends Zombie implements RangedAttackMob {
+         this.goalSelector.addGoal(7, new RandomStrollGoal(this, 1.0D));
+         this.targetSelector.addGoal(1, (new HurtByTargetGoal(this, new Class[]{Drowned.class})).setAlertOthers(ZombifiedPiglin.class));
+         this.targetSelector.addGoal(2, new NearestAttackableTargetGoal<>(this, Player.class, 10, true, false, this::okTarget));
+-        this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, AbstractVillager.class, false));
++        if (this.level.spigotConfig.zombieAggressiveTowardsVillager) this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, AbstractVillager.class, false)); // Paper
+         this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, IronGolem.class, true));
+         this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, Axolotl.class, true, false));
+         this.targetSelector.addGoal(5, new NearestAttackableTargetGoal<>(this, Turtle.class, 10, true, false, Turtle.BABY_ON_LAND_SELECTOR));

patches/server/0275-Add-option-to-prevent-players-from-moving-into-unloa.patch

@@ -0,0 +1,67 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Gabriele C <sgdc3.mail@gmail.com>
+Date: Mon, 22 Oct 2018 17:34:10 +0200
+Subject: [PATCH] Add option to prevent players from moving into unloaded
+ chunks #1551
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index c5ad4d8a08f03a6f75241f4e4913d84bcb0fdf0b..9843684ab5cf21bfc4fe30f3528dc75475b4dcd1 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -563,9 +563,9 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+                 double d0 = entity.getX();
+                 double d1 = entity.getY();
+                 double d2 = entity.getZ();
+-                double d3 = ServerGamePacketListenerImpl.clampHorizontal(packet.getX());
+-                double d4 = ServerGamePacketListenerImpl.clampVertical(packet.getY());
+-                double d5 = ServerGamePacketListenerImpl.clampHorizontal(packet.getZ());
++                double d3 = ServerGamePacketListenerImpl.clampHorizontal(packet.getX()); final double toX = d3; // Paper - OBFHELPER
++                double d4 = ServerGamePacketListenerImpl.clampVertical(packet.getY()); final double toY = d4; // Paper - OBFHELPER
++                double d5 = ServerGamePacketListenerImpl.clampHorizontal(packet.getZ()); final double toZ = d5; // Paper - OBFHELPER
+                 float f = Mth.wrapDegrees(packet.getYRot());
+                 float f1 = Mth.wrapDegrees(packet.getXRot());
+                 double d6 = d3 - this.vehicleFirstGoodX;
+@@ -600,6 +600,16 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+                 }
+                 speed *= 2f; // TODO: Get the speed of the vehicle instead of the player
+ 
++                // Paper start - Prevent moving into unloaded chunks
++                if (player.level.paperConfig().chunks.preventMovingIntoUnloadedChunks && (
++                    !worldserver.areChunksLoadedForMove(this.player.getBoundingBox().expandTowards(new Vec3(toX, toY, toZ).subtract(this.player.position()))) ||
++                        !worldserver.areChunksLoadedForMove(entity.getBoundingBox().expandTowards(new Vec3(toX, toY, toZ).subtract(entity.position())))
++                    )) {
++                    this.connection.send(new ClientboundMoveVehiclePacket(entity));
++                    return;
++                }
++                // Paper end
++
+                 if (d10 - d9 > Math.max(100.0D, Math.pow((double) (org.spigotmc.SpigotConfig.movedTooQuicklyMultiplier * (float) i * speed), 2)) && !this.isSingleplayerOwner()) {
+                 // CraftBukkit end
+                     ServerGamePacketListenerImpl.LOGGER.warn("{} (vehicle of {}) moved too quickly! {},{},{}", new Object[]{entity.getName().getString(), this.player.getName().getString(), d6, d7, d8});
+@@ -1249,9 +1259,9 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+                     this.allowedPlayerTicks = 20; // CraftBukkit
+                 } else {
+                     this.awaitingTeleportTime = this.tickCount;
+-                    double d0 = ServerGamePacketListenerImpl.clampHorizontal(packet.getX(this.player.getX()));
+-                    double d1 = ServerGamePacketListenerImpl.clampVertical(packet.getY(this.player.getY()));
+-                    double d2 = ServerGamePacketListenerImpl.clampHorizontal(packet.getZ(this.player.getZ()));
++                    double d0 = ServerGamePacketListenerImpl.clampHorizontal(packet.getX(this.player.getX())); final double toX = d0; // Paper - OBFHELPER
++                    double d1 = ServerGamePacketListenerImpl.clampVertical(packet.getY(this.player.getY())); final double toY = d1;
++                    double d2 = ServerGamePacketListenerImpl.clampHorizontal(packet.getZ(this.player.getZ())); final double toZ = d2; // Paper - OBFHELPER
+                     float f = Mth.wrapDegrees(packet.getYRot(this.player.getYRot()));
+                     float f1 = Mth.wrapDegrees(packet.getXRot(this.player.getXRot()));
+ 
+@@ -1307,6 +1317,12 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+                             } else {
+                                 speed = this.player.getAbilities().walkingSpeed * 10f;
+                             }
++                            // Paper start - Prevent moving into unloaded chunks
++                            if (player.level.paperConfig().chunks.preventMovingIntoUnloadedChunks && (this.player.getX() != toX || this.player.getZ() != toZ) && !worldserver.areChunksLoadedForMove(this.player.getBoundingBox().expandTowards(new Vec3(toX, toY, toZ).subtract(this.player.position())))) {
++                                this.internalTeleport(this.player.getX(), this.player.getY(), this.player.getZ(), this.player.getYRot(), this.player.getXRot(), Collections.emptySet(), true);
++                                return;
++                            }
++                            // Paper end
+ 
+                             if (!this.player.isChangingDimension() && (!this.player.getLevel().getGameRules().getBoolean(GameRules.RULE_DISABLE_ELYTRA_MOVEMENT_CHECK) || !this.player.isFallFlying())) {
+                                 float f2 = this.player.isFallFlying() ? 300.0F : 100.0F;

patches/server/0276-Reset-players-airTicks-on-respawn.patch

@@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: GreenMeanie <GreenMeanieMC@gmail.com>
+Date: Sat, 20 Oct 2018 22:34:02 -0400
+Subject: [PATCH] Reset players airTicks on respawn
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 572dc30729a4511dcc7002434017edf8b0ce5a89..15d4ad53cca71272e491bea31d83e8c8e697dac0 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -2337,6 +2337,7 @@ public class ServerPlayer extends Player {
+ 
+         this.setHealth(this.getMaxHealth());
+         this.stopUsingItem(); // CraftBukkit - SPIGOT-6682: Clear active item on reset
++        this.setAirSupply(this.getMaxAirSupply()); // Paper
+         this.remainingFireTicks = 0;
+         this.fallDistance = 0;
+         this.foodData = new FoodData(this);

patches/server/0277-Don-t-sleep-after-profile-lookups-if-not-needed.patch

@@ -0,0 +1,33 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 23 Oct 2018 20:25:05 -0400
+Subject: [PATCH] Don't sleep after profile lookups if not needed
+
+Mojang was sleeping even if we had no more requests to go after
+the current one finished, resulting in 100ms lost per profile lookup
+
+diff --git a/src/main/java/com/mojang/authlib/yggdrasil/YggdrasilGameProfileRepository.java b/src/main/java/com/mojang/authlib/yggdrasil/YggdrasilGameProfileRepository.java
+index cc38e909d1fa83206fa09666599d853a6e89ef36..c48a40155108b6bae18073638a0ba12649344261 100644
+--- a/src/main/java/com/mojang/authlib/yggdrasil/YggdrasilGameProfileRepository.java
++++ b/src/main/java/com/mojang/authlib/yggdrasil/YggdrasilGameProfileRepository.java
+@@ -43,6 +43,7 @@ public class YggdrasilGameProfileRepository implements GameProfileRepository {
+         }
+ 
+         final int page = 0;
++        boolean hasRequested = false; // Paper
+ 
+         for (final List<String> request : Iterables.partition(criteria, ENTRIES_PER_PAGE)) {
+             int failCount = 0;
+@@ -68,6 +69,12 @@ public class YggdrasilGameProfileRepository implements GameProfileRepository {
+                         LOGGER.debug("Couldn't find profile {}", name);
+                         callback.onProfileLookupFailed(new GameProfile(null, name), new ProfileNotFoundException("Server did not find the requested profile"));
+                     }
++                    // Paper start
++                    if (!hasRequested) {
++                        hasRequested = true;
++                        continue;
++                    }
++                    // Paper end
+ 
+                     try {
+                         Thread.sleep(DELAY_BETWEEN_PAGES);

patches/server/0278-Improve-Server-Thread-Pool-and-Thread-Priorities.patch

@@ -0,0 +1,94 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 23 Oct 2018 23:14:38 -0400
+Subject: [PATCH] Improve Server Thread Pool and Thread Priorities
+
+Use a simple executor since Fork join is a much more complex pool
+type and we are not using its capabilities.
+
+Set thread priorities so main thread has above normal priority over
+server threads
+
+Allow usage of a single thread executor by not using ForkJoin so single core CPU's.
+
+== AT ==
+public net.minecraft.Util onThreadException(Ljava/lang/Thread;Ljava/lang/Throwable;)V
+
+diff --git a/src/main/java/io/papermc/paper/util/ServerWorkerThread.java b/src/main/java/io/papermc/paper/util/ServerWorkerThread.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..b60f59cf5cc8eb84a6055b7861857dece7f2501b
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/util/ServerWorkerThread.java
+@@ -0,0 +1,14 @@
++package io.papermc.paper.util;
++
++import java.util.concurrent.atomic.AtomicInteger;
++import net.minecraft.Util;
++
++public class ServerWorkerThread extends Thread {
++    private static final AtomicInteger threadId = new AtomicInteger(1);
++    public ServerWorkerThread(Runnable target, String poolName, int prioritityModifier) {
++        super(target, "Worker-" + poolName + "-" + threadId.getAndIncrement());
++        setPriority(Thread.NORM_PRIORITY+prioritityModifier); // Deprioritize over main
++        this.setDaemon(true);
++        this.setUncaughtExceptionHandler(Util::onThreadException);
++    }
++}
+diff --git a/src/main/java/net/minecraft/Util.java b/src/main/java/net/minecraft/Util.java
+index c085ed233eb4d1f2100ec23a77447ef799ecdf1f..8120739e2a7c4c86ecb7058f08bd8179d3a943b8 100644
+--- a/src/main/java/net/minecraft/Util.java
++++ b/src/main/java/net/minecraft/Util.java
+@@ -79,8 +79,8 @@ public class Util {
+     private static final int DEFAULT_MAX_THREADS = 255;
+     private static final String MAX_THREADS_SYSTEM_PROPERTY = "max.bg.threads";
+     private static final AtomicInteger WORKER_COUNT = new AtomicInteger(1);
+-    private static final ExecutorService BOOTSTRAP_EXECUTOR = makeExecutor("Bootstrap");
+-    private static final ExecutorService BACKGROUND_EXECUTOR = makeExecutor("Main");
++    private static final ExecutorService BOOTSTRAP_EXECUTOR = makeExecutor("Bootstrap", -2); // Paper - add -2 priority
++    private static final ExecutorService BACKGROUND_EXECUTOR = makeExecutor("Main", -1); // Paper - add -1 priority
+     // Paper start - don't submit BLOCKING PROFILE LOOKUPS to the world gen thread
+     public static final ExecutorService PROFILE_EXECUTOR = Executors.newFixedThreadPool(2, new java.util.concurrent.ThreadFactory() {
+ 
+@@ -143,14 +143,18 @@ public class Util {
+         return FILENAME_DATE_TIME_FORMATTER.format(ZonedDateTime.now());
+     }
+ 
+-    private static ExecutorService makeExecutor(String name) {
+-        int i = Mth.clamp(Runtime.getRuntime().availableProcessors() - 1, 1, getMaxThreads());
++    private static ExecutorService makeExecutor(String s, int priorityModifier) { // Paper - add priority
++        // Paper start - use simpler thread pool that allows 1 thread
++        int i = Math.min(8, Math.max(Runtime.getRuntime().availableProcessors() - 2, 1));
++        i = Integer.getInteger("Paper.WorkerThreadCount", i);
+         ExecutorService executorService;
++
+         if (i <= 0) {
+             executorService = MoreExecutors.newDirectExecutorService();
+         } else {
+-            executorService = new ForkJoinPool(i, (forkJoinPool) -> {
+-                ForkJoinWorkerThread forkJoinWorkerThread = new ForkJoinWorkerThread(forkJoinPool) {
++            executorService = new java.util.concurrent.ThreadPoolExecutor(i, i,0L, TimeUnit.MILLISECONDS, new java.util.concurrent.LinkedBlockingQueue<Runnable>(), target -> new io.papermc.paper.util.ServerWorkerThread(target, s, priorityModifier));
++        }
++        /*
+                     @Override
+                     protected void onTermination(Throwable throwable) {
+                         if (throwable != null) {
+@@ -166,6 +170,7 @@ public class Util {
+                 return forkJoinWorkerThread;
+             }, Util::onThreadException, true);
+         }
++        }*/ // Paper end
+ 
+         return executorService;
+     }
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 6026a2da9645a5f22aa18c74e35d8b76a3f29352..45f3035be38571088edf293070b8d84b19a4101a 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -317,6 +317,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         S s0 = serverFactory.apply(thread); // CraftBukkit - decompile error
+ 
+         atomicreference.set(s0);
++        thread.setPriority(Thread.NORM_PRIORITY+2); // Paper - boost priority
+         thread.start();
+         return s0;
+     }

patches/server/0279-Optimize-World-Time-Updates.patch

@@ -0,0 +1,42 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Fri, 2 Nov 2018 23:11:51 -0400
+Subject: [PATCH] Optimize World Time Updates
+
+Splits time updates into incremental updates as well as does
+the updates per world, so that we can re-use the same packet
+object for every player unless they have per-player time enabled.
+
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 45f3035be38571088edf293070b8d84b19a4101a..f9007905422f7a6eac7c78fd5bdb17cb4da96712 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1379,12 +1379,24 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
+         MinecraftTimings.timeUpdateTimer.startTiming(); // Spigot // Paper
+         // Send time updates to everyone, it will get the right time from the world the player is in.
+-        if (this.tickCount % 20 == 0) {
+-            for (int i = 0; i < this.getPlayerList().players.size(); ++i) {
+-                ServerPlayer entityplayer = (ServerPlayer) this.getPlayerList().players.get(i);
+-                entityplayer.connection.send(new ClientboundSetTimePacket(entityplayer.level.getGameTime(), entityplayer.getPlayerTime(), entityplayer.level.getGameRules().getBoolean(GameRules.RULE_DAYLIGHT))); // Add support for per player time
++        // Paper start - optimize time updates
++        for (final ServerLevel world : this.getAllLevels()) {
++            final boolean doDaylight = world.getGameRules().getBoolean(GameRules.RULE_DAYLIGHT);
++            final long dayTime = world.getDayTime();
++            long worldTime = world.getGameTime();
++            final ClientboundSetTimePacket worldPacket = new ClientboundSetTimePacket(worldTime, dayTime, doDaylight);
++            for (Player entityhuman : world.players()) {
++                if (!(entityhuman instanceof ServerPlayer) || (tickCount + entityhuman.getId()) % 20 != 0) {
++                    continue;
++                }
++                ServerPlayer entityplayer = (ServerPlayer) entityhuman;
++                long playerTime = entityplayer.getPlayerTime();
++                ClientboundSetTimePacket packet = (playerTime == dayTime) ? worldPacket :
++                    new ClientboundSetTimePacket(worldTime, playerTime, doDaylight);
++                entityplayer.connection.send(packet); // Add support for per player time
+             }
+         }
++        // Paper end
+         MinecraftTimings.timeUpdateTimer.stopTiming(); // Spigot // Paper
+ 
+         while (iterator.hasNext()) {

patches/server/0280-Restore-custom-InventoryHolder-support.patch

@@ -0,0 +1,354 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Mon, 5 Nov 2018 04:23:51 +0000
+Subject: [PATCH] Restore custom InventoryHolder support
+
+Upstream removed the ability to consistently use a custom InventoryHolder,
+However, the implementation does not use an InventoryHolder in any form
+outside of custom inventories.
+
+== AT ==
+public-f net.minecraft.world.inventory.AbstractContainerMenu dataSlots
+public-f net.minecraft.world.inventory.AbstractContainerMenu remoteDataSlots
+
+Co-authored-by: Shane Freeder <theboyetronic@gmail.com>
+
+diff --git a/src/main/java/io/papermc/paper/inventory/PaperInventoryCustomHolderContainer.java b/src/main/java/io/papermc/paper/inventory/PaperInventoryCustomHolderContainer.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..224d4b2cc45b0d02230a76caee9c88573a448b4c
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/inventory/PaperInventoryCustomHolderContainer.java
+@@ -0,0 +1,141 @@
++package io.papermc.paper.inventory;
++
++import io.papermc.paper.adventure.PaperAdventure;
++import net.kyori.adventure.text.Component;
++import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
++import net.minecraft.world.Container;
++import net.minecraft.world.entity.player.Player;
++import net.minecraft.world.item.ItemStack;
++import net.minecraft.world.level.block.entity.BaseContainerBlockEntity;
++import org.bukkit.Location;
++import org.bukkit.craftbukkit.entity.CraftHumanEntity;
++import org.bukkit.entity.HumanEntity;
++import org.bukkit.event.inventory.InventoryType;
++import org.bukkit.inventory.InventoryHolder;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.checkerframework.checker.nullness.qual.Nullable;
++import org.checkerframework.framework.qual.DefaultQualifier;
++
++import java.util.List;
++
++@DefaultQualifier(NonNull.class)
++public final class PaperInventoryCustomHolderContainer implements Container {
++
++    private final InventoryHolder owner;
++    private final Container delegate;
++    private final InventoryType type;
++    private final String title;
++    private final Component adventure$title;
++
++    public PaperInventoryCustomHolderContainer(InventoryHolder owner, Container delegate, InventoryType type) {
++        this.owner = owner;
++        this.delegate = delegate;
++        this.type = type;
++        @Nullable Component adventure$title = null;
++        if (delegate instanceof BaseContainerBlockEntity blockEntity) {
++            adventure$title = blockEntity.getCustomName() != null ? PaperAdventure.asAdventure(blockEntity.getCustomName()) : null;
++        }
++        if (adventure$title == null) {
++            adventure$title = type.defaultTitle();
++        }
++        this.adventure$title = adventure$title;
++        this.title = LegacyComponentSerializer.legacySection().serialize(this.adventure$title);
++    }
++
++    public Component title() {
++        return this.adventure$title;
++    }
++
++    public String getTitle() {
++        return this.title;
++    }
++
++    public InventoryType getType() {
++        return this.type;
++    }
++
++    @Override
++    public int getContainerSize() {
++        return this.delegate.getContainerSize();
++    }
++
++    @Override
++    public boolean isEmpty() {
++        return this.delegate.isEmpty();
++    }
++
++    @Override
++    public ItemStack getItem(int slot) {
++        return this.delegate.getItem(slot);
++    }
++
++    @Override
++    public ItemStack removeItem(int slot, int amount) {
++        return this.delegate.removeItem(slot, amount);
++    }
++
++    @Override
++    public ItemStack removeItemNoUpdate(int slot) {
++        return this.delegate.removeItemNoUpdate(slot);
++    }
++
++    @Override
++    public void setItem(int slot, ItemStack stack) {
++        this.delegate.setItem(slot, stack);
++    }
++
++    @Override
++    public int getMaxStackSize() {
++        return this.delegate.getMaxStackSize();
++    }
++
++    @Override
++    public void setChanged() {
++        this.delegate.setChanged();
++    }
++
++    @Override
++    public boolean stillValid(Player player) {
++        return this.delegate.stillValid(player);
++    }
++
++    @Override
++    public List<ItemStack> getContents() {
++        return this.delegate.getContents();
++    }
++
++    @Override
++    public void onOpen(CraftHumanEntity who) {
++        this.delegate.onOpen(who);
++    }
++
++    @Override
++    public void onClose(CraftHumanEntity who) {
++        this.delegate.onClose(who);
++    }
++
++    @Override
++    public List<HumanEntity> getViewers() {
++        return this.delegate.getViewers();
++    }
++
++    @Override
++    public InventoryHolder getOwner() {
++        return this.owner;
++    }
++
++    @Override
++    public void setMaxStackSize(int size) {
++        this.delegate.setMaxStackSize(size);
++    }
++
++    @Override
++    public Location getLocation() {
++        return this.delegate.getLocation();
++    }
++
++    @Override
++    public void clearContent() {
++        this.delegate.clearContent();
++    }
++}
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftContainer.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftContainer.java
+index 0cbb702641348500bf8f8ab3b3c206f70aea9738..1f73834043c2d2be17ae647589653d517db36a1b 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftContainer.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftContainer.java
+@@ -71,13 +71,13 @@ public class CraftContainer extends AbstractContainerMenu {
+             // Paper start
+             @Override
+             public net.kyori.adventure.text.Component title() {
+-                return inventory instanceof CraftInventoryCustom ? ((CraftInventoryCustom.MinecraftInventory) ((CraftInventory) inventory).getInventory()).title() : net.kyori.adventure.text.Component.text(inventory.getType().getDefaultTitle());
++                return inventory instanceof CraftInventoryCustom custom ? custom.title() : inventory.getType().defaultTitle(); // Paper
+             }
+             // Paper end
+ 
+             @Override
+             public String getTitle() {
+-                return inventory instanceof CraftInventoryCustom ? ((CraftInventoryCustom.MinecraftInventory) ((CraftInventory) inventory).getInventory()).getTitle() : inventory.getType().getDefaultTitle();
++                return inventory instanceof CraftInventoryCustom custom ? custom.getTitle() : inventory.getType().getDefaultTitle(); // Paper
+             }
+         }, player, id);
+     }
+@@ -227,6 +227,10 @@ public class CraftContainer extends AbstractContainerMenu {
+             this.lastSlots = delegate.lastSlots;
+             this.slots = delegate.slots;
+             this.remoteSlots = delegate.remoteSlots;
++            // Paper start - copy data slots for InventoryView#set/getProperty
++            this.dataSlots = delegate.dataSlots;
++            this.remoteDataSlots = delegate.remoteDataSlots;
++            // Paper end
+         }
+ 
+         // SPIGOT-4598 - we should still delegate the shift click handler
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
+index ce70a77ec6da41b59660f5923d30eaebf24c4cc2..94a71073a0d69145cf3429a2b6f646a2dc2015fd 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
+@@ -491,6 +491,10 @@ public class CraftInventory implements Inventory {
+             return InventoryType.BREWING;
+         } else if (this.inventory instanceof CraftInventoryCustom.MinecraftInventory) {
+             return ((CraftInventoryCustom.MinecraftInventory) this.inventory).getType();
++            // Paper start
++        } else if (this.inventory instanceof io.papermc.paper.inventory.PaperInventoryCustomHolderContainer holderContainer) {
++            return holderContainer.getType();
++        // Paper end
+         } else if (this.inventory instanceof PlayerEnderChestContainer) {
+             return InventoryType.ENDER_CHEST;
+         } else if (this.inventory instanceof MerchantContainer) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryCustom.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryCustom.java
+index f3ebaefd949ae73afad3dcb69b8d9c632cc782f7..08f8ea0716ef8fa850f1f2f7b8a6e636f57ae872 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryCustom.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryCustom.java
+@@ -15,6 +15,11 @@ import org.bukkit.event.inventory.InventoryType;
+ import org.bukkit.inventory.InventoryHolder;
+ 
+ public class CraftInventoryCustom extends CraftInventory {
++    // Paper start
++    public CraftInventoryCustom(InventoryHolder owner, InventoryType type, Container delegate) {
++        super(new io.papermc.paper.inventory.PaperInventoryCustomHolderContainer(owner, delegate, type));
++    }
++    // Paper end
+     public CraftInventoryCustom(InventoryHolder owner, InventoryType type) {
+         super(new MinecraftInventory(owner, type));
+     }
+@@ -42,6 +47,27 @@ public class CraftInventoryCustom extends CraftInventory {
+     public CraftInventoryCustom(InventoryHolder owner, int size, String title) {
+         super(new MinecraftInventory(owner, size, title));
+     }
++    // Paper start
++    public String getTitle() {
++        if (this.inventory instanceof MinecraftInventory minecraftInventory) {
++            return minecraftInventory.getTitle();
++        } else if (this.inventory instanceof io.papermc.paper.inventory.PaperInventoryCustomHolderContainer customHolderContainer) {
++            return customHolderContainer.getTitle();
++        } else {
++            throw new UnsupportedOperationException(this.inventory.getClass() + " isn't a recognized Container type here");
++        }
++    }
++
++    public net.kyori.adventure.text.Component title() {
++        if (this.inventory instanceof MinecraftInventory minecraftInventory) {
++            return minecraftInventory.title();
++        } else if (this.inventory instanceof io.papermc.paper.inventory.PaperInventoryCustomHolderContainer customHolderContainer) {
++            return customHolderContainer.title();
++        } else {
++            throw new UnsupportedOperationException(this.inventory.getClass() + " isn't a recognized Container type here");
++        }
++    }
++    // Paper end
+ 
+     static class MinecraftInventory implements Container {
+         private final NonNullList<ItemStack> items;
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftTileInventoryConverter.java b/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftTileInventoryConverter.java
+index 7a7f3f53aef601f124d474d9890e23d87dd96900..54e61b9b058bee2167461aaaf828ed7a00949c29 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftTileInventoryConverter.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/util/CraftTileInventoryConverter.java
+@@ -28,7 +28,7 @@ public abstract class CraftTileInventoryConverter implements CraftInventoryCreat
+ 
+     @Override
+     public Inventory createInventory(InventoryHolder holder, InventoryType type) {
+-        return this.getInventory(this.getTileEntity());
++        return this.getInventory(holder, type, this.getTileEntity()); // Paper
+     }
+ 
+     // Paper start
+@@ -39,7 +39,7 @@ public abstract class CraftTileInventoryConverter implements CraftInventoryCreat
+             ((RandomizableContainerBlockEntity) te).setCustomName(io.papermc.paper.adventure.PaperAdventure.asVanilla(title));
+         }
+ 
+-        return getInventory(te);
++        return this.getInventory(owner, type, te); // Paper
+     }
+     // Paper end
+ 
+@@ -50,10 +50,18 @@ public abstract class CraftTileInventoryConverter implements CraftInventoryCreat
+             ((RandomizableContainerBlockEntity) te).setCustomName(CraftChatMessage.fromStringOrNull(title));
+         }
+ 
+-        return this.getInventory(te);
++        return this.getInventory(holder, type, te); // Paper
+     }
+ 
++    @Deprecated // Paper - use getInventory with owner and type
+     public Inventory getInventory(Container tileEntity) {
++        // Paper start
++        return this.getInventory(null, null, tileEntity);
++    }
++
++    public Inventory getInventory(InventoryHolder owner, InventoryType type, Container tileEntity) { // Paper
++        if (owner != null) return new org.bukkit.craftbukkit.inventory.CraftInventoryCustom(owner, type, tileEntity); // Paper
++        // Paper end
+         return new CraftInventory(tileEntity);
+     }
+ 
+@@ -70,7 +78,7 @@ public abstract class CraftTileInventoryConverter implements CraftInventoryCreat
+         public Inventory createInventory(InventoryHolder owner, InventoryType type, net.kyori.adventure.text.Component title) {
+             Container tileEntity = getTileEntity();
+             ((AbstractFurnaceBlockEntity) tileEntity).setCustomName(io.papermc.paper.adventure.PaperAdventure.asVanilla(title));
+-            return getInventory(tileEntity);
++            return this.getInventory(owner, type, tileEntity); // Paper
+         }
+         // Paper end
+ 
+@@ -78,11 +86,19 @@ public abstract class CraftTileInventoryConverter implements CraftInventoryCreat
+         public Inventory createInventory(InventoryHolder owner, InventoryType type, String title) {
+             Container tileEntity = this.getTileEntity();
+             ((AbstractFurnaceBlockEntity) tileEntity).setCustomName(CraftChatMessage.fromStringOrNull(title));
+-            return this.getInventory(tileEntity);
++            return this.getInventory(owner, type, tileEntity); // Paper
+         }
+ 
+         @Override
+         public Inventory getInventory(Container tileEntity) {
++            // Paper start
++            return getInventory(null, null, tileEntity);
++        }
++
++        @Override
++        public Inventory getInventory(InventoryHolder owner, InventoryType type, net.minecraft.world.Container tileEntity) { // Paper
++            if (owner != null) return new org.bukkit.craftbukkit.inventory.CraftInventoryCustom(owner, type, tileEntity); // Paper
++            // Paper end
+             return new CraftInventoryFurnace((AbstractFurnaceBlockEntity) tileEntity);
+         }
+     }
+@@ -102,7 +118,7 @@ public abstract class CraftTileInventoryConverter implements CraftInventoryCreat
+             if (tileEntity instanceof BrewingStandBlockEntity) {
+                 ((BrewingStandBlockEntity) tileEntity).setCustomName(io.papermc.paper.adventure.PaperAdventure.asVanilla(title));
+             }
+-            return getInventory(tileEntity);
++            return this.getInventory(owner, type, tileEntity); // Paper
+         }
+         // Paper end
+ 
+@@ -113,11 +129,19 @@ public abstract class CraftTileInventoryConverter implements CraftInventoryCreat
+             if (tileEntity instanceof BrewingStandBlockEntity) {
+                 ((BrewingStandBlockEntity) tileEntity).setCustomName(CraftChatMessage.fromStringOrNull(title));
+             }
+-            return this.getInventory(tileEntity);
++            return this.getInventory(holder, type, tileEntity); // Paper
+         }
+ 
+         @Override
+         public Inventory getInventory(Container tileEntity) {
++            // Paper start
++            return getInventory(null, null, tileEntity);
++        }
++
++        @Override
++        public Inventory getInventory(InventoryHolder owner, InventoryType type, net.minecraft.world.Container tileEntity) { // Paper
++            if (owner != null) return new org.bukkit.craftbukkit.inventory.CraftInventoryCustom(owner, type, tileEntity); // Paper
++            // Paper end
+             return new CraftInventoryBrewer(tileEntity);
+         }
+     }

patches/server/0281-Use-Vanilla-Minecart-Speeds.patch

@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Thu, 8 Nov 2018 21:33:09 -0500
+Subject: [PATCH] Use Vanilla Minecart Speeds
+
+CraftBukkit changed the values on flying speed, restore back to vanilla
+
+diff --git a/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java b/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java
+index 035d5108dce46e0e6d2095d12198cd1762755ba7..39a51f97001ef08f5d2d2eefb25908a3296eec96 100644
+--- a/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java
++++ b/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java
+@@ -102,9 +102,9 @@ public abstract class AbstractMinecart extends Entity {
+     private double derailedX = 0.5;
+     private double derailedY = 0.5;
+     private double derailedZ = 0.5;
+-    private double flyingX = 0.95;
+-    private double flyingY = 0.95;
+-    private double flyingZ = 0.95;
++    private double flyingX = 0.949999988079071D; // Paper - restore vanilla precision
++    private double flyingY = 0.949999988079071D; // Paper - restore vanilla precision
++    private double flyingZ = 0.949999988079071D; // Paper - restore vanilla precision
+     public double maxSpeed = 0.4D;
+     // CraftBukkit end
+ 

patches/server/0282-Fix-SpongeAbsortEvent-handling.patch

@@ -0,0 +1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Sat, 10 Nov 2018 05:15:21 +0000
+Subject: [PATCH] Fix SpongeAbsortEvent handling
+
+Only process drops when the block is actually going to be removed
+
+diff --git a/src/main/java/net/minecraft/world/level/block/SpongeBlock.java b/src/main/java/net/minecraft/world/level/block/SpongeBlock.java
+index 8fe119f1ce36ce9ee63a1ba32df0ae8645b6a669..7304b2659eb45bc4bc9fa7c43e6ca07221d0fc73 100644
+--- a/src/main/java/net/minecraft/world/level/block/SpongeBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/SpongeBlock.java
+@@ -129,8 +129,11 @@ public class SpongeBlock extends Block {
+                         // NOP
+                     } else if (material == Material.WATER_PLANT || material == Material.REPLACEABLE_WATER_PLANT) {
+                         BlockEntity tileentity = iblockdata.hasBlockEntity() ? world.getBlockEntity(blockposition2) : null;
+-
+-                        dropResources(iblockdata, world, blockposition2, tileentity);
++                        // Paper start
++                        if (block.getHandle().getMaterial() == Material.AIR) {
++                            dropResources(iblockdata, world, blockposition2, tileentity);
++                        }
++                        // Paper end
+                     }
+                 }
+                 world.setBlock(blockposition2, block.getHandle(), block.getFlag());

patches/server/0283-Don-t-allow-digging-into-unloaded-chunks.patch

@@ -0,0 +1,77 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Sun, 11 Nov 2018 21:01:09 +0000
+Subject: [PATCH] Don't allow digging into unloaded chunks
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+index 01a321a0c76c55b32922c94297139e85b3d4ac23..514c045883060e4a22f748176091d3b236c2a7fd 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+@@ -119,8 +119,8 @@ public class ServerPlayerGameMode {
+         BlockState iblockdata;
+ 
+         if (this.hasDelayedDestroy) {
+-            iblockdata = this.level.getBlockState(this.delayedDestroyPos);
+-            if (iblockdata.isAir()) {
++            iblockdata = this.level.getBlockStateIfLoaded(this.delayedDestroyPos); // Paper
++            if (iblockdata == null || iblockdata.isAir()) { // Paper
+                 this.hasDelayedDestroy = false;
+             } else {
+                 float f = this.incrementDestroyProgress(iblockdata, this.delayedDestroyPos, this.delayedTickStart);
+@@ -131,7 +131,13 @@ public class ServerPlayerGameMode {
+                 }
+             }
+         } else if (this.isDestroyingBlock) {
+-            iblockdata = this.level.getBlockState(this.destroyPos);
++            // Paper start - don't want to do same logic as above, return instead
++            iblockdata = this.level.getBlockStateIfLoaded(this.destroyPos);
++            if (iblockdata == null) {
++                this.isDestroyingBlock = false;
++                return;
++            }
++            // Paper end
+             if (iblockdata.isAir()) {
+                 this.level.destroyBlockProgress(this.player.getId(), this.destroyPos, -1);
+                 this.lastSentState = -1;
+@@ -160,6 +166,7 @@ public class ServerPlayerGameMode {
+ 
+     public void handleBlockBreakAction(BlockPos pos, ServerboundPlayerActionPacket.Action action, Direction direction, int worldHeight, int sequence) {
+         if (this.player.getEyePosition().distanceToSqr(Vec3.atCenterOf(pos)) > ServerGamePacketListenerImpl.MAX_INTERACTION_DISTANCE) {
++            if (true) return; // Paper - Don't notify if unreasonably far away
+             this.debugLogging(pos, false, sequence, "too far");
+         } else if (pos.getY() >= worldHeight) {
+             this.player.connection.send(new ClientboundBlockUpdatePacket(pos, this.level.getBlockState(pos)));
+@@ -296,10 +303,12 @@ public class ServerPlayerGameMode {
+                 this.debugLogging(pos, true, sequence, "stopped destroying");
+             } else if (action == ServerboundPlayerActionPacket.Action.ABORT_DESTROY_BLOCK) {
+                 this.isDestroyingBlock = false;
+-                if (!Objects.equals(this.destroyPos, pos)) {
++                if (!Objects.equals(this.destroyPos, pos) && !BlockPos.ZERO.equals(this.destroyPos)) { // Paper
+                     ServerPlayerGameMode.LOGGER.debug("Mismatch in destroy block pos: {} {}", this.destroyPos, pos); // CraftBukkit - SPIGOT-5457 sent by client when interact event cancelled
+-                    this.level.destroyBlockProgress(this.player.getId(), this.destroyPos, -1);
+-                    this.debugLogging(pos, true, sequence, "aborted mismatched destroying");
++                    BlockState type = this.level.getBlockStateIfLoaded(this.destroyPos); // Paper - don't load unloaded chunks for stale records here
++                    if (type != null) this.level.destroyBlockProgress(this.player.getId(), this.destroyPos, -1);
++                    if (type != null) this.debugLogging(pos, true, sequence, "aborted mismatched destroying");
++                    this.destroyPos = BlockPos.ZERO; // Paper
+                 }
+ 
+                 this.level.destroyBlockProgress(this.player.getId(), pos, -1);
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 9843684ab5cf21bfc4fe30f3528dc75475b4dcd1..133c6637be1abf3f9b4aa4f73f22b7d64b0438a2 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1668,6 +1668,12 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+             case START_DESTROY_BLOCK:
+             case ABORT_DESTROY_BLOCK:
+             case STOP_DESTROY_BLOCK:
++                // Paper start - Don't allow digging in unloaded chunks
++                if (this.player.level.getChunkIfLoadedImmediately(blockposition.getX() >> 4, blockposition.getZ() >> 4) == null) {
++                    this.player.connection.ackBlockChangesUpTo(packet.getSequence());
++                    return;
++                }
++                // Paper end - Don't allow digging in unloaded chunks
+                 this.player.gameMode.handleBlockBreakAction(blockposition, packetplayinblockdig_enumplayerdigtype, packet.getDirection(), this.player.level.getMaxBuildHeight(), packet.getSequence());
+                 this.player.connection.ackBlockChangesUpTo(packet.getSequence());
+                 return;

patches/server/0284-Make-the-default-permission-message-configurable.patch

@@ -0,0 +1,40 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Sun, 18 Nov 2018 19:49:56 +0000
+Subject: [PATCH] Make the default permission message configurable
+
+
+diff --git a/src/main/java/io/papermc/paper/command/PaperCommand.java b/src/main/java/io/papermc/paper/command/PaperCommand.java
+index 1e9105cf5ab2ff0ee847fafd00b41e1bd47f1d9e..65ee888280f917ccd11146505b7389513280a863 100644
+--- a/src/main/java/io/papermc/paper/command/PaperCommand.java
++++ b/src/main/java/io/papermc/paper/command/PaperCommand.java
+@@ -78,7 +78,7 @@ public final class PaperCommand extends Command {
+         if (sender.hasPermission(BASE_PERM + permission) || sender.hasPermission("bukkit.command.paper")) {
+             return true;
+         }
+-        sender.sendMessage(text("I'm sorry, but you do not have permission to perform this command. Please contact the server administrators if you believe that this is in error.", RED));
++        sender.sendMessage(Bukkit.permissionMessage());
+         return false;
+     }
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index dc9fce11cb5b76b9e29c0f50c90c96fdf0b830ce..9d778f076512969d8de93256dfde0ebbdb0433ae 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -2646,6 +2646,16 @@ public final class CraftServer implements Server {
+         return io.papermc.paper.configuration.GlobalConfiguration.get().commands.suggestPlayerNamesWhenNullTabCompletions;
+     }
+ 
++    @Override
++    public String getPermissionMessage() {
++        return net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacyAmpersand().serialize(io.papermc.paper.configuration.GlobalConfiguration.get().messages.noPermission);
++    }
++
++    @Override
++    public net.kyori.adventure.text.Component permissionMessage() {
++        return io.papermc.paper.configuration.GlobalConfiguration.get().messages.noPermission;
++    }
++
+     @Override
+     public com.destroystokyo.paper.profile.PlayerProfile createProfile(@Nonnull UUID uuid) {
+         return createProfile(uuid, null);

patches/server/0285-Prevent-rayTrace-from-loading-chunks.patch

@@ -0,0 +1,29 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 26 Nov 2018 19:21:58 -0500
+Subject: [PATCH] Prevent rayTrace from loading chunks
+
+ray tracing into an unloaded chunk should be treated as a miss
+this saves a ton of lag for when AI tries to raytrace near unloaded chunks.
+
+diff --git a/src/main/java/net/minecraft/world/level/BlockGetter.java b/src/main/java/net/minecraft/world/level/BlockGetter.java
+index 8a979600b49e8a11982577fb6dd79503e2521a0f..bca0838e40bc91d78e9b93df5318642d1c9f341e 100644
+--- a/src/main/java/net/minecraft/world/level/BlockGetter.java
++++ b/src/main/java/net/minecraft/world/level/BlockGetter.java
+@@ -75,7 +75,15 @@ public interface BlockGetter extends LevelHeightAccessor {
+ 
+     // CraftBukkit start - moved block handling into separate method for use by Block#rayTrace
+     default BlockHitResult clip(ClipContext raytrace1, BlockPos blockposition) {
+-            BlockState iblockdata = this.getBlockState(blockposition);
++            // Paper start - Prevent raytrace from loading chunks
++            BlockState iblockdata = this.getBlockStateIfLoaded(blockposition);
++            if (iblockdata == null) {
++                // copied the last function parameter (listed below)
++                Vec3 vec3d = raytrace1.getFrom().subtract(raytrace1.getTo());
++
++                return BlockHitResult.miss(raytrace1.getTo(), Direction.getNearest(vec3d.x, vec3d.y, vec3d.z), new BlockPos(raytrace1.getTo()));
++            }
++            // Paper end
+             FluidState fluid = this.getFluidState(blockposition);
+             Vec3 vec3d = raytrace1.getFrom();
+             Vec3 vec3d1 = raytrace1.getTo();

patches/server/0286-Handle-Large-Packets-disconnecting-client.patch

@@ -0,0 +1,115 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 27 Nov 2018 21:18:06 -0500
+Subject: [PATCH] Handle Large Packets disconnecting client
+
+If a players inventory is too big to send in a single packet,
+split the inventory set into multiple packets instead.
+
+diff --git a/src/main/java/net/minecraft/network/Connection.java b/src/main/java/net/minecraft/network/Connection.java
+index a31820cb543f3e72e461c91b3191b56b18fb33dd..0e739c0c54eaad5ab8dddcd8294c9ccaa3697fbf 100644
+--- a/src/main/java/net/minecraft/network/Connection.java
++++ b/src/main/java/net/minecraft/network/Connection.java
+@@ -149,6 +149,15 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
+     }
+ 
+     public void exceptionCaught(ChannelHandlerContext channelhandlercontext, Throwable throwable) {
++        // Paper start
++        if (throwable instanceof io.netty.handler.codec.EncoderException && throwable.getCause() instanceof PacketEncoder.PacketTooLargeException) {
++            if (((PacketEncoder.PacketTooLargeException) throwable.getCause()).getPacket().packetTooLarge(this)) {
++                return;
++            } else {
++                throwable = throwable.getCause();
++            }
++        }
++        // Paper end
+         if (throwable instanceof SkipPacketException) {
+             Connection.LOGGER.debug("Skipping packet due to errors", throwable.getCause());
+         } else {
+diff --git a/src/main/java/net/minecraft/network/PacketEncoder.java b/src/main/java/net/minecraft/network/PacketEncoder.java
+index 00d432bd395e7f7fb6ee24e371818d13892b2f0c..5fce1177e7198d791d4ab1c64b394c5b1c145782 100644
+--- a/src/main/java/net/minecraft/network/PacketEncoder.java
++++ b/src/main/java/net/minecraft/network/PacketEncoder.java
+@@ -54,7 +54,31 @@ public class PacketEncoder extends MessageToByteEncoder<Packet<?>> {
+                         throw var10;
+                     }
+                 }
++
++                // Paper start
++                int packetLength = friendlyByteBuf.readableBytes();
++                if (packetLength > MAX_PACKET_SIZE) {
++                    throw new PacketTooLargeException(packet, packetLength);
++                }
++                // Paper end
+             }
+         }
+     }
++
++    // Paper start
++    private static int MAX_PACKET_SIZE = 2097152;
++
++    public static class PacketTooLargeException extends RuntimeException {
++        private final Packet<?> packet;
++
++        PacketTooLargeException(Packet<?> packet, int packetLength) {
++            super("PacketTooLarge - " + packet.getClass().getSimpleName() + " is " + packetLength + ". Max is " + MAX_PACKET_SIZE);
++            this.packet = packet;
++        }
++
++        public Packet<?> getPacket() {
++            return packet;
++        }
++    }
++    // Paper end
+ }
+diff --git a/src/main/java/net/minecraft/network/protocol/Packet.java b/src/main/java/net/minecraft/network/protocol/Packet.java
+index 10c1f2d8a92f848c3f2be9d1d06fd254978e6dcc..74bfe0d3942259c45702b099efdc4e101a4e3022 100644
+--- a/src/main/java/net/minecraft/network/protocol/Packet.java
++++ b/src/main/java/net/minecraft/network/protocol/Packet.java
+@@ -8,6 +8,12 @@ public interface Packet<T extends PacketListener> {
+ 
+     void handle(T listener);
+ 
++    // Paper start
++    default boolean packetTooLarge(net.minecraft.network.Connection manager) {
++        return false;
++    }
++    // Paper end
++
+     default boolean isSkippable() {
+         return false;
+     }
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundContainerSetContentPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundContainerSetContentPacket.java
+index 0e076173033278587df2b5dfbd01cc9005651eb5..dbd8b9b09b82c1b75e8be9dc7416d9f0863c8c87 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundContainerSetContentPacket.java
++++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundContainerSetContentPacket.java
+@@ -31,6 +31,16 @@ public class ClientboundContainerSetContentPacket implements Packet<ClientGamePa
+         this.carriedItem = buf.readItem();
+     }
+ 
++    // Paper start
++    @Override
++    public boolean packetTooLarge(net.minecraft.network.Connection manager) {
++        for (int i = 0 ; i < this.items.size() ; i++) {
++            manager.send(new ClientboundContainerSetSlotPacket(this.containerId, this.stateId, i, this.items.get(i)));
++        }
++        return true;
++    }
++    // Paper end
++
+     @Override
+     public void write(FriendlyByteBuf buf) {
+         buf.writeByte(this.containerId);
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
+index 932cca4d957c1fc212b7a514ea23e8dc7ab5b9d9..f47eeb70661661610ef1a96dd9da67785825c126 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
++++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
+@@ -50,7 +50,7 @@ public class ClientboundLevelChunkPacketData {
+             throw new RuntimeException("Can't read heightmap in packet for [" + x + ", " + z + "]");
+         } else {
+             int i = buf.readVarInt();
+-            if (i > 2097152) {
++            if (i > 2097152) { // Paper - diff on change - if this changes, update PacketEncoder
+                 throw new RuntimeException("Chunk Packet trying to allocate too much memory on read.");
+             } else {
+                 this.buffer = new byte[i];

patches/server/0287-force-entity-dismount-during-teleportation.patch

@@ -0,0 +1,134 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Thu, 15 Nov 2018 13:38:37 +0000
+Subject: [PATCH] force entity dismount during teleportation
+
+Entities must be dismounted before teleportation in order to avoid
+multiple issues in the server with regards to teleportation, shamefully,
+too many plugins rely on the events firing, which means that not firing
+these events caues more issues than it solves;
+
+In order to counteract this, Entity dismount/exit vehicle events have
+been modified to supress cancellation (and has a method to allow plugins
+to check if this has been set), noting that cancellation will be silently
+surpressed given that plugins are not expecting this event to not be cancellable.
+
+This is a far from ideal scenario, however: given the current state of this
+event and other alternatives causing issues elsewhere, I believe that
+this is going to be the best soultion all around.
+
+Improvements/suggestions welcome!
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 15d4ad53cca71272e491bea31d83e8c8e697dac0..c7fe091d13349348b7288c0aa8bdde046dc47fa4 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -1366,11 +1366,13 @@ public class ServerPlayer extends Player {
+         }
+     }
+ 
+-    @Override
+-    public void stopRiding() {
++    // Paper start
++    @Override public void stopRiding() { stopRiding(false); }
++    @Override public void stopRiding(boolean suppressCancellation) {
++        // Paper end
+         Entity entity = this.getVehicle();
+ 
+-        super.stopRiding();
++        super.stopRiding(suppressCancellation); // Paper
+         Entity entity1 = this.getVehicle();
+ 
+         if (entity1 != entity && this.connection != null) {
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index b8257959acd2b38243fd259f367564080aff951e..d664b8691a8248a035cbe1b12a353f633980ea7b 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -2396,11 +2396,16 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+     }
+ 
+     public void removeVehicle() {
++        // Paper start
++        stopRiding(false);
++    }
++    public void stopRiding(boolean suppressCancellation) {
++        // Paper end
+         if (this.vehicle != null) {
+             Entity entity = this.vehicle;
+ 
+             this.vehicle = null;
+-            if (!entity.removePassenger(this)) this.vehicle = entity; // CraftBukkit
++            if (!entity.removePassenger(this, suppressCancellation)) this.vehicle = entity; // CraftBukkit // Paper
+         }
+ 
+     }
+@@ -2467,7 +2472,10 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+         return true; // CraftBukkit
+     }
+ 
+-    protected boolean removePassenger(Entity entity) { // CraftBukkit
++    // Paper start
++    protected boolean removePassenger(Entity entity) { return removePassenger(entity, false);}
++    protected boolean removePassenger(Entity entity, boolean suppressCancellation) { // CraftBukkit
++        // Paper end
+         if (entity.getVehicle() == this) {
+             throw new IllegalStateException("Use x.stopRiding(y), not y.removePassenger(x)");
+         } else {
+@@ -2477,7 +2485,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+             if (this.getBukkitEntity() instanceof Vehicle && entity.getBukkitEntity() instanceof LivingEntity) {
+                 VehicleExitEvent event = new VehicleExitEvent(
+                         (Vehicle) this.getBukkitEntity(),
+-                        (LivingEntity) entity.getBukkitEntity()
++                        (LivingEntity) entity.getBukkitEntity(), !suppressCancellation // Paper
+                 );
+                 // Suppress during worldgen
+                 if (this.valid) {
+@@ -2491,7 +2499,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+             }
+             // CraftBukkit end
+             // Spigot start
+-            org.spigotmc.event.entity.EntityDismountEvent event = new org.spigotmc.event.entity.EntityDismountEvent(entity.getBukkitEntity(), this.getBukkitEntity());
++            org.spigotmc.event.entity.EntityDismountEvent event = new org.spigotmc.event.entity.EntityDismountEvent(entity.getBukkitEntity(), this.getBukkitEntity(), !suppressCancellation); // Paper
+             // Suppress during worldgen
+             if (this.valid) {
+                 Bukkit.getPluginManager().callEvent(event);
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 2c804ef89d910f706c449b4ce540ed1be3ac242a..3ff18ddb1d4b36fcfd97c9b29f2ecdcb4958916e 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -3432,9 +3432,15 @@ public abstract class LivingEntity extends Entity {
+ 
+     @Override
+     public void stopRiding() {
++        // Paper start
++        stopRiding(false);
++    }
++    @Override
++    public void stopRiding(boolean suppressCancellation) {
++        // Paper end
+         Entity entity = this.getVehicle();
+ 
+-        super.stopRiding();
++        super.stopRiding(suppressCancellation); // Paper - suppress
+         if (entity != null && entity != this.getVehicle() && !this.level.isClientSide) {
+             this.dismountVehicle(entity);
+         }
+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 12904581bcf666c31ca6b02e5e0be2f5fe17de34..ba8b6d3fbc10eb9f02d3409eb2038827c47ca14d 100644
+--- a/src/main/java/net/minecraft/world/entity/player/Player.java
++++ b/src/main/java/net/minecraft/world/entity/player/Player.java
+@@ -1142,7 +1142,13 @@ public abstract class Player extends LivingEntity {
+ 
+     @Override
+     public void removeVehicle() {
+-        super.removeVehicle();
++        // Paper start
++        stopRiding(false);
++    }
++    @Override
++    public void stopRiding(boolean suppressCancellation) {
++        // Paper end
++        super.stopRiding(suppressCancellation); // Paper - suppress
+         this.boardingCooldown = 0;
+     }
+ 

patches/server/0288-Add-more-Zombie-API.patch

@@ -0,0 +1,117 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Sun, 7 Oct 2018 04:29:59 -0500
+Subject: [PATCH] Add more Zombie API
+
+== AT ==
+public net.minecraft.world.entity.monster.Zombie isSunSensitive()Z
+
+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 8ecbb64f9db9346757c5597404489496a0945508..f0bad2264df3a4b4631d66dad46ec03470a206ee 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Zombie.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Zombie.java
+@@ -95,6 +95,7 @@ public class Zombie extends Monster {
+     private int inWaterTime;
+     public int conversionTime;
+     private int lastTick = MinecraftServer.currentTick; // CraftBukkit - add field
++    private boolean shouldBurnInDay = true; // Paper
+ 
+     public Zombie(EntityType<? extends Zombie> type, Level world) {
+         super(type, world);
+@@ -263,6 +264,12 @@ public class Zombie extends Monster {
+         super.aiStep();
+     }
+ 
++    // Paper start
++    public void stopDrowning() {
++        this.conversionTime = -1;
++        this.getEntityData().set(Zombie.DATA_DROWNED_CONVERSION_ID, false);
++    }
++    // Paper end
+     public void startUnderWaterConversion(int ticksUntilWaterConversion) {
+         this.lastTick = MinecraftServer.currentTick; // CraftBukkit
+         this.conversionTime = ticksUntilWaterConversion;
+@@ -292,9 +299,15 @@ public class Zombie extends Monster {
+     }
+ 
+     public boolean isSunSensitive() {
+-        return true;
++        return this.shouldBurnInDay; // Paper - use api value instead
+     }
+ 
++    // Paper start
++    public void setShouldBurnInDay(boolean shouldBurnInDay) {
++        this.shouldBurnInDay = shouldBurnInDay;
++    }
++    // Paper end
++
+     @Override
+     public boolean hurt(DamageSource source, float amount) {
+         if (!super.hurt(source, amount)) {
+@@ -414,6 +427,7 @@ public class Zombie extends Monster {
+         nbt.putBoolean("CanBreakDoors", this.canBreakDoors());
+         nbt.putInt("InWaterTime", this.isInWater() ? this.inWaterTime : -1);
+         nbt.putInt("DrownedConversionTime", this.isUnderWaterConverting() ? this.conversionTime : -1);
++        nbt.putBoolean("Paper.ShouldBurnInDay", this.shouldBurnInDay); // Paper
+     }
+ 
+     @Override
+@@ -425,6 +439,11 @@ public class Zombie extends Monster {
+         if (nbt.contains("DrownedConversionTime", 99) && nbt.getInt("DrownedConversionTime") > -1) {
+             this.startUnderWaterConversion(nbt.getInt("DrownedConversionTime"));
+         }
++        // Paper start
++        if (nbt.contains("Paper.ShouldBurnInDay")) {
++            this.shouldBurnInDay = nbt.getBoolean("Paper.ShouldBurnInDay");
++        }
++        // Paper end
+ 
+     }
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftZombie.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftZombie.java
+index 9e249a194980796248d07481df2cd04e80f079d8..1e0154f2d06b0cc5bc58ec2de98cbdce1346da35 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftZombie.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftZombie.java
+@@ -93,6 +93,42 @@ public class CraftZombie extends CraftMonster implements Zombie {
+     @Override
+     public void setAgeLock(boolean b) {
+     }
++    // Paper start
++    @Override
++    public boolean isDrowning() {
++        return getHandle().isUnderWaterConverting();
++    }
++
++    @Override
++    public void startDrowning(int drownedConversionTime) {
++        getHandle().startUnderWaterConversion(drownedConversionTime);
++    }
++
++    @Override
++    public void stopDrowning() {
++        getHandle().stopDrowning();
++    }
++
++    @Override
++    public boolean shouldBurnInDay() {
++        return getHandle().isSunSensitive();
++    }
++
++    @Override
++    public boolean isArmsRaised() {
++        return getHandle().isAggressive();
++    }
++
++    @Override
++    public void setArmsRaised(final boolean raised) {
++        getHandle().setAggressive(raised);
++    }
++
++    @Override
++    public void setShouldBurnInDay(boolean shouldBurnInDay) {
++        getHandle().setShouldBurnInDay(shouldBurnInDay);
++    }
++    // Paper end
+ 
+     @Override
+     public boolean getAgeLock() {

patches/server/0289-Book-Size-Limits.patch

@@ -0,0 +1,57 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Fri, 16 Nov 2018 23:08:50 -0500
+Subject: [PATCH] Book Size Limits
+
+Puts some limits on the size of books.
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 133c6637be1abf3f9b4aa4f73f22b7d64b0438a2..60c9b8d45ae4884883fce1b402bf9ed2906aff79 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1116,6 +1116,45 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+ 
+     @Override
+     public void handleEditBook(ServerboundEditBookPacket packet) {
++        // Paper start
++        if (!this.cserver.isPrimaryThread()) {
++            List<String> pageList = packet.getPages();
++            long byteTotal = 0;
++            int maxBookPageSize = io.papermc.paper.configuration.GlobalConfiguration.get().itemValidation.bookSize.pageMax;
++            double multiplier = Math.max(0.3D, Math.min(1D, io.papermc.paper.configuration.GlobalConfiguration.get().itemValidation.bookSize.totalMultiplier));
++            long byteAllowed = maxBookPageSize;
++            for (String testString : pageList) {
++                int byteLength = testString.getBytes(java.nio.charset.StandardCharsets.UTF_8).length;
++                if (byteLength > 256 * 4) {
++                    ServerGamePacketListenerImpl.LOGGER.warn(this.player.getScoreboardName() + " tried to send a book with with a page too large!");
++                    server.scheduleOnMain(() -> this.disconnect("Book too large!"));
++                    return;
++                }
++                byteTotal += byteLength;
++                int length = testString.length();
++                int multibytes = 0;
++                if (byteLength != length) {
++                    for (char c : testString.toCharArray()) {
++                        if (c > 127) {
++                            multibytes++;
++                        }
++                    }
++                }
++                byteAllowed += (maxBookPageSize * Math.min(1, Math.max(0.1D, (double) length / 255D))) * multiplier;
++
++                if (multibytes > 1) {
++                    // penalize MB
++                    byteAllowed -= multibytes;
++                }
++            }
++
++            if (byteTotal > byteAllowed) {
++                ServerGamePacketListenerImpl.LOGGER.warn(this.player.getScoreboardName() + " tried to send too large of a book. Book Size: " + byteTotal + " - Allowed:  "+ byteAllowed + " - Pages: " + pageList.size());
++                server.scheduleOnMain(() -> this.disconnect("Book too large!"));
++                return;
++            }
++        }
++        // Paper end
+         // CraftBukkit start
+         if (this.lastBookTick + 20 > MinecraftServer.currentTick) {
+             this.disconnect("Book edited too quickly!");

patches/server/0290-Add-PlayerConnectionCloseEvent.patch

@@ -0,0 +1,71 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Sun, 7 Oct 2018 12:05:28 -0700
+Subject: [PATCH] Add PlayerConnectionCloseEvent
+
+This event is invoked when a player has disconnected. It is guaranteed that,
+if the server is in online-mode, that the provided uuid and username have been
+validated.
+
+The event is invoked for players who have not yet logged into the world, whereas
+PlayerQuitEvent is only invoked on players who have logged into the world.
+
+The event is invoked for players who have already logged into the world,
+although whether or not the player exists in the world at the time of
+firing is undefined. (That is, whether the plugin can retrieve a Player object
+using the event parameters is undefined). However, it is guaranteed that this
+event is invoked AFTER PlayerQuitEvent, if the player has already logged into
+the world.
+
+This event is guaranteed to never fire unless AsyncPlayerPreLoginEvent has
+been called beforehand, and this event may not be called in parallel with
+AsyncPlayerPreLoginEvent for the same connection.
+
+Cancelling the AsyncPlayerPreLoginEvent guarantees the corresponding
+PlayerConnectionCloseEvent is never called.
+
+The event may be invoked asynchronously or synchronously. As it stands,
+it is never invoked asynchronously. However, plugins should check
+Event#isAsynchronous to be future-proof.
+
+On purpose, the deprecated PlayerPreLoginEvent event is left out of the
+API spec for this event. Plugins should not be using that event, and
+how PlayerPreLoginEvent interacts with PlayerConnectionCloseEvent
+is undefined.
+
+== AT ==
+public net.minecraft.server.network.ServerLoginPacketListenerImpl$State
+public net.minecraft.server.network.ServerLoginPacketListenerImpl state
+public net.minecraft.server.network.ServerLoginPacketListenerImpl gameProfile
+
+diff --git a/src/main/java/net/minecraft/network/Connection.java b/src/main/java/net/minecraft/network/Connection.java
+index 0e739c0c54eaad5ab8dddcd8294c9ccaa3697fbf..8b1c39cc7f77ca36d0341fb68de1441cc61f19e4 100644
+--- a/src/main/java/net/minecraft/network/Connection.java
++++ b/src/main/java/net/minecraft/network/Connection.java
+@@ -469,6 +469,26 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
+                     this.getPacketListener().onDisconnect(Component.translatable("multiplayer.disconnect.generic"));
+                 }
+                 this.queue.clear(); // Free up packet queue.
++                // Paper start - Add PlayerConnectionCloseEvent
++                final PacketListener packetListener = this.getPacketListener();
++                if (packetListener instanceof net.minecraft.server.network.ServerGamePacketListenerImpl) {
++                    /* Player was logged in */
++                    final net.minecraft.server.network.ServerGamePacketListenerImpl playerConnection = (net.minecraft.server.network.ServerGamePacketListenerImpl) packetListener;
++                    new com.destroystokyo.paper.event.player.PlayerConnectionCloseEvent(playerConnection.player.getUUID(),
++                        playerConnection.player.getScoreboardName(), ((java.net.InetSocketAddress)address).getAddress(), false).callEvent();
++                } else if (packetListener instanceof net.minecraft.server.network.ServerLoginPacketListenerImpl) {
++                    /* Player is login stage */
++                    final net.minecraft.server.network.ServerLoginPacketListenerImpl loginListener = (net.minecraft.server.network.ServerLoginPacketListenerImpl) packetListener;
++                    switch (loginListener.state) {
++                        case READY_TO_ACCEPT:
++                        case DELAY_ACCEPT:
++                        case ACCEPTED:
++                            final com.mojang.authlib.GameProfile profile = loginListener.gameProfile; /* Should be non-null at this stage */
++                            new com.destroystokyo.paper.event.player.PlayerConnectionCloseEvent(profile.getId(), profile.getName(),
++                                ((java.net.InetSocketAddress)address).getAddress(), false).callEvent();
++                    }
++                }
++                // Paper end
+             }
+ 
+         }

patches/server/0291-Prevent-Enderman-from-loading-chunks.patch

@@ -0,0 +1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Tue, 18 Dec 2018 02:15:08 +0000
+Subject: [PATCH] Prevent Enderman from loading chunks
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+index 4fcd5e1e0641474beeaa834adce73ba10065e34e..1d8cf9b765f9c55feeb26e4ba4aa969be142dc3f 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
++++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
+@@ -509,7 +509,8 @@ public class EnderMan extends Monster implements NeutralMob {
+             int j = Mth.floor(this.enderman.getY() + randomsource.nextDouble() * 2.0D);
+             int k = Mth.floor(this.enderman.getZ() - 1.0D + randomsource.nextDouble() * 2.0D);
+             BlockPos blockposition = new BlockPos(i, j, k);
+-            BlockState iblockdata = world.getBlockState(blockposition);
++            BlockState iblockdata = world.getBlockStateIfLoaded(blockposition); // Paper
++            if (iblockdata == null) return; // Paper
+             BlockPos blockposition1 = blockposition.below();
+             BlockState iblockdata1 = world.getBlockState(blockposition1);
+             BlockState iblockdata2 = this.enderman.getCarriedBlock();
+@@ -555,7 +556,8 @@ public class EnderMan extends Monster implements NeutralMob {
+             int j = Mth.floor(this.enderman.getY() + randomsource.nextDouble() * 3.0D);
+             int k = Mth.floor(this.enderman.getZ() - 2.0D + randomsource.nextDouble() * 4.0D);
+             BlockPos blockposition = new BlockPos(i, j, k);
+-            BlockState iblockdata = world.getBlockState(blockposition);
++            BlockState iblockdata = world.getBlockStateIfLoaded(blockposition); // Paper
++            if (iblockdata == null) return; // Paper
+             Vec3 vec3d = new Vec3((double) this.enderman.getBlockX() + 0.5D, (double) j + 0.5D, (double) this.enderman.getBlockZ() + 0.5D);
+             Vec3 vec3d1 = new Vec3((double) i + 0.5D, (double) j + 0.5D, (double) k + 0.5D);
+             BlockHitResult movingobjectpositionblock = world.clip(new ClipContext(vec3d, vec3d1, ClipContext.Block.OUTLINE, ClipContext.Fluid.NONE, this.enderman));

patches/server/0292-Add-APIs-to-replace-OfflinePlayer-getLastPlayed.patch

@@ -0,0 +1,164 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach@zachbr.io>
+Date: Wed, 2 Jan 2019 00:35:43 -0600
+Subject: [PATCH] Add APIs to replace OfflinePlayer#getLastPlayed
+
+Currently OfflinePlayer#getLastPlayed could more accurately be described
+as "OfflinePlayer#getLastTimeTheirDataWasSaved".
+
+The API doc says it should return the last time the server "witnessed"
+the player, whilst also saying it should return the last time they
+logged in. The current implementation does neither.
+
+Given this interesting contradiction in the API documentation and the
+current defacto implementation, I've elected to deprecate (with no
+intent to remove) and replace it with two new methods, clearly named and
+documented as to their purpose.
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index c7fe091d13349348b7288c0aa8bdde046dc47fa4..8aac8dd53b171f05559fb233d47bf1c9e5815a03 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -235,6 +235,7 @@ public class ServerPlayer extends Player {
+     public int latency;
+     public boolean wonGame;
+     private int containerUpdateDelay; // Paper
++    public long loginTime; // Paper
+     // Paper start - cancellable death event
+     public boolean queueHealthUpdatePacket = false;
+     public net.minecraft.network.protocol.game.ClientboundSetHealthPacket queuedHealthUpdatePacket;
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 52708bcdc046cc0a7f3798bfef06e49a6215acfd..43ab48c7f11592c6f0c82243a1d88f48ef175aae 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
++++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -185,6 +185,7 @@ public abstract class PlayerList {
+ 
+     public void placeNewPlayer(Connection connection, ServerPlayer player) {
+         player.isRealPlayer = true; // Paper
++        player.loginTime = System.currentTimeMillis(); // Paper
+         GameProfile gameprofile = player.getGameProfile();
+         GameProfileCache usercache = this.server.getProfileCache();
+         Optional<GameProfile> optional = usercache.get(gameprofile.getId());
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java b/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
+index e7442952ef1f03969949014492a7ddc6d0796ba5..d7823d7dc88cfba6f6ac9dae220e03dea4a0bcdd 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
+@@ -250,6 +250,61 @@ public class CraftOfflinePlayer implements OfflinePlayer, ConfigurationSerializa
+         return this.getData() != null;
+     }
+ 
++    // Paper start
++    @Override
++    public long getLastLogin() {
++        Player player = getPlayer();
++        if (player != null) return player.getLastLogin();
++
++        CompoundTag data = getPaperData();
++
++        if (data != null) {
++            if (data.contains("LastLogin")) {
++                return data.getLong("LastLogin");
++            } else {
++                // if the player file cannot provide accurate data, this is probably the closest we can approximate
++                File file = getDataFile();
++                return file.lastModified();
++            }
++        } else {
++            return 0;
++        }
++    }
++
++    @Override
++    public long getLastSeen() {
++        Player player = getPlayer();
++        if (player != null) return player.getLastSeen();
++
++        CompoundTag data = getPaperData();
++
++        if (data != null) {
++            if (data.contains("LastSeen")) {
++                return data.getLong("LastSeen");
++            } else {
++                // if the player file cannot provide accurate data, this is probably the closest we can approximate
++                File file = getDataFile();
++                return file.lastModified();
++            }
++        } else {
++            return 0;
++        }
++    }
++
++    private CompoundTag getPaperData() {
++        CompoundTag result = getData();
++
++        if (result != null) {
++            if (!result.contains("Paper")) {
++                result.put("Paper", new CompoundTag());
++            }
++            result = result.getCompound("Paper");
++        }
++
++        return result;
++    }
++    // Paper end
++
+     @Override
+     public Location getLastDeathLocation() {
+         if (this.getData().contains("LastDeathLocation", 10)) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 15da4358e46547fa979dd5023ec6eb5d1358bcb5..7e4cdc2ff30bd85e2ddd271f7b0a531100fdce36 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -176,6 +176,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     private org.bukkit.event.player.PlayerResourcePackStatusEvent.Status resourcePackStatus;
+     private String resourcePackHash;
+     private static final boolean DISABLE_CHANNEL_LIMIT = System.getProperty("paper.disableChannelLimit") != null; // Paper - add a flag to disable the channel limit
++    private long lastSaveTime;
+     // Paper end
+ 
+     public CraftPlayer(CraftServer server, ServerPlayer entity) {
+@@ -1767,6 +1768,18 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         this.firstPlayed = firstPlayed;
+     }
+ 
++    // Paper start
++    @Override
++    public long getLastLogin() {
++        return getHandle().loginTime;
++    }
++
++    @Override
++    public long getLastSeen() {
++        return isOnline() ? System.currentTimeMillis() : this.lastSaveTime;
++    }
++    // Paper end
++
+     public void readExtraData(CompoundTag nbttagcompound) {
+         this.hasPlayedBefore = true;
+         if (nbttagcompound.contains("bukkit")) {
+@@ -1789,6 +1802,8 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     }
+ 
+     public void setExtraData(CompoundTag nbttagcompound) {
++        this.lastSaveTime = System.currentTimeMillis(); // Paper
++
+         if (!nbttagcompound.contains("bukkit")) {
+             nbttagcompound.put("bukkit", new CompoundTag());
+         }
+@@ -1803,6 +1818,16 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         data.putLong("firstPlayed", this.getFirstPlayed());
+         data.putLong("lastPlayed", System.currentTimeMillis());
+         data.putString("lastKnownName", handle.getScoreboardName());
++
++        // Paper start - persist for use in offline save data
++        if (!nbttagcompound.contains("Paper")) {
++            nbttagcompound.put("Paper", new CompoundTag());
++        }
++
++        CompoundTag paper = nbttagcompound.getCompound("Paper");
++        paper.putLong("LastLogin", handle.loginTime);
++        paper.putLong("LastSeen", System.currentTimeMillis());
++        // Paper end
+     }
+ 
+     @Override

patches/server/0293-Workaround-for-vehicle-tracking-issue-on-disconnect.patch

@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: connorhartley <vectrixu+gh@gmail.com>
+Date: Mon, 7 Jan 2019 14:43:48 -0600
+Subject: [PATCH] Workaround for vehicle tracking issue on disconnect
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 8aac8dd53b171f05559fb233d47bf1c9e5815a03..6092167b282a99799c27937dfa1bef424a7e2a9e 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -1609,6 +1609,13 @@ public class ServerPlayer extends Player {
+     public void disconnect() {
+         this.disconnected = true;
+         this.ejectPassengers();
++
++        // Paper start - Workaround an issue where the vehicle doesn't track the passenger disconnection dismount.
++        if (this.isPassenger() && this.getVehicle() instanceof ServerPlayer) {
++            this.stopRiding();
++        }
++        // Paper end
++
+         if (this.isSleeping()) {
+             this.stopSleepInBed(true, false);
+         }

patches/server/0294-Block-Entity-remove-from-being-called-on-Players.patch

@@ -0,0 +1,33 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach@zachbr.io>
+Date: Mon, 4 Feb 2019 23:33:24 -0500
+Subject: [PATCH] Block Entity#remove from being called on Players
+
+This doesn't result in the same behavior as other entities and causes
+several problems. Anyone ever complain about the "Cannot send chat
+message" thing? That's one of the issues this causes, among others.
+
+If a plugin developer can come up with a valid reason to call this on a
+Player we will look at limiting the scope of this change. It appears to
+be unintentional in the few cases we've seen so far.
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 7e4cdc2ff30bd85e2ddd271f7b0a531100fdce36..b9e484ec8173be94fae307830e87a9205e56a11e 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -2638,6 +2638,15 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     public void resetCooldown() {
+         getHandle().resetAttackStrengthTicker();
+     }
++
++    @Override
++    public void remove() {
++        if (this.getHandle().getClass().equals(ServerPlayer.class)) { // special case for NMS plugins inheriting
++            throw new UnsupportedOperationException("Calling Entity#remove on players produces undefined (bad) behavior");
++        } else {
++            super.remove();
++        }
++    }
+     // Paper end
+     // Spigot start
+     private final Player.Spigot spigot = new Player.Spigot()

patches/server/0295-BlockDestroyEvent.patch

@@ -0,0 +1,47 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Wed, 6 Feb 2019 00:20:33 -0500
+Subject: [PATCH] BlockDestroyEvent
+
+Adds an event for when the server is going to destroy a current block,
+potentially causing it to drop. This event can be cancelled to avoid
+the block destruction, such as preventing signs from popping when
+floating in the air.
+
+This can replace many uses of BlockPhysicsEvent
+
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 638a77d3ea65b509b9fcdd3c1e3ea0abe5b7566f..35838b3c858f8dd3c3cb59fe1c4cc8d1d878ff83 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
++++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -29,6 +29,7 @@ import net.minecraft.nbt.CompoundTag;
+ import net.minecraft.network.protocol.Packet;
+ import net.minecraft.resources.ResourceKey;
+ import net.minecraft.resources.ResourceLocation;
++import io.papermc.paper.util.MCUtil;
+ import net.minecraft.server.MinecraftServer;
+ import net.minecraft.server.level.ChunkHolder;
+ import net.minecraft.server.level.ServerLevel;
+@@ -582,8 +583,21 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+             return false;
+         } else {
+             FluidState fluid = this.getFluidState(pos);
++            // Paper start - while the above setAir method is named same and looks very similar
++            // they are NOT used with same intent and the above should not fire this event. The above method is more of a BlockSetToAirEvent,
++            // it doesn't imply destruction of a block that plays a sound effect / drops an item.
++            boolean playEffect = true;
++            if (com.destroystokyo.paper.event.block.BlockDestroyEvent.getHandlerList().getRegisteredListeners().length > 0) {
++                com.destroystokyo.paper.event.block.BlockDestroyEvent event = new com.destroystokyo.paper.event.block.BlockDestroyEvent(MCUtil.toBukkitBlock(this, pos), fluid.createLegacyBlock().createCraftBlockData(), drop);
++                if (!event.callEvent()) {
++                    return false;
++                }
++                playEffect = event.playEffect();
++                drop = event.willDrop();
++            }
++            // Paper end
+ 
+-            if (!(iblockdata.getBlock() instanceof BaseFireBlock)) {
++            if (playEffect && !(iblockdata.getBlock() instanceof BaseFireBlock)) { // Paper
+                 this.levelEvent(2001, pos, Block.getId(iblockdata));
+             }
+ 

patches/server/0296-Async-command-map-building.patch

@@ -0,0 +1,66 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Callahan <mr.callahhh@gmail.com>
+Date: Wed, 8 Apr 2020 02:42:14 -0500
+Subject: [PATCH] Async command map building
+
+This adds a custom pool inorder to make sure that they are closed
+without much though, as it doesn't matter if the client is not sent
+commands if the server is restarting. Using the default async pool caused issues to arise
+due to the shutdown logic generally being much later.
+
+diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java
+index 9eaa7ad424252ea2e033d6041a14bf1ef7dd9fde..6e931aa7220180336b64fbb3b4090df278fca0fa 100644
+--- a/src/main/java/net/minecraft/commands/Commands.java
++++ b/src/main/java/net/minecraft/commands/Commands.java
+@@ -368,6 +368,24 @@ public class Commands {
+         if ( org.spigotmc.SpigotConfig.tabComplete < 0 ) return; // Spigot
+         // CraftBukkit start
+         // Register Vanilla commands into builtRoot as before
++        // Paper start - Async command map building
++        COMMAND_SENDING_POOL.execute(() -> {
++                this.sendAsync(player);
++        });
++    }
++
++    public static final java.util.concurrent.ThreadPoolExecutor COMMAND_SENDING_POOL = new java.util.concurrent.ThreadPoolExecutor(
++        0, 2, 60L, java.util.concurrent.TimeUnit.SECONDS,
++        new java.util.concurrent.LinkedBlockingQueue<>(),
++        new com.google.common.util.concurrent.ThreadFactoryBuilder()
++            .setNameFormat("Paper Async Command Builder Thread Pool - %1$d")
++            .setUncaughtExceptionHandler(new net.minecraft.DefaultUncaughtExceptionHandlerWithName(net.minecraft.server.MinecraftServer.LOGGER))
++            .build(),
++        new java.util.concurrent.ThreadPoolExecutor.DiscardPolicy()
++    );
++
++    private void sendAsync(ServerPlayer player) {
++        // Paper end - Async command map building
+         Map<CommandNode<CommandSourceStack>, CommandNode<SharedSuggestionProvider>> map = Maps.newIdentityHashMap(); // Use identity to prevent aliasing issues
+         RootCommandNode vanillaRoot = new RootCommandNode();
+ 
+@@ -385,7 +403,14 @@ public class Commands {
+         for (CommandNode node : rootcommandnode.getChildren()) {
+             bukkit.add(node.getName());
+         }
++        // Paper start - Async command map building
++        net.minecraft.server.MinecraftServer.getServer().execute(() -> {
++           runSync(player, bukkit, rootcommandnode);
++        });
++    }
+ 
++    private void runSync(ServerPlayer player, Collection<String> bukkit, RootCommandNode<SharedSuggestionProvider> rootcommandnode) {
++        // Paper end - Async command map building
+         PlayerCommandSendEvent event = new PlayerCommandSendEvent(player.getBukkitEntity(), new LinkedHashSet<>(bukkit));
+         event.getPlayer().getServer().getPluginManager().callEvent(event);
+ 
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index f9007905422f7a6eac7c78fd5bdb17cb4da96712..1685f92acdf63decc6cd6b37957ca61212b43bbc 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -897,6 +897,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         }
+ 
+         MinecraftServer.LOGGER.info("Stopping server");
++        Commands.COMMAND_SENDING_POOL.shutdownNow(); // Paper - Shutdown and don't bother finishing
+         MinecraftTimings.stopServer(); // Paper
+         // CraftBukkit start
+         if (this.server != null) {

patches/server/0297-Implement-Brigadier-Mojang-API.patch

@@ -0,0 +1,208 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sun, 19 Apr 2020 18:15:29 -0400
+Subject: [PATCH] Implement Brigadier Mojang API
+
+Adds AsyncPlayerSendCommandsEvent
+  - Allows modifying on a per command basis what command data they see.
+
+Adds CommandRegisteredEvent
+  - Allows manipulating the CommandNode to add more children/metadata for the client
+
+diff --git a/build.gradle.kts b/build.gradle.kts
+index 28ca89a36d9cf9b7aca51a21be89e220c8e07589..a4b47b69e14643cd82d71d18941144ecbf50db8b 100644
+--- a/build.gradle.kts
++++ b/build.gradle.kts
+@@ -8,6 +8,7 @@ plugins {
+ 
+ dependencies {
+     implementation(project(":paper-api"))
++    implementation(project(":paper-mojangapi"))
+     // Paper start
+     implementation("org.jline:jline-terminal-jansi:3.21.0")
+     implementation("net.minecrell:terminalconsoleappender:1.3.0")
+diff --git a/src/main/java/com/mojang/brigadier/exceptions/CommandSyntaxException.java b/src/main/java/com/mojang/brigadier/exceptions/CommandSyntaxException.java
+index 3370731ee064d2693b972a0765c13dd4fd69f66a..614eba6cc55d1eb7755cac35c671cb6f6cacca13 100644
+--- a/src/main/java/com/mojang/brigadier/exceptions/CommandSyntaxException.java
++++ b/src/main/java/com/mojang/brigadier/exceptions/CommandSyntaxException.java
+@@ -5,7 +5,7 @@ package com.mojang.brigadier.exceptions;
+ 
+ import com.mojang.brigadier.Message;
+ 
+-public class CommandSyntaxException extends Exception {
++public class CommandSyntaxException extends Exception implements net.kyori.adventure.util.ComponentMessageThrowable { // Paper
+     public static final int CONTEXT_AMOUNT = 10;
+     public static boolean ENABLE_COMMAND_STACK_TRACES = true;
+     public static BuiltInExceptionProvider BUILT_IN_EXCEPTIONS = new BuiltInExceptions();
+@@ -73,4 +73,11 @@ public class CommandSyntaxException extends Exception {
+     public int getCursor() {
+         return cursor;
+     }
++
++    // Paper start
++    @Override
++    public @org.jetbrains.annotations.Nullable net.kyori.adventure.text.Component componentMessage() {
++        return io.papermc.paper.brigadier.PaperBrigadier.componentFromMessage(this.message);
++    }
++    // Paper end
+ }
+diff --git a/src/main/java/com/mojang/brigadier/tree/CommandNode.java b/src/main/java/com/mojang/brigadier/tree/CommandNode.java
+index da6250df1c5f3385b683cffde47754bca4606f5e..3384501f83d445f45aa8233e98c7597daa67b8ef 100644
+--- a/src/main/java/com/mojang/brigadier/tree/CommandNode.java
++++ b/src/main/java/com/mojang/brigadier/tree/CommandNode.java
+@@ -34,6 +34,7 @@ public abstract class CommandNode<S> implements Comparable<CommandNode<S>> {
+     private final RedirectModifier<S> modifier;
+     private final boolean forks;
+     private Command<S> command;
++    public LiteralCommandNode<CommandSourceStack> clientNode = null; // Paper
+     // CraftBukkit start
+     public void removeCommand(String name) {
+         this.children.remove(name);
+diff --git a/src/main/java/net/minecraft/commands/CommandSourceStack.java b/src/main/java/net/minecraft/commands/CommandSourceStack.java
+index 36bbe7d0b2089361beda89097c15eca9ab48a57d..b8f5b5895bf75aa8e08b2b0431ef6fdacd235430 100644
+--- a/src/main/java/net/minecraft/commands/CommandSourceStack.java
++++ b/src/main/java/net/minecraft/commands/CommandSourceStack.java
+@@ -41,7 +41,7 @@ import net.minecraft.world.phys.Vec2;
+ import net.minecraft.world.phys.Vec3;
+ import com.mojang.brigadier.tree.CommandNode; // CraftBukkit
+ 
+-public class CommandSourceStack implements SharedSuggestionProvider {
++public class CommandSourceStack implements SharedSuggestionProvider, com.destroystokyo.paper.brigadier.BukkitBrigadierCommandSource { // Paper
+ 
+     public static final SimpleCommandExceptionType ERROR_NOT_PLAYER = new SimpleCommandExceptionType(Component.translatable("permissions.requires.player"));
+     public static final SimpleCommandExceptionType ERROR_NOT_ENTITY = new SimpleCommandExceptionType(Component.translatable("permissions.requires.entity"));
+@@ -171,6 +171,26 @@ public class CommandSourceStack implements SharedSuggestionProvider {
+         return this.textName;
+     }
+ 
++    // Paper start
++    @Override
++    public org.bukkit.entity.Entity getBukkitEntity() {
++        return getEntity() != null ? getEntity().getBukkitEntity() : null;
++    }
++
++    @Override
++    public org.bukkit.World getBukkitWorld() {
++        return getLevel() != null ? getLevel().getWorld() : null;
++    }
++
++    @Override
++    public org.bukkit.Location getBukkitLocation() {
++        Vec3 pos = getPosition();
++        org.bukkit.World world = getBukkitWorld();
++        Vec2 rot = getRotation();
++        return world != null && pos != null ? new org.bukkit.Location(world, pos.x, pos.y, pos.z, rot != null ? rot.y : 0, rot != null ? rot.x : 0) : null;
++    }
++    // Paper end
++
+     @Override
+     public boolean hasPermission(int level) {
+         // CraftBukkit start
+diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java
+index 6e931aa7220180336b64fbb3b4090df278fca0fa..feb9e827357b3ffb76dfff90350e513592441d8e 100644
+--- a/src/main/java/net/minecraft/commands/Commands.java
++++ b/src/main/java/net/minecraft/commands/Commands.java
+@@ -404,6 +404,7 @@ public class Commands {
+             bukkit.add(node.getName());
+         }
+         // Paper start - Async command map building
++        new com.destroystokyo.paper.event.brigadier.AsyncPlayerSendCommandsEvent<CommandSourceStack>(player.getBukkitEntity(), (RootCommandNode) rootcommandnode, false).callEvent(); // Paper
+         net.minecraft.server.MinecraftServer.getServer().execute(() -> {
+            runSync(player, bukkit, rootcommandnode);
+         });
+@@ -411,6 +412,7 @@ public class Commands {
+ 
+     private void runSync(ServerPlayer player, Collection<String> bukkit, RootCommandNode<SharedSuggestionProvider> rootcommandnode) {
+         // Paper end - Async command map building
++        new com.destroystokyo.paper.event.brigadier.AsyncPlayerSendCommandsEvent<CommandSourceStack>(player.getBukkitEntity(), (RootCommandNode) rootcommandnode, false).callEvent(); // Paper
+         PlayerCommandSendEvent event = new PlayerCommandSendEvent(player.getBukkitEntity(), new LinkedHashSet<>(bukkit));
+         event.getPlayer().getServer().getPluginManager().callEvent(event);
+ 
+@@ -429,6 +431,11 @@ public class Commands {
+ 
+         while (iterator.hasNext()) {
+             CommandNode<CommandSourceStack> commandnode2 = (CommandNode) iterator.next();
++            // Paper start
++            if (commandnode2.clientNode != null) {
++                commandnode2 = commandnode2.clientNode;
++            }
++            // Paper end
+             if ( !org.spigotmc.SpigotConfig.sendNamespaced && commandnode2.getName().contains( ":" ) ) continue; // Spigot
+ 
+             if (commandnode2.canUse(source)) {
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 60c9b8d45ae4884883fce1b402bf9ed2906aff79..428f300a33589910eae058b77bb7aa611f2578e7 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -828,8 +828,12 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+                         ParseResults<CommandSourceStack> parseresults = this.server.getCommands().getDispatcher().parse(stringreader, this.player.createCommandSourceStack());
+ 
+                         this.server.getCommands().getDispatcher().getCompletionSuggestions(parseresults).thenAccept((suggestions) -> {
+-                            if (suggestions.isEmpty()) return; // CraftBukkit - don't send through empty suggestions - prevents [<args>] from showing for plugins with nothing more to offer
+-                            this.connection.send(new ClientboundCommandSuggestionsPacket(packet.getId(), suggestions));
++                            // Paper start - Brigadier API
++                            com.destroystokyo.paper.event.brigadier.AsyncPlayerSendSuggestionsEvent suggestEvent = new com.destroystokyo.paper.event.brigadier.AsyncPlayerSendSuggestionsEvent(this.getCraftPlayer(), suggestions, command);
++                            suggestEvent.setCancelled(suggestions.isEmpty());
++                            if (!suggestEvent.callEvent()) return;
++                            this.connection.send(new ClientboundCommandSuggestionsPacket(packet.getId(), suggestEvent.getSuggestions()));
++                            // Paper end - Brigadier API
+                         });
+                     });
+                 }
+@@ -844,7 +848,13 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+                         builder.suggest(completion.suggestion(), PaperAdventure.asVanilla(completion.tooltip()));
+                     }
+                 });
+-                player.connection.send(new ClientboundCommandSuggestionsPacket(packet.getId(), builder.buildFuture().join()));
++                // Paper start - Brigadier API
++                com.mojang.brigadier.suggestion.Suggestions suggestions = builder.buildFuture().join();
++                com.destroystokyo.paper.event.brigadier.AsyncPlayerSendSuggestionsEvent suggestEvent = new com.destroystokyo.paper.event.brigadier.AsyncPlayerSendSuggestionsEvent(this.getCraftPlayer(), suggestions, command);
++                suggestEvent.setCancelled(suggestions.isEmpty());
++                if (!suggestEvent.callEvent()) return;
++                this.connection.send(new ClientboundCommandSuggestionsPacket(packet.getId(), suggestEvent.getSuggestions()));
++                // Paper end - Brigadier API
+             }
+         });
+         // Paper end - async tab completion
+diff --git a/src/main/java/org/bukkit/craftbukkit/command/BukkitCommandWrapper.java b/src/main/java/org/bukkit/craftbukkit/command/BukkitCommandWrapper.java
+index 83d81b9371902b0302d13e53b31c15fac4e67966..d113e54a30db16e2ad955170df6030d15de530d6 100644
+--- a/src/main/java/org/bukkit/craftbukkit/command/BukkitCommandWrapper.java
++++ b/src/main/java/org/bukkit/craftbukkit/command/BukkitCommandWrapper.java
+@@ -20,7 +20,7 @@ import org.bukkit.command.CommandException;
+ import org.bukkit.command.CommandSender;
+ import org.bukkit.craftbukkit.CraftServer;
+ 
+-public class BukkitCommandWrapper implements com.mojang.brigadier.Command<CommandSourceStack>, Predicate<CommandSourceStack>, SuggestionProvider<CommandSourceStack> {
++public class BukkitCommandWrapper implements com.mojang.brigadier.Command<CommandSourceStack>, Predicate<CommandSourceStack>, SuggestionProvider<CommandSourceStack>, com.destroystokyo.paper.brigadier.BukkitBrigadierCommand<CommandSourceStack> { // Paper
+ 
+     private final CraftServer server;
+     private final Command command;
+@@ -31,10 +31,24 @@ public class BukkitCommandWrapper implements com.mojang.brigadier.Command<Comman
+     }
+ 
+     public LiteralCommandNode<CommandSourceStack> register(CommandDispatcher<CommandSourceStack> dispatcher, String label) {
+-        return dispatcher.register(
+-                LiteralArgumentBuilder.<CommandSourceStack>literal(label).requires(this).executes(this)
+-                .then(RequiredArgumentBuilder.<CommandSourceStack, String>argument("args", StringArgumentType.greedyString()).suggests(this).executes(this))
+-        );
++        // Paper start - Expose Brigadier to Paper-MojangAPI
++        com.mojang.brigadier.tree.RootCommandNode<CommandSourceStack> root = dispatcher.getRoot();
++        LiteralCommandNode<CommandSourceStack> literal = LiteralArgumentBuilder.<CommandSourceStack>literal(label).requires(this).executes(this).build();
++        LiteralCommandNode<CommandSourceStack> defaultNode = literal;
++        com.mojang.brigadier.tree.ArgumentCommandNode<CommandSourceStack, String> defaultArgs = RequiredArgumentBuilder.<CommandSourceStack, String>argument("args", StringArgumentType.greedyString()).suggests(this).executes(this).build();
++        literal.addChild(defaultArgs);
++        com.destroystokyo.paper.event.brigadier.CommandRegisteredEvent<CommandSourceStack> event = new com.destroystokyo.paper.event.brigadier.CommandRegisteredEvent<>(label, this, this.command, root, literal, defaultArgs);
++        if (!event.callEvent()) {
++            return null;
++        }
++        literal = event.getLiteral();
++        if (event.isRawCommand()) {
++            defaultNode.clientNode = literal;
++            literal = defaultNode;
++        }
++        root.addChild(literal);
++        return literal;
++        // Paper end
+     }
+ 
+     @Override

patches/server/0298-Fix-Custom-Shapeless-Custom-Crafting-Recipes.patch

@@ -0,0 +1,68 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Fri, 18 Jan 2019 00:08:15 -0500
+Subject: [PATCH] Fix Custom Shapeless Custom Crafting Recipes
+
+Mojang implemented Shapeless different than Shaped
+
+This made the Bukkit RecipeChoice API not work for Shapeless.
+
+This reimplements vanilla logic using the same test logic as Shaped
+
+diff --git a/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java b/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java
+index dc4d3034b193562c70a929f0af9420a1e6728f13..e7c06d98532160499f2610f69de27e30a326b16f 100644
+--- a/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java
++++ b/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java
+@@ -84,16 +84,49 @@ public class ShapelessRecipe implements CraftingRecipe {
+         StackedContents autorecipestackmanager = new StackedContents();
+         int i = 0;
+ 
++        // Paper start
++        java.util.List<ItemStack> providedItems = new java.util.ArrayList<>();
++        co.aikar.util.Counter<ItemStack> matchedProvided = new co.aikar.util.Counter<>();
++        co.aikar.util.Counter<Ingredient> matchedIngredients = new co.aikar.util.Counter<>();
++        // Paper end
+         for (int j = 0; j < inventory.getContainerSize(); ++j) {
+             ItemStack itemstack = inventory.getItem(j);
+ 
+             if (!itemstack.isEmpty()) {
+-                ++i;
+-                autorecipestackmanager.accountStack(itemstack, 1);
++                // Paper start
++                itemstack = itemstack.copy();
++                providedItems.add(itemstack);
++                for (Ingredient ingredient : ingredients) {
++                    if (ingredient.test(itemstack)) {
++                        matchedProvided.increment(itemstack);
++                        matchedIngredients.increment(ingredient);
++                    }
++                }
++                // Paper end
+             }
+         }
+ 
+-        return i == this.ingredients.size() && autorecipestackmanager.canCraft(this, (IntList) null);
++        // Paper start
++        if (matchedProvided.isEmpty() || matchedIngredients.isEmpty()) {
++            return false;
++        }
++        java.util.List<Ingredient> ingredients = new java.util.ArrayList<>(this.ingredients);
++        providedItems.sort(java.util.Comparator.comparingInt((ItemStack c) -> (int) matchedProvided.getCount(c)).reversed());
++        ingredients.sort(java.util.Comparator.comparingInt((Ingredient c) -> (int) matchedIngredients.getCount(c)));
++
++        PROVIDED:
++        for (ItemStack provided : providedItems) {
++            for (Iterator<Ingredient> itIngredient = ingredients.iterator(); itIngredient.hasNext(); ) {
++                Ingredient ingredient = itIngredient.next();
++                if (ingredient.test(provided)) {
++                    itIngredient.remove();
++                    continue PROVIDED;
++                }
++            }
++            return false;
++        }
++        return ingredients.isEmpty();
++        // Paper end
+     }
+ 
+     public ItemStack assemble(CraftingContainer inventory) {

patches/server/0299-Limit-Client-Sign-length-more.patch

@@ -0,0 +1,56 @@
+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 428f300a33589910eae058b77bb7aa611f2578e7..a1e75d2c44e854fd7976caa58c8beb618f92e0a0 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -296,6 +296,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+     private final MessageSignatureCache messageSignatureCache;
+     private final FutureChain chatMessageChain;
+     private static final long KEEPALIVE_LIMIT = Long.getLong("paper.playerconnection.keepalive", 30) * 1000; // Paper - provide property to set keepalive limit
++    private static final int MAX_SIGN_LINE_LENGTH = Integer.getInteger("Paper.maxSignLength", 80); // Paper
+ 
+     public ServerGamePacketListenerImpl(MinecraftServer server, Connection connection, ServerPlayer player) {
+         this.lastChatTimeStamp = new AtomicReference(Instant.EPOCH);
+@@ -3176,7 +3177,19 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+ 
+     @Override
+     public void handleSignUpdate(ServerboundSignUpdatePacket packet) {
+-        List<String> list = (List) Stream.of(packet.getLines()).map(ChatFormatting::stripFormatting).collect(Collectors.toList());
++        // Paper start - cap line length - modified clients can send longer data than normal
++        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
+ 
+         this.filterTextPacket(list).thenAcceptAsync((list1) -> {
+             this.updateSignText(packet, list1);

patches/server/0300-Don-t-check-ConvertSigns-boolean-every-sign-save.patch

@@ -0,0 +1,29 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sat, 2 Mar 2019 11:11:29 -0500
+Subject: [PATCH] Don't check ConvertSigns boolean every sign save
+
+property lookups arent super cheap. they synchronize, validate
+and check security managers.
+
+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 149728fa6371b4d8b0afaae769aacac27401ea03..aca2da47651a76f3e5593d71c500d749d92ccc3b 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
+@@ -26,6 +26,7 @@ import net.minecraft.world.phys.Vec2;
+ import net.minecraft.world.phys.Vec3;
+ 
+ public class SignBlockEntity extends BlockEntity implements CommandSource { // CraftBukkit - implements
++    private static final boolean CONVERT_LEGACY_SIGNS = Boolean.getBoolean("convertLegacySigns"); // Paper
+ 
+     public static final int LINES = 4;
+     private static final int MAX_TEXT_LINE_WIDTH = 90;
+@@ -84,7 +85,7 @@ public class SignBlockEntity extends BlockEntity implements CommandSource { // C
+         }
+ 
+         // CraftBukkit start
+-        if (Boolean.getBoolean("convertLegacySigns")) {
++        if (CONVERT_LEGACY_SIGNS) { // Paper
+             nbt.putBoolean("Bukkit.isConverted", true);
+         }
+         // CraftBukkit end

patches/server/0301-Optimize-Network-Manager-and-add-advanced-packet-sup.patch

@@ -0,0 +1,360 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Wed, 6 May 2020 04:53:35 -0400
+Subject: [PATCH] Optimize Network Manager and add advanced packet support
+
+Adds ability for 1 packet to bundle other packets to follow it
+Adds ability for a packet to delay sending more packets until a state is ready.
+
+Removes synchronization from sending packets
+Removes processing packet queue off of main thread
+  - for the few cases where it is allowed, order is not necessary nor
+    should it even be happening concurrently in first place (handshaking/login/status)
+
+Ensures packets sent asynchronously are dispatched on main thread
+
+This helps ensure safety for ProtocolLib as packet listeners
+are commonly accessing world state. This will allow you to schedule
+a packet to be sent async, but itll be dispatched sync for packet
+listeners to process.
+
+This should solve some deadlock risks
+
+Also adds Netty Channel Flush Consolidation to reduce the amount of flushing
+
+Also avoids spamming closed channel exception by rechecking closed state in dispatch
+and then catch exceptions and close if they fire.
+
+Part of this commit was authored by: Spottedleaf, sandtechnology
+
+diff --git a/src/main/java/net/minecraft/network/Connection.java b/src/main/java/net/minecraft/network/Connection.java
+index 8b1c39cc7f77ca36d0341fb68de1441cc61f19e4..8bc8b6013ea5803e091cf3534130b72278b9c29e 100644
+--- a/src/main/java/net/minecraft/network/Connection.java
++++ b/src/main/java/net/minecraft/network/Connection.java
+@@ -116,6 +116,10 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
+     public int protocolVersion;
+     public java.net.InetSocketAddress virtualHost;
+     private static boolean enableExplicitFlush = Boolean.getBoolean("paper.explicit-flush");
++    // Optimize network
++    public boolean isPending = true;
++    public boolean queueImmunity = false;
++    public ConnectionProtocol protocol;
+     // Paper end
+ 
+     public Connection(PacketFlow side) {
+@@ -139,6 +143,7 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
+     }
+ 
+     public void setProtocol(ConnectionProtocol state) {
++        protocol = state; // Paper
+         this.channel.attr(Connection.ATTRIBUTE_PROTOCOL).set(state);
+         this.channel.config().setAutoRead(true);
+         Connection.LOGGER.debug("Enabled auto read");
+@@ -217,19 +222,89 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
+         Validate.notNull(listener, "packetListener", new Object[0]);
+         this.packetListener = listener;
+     }
++    // Paper start
++    public @Nullable net.minecraft.server.level.ServerPlayer getPlayer() {
++        if (packetListener instanceof net.minecraft.server.network.ServerGamePacketListenerImpl serverGamePacketListener) {
++            return serverGamePacketListener.player;
++        } else {
++            return null;
++        }
++    }
++    private static class InnerUtil { // Attempt to hide these methods from ProtocolLib so it doesn't accidently pick them up.
++        private static java.util.List<Packet> buildExtraPackets(Packet packet) {
++            java.util.List<Packet> extra = packet.getExtraPackets();
++            if (extra == null || extra.isEmpty()) {
++                return null;
++            }
++            java.util.List<Packet> ret = new java.util.ArrayList<>(1 + extra.size());
++            buildExtraPackets0(extra, ret);
++            return ret;
++        }
++
++        private static void buildExtraPackets0(java.util.List<Packet> extraPackets, java.util.List<Packet> into) {
++            for (Packet extra : extraPackets) {
++                into.add(extra);
++                java.util.List<Packet> extraExtra = extra.getExtraPackets();
++                if (extraExtra != null && !extraExtra.isEmpty()) {
++                    buildExtraPackets0(extraExtra, into);
++                }
++            }
++        }
++        // Paper start
++        private static boolean canSendImmediate(Connection networkManager, Packet<?> packet) {
++            return networkManager.isPending || networkManager.protocol != ConnectionProtocol.PLAY ||
++                packet instanceof net.minecraft.network.protocol.game.ClientboundKeepAlivePacket ||
++                packet instanceof net.minecraft.network.protocol.game.ClientboundPlayerChatPacket ||
++                packet instanceof net.minecraft.network.protocol.game.ClientboundSystemChatPacket ||
++                packet instanceof net.minecraft.network.protocol.game.ClientboundChatPreviewPacket ||
++                packet instanceof net.minecraft.network.protocol.game.ClientboundCommandSuggestionsPacket ||
++                packet instanceof net.minecraft.network.protocol.game.ClientboundSetTitleTextPacket ||
++                packet instanceof net.minecraft.network.protocol.game.ClientboundSetSubtitleTextPacket ||
++                packet instanceof net.minecraft.network.protocol.game.ClientboundSetActionBarTextPacket ||
++                packet instanceof net.minecraft.network.protocol.game.ClientboundSetTitlesAnimationPacket ||
++                packet instanceof net.minecraft.network.protocol.game.ClientboundClearTitlesPacket ||
++                packet instanceof net.minecraft.network.protocol.game.ClientboundBossEventPacket;
++        }
++        // Paper end
++    }
++    // Paper end
+ 
+     public void send(Packet<?> packet) {
+         this.send(packet, (PacketSendListener) null);
+     }
+ 
+     public void send(Packet<?> packet, @Nullable PacketSendListener callbacks) {
+-        if (this.isConnected()) {
+-            this.flushQueue();
++        // Paper start - handle oversized packets better
++        boolean connected = this.isConnected();
++        if (!connected && !preparing) {
++            return; // Do nothing
++        }
++        packet.onPacketDispatch(getPlayer());
++        if (connected && (InnerUtil.canSendImmediate(this, packet) || (
++            io.papermc.paper.util.MCUtil.isMainThread() && packet.isReady() && this.queue.isEmpty() &&
++            (packet.getExtraPackets() == null || packet.getExtraPackets().isEmpty())
++        ))) {
+             this.sendPacket(packet, callbacks);
+-        } else {
+-            this.queue.add(new Connection.PacketHolder(packet, callbacks));
++            return;
+         }
++        // write the packets to the queue, then flush - antixray hooks there already
++        java.util.List<Packet> extraPackets = InnerUtil.buildExtraPackets(packet);
++        boolean hasExtraPackets = extraPackets != null && !extraPackets.isEmpty();
++        if (!hasExtraPackets) {
++            this.queue.add(new Connection.PacketHolder(packet, callbacks));
++        } else {
++            java.util.List<Connection.PacketHolder> packets = new java.util.ArrayList<>(1 + extraPackets.size());
++            packets.add(new Connection.PacketHolder(packet, null)); // delay the future listener until the end of the extra packets
+ 
++            for (int i = 0, len = extraPackets.size(); i < len;) {
++                Packet extra = extraPackets.get(i);
++                boolean end = ++i == len;
++                packets.add(new Connection.PacketHolder(extra, end ? callbacks : null)); // append listener to the end
++            }
++            this.queue.addAll(packets); // atomic
++        }
++        this.flushQueue();
++        // Paper end
+     }
+ 
+     private void sendPacket(Packet<?> packet, @Nullable PacketSendListener callbacks) {
+@@ -257,6 +332,15 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
+             this.setProtocol(packetState);
+         }
+ 
++        // Paper start
++        net.minecraft.server.level.ServerPlayer player = getPlayer();
++        if (!isConnected()) {
++            packet.onPacketDispatchFinish(player, null);
++            return;
++        }
++
++        try {
++            // Paper end
+         ChannelFuture channelfuture = this.channel.writeAndFlush(packet);
+ 
+         if (callbacks != null) {
+@@ -275,28 +359,72 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
+ 
+             });
+         }
++        // Paper start
++        if (packet.hasFinishListener()) {
++            channelfuture.addListener((ChannelFutureListener) channelFuture -> packet.onPacketDispatchFinish(player, channelFuture));
++        }
++        // Paper end
+ 
+         channelfuture.addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE);
++        // Paper start
++        } catch (Exception e) {
++            LOGGER.error("NetworkException: " + player, e);
++            disconnect(Component.translatable("disconnect.genericReason", "Internal Exception: " + e.getMessage()));
++            packet.onPacketDispatchFinish(player, null);
++        }
++        // Paper end
+     }
+ 
+     private ConnectionProtocol getCurrentProtocol() {
+         return (ConnectionProtocol) this.channel.attr(Connection.ATTRIBUTE_PROTOCOL).get();
+     }
+ 
+-    private void flushQueue() {
++    // Paper start - rewrite this to be safer if ran off main thread
++    private boolean flushQueue() { // void -> boolean
++        if (!isConnected()) {
++            return true;
++        }
++        if (io.papermc.paper.util.MCUtil.isMainThread()) {
++            return processQueue();
++        } else if (isPending) {
++            // Should only happen during login/status stages
++            synchronized (this.queue) {
++                return this.processQueue();
++            }
++        }
++        return false;
++    }
++    private boolean processQueue() {
+         try { // Paper - add pending task queue
+-        if (this.channel != null && this.channel.isOpen()) {
+-            Queue queue = this.queue;
++        if (this.queue.isEmpty()) return true;
++        // If we are on main, we are safe here in that nothing else should be processing queue off main anymore
++        // But if we are not on main due to login/status, the parent is synchronized on packetQueue
++        java.util.Iterator<PacketHolder> iterator = this.queue.iterator();
++        while (iterator.hasNext()) {
++            PacketHolder queued = iterator.next(); // poll -> peek
++
++            // Fix NPE (Spigot bug caused by handleDisconnection())
++            if (queued == null) {
++                return true;
++            }
+ 
+-            synchronized (this.queue) {
+-                Connection.PacketHolder networkmanager_queuedpacket;
++            // Paper start - checking isConsumed flag and skipping packet sending
++            if (queued.isConsumed()) {
++                continue;
++            }
++            // Paper end - checking isConsumed flag and skipping packet sending
+ 
+-                while ((networkmanager_queuedpacket = (Connection.PacketHolder) this.queue.poll()) != null) {
+-                    this.sendPacket(networkmanager_queuedpacket.packet, networkmanager_queuedpacket.listener);
++            Packet<?> packet = queued.packet;
++            if (!packet.isReady()) {
++                return false;
++            } else {
++                iterator.remove();
++                if (queued.tryMarkConsumed()) { // Paper - try to mark isConsumed flag for de-duplicating packet
++                    this.sendPacket(packet, queued.listener);
+                 }
+-
+             }
+         }
++        return true;
+         } finally { // Paper start - add pending task queue
+             Runnable r;
+             while ((r = this.pendingTasks.poll()) != null) {
+@@ -304,6 +432,7 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
+             }
+         } // Paper end - add pending task queue
+     }
++    // Paper end
+ 
+     public void tick() {
+         this.flushQueue();
+@@ -340,9 +469,22 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
+         return this.address;
+     }
+ 
++    // Paper start
++    public void clearPacketQueue() {
++        net.minecraft.server.level.ServerPlayer player = getPlayer();
++        queue.forEach(queuedPacket -> {
++            Packet<?> packet = queuedPacket.packet;
++            if (packet.hasFinishListener()) {
++                packet.onPacketDispatchFinish(player, null);
++            }
++        });
++        queue.clear();
++    }
++    // Paper end
+     public void disconnect(Component disconnectReason) {
+         // Spigot Start
+         this.preparing = false;
++        clearPacketQueue(); // Paper
+         // Spigot End
+         if (this.channel.isOpen()) {
+             this.channel.close(); // We can't wait as this may be called from an event loop.
+@@ -460,7 +602,7 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
+     public void handleDisconnection() {
+         if (this.channel != null && !this.channel.isOpen()) {
+             if (this.disconnectionHandled) {
+-                Connection.LOGGER.warn("handleDisconnection() called twice");
++                //Connection.LOGGER.warn("handleDisconnection() called twice"); // Paper - Do not log useless message
+             } else {
+                 this.disconnectionHandled = true;
+                 if (this.getDisconnectedReason() != null) {
+@@ -468,7 +610,7 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
+                 } else if (this.getPacketListener() != null) {
+                     this.getPacketListener().onDisconnect(Component.translatable("multiplayer.disconnect.generic"));
+                 }
+-                this.queue.clear(); // Free up packet queue.
++                clearPacketQueue(); // Paper
+                 // Paper start - Add PlayerConnectionCloseEvent
+                 final PacketListener packetListener = this.getPacketListener();
+                 if (packetListener instanceof net.minecraft.server.network.ServerGamePacketListenerImpl) {
+@@ -508,6 +650,18 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
+         @Nullable
+         final PacketSendListener listener;
+ 
++        // Paper start - isConsumed flag for the connection
++        private java.util.concurrent.atomic.AtomicBoolean isConsumed = new java.util.concurrent.atomic.AtomicBoolean(false);
++
++        public boolean tryMarkConsumed() {
++            return isConsumed.compareAndSet(false, true);
++        }
++
++        public boolean isConsumed() {
++            return isConsumed.get();
++        }
++        // Paper end - isConsumed flag for the connection
++
+         public PacketHolder(Packet<?> packet, @Nullable PacketSendListener callbacks) {
+             this.packet = packet;
+             this.listener = callbacks;
+diff --git a/src/main/java/net/minecraft/network/protocol/Packet.java b/src/main/java/net/minecraft/network/protocol/Packet.java
+index 74bfe0d3942259c45702b099efdc4e101a4e3022..e8fcd56906d26f6dc87959e32c4c7c78cfea9658 100644
+--- a/src/main/java/net/minecraft/network/protocol/Packet.java
++++ b/src/main/java/net/minecraft/network/protocol/Packet.java
+@@ -9,6 +9,19 @@ public interface Packet<T extends PacketListener> {
+     void handle(T listener);
+ 
+     // Paper start
++    /**
++     * @param player Null if not at PLAY stage yet
++     */
++    default void onPacketDispatch(@javax.annotation.Nullable net.minecraft.server.level.ServerPlayer player) {}
++
++    /**
++     * @param player Null if not at PLAY stage yet
++     * @param future Can be null if packet was cancelled
++     */
++    default void onPacketDispatchFinish(@javax.annotation.Nullable net.minecraft.server.level.ServerPlayer player, @javax.annotation.Nullable io.netty.channel.ChannelFuture future) {}
++    default boolean hasFinishListener() { return false; }
++    default boolean isReady() { return true; }
++    default java.util.List<Packet> getExtraPackets() { return null; }
+     default boolean packetTooLarge(net.minecraft.network.Connection manager) {
+         return false;
+     }
+diff --git a/src/main/java/net/minecraft/server/network/ServerConnectionListener.java b/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
+index 0e04532b8f1d48116eb46dcef7952bfcc0d11394..a24ef433d0c9d06b86fd612978cfd6d877036791 100644
+--- a/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
++++ b/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
+@@ -65,10 +65,12 @@ public class ServerConnectionListener {
+     final List<Connection> connections = Collections.synchronizedList(Lists.newArrayList());
+     // Paper start - prevent blocking on adding a new network manager while the server is ticking
+     private final java.util.Queue<Connection> pending = new java.util.concurrent.ConcurrentLinkedQueue<>();
++    private static final boolean disableFlushConsolidation = Boolean.getBoolean("Paper.disableFlushConsolidate"); // Paper
+     private final void addPending() {
+         Connection manager = null;
+         while ((manager = pending.poll()) != null) {
+             connections.add(manager);
++            manager.isPending = false;
+         }
+     }
+     // Paper end
+@@ -103,6 +105,7 @@ public class ServerConnectionListener {
+                         ;
+                     }
+ 
++                    if (!disableFlushConsolidation) channel.pipeline().addFirst(new io.netty.handler.flush.FlushConsolidationHandler()); // Paper
+                     channel.pipeline().addLast("timeout", new ReadTimeoutHandler(30)).addLast("legacy_query", new LegacyQueryHandler(ServerConnectionListener.this)).addLast("splitter", new Varint21FrameDecoder()).addLast("decoder", new PacketDecoder(PacketFlow.SERVERBOUND)).addLast("prepender", new Varint21LengthFieldPrepender()).addLast("encoder", new PacketEncoder(PacketFlow.CLIENTBOUND));
+                     int j = ServerConnectionListener.this.server.getRateLimitPacketsPerSecond();
+                     Object object = j > 0 ? new RateKickingConnection(j) : new Connection(PacketFlow.SERVERBOUND);

patches/server/0302-Handle-Oversized-Tile-Entities-in-chunks.patch

@@ -0,0 +1,64 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Wed, 6 May 2020 05:00:57 -0400
+Subject: [PATCH] Handle Oversized Tile Entities in chunks
+
+Splits out Extra Packets if too many TE's are encountered to prevent
+creating too large of a packet to sed.
+
+Co authored by Spottedleaf
+
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
+index f47eeb70661661610ef1a96dd9da67785825c126..0ef3e9b472e35bd2572b04722781abf7d4a1094b 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
++++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
+@@ -24,6 +24,14 @@ public class ClientboundLevelChunkPacketData {
+     private final CompoundTag heightmaps;
+     private final byte[] buffer;
+     private final List<ClientboundLevelChunkPacketData.BlockEntityInfo> blockEntitiesData;
++    // Paper start
++    private final java.util.List<net.minecraft.network.protocol.Packet> extraPackets = new java.util.ArrayList<>();
++    private static final int TE_LIMIT = Integer.getInteger("Paper.excessiveTELimit", 750);
++
++    public List<net.minecraft.network.protocol.Packet> getExtraPackets() {
++        return this.extraPackets;
++    }
++    // Paper end
+ 
+     public ClientboundLevelChunkPacketData(LevelChunk chunk) {
+         this.heightmaps = new CompoundTag();
+@@ -37,8 +45,18 @@ public class ClientboundLevelChunkPacketData {
+         this.buffer = new byte[calculateChunkSize(chunk)];
+         extractChunkData(new FriendlyByteBuf(this.getWriteBuffer()), chunk);
+         this.blockEntitiesData = Lists.newArrayList();
++        int totalTileEntities = 0; // Paper
+ 
+         for(Map.Entry<BlockPos, BlockEntity> entry2 : chunk.getBlockEntities().entrySet()) {
++            // Paper start
++            if (++totalTileEntities > TE_LIMIT) {
++                var packet = entry2.getValue().getUpdatePacket();
++                if (packet != null) {
++                    this.extraPackets.add(packet);
++                    continue;
++                }
++            }
++            // Paper end
+             this.blockEntitiesData.add(ClientboundLevelChunkPacketData.BlockEntityInfo.create(entry2.getValue()));
+         }
+ 
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java
+index aee73c4e20aff9bd0a560dc891f74f4f601c24b6..7825d6f0fdcfda6212cff8033ec55fb7db236154 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java
++++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java
+@@ -57,4 +57,11 @@ public class ClientboundLevelChunkWithLightPacket implements Packet<ClientGamePa
+     public ClientboundLightUpdatePacketData getLightData() {
+         return this.lightData;
+     }
++
++    // Paper start - handle over-sized TE packets
++    @Override
++    public java.util.List<Packet> getExtraPackets() {
++        return this.chunkData.getExtraPackets();
++    }
++    // Paper end
+ }

patches/server/0303-Call-WhitelistToggleEvent-when-whitelist-is-toggled.patch

@@ -0,0 +1,18 @@
+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 43ab48c7f11592c6f0c82243a1d88f48ef175aae..bd880228aaaefb2299b09ce91a58b2da1f04d953 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
++++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -1139,6 +1139,7 @@ public abstract class PlayerList {
+     }
+ 
+     public void setUsingWhiteList(boolean whitelistEnabled) {
++        new com.destroystokyo.paper.event.server.WhitelistToggleEvent(whitelistEnabled).callEvent();
+         this.doWhiteList = whitelistEnabled;
+     }
+ 

patches/server/0304-Entity-getEntitySpawnReason.patch

@@ -0,0 +1,121 @@
+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/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index f2b20fe0770b519756342c7b900919c6a9d93bdb..6ca2ea98531d28602905f0e68d368d0015a46dcd 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -1290,6 +1290,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+             return true;
+         }
+         // Paper end
++        if (entity.spawnReason == null) entity.spawnReason = spawnReason; // Paper
+         if (entity.isRemoved()) {
+             // Paper start
+             if (DEBUG_ENTITIES) {
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index bd880228aaaefb2299b09ce91a58b2da1f04d953..01cfa93571effead5498e766f6c7e254a5b13479 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
++++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -356,7 +356,7 @@ public abstract class PlayerList {
+             // CraftBukkit start
+             ServerLevel finalWorldServer = worldserver1;
+             Entity entity = EntityType.loadEntityRecursive(nbttagcompound1.getCompound("Entity"), finalWorldServer, (entity1) -> {
+-                return !finalWorldServer.addWithUUID(entity1) ? null : entity1;
++                return !finalWorldServer.addWithUUID(entity1, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.MOUNT) ? null : entity1; // Paper
+                 // CraftBukkit end
+             });
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index d664b8691a8248a035cbe1b12a353f633980ea7b..15625d54c32530eae73d6360ef68ffd1ddf752b0 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -74,6 +74,8 @@ import net.minecraft.world.InteractionHand;
+ import net.minecraft.world.InteractionResult;
+ import net.minecraft.world.Nameable;
+ import net.minecraft.world.damagesource.DamageSource;
++import net.minecraft.world.entity.animal.AbstractFish;
++import net.minecraft.world.entity.animal.Animal;
+ import net.minecraft.world.entity.item.ItemEntity;
+ import net.minecraft.world.entity.player.Player;
+ import net.minecraft.world.entity.vehicle.Boat;
+@@ -231,6 +233,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+         }
+     }
+     // Paper end
++    public org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason spawnReason; // Paper
+ 
+     public com.destroystokyo.paper.loottable.PaperLootableInventoryData lootableData; // Paper
+     private CraftEntity bukkitEntity;
+@@ -2038,6 +2041,9 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+                 }
+                 nbt.put("Paper.Origin", this.newDoubleList(origin.getX(), origin.getY(), origin.getZ()));
+             }
++            if (spawnReason != null) {
++                nbt.putString("Paper.SpawnReason", spawnReason.name());
++            }
+             // Save entity's from mob spawner status
+             if (spawnedViaMobSpawner) {
+                 nbt.putBoolean("Paper.FromMobSpawner", true);
+@@ -2183,6 +2189,26 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+             }
+ 
+             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 Animal || this instanceof 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 a985364e5dd4a592e282ad16f0555f842a1d5048..2ae7b8d1129a3549c5ba6fe03455b0b0683c9c31 100644
+--- a/src/main/java/net/minecraft/world/level/BaseSpawner.java
++++ b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+@@ -185,6 +185,7 @@ public abstract class BaseSpawner {
+                             // Spigot End
+                         }
+                         entity.spawnedViaMobSpawner = true; // Paper
++                        entity.spawnReason = org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.SPAWNER; // Paper
+                         flag = true; // Paper
+                         // Spigot Start
+                         if (org.bukkit.craftbukkit.event.CraftEventFactory.callSpawnerSpawnEvent(entity, pos).isCancelled()) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index 9ba0135932571c815fec15d2caccc789d3af3464..e900c64b8b07dc9cf47cc565e60df6781ca95756 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -1268,5 +1268,10 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+     public boolean fromMobSpawner() {
+         return getHandle().spawnedViaMobSpawner;
+     }
++
++    @Override
++    public org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason getEntitySpawnReason() {
++        return getHandle().spawnReason;
++    }
+     // Paper end
+ }

patches/server/0305-Fire-event-on-GS4-query.patch

@@ -0,0 +1,155 @@
+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/NetworkDataOutputStream.java b/src/main/java/net/minecraft/server/rcon/NetworkDataOutputStream.java
+index 51cb2644aa516a59e19fecb308d519dbc7e5fb11..e548aa0ca4e1e94ab628614b44fc11568ca3beff 100644
+--- a/src/main/java/net/minecraft/server/rcon/NetworkDataOutputStream.java
++++ b/src/main/java/net/minecraft/server/rcon/NetworkDataOutputStream.java
+@@ -22,6 +22,16 @@ public class NetworkDataOutputStream {
+         this.dataOutputStream.write(0);
+     }
+ 
++    // Paper start - unchecked exception variant to use in Stream API
++    public void writeStringUnchecked(String string) {
++        try {
++            writeString(string);
++        } catch (IOException e) {
++            com.destroystokyo.paper.util.SneakyThrow.sneaky(e);
++        }
++    }
++    // Paper end
++
+     public void write(int value) throws IOException {
+         this.dataOutputStream.write(value);
+     }
+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 88917d7a179739fc13c59831b15e7ddc711bed1b..1ef089dbf83de35d875c00efdf468c397be56978 100644
+--- a/src/main/java/net/minecraft/server/rcon/thread/QueryThreadGs4.java
++++ b/src/main/java/net/minecraft/server/rcon/thread/QueryThreadGs4.java
+@@ -106,13 +106,32 @@ 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 [{}]", (Object)socketAddress);
+                     }
+@@ -147,31 +166,75 @@ 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);

patches/server/0306-Implement-PlayerPostRespawnEvent.patch

@@ -0,0 +1,48 @@
+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] Implement PlayerPostRespawnEvent
+
+
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 01cfa93571effead5498e766f6c7e254a5b13479..8e8a4ab377e3d42ba2927745aa903861549de10e 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
++++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -736,9 +736,14 @@ public abstract class PlayerList {
+ 
+         boolean flag2 = false;
+ 
++        // Paper start
++        boolean isBedSpawn = false;
++        boolean isRespawn = false;
++        // Paper end
++
+         // CraftBukkit start - fire PlayerRespawnEvent
+         if (location == null) {
+-            boolean isBedSpawn = false;
++            // boolean isBedSpawn = false; // Paper - moved up
+             ServerLevel worldserver1 = this.server.getLevel(entityplayer.getRespawnDimension());
+             if (worldserver1 != null) {
+                 Optional optional;
+@@ -790,6 +795,7 @@ public abstract class PlayerList {
+ 
+             location = respawnEvent.getRespawnLocation();
+             if (!flag) entityplayer.reset(); // SPIGOT-4785
++            isRespawn = true; // Paper
+         } else {
+             location.setWorld(worldserver.getWorld());
+         }
+@@ -849,6 +855,13 @@ public abstract class PlayerList {
+         if (entityplayer.connection.isDisconnected()) {
+             this.save(entityplayer);
+         }
++
++        // Paper start
++        if (isRespawn) {
++            cserver.getPluginManager().callEvent(new com.destroystokyo.paper.event.player.PlayerPostRespawnEvent(entityplayer.getBukkitEntity(), location, isBedSpawn));
++        }
++        // Paper end
++
+         // CraftBukkit end
+         return entityplayer1;
+     }

patches/server/0307-don-t-go-below-0-for-pickupDelay-breaks-picking-up-i.patch

@@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sun, 24 Mar 2019 18:09:20 -0400
+Subject: [PATCH] don't go below 0 for pickupDelay, breaks picking up items
+
+vanilla checks for == 0
+
+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 42b056d58146991b86de0690fce595716ee5455b..02bd99934066b35a3f4fd59370cdabf0640ee218 100644
+--- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
++++ b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+@@ -112,6 +112,7 @@ public class ItemEntity extends Entity {
+             // CraftBukkit start - Use wall time for pickup and despawn timers
+             int elapsedTicks = MinecraftServer.currentTick - this.lastTick;
+             if (this.pickupDelay != 32767) this.pickupDelay -= elapsedTicks;
++            this.pickupDelay = Math.max(0, this.pickupDelay); // Paper - don't go below 0
+             if (this.age != -32768) this.age += elapsedTicks;
+             this.lastTick = MinecraftServer.currentTick;
+             // CraftBukkit end
+@@ -198,6 +199,7 @@ public class ItemEntity extends Entity {
+         // CraftBukkit start - Use wall time for pickup and despawn timers
+         int elapsedTicks = MinecraftServer.currentTick - this.lastTick;
+         if (this.pickupDelay != 32767) this.pickupDelay -= elapsedTicks;
++        this.pickupDelay = Math.max(0, this.pickupDelay); // Paper - don't go below 0
+         if (this.age != -32768) this.age += elapsedTicks;
+         this.lastTick = MinecraftServer.currentTick;
+         // CraftBukkit end

patches/server/0308-Server-Tick-Events.patch

@@ -0,0 +1,31 @@
+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 1685f92acdf63decc6cd6b37957ca61212b43bbc..e56a03b04e510a510d9deb2a013900241471ac0f 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1309,6 +1309,7 @@ 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
+ 
+         ++this.tickCount;
+         this.tickChildren(shouldKeepTicking);
+@@ -1347,6 +1348,11 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             this.runAllTasks();
+         }
+         // Paper end
++        // Paper start
++        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
+         this.profiler.push("tallying");
+         long l = this.tickTimes[this.tickCount % 100] = Util.getNanos() - i;
+ 

patches/server/0309-PlayerDeathEvent-getItemsToKeep.patch

@@ -0,0 +1,77 @@
+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 6092167b282a99799c27937dfa1bef424a7e2a9e..5eafbf1fd9b0f54819c9b2d99803c07a1708ce02 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -798,6 +798,46 @@ public class ServerPlayer extends Player {
+         });
+     }
+ 
++    // Paper start - process inventory
++    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
++
+     @Override
+     public void die(DamageSource damageSource) {
+         this.gameEvent(GameEvent.ENTITY_DIE);
+@@ -881,7 +921,12 @@ 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 - replace logic
++            for (NonNullList<ItemStack> inv : this.getInventory().compartments) {
++                processKeep(event, inv);
++            }
++            processKeep(event, null);
++            // Paper end
+         }
+ 
+         this.setCamera(this); // Remove spectated target

patches/server/0310-Optimize-Captured-TileEntity-Lookup.patch

@@ -0,0 +1,30 @@
+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 TileEntity 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 35838b3c858f8dd3c3cb59fe1c4cc8d1d878ff83..9b3a86710d5ac63afee9293f0c2cb1e443c98020 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
++++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -898,9 +898,12 @@ 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 - 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
+         // CraftBukkit end
+         return this.isOutsideBuildHeight(blockposition) ? null : (!this.isClientSide && !io.papermc.paper.util.TickThread.isTickThread() ? null : this.getChunkAt(blockposition).getBlockEntity(blockposition, LevelChunk.EntityCreationType.IMMEDIATE)); // Paper - rewrite chunk system
+     }

patches/server/0311-Add-Heightmap-API.patch

@@ -0,0 +1,40 @@
+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 00cfc9abb31c7fada8a7e4a99850d5c9f5b71c96..951613887929026805dcb96986cbd9238686c500 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -221,6 +221,29 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+         return this.getHighestBlockYAt(x, z, org.bukkit.HeightMap.MOTION_BLOCKING);
+     }
+ 
++    // 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();

patches/server/0312-Mob-Spawner-API-Enhancements.patch

@@ -0,0 +1,102 @@
+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
+
+diff --git a/src/main/java/net/minecraft/world/level/BaseSpawner.java b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+index 2ae7b8d1129a3549c5ba6fe03455b0b0683c9c31..c58cd26ac15308d249f7d50fed530a6093091d36 100644
+--- a/src/main/java/net/minecraft/world/level/BaseSpawner.java
++++ b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+@@ -239,7 +239,13 @@ 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) {
+@@ -262,9 +268,15 @@ 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", 99)) {
++            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");
+         }
+ 
+@@ -281,9 +293,20 @@ 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 nbt
+         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 590d77470e979b331917aaa8cbc30a6513e385db..348c4e10480fe261d557a113e086324236239422 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftCreatureSpawner.java
++++ b/src/main/java/org/bukkit/craftbukkit/block/CraftCreatureSpawner.java
+@@ -116,4 +116,28 @@ public class CraftCreatureSpawner extends CraftBlockEntityState<SpawnerBlockEnti
+     public void setSpawnRange(int spawnRange) {
+         this.getSnapshot().getSpawner().spawnRange = spawnRange;
+     }
++
++    // 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.Registry.ENTITY_TYPE.getKey(net.minecraft.world.entity.EntityType.ITEM).toString());
++        entity.put("Item", item.save(new net.minecraft.nbt.CompoundTag()));
++        this.getSnapshot().getSpawner().setNextSpawnData(this.isPlaced() ? this.world.getHandle() : null, this.getPosition(), new net.minecraft.world.level.SpawnData(entity, java.util.Optional.empty()));
++    }
++    // Paper end
+ }

patches/server/0313-Fix-CB-call-to-changed-postToMainThread-method.patch

@@ -0,0 +1,19 @@
+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/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index a1e75d2c44e854fd7976caa58c8beb618f92e0a0..00316713c4f3d444a85b69f222d0b620974c5a27 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -511,7 +511,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+ 
+         Objects.requireNonNull(this.connection);
+         // CraftBukkit - Don't wait
+-        minecraftserver.wrapRunnable(networkmanager::handleDisconnection);
++        minecraftserver.scheduleOnMain(networkmanager::handleDisconnection); // Paper
+     }
+ 
+     private <T, R> CompletableFuture<R> filterTextPacket(T text, BiFunction<TextFilter, T, CompletableFuture<R>> filterer) {

patches/server/0314-Fix-sounds-when-item-frames-are-modified-MC-123450.patch

@@ -0,0 +1,20 @@
+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 b3f2e45186ed01a18b204a8d23ed57ffc6886703..880ca7cb3ebccc16949e24a0230b1f83887b653f 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
++++ b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+@@ -328,7 +328,7 @@ 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);
+         }
+ 

patches/server/0315-Implement-CraftBlockSoundGroup.patch

@@ -0,0 +1,72 @@
+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..c5b07ec346105d1b95c1c938ffca12a21642040c
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/block/CraftBlockSoundGroup.java
+@@ -0,0 +1,39 @@
++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.getBukkit(soundEffectType.getBreakSound());
++    }
++
++    @Override
++    public Sound getStepSound() {
++        return CraftSound.getBukkit(soundEffectType.getStepSound());
++    }
++
++    @Override
++    public Sound getPlaceSound() {
++        return CraftSound.getBukkit(soundEffectType.getPlaceSound());
++    }
++
++    @Override
++    public Sound getHitSound() {
++        return CraftSound.getBukkit(soundEffectType.getHitSound());
++    }
++
++    @Override
++    public Sound getFallSound() {
++        return CraftSound.getBukkit(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 13da02b84d7e748d61fdf5db01d92a8d8cd5c799..2e3b675dca8cec906d533141e158e5db6ae87042 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
++++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
+@@ -646,4 +646,16 @@ public class CraftBlock implements Block {
+ 
+         return iblockdata.canSurvive(world, this.position);
+     }
++
++    // 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
+ }

patches/server/0316-Configurable-Keep-Spawn-Loaded-range-per-world.patch

@@ -0,0 +1,231 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sat, 13 Sep 2014 23:14:43 -0400
+Subject: [PATCH] Configurable Keep Spawn Loaded range per world
+
+This lets you disable it for some worlds and lower it for others.
+
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index e56a03b04e510a510d9deb2a013900241471ac0f..41376a0aaa2da34ec3194d38c59a4ea2f353bd64 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -737,31 +737,34 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
+     // CraftBukkit start
+     public void prepareLevels(ChunkProgressListener worldloadlistener, ServerLevel worldserver) {
++        ServerChunkCache chunkproviderserver = worldserver.getChunkSource(); // Paper
+         // WorldServer worldserver = this.overworld();
+         this.forceTicks = true;
+         // CraftBukkit end
++        if (worldserver.getWorld().getKeepSpawnInMemory()) { // Paper
+ 
+         MinecraftServer.LOGGER.info("Preparing start region for dimension {}", worldserver.dimension().location());
+         BlockPos blockposition = worldserver.getSharedSpawnPos();
+ 
+         worldloadlistener.updateSpawnPos(new ChunkPos(blockposition));
+-        ServerChunkCache chunkproviderserver = worldserver.getChunkSource();
++        //ChunkProviderServer chunkproviderserver = worldserver.getChunkProvider(); // Paper - move up
+ 
+         chunkproviderserver.getLightEngine().setTaskPerBatch(500);
+         this.nextTickTime = Util.getMillis();
+-        // CraftBukkit start
+-        if (worldserver.getWorld().getKeepSpawnInMemory()) {
+-            chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(blockposition), 11, Unit.INSTANCE);
+-
+-            while (chunkproviderserver.getTickingGenerated() != 441) {
+-                // this.nextTickTime = SystemUtils.getMillis() + 10L;
+-                this.executeModerately();
+-            }
+-        }
++        // Paper start - configurable spawn reason
++        int radiusBlocks = worldserver.paperConfig().spawn.keepSpawnLoadedRange * 16;
++        int radiusChunks = radiusBlocks / 16 + ((radiusBlocks & 15) != 0 ? 1 : 0);
++        int totalChunks = ((radiusChunks) * 2 + 1);
++        totalChunks *= totalChunks;
++        worldloadlistener.setChunkRadius(radiusBlocks / 16);
++
++        worldserver.addTicketsForSpawn(radiusBlocks, blockposition);
++        // Paper end
+ 
+         // this.nextTickTime = SystemUtils.getMillis() + 10L;
+         this.executeModerately();
+         // Iterator iterator = this.levels.values().iterator();
++        }
+ 
+         if (true) {
+             ServerLevel worldserver1 = worldserver;
+@@ -784,7 +787,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         // this.nextTickTime = SystemUtils.getMillis() + 10L;
+         this.executeModerately();
+         // CraftBukkit end
+-        worldloadlistener.stop();
++        if (worldserver.getWorld().getKeepSpawnInMemory()) worldloadlistener.stop(); // Paper
+         chunkproviderserver.getLightEngine().setTaskPerBatch(5);
+         // CraftBukkit start
+         // this.updateMobSpawningFlags();
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 6ca2ea98531d28602905f0e68d368d0015a46dcd..0635f84d062872a9a6e38a9ba3fe71026661e651 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -64,6 +64,7 @@ import net.minecraft.network.protocol.game.ClientboundSoundEntityPacket;
+ import net.minecraft.network.protocol.game.ClientboundSoundPacket;
+ import net.minecraft.network.protocol.game.DebugPackets;
+ import net.minecraft.resources.ResourceKey;
++import io.papermc.paper.util.MCUtil;
+ import net.minecraft.server.MinecraftServer;
+ import net.minecraft.server.ServerScoreboard;
+ import net.minecraft.server.level.progress.ChunkProgressListener;
+@@ -1727,12 +1728,84 @@ public class ServerLevel extends Level implements WorldGenLevel {
+         return ((MapIndex) this.getServer().overworld().getDataStorage().computeIfAbsent(MapIndex::load, MapIndex::new, "idcounts")).getFreeAuxValueForMap();
+     }
+ 
++    // Paper start - helper function for configurable spawn radius
++    public void addTicketsForSpawn(int radiusInBlocks, BlockPos spawn) {
++        // In order to respect vanilla behavior, which is ensuring everything but the spawn border can tick, we add tickets
++        // with level 31 for the non-border spawn chunks
++        ServerChunkCache chunkproviderserver = this.getChunkSource();
++        int tickRadius = radiusInBlocks - 16;
++
++        // add ticking chunks
++        for (int x = -tickRadius; x <= tickRadius; x += 16) {
++            for (int z = -tickRadius; z <= tickRadius; z += 16) {
++                // radius of 2 will have the current chunk be level 31
++                chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, z)), 2, Unit.INSTANCE);
++            }
++        }
++
++        // add border chunks
++
++        // add border along x axis (including corner chunks)
++        for (int x = -radiusInBlocks; x <= radiusInBlocks; x += 16) {
++            // top
++            chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, radiusInBlocks)), 1, Unit.INSTANCE); // level 32
++            // bottom
++            chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, -radiusInBlocks)), 1, Unit.INSTANCE); // level 32
++        }
++
++        // add border along z axis (excluding corner chunks)
++        for (int z = -radiusInBlocks + 16; z < radiusInBlocks; z += 16) {
++            // right
++            chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(spawn.offset(radiusInBlocks, 0, z)), 1, Unit.INSTANCE); // level 32
++            // left
++            chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(spawn.offset(-radiusInBlocks, 0, z)), 1, Unit.INSTANCE); // level 32
++        }
++    }
++    public void removeTicketsForSpawn(int radiusInBlocks, BlockPos spawn) {
++        // In order to respect vanilla behavior, which is ensuring everything but the spawn border can tick, we added tickets
++        // with level 31 for the non-border spawn chunks
++        ServerChunkCache chunkproviderserver = this.getChunkSource();
++        int tickRadius = radiusInBlocks - 16;
++
++        // remove ticking chunks
++        for (int x = -tickRadius; x <= tickRadius; x += 16) {
++            for (int z = -tickRadius; z <= tickRadius; z += 16) {
++                // radius of 2 will have the current chunk be level 31
++                chunkproviderserver.removeRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, z)), 2, Unit.INSTANCE);
++            }
++        }
++
++        // remove border chunks
++
++        // remove border along x axis (including corner chunks)
++        for (int x = -radiusInBlocks; x <= radiusInBlocks; x += 16) {
++            // top
++            chunkproviderserver.removeRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, radiusInBlocks)), 1, Unit.INSTANCE); // level 32
++            // bottom
++            chunkproviderserver.removeRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, -radiusInBlocks)), 1, Unit.INSTANCE); // level 32
++        }
++
++        // remove border along z axis (excluding corner chunks)
++        for (int z = -radiusInBlocks + 16; z < radiusInBlocks; z += 16) {
++            // right
++            chunkproviderserver.removeRegionTicket(TicketType.START, new ChunkPos(spawn.offset(radiusInBlocks, 0, z)), 1, Unit.INSTANCE); // level 32
++            // left
++            chunkproviderserver.removeRegionTicket(TicketType.START, new ChunkPos(spawn.offset(-radiusInBlocks, 0, z)), 1, Unit.INSTANCE); // level 32
++        }
++    }
++    // Paper end
++
+     public void setDefaultSpawnPos(BlockPos pos, float angle) {
+-        ChunkPos chunkcoordintpair = new ChunkPos(new BlockPos(this.levelData.getXSpawn(), 0, this.levelData.getZSpawn()));
++        // Paper - configurable spawn radius
++        BlockPos prevSpawn = this.getSharedSpawnPos();
++        //ChunkCoordIntPair chunkcoordintpair = new ChunkCoordIntPair(new BlockPosition(this.worldData.a(), 0, this.worldData.c()));
+ 
+         this.levelData.setSpawn(pos, angle);
+-        this.getChunkSource().removeRegionTicket(TicketType.START, chunkcoordintpair, 11, Unit.INSTANCE);
+-        this.getChunkSource().addRegionTicket(TicketType.START, new ChunkPos(pos), 11, Unit.INSTANCE);
++        if (this.keepSpawnInMemory) {
++            // if this keepSpawnInMemory is false a plugin has already removed our tickets, do not re-add
++            this.removeTicketsForSpawn(this.paperConfig().spawn.keepSpawnLoadedRange * 16, prevSpawn);
++            this.addTicketsForSpawn(this.paperConfig().spawn.keepSpawnLoadedRange * 16, pos);
++        }
+         this.getServer().getPlayerList().broadcastAll(new ClientboundSetDefaultSpawnPositionPacket(pos, angle));
+     }
+ 
+diff --git a/src/main/java/net/minecraft/server/level/progress/ChunkProgressListener.java b/src/main/java/net/minecraft/server/level/progress/ChunkProgressListener.java
+index 1b565b2809c2d367e21971c5154f35c9763995e6..b0f899835ded29aff108d1674bf4a1a6c89693db 100644
+--- a/src/main/java/net/minecraft/server/level/progress/ChunkProgressListener.java
++++ b/src/main/java/net/minecraft/server/level/progress/ChunkProgressListener.java
+@@ -12,4 +12,6 @@ public interface ChunkProgressListener {
+     void start();
+ 
+     void stop();
++
++    void setChunkRadius(int radius); // Paper - allow changing chunk radius
+ }
+diff --git a/src/main/java/net/minecraft/server/level/progress/LoggerChunkProgressListener.java b/src/main/java/net/minecraft/server/level/progress/LoggerChunkProgressListener.java
+index 4d2348df25410a0b5364eec066880326d6667dad..286aad3205ef8a9e21a47ef07893844fe857556a 100644
+--- a/src/main/java/net/minecraft/server/level/progress/LoggerChunkProgressListener.java
++++ b/src/main/java/net/minecraft/server/level/progress/LoggerChunkProgressListener.java
+@@ -11,12 +11,19 @@ import org.slf4j.Logger;
+ 
+ public class LoggerChunkProgressListener implements ChunkProgressListener {
+     private static final Logger LOGGER = LogUtils.getLogger();
+-    private final int maxCount;
++    private int maxCount;// Paper - remove final
+     private int count;
+     private long startTime;
+     private long nextTickTime = Long.MAX_VALUE;
+ 
+     public LoggerChunkProgressListener(int radius) {
++        // Paper start - Allow changing radius later for configurable spawn patch
++        this.setChunkRadius(radius); // Move to method
++    }
++
++    @Override
++    public void setChunkRadius(int radius) {
++        // Paper end
+         int i = radius * 2 + 1;
+         this.maxCount = i * i;
+     }
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index 951613887929026805dcb96986cbd9238686c500..31a4424670bbf631845ab0ec61e523d4aeea20f6 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -1345,15 +1345,21 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+ 
+     @Override
+     public void setKeepSpawnInMemory(boolean keepLoaded) {
+-        world.keepSpawnInMemory = keepLoaded;
++        // Paper start - Configurable spawn radius
++        if (keepLoaded == world.keepSpawnInMemory) {
++            // do nothing, nothing has changed
++            return;
++        }
++        this.world.keepSpawnInMemory = keepLoaded;
+         // Grab the worlds spawn chunk
+         BlockPos chunkcoordinates = this.world.getSharedSpawnPos();
+         if (keepLoaded) {
+-            this.world.getChunkSource().addRegionTicket(TicketType.START, new ChunkPos(chunkcoordinates), 11, Unit.INSTANCE);
++            this.world.addTicketsForSpawn(this.world.paperConfig().spawn.keepSpawnLoadedRange * 16, chunkcoordinates);
+         } else {
+-            // TODO: doesn't work well if spawn changed....
+-            this.world.getChunkSource().removeRegionTicket(TicketType.START, new ChunkPos(chunkcoordinates), 11, Unit.INSTANCE);
++            // TODO: doesn't work well if spawn changed.... // Paper - resolved
++            this.world.removeTicketsForSpawn(this.world.paperConfig().spawn.keepSpawnLoadedRange * 16, chunkcoordinates);
+         }
++        // Paper end
+     }
+ 
+     @Override

patches/server/0317-Allow-Saving-of-Oversized-Chunks.patch

@@ -0,0 +1,251 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Fri, 15 Feb 2019 01:08:19 -0500
+Subject: [PATCH] Allow Saving of Oversized Chunks
+
+Note 1.17 update: With 1.17, Entities are no longer stored in chunk slices, so this needs updating!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+The Minecraft World Region File format has a hard cap of 1MB per chunk.
+This is due to the fact that the header of the file format only allocates
+a single byte for sector count, meaning a maximum of 256 sectors, at 4k per sector.
+
+This limit can be reached fairly easily with books, resulting in the chunk being unable
+to save to the world. Worse off, is that nothing printed when this occured, and silently
+performed a chunk rollback on next load.
+
+This leads to security risk with duplication and is being actively exploited.
+
+This patch catches the too large scenario, falls back and moves any large Entity
+or Tile Entity into a new compound, and this compound is saved into a different file.
+
+On Chunk Load, we check for oversized status, and if so, we load the extra file and
+merge the Entities and Tile Entities from the oversized chunk back into the level to
+then be loaded as normal.
+
+Once a chunk is returned back to normal size, the oversized flag will clear, and no
+extra data file will exist.
+
+This fix maintains compatability with all existing Anvil Region Format tools as it
+does not alter the save format. They will just not know about the extra entities.
+
+This fix also maintains compatability if someone switches server jars to one without
+this fix, as the data will remain in the oversized file. Once the server returns
+to a jar with this fix, the data will be restored.
+
+diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
+index ddcc212ba83d9365adb842b3d3ced64e3d7dd155..584985272a02eb5b61a22cf2404fbd97a55a3358 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
++++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
+@@ -18,8 +18,12 @@ import java.nio.file.LinkOption;
+ import java.nio.file.Path;
+ import java.nio.file.StandardCopyOption;
+ import java.nio.file.StandardOpenOption;
++import java.util.zip.InflaterInputStream; // Paper
++
+ import javax.annotation.Nullable;
+ import net.minecraft.Util;
++import net.minecraft.nbt.CompoundTag;
++import net.minecraft.nbt.NbtIo;
+ import net.minecraft.world.level.ChunkPos;
+ import org.slf4j.Logger;
+ 
+@@ -45,6 +49,7 @@ public class RegionFile implements AutoCloseable {
+     @VisibleForTesting
+     protected final RegionBitmap usedSectors;
+     public final java.util.concurrent.locks.ReentrantLock fileLock = new java.util.concurrent.locks.ReentrantLock(true); // Paper
++    public final Path regionFile; // Paper
+ 
+     public RegionFile(Path file, Path directory, boolean dsync) throws IOException {
+         this(file, directory, RegionFileVersion.VERSION_DEFLATE, dsync);
+@@ -52,6 +57,8 @@ public class RegionFile implements AutoCloseable {
+ 
+     public RegionFile(Path file, Path directory, RegionFileVersion outputChunkStreamVersion, boolean dsync) throws IOException {
+         this.header = ByteBuffer.allocateDirect(8192);
++        this.regionFile = file; // Paper
++        initOversizedState(); // Paper
+         this.usedSectors = new RegionBitmap();
+         this.version = outputChunkStreamVersion;
+         if (!Files.isDirectory(directory, new LinkOption[0])) {
+@@ -430,6 +437,74 @@ public class RegionFile implements AutoCloseable {
+ 
+     }
+ 
++    // Paper start
++    private final byte[] oversized = new byte[1024];
++    private int oversizedCount = 0;
++
++    private synchronized void initOversizedState() throws IOException {
++        Path metaFile = getOversizedMetaFile();
++        if (Files.exists(metaFile)) {
++            final byte[] read = java.nio.file.Files.readAllBytes(metaFile);
++            System.arraycopy(read, 0, oversized, 0, oversized.length);
++            for (byte temp : oversized) {
++                oversizedCount += temp;
++            }
++        }
++    }
++
++    private static int getChunkIndex(int x, int z) {
++        return (x & 31) + (z & 31) * 32;
++    }
++    synchronized boolean isOversized(int x, int z) {
++        return this.oversized[getChunkIndex(x, z)] == 1;
++    }
++    synchronized void setOversized(int x, int z, boolean oversized) throws IOException {
++        final int offset = getChunkIndex(x, z);
++        boolean previous = this.oversized[offset] == 1;
++        this.oversized[offset] = (byte) (oversized ? 1 : 0);
++        if (!previous && oversized) {
++            oversizedCount++;
++        } else if (!oversized && previous) {
++            oversizedCount--;
++        }
++        if (previous && !oversized) {
++            Path oversizedFile = getOversizedFile(x, z);
++            if (Files.exists(oversizedFile)) {
++                Files.delete(oversizedFile);
++            }
++        }
++        if (oversizedCount > 0) {
++            if (previous != oversized) {
++                writeOversizedMeta();
++            }
++        } else if (previous) {
++            Path oversizedMetaFile = getOversizedMetaFile();
++            if (Files.exists(oversizedMetaFile)) {
++                Files.delete(oversizedMetaFile);
++            }
++        }
++    }
++
++    private void writeOversizedMeta() throws IOException {
++        java.nio.file.Files.write(getOversizedMetaFile(), oversized);
++    }
++
++    private Path getOversizedMetaFile() {
++        return this.regionFile.getParent().resolve(this.regionFile.getFileName().toString().replaceAll("\\.mca$", "") + ".oversized.nbt");
++    }
++
++    private Path getOversizedFile(int x, int z) {
++        return this.regionFile.getParent().resolve(this.regionFile.getFileName().toString().replaceAll("\\.mca$", "") + "_oversized_" + x + "_" + z + ".nbt");
++    }
++
++    synchronized CompoundTag getOversizedData(int x, int z) throws IOException {
++        Path file = getOversizedFile(x, z);
++        try (DataInputStream out = new DataInputStream(new java.io.BufferedInputStream(new InflaterInputStream(Files.newInputStream(file))))) {
++            return NbtIo.read((java.io.DataInput) out);
++        }
++
++    }
++    // Paper end
+     private class ChunkBuffer extends ByteArrayOutputStream {
+ 
+         private final ChunkPos pos;
+diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
+index 1a1ade7538263f4c1a91eb122086a150af3d86ba..8f729134d8f024678f3f5927059791e28ccb5b90 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
++++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
+@@ -11,8 +11,10 @@ import java.nio.file.Path;
+ import javax.annotation.Nullable;
+ import net.minecraft.FileUtil;
+ import net.minecraft.nbt.CompoundTag;
++import net.minecraft.nbt.ListTag;
+ import net.minecraft.nbt.NbtIo;
+ import net.minecraft.nbt.StreamTagVisitor;
++import net.minecraft.nbt.Tag;
+ import net.minecraft.util.ExceptionCollector;
+ import net.minecraft.world.level.ChunkPos;
+ 
+@@ -79,6 +81,71 @@ public class RegionFileStorage implements AutoCloseable {
+         }
+     }
+ 
++    // Paper start
++    private static void printOversizedLog(String msg, Path file, int x, int z) {
++        org.apache.logging.log4j.LogManager.getLogger().fatal(msg + " (" + file.toString().replaceAll(".+[\\\\/]", "") + " - " + x + "," + z + ") Go clean it up to remove this message. /minecraft:tp " + (x<<4)+" 128 "+(z<<4) + " - DO NOT REPORT THIS TO PAPER - You may ask for help on Discord, but do not file an issue. These error messages can not be removed.");
++    }
++
++    private static final int DEFAULT_SIZE_THRESHOLD = 1024 * 8;
++    private static final int OVERZEALOUS_TOTAL_THRESHOLD = 1024 * 64;
++    private static final int OVERZEALOUS_THRESHOLD = 1024;
++    private static int SIZE_THRESHOLD = DEFAULT_SIZE_THRESHOLD;
++    private static void resetFilterThresholds() {
++        SIZE_THRESHOLD = Math.max(1024 * 4, Integer.getInteger("Paper.FilterThreshhold", DEFAULT_SIZE_THRESHOLD));
++    }
++    static {
++        resetFilterThresholds();
++    }
++
++    static boolean isOverzealous() {
++        return SIZE_THRESHOLD == OVERZEALOUS_THRESHOLD;
++    }
++
++
++    private static CompoundTag readOversizedChunk(RegionFile regionfile, ChunkPos chunkCoordinate) throws IOException {
++        synchronized (regionfile) {
++            try (DataInputStream datainputstream = regionfile.getChunkDataInputStream(chunkCoordinate)) {
++                CompoundTag oversizedData = regionfile.getOversizedData(chunkCoordinate.x, chunkCoordinate.z);
++                CompoundTag chunk = NbtIo.read((DataInput) datainputstream);
++                if (oversizedData == null) {
++                    return chunk;
++                }
++                CompoundTag oversizedLevel = oversizedData.getCompound("Level");
++
++                mergeChunkList(chunk.getCompound("Level"), oversizedLevel, "Entities", "Entities");
++                mergeChunkList(chunk.getCompound("Level"), oversizedLevel, "TileEntities", "TileEntities");
++
++                return chunk;
++            } catch (Throwable throwable) {
++                throwable.printStackTrace();
++                throw throwable;
++            }
++        }
++    }
++
++    private static void mergeChunkList(CompoundTag level, CompoundTag oversizedLevel, String key, String oversizedKey) {
++        ListTag levelList = level.getList(key, 10);
++        ListTag oversizedList = oversizedLevel.getList(oversizedKey, 10);
++
++        if (!oversizedList.isEmpty()) {
++            levelList.addAll(oversizedList);
++            level.put(key, levelList);
++        }
++    }
++
++    private static int getNBTSize(Tag nbtBase) {
++        DataOutputStream test = new DataOutputStream(new org.apache.commons.io.output.NullOutputStream());
++        try {
++            nbtBase.write(test);
++            return test.size();
++        } catch (IOException e) {
++            e.printStackTrace();
++            return 0;
++        }
++    }
++
++    // Paper End
++
+     @Nullable
+     public CompoundTag read(ChunkPos pos) throws IOException {
+         // CraftBukkit start - SPIGOT-5680: There's no good reason to preemptively create files on read, save that for writing
+@@ -90,6 +157,12 @@ public class RegionFileStorage implements AutoCloseable {
+         try { // Paper
+         DataInputStream datainputstream = regionfile.getChunkDataInputStream(pos);
+ 
++        // Paper start
++        if (regionfile.isOversized(pos.x, pos.z)) {
++            printOversizedLog("Loading Oversized Chunk!", regionfile.regionFile, pos.x, pos.z);
++            return readOversizedChunk(regionfile, pos);
++        }
++        // Paper end
+         CompoundTag nbttagcompound;
+         label43:
+         {
+@@ -176,6 +249,7 @@ public class RegionFileStorage implements AutoCloseable {
+ 
+             try {
+                 NbtIo.write(nbt, (DataOutput) dataoutputstream);
++                regionfile.setOversized(pos.x, pos.z, false); // Paper - We don't do this anymore, mojang stores differently, but clear old meta flag if it exists to get rid of our own meta file once last oversized is gone
+             } catch (Throwable throwable) {
+                 if (dataoutputstream != null) {
+                     try {

patches/server/0318-Expose-the-internal-current-tick.patch

@@ -0,0 +1,21 @@
+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 9d778f076512969d8de93256dfde0ebbdb0433ae..9b5d3dbf302a44d6ed774c8397117e7a6231b2f9 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -2687,5 +2687,10 @@ public final class CraftServer implements Server {
+         profile.getProperties().putAll(((CraftPlayer)player).getHandle().getGameProfile().getProperties());
+         return new com.destroystokyo.paper.profile.CraftPlayerProfile(profile);
+     }
++
++    @Override
++    public int getCurrentTick() {
++        return net.minecraft.server.MinecraftServer.currentTick;
++    }
+     // Paper end
+ }

patches/server/0319-Fix-World-isChunkGenerated-calls.patch

@@ -0,0 +1,246 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Sat, 15 Jun 2019 08:54:33 -0700
+Subject: [PATCH] Fix World#isChunkGenerated calls
+
+Optimize World#loadChunk() too
+This patch also adds a chunk status cache on region files (note that
+its only purpose is to cache the status on DISK)
+
+diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
+index 23bbd70dd2dd487caf972c2b1a6c85a1caa3fbcd..7c9b73136b4fc5fda96317001eb8a32245b9768a 100644
+--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
++++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
+@@ -671,9 +671,13 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+     // Paper end
+ 
+     private CompletableFuture<Optional<CompoundTag>> readChunk(ChunkPos chunkPos) {
+-        return this.read(chunkPos).thenApplyAsync((optional) -> {
+-            return optional.map((nbttagcompound) -> this.upgradeChunkTag(nbttagcompound, chunkPos)); // CraftBukkit
+-        }, Util.backgroundExecutor());
++        // Paper start - Cache chunk status on disk
++        try {
++            return CompletableFuture.completedFuture(Optional.ofNullable(this.readConvertChunkSync(chunkPos)));
++        } catch (Throwable thr) {
++            return CompletableFuture.failedFuture(thr);
++        }
++        // Paper end - Cache chunk status on disk
+     }
+ 
+     // CraftBukkit start
+@@ -682,6 +686,63 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+         // CraftBukkit end
+     }
+ 
++    // Paper start - Cache chunk status on disk
++    @Nullable
++    public CompoundTag readConvertChunkSync(ChunkPos pos) throws IOException {
++        CompoundTag nbttagcompound = this.readSync(pos);
++        // Paper start - Cache chunk status on disk
++        if (nbttagcompound == null) {
++            return null;
++        }
++
++        nbttagcompound = this.upgradeChunkTag(nbttagcompound, pos); // CraftBukkit
++        if (nbttagcompound == null) {
++            return null;
++        }
++
++        this.updateChunkStatusOnDisk(pos, nbttagcompound);
++
++        return nbttagcompound;
++        // Paper end
++    }
++
++    // Paper start - chunk status cache "api"
++    public ChunkStatus getChunkStatusOnDiskIfCached(ChunkPos chunkPos) {
++        net.minecraft.world.level.chunk.storage.RegionFile regionFile = regionFileCache.getRegionFileIfLoaded(chunkPos);
++
++        return regionFile == null ? null : regionFile.getStatusIfCached(chunkPos.x, chunkPos.z);
++    }
++
++    public ChunkStatus getChunkStatusOnDisk(ChunkPos chunkPos) throws IOException {
++        net.minecraft.world.level.chunk.storage.RegionFile regionFile = regionFileCache.getRegionFile(chunkPos, true);
++
++        if (regionFile == null || !regionFileCache.chunkExists(chunkPos)) {
++            return null;
++        }
++
++        ChunkStatus status = regionFile.getStatusIfCached(chunkPos.x, chunkPos.z);
++
++        if (status != null) {
++            return status;
++        }
++
++        this.readChunk(chunkPos);
++
++        return regionFile.getStatusIfCached(chunkPos.x, chunkPos.z);
++    }
++
++    public void updateChunkStatusOnDisk(ChunkPos chunkPos, @Nullable CompoundTag compound) throws IOException {
++        net.minecraft.world.level.chunk.storage.RegionFile regionFile = regionFileCache.getRegionFile(chunkPos, false);
++
++        regionFile.setStatus(chunkPos.x, chunkPos.z, ChunkSerializer.getStatus(compound));
++    }
++
++    public ChunkAccess getUnloadingChunk(int chunkX, int chunkZ) {
++        ChunkHolder chunkHolder = io.papermc.paper.chunk.system.ChunkSystem.getUnloadingChunkHolder(this.level, chunkX, chunkZ);
++        return chunkHolder == null ? null : chunkHolder.getAvailableChunkNow();
++    }
++    // Paper end
++
+     boolean anyPlayerCloseEnoughForSpawning(ChunkPos pos) {
+         // Spigot start
+         return this.anyPlayerCloseEnoughForSpawning(pos, false);
+diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
+index 584985272a02eb5b61a22cf2404fbd97a55a3358..cda87a66fe80bf910f629c64e36c1fecbad81d77 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
++++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
+@@ -51,6 +51,30 @@ public class RegionFile implements AutoCloseable {
+     public final java.util.concurrent.locks.ReentrantLock fileLock = new java.util.concurrent.locks.ReentrantLock(true); // Paper
+     public final Path regionFile; // Paper
+ 
++    // Paper start - Cache chunk status
++    private final net.minecraft.world.level.chunk.ChunkStatus[] statuses = new net.minecraft.world.level.chunk.ChunkStatus[32 * 32];
++
++    private boolean closed;
++
++    // invoked on write/read
++    public void setStatus(int x, int z, net.minecraft.world.level.chunk.ChunkStatus status) {
++        if (this.closed) {
++            // We've used an invalid region file.
++            throw new IllegalStateException("RegionFile is closed");
++        }
++        this.statuses[getChunkLocation(x, z)] = status;
++    }
++
++    public net.minecraft.world.level.chunk.ChunkStatus getStatusIfCached(int x, int z) {
++        if (this.closed) {
++            // We've used an invalid region file.
++            throw new IllegalStateException("RegionFile is closed");
++        }
++        final int location = getChunkLocation(x, z);
++        return this.statuses[location];
++    }
++    // Paper end
++
+     public RegionFile(Path file, Path directory, boolean dsync) throws IOException {
+         this(file, directory, RegionFileVersion.VERSION_DEFLATE, dsync);
+     }
+@@ -398,6 +422,7 @@ public class RegionFile implements AutoCloseable {
+         return this.getOffset(pos) != 0;
+     }
+ 
++    private static int getChunkLocation(int x, int z) { return (x & 31) + (z & 31) * 32; } // Paper - OBFHELPER - sort of, mirror of logic below
+     private static int getOffsetIndex(ChunkPos pos) {
+         return pos.getRegionLocalX() + pos.getRegionLocalZ() * 32;
+     }
+@@ -408,6 +433,7 @@ public class RegionFile implements AutoCloseable {
+         synchronized (this) {
+         try {
+         // Paper end
++        this.closed = true; // Paper
+         try {
+             this.padToFullSector();
+         } finally {
+diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
+index 8f729134d8f024678f3f5927059791e28ccb5b90..b294ef87fb93e7f4651dc04128124f297575860d 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
++++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
+@@ -249,6 +249,7 @@ public class RegionFileStorage implements AutoCloseable {
+ 
+             try {
+                 NbtIo.write(nbt, (DataOutput) dataoutputstream);
++                regionfile.setStatus(pos.x, pos.z, ChunkSerializer.getStatus(nbt)); // Paper - cache status on disk
+                 regionfile.setOversized(pos.x, pos.z, false); // Paper - We don't do this anymore, mojang stores differently, but clear old meta flag if it exists to get rid of our own meta file once last oversized is gone
+             } catch (Throwable throwable) {
+                 if (dataoutputstream != null) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index 31a4424670bbf631845ab0ec61e523d4aeea20f6..cef2d2494268c968dc8d26f9d5d0ee68a4ad465c 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -298,9 +298,23 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+ 
+     @Override
+     public boolean isChunkGenerated(int x, int z) {
++        // Paper start - Fix this method
++        if (!Bukkit.isPrimaryThread()) {
++            return java.util.concurrent.CompletableFuture.supplyAsync(() -> {
++                return CraftWorld.this.isChunkGenerated(x, z);
++            }, world.getChunkSource().mainThreadProcessor).join();
++        }
++        ChunkAccess chunk = world.getChunkSource().getChunkAtImmediately(x, z);
++        if (chunk == null) {
++            chunk = world.getChunkSource().chunkMap.getUnloadingChunk(x, z);
++        }
++        if (chunk != null) {
++            return chunk instanceof ImposterProtoChunk || chunk instanceof net.minecraft.world.level.chunk.LevelChunk;
++        }
+         try {
+-            return this.isChunkLoaded(x, z) || this.world.getChunkSource().chunkMap.read(new ChunkPos(x, z)).get().isPresent();
+-        } catch (InterruptedException | ExecutionException ex) {
++            return world.getChunkSource().chunkMap.getChunkStatusOnDisk(new ChunkPos(x, z)) == ChunkStatus.FULL;
++            // Paper end
++        } catch (IOException ex) {
+             throw new RuntimeException(ex);
+         }
+     }
+@@ -414,20 +428,48 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+     @Override
+     public boolean loadChunk(int x, int z, boolean generate) {
+         org.spigotmc.AsyncCatcher.catchOp("chunk load"); // Spigot
+-        ChunkAccess chunk = this.world.getChunkSource().getChunk(x, z, generate || isChunkGenerated(x, z) ? ChunkStatus.FULL : ChunkStatus.EMPTY, true); // Paper
++        // Paper start - Optimize this method
++        ChunkPos chunkPos = new ChunkPos(x, z);
+ 
+-        // If generate = false, but the chunk already exists, we will get this back.
+-        if (chunk instanceof ImposterProtoChunk) {
+-            // We then cycle through again to get the full chunk immediately, rather than after the ticket addition
+-            chunk = this.world.getChunkSource().getChunk(x, z, ChunkStatus.FULL, true);
+-        }
++        if (!generate) {
++            ChunkAccess immediate = world.getChunkSource().getChunkAtImmediately(x, z);
++            if (immediate == null) {
++                immediate = world.getChunkSource().chunkMap.getUnloadingChunk(x, z);
++            }
++            if (immediate != null) {
++                if (!(immediate instanceof ImposterProtoChunk) && !(immediate instanceof net.minecraft.world.level.chunk.LevelChunk)) {
++                    return false; // not full status
++                }
++                world.getChunkSource().addRegionTicket(TicketType.PLUGIN, chunkPos, 1, Unit.INSTANCE);
++                world.getChunk(x, z); // make sure we're at ticket level 32 or lower
++                return true;
++            }
+ 
+-        if (chunk instanceof net.minecraft.world.level.chunk.LevelChunk) {
+-            this.world.getChunkSource().addRegionTicket(TicketType.PLUGIN, new ChunkPos(x, z), 1, Unit.INSTANCE);
+-            return true;
++            net.minecraft.world.level.chunk.storage.RegionFile file;
++            try {
++                file = world.getChunkSource().chunkMap.regionFileCache.getRegionFile(chunkPos, false);
++            } catch (IOException ex) {
++                throw new RuntimeException(ex);
++            }
++
++            ChunkStatus status = file.getStatusIfCached(x, z);
++            if (!file.hasChunk(chunkPos) || (status != null && status != ChunkStatus.FULL)) {
++                return false;
++            }
++
++            ChunkAccess chunk = world.getChunkSource().getChunk(x, z, ChunkStatus.EMPTY, true);
++            if (!(chunk instanceof ImposterProtoChunk) && !(chunk instanceof net.minecraft.world.level.chunk.LevelChunk)) {
++                return false;
++            }
++
++            // fall through to load
++            // we do this so we do not re-read the chunk data on disk
+         }
+ 
+-        return false;
++        world.getChunkSource().addRegionTicket(TicketType.PLUGIN, chunkPos, 1, Unit.INSTANCE);
++        world.getChunkSource().getChunk(x, z, ChunkStatus.FULL, true);
++        return true;
++        // Paper end
+     }
+ 
+     @Override

patches/server/0320-Show-blockstate-location-if-we-failed-to-read-it.patch

@@ -0,0 +1,33 @@
+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 a76cce199acdcecfdd8b998ec08974c2ed0751cf..87c25170fbe8b0591d452612496ee1a627138de7 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockEntityState.java
++++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockEntityState.java
+@@ -18,6 +18,7 @@ public class CraftBlockEntityState<T extends BlockEntity> extends CraftBlockStat
+ 
+         this.tileEntity = tileEntity;
+ 
++        try { // Paper - show location on failure
+         // Paper start
+         this.snapshotDisabled = DISABLE_SNAPSHOT;
+         if (DISABLE_SNAPSHOT) {
+@@ -30,6 +31,14 @@ public class CraftBlockEntityState<T extends BlockEntity> extends CraftBlockStat
+             this.load(this.snapshot);
+         }
+         // Paper end
++        // Paper start - show location on failure
++        } 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
+     }
+ 
+     public void refreshSnapshot() {

patches/server/0321-Only-count-Natural-Spawned-mobs-towards-natural-spaw.patch

@@ -0,0 +1,36 @@
+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 c3d6b904f1310c93a3d5c1e5e3fab2f3476f5a48..29dac07176eb99517c9cddbe012636908c3603fe 100644
+--- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java
++++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
+@@ -88,6 +88,13 @@ 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
+                 BlockPos blockposition = entity.blockPosition();
+ 
+                 chunkSource.query(ChunkPos.asLong(blockposition), (chunk) -> {

patches/server/0322-Configurable-projectile-relative-velocity.patch

@@ -0,0 +1,39 @@
+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 b0caf14a196cd8c3a02d8e931a08857173ffb4da..3eb33d83b9cfa6ac87876a6343c88ac992b60374 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
++++ b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
+@@ -162,7 +162,7 @@ public abstract class Projectile extends Entity {
+         this.shoot((double) f5, (double) f6, (double) f7, speed, divergence);
+         Vec3 vec3d = shooter.getDeltaMovement();
+ 
+-        this.setDeltaMovement(this.getDeltaMovement().add(vec3d.x, shooter.isOnGround() ? 0.0D : vec3d.y, vec3d.z));
++        if (!shooter.level.paperConfig().misc.disableRelativeProjectileVelocity) this.setDeltaMovement(this.getDeltaMovement().add(vec3d.x, shooter.isOnGround() ? 0.0D : vec3d.y, vec3d.z)); // Paper - allow disabling relative velocity
+     }
+ 
+     // CraftBukkit start - call projectile hit event

patches/server/0323-offset-item-frame-ticking.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: kickash32 <kickash32@gmail.com>
+Date: Tue, 30 Jul 2019 03:17:16 +0500
+Subject: [PATCH] offset item frame ticking
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/decoration/HangingEntity.java b/src/main/java/net/minecraft/world/entity/decoration/HangingEntity.java
+index 1a48108d98f89c4f2485424e6ddfadf152faddf9..334a47b5e0d205c57dfcbb17168cbd3f21d15606 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/HangingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/decoration/HangingEntity.java
+@@ -38,7 +38,7 @@ public abstract class HangingEntity extends Entity {
+     protected static final Predicate<Entity> HANGING_ENTITY = (entity) -> {
+         return entity instanceof HangingEntity;
+     };
+-    private int checkInterval;
++    private int checkInterval; { this.checkInterval = this.getId() % this.level.spigotConfig.hangingTickFrequency; } // Paper
+     public BlockPos pos;
+     protected Direction direction;
+ 

patches/server/0324-Fix-MC-158900.patch

@@ -0,0 +1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Tue, 13 Aug 2019 06:35:17 -0700
+Subject: [PATCH] Fix MC-158900
+
+The problem was we were checking isExpired() on the entry, but if it
+was expired at that point, then it would be null.
+
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 8e8a4ab377e3d42ba2927745aa903861549de10e..4b1a900ce1531526b91b01217f291bc10526956b 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
++++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -620,8 +620,10 @@ public abstract class PlayerList {
+         Player player = entity.getBukkitEntity();
+         PlayerLoginEvent event = new PlayerLoginEvent(player, loginlistener.connection.hostname, ((java.net.InetSocketAddress) socketaddress).getAddress(), ((java.net.InetSocketAddress) loginlistener.connection.getRawAddress()).getAddress());
+ 
+-        if (this.getBans().isBanned(gameprofile) && !this.getBans().get(gameprofile).hasExpired()) {
+-            UserBanListEntry gameprofilebanentry = (UserBanListEntry) this.bans.get(gameprofile);
++        // Paper start - Fix MC-158900
++        UserBanListEntry gameprofilebanentry;
++        if (getBans().isBanned(gameprofile) && (gameprofilebanentry = getBans().get(gameprofile)) != null) {
++            // Paper end
+ 
+             ichatmutablecomponent = Component.translatable("multiplayer.disconnect.banned.reason", gameprofilebanentry.getReason());
+             if (gameprofilebanentry.getExpires() != null) {

patches/server/0325-Prevent-consuming-the-wrong-itemstack.patch

@@ -0,0 +1,45 @@
+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 3ff18ddb1d4b36fcfd97c9b29f2ecdcb4958916e..399c34b2837f2b54b452c866c524c51ba813fcc0 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -3649,9 +3649,14 @@ public abstract class LivingEntity extends Entity {
+     }
+ 
+     public void startUsingItem(InteractionHand hand) {
++        // Paper start - forwarder to method with forceUpdate parameter
++        this.startUsingItem(hand, false);
++    }
++    public void startUsingItem(InteractionHand hand, boolean forceUpdate) {
++        // Paper end
+         ItemStack itemstack = this.getItemInHand(hand);
+ 
+-        if (!itemstack.isEmpty() && !this.isUsingItem()) {
++        if (!itemstack.isEmpty() && !this.isUsingItem() || forceUpdate) { // Paper use override flag
+             this.useItem = itemstack;
+             this.useItemRemaining = itemstack.getUseDuration();
+             if (!this.level.isClientSide) {
+@@ -3731,6 +3736,7 @@ public abstract class LivingEntity extends Entity {
+                 this.releaseUsingItem();
+             } else {
+                 if (!this.useItem.isEmpty() && this.isUsingItem()) {
++                this.startUsingItem(this.getUsedItemHand(), true); // Paper
+                     this.triggerItemUseEffects(this.useItem, 16);
+                     // CraftBukkit start - fire PlayerItemConsumeEvent
+                     ItemStack itemstack;
+@@ -3766,8 +3772,8 @@ public abstract class LivingEntity extends Entity {
+                     }
+ 
+                     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

patches/server/0326-Dont-send-unnecessary-sign-update.patch

@@ -0,0 +1,18 @@
+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/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 00316713c4f3d444a85b69f222d0b620974c5a27..c6ad5963540b5f51776ba52eefdf7d5be3475906 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -3214,6 +3214,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+ 
+             if (!tileentitysign.isEditable() || !this.player.getUUID().equals(tileentitysign.getPlayerWhoMayEdit())) {
+                 ServerGamePacketListenerImpl.LOGGER.warn("Player {} just tried to change non-editable sign", this.player.getName().getString());
++                if (this.player.distanceToSqr(blockposition.getX(), blockposition.getY(), blockposition.getZ()) < 32 * 32) // Paper
+                 this.send(tileentity.getUpdatePacket()); // CraftBukkit
+                 return;
+             }

patches/server/0327-Add-option-to-disable-pillager-patrols.patch

@@ -0,0 +1,18 @@
+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 65d9211b812995869e58900a2873583658122312..e5918fa3be107ac3a2fc8831fd78733a7506730a 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/PatrolSpawner.java
++++ b/src/main/java/net/minecraft/world/level/levelgen/PatrolSpawner.java
+@@ -25,6 +25,7 @@ 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
+         if (!spawnMonsters) {
+             return 0;
+         } else if (!world.getGameRules().getBoolean(GameRules.RULE_DO_PATROL_SPAWNING)) {

patches/server/0328-Flat-bedrock-generator-settings.patch

@@ -0,0 +1,210 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Byteflux <byte@byteflux.net>
+Date: Wed, 2 Mar 2016 02:17:54 -0600
+Subject: [PATCH] Flat bedrock generator settings
+
+== AT ==
+public net.minecraft.world.level.levelgen.SurfaceRules$Condition
+public net.minecraft.world.level.levelgen.SurfaceRules$Context
+public net.minecraft.world.level.levelgen.SurfaceRules$Context blockX
+public net.minecraft.world.level.levelgen.SurfaceRules$Context blockY
+public net.minecraft.world.level.levelgen.SurfaceRules$Context blockZ
+public net.minecraft.world.level.levelgen.SurfaceRules$Context context
+public net.minecraft.world.level.levelgen.SurfaceRules$Context randomState
+public net.minecraft.world.level.levelgen.SurfaceRules$LazyYCondition
+public net.minecraft.world.level.levelgen.SurfaceRules$LazyCondition
+public net.minecraft.world.level.levelgen.SurfaceRules$VerticalGradientConditionSource
+public net.minecraft.world.level.levelgen.SurfaceRules$SurfaceRule
+public net.minecraft.world.level.levelgen.SurfaceSystem getOrCreateRandomFactory(Lnet/minecraft/resources/ResourceLocation;)Lnet/minecraft/world/level/levelgen/PositionalRandomFactory;
+
+Co-authored-by: Noah van der Aa <ndvdaa@gmail.com>
+
+diff --git a/src/main/java/net/minecraft/data/worldgen/SurfaceRuleData.java b/src/main/java/net/minecraft/data/worldgen/SurfaceRuleData.java
+index 06e1774dfbb667aca69bc30c9675ed472cb5728c..1d5bc86516df3781aea894c3afd340421ba51a17 100644
+--- a/src/main/java/net/minecraft/data/worldgen/SurfaceRuleData.java
++++ b/src/main/java/net/minecraft/data/worldgen/SurfaceRuleData.java
+@@ -53,6 +53,66 @@ public class SurfaceRuleData {
+         return overworldLike(true, false, true);
+     }
+ 
++    // Paper start
++    // Taken from SurfaceRules$VerticalGradientConditionSource
++    // isRoof = true if roof, false if floor
++    public record PaperBedrockConditionSource(net.minecraft.resources.ResourceLocation randomName, VerticalAnchor trueAtAndBelow, VerticalAnchor falseAtAndAbove, boolean isRoof) implements SurfaceRules.ConditionSource {
++
++        public static final net.minecraft.util.KeyDispatchDataCodec<PaperBedrockConditionSource> CODEC = net.minecraft.util.KeyDispatchDataCodec.of(com.mojang.serialization.codecs.RecordCodecBuilder.<PaperBedrockConditionSource>mapCodec((instance) -> {
++            return instance.group(
++                net.minecraft.resources.ResourceLocation.CODEC.fieldOf("random_name").forGetter(PaperBedrockConditionSource::randomName),
++                VerticalAnchor.CODEC.fieldOf("true_at_and_below").forGetter(PaperBedrockConditionSource::trueAtAndBelow),
++                VerticalAnchor.CODEC.fieldOf("false_at_and_above").forGetter(PaperBedrockConditionSource::falseAtAndAbove),
++                com.mojang.serialization.Codec.BOOL.fieldOf("roof").forGetter(PaperBedrockConditionSource::isRoof)
++                ).apply(instance, PaperBedrockConditionSource::new);
++        }));
++
++        public PaperBedrockConditionSource(String randomName, net.minecraft.world.level.levelgen.VerticalAnchor trueAtAndBelow, net.minecraft.world.level.levelgen.VerticalAnchor falseAtAndAbove, boolean invert) {
++            this(new net.minecraft.resources.ResourceLocation(randomName), trueAtAndBelow, falseAtAndAbove, invert);
++        }
++
++        @Override
++        public net.minecraft.util.KeyDispatchDataCodec<PaperBedrockConditionSource>codec() {
++            return CODEC;
++        }
++
++        @Override
++        public SurfaceRules.Condition apply(SurfaceRules.Context context) {
++            boolean hasFlatBedrock = context.context.getWorld().paperConfig().environment.generateFlatBedrock;
++            int trueAtY = this.trueAtAndBelow().resolveY(context.context);
++            int falseAtY = this.falseAtAndAbove().resolveY(context.context);
++
++            int y = isRoof ? Math.max(falseAtY, trueAtY) - 1 : Math.min(falseAtY, trueAtY) ;
++            final int i = hasFlatBedrock ? y : trueAtY;
++            final int j = hasFlatBedrock ? y : falseAtY;
++            // TODO access transformer for randomState
++            final net.minecraft.world.level.levelgen.PositionalRandomFactory positionalRandomFactory = context.randomState.getOrCreateRandomFactory(this.randomName());
++
++            class VerticalGradientCondition extends SurfaceRules.LazyYCondition {
++                VerticalGradientCondition(SurfaceRules.Context context) {
++                    super(context);
++                }
++
++                @Override
++                protected boolean compute() {
++                    int y = this.context.blockY;
++                    if (y <= i) {
++                        return true;
++                    } else if (y >= j) {
++                        return false;
++                    } else {
++                        double d = net.minecraft.util.Mth.map((double) y, (double) i, (double) j, 1.0D, 0.0D);
++                        net.minecraft.util.RandomSource randomSource = positionalRandomFactory.at(this.context.blockX, y, this.context.blockZ);
++                        return (double) randomSource.nextFloat() < d;
++                    }
++                }
++            }
++
++            return new VerticalGradientCondition(context);
++        }
++    }
++    // Paper end
++
+     public static SurfaceRules.RuleSource overworldLike(boolean surface, boolean bedrockRoof, boolean bedrockFloor) {
+         SurfaceRules.ConditionSource conditionSource = SurfaceRules.yBlockCheck(VerticalAnchor.absolute(97), 2);
+         SurfaceRules.ConditionSource conditionSource2 = SurfaceRules.yBlockCheck(VerticalAnchor.absolute(256), 0);
+@@ -83,11 +143,11 @@ public class SurfaceRuleData {
+         SurfaceRules.RuleSource ruleSource9 = SurfaceRules.sequence(SurfaceRules.ifTrue(SurfaceRules.ON_FLOOR, SurfaceRules.sequence(SurfaceRules.ifTrue(SurfaceRules.isBiome(Biomes.WOODED_BADLANDS), SurfaceRules.ifTrue(conditionSource, SurfaceRules.sequence(SurfaceRules.ifTrue(conditionSource16, COARSE_DIRT), SurfaceRules.ifTrue(conditionSource17, COARSE_DIRT), SurfaceRules.ifTrue(conditionSource18, COARSE_DIRT), ruleSource))), SurfaceRules.ifTrue(SurfaceRules.isBiome(Biomes.SWAMP), SurfaceRules.ifTrue(conditionSource6, SurfaceRules.ifTrue(SurfaceRules.not(conditionSource7), SurfaceRules.ifTrue(SurfaceRules.noiseCondition(Noises.SWAMP, 0.0D), WATER)))), SurfaceRules.ifTrue(SurfaceRules.isBiome(Biomes.MANGROVE_SWAMP), SurfaceRules.ifTrue(conditionSource5, SurfaceRules.ifTrue(SurfaceRules.not(conditionSource7), SurfaceRules.ifTrue(SurfaceRules.noiseCondition(Noises.SWAMP, 0.0D), WATER)))))), SurfaceRules.ifTrue(SurfaceRules.isBiome(Biomes.BADLANDS, Biomes.ERODED_BADLANDS, Biomes.WOODED_BADLANDS), SurfaceRules.sequence(SurfaceRules.ifTrue(SurfaceRules.ON_FLOOR, SurfaceRules.sequence(SurfaceRules.ifTrue(conditionSource2, ORANGE_TERRACOTTA), SurfaceRules.ifTrue(conditionSource4, SurfaceRules.sequence(SurfaceRules.ifTrue(conditionSource16, TERRACOTTA), SurfaceRules.ifTrue(conditionSource17, TERRACOTTA), SurfaceRules.ifTrue(conditionSource18, TERRACOTTA), SurfaceRules.bandlands())), SurfaceRules.ifTrue(conditionSource8, SurfaceRules.sequence(SurfaceRules.ifTrue(SurfaceRules.ON_CEILING, RED_SANDSTONE), RED_SAND)), SurfaceRules.ifTrue(SurfaceRules.not(conditionSource11), ORANGE_TERRACOTTA), SurfaceRules.ifTrue(conditionSource10, WHITE_TERRACOTTA), ruleSource3)), SurfaceRules.ifTrue(conditionSource3, SurfaceRules.sequence(SurfaceRules.ifTrue(conditionSource7, SurfaceRules.ifTrue(SurfaceRules.not(conditionSource4), ORANGE_TERRACOTTA)), SurfaceRules.bandlands())), SurfaceRules.ifTrue(SurfaceRules.UNDER_FLOOR, SurfaceRules.ifTrue(conditionSource10, WHITE_TERRACOTTA)))), SurfaceRules.ifTrue(SurfaceRules.ON_FLOOR, SurfaceRules.ifTrue(conditionSource8, SurfaceRules.sequence(SurfaceRules.ifTrue(conditionSource12, SurfaceRules.ifTrue(conditionSource11, SurfaceRules.sequence(SurfaceRules.ifTrue(conditionSource9, AIR), SurfaceRules.ifTrue(SurfaceRules.temperature(), ICE), WATER))), ruleSource8))), SurfaceRules.ifTrue(conditionSource10, SurfaceRules.sequence(SurfaceRules.ifTrue(SurfaceRules.ON_FLOOR, SurfaceRules.ifTrue(conditionSource12, SurfaceRules.ifTrue(conditionSource11, WATER))), SurfaceRules.ifTrue(SurfaceRules.UNDER_FLOOR, ruleSource7), SurfaceRules.ifTrue(conditionSource14, SurfaceRules.ifTrue(SurfaceRules.DEEP_UNDER_FLOOR, SANDSTONE)), SurfaceRules.ifTrue(conditionSource15, SurfaceRules.ifTrue(SurfaceRules.VERY_DEEP_UNDER_FLOOR, SANDSTONE)))), SurfaceRules.ifTrue(SurfaceRules.ON_FLOOR, SurfaceRules.sequence(SurfaceRules.ifTrue(SurfaceRules.isBiome(Biomes.FROZEN_PEAKS, Biomes.JAGGED_PEAKS), STONE), SurfaceRules.ifTrue(SurfaceRules.isBiome(Biomes.WARM_OCEAN, Biomes.LUKEWARM_OCEAN, Biomes.DEEP_LUKEWARM_OCEAN), ruleSource2), ruleSource3)));
+         ImmutableList.Builder<SurfaceRules.RuleSource> builder = ImmutableList.builder();
+         if (bedrockRoof) {
+-            builder.add(SurfaceRules.ifTrue(SurfaceRules.not(SurfaceRules.verticalGradient("bedrock_roof", VerticalAnchor.belowTop(5), VerticalAnchor.top())), BEDROCK));
++            builder.add(SurfaceRules.ifTrue(SurfaceRules.not(new PaperBedrockConditionSource("bedrock_roof", VerticalAnchor.belowTop(5), VerticalAnchor.top(), true)), BEDROCK)); // Paper
+         }
+ 
+         if (bedrockFloor) {
+-            builder.add(SurfaceRules.ifTrue(SurfaceRules.verticalGradient("bedrock_floor", VerticalAnchor.bottom(), VerticalAnchor.aboveBottom(5)), BEDROCK));
++            builder.add(SurfaceRules.ifTrue(new PaperBedrockConditionSource("bedrock_floor", VerticalAnchor.bottom(), VerticalAnchor.aboveBottom(5), false), BEDROCK)); // Paper
+         }
+ 
+         SurfaceRules.RuleSource ruleSource10 = SurfaceRules.ifTrue(SurfaceRules.abovePreliminarySurface(), ruleSource9);
+@@ -112,7 +172,7 @@ public class SurfaceRuleData {
+         SurfaceRules.ConditionSource conditionSource11 = SurfaceRules.noiseCondition(Noises.NETHER_WART, 1.17D);
+         SurfaceRules.ConditionSource conditionSource12 = SurfaceRules.noiseCondition(Noises.NETHER_STATE_SELECTOR, 0.0D);
+         SurfaceRules.RuleSource ruleSource = SurfaceRules.ifTrue(conditionSource9, SurfaceRules.ifTrue(conditionSource3, SurfaceRules.ifTrue(conditionSource4, GRAVEL)));
+-        return SurfaceRules.sequence(SurfaceRules.ifTrue(SurfaceRules.verticalGradient("bedrock_floor", VerticalAnchor.bottom(), VerticalAnchor.aboveBottom(5)), BEDROCK), SurfaceRules.ifTrue(SurfaceRules.not(SurfaceRules.verticalGradient("bedrock_roof", VerticalAnchor.belowTop(5), VerticalAnchor.top())), BEDROCK), SurfaceRules.ifTrue(conditionSource5, NETHERRACK), SurfaceRules.ifTrue(SurfaceRules.isBiome(Biomes.BASALT_DELTAS), SurfaceRules.sequence(SurfaceRules.ifTrue(SurfaceRules.UNDER_CEILING, BASALT), SurfaceRules.ifTrue(SurfaceRules.UNDER_FLOOR, SurfaceRules.sequence(ruleSource, SurfaceRules.ifTrue(conditionSource12, BASALT), BLACKSTONE)))), SurfaceRules.ifTrue(SurfaceRules.isBiome(Biomes.SOUL_SAND_VALLEY), SurfaceRules.sequence(SurfaceRules.ifTrue(SurfaceRules.UNDER_CEILING, SurfaceRules.sequence(SurfaceRules.ifTrue(conditionSource12, SOUL_SAND), SOUL_SOIL)), SurfaceRules.ifTrue(SurfaceRules.UNDER_FLOOR, SurfaceRules.sequence(ruleSource, SurfaceRules.ifTrue(conditionSource12, SOUL_SAND), SOUL_SOIL)))), SurfaceRules.ifTrue(SurfaceRules.ON_FLOOR, SurfaceRules.sequence(SurfaceRules.ifTrue(SurfaceRules.not(conditionSource2), SurfaceRules.ifTrue(conditionSource6, LAVA)), SurfaceRules.ifTrue(SurfaceRules.isBiome(Biomes.WARPED_FOREST), SurfaceRules.ifTrue(SurfaceRules.not(conditionSource10), SurfaceRules.ifTrue(conditionSource, SurfaceRules.sequence(SurfaceRules.ifTrue(conditionSource11, WARPED_WART_BLOCK), WARPED_NYLIUM)))), SurfaceRules.ifTrue(SurfaceRules.isBiome(Biomes.CRIMSON_FOREST), SurfaceRules.ifTrue(SurfaceRules.not(conditionSource10), SurfaceRules.ifTrue(conditionSource, SurfaceRules.sequence(SurfaceRules.ifTrue(conditionSource11, NETHER_WART_BLOCK), CRIMSON_NYLIUM)))))), SurfaceRules.ifTrue(SurfaceRules.isBiome(Biomes.NETHER_WASTES), SurfaceRules.sequence(SurfaceRules.ifTrue(SurfaceRules.UNDER_FLOOR, SurfaceRules.ifTrue(conditionSource7, SurfaceRules.sequence(SurfaceRules.ifTrue(SurfaceRules.not(conditionSource6), SurfaceRules.ifTrue(conditionSource3, SurfaceRules.ifTrue(conditionSource4, SOUL_SAND))), NETHERRACK))), SurfaceRules.ifTrue(SurfaceRules.ON_FLOOR, SurfaceRules.ifTrue(conditionSource, SurfaceRules.ifTrue(conditionSource4, SurfaceRules.ifTrue(conditionSource8, SurfaceRules.sequence(SurfaceRules.ifTrue(conditionSource2, GRAVEL), SurfaceRules.ifTrue(SurfaceRules.not(conditionSource6), GRAVEL)))))))), NETHERRACK);
++        return SurfaceRules.sequence(SurfaceRules.ifTrue(new PaperBedrockConditionSource("bedrock_floor", VerticalAnchor.bottom(), VerticalAnchor.aboveBottom(5), false), BEDROCK), SurfaceRules.ifTrue(SurfaceRules.not(new PaperBedrockConditionSource("bedrock_roof", VerticalAnchor.belowTop(5), VerticalAnchor.top(), true)), BEDROCK), SurfaceRules.ifTrue(conditionSource5, NETHERRACK), SurfaceRules.ifTrue(SurfaceRules.isBiome(Biomes.BASALT_DELTAS), SurfaceRules.sequence(SurfaceRules.ifTrue(SurfaceRules.UNDER_CEILING, BASALT), SurfaceRules.ifTrue(SurfaceRules.UNDER_FLOOR, SurfaceRules.sequence(ruleSource, SurfaceRules.ifTrue(conditionSource12, BASALT), BLACKSTONE)))), SurfaceRules.ifTrue(SurfaceRules.isBiome(Biomes.SOUL_SAND_VALLEY), SurfaceRules.sequence(SurfaceRules.ifTrue(SurfaceRules.UNDER_CEILING, SurfaceRules.sequence(SurfaceRules.ifTrue(conditionSource12, SOUL_SAND), SOUL_SOIL)), SurfaceRules.ifTrue(SurfaceRules.UNDER_FLOOR, SurfaceRules.sequence(ruleSource, SurfaceRules.ifTrue(conditionSource12, SOUL_SAND), SOUL_SOIL)))), SurfaceRules.ifTrue(SurfaceRules.ON_FLOOR, SurfaceRules.sequence(SurfaceRules.ifTrue(SurfaceRules.not(conditionSource2), SurfaceRules.ifTrue(conditionSource6, LAVA)), SurfaceRules.ifTrue(SurfaceRules.isBiome(Biomes.WARPED_FOREST), SurfaceRules.ifTrue(SurfaceRules.not(conditionSource10), SurfaceRules.ifTrue(conditionSource, SurfaceRules.sequence(SurfaceRules.ifTrue(conditionSource11, WARPED_WART_BLOCK), WARPED_NYLIUM)))), SurfaceRules.ifTrue(SurfaceRules.isBiome(Biomes.CRIMSON_FOREST), SurfaceRules.ifTrue(SurfaceRules.not(conditionSource10), SurfaceRules.ifTrue(conditionSource, SurfaceRules.sequence(SurfaceRules.ifTrue(conditionSource11, NETHER_WART_BLOCK), CRIMSON_NYLIUM)))))), SurfaceRules.ifTrue(SurfaceRules.isBiome(Biomes.NETHER_WASTES), SurfaceRules.sequence(SurfaceRules.ifTrue(SurfaceRules.UNDER_FLOOR, SurfaceRules.ifTrue(conditionSource7, SurfaceRules.sequence(SurfaceRules.ifTrue(SurfaceRules.not(conditionSource6), SurfaceRules.ifTrue(conditionSource3, SurfaceRules.ifTrue(conditionSource4, SOUL_SAND))), NETHERRACK))), SurfaceRules.ifTrue(SurfaceRules.ON_FLOOR, SurfaceRules.ifTrue(conditionSource, SurfaceRules.ifTrue(conditionSource4, SurfaceRules.ifTrue(conditionSource8, SurfaceRules.sequence(SurfaceRules.ifTrue(conditionSource2, GRAVEL), SurfaceRules.ifTrue(SurfaceRules.not(conditionSource6), GRAVEL)))))))), NETHERRACK);
+     }
+ 
+     public static SurfaceRules.RuleSource end() {
+diff --git a/src/main/java/net/minecraft/server/Bootstrap.java b/src/main/java/net/minecraft/server/Bootstrap.java
+index 0d3a8f576c037886ccdd6068ce953c4ce010ae2f..bf3fa6454477041898ca00a6341db83a06a52d6f 100644
+--- a/src/main/java/net/minecraft/server/Bootstrap.java
++++ b/src/main/java/net/minecraft/server/Bootstrap.java
+@@ -70,6 +70,7 @@ public class Bootstrap {
+                     DispenseItemBehavior.bootStrap();
+                     CauldronInteraction.bootStrap();
+                     BuiltInRegistries.bootStrap();
++                    net.minecraft.core.Registry.register(net.minecraft.core.registries.BuiltInRegistries.MATERIAL_CONDITION, new net.minecraft.resources.ResourceLocation("paper", "bedrock_condition_source"), net.minecraft.data.worldgen.SurfaceRuleData.PaperBedrockConditionSource.CODEC.codec()); // Paper - register custom flat bedrock thing. TODO is this the best place to do this?
+                     Bootstrap.wrapStreams();
+                 }
+                 // CraftBukkit start - easier than fixing the decompile
+diff --git a/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java b/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java
+index cdc87f14e5d6336856c74d5089e50ae5ebad9923..6b84633bf6956406d2e2c5dd32fa358f41ccc890 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java
++++ b/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java
+@@ -207,7 +207,7 @@ public final class NoiseBasedChunkGenerator extends ChunkGenerator {
+     @Override
+     public void buildSurface(WorldGenRegion region, StructureManager structures, RandomState noiseConfig, ChunkAccess chunk) {
+         if (!SharedConstants.debugVoidTerrain(chunk.getPos())) {
+-            WorldGenerationContext worldgenerationcontext = new WorldGenerationContext(this, region);
++            WorldGenerationContext worldgenerationcontext = new WorldGenerationContext(this, region, region.getMinecraftWorld()); // Paper
+ 
+             this.buildSurface(chunk, worldgenerationcontext, noiseConfig, structures, region.getBiomeManager(), region.registryAccess().registryOrThrow(Registries.BIOME), Blender.of(region));
+         }
+@@ -235,7 +235,7 @@ public final class NoiseBasedChunkGenerator extends ChunkGenerator {
+             return this.createNoiseChunk(ichunkaccess1, structureAccessor, Blender.of(chunkRegion), noiseConfig);
+         });
+         Aquifer aquifer = noisechunk.aquifer();
+-        CarvingContext carvingcontext = new CarvingContext(this, chunkRegion.registryAccess(), chunk.getHeightAccessorForGeneration(), noisechunk, noiseConfig, ((NoiseGeneratorSettings) this.settings.value()).surfaceRule());
++        CarvingContext carvingcontext = new CarvingContext(this, chunkRegion.registryAccess(), chunk.getHeightAccessorForGeneration(), noisechunk, noiseConfig, ((NoiseGeneratorSettings) this.settings.value()).surfaceRule(), chunkRegion.getMinecraftWorld()); // Paper
+         CarvingMask carvingmask = ((ProtoChunk) chunk).getOrCreateCarvingMask(carverStep);
+ 
+         for (int j = -8; j <= 8; ++j) {
+diff --git a/src/main/java/net/minecraft/world/level/levelgen/WorldGenerationContext.java b/src/main/java/net/minecraft/world/level/levelgen/WorldGenerationContext.java
+index b99283c31193e2110f6e3f39c23dbfc2442bab2b..1c9d9ecdafb2bd04348045ba0404da052dcd6437 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/WorldGenerationContext.java
++++ b/src/main/java/net/minecraft/world/level/levelgen/WorldGenerationContext.java
+@@ -6,10 +6,13 @@ import net.minecraft.world.level.chunk.ChunkGenerator;
+ public class WorldGenerationContext {
+     private final int minY;
+     private final int height;
++    private final @javax.annotation.Nullable net.minecraft.world.level.Level level; // Paper
+ 
+-    public WorldGenerationContext(ChunkGenerator generator, LevelHeightAccessor world) {
++    public WorldGenerationContext(ChunkGenerator generator, LevelHeightAccessor world) { this(generator, world, null); } // Paper
++    public WorldGenerationContext(ChunkGenerator generator, LevelHeightAccessor world, @org.jetbrains.annotations.Nullable net.minecraft.world.level.Level level) { // Paper
+         this.minY = Math.max(world.getMinBuildHeight(), generator.getMinY());
+         this.height = Math.min(world.getHeight(), generator.getGenDepth());
++        this.level = level; // Paper
+     }
+ 
+     public int getMinGenY() {
+@@ -19,4 +22,13 @@ public class WorldGenerationContext {
+     public int getGenDepth() {
+         return this.height;
+     }
++
++    // Paper start
++    public net.minecraft.world.level.Level getWorld() {
++        if (this.level == null) {
++            throw new NullPointerException("WorldGenerationContext was initialized without a Level, but WorldGenerationContext#getWorld was called");
++        }
++        return this.level;
++    }
++    // Paper end
+ }
+diff --git a/src/main/java/net/minecraft/world/level/levelgen/carver/CarvingContext.java b/src/main/java/net/minecraft/world/level/levelgen/carver/CarvingContext.java
+index a745458ea3581ea91a68c863e3fd0a0292d73a61..f84ee8afe95f912a972e37fbae7a06ecdd3aba06 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/carver/CarvingContext.java
++++ b/src/main/java/net/minecraft/world/level/levelgen/carver/CarvingContext.java
+@@ -21,8 +21,8 @@ public class CarvingContext extends WorldGenerationContext {
+     private final RandomState randomState;
+     private final SurfaceRules.RuleSource surfaceRule;
+ 
+-    public CarvingContext(NoiseBasedChunkGenerator noiseChunkGenerator, RegistryAccess registryManager, LevelHeightAccessor heightLimitView, NoiseChunk chunkNoiseSampler, RandomState noiseConfig, SurfaceRules.RuleSource materialRule) {
+-        super(noiseChunkGenerator, heightLimitView);
++    public CarvingContext(NoiseBasedChunkGenerator noiseChunkGenerator, RegistryAccess registryManager, LevelHeightAccessor heightLimitView, NoiseChunk chunkNoiseSampler, RandomState noiseConfig, SurfaceRules.RuleSource materialRule, @javax.annotation.Nullable net.minecraft.world.level.Level level) { // Paper
++        super(noiseChunkGenerator, heightLimitView, level); // Paper
+         this.registryAccess = registryManager;
+         this.noiseChunk = chunkNoiseSampler;
+         this.randomState = noiseConfig;
+diff --git a/src/main/java/net/minecraft/world/level/levelgen/placement/PlacementContext.java b/src/main/java/net/minecraft/world/level/levelgen/placement/PlacementContext.java
+index 640c2683c842655bbaee8f293f1c2613ef44844e..53d818b0cc602f827d0b907e293515f6810c6792 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/placement/PlacementContext.java
++++ b/src/main/java/net/minecraft/world/level/levelgen/placement/PlacementContext.java
+@@ -18,7 +18,7 @@ public class PlacementContext extends WorldGenerationContext {
+     private final Optional<PlacedFeature> topFeature;
+ 
+     public PlacementContext(WorldGenLevel world, ChunkGenerator generator, Optional<PlacedFeature> placedFeature) {
+-        super(generator, world);
++        super(generator, world, world.getLevel()); // Paper
+         this.level = world;
+         this.generator = generator;
+         this.topFeature = placedFeature;

patches/server/0329-Prevent-sync-chunk-loads-when-villagers-try-to-find-.patch

@@ -0,0 +1,20 @@
+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 9012a6347b2f061e88c42d3c237c4b465883e941..6b2b34cb129f807af8042e26a5e180d18e195459 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
+@@ -43,7 +43,8 @@ public class SleepInBed extends Behavior<LivingEntity> {
+                     }
+                 }
+ 
+-                BlockState blockState = world.getBlockState(globalPos.pos());
++                BlockState blockState = world.getBlockStateIfLoaded(globalPos.pos()); // Paper
++                if (blockState == null) { return false; } // Paper
+                 return globalPos.pos().closerToCenterThan(entity.position(), 2.0D) && blockState.is(BlockTags.BEDS) && !blockState.getValue(BedBlock.OCCUPIED);
+             }
+         }

patches/server/0330-MC-145656-Fix-Follow-Range-Initial-Target.patch

@@ -0,0 +1,50 @@
+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 638942d54c6ea2d305350a330ac9fb8b82294f53..7f4fb6ad4b3b3da52a111b0c58499f27d8443124 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
+@@ -38,6 +38,7 @@ 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
+     }
+ 
+     @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 9f65f6cdbcc054bde03c42d7d3b16f65b93e5deb..a7575b5ef56af6f53448d391abb4956e130148ca 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
+@@ -76,7 +76,7 @@ public class TargetingConditions {
+ 
+                 if (this.range > 0.0D) {
+                     double d = this.testInvisible ? targetEntity.getVisibilityPercent(baseEntity) : 1.0D;
+-                    double e = Math.max(this.range * d, 2.0D);
++                    double e = Math.max((this.useFollowRange ? this.getFollowRange(baseEntity) : this.range) * d, 2.0D); // Paper
+                     double f = baseEntity.distanceToSqr(targetEntity.getX(), targetEntity.getY(), targetEntity.getZ());
+                     if (f > e * e) {
+                         return false;
+@@ -94,4 +94,18 @@ public class TargetingConditions {
+             return true;
+         }
+     }
++
++    // Paper start
++    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
+ }

patches/server/0331-Duplicate-UUID-Resolve-Option.patch

@@ -0,0 +1,119 @@
+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/io/papermc/paper/chunk/system/ChunkSystem.java b/src/main/java/io/papermc/paper/chunk/system/ChunkSystem.java
+index 0dc94dec1317b3f86d38074c6cbe41ab828cab1d..0e45a340ae534caf676b7f9d0adcbcee5829925e 100644
+--- a/src/main/java/io/papermc/paper/chunk/system/ChunkSystem.java
++++ b/src/main/java/io/papermc/paper/chunk/system/ChunkSystem.java
+@@ -73,7 +73,17 @@ public final class ChunkSystem {
+     }
+ 
+     public static void onEntityPreAdd(final ServerLevel level, final Entity entity) {
+-
++        // Paper start - duplicate uuid resolving
++        if (net.minecraft.server.level.ChunkMap.checkDupeUUID(level, entity)) {
++            return;
++        }
++        if (net.minecraft.world.level.Level.DEBUG_ENTITIES && ((Entity) entity).level.paperConfig().entities.spawning.duplicateUuid.mode != io.papermc.paper.configuration.WorldConfiguration.Entities.Spawning.DuplicateUUID.DuplicateUUIDMode.NOTHING) {
++            if (((Entity) entity).addedToWorldStack != null) {
++                ((Entity) entity).addedToWorldStack.printStackTrace();
++            }
++            net.minecraft.server.level.ServerLevel.getAddToWorldStackTrace((Entity) entity).printStackTrace();
++        }
++        // Paper end - duplicate uuid resolving
+     }
+ 
+     public static void onChunkHolderCreate(final ServerLevel level, final ChunkHolder holder) {
+diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
+index 7c9b73136b4fc5fda96317001eb8a32245b9768a..512e8ace73635e5494ec09bee29148617d45b460 100644
+--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
++++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
+@@ -534,6 +534,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+                     entity.discard();
+                     needsRemoval = true;
+                 }
++                checkDupeUUID(world, entity); // Paper
+                 return !needsRemoval;
+             }));
+             // CraftBukkit end
+@@ -545,6 +546,49 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+         throw new UnsupportedOperationException(); // Paper - rewrite chunk system
+     }
+ 
++    // Paper start
++    // 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
++        ) {
++            if (ServerLevel.DEBUG_ENTITIES) LOGGER.warn("[DUPE-UUID] Duplicate UUID found used by " + other + ", deleted entity " + entity + " because it was near the duplicate and likely an actual duplicate. See https://github.com/PaperMC/Paper/issues/1223 for discussion on what this is about.");
++            entity.discard();
++            return true;
++        }
++        if (other != null && !other.isRemoved()) {
++            switch (mode) {
++                case SAFE_REGEN: {
++                    entity.setUUID(java.util.UUID.randomUUID());
++                    if (ServerLevel.DEBUG_ENTITIES) LOGGER.warn("[DUPE-UUID] Duplicate UUID found used by " + other + ", regenerated UUID for " + entity + ". See https://github.com/PaperMC/Paper/issues/1223 for discussion on what this is about.");
++                    break;
++                }
++                case DELETE: {
++                    if (ServerLevel.DEBUG_ENTITIES) LOGGER.warn("[DUPE-UUID] Duplicate UUID found used by " + other + ", deleted entity " + entity + ". See https://github.com/PaperMC/Paper/issues/1223 for discussion on what this is about.");
++                    entity.discard();
++                    return true;
++                }
++                default:
++                    if (ServerLevel.DEBUG_ENTITIES) LOGGER.warn("[DUPE-UUID] Duplicate UUID found used by " + other + ", doing nothing to " + entity + ". See https://github.com/PaperMC/Paper/issues/1223 for discussion on what this is about.");
++                    break;
++            }
++        }
++        return false;
++    }
++    // Paper end
+     public CompletableFuture<Either<LevelChunk, ChunkHolder.ChunkLoadingFailure>> prepareTickingChunk(ChunkHolder holder) {
+         throw new UnsupportedOperationException(); // Paper - rewrite chunk system
+     }