even even even even even even even even even even even

even even even even even even even even even even
even even even even even even even even even even
even even even even even even even even even even
even even even even even even even even even even
even even even even even even even even even even
even even even even even even even even even even

more work

patches/server-remapped/Do-not-let-armorstands-drown.patch

@@ -1,42 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Zach Brown <1254957+zachbr@users.noreply.github.com>
-Date: Sat, 18 Feb 2017 19:29:58 -0600
-Subject: [PATCH] Do not let armorstands drown
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity {
-         super.checkFallDamage(heightDifference, onGround, landedState, landedPosition);
-     }
- 
-+    public boolean canBreatheUnderwater() { return this.canBreatheUnderwater(); } // Paper - OBFHELPER
-     public boolean canBreatheUnderwater() {
-         return this.getMobType() == MobType.UNDEAD;
-     }
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity {
- 
-         if (this.isAlive()) {
-             if (this.isEyeInFluid((Tag) FluidTags.WATER) && !this.level.getBlockState(new BlockPos(this.getX(), this.getEyeY(), this.getZ())).is(Blocks.BUBBLE_COLUMN)) {
--                if (!this.canBreatheUnderwater() && !MobEffectUtil.c(this) && !flag1) {
-+                if (!this.canBreatheUnderwater() && !MobEffectUtil.c(this) && !flag1) {  // Paper - use OBFHELPER so it can be overridden
-                     this.setAirSupply(this.decreaseAirSupply(this.getAirSupply()));
-                     if (this.getAirSupply() == -20) {
-                         this.setAirSupply(0);
-diff --git a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-+++ b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
-             super.move(type, movement);
-         }
-     }
-+
-+    @Override
-+    public boolean canBreatheUnderwater() { // Skips a bit of damage handling code, probably a micro-optimization
-+        return true;
-+    }
-     // Paper end
- }

patches/server-remapped/Provide-E-TE-Chunk-count-stat-methods.patch

@@ -1,61 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sat, 7 Jan 2017 15:24:46 -0500
-Subject: [PATCH] Provide E/TE/Chunk count stat methods
-
-Provides counts without the ineffeciency of using .getEntities().size()
-which creates copy of the collections.
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -0,0 +0,0 @@ public class CraftWorld implements World {
-     private int waterAmbientSpawn = -1;
-     private int ambientSpawn = -1;
- 
-+    // Paper start - Provide fast information methods
-+    public int getEntityCount() {
-+        int ret = 0;
-+        for (net.minecraft.world.entity.Entity entity : world.entitiesById.values()) {
-+            if (entity.isChunkLoaded()) {
-+                ++ret;
-+            }
-+        }
-+        return ret;
-+    }
-+    public int getTileEntityCount() {
-+        // We don't use the full world tile entity list, so we must iterate chunks
-+        Long2ObjectLinkedOpenHashMap<ChunkHolder> chunks = world.getChunkSource().chunkMap.visibleChunkMap;
-+        int size = 0;
-+        for (ChunkHolder playerchunk : chunks.values()) {
-+            net.minecraft.world.level.chunk.LevelChunk chunk = playerchunk.getTickingChunk();
-+            if (chunk == null) {
-+                continue;
-+            }
-+            size += chunk.blockEntities.size();
-+        }
-+        return size;
-+    }
-+    public int getTickableTileEntityCount() {
-+        return world.tickableBlockEntities.size();
-+    }
-+    public int getChunkCount() {
-+        int ret = 0;
-+
-+        for (ChunkHolder chunkHolder : world.getChunkSource().chunkMap.visibleChunkMap.values()) {
-+            if (chunkHolder.getTickingChunk() != null) {
-+                ++ret;
-+            }
-+        }
-+
-+        return ret;
-+    }
-+    public int getPlayerCount() {
-+        return world.players.size();
-+    }
-+    // Paper end
-+
-     private static final Random rand = new Random();
- 
-     public CraftWorld(ServerLevel world, ChunkGenerator gen, Environment env) {

patches/server/Cap-Entity-Collisions.patch

@@ -30,7 +30,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/jav
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, CommandSource, net.minecraft.s
+@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, n
      public final org.spigotmc.ActivationRange.ActivationType activationType = org.spigotmc.ActivationRange.initializeEntityActivationType(this);
      public final boolean defaultActivationState;
      public long activatedTick = Integer.MIN_VALUE;
@@ -47,11 +47,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              }
  
 -            for (j = 0; j < list.size(); ++j) {
-+            numCollisions = Math.max(0, numCollisions - level.paperConfig.maxCollisionsPerEntity); // Paper
-+            for (j = 0; j < list.size() && numCollisions < level.paperConfig.maxCollisionsPerEntity; ++j) { // Paper
++            this.numCollisions = Math.max(0, this.numCollisions - this.level.paperConfig.maxCollisionsPerEntity); // Paper
++            for (j = 0; j < list.size() && this.numCollisions < this.level.paperConfig.maxCollisionsPerEntity; ++j) { // Paper
                  Entity entity = (Entity) list.get(j);
 +                entity.numCollisions++; // Paper
-+                numCollisions++; // Paper
++                this.numCollisions++; // Paper
  
                  this.doPush(entity);
              }

patches/server/Do-not-let-armorstands-drown.patch

@@ -0,0 +1,23 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <1254957+zachbr@users.noreply.github.com>
+Date: Sat, 18 Feb 2017 19:29:58 -0600
+Subject: [PATCH] Do not let armorstands drown
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
++++ b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
+             super.move(type, movement);
+         }
+     }
++
++    // Paper start
++    @Override
++    public boolean canBreatheUnderwater() { // Skips a bit of damage handling code, probably a micro-optimization
++        return true;
++    }
++    // Paper end
+     // Paper end
+ }

patches/server/Don-t-allow-entities-to-ride-themselves-572.patch

@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/jav
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, CommandSource, net.minecraft.s
+@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, n
      }
  
      protected boolean addPassenger(Entity entity) { // CraftBukkit

patches/server/Enforce-Sync-Player-Saves.patch

@@ -14,11 +14,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      public void saveAll() {
-+        MCUtil.ensureMain("Save Players" , () -> { // Paper - Ensure main
++        net.minecraft.server.MCUtil.ensureMain("Save Players" , () -> { // Paper - Ensure main
          MinecraftTimings.savePlayers.startTiming(); // Paper
          for (int i = 0; i < this.players.size(); ++i) {
 -            this.save((ServerPlayer) this.players.get(i));
-+            this.savePlayerFile((EntityPlayer) this.players.get(i));
++            this.save(this.players.get(i));
          }
          MinecraftTimings.savePlayers.stopTiming(); // Paper
 +        return null; }); // Paper - ensure main

patches/server/ExperienceOrbs-API-for-Reason-Source-Triggering-play.patch

@@ -16,7 +16,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  // Drop event experience
                  if (flag && event != null) {
 -                    iblockdata.getBlock().popExperience(this.level, pos, event.getExpToDrop());
-+                    iblockdata.getBlock().dropExperience(this.level, pos, event.getExpToDrop(), this.player); // Paper
++                    iblockdata.getBlock().popExperience(this.level, pos, event.getExpToDrop(), this.player); // Paper
                  }
  
                  return true;
@@ -26,8 +26,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
 @@ -0,0 +0,0 @@ public class ExperienceOrb extends Entity {
      public int value;
+     private int count;
      private Player followingPlayer;
-     private int followingTime;
 +    // Paper start
 +    public java.util.UUID sourceEntityId;
 +    public java.util.UUID triggerEntityId;
@@ -71,11 +71,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        this(world, x, y, z, amount, null, null);
 +    }
 +
-+    public EntityExperienceOrb(Level world, double d0, double d1, double d2, int i, org.bukkit.entity.ExperienceOrb.SpawnReason reason, Entity triggerId) {
++    public ExperienceOrb(Level world, double d0, double d1, double d2, int i, org.bukkit.entity.ExperienceOrb.SpawnReason reason, Entity triggerId) {
 +        this(world, d0, d1, d2, i, reason, triggerId, null);
 +    }
 +
-+    public EntityExperienceOrb(Level world, double d0, double d1, double d2, int i, org.bukkit.entity.ExperienceOrb.SpawnReason reason, Entity triggerId, Entity sourceId) {
++    public ExperienceOrb(Level world, double d0, double d1, double d2, int i, org.bukkit.entity.ExperienceOrb.SpawnReason reason, Entity triggerId, Entity sourceId) {
          this(EntityType.EXPERIENCE_ORB, world);
 -        this.setPos(x, y, z);
 +        this.sourceEntityId = sourceId != null ? sourceId.getUUID() : null;
@@ -83,7 +83,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        this.spawnReason = reason != null ? reason : org.bukkit.entity.ExperienceOrb.SpawnReason.UNKNOWN;
 +        // Paper end
 +        this.setPos(d0, d1, d2);
-         this.yRot = (float) (this.random.nextDouble() * 360.0D);
+         this.setYRot((float) (this.random.nextDouble() * 360.0D));
          this.setDeltaMovement((this.random.nextDouble() * 0.20000000298023224D - 0.10000000149011612D) * 2.0D, this.random.nextDouble() * 0.2D * 2.0D, (this.random.nextDouble() * 0.20000000298023224D - 0.10000000149011612D) * 2.0D);
 -        this.value = amount;
 +        this.value = i;
@@ -91,18 +91,40 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public ExperienceOrb(EntityType<? extends ExperienceOrb> type, Level world) {
 @@ -0,0 +0,0 @@ public class ExperienceOrb extends Entity {
-         tag.putShort("Health", (short) this.health);
-         tag.putShort("Age", (short) this.age);
-         tag.putShort("Value", (short) this.value);
-+        this.savePaperNBT(tag); // Paper
+     }
+ 
+     public static void award(ServerLevel world, Vec3 pos, int amount) {
++        // Paper start - add reasons for orbs
++        award(world, pos, amount, null, null, null);
++    }
++    public static void award(ServerLevel world, Vec3 pos, int amount, org.bukkit.entity.ExperienceOrb.SpawnReason reason, Entity triggerId) {
++        award(world, pos, amount, reason, triggerId, null);
++    }
++    public static void award(ServerLevel world, Vec3 pos, int amount, org.bukkit.entity.ExperienceOrb.SpawnReason reason, Entity triggerId, Entity sourceId) {
++        // Paper end - add reasons for orbs
+         while (amount > 0) {
+             int j = ExperienceOrb.getExperienceValue(amount);
+ 
+             amount -= j;
+             if (!ExperienceOrb.tryMergeToExisting(world, pos, j)) {
+-                world.addFreshEntity(new ExperienceOrb(world, pos.x(), pos.y(), pos.z(), j));
++                world.addFreshEntity(new ExperienceOrb(world, pos.x(), pos.y(), pos.z(), j, reason, triggerId, sourceId)); // Paper - add reason
+             }
+         }
+ 
+@@ -0,0 +0,0 @@ public class ExperienceOrb extends Entity {
+         nbt.putShort("Age", (short) this.age);
+         nbt.putShort("Value", (short) this.value);
+         nbt.putInt("Count", this.count);
++        this.savePaperNBT(nbt); // Paper
      }
  
      @Override
 @@ -0,0 +0,0 @@ public class ExperienceOrb extends Entity {
-         this.health = tag.getShort("Health");
-         this.age = tag.getShort("Age");
-         this.value = tag.getShort("Value");
-+        this.loadPaperNBT(tag); // Paper
+         this.age = nbt.getShort("Age");
+         this.value = nbt.getShort("Value");
+         this.count = Math.max(nbt.getInt("Count"), 1);
++        this.loadPaperNBT(nbt); // Paper
      }
  
      @Override
@@ -111,25 +133,25 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
 +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
 @@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity {
-                 int j = ExperienceOrb.getExperienceValue(i);
- 
-                 i -= j;
--                this.level.addFreshEntity(new ExperienceOrb(this.level, this.getX(), this.getY(), this.getZ(), j));
-+                LivingEntity attacker = lastHurtByPlayer != null ? lastHurtByPlayer : lastHurtByMob; // Paper
-+                this.level.addFreshEntity(new ExperienceOrb(this.level, this.getX(), this.getY(), this.getZ(), j, this instanceof ServerPlayer ? org.bukkit.entity.ExperienceOrb.SpawnReason.PLAYER_DEATH : org.bukkit.entity.ExperienceOrb.SpawnReason.ENTITY_DEATH, attacker, this)); // Paper
-             }
+     protected void dropExperience() {
+         // CraftBukkit start - Update getExpReward() above if the removed if() changes!
+         if (true) {
+-            ExperienceOrb.award((ServerLevel) this.level, this.position(), this.expToDrop);
++            LivingEntity attacker = this.lastHurtByPlayer != null ? this.lastHurtByPlayer : this.lastHurtByMob; // Paper
++            ExperienceOrb.award((ServerLevel) this.level, this.position(), this.expToDrop, this instanceof ServerPlayer ? org.bukkit.entity.ExperienceOrb.SpawnReason.PLAYER_DEATH : org.bukkit.entity.ExperienceOrb.SpawnReason.ENTITY_DEATH, attacker, this); // Paper
              this.expToDrop = 0;
          }
+         // CraftBukkit end
 diff --git a/src/main/java/net/minecraft/world/entity/animal/Animal.java b/src/main/java/net/minecraft/world/entity/animal/Animal.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/animal/Animal.java
 +++ b/src/main/java/net/minecraft/world/entity/animal/Animal.java
-@@ -0,0 +0,0 @@ public abstract class Animal extends AgableMob {
-             if (worldserver.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
+@@ -0,0 +0,0 @@ public abstract class Animal extends AgeableMob {
+             if (world.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
                  // CraftBukkit start - use event experience
                  if (experience > 0) {
--                    worldserver.addFreshEntity(new ExperienceOrb(worldserver, this.getX(), this.getY(), this.getZ(), experience));
-+                    worldserver.addFreshEntity(new ExperienceOrb(worldserver, this.getX(), this.getY(), this.getZ(), experience, org.bukkit.entity.ExperienceOrb.SpawnReason.BREED, entityplayer, entityageable)); // Paper
+-                    world.addFreshEntity(new ExperienceOrb(world, this.getX(), this.getY(), this.getZ(), experience));
++                    world.addFreshEntity(new ExperienceOrb(world, this.getX(), this.getY(), this.getZ(), experience, org.bukkit.entity.ExperienceOrb.SpawnReason.BREED, entityplayer, entityageable)); // Paper
                  }
                  // CraftBukkit end
              }
@@ -164,14 +186,23 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
 +++ b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
 @@ -0,0 +0,0 @@ public class EnderDragon extends Mob implements Enemy {
-             int j = ExperienceOrb.getExperienceValue(amount);
  
-             amount -= j;
--            this.level.addFreshEntity(new ExperienceOrb(this.level, this.getX(), this.getY(), this.getZ(), j));
-+            this.level.addFreshEntity(new ExperienceOrb(this.level, this.getX(), this.getY(), this.getZ(), j, org.bukkit.entity.ExperienceOrb.SpawnReason.ENTITY_DEATH, this.lastHurtByPlayer, this)); // Paper
-         }
+         if (this.level instanceof ServerLevel) {
+             if (this.dragonDeathTime > 150 && this.dragonDeathTime % 5 == 0 && flag) {
+-                ExperienceOrb.award((ServerLevel) this.level, this.position(), Mth.floor((float) short0 * 0.08F));
++                ExperienceOrb.award((ServerLevel) this.level, this.position(), Mth.floor((float) short0 * 0.08F), org.bukkit.entity.ExperienceOrb.SpawnReason.ENTITY_DEATH, this.lastHurtByPlayer, this); // Paper
+             }
  
-     }
+             if (this.dragonDeathTime == 1 && !this.isSilent()) {
+@@ -0,0 +0,0 @@ public class EnderDragon extends Mob implements Enemy {
+         this.yBodyRot = this.getYRot();
+         if (this.dragonDeathTime == 200 && this.level instanceof ServerLevel) {
+             if (flag) {
+-                ExperienceOrb.award((ServerLevel) this.level, this.position(), Mth.floor((float) short0 * 0.2F));
++                ExperienceOrb.award((ServerLevel) this.level, this.position(), Mth.floor((float) short0 * 0.2F), org.bukkit.entity.ExperienceOrb.SpawnReason.ENTITY_DEATH, this.lastHurtByPlayer, this); // Paper
+             }
+ 
+             if (this.dragonFight != null) {
 diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
@@ -210,20 +241,20 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                        entityhuman.level.addFreshEntity(new ExperienceOrb(entityhuman.level, entityhuman.getX(), entityhuman.getY() + 0.5D, entityhuman.getZ() + 0.5D, playerFishEvent.getExpToDrop(), org.bukkit.entity.ExperienceOrb.SpawnReason.FISHING, this.getPlayerOwner(), this)); // Paper
                      }
                      // CraftBukkit end
-                     if (itemstack1.getItem().is((Tag) ItemTags.FISHES)) {
+                     if (itemstack1.is((Tag) ItemTags.FISHES)) {
 diff --git a/src/main/java/net/minecraft/world/entity/projectile/ThrownExperienceBottle.java b/src/main/java/net/minecraft/world/entity/projectile/ThrownExperienceBottle.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/projectile/ThrownExperienceBottle.java
 +++ b/src/main/java/net/minecraft/world/entity/projectile/ThrownExperienceBottle.java
 @@ -0,0 +0,0 @@ public class ThrownExperienceBottle extends ThrowableItemProjectile {
-                 int j = ExperienceOrb.getExperienceValue(i);
- 
-                 i -= j;
--                this.level.addFreshEntity(new ExperienceOrb(this.level, this.getX(), this.getY(), this.getZ(), j));
-+                this.level.addFreshEntity(new ExperienceOrb(this.level, this.getX(), this.getY(), this.getZ(), j, org.bukkit.entity.ExperienceOrb.SpawnReason.EXP_BOTTLE, getOwner(), this)); // Paper
              }
+             // CraftBukkit end
+ 
+-            ExperienceOrb.award((ServerLevel) this.level, this.position(), i);
++            ExperienceOrb.award((ServerLevel) this.level, this.position(), i, org.bukkit.entity.ExperienceOrb.SpawnReason.EXP_BOTTLE, this.getOwner(), this); // Paper
+             this.discard();
+         }
  
-             this.remove();
 diff --git a/src/main/java/net/minecraft/world/inventory/FurnaceResultSlot.java b/src/main/java/net/minecraft/world/inventory/FurnaceResultSlot.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/inventory/FurnaceResultSlot.java
@@ -242,11 +273,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/inventory/GrindstoneMenu.java
 +++ b/src/main/java/net/minecraft/world/inventory/GrindstoneMenu.java
 @@ -0,0 +0,0 @@ public class GrindstoneMenu extends AbstractContainerMenu {
-                         int k = ExperienceOrb.getExperienceValue(j);
- 
-                         j -= k;
--                        world.addFreshEntity(new ExperienceOrb(world, (double) blockposition.getX(), (double) blockposition.getY() + 0.5D, (double) blockposition.getZ() + 0.5D, k));
-+                        world.addFreshEntity(new ExperienceOrb(world, (double) blockposition.getX(), (double) blockposition.getY() + 0.5D, (double) blockposition.getZ() + 0.5D, k, org.bukkit.entity.ExperienceOrb.SpawnReason.GRINDSTONE, player)); // Paper
+             public void onTake(net.minecraft.world.entity.player.Player player, ItemStack stack) {
+                 context.execute((world, blockposition) -> {
+                     if (world instanceof ServerLevel) {
+-                        ExperienceOrb.award((ServerLevel) world, Vec3.atCenterOf((Vec3i) blockposition), this.getExperienceAmount(world));
++                        ExperienceOrb.award((ServerLevel) world, Vec3.atCenterOf((Vec3i) blockposition), this.getExperienceAmount(world), org.bukkit.entity.ExperienceOrb.SpawnReason.GRINDSTONE, player); // Paper
                      }
  
                      world.levelEvent(1042, blockposition, 0);
@@ -255,48 +286,43 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/level/block/Block.java
 +++ b/src/main/java/net/minecraft/world/level/block/Block.java
 @@ -0,0 +0,0 @@ public class Block extends BlockBehaviour implements ItemLike {
-         }
      }
  
--    public void popExperience(ServerLevel world, BlockPos pos, int size) {
--        if (world.getGameRules().getBoolean(GameRules.RULE_DOBLOCKDROPS)) {
--            while (size > 0) {
--                int j = ExperienceOrb.getExperienceValue(size);
-+    public void dropExperience(ServerLevel worldserver, BlockPos blockposition, int i, net.minecraft.server.level.ServerPlayer player) { // Paper
-+        if (worldserver.getGameRules().getBoolean(GameRules.RULE_DOBLOCKDROPS)) {
-+            while (i > 0) {
-+                int j = ExperienceOrb.getExperienceValue(i);
- 
--                size -= j;
--                world.addFreshEntity(new ExperienceOrb(world, (double) pos.getX() + 0.5D, (double) pos.getY() + 0.5D, (double) pos.getZ() + 0.5D, j));
-+                i -= j;
-+                worldserver.addFreshEntity(new ExperienceOrb(worldserver, (double) blockposition.getX() + 0.5D, (double) blockposition.getY() + 0.5D, (double) blockposition.getZ() + 0.5D, j, org.bukkit.entity.ExperienceOrb.SpawnReason.BLOCK_BREAK, player)); // Paper
-             }
+     public void popExperience(ServerLevel world, BlockPos pos, int size) {
++        // Paper start - add player parameter
++        popExperience(world, pos, size, null);
++    }
++    public void popExperience(ServerLevel world, BlockPos pos, int size, net.minecraft.server.level.ServerPlayer player) {
++        // Paper end - add player parameter
+         if (world.getGameRules().getBoolean(GameRules.RULE_DOBLOCKDROPS)) {
+-            ExperienceOrb.award(world, Vec3.atCenterOf((Vec3i) pos), size);
++            ExperienceOrb.award(world, Vec3.atCenterOf((Vec3i) pos), size, org.bukkit.entity.ExperienceOrb.SpawnReason.BLOCK_BREAK, player); // Paper
          }
  
+     }
 diff --git a/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
 +++ b/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
 @@ -0,0 +0,0 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
-             int k = ExperienceOrb.getExperienceValue(j);
- 
-             j -= k;
--            world.addFreshEntity(new ExperienceOrb(world, vec3d.x, vec3d.y, vec3d.z, k));
-+            world.addFreshEntity(new ExperienceOrb(world, vec3d.x, vec3d.y, vec3d.z, k, org.bukkit.entity.ExperienceOrb.SpawnReason.FURNACE, entityhuman)); // Paper
          }
+         // CraftBukkit end
  
+-        ExperienceOrb.award(worldserver, vec3d, j);
++        ExperienceOrb.award(worldserver, vec3d, j, org.bukkit.entity.ExperienceOrb.SpawnReason.FURNACE, entityhuman); // Paper
      }
+ 
+     @Override
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 @@ -0,0 +0,0 @@ public class CraftWorld implements World {
          } else if (TNTPrimed.class.isAssignableFrom(clazz)) {
-             entity = new PrimedTnt(world, x, y, z, null);
+             entity = new PrimedTnt(this.world, x, y, z, null);
          } else if (ExperienceOrb.class.isAssignableFrom(clazz)) {
--            entity = new net.minecraft.world.entity.ExperienceOrb(world, x, y, z, 0);
-+            entity = new net.minecraft.world.entity.ExperienceOrb(world, x, y, z, 0, org.bukkit.entity.ExperienceOrb.SpawnReason.CUSTOM, null, null); // Paper
+-            entity = new net.minecraft.world.entity.ExperienceOrb(this.world, x, y, z, 0);
++            entity = new net.minecraft.world.entity.ExperienceOrb(this.world, x, y, z, 0, org.bukkit.entity.ExperienceOrb.SpawnReason.CUSTOM, null, null); // Paper
          } else if (LightningStrike.class.isAssignableFrom(clazz)) {
              entity = net.minecraft.world.entity.EntityType.LIGHTNING_BOLT.create(world);
          } else if (AreaEffectCloud.class.isAssignableFrom(clazz)) {
@@ -304,15 +330,8 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftExperienceOrb.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftExperienceOrb.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftExperienceOrb.java
-@@ -0,0 +0,0 @@
- package org.bukkit.craftbukkit.entity;
- 
-+import SpawnReason;
- import org.bukkit.craftbukkit.CraftServer;
- import org.bukkit.entity.EntityType;
- import org.bukkit.entity.ExperienceOrb;
 @@ -0,0 +0,0 @@ public class CraftExperienceOrb extends CraftEntity implements ExperienceOrb {
-         getHandle().value = value;
+         this.getHandle().value = value;
      }
  
 +    // Paper start

patches/server/Firework-API-s.patch

@@ -4,52 +4,40 @@ Date: Wed, 28 Dec 2016 07:18:33 +0100
 Subject: [PATCH] Firework API's
 
 
-diff --git a/src/main/java/net/minecraft/nbt/CompoundTag.java b/src/main/java/net/minecraft/nbt/CompoundTag.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/nbt/CompoundTag.java
-+++ b/src/main/java/net/minecraft/nbt/CompoundTag.java
-@@ -0,0 +0,0 @@ public class CompoundTag implements Tag {
-         return NbtUtils.loadUUID(this.get(key));
-     }
- 
-+    public final boolean hasUUID(String s) { return this.hasUUID(s); } // Paper - OBFHELPER
-     public boolean hasUUID(String key) {
-         Tag nbtbase = this.get(key);
- 
 diff --git a/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java b/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java
 +++ b/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java
-@@ -0,0 +0,0 @@ public class FireworkRocketEntity extends Projectile {
-     public static final EntityDataAccessor<Boolean> DATA_SHOT_AT_ANGLE = SynchedEntityData.defineId(FireworkRocketEntity.class, EntityDataSerializers.BOOLEAN);
+@@ -0,0 +0,0 @@ public class FireworkRocketEntity extends Projectile implements ItemSupplier {
      private int life;
      public int lifetime;
+     @Nullable
 -    private LivingEntity attachedToEntity;
-+    public LivingEntity attachedToEntity; // Paper - public
++    public LivingEntity attachedToEntity; // Paper - private -> public
 +    public java.util.UUID spawningEntity; // Paper
  
      public FireworkRocketEntity(EntityType<? extends FireworkRocketEntity> type, Level world) {
          super(type, world);
-@@ -0,0 +0,0 @@ public class FireworkRocketEntity extends Projectile {
+@@ -0,0 +0,0 @@ public class FireworkRocketEntity extends Projectile implements ItemSupplier {
          }
  
-         tag.putBoolean("ShotAtAngle", (Boolean) this.entityData.get(FireworkRocketEntity.DATA_SHOT_AT_ANGLE));
+         nbt.putBoolean("ShotAtAngle", (Boolean) this.entityData.get(FireworkRocketEntity.DATA_SHOT_AT_ANGLE));
 +        // Paper start
 +        if (this.spawningEntity != null) {
-+            tag.setUUID("SpawningEntity", this.spawningEntity);
++            nbt.setUUID("SpawningEntity", this.spawningEntity);
 +        }
 +        // Paper end
      }
  
      @Override
-@@ -0,0 +0,0 @@ public class FireworkRocketEntity extends Projectile {
-         if (tag.contains("ShotAtAngle")) {
-             this.entityData.set(FireworkRocketEntity.DATA_SHOT_AT_ANGLE, tag.getBoolean("ShotAtAngle"));
+@@ -0,0 +0,0 @@ public class FireworkRocketEntity extends Projectile implements ItemSupplier {
+         if (nbt.contains("ShotAtAngle")) {
+             this.entityData.set(FireworkRocketEntity.DATA_SHOT_AT_ANGLE, nbt.getBoolean("ShotAtAngle"));
          }
 -
 +        // Paper start
-+        if (tag.hasUUID("SpawningEntity")) {
-+            this.spawningEntity = tag.getUUID("SpawningEntity");
++        if (nbt.hasUUID("SpawningEntity")) {
++            this.spawningEntity = nbt.getUUID("SpawningEntity");
 +        }
 +        // Paper end
      }
@@ -65,48 +53,35 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  object = new FireworkRocketEntity(world, projectile, shooter, shooter.getX(), shooter.getEyeY() - 0.15000000596046448D, shooter.getZ(), true);
 +                ((FireworkRocketEntity) object).spawningEntity = shooter.getUUID(); // Paper
              } else {
-                 object = getArrow(world, shooter, crossbow, projectile);
+                 object = CrossbowItem.getArrow(world, shooter, crossbow, projectile);
                  if (creative || simulated != 0.0F) {
 diff --git a/src/main/java/net/minecraft/world/item/FireworkRocketItem.java b/src/main/java/net/minecraft/world/item/FireworkRocketItem.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/item/FireworkRocketItem.java
 +++ b/src/main/java/net/minecraft/world/item/FireworkRocketItem.java
 @@ -0,0 +0,0 @@ public class FireworkRocketItem extends Item {
-             Vec3 vec3d = context.getClickLocation();
-             Direction enumdirection = context.getClickedFace();
-             FireworkRocketEntity entityfireworks = new FireworkRocketEntity(world, context.getPlayer(), vec3d.x + (double) enumdirection.getStepX() * 0.15D, vec3d.y + (double) enumdirection.getStepY() * 0.15D, vec3d.z + (double) enumdirection.getStepZ() * 0.15D, itemstack);
-+            entityfireworks.spawningEntity = context.getPlayer().getUUID(); // Paper
- 
-             world.addFreshEntity(entityfireworks);
-             itemstack.shrink(1);
+             Vec3 vec3 = context.getClickLocation();
+             Direction direction = context.getClickedFace();
+             FireworkRocketEntity fireworkRocketEntity = new FireworkRocketEntity(level, context.getPlayer(), vec3.x + (double)direction.getStepX() * 0.15D, vec3.y + (double)direction.getStepY() * 0.15D, vec3.z + (double)direction.getStepZ() * 0.15D, itemStack);
++            fireworkRocketEntity.spawningEntity = context.getPlayer() == null ? null : context.getPlayer().getUUID(); // Paper
+             level.addFreshEntity(fireworkRocketEntity);
+             itemStack.shrink(1);
+         }
 @@ -0,0 +0,0 @@ public class FireworkRocketItem extends Item {
-             ItemStack itemstack = user.getItemInHand(hand);
- 
+             ItemStack itemStack = user.getItemInHand(hand);
              if (!world.isClientSide) {
--                world.addFreshEntity(new FireworkRocketEntity(world, itemstack, user));
-+                // Paper start
-+                final FireworkRocketEntity entityfireworks = new FireworkRocketEntity(world, itemstack, user);
-+                entityfireworks.spawningEntity = user.getUUID();
-+                world.addFreshEntity(entityfireworks);
-+                // Paper end
-                 if (!user.abilities.instabuild) {
-                     itemstack.shrink(1);
-                 }
+                 FireworkRocketEntity fireworkRocketEntity = new FireworkRocketEntity(world, itemStack, user);
++                fireworkRocketEntity.spawningEntity = user.getUUID(); // Paper
+                 world.addFreshEntity(fireworkRocketEntity);
+                 if (!user.getAbilities().instabuild) {
+                     itemStack.shrink(1);
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftFirework.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftFirework.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftFirework.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftFirework.java
-@@ -0,0 +0,0 @@
- package org.bukkit.craftbukkit.entity;
- 
- import java.util.Random;
-+import net.minecraft.world.entity.LivingEntity;
- import net.minecraft.world.entity.projectile.FireworkRocketEntity;
- import net.minecraft.world.item.ItemStack;
- import net.minecraft.world.item.Items;
 @@ -0,0 +0,0 @@ public class CraftFirework extends CraftProjectile implements Firework {
      public void setShotAtAngle(boolean shotAtAngle) {
-         getHandle().getEntityData().set(FireworkRocketEntity.DATA_SHOT_AT_ANGLE, shotAtAngle);
+         this.getHandle().getEntityData().set(FireworkRocketEntity.DATA_SHOT_AT_ANGLE, shotAtAngle);
      }
 +
 +    // Paper start
@@ -117,7 +92,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public org.bukkit.entity.LivingEntity getBoostedEntity() {
-+        LivingEntity boostedEntity = getHandle().attachedToEntity;
++        net.minecraft.world.entity.LivingEntity boostedEntity = getHandle().attachedToEntity;
 +        return boostedEntity != null ? (org.bukkit.entity.LivingEntity) boostedEntity.getBukkitEntity() : null;
 +    }
 +    // Paper end

patches/server/Make-targetSize-more-aggressive-in-the-chunk-unload-.patch

@@ -8,30 +8,21 @@ diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/j
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java
 +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
-@@ -0,0 +0,0 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
-     private final PlayerMap playerMap;
-     public final Int2ObjectMap<ChunkMap.TrackedEntity> entityMap;
-     private final Long2ByteMap chunkTypeCache;
--    private final Queue<Runnable> unloadQueue;
-+    private final Queue<Runnable> unloadQueue; private final Queue<Runnable> getUnloadQueueTasks() { return this.unloadQueue; } // Paper - OBFHELPER
-     private int viewDistance;
- 
-     // CraftBukkit start - recursion-safe executor for Chunk loadCallback() and unloadCallback()
 @@ -0,0 +0,0 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
          this.playerMap = new PlayerMap();
          this.entityMap = new Int2ObjectOpenHashMap();
          this.chunkTypeCache = new Long2ByteOpenHashMap();
 -        this.unloadQueue = Queues.newConcurrentLinkedQueue();
 +        this.unloadQueue = new com.destroystokyo.paper.utils.CachedSizeConcurrentLinkedQueue<>(); // Paper - need constant-time size()
-         this.structureManager = definedstructuremanager;
-         this.storageFolder = convertable_conversionsession.getDimensionPath(worldserver.dimension());
-         this.level = worldserver;
+         this.structureManager = structureManager;
+         this.storageFolder = session.getDimensionPath(world.dimension());
+         this.level = world;
 @@ -0,0 +0,0 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
          // Spigot start
          org.spigotmc.SlackActivityAccountant activityAccountant = this.level.getServer().slackActivityAccountant;
          activityAccountant.startActivity(0.5);
--        int targetSize = (int) (this.toDrop.size() * UNLOAD_QUEUE_RESIZE_FACTOR);
-+        int targetSize = Math.min(this.toDrop.size() - 100,  (int) (this.toDrop.size() * UNLOAD_QUEUE_RESIZE_FACTOR)); // Paper - Make more aggressive
+-        int targetSize = (int) (this.toDrop.size() * ChunkMap.UNLOAD_QUEUE_RESIZE_FACTOR);
++        int targetSize = Math.min(this.toDrop.size() - 100,  (int) (this.toDrop.size() * ChunkMap.UNLOAD_QUEUE_RESIZE_FACTOR)); // Paper - Make more aggressive
          // Spigot end
          while (longiterator.hasNext()) { // Spigot
              long j = longiterator.nextLong();
@@ -40,8 +31,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          Runnable runnable;
  
 -        while ((shouldKeepTicking.getAsBoolean() || this.unloadQueue.size() > 2000) && (runnable = (Runnable) this.unloadQueue.poll()) != null) {
-+        int queueTarget = Math.min(this.getUnloadQueueTasks().size() - 100, (int) (this.getUnloadQueueTasks().size() * UNLOAD_QUEUE_RESIZE_FACTOR)); // Paper - Target this queue as well
-+        while ((shouldKeepTicking.getAsBoolean() || this.getUnloadQueueTasks().size() > queueTarget) && (runnable = (Runnable)this.getUnloadQueueTasks().poll()) != null) { // Paper - Target this queue as well
++        int queueTarget = Math.min(this.unloadQueue.size() - 100, (int) (this.unloadQueue.size() * UNLOAD_QUEUE_RESIZE_FACTOR)); // Paper - Target this queue as well
++        while ((shouldKeepTicking.getAsBoolean() || this.unloadQueue.size() > queueTarget) && (runnable = (Runnable)this.unloadQueue.poll()) != null) { // Paper - Target this queue as well
              runnable.run();
          }
  

patches/server/PlayerTeleportEndGatewayEvent.patch

@@ -17,12 +17,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  import net.minecraft.server.level.ServerLevel;
  import net.minecraft.server.level.ServerPlayer;
  import net.minecraft.util.Mth;
-@@ -0,0 +0,0 @@ public class TheEndGatewayBlockEntity extends TheEndPortalBlockEntity implements
+@@ -0,0 +0,0 @@ public class TheEndGatewayBlockEntity extends TheEndPortalBlockEntity {
                      location.setPitch(player.getLocation().getPitch());
                      location.setYaw(player.getLocation().getYaw());
  
 -                    PlayerTeleportEvent teleEvent = new PlayerTeleportEvent(player, player.getLocation(), location, PlayerTeleportEvent.TeleportCause.END_GATEWAY);
-+                    PlayerTeleportEvent teleEvent = new com.destroystokyo.paper.event.player.PlayerTeleportEndGatewayEvent(player, player.getLocation(), location, new org.bukkit.craftbukkit.block.CraftEndGateway(MCUtil.toLocation(level, this.getBlockPos()).getBlock())); // Paper
++                    PlayerTeleportEvent teleEvent = new com.destroystokyo.paper.event.player.PlayerTeleportEndGatewayEvent(player, player.getLocation(), location, new org.bukkit.craftbukkit.block.CraftEndGateway(net.minecraft.server.MCUtil.toLocation(worldserver, blockEntity.getBlockPos()).getBlock())); // Paper
                      Bukkit.getPluginManager().callEvent(teleEvent);
                      if (teleEvent.isCancelled()) {
                          return;

patches/server/Properly-fix-item-duplication-bug.patch

@@ -9,13 +9,11 @@ diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/ma
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
 +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player implements ContainerListener {
-     }
+@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
  
      @Override
--    public boolean isImmobile() {
--        return super.isImmobile() || !getBukkitEntity().isOnline();
-+    protected boolean isImmobile() {
+     public boolean isImmobile() {
+-        return super.isImmobile() || !this.getBukkitEntity().isOnline();
 +        return super.isImmobile() || (this.connection != null && this.connection.isDisconnected()); // Paper
      }
  
@@ -24,7 +22,7 @@ diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListener
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerGamePacketListener {
+@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
      }
  
      public final boolean isDisconnected() {

patches/server/Properly-handle-async-calls-to-restart-the-server.patch

@@ -46,60 +46,43 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              MinecraftServer.LOGGER.info("Saving players");
              this.playerList.saveAll();
 -            this.playerList.removeAll();
-+            this.playerList.shutdown(this.isRestarting); // Paper
++            this.playerList.removeAll(this.isRestarting); // Paper
              try { Thread.sleep(100); } catch (InterruptedException ex) {} // CraftBukkit - SPIGOT-625 - give server at least a chance to send packets
          }
  
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         return this.running;
      }
  
-+    // Paper start - allow passing of the intent to restart
      public void halt(boolean flag) {
++        // Paper start - allow passing of the intent to restart
 +        this.safeShutdown(flag, false);
 +    }
 +    public void safeShutdown(boolean flag, boolean isRestarting) {
-         this.running = false;
 +        this.isRestarting = isRestarting;
++        // Paper end
+         this.running = false;
          if (flag) {
              try {
-                 this.serverThread.join();
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         }
- 
-     }
-+    // Paper end
- 
-     // Spigot Start
-     private static double calcTps(double avg, double exp, double tps)
 diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/players/PlayerList.java
 +++ b/src/main/java/net/minecraft/server/players/PlayerList.java
 @@ -0,0 +0,0 @@ public abstract class PlayerList {
-         player.gameMode.updateGameMode(world.worldDataServer.getGameType()); // CraftBukkit
      }
  
-+    // Paper start - Extract method to allow for restarting flag
      public void removeAll() {
-+        this.shutdown(false);
++        // Paper start - Extract method to allow for restarting flag
++        this.removeAll(false);
 +    }
 +
-+    public void shutdown(boolean isRestarting) {
++    public void removeAll(boolean isRestarting) {
++        // Paper end
          // CraftBukkit start - disconnect safely
          for (ServerPlayer player : this.players) {
 +            if (isRestarting) player.connection.disconnect(org.spigotmc.SpigotConfig.restartMessage); else // Paper
              player.connection.disconnect(this.server.server.shutdownMessage()); // CraftBukkit - add custom shutdown message // Paper - Adventure
          }
          // CraftBukkit end
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-         }
-         // Paper end
-     }
-+    // Paper end
- 
-     // CraftBukkit start
-     public void sendMessage(Component[] iChatBaseComponents) {
 diff --git a/src/main/java/org/spigotmc/RestartCommand.java b/src/main/java/org/spigotmc/RestartCommand.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/spigotmc/RestartCommand.java

patches/server/Provide-E-TE-Chunk-count-stat-methods.patch

@@ -0,0 +1,96 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sat, 7 Jan 2017 15:24:46 -0500
+Subject: [PATCH] Provide E/TE/Chunk count stat methods
+
+Provides counts without the ineffeciency of using .getEntities().size()
+which creates copy of the collections.
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -0,0 +0,0 @@ public class ServerLevel extends net.minecraft.world.level.Level implements Worl
+     public static final BlockPos END_SPAWN_POINT = new BlockPos(100, 50, 0);
+     private static final Logger LOGGER = LogManager.getLogger();
+     private static final int EMPTY_TIME_NO_TICK = 300;
+-    final List<ServerPlayer> players;
++    final List<ServerPlayer> players; public final int getPlayerListSize() { return this.players.size(); } // Paper
+     public final ServerChunkCache chunkSource; // Paper - public
+     private final MinecraftServer server;
+     public final PrimaryLevelData serverLevelData; // CraftBukkit - type
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
++++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+     public static final int TICKS_PER_DAY = 24000;
+     public static final int MAX_ENTITY_SPAWN_Y = 20000000;
+     public static final int MIN_ENTITY_SPAWN_Y = -20000000;
+-    protected final List<TickingBlockEntity> blockEntityTickers = Lists.newArrayList();
++    protected final List<TickingBlockEntity> blockEntityTickers = Lists.newArrayList(); public final int getTotalTileEntityTickers() { return this.blockEntityTickers.size(); } // Paper
+     private final List<TickingBlockEntity> pendingBlockEntityTickers = Lists.newArrayList();
+     private boolean tickingBlockEntities;
+     public final Thread thread;
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -0,0 +0,0 @@ public class CraftWorld implements World {
+     private int waterAmbientSpawn = -1;
+     private int ambientSpawn = -1;
+ 
++    // Paper start - Provide fast information methods
++    @Override
++    public int getEntityCount() {
++        int ret = 0;
++        for (net.minecraft.world.entity.Entity entity : world.getEntities().getAll()) {
++            if (entity.isChunkLoaded()) {
++                ++ret;
++            }
++        }
++        return ret;
++    }
++
++    @Override
++    public int getTileEntityCount() {
++        // We don't use the full world tile entity list, so we must iterate chunks
++        Long2ObjectLinkedOpenHashMap<ChunkHolder> chunks = world.getChunkSource().chunkMap.visibleChunkMap;
++        int size = 0;
++        for (ChunkHolder playerchunk : chunks.values()) {
++            net.minecraft.world.level.chunk.LevelChunk chunk = playerchunk.getTickingChunk();
++            if (chunk == null) {
++                continue;
++            }
++            size += chunk.blockEntities.size();
++        }
++        return size;
++    }
++
++    @Override
++    public int getTickableTileEntityCount() {
++        return world.getTotalTileEntityTickers();
++    }
++
++    @Override
++    public int getChunkCount() {
++        int ret = 0;
++
++        for (ChunkHolder chunkHolder : world.getChunkSource().chunkMap.visibleChunkMap.values()) {
++            if (chunkHolder.getTickingChunk() != null) {
++                ++ret;
++            }
++        }
++
++        return ret;
++    }
++
++    @Override
++    public int getPlayerCount() {
++        return world.getPlayerListSize();
++    }
++    // Paper end
++
+     private static final Random rand = new Random();
+ 
+     public CraftWorld(ServerLevel world, ChunkGenerator gen, Environment env) {

patches/server/Remove-CraftScheduler-Async-Task-Debugger.patch

@@ -14,19 +14,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
 @@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
                  }
-                 parsePending();
+                 this.parsePending();
              } else {
--                debugTail = debugTail.setNext(new CraftAsyncDebugger(currentTick + RECENT_TICKS, task.getOwner(), task.getTaskClass()));
-+                //debugTail = debugTail.setNext(new CraftAsyncDebugger(currentTick + RECENT_TICKS, task.getOwner(), task.getTaskClass())); // Paper
-                 executor.execute(new ServerSchedulerReportingWrapper(task)); // Paper
+-                this.debugTail = this.debugTail.setNext(new CraftAsyncDebugger(currentTick + CraftScheduler.RECENT_TICKS, task.getOwner(), task.getTaskClass()));
++                //this.debugTail = this.debugTail.setNext(new CraftAsyncDebugger(currentTick + CraftScheduler.RECENT_TICKS, task.getOwner(), task.getTaskClass())); // Paper
+                 this.executor.execute(new 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)
 @@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
-         pending.addAll(temp);
+         this.pending.addAll(temp);
          temp.clear();
-         MinecraftTimings.bukkitSchedulerFinishTimer.stopTiming();
--        debugHead = debugHead.getNextHead(currentTick);
-+        //debugHead = debugHead.getNextHead(currentTick); // Paper
+         MinecraftTimings.bukkitSchedulerFinishTimer.stopTiming(); // Paper
+-        this.debugHead = this.debugHead.getNextHead(currentTick);
++        //this.debugHead = this.debugHead.getNextHead(currentTick); // Paper
      }
  
      private void addTask(final CraftTask task) {
@@ -37,9 +37,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        // Paper start
 +        return "";
 +        /*
-         int debugTick = currentTick;
-         StringBuilder string = new StringBuilder("Recent tasks from ").append(debugTick - RECENT_TICKS).append('-').append(debugTick).append('{');
-         debugHead.debugTo(string);
+         int debugTick = this.currentTick;
+         StringBuilder string = new StringBuilder("Recent tasks from ").append(debugTick - CraftScheduler.RECENT_TICKS).append('-').append(debugTick).append('{');
+         this.debugHead.debugTo(string);
          return string.append('}').toString();
 +        */
 +        // Paper end