more more more more work

2023-09-21 22:35:39 +02:00 · 2023-09-21 22:35:39 +02:00 · 7ebfdd5e6d
commit 7ebfdd5e6d
parent 91671751e7
58 changed files with 244 additions and 241 deletions
--- a/patches/server/0101-Add-server-name-parameter.patch
+++ b/patches/server/0101-Add-server-name-parameter.patch
@ -0,0 +1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Martin Panzer <postremus1996@googlemail.com>
+Date: Sat, 28 May 2016 16:54:03 +0200
+Subject: [PATCH] Add server-name parameter
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/Main.java b/src/main/java/org/bukkit/craftbukkit/Main.java
+index c4a7da71046a4669eb98d7260d3e00b4f5411a7a..e9dbf4504232ba667ee8f6de18ab5356acd19da6 100644
+--- a/src/main/java/org/bukkit/craftbukkit/Main.java
+++ b/src/main/java/org/bukkit/craftbukkit/Main.java
+@@ -166,6 +166,14 @@ public class Main {
+                         .defaultsTo(new File[] {})
+                         .describedAs("Jar file");
+                 // Paper end
+
+                // Paper start
+                acceptsAll(asList("server-name"), "Name of the server")
+                        .withRequiredArg()
+                        .ofType(String.class)
+                        .defaultsTo("Unknown Server")
+                        .describedAs("Name");
+                // Paper end
+             }
+         };
+ 
--- a/patches/server/0102-Only-send-global-sounds-to-same-world-if-limiting-ra.patch
+++ b/patches/server/0102-Only-send-global-sounds-to-same-world-if-limiting-ra.patch
@ -0,0 +1,47 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 31 May 2016 22:53:50 -0400
+Subject: [PATCH] Only send global sounds to same world if limiting radius
+
+Co-authored-by: Evan McCarthy <evanmccarthy@outlook.com>
+Co-authored-by: lexikiq <noellekiq@gmail.com>
+
+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 3bf174b1e259aebef9007c66cf2ee8b87eae7681..1a787bd4bdbbf7c78f4bf6bd7e2f36540fec7d50 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
+@@ -680,7 +680,7 @@ public class EnderDragon extends Mob implements Enemy {
+                 // CraftBukkit start - Use relative location for far away sounds
+                 // this.level().globalLevelEvent(1028, this.blockPosition(), 0);
+                 int viewDistance = ((ServerLevel) this.level()).getCraftServer().getViewDistance() * 16;
+-                for (net.minecraft.server.level.ServerPlayer player : this.level().getServer().getPlayerList().players) {
+                for (net.minecraft.server.level.ServerPlayer player : this.level().spigotConfig.dragonDeathSoundRadius > 0 ? ((ServerLevel) this.level()).players() : this.level().getServer().getPlayerList().players) { // Paper
+                     double deltaX = this.getX() - player.getX();
+                     double deltaZ = this.getZ() - player.getZ();
+                     double distanceSquared = deltaX * deltaX + deltaZ * deltaZ;
+diff --git a/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java b/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java
+index 8d3f3987f2a6816752bdb2e477338d6dbdd6b7b7..c23f05f0d951e0036fe2cf524989747fe236730b 100644
+--- a/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java
+++ b/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java
+@@ -271,7 +271,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob
+                     // CraftBukkit start - Use relative location for far away sounds
+                     // this.level().globalLevelEvent(1023, new BlockPosition(this), 0);
+                     int viewDistance = ((ServerLevel) this.level()).getCraftServer().getViewDistance() * 16;
+-                    for (ServerPlayer player : (List<ServerPlayer>) MinecraftServer.getServer().getPlayerList().players) {
+                    for (ServerPlayer player : this.level().spigotConfig.witherSpawnSoundRadius > 0 ? ((ServerLevel) this.level()).players() : this.level().getServer().getPlayerList().players) { // Paper
+                         double deltaX = this.getX() - player.getX();
+                         double deltaZ = this.getZ() - player.getZ();
+                         double distanceSquared = deltaX * deltaX + deltaZ * deltaZ;
+diff --git a/src/main/java/net/minecraft/world/item/EnderEyeItem.java b/src/main/java/net/minecraft/world/item/EnderEyeItem.java
+index 5bc68514a1e8a212e2681f06b918548c0ec565b6..1fddc9025a9e5079f05dd6c86f6ca43c5d51d9c3 100644
+--- a/src/main/java/net/minecraft/world/item/EnderEyeItem.java
+++ b/src/main/java/net/minecraft/world/item/EnderEyeItem.java
+@@ -64,7 +64,7 @@ public class EnderEyeItem extends Item {
+                     // world.b(1038, blockposition1.c(1, 0, 1), 0);
+                     int viewDistance = world.getCraftServer().getViewDistance() * 16;
+                     BlockPos soundPos = blockposition1.offset(1, 0, 1);
+-                    for (ServerPlayer player : world.getServer().getPlayerList().players) {
+                    for (ServerPlayer player : world.spigotConfig.endPortalSoundRadius > 0 ? ((ServerLevel) world).players() : world.getServer().getPlayerList().players) { // Paper
+                         double deltaX = soundPos.getX() - player.getX();
+                         double deltaZ = soundPos.getZ() - player.getZ();
+                         double distanceSquared = deltaX * deltaX + deltaZ * deltaZ;
--- a/patches/server/0103-Avoid-blocking-on-Network-Manager-creation.patch
+++ b/patches/server/0103-Avoid-blocking-on-Network-Manager-creation.patch
@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 16 May 2016 23:19:16 -0400
+Subject: [PATCH] Avoid blocking on Network Manager creation
+
+Per Paper issue 294
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerConnectionListener.java b/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
+index dbbca784fe45b7099f683745b36f5c195ca4c2af..d870fbec236a3660f12e0f45cf9431067b18468b 100644
+--- a/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
+++ b/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
+@@ -61,6 +61,15 @@ public class ServerConnectionListener {
+     public volatile boolean running;
+     private final List<ChannelFuture> channels = Collections.synchronizedList(Lists.newArrayList());
+     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 final void addPending() {
+        Connection manager = null;
+        while ((manager = pending.poll()) != null) {
+            connections.add(manager);
+        }
+    }
+    // Paper end
+ 
+     public ServerConnectionListener(MinecraftServer server) {
+         this.server = server;
+@@ -100,7 +109,8 @@ public class ServerConnectionListener {
+                     int j = ServerConnectionListener.this.server.getRateLimitPacketsPerSecond();
+                     Connection object = j > 0 ? new RateKickingConnection(j) : new Connection(PacketFlow.SERVERBOUND); // CraftBukkit - decompile error
+ 
+-                    ServerConnectionListener.this.connections.add(object);
+                    //ServerConnectionListener.this.connections.add(object); // Paper
+                    pending.add(object); // Paper
+                     ((Connection) object).configurePacketHandler(channelpipeline);
+                     ((Connection) object).setListenerForServerboundHandshake(new ServerHandshakePacketListenerImpl(ServerConnectionListener.this.server, (Connection) object));
+                 }
+@@ -163,6 +173,7 @@ public class ServerConnectionListener {
+ 
+         synchronized (this.connections) {
+             // Spigot Start
+            this.addPending(); // Paper
+             // This prevents players from 'gaming' the server, and strategically relogging to increase their position in the tick order
+             if ( org.spigotmc.SpigotConfig.playerShuffle > 0 && MinecraftServer.currentTick % org.spigotmc.SpigotConfig.playerShuffle == 0 )
+             {
--- a/patches/server/0104-Don-t-lookup-game-profiles-that-have-no-UUID-and-no-.patch
+++ b/patches/server/0104-Don-t-lookup-game-profiles-that-have-no-UUID-and-no-.patch
@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach.brown@destroystokyo.com>
+Date: Sat, 16 Jul 2016 19:11:17 -0500
+Subject: [PATCH] Don't lookup game profiles that have no UUID and no name
+
+
+diff --git a/src/main/java/net/minecraft/server/players/GameProfileCache.java b/src/main/java/net/minecraft/server/players/GameProfileCache.java
+index 322e07adc556ee8131d40d89856574b185ee4c94..7056a0309c76fe8980d60afb4e6059deceb210d9 100644
+--- a/src/main/java/net/minecraft/server/players/GameProfileCache.java
+++ b/src/main/java/net/minecraft/server/players/GameProfileCache.java
+@@ -86,6 +86,7 @@ public class GameProfileCache {
+             }
+         };
+ 
+        if (!org.apache.commons.lang3.StringUtils.isBlank(name)) // Paper - Don't lookup a profile with a blank name)
+         repository.findProfilesByNames(new String[]{name}, profilelookupcallback);
+         GameProfile gameprofile = (GameProfile) atomicreference.get();
+ 
--- a/patches/server/0105-Add-setting-for-proxy-online-mode-status.patch
+++ b/patches/server/0105-Add-setting-for-proxy-online-mode-status.patch
@ -0,0 +1,57 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Gabriele C <sgdc3.mail@gmail.com>
+Date: Fri, 5 Aug 2016 01:03:08 +0200
+Subject: [PATCH] Add setting for proxy online mode status
+
+TODO: Add isProxyOnlineMode check to Metrics
+
+diff --git a/src/main/java/net/minecraft/server/players/GameProfileCache.java b/src/main/java/net/minecraft/server/players/GameProfileCache.java
+index 7056a0309c76fe8980d60afb4e6059deceb210d9..82f6404e5c4c5b2c9aea1b1c27ebee1d3c7ee9dc 100644
+--- a/src/main/java/net/minecraft/server/players/GameProfileCache.java
+++ b/src/main/java/net/minecraft/server/players/GameProfileCache.java
+@@ -86,7 +86,8 @@ public class GameProfileCache {
+             }
+         };
+ 
+-        if (!org.apache.commons.lang3.StringUtils.isBlank(name)) // Paper - Don't lookup a profile with a blank name)
+        if (!org.apache.commons.lang3.StringUtils.isBlank(name) // Paper - Don't lookup a profile with a blank name
+                && io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode()) // Paper - only run in online mode - 100 COL
+         repository.findProfilesByNames(new String[]{name}, profilelookupcallback);
+         GameProfile gameprofile = (GameProfile) atomicreference.get();
+ 
+@@ -104,7 +105,7 @@ public class GameProfileCache {
+     }
+ 
+     private static boolean usesAuthentication() {
+-        return GameProfileCache.usesAuthentication;
+        return io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode(); // Paper
+     }
+ 
+     public void add(GameProfile profile) {
+diff --git a/src/main/java/net/minecraft/server/players/OldUsersConverter.java b/src/main/java/net/minecraft/server/players/OldUsersConverter.java
+index 0214830d9bc98b8d435ff11f40df65596980cf77..5db27d7bcaaa2eeaeeb08401513d8d23f6cb63c7 100644
+--- a/src/main/java/net/minecraft/server/players/OldUsersConverter.java
+++ b/src/main/java/net/minecraft/server/players/OldUsersConverter.java
+@@ -65,7 +65,8 @@ public class OldUsersConverter {
+             return new String[i];
+         });
+ 
+-        if (server.usesAuthentication() || org.spigotmc.SpigotConfig.bungee) { // Spigot: bungee = online mode, for now.
+        if (server.usesAuthentication() ||
+            (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode())) { // Spigot: bungee = online mode, for now.  // Paper - Handle via setting
+             server.getProfileRepository().findProfilesByNames(astring, callback);
+         } else {
+             String[] astring1 = astring;
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 6797239634ba90768e55fcfb37cb2c14141b7d28..e9c908750f40429108ce21cd2e01630d1416435b 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -1727,7 +1727,7 @@ public final class CraftServer implements Server {
+             // Spigot Start
+             GameProfile profile = null;
+             // Only fetch an online UUID in online mode
+-            if ( this.getOnlineMode() || org.spigotmc.SpigotConfig.bungee )
+            if ( this.getOnlineMode() || io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode() ) // Paper - Handle via setting
+             {
+                 profile = this.console.getProfileCache().get(name).orElse(null);
+             }
--- a/patches/server/0106-Optimise-BlockState-s-hashCode-equals.patch
+++ b/patches/server/0106-Optimise-BlockState-s-hashCode-equals.patch
@ -0,0 +1,72 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Alfie Cleveland <alfeh@me.com>
+Date: Fri, 19 Aug 2016 01:52:56 +0100
+Subject: [PATCH] Optimise BlockState's hashCode/equals
+
+These are singleton "single instance" objects. We can rely on
+object identity checks safely.
+
+Use a simpler optimized hashcode
+
+diff --git a/src/main/java/net/minecraft/world/level/block/state/properties/BooleanProperty.java b/src/main/java/net/minecraft/world/level/block/state/properties/BooleanProperty.java
+index 3084343b724098de9791bb74ffb037a499c0c430..bf7ed22094ac92a152e522bafccffb9589f84343 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/properties/BooleanProperty.java
+++ b/src/main/java/net/minecraft/world/level/block/state/properties/BooleanProperty.java
+@@ -30,8 +30,7 @@ public class BooleanProperty extends Property<Boolean> {
+         return value.toString();
+     }
+ 
+-    @Override
+-    public boolean equals(Object object) {
+    public boolean equals_unused(Object object) { // Paper
+         if (this == object) {
+             return true;
+         } else {
+diff --git a/src/main/java/net/minecraft/world/level/block/state/properties/EnumProperty.java b/src/main/java/net/minecraft/world/level/block/state/properties/EnumProperty.java
+index 647e295c7761b95db6da28f6fd043ec963f27872..2d69d1c17f734ee38667d51e6fd0a268211ec595 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/properties/EnumProperty.java
+++ b/src/main/java/net/minecraft/world/level/block/state/properties/EnumProperty.java
+@@ -45,8 +45,7 @@ public class EnumProperty<T extends Enum<T> & StringRepresentable> extends Prope
+         return value.getSerializedName();
+     }
+ 
+-    @Override
+-    public boolean equals(Object object) {
+    public boolean equals_unused(Object object) { // Paper
+         if (this == object) {
+             return true;
+         } else {
+diff --git a/src/main/java/net/minecraft/world/level/block/state/properties/IntegerProperty.java b/src/main/java/net/minecraft/world/level/block/state/properties/IntegerProperty.java
+index d6c1b1817ba79a652c4094f003a7d899d4939971..33268d953b30d384564eee6dfab2a37fa722e465 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/properties/IntegerProperty.java
+++ b/src/main/java/net/minecraft/world/level/block/state/properties/IntegerProperty.java
+@@ -35,8 +35,7 @@ public class IntegerProperty extends Property<Integer> {
+         return this.values;
+     }
+ 
+-    @Override
+-    public boolean equals(Object object) {
+    public boolean equals_unused(Object object) { // Paper
+         if (this == object) {
+             return true;
+         } else {
+diff --git a/src/main/java/net/minecraft/world/level/block/state/properties/Property.java b/src/main/java/net/minecraft/world/level/block/state/properties/Property.java
+index d1f2e29623b15fdb99ba082fd757a54fd4713761..66b8e23d799adaf872233ea44c54330d75135544 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/properties/Property.java
+++ b/src/main/java/net/minecraft/world/level/block/state/properties/Property.java
+@@ -70,14 +70,7 @@ public abstract class Property<T extends Comparable<T>> {
+ 
+     @Override
+     public boolean equals(Object object) {
+-        if (this == object) {
+-            return true;
+-        } else if (!(object instanceof Property)) {
+-            return false;
+-        } else {
+-            Property<?> property = (Property)object;
+-            return this.clazz.equals(property.clazz) && this.name.equals(property.name);
+-        }
+        return this == object; // Paper
+     }
+ 
+     @Override
--- a/patches/server/0107-Configurable-packet-in-spam-threshold.patch
+++ b/patches/server/0107-Configurable-packet-in-spam-threshold.patch
@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach.brown@destroystokyo.com>
+Date: Sun, 11 Sep 2016 14:30:57 -0500
+Subject: [PATCH] Configurable packet in spam threshold
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index e58a87d933b916dd246f392577432d8022f117f7..0ce757dd60d167886d56eb651140cec93b1af41e 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1498,13 +1498,14 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+     // Spigot start - limit place/interactions
+     private int limitedPackets;
+     private long lastLimitedPacket = -1;
+    private static int getSpamThreshold() { return io.papermc.paper.configuration.GlobalConfiguration.get().spamLimiter.incomingPacketThreshold; } // Paper - Configurable threshold
+ 
+     private boolean checkLimit(long timestamp) {
+-        if (this.lastLimitedPacket != -1 && timestamp - this.lastLimitedPacket < 30 && this.limitedPackets++ >= 4) {
+        if (this.lastLimitedPacket != -1 && timestamp - this.lastLimitedPacket < getSpamThreshold() && this.limitedPackets++ >= 8) { // Paper - Use threshold, raise packet limit to 8
+             return false;
+         }
+ 
+-        if (this.lastLimitedPacket == -1 || timestamp - this.lastLimitedPacket >= 30) {
+        if (this.lastLimitedPacket == -1 || timestamp - this.lastLimitedPacket >= getSpamThreshold()) { // Paper
+             this.lastLimitedPacket = timestamp;
+             this.limitedPackets = 0;
+             return true;
--- a/patches/server/0108-Configurable-flying-kick-messages.patch
+++ b/patches/server/0108-Configurable-flying-kick-messages.patch
@ -0,0 +1,28 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: kashike <kashike@vq.lc>
+Date: Tue, 20 Sep 2016 00:58:01 +0000
+Subject: [PATCH] Configurable flying kick messages
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 0ce757dd60d167886d56eb651140cec93b1af41e..4c9454589b5fe98d8b6be84fe07970efa5f07732 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -336,7 +336,7 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+         if (this.clientIsFloating && !this.player.isSleeping() && !this.player.isPassenger() && !this.player.isDeadOrDying()) {
+             if (++this.aboveGroundTickCount > 80) {
+                 ServerGamePacketListenerImpl.LOGGER.warn("{} was kicked for floating too long!", this.player.getName().getString());
+-                this.disconnect(Component.translatable("multiplayer.disconnect.flying"));
+                this.disconnect(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.flyingPlayer); // Paper - use configurable kick message
+                 return;
+             }
+         } else {
+@@ -355,7 +355,7 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+             if (this.clientVehicleIsFloating && this.player.getRootVehicle().getControllingPassenger() == this.player) {
+                 if (++this.aboveGroundVehicleTickCount > 80) {
+                     ServerGamePacketListenerImpl.LOGGER.warn("{} was kicked for floating a vehicle too long!", this.player.getName().getString());
+-                    this.disconnect(Component.translatable("multiplayer.disconnect.flying"));
+                    this.disconnect(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.flyingVehicle); // Paper - use configurable kick message
+                     return;
+                 }
+             } else {
--- a/patches/server/0109-Add-EntityZapEvent.patch
+++ b/patches/server/0109-Add-EntityZapEvent.patch
@ -0,0 +1,48 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: AlphaBlend <whizkid3000@hotmail.com>
+Date: Sun, 16 Oct 2016 23:19:30 -0700
+Subject: [PATCH] Add EntityZapEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+index 2f97e4f0078cecbcf044d0b27f375638a6ea047b..b70ee1dff0442de32a9e20ad54b246d5eae45e58 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
+++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+@@ -851,10 +851,17 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+     @Override
+     public void thunderHit(ServerLevel world, LightningBolt lightning) {
+         if (world.getDifficulty() != Difficulty.PEACEFUL) {
+-            Villager.LOGGER.info("Villager {} was struck by lightning {}.", this, lightning);
+            // Paper - move log down, event can cancel
+             Witch entitywitch = (Witch) EntityType.WITCH.create(world);
+ 
+             if (entitywitch != null) {
+                // Paper start
+                if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityZapEvent(this, lightning, entitywitch).isCancelled()) {
+                    return;
+                }
+                if (org.spigotmc.SpigotConfig.logVillagerDeaths) Villager.LOGGER.info("Villager {} was struck by lightning {}.", this, lightning); // Move down
+                // Paper end
+
+                 entitywitch.moveTo(this.getX(), this.getY(), this.getZ(), this.getYRot(), this.getXRot());
+                 entitywitch.finalizeSpawn(world, world.getCurrentDifficultyAt(entitywitch.blockPosition()), MobSpawnType.CONVERSION, (SpawnGroupData) null, (CompoundTag) null);
+                 entitywitch.setNoAi(this.isNoAi());
+diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+index 8e1bb9d86ec12240b00ee118a88ebe4dec4e6329..e974520bb5c069229b214962a5e377b92c07e339 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -1240,6 +1240,14 @@ public class CraftEventFactory {
+         return !event.isCancelled();
+     }
+ 
+    // Paper start
+    public static com.destroystokyo.paper.event.entity.EntityZapEvent callEntityZapEvent (Entity entity, Entity lightning, Entity changedEntity) {
+        com.destroystokyo.paper.event.entity.EntityZapEvent event = new com.destroystokyo.paper.event.entity.EntityZapEvent(entity.getBukkitEntity(), (LightningStrike) lightning.getBukkitEntity(), changedEntity.getBukkitEntity());
+        entity.getBukkitEntity().getServer().getPluginManager().callEvent(event);
+        return event;
+    }
+    // Paper end
+
+     public static boolean callEntityChangeBlockEvent(Entity entity, BlockPos position, net.minecraft.world.level.block.state.BlockState newBlock) {
+         return CraftEventFactory.callEntityChangeBlockEvent(entity, position, newBlock, false);
+     }
--- a/patches/server/0110-Filter-bad-tile-entity-nbt-data-from-falling-blocks.patch
+++ b/patches/server/0110-Filter-bad-tile-entity-nbt-data-from-falling-blocks.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach.brown@destroystokyo.com>
+Date: Sat, 12 Nov 2016 23:25:22 -0600
+Subject: [PATCH] Filter bad tile entity nbt data from falling blocks
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java b/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java
+index 90f52ed06b4493610f65c8a82d6a3a3b32fef1a7..b8c8b10656e4151c8c19b8cecc3bc7502dd57d3d 100644
+--- a/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java
+++ b/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java
+@@ -334,7 +334,7 @@ public class FallingBlockEntity extends Entity {
+             this.dropItem = nbt.getBoolean("DropItem");
+         }
+ 
+-        if (nbt.contains("TileEntityData", 10)) {
+        if (nbt.contains("TileEntityData", 10) && !(this.level().paperConfig().entities.spawning.filterBadTileEntityNbtFromFallingBlocks && this.blockState.getBlock() instanceof net.minecraft.world.level.block.GameMasterBlock)) {
+             this.blockData = nbt.getCompound("TileEntityData");
+         }
+ 
--- a/patches/server/0111-Cache-user-authenticator-threads.patch
+++ b/patches/server/0111-Cache-user-authenticator-threads.patch
@ -0,0 +1,63 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Alfie Cleveland <alfeh@me.com>
+Date: Fri, 25 Nov 2016 13:22:40 +0000
+Subject: [PATCH] Cache user authenticator threads
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+index ef5d73a296982d8b9ac022c5ea755843c2da1c84..490af173c265d03904396e9336c95520fcd16c48 100644
+--- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+@@ -139,8 +139,8 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
+                 this.connection.send(new ClientboundHelloPacket("", this.server.getKeyPair().getPublic().getEncoded(), this.challenge));
+             } else {
+                 // Spigot start
+-                new Thread("User Authenticator #" + ServerLoginPacketListenerImpl.UNIQUE_THREAD_ID.incrementAndGet()) {
+-
+            // Paper start - Cache authenticator threads
+            authenticatorPool.execute(new Runnable() {
+                     @Override
+                     public void run() {
+                         try {
+@@ -150,7 +150,8 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
+                             server.server.getLogger().log(java.util.logging.Level.WARNING, "Exception verifying " + ServerLoginPacketListenerImpl.this.requestedUsername, ex);
+                         }
+                     }
+-                }.start();
+            });
+            // Paper end
+                 // Spigot end
+             }
+ 
+@@ -223,7 +224,8 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
+             throw new IllegalStateException("Protocol error", cryptographyexception);
+         }
+ 
+-        Thread thread = new Thread("User Authenticator #" + ServerLoginPacketListenerImpl.UNIQUE_THREAD_ID.incrementAndGet()) {
+        // Paper start - Cache authenticator threads
+        authenticatorPool.execute(new Runnable() {
+             public void run() {
+                 String s1 = (String) Objects.requireNonNull(ServerLoginPacketListenerImpl.this.requestedUsername, "Player name not initialized");
+ 
+@@ -269,10 +271,8 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
+ 
+                 return ServerLoginPacketListenerImpl.this.server.getPreventProxyConnections() && socketaddress instanceof InetSocketAddress ? ((InetSocketAddress) socketaddress).getAddress() : null;
+             }
+-        };
+-
+-        thread.setUncaughtExceptionHandler(new DefaultUncaughtExceptionHandler(ServerLoginPacketListenerImpl.LOGGER));
+-        thread.start();
+        });
+        // Paper end
+     }
+ 
+     // Spigot start
+@@ -333,6 +333,8 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
+         this.state = ServerLoginPacketListenerImpl.State.ACCEPTED;
+     }
+ 
+    private static final java.util.concurrent.ExecutorService authenticatorPool = java.util.concurrent.Executors.newCachedThreadPool(new com.google.common.util.concurrent.ThreadFactoryBuilder().setNameFormat("User Authenticator #%d").setUncaughtExceptionHandler(new DefaultUncaughtExceptionHandler(LOGGER)).build()); // Paper - Cache authenticator threads
+
+     // Spigot start
+     protected GameProfile createOfflineProfile(String name) {
+         UUID uuid;
--- a/patches/server/0112-Allow-Reloading-of-Command-Aliases.patch
+++ b/patches/server/0112-Allow-Reloading-of-Command-Aliases.patch
@ -0,0 +1,36 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: willies952002 <admin@domnian.com>
+Date: Mon, 28 Nov 2016 10:21:52 -0500
+Subject: [PATCH] Allow Reloading of Command Aliases
+
+Reload the aliases stored in commands.yml
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index e9c908750f40429108ce21cd2e01630d1416435b..c23e5dc08bbcbdc5787c730f0a2857aacff2e69e 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -2648,5 +2648,24 @@ public final class CraftServer implements Server {
+         DefaultPermissions.registerCorePermissions();
+         CraftDefaultPermissions.registerCorePermissions();
+     }
+
+    @Override
+    public boolean reloadCommandAliases() {
+        Set<String> removals = getCommandAliases().keySet().stream()
+                .map(key -> key.toLowerCase(java.util.Locale.ENGLISH))
+                .collect(java.util.stream.Collectors.toSet());
+        getCommandMap().getKnownCommands().keySet().removeIf(removals::contains);
+        File file = getCommandsConfigFile();
+        try {
+            commandsConfiguration.load(file);
+        } catch (FileNotFoundException ex) {
+            return false;
+        } catch (IOException | org.bukkit.configuration.InvalidConfigurationException ex) {
+            Bukkit.getLogger().log(Level.SEVERE, "Cannot load " + file, ex);
+            return false;
+        }
+        commandMap.registerServerAliases();
+        return true;
+    }
+     // Paper end
+ }
--- a/patches/server/0113-Add-source-to-PlayerExpChangeEvent.patch
+++ b/patches/server/0113-Add-source-to-PlayerExpChangeEvent.patch
@ -0,0 +1,41 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: AlphaBlend <whizkid3000@hotmail.com>
+Date: Thu, 8 Sep 2016 08:48:33 -0700
+Subject: [PATCH] Add source to PlayerExpChangeEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+index 93c83cfedc7d3a169ad0504aa6e63f600873501b..9dffdfe5bbd0517e9a2c6a6770eea07b43ef9b33 100644
+--- a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+++ b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+@@ -254,7 +254,7 @@ public class ExperienceOrb extends Entity {
+                 int i = this.repairPlayerItems(player, this.value);
+ 
+                 if (i > 0) {
+-                    player.giveExperiencePoints(CraftEventFactory.callPlayerExpChangeEvent(player, i).getAmount()); // CraftBukkit - this.value -> event.getAmount()
+                    player.giveExperiencePoints(CraftEventFactory.callPlayerExpChangeEvent(player, this).getAmount()); // CraftBukkit - this.value -> event.getAmount() // Paper - supply experience orb object
+                 }
+ 
+                 --this.count;
+diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+index e974520bb5c069229b214962a5e377b92c07e339..db681778c2eae84b1e564413ba239b7300ea1789 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -1193,6 +1193,17 @@ public class CraftEventFactory {
+         return event;
+     }
+ 
+    // Paper start - Add orb
+    public static PlayerExpChangeEvent callPlayerExpChangeEvent(net.minecraft.world.entity.player.Player entity, net.minecraft.world.entity.ExperienceOrb entityOrb) {
+        Player player = (Player) entity.getBukkitEntity();
+        ExperienceOrb source = (ExperienceOrb) entityOrb.getBukkitEntity();
+        int expAmount = source.getExperience();
+        PlayerExpChangeEvent event = new PlayerExpChangeEvent(player, source, expAmount);
+        Bukkit.getPluginManager().callEvent(event);
+        return event;
+    }
+    // Paper end
+
+     public static boolean handleBlockGrowEvent(Level world, BlockPos pos, net.minecraft.world.level.block.state.BlockState block) {
+         return CraftEventFactory.handleBlockGrowEvent(world, pos, block, 3);
+     }
--- a/patches/server/0114-Add-ProjectileCollideEvent.patch
+++ b/patches/server/0114-Add-ProjectileCollideEvent.patch
@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Techcable <Techcable@outlook.com>
+Date: Fri, 16 Dec 2016 21:25:39 -0600
+Subject: [PATCH] Add ProjectileCollideEvent
+
+Deprecated now and replaced with ProjectileHitEvent
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+index db681778c2eae84b1e564413ba239b7300ea1789..f51a0e99d7e3ad6379057175931cf95e863b45dd 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -1337,6 +1337,17 @@ public class CraftEventFactory {
+         return CraftItemStack.asNMSCopy(bitem);
+     }
+ 
+    // Paper start
+    @Deprecated
+    public static com.destroystokyo.paper.event.entity.ProjectileCollideEvent callProjectileCollideEvent(Entity entity, EntityHitResult position) {
+        Projectile projectile = (Projectile) entity.getBukkitEntity();
+        org.bukkit.entity.Entity collided = position.getEntity().getBukkitEntity();
+        com.destroystokyo.paper.event.entity.ProjectileCollideEvent event = new com.destroystokyo.paper.event.entity.ProjectileCollideEvent(projectile, collided);
+        Bukkit.getPluginManager().callEvent(event);
+        return event;
+    }
+    // Paper end
+
+     public static ProjectileLaunchEvent callProjectileLaunchEvent(Entity entity) {
+         Projectile bukkitEntity = (Projectile) entity.getBukkitEntity();
+         ProjectileLaunchEvent event = new ProjectileLaunchEvent(bukkitEntity);
+@@ -1361,8 +1372,15 @@ public class CraftEventFactory {
+         if (position.getType() == HitResult.Type.ENTITY) {
+             hitEntity = ((EntityHitResult) position).getEntity().getBukkitEntity();
+         }
+        // Paper start - legacy event
+        boolean cancelled = false;
+        if (hitEntity != null && position instanceof EntityHitResult entityHitResult) {
+            cancelled = callProjectileCollideEvent(entity, entityHitResult).isCancelled();
+        }
+        // Paper end
+ 
+         ProjectileHitEvent event = new ProjectileHitEvent((Projectile) entity.getBukkitEntity(), hitEntity, hitBlock, hitFace);
+        event.setCancelled(cancelled); // Paper - propagate legacy event cancellation to modern event
+         entity.level().getCraftServer().getPluginManager().callEvent(event);
+         return event;
+     }
--- a/patches/server/0115-Prevent-Pathfinding-out-of-World-Border.patch
+++ b/patches/server/0115-Prevent-Pathfinding-out-of-World-Border.patch
@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 19 Dec 2016 23:07:42 -0500
+Subject: [PATCH] Prevent Pathfinding out of World Border
+
+This prevents Entities from trying to run outside of the World Border
+
+TODO: This doesn't prevent the pathfinder from using blocks outside the world border as nodes. We can fix this
+by adding code to all overrides in:
+    NodeEvaluator:
+    public abstract BlockPathTypes getBlockPathType(BlockGetter world, int x, int y, int z);
+
+to return BLOCKED if it is outside the world border.
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java b/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java
+index d14b329e5bccf13139c32f71da274082efc7199c..68edd488087a6ec1e65797cfbd4118bd0efbab50 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java
+++ b/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java
+@@ -158,7 +158,7 @@ public abstract class PathNavigation {
+             // Paper start - Pathfind event
+             boolean copiedSet = false;
+             for (BlockPos possibleTarget : positions) {
+-                if (!new com.destroystokyo.paper.event.entity.EntityPathfindEvent(this.mob.getBukkitEntity(),
+                if (!this.mob.getCommandSenderWorld().getWorldBorder().isWithinBounds(possibleTarget) || !new com.destroystokyo.paper.event.entity.EntityPathfindEvent(this.mob.getBukkitEntity(), // Paper - don't path out of world border
+                     io.papermc.paper.util.MCUtil.toLocation(this.mob.level(), possibleTarget), target == null ? null : target.getBukkitEntity()).callEvent()) {
+                     if (!copiedSet) {
+                         copiedSet = true;
--- a/patches/server/0116-Optimize-World.isLoaded-BlockPosition-Z.patch
+++ b/patches/server/0116-Optimize-World.isLoaded-BlockPosition-Z.patch
@ -0,0 +1,23 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Fri, 2 Dec 2016 00:11:43 -0500
+Subject: [PATCH] Optimize World.isLoaded(BlockPosition)Z
+
+Reduce method invocations for World.isLoaded(BlockPosition)Z
+
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index efb2c0f5f7b3acd127f9a570d00c5826c9e9bb6f..936f21b61589a6bcd9bf19c7466b9b1b9a14f280 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -427,6 +427,11 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+         return chunk == null ? null : chunk.getFluidState(blockposition);
+     }
+ 
+    @Override
+    public final boolean hasChunkAt(BlockPos pos) {
+        return getChunkIfLoaded(pos.getX() >> 4, pos.getZ() >> 4) != null; // Paper
+    }
+
+     public final boolean isLoadedAndInBounds(BlockPos blockposition) { // Paper - final for inline
+         return getWorldBorder().isWithinBounds(blockposition) && getChunkIfLoadedImmediately(blockposition.getX() >> 4, blockposition.getZ() >> 4) != null;
+     }
--- a/patches/server/0117-Bound-Treasure-Maps-to-World-Border.patch
+++ b/patches/server/0117-Bound-Treasure-Maps-to-World-Border.patch
@ -0,0 +1,47 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 20 Dec 2016 15:15:11 -0500
+Subject: [PATCH] Bound Treasure Maps to World Border
+
+Make it so a Treasure Map does not target a structure outside of the
+World Border, where players are not even able to reach.
+
+This also would help the case where a players close to the border, and one
+that is outside happens to be closer, but unreachable, yet another reachable
+one is in border that would of been missed.
+
+diff --git a/src/main/java/net/minecraft/world/level/border/WorldBorder.java b/src/main/java/net/minecraft/world/level/border/WorldBorder.java
+index 52325a99ea38530ad69a39ac0215233139f35268..dd74e8a034022fe72a1652f92712182b4910f651 100644
+--- a/src/main/java/net/minecraft/world/level/border/WorldBorder.java
+++ b/src/main/java/net/minecraft/world/level/border/WorldBorder.java
+@@ -37,6 +37,18 @@ public class WorldBorder {
+         return (double) (pos.getX() + 1) > this.getMinX() && (double) pos.getX() < this.getMaxX() && (double) (pos.getZ() + 1) > this.getMinZ() && (double) pos.getZ() < this.getMaxZ();
+     }
+ 
+    // Paper start
+    private final BlockPos.MutableBlockPos mutPos = new BlockPos.MutableBlockPos();
+    public boolean isBlockInBounds(int chunkX, int chunkZ) {
+        this.mutPos.set(chunkX, 64, chunkZ);
+        return this.isWithinBounds(this.mutPos);
+    }
+    public boolean isChunkInBounds(int chunkX, int chunkZ) {
+        this.mutPos.set(((chunkX << 4) + 15), 64, (chunkZ << 4) + 15);
+        return this.isWithinBounds(this.mutPos);
+    }
+    // Paper end
+
+     public boolean isWithinBounds(ChunkPos pos) {
+         return (double) pos.getMaxBlockX() > this.getMinX() && (double) pos.getMinBlockX() < this.getMaxX() && (double) pos.getMaxBlockZ() > this.getMinZ() && (double) pos.getMinBlockZ() < this.getMaxZ();
+     }
+diff --git a/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java b/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
+index f739a175e26f250c652c73b8985158fe37c2823a..d70317d0306a7b55ba88b0d2360c9b190454e049 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
+++ b/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
+@@ -217,6 +217,7 @@ public abstract class ChunkGenerator {
+ 
+             while (iterator.hasNext()) {
+                 ChunkPos chunkcoordintpair = (ChunkPos) iterator.next();
+                if (!world.getWorldBorder().isChunkInBounds(chunkcoordintpair.x, chunkcoordintpair.z)) { continue; } // Paper
+ 
+                 blockposition_mutableblockposition.set(SectionPos.sectionToBlockCoord(chunkcoordintpair.x, 8), 32, SectionPos.sectionToBlockCoord(chunkcoordintpair.z, 8));
+                 double d1 = blockposition_mutableblockposition.distSqr(center);
--- a/patches/server/0118-Configurable-Cartographer-Treasure-Maps.patch
+++ b/patches/server/0118-Configurable-Cartographer-Treasure-Maps.patch
@ -0,0 +1,46 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 20 Dec 2016 15:26:27 -0500
+Subject: [PATCH] Configurable Cartographer Treasure Maps
+
+Allow configuring for cartographers to return the same map location
+
+Also allow turning off treasure maps all together as they can eat up Map ID's
+which are limited in quantity.
+
+diff --git a/src/main/java/net/minecraft/world/entity/npc/VillagerTrades.java b/src/main/java/net/minecraft/world/entity/npc/VillagerTrades.java
+index 43fb44b8cd164b0815335a32f04879b301a54728..8d0ff6e820af9a3f67e25298b34d1539841339d8 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/VillagerTrades.java
+++ b/src/main/java/net/minecraft/world/entity/npc/VillagerTrades.java
+@@ -451,7 +451,8 @@ public class VillagerTrades {
+                 return null;
+             } else {
+                 ServerLevel serverLevel = (ServerLevel)entity.level();
+-                BlockPos blockPos = serverLevel.findNearestMapStructure(this.destination, entity.blockPosition(), 100, true);
+                if (!serverLevel.paperConfig().environment.treasureMaps.enabled) return null; // Paper
+                BlockPos blockPos = serverLevel.findNearestMapStructure(this.destination, entity.blockPosition(), 100, !serverLevel.paperConfig().environment.treasureMaps.findAlreadyDiscoveredVillager); // Paper
+                 if (blockPos != null) {
+                     ItemStack itemStack = MapItem.create(serverLevel, blockPos.getX(), blockPos.getZ(), (byte)2, true, true);
+                     MapItem.renderBiomePreviewMap(serverLevel, itemStack);
+diff --git a/src/main/java/net/minecraft/world/level/storage/loot/functions/ExplorationMapFunction.java b/src/main/java/net/minecraft/world/level/storage/loot/functions/ExplorationMapFunction.java
+index a926b07cd3c5d7c6b615302671fedb51eff89faf..7c8267ad6de50daaa3390debf99a354e3e575c87 100644
+--- a/src/main/java/net/minecraft/world/level/storage/loot/functions/ExplorationMapFunction.java
+++ b/src/main/java/net/minecraft/world/level/storage/loot/functions/ExplorationMapFunction.java
+@@ -75,7 +75,16 @@ public class ExplorationMapFunction extends LootItemConditionalFunction {
+             Vec3 vec3 = context.getParamOrNull(LootContextParams.ORIGIN);
+             if (vec3 != null) {
+                 ServerLevel serverLevel = context.getLevel();
+-                BlockPos blockPos = serverLevel.findNearestMapStructure(this.destination, BlockPos.containing(vec3), this.searchRadius, this.skipKnownStructures);
+                // Paper start
+                if (!serverLevel.paperConfig().environment.treasureMaps.enabled) {
+                    /*
+                     * NOTE: I fear users will just get a plain map as their "treasure"
+                     * This is preferable to disrespecting the config.
+                     */
+                    return stack;
+                }
+                // Paper end
+                BlockPos blockPos = serverLevel.findNearestMapStructure(this.destination, BlockPos.containing(vec3), this.searchRadius, !serverLevel.paperConfig().environment.treasureMaps.findAlreadyDiscoveredLootTable.or(!this.skipKnownStructures)); // Paper
+                 if (blockPos != null) {
+                     ItemStack itemStack = MapItem.create(serverLevel, blockPos.getX(), blockPos.getZ(), this.zoom, true, true);
+                     MapItem.renderBiomePreviewMap(serverLevel, itemStack);
--- a/patches/server/0119-Add-API-methods-to-control-if-armour-stands-can-move.patch
+++ b/patches/server/0119-Add-API-methods-to-control-if-armour-stands-can-move.patch
@ -0,0 +1,52 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: kashike <kashike@vq.lc>
+Date: Wed, 21 Dec 2016 11:47:25 -0600
+Subject: [PATCH] Add API methods to control if armour stands can move
+
+
+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 c0c4bbf25b2da40f53b1cdedb47fdd74b493fba2..d79fbc3e1cab0d4ec38ae25325e55eb23a1b5a19 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+++ b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+@@ -92,6 +92,7 @@ public class ArmorStand extends LivingEntity {
+     public Rotations rightArmPose;
+     public Rotations leftLegPose;
+     public Rotations rightLegPose;
+    public boolean canMove = true; // Paper
+ 
+     public ArmorStand(EntityType<? extends ArmorStand> type, Level world) {
+         super(type, world);
+@@ -950,4 +951,13 @@ public class ArmorStand extends LivingEntity {
+     public boolean canBeSeenByAnyone() {
+         return !this.isInvisible() && !this.isMarker();
+     }
+
+    // Paper start
+    @Override
+    public void move(net.minecraft.world.entity.MoverType type, Vec3 movement) {
+        if (this.canMove) {
+            super.move(type, movement);
+        }
+    }
+    // Paper end
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
+index 76536f0d700fb4b120ffef066588e305013a5a66..fc3b98746a558b3ad6c89543170225bdae1e63ba 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
+@@ -222,4 +222,15 @@ public class CraftArmorStand extends CraftLivingEntity implements ArmorStand {
+     public boolean hasEquipmentLock(EquipmentSlot equipmentSlot, LockType lockType) {
+         return (this.getHandle().disabledSlots & (1 << CraftEquipmentSlot.getNMS(equipmentSlot).getFilterFlag() + lockType.ordinal() * 8)) != 0;
+     }
+    // Paper start
+    @Override
+    public boolean canMove() {
+        return getHandle().canMove;
+    }
+
+    @Override
+    public void setCanMove(boolean move) {
+        getHandle().canMove = move;
+    }
+    // Paper end
+ }
--- a/patches/server/0120-String-based-Action-Bar-API.patch
+++ b/patches/server/0120-String-based-Action-Bar-API.patch
@ -0,0 +1,61 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 27 Dec 2016 15:02:42 -0500
+Subject: [PATCH] String based Action Bar API
+
+
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetActionBarTextPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetActionBarTextPacket.java
+index 32ef3edebe94a2014168b7e438752a80b2687e5f..ab6c58eed6707ab7b0aa3e7549a871ad7dfad87f 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetActionBarTextPacket.java
+++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetActionBarTextPacket.java
+@@ -7,6 +7,7 @@ import net.minecraft.network.protocol.Packet;
+ public class ClientboundSetActionBarTextPacket implements Packet<ClientGamePacketListener> {
+     private final Component text;
+     public net.kyori.adventure.text.Component adventure$text; // Paper
+    public net.md_5.bungee.api.chat.BaseComponent[] components; // Paper
+ 
+     public ClientboundSetActionBarTextPacket(Component message) {
+         this.text = message;
+@@ -21,6 +22,8 @@ public class ClientboundSetActionBarTextPacket implements Packet<ClientGamePacke
+         // Paper start
+         if (this.adventure$text != null) {
+             buf.writeComponent(this.adventure$text);
+        } else if (this.components != null) {
+            buf.writeComponent(this.components);
+         } else
+         // Paper end
+         buf.writeComponent(this.text);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 6deb65557561268ae7126cbb9e177def16d89d97..38c544cdf2230e94850eda4d38afce9df53973a8 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -300,6 +300,29 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     }
+ 
+     // Paper start
+    @Override
+    @Deprecated
+    public void sendActionBar(BaseComponent[] message) {
+        if (getHandle().connection == null) return;
+        net.minecraft.network.protocol.game.ClientboundSetActionBarTextPacket packet = new net.minecraft.network.protocol.game.ClientboundSetActionBarTextPacket((net.minecraft.network.chat.Component) null);
+        packet.components = message;
+        getHandle().connection.send(packet);
+    }
+
+    @Override
+    @Deprecated
+    public void sendActionBar(String message) {
+        if (getHandle().connection == null || message == null || message.isEmpty()) return;
+        getHandle().connection.send(new net.minecraft.network.protocol.game.ClientboundSetActionBarTextPacket(CraftChatMessage.fromStringOrNull(message)));
+    }
+
+    @Override
+    @Deprecated
+    public void sendActionBar(char alternateChar, String message) {
+        if (message == null || message.isEmpty()) return;
+        sendActionBar(org.bukkit.ChatColor.translateAlternateColorCodes(alternateChar, message));
+    }
+
+     @Override
+     public void setPlayerListHeaderFooter(BaseComponent[] header, BaseComponent[] footer) {
+          if (header != null) {
--- a/patches/server/0121-Properly-fix-item-duplication-bug.patch
+++ b/patches/server/0121-Properly-fix-item-duplication-bug.patch
@ -0,0 +1,33 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Alfie Cleveland <alfeh@me.com>
+Date: Tue, 27 Dec 2016 01:57:57 +0000
+Subject: [PATCH] Properly fix item duplication bug
+
+Credit to prplz for figuring out the real issue
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index d90748aab21adf9c7f463e31e7d7eb5f9bc0bbbd..40efa19ffe9275748a62e0546c3fd42bbcb0883d 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -2352,7 +2352,7 @@ public class ServerPlayer extends Player {
+ 
+     @Override
+     public boolean isImmobile() {
+-        return super.isImmobile() || !this.getBukkitEntity().isOnline();
+        return super.isImmobile() || (this.connection != null && this.connection.isDisconnected()); // Paper
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+index e8b12a8ae009023afa2818ecbf398a1440b9926e..6faec2ca225fcebbad65190ab485e2cab77cfd6e 100644
+--- a/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+@@ -145,7 +145,7 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+     }
+ 
+     public final boolean isDisconnected() {
+-        return !this.player.joining && !this.connection.isConnected();
+        return (!this.player.joining && !this.connection.isConnected()) || this.processedDisconnect; // Paper
+     }
+     // CraftBukkit end
+ 
--- a/patches/server/0122-Firework-API-s.patch
+++ b/patches/server/0122-Firework-API-s.patch
@ -0,0 +1,93 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Wed, 28 Dec 2016 07:18:33 +0100
+Subject: [PATCH] Firework API's
+
+== AT ==
+public net.minecraft.world.entity.projectile.FireworkRocketEntity attachedToEntity
+
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java b/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java
+index b16add0be6ac782a7e40be0cdeea4c1829a19d4e..288910fb168ddc5d3a61971778b8038a56772fa8 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java
+@@ -38,6 +38,7 @@ public class FireworkRocketEntity extends Projectile implements ItemSupplier {
+     public int lifetime;
+     @Nullable
+     public LivingEntity attachedToEntity;
+    public java.util.UUID spawningEntity; // Paper
+ 
+     public FireworkRocketEntity(EntityType<? extends FireworkRocketEntity> type, Level world) {
+         super(type, world);
+@@ -317,6 +318,11 @@ public class FireworkRocketEntity extends Projectile implements ItemSupplier {
+         }
+ 
+         nbt.putBoolean("ShotAtAngle", (Boolean) this.entityData.get(FireworkRocketEntity.DATA_SHOT_AT_ANGLE));
+        // Paper start
+        if (this.spawningEntity != null) {
+            nbt.putUUID("SpawningEntity", this.spawningEntity);
+        }
+        // Paper end
+     }
+ 
+     @Override
+@@ -333,7 +339,11 @@ public class FireworkRocketEntity extends Projectile implements ItemSupplier {
+         if (nbt.contains("ShotAtAngle")) {
+             this.entityData.set(FireworkRocketEntity.DATA_SHOT_AT_ANGLE, nbt.getBoolean("ShotAtAngle"));
+         }
+-
+        // Paper start
+        if (nbt.hasUUID("SpawningEntity")) {
+            this.spawningEntity = nbt.getUUID("SpawningEntity");
+        }
+        // Paper end
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/item/CrossbowItem.java b/src/main/java/net/minecraft/world/item/CrossbowItem.java
+index ac7371882d15746e9353865635d0bb716f890c53..ba570f1c9654e1004e068a1efe2118f36c954505 100644
+--- a/src/main/java/net/minecraft/world/item/CrossbowItem.java
+++ b/src/main/java/net/minecraft/world/item/CrossbowItem.java
+@@ -217,6 +217,7 @@ public class CrossbowItem extends ProjectileWeaponItem implements Vanishable {
+ 
+             if (flag1) {
+                 object = new FireworkRocketEntity(world, projectile, shooter, shooter.getX(), shooter.getEyeY() - 0.15000000596046448D, shooter.getZ(), true);
+                ((FireworkRocketEntity) object).spawningEntity = shooter.getUUID(); // Paper
+             } else {
+                 object = CrossbowItem.getArrow(world, shooter, crossbow, projectile);
+                 if (creative || simulated != 0.0F) {
+diff --git a/src/main/java/net/minecraft/world/item/FireworkRocketItem.java b/src/main/java/net/minecraft/world/item/FireworkRocketItem.java
+index 5cafb6f0b507127665393741b372286da098d603..7c627d27300247db9122ab2081049345ef306073 100644
+--- a/src/main/java/net/minecraft/world/item/FireworkRocketItem.java
+++ b/src/main/java/net/minecraft/world/item/FireworkRocketItem.java
+@@ -46,6 +46,7 @@ public class FireworkRocketItem extends Item {
+             Vec3 vec3 = context.getClickLocation();
+             Direction direction = context.getClickedFace();
+             FireworkRocketEntity fireworkRocketEntity = new FireworkRocketEntity(level, context.getPlayer(), vec3.x + (double)direction.getStepX() * 0.15D, vec3.y + (double)direction.getStepY() * 0.15D, vec3.z + (double)direction.getStepZ() * 0.15D, itemStack);
+            fireworkRocketEntity.spawningEntity = context.getPlayer() == null ? null : context.getPlayer().getUUID(); // Paper
+             level.addFreshEntity(fireworkRocketEntity);
+             itemStack.shrink(1);
+         }
+@@ -59,6 +60,7 @@ public class FireworkRocketItem extends Item {
+             ItemStack itemStack = user.getItemInHand(hand);
+             if (!world.isClientSide) {
+                 FireworkRocketEntity fireworkRocketEntity = new FireworkRocketEntity(world, itemStack, user);
+                fireworkRocketEntity.spawningEntity = user.getUUID(); // Paper
+                 world.addFreshEntity(fireworkRocketEntity);
+                 if (!user.getAbilities().instabuild) {
+                     itemStack.shrink(1);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftFirework.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftFirework.java
+index 437fd93bf0de2b4fd74b5f94d0b931ed10f2b6ec..7417e3d51497fe7e62e108d83ee4b70942972144 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftFirework.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftFirework.java
+@@ -129,4 +129,11 @@ public class CraftFirework extends CraftProjectile implements Firework {
+     public void setShotAtAngle(boolean shotAtAngle) {
+         this.getHandle().getEntityData().set(FireworkRocketEntity.DATA_SHOT_AT_ANGLE, shotAtAngle);
+     }
+
+    // Paper start
+    @Override
+    public java.util.UUID getSpawningEntity() {
+        return getHandle().spawningEntity;
+    }
+    // Paper end
+ }
--- a/patches/server/0123-PlayerTeleportEndGatewayEvent.patch
+++ b/patches/server/0123-PlayerTeleportEndGatewayEvent.patch
@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sat, 31 Dec 2016 21:44:50 -0500
+Subject: [PATCH] PlayerTeleportEndGatewayEvent
+
+Allows you to access the Gateway being used in a teleport event
+Fix the offset used for player teleportation
+
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
+index 97c57619ebcf31f17f8430ffb68043771d1377f9..020314dded2c6305bd5e9013b108bc74be25ccc1 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
+@@ -207,11 +207,11 @@ public class TheEndGatewayBlockEntity extends TheEndPortalBlockEntity {
+                 // CraftBukkit start - Fire PlayerTeleportEvent
+                 if (entity1 instanceof ServerPlayer) {
+                     org.bukkit.craftbukkit.entity.CraftPlayer player = (CraftPlayer) entity1.getBukkitEntity();
+-                    org.bukkit.Location location = CraftLocation.toBukkit(blockposition1, world.getWorld()).add(0.5D, 0.5D, 0.5D);
+                    org.bukkit.Location location = CraftLocation.toBukkit(blockposition1, world.getWorld()).add(0.5D, 0, 0.5D); // Paper - use the right Y offset
+                     location.setPitch(player.getLocation().getPitch());
+                     location.setYaw(player.getLocation().getYaw());
+ 
+-                    PlayerTeleportEvent teleEvent = new PlayerTeleportEvent(player, player.getLocation(), location, PlayerTeleportEvent.TeleportCause.END_GATEWAY);
+                    PlayerTeleportEvent teleEvent = new com.destroystokyo.paper.event.player.PlayerTeleportEndGatewayEvent(player, player.getLocation(), location, new org.bukkit.craftbukkit.block.CraftEndGateway(worldserver.getWorld(), blockEntity)); // Paper
+                     Bukkit.getPluginManager().callEvent(teleEvent);
+                     if (teleEvent.isCancelled()) {
+                         return;
+@@ -226,7 +226,7 @@ public class TheEndGatewayBlockEntity extends TheEndPortalBlockEntity {
+                 // CraftBukkit end
+ 
+                 entity1.setPortalCooldown();
+-                entity1.teleportToWithTicket((double) blockposition1.getX() + 0.5D, (double) blockposition1.getY(), (double) blockposition1.getZ() + 0.5D);
+                entity1.teleportToWithTicket((double) blockposition1.getX() + 0.5D, (double) blockposition1.getY(), (double) blockposition1.getZ() + 0.5D); // Paper - diff on change
+             }
+ 
+             TheEndGatewayBlockEntity.triggerCooldown(world, pos, state, blockEntity);
--- a/patches/server/0124-Provide-E-TE-Chunk-count-stat-methods.patch
+++ b/patches/server/0124-Provide-E-TE-Chunk-count-stat-methods.patch
@ -0,0 +1,82 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sat, 7 Jan 2017 15:24:46 -0500
+Subject: [PATCH] Provide E/TE/Chunk count stat methods
+
+Provides counts without the ineffeciency of using .getEntities().size()
+which creates copy of the collections.
+
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 936f21b61589a6bcd9bf19c7466b9b1b9a14f280..776a5a9947c56eb63df7ac9797166be456282af1 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -116,7 +116,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+     public static final int TICKS_PER_DAY = 24000;
+     public static final int MAX_ENTITY_SPAWN_Y = 20000000;
+     public static final int MIN_ENTITY_SPAWN_Y = -20000000;
+-    protected final List<TickingBlockEntity> blockEntityTickers = Lists.newArrayList();
+    protected final List<TickingBlockEntity> blockEntityTickers = Lists.newArrayList(); public final int getTotalTileEntityTickers() { return this.blockEntityTickers.size(); } // Paper
+     protected final NeighborUpdater neighborUpdater;
+     private final List<TickingBlockEntity> pendingBlockEntityTickers = Lists.newArrayList();
+     private boolean tickingBlockEntities;
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index d01388bbadf3069357cf52463f4104a1be4d2b56..9d79b31baea99d25218e9d3f27ab895d4f73ef8a 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -154,6 +154,56 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+     private final CraftPersistentDataContainer persistentDataContainer = new CraftPersistentDataContainer(CraftWorld.DATA_TYPE_REGISTRY);
+     private net.kyori.adventure.pointer.Pointers adventure$pointers; // Paper - implement pointers
+ 
+    // Paper start - Provide fast information methods
+    @Override
+    public int getEntityCount() {
+        int ret = 0;
+        for (net.minecraft.world.entity.Entity entity : world.getEntities().getAll()) {
+            if (entity.isChunkLoaded()) {
+                ++ret;
+            }
+        }
+        return ret;
+    }
+
+    @Override
+    public int getTileEntityCount() {
+        // We don't use the full world tile entity list, so we must iterate chunks
+        int size = 0;
+        for (ChunkHolder playerchunk : io.papermc.paper.chunk.system.ChunkSystem.getVisibleChunkHolders(this.world)) {
+            net.minecraft.world.level.chunk.LevelChunk chunk = playerchunk.getTickingChunk();
+            if (chunk == null) {
+                continue;
+            }
+            size += chunk.blockEntities.size();
+        }
+        return size;
+    }
+
+    @Override
+    public int getTickableTileEntityCount() {
+        return world.getTotalTileEntityTickers();
+    }
+
+    @Override
+    public int getChunkCount() {
+        int ret = 0;
+
+        for (ChunkHolder chunkHolder : io.papermc.paper.chunk.system.ChunkSystem.getVisibleChunkHolders(this.world)) {
+            if (chunkHolder.getTickingChunk() != null) {
+                ++ret;
+            }
+        }
+
+        return ret;
+    }
+
+    @Override
+    public int getPlayerCount() {
+        return world.players().size();
+    }
+    // Paper end
+
+     private static final Random rand = new Random();
+ 
+     public CraftWorld(ServerLevel world, ChunkGenerator gen, BiomeProvider biomeProvider, Environment env) {
--- a/patches/server/0125-Enforce-Sync-Player-Saves.patch
+++ b/patches/server/0125-Enforce-Sync-Player-Saves.patch
@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sat, 7 Jan 2017 15:41:58 -0500
+Subject: [PATCH] Enforce Sync Player Saves
+
+Saving players async is extremely dangerous. This will force it to main
+the same way we handle async chunk loads.
+
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 5406ac93eaf9b9f9e810bfbbcf4a35e2f38f680c..a2b4e5fc6b3174705f2232abb2df7bf869dc3926 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -1063,11 +1063,13 @@ public abstract class PlayerList {
+     }
+ 
+     public void saveAll() {
+        io.papermc.paper.util.MCUtil.ensureMain("Save Players" , () -> { // Paper - Ensure main
+         MinecraftTimings.savePlayers.startTiming(); // Paper
+         for (int i = 0; i < this.players.size(); ++i) {
+-            this.save((ServerPlayer) this.players.get(i));
+            this.save(this.players.get(i));
+         }
+         MinecraftTimings.savePlayers.stopTiming(); // Paper
+        return null; }); // Paper - ensure main
+     }
+ 
+     public UserWhiteList getWhiteList() {
--- a/patches/server/0126-ExperienceOrbs-API-for-Reason-Source-Triggering-play.patch
+++ b/patches/server/0126-ExperienceOrbs-API-for-Reason-Source-Triggering-play.patch
@ -0,0 +1,361 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 19 Dec 2017 16:31:46 -0500
+Subject: [PATCH] ExperienceOrbs API for Reason/Source/Triggering player
+
+Adds lots of information about why this orb exists.
+
+Replaces isFromBottle() with logic that persists entity reloads too.
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+index 4814601e549b0b96e83ed64ee094ddaa825565de..16468dfd657501f6fd5eefa4c32682e24eaba22d 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+@@ -427,7 +427,7 @@ public class ServerPlayerGameMode {
+ 
+                 // Drop event experience
+                 if (flag && event != null) {
+-                    iblockdata.getBlock().popExperience(this.level, pos, event.getExpToDrop());
+                    iblockdata.getBlock().popExperience(this.level, pos, event.getExpToDrop(), this.player); // Paper
+                 }
+ 
+                 return true;
+diff --git a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+index 9dffdfe5bbd0517e9a2c6a6770eea07b43ef9b33..6de7fcccb6da757185a38b79b3a22821b1186201 100644
+--- a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+++ b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+@@ -39,13 +39,67 @@ public class ExperienceOrb extends Entity {
+     public int value;
+     private int count;
+     private Player followingPlayer;
+    // Paper start
+    @javax.annotation.Nullable
+    public java.util.UUID sourceEntityId;
+    @javax.annotation.Nullable
+    public java.util.UUID triggerEntityId;
+    public org.bukkit.entity.ExperienceOrb.SpawnReason spawnReason = org.bukkit.entity.ExperienceOrb.SpawnReason.UNKNOWN;
+
+    private void loadPaperNBT(CompoundTag nbttagcompound) {
+        if (!nbttagcompound.contains("Paper.ExpData", 10)) { // 10 = compound
+            return;
+        }
+        CompoundTag comp = nbttagcompound.getCompound("Paper.ExpData");
+        if (comp.hasUUID("source")) {
+            this.sourceEntityId = comp.getUUID("source");
+        }
+        if (comp.hasUUID("trigger")) {
+            this.triggerEntityId = comp.getUUID("trigger");
+        }
+        if (comp.contains("reason")) {
+            String reason = comp.getString("reason");
+            try {
+                this.spawnReason = org.bukkit.entity.ExperienceOrb.SpawnReason.valueOf(reason);
+            } catch (Exception e) {
+                this.level().getCraftServer().getLogger().warning("Invalid spawnReason set for experience orb: " + e.getMessage() + " - " + reason);
+            }
+        }
+    }
+    private void savePaperNBT(CompoundTag nbttagcompound) {
+        CompoundTag comp = new CompoundTag();
+        if (this.sourceEntityId != null) {
+            comp.putUUID("source", this.sourceEntityId);
+        }
+        if (this.triggerEntityId != null) {
+            comp.putUUID("trigger", triggerEntityId);
+        }
+        if (this.spawnReason != null && this.spawnReason != org.bukkit.entity.ExperienceOrb.SpawnReason.UNKNOWN) {
+            comp.putString("reason", this.spawnReason.name());
+        }
+        nbttagcompound.put("Paper.ExpData", comp);
+    }
+ 
+    @io.papermc.paper.annotation.DoNotUse
+    @Deprecated
+     public ExperienceOrb(Level world, double x, double y, double z, int amount) {
+        this(world, x, y, z, amount, null, null);
+    }
+
+    public ExperienceOrb(Level world, double d0, double d1, double d2, int i, @javax.annotation.Nullable org.bukkit.entity.ExperienceOrb.SpawnReason reason, @javax.annotation.Nullable Entity triggerId) {
+        this(world, d0, d1, d2, i, reason, triggerId, null);
+    }
+
+    public ExperienceOrb(Level world, double d0, double d1, double d2, int i, @javax.annotation.Nullable org.bukkit.entity.ExperienceOrb.SpawnReason reason, @javax.annotation.Nullable Entity triggerId, @javax.annotation.Nullable Entity sourceId) {
+         this(EntityType.EXPERIENCE_ORB, world);
+-        this.setPos(x, y, z);
+        this.sourceEntityId = sourceId != null ? sourceId.getUUID() : null;
+        this.triggerEntityId = triggerId != null ? triggerId.getUUID() : null;
+        this.spawnReason = reason != null ? reason : org.bukkit.entity.ExperienceOrb.SpawnReason.UNKNOWN;
+        // Paper end
+        this.setPos(d0, d1, d2);
+         this.setYRot((float) (this.random.nextDouble() * 360.0D));
+         this.setDeltaMovement((this.random.nextDouble() * 0.20000000298023224D - 0.10000000149011612D) * 2.0D, this.random.nextDouble() * 0.2D * 2.0D, (this.random.nextDouble() * 0.20000000298023224D - 0.10000000149011612D) * 2.0D);
+-        this.value = amount;
+        this.value = i;
+     }
+ 
+     public ExperienceOrb(EntityType<? extends ExperienceOrb> type, Level world) {
+@@ -160,12 +214,20 @@ public class ExperienceOrb extends Entity {
+     }
+ 
+     public static void award(ServerLevel world, Vec3 pos, int amount) {
+        // Paper start - add reasons for orbs
+        award(world, pos, amount, null, null, null);
+    }
+    public static void award(ServerLevel world, Vec3 pos, int amount, org.bukkit.entity.ExperienceOrb.SpawnReason reason, Entity triggerId) {
+        award(world, pos, amount, reason, triggerId, null);
+    }
+    public static void award(ServerLevel world, Vec3 pos, int amount, org.bukkit.entity.ExperienceOrb.SpawnReason reason, Entity triggerId, Entity sourceId) {
+        // Paper end - add reasons for orbs
+         while (amount > 0) {
+             int j = ExperienceOrb.getExperienceValue(amount);
+ 
+             amount -= j;
+             if (!ExperienceOrb.tryMergeToExisting(world, pos, j)) {
+-                world.addFreshEntity(new ExperienceOrb(world, pos.x(), pos.y(), pos.z(), j));
+                world.addFreshEntity(new ExperienceOrb(world, pos.x(), pos.y(), pos.z(), j, reason, triggerId, sourceId)); // Paper - add reason
+             }
+         }
+ 
+@@ -235,6 +297,7 @@ public class ExperienceOrb extends Entity {
+         nbt.putShort("Age", (short) this.age);
+         nbt.putShort("Value", (short) this.value);
+         nbt.putInt("Count", this.count);
+        this.savePaperNBT(nbt); // Paper
+     }
+ 
+     @Override
+@@ -243,6 +306,7 @@ public class ExperienceOrb extends Entity {
+         this.age = nbt.getShort("Age");
+         this.value = nbt.getShort("Value");
+         this.count = Math.max(nbt.getInt("Count"), 1);
+        this.loadPaperNBT(nbt); // Paper
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index c61ddc868fa2eed1dce72ebcf98940756cca401e..45d1b869b0aa2d12000a58c5c3cd1c8232429d36 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -1792,7 +1792,8 @@ public abstract class LivingEntity extends Entity implements Attackable {
+     protected void dropExperience() {
+         // CraftBukkit start - Update getExpReward() above if the removed if() changes!
+         if (true && !(this instanceof net.minecraft.world.entity.boss.enderdragon.EnderDragon)) { // CraftBukkit - SPIGOT-2420: Special case ender dragon will drop the xp over time
+-            ExperienceOrb.award((ServerLevel) this.level(), this.position(), this.expToDrop);
+            LivingEntity attacker = this.lastHurtByPlayer != null ? this.lastHurtByPlayer : this.lastHurtByMob; // Paper
+            ExperienceOrb.award((ServerLevel) this.level(), this.position(), this.expToDrop, this instanceof ServerPlayer ? org.bukkit.entity.ExperienceOrb.SpawnReason.PLAYER_DEATH : org.bukkit.entity.ExperienceOrb.SpawnReason.ENTITY_DEATH, attacker, this); // Paper
+             this.expToDrop = 0;
+         }
+         // CraftBukkit end
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Animal.java b/src/main/java/net/minecraft/world/entity/animal/Animal.java
+index b5b93396166202cbe5a4456794fd394de932262a..be105a4460e9bf2ef4b72a307fa31291c37d5e0e 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Animal.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Animal.java
+@@ -256,12 +256,14 @@ public abstract class Animal extends AgeableMob {
+ 
+     public void finalizeSpawnChildFromBreeding(ServerLevel worldserver, Animal entityanimal, @Nullable AgeableMob entityageable, int experience) {
+         // CraftBukkit end
+-        Optional.ofNullable(this.getLoveCause()).or(() -> {
+-            return Optional.ofNullable(entityanimal.getLoveCause());
+-        }).ifPresent((entityplayer) -> {
+        // Paper start
+        ServerPlayer entityplayer = this.getLoveCause();
+        if (entityplayer == null) entityplayer = entityanimal.getLoveCause();
+        if (entityplayer != null) {
+            // Paper end
+             entityplayer.awardStat(Stats.ANIMALS_BRED);
+             CriteriaTriggers.BRED_ANIMALS.trigger(entityplayer, this, entityanimal, entityageable);
+-        });
+        } // Paper
+         this.setAge(6000);
+         entityanimal.setAge(6000);
+         this.resetLove();
+@@ -270,7 +272,7 @@ public abstract class Animal extends AgeableMob {
+         if (worldserver.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
+             // CraftBukkit start - use event experience
+             if (experience > 0) {
+-                worldserver.addFreshEntity(new ExperienceOrb(worldserver, this.getX(), this.getY(), this.getZ(), experience));
+                worldserver.addFreshEntity(new ExperienceOrb(worldserver, this.getX(), this.getY(), this.getZ(), experience, org.bukkit.entity.ExperienceOrb.SpawnReason.BREED, entityplayer, entityageable)); // Paper
+             }
+             // CraftBukkit 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 1bf6126b38dd127bb72b174b049fb3b396db713c..0d4b86411d2d064b04334b508b1cb65695afaebd 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Fox.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Fox.java
+@@ -909,7 +909,7 @@ public class Fox extends Animal implements VariantHolder<Fox.Type> {
+                 if (this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
+                     // CraftBukkit start - use event experience
+                     if (experience > 0) {
+-                        this.level.addFreshEntity(new ExperienceOrb(this.level, this.animal.getX(), this.animal.getY(), this.animal.getZ(), experience));
+                        this.level.addFreshEntity(new ExperienceOrb(this.level, this.animal.getX(), this.animal.getY(), this.animal.getZ(), experience, org.bukkit.entity.ExperienceOrb.SpawnReason.BREED, entityplayer, entityfox)); // Paper
+                     }
+                     // CraftBukkit end
+                 }
+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 6dba24f47ca76a432a836178af178c2d52631eee..ed1f6e77d5fc9b6f5f52b1a10275783b514c162c 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Turtle.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Turtle.java
+@@ -464,7 +464,7 @@ public class Turtle extends Animal {
+             RandomSource randomsource = this.animal.getRandom();
+ 
+             if (this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
+-                this.level.addFreshEntity(new ExperienceOrb(this.level, this.animal.getX(), this.animal.getY(), this.animal.getZ(), randomsource.nextInt(7) + 1));
+                this.level.addFreshEntity(new ExperienceOrb(this.level, this.animal.getX(), this.animal.getY(), this.animal.getZ(), randomsource.nextInt(7) + 1, org.bukkit.entity.ExperienceOrb.SpawnReason.BREED, entityplayer)); // Paper;
+             }
+ 
+         }
+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 1a787bd4bdbbf7c78f4bf6bd7e2f36540fec7d50..8bfb2f94226e6b623def141a7af79d0f46d7d445 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
+@@ -673,7 +673,7 @@ public class EnderDragon extends Mob implements Enemy {
+ 
+         if (this.level() instanceof ServerLevel) {
+             if (this.dragonDeathTime > 150 && this.dragonDeathTime % 5 == 0 && true) {  // CraftBukkit - SPIGOT-2420: Already checked for the game rule when calculating the xp
+-                ExperienceOrb.award((ServerLevel) this.level(), this.position(), Mth.floor((float) short0 * 0.08F));
+                ExperienceOrb.award((ServerLevel) this.level(), this.position(), Mth.floor((float) short0 * 0.08F), org.bukkit.entity.ExperienceOrb.SpawnReason.ENTITY_DEATH, this.lastHurtByPlayer, this); // Paper
+             }
+ 
+             if (this.dragonDeathTime == 1 && !this.isSilent()) {
+@@ -701,7 +701,7 @@ public class EnderDragon extends Mob implements Enemy {
+         this.move(MoverType.SELF, new Vec3(0.0D, 0.10000000149011612D, 0.0D));
+         if (this.dragonDeathTime == 200 && this.level() instanceof ServerLevel) {
+             if (true) { // CraftBukkit - SPIGOT-2420: Already checked for the game rule when calculating the xp
+-                ExperienceOrb.award((ServerLevel) this.level(), this.position(), Mth.floor((float) short0 * 0.2F));
+                ExperienceOrb.award((ServerLevel) this.level(), this.position(), Mth.floor((float) short0 * 0.2F), org.bukkit.entity.ExperienceOrb.SpawnReason.ENTITY_DEATH, this.lastHurtByPlayer, this); // Paper
+             }
+ 
+             if (this.dragonFight != null) {
+diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+index b70ee1dff0442de32a9e20ad54b246d5eae45e58..b3127238cea62c47d710abab44f6570103ba9364 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
+++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
+@@ -638,7 +638,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+         }
+ 
+         if (offer.shouldRewardExp()) {
+-            this.level().addFreshEntity(new ExperienceOrb(this.level(), this.getX(), this.getY() + 0.5D, this.getZ(), i));
+            this.level().addFreshEntity(new ExperienceOrb(this.level(), this.getX(), this.getY() + 0.5D, this.getZ(), i, org.bukkit.entity.ExperienceOrb.SpawnReason.VILLAGER_TRADE, this.getTradingPlayer(), this)); // Paper
+         }
+ 
+     }
+diff --git a/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java b/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+index eb15d694ad8c24b659feba53e6992661ba1a9b76..5ea5f424c55f60bf63d3a4d3fe51362939f42f4c 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+++ b/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+@@ -207,7 +207,7 @@ public class WanderingTrader extends net.minecraft.world.entity.npc.AbstractVill
+         if (offer.shouldRewardExp()) {
+             int i = 3 + this.random.nextInt(4);
+ 
+-            this.level().addFreshEntity(new ExperienceOrb(this.level(), this.getX(), this.getY() + 0.5D, this.getZ(), i));
+            this.level().addFreshEntity(new ExperienceOrb(this.level(), this.getX(), this.getY() + 0.5D, this.getZ(), i, org.bukkit.entity.ExperienceOrb.SpawnReason.VILLAGER_TRADE, this.getTradingPlayer(), this)); // Paper
+         }
+ 
+     }
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java b/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java
+index af6829c25fcd186adc3575d50cab6d46db9a2fac..5c77992e0c49eb217dd66657b35164225b400518 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java
+@@ -522,7 +522,7 @@ public class FishingHook extends Projectile {
+                     this.level().addFreshEntity(entityitem);
+                     // CraftBukkit start - this.random.nextInt(6) + 1 -> playerFishEvent.getExpToDrop()
+                     if (playerFishEvent.getExpToDrop() > 0) {
+-                        entityhuman.level().addFreshEntity(new ExperienceOrb(entityhuman.level(), entityhuman.getX(), entityhuman.getY() + 0.5D, entityhuman.getZ() + 0.5D, playerFishEvent.getExpToDrop()));
+                        entityhuman.level().addFreshEntity(new ExperienceOrb(entityhuman.level(), entityhuman.getX(), entityhuman.getY() + 0.5D, entityhuman.getZ() + 0.5D, playerFishEvent.getExpToDrop(), org.bukkit.entity.ExperienceOrb.SpawnReason.FISHING, this.getPlayerOwner(), this)); // Paper
+                     }
+                     // CraftBukkit end
+                     if (itemstack1.is(ItemTags.FISHES)) {
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/ThrownExperienceBottle.java b/src/main/java/net/minecraft/world/entity/projectile/ThrownExperienceBottle.java
+index 2191af62f4202413738542d738456ca71febdbf4..5b3059460d4b18d984483d655526d83204fb1c73 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/ThrownExperienceBottle.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/ThrownExperienceBottle.java
+@@ -51,7 +51,7 @@ public class ThrownExperienceBottle extends ThrowableItemProjectile {
+             }
+             // CraftBukkit end
+ 
+-            ExperienceOrb.award((ServerLevel) this.level(), this.position(), i);
+            ExperienceOrb.award((ServerLevel) this.level(), this.position(), i, org.bukkit.entity.ExperienceOrb.SpawnReason.EXP_BOTTLE, this.getOwner(), this); // Paper
+             this.discard();
+         }
+ 
+diff --git a/src/main/java/net/minecraft/world/inventory/GrindstoneMenu.java b/src/main/java/net/minecraft/world/inventory/GrindstoneMenu.java
+index c858b987cb6f92cc6fa705bbe1ae11a720eb242c..2c263447aa8853f18d1c1d476b49a47f6e9ca2ad 100644
+--- a/src/main/java/net/minecraft/world/inventory/GrindstoneMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/GrindstoneMenu.java
+@@ -97,7 +97,7 @@ public class GrindstoneMenu extends AbstractContainerMenu {
+             public void onTake(net.minecraft.world.entity.player.Player player, ItemStack stack) {
+                 context.execute((world, blockposition) -> {
+                     if (world instanceof ServerLevel) {
+-                        ExperienceOrb.award((ServerLevel) world, Vec3.atCenterOf(blockposition), this.getExperienceAmount(world));
+                        ExperienceOrb.award((ServerLevel) world, Vec3.atCenterOf(blockposition), this.getExperienceAmount(world), org.bukkit.entity.ExperienceOrb.SpawnReason.GRINDSTONE, player); // Paper
+                     }
+ 
+                     world.levelEvent(1042, blockposition, 0);
+diff --git a/src/main/java/net/minecraft/world/level/block/Block.java b/src/main/java/net/minecraft/world/level/block/Block.java
+index 7ed82beb538a25a5246f6288c1dddb4f5f85e997..7646b66bc5ba0288608de0d836c7307e02eebe67 100644
+--- a/src/main/java/net/minecraft/world/level/block/Block.java
+++ b/src/main/java/net/minecraft/world/level/block/Block.java
+@@ -362,8 +362,13 @@ public class Block extends BlockBehaviour implements ItemLike {
+     }
+ 
+     public void popExperience(ServerLevel world, BlockPos pos, int size) {
+        // Paper start - add player parameter
+        popExperience(world, pos, size, null);
+    }
+    public void popExperience(ServerLevel world, BlockPos pos, int size, net.minecraft.server.level.ServerPlayer player) {
+        // Paper end - add player parameter
+         if (world.getGameRules().getBoolean(GameRules.RULE_DOBLOCKDROPS)) {
+-            ExperienceOrb.award(world, Vec3.atCenterOf(pos), size);
+            ExperienceOrb.award(world, Vec3.atCenterOf(pos), size, org.bukkit.entity.ExperienceOrb.SpawnReason.BLOCK_BREAK, player); // Paper
+         }
+ 
+     }
+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 e72ed2ed8664cbc408cbe1e38f1f0acacc3841dd..2f628f36c32752d1bac910e180b90639c1ae2c9d 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
+@@ -650,7 +650,7 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
+         j = event.getExpToDrop();
+         // CraftBukkit end
+ 
+-        ExperienceOrb.award(worldserver, vec3d, j);
+        ExperienceOrb.award(worldserver, vec3d, j, org.bukkit.entity.ExperienceOrb.SpawnReason.FURNACE, entityhuman); // Paper
+     }
+ 
+     @Override
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+index 8e1d70bbc433780f264dde137aa7f37e7f6362cd..3dd759d030411420f93eb5ac51f2087ecbf2dc49 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+@@ -942,7 +942,7 @@ public abstract class CraftRegionAccessor implements RegionAccessor {
+         } else if (TNTPrimed.class.isAssignableFrom(clazz)) {
+             entity = new PrimedTnt(world, x, y, z, null);
+         } else if (ExperienceOrb.class.isAssignableFrom(clazz)) {
+-            entity = new net.minecraft.world.entity.ExperienceOrb(world, x, y, z, 0);
+            entity = new net.minecraft.world.entity.ExperienceOrb(world, x, y, z, 0, org.bukkit.entity.ExperienceOrb.SpawnReason.CUSTOM, null, null); // Paper
+         } else if (LightningStrike.class.isAssignableFrom(clazz)) {
+             entity = net.minecraft.world.entity.EntityType.LIGHTNING_BOLT.create(world);
+             entity.moveTo(location.getX(), location.getY(), location.getZ());
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftExperienceOrb.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftExperienceOrb.java
+index 4907d61b0254919e137c4f92e0dbeb2d61a906f6..26c795983515580b30b5ef8c701faa95ab1aea8e 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftExperienceOrb.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftExperienceOrb.java
+@@ -18,6 +18,18 @@ public class CraftExperienceOrb extends CraftEntity implements ExperienceOrb {
+         this.getHandle().value = value;
+     }
+ 
+    // Paper start
+    public java.util.UUID getTriggerEntityId() {
+        return getHandle().triggerEntityId;
+    }
+    public java.util.UUID getSourceEntityId() {
+        return getHandle().sourceEntityId;
+    }
+    public SpawnReason getSpawnReason() {
+        return getHandle().spawnReason;
+    }
+    // Paper end
+
+     @Override
+     public net.minecraft.world.entity.ExperienceOrb getHandle() {
+         return (net.minecraft.world.entity.ExperienceOrb) entity;
--- a/patches/server/0127-Cap-Entity-Collisions.patch
+++ b/patches/server/0127-Cap-Entity-Collisions.patch
@ -0,0 +1,44 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sun, 22 Jan 2017 18:07:56 -0500
+Subject: [PATCH] Cap Entity Collisions
+
+Limit a single entity to colliding a max of configurable times per tick.
+This will alleviate issues where living entities are hoarded in 1x1 pens
+
+This is not tied to the maxEntityCramming rule. Cramming will still apply
+just as it does in Vanilla, but entity pushing logic will be capped.
+
+You can set this to 0 to disable collisions.
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 468111bb80e7756371d22eb831596c187538f0c1..b4c91cb985d3772c5b105b8d2267b51d7483e005 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -387,6 +387,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+     public void inactiveTick() { }
+     // Spigot end
+     // Paper start
+    protected int numCollisions = 0; // Paper
+     @javax.annotation.Nullable
+     private org.bukkit.util.Vector origin;
+     @javax.annotation.Nullable
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 45d1b869b0aa2d12000a58c5c3cd1c8232429d36..a8d39b7257332ec8b3b711aab2c4b76a867e73bc 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -3349,10 +3349,12 @@ public abstract class LivingEntity extends Entity implements Attackable {
+                 }
+ 
+                 Iterator iterator1 = list.iterator();
+                this.numCollisions = Math.max(0, this.numCollisions - this.level().paperConfig().collisions.maxEntityCollisions); // Paper
+ 
+-                while (iterator1.hasNext()) {
+                while (iterator1.hasNext() && this.numCollisions < this.level().paperConfig().collisions.maxEntityCollisions) { // Paper
+                     Entity entity1 = (Entity) iterator1.next();
+-
+                    entity1.numCollisions++; // Paper
+                    this.numCollisions++; // Paper
+                     this.doPush(entity1);
+                 }
+             }
--- a/patches/server/0128-Remove-CraftScheduler-Async-Task-Debugger.patch
+++ b/patches/server/0128-Remove-CraftScheduler-Async-Task-Debugger.patch
@ -0,0 +1,48 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sun, 5 Feb 2017 00:04:04 -0500
+Subject: [PATCH] Remove CraftScheduler Async Task Debugger
+
+I have not once ever seen this system help debug a crash.
+One report of a suspected memory leak with the system.
+
+This adds additional overhead to asynchronous task dispatching
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
+index 833240d2a4936343710a60876a66d01112e15a2c..ef4fdfa3fbe8216a0a020949347bc992cd5c0c60 100644
+--- a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
+++ b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
+@@ -442,7 +442,7 @@ public class CraftScheduler implements BukkitScheduler {
+                 }
+                 this.parsePending();
+             } else {
+-                this.debugTail = this.debugTail.setNext(new CraftAsyncDebugger(currentTick + CraftScheduler.RECENT_TICKS, task.getOwner(), task.getTaskClass()));
+                // this.debugTail = this.debugTail.setNext(new CraftAsyncDebugger(currentTick + CraftScheduler.RECENT_TICKS, task.getOwner(), task.getTaskClass())); // Paper
+                 this.executor.execute(new com.destroystokyo.paper.ServerSchedulerReportingWrapper(task)); // Paper
+                 // We don't need to parse pending
+                 // (async tasks must live with race-conditions if they attempt to cancel between these few lines of code)
+@@ -459,7 +459,7 @@ public class CraftScheduler implements BukkitScheduler {
+         this.pending.addAll(temp);
+         temp.clear();
+         MinecraftTimings.bukkitSchedulerFinishTimer.stopTiming(); // Paper
+-        this.debugHead = this.debugHead.getNextHead(currentTick);
+        //this.debugHead = this.debugHead.getNextHead(currentTick); // Paper
+     }
+ 
+     private void addTask(final CraftTask task) {
+@@ -523,10 +523,15 @@ public class CraftScheduler implements BukkitScheduler {
+ 
+     @Override
+     public String toString() {
+        // Paper start
+        return "";
+        /*
+         int debugTick = this.currentTick;
+         StringBuilder string = new StringBuilder("Recent tasks from ").append(debugTick - CraftScheduler.RECENT_TICKS).append('-').append(debugTick).append('{');
+         this.debugHead.debugTo(string);
+         return string.append('}').toString();
+        */
+        // Paper end
+     }
+ 
+     @Deprecated
--- a/patches/server/0129-Do-not-let-armorstands-drown.patch
+++ b/patches/server/0129-Do-not-let-armorstands-drown.patch
@ -0,0 +1,23 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach.brown@destroystokyo.com>
+Date: Sat, 18 Feb 2017 19:29:58 -0600
+Subject: [PATCH] Do not let armorstands drown
+
+
+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 d79fbc3e1cab0d4ec38ae25325e55eb23a1b5a19..37c19685049ef6b267a74a4323dc4ec33159c3d2 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+++ b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+@@ -959,5 +959,12 @@ public class ArmorStand extends LivingEntity {
+             super.move(type, movement);
+         }
+     }
+
+    // Paper start
+    @Override
+    public boolean canBreatheUnderwater() { // Skips a bit of damage handling code, probably a micro-optimization
+        return true;
+    }
+    // Paper end
+     // Paper end
+ }
--- a/patches/server/0130-Properly-handle-async-calls-to-restart-the-server.patch
+++ b/patches/server/0130-Properly-handle-async-calls-to-restart-the-server.patch
@ -0,0 +1,290 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach.brown@destroystokyo.com>
+Date: Fri, 12 May 2017 23:34:11 -0500
+Subject: [PATCH] Properly handle async calls to restart the server
+
+The watchdog thread calls the server restart function asynchronously. Prior to
+this change, it attempted to do several non-safe operations from the watchdog
+thread, rather than the main. Specifically, because of a separate upstream change,
+it causes player entities to be ticked asynchronously, among other things.
+
+This is dangerous.
+
+This patch moves the old handling into a synchronous variant, for calls from the
+restart command, and adds separate handling for async calls, such as those from
+the watchdog thread.
+
+When calling from the watchdog thread, we cannot assume the main thread is in a
+tickable state; it may be completely deadlocked. In order to handle this, we mark
+the server as stopping, in order to account for situations where the server should
+complete a tick reasonbly soon, i.e. 99% of cases.
+
+Should the server not enter a state where it is stopping within 10 seconds, We
+will assume that the server has in fact deadlocked and will proceed to force
+kill the server.
+
+This modification does not force restart the server should we actually enter a
+deadlocked state where the server is stopping, whereas this will in most cases
+exit within a reasonable amount of time, to put a fixed limit on a process that
+will have plugins and worlds saving to the disk has a high potential to result
+in corruption/dataloss.
+
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 6ab95b11eafe69ed0fd584e87ac0f0bb176ce180..834c60f1e85995c487f59f6504e96385d5d0ff27 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -233,6 +233,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     private Map<ResourceKey<Level>, ServerLevel> levels;
+     private PlayerList playerList;
+     private volatile boolean running;
+    private volatile boolean isRestarting = false; // Paper - flag to signify we're attempting to restart
+     private boolean stopped;
+     private int tickCount;
+     protected final Proxy proxy;
+@@ -872,7 +873,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         if (this.playerList != null) {
+             MinecraftServer.LOGGER.info("Saving players");
+             this.playerList.saveAll();
+-            this.playerList.removeAll();
+            this.playerList.removeAll(this.isRestarting); // Paper
+             try { Thread.sleep(100); } catch (InterruptedException ex) {} // CraftBukkit - SPIGOT-625 - give server at least a chance to send packets
+         }
+ 
+@@ -952,6 +953,12 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     }
+ 
+     public void halt(boolean waitForShutdown) {
+        // Paper start - allow passing of the intent to restart
+        this.safeShutdown(waitForShutdown, false);
+    }
+    public void safeShutdown(boolean waitForShutdown, boolean isRestarting) {
+        this.isRestarting = isRestarting;
+        // Paper end
+         this.running = false;
+         if (waitForShutdown) {
+             try {
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index a2b4e5fc6b3174705f2232abb2df7bf869dc3926..9d700d27d05c6f276b3ca159735fece0a75ca9b1 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -1175,8 +1175,15 @@ public abstract class PlayerList {
+     }
+ 
+     public void removeAll() {
+        // Paper start - Extract method to allow for restarting flag
+        this.removeAll(false);
+    }
+
+    public void removeAll(boolean isRestarting) {
+        // Paper end
+         // CraftBukkit start - disconnect safely
+         for (ServerPlayer player : this.players) {
+            if (isRestarting) player.connection.disconnect(org.spigotmc.SpigotConfig.restartMessage); else // Paper
+             player.connection.disconnect(this.server.server.shutdownMessage()); // CraftBukkit - add custom shutdown message // Paper - Adventure
+         }
+         // CraftBukkit end
+diff --git a/src/main/java/org/spigotmc/RestartCommand.java b/src/main/java/org/spigotmc/RestartCommand.java
+index 882e93ad4471e3688f2fcfb1e6f16926786ee5e7..14eadb0f81dfad072d82d7793cce1a4dd3f2c5f0 100644
+--- a/src/main/java/org/spigotmc/RestartCommand.java
+++ b/src/main/java/org/spigotmc/RestartCommand.java
+@@ -45,86 +45,134 @@ public class RestartCommand extends Command
+         AsyncCatcher.enabled = false; // Disable async catcher incase it interferes with us
+         try
+         {
+-            String[] split = restartScript.split( " " );
+-            if ( split.length > 0 && new File( split[0] ).isFile() )
+            // Paper - extract method and cleanup
+            boolean isRestarting = addShutdownHook( restartScript );
+            if ( isRestarting )
+             {
+-                System.out.println( "Attempting to restart with " + restartScript );
+                System.out.println( "Attempting to restart with " + SpigotConfig.restartScript );
+            } else
+            {
+                System.out.println( "Startup script '" + SpigotConfig.restartScript + "' does not exist! Stopping server." );
+            }
+            // Stop the watchdog
+            WatchdogThread.doStop();
+ 
+-                // Disable Watchdog
+-                WatchdogThread.doStop();
+            shutdownServer( isRestarting );
+            // Paper end
+        } catch ( Exception ex )
+        {
+            ex.printStackTrace();
+        }
+    }
+ 
+-                // Kick all players
+-                for ( ServerPlayer p : (List<ServerPlayer>) MinecraftServer.getServer().getPlayerList().players )
+-                {
+-                    p.connection.disconnect(SpigotConfig.restartMessage);
+-                }
+-                // Give the socket a chance to send the packets
+-                try
+-                {
+-                    Thread.sleep( 100 );
+-                } catch ( InterruptedException ex )
+-                {
+-                }
+-                // Close the socket so we can rebind with the new process
+-                MinecraftServer.getServer().getConnection().stop();
+    // Paper start - sync copied from above with minor changes, async added
+    private static void shutdownServer(boolean isRestarting)
+    {
+        if ( MinecraftServer.getServer().isSameThread() )
+        {
+            // Kick all players
+            for ( ServerPlayer p : com.google.common.collect.ImmutableList.copyOf( MinecraftServer.getServer().getPlayerList().players ) )
+            {
+                p.connection.disconnect(SpigotConfig.restartMessage);
+            }
+            // Give the socket a chance to send the packets
+            try
+            {
+                Thread.sleep( 100 );
+            } catch ( InterruptedException ex )
+            {
+            }
+ 
+-                // Give time for it to kick in
+-                try
+-                {
+-                    Thread.sleep( 100 );
+-                } catch ( InterruptedException ex )
+-                {
+-                }
+            closeSocket();
+ 
+-                // Actually shutdown
+-                try
+-                {
+-                    MinecraftServer.getServer().close();
+-                } catch ( Throwable t )
+-                {
+-                }
+            // Actually shutdown
+            try
+            {
+                MinecraftServer.getServer().close(); // calls stop()
+            } catch ( Throwable t )
+            {
+            }
+
+            // Actually stop the JVM
+            System.exit( 0 );
+ 
+-                // This will be done AFTER the server has completely halted
+-                Thread shutdownHook = new Thread()
+        } else
+        {
+            // Mark the server to shutdown at the end of the tick
+            MinecraftServer.getServer().safeShutdown( false, isRestarting );
+
+            // wait 10 seconds to see if we're actually going to try shutdown
+            try
+            {
+                Thread.sleep( 10000 );
+            }
+            catch (InterruptedException ignored)
+            {
+            }
+
+            // Check if we've actually hit a state where the server is going to safely shutdown
+            // if we have, let the server stop as usual
+            if (MinecraftServer.getServer().isStopped()) return;
+
+            // If the server hasn't stopped by now, assume worse case and kill
+            closeSocket();
+            System.exit( 0 );
+        }
+    }
+    // Paper end
+
+    // Paper - Split from moved code
+    private static void closeSocket()
+    {
+        // Close the socket so we can rebind with the new process
+        MinecraftServer.getServer().getConnection().stop();
+
+        // Give time for it to kick in
+        try
+        {
+            Thread.sleep( 100 );
+        } catch ( InterruptedException ex )
+        {
+        }
+    }
+    // Paper end
+
+    // Paper start - copied from above and modified to return if the hook registered
+    private static boolean addShutdownHook(String restartScript)
+    {
+        String[] split = restartScript.split( " " );
+        if ( split.length > 0 && new File( split[0] ).isFile() )
+        {
+            Thread shutdownHook = new Thread()
+            {
+                @Override
+                public void run()
+                 {
+-                    @Override
+-                    public void run()
+                    try
+                     {
+-                        try
+                        String os = System.getProperty( "os.name" ).toLowerCase(java.util.Locale.ENGLISH);
+                        if ( os.contains( "win" ) )
+                         {
+-                            String os = System.getProperty( "os.name" ).toLowerCase(java.util.Locale.ENGLISH);
+-                            if ( os.contains( "win" ) )
+-                            {
+-                                Runtime.getRuntime().exec( "cmd /c start " + restartScript );
+-                            } else
+-                            {
+-                                Runtime.getRuntime().exec( "sh " + restartScript );
+-                            }
+-                        } catch ( Exception e )
+                            Runtime.getRuntime().exec( "cmd /c start " + restartScript );
+                        } else
+                         {
+-                            e.printStackTrace();
+                            Runtime.getRuntime().exec( "sh " + restartScript );
+                         }
+                    } catch ( Exception e )
+                    {
+                        e.printStackTrace();
+                     }
+-                };
+-
+-                shutdownHook.setDaemon( true );
+-                Runtime.getRuntime().addShutdownHook( shutdownHook );
+-            } else
+-            {
+-                System.out.println( "Startup script '" + SpigotConfig.restartScript + "' does not exist! Stopping server." );
+-
+-                // Actually shutdown
+-                try
+-                {
+-                    MinecraftServer.getServer().close();
+-                } catch ( Throwable t )
+-                {
+                 }
+-            }
+-            System.exit( 0 );
+-        } catch ( Exception ex )
+            };
+
+            shutdownHook.setDaemon( true );
+            Runtime.getRuntime().addShutdownHook( shutdownHook );
+            return true;
+        } else
+         {
+-            ex.printStackTrace();
+            return false;
+         }
+     }
+    // Paper end
+
+ }
--- a/patches/server/0131-Add-option-to-make-parrots-stay-on-shoulders-despite.patch
+++ b/patches/server/0131-Add-option-to-make-parrots-stay-on-shoulders-despite.patch
@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach.brown@destroystokyo.com>
+Date: Tue, 16 May 2017 21:29:08 -0500
+Subject: [PATCH] Add option to make parrots stay on shoulders despite movement
+
+Makes parrots not fall off whenever the player changes height, or touches water, or gets hit by a passing leaf.
+Instead, switches the behavior so that players have to sneak to make the birds leave.
+
+I suspect Mojang may switch to this behavior before full release.
+
+To be converted into a Paper-API event at some point in the future?
+
+== AT ==
+public net.minecraft.world.entity.player.Player removeEntitiesOnShoulder()V
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 4c9454589b5fe98d8b6be84fe07970efa5f07732..4ab881766975eb4853094ad0d70e9e0647a0c23e 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -2163,6 +2163,13 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+         switch (packet.getAction()) {
+             case PRESS_SHIFT_KEY:
+                 this.player.setShiftKeyDown(true);
+
+                // Paper start - Hang on!
+                if (this.player.level().paperConfig().entities.behavior.parrotsAreUnaffectedByPlayerMovement) {
+                    this.player.removeEntitiesOnShoulder();
+                }
+                // Paper end
+
+                 break;
+             case RELEASE_SHIFT_KEY:
+                 this.player.setShiftKeyDown(false);
+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 62a52216e27c0e4847b9c346c35c3d1b7b3b15aa..a2f6e3f381bf251d93a63aff9f9af307350ffc50 100644
+--- a/src/main/java/net/minecraft/world/entity/player/Player.java
+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
+@@ -594,6 +594,7 @@ public abstract class Player extends LivingEntity {
+         this.playShoulderEntityAmbientSound(this.getShoulderEntityLeft());
+         this.playShoulderEntityAmbientSound(this.getShoulderEntityRight());
+         if (!this.level().isClientSide && (this.fallDistance > 0.5F || this.isInWater()) || this.abilities.flying || this.isSleeping() || this.isInPowderSnow) {
+            if (!this.level().paperConfig().entities.behavior.parrotsAreUnaffectedByPlayerMovement) // Paper - Hang on!
+             this.removeEntitiesOnShoulder();
+         }
+ 
--- a/patches/server/0132-Add-configuration-option-to-prevent-player-names-fro.patch
+++ b/patches/server/0132-Add-configuration-option-to-prevent-player-names-fro.patch
@ -0,0 +1,22 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: kashike <kashike@vq.lc>
+Date: Fri, 9 Jun 2017 07:24:34 -0700
+Subject: [PATCH] Add configuration option to prevent player names from being
+ suggested
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index c23e5dc08bbcbdc5787c730f0a2857aacff2e69e..a51ab0eddb94263642b0015967cd2e6987ed2619 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -2667,5 +2667,10 @@ public final class CraftServer implements Server {
+         commandMap.registerServerAliases();
+         return true;
+     }
+
+    @Override
+    public boolean suggestPlayerNamesWhenNullTabCompletions() {
+        return io.papermc.paper.configuration.GlobalConfiguration.get().commands.suggestPlayerNamesWhenNullTabCompletions;
+    }
+     // Paper end
+ }
--- a/patches/server/0133-Use-TerminalConsoleAppender-for-console-improvements.patch
+++ b/patches/server/0133-Use-TerminalConsoleAppender-for-console-improvements.patch
@ -0,0 +1,670 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Minecrell <minecrell@minecrell.net>
+Date: Fri, 9 Jun 2017 19:03:43 +0200
+Subject: [PATCH] Use TerminalConsoleAppender for console improvements
+
+Rewrite console improvements (console colors, tab completion,
+persistent input line, ...) using JLine 3.x and TerminalConsoleAppender.
+
+Also uses the new ANSIComponentSerializer to serialize components when
+logging them via the ComponentLogger, or when sending messages to the
+console, for hex color support.
+
+New features:
+  - Support console colors for Vanilla commands
+  - Add console colors for warnings and errors
+  - Server can now be turned off safely using CTRL + C. JLine catches
+    the signal and the implementation shuts down the server cleanly.
+  - Support console colors and persistent input line when running in
+    IntelliJ IDEA
+
+Other changes:
+  - Server starts 1-2 seconds faster thanks to optimizations in Log4j
+    configuration
+
+Co-Authored-By: Emilia Kond <emilia@rymiel.space>
+
+diff --git a/build.gradle.kts b/build.gradle.kts
+index ba38153a37e864ab7f02a169da3df8806122aa76..2f562d2fb02d58551338b055a0dd6c05df44e532 100644
+--- a/build.gradle.kts
+++ b/build.gradle.kts
+@@ -6,9 +6,30 @@ plugins {
+     id("com.github.johnrengelman.shadow")
+ }
+ 
+val log4jPlugins = sourceSets.create("log4jPlugins")
+configurations.named(log4jPlugins.compileClasspathConfigurationName) {
+    extendsFrom(configurations.compileClasspath.get())
+}
+val alsoShade: Configuration by configurations.creating
+
+ dependencies {
+     implementation(project(":paper-api"))
+-    implementation("jline:jline:2.12.1")
+    // Paper start
+    implementation("org.jline:jline-terminal-jansi:3.21.0")
+    implementation("net.minecrell:terminalconsoleappender:1.3.0")
+    implementation("net.kyori:adventure-text-serializer-ansi:4.14.0") // Keep in sync with adventureVersion from Paper-API build file
+    implementation("net.kyori:ansi:1.0.3") // Manually bump beyond above transitive dep
+    /*
+          Required to add the missing Log4j2Plugins.dat file from log4j-core
+          which has been removed by Mojang. Without it, log4j has to classload
+          all its classes to check if they are plugins.
+          Scanning takes about 1-2 seconds so adding this speeds up the server start.
+     */
+    runtimeOnly("org.apache.logging.log4j:log4j-core:2.19.0")
+    log4jPlugins.annotationProcessorConfigurationName("org.apache.logging.log4j:log4j-core:2.19.0") // Paper - Needed to generate meta for our Log4j plugins
+    runtimeOnly(log4jPlugins.output)
+    alsoShade(log4jPlugins.output)
+    // Paper end
+     implementation("org.apache.logging.log4j:log4j-iostreams:2.19.0") // Paper - remove exclusion
+     implementation("org.ow2.asm:asm:9.5")
+     implementation("org.ow2.asm:asm-commons:9.5") // Paper - ASM event executor generation
+@@ -75,7 +96,7 @@ relocation {
+ }
+ 
+ tasks.shadowJar {
+-    configurations = listOf(project.configurations.vanillaServer.get())
+    configurations = listOf(project.configurations.vanillaServer.get(), alsoShade)
+     archiveClassifier.set("mojang-mapped")
+ 
+     for (relocation in relocation.relocations.get()) {
+diff --git a/src/log4jPlugins/java/io/papermc/paper/console/StripANSIConverter.java b/src/log4jPlugins/java/io/papermc/paper/console/StripANSIConverter.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..91547f6e6fe90006713beb2818da634304bdd236
+--- /dev/null
+++ b/src/log4jPlugins/java/io/papermc/paper/console/StripANSIConverter.java
+@@ -0,0 +1,51 @@
+package io.papermc.paper.console;
+
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.config.Configuration;
+import org.apache.logging.log4j.core.config.plugins.Plugin;
+import org.apache.logging.log4j.core.layout.PatternLayout;
+import org.apache.logging.log4j.core.pattern.ConverterKeys;
+import org.apache.logging.log4j.core.pattern.LogEventPatternConverter;
+import org.apache.logging.log4j.core.pattern.PatternConverter;
+import org.apache.logging.log4j.core.pattern.PatternFormatter;
+import org.apache.logging.log4j.core.pattern.PatternParser;
+
+import java.util.List;
+import java.util.regex.Pattern;
+
+@Plugin(name = "stripAnsi", category = PatternConverter.CATEGORY)
+@ConverterKeys({"stripAnsi"})
+public final class StripANSIConverter extends LogEventPatternConverter {
+    final private Pattern ANSI_PATTERN = Pattern.compile("\\e\\[[\\d;]*[^\\d;]");
+
+    private final List<PatternFormatter> formatters;
+
+    private StripANSIConverter(List<PatternFormatter> formatters) {
+        super("stripAnsi", null);
+        this.formatters = formatters;
+    }
+
+    @Override
+    public void format(LogEvent event, StringBuilder toAppendTo) {
+        int start = toAppendTo.length();
+        for (PatternFormatter formatter : formatters) {
+            formatter.format(event, toAppendTo);
+        }
+        String content = toAppendTo.substring(start);
+        content = ANSI_PATTERN.matcher(content).replaceAll("");
+
+        toAppendTo.setLength(start);
+        toAppendTo.append(content);
+    }
+
+    public static StripANSIConverter newInstance(Configuration config, String[] options) {
+        if (options.length != 1) {
+            LOGGER.error("Incorrect number of options on stripAnsi. Expected exactly 1, received " + options.length);
+            return null;
+        }
+
+        PatternParser parser = PatternLayout.createPatternParser(config);
+        List<PatternFormatter> formatters = parser.parse(options[0]);
+        return new StripANSIConverter(formatters);
+    }
+}
+diff --git a/src/main/java/com/destroystokyo/paper/console/PaperConsole.java b/src/main/java/com/destroystokyo/paper/console/PaperConsole.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..a4070b59e261f0f1ac4beec47b11492f4724bf27
+--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/console/PaperConsole.java
+@@ -0,0 +1,41 @@
+package com.destroystokyo.paper.console;
+
+import net.minecraft.server.dedicated.DedicatedServer;
+import net.minecrell.terminalconsole.SimpleTerminalConsole;
+import org.bukkit.craftbukkit.command.ConsoleCommandCompleter;
+import org.jline.reader.LineReader;
+import org.jline.reader.LineReaderBuilder;
+
+public final class PaperConsole extends SimpleTerminalConsole {
+
+    private final DedicatedServer server;
+
+    public PaperConsole(DedicatedServer server) {
+        this.server = server;
+    }
+
+    @Override
+    protected LineReader buildReader(LineReaderBuilder builder) {
+        return super.buildReader(builder
+                .appName("Paper")
+                .variable(LineReader.HISTORY_FILE, java.nio.file.Paths.get(".console_history"))
+                .completer(new ConsoleCommandCompleter(this.server))
+        );
+    }
+
+    @Override
+    protected boolean isRunning() {
+        return !this.server.isStopped() && this.server.isRunning();
+    }
+
+    @Override
+    protected void runCommand(String command) {
+        this.server.handleConsoleInput(command, this.server.createCommandSourceStack());
+    }
+
+    @Override
+    protected void shutdown() {
+        this.server.halt(false);
+    }
+
+}
+diff --git a/src/main/java/com/destroystokyo/paper/console/TerminalConsoleCommandSender.java b/src/main/java/com/destroystokyo/paper/console/TerminalConsoleCommandSender.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..8f07539a82f449ad217e316a7513a1708781fb63
+--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/console/TerminalConsoleCommandSender.java
+@@ -0,0 +1,26 @@
+package com.destroystokyo.paper.console;
+
+import net.kyori.adventure.audience.MessageType;
+import net.kyori.adventure.identity.Identity;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.logger.slf4j.ComponentLogger;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+import org.apache.logging.log4j.LogManager;
+import org.bukkit.craftbukkit.command.CraftConsoleCommandSender;
+
+public class TerminalConsoleCommandSender extends CraftConsoleCommandSender {
+
+    private static final ComponentLogger LOGGER = ComponentLogger.logger(LogManager.getRootLogger().getName());
+
+    @Override
+    public void sendRawMessage(String message) {
+        final Component msg = LegacyComponentSerializer.legacySection().deserialize(message);
+        this.sendMessage(Identity.nil(), msg, MessageType.SYSTEM);
+    }
+
+    @Override
+    public void sendMessage(Identity identity, Component message, MessageType type) {
+        LOGGER.info(message);
+    }
+
+}
+diff --git a/src/main/java/io/papermc/paper/adventure/PaperAdventure.java b/src/main/java/io/papermc/paper/adventure/PaperAdventure.java
+index 3dc613116c086444ece88bcb0a569eeea953074f..db54a9c32578defa02fa58dc694c96684a4885ac 100644
+--- a/src/main/java/io/papermc/paper/adventure/PaperAdventure.java
+++ b/src/main/java/io/papermc/paper/adventure/PaperAdventure.java
+@@ -20,6 +20,7 @@ import net.kyori.adventure.text.TranslatableComponent;
+ import net.kyori.adventure.text.flattener.ComponentFlattener;
+ import net.kyori.adventure.text.format.TextColor;
+ import net.kyori.adventure.text.serializer.ComponentSerializer;
+import net.kyori.adventure.text.serializer.ansi.ANSIComponentSerializer;
+ import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
+ import net.kyori.adventure.text.serializer.plain.PlainComponentSerializer;
+ import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
+@@ -107,6 +108,9 @@ public final class PaperAdventure {
+     public static final AttributeKey<Locale> LOCALE_ATTRIBUTE = AttributeKey.valueOf("adventure:locale"); // init after FLATTENER because classloading triggered here might create a logger
+     @Deprecated
+     public static final PlainComponentSerializer PLAIN = PlainComponentSerializer.builder().flattener(FLATTENER).build();
+
+    public static final ANSIComponentSerializer ANSI_SERIALIZER = ANSIComponentSerializer.builder().flattener(FLATTENER).build();
+
+     private static final Codec<CompoundTag, String, IOException, IOException> NBT_CODEC = new Codec<CompoundTag, String, IOException, IOException>() {
+         @Override
+         public @NotNull CompoundTag decode(final @NotNull String encoded) throws IOException {
+diff --git a/src/main/java/io/papermc/paper/adventure/providers/ComponentLoggerProviderImpl.java b/src/main/java/io/papermc/paper/adventure/providers/ComponentLoggerProviderImpl.java
+index c3631efda9c7fa531a8a9f18fbee7b5f8655382b..769f6489632302627fa1730cc08e77f51eb54eb4 100644
+--- a/src/main/java/io/papermc/paper/adventure/providers/ComponentLoggerProviderImpl.java
+++ b/src/main/java/io/papermc/paper/adventure/providers/ComponentLoggerProviderImpl.java
+@@ -1,9 +1,11 @@
+ package io.papermc.paper.adventure.providers;
+ 
+ import io.papermc.paper.adventure.PaperAdventure;
+import java.util.Locale;
+ import net.kyori.adventure.text.Component;
+ import net.kyori.adventure.text.logger.slf4j.ComponentLogger;
+ import net.kyori.adventure.text.logger.slf4j.ComponentLoggerProvider;
+import net.kyori.adventure.translation.GlobalTranslator;
+ import org.jetbrains.annotations.NotNull;
+ import org.slf4j.LoggerFactory;
+ 
+@@ -14,6 +16,6 @@ public class ComponentLoggerProviderImpl implements ComponentLoggerProvider {
+     }
+ 
+     private String serialize(final Component message) {
+-        return PaperAdventure.asPlain(message, null);
+        return PaperAdventure.ANSI_SERIALIZER.serialize(GlobalTranslator.render(message, Locale.getDefault()));
+     }
+ }
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 834c60f1e85995c487f59f6504e96385d5d0ff27..440d1db090dfa62843124cec802224553aad51c0 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -164,7 +164,7 @@ import com.mojang.datafixers.util.Pair;
+ import com.mojang.serialization.DynamicOps;
+ import com.mojang.serialization.Lifecycle;
+ import java.util.Random;
+-import jline.console.ConsoleReader;
+// import jline.console.ConsoleReader; // Paper
+ import joptsimple.OptionSet;
+ import net.minecraft.core.HolderLookup;
+ import net.minecraft.resources.RegistryOps;
+@@ -278,7 +278,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     public org.bukkit.craftbukkit.CraftServer server;
+     public OptionSet options;
+     public org.bukkit.command.ConsoleCommandSender console;
+-    public ConsoleReader reader;
+    //public ConsoleReader reader; // Paper
+     public static int currentTick = 0; // Paper - Further improve tick loop
+     public java.util.Queue<Runnable> processQueue = new java.util.concurrent.ConcurrentLinkedQueue<Runnable>();
+     public int autosavePeriod;
+@@ -361,7 +361,9 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         this.options = options;
+         this.worldLoader = worldLoader;
+         this.vanillaCommandDispatcher = worldstem.dataPackResources().commands; // CraftBukkit
+        // Paper start - Handled by TerminalConsoleAppender
+         // Try to see if we're actually running in a terminal, disable jline if not
+        /*
+         if (System.console() == null && System.getProperty("jline.terminal") == null) {
+             System.setProperty("jline.terminal", "jline.UnsupportedTerminal");
+             Main.useJline = false;
+@@ -382,6 +384,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+                 MinecraftServer.LOGGER.warn((String) null, ex);
+             }
+         }
+        */
+        // Paper end
+         Runtime.getRuntime().addShutdownHook(new org.bukkit.craftbukkit.util.ServerShutdownThread(this));
+         // CraftBukkit end
+         this.paperConfigurations = services.paperConfigurations(); // Paper
+@@ -1125,7 +1129,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+                 org.spigotmc.WatchdogThread.doStop(); // Spigot
+                 // CraftBukkit start - Restore terminal to original settings
+                 try {
+-                    this.reader.getTerminal().restore();
+                    net.minecrell.terminalconsole.TerminalConsoleAppender.close(); // Paper - Use TerminalConsoleAppender
+                 } catch (Exception ignored) {
+                 }
+                 // CraftBukkit end
+@@ -1592,7 +1596,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
+     @Override
+     public void sendSystemMessage(Component message) {
+-        MinecraftServer.LOGGER.info(message.getString());
+        MinecraftServer.LOGGER.info(io.papermc.paper.adventure.PaperAdventure.ANSI_SERIALIZER.serialize(io.papermc.paper.adventure.PaperAdventure.asAdventure(message))); // Paper - Log message with colors
+     }
+ 
+     public KeyPair getKeyPair() {
+diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+index 6cc085cf212994cd00dbabd4dd363fc5b3c97281..e11aee38009a6a37dceaf42232e295b71e0b7d40 100644
+--- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -98,6 +98,9 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+                 if (!org.bukkit.craftbukkit.Main.useConsole) {
+                     return;
+                 }
+                // Paper start - Use TerminalConsoleAppender
+                new com.destroystokyo.paper.console.PaperConsole(DedicatedServer.this).start();
+                /*
+                 jline.console.ConsoleReader bufferedreader = reader;
+ 
+                 // MC-33041, SPIGOT-5538: if System.in is not valid due to javaw, then return
+@@ -129,7 +132,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+                             continue;
+                         }
+                         if (s.trim().length() > 0) { // Trim to filter lines which are just spaces
+-                            DedicatedServer.this.handleConsoleInput(s, DedicatedServer.this.createCommandSourceStack());
+                            DedicatedServer.this.issueCommand(s, DedicatedServer.this.getServerCommandListener());
+                         }
+                         // CraftBukkit end
+                     }
+@@ -137,6 +140,8 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+                     DedicatedServer.LOGGER.error("Exception handling console input", ioexception);
+                 }
+ 
+                */
+                // Paper end
+             }
+         };
+ 
+@@ -148,6 +153,9 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+         }
+         global.addHandler(new org.bukkit.craftbukkit.util.ForwardLogHandler());
+ 
+        // Paper start - Not needed with TerminalConsoleAppender
+        final org.apache.logging.log4j.Logger logger = LogManager.getRootLogger();
+        /*
+         final org.apache.logging.log4j.core.Logger logger = ((org.apache.logging.log4j.core.Logger) LogManager.getRootLogger());
+         for (org.apache.logging.log4j.core.Appender appender : logger.getAppenders().values()) {
+             if (appender instanceof org.apache.logging.log4j.core.appender.ConsoleAppender) {
+@@ -156,6 +164,8 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+         }
+ 
+         new org.bukkit.craftbukkit.util.TerminalConsoleWriterThread(System.out, this.reader).start();
+        */
+        // Paper end
+ 
+         System.setOut(IoBuilder.forLogger(logger).setLevel(Level.INFO).buildPrintStream());
+         System.setErr(IoBuilder.forLogger(logger).setLevel(Level.WARN).buildPrintStream());
+diff --git a/src/main/java/net/minecraft/server/gui/MinecraftServerGui.java b/src/main/java/net/minecraft/server/gui/MinecraftServerGui.java
+index 75083eeb9b413e6dd5375007360dce6857a08fff..d292fdb165436f0b9b46b32110f5e09ad0e517a1 100644
+--- a/src/main/java/net/minecraft/server/gui/MinecraftServerGui.java
+++ b/src/main/java/net/minecraft/server/gui/MinecraftServerGui.java
+@@ -166,7 +166,7 @@ public class MinecraftServerGui extends JComponent {
+         this.finalizers.forEach(Runnable::run);
+     }
+ 
+-    private static final java.util.regex.Pattern ANSI = java.util.regex.Pattern.compile("\\x1B\\[([0-9]{1,2}(;[0-9]{1,2})*)?[m|K]"); // CraftBukkit
+    private static final java.util.regex.Pattern ANSI = java.util.regex.Pattern.compile("\\e\\[[\\d;]*[^\\d;]"); // CraftBukkit // Paper
+     public void print(JTextArea textArea, JScrollPane scrollPane, String message) {
+         if (!SwingUtilities.isEventDispatchThread()) {
+             SwingUtilities.invokeLater(() -> {
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 9d700d27d05c6f276b3ca159735fece0a75ca9b1..0fb1fda1aba730e54d9e922e18de3bd048a78a62 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -162,8 +162,7 @@ public abstract class PlayerList {
+ 
+     public PlayerList(MinecraftServer server, LayeredRegistryAccess<RegistryLayer> registryManager, PlayerDataStorage saveHandler, int maxPlayers) {
+         this.cserver = server.server = new CraftServer((DedicatedServer) server, this);
+-        server.console = org.bukkit.craftbukkit.command.ColouredConsoleSender.getInstance();
+-        server.reader.addCompleter(new org.bukkit.craftbukkit.command.ConsoleCommandCompleter(server.server));
+        server.console = new com.destroystokyo.paper.console.TerminalConsoleCommandSender(); // Paper
+         // CraftBukkit end
+ 
+         this.bans = new UserBanList(PlayerList.USERBANLIST_FILE);
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index a51ab0eddb94263642b0015967cd2e6987ed2619..15d881193f40dda74996932854283e4551742185 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -44,7 +44,6 @@ import java.util.logging.Level;
+ import java.util.logging.Logger;
+ import java.util.stream.Collectors;
+ import javax.imageio.ImageIO;
+-import jline.console.ConsoleReader;
+ import net.minecraft.advancements.Advancement;
+ import net.minecraft.advancements.AdvancementHolder;
+ import net.minecraft.commands.CommandSourceStack;
+@@ -1295,9 +1294,13 @@ public final class CraftServer implements Server {
+         return this.logger;
+     }
+ 
+    // Paper start - JLine update
+    /*
+     public ConsoleReader getReader() {
+         return console.reader;
+     }
+    */
+    // Paper end
+ 
+     @Override
+     public PluginCommand getPluginCommand(String name) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/Main.java b/src/main/java/org/bukkit/craftbukkit/Main.java
+index e9dbf4504232ba667ee8f6de18ab5356acd19da6..601288ff52f0f0b0c82a5ff0414b60b8cb6e3a26 100644
+--- a/src/main/java/org/bukkit/craftbukkit/Main.java
+++ b/src/main/java/org/bukkit/craftbukkit/Main.java
+@@ -13,7 +13,6 @@ import java.util.logging.Logger;
+ import joptsimple.OptionParser;
+ import joptsimple.OptionSet;
+ import joptsimple.util.PathConverter;
+-import org.fusesource.jansi.AnsiConsole;
+ 
+ public class Main {
+     public static boolean useJline = true;
+@@ -219,6 +218,8 @@ public class Main {
+             }
+ 
+             try {
+                // Paper start - Handled by TerminalConsoleAppender
+                /*
+                 // This trick bypasses Maven Shade's clever rewriting of our getProperty call when using String literals
+                 String jline_UnsupportedTerminal = new String(new char[]{'j', 'l', 'i', 'n', 'e', '.', 'U', 'n', 's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', 'T', 'e', 'r', 'm', 'i', 'n', 'a', 'l'});
+                 String jline_terminal = new String(new char[]{'j', 'l', 'i', 'n', 'e', '.', 't', 'e', 'r', 'm', 'i', 'n', 'a', 'l'});
+@@ -236,9 +237,18 @@ public class Main {
+                     // This ensures the terminal literal will always match the jline implementation
+                     System.setProperty(jline.TerminalFactory.JLINE_TERMINAL, jline.UnsupportedTerminal.class.getName());
+                 }
+                */
+
+                if (options.has("nojline")) {
+                    System.setProperty(net.minecrell.terminalconsole.TerminalConsoleAppender.JLINE_OVERRIDE_PROPERTY, "false");
+                    useJline = false;
+                }
+                // Paper end
+ 
+                 if (options.has("noconsole")) {
+                     Main.useConsole = false;
+                    useJline = false; // Paper
+                    System.setProperty(net.minecrell.terminalconsole.TerminalConsoleAppender.JLINE_OVERRIDE_PROPERTY, "false"); // Paper
+                 }
+ 
+                 if (Main.class.getPackage().getImplementationVendor() != null && System.getProperty("IReallyKnowWhatIAmDoingISwear") == null) {
+@@ -266,7 +276,7 @@ public class Main {
+                     System.out.println("Unable to read system info");
+                 }
+                 // Paper end
+-
+                System.setProperty( "library.jansi.version", "Paper" ); // Paper - set meaningless jansi version to prevent git builds from crashing on Windows
+                 System.out.println("Loading libraries, please wait...");
+                 net.minecraft.server.Main.main(options);
+             } catch (Throwable t) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/command/ColouredConsoleSender.java b/src/main/java/org/bukkit/craftbukkit/command/ColouredConsoleSender.java
+index 76fb1ecd47cb86b50486effe8cc7fe4abf8e311c..21f889ddec72b40f5954eec07417e08d192b4661 100644
+--- a/src/main/java/org/bukkit/craftbukkit/command/ColouredConsoleSender.java
+++ b/src/main/java/org/bukkit/craftbukkit/command/ColouredConsoleSender.java
+@@ -5,15 +5,13 @@ import java.util.EnumMap;
+ import java.util.Map;
+ import java.util.regex.Matcher;
+ import java.util.regex.Pattern;
+-import jline.Terminal;
+//import jline.Terminal;
+ import org.bukkit.Bukkit;
+ import org.bukkit.ChatColor;
+ import org.bukkit.command.ConsoleCommandSender;
+ import org.bukkit.craftbukkit.CraftServer;
+-import org.fusesource.jansi.Ansi;
+-import org.fusesource.jansi.Ansi.Attribute;
+ 
+-public class ColouredConsoleSender extends CraftConsoleCommandSender {
+public class ColouredConsoleSender /*extends CraftConsoleCommandSender */{/* // Paper - disable
+     private final Terminal terminal;
+     private final Map<ChatColor, String> replacements = new EnumMap<ChatColor, String>(ChatColor.class);
+     private final ChatColor[] colors = ChatColor.values();
+@@ -93,5 +91,5 @@ public class ColouredConsoleSender extends CraftConsoleCommandSender {
+         } else {
+             return new ColouredConsoleSender();
+         }
+-    }
+    }*/ // Paper
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java b/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java
+index 0b4c62387c1093652ac15b64a8703249de4cf088..b996fde481cebbbcce80a6c267591136db7cc0bc 100644
+--- a/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java
+++ b/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java
+@@ -4,50 +4,73 @@ import java.util.Collections;
+ import java.util.List;
+ import java.util.concurrent.ExecutionException;
+ import java.util.logging.Level;
+-import jline.console.completer.Completer;
+import net.minecraft.server.dedicated.DedicatedServer;
+ import org.bukkit.craftbukkit.CraftServer;
+ import org.bukkit.craftbukkit.util.Waitable;
+
+// Paper start - JLine update
+import org.jline.reader.Candidate;
+import org.jline.reader.Completer;
+import org.jline.reader.LineReader;
+import org.jline.reader.ParsedLine;
+// Paper end
+ import org.bukkit.event.server.TabCompleteEvent;
+ 
+ public class ConsoleCommandCompleter implements Completer {
+-    private final CraftServer server;
+    private final DedicatedServer server; // Paper - CraftServer -> DedicatedServer
+ 
+-    public ConsoleCommandCompleter(CraftServer server) {
+    public ConsoleCommandCompleter(DedicatedServer server) { // Paper - CraftServer -> DedicatedServer
+         this.server = server;
+     }
+ 
+    // Paper start - Change method signature for JLine update
+     @Override
+-    public int complete(final String buffer, final int cursor, final List<CharSequence> candidates) {
+    public void complete(LineReader reader, ParsedLine line, List<Candidate> candidates) {
+        final CraftServer server = this.server.server;
+        final String buffer = line.line();
+        // Paper end
+         Waitable<List<String>> waitable = new Waitable<List<String>>() {
+             @Override
+             protected List<String> evaluate() {
+-                List<String> offers = ConsoleCommandCompleter.this.server.getCommandMap().tabComplete(ConsoleCommandCompleter.this.server.getConsoleSender(), buffer);
+                List<String> offers = server.getCommandMap().tabComplete(server.getConsoleSender(), buffer); // Paper - fix remap
+ 
+-                TabCompleteEvent tabEvent = new TabCompleteEvent(ConsoleCommandCompleter.this.server.getConsoleSender(), buffer, (offers == null) ? Collections.EMPTY_LIST : offers);
+-                ConsoleCommandCompleter.this.server.getPluginManager().callEvent(tabEvent);
+                TabCompleteEvent tabEvent = new TabCompleteEvent(server.getConsoleSender(), buffer, (offers == null) ? Collections.EMPTY_LIST : offers); // Paper - fix remap
+                server.getPluginManager().callEvent(tabEvent); // Paper - fix remap
+ 
+                 return tabEvent.isCancelled() ? Collections.EMPTY_LIST : tabEvent.getCompletions();
+             }
+         };
+-        this.server.getServer().processQueue.add(waitable);
+        server.getServer().processQueue.add(waitable); // Paper - Remove "this."
+         try {
+             List<String> offers = waitable.get();
+             if (offers == null) {
+-                return cursor;
+                return; // Paper - Method returns void
+            }
+
+            // Paper start - JLine update
+            for (String completion : offers) {
+                if (completion.isEmpty()) {
+                    continue;
+                }
+
+                candidates.add(new Candidate(completion));
+             }
+-            candidates.addAll(offers);
+            // Paper end
+ 
+            // Paper start - JLine handles cursor now
+            /*
+             final int lastSpace = buffer.lastIndexOf(' ');
+             if (lastSpace == -1) {
+                 return cursor - buffer.length();
+             } else {
+                 return cursor - (buffer.length() - lastSpace - 1);
+             }
+            */
+            // Paper end
+         } catch (ExecutionException e) {
+-            this.server.getLogger().log(Level.WARNING, "Unhandled exception when tab completing", e);
+            server.getLogger().log(Level.WARNING, "Unhandled exception when tab completing", e); // Paper - Remove "this."
+         } catch (InterruptedException e) {
+             Thread.currentThread().interrupt();
+         }
+-        return cursor;
+     }
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/util/ServerShutdownThread.java b/src/main/java/org/bukkit/craftbukkit/util/ServerShutdownThread.java
+index 19c44daaa407b7c1c7a7ffe56fef8c8814c6d5b2..c6e8441e299f477ddb22c1ce2618710763978f1a 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/ServerShutdownThread.java
+++ b/src/main/java/org/bukkit/craftbukkit/util/ServerShutdownThread.java
+@@ -16,7 +16,7 @@ public class ServerShutdownThread extends Thread {
+             this.server.close();
+         } finally {
+             try {
+-                server.reader.getTerminal().restore();
+                net.minecrell.terminalconsole.TerminalConsoleAppender.close(); // Paper - Use TerminalConsoleAppender
+             } catch (Exception e) {
+             }
+         }
+diff --git a/src/main/java/org/bukkit/craftbukkit/util/TerminalConsoleWriterThread.java b/src/main/java/org/bukkit/craftbukkit/util/TerminalConsoleWriterThread.java
+index 1d8b279f3cbe6fde6bb1bfc4985c4133b0d4a95d..cdc52bbe5c6ae4688615a7732b10071f7f51718e 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/TerminalConsoleWriterThread.java
+++ b/src/main/java/org/bukkit/craftbukkit/util/TerminalConsoleWriterThread.java
+@@ -5,12 +5,12 @@ import java.io.IOException;
+ import java.io.OutputStream;
+ import java.util.logging.Level;
+ import java.util.logging.Logger;
+-import jline.console.ConsoleReader;
+//import jline.console.ConsoleReader;
+ import org.bukkit.craftbukkit.Main;
+-import org.fusesource.jansi.Ansi;
+-import org.fusesource.jansi.Ansi.Erase;
+//import org.fusesource.jansi.Ansi;
+//import org.fusesource.jansi.Ansi.Erase;
+ 
+-public class TerminalConsoleWriterThread extends Thread {
+public class TerminalConsoleWriterThread /*extends Thread*/ {/* // Paper - disable
+     private final ConsoleReader reader;
+     private final OutputStream output;
+ 
+@@ -54,5 +54,5 @@ public class TerminalConsoleWriterThread extends Thread {
+                 Logger.getLogger(TerminalConsoleWriterThread.class.getName()).log(Level.SEVERE, null, ex);
+             }
+         }
+-    }
+    }*/
+ }
+diff --git a/src/main/resources/log4j2.component.properties b/src/main/resources/log4j2.component.properties
+new file mode 100644
+index 0000000000000000000000000000000000000000..0694b21465fb9e4164e71862ff24b62241b191f2
+--- /dev/null
+++ b/src/main/resources/log4j2.component.properties
+@@ -0,0 +1 @@
+log4j.skipJansi=true
+diff --git a/src/main/resources/log4j2.xml b/src/main/resources/log4j2.xml
+index 722ca84968cbbbdeffd09939abff0cccd0a84010..a994ec0f8621b1f267b40049306f63479c050e2f 100644
+--- a/src/main/resources/log4j2.xml
+++ b/src/main/resources/log4j2.xml
+@@ -1,17 +1,14 @@
+ <?xml version="1.0" encoding="UTF-8"?>
+ <Configuration status="WARN" packages="com.mojang.util">
+     <Appenders>
+-        <Console name="SysOut" target="SYSTEM_OUT">
+-            <PatternLayout pattern="[%d{HH:mm:ss}] [%t/%level]: %msg%n" />
+-        </Console>
+         <Queue name="ServerGuiConsole">
+             <PatternLayout pattern="[%d{HH:mm:ss} %level]: %msg%n" />
+         </Queue>
+-        <Queue name="TerminalConsole">
+-            <PatternLayout pattern="[%d{HH:mm:ss}] [%t/%level]: %msg%n" />
+-        </Queue>
+        <TerminalConsole name="TerminalConsole">
+            <PatternLayout pattern="%highlightError{[%d{HH:mm:ss} %level]: %msg%n%xEx}" />
+        </TerminalConsole>
+         <RollingRandomAccessFile name="File" fileName="logs/latest.log" filePattern="logs/%d{yyyy-MM-dd}-%i.log.gz">
+-            <PatternLayout pattern="[%d{HH:mm:ss}] [%t/%level]: %msg%n" />
+            <PatternLayout pattern="[%d{HH:mm:ss}] [%t/%level]: %stripAnsi{%msg}%n" />
+             <Policies>
+                 <TimeBasedTriggeringPolicy />
+                 <OnStartupTriggeringPolicy />
+@@ -24,10 +21,9 @@
+             <filters>
+                 <MarkerFilter marker="NETWORK_PACKETS" onMatch="DENY" onMismatch="NEUTRAL" />
+             </filters>
+-            <AppenderRef ref="SysOut" level="info"/>
+             <AppenderRef ref="File"/>
+-            <AppenderRef ref="ServerGuiConsole" level="info"/>
+             <AppenderRef ref="TerminalConsole" level="info"/>
+            <AppenderRef ref="ServerGuiConsole" level="info"/>
+         </Root>
+     </Loggers>
+ </Configuration>
--- a/patches/server/0134-provide-a-configurable-option-to-disable-creeper-lin.patch
+++ b/patches/server/0134-provide-a-configurable-option-to-disable-creeper-lin.patch
@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Sun, 11 Jun 2017 21:01:18 +0100
+Subject: [PATCH] provide a configurable option to disable creeper lingering
+ effect spawns
+
+
+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 25c4092d8d28b04b7ba5caee592b96530a08227c..6594d501f51d18f5850999cceb9febfe206ec596 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+@@ -287,7 +287,7 @@ public class Creeper extends Monster implements PowerableMob {
+     private void spawnLingeringCloud() {
+         Collection<MobEffectInstance> collection = this.getActiveEffects();
+ 
+-        if (!collection.isEmpty()) {
+        if (!collection.isEmpty() && !this.level().paperConfig().entities.behavior.disableCreeperLingeringEffect) { // Paper
+             AreaEffectCloud entityareaeffectcloud = new AreaEffectCloud(this.level(), this.getX(), this.getY(), this.getZ());
+ 
+             entityareaeffectcloud.setOwner(this); // CraftBukkit
--- a/patches/server/0135-Item-canEntityPickup.patch
+++ b/patches/server/0135-Item-canEntityPickup.patch
@ -0,0 +1,57 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Fri, 5 May 2017 03:57:17 -0500
+Subject: [PATCH] Item#canEntityPickup
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
+index 873a96693110982600d3e7979489fb00f3cd7941..645ee527b9e7e7edbf3320eae6e441bea84f58f9 100644
+--- a/src/main/java/net/minecraft/world/entity/Mob.java
+++ b/src/main/java/net/minecraft/world/entity/Mob.java
+@@ -669,6 +669,11 @@ public abstract class Mob extends LivingEntity implements Targeting {
+                 ItemEntity entityitem = (ItemEntity) iterator.next();
+ 
+                 if (!entityitem.isRemoved() && !entityitem.getItem().isEmpty() && !entityitem.hasPickUpDelay() && this.wantsToPickUp(entityitem.getItem())) {
+                    // Paper Start
+                    if (!entityitem.canMobPickup) {
+                        continue;
+                    }
+                    // Paper End
+                     this.pickUpItem(entityitem);
+                 }
+             }
+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 23c51152288d9616673ef544a09dd816dff44cf6..2d1b8d6e490e1dcde801feaae2518a59ed35e440 100644
+--- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+++ b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+@@ -52,6 +52,7 @@ public class ItemEntity extends Entity implements TraceableEntity {
+     public UUID target;
+     public final float bobOffs;
+     private int lastTick = MinecraftServer.currentTick - 1; // CraftBukkit
+    public boolean canMobPickup = true; // Paper
+ 
+     public ItemEntity(EntityType<? extends ItemEntity> type, Level world) {
+         super(type, world);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java
+index 4fbbc3c76d49c31aadd957ad3a30d479f6c99c15..66e69cb13e2d82acc0a2398625766a49bc701a09 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java
+@@ -65,6 +65,18 @@ public class CraftItem extends CraftEntity implements Item {
+         }
+     }
+ 
+    // Paper Start
+    @Override
+    public boolean canMobPickup() {
+        return item.canMobPickup;
+    }
+
+    @Override
+    public void setCanMobPickup(boolean canMobPickup) {
+        item.canMobPickup = canMobPickup;
+    }
+    // Paper End
+
+     @Override
+     public void setOwner(UUID uuid) {
+         this.item.setTarget(uuid);
--- a/patches/server/0136-PlayerPickupItemEvent-setFlyAtPlayer.patch
+++ b/patches/server/0136-PlayerPickupItemEvent-setFlyAtPlayer.patch
@ -0,0 +1,41 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Sun, 7 May 2017 06:26:09 -0500
+Subject: [PATCH] PlayerPickupItemEvent#setFlyAtPlayer
+
+
+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 2d1b8d6e490e1dcde801feaae2518a59ed35e440..0816b5fd4a384e5f8939c6d573666802dceb255c 100644
+--- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+++ b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+@@ -404,6 +404,7 @@ public class ItemEntity extends Entity implements TraceableEntity {
+             // CraftBukkit start - fire PlayerPickupItemEvent
+             int canHold = player.getInventory().canHold(itemstack);
+             int remaining = i - canHold;
+            boolean flyAtPlayer = false; // Paper
+ 
+             if (this.pickupDelay <= 0 && canHold > 0) {
+                 itemstack.setCount(canHold);
+@@ -411,8 +412,14 @@ public class ItemEntity extends Entity implements TraceableEntity {
+                 PlayerPickupItemEvent playerEvent = new PlayerPickupItemEvent((Player) player.getBukkitEntity(), (org.bukkit.entity.Item) this.getBukkitEntity(), remaining);
+                 playerEvent.setCancelled(!playerEvent.getPlayer().getCanPickupItems());
+                 this.level().getCraftServer().getPluginManager().callEvent(playerEvent);
+                flyAtPlayer = playerEvent.getFlyAtPlayer(); // Paper
+                 if (playerEvent.isCancelled()) {
+                     itemstack.setCount(i); // SPIGOT-5294 - restore count
+                    // Paper Start
+                    if (flyAtPlayer) {
+                        player.take(this, i);
+                    }
+                    // Paper End
+                     return;
+                 }
+ 
+@@ -442,6 +449,7 @@ public class ItemEntity extends Entity implements TraceableEntity {
+             // CraftBukkit end
+ 
+             if (this.pickupDelay == 0 && (this.target == null || this.target.equals(player.getUUID())) && player.getInventory().add(itemstack)) {
+                if (flyAtPlayer) // Paper
+                 player.take(this, i);
+                 if (itemstack.isEmpty()) {
+                     this.discard();
--- a/patches/server/0137-PlayerAttemptPickupItemEvent.patch
+++ b/patches/server/0137-PlayerAttemptPickupItemEvent.patch
@ -0,0 +1,41 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Sun, 11 Jun 2017 16:30:30 -0500
+Subject: [PATCH] PlayerAttemptPickupItemEvent
+
+
+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 0816b5fd4a384e5f8939c6d573666802dceb255c..91eba1c571764c88489ea2598fb9b4736554d5cc 100644
+--- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+++ b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
+@@ -36,6 +36,7 @@ import org.bukkit.entity.Player;
+ import org.bukkit.event.entity.EntityPickupItemEvent;
+ import org.bukkit.event.player.PlayerPickupItemEvent;
+ // CraftBukkit end
+import org.bukkit.event.player.PlayerAttemptPickupItemEvent; // Paper
+ 
+ public class ItemEntity extends Entity implements TraceableEntity {
+ 
+@@ -406,6 +407,22 @@ public class ItemEntity extends Entity implements TraceableEntity {
+             int remaining = i - canHold;
+             boolean flyAtPlayer = false; // Paper
+ 
+            // Paper start
+            if (this.pickupDelay <= 0) {
+                PlayerAttemptPickupItemEvent attemptEvent = new PlayerAttemptPickupItemEvent((org.bukkit.entity.Player) player.getBukkitEntity(), (org.bukkit.entity.Item) this.getBukkitEntity(), remaining);
+                this.level().getCraftServer().getPluginManager().callEvent(attemptEvent);
+
+                flyAtPlayer = attemptEvent.getFlyAtPlayer();
+                if (attemptEvent.isCancelled()) {
+                    if (flyAtPlayer) {
+                        player.take(this, i);
+                    }
+
+                    return;
+                }
+            }
+            // Paper end
+
+             if (this.pickupDelay <= 0 && canHold > 0) {
+                 itemstack.setCount(canHold);
+                 // Call legacy event
--- a/patches/server/0138-Do-not-submit-profile-lookups-to-worldgen-threads.patch
+++ b/patches/server/0138-Do-not-submit-profile-lookups-to-worldgen-threads.patch
@ -0,0 +1,77 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Sun, 8 Aug 2021 16:26:46 -0700
+Subject: [PATCH] Do not submit profile lookups to worldgen threads
+
+They block. On network I/O.
+
+If enough tasks are submitted the server will eventually stall
+out due to a sync load, as the worldgen threads will be
+stalling on profile lookups.
+
+diff --git a/src/main/java/net/minecraft/Util.java b/src/main/java/net/minecraft/Util.java
+index 9870eccc1dc5c2201f12f8e2affe647f6b0375f8..30237ca94a36197ce21369bdcc7bb1dfafe02680 100644
+--- a/src/main/java/net/minecraft/Util.java
+++ b/src/main/java/net/minecraft/Util.java
+@@ -82,6 +82,22 @@ public class Util {
+     private static final String MAX_THREADS_SYSTEM_PROPERTY = "max.bg.threads";
+     private static final AtomicInteger WORKER_COUNT = new AtomicInteger(1);
+     private static final ExecutorService BACKGROUND_EXECUTOR = makeExecutor("Main");
+    // 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() {
+
+        private final AtomicInteger count = new AtomicInteger();
+
+        @Override
+        public Thread newThread(Runnable run) {
+            Thread ret = new Thread(run);
+            ret.setName("Profile Lookup Executor #" + this.count.getAndIncrement());
+            ret.setUncaughtExceptionHandler((Thread thread, Throwable throwable) -> {
+                LOGGER.error("Uncaught exception in thread " + thread.getName(), throwable);
+            });
+            return ret;
+        }
+    });
+    // Paper end - don't submit BLOCKING PROFILE LOOKUPS to the world gen thread
+     private static final ExecutorService IO_POOL = makeIoExecutor();
+     private static final DateTimeFormatter FILENAME_DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd_HH.mm.ss", Locale.ROOT);
+     public static final long NANOS_PER_MILLI = 1000000L;
+diff --git a/src/main/java/net/minecraft/server/players/GameProfileCache.java b/src/main/java/net/minecraft/server/players/GameProfileCache.java
+index 82f6404e5c4c5b2c9aea1b1c27ebee1d3c7ee9dc..c70cd016e1978931d115cfca94664897f0158196 100644
+--- a/src/main/java/net/minecraft/server/players/GameProfileCache.java
+++ b/src/main/java/net/minecraft/server/players/GameProfileCache.java
+@@ -167,7 +167,7 @@ public class GameProfileCache {
+             } else {
+                 CompletableFuture<Optional<GameProfile>> completablefuture1 = CompletableFuture.supplyAsync(() -> {
+                     return this.get(username);
+-                }, Util.backgroundExecutor()).whenCompleteAsync((optional, throwable) -> {
+                }, Util.PROFILE_EXECUTOR).whenCompleteAsync((optional, throwable) -> { // Paper - not a good idea to use BLOCKING OPERATIONS on the worldgen executor
+                     this.requests.remove(username);
+                 }, this.executor);
+ 
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java
+index cf7e64eac9e3eb395a0be0a2a4fa0175a731b6e7..f5162f7171c348ff523b18e577246561d79e1c20 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java
+@@ -222,7 +222,7 @@ public class SkullBlockEntity extends BlockEntity {
+             } else {
+                 return Optional.empty();
+             }
+-        }, Util.backgroundExecutor());
+        }, Util.PROFILE_EXECUTOR); // Paper - not a good idea to use BLOCKING OPERATIONS on the worldgen executor
+     }
+ 
+     private static boolean hasTextures(GameProfile profile) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
+index 5a21cc441e1c925a7674299073ac374e63b911ec..ac05e268c9f00bca9f8ac19650937eede711810b 100644
+--- a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
+++ b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
+@@ -125,7 +125,7 @@ public final class CraftPlayerProfile implements PlayerProfile {
+ 
+     @Override
+     public CompletableFuture<PlayerProfile> update() {
+-        return CompletableFuture.supplyAsync(this::getUpdatedProfile, Util.backgroundExecutor());
+        return CompletableFuture.supplyAsync(this::getUpdatedProfile, Util.PROFILE_EXECUTOR); // Paper - not a good idea to use BLOCKING OPERATIONS on the worldgen executor
+     }
+ 
+     private CraftPlayerProfile getUpdatedProfile() {
--- a/patches/server/0139-Add-UnknownCommandEvent.patch
+++ b/patches/server/0139-Add-UnknownCommandEvent.patch
@ -0,0 +1,111 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Sweepyoface <github@sweepy.pw>
+Date: Sat, 17 Jun 2017 18:48:21 -0400
+Subject: [PATCH] Add UnknownCommandEvent
+
+Co-authored-by: Jake Potrebic <jake.m.potrebic@gmail.com>
+
+diff --git a/src/main/java/net/minecraft/commands/CommandSourceStack.java b/src/main/java/net/minecraft/commands/CommandSourceStack.java
+index 2ee328f204acf97b23702b4dc3b13b7f33b97a8e..902671a335da23d3945c363afc8abde6f5a1d444 100644
+--- a/src/main/java/net/minecraft/commands/CommandSourceStack.java
+++ b/src/main/java/net/minecraft/commands/CommandSourceStack.java
+@@ -344,8 +344,13 @@ public class CommandSourceStack implements SharedSuggestionProvider {
+     }
+ 
+     public void sendFailure(Component message) {
+        // Paper start
+        this.sendFailure(message, true);
+    }
+    public void sendFailure(Component message, boolean withStyle) {
+        // Paper end
+         if (this.source.acceptsFailure() && !this.silent) {
+-            this.source.sendSystemMessage(Component.empty().append(message).withStyle(ChatFormatting.RED));
+            this.source.sendSystemMessage(withStyle ? Component.empty().append(message).withStyle(ChatFormatting.RED) : message); // Paper
+         }
+ 
+     }
+diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java
+index d1ecf61ffecb8669214ad85334374a4569811de8..e63632f09d608371aaeaf09a6dac57c1d8a719d4 100644
+--- a/src/main/java/net/minecraft/commands/Commands.java
+++ b/src/main/java/net/minecraft/commands/Commands.java
+@@ -139,6 +139,7 @@ public class Commands {
+     public static final int LEVEL_ADMINS = 3;
+     public static final int LEVEL_OWNERS = 4;
+     private final com.mojang.brigadier.CommandDispatcher<CommandSourceStack> dispatcher = new com.mojang.brigadier.CommandDispatcher();
+    public final java.util.List<CommandNode<CommandSourceStack>> vanillaCommandNodes = new java.util.ArrayList<>(); // Paper
+ 
+     public Commands(Commands.CommandSelection environment, CommandBuildContext commandRegistryAccess) {
+         this(); // CraftBukkit
+@@ -234,6 +235,7 @@ public class Commands {
+         if (environment.includeIntegrated) {
+             PublishCommand.register(this.dispatcher);
+         }
+        this.vanillaCommandNodes.addAll(this.dispatcher.getRoot().getChildren()); // Paper
+ 
+         // CraftBukkit start
+     }
+@@ -325,7 +327,16 @@ public class Commands {
+                 b1 = 0;
+                 return b1;
+             } catch (CommandSyntaxException commandsyntaxexception) {
+-                commandlistenerwrapper.sendFailure(ComponentUtils.fromMessage(commandsyntaxexception.getRawMessage()));
+                // Paper start
+                final net.kyori.adventure.text.TextComponent.Builder builder = net.kyori.adventure.text.Component.text();
+                if ((parseresults.getContext().getNodes().isEmpty() || !this.vanillaCommandNodes.contains(parseresults.getContext().getNodes().get(0).getNode()))) {
+                    if (!org.spigotmc.SpigotConfig.unknownCommandMessage.isEmpty()) {
+                        builder.append(net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(org.spigotmc.SpigotConfig.unknownCommandMessage));
+                    }
+                } else {
+                // commandlistenerwrapper.sendFailure(ComponentUtils.fromMessage(commandsyntaxexception.getRawMessage()));
+                builder.color(net.kyori.adventure.text.format.NamedTextColor.RED).append(io.papermc.paper.brigadier.PaperBrigadier.componentFromMessage(commandsyntaxexception.getRawMessage()));
+                // Paper end
+                 if (commandsyntaxexception.getInput() != null && commandsyntaxexception.getCursor() >= 0) {
+                     int j = Math.min(commandsyntaxexception.getInput().length(), commandsyntaxexception.getCursor());
+                     MutableComponent ichatmutablecomponent = Component.empty().withStyle(ChatFormatting.GRAY).withStyle((chatmodifier) -> {
+@@ -344,7 +355,18 @@ public class Commands {
+                     }
+ 
+                     ichatmutablecomponent.append((Component) Component.translatable("command.context.here").withStyle(ChatFormatting.RED, ChatFormatting.ITALIC));
+-                    commandlistenerwrapper.sendFailure(ichatmutablecomponent);
+                // Paper start
+                    // commandlistenerwrapper.sendFailure(ichatmutablecomponent);
+                    builder
+                        .append(net.kyori.adventure.text.Component.newline())
+                        .append(io.papermc.paper.adventure.PaperAdventure.asAdventure(ichatmutablecomponent));
+                }
+                }
+                org.bukkit.event.command.UnknownCommandEvent event = new org.bukkit.event.command.UnknownCommandEvent(commandlistenerwrapper.getBukkitSender(), s, org.spigotmc.SpigotConfig.unknownCommandMessage.isEmpty() ? null : builder.build());
+                org.bukkit.Bukkit.getServer().getPluginManager().callEvent(event);
+                if (event.message() != null) {
+                    commandlistenerwrapper.sendFailure(io.papermc.paper.adventure.PaperAdventure.asVanilla(event.message()), false);
+                // Paper end
+                 }
+ 
+                 b1 = 0;
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 15d881193f40dda74996932854283e4551742185..c37793f660c0b2a28e4478dfee0582a61a8faf3c 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -531,6 +531,7 @@ public final class CraftServer implements Server {
+                     }
+                     node = clone;
+                 }
+                dispatcher.vanillaCommandNodes.add(node); // Paper
+ 
+                 dispatcher.getDispatcher().getRoot().addChild(node);
+             } else {
+@@ -898,7 +899,13 @@ public final class CraftServer implements Server {
+ 
+         // Spigot start
+         if (!org.spigotmc.SpigotConfig.unknownCommandMessage.isEmpty()) {
+-            sender.sendMessage(org.spigotmc.SpigotConfig.unknownCommandMessage);
+            // Paper start
+            org.bukkit.event.command.UnknownCommandEvent event = new org.bukkit.event.command.UnknownCommandEvent(sender, commandLine, net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(org.spigotmc.SpigotConfig.unknownCommandMessage));
+            Bukkit.getServer().getPluginManager().callEvent(event);
+            if (event.message() != null) {
+                sender.sendMessage(event.message());
+            }
+            // Paper end
+         }
+         // Spigot end
+ 
--- a/patches/server/0140-Basic-PlayerProfile-API.patch
+++ b/patches/server/0140-Basic-PlayerProfile-API.patch
@ -0,0 +1,770 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 15 Jan 2018 22:11:48 -0500
+Subject: [PATCH] Basic PlayerProfile API
+
+Establishes base extension of profile systems for future edits too
+
+== AT ==
+public org.bukkit.craftbukkit.profile.CraftProfileProperty
+public org.bukkit.craftbukkit.profile.CraftPlayerTextures
+public org.bukkit.craftbukkit.profile.CraftPlayerTextures copyFrom(Lorg/bukkit/profile/PlayerTextures;)V
+public org.bukkit.craftbukkit.profile.CraftPlayerTextures rebuildPropertyIfDirty()V
+public org.bukkit.craftbukkit.profile.CraftPlayerProfile toString(Lcom/mojang/authlib/properties/PropertyMap;)Ljava/lang/String;
+# needed to maintain visibility with overriden methods
+public org.bukkit.craftbukkit.profile.CraftPlayerProfile getProperty(Ljava/lang/String;)Lcom/mojang/authlib/properties/Property;
+public org.bukkit.craftbukkit.profile.CraftPlayerProfile setProperty(Ljava/lang/String;Lcom/mojang/authlib/properties/Property;)V
+
+diff --git a/src/main/java/com/destroystokyo/paper/profile/CraftPlayerProfile.java b/src/main/java/com/destroystokyo/paper/profile/CraftPlayerProfile.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..3ff790cec1ad89caec4be64421dd7d51652be598
+--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/profile/CraftPlayerProfile.java
+@@ -0,0 +1,399 @@
+package com.destroystokyo.paper.profile;
+
+import io.papermc.paper.configuration.GlobalConfiguration;
+import com.google.common.base.Charsets;
+import com.google.common.collect.Iterables;
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import com.mojang.authlib.properties.PropertyMap;
+import net.minecraft.Util;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.players.GameProfileCache;
+import org.apache.commons.lang3.Validate;
+import org.bukkit.configuration.serialization.SerializableAs;
+import org.bukkit.craftbukkit.configuration.ConfigSerializationUtil;
+import org.bukkit.craftbukkit.entity.CraftPlayer;
+import org.bukkit.craftbukkit.profile.CraftPlayerTextures;
+import org.bukkit.craftbukkit.profile.CraftProfileProperty;
+import org.bukkit.profile.PlayerTextures;
+import org.jetbrains.annotations.NotNull;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+
+@SerializableAs("PlayerProfile")
+public class CraftPlayerProfile implements PlayerProfile, SharedPlayerProfile {
+
+    private GameProfile profile;
+    private final PropertySet properties = new PropertySet();
+
+    public CraftPlayerProfile(CraftPlayer player) {
+        this.profile = player.getHandle().getGameProfile();
+    }
+
+    public CraftPlayerProfile(UUID id, String name) {
+        this.profile = new GameProfile(id, name);
+    }
+
+    public CraftPlayerProfile(GameProfile profile) {
+        Validate.notNull(profile, "GameProfile cannot be null!");
+        this.profile = profile;
+    }
+
+    @Override
+    public boolean hasProperty(String property) {
+        return profile.getProperties().containsKey(property);
+    }
+
+    @Override
+    public void setProperty(ProfileProperty property) {
+        String name = property.getName();
+        PropertyMap properties = profile.getProperties();
+        properties.removeAll(name);
+        properties.put(name, new Property(name, property.getValue(), property.getSignature()));
+    }
+
+    @Override
+    public CraftPlayerTextures getTextures() {
+        return new CraftPlayerTextures(this);
+    }
+
+    @Override
+    public void setTextures(@Nullable PlayerTextures textures) {
+        if (textures == null) {
+            this.removeProperty("textures");
+        } else {
+            CraftPlayerTextures craftPlayerTextures = new CraftPlayerTextures(this);
+            craftPlayerTextures.copyFrom(textures);
+            craftPlayerTextures.rebuildPropertyIfDirty();
+        }
+    }
+
+    public GameProfile getGameProfile() {
+        return profile;
+    }
+
+    @Nullable
+    @Override
+    public UUID getId() {
+        return profile.getId();
+    }
+
+    @Override
+    @Deprecated(forRemoval = true)
+    public UUID setId(@Nullable UUID uuid) {
+        GameProfile prev = this.profile;
+        this.profile = new GameProfile(uuid, prev.getName());
+        copyProfileProperties(prev, this.profile);
+        return prev.getId();
+    }
+
+    @Override
+    public UUID getUniqueId() {
+        return getId();
+    }
+
+    @Nullable
+    @Override
+    public String getName() {
+        return profile.getName();
+    }
+
+    @Override
+    @Deprecated(forRemoval = true)
+    public String setName(@Nullable String name) {
+        GameProfile prev = this.profile;
+        this.profile = new GameProfile(prev.getId(), name);
+        copyProfileProperties(prev, this.profile);
+        return prev.getName();
+    }
+
+    @Nonnull
+    @Override
+    public Set<ProfileProperty> getProperties() {
+        return properties;
+    }
+
+    @Override
+    public void setProperties(Collection<ProfileProperty> properties) {
+        properties.forEach(this::setProperty);
+    }
+
+    @Override
+    public void clearProperties() {
+        profile.getProperties().clear();
+    }
+
+    @Override
+    public boolean removeProperty(String property) {
+        return !profile.getProperties().removeAll(property).isEmpty();
+    }
+
+    @Nullable
+    @Override
+    public Property getProperty(String property) {
+        return Iterables.getFirst(this.profile.getProperties().get(property), null);
+    }
+
+    @Nullable
+    @Override
+    public void setProperty(@NotNull String propertyName, @Nullable Property property) {
+        PropertyMap properties = profile.getProperties();
+        properties.removeAll(propertyName);
+        if (property != null) {
+            properties.put(propertyName, property);
+        }
+    }
+
+    @Override
+    public @NotNull GameProfile buildGameProfile() {
+        GameProfile profile = new GameProfile(this.profile.getId(), this.profile.getName());
+        profile.getProperties().putAll(this.profile.getProperties());
+        return profile;
+    }
+
+    @Override
+    public CraftPlayerProfile clone() {
+        CraftPlayerProfile clone = new CraftPlayerProfile(this.getId(), this.getName());
+        clone.setProperties(getProperties());
+        return clone;
+    }
+
+    @Override
+    public boolean isComplete() {
+        return profile.isComplete();
+    }
+
+    @Override
+    public @NotNull CompletableFuture<PlayerProfile> update() {
+        return CompletableFuture.supplyAsync(() -> {
+            final CraftPlayerProfile clone = clone();
+            clone.complete(true);
+            return clone;
+        }, Util.PROFILE_EXECUTOR);
+    }
+
+    @Override
+    public boolean completeFromCache() {
+        return completeFromCache(false, GlobalConfiguration.get().proxies.isProxyOnlineMode());
+    }
+
+    public boolean completeFromCache(boolean onlineMode) {
+        return completeFromCache(false, onlineMode);
+    }
+
+    public boolean completeFromCache(boolean lookupUUID, boolean onlineMode) {
+        MinecraftServer server = MinecraftServer.getServer();
+        String name = profile.getName();
+        GameProfileCache userCache = server.getProfileCache();
+        if (profile.getId() == null) {
+            final GameProfile profile;
+            if (onlineMode) {
+                profile = lookupUUID ? userCache.get(name).orElse(null) : userCache.getProfileIfCached(name);
+            } else {
+                // Make an OfflinePlayer using an offline mode UUID since the name has no profile
+                profile = new GameProfile(UUID.nameUUIDFromBytes(("OfflinePlayer:" + name).getBytes(Charsets.UTF_8)), name);
+            }
+            if (profile != null) {
+                // if old has it, assume its newer, so overwrite, else use cached if it was set and ours wasn't
+                copyProfileProperties(this.profile, profile);
+                this.profile = profile;
+            }
+        }
+
+        if ((profile.getName() == null || !hasTextures()) && profile.getId() != null) {
+            Optional<GameProfile> optProfile = userCache.get(this.profile.getId());
+            if (optProfile.isPresent()) {
+                GameProfile profile = optProfile.get();
+                if (this.profile.getName() == null) {
+                    // if old has it, assume its newer, so overwrite, else use cached if it was set and ours wasn't
+                    copyProfileProperties(this.profile, profile);
+                    this.profile = profile;
+                } else {
+                    copyProfileProperties(profile, this.profile);
+                }
+            }
+        }
+        return this.profile.isComplete();
+    }
+
+    public boolean complete(boolean textures) {
+        return complete(textures, GlobalConfiguration.get().proxies.isProxyOnlineMode());
+    }
+    public boolean complete(boolean textures, boolean onlineMode) {
+        MinecraftServer server = MinecraftServer.getServer();
+        boolean isCompleteFromCache = this.completeFromCache(true, onlineMode);
+        if (onlineMode && (!isCompleteFromCache || textures && !hasTextures())) {
+            GameProfile result = server.getSessionService().fillProfileProperties(profile, true);
+            if (result != null) {
+                copyProfileProperties(result, this.profile, true);
+            }
+            if (this.profile.isComplete()) {
+                server.getProfileCache().add(this.profile);
+            }
+        }
+        return profile.isComplete() && (!onlineMode || !textures || hasTextures());
+    }
+
+    private static void copyProfileProperties(GameProfile source, GameProfile target) {
+        copyProfileProperties(source, target, false);
+    }
+
+    private static void copyProfileProperties(GameProfile source, GameProfile target, boolean clearTarget) {
+        PropertyMap sourceProperties = source.getProperties();
+        PropertyMap targetProperties = target.getProperties();
+        if (clearTarget) targetProperties.clear();
+        if (sourceProperties.isEmpty()) {
+            return;
+        }
+
+        for (Property property : sourceProperties.values()) {
+            targetProperties.removeAll(property.getName());
+            targetProperties.put(property.getName(), property);
+        }
+    }
+
+    private static ProfileProperty toBukkit(Property property) {
+        return new ProfileProperty(property.getName(), property.getValue(), property.getSignature());
+    }
+
+    public static PlayerProfile asBukkitCopy(GameProfile gameProfile) {
+        CraftPlayerProfile profile = new CraftPlayerProfile(gameProfile.getId(), gameProfile.getName());
+        copyProfileProperties(gameProfile, profile.profile);
+        return profile;
+    }
+
+    public static PlayerProfile asBukkitMirror(GameProfile profile) {
+        return new CraftPlayerProfile(profile);
+    }
+
+    public static Property asAuthlib(ProfileProperty property) {
+        return new Property(property.getName(), property.getValue(), property.getSignature());
+    }
+
+    public static GameProfile asAuthlibCopy(PlayerProfile profile) {
+        CraftPlayerProfile craft = ((CraftPlayerProfile) profile);
+        return asAuthlib(craft.clone());
+    }
+
+    public static GameProfile asAuthlib(PlayerProfile profile) {
+        CraftPlayerProfile craft = ((CraftPlayerProfile) profile);
+        return craft.getGameProfile();
+    }
+
+    @Override
+    public @NotNull Map<String, Object> serialize() {
+        Map<String, Object> map = new LinkedHashMap<>();
+        if (this.getId() != null) {
+            map.put("uniqueId", this.getId().toString());
+        }
+        if (this.getName() != null) {
+            map.put("name", getName());
+        }
+        if (!this.properties.isEmpty()) {
+            List<Object> propertiesData = new ArrayList<>();
+            for (ProfileProperty property : properties) {
+                propertiesData.add(CraftProfileProperty.serialize(new Property(property.getName(), property.getValue(), property.getSignature())));
+            }
+            map.put("properties", propertiesData);
+        }
+        return map;
+    }
+
+    public static CraftPlayerProfile deserialize(Map<String, Object> map) {
+        UUID uniqueId = ConfigSerializationUtil.getUuid(map, "uniqueId", true);
+        String name = ConfigSerializationUtil.getString(map, "name", true);
+
+        // This also validates the deserialized unique id and name (ensures that not both are null):
+        CraftPlayerProfile profile = new CraftPlayerProfile(uniqueId, name);
+
+        if (map.containsKey("properties")) {
+            for (Object propertyData : (List<?>) map.get("properties")) {
+                if (!(propertyData instanceof Map)) {
+                    throw new IllegalArgumentException("Property data (" + propertyData + ") is not a valid Map");
+                }
+                Property property = CraftProfileProperty.deserialize((Map<?, ?>) propertyData);
+                profile.profile.getProperties().put(property.getName(), property);
+            }
+        }
+
+        return profile;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (!(obj instanceof CraftPlayerProfile otherProfile)) return false;
+        return Objects.equals(this.profile, otherProfile.profile);
+    }
+
+    @Override
+    public String toString() {
+        return "CraftPlayerProfile [uniqueId=" + getId() +
+            ", name=" + getName() +
+            ", properties=" + org.bukkit.craftbukkit.profile.CraftPlayerProfile.toString(this.profile.getProperties()) +
+            "]";
+    }
+
+    @Override
+    public int hashCode() {
+        return this.profile.hashCode();
+    }
+
+    private class PropertySet extends AbstractSet<ProfileProperty> {
+
+        @Override
+        @Nonnull
+        public Iterator<ProfileProperty> iterator() {
+            return new ProfilePropertyIterator(profile.getProperties().values().iterator());
+        }
+
+        @Override
+        public int size() {
+            return profile.getProperties().size();
+        }
+
+        @Override
+        public boolean add(ProfileProperty property) {
+            setProperty(property);
+            return true;
+        }
+
+        @Override
+        public boolean addAll(Collection<? extends ProfileProperty> c) {
+            //noinspection unchecked
+            setProperties((Collection<ProfileProperty>) c);
+            return true;
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            return o instanceof ProfileProperty && profile.getProperties().containsKey(((ProfileProperty) o).getName());
+        }
+
+        private class ProfilePropertyIterator implements Iterator<ProfileProperty> {
+            private final Iterator<Property> iterator;
+
+            ProfilePropertyIterator(Iterator<Property> iterator) {
+                this.iterator = iterator;
+            }
+
+            @Override
+            public boolean hasNext() {
+                return iterator.hasNext();
+            }
+
+            @Override
+            public ProfileProperty next() {
+                return toBukkit(iterator.next());
+            }
+
+            @Override
+            public void remove() {
+                iterator.remove();
+            }
+        }
+    }
+}
+diff --git a/src/main/java/com/destroystokyo/paper/profile/PaperAuthenticationService.java b/src/main/java/com/destroystokyo/paper/profile/PaperAuthenticationService.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..1459a1f99fe614d072a087cda18788cf13102645
+--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/profile/PaperAuthenticationService.java
+@@ -0,0 +1,31 @@
+package com.destroystokyo.paper.profile;
+
+import com.mojang.authlib.*;
+import com.mojang.authlib.minecraft.MinecraftSessionService;
+import com.mojang.authlib.yggdrasil.YggdrasilAuthenticationService;
+import com.mojang.authlib.yggdrasil.YggdrasilEnvironment;
+
+import java.net.Proxy;
+
+public class PaperAuthenticationService extends YggdrasilAuthenticationService {
+    private final Environment environment;
+    public PaperAuthenticationService(Proxy proxy) {
+        super(proxy);
+        this.environment = EnvironmentParser.getEnvironmentFromProperties().orElse(YggdrasilEnvironment.PROD.getEnvironment());
+    }
+
+    @Override
+    public UserAuthentication createUserAuthentication(Agent agent) {
+        return new PaperUserAuthentication(this, agent);
+    }
+
+    @Override
+    public MinecraftSessionService createMinecraftSessionService() {
+        return new PaperMinecraftSessionService(this, this.environment);
+    }
+
+    @Override
+    public GameProfileRepository createProfileRepository() {
+        return new PaperGameProfileRepository(this, this.environment);
+    }
+}
+diff --git a/src/main/java/com/destroystokyo/paper/profile/PaperGameProfileRepository.java b/src/main/java/com/destroystokyo/paper/profile/PaperGameProfileRepository.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..582c169c85ac66f1f9430f79042e4655f776c157
+--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/profile/PaperGameProfileRepository.java
+@@ -0,0 +1,18 @@
+package com.destroystokyo.paper.profile;
+
+import com.mojang.authlib.Agent;
+import com.mojang.authlib.Environment;
+import com.mojang.authlib.ProfileLookupCallback;
+import com.mojang.authlib.yggdrasil.YggdrasilAuthenticationService;
+import com.mojang.authlib.yggdrasil.YggdrasilGameProfileRepository;
+
+public class PaperGameProfileRepository extends YggdrasilGameProfileRepository {
+    public PaperGameProfileRepository(YggdrasilAuthenticationService authenticationService, Environment environment) {
+        super(authenticationService, environment);
+    }
+
+    @Override
+    public void findProfilesByNames(String[] names, Agent agent, ProfileLookupCallback callback) {
+        super.findProfilesByNames(names, agent, callback);
+    }
+}
+diff --git a/src/main/java/com/destroystokyo/paper/profile/PaperMinecraftSessionService.java b/src/main/java/com/destroystokyo/paper/profile/PaperMinecraftSessionService.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..93d73c27340645c7502acafdc0b2cfbc1a759dd8
+--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/profile/PaperMinecraftSessionService.java
+@@ -0,0 +1,30 @@
+package com.destroystokyo.paper.profile;
+
+import com.mojang.authlib.Environment;
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.minecraft.MinecraftProfileTexture;
+import com.mojang.authlib.yggdrasil.YggdrasilAuthenticationService;
+import com.mojang.authlib.yggdrasil.YggdrasilMinecraftSessionService;
+
+import java.util.Map;
+
+public class PaperMinecraftSessionService extends YggdrasilMinecraftSessionService {
+    protected PaperMinecraftSessionService(YggdrasilAuthenticationService authenticationService, Environment environment) {
+        super(authenticationService, environment);
+    }
+
+    @Override
+    public Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> getTextures(GameProfile profile, boolean requireSecure) {
+        return super.getTextures(profile, requireSecure);
+    }
+
+    @Override
+    public GameProfile fillProfileProperties(GameProfile profile, boolean requireSecure) {
+        return super.fillProfileProperties(profile, requireSecure);
+    }
+
+    @Override
+    protected GameProfile fillGameProfile(GameProfile profile, boolean requireSecure) {
+        return super.fillGameProfile(profile, requireSecure);
+    }
+}
+diff --git a/src/main/java/com/destroystokyo/paper/profile/PaperUserAuthentication.java b/src/main/java/com/destroystokyo/paper/profile/PaperUserAuthentication.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..3cdd06d3af7ff94f1fe1a11b9a9275e17c695a38
+--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/profile/PaperUserAuthentication.java
+@@ -0,0 +1,12 @@
+package com.destroystokyo.paper.profile;
+
+import com.mojang.authlib.Agent;
+import com.mojang.authlib.yggdrasil.YggdrasilAuthenticationService;
+import com.mojang.authlib.yggdrasil.YggdrasilUserAuthentication;
+import java.util.UUID;
+
+public class PaperUserAuthentication extends YggdrasilUserAuthentication {
+    public PaperUserAuthentication(YggdrasilAuthenticationService authenticationService, Agent agent) {
+        super(authenticationService, UUID.randomUUID().toString(), agent);
+    }
+}
+diff --git a/src/main/java/com/destroystokyo/paper/profile/SharedPlayerProfile.java b/src/main/java/com/destroystokyo/paper/profile/SharedPlayerProfile.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..7ac27392a8647ef7d0dc78efe78703e993885017
+--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/profile/SharedPlayerProfile.java
+@@ -0,0 +1,23 @@
+package com.destroystokyo.paper.profile;
+
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.UUID;
+
+public interface SharedPlayerProfile {
+
+    @Nullable UUID getUniqueId();
+
+    @Nullable String getName();
+
+    boolean removeProperty(@NotNull String property);
+
+    @Nullable Property getProperty(@NotNull String propertyName);
+
+    @Nullable void setProperty(@NotNull String propertyName, @Nullable Property property);
+
+    @NotNull GameProfile buildGameProfile();
+}
+diff --git a/src/main/java/io/papermc/paper/util/MCUtil.java b/src/main/java/io/papermc/paper/util/MCUtil.java
+index 9572294a50110f2452090da1f32e0a73edc3db05..ff8876b7e7cc2172a2cb5e12d6836b9875cc9aa1 100644
+--- a/src/main/java/io/papermc/paper/util/MCUtil.java
+++ b/src/main/java/io/papermc/paper/util/MCUtil.java
+@@ -1,5 +1,7 @@
+ package io.papermc.paper.util;
+ 
+import com.destroystokyo.paper.profile.CraftPlayerProfile;
+import com.destroystokyo.paper.profile.PlayerProfile;
+ import com.google.common.util.concurrent.ThreadFactoryBuilder;
+ import io.papermc.paper.math.BlockPosition;
+ import io.papermc.paper.math.FinePosition;
+@@ -17,6 +19,7 @@ import net.minecraft.world.level.ClipContext;
+ import net.minecraft.world.level.Level;
+ import net.minecraft.world.phys.Vec3;
+ import org.apache.commons.lang.exception.ExceptionUtils;
+import com.mojang.authlib.GameProfile;
+ import org.bukkit.Location;
+ import org.bukkit.block.BlockFace;
+ import org.bukkit.craftbukkit.CraftWorld;
+@@ -362,6 +365,10 @@ public final class MCUtil {
+         return run.get();
+     }
+ 
+    public static PlayerProfile toBukkit(GameProfile profile) {
+        return CraftPlayerProfile.asBukkitMirror(profile);
+    }
+
+     /**
+      * Calculates distance between 2 entities
+      * @param e1
+diff --git a/src/main/java/net/minecraft/server/Main.java b/src/main/java/net/minecraft/server/Main.java
+index ae0b713870976d4b1e469a90cef9b2e282dbcaab..6c3e0540dce5f810a7822cefe59228ef77528132 100644
+--- a/src/main/java/net/minecraft/server/Main.java
+++ b/src/main/java/net/minecraft/server/Main.java
+@@ -178,7 +178,7 @@ public class Main {
+             }
+ 
+             File file = (File) optionset.valueOf("universe"); // CraftBukkit
+-            Services services = Services.create(new YggdrasilAuthenticationService(Proxy.NO_PROXY), file, optionset); // Paper
+            Services services = Services.create(new com.destroystokyo.paper.profile.PaperAuthenticationService(Proxy.NO_PROXY), file, optionset); // Paper
+             // CraftBukkit start
+             String s = (String) Optional.ofNullable((String) optionset.valueOf("world")).orElse(dedicatedserversettings.getProperties().levelName);
+             LevelStorageSource convertable = LevelStorageSource.createDefault(file.toPath());
+diff --git a/src/main/java/net/minecraft/server/players/GameProfileCache.java b/src/main/java/net/minecraft/server/players/GameProfileCache.java
+index c70cd016e1978931d115cfca94664897f0158196..eac9658fa4cab7a651e10e4e18c679e040e4aed0 100644
+--- a/src/main/java/net/minecraft/server/players/GameProfileCache.java
+++ b/src/main/java/net/minecraft/server/players/GameProfileCache.java
+@@ -124,6 +124,17 @@ public class GameProfileCache {
+         return this.operationCount.incrementAndGet();
+     }
+ 
+    // Paper start
+    public @Nullable GameProfile getProfileIfCached(String name) {
+        GameProfileCache.GameProfileInfo entry = this.profilesByName.get(name.toLowerCase(Locale.ROOT));
+        if (entry == null) {
+            return null;
+        }
+        entry.setLastAccess(this.getNextOperation());
+        return entry.getProfile();
+    }
+    // Paper end
+
+     public Optional<GameProfile> get(String name) {
+         String s1 = name.toLowerCase(Locale.ROOT);
+         GameProfileCache.GameProfileInfo usercache_usercacheentry = (GameProfileCache.GameProfileInfo) this.profilesByName.get(s1);
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index c37793f660c0b2a28e4478dfee0582a61a8faf3c..35dc09187b0bed916c9a10f3cf3a900052926a72 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -264,6 +264,9 @@ import org.yaml.snakeyaml.error.MarkedYAMLException;
+ 
+ import net.md_5.bungee.api.chat.BaseComponent; // Spigot
+ 
+import javax.annotation.Nullable; // Paper
+import javax.annotation.Nonnull; // Paper
+
+ public final class CraftServer implements Server {
+     private final String serverName = "Paper"; // Paper
+     private final String serverVersion;
+@@ -306,6 +309,7 @@ public final class CraftServer implements Server {
+     static {
+         ConfigurationSerialization.registerClass(CraftOfflinePlayer.class);
+         ConfigurationSerialization.registerClass(CraftPlayerProfile.class);
+        ConfigurationSerialization.registerClass(com.destroystokyo.paper.profile.CraftPlayerProfile.class); // Paper
+         CraftItemFactory.instance();
+     }
+ 
+@@ -2682,5 +2686,37 @@ public final class CraftServer implements Server {
+     public boolean suggestPlayerNamesWhenNullTabCompletions() {
+         return io.papermc.paper.configuration.GlobalConfiguration.get().commands.suggestPlayerNamesWhenNullTabCompletions;
+     }
+
+    @Override
+    public com.destroystokyo.paper.profile.PlayerProfile createProfile(@Nonnull UUID uuid) {
+        return createProfile(uuid, null);
+    }
+
+    @Override
+    public com.destroystokyo.paper.profile.PlayerProfile createProfile(@Nonnull String name) {
+        return createProfile(null, name);
+    }
+
+    @Override
+    public com.destroystokyo.paper.profile.PlayerProfile createProfile(@Nullable UUID uuid, @Nullable String name) {
+        Player player = uuid != null ? Bukkit.getPlayer(uuid) : (name != null ? Bukkit.getPlayerExact(name) : null);
+        if (player != null) return new com.destroystokyo.paper.profile.CraftPlayerProfile((CraftPlayer) player);
+
+        return new com.destroystokyo.paper.profile.CraftPlayerProfile(uuid, name);
+    }
+
+    @Override
+    public com.destroystokyo.paper.profile.PlayerProfile createProfileExact(@Nullable UUID uuid, @Nullable String name) {
+        Player player = uuid != null ? Bukkit.getPlayer(uuid) : (name != null ? Bukkit.getPlayerExact(name) : null);
+        if (player == null) return new com.destroystokyo.paper.profile.CraftPlayerProfile(uuid, name);
+
+        if (java.util.Objects.equals(uuid, player.getUniqueId()) && java.util.Objects.equals(name, player.getName())) {
+            return new com.destroystokyo.paper.profile.CraftPlayerProfile((CraftPlayer) player);
+        }
+
+        final com.mojang.authlib.GameProfile profile = new com.mojang.authlib.GameProfile(uuid, name);
+        profile.getProperties().putAll(((CraftPlayer)player).getHandle().getGameProfile().getProperties());
+        return new com.destroystokyo.paper.profile.CraftPlayerProfile(profile);
+    }
+     // Paper end
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
+index ac05e268c9f00bca9f8ac19650937eede711810b..8d2997efaacbe37d9007861ac871fd2719c2d663 100644
+--- a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
+++ b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
+@@ -31,7 +31,7 @@ import org.bukkit.profile.PlayerProfile;
+ import org.bukkit.profile.PlayerTextures;
+ 
+ @SerializableAs("PlayerProfile")
+-public final class CraftPlayerProfile implements PlayerProfile {
+public final class CraftPlayerProfile implements PlayerProfile, com.destroystokyo.paper.profile.SharedPlayerProfile { // Paper
+ 
+     @Nonnull
+     public static GameProfile validateSkullProfile(@Nonnull GameProfile gameProfile) {
+@@ -96,8 +96,10 @@ public final class CraftPlayerProfile implements PlayerProfile {
+         }
+     }
+ 
+-    void removeProperty(String propertyName) {
+-        this.properties.removeAll(propertyName);
+    // Paper start - change return value for shared interface
+    public boolean removeProperty(String propertyName) {
+        return !this.properties.removeAll(propertyName).isEmpty();
+        // Paper end
+     }
+ 
+     void rebuildDirtyProperties() {
+@@ -245,6 +247,7 @@ public final class CraftPlayerProfile implements PlayerProfile {
+ 
+     @Override
+     public Map<String, Object> serialize() {
+        // Paper - diff on change
+         Map<String, Object> map = new LinkedHashMap<>();
+         if (this.uniqueId != null) {
+             map.put("uniqueId", this.uniqueId.toString());
+@@ -260,10 +263,12 @@ public final class CraftPlayerProfile implements PlayerProfile {
+             });
+             map.put("properties", propertiesData);
+         }
+        // Paper - diff on change
+         return map;
+     }
+ 
+     public static CraftPlayerProfile deserialize(Map<String, Object> map) {
+        // Paper - diff on change
+         UUID uniqueId = ConfigSerializationUtil.getUuid(map, "uniqueId", true);
+         String name = ConfigSerializationUtil.getString(map, "name", true);
+ 
+@@ -277,7 +282,7 @@ public final class CraftPlayerProfile implements PlayerProfile {
+                 profile.properties.put(property.name(), property);
+             }
+         }
+-
+        // Paper - diff on change
+         return profile;
+     }
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerTextures.java b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerTextures.java
+index 3d76d833e428d8760413bb2325a3680c7bcddb32..d734b1bc1ecea935e45893b88d7bf78f5082352e 100644
+--- a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerTextures.java
+++ b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerTextures.java
+@@ -48,7 +48,7 @@ public final class CraftPlayerTextures implements PlayerTextures {
+         }
+     }
+ 
+-    private final CraftPlayerProfile profile;
+    private final com.destroystokyo.paper.profile.SharedPlayerProfile profile; // Paper
+ 
+     // The textures data is loaded lazily:
+     private boolean loaded = false;
+@@ -67,7 +67,7 @@ public final class CraftPlayerTextures implements PlayerTextures {
+     // GameProfiles (even if these modifications are later reverted).
+     private boolean dirty = false;
+ 
+-    CraftPlayerTextures(@Nonnull CraftPlayerProfile profile) {
+    public CraftPlayerTextures(@Nonnull com.destroystokyo.paper.profile.SharedPlayerProfile profile) { // Paper
+         this.profile = profile;
+     }
+ 
--- a/patches/server/0141-Shoulder-Entities-Release-API.patch
+++ b/patches/server/0141-Shoulder-Entities-Release-API.patch
@ -0,0 +1,97 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sat, 17 Jun 2017 15:18:30 -0400
+Subject: [PATCH] Shoulder Entities Release API
+
+
+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 a2f6e3f381bf251d93a63aff9f9af307350ffc50..3d333332ae02951af087cd37cbe7f1ecf8b0c932 100644
+--- a/src/main/java/net/minecraft/world/entity/player/Player.java
+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
+@@ -2042,20 +2042,45 @@ public abstract class Player extends LivingEntity {
+ 
+     }
+ 
+    // Paper start
+    public Entity releaseLeftShoulderEntity() {
+        Entity entity = this.respawnEntityOnShoulder0(this.getShoulderEntityLeft());
+        if (entity != null) {
+            this.setShoulderEntityLeft(new CompoundTag());
+        }
+        return entity;
+    }
+
+    public Entity releaseRightShoulderEntity() {
+        Entity entity = this.respawnEntityOnShoulder0(this.getShoulderEntityRight());
+        if (entity != null) {
+            this.setShoulderEntityRight(new CompoundTag());
+        }
+        return entity;
+    }
+    // Paper - maintain old signature
+
+     private boolean respawnEntityOnShoulder(CompoundTag nbttagcompound) { // CraftBukkit void->boolean
+-        if (!this.level().isClientSide && !nbttagcompound.isEmpty()) {
+        return this.respawnEntityOnShoulder0(nbttagcompound) != null;
+    }
+
+    // Paper - return entity
+    private Entity respawnEntityOnShoulder0(CompoundTag nbttagcompound) { // CraftBukkit void->boolean
+        if (!this.level().isClientSide && nbttagcompound != null && !nbttagcompound.isEmpty()) {
+             return EntityType.create(nbttagcompound, this.level()).map((entity) -> { // CraftBukkit
+                 if (entity instanceof TamableAnimal) {
+                     ((TamableAnimal) entity).setOwnerUUID(this.uuid);
+                 }
+ 
+                 entity.setPos(this.getX(), this.getY() + 0.699999988079071D, this.getZ());
+-                return ((ServerLevel) this.level()).addWithUUID(entity, CreatureSpawnEvent.SpawnReason.SHOULDER_ENTITY); // CraftBukkit
+-            }).orElse(true); // CraftBukkit
+                boolean addedToWorld = ((ServerLevel) this.level()).addWithUUID(entity, CreatureSpawnEvent.SpawnReason.SHOULDER_ENTITY); // CraftBukkit
+                return addedToWorld ? entity : null;
+            }).orElse(null); // CraftBukkit // Paper - true -> null
+         }
+ 
+-        return true; // CraftBukkit
+        return null; // Paper - return null
+     }
+    // Paper end
+ 
+     @Override
+     public abstract boolean isSpectator();
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+index b9578f7d0f61d15bee1f99181bf932cdbb0e611c..c40b3b8ff02c0e21fab53f6749f9c72b7e3c48a1 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+@@ -516,6 +516,32 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
+         this.getHandle().getCooldowns().addCooldown(CraftMagicNumbers.getItem(material), ticks);
+     }
+ 
+    // Paper start
+    @Override
+    public org.bukkit.entity.Entity releaseLeftShoulderEntity() {
+        if (!getHandle().getShoulderEntityLeft().isEmpty()) {
+            Entity entity = getHandle().releaseLeftShoulderEntity();
+            if (entity != null) {
+                return entity.getBukkitEntity();
+            }
+        }
+
+        return null;
+    }
+
+    @Override
+    public org.bukkit.entity.Entity releaseRightShoulderEntity() {
+        if (!getHandle().getShoulderEntityRight().isEmpty()) {
+            Entity entity = getHandle().releaseRightShoulderEntity();
+            if (entity != null) {
+                return entity.getBukkitEntity();
+            }
+        }
+
+        return null;
+    }
+    // Paper end
+
+     @Override
+     public boolean discoverRecipe(NamespacedKey recipe) {
+         return this.discoverRecipes(Arrays.asList(recipe)) != 0;
--- a/patches/server/0142-Profile-Lookup-Events.patch
+++ b/patches/server/0142-Profile-Lookup-Events.patch
@ -0,0 +1,81 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sat, 17 Jun 2017 17:00:32 -0400
+Subject: [PATCH] Profile Lookup Events
+
+Adds a Pre Lookup Event and a Post Lookup Event so that plugins may prefill in profile data, and cache the responses from
+profiles that had to be looked up.
+
+diff --git a/src/main/java/com/destroystokyo/paper/profile/PaperGameProfileRepository.java b/src/main/java/com/destroystokyo/paper/profile/PaperGameProfileRepository.java
+index 582c169c85ac66f1f9430f79042e4655f776c157..08fdb681a68e8be6e4062af0630957ce3e524806 100644
+--- a/src/main/java/com/destroystokyo/paper/profile/PaperGameProfileRepository.java
+++ b/src/main/java/com/destroystokyo/paper/profile/PaperGameProfileRepository.java
+@@ -1,11 +1,16 @@
+ package com.destroystokyo.paper.profile;
+ 
+import com.destroystokyo.paper.event.profile.LookupProfileEvent;
+import com.destroystokyo.paper.event.profile.PreLookupProfileEvent;
+import com.google.common.collect.Sets;
+ import com.mojang.authlib.Agent;
+ import com.mojang.authlib.Environment;
+import com.mojang.authlib.GameProfile;
+ import com.mojang.authlib.ProfileLookupCallback;
+ import com.mojang.authlib.yggdrasil.YggdrasilAuthenticationService;
+ import com.mojang.authlib.yggdrasil.YggdrasilGameProfileRepository;
+ 
+import java.util.Set;
+ public class PaperGameProfileRepository extends YggdrasilGameProfileRepository {
+     public PaperGameProfileRepository(YggdrasilAuthenticationService authenticationService, Environment environment) {
+         super(authenticationService, environment);
+@@ -13,6 +18,50 @@ public class PaperGameProfileRepository extends YggdrasilGameProfileRepository {
+ 
+     @Override
+     public void findProfilesByNames(String[] names, Agent agent, ProfileLookupCallback callback) {
+-        super.findProfilesByNames(names, agent, callback);
+        Set<String> unfoundNames = Sets.newHashSet();
+        for (String name : names) {
+            PreLookupProfileEvent event = new PreLookupProfileEvent(name);
+            event.callEvent();
+            if (event.getUUID() != null) {
+                // Plugin provided UUI, we can skip network call.
+                GameProfile gameprofile = new GameProfile(event.getUUID(), name);
+                // We might even have properties!
+                Set<ProfileProperty> profileProperties = event.getProfileProperties();
+                if (!profileProperties.isEmpty()) {
+                    for (ProfileProperty property : profileProperties) {
+                        gameprofile.getProperties().put(property.getName(), CraftPlayerProfile.asAuthlib(property));
+                    }
+                }
+                callback.onProfileLookupSucceeded(gameprofile);
+            } else {
+                unfoundNames.add(name);
+            }
+        }
+
+        // Some things were not found.... Proceed to look up.
+        if (!unfoundNames.isEmpty()) {
+            String[] namesArr = unfoundNames.toArray(new String[unfoundNames.size()]);
+            super.findProfilesByNames(namesArr, agent, new PreProfileLookupCallback(callback));
+        }
+    }
+
+    private static class PreProfileLookupCallback implements ProfileLookupCallback {
+        private final ProfileLookupCallback callback;
+
+        PreProfileLookupCallback(ProfileLookupCallback callback) {
+            this.callback = callback;
+        }
+
+        @Override
+        public void onProfileLookupSucceeded(GameProfile gameProfile) {
+            PlayerProfile from = CraftPlayerProfile.asBukkitMirror(gameProfile);
+            new LookupProfileEvent(from).callEvent();
+            callback.onProfileLookupSucceeded(gameProfile);
+        }
+
+        @Override
+        public void onProfileLookupFailed(GameProfile gameProfile, Exception e) {
+            callback.onProfileLookupFailed(gameProfile, e);
+        }
+     }
+ }
--- a/patches/server/0143-Block-player-logins-during-server-shutdown.patch
+++ b/patches/server/0143-Block-player-logins-during-server-shutdown.patch
@ -0,0 +1,23 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach.brown@destroystokyo.com>
+Date: Sun, 2 Jul 2017 21:35:56 -0500
+Subject: [PATCH] Block player logins during server shutdown
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+index 490af173c265d03904396e9336c95520fcd16c48..b52ed512000328c1ac006fac18d997157faf4cb6 100644
+--- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+@@ -72,6 +72,12 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
+ 
+     @Override
+     public void tick() {
+        // Paper start - Do not allow logins while the server is shutting down
+        if (!MinecraftServer.getServer().isRunning()) {
+            this.disconnect(org.bukkit.craftbukkit.util.CraftChatMessage.fromString(org.spigotmc.SpigotConfig.restartMessage)[0]);
+            return;
+        }
+        // Paper end
+         if (this.state == ServerLoginPacketListenerImpl.State.VERIFYING) {
+             this.verifyLoginAndFinishConnectionSetup((GameProfile) Objects.requireNonNull(this.authenticatedProfile));
+         }
--- a/patches/server/0144-Entity-fromMobSpawner.patch
+++ b/patches/server/0144-Entity-fromMobSpawner.patch
@ -0,0 +1,65 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Sun, 18 Jun 2017 18:17:05 -0500
+Subject: [PATCH] Entity#fromMobSpawner()
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index b4c91cb985d3772c5b105b8d2267b51d7483e005..3fc715e7ceb35e2309ba3ffeb19ae58cfd25fde6 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -388,6 +388,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+     // Spigot end
+     // Paper start
+     protected int numCollisions = 0; // Paper
+    public boolean spawnedViaMobSpawner; // Paper - Yes this name is similar to above, upstream took the better one
+     @javax.annotation.Nullable
+     private org.bukkit.util.Vector origin;
+     @javax.annotation.Nullable
+@@ -2125,6 +2126,10 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+                 }
+                 nbt.put("Paper.Origin", this.newDoubleList(origin.getX(), origin.getY(), origin.getZ()));
+             }
+            // Save entity's from mob spawner status
+            if (spawnedViaMobSpawner) {
+                nbt.putBoolean("Paper.FromMobSpawner", true);
+            }
+             // Paper end
+             return nbt;
+         } catch (Throwable throwable) {
+@@ -2265,6 +2270,8 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+                 this.originWorld = originWorld;
+                 origin = new org.bukkit.util.Vector(originTag.getDouble(0), originTag.getDouble(1), originTag.getDouble(2));
+             }
+
+            spawnedViaMobSpawner = nbt.getBoolean("Paper.FromMobSpawner"); // Restore entity's from mob spawner status
+             // 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 7ae0465091db8e8061737bf93884afa3db49feeb..5d6403fa27521860a69a707dc4358b013adfafd7 100644
+--- a/src/main/java/net/minecraft/world/level/BaseSpawner.java
+++ b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+@@ -165,6 +165,7 @@ public abstract class BaseSpawner {
+                             // Spigot End
+                         }
+ 
+                        entity.spawnedViaMobSpawner = true; // Paper
+                         // CraftBukkit start
+                         if (org.bukkit.craftbukkit.event.CraftEventFactory.callSpawnerSpawnEvent(entity, pos).isCancelled()) {
+                             continue;
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index 5767eefb09d9e0e3a3d5a006242220b844d28055..a6009f9075035e34150ff692d38cac47930363d1 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -1301,5 +1301,10 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+         //noinspection ConstantConditions
+         return originVector.toLocation(world);
+     }
+
+    @Override
+    public boolean fromMobSpawner() {
+        return getHandle().spawnedViaMobSpawner;
+    }
+     // Paper end
+ }
--- a/patches/server/0145-Improve-the-Saddle-API-for-Horses.patch
+++ b/patches/server/0145-Improve-the-Saddle-API-for-Horses.patch
@ -0,0 +1,59 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sat, 10 Dec 2016 16:24:06 -0500
+Subject: [PATCH] Improve the Saddle API for Horses
+
+Not all horses with Saddles have armor. This lets us break up the horses with saddles
+and access their saddle state separately from an interface shared with Armor.
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftAbstractHorse.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftAbstractHorse.java
+index 349bc3becee3f878fe8f6bc589cc9fbecf7dd17a..4bb5e953ec0ad6a2e068cb26237bc59e68c13699 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftAbstractHorse.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftAbstractHorse.java
+@@ -5,6 +5,7 @@ import java.util.UUID;
+ import net.minecraft.world.entity.ai.attributes.Attributes;
+ import org.bukkit.craftbukkit.CraftServer;
+ import org.bukkit.craftbukkit.inventory.CraftInventoryAbstractHorse;
+import org.bukkit.craftbukkit.inventory.CraftSaddledInventory;
+ import org.bukkit.entity.AbstractHorse;
+ import org.bukkit.entity.AnimalTamer;
+ import org.bukkit.entity.Horse;
+@@ -107,6 +108,6 @@ public abstract class CraftAbstractHorse extends CraftAnimals implements Abstrac
+ 
+     @Override
+     public AbstractHorseInventory getInventory() {
+-        return new CraftInventoryAbstractHorse(this.getHandle().inventory);
+        return new CraftSaddledInventory(getHandle().inventory);
+     }
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryHorse.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryHorse.java
+index 7013059856c2471dc34112a1a2068b96b809dd96..b72b4260fc1c0e9928d70f97589d8db00849b9e8 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryHorse.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryHorse.java
+@@ -4,7 +4,7 @@ import net.minecraft.world.Container;
+ import org.bukkit.inventory.HorseInventory;
+ import org.bukkit.inventory.ItemStack;
+ 
+-public class CraftInventoryHorse extends CraftInventoryAbstractHorse implements HorseInventory {
+public class CraftInventoryHorse extends CraftSaddledInventory implements HorseInventory {
+ 
+     public CraftInventoryHorse(Container inventory) {
+         super(inventory);
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftSaddledInventory.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftSaddledInventory.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..3a617c07d445bacf5a13e0e3ff6481823cfc8477
+--- /dev/null
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftSaddledInventory.java
+@@ -0,0 +1,12 @@
+package org.bukkit.craftbukkit.inventory;
+
+import net.minecraft.world.Container;
+import org.bukkit.inventory.SaddledHorseInventory;
+
+public class CraftSaddledInventory extends CraftInventoryAbstractHorse implements SaddledHorseInventory {
+
+    public CraftSaddledInventory(Container inventory) {
+        super(inventory);
+    }
+
+}
--- a/patches/server/0146-Implement-ensureServerConversions-API.patch
+++ b/patches/server/0146-Implement-ensureServerConversions-API.patch
@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Wed, 4 May 2016 22:43:12 -0400
+Subject: [PATCH] Implement ensureServerConversions API
+
+This will take a Bukkit ItemStack and run it through any conversions a server process would perform on it,
+to ensure it meets latest minecraft expectations.
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java
+index 45872e28cabc655c170bee163d471acf5d913c00..7e9e365fdce960bb266a4616d4bdc6d434cb2187 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java
+@@ -469,4 +469,11 @@ public final class CraftItemFactory implements ItemFactory {
+         return io.papermc.paper.adventure.PaperAdventure.asAdventure(CraftItemStack.asNMSCopy(itemStack).getDisplayName());
+     }
+     // Paper end - Adventure
+
+    // Paper start - ensure server conversions API
+    @Override
+    public ItemStack ensureServerConversions(ItemStack item) {
+        return CraftItemStack.asCraftMirror(CraftItemStack.asNMSCopy(item));
+    }
+    // Paper end - ensure server conversions API
+ }
--- a/patches/server/0147-Implement-getI18NDisplayName.patch
+++ b/patches/server/0147-Implement-getI18NDisplayName.patch
@ -0,0 +1,33 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Wed, 4 May 2016 23:59:38 -0400
+Subject: [PATCH] Implement getI18NDisplayName
+
+Gets the Display name as seen in the Client.
+Currently the server only supports the English language. To override this,
+You must replace the language file embedded in the server jar.
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java
+index 7e9e365fdce960bb266a4616d4bdc6d434cb2187..5aece14ec931f4c564e847a2797e92da8ffb569b 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java
+@@ -476,4 +476,19 @@ public final class CraftItemFactory implements ItemFactory {
+         return CraftItemStack.asCraftMirror(CraftItemStack.asNMSCopy(item));
+     }
+     // Paper end - ensure server conversions API
+
+    // Paper start - add getI18NDisplayName
+    @Override
+    public String getI18NDisplayName(ItemStack item) {
+        net.minecraft.world.item.ItemStack nms = null;
+        if (item instanceof CraftItemStack) {
+            nms = ((CraftItemStack) item).handle;
+        }
+        if (nms == null) {
+            nms = CraftItemStack.asNMSCopy(item);
+        }
+
+        return nms != null ? net.minecraft.locale.Language.getInstance().getOrDefault(nms.getItem().getDescriptionId(nms)) : null;
+    }
+    // Paper end - add getI18NDisplayName
+ }
--- a/patches/server/0148-ProfileWhitelistVerifyEvent.patch
+++ b/patches/server/0148-ProfileWhitelistVerifyEvent.patch
@ -0,0 +1,48 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 3 Jul 2017 18:11:10 -0500
+Subject: [PATCH] ProfileWhitelistVerifyEvent
+
+
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 0fb1fda1aba730e54d9e922e18de3bd048a78a62..0cdab5d4f1b4d368dfee0dc50183a83ca446fc17 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -633,9 +633,9 @@ public abstract class PlayerList {
+ 
+             // return chatmessage;
+             event.disallow(PlayerLoginEvent.Result.KICK_BANNED, io.papermc.paper.adventure.PaperAdventure.asAdventure(ichatmutablecomponent)); // Paper - Adventure
+-        } else if (!this.isWhiteListed(gameprofile)) {
+-            ichatmutablecomponent = Component.translatable("multiplayer.disconnect.not_whitelisted");
+-            event.disallow(PlayerLoginEvent.Result.KICK_WHITELIST, net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(org.spigotmc.SpigotConfig.whitelistMessage)); // Spigot // Paper - Adventure
+        } 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()) {
+             IpBanListEntry ipbanentry = this.ipBans.get(socketaddress);
+ 
+@@ -1026,7 +1026,23 @@ public abstract class PlayerList {
+     }
+ 
+     public boolean isWhiteListed(GameProfile profile) {
+-        return !this.doWhiteList || this.ops.contains(profile) || this.whitelist.contains(profile);
+        // Paper start
+        return isWhiteListed(profile, null);
+    }
+    public boolean isWhiteListed(GameProfile gameprofile, org.bukkit.event.player.PlayerLoginEvent loginEvent) {
+        boolean isOp = this.ops.contains(gameprofile);
+        boolean isWhitelisted = !this.doWhiteList || isOp || this.whitelist.contains(gameprofile);
+        final com.destroystokyo.paper.event.profile.ProfileWhitelistVerifyEvent event;
+        event = new com.destroystokyo.paper.event.profile.ProfileWhitelistVerifyEvent(io.papermc.paper.util.MCUtil.toBukkit(gameprofile), this.doWhiteList, isWhitelisted, isOp, org.spigotmc.SpigotConfig.whitelistMessage);
+        event.callEvent();
+        if (!event.isWhitelisted()) {
+            if (loginEvent != null) {
+                loginEvent.disallow(PlayerLoginEvent.Result.KICK_WHITELIST, net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(event.getKickMessage() == null ? org.spigotmc.SpigotConfig.whitelistMessage : event.getKickMessage()));
+            }
+            return false;
+        }
+        return true;
+        // Paper end
+     }
+ 
+     public boolean isOp(GameProfile profile) {
--- a/patches/server/0149-Fix-this-stupid-bullshit.patch
+++ b/patches/server/0149-Fix-this-stupid-bullshit.patch
@ -0,0 +1,52 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Kyle Wood <kyle@denwav.dev>
+Date: Sun, 6 Aug 2017 17:17:53 -0500
+Subject: [PATCH] Fix this stupid bullshit
+
+Disable the 15 second sleep when the server jar hasn't been rebuilt within a period of time.
+
+modified in order to prevent merge conflicts when Spigot changes/disables the warning,
+and to provide some level of hint without being disruptive.
+
+diff --git a/src/main/java/net/minecraft/server/Bootstrap.java b/src/main/java/net/minecraft/server/Bootstrap.java
+index 8ff786c366332588a2df053438f23cc9fb7e2b84..c887d34171f89c731d76c4ca92c70be2b1edc1e6 100644
+--- a/src/main/java/net/minecraft/server/Bootstrap.java
+++ b/src/main/java/net/minecraft/server/Bootstrap.java
+@@ -45,7 +45,7 @@ public class Bootstrap {
+     public static void bootStrap() {
+         if (!Bootstrap.isBootstrapped) {
+             // CraftBukkit start
+-            String name = Bootstrap.class.getSimpleName();
+            /*String name = Bootstrap.class.getSimpleName(); // Paper
+             switch (name) {
+                 case "DispenserRegistry":
+                     break;
+@@ -59,7 +59,7 @@ public class Bootstrap {
+                     System.err.println("*** WARNING: This server jar is unsupported, use at your own risk. ***");
+                     System.err.println("**********************************************************************");
+                     break;
+-            }
+            }*/ // Paper
+             // CraftBukkit end
+             Bootstrap.isBootstrapped = true;
+             Instant instant = Instant.now();
+diff --git a/src/main/java/org/bukkit/craftbukkit/Main.java b/src/main/java/org/bukkit/craftbukkit/Main.java
+index 601288ff52f0f0b0c82a5ff0414b60b8cb6e3a26..bf34d343fd0b3158bf00f9ce22b45dfd82c75dc5 100644
+--- a/src/main/java/org/bukkit/craftbukkit/Main.java
+++ b/src/main/java/org/bukkit/craftbukkit/Main.java
+@@ -257,10 +257,12 @@ public class Main {
+                     Calendar deadline = Calendar.getInstance();
+                     deadline.add(Calendar.DAY_OF_YEAR, -3);
+                     if (buildDate.before(deadline.getTime())) {
+-                        System.err.println("*** Error, this build is outdated ***");
+                        // Paper start - This is some stupid bullshit
+                        System.err.println("*** Warning, you've not updated in a while! ***");
+                         System.err.println("*** Please download a new build as per instructions from https://papermc.io/downloads/paper ***"); // Paper
+-                        System.err.println("*** Server will start in 20 seconds ***");
+-                        Thread.sleep(TimeUnit.SECONDS.toMillis(20));
+                        //System.err.println("*** Server will start in 20 seconds ***");
+                        //Thread.sleep(TimeUnit.SECONDS.toMillis(20));
+                        // Paper End
+                     }
+                 }
+ 
--- a/patches/server/0150-LivingEntity-setKiller.patch
+++ b/patches/server/0150-LivingEntity-setKiller.patch
@ -0,0 +1,29 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Mon, 31 Jul 2017 01:49:48 -0500
+Subject: [PATCH] LivingEntity#setKiller
+
+== AT ==
+public net.minecraft.world.entity.LivingEntity lastHurtByPlayerTime
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index 184ba082edac85a7df16eeebc4473a1a193b6a26..03d791e98d369c1d8fe4a4da11f89301392a934d 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -365,6 +365,16 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+         return this.getHandle().lastHurtByPlayer == null ? null : (Player) this.getHandle().lastHurtByPlayer.getBukkitEntity();
+     }
+ 
+    // Paper start
+    @Override
+    public void setKiller(Player killer) {
+        net.minecraft.server.level.ServerPlayer entityPlayer = killer == null ? null : ((CraftPlayer) killer).getHandle();
+        getHandle().lastHurtByPlayer = entityPlayer;
+        getHandle().lastHurtByMob = entityPlayer;
+        getHandle().lastHurtByPlayerTime = entityPlayer == null ? 0 : 100; // 100 value taken from EntityLiving#damageEntity
+    }
+    // Paper end
+
+     @Override
+     public boolean addPotionEffect(PotionEffect effect) {
+         return this.addPotionEffect(effect, false);
--- a/patches/server/0151-Ocelot-despawns-should-honor-nametags-and-leash.patch
+++ b/patches/server/0151-Ocelot-despawns-should-honor-nametags-and-leash.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Mon, 31 Jul 2017 01:54:40 -0500
+Subject: [PATCH] Ocelot despawns should honor nametags and leash
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Ocelot.java b/src/main/java/net/minecraft/world/entity/animal/Ocelot.java
+index 68679cd5857240ec4bc2951fa42a0dbbd4c13ee0..4300fab61765dd224fab084d118aae7294fc9de6 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Ocelot.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Ocelot.java
+@@ -135,7 +135,7 @@ public class Ocelot extends Animal {
+ 
+     @Override
+     public boolean removeWhenFarAway(double distanceSquared) {
+-        return !this.isTrusting() && this.tickCount > 2400;
+        return !this.isTrusting() && this.tickCount > 2400 && !this.hasCustomName() && !this.isLeashed(); // Paper - honor name and leash
+     }
+ 
+     public static AttributeSupplier.Builder createAttributes() {
--- a/patches/server/0152-Reset-spawner-timer-when-spawner-event-is-cancelled.patch
+++ b/patches/server/0152-Reset-spawner-timer-when-spawner-event-is-cancelled.patch
@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Mon, 31 Jul 2017 01:45:19 -0500
+Subject: [PATCH] Reset spawner timer when spawner event is cancelled
+
+
+diff --git a/src/main/java/net/minecraft/world/level/BaseSpawner.java b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+index 5d6403fa27521860a69a707dc4358b013adfafd7..20c39481bcf05e0d43c97b7e841ec9f5f6a0d45d 100644
+--- a/src/main/java/net/minecraft/world/level/BaseSpawner.java
+++ b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+@@ -166,6 +166,7 @@ public abstract class BaseSpawner {
+                         }
+ 
+                         entity.spawnedViaMobSpawner = true; // Paper
+                        flag = true; // Paper
+                         // CraftBukkit start
+                         if (org.bukkit.craftbukkit.event.CraftEventFactory.callSpawnerSpawnEvent(entity, pos).isCancelled()) {
+                             continue;
+@@ -182,7 +183,7 @@ public abstract class BaseSpawner {
+                             ((Mob) entity).spawnAnim();
+                         }
+ 
+-                        flag = true;
+                        //flag = true; // Paper - moved up above cancellable event
+                     }
+                 }
+ 
--- a/patches/server/0153-Allow-specifying-a-custom-authentication-servers-dow.patch
+++ b/patches/server/0153-Allow-specifying-a-custom-authentication-servers-dow.patch
@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: kashike <kashike@vq.lc>
+Date: Thu, 17 Aug 2017 16:08:20 -0700
+Subject: [PATCH] Allow specifying a custom "authentication servers down" kick
+ message
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+index b52ed512000328c1ac006fac18d997157faf4cb6..b98c7bb70a2d8867e1236d3c8d78d2cfffe76e28 100644
+--- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+@@ -259,7 +259,7 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
+                         ServerLoginPacketListenerImpl.LOGGER.warn("Authentication servers are down but will let them in anyway!");
+                         ServerLoginPacketListenerImpl.this.startClientVerification(ServerLoginPacketListenerImpl.this.createOfflineProfile(s1)); // Spigot
+                     } else {
+-                        ServerLoginPacketListenerImpl.this.disconnect(Component.translatable("multiplayer.disconnect.authservers_down"));
+                        ServerLoginPacketListenerImpl.this.disconnect(io.papermc.paper.adventure.PaperAdventure.asVanilla(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.authenticationServersDown)); // Paper
+                         ServerLoginPacketListenerImpl.LOGGER.error("Couldn't verify username because servers are unavailable");
+                     }
+                     // CraftBukkit start - catch all exceptions
--- a/patches/server/0154-Handle-plugin-prefixes-using-Log4J-configuration.patch
+++ b/patches/server/0154-Handle-plugin-prefixes-using-Log4J-configuration.patch
@ -0,0 +1,71 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Minecrell <minecrell@minecrell.net>
+Date: Thu, 21 Sep 2017 16:14:55 +0200
+Subject: [PATCH] Handle plugin prefixes using Log4J configuration
+
+Display logger name in the console for all loggers except the
+root logger, Bukkit's logger ("Minecraft") and Minecraft loggers.
+Since plugins now use the plugin name as logger name this will
+restore the plugin prefixes without having to prepend them manually
+to the log messages.
+
+Logger prefixes are shown by default for all loggers except for
+the root logger, the Minecraft/Mojang loggers and the Bukkit loggers.
+This may cause additional prefixes to be disabled for plugins bypassing
+the plugin logger.
+
+diff --git a/build.gradle.kts b/build.gradle.kts
+index 2f562d2fb02d58551338b055a0dd6c05df44e532..7002a2ccb519ede29244924062f7ed2f49546f7d 100644
+--- a/build.gradle.kts
+++ b/build.gradle.kts
+@@ -25,7 +25,7 @@ dependencies {
+           all its classes to check if they are plugins.
+           Scanning takes about 1-2 seconds so adding this speeds up the server start.
+      */
+-    runtimeOnly("org.apache.logging.log4j:log4j-core:2.19.0")
+    implementation("org.apache.logging.log4j:log4j-core:2.19.0") // Paper - implementation
+     log4jPlugins.annotationProcessorConfigurationName("org.apache.logging.log4j:log4j-core:2.19.0") // Paper - Needed to generate meta for our Log4j plugins
+     runtimeOnly(log4jPlugins.output)
+     alsoShade(log4jPlugins.output)
+diff --git a/src/main/java/org/spigotmc/SpigotConfig.java b/src/main/java/org/spigotmc/SpigotConfig.java
+index 0a0aa6de31a94a701074cc5f43c94be7515a185c..489ce6f439778b26eb33ede9432681d4bf9e0116 100644
+--- a/src/main/java/org/spigotmc/SpigotConfig.java
+++ b/src/main/java/org/spigotmc/SpigotConfig.java
+@@ -290,7 +290,7 @@ public class SpigotConfig
+     private static void playerSample()
+     {
+         SpigotConfig.playerSample = SpigotConfig.getInt( "settings.sample-count", 12 );
+-        System.out.println( "Server Ping Player Sample Count: " + SpigotConfig.playerSample );
+        Bukkit.getLogger().log( Level.INFO, "Server Ping Player Sample Count: {0}", playerSample ); // Paper - Use logger
+     }
+ 
+     public static int playerShuffle;
+diff --git a/src/main/resources/log4j2.xml b/src/main/resources/log4j2.xml
+index a994ec0f8621b1f267b40049306f63479c050e2f..bba2de3f3feb5e6a876f9df1eee6da0c7d93e271 100644
+--- a/src/main/resources/log4j2.xml
+++ b/src/main/resources/log4j2.xml
+@@ -5,10 +5,22 @@
+             <PatternLayout pattern="[%d{HH:mm:ss} %level]: %msg%n" />
+         </Queue>
+         <TerminalConsole name="TerminalConsole">
+-            <PatternLayout pattern="%highlightError{[%d{HH:mm:ss} %level]: %msg%n%xEx}" />
+            <PatternLayout>
+                <LoggerNamePatternSelector defaultPattern="%highlightError{[%d{HH:mm:ss} %level]: [%logger] %msg%n%xEx}">
+                    <!-- Log root, Minecraft, Mojang and Bukkit loggers without prefix -->
+                    <PatternMatch key=",net.minecraft.,Minecraft,com.mojang."
+                                  pattern="%highlightError{[%d{HH:mm:ss} %level]: %msg%n%xEx}" />
+                </LoggerNamePatternSelector>
+            </PatternLayout>
+         </TerminalConsole>
+         <RollingRandomAccessFile name="File" fileName="logs/latest.log" filePattern="logs/%d{yyyy-MM-dd}-%i.log.gz">
+-            <PatternLayout pattern="[%d{HH:mm:ss}] [%t/%level]: %stripAnsi{%msg}%n" />
+            <PatternLayout>
+                <LoggerNamePatternSelector defaultPattern="[%d{HH:mm:ss}] [%t/%level]: [%logger] %stripAnsi{%msg}%n">
+                    <!-- Log root, Minecraft, Mojang and Bukkit loggers without prefix -->
+                    <PatternMatch key=",net.minecraft.,Minecraft,com.mojang."
+                                  pattern="[%d{HH:mm:ss}] [%t/%level]: %stripAnsi{%msg}%n" />
+                </LoggerNamePatternSelector>
+            </PatternLayout>
+             <Policies>
+                 <TimeBasedTriggeringPolicy />
+                 <OnStartupTriggeringPolicy />
--- a/patches/server/0155-Improve-Log4J-Configuration-Plugin-Loggers.patch
+++ b/patches/server/0155-Improve-Log4J-Configuration-Plugin-Loggers.patch
@ -0,0 +1,47 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Minecrell <minecrell@minecrell.net>
+Date: Sat, 23 Sep 2017 21:07:20 +0200
+Subject: [PATCH] Improve Log4J Configuration / Plugin Loggers
+
+Add full exceptions to log4j to not truncate stack traces
+
+Disable logger prefix for various plugins bypassing the plugin logger
+
+Some plugins bypass the plugin logger and add the plugin prefix
+manually to the log message. Since they use other logger names
+(e.g. qualified class names) these would now also appear in the
+log. Disable the logger prefix for these plugins so the messages
+show up correctly.
+
+diff --git a/src/main/resources/log4j2.xml b/src/main/resources/log4j2.xml
+index bba2de3f3feb5e6a876f9df1eee6da0c7d93e271..88957220d5574e5590e8a545605d76c0c7b0a10e 100644
+--- a/src/main/resources/log4j2.xml
+++ b/src/main/resources/log4j2.xml
+@@ -6,19 +6,21 @@
+         </Queue>
+         <TerminalConsole name="TerminalConsole">
+             <PatternLayout>
+-                <LoggerNamePatternSelector defaultPattern="%highlightError{[%d{HH:mm:ss} %level]: [%logger] %msg%n%xEx}">
+                <LoggerNamePatternSelector defaultPattern="%highlightError{[%d{HH:mm:ss} %level]: [%logger] %msg%n%xEx{full}}">
+                     <!-- Log root, Minecraft, Mojang and Bukkit loggers without prefix -->
+-                    <PatternMatch key=",net.minecraft.,Minecraft,com.mojang."
+-                                  pattern="%highlightError{[%d{HH:mm:ss} %level]: %msg%n%xEx}" />
+                    <!-- Disable prefix for various plugins that bypass the plugin logger -->
+                    <PatternMatch key=",net.minecraft.,Minecraft,com.mojang.,com.sk89q.,ru.tehkode.,Minecraft.AWE"
+                                  pattern="%highlightError{[%d{HH:mm:ss} %level]: %msg%n%xEx{full}}" />
+                 </LoggerNamePatternSelector>
+             </PatternLayout>
+         </TerminalConsole>
+         <RollingRandomAccessFile name="File" fileName="logs/latest.log" filePattern="logs/%d{yyyy-MM-dd}-%i.log.gz">
+             <PatternLayout>
+-                <LoggerNamePatternSelector defaultPattern="[%d{HH:mm:ss}] [%t/%level]: [%logger] %stripAnsi{%msg}%n">
+                <LoggerNamePatternSelector defaultPattern="[%d{HH:mm:ss}] [%t/%level]: [%logger] %stripAnsi{%msg}%n%xEx{full}">
+                     <!-- Log root, Minecraft, Mojang and Bukkit loggers without prefix -->
+-                    <PatternMatch key=",net.minecraft.,Minecraft,com.mojang."
+-                                  pattern="[%d{HH:mm:ss}] [%t/%level]: %stripAnsi{%msg}%n" />
+                    <!-- Disable prefix for various plugins that bypass the plugin logger -->
+                    <PatternMatch key=",net.minecraft.,Minecraft,com.mojang.,com.sk89q.,ru.tehkode.,Minecraft.AWE"
+                                  pattern="[%d{HH:mm:ss}] [%t/%level]: %stripAnsi{%msg}%n%xEx{full}" />
+                 </LoggerNamePatternSelector>
+             </PatternLayout>
+             <Policies>
--- a/patches/server/0156-Add-PlayerJumpEvent.patch
+++ b/patches/server/0156-Add-PlayerJumpEvent.patch
@ -0,0 +1,46 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach.brown@destroystokyo.com>
+Date: Thu, 28 Sep 2017 17:21:44 -0400
+Subject: [PATCH] Add PlayerJumpEvent
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 4ab881766975eb4853094ad0d70e9e0647a0c23e..d849ca56d36f4652a5c1526a92f183a2defb3e0d 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1192,7 +1192,34 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+                             boolean flag = d7 > 0.0D;
+ 
+                             if (this.player.onGround() && !packet.isOnGround() && flag) {
+-                                this.player.jumpFromGround();
+                                // Paper start - Add player jump event
+                                Player player = this.getCraftPlayer();
+                                Location from = new Location(player.getWorld(), lastPosX, lastPosY, lastPosZ, lastYaw, lastPitch); // Get the Players previous Event location.
+                                Location to = player.getLocation().clone(); // Start off the To location as the Players current location.
+
+                                // If the packet contains movement information then we update the To location with the correct XYZ.
+                                if (packet.hasPos) {
+                                    to.setX(packet.x);
+                                    to.setY(packet.y);
+                                    to.setZ(packet.z);
+                                }
+
+                                // If the packet contains look information then we update the To location with the correct Yaw & Pitch.
+                                if (packet.hasRot) {
+                                    to.setYaw(packet.yRot);
+                                    to.setPitch(packet.xRot);
+                                }
+
+                                com.destroystokyo.paper.event.player.PlayerJumpEvent event = new com.destroystokyo.paper.event.player.PlayerJumpEvent(player, from, to);
+
+                                if (event.callEvent()) {
+                                    this.player.jumpFromGround();
+                                } else {
+                                    from = event.getFrom();
+                                    this.internalTeleport(from.getX(), from.getY(), from.getZ(), from.getYaw(), from.getPitch(), Collections.emptySet());
+                                    return;
+                                }
+                                // Paper end
+                             }
+ 
+                             boolean flag1 = this.player.verticalCollisionBelow;
--- a/patches/server/0157-handle-ServerboundKeepAlivePacket-async.patch
+++ b/patches/server/0157-handle-ServerboundKeepAlivePacket-async.patch
@ -0,0 +1,41 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Thu, 5 Oct 2017 01:54:07 +0100
+Subject: [PATCH] handle ServerboundKeepAlivePacket async
+
+In 1.12.2, Mojang moved the processing of ServerboundKeepAlivePacket off the main
+thread, while entirely correct for the server, this causes issues with
+plugins which are expecting the PlayerQuitEvent on the main thread.
+
+In order to counteract some bad behavior, we will post handling of the
+disconnection to the main thread, but leave the actual processing of the packet
+off the main thread.
+
+also adding some additional logging in order to help work out what is causing
+random disconnections for clients.
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+index 6faec2ca225fcebbad65190ab485e2cab77cfd6e..e8fb051bf24a4c239ae980c37d8d64f261b5db60 100644
+--- a/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+@@ -83,14 +83,18 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+ 
+     @Override
+     public void handleKeepAlive(ServerboundKeepAlivePacket packet) {
+-        PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel()); // CraftBukkit
+        //PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel()); // CraftBukkit // Paper - This shouldn't be on the main thread
+         if (this.keepAlivePending && packet.getId() == this.keepAliveChallenge) {
+             int i = (int) (Util.getMillis() - this.keepAliveTime);
+ 
+             this.latency = (this.latency * 3 + i) / 4;
+             this.keepAlivePending = false;
+         } else if (!this.isSingleplayerOwner()) {
+-            this.disconnect(ServerCommonPacketListenerImpl.TIMEOUT_DISCONNECTION_MESSAGE);
+            // Paper start - This needs to be handled on the main thread for plugins
+            server.submit(() -> {
+                this.disconnect(ServerCommonPacketListenerImpl.TIMEOUT_DISCONNECTION_MESSAGE);
+            });
+            // Paper endg
+         }
+ 
+     }
--- a/patches/server/0158-Expose-client-protocol-version-and-virtual-host.patch
+++ b/patches/server/0158-Expose-client-protocol-version-and-virtual-host.patch
@ -0,0 +1,116 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Minecrell <minecrell@minecrell.net>
+Date: Tue, 10 Oct 2017 18:45:20 +0200
+Subject: [PATCH] Expose client protocol version and virtual host
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/network/PaperNetworkClient.java b/src/main/java/com/destroystokyo/paper/network/PaperNetworkClient.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..a5a7624f1f372a26b982836cd31cff15e2589e9b
+--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/network/PaperNetworkClient.java
+@@ -0,0 +1,49 @@
+package com.destroystokyo.paper.network;
+
+import java.net.InetSocketAddress;
+
+import javax.annotation.Nullable;
+import net.minecraft.network.Connection;
+
+public class PaperNetworkClient implements NetworkClient {
+
+    private final Connection networkManager;
+
+    PaperNetworkClient(Connection networkManager) {
+        this.networkManager = networkManager;
+    }
+
+    @Override
+    public InetSocketAddress getAddress() {
+        return (InetSocketAddress) this.networkManager.getRemoteAddress();
+    }
+
+    @Override
+    public int getProtocolVersion() {
+        return this.networkManager.protocolVersion;
+    }
+
+    @Nullable
+    @Override
+    public InetSocketAddress getVirtualHost() {
+        return this.networkManager.virtualHost;
+    }
+
+    public static InetSocketAddress prepareVirtualHost(String host, int port) {
+        int len = host.length();
+
+        // FML appends a marker to the host to recognize FML clients (\0FML\0)
+        int pos = host.indexOf('\0');
+        if (pos >= 0) {
+            len = pos;
+        }
+
+        // When clients connect with a SRV record, their host contains a trailing '.'
+        if (len > 0 && host.charAt(len -  1) == '.') {
+            len--;
+        }
+
+        return InetSocketAddress.createUnresolved(host.substring(0, len), port);
+    }
+
+}
+diff --git a/src/main/java/net/minecraft/network/Connection.java b/src/main/java/net/minecraft/network/Connection.java
+index e7a124403f2b07c96caaaf97d1c9023f9ec2f9d9..e5e4a5fb2c342a249344d207ffea4000cc998710 100644
+--- a/src/main/java/net/minecraft/network/Connection.java
+++ b/src/main/java/net/minecraft/network/Connection.java
+@@ -111,6 +111,10 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
+     @Nullable
+     BandwidthDebugMonitor bandwidthDebugMonitor;
+     public String hostname = ""; // CraftBukkit - add field
+    // Paper start - NetworkClient implementation
+    public int protocolVersion;
+    public java.net.InetSocketAddress virtualHost;
+    // Paper end
+ 
+     public Connection(PacketFlow side) {
+         this.receiving = side;
+diff --git a/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
+index 9a327d193d732baea1fadaab7ebc663d6fd5307c..17f01fa589cb7c4eff4233a27e60a5928cbd604d 100644
+--- a/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
+@@ -157,6 +157,10 @@ public class ServerHandshakePacketListenerImpl implements ServerHandshakePacketL
+                 throw new UnsupportedOperationException("Invalid intention " + packet.intention());
+         }
+ 
+        // Paper start - NetworkClient implementation
+        this.connection.protocolVersion = packet.getProtocolVersion();
+        this.connection.virtualHost = com.destroystokyo.paper.network.PaperNetworkClient.prepareVirtualHost(packet.hostName, packet.port);
+        // Paper end
+     }
+ 
+     @Override
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 38c544cdf2230e94850eda4d38afce9df53973a8..e12ae345142f27efa9a4b97c9da522571fc1288a 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -246,6 +246,20 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         }
+     }
+ 
+    // Paper start - Implement NetworkClient
+    @Override
+    public int getProtocolVersion() {
+        if (getHandle().connection == null) return -1;
+        return getHandle().connection.connection.protocolVersion;
+    }
+
+    @Override
+    public InetSocketAddress getVirtualHost() {
+        if (getHandle().connection == null) return null;
+        return getHandle().connection.connection.virtualHost;
+    }
+    // Paper end
+
+     @Override
+     public double getEyeHeight(boolean ignorePose) {
+         if (ignorePose) {