More work

2021-06-13 13:40:34 +02:00 · 2021-06-13 13:40:34 +02:00 · 19da14ee00
commit 19da14ee00
parent d42140148f
23 changed files with 276 additions and 307 deletions
--- a/patches/server/0316-don-t-go-below-0-for-pickupDelay-breaks-picking-up-i.patch
+++ b/patches/server/0316-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 0741dcbd06395b4696eb6083128a5d9b679cb3fb..82ffe3624943d2e931e2cc2f85ede94f369bd06b 100644
+--- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+++ b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+@@ -105,6 +105,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
+@@ -193,6 +194,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
--- a/patches/server/0317-Server-Tick-Events.patch
+++ b/patches/server/0317-Server-Tick-Events.patch
@ -0,0 +1,32 @@
+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 a1c65ea148692e50dbc466d87dae5198e0b6a51f..eb103c15218c334b9f85a57e30582e9efb188704 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1310,6 +1310,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);
+@@ -1353,6 +1354,12 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         }
+         // 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;
+ 
--- a/patches/server/0318-PlayerDeathEvent-getItemsToKeep.patch
+++ b/patches/server/0318-PlayerDeathEvent-getItemsToKeep.patch
@ -0,0 +1,73 @@
+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
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 955a7fcd80a57f920e402a5533f5029b9683104c..679f1e3ef4c19ab466cf2d06c47b1018aabaa7bf 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -729,6 +729,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 source) {
+         boolean flag = this.level.getGameRules().getBoolean(GameRules.RULE_SHOWDEATHMESSAGES);
+@@ -813,6 +853,12 @@ public class ServerPlayer extends Player {
+         // 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().getComponents()) {
+                processKeep(event, inv);
+            }
+            processKeep(event, null);
+            // Paper end
+         }
+ 
+         this.setCamera(this); // Remove spectated target
--- a/patches/server/0319-Optimize-Captured-TileEntity-Lookup.patch
+++ b/patches/server/0319-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 a1b713391c2445967c3b5a645304f193c013d551..9891e40972c1dc6bebe8ccec2bf82123dcdd7e94 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -869,9 +869,12 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+ 
+     @Nullable
+     public BlockEntity getTileEntity(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 && Thread.currentThread() != this.thread ? null : this.getChunkAt(blockposition).getBlockEntity(blockposition, LevelChunk.EntityCreationType.IMMEDIATE));
+     }
--- a/patches/server/0320-Add-Heightmap-API.patch
+++ b/patches/server/0320-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 fda8858375a08e0aac15ca00751df5a34ed6a0f2..5f93589106bcf29eabd4544951fa3ad36e00c5a6 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -341,6 +341,29 @@ public class CraftWorld 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();
--- a/patches/server/0321-Mob-Spawner-API-Enhancements.patch
+++ b/patches/server/0321-Mob-Spawner-API-Enhancements.patch
@ -0,0 +1,129 @@
+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
+
+
+diff --git a/src/main/java/net/minecraft/world/level/BaseSpawner.java b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+index 3aadcb472ab808ee981065ddfa86be6cbf38c8d9..c6298b12e4e0c20be20e7e493be728f028f9eb31 100644
+--- a/src/main/java/net/minecraft/world/level/BaseSpawner.java
+++ b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+@@ -31,7 +31,7 @@ public abstract class BaseSpawner {
+ 
+     private static final Logger LOGGER = LogManager.getLogger();
+     private static final int EVENT_SPAWN = 1;
+-    private static WeightedRandomList<SpawnData> EMPTY_POTENTIALS = WeightedRandomList.create();
+    public static WeightedRandomList<SpawnData> EMPTY_POTENTIALS = WeightedRandomList.create(); // Paper - private->public
+     public int spawnDelay = 20;
+     public WeightedRandomList<SpawnData> spawnPotentials;
+     public SpawnData nextSpawnData;
+@@ -77,7 +77,7 @@ public abstract class BaseSpawner {
+         this.spawnPotentials = BaseSpawner.EMPTY_POTENTIALS; // CraftBukkit - SPIGOT-3496, MC-92282
+     }
+ 
+-    private boolean isNearPlayer(Level world, BlockPos pos) {
+    public boolean isNearPlayer(Level world, BlockPos pos) { // Paper private->public
+         return world.isAffectsSpawningPlayerNearby((double) pos.getX() + 0.5D, (double) pos.getY() + 0.5D, (double) pos.getZ() + 0.5D, (double) this.requiredPlayerRange); // Paper
+     }
+ 
+@@ -204,7 +204,7 @@ public abstract class BaseSpawner {
+         }
+     }
+ 
+-    private void delay(Level world, BlockPos pos) {
+    public void delay(Level world, BlockPos pos) { // Paper private->public
+         if (this.maxSpawnDelay <= this.minSpawnDelay) {
+             this.spawnDelay = this.minSpawnDelay;
+         } else {
+@@ -218,7 +218,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
+         List<SpawnData> list = Lists.newArrayList();
+ 
+         if (nbt.contains("SpawnPotentials", 9)) {
+@@ -237,10 +243,15 @@ public abstract class BaseSpawner {
+                 this.setSpawnData(world, pos, mobspawnerdata);
+             });
+         }
+-
+        // 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");
+         }
+ 
+@@ -262,9 +273,20 @@ public abstract class BaseSpawner {
+         if (minecraftkey == null) {
+             return nbt;
+         } else {
+-            nbt.putShort("Delay", (short) this.spawnDelay);
+-            nbt.putShort("MinSpawnDelay", (short) this.minSpawnDelay);
+-            nbt.putShort("MaxSpawnDelay", (short) this.maxSpawnDelay);
+            // Paper start
+            if (spawnDelay > Short.MAX_VALUE) {
+                nbt.putInt("Paper.Delay", this.spawnDelay);
+            }
+            nbt.putShort("Delay", (short) Math.min(Short.MAX_VALUE, this.spawnDelay));
+
+            if (minSpawnDelay > Short.MAX_VALUE || maxSpawnDelay > Short.MAX_VALUE) {
+                nbt.putInt("Paper.MinSpawnDelay", this.minSpawnDelay);
+                nbt.putInt("Paper.MaxSpawnDelay", this.maxSpawnDelay);
+            }
+
+            nbt.putShort("MinSpawnDelay", (short) Math.min(Short.MAX_VALUE, this.minSpawnDelay));
+            nbt.putShort("MaxSpawnDelay", (short) Math.min(Short.MAX_VALUE, this.maxSpawnDelay));
+            // Paper end
+             nbt.putShort("SpawnCount", (short) this.spawnCount);
+             nbt.putShort("MaxNearbyEntities", (short) this.maxNearbyEntities);
+             nbt.putShort("RequiredPlayerRange", (short) this.requiredPlayerRange);
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftCreatureSpawner.java b/src/main/java/org/bukkit/craftbukkit/block/CraftCreatureSpawner.java
+index ff8eba31e6169b5a1debe47f17a40e6d0be67897..75575b24aa0291c26d65de9787bc9d2f88c867e4 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftCreatureSpawner.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftCreatureSpawner.java
+@@ -121,4 +121,30 @@ public class CraftCreatureSpawner extends CraftBlockEntityState<SpawnerBlockEnti
+     public void setSpawnRange(int spawnRange) {
+         this.getSnapshot().getSpawner().spawnRange = spawnRange;
+     }
+
+    // Paper start
+    @Override
+    public boolean isActivated() {
+        return this.getSnapshot().getSpawner().isNearPlayer(world.getHandle(), getPosition());
+    }
+
+    @Override
+    public void resetTimer() {
+        this.getSnapshot().getSpawner().delay(world.getHandle(), 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 compound = new net.minecraft.nbt.CompoundTag();
+        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()));
+        compound.put("Entity", entity);
+        compound.putInt("Weight", this.getSnapshotNBT().contains("Weight", org.bukkit.craftbukkit.util.CraftMagicNumbers.NBT.TAG_ANY_NUMBER) ? this.getSnapshotNBT().getInt("Weight") : 1);
+        this.getSnapshot().getSpawner().setSpawnData(world.getHandle(), getPosition(), new net.minecraft.world.level.SpawnData(compound));
+        this.getSnapshot().getSpawner().spawnPotentials= net.minecraft.world.level.BaseSpawner.EMPTY_POTENTIALS;
+    }
+    // Paper end
+ }
--- a/patches/server/0322-Fix-CB-call-to-changed-postToMainThread-method.patch
+++ b/patches/server/0322-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 6c4266d847b1181a055fa425d5734032dadabf93..377e224acb06bfd5f769b5f75b7f52129394b494 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -440,7 +440,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
+ 
+         Objects.requireNonNull(this.connection);
+         // CraftBukkit - Don't wait
+-        minecraftserver.wrapRunnable(networkmanager::handleDisconnection);
+        minecraftserver.scheduleOnMain(networkmanager::handleDisconnection); // Paper
+     }
+ 
+     private <T, R> void filterTextPacket(T text, Consumer<R> consumer, BiFunction<TextFilter, T, CompletableFuture<R>> backingFilterer) {
--- a/patches/server/0323-Fix-sounds-when-item-frames-are-modified-MC-123450.patch
+++ b/patches/server/0323-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 5fab5f74f7ef2ba94d7dae1679653201d7ccb30f..b829efdb40051a41b3bf1cabb8bf7d7c952797b5 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+++ b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+@@ -307,7 +307,7 @@ public class ItemFrame extends HangingEntity {
+         }
+ 
+         this.getEntityData().set(ItemFrame.DATA_ITEM, itemstack);
+-        if (!itemstack.isEmpty() && playSound) { // CraftBukkit
+        if (!itemstack.isEmpty() && flag && playSound) { // CraftBukkit // Paper - only play sound when update flag is set
+             this.playSound(this.getAddItemSound(), 1.0F, 1.0F);
+         }
+ 
--- a/patches/server/0324-Fix-CraftServer-isPrimaryThread-and-MinecraftServer-.patch
+++ b/patches/server/0324-Fix-CraftServer-isPrimaryThread-and-MinecraftServer-.patch
@ -0,0 +1,43 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Mon, 13 May 2019 21:10:59 -0700
+Subject: [PATCH] Fix CraftServer#isPrimaryThread and MinecraftServer
+ isMainThread
+
+md_5 changed it so he could shut down the server asynchronously
+from watchdog, although we have patches that prevent that type
+of behavior for this exact reason.
+
+md_5 also placed code in PlayerConnectionUtils that would have
+solved https://bugs.mojang.com/browse/MC-142590, making the change
+to MinecraftServer#isMainThread irrelevant.
+By reverting his change to MinecraftServer#isMainThread packet
+handling that should have been handled synchronously will be handled
+synchronously when the server gets shut down.
+
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index eb103c15218c334b9f85a57e30582e9efb188704..c8a59de4673d430fc8ec2e53315f107293122e7e 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -2262,7 +2262,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     // CraftBukkit start
+     @Override
+     public boolean isSameThread() {
+-        return super.isSameThread() || this.isStopped(); // CraftBukkit - MC-142590
+        return super.isSameThread() /*|| this.isStopped()*/; // CraftBukkit - MC-142590 // Paper - causes issues elsewhere
+     }
+ 
+     public boolean isDebugging() {
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 0448e6b4c512f512bda13f41f1feb58de02fc9d4..58d7fec472dd8c8d7775eb6d931be29871102054 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -1840,7 +1840,7 @@ public final class CraftServer implements Server {
+ 
+     @Override
+     public boolean isPrimaryThread() {
+-        return Thread.currentThread().equals(console.serverThread) || this.console.hasStopped() || !org.spigotmc.AsyncCatcher.enabled; // All bets are off if we have shut down (e.g. due to watchdog)
+        return Thread.currentThread().equals(console.serverThread); // Paper - Fix issues with detecting main thread properly
+     }
+ 
+     // Paper start
--- a/patches/server/0325-improve-CraftWorld-isChunkLoaded.patch
+++ b/patches/server/0325-improve-CraftWorld-isChunkLoaded.patch
@ -0,0 +1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Tue, 21 May 2019 02:34:04 +0100
+Subject: [PATCH] improve CraftWorld#isChunkLoaded
+
+getChunkAt will request the chunk using vanillas chunk loading system,
+which while we're not going to load the chunk, does involve the server
+waiting for the execution queue to get to our request; We can just query
+the chunk status and get a response now, vs having to wait
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index 5f93589106bcf29eabd4544951fa3ad36e00c5a6..a7eb8f69b49bb0229de9e5a4400a4424555ac1dd 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -412,13 +412,13 @@ public class CraftWorld implements World {
+ 
+     @Override
+     public boolean isChunkLoaded(int x, int z) {
+-        return this.world.getChunkSource().isChunkLoaded(x, z);
+        return this.world.getChunkSource().getChunkAtIfLoadedImmediately(x, z) != null; // Paper
+     }
+ 
+     @Override
+     public boolean isChunkGenerated(int x, int z) {
+         try {
+-            return this.isChunkLoaded(x, z) || this.world.getChunkSource().chunkMap.read(new ChunkPos(x, z)) != null;
+            return this.world.getChunkSource().getChunkAtIfCachedImmediately(x, z) != null || this.world.getChunkSource().chunkMap.read(new ChunkPos(x, z)) != null; // Paper (TODO check if the first part can be removed)
+         } catch (IOException ex) {
+             throw new RuntimeException(ex);
+         }
--- a/patches/server/0326-Configurable-Keep-Spawn-Loaded-range-per-world.patch
+++ b/patches/server/0326-Configurable-Keep-Spawn-Loaded-range-per-world.patch
@ -0,0 +1,256 @@
+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/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index 13e730b18c346934c061fb570048623ad66e7344..090958a30ce20ff01ae77d4cd821a167474f0214 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -36,6 +36,12 @@ public class PaperWorldConfig {
+         }
+     }
+ 
+    public short keepLoadedRange;
+    private void keepLoadedRange() {
+        keepLoadedRange = (short) (getInt("keep-spawn-loaded-range", Math.min(spigotConfig.viewDistance, 10)) * 16);
+        log( "Keep Spawn Loaded Range: " + (keepLoadedRange/16));
+    }
+
+     private boolean getBoolean(String path, boolean def) {
+         config.addDefault("world-settings.default." + path, def);
+         return config.getBoolean("world-settings." + worldName + "." + path, config.getBoolean("world-settings.default." + path));
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index c8a59de4673d430fc8ec2e53315f107293122e7e..40e48c3f1199b127066732e3c8a6d40c232215b2 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -775,35 +775,36 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
+     // CraftBukkit start
+     public void loadSpawn(ChunkProgressListener worldloadlistener, ServerLevel worldserver) {
+-        if (!worldserver.getWorld().getKeepSpawnInMemory()) {
+-            return;
+-        }
+        ServerChunkCache chunkproviderserver = worldserver.getChunkSource(); // Paper
+ 
+         // WorldServer worldserver = this.F();
+         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();
+-        chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(blockposition), 11, Unit.INSTANCE);
+-
+-        while (chunkproviderserver.getTickingGenerated() != 441) {
+-            // CraftBukkit start
+-            // this.nextTickTime = SystemUtils.getMonotonicMillis() + 10L;
+-            this.executeModerately();
+-            // CraftBukkit end
+-        }
+        // Paper start - configurable spawn reason
+        int radiusBlocks = worldserver.paperConfig.keepLoadedRange;
+        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
+ 
+         // CraftBukkit start
+         // this.nextTickTime = SystemUtils.getMonotonicMillis() + 10L;
+         this.executeModerately();
+         // Iterator iterator = this.worldServer.values().iterator();
+        }
+ 
+         if (true) {
+             ServerLevel worldserver1 = worldserver;
+@@ -826,7 +827,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         // this.nextTick = SystemUtils.getMonotonicMillis() + 10L;
+         this.executeModerately();
+         // CraftBukkit end
+-        worldloadlistener.stop();
+        if (worldserver.getWorld().getKeepSpawnInMemory()) worldloadlistener.stop(); // Paper
+         chunkproviderserver.getLightEngine().setTaskPerBatch(5);
+         // CraftBukkit start
+         // this.updateSpawnFlags();
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 940e6587125df1f203cdeeefc31658635badea81..420ecc61be194486d335c44fc743894023d3f115 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -61,6 +61,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 net.minecraft.server.MCUtil;
+ import net.minecraft.server.MinecraftServer;
+ import net.minecraft.server.ServerScoreboard;
+ import net.minecraft.server.level.progress.ChunkProgressListener;
+@@ -1486,12 +1487,88 @@ public class ServerLevel extends net.minecraft.world.level.Level implements Worl
+         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.add(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.add(x, 0, radiusInBlocks)), 1, Unit.INSTANCE); // level 32
+            // bottom
+            chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(spawn.add(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.add(radiusInBlocks, 0, z)), 1, Unit.INSTANCE); // level 32
+            // left
+            chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(spawn.add(-radiusInBlocks, 0, z)), 1, Unit.INSTANCE); // level 32
+        }
+
+        MCUtil.getSpiralOutChunks(spawn, radiusInBlocks >> 4).forEach(pair -> {
+            getChunkSource().getChunkAtMainThread(pair.x, pair.z);
+        });
+    }
+    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.add(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.add(x, 0, radiusInBlocks)), 1, Unit.INSTANCE); // level 32
+            // bottom
+            chunkproviderserver.removeRegionTicket(TicketType.START, new ChunkPos(spawn.add(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.add(radiusInBlocks, 0, z)), 1, Unit.INSTANCE); // level 32
+            // left
+            chunkproviderserver.removeRegionTicket(TicketType.START, new ChunkPos(spawn.add(-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.getSpawn();
+        //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.keepLoadedRange, prevSpawn);
+            this.addTicketsForSpawn(this.paperConfig.keepLoadedRange, 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 4185e6bcf9b2bb65b2a0fa5fcbeb5684615169a7..dbc29442f2b2ad3ea451910f4944e90114a317c7 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.apache.logging.log4j.Logger;
+ 
+ public class LoggerChunkProgressListener implements ChunkProgressListener {
+     private static final Logger LOGGER = LogManager.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 a7eb8f69b49bb0229de9e5a4400a4424555ac1dd..30305736b7dc023ad5eb3a177914560b3fec64ee 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -1974,15 +1974,21 @@ public class CraftWorld 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.keepLoadedRange, 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.keepLoadedRange, chunkcoordinates);
+         }
+        // Paper end
+     }
+ 
+     @Override