even more wooooooooooooooooooooooooork uwu

patches/server-remapped/Avoid-NPE-in-PathfinderGoalTempt.patch

@@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Wed, 29 Nov 2017 22:18:54 -0500
-Subject: [PATCH] Avoid NPE in PathfinderGoalTempt
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/TemptGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/TemptGoal.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ai/goal/TemptGoal.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/goal/TemptGoal.java
-@@ -0,0 +0,0 @@ public class TemptGoal extends Goal {
-                 }
-                 this.target = (event.getTarget() == null) ? null : ((CraftLivingEntity) event.getTarget()).getHandle();
-             }
--            return tempt;
-+            return tempt && this.target != null; // Paper - must have target - plugin might of cancelled
-             // CraftBukkit end
-         }
-     }

patches/server-remapped/ExperienceOrbMergeEvent.patch

@@ -1,22 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Tue, 19 Dec 2017 22:57:26 -0500
-Subject: [PATCH] ExperienceOrbMergeEvent
-
-Fired when the server is about to merge 2 experience orbs
-Plugins can cancel this if they want to ensure experience orbs do not lose important
-metadata such as spawn reason, or conditionally move data from source to target.
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
-                     if (e instanceof net.minecraft.world.entity.ExperienceOrb) {
-                         net.minecraft.world.entity.ExperienceOrb loopItem = (net.minecraft.world.entity.ExperienceOrb) e;
-                         // Paper start
--                        if (!loopItem.removed && !(maxValue > 0 && loopItem.value >= maxValue)) {
-+                        if (!loopItem.removed && !(maxValue > 0 && loopItem.value >= maxValue)  && new com.destroystokyo.paper.event.entity.ExperienceOrbMergeEvent((org.bukkit.entity.ExperienceOrb) entity.getBukkitEntity(), (org.bukkit.entity.ExperienceOrb) loopItem.getBukkitEntity()).callEvent()) { // Paper
-                             long newTotal = (long)xp.value + (long)loopItem.value;
-                             if ((int) newTotal < 0) continue; // Overflow
-                             if (maxValue > 0 && newTotal > (long)maxValue) {

patches/server-remapped/Option-for-maximum-exp-value-when-merging-orbs.patch

@@ -1,61 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Fri, 10 Nov 2017 23:03:12 -0500
-Subject: [PATCH] Option for maximum exp value when merging orbs
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         disableCreeperLingeringEffect = getBoolean("disable-creeper-lingering-effect", false);
-         log("Creeper lingering effect: " + disableCreeperLingeringEffect);
-     }
-+
-+    public int expMergeMaxValue;
-+    private void expMergeMaxValue() {
-+        expMergeMaxValue = getInt("experience-merge-max-value", -1);
-+        log("Experience Merge Max Value: " + expMergeMaxValue);
-+    }
- }
-diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
-             net.minecraft.world.entity.ExperienceOrb xp = (net.minecraft.world.entity.ExperienceOrb) entity;
-             double radius = world.spigotConfig.expMerge;
-             if (radius > 0) {
-+                // Paper start - Maximum exp value when merging - Whole section has been tweaked, see comments for specifics
-+                final int maxValue = world.paperConfig.expMergeMaxValue;
-+                final boolean mergeUnconditionally = world.paperConfig.expMergeMaxValue <= 0;
-+                if (mergeUnconditionally || xp.value < maxValue) { // Paper - Skip iteration if unnecessary
-+
-                 List<Entity> entities = world.getEntities(entity, entity.getBoundingBox().inflate(radius, radius, radius));
-                 for (Entity e : entities) {
-                     if (e instanceof net.minecraft.world.entity.ExperienceOrb) {
-                         net.minecraft.world.entity.ExperienceOrb loopItem = (net.minecraft.world.entity.ExperienceOrb) e;
--                        if (!loopItem.removed) {
--                            xp.value += loopItem.value;
--                            loopItem.remove();
-+                        // Paper start
-+                        if (!loopItem.removed && !(maxValue > 0 && loopItem.value >= maxValue)) {
-+                            long newTotal = (long)xp.value + (long)loopItem.value;
-+                            if ((int) newTotal < 0) continue; // Overflow
-+                            if (maxValue > 0 && newTotal > (long)maxValue) {
-+                                loopItem.value = (int) (newTotal - maxValue);
-+                                xp.value = maxValue;
-+                            } else {
-+                                xp.value += loopItem.value;
-+                                loopItem.remove();
-+                            }
-+                            // Paper end
-                         }
-                     }
-                 }
-+
-+                } // Paper end - End iteration skip check - All tweaking ends here
-             }
-         // Spigot end
-         } else if (!(entity instanceof ServerPlayer)) {

patches/server-remapped/PlayerPickupExperienceEvent.patch

@@ -1,28 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Tue, 19 Dec 2017 22:02:53 -0500
-Subject: [PATCH] PlayerPickupExperienceEvent
-
-Allows plugins to cancel a player picking up an experience orb
-
-diff --git a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-+++ b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-@@ -0,0 +0,0 @@ import net.minecraft.core.BlockPos;
- import net.minecraft.nbt.CompoundTag;
- import net.minecraft.network.protocol.Packet;
- import net.minecraft.network.protocol.game.ClientboundAddExperienceOrbPacket;
-+import net.minecraft.server.level.ServerPlayer;
- import net.minecraft.sounds.SoundEvents;
- import net.minecraft.tags.FluidTags;
- import net.minecraft.tags.Tag;
-@@ -0,0 +0,0 @@ public class ExperienceOrb extends Entity {
-     @Override
-     public void playerTouch(Player player) {
-         if (!this.level.isClientSide) {
--            if (this.throwTime == 0 && player.takeXpDelay == 0) {
-+            if (this.throwTime == 0 && player.takeXpDelay == 0 && new com.destroystokyo.paper.event.player.PlayerPickupExperienceEvent(((ServerPlayer) player).getBukkitEntity(), (org.bukkit.entity.ExperienceOrb) this.getBukkitEntity()).callEvent()) { // Paper
-                 player.takeXpDelay = 2;
-                 player.take(this, 1);
-                 Entry<EquipmentSlot, ItemStack> entry = EnchantmentHelper.getRandomItemWith(Enchantments.MENDING, (LivingEntity) player, ItemStack::isDamaged);

patches/server-remapped/PreCreatureSpawnEvent.patch

@@ -1,215 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sun, 14 Jan 2018 17:01:31 -0500
-Subject: [PATCH] PreCreatureSpawnEvent
-
-Adds an event to fire before an Entity is created, so that plugins that need to cancel
-CreatureSpawnEvent can do so from this event instead.
-
-Cancelling CreatureSpawnEvent rapidly causes a lot of garbage collection and CPU waste
-as it's done after the Entity object has been fully created.
-
-Mob Limiting plugins and blanket "ban this type of monster" plugins should use this event
-instead and save a lot of server resources.
-
-See: https://github.com/PaperMC/Paper/issues/917
-
-diff --git a/src/main/java/net/minecraft/world/entity/EntityType.java b/src/main/java/net/minecraft/world/entity/EntityType.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/EntityType.java
-+++ b/src/main/java/net/minecraft/world/entity/EntityType.java
-@@ -0,0 +0,0 @@ import net.minecraft.nbt.ListTag;
- import net.minecraft.network.chat.Component;
- import net.minecraft.network.chat.TranslatableComponent;
- import net.minecraft.resources.ResourceLocation;
-+import net.minecraft.server.MCUtil;
- import net.minecraft.server.MinecraftServer;
- import net.minecraft.server.level.ServerLevel;
- import net.minecraft.tags.BlockTags;
-@@ -0,0 +0,0 @@ public class EntityType<T extends Entity> {
- 
-     @Nullable
-     public T spawnCreature(ServerLevel worldserver, @Nullable CompoundTag nbttagcompound, @Nullable Component ichatbasecomponent, @Nullable Player entityhuman, BlockPos blockposition, MobSpawnType enummobspawn, boolean flag, boolean flag1, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason spawnReason) {
-+        // Paper start - Call PreCreatureSpawnEvent
-+        org.bukkit.entity.EntityType type = org.bukkit.entity.EntityType.fromName(EntityType.getKey(this).getPath());
-+        if (type != null) {
-+            com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent event;
-+            event = new com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent(
-+                MCUtil.toLocation(worldserver, blockposition),
-+                type,
-+                spawnReason
-+            );
-+            if (!event.callEvent()) {
-+                return null;
-+            }
-+        }
-+        // Paper end
-         T t0 = this.create(worldserver, nbttagcompound, ichatbasecomponent, entityhuman, blockposition, enummobspawn, flag, flag1);
- 
-         if (t0 != null) {
-diff --git a/src/main/java/net/minecraft/world/entity/ai/sensing/GolemSensor.java b/src/main/java/net/minecraft/world/entity/ai/sensing/GolemSensor.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ai/sensing/GolemSensor.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/sensing/GolemSensor.java
-@@ -0,0 +0,0 @@ public class GolemSensor extends Sensor<LivingEntity> {
-         Optional<List<LivingEntity>> optional = entityliving.getBrain().getMemory(MemoryModuleType.MOBS);
- 
-         if (optional.isPresent()) {
--            boolean flag = ((List) optional.get()).stream().anyMatch((entityliving1) -> {
--                return entityliving1.getEntityType().equals(EntityType.IRON_GOLEM);
-+            boolean flag = optional.get().stream().anyMatch((entityliving1) -> { // Paper - decompile fixes
-+                return entityliving1.getType().equals(EntityType.IRON_GOLEM);
-             });
- 
-             if (flag) {
-@@ -0,0 +0,0 @@ public class GolemSensor extends Sensor<LivingEntity> {
-         }
-     }
- 
-+    public static void setDetectedRecently(LivingEntity entityLiving) { golemDetected(entityLiving); } // Paper - OBFHELPER
-     public static void golemDetected(LivingEntity entityliving) {
-         entityliving.getBrain().setMemoryWithExpiry(MemoryModuleType.GOLEM_DETECTED_RECENTLY, true, 600L);
-     }
-diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
-+++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
-@@ -0,0 +0,0 @@ import net.minecraft.network.protocol.game.DebugPackets;
- import net.minecraft.network.syncher.EntityDataAccessor;
- import net.minecraft.network.syncher.EntityDataSerializers;
- import net.minecraft.network.syncher.SynchedEntityData;
-+import net.minecraft.server.MCUtil;
- import net.minecraft.server.MinecraftServer;
- import net.minecraft.server.level.ServerLevel;
- import net.minecraft.sounds.SoundEvent;
-@@ -0,0 +0,0 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
-             BlockPos blockposition1 = this.findSpawnPositionForGolemInColumn(blockposition, d0, d1);
- 
-             if (blockposition1 != null) {
-+                // Paper start - Call PreCreatureSpawnEvent
-+                com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent event;
-+                event = new com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent(
-+                    MCUtil.toLocation(level, blockposition1),
-+                    org.bukkit.entity.EntityType.IRON_GOLEM,
-+                    org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.VILLAGE_DEFENSE
-+                );
-+                if (!event.callEvent()) {
-+                    if (event.shouldAbortSpawn()) {
-+                        GolemSensor.golemDetected(this); // Set Golem Last Seen to stop it from spawning another one
-+                        return null;
-+                    }
-+                    break;
-+                }
-+                // Paper end
-                 IronGolem entityirongolem = (IronGolem) EntityType.IRON_GOLEM.create(world, (CompoundTag) null, (Component) null, (Player) null, blockposition1, MobSpawnType.MOB_SUMMONED, false, false);
- 
-                 if (entityirongolem != null) {
-diff --git a/src/main/java/net/minecraft/world/level/BaseSpawner.java b/src/main/java/net/minecraft/world/level/BaseSpawner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/BaseSpawner.java
-+++ b/src/main/java/net/minecraft/world/level/BaseSpawner.java
-@@ -0,0 +0,0 @@ import net.minecraft.core.particles.ParticleTypes;
- import net.minecraft.nbt.CompoundTag;
- import net.minecraft.nbt.ListTag;
- import net.minecraft.resources.ResourceLocation;
-+import net.minecraft.server.MCUtil;
- import net.minecraft.server.level.ServerLevel;
- import net.minecraft.util.StringUtil;
- import net.minecraft.util.WeighedRandom;
-@@ -0,0 +0,0 @@ public abstract class BaseSpawner {
-                         ServerLevel worldserver = (ServerLevel) world;
- 
-                         if (SpawnPlacements.checkSpawnRules((EntityType) optional.get(), worldserver, MobSpawnType.SPAWNER, new BlockPos(d3, d4, d5), world.getRandom())) {
-+                            // Paper start
-+                            EntityType<?> entityType = optional.get();
-+                            String key = EntityType.getKey(entityType).getPath();
-+
-+                            org.bukkit.entity.EntityType type = org.bukkit.entity.EntityType.fromName(key);
-+                            if (type != null) {
-+                                com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent event;
-+                                event = new com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent(
-+                                    MCUtil.toLocation(world, d3, d4, d5),
-+                                    type,
-+                                    org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.SPAWNER
-+                                );
-+                                if (!event.callEvent()) {
-+                                    flag = true;
-+                                    if (event.shouldAbortSpawn()) {
-+                                        break;
-+                                    }
-+                                    continue;
-+                                }
-+                            }
-+                            // Paper end
-                             Entity entity = EntityType.loadEntityRecursive(nbttagcompound, world, (entity1) -> {
-                                 entity1.moveTo(d3, d4, d5, entity1.yRot, entity1.xRot);
-                                 return entity1;
-diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java
-+++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
-@@ -0,0 +0,0 @@ import net.minecraft.core.Direction;
- import net.minecraft.core.Position;
- import net.minecraft.core.Registry;
- import net.minecraft.nbt.CompoundTag;
-+import net.minecraft.server.MCUtil;
- import net.minecraft.server.level.ServerLevel;
- import net.minecraft.tags.BlockTags;
- import net.minecraft.tags.FluidTags;
-@@ -0,0 +0,0 @@ public final class NaturalSpawner {
-                                         j1 = biomesettingsmobs_c.minCount + world.random.nextInt(1 + biomesettingsmobs_c.maxCount - biomesettingsmobs_c.minCount);
-                                     }
- 
--                                    if (isValidSpawnPostitionForType(world, group, structuremanager, chunkgenerator, biomesettingsmobs_c, blockposition_mutableblockposition, d2) && checker.test(biomesettingsmobs_c.type, blockposition_mutableblockposition, chunk)) {
-+                                    // Paper start
-+                                    Boolean doSpawning = a(world, group, structuremanager, chunkgenerator, biomesettingsmobs_c, blockposition_mutableblockposition, d2);
-+                                    if (doSpawning == null) {
-+                                        return;
-+                                    }
-+                                    if (doSpawning && checker.test(biomesettingsmobs_c.type, blockposition_mutableblockposition, chunk)) {
-+                                        // Paper end
-                                         Mob entityinsentient = getMobForSpawn(world, biomesettingsmobs_c.type);
- 
-+
-                                         if (entityinsentient == null) {
-                                             return;
-                                         }
-@@ -0,0 +0,0 @@ public final class NaturalSpawner {
-         }
-     }
- 
--    private static boolean isValidSpawnPostitionForType(ServerLevel world, MobCategory group, StructureFeatureManager structureAccessor, ChunkGenerator chunkGenerator, MobSpawnSettings.SpawnerData spawnEntry, BlockPos.MutableBlockPos pos, double squaredDistance) {
--        EntityType<?> entitytypes = spawnEntry.type;
-+    private static Boolean a(ServerLevel worldserver, MobCategory enumcreaturetype, StructureFeatureManager structuremanager, ChunkGenerator chunkgenerator, MobSpawnSettings.SpawnerData biomesettingsmobs_c, BlockPos.MutableBlockPos blockposition_mutableblockposition, double d0) { // Paper
-+        EntityType<?> entitytypes = biomesettingsmobs_c.type;
-+        // Paper start
-+        com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent event;
-+        org.bukkit.entity.EntityType type = org.bukkit.entity.EntityType.fromName(EntityType.getKey(entitytypes).getPath());
-+        if (type != null) {
-+            event = new com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent(
-+                MCUtil.toLocation(worldserver, blockposition_mutableblockposition),
-+                type, SpawnReason.NATURAL
-+            );
-+            if (!event.callEvent()) {
-+                if (event.shouldAbortSpawn()) {
-+                    return null;
-+                }
-+                return false;
-+            }
-+        }
-+        // Paper end
- 
-         if (entitytypes.getCategory() == MobCategory.MISC) {
-             return false;
--        } else if (!entitytypes.canSpawnFarFromPlayer() && squaredDistance > (double) (entitytypes.getCategory().getDespawnDistance() * entitytypes.getCategory().getDespawnDistance())) {
-+        } else if (!entitytypes.canSpawnFarFromPlayer() && d0 > (double) (entitytypes.getCategory().getDespawnDistance() * entitytypes.getCategory().getDespawnDistance())) {
-             return false;
--        } else if (entitytypes.canSummon() && canSpawnMobAt(world, structureAccessor, chunkGenerator, group, spawnEntry, (BlockPos) pos)) {
-+        } else if (entitytypes.canSummon() && canSpawnMobAt(worldserver, structuremanager, chunkgenerator, enumcreaturetype, biomesettingsmobs_c, (BlockPos) blockposition_mutableblockposition)) {
-             SpawnPlacements.Type entitypositiontypes_surface = SpawnPlacements.getPlacementType(entitytypes);
- 
--            return !isSpawnPositionOk(entitypositiontypes_surface, (LevelReader) world, pos, entitytypes) ? false : (!SpawnPlacements.checkSpawnRules(entitytypes, world, MobSpawnType.NATURAL, pos, world.random) ? false : world.noCollision(entitytypes.getAABB((double) pos.getX() + 0.5D, (double) pos.getY(), (double) pos.getZ() + 0.5D)));
-+            return !isSpawnPositionOk(entitypositiontypes_surface, (LevelReader) worldserver, blockposition_mutableblockposition, entitytypes) ? false : (!SpawnPlacements.checkSpawnRules(entitytypes, worldserver, MobSpawnType.NATURAL, blockposition_mutableblockposition, worldserver.random) ? false : worldserver.noCollision(entitytypes.getAABB((double) blockposition_mutableblockposition.getX() + 0.5D, (double) blockposition_mutableblockposition.getY(), (double) blockposition_mutableblockposition.getZ() + 0.5D)));
-         } else {
-             return false;
-         }

patches/server/API-to-get-a-BlockState-without-a-snapshot.patch

@@ -17,21 +17,30 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
 +++ b/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
 @@ -0,0 +0,0 @@ public abstract class BlockEntity implements net.minecraft.server.KeyedObject {
-     public BlockEntity(BlockEntityType<?> type) {
+     // CraftBukkit end
-         this.worldPosition = BlockPos.ZERO;
+     private static final Logger LOGGER = LogManager.getLogger();
+     public boolean isLoadingStructure = false; // Paper
+-    private final BlockEntityType<?> type; public BlockEntityType getTileEntityType() { return type; } // Paper - OBFHELPER
++    private final BlockEntityType<?> type;
+     @Nullable
+     protected Level level;
+     protected final BlockPos worldPosition;
+@@ -0,0 +0,0 @@ public abstract class BlockEntity implements net.minecraft.server.KeyedObject {
          this.type = type;
+         this.worldPosition = pos.immutable();
+         this.blockState = state;
 +        persistentDataContainer = new CraftPersistentDataContainer(DATA_TYPE_REGISTRY); // Paper - always init
      }
  
      // Paper start
 @@ -0,0 +0,0 @@ public abstract class BlockEntity implements net.minecraft.server.KeyedObject {
-     public void load(BlockState state, CompoundTag tag) {
-         this.worldPosition = new BlockPos(tag.getInt("x"), tag.getInt("y"), tag.getInt("z"));
-         // CraftBukkit start - read container
--        this.persistentDataContainer = new CraftPersistentDataContainer(DATA_TYPE_REGISTRY);
-+        this.persistentDataContainer.clear(); // Paper - clear instead of reinit
  
-         net.minecraft.nbt.Tag persistentDataTag = tag.get("PublicBukkitValues");
+     // CraftBukkit start - read container
+     public void load(CompoundTag nbt) {
+-        this.persistentDataContainer = new CraftPersistentDataContainer(BlockEntity.DATA_TYPE_REGISTRY);
++        this.persistentDataContainer.clear();
+ 
+         net.minecraft.nbt.Tag persistentDataTag = nbt.get("PublicBukkitValues");
          if (persistentDataTag instanceof CompoundTag) {
 @@ -0,0 +0,0 @@ public abstract class BlockEntity implements net.minecraft.server.KeyedObject {
      }
@@ -39,13 +48,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      // CraftBukkit start - add method
 +    // Paper start
      public InventoryHolder getOwner() {
+-        if (this.level == null) return null;
 +        return getOwner(true);
 +    }
 +    public InventoryHolder getOwner(boolean useSnapshot) {
 +        // Paper end
-         if (level == null) return null;
++        if (level == null) return null;
          // Spigot start
-         org.bukkit.block.Block block = level.getWorld().getBlockAt(worldPosition.getX(), worldPosition.getY(), worldPosition.getZ());
+         org.bukkit.block.Block block = this.level.getWorld().getBlockAt(this.worldPosition.getX(), this.worldPosition.getY(), this.worldPosition.getZ());
+         if (block == null) {
 @@ -0,0 +0,0 @@ public abstract class BlockEntity implements net.minecraft.server.KeyedObject {
              return null;
          }
@@ -63,6 +74,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      @Override
      public BlockState getState() {
+-        Material material = this.getType();
 +        // Paper start - allow disabling the use of snapshots
 +        return getState(true);
 +    }
@@ -77,9 +89,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +    public BlockState getState0() {
 +        // Paper end
-         Material material = getType();
++        Material material = getType();
  
          switch (material) {
+             case ACACIA_SIGN:
 diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockEntityState.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockEntityState.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockEntityState.java
@@ -136,7 +149,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/org/bukkit/craftbukkit/persistence/CraftPersistentDataContainer.java
 @@ -0,0 +0,0 @@ public final class CraftPersistentDataContainer implements PersistentDataContain
      public Map<String, Object> serialize() {
-         return (Map<String, Object>) CraftNBTTagConfigSerializer.serialize(toTagCompound());
+         return (Map<String, Object>) CraftNBTTagConfigSerializer.serialize(this.toTagCompound());
      }
 +
 +    // Paper start

patches/server/Ability-to-apply-mending-to-XP-API.patch

@@ -38,7 +38,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -    public static Entry<EquipmentSlot, ItemStack> getRandomItemWith(Enchantment enchantment, LivingEntity entity) {
 +    public static @javax.annotation.Nonnull ItemStack getRandomEquippedItemWithEnchant(Enchantment enchantment, LivingEntity entityliving) { Entry<EquipmentSlot, ItemStack> entry = getRandomItemWith(enchantment, entityliving); return entry != null ? entry.getValue() : ItemStack.NULL_ITEM; } // Paper - OBFHELPER
 +    @Nullable public static Entry<EquipmentSlot, ItemStack> getRandomItemWith(Enchantment enchantment, LivingEntity entity) {
-         return getRandomItemWith(enchantment, entity, (itemstack) -> {
+         return getRandomItemWith(enchantment, entity, (stack) -> {
              return true;
          });
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
@@ -58,15 +58,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import net.minecraft.world.item.enchantment.EnchantmentHelper;
 +import net.minecraft.world.item.enchantment.Enchantments;
  import net.minecraft.world.level.GameType;
+ import net.minecraft.world.level.block.Blocks;
  import net.minecraft.world.level.block.entity.SignBlockEntity;
- import net.minecraft.world.level.saveddata.maps.MapDecoration;
 @@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-         return GameMode.getByValue(getHandle().gameMode.getGameModeForPlayer().getId());
+         return GameMode.getByValue(this.getHandle().gameMode.getGameModeForPlayer().getId());
      }
  
 +    // Paper start
-     @Override
++    @Override
--    public void giveExp(int exp) {
 +    public int applyMending(int amount) {
 +        ServerPlayer handle = getHandle();
 +        // Logic copied from EntityExperienceOrb and remapped to unobfuscated methods/properties
@@ -90,12 +89,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return amount;
 +    }
 +
-+    @Override
+     @Override
+-    public void giveExp(int exp) {
 +    public void giveExp(int exp, boolean applyMending) {
 +        if (applyMending) {
 +            exp = this.applyMending(exp);
 +        }
 +        // Paper end
-         getHandle().giveExperiencePoints(exp);
+         this.getHandle().giveExperiencePoints(exp);
      }
  

patches/server/Add-PlayerArmorChangeEvent.patch

@@ -9,7 +9,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/entity/EquipmentSlot.java
 +++ b/src/main/java/net/minecraft/world/entity/EquipmentSlot.java
 @@ -0,0 +0,0 @@ public enum EquipmentSlot {
-         this.name = s;
+         this.name = name;
      }
  
 +    public EquipmentSlot.Type getType() { return this.getType(); } // Paper - OBFHELPER

patches/server/AsyncTabCompleteEvent.patch

@@ -17,20 +17,20 @@ diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListener
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerGamePacketListener {
+@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
  
      @Override
      public void handleCustomCommandSuggestions(ServerboundCommandSuggestionPacket packet) {
 -        PacketUtils.ensureRunningOnSameThread(packet, this, this.player.getLevel());
 +        // PlayerConnectionUtils.ensureMainThread(packetplayintabcomplete, this, this.player.getWorldServer()); // Paper - run this async
          // CraftBukkit start
-         if (chatSpamField.addAndGet(this, 1) > 500 && !this.server.getPlayerList().isOp(this.player.getGameProfile())) {
+         if (this.chatSpamTickCount.addAndGet(1) > 500 && !this.server.getPlayerList().isOp(this.player.getGameProfile())) {
 -            this.disconnect(new TranslatableComponent("disconnect.spam", new Object[0]));
 +            server.scheduleOnMain(() -> this.disconnect(new TranslatableComponent("disconnect.spam", new Object[0]))); // Paper
              return;
          }
          // CraftBukkit end
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerGamePacketListener {
+@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
              stringreader.skip();
          }
  
@@ -76,12 +76,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 @@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-             offers = tabCompleteChat(player, message);
+             offers = this.tabCompleteChat(player, message);
          }
  
 -        TabCompleteEvent tabEvent = new TabCompleteEvent(player, message, offers);
 +        TabCompleteEvent tabEvent = new TabCompleteEvent(player, message, offers, message.startsWith("/") || forceCommand, pos != null ? net.minecraft.server.MCUtil.toLocation(((CraftWorld) player.getWorld()).getHandle(), new BlockPos(pos)) : null); // Paper
-         getPluginManager().callEvent(tabEvent);
+         this.getPluginManager().callEvent(tabEvent);
  
          return tabEvent.isCancelled() ? Collections.EMPTY_LIST : tabEvent.getCompletions();
 diff --git a/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java b/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java

patches/server/Make-max-squid-spawn-height-configurable.patch

@@ -11,8 +11,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
 +++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
 @@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         expMergeMaxValue = getInt("experience-merge-max-value", -1);
+         disableCreeperLingeringEffect = getBoolean("disable-creeper-lingering-effect", false);
-         log("Experience Merge Max Value: " + expMergeMaxValue);
+         log("Creeper lingering effect: " + disableCreeperLingeringEffect);
      }
 +
 +    public double squidMaxSpawnHeight;
@@ -28,9 +28,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      public static boolean checkSquidSpawnRules(EntityType<Squid> type, LevelAccessor world, MobSpawnType spawnReason, BlockPos pos, Random random) {
--        return pos.getY() > world.getLevel().spigotConfig.squidSpawnRangeMin && pos.getY() < world.getSeaLevel(); // Spigot
+-        return pos.getY() > world.getMinecraftWorld().spigotConfig.squidSpawnRangeMin && pos.getY() < world.getSeaLevel(); // Spigot
-+        final double maxHeight = world.getLevel().paperConfig.squidMaxSpawnHeight > 0 ? world.getLevel().paperConfig.squidMaxSpawnHeight : world.getSeaLevel(); // Paper
++        final double maxHeight = world.getMinecraftWorld().paperConfig.squidMaxSpawnHeight > 0 ? world.getMinecraftWorld().paperConfig.squidMaxSpawnHeight : world.getSeaLevel(); // Paper
-+        return pos.getY() > world.getLevel().spigotConfig.squidSpawnRangeMin && pos.getY() < maxHeight; // Spigot // Paper
++        return pos.getY() > world.getMinecraftWorld().spigotConfig.squidSpawnRangeMin && pos.getY() < maxHeight; // Spigot // Paper
      }
  
-     public void setMovementVector(float x, float y, float z) {
+     @Override

patches/server/PlayerNaturallySpawnCreaturesEvent.patch

@@ -22,9 +22,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          // Spigot end
          long i = chunkcoordintpair.toLong();
  
-         return !this.distanceManager.hasPlayersNearby(i) ? true : this.playerMap.a(i).noneMatch((entityplayer) -> {
+         return !this.distanceManager.hasPlayersNearby(i) ? true : this.playerMap.getPlayers(i).noneMatch((entityplayer) -> {
--            return !entityplayer.isSpectator() && a(chunkcoordintpair, (Entity) entityplayer) < blockRange; // Spigot
++            // Paper start - add PlayerNaturallySpawnCreaturesEvent
-+            // Paper start -
 +            com.destroystokyo.paper.event.entity.PlayerNaturallySpawnCreaturesEvent event;
 +            double blockRange = 16384.0D;
 +            if (reducedRange) {
@@ -32,12 +31,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                if (event == null || event.isCancelled()) return false;
 +                blockRange = (double) ((event.getSpawnRadius() << 4) * (event.getSpawnRadius() << 4));
 +            }
-+
-+            return (!entityplayer.isSpectator() && a(chunkcoordintpair, (Entity) entityplayer) < blockRange); // Spigot
 +            // Paper end
+             return !entityplayer.isSpectator() && ChunkMap.euclideanDistanceSquared(chunkcoordintpair, (Entity) entityplayer) < blockRange; // Spigot
          });
      }
- 
 diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
@@ -69,7 +66,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  import com.google.common.collect.Lists;
  import com.mojang.authlib.GameProfile;
  import com.mojang.datafixers.util.Either;
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player implements ContainerListener {
+@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
      public boolean sentListPacket = false;
      public Integer clientViewDistance;
      // CraftBukkit end

patches/server/PlayerPickupExperienceEvent.patch

@@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Tue, 19 Dec 2017 22:02:53 -0500
+Subject: [PATCH] PlayerPickupExperienceEvent
+
+Allows plugins to cancel a player picking up an experience orb
+
+diff --git a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
++++ b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
+@@ -0,0 +0,0 @@ public class ExperienceOrb extends Entity {
+     @Override
+     public void playerTouch(Player player) {
+         if (!this.level.isClientSide) {
+-            if (player.takeXpDelay == 0) {
++            if (player.takeXpDelay == 0 && new com.destroystokyo.paper.event.player.PlayerPickupExperienceEvent(((net.minecraft.server.level.ServerPlayer) player).getBukkitEntity(), (org.bukkit.entity.ExperienceOrb) this.getBukkitEntity()).callEvent()) { // Paper
+                 player.takeXpDelay = 2;
+                 player.take(this, 1);
+                 int i = this.repairPlayerItems(player, this.value);

patches/server/use-CB-BlockState-implementations-for-captured-block.patch

@@ -34,8 +34,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public boolean setBlock(BlockPos pos, BlockState state, int flags, int maxUpdateDepth) {
          // CraftBukkit start - tree generation
          if (this.captureTreeGeneration) {
--            CapturedBlockState blockstate = capturedBlockStates.get(pos);
+-            CapturedBlockState blockstate = this.capturedBlockStates.get(pos);
-+            CraftBlockState blockstate = capturedBlockStates.get(pos);
++            CraftBlockState blockstate = this.capturedBlockStates.get(pos);
              if (blockstate == null) {
                  blockstate = CapturedBlockState.getTreeBlockState(this, pos, flags);
                  this.capturedBlockStates.put(pos.immutable(), blockstate);
@@ -52,9 +52,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
      public BlockState getBlockState(BlockPos pos) {
          // CraftBukkit start - tree generation
-         if (captureTreeGeneration) {
+         if (this.captureTreeGeneration) {
--            CapturedBlockState previous = capturedBlockStates.get(pos);
+-            CapturedBlockState previous = this.capturedBlockStates.get(pos);
-+            CraftBlockState previous = capturedBlockStates.get(pos); // Paper
++            CraftBlockState previous = this.capturedBlockStates.get(pos); // Paper
              if (previous != null) {
                  return previous.getHandle();
              }