242

2024-10-23 12:32:08 +02:00 · 2024-10-23 12:32:08 +02:00 · a400929816
commit a400929816
parent 7c04a31c9f
29 changed files with 223 additions and 219 deletions
--- a/patches/server/0213-Improve-BlockPosition-inlining.patch
+++ b/patches/server/0213-Improve-BlockPosition-inlining.patch
@ -0,0 +1,60 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Techcable <Techcable@outlook.com>
+Date: Wed, 30 Nov 2016 20:56:58 -0600
+Subject: [PATCH] Improve BlockPosition inlining
+
+Normally the JVM can inline virtual getters by having two sets of code, one is the 'optimized' code and the other is the 'deoptimized' code.
+If a single type is used 99% of the time, then its worth it to inline, and to revert to 'deoptimized' the 1% of the time we encounter other types.
+But if two types are encountered commonly, then the JVM can't inline them both, and the call overhead remains.
+
+This scenario also occurs with BlockPos and MutableBlockPos.
+The variables in BlockPos are final, so MutableBlockPos can't modify them.
+MutableBlockPos fixes this by adding custom mutable variables, and overriding the getters to access them.
+
+This approach with utility methods that operate on MutableBlockPos and BlockPos.
+Specific examples are BlockPosition.up(), and World.isValidLocation().
+It makes these simple methods much slower than they need to be.
+
+This should result in an across the board speedup in anything that accesses blocks or does logic with positions.
+
+This is based upon conclusions drawn from inspecting the assenmbly generated bythe JIT compiler on my microbenchmarks.
+They had 'callq' (invoke) instead of 'mov' (get from memory) instructions.
+
+diff --git a/src/main/java/net/minecraft/core/Vec3i.java b/src/main/java/net/minecraft/core/Vec3i.java
+index 671550477476a7252a52686aa60fe6454eda2055..7d5f99cac756c54e5922bf85d5d359edcc21f1e8 100644
+--- a/src/main/java/net/minecraft/core/Vec3i.java
+++ b/src/main/java/net/minecraft/core/Vec3i.java
+@@ -35,12 +35,12 @@ public class Vec3i implements Comparable<Vec3i> {
+     }
+ 
+     @Override
+-    public boolean equals(Object object) {
+    public final boolean equals(Object object) { // Paper - Perf: Final for inline
+         return this == object || object instanceof Vec3i vec3i && this.getX() == vec3i.getX() && this.getY() == vec3i.getY() && this.getZ() == vec3i.getZ();
+     }
+ 
+     @Override
+-    public int hashCode() {
+    public final int hashCode() { // Paper - Perf: Final for inline
+         return (this.getY() + this.getZ() * 31) * 31 + this.getX();
+     }
+ 
+@@ -53,15 +53,15 @@ public class Vec3i implements Comparable<Vec3i> {
+         }
+     }
+ 
+-    public int getX() {
+    public final int getX() { // Paper - Perf: Final for inline
+         return this.x;
+     }
+ 
+-    public int getY() {
+    public final int getY() { // Paper - Perf: Final for inline
+         return this.y;
+     }
+ 
+-    public int getZ() {
+    public final int getZ() { // Paper - Perf: Final for inline
+         return this.z;
+     }
+ 
--- a/patches/server/0214-Option-to-prevent-armor-stands-from-doing-entity-loo.patch
+++ b/patches/server/0214-Option-to-prevent-armor-stands-from-doing-entity-loo.patch
@ -0,0 +1,36 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Hugo Manrique <hugmanrique@gmail.com>
+Date: Mon, 23 Jul 2018 12:57:39 +0200
+Subject: [PATCH] Option to prevent armor stands from doing entity lookups
+
+
+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 aea97a30a9226275f8fbf9cb2c15d5ddf36371ac..e9d6211eb0f955eb95d2f73ad96799ef4740d506 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+++ b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+@@ -348,6 +348,7 @@ public class ArmorStand extends LivingEntity {
+ 
+     @Override
+     protected void pushEntities() {
+        if (!this.level().paperConfig().entities.armorStands.doCollisionEntityLookups) return; // Paper - Option to prevent armor stands from doing entity lookups
+         List<Entity> list = this.level().getEntities((Entity) this, this.getBoundingBox(), ArmorStand.RIDABLE_MINECARTS);
+         Iterator iterator = list.iterator();
+ 
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index c628524274110bcad175472dbcb82e6c62476a12..3ccd28193bec6363eb87f916589310ee8b45dd3a 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -766,6 +766,13 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+             // Paper end - Prevent block entity and entity crashes
+         }
+     }
+    // Paper start - Option to prevent armor stands from doing entity lookups
+    @Override
+    public boolean noCollision(@Nullable Entity entity, AABB box) {
+        if (entity instanceof net.minecraft.world.entity.decoration.ArmorStand && !entity.level().paperConfig().entities.armorStands.doCollisionEntityLookups) return false;
+        return LevelAccessor.super.noCollision(entity, box);
+    }
+    // Paper end - Option to prevent armor stands from doing entity lookups
+ 
+     public boolean shouldTickDeath(Entity entity) {
+         return true;
--- a/patches/server/0215-Vanished-players-don-t-have-rights.patch
+++ b/patches/server/0215-Vanished-players-don-t-have-rights.patch
@ -0,0 +1,109 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Hugo Manrique <hugmanrique@gmail.com>
+Date: Mon, 23 Jul 2018 14:22:26 +0200
+Subject: [PATCH] Vanished players don't have rights
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
+index 55c0d23ea68cd328881bd40d6bfd12d58477d15b..e7fe338572a8bb740d6023c688d8c84ea04a2169 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
+@@ -387,6 +387,15 @@ public abstract class Projectile extends Entity implements TraceableEntity {
+         } else {
+             Entity entity1 = this.getOwner();
+ 
+            // Paper start - Cancel hit for vanished players
+            if (entity1 instanceof net.minecraft.server.level.ServerPlayer && entity instanceof net.minecraft.server.level.ServerPlayer) {
+                org.bukkit.entity.Player collided = (org.bukkit.entity.Player) entity.getBukkitEntity();
+                org.bukkit.entity.Player shooter = (org.bukkit.entity.Player) entity1.getBukkitEntity();
+                if (!shooter.canSee(collided)) {
+                    return false;
+                }
+            }
+            // Paper end - Cancel hit for vanished players
+             return entity1 == null || this.leftOwner || !entity1.isPassengerOfSameVehicle(entity);
+         }
+     }
+diff --git a/src/main/java/net/minecraft/world/item/BlockItem.java b/src/main/java/net/minecraft/world/item/BlockItem.java
+index 752929f3bcd6404b08dad1c67e9a0023b671f10d..407f5db0a4b3884440bc49bf4f00d9c035899e86 100644
+--- a/src/main/java/net/minecraft/world/item/BlockItem.java
+++ b/src/main/java/net/minecraft/world/item/BlockItem.java
+@@ -168,7 +168,8 @@ public class BlockItem extends Item {
+         Player entityhuman = context.getPlayer();
+         CollisionContext voxelshapecollision = entityhuman == null ? CollisionContext.empty() : CollisionContext.of(entityhuman);
+         // CraftBukkit start - store default return
+-        boolean defaultReturn = (!this.mustSurvive() || state.canSurvive(context.getLevel(), context.getClickedPos())) && context.getLevel().isUnobstructed(state, context.getClickedPos(), voxelshapecollision);
+        Level world = context.getLevel(); // Paper - Cancel hit for vanished players
+        boolean defaultReturn = (!this.mustSurvive() || state.canSurvive(context.getLevel(), context.getClickedPos())) && world.checkEntityCollision(state, entityhuman, voxelshapecollision, context.getClickedPos(), true); // Paper - Cancel hit for vanished players
+         org.bukkit.entity.Player player = (context.getPlayer() instanceof ServerPlayer) ? (org.bukkit.entity.Player) context.getPlayer().getBukkitEntity() : null;
+ 
+         BlockCanBuildEvent event = new BlockCanBuildEvent(CraftBlock.at(context.getLevel(), context.getClickedPos()), player, CraftBlockData.fromData(state), defaultReturn);
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 3ccd28193bec6363eb87f916589310ee8b45dd3a..cf422de89f0ed81e7c9759328e28ca6b190283ef 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -265,6 +265,45 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+         this.tileLimiter = new org.spigotmc.TickLimiter(this.spigotConfig.tileMaxTickTime);
+     }
+ 
+    // Paper start - Cancel hit for vanished players
+    // ret true if no collision
+    public final boolean checkEntityCollision(BlockState data, Entity source, net.minecraft.world.phys.shapes.CollisionContext voxelshapedcollision,
+                                              BlockPos position, boolean checkCanSee) {
+        // Copied from IWorldReader#a(IBlockData, BlockPosition, VoxelShapeCollision) & EntityAccess#a(Entity, VoxelShape)
+        net.minecraft.world.phys.shapes.VoxelShape voxelshape = data.getCollisionShape(this, position, voxelshapedcollision);
+        if (voxelshape.isEmpty()) {
+            return true;
+        }
+
+        voxelshape = voxelshape.move((double) position.getX(), (double) position.getY(), (double) position.getZ());
+        if (voxelshape.isEmpty()) {
+            return true;
+        }
+
+        List<Entity> entities = this.getEntities(null, voxelshape.bounds());
+        for (int i = 0, len = entities.size(); i < len; ++i) {
+            Entity entity = entities.get(i);
+
+            if (checkCanSee && source instanceof net.minecraft.server.level.ServerPlayer && entity instanceof net.minecraft.server.level.ServerPlayer
+                && !((net.minecraft.server.level.ServerPlayer) source).getBukkitEntity().canSee(((net.minecraft.server.level.ServerPlayer) entity).getBukkitEntity())) {
+                continue;
+            }
+
+            // !entity1.dead && entity1.i && (entity == null || !entity1.x(entity));
+            // elide the last check since vanilla calls with entity = null
+            // only we care about the source for the canSee check
+            if (entity.isRemoved() || !entity.blocksBuilding) {
+                continue;
+            }
+
+            if (net.minecraft.world.phys.shapes.Shapes.joinIsNotEmpty(voxelshape, net.minecraft.world.phys.shapes.Shapes.create(entity.getBoundingBox()), net.minecraft.world.phys.shapes.BooleanOp.AND)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+    // Paper end - Cancel hit for vanished players
+     @Override
+     public boolean isClientSide() {
+         return this.isClientSide;
+diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+index 41c6a7260317ed575a3320ac36b0f2be22c120aa..474f330f381aa74e9f2fd0accdbaf2617ec1c557 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -1327,6 +1327,14 @@ public class CraftEventFactory {
+         Projectile projectile = (Projectile) entity.getBukkitEntity();
+         org.bukkit.entity.Entity collided = position.getEntity().getBukkitEntity();
+         com.destroystokyo.paper.event.entity.ProjectileCollideEvent event = new com.destroystokyo.paper.event.entity.ProjectileCollideEvent(projectile, collided);
+
+        if (projectile.getShooter() instanceof Player && collided instanceof Player) {
+            if (!((Player) projectile.getShooter()).canSee((Player) collided)) {
+                event.setCancelled(true);
+                return event;
+            }
+        }
+
+         Bukkit.getPluginManager().callEvent(event);
+         return event;
+     }
--- a/patches/server/0216-Allow-disabling-armor-stand-ticking.patch
+++ b/patches/server/0216-Allow-disabling-armor-stand-ticking.patch
@ -0,0 +1,145 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: kashike <kashike@vq.lc>
+Date: Wed, 15 Aug 2018 01:26:09 -0700
+Subject: [PATCH] Allow disabling armor stand ticking
+
+
+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 e9d6211eb0f955eb95d2f73ad96799ef4740d506..2caba38a50b7ea535337a3540aa5272d4a9f1878 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+++ b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+@@ -108,9 +108,16 @@ public class ArmorStand extends LivingEntity {
+     public Rotations leftLegPose;
+     public Rotations rightLegPose;
+     public boolean canMove = true; // Paper
+    // Paper start - Allow ArmorStands not to tick
+    public boolean canTick = true;
+    public boolean canTickSetByAPI = false;
+    private boolean noTickPoseDirty = false;
+    private boolean noTickEquipmentDirty = false;
+    // Paper end - Allow ArmorStands not to tick
+ 
+     public ArmorStand(EntityType<? extends ArmorStand> type, Level world) {
+         super(type, world);
+        if (world != null) this.canTick = world.paperConfig().entities.armorStands.tick; // Paper - Allow ArmorStands not to tick
+         this.handItems = NonNullList.withSize(2, ItemStack.EMPTY);
+         this.armorItems = NonNullList.withSize(4, ItemStack.EMPTY);
+         this.headPose = ArmorStand.DEFAULT_HEAD_POSE;
+@@ -213,6 +220,7 @@ public class ArmorStand extends LivingEntity {
+                 this.onEquipItem(enumitemslot, (ItemStack) this.armorItems.set(enumitemslot.getIndex(), itemstack), itemstack, silent); // CraftBukkit
+         }
+ 
+        this.noTickEquipmentDirty = true; // Paper - Allow ArmorStands not to tick; Still update equipment
+     }
+ 
+     @Override
+@@ -248,6 +256,7 @@ public class ArmorStand extends LivingEntity {
+         }
+ 
+         nbt.put("Pose", this.writePose());
+        if (this.canTickSetByAPI) nbt.putBoolean("Paper.CanTickOverride", this.canTick); // Paper - Allow ArmorStands not to tick
+     }
+ 
+     @Override
+@@ -282,6 +291,12 @@ public class ArmorStand extends LivingEntity {
+         this.setNoBasePlate(nbt.getBoolean("NoBasePlate"));
+         this.setMarker(nbt.getBoolean("Marker"));
+         this.noPhysics = !this.hasPhysics();
+        // Paper start - Allow ArmorStands not to tick
+        if (nbt.contains("Paper.CanTickOverride")) {
+            this.canTick = nbt.getBoolean("Paper.CanTickOverride");
+            this.canTickSetByAPI = true;
+        }
+        // Paper end - Allow ArmorStands not to tick
+         CompoundTag nbttagcompound2 = nbt.getCompound("Pose");
+ 
+         this.readPose(nbttagcompound2);
+@@ -661,7 +676,29 @@ public class ArmorStand extends LivingEntity {
+ 
+     @Override
+     public void tick() {
+        // Paper start - Allow ArmorStands not to tick
+        if (!this.canTick) {
+            if (this.noTickPoseDirty) {
+                this.noTickPoseDirty = false;
+                this.updatePose();
+            }
+
+            if (this.noTickEquipmentDirty) {
+                this.noTickEquipmentDirty = false;
+                this.detectEquipmentUpdatesPublic();
+            }
+
+            return;
+        }
+        // Paper end - Allow ArmorStands not to tick
+
+         super.tick();
+        // Paper start - Allow ArmorStands not to tick
+        updatePose();
+    }
+
+    public void updatePose() {
+        // Paper end - Allow ArmorStands not to tick
+         Rotations vector3f = (Rotations) this.entityData.get(ArmorStand.DATA_HEAD_POSE);
+ 
+         if (!this.headPose.equals(vector3f)) {
+@@ -796,31 +833,37 @@ public class ArmorStand extends LivingEntity {
+     public void setHeadPose(Rotations angle) {
+         this.headPose = angle;
+         this.entityData.set(ArmorStand.DATA_HEAD_POSE, angle);
+        this.noTickPoseDirty = true; // Paper - Allow updates when not ticking
+     }
+ 
+     public void setBodyPose(Rotations angle) {
+         this.bodyPose = angle;
+         this.entityData.set(ArmorStand.DATA_BODY_POSE, angle);
+        this.noTickPoseDirty = true; // Paper - Allow updates when not ticking
+     }
+ 
+     public void setLeftArmPose(Rotations angle) {
+         this.leftArmPose = angle;
+         this.entityData.set(ArmorStand.DATA_LEFT_ARM_POSE, angle);
+        this.noTickPoseDirty = true; // Paper - Allow updates when not ticking
+     }
+ 
+     public void setRightArmPose(Rotations angle) {
+         this.rightArmPose = angle;
+         this.entityData.set(ArmorStand.DATA_RIGHT_ARM_POSE, angle);
+        this.noTickPoseDirty = true; // Paper - Allow updates when not ticking
+     }
+ 
+     public void setLeftLegPose(Rotations angle) {
+         this.leftLegPose = angle;
+         this.entityData.set(ArmorStand.DATA_LEFT_LEG_POSE, angle);
+        this.noTickPoseDirty = true; // Paper - Allow updates when not ticking
+     }
+ 
+     public void setRightLegPose(Rotations angle) {
+         this.rightLegPose = angle;
+         this.entityData.set(ArmorStand.DATA_RIGHT_LEG_POSE, angle);
+        this.noTickPoseDirty = true; // Paper - Allow updates when not ticking
+     }
+ 
+     public Rotations getHeadPose() {
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
+index 56fcd9dd40e6a63e1af5fbd470ece0d6100292a2..1bb080a8af45411b68a0f2a3c40718d60fdc9d97 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
+@@ -232,5 +232,16 @@ public class CraftArmorStand extends CraftLivingEntity implements ArmorStand {
+     public void setCanMove(boolean move) {
+         getHandle().canMove = move;
+     }
+
+    @Override
+    public boolean canTick() {
+        return this.getHandle().canTick;
+    }
+
+    @Override
+    public void setCanTick(final boolean tick) {
+        this.getHandle().canTick = tick;
+        this.getHandle().canTickSetByAPI = true;
+    }
+     // Paper end
+ }
--- a/patches/server/0217-SkeletonHorse-Additions.patch
+++ b/patches/server/0217-SkeletonHorse-Additions.patch
@ -0,0 +1,87 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Fri, 27 Jul 2018 22:36:31 -0500
+Subject: [PATCH] SkeletonHorse Additions
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/SkeletonTrapGoal.java b/src/main/java/net/minecraft/world/entity/animal/horse/SkeletonTrapGoal.java
+index 521b09ac14372f524b06ffdce57932d0a590700b..b782fd54d94d1a1704ddc8e7bfda03d3aefbccbe 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/horse/SkeletonTrapGoal.java
+++ b/src/main/java/net/minecraft/world/entity/animal/horse/SkeletonTrapGoal.java
+@@ -20,6 +20,7 @@ import net.minecraft.world.item.enchantment.providers.VanillaEnchantmentProvider
+ public class SkeletonTrapGoal extends Goal {
+ 
+     private final SkeletonHorse horse;
+    private java.util.List<org.bukkit.entity.HumanEntity> eligiblePlayers; // Paper
+ 
+     public SkeletonTrapGoal(SkeletonHorse skeletonHorse) {
+         this.horse = skeletonHorse;
+@@ -27,12 +28,13 @@ public class SkeletonTrapGoal extends Goal {
+ 
+     @Override
+     public boolean canUse() {
+-        return this.horse.level().hasNearbyAlivePlayerThatAffectsSpawning(this.horse.getX(), this.horse.getY(), this.horse.getZ(), 10.0D); // Paper - Affects Spawning API
+        return !(eligiblePlayers = this.horse.level().findNearbyBukkitPlayers(this.horse.getX(), this.horse.getY(), this.horse.getZ(), 10.0D, net.minecraft.world.entity.EntitySelector.PLAYER_AFFECTS_SPAWNING)).isEmpty(); // Paper - Affects Spawning API & SkeletonHorseTrapEvent
+     }
+ 
+     @Override
+     public void tick() {
+         ServerLevel worldserver = (ServerLevel) this.horse.level();
+        if (!new com.destroystokyo.paper.event.entity.SkeletonHorseTrapEvent((org.bukkit.entity.SkeletonHorse) this.horse.getBukkitEntity(), eligiblePlayers).callEvent()) return; // Paper
+         DifficultyInstance difficultydamagescaler = worldserver.getCurrentDifficultyAt(this.horse.blockPosition());
+ 
+         this.horse.setTrap(false);
+diff --git a/src/main/java/net/minecraft/world/level/EntityGetter.java b/src/main/java/net/minecraft/world/level/EntityGetter.java
+index fb043d67eaa6336fc0b5d62774b8f1107f9dfa1e..dac8305f1c897e6f82a2dde67c5b1b6b8b649b19 100644
+--- a/src/main/java/net/minecraft/world/level/EntityGetter.java
+++ b/src/main/java/net/minecraft/world/level/EntityGetter.java
+@@ -94,6 +94,28 @@ public interface EntityGetter {
+         return player;
+     }
+ 
+    // Paper start
+    default List<org.bukkit.entity.HumanEntity> findNearbyBukkitPlayers(double x, double y, double z, double radius, boolean notSpectator) {
+        return findNearbyBukkitPlayers(x, y, z, radius, notSpectator ? EntitySelector.NO_SPECTATORS : net.minecraft.world.entity.EntitySelector.NO_CREATIVE_OR_SPECTATOR);
+    }
+
+    default List<org.bukkit.entity.HumanEntity> findNearbyBukkitPlayers(double x, double y, double z, double radius, @Nullable Predicate<Entity> predicate) {
+        com.google.common.collect.ImmutableList.Builder<org.bukkit.entity.HumanEntity> builder = com.google.common.collect.ImmutableList.builder();
+
+        for (Player human : this.players()) {
+            if (predicate == null || predicate.test(human)) {
+                double distanceSquared = human.distanceToSqr(x, y, z);
+
+                if (radius < 0.0D || distanceSquared < radius * radius) {
+                    builder.add(human.getBukkitEntity());
+                }
+            }
+        }
+
+        return builder.build();
+    }
+    // Paper end
+
+     @Nullable
+     default Player getNearestPlayer(Entity entity, double maxDistance) {
+         return this.getNearestPlayer(entity.getX(), entity.getY(), entity.getZ(), maxDistance, false);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftSkeletonHorse.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftSkeletonHorse.java
+index 248e4febbe8fe225920b6504d2c29d295cf09ec6..fbb47491dcc75f8247dee9f123f946f99ef1467f 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftSkeletonHorse.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftSkeletonHorse.java
+@@ -44,4 +44,16 @@ public class CraftSkeletonHorse extends CraftAbstractHorse implements SkeletonHo
+     public void setTrapTime(int trapTime) {
+         this.getHandle().trapTime = trapTime;
+     }
+
+    // Paper start - replaced by above methods
+    @Override
+    public boolean isTrap() {
+        return getHandle().isTrap();
+    }
+
+    @Override
+    public void setTrap(boolean trap) {
+        getHandle().setTrap(trap);
+    }
+    // Paper end
+ }
--- a/patches/server/0218-Expand-ArmorStand-API.patch
+++ b/patches/server/0218-Expand-ArmorStand-API.patch
@ -0,0 +1,169 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: willies952002 <admin@domnian.com>
+Date: Thu, 26 Jul 2018 02:25:46 -0400
+Subject: [PATCH] Expand ArmorStand API
+
+Adds the following:
+- Add proper methods for getting and setting items in both hands. Deprecates old methods
+- Enable/Disable slot interactions
+- Allow using degrees for ArmorStand rotations (via new Rotations class)
+
+== AT ==
+public net.minecraft.world.entity.decoration.ArmorStand isDisabled(Lnet/minecraft/world/entity/EquipmentSlot;)Z
+
+Co-authored-by: SoSeDiK <mrsosedik@gmail.com>
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
+index 1bb080a8af45411b68a0f2a3c40718d60fdc9d97..e1cedcb95e9b2e2e9587b623256b5cffa7b08ce4 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
+@@ -233,6 +233,149 @@ public class CraftArmorStand extends CraftLivingEntity implements ArmorStand {
+         getHandle().canMove = move;
+     }
+ 
+    @Override
+    public ItemStack getItem(org.bukkit.inventory.EquipmentSlot slot) {
+        com.google.common.base.Preconditions.checkArgument(slot != null, "slot");
+        com.google.common.base.Preconditions.checkArgument(slot != EquipmentSlot.BODY, "Cannot get body item");
+        return getHandle().getItemBySlot(org.bukkit.craftbukkit.CraftEquipmentSlot.getNMS(slot)).asBukkitMirror();
+    }
+
+    @Override
+    public void setItem(org.bukkit.inventory.EquipmentSlot slot, ItemStack item) {
+        com.google.common.base.Preconditions.checkArgument(slot != null, "slot");
+        com.google.common.base.Preconditions.checkArgument(slot != EquipmentSlot.BODY, "Cannot set body item");
+        switch (slot) {
+            case HAND:
+                getEquipment().setItemInMainHand(item);
+                return;
+            case OFF_HAND:
+                getEquipment().setItemInOffHand(item);
+                return;
+            case FEET:
+                setBoots(item);
+                return;
+            case LEGS:
+                setLeggings(item);
+                return;
+            case CHEST:
+                setChestplate(item);
+                return;
+            case HEAD:
+                setHelmet(item);
+                return;
+        }
+        throw new UnsupportedOperationException(slot.name());
+    }
+
+    @Override
+    public java.util.Set<org.bukkit.inventory.EquipmentSlot> getDisabledSlots() {
+        java.util.Set<org.bukkit.inventory.EquipmentSlot> disabled = new java.util.HashSet<>();
+        for (org.bukkit.inventory.EquipmentSlot slot : org.bukkit.inventory.EquipmentSlot.values()) {
+            if (this.isSlotDisabled(slot)) {
+                disabled.add(slot);
+            }
+        }
+        return disabled;
+    }
+
+    @Override
+    public void setDisabledSlots(org.bukkit.inventory.EquipmentSlot... slots) {
+        int disabled = 0;
+        for (org.bukkit.inventory.EquipmentSlot slot : slots) {
+            if (slot == org.bukkit.inventory.EquipmentSlot.OFF_HAND) continue;
+            net.minecraft.world.entity.EquipmentSlot nmsSlot = org.bukkit.craftbukkit.CraftEquipmentSlot.getNMS(slot);
+            disabled += (1 << nmsSlot.getFilterFlag()) + (1 << (nmsSlot.getFilterFlag() + 8)) + (1 << (nmsSlot.getFilterFlag() + 16));
+        }
+        getHandle().disabledSlots = disabled;
+    }
+
+    @Override
+    public void addDisabledSlots(org.bukkit.inventory.EquipmentSlot... slots) {
+        java.util.Set<org.bukkit.inventory.EquipmentSlot> disabled = getDisabledSlots();
+        java.util.Collections.addAll(disabled, slots);
+        setDisabledSlots(disabled.toArray(new org.bukkit.inventory.EquipmentSlot[0]));
+    }
+
+    @Override
+    public void removeDisabledSlots(org.bukkit.inventory.EquipmentSlot... slots) {
+        java.util.Set<org.bukkit.inventory.EquipmentSlot> disabled = getDisabledSlots();
+        for (final org.bukkit.inventory.EquipmentSlot slot : slots) disabled.remove(slot);
+        setDisabledSlots(disabled.toArray(new org.bukkit.inventory.EquipmentSlot[0]));
+    }
+
+    @Override
+    public boolean isSlotDisabled(org.bukkit.inventory.EquipmentSlot slot) {
+        return getHandle().isDisabled(org.bukkit.craftbukkit.CraftEquipmentSlot.getNMS(slot));
+    }
+
+    @Override
+    public io.papermc.paper.math.Rotations getBodyRotations() {
+        return fromNMSRotations(getHandle().bodyPose);
+    }
+
+    @Override
+    public void setBodyRotations(io.papermc.paper.math.Rotations rotations) {
+        getHandle().setBodyPose(toNMSRotations(rotations));
+    }
+
+    @Override
+    public io.papermc.paper.math.Rotations getLeftArmRotations() {
+        return fromNMSRotations(getHandle().leftArmPose);
+    }
+
+    @Override
+    public void setLeftArmRotations(io.papermc.paper.math.Rotations rotations) {
+        getHandle().setLeftArmPose(toNMSRotations(rotations));
+    }
+
+    @Override
+    public io.papermc.paper.math.Rotations getRightArmRotations() {
+        return fromNMSRotations(getHandle().rightArmPose);
+    }
+
+    @Override
+    public void setRightArmRotations(io.papermc.paper.math.Rotations rotations) {
+        getHandle().setRightArmPose(toNMSRotations(rotations));
+    }
+
+    @Override
+    public io.papermc.paper.math.Rotations getLeftLegRotations() {
+        return fromNMSRotations(getHandle().leftLegPose);
+    }
+
+    @Override
+    public void setLeftLegRotations(io.papermc.paper.math.Rotations rotations) {
+        getHandle().setLeftLegPose(toNMSRotations(rotations));
+    }
+
+    @Override
+    public io.papermc.paper.math.Rotations getRightLegRotations() {
+        return fromNMSRotations(getHandle().rightLegPose);
+    }
+
+    @Override
+    public void setRightLegRotations(io.papermc.paper.math.Rotations rotations) {
+        getHandle().setRightLegPose(toNMSRotations(rotations));
+    }
+
+    @Override
+    public io.papermc.paper.math.Rotations getHeadRotations() {
+        return fromNMSRotations(getHandle().headPose);
+    }
+
+    @Override
+    public void setHeadRotations(io.papermc.paper.math.Rotations rotations) {
+        getHandle().setHeadPose(toNMSRotations(rotations));
+    }
+
+    private static io.papermc.paper.math.Rotations fromNMSRotations(Rotations old) {
+        return io.papermc.paper.math.Rotations.ofDegrees(old.getX(), old.getY(), old.getZ());
+    }
+
+    private static Rotations toNMSRotations(io.papermc.paper.math.Rotations old) {
+        return new Rotations((float) old.x(), (float) old.y(), (float) old.z());
+    }
+
+     @Override
+     public boolean canTick() {
+         return this.getHandle().canTick;
--- a/patches/server/0219-AnvilDamageEvent.patch
+++ b/patches/server/0219-AnvilDamageEvent.patch
@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Fri, 20 Jul 2018 23:37:03 -0500
+Subject: [PATCH] AnvilDamageEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/inventory/AnvilMenu.java b/src/main/java/net/minecraft/world/inventory/AnvilMenu.java
+index ab59f5cdd5ce76a0408f4b6ce907e7be103d7950..126565e673e94b9c66aa4547596bbf198c57c7ad 100644
+--- a/src/main/java/net/minecraft/world/inventory/AnvilMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/AnvilMenu.java
+@@ -111,6 +111,16 @@ public class AnvilMenu extends ItemCombinerMenu {
+             if (!player.hasInfiniteMaterials() && iblockdata.is(BlockTags.ANVIL) && player.getRandom().nextFloat() < 0.12F) {
+                 BlockState iblockdata1 = AnvilBlock.damage(iblockdata);
+ 
+                // Paper start - AnvilDamageEvent
+                com.destroystokyo.paper.event.block.AnvilDamagedEvent event = new com.destroystokyo.paper.event.block.AnvilDamagedEvent(getBukkitView(), iblockdata1 != null ? org.bukkit.craftbukkit.block.data.CraftBlockData.fromData(iblockdata1) : null);
+                if (!event.callEvent()) {
+                    return;
+                } else if (event.getDamageState() == com.destroystokyo.paper.event.block.AnvilDamagedEvent.DamageState.BROKEN) {
+                    iblockdata1 = null;
+                } else {
+                    iblockdata1 = ((org.bukkit.craftbukkit.block.data.CraftBlockData) event.getDamageState().getMaterial().createBlockData()).getState().setValue(AnvilBlock.FACING, iblockdata.getValue(AnvilBlock.FACING));
+                }
+                // Paper end - AnvilDamageEvent
+                 if (iblockdata1 == null) {
+                     world.removeBlock(blockposition, false);
+                     world.levelEvent(1029, blockposition, 0);
--- a/patches/server/0220-Add-TNTPrimeEvent.patch
+++ b/patches/server/0220-Add-TNTPrimeEvent.patch
@ -0,0 +1,117 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mark Vainomaa <mikroskeem@mikroskeem.eu>
+Date: Mon, 16 Jul 2018 00:05:05 +0300
+Subject: [PATCH] Add TNTPrimeEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
+index ba1bb0f82634054e02c5f4bc062c1822a356e2a6..25d2226c2a5dda411a9e35f7a0e3ab183110c227 100644
+--- a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
+++ b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
+@@ -543,6 +543,11 @@ public class EnderDragon extends Mob implements Enemy {
+                     });
+                     craftBlock.getNMS().spawnAfterBreak((ServerLevel) this.level(), blockposition, ItemStack.EMPTY, false);
+                 }
+                // Paper start - TNTPrimeEvent
+                org.bukkit.block.Block tntBlock = CraftBlock.at(this.level(), blockposition);
+                if (!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.EXPLOSION, explosionSource.getIndirectSourceEntity().getBukkitEntity()).callEvent())
+                    continue;
+                // Paper end - TNTPrimeEvent
+                 nmsBlock.wasExploded((ServerLevel) this.level(), blockposition, this.explosionSource);
+ 
+                 this.level().removeBlock(blockposition, false);
+diff --git a/src/main/java/net/minecraft/world/level/block/FireBlock.java b/src/main/java/net/minecraft/world/level/block/FireBlock.java
+index 88976aa06028adcb8f0c91e32b794887d0b55308..f44457c0d75efe323cc8242ef5173a3d5067fad0 100644
+--- a/src/main/java/net/minecraft/world/level/block/FireBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/FireBlock.java
+@@ -302,12 +302,19 @@ public class FireBlock extends BaseFireBlock {
+ 
+                 world.setBlock(blockposition, this.getStateWithAge(world, blockposition, l), 3);
+             } else {
+-                world.removeBlock(blockposition, false);
+                if(iblockdata.getBlock() != Blocks.TNT) world.removeBlock(blockposition, false); // Paper - TNTPrimeEvent; We might be cancelling it below, move the setAir down
+             }
+ 
+             Block block = iblockdata.getBlock();
+ 
+             if (block instanceof TntBlock) {
+                // Paper start - TNTPrimeEvent
+                org.bukkit.block.Block tntBlock = org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition);
+                if (!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.FIRE, null).callEvent()) {
+                    return;
+                }
+                world.removeBlock(blockposition, false);
+                // Paper end - TNTPrimeEvent
+                 TntBlock.explode(world, blockposition);
+             }
+         }
+diff --git a/src/main/java/net/minecraft/world/level/block/TntBlock.java b/src/main/java/net/minecraft/world/level/block/TntBlock.java
+index 5e14568b325dc805e507d23ae66e789fc35ec3df..d256b0f3998028709334dd6c394d184f2c36efce 100644
+--- a/src/main/java/net/minecraft/world/level/block/TntBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/TntBlock.java
+@@ -52,6 +52,12 @@ public class TntBlock extends Block {
+     protected void onPlace(BlockState state, Level world, BlockPos pos, BlockState oldState, boolean notify) {
+         if (!oldState.is(state.getBlock())) {
+             if (world.hasNeighborSignal(pos) && CraftEventFactory.callTNTPrimeEvent(world, pos, PrimeCause.REDSTONE, null, null)) { // CraftBukkit - TNTPrimeEvent
+                // Paper start - TNTPrimeEvent
+                org.bukkit.block.Block tntBlock = org.bukkit.craftbukkit.block.CraftBlock.at(world, pos);
+                if (!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.REDSTONE, null).callEvent()) {
+                    return;
+                }
+                // Paper end - TNTPrimeEvent
+                 TntBlock.explode(world, pos);
+                 world.removeBlock(pos, false);
+             }
+@@ -62,6 +68,12 @@ public class TntBlock extends Block {
+     @Override
+     protected void neighborChanged(BlockState state, Level world, BlockPos pos, Block sourceBlock, @Nullable Orientation wireOrientation, boolean notify) {
+         if (world.hasNeighborSignal(pos) && CraftEventFactory.callTNTPrimeEvent(world, pos, PrimeCause.REDSTONE, null, null)) { // CraftBukkit - TNTPrimeEvent
+            // Paper start - TNTPrimeEvent
+            org.bukkit.block.Block tntBlock = org.bukkit.craftbukkit.block.CraftBlock.at(world, pos);
+            if (!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.REDSTONE, null).callEvent()) {
+                return;
+            }
+            // Paper end - TNTPrimeEvent
+             TntBlock.explode(world, pos);
+             world.removeBlock(pos, false);
+         }
+@@ -79,6 +91,13 @@ public class TntBlock extends Block {
+ 
+     @Override
+     public void wasExploded(ServerLevel world, BlockPos pos, Explosion explosion) {
+        // Paper start - TNTPrimeEvent
+        org.bukkit.block.Block tntBlock = org.bukkit.craftbukkit.block.CraftBlock.at(world, pos);
+        org.bukkit.entity.Entity source = explosion.getDirectSourceEntity() != null ? explosion.getDirectSourceEntity().getBukkitEntity() : null;
+        if (!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.EXPLOSION, source).callEvent()) {
+            return;
+        }
+        // Paper end - TNTPrimeEvent
+         PrimedTnt entitytntprimed = new PrimedTnt(world, (double) pos.getX() + 0.5D, (double) pos.getY(), (double) pos.getZ() + 0.5D, explosion.getIndirectSourceEntity());
+         int i = entitytntprimed.getFuse();
+ 
+@@ -110,6 +129,12 @@ public class TntBlock extends Block {
+                 return InteractionResult.CONSUME;
+             }
+             // CraftBukkit end
+            // Paper start - TNTPrimeEvent
+            org.bukkit.block.Block tntBlock = org.bukkit.craftbukkit.block.CraftBlock.at(world, pos);
+            if (!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.ITEM, player.getBukkitEntity()).callEvent()) {
+                return InteractionResult.FAIL;
+            }
+            // Paper end - TNTPrimeEvent
+             TntBlock.explode(world, pos, player);
+             world.setBlock(pos, Blocks.AIR.defaultBlockState(), 11);
+             Item item = stack.getItem();
+@@ -137,6 +162,12 @@ public class TntBlock extends Block {
+                     return;
+                 }
+                 // CraftBukkit end
+                // Paper start - TNTPrimeEvent
+                org.bukkit.block.Block tntBlock = org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition);
+                if (!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.PROJECTILE, projectile.getBukkitEntity()).callEvent()) {
+                    return;
+                }
+                // Paper end - TNTPrimeEvent
+                 TntBlock.explode(world, blockposition, entity instanceof LivingEntity ? (LivingEntity) entity : null);
+                 world.removeBlock(blockposition, false);
+             }
--- a/patches/server/0221-Break-up-and-make-tab-spam-limits-configurable.patch
+++ b/patches/server/0221-Break-up-and-make-tab-spam-limits-configurable.patch
@ -0,0 +1,60 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Sun, 29 Jul 2018 05:02:15 +0100
+Subject: [PATCH] Break up and make tab spam limits configurable
+
+Due to the changes in 1.13, clients will send a tab completion request
+for all bukkit commands in order to factor in the lack of support for
+brigadier and provide backwards support in the API.
+
+Craftbukkit, however; has moved the chat spam limiter to also interact
+with the tab completion request, which while good for avoiding abuse,
+causes 1.13 clients to easilly be kicked from a server in bukkit due
+to this. Removing the spam limit could cause issues for servers, however,
+there is no way for servers to manipulate this without blindly cancelling
+kick events, which only causes additional complications. This also causes
+issues in that the tab spam limit and chat share the same field but different
+limits, meaning that a player having typed a long command may be kicked from
+the server.
+
+Splitting the field up and making it configurable allows for server owners
+to take the burden of this into their own hand without having to rely on
+plugins doing unsafe things.
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index bcceb9d18524ddcf7cdf2ab6dcb95a67f1155414..816b53894c6420a6b1603252e53facacecc07c52 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -7,6 +7,7 @@ import com.mojang.brigadier.ParseResults;
+ import com.mojang.brigadier.StringReader;
+ import com.mojang.brigadier.suggestion.Suggestions;
+ import com.mojang.logging.LogUtils;
+import io.papermc.paper.configuration.GlobalConfiguration;
+ import it.unimi.dsi.fastutil.ints.Int2ObjectMap.Entry;
+ import it.unimi.dsi.fastutil.ints.Int2ObjectMaps;
+ import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+@@ -272,6 +273,7 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+     private int tickCount;
+     private int ackBlockChangesUpTo = -1;
+     private final TickThrottler chatSpamThrottler = new TickThrottler(20, 200);
+    private final TickThrottler tabSpamThrottler = new TickThrottler(GlobalConfiguration.get().spamLimiter.tabSpamIncrement, GlobalConfiguration.get().spamLimiter.tabSpamLimit); // Paper - configurable tab spam limits
+     private final TickThrottler dropSpamThrottler = new TickThrottler(20, 1480);
+     private double firstGoodX;
+     private double firstGoodY;
+@@ -387,6 +389,7 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+ 
+         this.keepConnectionAlive();
+         this.chatSpamThrottler.tick();
+        this.tabSpamThrottler.tick(); // Paper - configurable tab spam limits
+         this.dropSpamThrottler.tick();
+         if (this.player.getLastActionTime() > 0L && this.server.getPlayerIdleTimeout() > 0 && Util.getMillis() - this.player.getLastActionTime() > (long) this.server.getPlayerIdleTimeout() * 1000L * 60L) {
+             this.player.resetLastActionTime(); // CraftBukkit - SPIGOT-854
+@@ -722,7 +725,7 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+     public void handleCustomCommandSuggestions(ServerboundCommandSuggestionPacket packet) {
+         // PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel()); // Paper - AsyncTabCompleteEvent; run this async
+         // CraftBukkit start
+-        if (!this.chatSpamThrottler.isIncrementAndUnderThreshold(1, 500) && !this.server.getPlayerList().isOp(this.player.getGameProfile()) && !this.server.isSingleplayerOwner(this.player.getGameProfile())) {
+        if (!this.tabSpamThrottler.isIncrementAndUnderThreshold() && !this.server.getPlayerList().isOp(this.player.getGameProfile()) && !this.server.isSingleplayerOwner(this.player.getGameProfile())) { // Paper - configurable tab spam limits
+             this.disconnect(Component.translatable("disconnect.spam"));
+             return;
+         }
--- a/patches/server/0222-Fix-NBT-type-issues.patch
+++ b/patches/server/0222-Fix-NBT-type-issues.patch
@ -0,0 +1,44 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Fri, 3 Aug 2018 00:04:54 -0400
+Subject: [PATCH] Fix NBT type issues
+
+Addresses two issues:
+- MC-135506: Experience should save as Integers
+- Allay duplication cooldown is saved and exposed as a long, but loaded as an int
+
+diff --git a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+index 74a0bebbf829fdb2bbae87100c4e2523c34f95a0..9d9e3daebc5da0af627c3d3cdb50029aacbc587b 100644
+--- a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+++ b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+@@ -309,7 +309,7 @@ public class ExperienceOrb extends Entity {
+     public void addAdditionalSaveData(CompoundTag nbt) {
+         nbt.putShort("Health", (short) this.health);
+         nbt.putShort("Age", (short) this.age);
+-        nbt.putShort("Value", (short) this.value);
+        nbt.putInt("Value", this.value); // Paper - save as Integer
+         nbt.putInt("Count", this.count);
+         this.savePaperNBT(nbt); // Paper
+     }
+@@ -318,7 +318,7 @@ public class ExperienceOrb extends Entity {
+     public void readAdditionalSaveData(CompoundTag nbt) {
+         this.health = nbt.getShort("Health");
+         this.age = nbt.getShort("Age");
+-        this.value = nbt.getShort("Value");
+        this.value = nbt.getInt("Value"); // Paper - load as Integer
+         this.count = Math.max(nbt.getInt("Count"), 1);
+         this.loadPaperNBT(nbt); // Paper
+     }
+diff --git a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java
+index c0c054b604cdf87591e4ce7c9f15baa5c942aadc..05c3d43fafc781e2c2d762dd5f509753df8da3b3 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java
+++ b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java
+@@ -495,7 +495,7 @@ public class Allay extends PathfinderMob implements InventoryCarrier, VibrationS
+             });
+         }
+ 
+-        this.duplicationCooldown = (long) nbt.getInt("DuplicationCooldown");
+        this.duplicationCooldown = nbt.getLong("DuplicationCooldown"); // Paper - Load as long
+         this.entityData.set(Allay.DATA_CAN_DUPLICATE, nbt.getBoolean("CanDuplicate"));
+     }
+ 
--- a/patches/server/0223-Remove-unnecessary-itemmeta-handling.patch
+++ b/patches/server/0223-Remove-unnecessary-itemmeta-handling.patch
@ -0,0 +1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 22 Nov 2016 00:40:42 -0500
+Subject: [PATCH] Remove unnecessary itemmeta handling
+
+
+diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
+index 1ebaedc9617e5b79458fa119887fd72cb1f39852..957c112b4145fda5078a6f8f1689935fa0290806 100644
+--- a/src/main/java/net/minecraft/world/item/ItemStack.java
+++ b/src/main/java/net/minecraft/world/item/ItemStack.java
+@@ -165,7 +165,7 @@ public final class ItemStack implements DataComponentHolder {
+ 
+                 // CraftBukkit start
+                 ItemStack itemstack = new ItemStack(holder, i, datacomponentpatch);
+-                if (!datacomponentpatch.isEmpty()) {
+                if (false && !datacomponentpatch.isEmpty()) { // Paper - This is no longer needed with raw NBT being handled in metadata
+                     CraftItemStack.setItemMeta(itemstack, CraftItemStack.getItemMeta(itemstack));
+                 }
+                 return itemstack;
+@@ -179,8 +179,8 @@ public final class ItemStack implements DataComponentHolder {
+             } else {
+                 registryfriendlybytebuf.writeVarInt(itemstack.getCount());
+                 // Spigot start - filter
+-                itemstack = itemstack.copy();
+-                CraftItemStack.setItemMeta(itemstack, CraftItemStack.getItemMeta(itemstack));
+                // itemstack = itemstack.copy();
+                // CraftItemStack.setItemMeta(itemstack, CraftItemStack.getItemMeta(itemstack)); // Paper - This is no longer with raw NBT being handled in metadata
+                 // Spigot end
+                 ITEM_STREAM_CODEC.encode(registryfriendlybytebuf, itemstack.getItemHolder()); // CraftBukkit - decompile error
+                 // Paper start - adventure; conditionally render translatable components
--- a/patches/server/0224-Add-Debug-Entities-option-to-debug-dupe-uuid-issues.patch
+++ b/patches/server/0224-Add-Debug-Entities-option-to-debug-dupe-uuid-issues.patch
@ -0,0 +1,42 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sat, 21 Jul 2018 08:25:40 -0400
+Subject: [PATCH] Add Debug Entities option to debug dupe uuid issues
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 438c936fceede5b21435e1f37f2372072a9d4571..3f4d3e2f45c2b2228a333076ec1f34228560593e 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -1196,6 +1196,12 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+     // CraftBukkit start
+     private boolean addEntity(Entity entity, CreatureSpawnEvent.SpawnReason spawnReason) {
+         org.spigotmc.AsyncCatcher.catchOp("entity add"); // Spigot
+        // Paper start - extra debug info
+        if (entity.valid) {
+            MinecraftServer.LOGGER.error("Attempted Double World add on {}", entity, new Throwable());
+            return true;
+        }
+        // Paper end - extra debug info
+         if (entity.isRemoved()) {
+             // WorldServer.LOGGER.warn("Tried to add entity {} but it was marked as removed already", EntityTypes.getKey(entity.getType())); // CraftBukkit
+             return false;
+diff --git a/src/main/java/net/minecraft/world/level/entity/EntityLookup.java b/src/main/java/net/minecraft/world/level/entity/EntityLookup.java
+index 38df704dca30ef08f4d0831dc1cc48c6d6f71a4d..ed6aea7a38ef6e80c300ff9b012dcdbc390ad2c7 100644
+--- a/src/main/java/net/minecraft/world/level/entity/EntityLookup.java
+++ b/src/main/java/net/minecraft/world/level/entity/EntityLookup.java
+@@ -33,6 +33,14 @@ public class EntityLookup<T extends EntityAccess> {
+         UUID uUID = entity.getUUID();
+         if (this.byUuid.containsKey(uUID)) {
+             LOGGER.warn("Duplicate entity UUID {}: {}", uUID, entity);
+            // Paper start - extra debug info
+            if (entity instanceof net.minecraft.world.entity.Entity) {
+                final T old = this.byUuid.get(entity.getUUID());
+                if (old instanceof net.minecraft.world.entity.Entity oldCast && oldCast.getId() != entity.getId() && oldCast.valid) {
+                    LOGGER.error("Overwrote an existing entity {} with {}", oldCast, entity);
+                }
+            }
+            // Paper end - extra debug info
+         } else {
+             this.byUuid.put(uUID, entity);
+             this.byId.put(entity.getId(), entity);
--- a/patches/server/0225-Add-Early-Warning-Feature-to-WatchDog.patch
+++ b/patches/server/0225-Add-Early-Warning-Feature-to-WatchDog.patch
@ -0,0 +1,159 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: miclebrick <miclebrick@outlook.com>
+Date: Wed, 8 Aug 2018 15:30:52 -0400
+Subject: [PATCH] Add Early Warning Feature to WatchDog
+
+Detect when the server has been hung for a long duration, and start printing
+thread dumps at an interval until the point of crash.
+
+This will help diagnose what was going on in that time before the crash.
+
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 6abcb987109c01d012c70c4c3b411f91b7630bb4..cc15ec47155ee16377a65c9f56a62339dc0a129d 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1123,6 +1123,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             this.status = this.buildServerStatus();
+ 
+             // Spigot start
+            org.spigotmc.WatchdogThread.hasStarted = true; // Paper
+             Arrays.fill( this.recentTps, 20 );
+             // Paper start - further improve server tick loop
+             long tickSection = Util.getNanos();
+diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+index a5880be1ec88c70f7ee46225036b04dac87943d4..ff0b610cae7e9e0eb83bf95f350fd9ba7477535a 100644
+--- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -215,6 +215,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+         this.paperConfigurations.initializeGlobalConfiguration(this.registryAccess());
+         this.paperConfigurations.initializeWorldDefaultsConfiguration(this.registryAccess());
+         // Paper end - initialize global and world-defaults configuration
+        org.spigotmc.WatchdogThread.doStart(org.spigotmc.SpigotConfig.timeoutTime, org.spigotmc.SpigotConfig.restartOnCrash); // Paper - start watchdog thread
+         io.papermc.paper.command.PaperCommands.registerCommands(this); // Paper - setup /paper command
+         com.destroystokyo.paper.Metrics.PaperMetrics.startMetrics(); // Paper - start metrics
+         com.destroystokyo.paper.VersionHistoryManager.INSTANCE.getClass(); // Paper - load version history now
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index b4f8482dd92f33111600ae64834abefbda9e696d..d7e944c9f688221958bdd78913ddc649b21d714e 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -966,6 +966,7 @@ public final class CraftServer implements Server {
+ 
+     @Override
+     public void reload() {
+        org.spigotmc.WatchdogThread.hasStarted = false; // Paper - Disable watchdog early timeout on reload
+         this.reloadCount++;
+         this.configuration = YamlConfiguration.loadConfiguration(this.getConfigFile());
+         this.commandsConfiguration = YamlConfiguration.loadConfiguration(this.getCommandsConfigFile());
+@@ -1058,6 +1059,7 @@ public final class CraftServer implements Server {
+         this.enablePlugins(PluginLoadOrder.POSTWORLD);
+         if (io.papermc.paper.plugin.PluginInitializerManager.instance().pluginRemapper != null) io.papermc.paper.plugin.PluginInitializerManager.instance().pluginRemapper.pluginsEnabled(); // Paper - Remap plugins
+         this.getPluginManager().callEvent(new ServerLoadEvent(ServerLoadEvent.LoadType.RELOAD));
+        org.spigotmc.WatchdogThread.hasStarted = true; // Paper - Disable watchdog early timeout on reload
+     }
+ 
+     @Override
+diff --git a/src/main/java/org/spigotmc/SpigotConfig.java b/src/main/java/org/spigotmc/SpigotConfig.java
+index b97ff4a9b69699577bf8cde0869b70353101ef46..85f3433860abd91a89961907940a807a8b190a46 100644
+--- a/src/main/java/org/spigotmc/SpigotConfig.java
+++ b/src/main/java/org/spigotmc/SpigotConfig.java
+@@ -225,7 +225,7 @@ public class SpigotConfig
+         SpigotConfig.restartScript = SpigotConfig.getString( "settings.restart-script", SpigotConfig.restartScript );
+         SpigotConfig.restartMessage = SpigotConfig.transform( SpigotConfig.getString( "messages.restart", "Server is restarting" ) );
+         SpigotConfig.commands.put( "restart", new RestartCommand( "restart" ) );
+-        WatchdogThread.doStart( SpigotConfig.timeoutTime, SpigotConfig.restartOnCrash );
+        // WatchdogThread.doStart( SpigotConfig.timeoutTime, SpigotConfig.restartOnCrash ); // Paper - moved to after paper config initialization
+     }
+ 
+     public static boolean bungee;
+diff --git a/src/main/java/org/spigotmc/WatchdogThread.java b/src/main/java/org/spigotmc/WatchdogThread.java
+index 81ccbe2533e6fc5899d6c068e421e0d7f1351d34..ad282d34919716b75acd10426cd071da9d064a51 100644
+--- a/src/main/java/org/spigotmc/WatchdogThread.java
+++ b/src/main/java/org/spigotmc/WatchdogThread.java
+@@ -14,6 +14,10 @@ public class WatchdogThread extends Thread
+     private static WatchdogThread instance;
+     private long timeoutTime;
+     private boolean restart;
+    private final long earlyWarningEvery; // Paper - Timeout time for just printing a dump but not restarting
+    private final long earlyWarningDelay; // Paper
+    public static volatile boolean hasStarted; // Paper
+    private long lastEarlyWarning; // Paper - Keep track of short dump times to avoid spamming console with short dumps
+     private volatile long lastTick;
+     private volatile boolean stopping;
+ 
+@@ -22,6 +26,8 @@ public class WatchdogThread extends Thread
+         super( "Paper Watchdog Thread" );
+         this.timeoutTime = timeoutTime;
+         this.restart = restart;
+        earlyWarningEvery = Math.min(io.papermc.paper.configuration.GlobalConfiguration.get().watchdog.earlyWarningEvery, timeoutTime); // Paper
+        earlyWarningDelay = Math.min(io.papermc.paper.configuration.GlobalConfiguration.get().watchdog.earlyWarningDelay, timeoutTime); // Paper
+     }
+ 
+     private static long monotonicMillis()
+@@ -61,9 +67,18 @@ public class WatchdogThread extends Thread
+         while ( !this.stopping )
+         {
+             //
+-            if ( this.lastTick != 0 && this.timeoutTime > 0 && WatchdogThread.monotonicMillis() > this.lastTick + this.timeoutTime && !Boolean.getBoolean("disable.watchdog")) // Paper - Add property to disable
+            // Paper start
+            Logger log = Bukkit.getServer().getLogger();
+            long currentTime = WatchdogThread.monotonicMillis();
+            if ( this.lastTick != 0 && this.timeoutTime > 0 && currentTime > this.lastTick + this.earlyWarningEvery && !Boolean.getBoolean("disable.watchdog")) // Paper - Add property to disable
+             {
+-                Logger log = Bukkit.getServer().getLogger();
+                boolean isLongTimeout = currentTime > lastTick + timeoutTime;
+                // Don't spam early warning dumps
+                if ( !isLongTimeout && (earlyWarningEvery <= 0 || !hasStarted || currentTime < lastEarlyWarning + earlyWarningEvery || currentTime < lastTick + earlyWarningDelay)) continue;
+                if ( !isLongTimeout && MinecraftServer.getServer().hasStopped()) continue; // Don't spam early watchdog warnings during shutdown, we'll come back to this...
+                lastEarlyWarning = currentTime;
+                if (isLongTimeout) {
+                // Paper end
+                 log.log( Level.SEVERE, "------------------------------" );
+                 log.log( Level.SEVERE, "The server has stopped responding! This is (probably) not a Paper bug." ); // Paper
+                 log.log( Level.SEVERE, "If you see a plugin in the Server thread dump below, then please report it to that author" );
+@@ -92,29 +107,45 @@ public class WatchdogThread extends Thread
+                     }
+                 }
+                 // Paper end
+                } else
+                {
+                    log.log(Level.SEVERE, "--- DO NOT REPORT THIS TO PAPER - THIS IS NOT A BUG OR A CRASH  - " + Bukkit.getServer().getVersion() + " ---");
+                    log.log(Level.SEVERE, "The server has not responded for " + (currentTime - lastTick) / 1000 + " seconds! Creating thread dump");
+                }
+                // Paper end - Different message for short timeout
+                 log.log( Level.SEVERE, "------------------------------" );
+                 log.log( Level.SEVERE, "Server thread dump (Look for plugins here before reporting to Paper!):" ); // Paper
+                 WatchdogThread.dumpThread( ManagementFactory.getThreadMXBean().getThreadInfo( MinecraftServer.getServer().serverThread.getId(), Integer.MAX_VALUE ), log );
+                 log.log( Level.SEVERE, "------------------------------" );
+                 //
+                // Paper start - Only print full dump on long timeouts
+                if ( isLongTimeout )
+                {
+                 log.log( Level.SEVERE, "Entire Thread Dump:" );
+                 ThreadInfo[] threads = ManagementFactory.getThreadMXBean().dumpAllThreads( true, true );
+                 for ( ThreadInfo thread : threads )
+                 {
+                     WatchdogThread.dumpThread( thread, log );
+                 }
+                } else {
+                    log.log(Level.SEVERE, "--- DO NOT REPORT THIS TO PAPER - THIS IS NOT A BUG OR A CRASH ---");
+                }
+
+                 log.log( Level.SEVERE, "------------------------------" );
+ 
+                if ( isLongTimeout )
+                {
+                 if ( this.restart && !MinecraftServer.getServer().hasStopped() )
+                 {
+                     RestartCommand.restart();
+                 }
+                 break;
+                } // Paper end
+             }
+ 
+             try
+             {
+-                sleep( 10000 );
+                sleep( 1000 ); // Paper - Reduce check time to every second instead of every ten seconds, more consistent and allows for short timeout
+             } catch ( InterruptedException ex )
+             {
+                 this.interrupt();
--- a/patches/server/0226-Use-ConcurrentHashMap-in-JsonList.patch
+++ b/patches/server/0226-Use-ConcurrentHashMap-in-JsonList.patch
@ -0,0 +1,108 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: egg82 <phantom_zero@ymail.com>
+Date: Tue, 7 Aug 2018 01:24:23 -0600
+Subject: [PATCH] Use ConcurrentHashMap in JsonList
+
+This is specifically aimed at fixing #471
+
+Using a ConcurrentHashMap because thread safety
+The performance benefit of Map over ConcurrentMap is negligabe at best in this scenaio, as most operations will be get and not add or remove
+Even without considering the use-case the benefits are still negligable
+
+Original ideas for the system included an expiration policy and/or handler
+The simpler solution was to use a computeIfPresent in the get method
+This will simultaneously have an O(1) lookup time and automatically expire any values
+Since the get method (nor other similar methods) don't seem to have a critical need to flush the map to disk at any of these points further processing is simply wasteful
+Meaning the original function expired values unrelated to the current value without actually having any explicit need to
+
+The h method was heavily modified to be much more efficient in its processing
+Also instead of being called on every get, it's now called just before a save
+This will eliminate stale values being flushed to disk
+
+Modified isEmpty to use the isEmpty() method instead of the slightly confusing size() < 1
+The point of this is readability, but does have a side-benefit of a small microptimization
+
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 038c5f16e60f0e182774e6df5b6c5359153a4b07..9294ab23940cb2a822ba760052e3ad369abdfed6 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -594,7 +594,7 @@ public abstract class PlayerList {
+         } else if (!this.isWhiteListed(gameprofile, event)) { // Paper - ProfileWhitelistVerifyEvent
+             //ichatmutablecomponent = Component.translatable("multiplayer.disconnect.not_whitelisted"); // Paper
+             //event.disallow(PlayerLoginEvent.Result.KICK_WHITELIST, net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(org.spigotmc.SpigotConfig.whitelistMessage)); // Spigot // Paper - Adventure - moved to isWhitelisted
+-        } else if (this.getIpBans().isBanned(socketaddress) && !this.getIpBans().get(socketaddress).hasExpired()) {
+        } else if (this.getIpBans().isBanned(socketaddress) && getIpBans().get(socketaddress) != null && !this.getIpBans().get(socketaddress).hasExpired()) { // Paper - fix NPE with temp ip bans
+             IpBanListEntry ipbanentry = this.ipBans.get(socketaddress);
+ 
+             ichatmutablecomponent = Component.translatable("multiplayer.disconnect.banned_ip.reason", ipbanentry.getReason());
+diff --git a/src/main/java/net/minecraft/server/players/StoredUserList.java b/src/main/java/net/minecraft/server/players/StoredUserList.java
+index 7e81907bfdca225413e8191e37969990e6f4cf2c..c038da20b76c0b7b1c18471b20be01e849d29f3a 100644
+--- a/src/main/java/net/minecraft/server/players/StoredUserList.java
+++ b/src/main/java/net/minecraft/server/players/StoredUserList.java
+@@ -30,7 +30,7 @@ public abstract class StoredUserList<K, V extends StoredUserEntry<K>> {
+     private static final Logger LOGGER = LogUtils.getLogger();
+     private static final Gson GSON = (new GsonBuilder()).setPrettyPrinting().create();
+     private final File file;
+-    private final Map<String, V> map = Maps.newHashMap();
+    private final Map<String, V> map = Maps.newConcurrentMap(); // Paper - Use ConcurrentHashMap in JsonList
+ 
+     public StoredUserList(File file) {
+         this.file = file;
+@@ -53,8 +53,11 @@ public abstract class StoredUserList<K, V extends StoredUserEntry<K>> {
+ 
+     @Nullable
+     public V get(K key) {
+-        this.removeExpired();
+-        return (V) this.map.get(this.getKeyForUser(key)); // CraftBukkit - fix decompile error
+        // Paper start - Use ConcurrentHashMap in JsonList
+        return (V) this.map.computeIfPresent(this.getKeyForUser(key), (k, v) -> {
+            return v.hasExpired() ? null : v;
+        });
+        // Paper end - Use ConcurrentHashMap in JsonList
+     }
+ 
+     public void remove(K key) {
+@@ -77,7 +80,7 @@ public abstract class StoredUserList<K, V extends StoredUserEntry<K>> {
+     }
+ 
+     public boolean isEmpty() {
+-        return this.map.size() < 1;
+        return this.map.isEmpty(); // Paper - Use ConcurrentHashMap in JsonList
+     }
+ 
+     protected String getKeyForUser(K profile) {
+@@ -90,25 +93,7 @@ public abstract class StoredUserList<K, V extends StoredUserEntry<K>> {
+     }
+ 
+     private void removeExpired() {
+-        List<K> list = Lists.newArrayList();
+-        Iterator iterator = this.map.values().iterator();
+-
+-        while (iterator.hasNext()) {
+-            V v0 = (V) iterator.next(); // CraftBukkit - decompile error
+-
+-            if (v0.hasExpired()) {
+-                list.add(v0.getUser());
+-            }
+-        }
+-
+-        iterator = list.iterator();
+-
+-        while (iterator.hasNext()) {
+-            K k0 = (K) iterator.next(); // CraftBukkit - decompile error
+-
+-            this.map.remove(this.getKeyForUser(k0));
+-        }
+-
+        this.map.values().removeIf(StoredUserEntry::hasExpired); // Paper - Use ConcurrentHashMap in JsonList
+     }
+ 
+     protected abstract StoredUserEntry<K> createEntry(JsonObject json);
+@@ -118,6 +103,7 @@ public abstract class StoredUserList<K, V extends StoredUserEntry<K>> {
+     }
+ 
+     public void save() throws IOException {
+        this.removeExpired(); // Paper - remove expired values before saving
+         JsonArray jsonarray = new JsonArray();
+         Stream<JsonObject> stream = this.map.values().stream().map((jsonlistentry) -> { // CraftBukkit - decompile error
+             JsonObject jsonobject = new JsonObject();
--- a/patches/server/0227-Use-a-Queue-for-Queueing-Commands.patch
+++ b/patches/server/0227-Use-a-Queue-for-Queueing-Commands.patch
@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sun, 12 Aug 2018 02:33:39 -0400
+Subject: [PATCH] Use a Queue for Queueing Commands
+
+Lists are bad as Queues mmmkay.
+
+diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+index ff0b610cae7e9e0eb83bf95f350fd9ba7477535a..6d36c02d42e0b6e667d3076b1b455ba3adfde65b 100644
+--- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -77,7 +77,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+     static final Logger LOGGER = LogUtils.getLogger();
+     private static final int CONVERSION_RETRY_DELAY_MS = 5000;
+     private static final int CONVERSION_RETRIES = 2;
+-    private final List<ConsoleInput> consoleInput = Collections.synchronizedList(Lists.newArrayList());
+    private final java.util.Queue<ConsoleInput> serverCommandQueue = new java.util.concurrent.ConcurrentLinkedQueue<>(); // Paper - Perf: use a proper queue
+     @Nullable
+     private QueryThreadGs4 queryThreadGs4;
+     // private final RemoteControlCommandListener rconConsoleSource; // CraftBukkit - remove field
+@@ -420,13 +420,15 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+     }
+ 
+     public void handleConsoleInput(String command, CommandSourceStack commandSource) {
+-        this.consoleInput.add(new ConsoleInput(command, commandSource));
+        this.serverCommandQueue.add(new ConsoleInput(command, commandSource)); // Paper - Perf: use proper queue
+     }
+ 
+     public void handleConsoleInputs() {
+         MinecraftTimings.serverCommandTimer.startTiming(); // Spigot
+-        while (!this.consoleInput.isEmpty()) {
+-            ConsoleInput servercommand = (ConsoleInput) this.consoleInput.remove(0);
+        // Paper start - Perf: use proper queue
+        ConsoleInput servercommand;
+        while ((servercommand = this.serverCommandQueue.poll()) != null) {
+            // Paper end - Perf: use proper queue
+ 
+             // CraftBukkit start - ServerCommand for preprocessing
+             ServerCommandEvent event = new ServerCommandEvent(this.console, servercommand.msg);
--- a/patches/server/0228-Ability-to-get-block-entities-from-a-chunk-without-s.patch
+++ b/patches/server/0228-Ability-to-get-block-entities-from-a-chunk-without-s.patch
@ -0,0 +1,55 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Wed, 15 Aug 2018 01:16:34 -0400
+Subject: [PATCH] Ability to get block entities from a chunk without snapshots
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
+index 91d2b6eaa2af0abb1bdf11849f0fd59660f765dd..b2d85abb6c9c725955d972cd6895440849213fdf 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
+@@ -174,6 +174,13 @@ public class CraftChunk implements Chunk {
+ 
+     @Override
+     public BlockState[] getTileEntities() {
+        // Paper start
+        return getTileEntities(true);
+    }
+
+    @Override
+    public BlockState[] getTileEntities(boolean useSnapshot) {
+        // Paper end
+         if (!this.isLoaded()) {
+             this.getWorld().getChunkAt(this.x, this.z); // Transient load for this tick
+         }
+@@ -183,7 +190,29 @@ public class CraftChunk implements Chunk {
+         BlockState[] entities = new BlockState[chunk.blockEntities.size()];
+ 
+         for (BlockPos position : chunk.blockEntities.keySet()) {
+-            entities[index++] = this.worldServer.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ()).getState();
+            // Paper start
+            entities[index++] = this.worldServer.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ()).getState(useSnapshot);
+        }
+
+        return entities;
+    }
+
+    @Override
+    public Collection<BlockState> getTileEntities(Predicate<? super Block> blockPredicate, boolean useSnapshot) {
+        Preconditions.checkNotNull(blockPredicate, "blockPredicate");
+        if (!this.isLoaded()) {
+            this.getWorld().getChunkAt(this.x, this.z); // Transient load for this tick
+        }
+        ChunkAccess chunk = this.getHandle(ChunkStatus.FULL);
+
+        java.util.List<BlockState> entities = new java.util.ArrayList<>();
+
+        for (BlockPos position : chunk.blockEntities.keySet()) {
+            Block block = this.worldServer.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ());
+            if (blockPredicate.test(block)) {
+                entities.add(block.getState(useSnapshot));
+            }
+            // Paper end
+         }
+ 
+         return entities;
--- a/patches/server/0229-Optimize-BlockPosition-helper-methods.patch
+++ b/patches/server/0229-Optimize-BlockPosition-helper-methods.patch
@ -0,0 +1,107 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Wed, 15 Aug 2018 12:05:12 -0700
+Subject: [PATCH] Optimize BlockPosition helper methods
+
+
+diff --git a/src/main/java/net/minecraft/core/BlockPos.java b/src/main/java/net/minecraft/core/BlockPos.java
+index 83e7c141d947f8f8096fed1da716560494bc5c62..eea8bea0f40db8d36c59e628babf788fa920df94 100644
+--- a/src/main/java/net/minecraft/core/BlockPos.java
+++ b/src/main/java/net/minecraft/core/BlockPos.java
+@@ -157,67 +157,84 @@ public class BlockPos extends Vec3i {
+ 
+     @Override
+     public BlockPos above() {
+-        return this.relative(Direction.UP);
+        return new BlockPos(this.getX(), this.getY() + 1, this.getZ()); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos above(int distance) {
+-        return this.relative(Direction.UP, distance);
+        return distance == 0 ? this : new BlockPos(this.getX(), this.getY() + distance, this.getZ()); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos below() {
+-        return this.relative(Direction.DOWN);
+        return new BlockPos(this.getX(), this.getY() - 1, this.getZ()); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos below(int i) {
+-        return this.relative(Direction.DOWN, i);
+        return i == 0 ? this : new BlockPos(this.getX(), this.getY() - i, this.getZ()); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos north() {
+-        return this.relative(Direction.NORTH);
+        return new BlockPos(this.getX(), this.getY(), this.getZ() - 1); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos north(int distance) {
+-        return this.relative(Direction.NORTH, distance);
+        return distance == 0 ? this : new BlockPos(this.getX(), this.getY(), this.getZ() - distance); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos south() {
+-        return this.relative(Direction.SOUTH);
+        return new BlockPos(this.getX(), this.getY(), this.getZ() + 1); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos south(int distance) {
+-        return this.relative(Direction.SOUTH, distance);
+        return distance == 0 ? this : new BlockPos(this.getX(), this.getY(), this.getZ() + distance); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos west() {
+-        return this.relative(Direction.WEST);
+        return new BlockPos(this.getX() - 1, this.getY(), this.getZ()); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos west(int distance) {
+-        return this.relative(Direction.WEST, distance);
+        return distance == 0 ? this : new BlockPos(this.getX() - distance, this.getY(), this.getZ()); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos east() {
+-        return this.relative(Direction.EAST);
+        return new BlockPos(this.getX() + 1, this.getY(), this.getZ()); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos east(int distance) {
+-        return this.relative(Direction.EAST, distance);
+        return distance == 0 ? this : new BlockPos(this.getX() + distance, this.getY(), this.getZ()); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
+     public BlockPos relative(Direction direction) {
+        // Paper start - Perf: Optimize BlockPosition
+        switch(direction) {
+            case UP:
+                return new BlockPos(this.getX(), this.getY() + 1, this.getZ());
+            case DOWN:
+                return new BlockPos(this.getX(), this.getY() - 1, this.getZ());
+            case NORTH:
+                return new BlockPos(this.getX(), this.getY(), this.getZ() - 1);
+            case SOUTH:
+                return new BlockPos(this.getX(), this.getY(), this.getZ() + 1);
+            case WEST:
+                return new BlockPos(this.getX() - 1, this.getY(), this.getZ());
+            case EAST:
+                return new BlockPos(this.getX() + 1, this.getY(), this.getZ());
+            default:
+         return new BlockPos(this.getX() + direction.getStepX(), this.getY() + direction.getStepY(), this.getZ() + direction.getStepZ());
+        }
+        // Paper end - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
--- a/patches/server/0230-Restore-vanilla-default-mob-spawn-range-and-water-an.patch
+++ b/patches/server/0230-Restore-vanilla-default-mob-spawn-range-and-water-an.patch
@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sat, 18 Aug 2018 12:43:16 -0400
+Subject: [PATCH] Restore vanilla default mob-spawn-range and water animals
+ limit
+
+
+diff --git a/src/main/java/org/spigotmc/SpigotWorldConfig.java b/src/main/java/org/spigotmc/SpigotWorldConfig.java
+index 8bc7a9da0eb345e65f42461e2fb22731eb80790a..c4acaec8d331b4600c7b8b28fa969de9645938da 100644
+--- a/src/main/java/org/spigotmc/SpigotWorldConfig.java
+++ b/src/main/java/org/spigotmc/SpigotWorldConfig.java
+@@ -190,7 +190,7 @@ public class SpigotWorldConfig
+     public byte mobSpawnRange;
+     private void mobSpawnRange()
+     {
+-        this.mobSpawnRange = (byte) this.getInt( "mob-spawn-range", 6 );
+        this.mobSpawnRange = (byte) getInt( "mob-spawn-range", 8 ); // Paper - Vanilla
+         this.log( "Mob Spawn Range: " + this.mobSpawnRange );
+     }
+ 
--- a/patches/server/0231-Slime-Pathfinder-Events.patch
+++ b/patches/server/0231-Slime-Pathfinder-Events.patch
@ -0,0 +1,154 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Fri, 24 Aug 2018 08:18:42 -0500
+Subject: [PATCH] Slime Pathfinder Events
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Slime.java b/src/main/java/net/minecraft/world/entity/monster/Slime.java
+index 131fce812eb0dcdebab02b529ed18e81eb1861eb..26f4db572dc6c25a9815b8f352d8829e252fa1a2 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Slime.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Slime.java
+@@ -119,6 +119,7 @@ public class Slime extends Mob implements Enemy {
+     @Override
+     public void addAdditionalSaveData(CompoundTag nbt) {
+         super.addAdditionalSaveData(nbt);
+        nbt.putBoolean("Paper.canWander", this.canWander); // Paper
+         nbt.putInt("Size", this.getSize() - 1);
+         nbt.putBoolean("wasOnGround", this.wasOnGround);
+     }
+@@ -127,6 +128,11 @@ public class Slime extends Mob implements Enemy {
+     public void readAdditionalSaveData(CompoundTag nbt) {
+         this.setSize(nbt.getInt("Size") + 1, false);
+         super.readAdditionalSaveData(nbt);
+        // Paper start
+        if (nbt.contains("Paper.canWander")) {
+            this.canWander = nbt.getBoolean("Paper.canWander");
+        }
+        // Paper end
+         this.wasOnGround = nbt.getBoolean("wasOnGround");
+     }
+ 
+@@ -474,7 +480,7 @@ public class Slime extends Mob implements Enemy {
+ 
+         @Override
+         public boolean canUse() {
+-            return (this.slime.isInWater() || this.slime.isInLava()) && this.slime.getMoveControl() instanceof Slime.SlimeMoveControl;
+            return (this.slime.isInWater() || this.slime.isInLava()) && this.slime.getMoveControl() instanceof Slime.SlimeMoveControl && this.slime.canWander && new com.destroystokyo.paper.event.entity.SlimeSwimEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity()).callEvent(); // Paper - Slime pathfinder events
+         }
+ 
+         @Override
+@@ -511,7 +517,15 @@ public class Slime extends Mob implements Enemy {
+         public boolean canUse() {
+             LivingEntity entityliving = this.slime.getTarget();
+ 
+-            return entityliving == null ? false : (!this.slime.canAttack(entityliving) ? false : this.slime.getMoveControl() instanceof Slime.SlimeMoveControl);
+            // Paper start - Slime pathfinder events
+            if (entityliving == null || !entityliving.isAlive()) {
+                return false;
+            }
+            if (!this.slime.canAttack(entityliving)) {
+                return false;
+            }
+            return this.slime.getMoveControl() instanceof Slime.SlimeMoveControl && this.slime.canWander && new com.destroystokyo.paper.event.entity.SlimeTargetLivingEntityEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity(), (org.bukkit.entity.LivingEntity) entityliving.getBukkitEntity()).callEvent();
+            // Paper end - Slime pathfinder events
+         }
+ 
+         @Override
+@@ -524,7 +538,15 @@ public class Slime extends Mob implements Enemy {
+         public boolean canContinueToUse() {
+             LivingEntity entityliving = this.slime.getTarget();
+ 
+-            return entityliving == null ? false : (!this.slime.canAttack(entityliving) ? false : --this.growTiredTimer > 0);
+            // Paper start - Slime pathfinder events
+            if (entityliving == null || !entityliving.isAlive()) {
+                return false;
+            }
+            if (!this.slime.canAttack(entityliving)) {
+                return false;
+            }
+            return --this.growTiredTimer > 0 && this.slime.canWander && new com.destroystokyo.paper.event.entity.SlimeTargetLivingEntityEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity(), (org.bukkit.entity.LivingEntity) entityliving.getBukkitEntity()).callEvent();
+            // Paper end - Slime pathfinder events
+         }
+ 
+         @Override
+@@ -547,6 +569,13 @@ public class Slime extends Mob implements Enemy {
+             }
+ 
+         }
+
+        // Paper start - Slime pathfinder events; clear timer and target when goal resets
+        public void stop() {
+            this.growTiredTimer = 0;
+            this.slime.setTarget(null);
+        }
+        // Paper end - Slime pathfinder events
+     }
+ 
+     private static class SlimeRandomDirectionGoal extends Goal {
+@@ -562,7 +591,7 @@ public class Slime extends Mob implements Enemy {
+ 
+         @Override
+         public boolean canUse() {
+-            return this.slime.getTarget() == null && (this.slime.onGround() || this.slime.isInWater() || this.slime.isInLava() || this.slime.hasEffect(MobEffects.LEVITATION)) && this.slime.getMoveControl() instanceof Slime.SlimeMoveControl;
+            return this.slime.getTarget() == null && (this.slime.onGround() || this.slime.isInWater() || this.slime.isInLava() || this.slime.hasEffect(MobEffects.LEVITATION)) && this.slime.getMoveControl() instanceof Slime.SlimeMoveControl && this.slime.canWander; // Paper - Slime pathfinder events
+         }
+ 
+         @Override
+@@ -570,6 +599,11 @@ public class Slime extends Mob implements Enemy {
+             if (--this.nextRandomizeTime <= 0) {
+                 this.nextRandomizeTime = this.adjustedTickDelay(40 + this.slime.getRandom().nextInt(60));
+                 this.chosenDegrees = (float) this.slime.getRandom().nextInt(360);
+                // Paper start - Slime pathfinder events
+                com.destroystokyo.paper.event.entity.SlimeChangeDirectionEvent event = new com.destroystokyo.paper.event.entity.SlimeChangeDirectionEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity(), this.chosenDegrees);
+                if (!this.slime.canWander || !event.callEvent()) return;
+                this.chosenDegrees = event.getNewYaw();
+                // Paper end - Slime pathfinder events
+             }
+ 
+             MoveControl controllermove = this.slime.getMoveControl();
+@@ -592,7 +626,7 @@ public class Slime extends Mob implements Enemy {
+ 
+         @Override
+         public boolean canUse() {
+-            return !this.slime.isPassenger();
+            return !this.slime.isPassenger() && this.slime.canWander && new com.destroystokyo.paper.event.entity.SlimeWanderEvent((org.bukkit.entity.Slime) this.slime.getBukkitEntity()).callEvent(); // Paper - Slime pathfinder events
+         }
+ 
+         @Override
+@@ -605,4 +639,15 @@ public class Slime extends Mob implements Enemy {
+ 
+         }
+     }
+
+    // Paper start - Slime pathfinder events
+    private boolean canWander = true;
+    public boolean canWander() {
+        return canWander;
+    }
+
+    public void setWander(boolean canWander) {
+        this.canWander = canWander;
+    }
+    // Paper end - Slime pathfinder events
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftSlime.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftSlime.java
+index 3d991d9d9388108ec6d137950913209d61d132e7..3d9b7c0e128ea05bec5600c774e9685998b71cac 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftSlime.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftSlime.java
+@@ -28,4 +28,16 @@ public class CraftSlime extends CraftMob implements Slime, CraftEnemy {
+     public String toString() {
+         return "CraftSlime";
+     }
+
+    // Paper start
+    @Override
+    public boolean canWander() {
+        return getHandle().canWander();
+    }
+
+    @Override
+    public void setWander(boolean canWander) {
+        getHandle().setWander(canWander);
+    }
+    // Paper end
+ }
--- a/patches/server/0232-Configurable-speed-for-water-flowing-over-lava.patch
+++ b/patches/server/0232-Configurable-speed-for-water-flowing-over-lava.patch
@ -0,0 +1,52 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Byteflux <byte@byteflux.net>
+Date: Wed, 8 Aug 2018 16:33:21 -0600
+Subject: [PATCH] Configurable speed for water flowing over lava
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/LiquidBlock.java b/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
+index ac54fd2abb3334c16cba844aee38d7a6797046f3..a2d023ff011f71f80032f02430a53d6a08a23623 100644
+--- a/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
+@@ -141,11 +141,31 @@ public class LiquidBlock extends Block implements BucketPickup {
+     @Override
+     protected void onPlace(BlockState state, Level world, BlockPos pos, BlockState oldState, boolean notify) {
+         if (this.shouldSpreadLiquid(world, pos, state)) {
+-            world.scheduleTick(pos, state.getFluidState().getType(), this.fluid.getTickDelay(world));
+            world.scheduleTick(pos, state.getFluidState().getType(), this.getFlowSpeed(world, pos)); // Paper - Configurable speed for water flowing over lava
+         }
+ 
+     }
+ 
+    // Paper start - Configurable speed for water flowing over lava
+    public int getFlowSpeed(Level world, BlockPos blockposition) {
+        if (net.minecraft.core.registries.BuiltInRegistries.FLUID.wrapAsHolder(this.fluid).is(FluidTags.WATER)) {
+            if (
+                isLava(world, blockposition.north(1)) ||
+                isLava(world, blockposition.south(1)) ||
+                isLava(world, blockposition.west(1)) ||
+                isLava(world, blockposition.east(1))
+            ) {
+                return world.paperConfig().environment.waterOverLavaFlowSpeed;
+            }
+        }
+        return this.fluid.getTickDelay(world);
+    }
+    private static boolean isLava(Level world, BlockPos blockPos) {
+        final FluidState fluidState = world.getFluidIfLoaded(blockPos);
+        return fluidState != null && fluidState.is(FluidTags.LAVA);
+    }
+    // Paper end - Configurable speed for water flowing over lava
+
+     @Override
+     protected BlockState updateShape(BlockState state, LevelReader world, ScheduledTickAccess tickView, BlockPos pos, Direction direction, BlockPos neighborPos, BlockState neighborState, RandomSource random) {
+         if (state.getFluidState().isSource() || neighborState.getFluidState().isSource()) {
+@@ -158,7 +178,7 @@ public class LiquidBlock extends Block implements BucketPickup {
+     @Override
+     protected void neighborChanged(BlockState state, Level world, BlockPos pos, Block sourceBlock, @Nullable Orientation wireOrientation, boolean notify) {
+         if (this.shouldSpreadLiquid(world, pos, state)) {
+-            world.scheduleTick(pos, state.getFluidState().getType(), this.fluid.getTickDelay(world));
+            world.scheduleTick(pos, state.getFluidState().getType(), this.getFlowSpeed(world, pos)); // Paper - Configurable speed for water flowing over lava
+         }
+ 
+     }
--- a/patches/server/0233-Optimize-CraftBlockData-Creation.patch
+++ b/patches/server/0233-Optimize-CraftBlockData-Creation.patch
@ -0,0 +1,49 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: miclebrick <miclebrick@outlook.com>
+Date: Thu, 23 Aug 2018 11:45:32 -0400
+Subject: [PATCH] Optimize CraftBlockData Creation
+
+Avoids a hashmap lookup by cacheing a reference to the CraftBlockData
+and cloning it when one is needed.
+
+diff --git a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+index 0bae4e8d1e9fcc4608b3ef1c981c65f3b03de22b..83a3c877f2969549ea154ad86687e96fdf34d881 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+++ b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+@@ -862,6 +862,14 @@ public abstract class BlockBehaviour implements FeatureElement {
+             this.instrument = blockbase_info.instrument;
+             this.replaceable = blockbase_info.replaceable;
+         }
+        // Paper start - Perf: impl cached craft block data, lazy load to fix issue with loading at the wrong time
+        private org.bukkit.craftbukkit.block.data.CraftBlockData cachedCraftBlockData;
+
+        public org.bukkit.craftbukkit.block.data.CraftBlockData createCraftBlockData() {
+            if (cachedCraftBlockData == null) cachedCraftBlockData = org.bukkit.craftbukkit.block.data.CraftBlockData.createData(asState());
+            return (org.bukkit.craftbukkit.block.data.CraftBlockData) cachedCraftBlockData.clone();
+        }
+        // Paper end - Perf: impl cached craft block data, lazy load to fix issue with loading at the wrong time
+ 
+         private boolean calculateSolid() {
+             if (((Block) this.owner).properties.forceSolidOn) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/data/CraftBlockData.java b/src/main/java/org/bukkit/craftbukkit/block/data/CraftBlockData.java
+index da39a252be9b77c81c07d6b67da9f2380f9445a8..c53dbcfde62ae8e2f019e854c336ce4a60346dc9 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/data/CraftBlockData.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/data/CraftBlockData.java
+@@ -574,7 +574,17 @@ public class CraftBlockData implements BlockData {
+         return craft;
+     }
+ 
+    // Paper start - optimize creating BlockData to not need a map lookup
+    static {
+        // Initialize cached data for all IBlockData instances after registration
+        Block.BLOCK_STATE_REGISTRY.iterator().forEachRemaining(net.minecraft.world.level.block.state.BlockState::createCraftBlockData);
+    }
+     public static CraftBlockData fromData(net.minecraft.world.level.block.state.BlockState data) {
+        return data.createCraftBlockData();
+    }
+
+    public static CraftBlockData createData(net.minecraft.world.level.block.state.BlockState data) {
+        // Paper end
+         return CraftBlockData.MAP.getOrDefault(data.getBlock().getClass(), CraftBlockData::new).apply(data);
+     }
+ 
--- a/patches/server/0234-Optimize-MappedRegistry.patch
+++ b/patches/server/0234-Optimize-MappedRegistry.patch
@ -0,0 +1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Sun, 26 Aug 2018 20:49:50 -0400
+Subject: [PATCH] Optimize MappedRegistry
+
+Use larger initial sizes to increase bucket capacity on the BiMap
+
+BiMap.get was seen to be using a good bit of CPU time.
+
+diff --git a/src/main/java/net/minecraft/core/MappedRegistry.java b/src/main/java/net/minecraft/core/MappedRegistry.java
+index ecfb5efd6256ab212c28fa5eaa7005d6c7f80125..71e04e5c1bc0722abf8ca2e0738bd60b6d7ae21c 100644
+--- a/src/main/java/net/minecraft/core/MappedRegistry.java
+++ b/src/main/java/net/minecraft/core/MappedRegistry.java
+@@ -33,11 +33,11 @@ import net.minecraft.util.RandomSource;
+ public class MappedRegistry<T> implements WritableRegistry<T> {
+     private final ResourceKey<? extends Registry<T>> key;
+     private final ObjectList<Holder.Reference<T>> byId = new ObjectArrayList<>(256);
+-    private final Reference2IntMap<T> toId = Util.make(new Reference2IntOpenHashMap<>(), map -> map.defaultReturnValue(-1));
+-    private final Map<ResourceLocation, Holder.Reference<T>> byLocation = new HashMap<>();
+-    private final Map<ResourceKey<T>, Holder.Reference<T>> byKey = new HashMap<>();
+-    private final Map<T, Holder.Reference<T>> byValue = new IdentityHashMap<>();
+-    private final Map<ResourceKey<T>, RegistrationInfo> registrationInfos = new IdentityHashMap<>();
+    private final Reference2IntMap<T> toId = Util.make(new Reference2IntOpenHashMap<>(2048), map -> map.defaultReturnValue(-1)); // Paper - Perf: Use bigger expected size to reduce collisions
+    private final Map<ResourceLocation, Holder.Reference<T>> byLocation = new HashMap<>(2048); // Paper - Perf: Use bigger expected size to reduce collisions
+    private final Map<ResourceKey<T>, Holder.Reference<T>> byKey = new HashMap<>(2048); // Paper - Perf: Use bigger expected size to reduce collisions
+    private final Map<T, Holder.Reference<T>> byValue = new IdentityHashMap<>(2048); // Paper - Perf: Use bigger expected size to reduce collisions
+    private final Map<ResourceKey<T>, RegistrationInfo> registrationInfos = new IdentityHashMap<>(2048); // Paper - Perf: Use bigger expected size to reduce collisions
+     private Lifecycle registryLifecycle;
+     private final Map<TagKey<T>, HolderSet.Named<T>> frozenTags = new IdentityHashMap<>();
+     MappedRegistry.TagSet<T> allTags = MappedRegistry.TagSet.unbound();
--- a/patches/server/0235-Add-PhantomPreSpawnEvent.patch
+++ b/patches/server/0235-Add-PhantomPreSpawnEvent.patch
@ -0,0 +1,92 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Sat, 25 Aug 2018 19:56:51 -0500
+Subject: [PATCH] Add PhantomPreSpawnEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Phantom.java b/src/main/java/net/minecraft/world/entity/monster/Phantom.java
+index d9d374e18b1cacf0b04e6e02f3a94b145f4052fb..748f07c7036fe5955d76e28c4e7d23f8c0235d5f 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Phantom.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Phantom.java
+@@ -161,6 +161,11 @@ public class Phantom extends FlyingMob implements Enemy {
+         }
+ 
+         this.setPhantomSize(nbt.getInt("Size"));
+        // Paper start
+        if (nbt.hasUUID("Paper.SpawningEntity")) {
+            this.spawningEntity = nbt.getUUID("Paper.SpawningEntity");
+        }
+        // Paper end
+     }
+ 
+     @Override
+@@ -170,6 +175,11 @@ public class Phantom extends FlyingMob implements Enemy {
+         nbt.putInt("AY", this.anchorPoint.getY());
+         nbt.putInt("AZ", this.anchorPoint.getZ());
+         nbt.putInt("Size", this.getPhantomSize());
+        // Paper start
+        if (this.spawningEntity != null) {
+            nbt.putUUID("Paper.SpawningEntity", this.spawningEntity);
+        }
+        // Paper end
+     }
+ 
+     @Override
+@@ -219,6 +229,17 @@ public class Phantom extends FlyingMob implements Enemy {
+         return predicate.test(world, this, target);
+     }
+ 
+    // Paper start
+    @Nullable
+    java.util.UUID spawningEntity;
+
+    @Nullable
+    public java.util.UUID getSpawningEntity() {
+        return this.spawningEntity;
+    }
+    public void setSpawningEntity(java.util.UUID entity) { this.spawningEntity = entity; }
+    // Paper end
+
+     private static enum AttackPhase {
+ 
+         CIRCLE, SWOOP;
+diff --git a/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java b/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
+index 1ef81620541c97dce0fca4d85951202e9532e733..499b124f905ffa8e375efa354a3f2240997ddea5 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
+@@ -69,9 +69,19 @@ public class PhantomSpawner implements CustomSpawner {
+                                             int k = 1 + randomsource.nextInt(difficultydamagescaler.getDifficulty().getId() + 1);
+ 
+                                             for (int l = 0; l < k; ++l) {
+                                                // Paper start - PhantomPreSpawnEvent
+                                                com.destroystokyo.paper.event.entity.PhantomPreSpawnEvent event = new com.destroystokyo.paper.event.entity.PhantomPreSpawnEvent(io.papermc.paper.util.MCUtil.toLocation(world, blockposition1), entityplayer.getBukkitEntity(), org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL);
+                                                if (!event.callEvent()) {
+                                                    if (event.shouldAbortSpawn()) {
+                                                        break;
+                                                    }
+                                                    continue;
+                                                }
+                                                // Paper end - PhantomPreSpawnEvent
+                                                 Phantom entityphantom = (Phantom) EntityType.PHANTOM.create(world, EntitySpawnReason.NATURAL);
+ 
+                                                 if (entityphantom != null) {
+                                                    entityphantom.setSpawningEntity(entityplayer.getUUID()); // Paper - PhantomPreSpawnEvent
+                                                     entityphantom.moveTo(blockposition1, 0.0F, 0.0F);
+                                                     groupdataentity = entityphantom.finalizeSpawn(world, difficultydamagescaler, EntitySpawnReason.NATURAL, groupdataentity);
+                                                     world.addFreshEntityWithPassengers(entityphantom, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL); // CraftBukkit
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPhantom.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPhantom.java
+index 0359c161448941f1b9fdac545a5c47a68f19b760..305a635b049741ac5e2670060c6818cb2c07e5ab 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPhantom.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPhantom.java
+@@ -28,4 +28,11 @@ public class CraftPhantom extends CraftFlying implements Phantom, CraftEnemy {
+     public String toString() {
+         return "CraftPhantom";
+     }
+
+    // Paper start
+    @Override
+    public java.util.UUID getSpawningEntity() {
+        return getHandle().getSpawningEntity();
+    }
+    // Paper end
+ }
--- a/patches/server/0236-Add-More-Creeper-API.patch
+++ b/patches/server/0236-Add-More-Creeper-API.patch
@ -0,0 +1,60 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Fri, 24 Aug 2018 11:50:26 -0500
+Subject: [PATCH] Add More Creeper API
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Creeper.java b/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+index 0552cc23391ec305754339d000630ccab0729100..7a18dc59aed5294cd442994aa2d34ea00b877f46 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+++ b/src/main/java/net/minecraft/world/entity/monster/Creeper.java
+@@ -133,7 +133,7 @@ public class Creeper extends Monster {
+         }
+ 
+         if (nbt.getBoolean("ignited")) {
+-            this.ignite();
+            this.entityData.set(Creeper.DATA_IS_IGNITED, true); // Paper - set directly to avoid firing event
+         }
+ 
+     }
+@@ -315,7 +315,18 @@ public class Creeper extends Monster {
+     }
+ 
+     public void ignite() {
+-        this.entityData.set(Creeper.DATA_IS_IGNITED, true);
+        // Paper start - CreeperIgniteEvent
+        setIgnited(true);
+    }
+
+    public void setIgnited(boolean ignited) {
+        if (isIgnited() != ignited) {
+            com.destroystokyo.paper.event.entity.CreeperIgniteEvent event = new com.destroystokyo.paper.event.entity.CreeperIgniteEvent((org.bukkit.entity.Creeper) getBukkitEntity(), ignited);
+            if (event.callEvent()) {
+                this.entityData.set(Creeper.DATA_IS_IGNITED, event.isIgnited());
+            }
+        }
+        // Paper end - CreeperIgniteEvent
+     }
+ 
+     public boolean canDropMobsSkull() {
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java
+index 15bd44f8bd08b55b4da7fbbfdddc7ec3db454d89..42dd26b9170f7d217d73f725a6b8440b45ac2190 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java
+@@ -101,4 +101,16 @@ public class CraftCreeper extends CraftMonster implements Creeper {
+     public String toString() {
+         return "CraftCreeper";
+     }
+
+    // Paper start
+    @Override
+    public void setIgnited(boolean ignited) {
+        getHandle().setIgnited(ignited);
+    }
+
+    @Override
+    public boolean isIgnited() {
+        return getHandle().isIgnited();
+    }
+    // Paper end
+ }
--- a/patches/server/0237-Inventory-removeItemAnySlot.patch
+++ b/patches/server/0237-Inventory-removeItemAnySlot.patch
@ -0,0 +1,58 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Zach Brown <zach.brown@destroystokyo.com>
+Date: Tue, 28 Aug 2018 23:04:15 -0400
+Subject: [PATCH] Inventory#removeItemAnySlot
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
+index 88d5590aa07de09e56ac0bd8d23caa588e36807b..6a47c6adb721f0c6737150d8b0ee18ab70f5f281 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
+@@ -224,10 +224,16 @@ public class CraftInventory implements Inventory {
+     }
+ 
+     private int first(ItemStack item, boolean withAmount) {
+        // Paper start
+        return first(item, withAmount, getStorageContents());
+    }
+
+    private int first(ItemStack item, boolean withAmount, ItemStack[] inventory) {
+        // Paper end
+         if (item == null) {
+             return -1;
+         }
+-        ItemStack[] inventory = this.getStorageContents();
+        // ItemStack[] inventory = this.getStorageContents(); // Paper - let param deal
+         for (int i = 0; i < inventory.length; i++) {
+             if (inventory[i] == null) continue;
+ 
+@@ -351,6 +357,17 @@ public class CraftInventory implements Inventory {
+ 
+     @Override
+     public HashMap<Integer, ItemStack> removeItem(ItemStack... items) {
+        // Paper start
+        return removeItem(false, items);
+    }
+
+    @Override
+    public HashMap<Integer, ItemStack> removeItemAnySlot(ItemStack... items) {
+        return removeItem(true, items);
+    }
+
+    private HashMap<Integer, ItemStack> removeItem(boolean searchEntire, ItemStack... items) {
+        // Paper end
+         Preconditions.checkArgument(items != null, "items cannot be null");
+         HashMap<Integer, ItemStack> leftover = new HashMap<Integer, ItemStack>();
+ 
+@@ -362,7 +379,10 @@ public class CraftInventory implements Inventory {
+             int toDelete = item.getAmount();
+ 
+             while (true) {
+-                int first = this.first(item, false);
+                // Paper start - Allow searching entire contents
+                ItemStack[] toSearch = searchEntire ? getContents() : getStorageContents();
+                int first = this.first(item, false, toSearch);
+                // Paper end
+ 
+                 // Drat! we don't have this type in the inventory
+                 if (first == -1) {
--- a/patches/server/0238-Make-CraftWorld-loadChunk-int-int-false-load-unconve.patch
+++ b/patches/server/0238-Make-CraftWorld-loadChunk-int-int-false-load-unconve.patch
@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Sun, 2 Sep 2018 19:34:33 -0700
+Subject: [PATCH] Make CraftWorld#loadChunk(int, int, false) load unconverted
+ chunks
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index 1982385aa0e4984544d2aef88f5cafd5c0d5a49a..0a53b01094bd8070e57fb3c967c1129a53bd7ff8 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -438,7 +438,7 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+     @Override
+     public boolean loadChunk(int x, int z, boolean generate) {
+         org.spigotmc.AsyncCatcher.catchOp("chunk load"); // Spigot
+-        ChunkAccess chunk = this.world.getChunkSource().getChunk(x, z, generate ? ChunkStatus.FULL : ChunkStatus.EMPTY, true);
+        ChunkAccess chunk = this.world.getChunkSource().getChunk(x, z, generate || isChunkGenerated(x, z) ? ChunkStatus.FULL : ChunkStatus.EMPTY, true); // Paper
+ 
+         // If generate = false, but the chunk already exists, we will get this back.
+         if (chunk instanceof ImposterProtoChunk) {
--- a/patches/server/0239-Add-ray-tracing-methods-to-LivingEntity.patch
+++ b/patches/server/0239-Add-ray-tracing-methods-to-LivingEntity.patch
@ -0,0 +1,68 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Mon, 3 Sep 2018 18:20:03 -0500
+Subject: [PATCH] Add ray tracing methods to LivingEntity
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index c9d7589a18e9cee204f4e52368a60aa421c1e150..35dfaf46429f5478049835e1a5e4b03c362a64e8 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -4114,6 +4114,19 @@ public abstract class LivingEntity extends Entity implements Attackable {
+     }
+ 
+     // Paper start - Make shield blocking delay configurable
+    public HitResult getRayTrace(int maxDistance, ClipContext.Fluid fluidCollisionOption) {
+        if (maxDistance < 1 || maxDistance > 120) {
+            throw new IllegalArgumentException("maxDistance must be between 1-120");
+        }
+
+        Vec3 start = new Vec3(getX(), getY() + getEyeHeight(), getZ());
+        org.bukkit.util.Vector dir = getBukkitEntity().getLocation().getDirection().multiply(maxDistance);
+        Vec3 end = new Vec3(start.x + dir.getX(), start.y + dir.getY(), start.z + dir.getZ());
+        ClipContext raytrace = new ClipContext(start, end, ClipContext.Block.OUTLINE, fluidCollisionOption, this);
+
+        return this.level().clip(raytrace);
+    }
+
+     public int shieldBlockingDelay = this.level().paperConfig().misc.shieldBlockingDelay;
+ 
+     public int getShieldBlockingDelay() {
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index 2033354daafc739a8bd9ddf4a6128d3204d32094..0c7bf4124d67258ebca9b9b73b92c2e0efbdaa86 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -207,6 +207,33 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+         return blocks.get(0);
+     }
+ 
+    // Paper start
+    @Override
+    public Block getTargetBlock(int maxDistance, com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode) {
+        return this.getTargetBlockExact(maxDistance, fluidMode.bukkit);
+    }
+
+    @Override
+    public org.bukkit.block.BlockFace getTargetBlockFace(int maxDistance, com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode) {
+        return this.getTargetBlockFace(maxDistance, fluidMode.bukkit);
+    }
+
+    @Override
+    public org.bukkit.block.BlockFace getTargetBlockFace(int maxDistance, org.bukkit.FluidCollisionMode fluidMode) {
+        RayTraceResult result = this.rayTraceBlocks(maxDistance, fluidMode);
+        return result != null ? result.getHitBlockFace() : null;
+    }
+
+    @Override
+    public com.destroystokyo.paper.block.TargetBlockInfo getTargetBlockInfo(int maxDistance, com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode) {
+        RayTraceResult result = this.rayTraceBlocks(maxDistance, fluidMode.bukkit);
+        if (result != null && result.getHitBlock() != null && result.getHitBlockFace() != null) {
+            return new com.destroystokyo.paper.block.TargetBlockInfo(result.getHitBlock(), result.getHitBlockFace());
+        }
+        return null;
+    }
+    // Paper end
+
+     @Override
+     public List<Block> getLastTwoTargetBlocks(Set<Material> transparent, int maxDistance) {
+         return this.getLineOfSight(transparent, maxDistance, 2);
--- a/patches/server/0240-Expose-attack-cooldown-methods-for-Player.patch
+++ b/patches/server/0240-Expose-attack-cooldown-methods-for-Player.patch
@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Tue, 4 Sep 2018 15:02:00 -0500
+Subject: [PATCH] Expose attack cooldown methods for Player
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index ad75996926b7e054f1053d07fb978ac745f22ce6..535e0438b02fd7c10aee0d24786a6e38c6e48359 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -2993,6 +2993,21 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+ 
+         return this.adventure$pointers;
+     }
+
+    @Override
+    public float getCooldownPeriod() {
+        return getHandle().getCurrentItemAttackStrengthDelay();
+    }
+
+    @Override
+    public float getCooledAttackStrength(float adjustTicks) {
+        return getHandle().getAttackStrengthScale(adjustTicks);
+    }
+
+    @Override
+    public void resetCooldown() {
+        getHandle().resetAttackStrengthTicker();
+    }
+     // Paper end
+     // Spigot start
+     private final Player.Spigot spigot = new Player.Spigot()
--- a/patches/server/0241-Improve-death-events.patch
+++ b/patches/server/0241-Improve-death-events.patch
@ -0,0 +1,508 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Phoenix616 <mail@moep.tv>
+Date: Tue, 21 Aug 2018 01:39:35 +0100
+Subject: [PATCH] Improve death events
+
+This adds the ability to cancel the death events and to modify the sound
+an entity makes when dying. (In cases were no sound should it will be
+called with shouldPlaySound set to false allowing unsilencing of silent
+entities)
+
+It makes handling of entity deaths a lot nicer as you no longer need
+to listen on the damage event and calculate if the entity dies yourself
+to cancel the death which has the benefit of also receiving the dropped
+items and experience which is otherwise only properly possible by using
+internal code.
+
+== AT ==
+public net.minecraft.world.entity.LivingEntity getDeathSound()Lnet/minecraft/sounds/SoundEvent;
+public net.minecraft.world.entity.LivingEntity getSoundVolume()F
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 29b836a75b835f0d5233db419fc5ca8dde885fdb..2bd97344502a63173de923542f27759d7e98b6cc 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -296,6 +296,10 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player {
+     private int containerCounter;
+     public boolean wonGame;
+     private int containerUpdateDelay; // Paper - Configurable container update tick rate
+    // Paper start - cancellable death event
+    public boolean queueHealthUpdatePacket;
+    public net.minecraft.network.protocol.game.ClientboundSetHealthPacket queuedHealthUpdatePacket;
+    // Paper end - cancellable death event
+ 
+     // CraftBukkit start
+     public CraftPlayer.TransferCookieConnection transferCookieConnection;
+@@ -1154,7 +1158,7 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player {
+ 
+     @Override
+     public void die(DamageSource damageSource) {
+-        this.gameEvent(GameEvent.ENTITY_DIE);
+        // this.gameEvent(GameEvent.ENTITY_DIE); // Paper - move below event cancellation check
+         boolean flag = this.serverLevel().getGameRules().getBoolean(GameRules.RULE_SHOWDEATHMESSAGES);
+         // CraftBukkit start - fire PlayerDeathEvent
+         if (this.isRemoved()) {
+@@ -1182,6 +1186,16 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player {
+         String deathmessage = defaultMessage.getString();
+         this.keepLevel = keepInventory; // SPIGOT-2222: pre-set keepLevel
+         org.bukkit.event.entity.PlayerDeathEvent event = CraftEventFactory.callPlayerDeathEvent(this, damageSource, loot, PaperAdventure.asAdventure(defaultMessage), keepInventory); // Paper - Adventure
+        // Paper start - cancellable death event
+        if (event.isCancelled()) {
+            // make compatible with plugins that might have already set the health in an event listener
+            if (this.getHealth() <= 0) {
+                this.setHealth((float) event.getReviveHealth());
+            }
+            return;
+        }
+        this.gameEvent(GameEvent.ENTITY_DIE); // moved from the top of this method
+        // Paper end
+ 
+         // SPIGOT-943 - only call if they have an inventory open
+         if (this.containerMenu != this.inventoryMenu) {
+@@ -1331,7 +1345,17 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player {
+                     }
+                 }
+ 
+-                return super.hurtServer(world, source, amount);
+                // Paper start - cancellable death events
+                //return super.hurt(source, amount);
+                this.queueHealthUpdatePacket = true;
+                boolean damaged = super.hurtServer(world, source, amount);
+                this.queueHealthUpdatePacket = false;
+                if (this.queuedHealthUpdatePacket != null) {
+                    this.connection.send(this.queuedHealthUpdatePacket);
+                    this.queuedHealthUpdatePacket = null;
+                }
+                return damaged;
+                // Paper end
+             }
+         }
+     }
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 35dfaf46429f5478049835e1a5e4b03c362a64e8..a7e950bc5aa827c1b137a12c9eaaf7eac867bdc3 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -297,6 +297,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+     public Set<UUID> collidableExemptions = new HashSet<>();
+     public boolean bukkitPickUpLoot;
+     public org.bukkit.craftbukkit.entity.CraftLivingEntity getBukkitLivingEntity() { return (org.bukkit.craftbukkit.entity.CraftLivingEntity) super.getBukkitEntity(); } // Paper
+    public boolean silentDeath = false; // Paper - mark entity as dying silently for cancellable death event
+ 
+     @Override
+     public float getBukkitYaw() {
+@@ -1574,11 +1575,12 @@ public abstract class LivingEntity extends Entity implements Attackable {
+ 
+             if (this.isDeadOrDying()) {
+                 if (!this.checkTotemDeathProtection(source)) {
+-                    if (flag1) {
+-                        this.makeSound(this.getDeathSound());
+-                    }
+                    // Paper start - moved into CraftEventFactory event caller for cancellable death event
+                    this.silentDeath = !flag1; // mark entity as dying silently
+                    // Paper end
+ 
+                     this.die(source);
+                    this.silentDeath = false; // Paper - cancellable death event - reset to default
+                 }
+             } else if (flag1) {
+                 this.playHurtSound(source);
+@@ -1740,6 +1742,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+             Entity entity = damageSource.getEntity();
+             LivingEntity entityliving = this.getKillCredit();
+ 
+            /* // Paper - move down to make death event cancellable - this is the awardKillScore below
+             if (this.deathScore >= 0 && entityliving != null) {
+                 entityliving.awardKillScore(this, this.deathScore, damageSource);
+             }
+@@ -1751,24 +1754,59 @@ public abstract class LivingEntity extends Entity implements Attackable {
+             if (!this.level().isClientSide && this.hasCustomName()) {
+                 if (org.spigotmc.SpigotConfig.logNamedDeaths) LivingEntity.LOGGER.info("Named entity {} died: {}", this, this.getCombatTracker().getDeathMessage().getString()); // Spigot
+             }
+             */ // Paper - move down to make death event cancellable - this is the awardKillScore below
+ 
+             this.dead = true;
+-            this.getCombatTracker().recheckStatus();
+            // Paper - moved into if below
+             Level world = this.level();
+ 
+             if (world instanceof ServerLevel) {
+                 ServerLevel worldserver = (ServerLevel) world;
+                // Paper - move below into if for onKill
+
+                // Paper start
+                org.bukkit.event.entity.EntityDeathEvent deathEvent = this.dropAllDeathLoot(worldserver, damageSource);
+                if (deathEvent == null || !deathEvent.isCancelled()) {
+                    if (this.deathScore >= 0 && entityliving != null) {
+                        entityliving.awardKillScore(this, this.deathScore, damageSource);
+                    }
+                    // Paper start - clear equipment if event is not cancelled
+                    if (this instanceof Mob) {
+                        for (EquipmentSlot slot : this.clearedEquipmentSlots) {
+                            this.setItemSlot(slot, ItemStack.EMPTY);
+                        }
+                        this.clearedEquipmentSlots.clear();
+                    }
+                    // Paper end
+
+                    if (this.isSleeping()) {
+                        this.stopSleeping();
+                    }
+ 
+-                if (entity == null || entity.killedEntity(worldserver, this)) {
+                    if (!this.level().isClientSide && this.hasCustomName()) {
+                        if (org.spigotmc.SpigotConfig.logNamedDeaths) LivingEntity.LOGGER.info("Named entity {} died: {}", this, this.getCombatTracker().getDeathMessage().getString()); // Spigot
+                    }
+
+                    this.getCombatTracker().recheckStatus();
+                    if (entity != null) {
+                        entity.killedEntity((ServerLevel) this.level(), this);
+                    }
+                     this.gameEvent(GameEvent.ENTITY_DIE);
+-                    this.dropAllDeathLoot(worldserver, damageSource);
+                } else {
+                    this.dead = false;
+                    this.setHealth((float) deathEvent.getReviveHealth());
+                }
+                // Paper end
+                     this.createWitherRose(entityliving);
+                 }
+ 
+            // Paper start
+            if (this.dead) { // Paper
+                 this.level().broadcastEntityEvent(this, (byte) 3);
+-            }
+ 
+             this.setPose(Pose.DYING);
+            }
+            // Paper end
+         }
+     }
+ 
+@@ -1778,7 +1816,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+         if (world instanceof ServerLevel worldserver) {
+             boolean flag = false;
+ 
+-            if (adversary instanceof WitherBoss) {
+            if (this.dead && adversary instanceof WitherBoss) { // Paper
+                 if (worldserver.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
+                     BlockPos blockposition = this.blockPosition();
+                     BlockState iblockdata = Blocks.WITHER_ROSE.defaultBlockState();
+@@ -1807,24 +1845,37 @@ public abstract class LivingEntity extends Entity implements Attackable {
+         }
+     }
+ 
+-    protected void dropAllDeathLoot(ServerLevel world, DamageSource damageSource) {
+    // Paper start
+    protected boolean clearEquipmentSlots = true;
+    protected Set<EquipmentSlot> clearedEquipmentSlots = new java.util.HashSet<>();
+    protected org.bukkit.event.entity.EntityDeathEvent dropAllDeathLoot(ServerLevel world, DamageSource damageSource) {
+        // Paper end
+         boolean flag = this.lastHurtByPlayerTime > 0;
+ 
+         this.dropEquipment(world); // CraftBukkit - from below
+         if (this.shouldDropLoot() && world.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
+             this.dropFromLootTable(world, damageSource, flag);
+            // Paper start
+            final boolean prev = this.clearEquipmentSlots;
+            this.clearEquipmentSlots = false;
+            this.clearedEquipmentSlots.clear();
+            // Paper end
+             this.dropCustomDeathLoot(world, damageSource, flag);
+            this.clearEquipmentSlots = prev; // Paper
+         }
+         // CraftBukkit start - Call death event
+-        CraftEventFactory.callEntityDeathEvent(this, damageSource, this.drops);
+        org.bukkit.event.entity.EntityDeathEvent deathEvent = CraftEventFactory.callEntityDeathEvent(this, damageSource, this.drops); // Paper
+        this.postDeathDropItems(deathEvent); // Paper
+         this.drops = new ArrayList<>();
+         // CraftBukkit end
+ 
+         // this.dropEquipment(worldserver);// CraftBukkit - moved up
+         this.dropExperience(world, damageSource.getEntity());
+        return deathEvent; // Paper
+     }
+ 
+     protected void dropEquipment(ServerLevel world) {}
+    protected void postDeathDropItems(org.bukkit.event.entity.EntityDeathEvent event) {} // Paper - method for post death logic that cannot be ran before the event is potentially cancelled
+ 
+     public int getExpReward(ServerLevel worldserver, @Nullable Entity entity) { // CraftBukkit
+         if (!this.wasExperienceConsumed() && (this.isAlwaysExperienceDropper() || this.lastHurtByPlayerTime > 0 && this.shouldDropExperience() && worldserver.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT))) {
+diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
+index 2b8bfccbf520f9a356f816522ac3a5caa51e44e1..a8ab3c03a6f96658ce2a3f5758225954a36de6a9 100644
+--- a/src/main/java/net/minecraft/world/entity/Mob.java
+++ b/src/main/java/net/minecraft/world/entity/Mob.java
+@@ -1117,6 +1117,12 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
+ 
+     }
+ 
+    // Paper start
+    protected boolean shouldSkipLoot(EquipmentSlot slot) { // method to avoid to fallback into the global mob loot logic (i.e fox)
+        return false;
+    }
+    // Paper end
+
+     @Override
+     protected void dropCustomDeathLoot(ServerLevel world, DamageSource source, boolean causedByPlayer) {
+         super.dropCustomDeathLoot(world, source, causedByPlayer);
+@@ -1124,6 +1130,7 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
+ 
+         while (iterator.hasNext()) {
+             EquipmentSlot enumitemslot = (EquipmentSlot) iterator.next();
+            if (this.shouldSkipLoot(enumitemslot)) continue; // Paper
+             ItemStack itemstack = this.getItemBySlot(enumitemslot);
+             float f = this.getEquipmentDropChance(enumitemslot);
+ 
+@@ -1148,7 +1155,13 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
+                     }
+ 
+                     this.spawnAtLocation(world, itemstack);
+                    if (this.clearEquipmentSlots) { // Paper
+                     this.setItemSlot(enumitemslot, ItemStack.EMPTY);
+                    // Paper start
+                    } else {
+                        this.clearedEquipmentSlots.add(enumitemslot);
+                    }
+                    // Paper end
+                 }
+             }
+         }
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Fox.java b/src/main/java/net/minecraft/world/entity/animal/Fox.java
+index faffc3a9ed8bc306277cad37bc43af2ef7303493..205aefd38a185fa411ff17cfb0155769de8fc2fd 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Fox.java
+++ b/src/main/java/net/minecraft/world/entity/animal/Fox.java
+@@ -689,16 +689,38 @@ public class Fox extends Animal implements VariantHolder<Fox.Variant> {
+         return this.getTrustedUUIDs().contains(uuid);
+     }
+ 
+    // Paper start - handle the bitten item separately like vanilla
+     @Override
+-    protected void dropAllDeathLoot(ServerLevel world, DamageSource damageSource) {
+    protected boolean shouldSkipLoot(EquipmentSlot slot) {
+        return slot == EquipmentSlot.MAINHAND;
+    }
+    // Paper end
+
+    @Override
+    // Paper start - Cancellable death event
+    protected org.bukkit.event.entity.EntityDeathEvent dropAllDeathLoot(ServerLevel world, DamageSource damageSource) {
+         ItemStack itemstack = this.getItemBySlot(EquipmentSlot.MAINHAND);
+ 
+-        if (!itemstack.isEmpty()) {
+        boolean releaseMouth = false;
+        if (!itemstack.isEmpty() && world.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) { // Fix MC-153010
+             this.spawnAtLocation(world, itemstack);
+            releaseMouth = true;
+        }
+
+        org.bukkit.event.entity.EntityDeathEvent deathEvent = super.dropAllDeathLoot(world, damageSource);
+
+        // Below is code to drop
+
+        if (deathEvent == null || deathEvent.isCancelled()) {
+            return deathEvent;
+        }
+
+        if (releaseMouth) {
+            // Paper end - Cancellable death event
+             this.setItemSlot(EquipmentSlot.MAINHAND, ItemStack.EMPTY);
+         }
+ 
+-        super.dropAllDeathLoot(world, damageSource);
+        return deathEvent; // Paper - Cancellable death event
+     }
+ 
+     public static boolean isPathClear(Fox fox, LivingEntity chasedEntity) {
+diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/AbstractChestedHorse.java b/src/main/java/net/minecraft/world/entity/animal/horse/AbstractChestedHorse.java
+index dd7ef4c873d5e06eb5be3abc8049bf8acbd5a3fb..112b82ba7709b36e996e2f984c72ce40ca718720 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/horse/AbstractChestedHorse.java
+++ b/src/main/java/net/minecraft/world/entity/animal/horse/AbstractChestedHorse.java
+@@ -69,9 +69,16 @@ public abstract class AbstractChestedHorse extends AbstractHorse {
+         super.dropEquipment(world);
+         if (this.hasChest()) {
+             this.spawnAtLocation(world, Blocks.CHEST);
+            //this.setChest(false); // Paper - moved to post death logic
+        }
+    }
+    // Paper start
+    protected void postDeathDropItems(org.bukkit.event.entity.EntityDeathEvent event) {
+        if (this.hasChest() && (event == null || !event.isCancelled())) {
+             this.setChest(false);
+         }
+     }
+    // Paper end
+ 
+     @Override
+     public void addAdditionalSaveData(CompoundTag nbt) {
+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 2caba38a50b7ea535337a3540aa5272d4a9f1878..e20565cf256aacd012a1722c5ebbf9016bc82e42 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+++ b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
+@@ -506,8 +506,10 @@ public class ArmorStand extends LivingEntity {
+             }
+             // CraftBukkit end
+             if (source.is(DamageTypeTags.IS_EXPLOSION)) {
+-                this.brokenByAnything(world, source);
+-                this.kill(world, source); // CraftBukkit
+                // Paper start - avoid duplicate event call
+                org.bukkit.event.entity.EntityDeathEvent event = this.brokenByAnything(world, source);
+                if (!event.isCancelled()) this.kill(source, false); // CraftBukkit
+                // Paper end
+                 return false;
+             } else if (source.is(DamageTypeTags.IGNITES_ARMOR_STANDS)) {
+                 if (this.isOnFire()) {
+@@ -550,9 +552,9 @@ public class ArmorStand extends LivingEntity {
+                             this.gameEvent(GameEvent.ENTITY_DAMAGE, source.getEntity());
+                             this.lastHit = i;
+                         } else {
+-                            this.brokenByPlayer(world, source);
+                            org.bukkit.event.entity.EntityDeathEvent event = this.brokenByPlayer(world, source); // Paper
+                             this.showBreakingParticles();
+-                            this.discard(EntityRemoveEvent.Cause.DEATH); // CraftBukkit - SPIGOT-4890: remain as this.discard() since above damagesource method will call death event
+                            if (!event.isCancelled()) this.kill(source, false); // Paper - we still need to kill to follow vanilla logic (emit the game event etc...)
+                         }
+ 
+                         return true;
+@@ -602,7 +604,10 @@ public class ArmorStand extends LivingEntity {
+         f1 -= amount;
+         if (f1 <= 0.5F) {
+             this.brokenByAnything(world, damageSource);
+-            this.kill(world, damageSource); // CraftBukkit
+            // Paper start - avoid duplicate event call
+            org.bukkit.event.entity.EntityDeathEvent event = this.brokenByAnything(world, damageSource);
+            if (!event.isCancelled()) this.kill(damageSource, false); // CraftBukkit
+            // Paper end
+         } else {
+             this.setHealth(f1);
+             this.gameEvent(GameEvent.ENTITY_DAMAGE, damageSource.getEntity());
+@@ -610,15 +615,15 @@ public class ArmorStand extends LivingEntity {
+ 
+     }
+ 
+-    private void brokenByPlayer(ServerLevel world, DamageSource damageSource) {
+    private org.bukkit.event.entity.EntityDeathEvent brokenByPlayer(ServerLevel world, DamageSource damageSource) { // Paper
+         ItemStack itemstack = new ItemStack(Items.ARMOR_STAND);
+ 
+         itemstack.set(DataComponents.CUSTOM_NAME, this.getCustomName());
+         this.drops.add(org.bukkit.craftbukkit.inventory.CraftItemStack.asBukkitCopy(itemstack)); // CraftBukkit - add to drops
+-        this.brokenByAnything(world, damageSource);
+        return this.brokenByAnything(world, damageSource); // Paper
+     }
+ 
+-    private void brokenByAnything(ServerLevel world, DamageSource damageSource) {
+    private org.bukkit.event.entity.EntityDeathEvent brokenByAnything(ServerLevel world, DamageSource damageSource) { // Paper
+         this.playBrokenSound();
+         // this.dropAllDeathLoot(worldserver, damagesource); // CraftBukkit - moved down
+ 
+@@ -640,7 +645,7 @@ public class ArmorStand extends LivingEntity {
+                 this.armorItems.set(i, ItemStack.EMPTY);
+             }
+         }
+-        this.dropAllDeathLoot(world, damageSource); // CraftBukkit - moved from above
+        return this.dropAllDeathLoot(world, damageSource); // CraftBukkit - moved from above // Paper
+ 
+     }
+ 
+@@ -767,7 +772,15 @@ public class ArmorStand extends LivingEntity {
+     }
+ 
+     public void kill(ServerLevel worldserver, DamageSource damageSource) {
+-        org.bukkit.craftbukkit.event.CraftEventFactory.callEntityDeathEvent(this, (damageSource == null ? this.damageSources().genericKill() : damageSource), this.drops); // CraftBukkit - call event
+        // Paper start - make cancellable
+        this.kill(damageSource, true);
+    }
+    public void kill(DamageSource damageSource, boolean callEvent) {
+        if (callEvent) {
+            org.bukkit.event.entity.EntityDeathEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityDeathEvent(this, (damageSource == null ? this.damageSources().genericKill() : damageSource), this.drops); // CraftBukkit - call event
+            if (event.isCancelled()) return;
+        }
+        // Paper end
+         this.remove(Entity.RemovalReason.KILLED, EntityRemoveEvent.Cause.DEATH); // CraftBukkit - add Bukkit remove cause
+         // CraftBukkit end
+         this.gameEvent(GameEvent.ENTITY_DIE);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 535e0438b02fd7c10aee0d24786a6e38c6e48359..c132b4d4d871eaeadec78921a99ba7066c59ddda 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -2530,7 +2530,14 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     @Override
+     public void sendHealthUpdate() {
+         FoodData foodData = this.getHandle().getFoodData();
+-        this.sendHealthUpdate(this.getScaledHealth(), foodData.getFoodLevel(), foodData.getSaturationLevel());
+        // Paper start - cancellable death event
+        ClientboundSetHealthPacket packet = new ClientboundSetHealthPacket(this.getScaledHealth(), foodData.getFoodLevel(), foodData.getSaturationLevel());
+        if (this.getHandle().queueHealthUpdatePacket) {
+            this.getHandle().queuedHealthUpdatePacket = packet;
+        } else {
+            this.getHandle().connection.send(packet);
+        }
+        // Paper end
+     }
+ 
+     public void injectScaledMaxHealth(Collection<AttributeInstance> collection, boolean force) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+index 474f330f381aa74e9f2fd0accdbaf2617ec1c557..834516cac1f3ac5f078dd4e4dfa449f39462658c 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -902,8 +902,15 @@ public class CraftEventFactory {
+         CraftDamageSource bukkitDamageSource = new CraftDamageSource(damageSource);
+         CraftWorld world = (CraftWorld) entity.getWorld();
+         EntityDeathEvent event = new EntityDeathEvent(entity, bukkitDamageSource, drops, victim.getExpReward(world.getHandle(), damageSource.getEntity()));
+        populateFields(victim, event); // Paper - make cancellable
+         Bukkit.getServer().getPluginManager().callEvent(event);
+ 
+        // Paper start - make cancellable
+        if (event.isCancelled()) {
+            return event;
+        }
+        playDeathSound(victim, event);
+        // Paper end
+         victim.expToDrop = event.getDroppedExp();
+ 
+         for (org.bukkit.inventory.ItemStack stack : event.getDrops()) {
+@@ -921,7 +928,14 @@ public class CraftEventFactory {
+         PlayerDeathEvent event = new PlayerDeathEvent(entity, bukkitDamageSource, drops, victim.getExpReward(victim.serverLevel(), damageSource.getEntity()), 0, deathMessage);
+         event.setKeepInventory(keepInventory);
+         event.setKeepLevel(victim.keepLevel); // SPIGOT-2222: pre-set keepLevel
+populateFields(victim, event); // Paper - make cancellable
+         Bukkit.getServer().getPluginManager().callEvent(event);
+        // Paper start - make cancellable
+        if (event.isCancelled()) {
+            return event;
+        }
+        playDeathSound(victim, event);
+        // Paper end
+ 
+         victim.keepLevel = event.getKeepLevel();
+         victim.newLevel = event.getNewLevel();
+@@ -944,6 +958,31 @@ public class CraftEventFactory {
+         return event;
+     }
+ 
+    // Paper start - helper methods for making death event cancellable
+    // Add information to death event
+    private static void populateFields(net.minecraft.world.entity.LivingEntity victim, EntityDeathEvent event) {
+        event.setReviveHealth(event.getEntity().getAttribute(org.bukkit.attribute.Attribute.GENERIC_MAX_HEALTH).getValue());
+        event.setShouldPlayDeathSound(!victim.silentDeath && !victim.isSilent());
+        net.minecraft.sounds.SoundEvent soundEffect = victim.getDeathSound();
+        event.setDeathSound(soundEffect != null ? org.bukkit.craftbukkit.CraftSound.minecraftToBukkit(soundEffect) : null);
+        event.setDeathSoundCategory(org.bukkit.SoundCategory.valueOf(victim.getSoundSource().name()));
+        event.setDeathSoundVolume(victim.getSoundVolume());
+        event.setDeathSoundPitch(victim.getVoicePitch());
+    }
+
+    // Play death sound manually
+    private static void playDeathSound(net.minecraft.world.entity.LivingEntity victim, EntityDeathEvent event) {
+        if (event.shouldPlayDeathSound() && event.getDeathSound() != null && event.getDeathSoundCategory() != null) {
+            net.minecraft.world.entity.player.Player source = victim instanceof net.minecraft.world.entity.player.Player ? (net.minecraft.world.entity.player.Player) victim : null;
+            double x = event.getEntity().getLocation().getX();
+            double y = event.getEntity().getLocation().getY();
+            double z = event.getEntity().getLocation().getZ();
+            net.minecraft.sounds.SoundEvent soundEffect = org.bukkit.craftbukkit.CraftSound.bukkitToMinecraft(event.getDeathSound());
+            net.minecraft.sounds.SoundSource soundCategory = net.minecraft.sounds.SoundSource.valueOf(event.getDeathSoundCategory().name());
+            victim.level().playSound(source, x, y, z, soundEffect, soundCategory, event.getDeathSoundVolume(), event.getDeathSoundPitch());
+        }
+    }
+    // Paper end
+     /**
+      * Server methods
+      */