More more more work

2021-11-23 13:15:10 +01:00 · 2021-11-23 13:15:10 +01:00 · e9954ed32a
commit e9954ed32a
parent c8cb91bb99
79 changed files with 356 additions and 330 deletions
--- a/patches/server/0024-Further-improve-server-tick-loop.patch
+++ b/patches/server/0024-Further-improve-server-tick-loop.patch
@ -0,0 +1,212 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 1 Mar 2016 23:09:29 -0600
+Subject: [PATCH] Further improve server tick loop
+
+Improves how the catchup buffer is handled, allowing it to roll both ways
+increasing the effeciency of the thread sleep so it only will sleep once.
+
+Also increases the buffer of the catchup to ensure server stays at 20 TPS unless extreme conditions
+
+Previous implementation did not calculate TPS correctly.
+Switch to a realistic rolling average and factor in std deviation as an extra reporting variable
+
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 15163398f96b4eda94d99b4b48ab2b06622bd2af..608b6218f5c59ecb3e7137121b8c4c2188479297 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -281,7 +281,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     public org.bukkit.command.ConsoleCommandSender console;
+     public org.bukkit.command.RemoteConsoleCommandSender remoteConsole;
+     public ConsoleReader reader;
+-    public static int currentTick = (int) (System.currentTimeMillis() / 50);
+    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;
+     public Commands vanillaCommandDispatcher;
+@@ -290,7 +290,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     // Spigot start
+     public static final int TPS = 20;
+     public static final int TICK_TIME = 1000000000 / MinecraftServer.TPS;
+-    private static final int SAMPLE_INTERVAL = 100;
+    private static final int SAMPLE_INTERVAL = 20; // Paper
+     public final double[] recentTps = new double[ 3 ];
+     public final SlackActivityAccountant slackActivityAccountant = new SlackActivityAccountant();
+     // Spigot end
+@@ -990,6 +990,57 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     {
+         return ( avg * exp ) + ( tps * ( 1 - exp ) );
+     }
+
+    // Paper start - Further improve server tick loop
+    private static final long SEC_IN_NANO = 1000000000;
+    private static final long MAX_CATCHUP_BUFFER = TICK_TIME * TPS * 60L;
+    private long lastTick = 0;
+    private long catchupTime = 0;
+    public final RollingAverage tps1 = new RollingAverage(60);
+    public final RollingAverage tps5 = new RollingAverage(60 * 5);
+    public final RollingAverage tps15 = new RollingAverage(60 * 15);
+
+    public static class RollingAverage {
+        private final int size;
+        private long time;
+        private java.math.BigDecimal total;
+        private int index = 0;
+        private final java.math.BigDecimal[] samples;
+        private final long[] times;
+
+        RollingAverage(int size) {
+            this.size = size;
+            this.time = size * SEC_IN_NANO;
+            this.total = dec(TPS).multiply(dec(SEC_IN_NANO)).multiply(dec(size));
+            this.samples = new java.math.BigDecimal[size];
+            this.times = new long[size];
+            for (int i = 0; i < size; i++) {
+                this.samples[i] = dec(TPS);
+                this.times[i] = SEC_IN_NANO;
+            }
+        }
+
+        private static java.math.BigDecimal dec(long t) {
+            return new java.math.BigDecimal(t);
+        }
+        public void add(java.math.BigDecimal x, long t) {
+            time -= times[index];
+            total = total.subtract(samples[index].multiply(dec(times[index])));
+            samples[index] = x;
+            times[index] = t;
+            time += t;
+            total = total.add(x.multiply(dec(t)));
+            if (++index == size) {
+                index = 0;
+            }
+        }
+
+        public double getAverage() {
+            return total.divide(dec(time), 30, java.math.RoundingMode.HALF_UP).doubleValue();
+        }
+    }
+    private static final java.math.BigDecimal TPS_BASE = new java.math.BigDecimal(1E9).multiply(new java.math.BigDecimal(SAMPLE_INTERVAL));
+    // Paper End
+     // Spigot End
+ 
+     protected void runServer() {
+@@ -1002,26 +1053,33 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
+                 // Spigot start
+                 Arrays.fill( recentTps, 20 );
+-                long curTime, tickSection = Util.getMillis(), tickCount = 1;
+                long start = System.nanoTime(), curTime, tickSection = start; // Paper - Further improve server tick loop
+                lastTick = start - TICK_TIME; // Paper
+                 while (this.running) {
+-                    long i = (curTime = Util.getMillis()) - this.nextTickTime;
+                    long i = ((curTime = System.nanoTime()) / (1000L * 1000L)) - this.nextTickTime; // Paper
+ 
+                     if (i > 5000L && this.nextTickTime - this.lastOverloadWarning >= 30000L) { // CraftBukkit
+                         long j = i / 50L;
+ 
+                         if (this.server.getWarnOnOverload()) // CraftBukkit
+-                        MinecraftServer.LOGGER.warn("Can't keep up! Is the server overloaded? Running {}ms or {} ticks behind", i, j);
+                            MinecraftServer.LOGGER.warn("Can't keep up! Is the server overloaded? Running {}ms or {} ticks behind", i, j);
+                         this.nextTickTime += j * 50L;
+                         this.lastOverloadWarning = this.nextTickTime;
+                     }
+ 
+                     ++MinecraftServer.currentTickLong; // Paper
+-                    if ( tickCount++ % MinecraftServer.SAMPLE_INTERVAL == 0 )
+                    if ( ++MinecraftServer.currentTick % MinecraftServer.SAMPLE_INTERVAL == 0 )
+                     {
+-                        double currentTps = 1E3 / ( curTime - tickSection ) * MinecraftServer.SAMPLE_INTERVAL;
+-                        this.recentTps[0] = MinecraftServer.calcTps( this.recentTps[0], 0.92, currentTps ); // 1/exp(5sec/1min)
+-                        this.recentTps[1] = MinecraftServer.calcTps( this.recentTps[1], 0.9835, currentTps ); // 1/exp(5sec/5min)
+-                        this.recentTps[2] = MinecraftServer.calcTps( this.recentTps[2], 0.9945, currentTps ); // 1/exp(5sec/15min)
+                        final long diff = curTime - tickSection;
+                        java.math.BigDecimal currentTps = TPS_BASE.divide(new java.math.BigDecimal(diff), 30, java.math.RoundingMode.HALF_UP);
+                        tps1.add(currentTps, diff);
+                        tps5.add(currentTps, diff);
+                        tps15.add(currentTps, diff);
+                        // Backwards compat with bad plugins
+                        this.recentTps[0] = tps1.getAverage();
+                        this.recentTps[1] = tps5.getAverage();
+                        this.recentTps[2] = tps15.getAverage();
+                        // Paper end
+                         tickSection = curTime;
+                     }
+                     // Spigot end
+@@ -1031,7 +1089,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+                         this.debugCommandProfiler = new MinecraftServer.TimeProfiler(Util.getNanos(), this.tickCount);
+                     }
+ 
+-                    MinecraftServer.currentTick = (int) (System.currentTimeMillis() / 50); // CraftBukkit
+                    //MinecraftServer.currentTick = (int) (System.currentTimeMillis() / 50); // CraftBukkit // Paper - don't overwrite current tick time
+                    lastTick = curTime;
+                     this.nextTickTime += 50L;
+                     this.startMetricsRecordingTick();
+                     this.profiler.push("tick");
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 6381ef19b4ea9ddcbf797eaae8103fe88d5d7fb7..c365a1cd02dbb8a248ba6247d3feb9553a22dfe6 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -2316,6 +2316,17 @@ public final class CraftServer implements Server {
+         return CraftMagicNumbers.INSTANCE;
+     }
+ 
+    // Paper - Add getTPS API - Further improve tick loop
+    @Override
+    public double[] getTPS() {
+        return new double[] {
+                net.minecraft.server.MinecraftServer.getServer().tps1.getAverage(),
+                net.minecraft.server.MinecraftServer.getServer().tps5.getAverage(),
+                net.minecraft.server.MinecraftServer.getServer().tps15.getAverage()
+        };
+    }
+    // Paper end
+
+     // Spigot start
+     private final org.bukkit.Server.Spigot spigot = new org.bukkit.Server.Spigot()
+     {
+diff --git a/src/main/java/org/spigotmc/TicksPerSecondCommand.java b/src/main/java/org/spigotmc/TicksPerSecondCommand.java
+index 4ab81a99f906e3f28e026d0e50b5b943c1bdcfb5..9bede6a26c08ede063c7a38f1149c811df14b258 100644
+--- a/src/main/java/org/spigotmc/TicksPerSecondCommand.java
+++ b/src/main/java/org/spigotmc/TicksPerSecondCommand.java
+@@ -24,22 +24,30 @@ public class TicksPerSecondCommand extends Command
+             return true;
+         }
+ 
+-        StringBuilder sb = new StringBuilder( ChatColor.GOLD + "TPS from last 1m, 5m, 15m: " );
+-        for ( double tps : MinecraftServer.getServer().recentTps )
+-        {
+-            sb.append( this.format( tps ) );
+-            sb.append( ", " );
+        // Paper start - Further improve tick handling
+        double[] tps = org.bukkit.Bukkit.getTPS();
+        String[] tpsAvg = new String[tps.length];
+
+        for ( int i = 0; i < tps.length; i++) {
+            tpsAvg[i] = TicksPerSecondCommand.format( tps[i] );
+        }
+        sender.sendMessage(ChatColor.GOLD + "TPS from last 1m, 5m, 15m: " + org.apache.commons.lang.StringUtils.join(tpsAvg, ", "));
+        if (args.length > 0 && args[0].equals("mem") && sender.hasPermission("bukkit.command.tpsmemory")) {
+            sender.sendMessage(ChatColor.GOLD + "Current Memory Usage: " + ChatColor.GREEN + ((Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) / (1024 * 1024)) + "/" + (Runtime.getRuntime().totalMemory() / (1024 * 1024)) + " mb (Max: " + (Runtime.getRuntime().maxMemory() / (1024 * 1024)) + " mb)");
+            if (!hasShownMemoryWarning) {
+                sender.sendMessage(ChatColor.RED + "Warning: " + ChatColor.GOLD + " Memory usage on modern garbage collectors is not a stable value and it is perfectly normal to see it reach max. Please do not pay it much attention.");
+                hasShownMemoryWarning = true;
+            }
+         }
+-        sender.sendMessage( sb.substring( 0, sb.length() - 2 ) );
+-        sender.sendMessage(ChatColor.GOLD + "Current Memory Usage: " + ChatColor.GREEN + ((Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) / (1024 * 1024)) + "/" + (Runtime.getRuntime().totalMemory() / (1024 * 1024)) + " mb (Max: "
+-                + (Runtime.getRuntime().maxMemory() / (1024 * 1024)) + " mb)");
+        // Paper end
+ 
+         return true;
+     }
+ 
+-    private String format(double tps)
+    private boolean hasShownMemoryWarning; // Paper
+    private static String format(double tps) // Paper - Made static
+     {
+         return ( ( tps > 18.0 ) ? ChatColor.GREEN : ( tps > 16.0 ) ? ChatColor.YELLOW : ChatColor.RED ).toString()
+-                + ( ( tps > 20.0 ) ? "*" : "" ) + Math.min( Math.round( tps * 100.0 ) / 100.0, 20.0 );
+                + ( ( tps > 21.0 ) ? "*" : "" ) + Math.min( Math.round( tps * 100.0 ) / 100.0, 20.0 ); // Paper - only print * at 21, we commonly peak to 20.02 as the tick sleep is not accurate enough, stop the noise
+     }
+ }
--- a/patches/server/0025-Only-refresh-abilities-if-needed.patch
+++ b/patches/server/0025-Only-refresh-abilities-if-needed.patch
@ -0,0 +1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach.brown@destroystokyo.com>
+Date: Tue, 1 Mar 2016 23:12:03 -0600
+Subject: [PATCH] Only refresh abilities if needed
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 6b945d22a84b77f835500ea8215748de24d5a00d..22c317d3762b9e2d8f70bd413555507c68b0cae4 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -1447,12 +1447,13 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+ 
+     @Override
+     public void setFlying(boolean value) {
+        boolean needsUpdate = getHandle().getAbilities().flying != value; // Paper - Only refresh abilities if needed
+         if (!this.getAllowFlight() && value) {
+             throw new IllegalArgumentException("Cannot make player fly if getAllowFlight() is false");
+         }
+ 
+         this.getHandle().getAbilities().flying = value;
+-        this.getHandle().onUpdateAbilities();
+        if (needsUpdate) this.getHandle().onUpdateAbilities(); // Paper - Only refresh abilities if needed
+     }
+ 
+     @Override
--- a/patches/server/0026-Entity-Origin-API.patch
+++ b/patches/server/0026-Entity-Origin-API.patch
@ -0,0 +1,159 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Byteflux <byte@byteflux.net>
+Date: Tue, 1 Mar 2016 23:45:08 -0600
+Subject: [PATCH] Entity Origin API
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 0486dc411f7cbda85c4e02fc85512a122522e035..057285ca421dc7e9a0c6449238409eaf42235ef5 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -1980,6 +1980,15 @@ public class ServerLevel extends Level implements WorldGenLevel {
+             }
+ 
+             entity.valid = true; // CraftBukkit
+            // Paper start - Set origin location when the entity is being added to the world
+            if (entity.getOriginVector() == null) {
+                entity.setOrigin(entity.getBukkitEntity().getLocation());
+            }
+            // Default to current world if unknown, gross assumption but entities rarely change world
+            if (entity.getOriginWorld() == null) {
+                entity.setOrigin(entity.getOriginVector().toLocation(getWorld()));
+            }
+            // Paper end
+         }
+ 
+         public void onTrackingEnd(Entity entity) {
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 969017958ff8ea6d8efba261ce1fe6e5c3a3f518..ff233d417d3f4f8fa4fa9ae9e77de7640102a172 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -285,6 +285,27 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, i
+     public org.bukkit.projectiles.ProjectileSource projectileSource; // For projectiles only
+     public boolean forceExplosionKnockback; // SPIGOT-949
+     public boolean persistentInvisibility = false;
+    // Paper start
+    @javax.annotation.Nullable
+    private org.bukkit.util.Vector origin;
+    @javax.annotation.Nullable
+    private UUID originWorld;
+
+    public void setOrigin(@javax.annotation.Nonnull Location location) {
+        this.origin = location.toVector();
+        this.originWorld = location.getWorld().getUID();
+    }
+
+    @javax.annotation.Nullable
+    public org.bukkit.util.Vector getOriginVector() {
+        return this.origin != null ? this.origin.clone() : null;
+    }
+
+    @javax.annotation.Nullable
+    public UUID getOriginWorld() {
+        return this.originWorld;
+    }
+    // Paper end
+     // Spigot start
+     public final org.spigotmc.ActivationRange.ActivationType activationType = org.spigotmc.ActivationRange.initializeEntityActivationType(this);
+     public final boolean defaultActivationState;
+@@ -1847,6 +1868,15 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, i
+                 this.bukkitEntity.storeBukkitValues(nbt);
+             }
+             // CraftBukkit end
+            // Paper start - Save the entity's origin location
+            if (this.origin != null) {
+                UUID originWorld = this.originWorld != null ? this.originWorld : this.level != null ? this.level.getWorld().getUID() : null;
+                if (originWorld != null) {
+                    nbt.putUUID("Paper.OriginWorld", originWorld);
+                }
+                nbt.put("Paper.Origin", this.newDoubleList(origin.getX(), origin.getY(), origin.getZ()));
+            }
+            // Paper end
+             return nbt;
+         } catch (Throwable throwable) {
+             CrashReport crashreport = CrashReport.forThrowable(throwable, "Saving entity NBT");
+@@ -1973,6 +2003,20 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, i
+             }
+             // CraftBukkit end
+ 
+            // Paper start - Restore the entity's origin location
+            ListTag originTag = nbt.getList("Paper.Origin", 6);
+            if (!originTag.isEmpty()) {
+                UUID originWorld = null;
+                if (nbt.contains("Paper.OriginWorld")) {
+                    originWorld = nbt.getUUID("Paper.OriginWorld");
+                } else if (this.level != null) {
+                    originWorld = this.level.getWorld().getUID();
+                }
+                this.originWorld = originWorld;
+                origin = new org.bukkit.util.Vector(originTag.getDouble(0), originTag.getDouble(1), originTag.getDouble(2));
+            }
+            // Paper end
+
+         } catch (Throwable throwable) {
+             CrashReport crashreport = CrashReport.forThrowable(throwable, "Loading entity NBT");
+             CrashReportCategory crashreportsystemdetails = crashreport.addCategory("Entity being loaded");
+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 1cc849fadd1e1cf4ef1d1009c8e42febe92a6e28..0366303a986ae6da8e95ed3051610c432a790194 100644
+--- a/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java
+++ b/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java
+@@ -345,6 +345,14 @@ public class FallingBlockEntity extends Entity {
+             this.blockState = Blocks.SAND.defaultBlockState();
+         }
+ 
+        // Paper start - Try and load origin location from the old NBT tags for backwards compatibility
+        if (nbt.contains("SourceLoc_x")) {
+            int srcX = nbt.getInt("SourceLoc_x");
+            int srcY = nbt.getInt("SourceLoc_y");
+            int srcZ = nbt.getInt("SourceLoc_z");
+            this.setOrigin(new org.bukkit.Location(level.getWorld(), srcX, srcY, srcZ));
+        }
+        // Paper end
+     }
+ 
+     public void setHurtsEntities(float fallHurtAmount, int fallHurtMax) {
+diff --git a/src/main/java/net/minecraft/world/entity/item/PrimedTnt.java b/src/main/java/net/minecraft/world/entity/item/PrimedTnt.java
+index 1f61dcc3d6f33f69fbebaaaee0554403c3e13adf..7135e22a2ee274eaef52804d60f15002176ff1db 100644
+--- a/src/main/java/net/minecraft/world/entity/item/PrimedTnt.java
+++ b/src/main/java/net/minecraft/world/entity/item/PrimedTnt.java
+@@ -120,6 +120,14 @@ public class PrimedTnt extends Entity {
+     @Override
+     protected void readAdditionalSaveData(CompoundTag nbt) {
+         this.setFuse(nbt.getShort("Fuse"));
+        // Paper start - Try and load origin location from the old NBT tags for backwards compatibility
+        if (nbt.contains("SourceLoc_x")) {
+            int srcX = nbt.getInt("SourceLoc_x");
+            int srcY = nbt.getInt("SourceLoc_y");
+            int srcZ = nbt.getInt("SourceLoc_z");
+            this.setOrigin(new org.bukkit.Location(level.getWorld(), srcX, srcY, srcZ));
+        }
+        // Paper end
+     }
+ 
+     @Nullable
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index b80b834fc35201746f5bba079aff6d95874f8f57..506bc08a7aadf5246f57e6935dbaa81ca482fb9a 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -1146,4 +1146,21 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+         return this.spigot;
+     }
+     // Spigot end
+
+    // Paper start
+    @Override
+    public Location getOrigin() {
+        Vector originVector = this.getHandle().getOriginVector();
+        if (originVector == null) {
+            return null;
+        }
+        World world = this.getWorld();
+        if (this.getHandle().getOriginWorld() != null) {
+            world = org.bukkit.Bukkit.getWorld(this.getHandle().getOriginWorld());
+        }
+
+        //noinspection ConstantConditions
+        return originVector.toLocation(world);
+    }
+    // Paper end
+ }
--- a/patches/server/0027-Prevent-tile-entity-and-entity-crashes.patch
+++ b/patches/server/0027-Prevent-tile-entity-and-entity-crashes.patch
@ -0,0 +1,66 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 1 Mar 2016 23:52:34 -0600
+Subject: [PATCH] Prevent tile entity and entity crashes
+
+
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index e112598c854a2c93a8e6b6bda3cfdd4ee4091980..1195a4b79103d62ed4f8c91dd36ccd77fa561f01 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -737,11 +737,11 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+         try {
+             tickConsumer.accept(entity);
+         } catch (Throwable throwable) {
+-            CrashReport crashreport = CrashReport.forThrowable(throwable, "Ticking entity");
+-            CrashReportCategory crashreportsystemdetails = crashreport.addCategory("Entity being ticked");
+-
+-            entity.fillCrashReportCategory(crashreportsystemdetails);
+-            throw new ReportedException(crashreport);
+            // Paper start - Prevent tile entity and entity crashes
+            final String msg = String.format("Entity threw exception at %s:%s,%s,%s", entity.level.getWorld().getName(), entity.getX(), entity.getY(), entity.getZ());
+            MinecraftServer.LOGGER.error(msg, throwable);
+            entity.discard();
+            // Paper end
+         }
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
+index e1cbecc402bfc14fb9e36d5c449cd404f119752d..52b4c231faa2f33f766f50399e52e30184fb01a7 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
+@@ -233,7 +233,12 @@ public abstract class BlockEntity implements io.papermc.paper.util.KeyedObject {
+             return minecraftkey + " // " + this.getClass().getCanonicalName();
+         });
+         if (this.level != null) {
+-            CrashReportCategory.populateBlockDetails(crashReportSection, this.level, this.worldPosition, this.getBlockState());
+            // Paper start - Prevent TileEntity and Entity crashes
+            BlockState block = this.getBlockState();
+            if (block != null) {
+                CrashReportCategory.populateBlockDetails(crashReportSection, this.level, this.worldPosition, block);
+            }
+            // Paper end
+             CrashReportCategory.populateBlockDetails(crashReportSection, this.level, this.worldPosition, this.level.getBlockState(this.worldPosition));
+         }
+     }
+diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+index 3e4ece7b607d06c9d88322ce79f4888e1cc07aee..cadcafec7dc8af1e938b20d07bd9a24acd350ab1 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+@@ -1029,11 +1029,11 @@ public class LevelChunk extends ChunkAccess {
+ 
+                         gameprofilerfiller.pop();
+                     } catch (Throwable throwable) {
+-                        CrashReport crashreport = CrashReport.forThrowable(throwable, "Ticking block entity");
+-                        CrashReportCategory crashreportsystemdetails = crashreport.addCategory("Block entity being ticked");
+-
+-                        this.blockEntity.fillCrashReportCategory(crashreportsystemdetails);
+-                        throw new ReportedException(crashreport);
+                        // Paper start - Prevent tile entity and entity crashes
+                        final String msg = String.format("BlockEntity threw exception at %s:%s,%s,%s", LevelChunk.this.getLevel().getWorld().getName(), this.getPos().getX(), this.getPos().getY(), this.getPos().getZ());
+                        net.minecraft.server.MinecraftServer.LOGGER.error(msg, throwable);
+                        LevelChunk.this.removeBlockEntity(this.getPos());
+                        // Paper end
+                         // Spigot start
+                     } finally {
+                         this.blockEntity.tickTimer.stopTiming();
--- a/patches/server/0028-Configurable-top-of-nether-void-damage.patch
+++ b/patches/server/0028-Configurable-top-of-nether-void-damage.patch
@ -0,0 +1,47 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach.brown@destroystokyo.com>
+Date: Tue, 1 Mar 2016 23:58:50 -0600
+Subject: [PATCH] Configurable top of nether void damage
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index 1cfa6ae0a2fc42cd83c1323d49151ec2bbbacf83..08281351cc99e904a3a388607425dde4c83f13e2 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -175,4 +175,19 @@ public class PaperWorldConfig {
+         if (fallingBlockHeightNerf != 0) log("Falling Block Height Limit set to Y: " + fallingBlockHeightNerf);
+         if (entityTNTHeightNerf != 0) log("TNT Entity Height Limit set to Y: " + entityTNTHeightNerf);
+     }
+
+    public int netherVoidTopDamageHeight;
+    public boolean doNetherTopVoidDamage() { return netherVoidTopDamageHeight > 0; }
+    private void netherVoidTopDamageHeight() {
+        netherVoidTopDamageHeight = getInt("nether-ceiling-void-damage-height", 0);
+        log("Top of the nether void damage height: " + netherVoidTopDamageHeight);
+
+        if (PaperConfig.version < 18) {
+            boolean legacy = getBoolean("nether-ceiling-void-damage", false);
+            if (legacy) {
+                netherVoidTopDamageHeight = 128;
+                set("nether-ceiling-void-damage-height", netherVoidTopDamageHeight);
+            }
+        }
+    }
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index ff233d417d3f4f8fa4fa9ae9e77de7640102a172..6bc8c8e15e66cd54cbb6ebc6d09a6fe8652b5d18 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -634,7 +634,11 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, i
+     }
+ 
+     public void checkOutOfWorld() {
+-        if (this.getY() < (double) (this.level.getMinBuildHeight() - 64)) {
+        // Paper start - Configurable nether ceiling damage
+        if (this.getY() < (double) (this.level.getMinBuildHeight() - 64) || (this.level.getWorld().getEnvironment() == org.bukkit.World.Environment.NETHER
+            && level.paperConfig.doNetherTopVoidDamage()
+            && this.getY() >= this.level.paperConfig.netherVoidTopDamageHeight)) {
+            // Paper end
+             this.outOfWorld();
+         }
+ 
--- a/patches/server/0029-Check-online-mode-before-converting-and-renaming-pla.patch
+++ b/patches/server/0029-Check-online-mode-before-converting-and-renaming-pla.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach.brown@destroystokyo.com>
+Date: Wed, 2 Mar 2016 00:03:55 -0600
+Subject: [PATCH] Check online mode before converting and renaming player data
+
+
+diff --git a/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java b/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java
+index 4dcdfda78966df2596b44f7e2d3b1d61c45f17af..7b367e273c2a6869f8d8929c24ee45efdf6d4b1e 100644
+--- a/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java
+++ b/src/main/java/net/minecraft/world/level/storage/PlayerDataStorage.java
+@@ -56,7 +56,7 @@ public class PlayerDataStorage {
+             File file = new File(this.playerDir, player.getStringUUID() + ".dat");
+             // Spigot Start
+             boolean usingWrongFile = false;
+-            if ( !file.exists() )
+            if ( org.bukkit.Bukkit.getOnlineMode() && !file.exists() ) // Paper - Check online mode first
+             {
+                 file = new File( this.playerDir, java.util.UUID.nameUUIDFromBytes( ( "OfflinePlayer:" + player.getScoreboardName() ).getBytes( "UTF-8" ) ).toString() + ".dat");
+                 if ( file.exists() )
--- a/patches/server/0030-Always-tick-falling-blocks.patch
+++ b/patches/server/0030-Always-tick-falling-blocks.patch
@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach.brown@destroystokyo.com>
+Date: Wed, 2 Mar 2016 00:32:25 -0600
+Subject: [PATCH] Always tick falling blocks
+
+
+diff --git a/src/main/java/org/spigotmc/ActivationRange.java b/src/main/java/org/spigotmc/ActivationRange.java
+index f023f3a0d1671398363f0caa432ffb61fd07c9b2..84ce3d38d5decb4a2f9fae78e0ef5d715860dc7d 100644
+--- a/src/main/java/org/spigotmc/ActivationRange.java
+++ b/src/main/java/org/spigotmc/ActivationRange.java
+@@ -89,6 +89,7 @@ public class ActivationRange
+                 || entity instanceof AbstractHurtingProjectile
+                 || entity instanceof LightningBolt
+                 || entity instanceof PrimedTnt
+                || entity instanceof net.minecraft.world.entity.item.FallingBlockEntity // Paper - Always tick falling blocks
+                 || entity instanceof EndCrystal
+                 || entity instanceof FireworkRocketEntity
+                 || entity instanceof ThrownTrident )
--- a/patches/server/0031-Configurable-end-credits.patch
+++ b/patches/server/0031-Configurable-end-credits.patch
@ -0,0 +1,33 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: DoctorDark <doctordark11@gmail.com>
+Date: Wed, 16 Mar 2016 02:21:39 -0500
+Subject: [PATCH] Configurable end credits
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index 08281351cc99e904a3a388607425dde4c83f13e2..58c8c6db87492cf70de3a26d23209a931c6726b2 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -190,4 +190,10 @@ public class PaperWorldConfig {
+             }
+         }
+     }
+
+    public boolean disableEndCredits;
+    private void disableEndCredits() {
+        disableEndCredits = getBoolean("game-mechanics.disable-end-credits", false);
+        log("End credits disabled: " + disableEndCredits);
+    }
+ }
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index a3436596d05547a60c9906c92f709bb56a9175bd..88b6be62678fc09b5a39db28c6d71cc31b16dbcd 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -974,6 +974,7 @@ public class ServerPlayer extends Player {
+             this.unRide();
+             this.getLevel().removePlayerImmediately(this, Entity.RemovalReason.CHANGED_DIMENSION);
+             if (!this.wonGame) {
+                if (level.paperConfig.disableEndCredits) this.seenCredits = true; // Paper - Toggle to always disable end credits
+                 this.wonGame = true;
+                 this.connection.send(new ClientboundGameEventPacket(ClientboundGameEventPacket.WIN_GAME, this.seenCredits ? 0.0F : 1.0F));
+                 this.seenCredits = true;
--- a/patches/server/0032-Fix-lag-from-explosions-processing-dead-entities.patch
+++ b/patches/server/0032-Fix-lag-from-explosions-processing-dead-entities.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Iceee <andrew@opticgaming.tv>
+Date: Wed, 2 Mar 2016 01:39:52 -0600
+Subject: [PATCH] Fix lag from explosions processing dead entities
+
+
+diff --git a/src/main/java/net/minecraft/world/level/Explosion.java b/src/main/java/net/minecraft/world/level/Explosion.java
+index a0e364c3f6d5c513c8b37de60ced9ef6433b6cda..996e02be9f3150ba125d52e3d544599c2b8dd968 100644
+--- a/src/main/java/net/minecraft/world/level/Explosion.java
+++ b/src/main/java/net/minecraft/world/level/Explosion.java
+@@ -207,7 +207,7 @@ public class Explosion {
+         int i1 = Mth.floor(this.y + (double) f2 + 1.0D);
+         int j1 = Mth.floor(this.z - (double) f2 - 1.0D);
+         int k1 = Mth.floor(this.z + (double) f2 + 1.0D);
+-        List<Entity> list = this.level.getEntities(this.source, new AABB((double) i, (double) l, (double) j1, (double) j, (double) i1, (double) k1));
+        List<Entity> list = this.level.getEntities(this.source, new AABB((double) i, (double) l, (double) j1, (double) j, (double) i1, (double) k1), (com.google.common.base.Predicate<Entity>) entity -> entity.isAlive() && !entity.isSpectator()); // Paper - Fix lag from explosions processing dead entities
+         Vec3 vec3d = new Vec3(this.x, this.y, this.z);
+ 
+         for (int l1 = 0; l1 < list.size(); ++l1) {
--- a/patches/server/0033-Optimize-explosions.patch
+++ b/patches/server/0033-Optimize-explosions.patch
@ -0,0 +1,148 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Byteflux <byte@byteflux.net>
+Date: Wed, 2 Mar 2016 11:59:48 -0600
+Subject: [PATCH] Optimize explosions
+
+The process of determining an entity's exposure from explosions can be
+expensive when there are hundreds or more entities in range.
+
+This patch adds a per-tick cache that is used for storing and retrieving
+an entity's exposure during an explosion.
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index 58c8c6db87492cf70de3a26d23209a931c6726b2..ef0ec6b45cee27547e06ead7ef5acd6e51380a52 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -196,4 +196,10 @@ public class PaperWorldConfig {
+         disableEndCredits = getBoolean("game-mechanics.disable-end-credits", false);
+         log("End credits disabled: " + disableEndCredits);
+     }
+
+    public boolean optimizeExplosions;
+    private void optimizeExplosions() {
+        optimizeExplosions = getBoolean("optimize-explosions", false);
+        log("Optimize explosions: " + optimizeExplosions);
+    }
+ }
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 608b6218f5c59ecb3e7137121b8c4c2188479297..5cf85636e089a4bf2422d76b8df52c1166d3f148 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1405,6 +1405,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
+             this.profiler.pop();
+             this.profiler.pop();
+            worldserver.explosionDensityCache.clear(); // Paper - Optimize explosions
+         }
+ 
+         this.profiler.popPush("connection");
+diff --git a/src/main/java/net/minecraft/world/level/Explosion.java b/src/main/java/net/minecraft/world/level/Explosion.java
+index 996e02be9f3150ba125d52e3d544599c2b8dd968..688ebb68209beb4550293f72b1fa7b39852be453 100644
+--- a/src/main/java/net/minecraft/world/level/Explosion.java
+++ b/src/main/java/net/minecraft/world/level/Explosion.java
+@@ -226,7 +226,7 @@ public class Explosion {
+                         d8 /= d11;
+                         d9 /= d11;
+                         d10 /= d11;
+-                        double d12 = (double) Explosion.getSeenPercent(vec3d, entity);
+                        double d12 = this.getBlockDensity(vec3d, entity); // Paper - Optimize explosions
+                         double d13 = (1.0D - d7) * d12;
+ 
+                         // CraftBukkit start
+@@ -444,4 +444,84 @@ public class Explosion {
+ 
+         private BlockInteraction() {}
+     }
+    // Paper start - Optimize explosions
+    private float getBlockDensity(Vec3 vec3d, Entity entity) {
+        if (!this.level.paperConfig.optimizeExplosions) {
+            return getSeenPercent(vec3d, entity);
+        }
+        CacheKey key = new CacheKey(this, entity.getBoundingBox());
+        Float blockDensity = this.level.explosionDensityCache.get(key);
+        if (blockDensity == null) {
+            blockDensity = getSeenPercent(vec3d, entity);
+            this.level.explosionDensityCache.put(key, blockDensity);
+        }
+
+        return blockDensity;
+    }
+
+    static class CacheKey {
+        private final Level world;
+        private final double posX, posY, posZ;
+        private final double minX, minY, minZ;
+        private final double maxX, maxY, maxZ;
+
+        public CacheKey(Explosion explosion, AABB aabb) {
+            this.world = explosion.level;
+            this.posX = explosion.x;
+            this.posY = explosion.y;
+            this.posZ = explosion.z;
+            this.minX = aabb.minX;
+            this.minY = aabb.minY;
+            this.minZ = aabb.minZ;
+            this.maxX = aabb.maxX;
+            this.maxY = aabb.maxY;
+            this.maxZ = aabb.maxZ;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+
+            CacheKey cacheKey = (CacheKey) o;
+
+            if (Double.compare(cacheKey.posX, posX) != 0) return false;
+            if (Double.compare(cacheKey.posY, posY) != 0) return false;
+            if (Double.compare(cacheKey.posZ, posZ) != 0) return false;
+            if (Double.compare(cacheKey.minX, minX) != 0) return false;
+            if (Double.compare(cacheKey.minY, minY) != 0) return false;
+            if (Double.compare(cacheKey.minZ, minZ) != 0) return false;
+            if (Double.compare(cacheKey.maxX, maxX) != 0) return false;
+            if (Double.compare(cacheKey.maxY, maxY) != 0) return false;
+            if (Double.compare(cacheKey.maxZ, maxZ) != 0) return false;
+            return world.equals(cacheKey.world);
+        }
+
+        @Override
+        public int hashCode() {
+            int result;
+            long temp;
+            result = world.hashCode();
+            temp = Double.doubleToLongBits(posX);
+            result = 31 * result + (int) (temp ^ (temp >>> 32));
+            temp = Double.doubleToLongBits(posY);
+            result = 31 * result + (int) (temp ^ (temp >>> 32));
+            temp = Double.doubleToLongBits(posZ);
+            result = 31 * result + (int) (temp ^ (temp >>> 32));
+            temp = Double.doubleToLongBits(minX);
+            result = 31 * result + (int) (temp ^ (temp >>> 32));
+            temp = Double.doubleToLongBits(minY);
+            result = 31 * result + (int) (temp ^ (temp >>> 32));
+            temp = Double.doubleToLongBits(minZ);
+            result = 31 * result + (int) (temp ^ (temp >>> 32));
+            temp = Double.doubleToLongBits(maxX);
+            result = 31 * result + (int) (temp ^ (temp >>> 32));
+            temp = Double.doubleToLongBits(maxY);
+            result = 31 * result + (int) (temp ^ (temp >>> 32));
+            temp = Double.doubleToLongBits(maxZ);
+            result = 31 * result + (int) (temp ^ (temp >>> 32));
+            return result;
+        }
+    }
+    // Paper end
+ }
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 1195a4b79103d62ed4f8c91dd36ccd77fa561f01..d8da1dfdc58726eda01e1bfb059c144e98ce7fe8 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -156,6 +156,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+     private org.spigotmc.TickLimiter entityLimiter;
+     private org.spigotmc.TickLimiter tileLimiter;
+     private int tileTickPosition;
+    public final Map<Explosion.CacheKey, Float> explosionDensityCache = new HashMap<>(); // Paper - Optimize explosions
+ 
+     public CraftWorld getWorld() {
+         return this.world;
--- a/patches/server/0034-Disable-explosion-knockback.patch
+++ b/patches/server/0034-Disable-explosion-knockback.patch
@ -0,0 +1,69 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Sudzzy <originmc@outlook.com>
+Date: Wed, 2 Mar 2016 14:48:03 -0600
+Subject: [PATCH] Disable explosion knockback
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index ef0ec6b45cee27547e06ead7ef5acd6e51380a52..dc8a1e4c5375fdd733146f671df91f59817f8377 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -202,4 +202,9 @@ public class PaperWorldConfig {
+         optimizeExplosions = getBoolean("optimize-explosions", false);
+         log("Optimize explosions: " + optimizeExplosions);
+     }
+
+    public boolean disableExplosionKnockback;
+    private void disableExplosionKnockback(){
+        disableExplosionKnockback = getBoolean("disable-explosion-knockback", false);
+    }
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 906c23068d1f5be76a6985b7255f6f155335b673..deef28110441cd2965c6b531bc255ee2aa994ace 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -1375,6 +1375,7 @@ public abstract class LivingEntity extends Entity {
+                 }
+             }
+ 
+            boolean knockbackCancelled = level.paperConfig.disableExplosionKnockback && source.isExplosion() && this instanceof net.minecraft.world.entity.player.Player; // Paper - Disable explosion knockback
+             if (flag1) {
+                 if (flag) {
+                     this.level.broadcastEntityEvent(this, (byte) 29);
+@@ -1395,6 +1396,7 @@ public abstract class LivingEntity extends Entity {
+                         b0 = 2;
+                     }
+ 
+                    if (!knockbackCancelled) // Paper - Disable explosion knockback
+                     this.level.broadcastEntityEvent(this, b0);
+                 }
+ 
+@@ -1418,6 +1420,7 @@ public abstract class LivingEntity extends Entity {
+                 }
+             }
+ 
+            if (knockbackCancelled) this.level.broadcastEntityEvent(this, (byte) 2); // Paper - Disable explosion knockback
+             if (this.isDeadOrDying()) {
+                 if (!this.checkTotemDeathProtection(source)) {
+                     SoundEvent soundeffect = this.getDeathSound();
+diff --git a/src/main/java/net/minecraft/world/level/Explosion.java b/src/main/java/net/minecraft/world/level/Explosion.java
+index 688ebb68209beb4550293f72b1fa7b39852be453..32c8403d6a5f5fbd52679b12b07936147744b8a4 100644
+--- a/src/main/java/net/minecraft/world/level/Explosion.java
+++ b/src/main/java/net/minecraft/world/level/Explosion.java
+@@ -241,14 +241,14 @@ public class Explosion {
+                         double d14 = d13;
+ 
+                         if (entity instanceof LivingEntity) {
+-                            d14 = ProtectionEnchantment.getExplosionKnockbackAfterDampener((LivingEntity) entity, d13);
+                            d14 = entity instanceof Player && level.paperConfig.disableExplosionKnockback ? 0 : ProtectionEnchantment.getExplosionKnockbackAfterDampener((LivingEntity) entity, d13); // Paper - Disable explosion knockback
+                         }
+ 
+                         entity.setDeltaMovement(entity.getDeltaMovement().add(d8 * d14, d9 * d14, d10 * d14));
+                         if (entity instanceof Player) {
+                             Player entityhuman = (Player) entity;
+ 
+-                            if (!entityhuman.isSpectator() && (!entityhuman.isCreative() || !entityhuman.getAbilities().flying)) {
+                            if (!entityhuman.isSpectator() && (!entityhuman.isCreative() || !entityhuman.getAbilities().flying) && !level.paperConfig.disableExplosionKnockback) { // Paper - Disable explosion knockback
+                                 this.hitPlayers.put(entityhuman, new Vec3(d8 * d13, d9 * d13, d10 * d13));
+                             }
+                         }
--- a/patches/server/0035-Disable-thunder.patch
+++ b/patches/server/0035-Disable-thunder.patch
@ -0,0 +1,33 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Sudzzy <originmc@outlook.com>
+Date: Wed, 2 Mar 2016 14:52:43 -0600
+Subject: [PATCH] Disable thunder
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index dc8a1e4c5375fdd733146f671df91f59817f8377..3ca83e07060e184cbd19a5585d44f5e7a5354462 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -207,4 +207,9 @@ public class PaperWorldConfig {
+     private void disableExplosionKnockback(){
+         disableExplosionKnockback = getBoolean("disable-explosion-knockback", false);
+     }
+
+    public boolean disableThunder;
+    private void disableThunder() {
+        disableThunder = getBoolean("disable-thunder", false);
+    }
+ }
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 057285ca421dc7e9a0c6449238409eaf42235ef5..0fd9ad873ed681dab1b297bf5cdf700e43be2200 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -556,7 +556,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+         gameprofilerfiller.push("thunder");
+         BlockPos blockposition;
+ 
+-        if (flag && this.isThundering() && this.spigotConfig.thunderChance > 0 && this.random.nextInt(this.spigotConfig.thunderChance) == 0) { // Spigot
+        if (!this.paperConfig.disableThunder && flag && this.isThundering() && this.spigotConfig.thunderChance > 0 && this.random.nextInt(this.spigotConfig.thunderChance) == 0) { // Spigot // Paper - disable thunder
+             blockposition = this.findLightningTargetAround(this.getBlockRandomPos(j, 0, k, 15));
+             if (this.isRainingAt(blockposition)) {
+                 DifficultyInstance difficultydamagescaler = this.getCurrentDifficultyAt(blockposition);
--- a/patches/server/0036-Disable-ice-and-snow.patch
+++ b/patches/server/0036-Disable-ice-and-snow.patch
@ -0,0 +1,33 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Sudzzy <originmc@outlook.com>
+Date: Wed, 2 Mar 2016 14:57:24 -0600
+Subject: [PATCH] Disable ice and snow
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index 3ca83e07060e184cbd19a5585d44f5e7a5354462..bf0c767af0ca5129b69b3c8dcfe54cdee989854b 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -212,4 +212,9 @@ public class PaperWorldConfig {
+     private void disableThunder() {
+         disableThunder = getBoolean("disable-thunder", false);
+     }
+
+    public boolean disableIceAndSnow;
+    private void disableIceAndSnow(){
+        disableIceAndSnow = getBoolean("disable-ice-and-snow", false);
+    }
+ }
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 0fd9ad873ed681dab1b297bf5cdf700e43be2200..032e1e08413f2d0f601cdc32fe12145e2c1fec5f 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -580,7 +580,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+         }
+ 
+         gameprofilerfiller.popPush("iceandsnow");
+-        if (this.random.nextInt(16) == 0) {
+        if (!this.paperConfig.disableIceAndSnow && this.random.nextInt(16) == 0) { // Paper - Disable ice and snow
+             blockposition = this.getHeightmapPos(Heightmap.Types.MOTION_BLOCKING, this.getBlockRandomPos(j, 0, k, 15));
+             BlockPos blockposition1 = blockposition.below();
+             Biome biomebase = this.getBiome(blockposition);
--- a/patches/server/0037-Configurable-mob-spawner-tick-rate.patch
+++ b/patches/server/0037-Configurable-mob-spawner-tick-rate.patch
@ -0,0 +1,63 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Sudzzy <originmc@outlook.com>
+Date: Wed, 2 Mar 2016 15:03:53 -0600
+Subject: [PATCH] Configurable mob spawner tick rate
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index bf0c767af0ca5129b69b3c8dcfe54cdee989854b..cff814a123e02aea96197c1be092c210c2fcf781 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -217,4 +217,9 @@ public class PaperWorldConfig {
+     private void disableIceAndSnow(){
+         disableIceAndSnow = getBoolean("disable-ice-and-snow", false);
+     }
+
+    public int mobSpawnerTickRate;
+    private void mobSpawnerTickRate() {
+        mobSpawnerTickRate = getInt("mob-spawner-tick-rate", 1);
+    }
+ }
+diff --git a/src/main/java/net/minecraft/world/level/BaseSpawner.java b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+index b3a4c907bb15907d82e58247cb049e3f9fcf990e..840a47fdfa67b166bbafd5d7958462b32fb26681 100644
+--- a/src/main/java/net/minecraft/world/level/BaseSpawner.java
+++ b/src/main/java/net/minecraft/world/level/BaseSpawner.java
+@@ -42,6 +42,7 @@ public abstract class BaseSpawner {
+     public int requiredPlayerRange = 16;
+     public int spawnRange = 4;
+     private final Random random = new Random();
+    private int tickDelay = 0; // Paper
+ 
+     public BaseSpawner() {}
+ 
+@@ -75,13 +76,18 @@ public abstract class BaseSpawner {
+     }
+ 
+     public void serverTick(ServerLevel world, BlockPos pos) {
+        // Paper start - Configurable mob spawner tick rate
+        if (spawnDelay > 0 && --tickDelay > 0) return;
+        tickDelay = world.paperConfig.mobSpawnerTickRate;
+        if (tickDelay == -1) { return; } // If disabled
+        // Paper end
+         if (this.isNearPlayer(world, pos)) {
+-            if (this.spawnDelay == -1) {
+            if (this.spawnDelay < -tickDelay) {
+                 this.delay(world, pos);
+             }
+ 
+             if (this.spawnDelay > 0) {
+-                --this.spawnDelay;
+                this.spawnDelay -= tickDelay; // Paper
+             } else {
+                 boolean flag = false;
+ 
+@@ -146,8 +152,7 @@ public abstract class BaseSpawner {
+                                 ((Mob) entity).finalizeSpawn(world, world.getCurrentDifficultyAt(entity.blockPosition()), MobSpawnType.SPAWNER, (SpawnGroupData) null, (CompoundTag) null);
+                             }
+                             // Spigot Start
+-                            if ( entityinsentient.level.spigotConfig.nerfSpawnerMobs )
+-                            {
+                            if (entityinsentient.level.spigotConfig.nerfSpawnerMobs) {
+                                 entityinsentient.aware = false;
+                             }
+                             // Spigot End
--- a/patches/server/0038-Implement-PlayerLocaleChangeEvent.patch
+++ b/patches/server/0038-Implement-PlayerLocaleChangeEvent.patch
@ -0,0 +1,48 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Isaac Moore <rmsy@me.com>
+Date: Tue, 19 Apr 2016 14:09:31 -0500
+Subject: [PATCH] Implement PlayerLocaleChangeEvent
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 88b6be62678fc09b5a39db28c6d71cc31b16dbcd..352bfe795aea26307de9c998d67a43af3e4845f0 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -1727,7 +1727,7 @@ public class ServerPlayer extends Player {
+         return s;
+     }
+ 
+-    public String locale = "en_us"; // CraftBukkit - add, lowercase
+    public String locale = null; // CraftBukkit - add, lowercase // Paper - default to null
+     public java.util.Locale adventure$locale = java.util.Locale.US; // Paper
+     public void updateOptions(ServerboundClientInformationPacket packet) {
+         // CraftBukkit start
+@@ -1735,9 +1735,10 @@ public class ServerPlayer extends Player {
+             PlayerChangedMainHandEvent event = new PlayerChangedMainHandEvent(this.getBukkitEntity(), getMainArm() == HumanoidArm.LEFT ? MainHand.LEFT : MainHand.RIGHT);
+             this.server.server.getPluginManager().callEvent(event);
+         }
+-        if (!this.locale.equals(packet.language)) {
+        if (this.locale == null || !this.locale.equals(packet.language)) { // Paper - check for null
+             PlayerLocaleChangeEvent event = new PlayerLocaleChangeEvent(this.getBukkitEntity(), packet.language);
+             this.server.server.getPluginManager().callEvent(event);
+            this.server.server.getPluginManager().callEvent(new com.destroystokyo.paper.event.player.PlayerLocaleChangeEvent(this.getBukkitEntity(), this.locale, packet.language)); // Paper
+         }
+         this.locale = packet.language;
+         // Paper start
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 22c317d3762b9e2d8f70bd413555507c68b0cae4..60807ed83e4240cdf1e05654d24c55313aba813f 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -1778,8 +1778,10 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+ 
+     @Override
+     public String getLocale() {
+-        return this.getHandle().locale;
+-
+        // Paper start - Locale change event
+        final String locale = this.getHandle().locale;
+        return locale != null ? locale : "en_us";
+        // Paper end
+     }
+ 
+     // Paper start
--- a/patches/server/0039-Per-Player-View-Distance-API-placeholders.patch
+++ b/patches/server/0039-Per-Player-View-Distance-API-placeholders.patch
@ -0,0 +1,98 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach@zachbr.io>
+Date: Mon, 6 May 2019 01:29:25 -0400
+Subject: [PATCH] Per-Player View Distance API placeholders
+
+I hope to look at this more in-depth soon. It appears doable.
+However this should not block the update.
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 352bfe795aea26307de9c998d67a43af3e4845f0..4689d52cd314a607d17be3657099157e95f34d47 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -167,6 +167,8 @@ import org.bukkit.inventory.MainHand;
+ 
+ public class ServerPlayer extends Player {
+ 
+    public final int getViewDistance() { return this.getLevel().getChunkSource().chunkMap.viewDistance - 1; } // Paper - placeholder
+
+     private static final Logger LOGGER = LogManager.getLogger();
+     private static final int NEUTRAL_MOB_DEATH_NOTIFICATION_RADII_XZ = 32;
+     private static final int NEUTRAL_MOB_DEATH_NOTIFICATION_RADII_Y = 10;
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index 277b946bec2cfd8cfb4054504133f6ab9059ba8c..a465ef627169e62132287cded07efb5b05e1ed36 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -1750,6 +1750,31 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+     public int getSimulationDistance() {
+         return world.spigotConfig.simulationDistance;
+     }
+
+    @Override
+    public void setViewDistance(int viewDistance) {
+        throw new UnsupportedOperationException(); //TODO
+    }
+
+    @Override
+    public int getNoTickViewDistance() {
+        throw new UnsupportedOperationException(); //TODO
+    }
+
+    @Override
+    public void setNoTickViewDistance(int viewDistance) {
+        throw new UnsupportedOperationException(); //TODO
+    }
+
+    @Override
+    public int getSendViewDistance() {
+        throw new UnsupportedOperationException(); //TODO
+    }
+
+    @Override
+    public void setSendViewDistance(int viewDistance) {
+        throw new UnsupportedOperationException(); //TODO
+    }
+     // Spigot end
+ 
+     // Spigot start
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 60807ed83e4240cdf1e05654d24c55313aba813f..4fc2310287c2f0d366ac9ad23607125541a3c8bb 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -377,6 +377,36 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+             connection.disconnect(message == null ? net.kyori.adventure.text.Component.empty() : message);
+         }
+     }
+
+    @Override
+    public int getViewDistance() {
+        throw new NotImplementedException("Per-Player View Distance APIs need further understanding to properly implement (There are per world view distances though!)"); // TODO
+    }
+
+    @Override
+    public void setViewDistance(int viewDistance) {
+        throw new NotImplementedException("Per-Player View Distance APIs need further understanding to properly implement (There are per world view distances though!)"); // TODO
+    }
+
+    @Override
+    public int getNoTickViewDistance() {
+        throw new NotImplementedException("Per-Player View Distance APIs need further understanding to properly implement (There are per world view distances though!)"); // TODO
+    }
+
+    @Override
+    public void setNoTickViewDistance(int viewDistance) {
+        throw new NotImplementedException("Per-Player View Distance APIs need further understanding to properly implement (There are per world view distances though!)"); // TODO
+    }
+
+    @Override
+    public int getSendViewDistance() {
+        throw new NotImplementedException("Per-Player View Distance APIs need further understanding to properly implement (There are per world view distances though!)"); // TODO
+    }
+
+    @Override
+    public void setSendViewDistance(int viewDistance) {
+        throw new NotImplementedException("Per-Player View Distance APIs need further understanding to properly implement (There are per world view distances though!)"); // TODO
+    }
+     // Paper end
+ 
+     @Override
--- a/patches/server/0040-Add-BeaconEffectEvent.patch
+++ b/patches/server/0040-Add-BeaconEffectEvent.patch
@ -0,0 +1,62 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Byteflux <byte@byteflux.net>
+Date: Wed, 2 Mar 2016 23:30:53 -0600
+Subject: [PATCH] Add BeaconEffectEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
+index f51c5c07f8f877f778535ee2d0ecc9dff01cca0c..76a401bcfdacded2137142ed38d739ed65d9fae6 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
+@@ -42,6 +42,10 @@ import net.minecraft.world.phys.AABB;
+ import org.bukkit.craftbukkit.potion.CraftPotionUtil;
+ import org.bukkit.potion.PotionEffect;
+ // CraftBukkit end
+// Paper start
+import org.bukkit.craftbukkit.event.CraftEventFactory;
+import com.destroystokyo.paper.event.block.BeaconEffectEvent;
+// Paper end
+ 
+ public class BeaconBlockEntity extends BlockEntity implements MenuProvider {
+ 
+@@ -273,15 +277,23 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider {
+         }
+     }
+ 
+-    private static void applyEffect(List list, MobEffect mobeffectlist, int j, int b0) {
+-        {
+    private static void applyEffect(List list, MobEffect effects, int i, int b0, boolean isPrimary, BlockPos worldPosition) { // Paper - BeaconEffectEvent
+        if (!list.isEmpty()) { // Paper - BeaconEffectEvent
+             Iterator iterator = list.iterator();
+ 
+             Player entityhuman;
+            // Paper start - BeaconEffectEvent
+            org.bukkit.block.Block block = ((Player) list.get(0)).level.getWorld().getBlockAt(worldPosition.getX(), worldPosition.getY(), worldPosition.getZ());
+            PotionEffect effect = CraftPotionUtil.toBukkit(new MobEffectInstance(effects, i, b0, true, true));
+            // Paper end
+ 
+             while (iterator.hasNext()) {
+-                entityhuman = (Player) iterator.next();
+-                entityhuman.addEffect(new MobEffectInstance(mobeffectlist, j, b0, true, true), org.bukkit.event.entity.EntityPotionEffectEvent.Cause.BEACON);
+                // Paper start - BeaconEffectEvent
+                entityhuman = (ServerPlayer) iterator.next();
+                BeaconEffectEvent event = new BeaconEffectEvent(block, effect, (org.bukkit.entity.Player) entityhuman.getBukkitEntity(), isPrimary);
+                if (CraftEventFactory.callEvent(event).isCancelled()) continue;
+                entityhuman.addEffect(new MobEffectInstance(CraftPotionUtil.fromBukkit(event.getEffect())), org.bukkit.event.entity.EntityPotionEffectEvent.Cause.BEACON);
+                // Paper end
+             }
+         }
+     }
+@@ -304,10 +316,10 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider {
+             int j = BeaconBlockEntity.getLevel(beaconLevel);
+             List list = BeaconBlockEntity.getHumansInRange(world, pos, beaconLevel);
+ 
+-            BeaconBlockEntity.applyEffect(list, primaryEffect, j, b0);
+            BeaconBlockEntity.applyEffect(list, primaryEffect, j, b0, true, pos); // Paper - BeaconEffectEvent
+ 
+             if (BeaconBlockEntity.hasSecondaryEffect(beaconLevel, primaryEffect, secondaryEffect)) {
+-                BeaconBlockEntity.applyEffect(list, secondaryEffect, j, 0);
+                BeaconBlockEntity.applyEffect(list, secondaryEffect, j, 0, false, pos); // Paper - BeaconEffectEvent
+             }
+         }
+ 
--- a/patches/server/0041-Configurable-container-update-tick-rate.patch
+++ b/patches/server/0041-Configurable-container-update-tick-rate.patch
@ -0,0 +1,46 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Sudzzy <originmc@outlook.com>
+Date: Wed, 2 Mar 2016 23:34:44 -0600
+Subject: [PATCH] Configurable container update tick rate
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index cff814a123e02aea96197c1be092c210c2fcf781..0f93c6ba2bc1b6207f8a5c3f9a39cb086797e800 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -222,4 +222,9 @@ public class PaperWorldConfig {
+     private void mobSpawnerTickRate() {
+         mobSpawnerTickRate = getInt("mob-spawner-tick-rate", 1);
+     }
+
+    public int containerUpdateTickRate;
+    private void containerUpdateTickRate() {
+        containerUpdateTickRate = getInt("container-update-tick-rate", 1);
+    }
+ }
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 4689d52cd314a607d17be3657099157e95f34d47..3a97690a1e65db9a1c184fa4df5899cfda3d44bc 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -220,6 +220,7 @@ public class ServerPlayer extends Player {
+     private int containerCounter;
+     public int latency;
+     public boolean wonGame;
+    private int containerUpdateDelay; // Paper
+ 
+     // CraftBukkit start
+     public String displayName;
+@@ -591,7 +592,12 @@ public class ServerPlayer extends Player {
+             --this.invulnerableTime;
+         }
+ 
+-        this.containerMenu.broadcastChanges();
+        // Paper start - Configurable container update tick rate
+        if (--containerUpdateDelay <= 0) {
+            this.containerMenu.broadcastChanges();
+            containerUpdateDelay = level.paperConfig.containerUpdateTickRate;
+        }
+        // Paper end
+         if (!this.level.isClientSide && !this.containerMenu.stillValid(this)) {
+             this.closeContainer();
+             this.containerMenu = this.inventoryMenu;
--- a/patches/server/0042-Use-UserCache-for-player-heads.patch
+++ b/patches/server/0042-Use-UserCache-for-player-heads.patch
@ -0,0 +1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Techcable <Techcable@outlook.com>
+Date: Wed, 2 Mar 2016 23:42:37 -0600
+Subject: [PATCH] Use UserCache for player heads
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaSkull.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaSkull.java
+index 6432f668f72c0543283b5a1439d01da81ff5b981..9405812b8c308d70de1e26ba55500301b24ecc3c 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaSkull.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaSkull.java
+@@ -168,7 +168,13 @@ class CraftMetaSkull extends CraftMetaItem implements SkullMeta {
+         if (name == null) {
+             this.setProfile(null);
+         } else {
+-            this.setProfile(new GameProfile(null, name));
+            // Paper start - Use Online Players Skull
+            GameProfile newProfile = null;
+            net.minecraft.server.level.ServerPlayer player = net.minecraft.server.MinecraftServer.getServer().getPlayerList().getPlayerByName(name);
+            if (player != null) newProfile = player.getGameProfile();
+            if (newProfile == null) newProfile = new GameProfile(null, name);
+            this.setProfile(newProfile);
+            // Paper end
+         }
+ 
+         return true;
--- a/patches/server/0043-Disable-spigot-tick-limiters.patch
+++ b/patches/server/0043-Disable-spigot-tick-limiters.patch
@ -0,0 +1,21 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach.brown@destroystokyo.com>
+Date: Wed, 2 Mar 2016 23:45:17 -0600
+Subject: [PATCH] Disable spigot tick limiters
+
+
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index d8da1dfdc58726eda01e1bfb059c144e98ce7fe8..8e06ce1d838b9eaa71a699a999e91dcd5d596a7b 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -703,9 +703,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+         // Spigot start
+         // Iterator iterator = this.blockEntityTickers.iterator();
+         int tilesThisCycle = 0;
+-        for (this.tileLimiter.initTick();
+-                tilesThisCycle < this.blockEntityTickers.size() && (tilesThisCycle % 10 != 0 || this.tileLimiter.shouldContinue());
+-                this.tileTickPosition++, tilesThisCycle++) {
+        for (tileTickPosition = 0; tileTickPosition < this.blockEntityTickers.size(); tileTickPosition++) { // Paper - Disable tick limiters
+             this.tileTickPosition = (this.tileTickPosition < this.blockEntityTickers.size()) ? this.tileTickPosition : 0;
+             TickingBlockEntity tickingblockentity = (TickingBlockEntity) this.blockEntityTickers.get(tileTickPosition);
+             // Spigot start
--- a/patches/server/0044-Add-PlayerInitialSpawnEvent.patch
+++ b/patches/server/0044-Add-PlayerInitialSpawnEvent.patch
@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Steve Anton <anxuiz.nx@gmail.com>
+Date: Thu, 3 Mar 2016 00:09:38 -0600
+Subject: [PATCH] Add PlayerInitialSpawnEvent
+
+For modifying a player's initial spawn location as they join the server
+
+This is a duplicate API from spigot, so use our duplicate subclass and
+improve setPosition to use raw
+
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 1cfeaeeddbc97e28f51c79ab3082a5d387daaead..db52eb4df917c9ad3ba807e40f1d44ea9c52aae8 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -217,7 +217,7 @@ public abstract class PlayerList {
+ 
+         // Spigot start - spawn location event
+         Player spawnPlayer = player.getBukkitEntity();
+-        org.spigotmc.event.player.PlayerSpawnLocationEvent ev = new org.spigotmc.event.player.PlayerSpawnLocationEvent(spawnPlayer, spawnPlayer.getLocation());
+        org.spigotmc.event.player.PlayerSpawnLocationEvent ev = new com.destroystokyo.paper.event.player.PlayerInitialSpawnEvent(spawnPlayer, spawnPlayer.getLocation()); // Paper use our duplicate event
+         this.cserver.getPluginManager().callEvent(ev);
+ 
+         Location loc = ev.getSpawnLocation();
+@@ -225,7 +225,10 @@ public abstract class PlayerList {
+ 
+         player.spawnIn(worldserver1);
+         player.gameMode.setLevel((ServerLevel) player.level);
+-        player.absMoveTo(loc.getX(), loc.getY(), loc.getZ(), loc.getYaw(), loc.getPitch());
+        // Paper start - set raw so we aren't fully joined to the world (not added to chunk or world)
+        player.setPosRaw(loc.getX(), loc.getY(), loc.getZ());
+        player.setRot(loc.getYaw(), loc.getPitch());
+        // Paper end
+         // Spigot end
+ 
+         // CraftBukkit - Moved message to after join
--- a/patches/server/0045-Configurable-Disabling-Cat-Chest-Detection.patch
+++ b/patches/server/0045-Configurable-Disabling-Cat-Chest-Detection.patch
@ -0,0 +1,37 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Thu, 3 Mar 2016 01:13:45 -0600
+Subject: [PATCH] Configurable Disabling Cat Chest Detection
+
+Offers a gameplay feature to stop cats from blocking chests
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index 0f93c6ba2bc1b6207f8a5c3f9a39cb086797e800..0ccb86aed122ecd54a460db426163d0d2639c609 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -227,4 +227,9 @@ public class PaperWorldConfig {
+     private void containerUpdateTickRate() {
+         containerUpdateTickRate = getInt("container-update-tick-rate", 1);
+     }
+
+    public boolean disableChestCatDetection;
+    private void disableChestCatDetection() {
+        disableChestCatDetection = getBoolean("game-mechanics.disable-chest-cat-detection", false);
+    }
+ }
+diff --git a/src/main/java/net/minecraft/world/level/block/ChestBlock.java b/src/main/java/net/minecraft/world/level/block/ChestBlock.java
+index 306fd5b1893d8a68af2073978bab7e590e936ef5..db726697b00afdee6078849fd224263483349912 100644
+--- a/src/main/java/net/minecraft/world/level/block/ChestBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/ChestBlock.java
+@@ -362,6 +362,11 @@ public class ChestBlock extends AbstractChestBlock<ChestBlockEntity> implements
+     }
+ 
+     private static boolean isCatSittingOnChest(LevelAccessor world, BlockPos pos) {
+        // Paper start - Option to disable chest cat detection
+        if (((Level) world).paperConfig.disableChestCatDetection) {
+            return false;
+        }
+        // Paper end
+         List<Cat> list = world.getEntitiesOfClass(Cat.class, new AABB((double) pos.getX(), (double) (pos.getY() + 1), (double) pos.getZ(), (double) (pos.getX() + 1), (double) (pos.getY() + 2), (double) (pos.getZ() + 1)));
+ 
+         if (!list.isEmpty()) {
--- a/patches/server/0046-Ensure-commands-are-not-ran-async.patch
+++ b/patches/server/0046-Ensure-commands-are-not-ran-async.patch
@ -0,0 +1,118 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Thu, 3 Mar 2016 01:17:12 -0600
+Subject: [PATCH] Ensure commands are not ran async
+
+Plugins calling Player.chat("/foo") or Server.dispatchCommand() could
+trigger the server to execute a command while on another thread.
+
+These commands would then process EXPECTING to be on the main thread, leaving to
+very hard to trace concurrency issues.
+
+This change will synchronize the command execution back to the main thread, causing a
+big slowdown in execution but throwing an exception at same time to raise awareness
+that it is happening so that plugin authors can fix their code to stop executing commands async.
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 11687dc95f606750e9042b043f333e3b00eb171c..38909ef14fcfd4b93d83512f4cacbe2c3fe431a1 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1852,6 +1852,29 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
+         }
+ 
+         if (!async && s.startsWith("/")) {
+            // Paper Start
+            if (!org.spigotmc.AsyncCatcher.shuttingDown && !org.bukkit.Bukkit.isPrimaryThread()) {
+                final String fCommandLine = s;
+                MinecraftServer.LOGGER.log(org.apache.logging.log4j.Level.ERROR, "Command Dispatched Async: " + fCommandLine);
+                MinecraftServer.LOGGER.log(org.apache.logging.log4j.Level.ERROR, "Please notify author of plugin causing this execution to fix this bug! see: http://bit.ly/1oSiM6C", new Throwable());
+                Waitable wait = new Waitable() {
+                    @Override
+                    protected Object evaluate() {
+                        chat(fCommandLine, false);
+                        return null;
+                    }
+                };
+                server.processQueue.add(wait);
+                try {
+                    wait.get();
+                    return;
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt(); // This is proper habit for java. If we aren't handling it, pass it on!
+                } catch (Exception e) {
+                    throw new RuntimeException("Exception processing chat command", e.getCause());
+                }
+            }
+            // Paper End
+             this.handleCommand(s);
+         } else if (this.player.getChatVisibility() == ChatVisiblity.SYSTEM) {
+             // Do nothing, this is coming from a plugin
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index c365a1cd02dbb8a248ba6247d3feb9553a22dfe6..7292cc72e9d8227b4354f1d91246d27d639c5abb 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -796,6 +796,28 @@ public final class CraftServer implements Server {
+         Validate.notNull(commandLine, "CommandLine cannot be null");
+         org.spigotmc.AsyncCatcher.catchOp("command dispatch"); // Spigot
+ 
+        // Paper Start
+        if (!org.spigotmc.AsyncCatcher.shuttingDown && !Bukkit.isPrimaryThread()) {
+            final CommandSender fSender = sender;
+            final String fCommandLine = commandLine;
+            Bukkit.getLogger().log(Level.SEVERE, "Command Dispatched Async: " + commandLine);
+            Bukkit.getLogger().log(Level.SEVERE, "Please notify author of plugin causing this execution to fix this bug! see: http://bit.ly/1oSiM6C", new Throwable());
+            org.bukkit.craftbukkit.util.Waitable<Boolean> wait = new org.bukkit.craftbukkit.util.Waitable<Boolean>() {
+                @Override
+                protected Boolean evaluate() {
+                    return dispatchCommand(fSender, fCommandLine);
+                }
+            };
+            net.minecraft.server.MinecraftServer.getServer().processQueue.add(wait);
+            try {
+                return wait.get();
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt(); // This is proper habit for java. If we aren't handling it, pass it on!
+            } catch (Exception e) {
+                throw new RuntimeException("Exception processing dispatch command", e.getCause());
+            }
+        }
+        // Paper End
+         if (this.commandMap.dispatch(sender, commandLine)) {
+             return true;
+         }
+diff --git a/src/main/java/org/bukkit/craftbukkit/util/ServerShutdownThread.java b/src/main/java/org/bukkit/craftbukkit/util/ServerShutdownThread.java
+index 19c44daaa407b7c1c7a7ffe56fef8c8814c6d5b2..6a073a9dc44d93eba296a0e18a9c7be8a7881725 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/ServerShutdownThread.java
+++ b/src/main/java/org/bukkit/craftbukkit/util/ServerShutdownThread.java
+@@ -13,6 +13,7 @@ public class ServerShutdownThread extends Thread {
+     public void run() {
+         try {
+             org.spigotmc.AsyncCatcher.enabled = false; // Spigot
+            org.spigotmc.AsyncCatcher.shuttingDown = true; // Paper
+             this.server.close();
+         } finally {
+             try {
+diff --git a/src/main/java/org/spigotmc/AsyncCatcher.java b/src/main/java/org/spigotmc/AsyncCatcher.java
+index 78669fa035b7537ff7e533cf32aaf2995625424f..7585a30e8f063ac2656b5de519b1e9edaceffbc7 100644
+--- a/src/main/java/org/spigotmc/AsyncCatcher.java
+++ b/src/main/java/org/spigotmc/AsyncCatcher.java
+@@ -6,6 +6,7 @@ public class AsyncCatcher
+ {
+ 
+     public static boolean enabled = true;
+    public static boolean shuttingDown = false; // Paper
+ 
+     public static void catchOp(String reason)
+     {
+diff --git a/src/main/java/org/spigotmc/RestartCommand.java b/src/main/java/org/spigotmc/RestartCommand.java
+index 882e93ad4471e3688f2fcfb1e6f16926786ee5e7..94d8ba376cd1f024b244654cac9bb62bb19e3060 100644
+--- a/src/main/java/org/spigotmc/RestartCommand.java
+++ b/src/main/java/org/spigotmc/RestartCommand.java
+@@ -43,6 +43,7 @@ public class RestartCommand extends Command
+     private static void restart(final String restartScript)
+     {
+         AsyncCatcher.enabled = false; // Disable async catcher incase it interferes with us
+        org.spigotmc.AsyncCatcher.shuttingDown = true; // Paper
+         try
+         {
+             String[] split = restartScript.split( " " );
--- a/patches/server/0047-All-chunks-are-slime-spawn-chunks-toggle.patch
+++ b/patches/server/0047-All-chunks-are-slime-spawn-chunks-toggle.patch
@ -0,0 +1,33 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: vemacs <d@nkmem.es>
+Date: Thu, 3 Mar 2016 01:19:22 -0600
+Subject: [PATCH] All chunks are slime spawn chunks toggle
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index 0ccb86aed122ecd54a460db426163d0d2639c609..84df54523eada327033bb8821a7009df62dc7bca 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -232,4 +232,9 @@ public class PaperWorldConfig {
+     private void disableChestCatDetection() {
+         disableChestCatDetection = getBoolean("game-mechanics.disable-chest-cat-detection", false);
+     }
+
+    public boolean allChunksAreSlimeChunks;
+    private void allChunksAreSlimeChunks() {
+        allChunksAreSlimeChunks = getBoolean("all-chunks-are-slime-chunks", false);
+    }
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Slime.java b/src/main/java/net/minecraft/world/entity/monster/Slime.java
+index 19a2702d9053037203c192d7f26f3c9afbe6f782..11aefbf65b0e63777d6ed5bfdb18c7f7df30fc0e 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Slime.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Slime.java
+@@ -323,7 +323,7 @@ public class Slime extends Mob implements Enemy {
+             }
+ 
+             ChunkPos chunkcoordintpair = new ChunkPos(pos);
+-            boolean flag = WorldgenRandom.seedSlimeChunk(chunkcoordintpair.x, chunkcoordintpair.z, ((WorldGenLevel) world).getSeed(), world.getMinecraftWorld().spigotConfig.slimeSeed).nextInt(10) == 0; // Spigot
+            boolean flag = world.getMinecraftWorld().paperConfig.allChunksAreSlimeChunks || WorldgenRandom.seedSlimeChunk(chunkcoordintpair.x, chunkcoordintpair.z, ((WorldGenLevel) world).getSeed(), world.getMinecraftWorld().spigotConfig.slimeSeed).nextInt(10) == 0; // Spigot // Paper
+ 
+             if (random.nextInt(10) == 0 && flag && pos.getY() < 40) {
+                 return checkMobSpawnRules(type, world, spawnReason, pos, random);
--- a/patches/server/0048-Expose-server-CommandMap.patch
+++ b/patches/server/0048-Expose-server-CommandMap.patch
@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: kashike <kashike@vq.lc>
+Date: Thu, 3 Mar 2016 02:15:57 -0600
+Subject: [PATCH] Expose server CommandMap
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 7292cc72e9d8227b4354f1d91246d27d639c5abb..c66577e495b59acd9bc666e1291c6417cfa9e477 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -1934,6 +1934,7 @@ public final class CraftServer implements Server {
+         return this.helpMap;
+     }
+ 
+    @Override // Paper - add override
+     public SimpleCommandMap getCommandMap() {
+         return this.commandMap;
+     }
--- a/patches/server/0049-Be-a-bit-more-informative-in-maxHealth-exception.patch
+++ b/patches/server/0049-Be-a-bit-more-informative-in-maxHealth-exception.patch
@ -0,0 +1,22 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: kashike <kashike@vq.lc>
+Date: Thu, 3 Mar 2016 02:18:39 -0600
+Subject: [PATCH] Be a bit more informative in maxHealth exception
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index a6192a7edd94e63c568ca8196e0ed9fa993da6bb..1d3cd79634366718cd354cd2f55c6fc974ad3525 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -99,7 +99,10 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+     public void setHealth(double health) {
+         health = (float) health;
+         if ((health < 0) || (health > this.getMaxHealth())) {
+-            throw new IllegalArgumentException("Health must be between 0 and " + this.getMaxHealth() + "(" + health + ")");
+            // Paper - Be more informative
+            throw new IllegalArgumentException("Health must be between 0 and " + getMaxHealth() + ", but was " + health
+                + ". (attribute base value: " + this.getHandle().getAttribute(Attributes.MAX_HEALTH).getBaseValue()
+                + (this instanceof CraftPlayer ? ", player: " + this.getName() + ')' : ')'));
+         }
+ 
+         // during world generation, we don't want to run logic for dropping items and xp
--- a/patches/server/0050-Ensure-inv-drag-is-in-bounds.patch
+++ b/patches/server/0050-Ensure-inv-drag-is-in-bounds.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Joseph Hirschfeld <joe@ibj.io>
+Date: Thu, 3 Mar 2016 02:33:53 -0600
+Subject: [PATCH] Ensure inv drag is in bounds
+
+
+diff --git a/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java b/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+index ccb6ff0cf31e619ce555d404a6454750f0958f12..36834f30ccefd229df4da2dbc7b22edcb83429c3 100644
+--- a/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+@@ -406,7 +406,7 @@ public abstract class AbstractContainerMenu {
+                     this.resetQuickCraft();
+                 }
+             } else if (this.quickcraftStatus == 1) {
+-                slot = (Slot) this.slots.get(slotIndex);
+                slot = slotIndex < this.slots.size() ? this.slots.get(slotIndex) : null; // Paper - Ensure drag in bounds
+                 itemstack = this.getCarried();
+                 if (AbstractContainerMenu.canItemQuickReplace(slot, itemstack, true) && slot.mayPlace(itemstack) && (this.quickcraftType == 2 || itemstack.getCount() > this.quickcraftSlots.size()) && this.canDragTo(slot)) {
+                     this.quickcraftSlots.add(slot);
--- a/patches/server/0051-Player-Tab-List-and-Title-APIs.patch
+++ b/patches/server/0051-Player-Tab-List-and-Title-APIs.patch
@ -0,0 +1,176 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Techcable <Techcable@outlook.com>
+Date: Thu, 3 Mar 2016 02:32:10 -0600
+Subject: [PATCH] Player Tab List and Title APIs
+
+
+diff --git a/src/main/java/net/minecraft/network/FriendlyByteBuf.java b/src/main/java/net/minecraft/network/FriendlyByteBuf.java
+index 0053474ab7c25de6d86c16e3079feb21f75d1c11..303b877bc467de7c046cc221d061fac841c1d9f3 100644
+--- a/src/main/java/net/minecraft/network/FriendlyByteBuf.java
+++ b/src/main/java/net/minecraft/network/FriendlyByteBuf.java
+@@ -356,6 +356,11 @@ public class FriendlyByteBuf extends ByteBuf {
+     public FriendlyByteBuf writeComponent(final net.kyori.adventure.text.Component component) {
+         return this.writeUtf(PaperAdventure.asJsonString(component, this.adventure$locale), 262144);
+     }
+
+    @Deprecated
+    public FriendlyByteBuf writeComponent(final net.md_5.bungee.api.chat.BaseComponent[] component) {
+        return this.writeUtf(net.md_5.bungee.chat.ComponentSerializer.toString(component), 262144);
+    }
+     // Paper end
+ 
+     public FriendlyByteBuf writeComponent(Component text) {
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetSubtitleTextPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetSubtitleTextPacket.java
+index c44a276d201fdfa5144d45d319d7761583c60639..f68a1a6dc6add9496e25cb52c318e086e356e2bb 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetSubtitleTextPacket.java
+++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetSubtitleTextPacket.java
+@@ -7,6 +7,7 @@ import net.minecraft.network.protocol.Packet;
+ public class ClientboundSetSubtitleTextPacket 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 ClientboundSetSubtitleTextPacket(Component subtitle) {
+         this.text = subtitle;
+@@ -21,6 +22,8 @@ public class ClientboundSetSubtitleTextPacket implements Packet<ClientGamePacket
+         // 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/net/minecraft/network/protocol/game/ClientboundSetTitleTextPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetTitleTextPacket.java
+index bd808eb312ade7122973a47f4b96505829511da5..bf0f9cab7c66c089f35b851e799ba4a43420b437 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetTitleTextPacket.java
+++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetTitleTextPacket.java
+@@ -7,6 +7,7 @@ import net.minecraft.network.protocol.Packet;
+ public class ClientboundSetTitleTextPacket 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 ClientboundSetTitleTextPacket(Component title) {
+         this.text = title;
+@@ -21,6 +22,8 @@ public class ClientboundSetTitleTextPacket implements Packet<ClientGamePacketLis
+         // 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 4fc2310287c2f0d366ac9ad23607125541a3c8bb..b7dae85766f3077f92ab014562cf0143bff7c9d3 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -1,5 +1,6 @@
+ package org.bukkit.craftbukkit.entity;
+ 
+import com.destroystokyo.paper.Title;
+ import com.google.common.base.Preconditions;
+ import com.google.common.collect.ImmutableSet;
+ import com.google.common.io.BaseEncoding;
+@@ -248,6 +249,100 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         }
+     }
+ 
+    // Paper start
+    @Override
+    public void setPlayerListHeaderFooter(BaseComponent[] header, BaseComponent[] footer) {
+         if (header != null) {
+             String headerJson = net.md_5.bungee.chat.ComponentSerializer.toString(header);
+             playerListHeader = net.kyori.adventure.text.serializer.gson.GsonComponentSerializer.gson().deserialize(headerJson);
+         } else {
+             playerListHeader = null;
+         }
+
+        if (footer != null) {
+             String footerJson = net.md_5.bungee.chat.ComponentSerializer.toString(footer);
+             playerListFooter = net.kyori.adventure.text.serializer.gson.GsonComponentSerializer.gson().deserialize(footerJson);
+        } else {
+             playerListFooter = null;
+         }
+
+         updatePlayerListHeaderFooter();
+    }
+
+    @Override
+    public void setPlayerListHeaderFooter(BaseComponent header, BaseComponent footer) {
+        this.setPlayerListHeaderFooter(header == null ? null : new BaseComponent[]{header},
+                footer == null ? null : new BaseComponent[]{footer});
+    }
+
+
+    @Override
+    public void setTitleTimes(int fadeInTicks, int stayTicks, int fadeOutTicks) {
+        getHandle().connection.send(new ClientboundSetTitlesAnimationPacket(fadeInTicks, stayTicks, fadeOutTicks));
+    }
+
+    @Override
+    public void setSubtitle(BaseComponent[] subtitle) {
+        final ClientboundSetSubtitleTextPacket packet = new ClientboundSetSubtitleTextPacket((net.minecraft.network.chat.Component) null);
+        packet.components = subtitle;
+        getHandle().connection.send(packet);
+    }
+
+    @Override
+    public void setSubtitle(BaseComponent subtitle) {
+        setSubtitle(new BaseComponent[]{subtitle});
+    }
+
+    @Override
+    public void showTitle(BaseComponent[] title) {
+        final ClientboundSetTitleTextPacket packet = new ClientboundSetTitleTextPacket((net.minecraft.network.chat.Component) null);
+        packet.components = title;
+        getHandle().connection.send(packet);
+    }
+
+    @Override
+    public void showTitle(BaseComponent title) {
+        showTitle(new BaseComponent[]{title});
+    }
+
+    @Override
+    public void showTitle(BaseComponent[] title, BaseComponent[] subtitle, int fadeInTicks, int stayTicks, int fadeOutTicks) {
+        setTitleTimes(fadeInTicks, stayTicks, fadeOutTicks);
+        setSubtitle(subtitle);
+        showTitle(title);
+    }
+
+    @Override
+    public void showTitle(BaseComponent title, BaseComponent subtitle, int fadeInTicks, int stayTicks, int fadeOutTicks) {
+        setTitleTimes(fadeInTicks, stayTicks, fadeOutTicks);
+        setSubtitle(subtitle);
+        showTitle(title);
+    }
+
+    @Override
+    public void sendTitle(Title title) {
+        Preconditions.checkNotNull(title, "Title is null");
+        setTitleTimes(title.getFadeIn(), title.getStay(), title.getFadeOut());
+        setSubtitle(title.getSubtitle() == null ? new BaseComponent[0] : title.getSubtitle());
+        showTitle(title.getTitle());
+    }
+
+    @Override
+    public void updateTitle(Title title) {
+        Preconditions.checkNotNull(title, "Title is null");
+        setTitleTimes(title.getFadeIn(), title.getStay(), title.getFadeOut());
+        if (title.getSubtitle() != null) {
+            setSubtitle(title.getSubtitle());
+        }
+        showTitle(title.getTitle());
+    }
+
+    @Override
+    public void hideTitle() {
+        getHandle().connection.send(new ClientboundClearTitlesPacket(false));
+    }
+    // Paper end
+
+     @Override
+     public String getDisplayName() {
+         if(true) return io.papermc.paper.adventure.DisplayNames.getLegacy(this); // Paper
--- a/patches/server/0052-Add-configurable-portal-search-radius.patch
+++ b/patches/server/0052-Add-configurable-portal-search-radius.patch
@ -0,0 +1,56 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Joseph Hirschfeld <joe@ibj.io>
+Date: Thu, 3 Mar 2016 02:46:17 -0600
+Subject: [PATCH] Add configurable portal search radius
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index 84df54523eada327033bb8821a7009df62dc7bca..304883dc18bab3bf4740006a5e6d7c58bab12348 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -237,4 +237,13 @@ public class PaperWorldConfig {
+     private void allChunksAreSlimeChunks() {
+         allChunksAreSlimeChunks = getBoolean("all-chunks-are-slime-chunks", false);
+     }
+
+    public int portalSearchRadius;
+    public int portalCreateRadius;
+    public boolean portalSearchVanillaDimensionScaling;
+    private void portalSearchRadius() {
+        portalSearchRadius = getInt("portal-search-radius", 128);
+        portalCreateRadius = getInt("portal-create-radius", 16);
+        portalSearchVanillaDimensionScaling = getBoolean("portal-search-vanilla-dimension-scaling", true);
+    }
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 6bc8c8e15e66cd54cbb6ebc6d09a6fe8652b5d18..8161cbd3cfed89bee74209c718d0ceff2b401890 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -2939,7 +2939,13 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, i
+                 double d0 = DimensionType.getTeleportationScale(this.level.dimensionType(), destination.dimensionType());
+                 BlockPos blockposition = worldborder.clampToBounds(this.getX() * d0, this.getY(), this.getZ() * d0);
+                 // CraftBukkit start
+-                CraftPortalEvent event = this.callPortalEvent(this, destination, blockposition, PlayerTeleportEvent.TeleportCause.NETHER_PORTAL, flag2 ? 16 : 128, 16);
+                // Paper start
+                int portalSearchRadius = destination.paperConfig.portalSearchRadius;
+                if (level.paperConfig.portalSearchVanillaDimensionScaling && flag2) { // == THE_NETHER
+                    portalSearchRadius = (int) (portalSearchRadius / destination.dimensionType().coordinateScale());
+                }
+                // Paper end
+                CraftPortalEvent event = this.callPortalEvent(this, destination, blockposition, PlayerTeleportEvent.TeleportCause.NETHER_PORTAL, portalSearchRadius, destination.paperConfig.portalCreateRadius); // Paper start - configurable portal radius
+                 if (event == null) {
+                     return null;
+                 }
+diff --git a/src/main/java/net/minecraft/world/level/portal/PortalForcer.java b/src/main/java/net/minecraft/world/level/portal/PortalForcer.java
+index 194465751c351a921100e621a0ef1616c7e5f3fb..80811386c1006d56824ff4d43830f2a140aaee30 100644
+--- a/src/main/java/net/minecraft/world/level/portal/PortalForcer.java
+++ b/src/main/java/net/minecraft/world/level/portal/PortalForcer.java
+@@ -43,7 +43,7 @@ public class PortalForcer {
+ 
+     public Optional<BlockUtil.FoundRectangle> findPortalAround(BlockPos blockposition, boolean destIsNether, WorldBorder worldborder) {
+         // CraftBukkit start
+-        return this.findPortalAround(blockposition, worldborder, destIsNether ? 16 : 128); // Search Radius
+        return this.findPortalAround(blockposition, worldborder, destIsNether ? level.paperConfig.portalCreateRadius : level.paperConfig.portalSearchRadius); // Search Radius // Paper - search Radius
+     }
+ 
+     public Optional<BlockUtil.FoundRectangle> findPortalAround(BlockPos blockposition, WorldBorder worldborder, int i) {
--- a/patches/server/0053-Add-velocity-warnings.patch
+++ b/patches/server/0053-Add-velocity-warnings.patch
@ -0,0 +1,88 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Joseph Hirschfeld <joe@ibj.io>
+Date: Thu, 3 Mar 2016 02:48:12 -0600
+Subject: [PATCH] Add velocity warnings
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index c66577e495b59acd9bc666e1291c6417cfa9e477..e62ee04cbe0f3281783aff8ef74d7165447b34ba 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -289,6 +289,7 @@ public final class CraftServer implements Server {
+     public boolean ignoreVanillaPermissions = false;
+     private final List<CraftPlayer> playerView;
+     public int reloadCount;
+    public static Exception excessiveVelEx; // Paper - Velocity warnings
+ 
+     static {
+         ConfigurationSerialization.registerClass(CraftOfflinePlayer.class);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index 506bc08a7aadf5246f57e6935dbaa81ca482fb9a..78b3be2ea6351cb6375b77340218615aa75b87f5 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -436,10 +436,40 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+     public void setVelocity(Vector velocity) {
+         Preconditions.checkArgument(velocity != null, "velocity");
+         velocity.checkFinite();
+        // Paper start - Warn server owners when plugins try to set super high velocities
+        if (!(this instanceof org.bukkit.entity.Projectile) && isUnsafeVelocity(velocity)) {
+            CraftServer.excessiveVelEx = new Exception("Excessive velocity set detected: tried to set velocity of entity " + entity.getScoreboardName() + " id #" + getEntityId() + " to (" + velocity.getX() + "," + velocity.getY() + "," + velocity.getZ() + ").");
+        }
+        // Paper end
+         this.entity.setDeltaMovement(CraftVector.toNMS(velocity));
+         entity.hurtMarked = true;
+     }
+ 
+    // Paper start
+    /**
+     * Checks if the given velocity is not necessarily safe in all situations.
+     * This function returning true does not mean the velocity is dangerous or to be avoided, only that it may be
+     * a detriment to performance on the server.
+     *
+     * It is not to be used as a hard rule of any sort.
+     * Paper only uses it to warn server owners in watchdog crashes.
+     *
+     * @param vel incoming velocity to check
+     * @return if the velocity has the potential to be a performance detriment
+     */
+    private static boolean isUnsafeVelocity(Vector vel) {
+        final double x = vel.getX();
+        final double y = vel.getY();
+        final double z = vel.getZ();
+
+        if (x > 4 || x < -4 || y > 4 || y < -4 || z > 4 || z < -4) {
+            return true;
+        }
+
+        return false;
+    }
+    // Paper end
+
+     @Override
+     public double getHeight() {
+         return this.getHandle().getBbHeight();
+diff --git a/src/main/java/org/spigotmc/WatchdogThread.java b/src/main/java/org/spigotmc/WatchdogThread.java
+index d5863b0b06384b25eaa33572fa02649795463ed8..2693cc933d746e40d8a47d96c6cb6799f0a2472f 100644
+--- a/src/main/java/org/spigotmc/WatchdogThread.java
+++ b/src/main/java/org/spigotmc/WatchdogThread.java
+@@ -80,7 +80,19 @@ public class WatchdogThread extends Thread
+                     log.log( Level.SEVERE, "During the run of the server, a physics stackoverflow was supressed" );
+                     log.log( Level.SEVERE, "near " + net.minecraft.world.level.Level.lastPhysicsProblem );
+                 }
+-                //
+                // Paper start - Warn in watchdog if an excessive velocity was ever set
+                if ( org.bukkit.craftbukkit.CraftServer.excessiveVelEx != null )
+                {
+                    log.log( Level.SEVERE, "------------------------------" );
+                    log.log( Level.SEVERE, "During the run of the server, a plugin set an excessive velocity on an entity" );
+                    log.log( Level.SEVERE, "This may be the cause of the issue, or it may be entirely unrelated" );
+                    log.log( Level.SEVERE, org.bukkit.craftbukkit.CraftServer.excessiveVelEx.getMessage());
+                    for ( StackTraceElement stack : org.bukkit.craftbukkit.CraftServer.excessiveVelEx.getStackTrace() )
+                    {
+                        log.log( Level.SEVERE, "\t\t" + stack );
+                    }
+                }
+                // Paper end
+                 log.log( Level.SEVERE, "------------------------------" );
+                 log.log( Level.SEVERE, "Server thread dump (Look for plugins here before reporting to Paper!):" ); // Paper
+                 WatchdogThread.dumpThread( ManagementFactory.getThreadMXBean().getThreadInfo( MinecraftServer.getServer().serverThread.getId(), Integer.MAX_VALUE ), log );
--- a/patches/server/0054-Configurable-inter-world-teleportation-safety.patch
+++ b/patches/server/0054-Configurable-inter-world-teleportation-safety.patch
@ -0,0 +1,44 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Sudzzy <originmc@outlook.com>
+Date: Thu, 3 Mar 2016 02:50:31 -0600
+Subject: [PATCH] Configurable inter-world teleportation safety
+
+People are able to abuse the way Bukkit handles teleportation across worlds since it provides a built in teleportation
+safety check.
+
+To abuse the safety check, players are required to get into a location deemed unsafe by Bukkit e.g. be within a chest
+or door block. While they are in this block, they accept a teleport request from a player within a different world. Once
+the player teleports, Minecraft will recursively search upwards for a safe location, this could eventually land within a
+player's skybase.
+
+Example setup to perform the glitch: http://puu.sh/ng3PC/cf072dcbdb.png
+The wanted destination was on top of the emerald block however the player ended on top of the diamond block.
+This only is the case if the player is teleporting between worlds.
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index 304883dc18bab3bf4740006a5e6d7c58bab12348..6d1473a5267ecd3617d76fee23527bde58283bb1 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -246,4 +246,9 @@ public class PaperWorldConfig {
+         portalCreateRadius = getInt("portal-create-radius", 16);
+         portalSearchVanillaDimensionScaling = getBoolean("portal-search-vanilla-dimension-scaling", true);
+     }
+
+    public boolean disableTeleportationSuffocationCheck;
+    private void disableTeleportationSuffocationCheck() {
+        disableTeleportationSuffocationCheck = getBoolean("disable-teleportation-suffocation-check", false);
+    }
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index b7dae85766f3077f92ab014562cf0143bff7c9d3..3c7ae0966f2e8d0ab0924047653792ac7ac75f10 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -905,7 +905,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         if (fromWorld == toWorld) {
+             entity.connection.teleport(to);
+         } else {
+-            server.getHandle().respawn(entity, toWorld, true, to, true);
+            server.getHandle().respawn(entity, toWorld, true, to, !toWorld.paperConfig.disableTeleportationSuffocationCheck); // Paper
+         }
+         return true;
+     }
--- a/patches/server/0055-Add-exception-reporting-event.patch
+++ b/patches/server/0055-Add-exception-reporting-event.patch
@ -0,0 +1,256 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Joseph Hirschfeld <joe@ibj.io>
+Date: Thu, 3 Mar 2016 03:15:41 -0600
+Subject: [PATCH] Add exception reporting event
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/ServerSchedulerReportingWrapper.java b/src/main/java/com/destroystokyo/paper/ServerSchedulerReportingWrapper.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..f699ce18ca044f813e194ef2786b7ea853ea86e7
+--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/ServerSchedulerReportingWrapper.java
+@@ -0,0 +1,38 @@
+package com.destroystokyo.paper;
+
+import com.google.common.base.Preconditions;
+import org.bukkit.craftbukkit.scheduler.CraftTask;
+import com.destroystokyo.paper.event.server.ServerExceptionEvent;
+import com.destroystokyo.paper.exception.ServerSchedulerException;
+
+/**
+ * Reporting wrapper to catch exceptions not natively
+ */
+public class ServerSchedulerReportingWrapper implements Runnable {
+
+    private final CraftTask internalTask;
+
+    public ServerSchedulerReportingWrapper(CraftTask internalTask) {
+        this.internalTask = Preconditions.checkNotNull(internalTask, "internalTask");
+    }
+
+    @Override
+    public void run() {
+        try {
+            internalTask.run();
+        } catch (RuntimeException e) {
+            internalTask.getOwner().getServer().getPluginManager().callEvent(
+                    new ServerExceptionEvent(new ServerSchedulerException(e, internalTask))
+            );
+            throw e;
+        } catch (Throwable t) {
+            internalTask.getOwner().getServer().getPluginManager().callEvent(
+                    new ServerExceptionEvent(new ServerSchedulerException(t, internalTask))
+            ); //Do not rethrow, since it is not permitted with Runnable#run
+        }
+    }
+
+    public CraftTask getInternalTask() {
+        return internalTask;
+    }
+}
+diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
+index cab03a81a97d851db61e517cfe3a43fa8afd32b2..9dd0279f9d33fabd1dc4ff029f0ad76a9cc8cb21 100644
+--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
+++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
+@@ -924,6 +924,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+                 return true;
+             } catch (Exception exception) {
+                 ChunkMap.LOGGER.error("Failed to save chunk {},{}", chunkcoordintpair.x, chunkcoordintpair.z, exception);
+                com.destroystokyo.paper.exception.ServerInternalException.reportInternalException(exception); // Paper
+                 return false;
+             }
+         }
+diff --git a/src/main/java/net/minecraft/server/players/OldUsersConverter.java b/src/main/java/net/minecraft/server/players/OldUsersConverter.java
+index 38403f62a9539382d5330f9231fe9ef618b87c21..876658b685ea09adb4c01d436da56daadb7eedaa 100644
+--- a/src/main/java/net/minecraft/server/players/OldUsersConverter.java
+++ b/src/main/java/net/minecraft/server/players/OldUsersConverter.java
+@@ -1,5 +1,6 @@
+ package net.minecraft.server.players;
+ 
+import com.destroystokyo.paper.exception.ServerInternalException;
+ import com.google.common.collect.Lists;
+ import com.google.common.collect.Maps;
+ import com.google.common.io.Files;
+@@ -363,6 +364,7 @@ public class OldUsersConverter {
+                             root = NbtIo.readCompressed(new java.io.FileInputStream(file5));
+                         } catch (Exception exception) {
+                             exception.printStackTrace();
+                            ServerInternalException.reportInternalException(exception); // Paper
+                         }
+ 
+                         if (root != null) {
+@@ -376,6 +378,7 @@ public class OldUsersConverter {
+                                 NbtIo.writeCompressed(root, new java.io.FileOutputStream(file2));
+                             } catch (Exception exception) {
+                                 exception.printStackTrace();
+                                ServerInternalException.reportInternalException(exception); // Paper
+                             }
+                        }
+                         // CraftBukkit end
+diff --git a/src/main/java/net/minecraft/world/entity/ai/village/VillageSiege.java b/src/main/java/net/minecraft/world/entity/ai/village/VillageSiege.java
+index 4cde8d630a0951f297622af4ef781f5b3fabf9af..7044d8c71e85551e11bf2d96b767e08811bdb9fe 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/village/VillageSiege.java
+++ b/src/main/java/net/minecraft/world/entity/ai/village/VillageSiege.java
+@@ -1,5 +1,7 @@
+ package net.minecraft.world.entity.ai.village;
+ 
+import com.destroystokyo.paper.exception.ServerInternalException;
+
+ import java.util.Iterator;
+ import javax.annotation.Nullable;
+ import net.minecraft.core.BlockPos;
+@@ -118,6 +120,7 @@ public class VillageSiege implements CustomSpawner {
+                 entityzombie.finalizeSpawn(world, world.getCurrentDifficultyAt(entityzombie.blockPosition()), MobSpawnType.EVENT, (SpawnGroupData) null, (CompoundTag) null);
+             } catch (Exception exception) {
+                 VillageSiege.LOGGER.warn("Failed to create zombie for village siege at {}", vec3d, exception);
+                ServerInternalException.reportInternalException(exception); // Paper
+                 return;
+             }
+ 
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 8e06ce1d838b9eaa71a699a999e91dcd5d596a7b..79764895307139b34f2b018f3be86d6610503b64 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -1,5 +1,10 @@
+ package net.minecraft.world.level;
+ 
+import co.aikar.timings.Timing;
+import co.aikar.timings.Timings;
+import com.destroystokyo.paper.event.server.ServerExceptionEvent;
+import com.destroystokyo.paper.exception.ServerInternalException;
+import com.google.common.base.MoreObjects;
+ import com.google.common.collect.Lists;
+ import com.mojang.serialization.Codec;
+ import java.io.IOException;
+@@ -739,6 +744,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+             // Paper start - Prevent tile entity and entity crashes
+             final String msg = String.format("Entity threw exception at %s:%s,%s,%s", entity.level.getWorld().getName(), entity.getX(), entity.getY(), entity.getZ());
+             MinecraftServer.LOGGER.error(msg, throwable);
+            getCraftServer().getPluginManager().callEvent(new ServerExceptionEvent(new ServerInternalException(msg, throwable)));
+             entity.discard();
+             // Paper end
+         }
+diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
+index 81b61b6cc1e99328d4d339ca32895d1268c88ca7..28a7c53d98450cc79bee953411a18f50cfed26c2 100644
+--- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java
+++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
+@@ -316,6 +316,7 @@ public final class NaturalSpawner {
+             }
+         } catch (Exception exception) {
+             NaturalSpawner.LOGGER.warn("Failed to create mob", exception);
+            com.destroystokyo.paper.exception.ServerInternalException.reportInternalException(exception); // Paper
+             return null;
+         }
+     }
+@@ -422,6 +423,7 @@ public final class NaturalSpawner {
+                                     entity = biomesettingsmobs_c.type.create(world.getLevel());
+                                 } catch (Exception exception) {
+                                     NaturalSpawner.LOGGER.warn("Failed to create mob", exception);
+                                    com.destroystokyo.paper.exception.ServerInternalException.reportInternalException(exception); // Paper
+                                     continue;
+                                 }
+ 
+diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+index cadcafec7dc8af1e938b20d07bd9a24acd350ab1..ac17877ea6e210acfb54961a2818ca1ae7f6c738 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+@@ -1,6 +1,7 @@
+ package net.minecraft.world.level.chunk;
+ 
+ import com.google.common.collect.ImmutableList;
+import com.destroystokyo.paper.exception.ServerInternalException;
+ import com.google.common.collect.Maps;
+ import com.google.common.collect.UnmodifiableIterator;
+ import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
+@@ -547,10 +548,15 @@ public class LevelChunk extends ChunkAccess {
+             this.removeBlockEntity(blockEntity.getBlockPos());
+             // Paper end
+         } else {
+-            System.out.println("Attempted to place a tile entity (" + blockEntity + ") at " + blockEntity.getBlockPos().getX() + "," + blockEntity.getBlockPos().getY() + "," + blockEntity.getBlockPos().getZ()
+-                + " (" + this.getBlockState(blockposition) + ") where there was no entity tile!");
+-            System.out.println("Chunk coordinates: " + (this.chunkPos.x * 16) + "," + (this.chunkPos.z * 16));
+-            new Exception().printStackTrace();
+            // Paper start
+            ServerInternalException e = new ServerInternalException(
+                "Attempted to place a tile entity (" + blockEntity + ") at " + blockEntity.getBlockPos().getX() + ","
+                    + blockEntity.getBlockPos().getY() + "," + blockEntity.getBlockPos().getZ()
+                    + " (" + getBlockState(blockposition) + ") where there was no entity tile!\n" +
+                    "Chunk coordinates: " + (this.chunkPos.x * 16) + "," + (this.chunkPos.z * 16));
+            e.printStackTrace();
+            ServerInternalException.reportInternalException(e);
+            // Paper end
+             // CraftBukkit end
+         }
+     }
+@@ -1032,6 +1038,7 @@ public class LevelChunk extends ChunkAccess {
+                         // Paper start - Prevent tile entity and entity crashes
+                         final String msg = String.format("BlockEntity threw exception at %s:%s,%s,%s", LevelChunk.this.getLevel().getWorld().getName(), this.getPos().getX(), this.getPos().getY(), this.getPos().getZ());
+                         net.minecraft.server.MinecraftServer.LOGGER.error(msg, throwable);
+                        net.minecraft.world.level.chunk.LevelChunk.this.level.getCraftServer().getPluginManager().callEvent(new com.destroystokyo.paper.event.server.ServerExceptionEvent(new ServerInternalException(msg, throwable)));
+                         LevelChunk.this.removeBlockEntity(this.getPos());
+                         // Paper end
+                         // Spigot start
+diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
+index c87faa811ec3eafa206d74c89927259d382fb492..9f3223947d2fcc1aaf259effe6afce7a47888858 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
+++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
+@@ -274,6 +274,7 @@ public class RegionFile implements AutoCloseable {
+                     return true;
+                 }
+             } catch (IOException ioexception) {
+                com.destroystokyo.paper.exception.ServerInternalException.reportInternalException(ioexception); // Paper
+                 return false;
+             }
+         }
+@@ -355,6 +356,7 @@ public class RegionFile implements AutoCloseable {
+             ((java.nio.Buffer) bytebuffer).position(5); // CraftBukkit - decompile error
+             filechannel.write(bytebuffer);
+         } catch (Throwable throwable) {
+            com.destroystokyo.paper.exception.ServerInternalException.reportInternalException(throwable); // Paper
+             if (filechannel != null) {
+                 try {
+                     filechannel.close();
+diff --git a/src/main/java/net/minecraft/world/level/storage/DimensionDataStorage.java b/src/main/java/net/minecraft/world/level/storage/DimensionDataStorage.java
+index 2fdb313e8eaed868c36f68c9b7f6a6f9f4864575..c8ed0673ff819cb88d0ee6f53f2a2b9b46b203d4 100644
+--- a/src/main/java/net/minecraft/world/level/storage/DimensionDataStorage.java
+++ b/src/main/java/net/minecraft/world/level/storage/DimensionDataStorage.java
+@@ -120,6 +120,7 @@ public class DimensionDataStorage {
+ 
+             pushbackInputStream.close();
+         } catch (Throwable var15) {
+            com.destroystokyo.paper.exception.ServerInternalException.reportInternalException(var15); // Paper
+             try {
+                 fileInputStream.close();
+             } catch (Throwable var10) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
+index 07c4d9cd5081378e1b903518f7174fca959cd9e3..dfc2789009fcaa08baa8054bdac915590b8701d6 100644
+--- a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
+++ b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
+@@ -17,6 +17,9 @@ import java.util.concurrent.atomic.AtomicReference;
+ import java.util.function.Consumer;
+ import java.util.function.IntUnaryOperator;
+ import java.util.logging.Level;
+import com.destroystokyo.paper.ServerSchedulerReportingWrapper;
+import com.destroystokyo.paper.event.server.ServerExceptionEvent;
+import com.destroystokyo.paper.exception.ServerSchedulerException;
+ import org.apache.commons.lang.Validate;
+ import org.bukkit.plugin.IllegalPluginAccessException;
+ import org.bukkit.plugin.Plugin;
+@@ -434,6 +437,8 @@ public class CraftScheduler implements BukkitScheduler {
+                             msg,
+                             throwable);
+                     }
+                    org.bukkit.Bukkit.getServer().getPluginManager().callEvent(
+                        new ServerExceptionEvent(new ServerSchedulerException(msg, throwable, task)));
+                     // Paper end
+                 } finally {
+                     this.currentTask = null;
+@@ -441,7 +446,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.executor.execute(task);
+                this.executor.execute(new 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)
+             }
--- a/patches/server/0056-Don-t-nest-if-we-don-t-need-to-when-cerealising-text.patch
+++ b/patches/server/0056-Don-t-nest-if-we-don-t-need-to-when-cerealising-text.patch
@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: kashike <kashike@vq.lc>
+Date: Tue, 8 Mar 2016 18:28:43 -0800
+Subject: [PATCH] Don't nest if we don't need to when cerealising text
+ components
+
+
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundChatPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundChatPacket.java
+index 1f5050e6c1d932aa196ab9524f7f1f9bd1b45fce..a64780b4b49d01322d8f755ff540a9622c89e983 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundChatPacket.java
+++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundChatPacket.java
+@@ -36,7 +36,14 @@ public class ClientboundChatPacket implements Packet<ClientGamePacketListener> {
+         // Paper end
+         // Spigot start
+         if (this.components != null) {
+-            buf.writeUtf(net.md_5.bungee.chat.ComponentSerializer.toString(components));
+            // buf.writeUtf(net.md_5.bungee.chat.ComponentSerializer.toString(components)); // Paper - comment, replaced with below
+            // Paper start - don't nest if we don't need to so that we can preserve formatting
+            if (this.components.length == 1) {
+                buf.writeUtf(net.md_5.bungee.chat.ComponentSerializer.toString(this.components[0]));
+            } else {
+                buf.writeUtf(net.md_5.bungee.chat.ComponentSerializer.toString(this.components));
+            }
+            // Paper end
+         } else {
+             buf.writeComponent(this.message);
+         }
--- a/patches/server/0057-Disable-Scoreboards-for-non-players-by-default.patch
+++ b/patches/server/0057-Disable-Scoreboards-for-non-players-by-default.patch
@ -0,0 +1,50 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 8 Mar 2016 23:25:45 -0500
+Subject: [PATCH] Disable Scoreboards for non players by default
+
+Entities collision is checking for scoreboards setting.
+This is very heavy to do map lookups for every collision to check
+this setting.
+
+So avoid looking up scoreboards and short circuit to the "not on a team"
+logic which is most likely to be true.
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index 6d1473a5267ecd3617d76fee23527bde58283bb1..1ab2ede5e9d8939f69fb430084437fda63879fb7 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -251,4 +251,9 @@ public class PaperWorldConfig {
+     private void disableTeleportationSuffocationCheck() {
+         disableTeleportationSuffocationCheck = getBoolean("disable-teleportation-suffocation-check", false);
+     }
+
+    public boolean nonPlayerEntitiesOnScoreboards = false;
+    private void nonPlayerEntitiesOnScoreboards() {
+        nonPlayerEntitiesOnScoreboards = getBoolean("allow-non-player-entities-on-scoreboards", false);
+    }
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 8161cbd3cfed89bee74209c718d0ceff2b401890..a957a168450ee5c34a58ed993f281ca774fccfc1 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -2588,6 +2588,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, i
+ 
+     @Nullable
+     public Team getTeam() {
+        if (!this.level.paperConfig.nonPlayerEntitiesOnScoreboards && !(this instanceof Player)) { return null; } // Paper
+         return this.level.getScoreboard().getPlayersTeam(this.getScoreboardName());
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index deef28110441cd2965c6b531bc255ee2aa994ace..60356e889f2da17b313ee5cf223ee0c5066182c4 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -798,6 +798,7 @@ public abstract class LivingEntity extends Entity {
+         if (nbt.contains("Team", 8)) {
+             String s = nbt.getString("Team");
+             PlayerTeam scoreboardteam = this.level.getScoreboard().getPlayerTeam(s);
+            if (!level.paperConfig.nonPlayerEntitiesOnScoreboards && !(this instanceof net.minecraft.world.entity.player.Player)) { scoreboardteam = null; } // Paper
+             boolean flag = scoreboardteam != null && this.level.getScoreboard().addPlayerToTeam(this.getStringUUID(), scoreboardteam);
+ 
+             if (!flag) {
--- a/patches/server/0058-Add-methods-for-working-with-arrows-stuck-in-living-.patch
+++ b/patches/server/0058-Add-methods-for-working-with-arrows-stuck-in-living-.patch
@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: mrapple <tony@oc.tc>
+Date: Sun, 25 Nov 2012 13:43:39 -0600
+Subject: [PATCH] Add methods for working with arrows stuck in living entities
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index 1d3cd79634366718cd354cd2f55c6fc974ad3525..b65d44780c7e6e1e2e8724df838d1aa54edcc30a 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -717,4 +717,16 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+         this.getHandle().persistentInvisibility = invisible;
+         this.getHandle().setSharedFlag(5, invisible);
+     }
+
+    // Paper start
+    @Override
+    public int getArrowsStuck() {
+        return getHandle().getArrowCount();
+    }
+
+    @Override
+    public void setArrowsStuck(int arrows) {
+        getHandle().setArrowCount(arrows);
+    }
+    // Paper end
+ }
--- a/patches/server/0059-Chunk-Save-Reattempt.patch
+++ b/patches/server/0059-Chunk-Save-Reattempt.patch
@ -0,0 +1,51 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 4 Mar 2013 23:46:10 -0500
+Subject: [PATCH] Chunk Save Reattempt
+
+We commonly have "Stream Closed" errors on chunk saving, so this code should re-try to save the chunk in the event of failure and hopefully prevent rollbacks.
+
+diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
+index 9f3223947d2fcc1aaf259effe6afce7a47888858..7b69007609ed421ee72ddc3d6f2a7b64888babf1 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
+++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
+@@ -274,7 +274,7 @@ public class RegionFile implements AutoCloseable {
+                     return true;
+                 }
+             } catch (IOException ioexception) {
+-                com.destroystokyo.paper.exception.ServerInternalException.reportInternalException(ioexception); // Paper
+                com.destroystokyo.paper.util.SneakyThrow.sneaky(ioexception); // Paper - we want the upper try/catch to retry this
+                 return false;
+             }
+         }
+diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
+index 8ba1c073387fa21a20bd42a873ec3cc314eae64e..eaf22cec54b512e0f57606f50627d5fe9b39bd5c 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
+++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
+@@ -131,6 +131,7 @@ public class RegionFileStorage implements AutoCloseable {
+ 
+     protected void write(ChunkPos pos, @Nullable CompoundTag nbt) throws IOException {
+         RegionFile regionfile = this.getRegionFile(pos, false); // CraftBukkit
+        int attempts = 0; Exception laste = null; while (attempts++ < 5) { try { // Paper
+ 
+         if (nbt == null) {
+             regionfile.clear(pos);
+@@ -156,6 +157,18 @@ public class RegionFileStorage implements AutoCloseable {
+             }
+         }
+ 
+            // Paper start
+            return;
+        } catch (Exception ex)  {
+            laste = ex;
+        }
+        }
+
+        if (laste != null) {
+            com.destroystokyo.paper.exception.ServerInternalException.reportInternalException(laste);
+            net.minecraft.server.MinecraftServer.LOGGER.error("Failed to save chunk", laste);
+        }
+        // Paper end
+     }
+ 
+     public void close() throws IOException {
--- a/patches/server/0060-Complete-resource-pack-API.patch
+++ b/patches/server/0060-Complete-resource-pack-API.patch
@ -0,0 +1,93 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jedediah Smith <jedediah@silencegreys.com>
+Date: Sat, 4 Apr 2015 23:17:52 -0400
+Subject: [PATCH] Complete resource pack API
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 38909ef14fcfd4b93d83512f4cacbe2c3fe431a1..76e34fb4bb6b3d194e155bec30d36887350f3ee3 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1634,8 +1634,11 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
+             ServerGamePacketListenerImpl.LOGGER.info("Disconnecting {} due to resource pack rejection", this.player.getName());
+             this.disconnect(new TranslatableComponent("multiplayer.requiredTexturePrompt.disconnect"));
+         }
+-        this.cserver.getPluginManager().callEvent(new PlayerResourcePackStatusEvent(this.getCraftPlayer(), PlayerResourcePackStatusEvent.Status.values()[packet.action.ordinal()])); // CraftBukkit
+-
+        // Paper start
+        PlayerResourcePackStatusEvent.Status packStatus = PlayerResourcePackStatusEvent.Status.values()[packet.action.ordinal()];
+        player.getBukkitEntity().setResourcePackStatus(packStatus);
+        this.cserver.getPluginManager().callEvent(new PlayerResourcePackStatusEvent(this.getCraftPlayer(), packStatus)); // CraftBukkit
+        // 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 3c7ae0966f2e8d0ab0924047653792ac7ac75f10..97a21ecae2b2b17c9041cd7e5148c68472929d6a 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -132,6 +132,7 @@ import org.bukkit.metadata.MetadataValue;
+ import org.bukkit.plugin.Plugin;
+ import org.bukkit.plugin.messaging.StandardMessenger;
+ import org.bukkit.scoreboard.Scoreboard;
+import org.jetbrains.annotations.NotNull;
+ 
+ import net.md_5.bungee.api.chat.BaseComponent; // Spigot
+ 
+@@ -148,6 +149,10 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     private double health = 20;
+     private boolean scaledHealth = false;
+     private double healthScale = 20;
+    // Paper start
+    private org.bukkit.event.player.PlayerResourcePackStatusEvent.Status resourcePackStatus;
+    private String resourcePackHash;
+    // Paper end
+ 
+     public CraftPlayer(CraftServer server, ServerPlayer entity) {
+         super(server, entity);
+@@ -1918,6 +1923,45 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     public boolean getAffectsSpawning() {
+         return this.getHandle().affectsSpawning;
+     }
+
+    @Override
+    public void setResourcePack(@NotNull String url, @NotNull String hash) {
+        this.setResourcePack(url, hash, false, null);
+    }
+
+    @Override
+    public void setResourcePack(@NotNull String url, @NotNull String hash, boolean required) {
+        this.setResourcePack(url, hash, required, null);
+    }
+
+    @Override
+    public void setResourcePack(@NotNull String url, @NotNull String hash, boolean required, net.kyori.adventure.text.Component resourcePackPrompt) {
+        Validate.notNull(url, "Resource pack URL cannot be null");
+        Validate.notNull(hash, "Hash cannot be null");
+        net.minecraft.network.chat.Component promptComponent = resourcePackPrompt != null ?
+                            io.papermc.paper.adventure.PaperAdventure.asVanilla(resourcePackPrompt) :
+                           null;
+        this.getHandle().sendTexturePack(url, hash, required, promptComponent);
+    }
+
+    @Override
+    public org.bukkit.event.player.PlayerResourcePackStatusEvent.Status getResourcePackStatus() {
+        return this.resourcePackStatus;
+    }
+
+    @Override
+    public String getResourcePackHash() {
+        return this.resourcePackHash;
+    }
+
+    @Override
+    public boolean hasResourcePack() {
+        return this.resourcePackStatus == org.bukkit.event.player.PlayerResourcePackStatusEvent.Status.SUCCESSFULLY_LOADED;
+    }
+
+    public void setResourcePackStatus(org.bukkit.event.player.PlayerResourcePackStatusEvent.Status status) {
+        this.resourcePackStatus = status;
+    }
+     // Paper end
+ 
+     @Override
--- a/patches/server/0061-Default-loading-permissions.yml-before-plugins.patch
+++ b/patches/server/0061-Default-loading-permissions.yml-before-plugins.patch
@ -0,0 +1,52 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Fri, 18 Mar 2016 13:17:38 -0400
+Subject: [PATCH] Default loading permissions.yml before plugins
+
+Under previous behavior, plugins were not able to check if a player had a permission
+if it was defined in permissions.yml. there is no clean way for a plugin to fix that either.
+
+This will change the order so that by default, permissions.yml loads BEFORE plugins instead of after.
+
+This gives plugins expected permission checks.
+
+It also helps improve the expected logic, as servers should set the initial defaults, and then let plugins
+modify that. Under the previous logic, plugins were unable (cleanly) override permissions.yml.
+
+A config option has been added for those who depend on the previous behavior, but I don't expect that.
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
+index 701a2ffd04df48d437b2cb963dd150af99725b6e..817d4572c9991992b720b3ba163188ac0e5b59b7 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
+@@ -234,4 +234,9 @@ public class PaperConfig {
+         }
+         useDisplayNameInQuit = getBoolean("settings.use-display-name-in-quit-message", useDisplayNameInQuit);
+     }
+
+    public static boolean loadPermsBeforePlugins = true;
+    private static void loadPermsBeforePlugins() {
+        loadPermsBeforePlugins = getBoolean("settings.load-permissions-yml-before-plugins", true);
+    }
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index e62ee04cbe0f3281783aff8ef74d7165447b34ba..49725d304ade26d537552788952f18291c64f927 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -428,6 +428,7 @@ public final class CraftServer implements Server {
+         if (type == PluginLoadOrder.STARTUP) {
+             this.helpMap.clear();
+             this.helpMap.initializeGeneralTopics();
+            if (com.destroystokyo.paper.PaperConfig.loadPermsBeforePlugins) loadCustomPermissions(); // Paper
+         }
+ 
+         Plugin[] plugins = this.pluginManager.getPlugins();
+@@ -447,7 +448,7 @@ public final class CraftServer implements Server {
+             this.commandMap.registerServerAliases();
+             DefaultPermissions.registerCorePermissions();
+             CraftDefaultPermissions.registerCorePermissions();
+-            this.loadCustomPermissions();
+            if (!com.destroystokyo.paper.PaperConfig.loadPermsBeforePlugins) this.loadCustomPermissions(); // Paper
+             this.helpMap.initializeCommands();
+             this.syncCommands();
+         }
--- a/patches/server/0062-Allow-Reloading-of-Custom-Permissions.patch
+++ b/patches/server/0062-Allow-Reloading-of-Custom-Permissions.patch
@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: William <admin@domnian.com>
+Date: Fri, 18 Mar 2016 03:30:17 -0400
+Subject: [PATCH] Allow Reloading of Custom Permissions
+
+https://github.com/PaperMC/Paper/issues/49
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 49725d304ade26d537552788952f18291c64f927..657c810f86c73cdbb2c044c742803c835e6d4c50 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -2446,5 +2446,23 @@ public final class CraftServer implements Server {
+         }
+         return this.adventure$audiences;
+     }
+
+    @Override
+    public void reloadPermissions() {
+        pluginManager.clearPermissions();
+        if (com.destroystokyo.paper.PaperConfig.loadPermsBeforePlugins) loadCustomPermissions();
+        for (Plugin plugin : pluginManager.getPlugins()) {
+            for (Permission perm : plugin.getDescription().getPermissions()) {
+                try {
+                    pluginManager.addPermission(perm);
+                } catch (IllegalArgumentException ex) {
+                    getLogger().log(Level.WARNING, "Plugin " + plugin.getDescription().getFullName() + " tried to register permission '" + perm.getName() + "' but it's already registered", ex);
+                }
+            }
+        }
+        if (!com.destroystokyo.paper.PaperConfig.loadPermsBeforePlugins) loadCustomPermissions();
+        DefaultPermissions.registerCorePermissions();
+        CraftDefaultPermissions.registerCorePermissions();
+    }
+     // Paper end
+ }
--- a/patches/server/0063-Remove-Metadata-on-reload.patch
+++ b/patches/server/0063-Remove-Metadata-on-reload.patch
@ -0,0 +1,29 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Fri, 18 Mar 2016 13:50:14 -0400
+Subject: [PATCH] Remove Metadata on reload
+
+Metadata is not meant to persist reload as things break badly with non primitive types
+This will remove metadata on reload so it does not crash everything if a plugin uses it.
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 657c810f86c73cdbb2c044c742803c835e6d4c50..bf18ed30b1e66cb94f346b1e63a67ec5f4030b0b 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -913,8 +913,16 @@ public final class CraftServer implements Server {
+             world.paperConfig.init(); // Paper
+         }
+ 
+        Plugin[] pluginClone = pluginManager.getPlugins().clone(); // Paper
+         this.pluginManager.clearPlugins();
+         this.commandMap.clearCommands();
+        // Paper start
+        for (Plugin plugin : pluginClone) {
+            entityMetadata.removeAll(plugin);
+            worldMetadata.removeAll(plugin);
+            playerMetadata.removeAll(plugin);
+        }
+        // Paper end
+         this.reloadData();
+         org.spigotmc.SpigotConfig.registerCommands(); // Spigot
+         com.destroystokyo.paper.PaperConfig.registerCommands(); // Paper
--- a/patches/server/0064-Handle-Item-Meta-Inconsistencies.patch
+++ b/patches/server/0064-Handle-Item-Meta-Inconsistencies.patch
@ -0,0 +1,336 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Thu, 28 May 2015 23:00:19 -0400
+Subject: [PATCH] Handle Item Meta Inconsistencies
+
+First, Enchantment order would blow away seeing 2 items as the same,
+however the Client forces enchantment list in a certain order, as well
+as does the /enchant command. Anvils can insert it into forced order,
+causing 2 same items to be considered different.
+
+This change makes unhandled NBT Tags and Enchantments use a sorted tree map,
+so they will always be in a consistent order.
+
+Additionally, the old enchantment API was never updated when ItemMeta
+was added, resulting in 2 different ways to modify an items enchantments.
+
+For consistency, the old API methods now forward to use the
+ItemMeta API equivalents, and should deprecate the old API's.
+
+diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
+index df787c12053f799b111c539d866ff8c751e21611..4019a8cd594f8c093cf790600a92f0725250e82b 100644
+--- a/src/main/java/net/minecraft/world/item/ItemStack.java
+++ b/src/main/java/net/minecraft/world/item/ItemStack.java
+@@ -13,6 +13,8 @@ import java.text.DecimalFormatSymbols;
+ import java.util.Collection;
+ import java.util.Iterator;
+ import java.util.List;
+import java.util.Collections;
+import java.util.Comparator;
+ import java.util.Locale;
+ import java.util.Map.Entry;
+ import java.util.Optional;
+@@ -151,6 +153,23 @@ public final class ItemStack {
+         return this.getItem().getTooltipImage(this);
+     }
+ 
+    // Paper start
+    private static final java.util.Comparator<? super CompoundTag> enchantSorter = java.util.Comparator.comparing(o -> o.getString("id"));
+    private void processEnchantOrder(CompoundTag tag) {
+        if (tag == null || !tag.contains("Enchantments", 9)) {
+            return;
+        }
+        ListTag list = tag.getList("Enchantments", 10);
+        if (list.size() < 2) {
+            return;
+        }
+        try {
+            //noinspection unchecked
+            list.sort((Comparator<? super net.minecraft.nbt.Tag>) enchantSorter); // Paper
+        } catch (Exception ignored) {}
+    }
+    // Paper end
+
+     public ItemStack(ItemLike item) {
+         this(item, 1);
+     }
+@@ -194,9 +213,11 @@ public final class ItemStack {
+             // CraftBukkit start - make defensive copy as this data may be coming from the save thread
+             this.tag = nbttagcompound.getCompound("tag").copy();
+             // CraftBukkit end
+            this.processEnchantOrder(this.tag); // Paper
+             this.getItem().verifyTagAfterLoad(this.tag);
+         }
+ 
+        processEnchantOrder(this.tag); // Paper
+         if (this.getItem().canBeDepleted()) {
+             this.setDamageValue(this.getDamageValue());
+         }
+@@ -1055,6 +1076,7 @@ public final class ItemStack {
+         ListTag nbttaglist = this.tag.getList("Enchantments", 10);
+ 
+         nbttaglist.add(EnchantmentHelper.storeEnchantment(EnchantmentHelper.getEnchantmentId(enchantment), (byte) level));
+        processEnchantOrder(this.tag); // Paper
+     }
+ 
+     public boolean isEnchanted() {
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
+index e88df908377450964ae5b6ff97ee97bd2f09c05f..ba70ac49222c517a38e20e86cee1fd38aecb6318 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
+@@ -6,7 +6,6 @@ import java.util.Map;
+ import net.minecraft.nbt.CompoundTag;
+ import net.minecraft.nbt.ListTag;
+ import net.minecraft.world.item.Item;
+-import net.minecraft.world.item.enchantment.EnchantmentHelper;
+ import org.apache.commons.lang.Validate;
+ import org.bukkit.Material;
+ import org.bukkit.NamespacedKey;
+@@ -178,28 +177,11 @@ public final class CraftItemStack extends ItemStack {
+     public void addUnsafeEnchantment(Enchantment ench, int level) {
+         Validate.notNull(ench, "Cannot add null enchantment");
+ 
+-        if (!CraftItemStack.makeTag(this.handle)) {
+-            return;
+-        }
+-        ListTag list = CraftItemStack.getEnchantmentList(this.handle);
+-        if (list == null) {
+-            list = new ListTag();
+-            this.handle.getTag().put(ENCHANTMENTS.NBT, list);
+-        }
+-        int size = list.size();
+-
+-        for (int i = 0; i < size; i++) {
+-            CompoundTag tag = (CompoundTag) list.get(i);
+-            String id = tag.getString(ENCHANTMENTS_ID.NBT);
+-            if (ench.getKey().equals(NamespacedKey.fromString(id))) {
+-                tag.putShort(ENCHANTMENTS_LVL.NBT, (short) level);
+-                return;
+-            }
+-        }
+-        CompoundTag tag = new CompoundTag();
+-        tag.putString(ENCHANTMENTS_ID.NBT, ench.getKey().toString());
+-        tag.putShort(ENCHANTMENTS_LVL.NBT, (short) level);
+-        list.add(tag);
+        // Paper start - Replace whole method
+        final ItemMeta itemMeta = this.getItemMeta();
+        itemMeta.addEnchant(ench, level, true);
+        this.setItemMeta(itemMeta);
+        // Paper end
+     }
+ 
+     static boolean makeTag(net.minecraft.world.item.ItemStack item) {
+@@ -216,66 +198,34 @@ public final class CraftItemStack extends ItemStack {
+ 
+     @Override
+     public boolean containsEnchantment(Enchantment ench) {
+-        return this.getEnchantmentLevel(ench) > 0;
+        return this.hasItemMeta() && this.getItemMeta().hasEnchant(ench); // Paper - use meta
+     }
+ 
+     @Override
+     public int getEnchantmentLevel(Enchantment ench) {
+-        Validate.notNull(ench, "Cannot find null enchantment");
+-        if (this.handle == null) {
+-            return 0;
+-        }
+-        return EnchantmentHelper.getItemEnchantmentLevel(CraftEnchantment.getRaw(ench), handle);
+        return this.hasItemMeta() ? this.getItemMeta().getEnchantLevel(ench) : 0; // Paper - replace entire method with meta
+     }
+ 
+     @Override
+     public int removeEnchantment(Enchantment ench) {
+         Validate.notNull(ench, "Cannot remove null enchantment");
+ 
+-        ListTag list = CraftItemStack.getEnchantmentList(this.handle), listCopy;
+-        if (list == null) {
+-            return 0;
+-        }
+-        int index = Integer.MIN_VALUE;
+-        int level = Integer.MIN_VALUE;
+-        int size = list.size();
+-
+-        for (int i = 0; i < size; i++) {
+-            CompoundTag enchantment = (CompoundTag) list.get(i);
+-            String id = enchantment.getString(ENCHANTMENTS_ID.NBT);
+-            if (ench.getKey().equals(NamespacedKey.fromString(id))) {
+-                index = i;
+-                level = 0xffff & enchantment.getShort(ENCHANTMENTS_LVL.NBT);
+-                break;
+-            }
+-        }
+-
+-        if (index == Integer.MIN_VALUE) {
+-            return 0;
+-        }
+-        if (size == 1) {
+-            this.handle.getTag().remove(ENCHANTMENTS.NBT);
+-            if (this.handle.getTag().isEmpty()) {
+-                this.handle.setTag(null);
+-            }
+-            return level;
+-        }
+-
+-        // This is workaround for not having an index removal
+-        listCopy = new ListTag();
+-        for (int i = 0; i < size; i++) {
+-            if (i != index) {
+-                listCopy.add(list.get(i));
+-            }
+        // Paper start - replace entire method
+        final ItemMeta itemMeta = this.getItemMeta();
+        if (itemMeta == null) return 0;
+        int level = itemMeta.getEnchantLevel(ench);
+        if (level > 0) {
+            itemMeta.removeEnchant(ench);
+            this.setItemMeta(itemMeta);
+         }
+-        this.handle.getTag().put(ENCHANTMENTS.NBT, listCopy);
+        // Paper end
+ 
+         return level;
+     }
+ 
+     @Override
+     public Map<Enchantment, Integer> getEnchantments() {
+-        return CraftItemStack.getEnchantments(this.handle);
+        return this.hasItemMeta() ? this.getItemMeta().getEnchants() : ImmutableMap.<Enchantment, Integer>of(); // Paper - use Item Meta
+     }
+ 
+     static Map<Enchantment, Integer> getEnchantments(net.minecraft.world.item.ItemStack item) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
+index af2d0bfab14cf7133eeaff484895cba6b37391e8..0baca5f3c3f73323b6f5b283fc00be39477ccf59 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
+@@ -6,6 +6,7 @@ import com.google.common.collect.ImmutableList;
+ import com.google.common.collect.ImmutableMap;
+ import com.google.common.collect.ImmutableMultimap;
+ import com.google.common.collect.LinkedHashMultimap;
+import com.google.common.collect.ImmutableSortedMap; // Paper
+ import com.google.common.collect.Lists;
+ import com.google.common.collect.Multimap;
+ import com.google.common.collect.SetMultimap;
+@@ -23,6 +24,7 @@ import java.util.ArrayList;
+ import java.util.Arrays;
+ import java.util.Base64;
+ import java.util.Collection;
+import java.util.Comparator; // Paper
+ import java.util.EnumSet;
+ import java.util.HashMap;
+ import java.util.Iterator;
+@@ -33,6 +35,7 @@ import java.util.Map;
+ import java.util.NoSuchElementException;
+ import java.util.Objects;
+ import java.util.Set;
+import java.util.TreeMap; // Paper
+ import java.util.logging.Level;
+ import java.util.logging.Logger;
+ import javax.annotation.Nonnull;
+@@ -272,7 +275,7 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+     private List<String> lore; // null and empty are two different states internally
+     private Integer customModelData;
+     private CompoundTag blockData;
+-    private Map<Enchantment, Integer> enchantments;
+    private EnchantmentMap enchantments; // Paper
+     private Multimap<Attribute, AttributeModifier> attributeModifiers;
+     private int repairCost;
+     private int hideFlag;
+@@ -283,7 +286,7 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+     private static final CraftPersistentDataTypeRegistry DATA_TYPE_REGISTRY = new CraftPersistentDataTypeRegistry();
+ 
+     private CompoundTag internalTag;
+-    final Map<String, Tag> unhandledTags = new HashMap<String, Tag>(); // Visible for testing only
+    final Map<String, Tag> unhandledTags = new TreeMap<String, Tag>(); // Visible for testing only // Paper
+     private CraftPersistentDataContainer persistentDataContainer = new CraftPersistentDataContainer(CraftMetaItem.DATA_TYPE_REGISTRY);
+ 
+     private int version = CraftMagicNumbers.INSTANCE.getDataVersion(); // Internal use only
+@@ -304,7 +307,7 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+         this.blockData = meta.blockData;
+ 
+         if (meta.enchantments != null) { // Spigot
+-            this.enchantments = new LinkedHashMap<Enchantment, Integer>(meta.enchantments);
+            this.enchantments = new EnchantmentMap(meta.enchantments); // Paper
+         }
+ 
+         if (meta.hasAttributeModifiers()) {
+@@ -387,13 +390,13 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+         }
+     }
+ 
+-    static Map<Enchantment, Integer> buildEnchantments(CompoundTag tag, ItemMetaKey key) {
+    static EnchantmentMap buildEnchantments(CompoundTag tag, ItemMetaKey key) { // Paper
+         if (!tag.contains(key.NBT)) {
+             return null;
+         }
+ 
+         ListTag ench = tag.getList(key.NBT, CraftMagicNumbers.NBT.TAG_COMPOUND);
+-        Map<Enchantment, Integer> enchantments = new LinkedHashMap<Enchantment, Integer>(ench.size());
+        EnchantmentMap enchantments = new EnchantmentMap(); // Paper
+ 
+         for (int i = 0; i < ench.size(); i++) {
+             String id = ((CompoundTag) ench.get(i)).getString(ENCHANTMENTS_ID.NBT);
+@@ -546,13 +549,13 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+         }
+     }
+ 
+-    static Map<Enchantment, Integer> buildEnchantments(Map<String, Object> map, ItemMetaKey key) {
+    static EnchantmentMap buildEnchantments(Map<String, Object> map, ItemMetaKey key) { // Paper
+         Map<?, ?> ench = SerializableMeta.getObject(Map.class, map, key.BUKKIT, true);
+         if (ench == null) {
+             return null;
+         }
+ 
+-        Map<Enchantment, Integer> enchantments = new LinkedHashMap<Enchantment, Integer>(ench.size());
+        EnchantmentMap enchantments = new EnchantmentMap(); // Paper
+         for (Map.Entry<?, ?> entry : ench.entrySet()) {
+             // Doctor older enchants
+             String enchantKey = entry.getKey().toString();
+@@ -828,14 +831,14 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+ 
+     @Override
+     public Map<Enchantment, Integer> getEnchants() {
+-        return this.hasEnchants() ? ImmutableMap.copyOf(enchantments) : ImmutableMap.<Enchantment, Integer>of();
+        return this.hasEnchants() ? ImmutableSortedMap.copyOfSorted(this.enchantments) : ImmutableMap.<Enchantment, Integer>of(); // Paper
+     }
+ 
+     @Override
+     public boolean addEnchant(Enchantment ench, int level, boolean ignoreRestrictions) {
+         Validate.notNull(ench, "Enchantment cannot be null");
+         if (this.enchantments == null) {
+-            this.enchantments = new LinkedHashMap<Enchantment, Integer>(4);
+            this.enchantments = new EnchantmentMap(); // Paper
+         }
+ 
+         if (ignoreRestrictions || level >= ench.getStartLevel() && level <= ench.getMaxLevel()) {
+@@ -1216,7 +1219,7 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+             clone.customModelData = this.customModelData;
+             clone.blockData = this.blockData;
+             if (this.enchantments != null) {
+-                clone.enchantments = new LinkedHashMap<Enchantment, Integer>(this.enchantments);
+                clone.enchantments = new EnchantmentMap(this.enchantments); // Paper
+             }
+             if (this.hasAttributeModifiers()) {
+                 clone.attributeModifiers = LinkedHashMultimap.create(this.attributeModifiers);
+@@ -1450,4 +1453,22 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+             return CraftMetaItem.HANDLED_TAGS;
+         }
+     }
+
+    // Paper start
+    private static class EnchantmentMap extends TreeMap<Enchantment, Integer> {
+        private EnchantmentMap(Map<Enchantment, Integer> enchantments) {
+            this();
+            putAll(enchantments);
+        }
+
+        private EnchantmentMap() {
+            super(Comparator.comparing(o -> o.getKey().toString()));
+        }
+
+        public EnchantmentMap clone() {
+            return (EnchantmentMap) super.clone();
+        }
+    }
+    // Paper end
+
+ }
--- a/patches/server/0065-Configurable-Non-Player-Arrow-Despawn-Rate.patch
+++ b/patches/server/0065-Configurable-Non-Player-Arrow-Despawn-Rate.patch
@ -0,0 +1,44 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Fri, 18 Mar 2016 15:12:22 -0400
+Subject: [PATCH] Configurable Non Player Arrow Despawn Rate
+
+Can set a much shorter despawn rate for arrows that players can not pick up.
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index 1ab2ede5e9d8939f69fb430084437fda63879fb7..e5d5f4c692e80c616ccde58ab13604777eb71101 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -256,4 +256,19 @@ public class PaperWorldConfig {
+     private void nonPlayerEntitiesOnScoreboards() {
+         nonPlayerEntitiesOnScoreboards = getBoolean("allow-non-player-entities-on-scoreboards", false);
+     }
+
+    public int nonPlayerArrowDespawnRate = -1;
+    public int creativeArrowDespawnRate = -1;
+    private void nonPlayerArrowDespawnRate() {
+        nonPlayerArrowDespawnRate = getInt("non-player-arrow-despawn-rate", -1);
+        if (nonPlayerArrowDespawnRate == -1) {
+            nonPlayerArrowDespawnRate = spigotConfig.arrowDespawnRate;
+        }
+        creativeArrowDespawnRate = getInt("creative-arrow-despawn-rate", -1);
+        if (creativeArrowDespawnRate == -1) {
+            creativeArrowDespawnRate = spigotConfig.arrowDespawnRate;
+        }
+        log("Non Player Arrow Despawn Rate: " + nonPlayerArrowDespawnRate);
+        log("Creative Arrow Despawn Rate: " + creativeArrowDespawnRate);
+    }
+ }
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+index 04bd882525235e6712082d6b710f33abe555884c..68b15e3061e1e8637a34ee5e0f0953dd23645f49 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+@@ -310,7 +310,7 @@ public abstract class AbstractArrow extends Projectile {
+ 
+     protected void tickDespawn() {
+         ++this.life;
+-        if (this.life >= ((this instanceof ThrownTrident) ? level.spigotConfig.tridentDespawnRate : level.spigotConfig.arrowDespawnRate)) { // Spigot
+        if (this.life >= (pickup == Pickup.CREATIVE_ONLY ? level.paperConfig.creativeArrowDespawnRate : (pickup == Pickup.DISALLOWED ? level.paperConfig.nonPlayerArrowDespawnRate : ((this instanceof ThrownTrident) ? level.spigotConfig.tridentDespawnRate : level.spigotConfig.arrowDespawnRate)))) { // Spigot // Paper - TODO: Extract this to init?
+             this.discard();
+         }
+ 
--- a/patches/server/0066-Add-World-Util-Methods.patch
+++ b/patches/server/0066-Add-World-Util-Methods.patch
@ -0,0 +1,53 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Fri, 18 Mar 2016 20:16:03 -0400
+Subject: [PATCH] Add World Util Methods
+
+Methods that can be used for other patches to help improve logic.
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 032e1e08413f2d0f601cdc32fe12145e2c1fec5f..19c97a14cbf23130db2de80e3f7f6e0c4ff27662 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -206,7 +206,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+     public final LevelStorageSource.LevelStorageAccess convertable;
+     public final UUID uuid;
+ 
+-    public LevelChunk getChunkIfLoaded(int x, int z) {
+    @Override public LevelChunk getChunkIfLoaded(int x, int z) { // Paper - this was added in world too but keeping here for NMS ABI
+         return this.chunkSource.getChunk(x, z, false);
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 79764895307139b34f2b018f3be86d6610503b64..507d38a8e7b643712fe235c73f440c0a52b6d8b2 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -313,11 +313,27 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+     }
+ 
+     @Override
+-    public FluidState getFluidIfLoaded(BlockPos blockposition) {
+    public final FluidState getFluidIfLoaded(BlockPos blockposition) {
+         ChunkAccess chunk = this.getChunkIfLoadedImmediately(blockposition.getX() >> 4, blockposition.getZ() >> 4);
+ 
+         return chunk == null ? null : chunk.getFluidState(blockposition);
+     }
+
+    public final boolean isLoadedAndInBounds(BlockPos blockposition) { // Paper - final for inline
+        return getWorldBorder().isWithinBounds(blockposition) && getChunkIfLoadedImmediately(blockposition.getX() >> 4, blockposition.getZ() >> 4) != null;
+    }
+
+    public LevelChunk getChunkIfLoaded(int x, int z) { // Overridden in WorldServer for ABI compat which has final
+        return ((ServerLevel) this).getChunkSource().getChunkAtIfLoadedImmediately(x, z);
+    }
+    public final LevelChunk getChunkIfLoaded(BlockPos blockposition) {
+        return ((ServerLevel) this).getChunkSource().getChunkAtIfLoadedImmediately(blockposition.getX() >> 4, blockposition.getZ() >> 4);
+    }
+
+    //  reduces need to do isLoaded before getType
+    public final BlockState getTypeIfLoadedAndInBounds(BlockPos blockposition) {
+        return getWorldBorder().isWithinBounds(blockposition) ? getTypeIfLoaded(blockposition) : null;
+    }
+     // Paper end
+ 
+     @Override
--- a/patches/server/0067-Custom-replacement-for-eaten-items.patch
+++ b/patches/server/0067-Custom-replacement-for-eaten-items.patch
@ -0,0 +1,48 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jedediah Smith <jedediah@silencegreys.com>
+Date: Sun, 21 Jun 2015 15:07:20 -0400
+Subject: [PATCH] Custom replacement for eaten items
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 60356e889f2da17b313ee5cf223ee0c5066182c4..c8e60153986e9be21a1e372d5c1cb25c762ab81b 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -3563,9 +3563,10 @@ public abstract class LivingEntity extends Entity {
+                 this.triggerItemUseEffects(this.useItem, 16);
+                 // CraftBukkit start - fire PlayerItemConsumeEvent
+                 ItemStack itemstack;
+                PlayerItemConsumeEvent event = null; // Paper
+                 if (this instanceof ServerPlayer) {
+                     org.bukkit.inventory.ItemStack craftItem = CraftItemStack.asBukkitCopy(this.useItem);
+-                    PlayerItemConsumeEvent event = new PlayerItemConsumeEvent((Player) this.getBukkitEntity(), craftItem);
+                    event = new PlayerItemConsumeEvent((Player) this.getBukkitEntity(), craftItem); // Paper
+                     level.getCraftServer().getPluginManager().callEvent(event);
+ 
+                     if (event.isCancelled()) {
+@@ -3579,6 +3580,13 @@ public abstract class LivingEntity extends Entity {
+                 } else {
+                     itemstack = this.useItem.finishUsingItem(this.level, this);
+                 }
+
+                // Paper start - save the default replacement item and change it if necessary
+                final ItemStack defaultReplacement = itemstack;
+                if (event != null && event.getReplacement() != null) {
+                    itemstack = CraftItemStack.asNMSCopy(event.getReplacement());
+                }
+                // Paper end
+                 // CraftBukkit end
+ 
+                 if (itemstack != this.useItem) {
+@@ -3586,6 +3594,11 @@ public abstract class LivingEntity extends Entity {
+                 }
+ 
+                 this.stopUsingItem();
+                // Paper start - if the replacement is anything but the default, update the client inventory
+                if (this instanceof ServerPlayer && !com.google.common.base.Objects.equal(defaultReplacement, itemstack)) {
+                    ((ServerPlayer) this).getBukkitEntity().updateInventory();
+                }
+                // Paper end
+             }
+ 
+         }
--- a/patches/server/0068-handle-NaN-health-absorb-values-and-repair-bad-data.patch
+++ b/patches/server/0068-handle-NaN-health-absorb-values-and-repair-bad-data.patch
@ -0,0 +1,57 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sun, 27 Sep 2015 01:18:02 -0400
+Subject: [PATCH] handle NaN health/absorb values and repair bad data
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index c8e60153986e9be21a1e372d5c1cb25c762ab81b..e5a0f6edbb1d43f8c918b9cee9a291db630663b4 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -759,7 +759,13 @@ public abstract class LivingEntity extends Entity {
+ 
+     @Override
+     public void readAdditionalSaveData(CompoundTag nbt) {
+-        this.setAbsorptionAmount(nbt.getFloat("AbsorptionAmount"));
+        // Paper start - jvm keeps optimizing the setter
+        float absorptionAmount = nbt.getFloat("AbsorptionAmount");
+        if (Float.isNaN(absorptionAmount)) {
+            absorptionAmount = 0;
+        }
+        this.setAbsorptionAmount(absorptionAmount);
+        // Paper end
+         if (nbt.contains("Attributes", 9) && this.level != null && !this.level.isClientSide) {
+             this.getAttributes().load(nbt.getList("Attributes", 10));
+         }
+@@ -1246,6 +1252,10 @@ public abstract class LivingEntity extends Entity {
+     }
+ 
+     public void setHealth(float health) {
+        // Paper start
+        if (Float.isNaN(health)) { health = getMaxHealth(); if (this.valid) {
+            System.err.println("[NAN-HEALTH] " + getScoreboardName() + " had NaN health set");
+        } } // Paper end
+         // CraftBukkit start - Handle scaled health
+         if (this instanceof ServerPlayer) {
+             org.bukkit.craftbukkit.entity.CraftPlayer player = ((ServerPlayer) this).getBukkitEntity();
+@@ -3398,7 +3408,7 @@ public abstract class LivingEntity extends Entity {
+     }
+ 
+     public void setAbsorptionAmount(float amount) {
+-        if (amount < 0.0F) {
+        if (amount < 0.0F || Float.isNaN(amount)) { // Paper
+             amount = 0.0F;
+         }
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 97a21ecae2b2b17c9041cd7e5148c68472929d6a..e41df687f7d681574bc16f5d3b1572a3ea9902f0 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -1723,6 +1723,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     }
+ 
+     public void setRealHealth(double health) {
+        if (Double.isNaN(health)) {return;} // Paper
+         this.health = health;
+     }
+ 
--- a/patches/server/0069-Use-a-Shared-Random-for-Entities.patch
+++ b/patches/server/0069-Use-a-Shared-Random-for-Entities.patch
@ -0,0 +1,55 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 22 Mar 2016 00:33:47 -0400
+Subject: [PATCH] Use a Shared Random for Entities
+
+Reduces memory usage and provides ensures more randomness, Especially since a lot of garbage entity objects get created.
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index a957a168450ee5c34a58ed993f281ca774fccfc1..30d30c2fd66b312a45d3bf706d41b38724d52a7b 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -153,6 +153,21 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, i
+         return tag.contains("Bukkit.updateLevel") && tag.getInt("Bukkit.updateLevel") >= level;
+     }
+ 
+    // Paper start
+    public static Random SHARED_RANDOM = new Random() {
+        private boolean locked = false;
+        @Override
+        public synchronized void setSeed(long seed) {
+            if (locked) {
+                LogManager.getLogger().error("Ignoring setSeed on Entity.SHARED_RANDOM", new Throwable());
+            } else {
+                super.setSeed(seed);
+                locked = true;
+            }
+        }
+    };
+    // Paper end
+
+     private CraftEntity bukkitEntity;
+ 
+     public CraftEntity getBukkitEntity() {
+@@ -334,7 +349,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, i
+         this.bb = Entity.INITIAL_AABB;
+         this.stuckSpeedMultiplier = Vec3.ZERO;
+         this.nextStep = 1.0F;
+-        this.random = new Random();
+        this.random = SHARED_RANDOM; // Paper
+         this.remainingFireTicks = -this.getFireImmuneTicks();
+         this.fluidHeight = new Object2DoubleArrayMap(2);
+         this.firstTick = true;
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Squid.java b/src/main/java/net/minecraft/world/entity/animal/Squid.java
+index 09ec4d66aaa5b9e4ef09750a76cebc389a4306fd..370513fbc39f178f903ce140ced1a97029dd39db 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Squid.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Squid.java
+@@ -47,7 +47,7 @@ public class Squid extends WaterAnimal {
+ 
+     public Squid(EntityType<? extends Squid> type, Level world) {
+         super(type, world);
+-        this.random.setSeed((long) this.getId());
+        //this.random.setSeed((long) this.getId()); // Paper - we set the random to shared, do not clobber the seed
+         this.tentacleSpeed = 1.0F / (this.random.nextFloat() + 1.0F) * 0.2F;
+     }
+ 
--- a/patches/server/0070-Configurable-spawn-chances-for-skeleton-horses.patch
+++ b/patches/server/0070-Configurable-spawn-chances-for-skeleton-horses.patch
@ -0,0 +1,36 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach.brown@destroystokyo.com>
+Date: Tue, 22 Mar 2016 12:04:28 -0500
+Subject: [PATCH] Configurable spawn chances for skeleton horses
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index e5d5f4c692e80c616ccde58ab13604777eb71101..7addb5c66c88da73a4d80da1e898d629d76074f0 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -271,4 +271,12 @@ public class PaperWorldConfig {
+         log("Non Player Arrow Despawn Rate: " + nonPlayerArrowDespawnRate);
+         log("Creative Arrow Despawn Rate: " + creativeArrowDespawnRate);
+     }
+
+    public double skeleHorseSpawnChance;
+    private void skeleHorseSpawnChance() {
+        skeleHorseSpawnChance = getDouble("skeleton-horse-thunder-spawn-chance", 0.01D);
+        if (skeleHorseSpawnChance < 0) {
+            skeleHorseSpawnChance = 0.01D; // Vanilla value
+        }
+    }
+ }
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 19c97a14cbf23130db2de80e3f7f6e0c4ff27662..9f7bbd602c19f317d05cd8b72453c2e37d8acff5 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -560,7 +560,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+             blockposition = this.findLightningTargetAround(this.getBlockRandomPos(j, 0, k, 15));
+             if (this.isRainingAt(blockposition)) {
+                 DifficultyInstance difficultydamagescaler = this.getCurrentDifficultyAt(blockposition);
+-                boolean flag1 = this.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && this.random.nextDouble() < (double) difficultydamagescaler.getEffectiveDifficulty() * 0.01D && !this.getBlockState(blockposition.below()).is(Blocks.LIGHTNING_ROD);
+                boolean flag1 = this.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && this.random.nextDouble() < (double) difficultydamagescaler.getEffectiveDifficulty() * paperConfig.skeleHorseSpawnChance && !this.getBlockState(blockposition.below()).is(Blocks.LIGHTNING_ROD); // Paper
+ 
+                 if (flag1) {
+                     SkeletonHorse entityhorseskeleton = (SkeletonHorse) EntityType.SKELETON_HORSE.create(this);
--- a/patches/server/0071-Optimize-isValidLocation-getType-and-getBlockData-fo.patch
+++ b/patches/server/0071-Optimize-isValidLocation-getType-and-getBlockData-fo.patch
@ -0,0 +1,167 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Thu, 3 Mar 2016 02:07:55 -0600
+Subject: [PATCH] Optimize isValidLocation, getType and getBlockData for
+ inlining
+
+Hot methods, so reduce # of instructions for the method.
+
+Move is valid location test to the BlockPosition class so that it can access local variables.
+
+Replace all calls to the new place to the unnecessary forward.
+
+Optimize getType and getBlockData to manually inline and optimize the calls
+
+diff --git a/src/main/java/net/minecraft/core/Vec3i.java b/src/main/java/net/minecraft/core/Vec3i.java
+index 543d5a67e76a3114f6eac29a053ff04ceecb6256..c33bac27edfdab4c3ee618c9ed39c629b1513f09 100644
+--- a/src/main/java/net/minecraft/core/Vec3i.java
+++ b/src/main/java/net/minecraft/core/Vec3i.java
+@@ -33,6 +33,15 @@ public class Vec3i implements Comparable<Vec3i> {
+         return CODEC.flatXmap(checkOffsetAxes(maxAbsValue), checkOffsetAxes(maxAbsValue));
+     }
+ 
+    // Paper start
+    public boolean isValidLocation(net.minecraft.world.level.LevelHeightAccessor levelHeightAccessor) {
+        return getX() >= -30000000 && getZ() >= -30000000 && getX() < 30000000 && getZ() < 30000000 && !levelHeightAccessor.isOutsideBuildHeight(getY());
+    }
+    public boolean isInvalidYLocation(net.minecraft.world.level.LevelHeightAccessor levelHeightAccessor) {
+        return levelHeightAccessor.isOutsideBuildHeight(getY());
+    }
+    // Paper end
+
+     public Vec3i(int x, int y, int z) {
+         this.x = x;
+         this.y = y;
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 507d38a8e7b643712fe235c73f440c0a52b6d8b2..b6f2be487720e31a548a3cee4cd73319f402f6ff 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -263,7 +263,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+     }
+ 
+     public boolean isInWorldBounds(BlockPos pos) {
+-        return !this.isOutsideBuildHeight(pos) && Level.isInWorldBoundsHorizontal(pos);
+        return pos.isValidLocation(this); // Paper - use better/optimized check
+     }
+ 
+     public static boolean isInSpawnableBounds(BlockPos pos) {
+diff --git a/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java b/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java
+index 2e5619a581d18008df31f4b2a279e7418264aa4f..7bec92f343d5c79fdff43b36272c0e979c6879d4 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java
+++ b/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java
+@@ -113,6 +113,7 @@ public abstract class ChunkAccess implements BlockGetter, BiomeManager.NoiseBiom
+         return GameEventDispatcher.NOOP;
+     }
+ 
+    public abstract BlockState getType(final int x, final int y, final int z); // Paper
+     @Nullable
+     public abstract BlockState setBlockState(BlockPos pos, BlockState state, boolean moved);
+ 
+diff --git a/src/main/java/net/minecraft/world/level/chunk/EmptyLevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/EmptyLevelChunk.java
+index 31d01f8df394e718f1f2a268ddccee77b6706eb9..25e9cc39d748dfd99d38f504c14f40f9ec7bdd2d 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/EmptyLevelChunk.java
+++ b/src/main/java/net/minecraft/world/level/chunk/EmptyLevelChunk.java
+@@ -18,6 +18,11 @@ public class EmptyLevelChunk extends LevelChunk {
+         super(world, pos);
+     }
+ 
+    // Paper start
+    @Override public BlockState getType(int x, int y, int z) {
+        return Blocks.VOID_AIR.defaultBlockState();
+    }
+    // Paper end
+     @Override
+     public BlockState getBlockState(BlockPos pos) {
+         return Blocks.VOID_AIR.defaultBlockState();
+diff --git a/src/main/java/net/minecraft/world/level/chunk/ImposterProtoChunk.java b/src/main/java/net/minecraft/world/level/chunk/ImposterProtoChunk.java
+index 65967fd834d8aadf9a6af3ee26164819488dc680..de235aadb3aebcd173fea7ea4783c1e8aa8f4c6a 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/ImposterProtoChunk.java
+++ b/src/main/java/net/minecraft/world/level/chunk/ImposterProtoChunk.java
+@@ -46,6 +46,11 @@ public class ImposterProtoChunk extends ProtoChunk {
+     public BlockState getBlockState(BlockPos pos) {
+         return this.wrapped.getBlockState(pos);
+     }
+    // Paper start
+    public final BlockState getType(final int x, final int y, final int z) {
+        return this.wrapped.getBlockData(x, y, z);
+    }
+    // Paper end
+ 
+     @Override
+     public FluidState getFluidState(BlockPos pos) {
+diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+index ac17877ea6e210acfb54961a2818ca1ae7f6c738..6e998ca50d07e1ecb0cd0639b81cc07e8be71cb8 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+@@ -287,12 +287,28 @@ public class LevelChunk extends ChunkAccess {
+         });
+     }
+ 
+    // Paper start - Optimize getBlockData to reduce instructions
+     @Override
+     public BlockState getBlockState(BlockPos pos) {
+-        int i = pos.getX();
+-        int j = pos.getY();
+-        int k = pos.getZ();
+        return this.getBlockData(pos.getX(), pos.getY(), pos.getZ());
+    }
+
+    public BlockState getType(final int x, final int y, final int z) {
+        return this.getBlockData(x, y, z);
+    }
+    public final BlockState getBlockData(final int x, final int y, final int z) {
+        // Method body / logic copied from below
+        final int i = this.getSectionIndex(y);
+        if (i < 0 || i >= this.sections.length || this.sections[i] == null || this.sections[i].nonEmptyBlockCount == 0) {
+            return Blocks.AIR.defaultBlockState();
+        }
+        // Inlined ChunkSection.getType() and DataPaletteBlock.a(int,int,int)
+        return this.sections[i].states.get((y & 15) << 8 | (z & 15) << 4 | x & 15);
+ 
+    }
+
+    public BlockState getBlockData_unused(int i, int j, int k) {
+        // Paper end
+         if (this.level.isDebug()) {
+             BlockState iblockdata = null;
+ 
+diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
+index 10848c41b7f2f83717df650bd1fac7149c3a32af..92a42aea3f54c49e2055e8000645d91da9471e09 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
+++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
+@@ -20,7 +20,7 @@ public class LevelChunkSection {
+     public static final int SECTION_SIZE = 4096;
+     public static final int BIOME_CONTAINER_BITS = 2;
+     private final int bottomBlockY;
+-    private short nonEmptyBlockCount;
+    short nonEmptyBlockCount; // Paper - package-private
+     private short tickingBlockCount;
+     private short tickingFluidCount;
+     public final PalettedContainer<BlockState> states;
+diff --git a/src/main/java/net/minecraft/world/level/chunk/ProtoChunk.java b/src/main/java/net/minecraft/world/level/chunk/ProtoChunk.java
+index b7dbdcb0ce7948c6f98ec67d0cf2033a8e348085..568dc3c9cbf009a3892766cacdd00667556e27c5 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/ProtoChunk.java
+++ b/src/main/java/net/minecraft/world/level/chunk/ProtoChunk.java
+@@ -87,14 +87,18 @@ public class ProtoChunk extends ChunkAccess {
+ 
+     @Override
+     public BlockState getBlockState(BlockPos pos) {
+-        int i = pos.getY();
+-        if (this.isOutsideBuildHeight(i)) {
+        // Paper start
+        return getType(pos.getX(), pos.getY(), pos.getZ());
+    }
+    public BlockState getType(final int x, final int y, final int z) {
+        if (this.isOutsideBuildHeight(y)) {
+             return Blocks.VOID_AIR.defaultBlockState();
+         } else {
+-            LevelChunkSection levelChunkSection = this.getSection(this.getSectionIndex(i));
+-            return levelChunkSection.hasOnlyAir() ? Blocks.AIR.defaultBlockState() : levelChunkSection.getBlockState(pos.getX() & 15, i & 15, pos.getZ() & 15);
+            LevelChunkSection levelChunkSection = this.getSections()[this.getSectionIndex(y)];
+            return levelChunkSection.hasOnlyAir() ? Blocks.AIR.defaultBlockState() : levelChunkSection.getBlockState(x & 15, y & 15, z & 15);
+         }
+     }
+    // Paper end
+ 
+     @Override
+     public FluidState getFluidState(BlockPos pos) {
--- a/patches/server/0072-Only-process-BlockPhysicsEvent-if-a-plugin-has-a-lis.patch
+++ b/patches/server/0072-Only-process-BlockPhysicsEvent-if-a-plugin-has-a-lis.patch
@ -0,0 +1,95 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 28 Mar 2016 19:55:45 -0400
+Subject: [PATCH] Only process BlockPhysicsEvent if a plugin has a listener
+
+Saves on some object allocation and processing when no plugin listens to this
+
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 5cf85636e089a4bf2422d76b8df52c1166d3f148..697f2e6c10a74cb60191ed8c1cb563360089c8ea 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1366,6 +1366,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
+         while (iterator.hasNext()) {
+             ServerLevel worldserver = (ServerLevel) iterator.next();
+            worldserver.hasPhysicsEvent =  org.bukkit.event.block.BlockPhysicsEvent.getHandlerList().getRegisteredListeners().length > 0; // Paper
+ 
+             this.profiler.push(() -> {
+                 return worldserver + " " + worldserver.dimension().location();
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 9f7bbd602c19f317d05cd8b72453c2e37d8acff5..bd53d00db453767fb43ba0e50c0dc0a7730d55a4 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -205,6 +205,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+     private int tickPosition;
+     public final LevelStorageSource.LevelStorageAccess convertable;
+     public final UUID uuid;
+    public boolean hasPhysicsEvent = true; // Paper
+ 
+     @Override public LevelChunk getChunkIfLoaded(int x, int z) { // Paper - this was added in world too but keeping here for NMS ABI
+         return this.chunkSource.getChunk(x, z, false);
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index b6f2be487720e31a548a3cee4cd73319f402f6ff..bb6083b40e211964730f88057df509f6d860bc11 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -474,7 +474,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+                 // CraftBukkit start
+                 iblockdata1.updateIndirectNeighbourShapes(this, blockposition, k, j - 1); // Don't call an event for the old block to limit event spam
+                 CraftWorld world = ((ServerLevel) this).getWorld();
+-                if (world != null) {
+                if (world != null && ((ServerLevel)this).hasPhysicsEvent) { // Paper
+                     BlockPhysicsEvent event = new BlockPhysicsEvent(world.getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()), CraftBlockData.fromData(iblockdata));
+                     this.getCraftServer().getPluginManager().callEvent(event);
+ 
+@@ -587,7 +587,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+             try {
+                 // CraftBukkit start
+                 CraftWorld world = ((ServerLevel) this).getWorld();
+-                if (world != null) {
+                if (world != null && ((ServerLevel)this).hasPhysicsEvent) { // Paper
+                     BlockPhysicsEvent event = new BlockPhysicsEvent(world.getBlockAt(pos.getX(), pos.getY(), pos.getZ()), CraftBlockData.fromData(iblockdata), world.getBlockAt(neighborPos.getX(), neighborPos.getY(), neighborPos.getZ()));
+                     this.getCraftServer().getPluginManager().callEvent(event);
+ 
+diff --git a/src/main/java/net/minecraft/world/level/block/BushBlock.java b/src/main/java/net/minecraft/world/level/block/BushBlock.java
+index 24227939493f852a88477c84160bda1605291eb0..1f8cf302d2309aec2955832ffafd87f14934e141 100644
+--- a/src/main/java/net/minecraft/world/level/block/BushBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/BushBlock.java
+@@ -4,6 +4,7 @@ import net.minecraft.core.BlockPos;
+ import net.minecraft.core.Direction;
+ import net.minecraft.tags.BlockTags;
+ import net.minecraft.tags.Tag;
+import net.minecraft.server.level.ServerLevel;
+ import net.minecraft.world.level.BlockGetter;
+ import net.minecraft.world.level.LevelAccessor;
+ import net.minecraft.world.level.LevelReader;
+@@ -25,7 +26,7 @@ public class BushBlock extends Block {
+     public BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
+         // CraftBukkit start
+         if (!state.canSurvive(world, pos)) {
+-            if (!org.bukkit.craftbukkit.event.CraftEventFactory.callBlockPhysicsEvent(world, pos).isCancelled()) {
+            if (!(world instanceof ServerLevel && ((ServerLevel) world).hasPhysicsEvent) || !org.bukkit.craftbukkit.event.CraftEventFactory.callBlockPhysicsEvent(world, pos).isCancelled()) { // Paper
+                 return Blocks.AIR.defaultBlockState();
+             }
+         }
+diff --git a/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java b/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java
+index bad85ac1f369d1044fa2e68b6e49cebc3c253c5b..e12b76238cb52a1007f2102473b7f892f8521b62 100644
+--- a/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java
+@@ -4,6 +4,7 @@ import javax.annotation.Nullable;
+ import net.minecraft.core.BlockPos;
+ import net.minecraft.core.Direction;
+ import net.minecraft.util.Mth;
+import net.minecraft.server.level.ServerLevel;
+ import net.minecraft.world.entity.LivingEntity;
+ import net.minecraft.world.entity.player.Player;
+ import net.minecraft.world.item.ItemStack;
+@@ -93,7 +94,7 @@ public class DoublePlantBlock extends BushBlock {
+ 
+     protected static void preventCreativeDropFromBottomPart(Level world, BlockPos pos, BlockState state, Player player) {
+         // CraftBukkit start
+-        if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockPhysicsEvent(world, pos).isCancelled()) {
+        if (((ServerLevel)world).hasPhysicsEvent && org.bukkit.craftbukkit.event.CraftEventFactory.callBlockPhysicsEvent(world, pos).isCancelled()) { // Paper
+             return;
+         }
+         // CraftBukkit end
--- a/patches/server/0073-Entity-AddTo-RemoveFrom-World-Events.patch
+++ b/patches/server/0073-Entity-AddTo-RemoveFrom-World-Events.patch
@ -0,0 +1,26 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 28 Mar 2016 20:32:58 -0400
+Subject: [PATCH] Entity AddTo/RemoveFrom World Events
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index bd53d00db453767fb43ba0e50c0dc0a7730d55a4..9582da4afcc68b3c898be86dcf74f0833258e34c 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -1990,6 +1990,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+                 entity.setOrigin(entity.getOriginVector().toLocation(getWorld()));
+             }
+             // Paper end
+            new com.destroystokyo.paper.event.entity.EntityAddToWorldEvent(entity.getBukkitEntity()).callEvent(); // Paper - fire while valid
+         }
+ 
+         public void onTrackingEnd(Entity entity) {
+@@ -2054,6 +2055,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+             }
+ 
+             entity.valid = false; // CraftBukkit
+            new com.destroystokyo.paper.event.entity.EntityRemoveFromWorldEvent(entity.getBukkitEntity()).callEvent(); // Paper - fire while valid
+         }
+     }
+ }
--- a/patches/server/0074-Configurable-Chunk-Inhabited-Time.patch
+++ b/patches/server/0074-Configurable-Chunk-Inhabited-Time.patch
@ -0,0 +1,49 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 28 Mar 2016 20:46:14 -0400
+Subject: [PATCH] Configurable Chunk Inhabited Time
+
+Vanilla stores how long a chunk has been active on a server, and dynamically scales some
+aspects of vanilla gameplay to this factor.
+
+For people who want all chunks to be treated equally, you can chose a fixed value.
+
+This allows to fine-tune vanilla gameplay.
+
+diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+index 7addb5c66c88da73a4d80da1e898d629d76074f0..a0688ef7eb38e7c156193db3d94c44a3c290d8f2 100644
+--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+@@ -279,4 +279,14 @@ public class PaperWorldConfig {
+             skeleHorseSpawnChance = 0.01D; // Vanilla value
+         }
+     }
+
+    public int fixedInhabitedTime;
+    private void fixedInhabitedTime() {
+        if (PaperConfig.version < 16) {
+            if (!config.getBoolean("world-settings.default.use-chunk-inhabited-timer", true)) config.set("world-settings.default.fixed-chunk-inhabited-time", 0);
+            if (!config.getBoolean("world-settings." + worldName + ".use-chunk-inhabited-timer", true)) config.set("world-settings." + worldName + ".fixed-chunk-inhabited-time", 0);
+            set("use-chunk-inhabited-timer", null);
+        }
+        fixedInhabitedTime = getInt("fixed-chunk-inhabited-time", -1);
+    }
+ }
+diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+index 6e998ca50d07e1ecb0cd0639b81cc07e8be71cb8..e641779c58b503c88cb533a45a3614f45c4b8fa3 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+@@ -280,6 +280,13 @@ public class LevelChunk extends ChunkAccess {
+         return new ChunkAccess.TicksToSave(this.blockTicks, this.fluidTicks);
+     }
+ 
+    // Paper start
+    @Override
+    public long getInhabitedTime() {
+        return this.level.paperConfig.fixedInhabitedTime < 0 ? super.getInhabitedTime() : this.level.paperConfig.fixedInhabitedTime;
+    }
+    // Paper end
+
+     @Override
+     public GameEventDispatcher getEventDispatcher(int ySectionCoord) {
+         return (GameEventDispatcher) this.gameEventDispatcherSections.computeIfAbsent(ySectionCoord, (j) -> {
--- a/patches/server/0075-EntityPathfindEvent.patch
+++ b/patches/server/0075-EntityPathfindEvent.patch
@ -0,0 +1,110 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 28 Mar 2016 21:22:26 -0400
+Subject: [PATCH] EntityPathfindEvent
+
+Fires when an Entity decides to start moving to a location.
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/navigation/FlyingPathNavigation.java b/src/main/java/net/minecraft/world/entity/ai/navigation/FlyingPathNavigation.java
+index 57a17458dbe1629ebbf58fea9f43f09511b91fb0..dda38820f763f93513b5d83a4239197b48a45238 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/navigation/FlyingPathNavigation.java
+++ b/src/main/java/net/minecraft/world/entity/ai/navigation/FlyingPathNavigation.java
+@@ -35,7 +35,7 @@ public class FlyingPathNavigation extends PathNavigation {
+ 
+     @Override
+     public Path createPath(Entity entity, int distance) {
+-        return this.createPath(entity.blockPosition(), distance);
+        return this.createPath(entity.blockPosition(), entity, distance); // Paper - Forward target entity
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/ai/navigation/GroundPathNavigation.java b/src/main/java/net/minecraft/world/entity/ai/navigation/GroundPathNavigation.java
+index a9fd90d5282bd013e031b9d7481e3f777d6892c6..a6f8ca71ba5d107cfbd24b8e8a225195dc233637 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/navigation/GroundPathNavigation.java
+++ b/src/main/java/net/minecraft/world/entity/ai/navigation/GroundPathNavigation.java
+@@ -69,7 +69,7 @@ public class GroundPathNavigation extends PathNavigation {
+ 
+     @Override
+     public Path createPath(Entity entity, int distance) {
+-        return this.createPath(entity.blockPosition(), distance);
+        return this.createPath(entity.blockPosition(), entity, distance); // Paper - Forward target entity
+     }
+ 
+     private int getSurfaceY() {
+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 80c172b57857a19d5f78c6f06335dc7c957ccbb6..e10d377eb7540ed54ddcb6632afc2395c021b8ab 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
+@@ -10,6 +10,7 @@ import net.minecraft.core.BlockPos;
+ import net.minecraft.core.Vec3i;
+ import net.minecraft.network.protocol.game.DebugPackets;
+ import net.minecraft.tags.BlockTags;
+import net.minecraft.server.MCUtil;
+ import net.minecraft.util.Mth;
+ import net.minecraft.world.entity.Entity;
+ import net.minecraft.world.entity.Mob;
+@@ -110,7 +111,13 @@ public abstract class PathNavigation {
+ 
+     @Nullable
+     public Path createPath(BlockPos target, int distance) {
+-        return this.createPath(ImmutableSet.of(target), 8, false, distance);
+        // Paper start - add target entity parameter
+        return this.createPath(target, null, distance);
+    }
+    @Nullable
+    public Path createPath(BlockPos target, Entity entity, int distance) {
+        return this.createPath(ImmutableSet.of(target), entity, 8, false, distance);
+        // Paper end
+     }
+ 
+     @Nullable
+@@ -120,7 +127,7 @@ public abstract class PathNavigation {
+ 
+     @Nullable
+     public Path createPath(Entity entity, int distance) {
+-        return this.createPath(ImmutableSet.of(entity.blockPosition()), 16, true, distance);
+        return this.createPath(ImmutableSet.of(entity.blockPosition()), entity, 16, true, distance); // Paper
+     }
+ 
+     @Nullable
+@@ -130,6 +137,16 @@ public abstract class PathNavigation {
+ 
+     @Nullable
+     protected Path createPath(Set<BlockPos> positions, int range, boolean useHeadPos, int distance, float followRange) {
+        return this.createPath(positions, null, range, useHeadPos, distance, (float) this.mob.getAttributeValue(Attributes.FOLLOW_RANGE));
+    }
+
+    @Nullable
+    protected Path createPath(Set<BlockPos> positions, Entity target, int range, boolean useHeadPos, int distance) {
+        return this.createPath(positions, target, range, useHeadPos, distance, (float) this.mob.getAttributeValue(Attributes.FOLLOW_RANGE));
+    }
+
+    @Nullable protected Path createPath(Set<BlockPos> positions, Entity target, int range, boolean useHeadPos, int distance, float followRange) {
+        // Paper end
+         if (positions.isEmpty()) {
+             return null;
+         } else if (this.mob.getY() < (double)this.level.getMinBuildHeight()) {
+@@ -139,6 +156,23 @@ public abstract class PathNavigation {
+         } else if (this.path != null && !this.path.isDone() && positions.contains(this.targetPos)) {
+             return this.path;
+         } else {
+            // Paper start - Pathfind event
+            boolean copiedSet = false;
+            for (BlockPos possibleTarget : positions) {
+                if (!new com.destroystokyo.paper.event.entity.EntityPathfindEvent(this.mob.getBukkitEntity(),
+                    MCUtil.toLocation(this.mob.level, possibleTarget), target == null ? null : target.getBukkitEntity()).callEvent()) {
+                    if (!copiedSet) {
+                        copiedSet = true;
+                        positions = new java.util.HashSet<>(positions);
+                    }
+                    // note: since we copy the set this remove call is safe, since we're iterating over the old copy
+                    positions.remove(possibleTarget);
+                    if (positions.isEmpty()) {
+                        return null;
+                    }
+                }
+            }
+            // Paper end
+             this.level.getProfiler().push("pathfind");
+             BlockPos blockPos = useHeadPos ? this.mob.blockPosition().above() : this.mob.blockPosition();
+             int i = (int)(followRange + (float)range);