1.16.2 Release (#4123)

PaperMC believes that 1.16.2 is now ready for general release as we fixed the main issue plagueing the 1.16.x release, the MapLike data conversion issues.

Until now, it was not safe for a server to convert a world to 1.16.2 without data conversion issues around villages and potentially other things. If you did, those MapLike errors meant something went wrong.

This is now resolved.

Big thanks to all those that helped, notably @BillyGalbreath and @Proximyst who did large parts of the update process with me.

Please as always, backup your worlds and test before updating to 1.16.2!

If you update to 1.16.2, there is no going back to an older build than this.

---------------------------------

Co-authored-by: William Blake Galbreath <Blake.Galbreath@GMail.com>
Co-authored-by: Mariell Hoversholm <proximyst@proximyst.com>
Co-authored-by: krolik-exe <69214078+krolik-exe@users.noreply.github.com>
Co-authored-by: BillyGalbreath <BillyGalbreath@users.noreply.github.com>
Co-authored-by: stonar96 <minecraft.stonar96@gmail.com>
Co-authored-by: Shane Freeder <theboyetronic@gmail.com>
Co-authored-by: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
Co-authored-by: Riley Park <rileysebastianpark@gmail.com>
Co-authored-by: Aurora <21148213+aurorasmiles@users.noreply.github.com>
Co-authored-by: Nassim Jahnke <nassim@njahnke.dev>
Co-authored-by: commandblockguy <commandblockguy1@gmail.com>
Co-authored-by: DigitalRegent <misterwener@gmail.com>
Co-authored-by: ishland <ishlandmc@yeah.net>

.github/ISSUE_TEMPLATE/behavior-bug---plugin-incompatibility.md

@@ -4,6 +4,9 @@ about: Server Bug or Plugin Incompatibility
 
 ---
 
+<!-- Before reporting an issue here, please make sure you are on the latest version of Paper. -->
+<!-- Forks of Paper receive no support here. Please make sure that your issue is reproducable on Paper first.  -->
+
 ### What behaviour is expected:
 ___What you expected to see___
 
@@ -16,8 +19,8 @@ ___This may include a build schematic, a video, or detailed instructions to help
 ### Plugin list:
 ___A list of your plugins___
 
-### Paper build number:
+### Paper version:
-___This can be found by running `/version` on your server. `latest` is not a proper version number; we require the output of `/version` so we can properly track down the issue.___
+___Paste the output of running `/version` on your server WITH the Minecraft version. `latest` is not a version; we require the output of `/version` so we can properly track down the issue.___
 
 ### Anything else:
 ___Anything else you think may help us resolve the problem___

.github/ISSUE_TEMPLATE/feature_request.md

@@ -4,6 +4,8 @@ about: Suggest an idea for this project
 
 ---
 
+<!-- Before requesting a new feature, please make sure you are using the latest version and that the feature you are requesting is not already in Paper. -->
+
 **Is your feature request related to a problem? Please describe.**
 A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
 

.github/ISSUE_TEMPLATE/performance-problem.md

@@ -4,6 +4,9 @@ about: Report performance problems or areas of concern
 
 ---
 
+<!-- Before reporting performance problems here, please make sure you are on the latest version of Paper.  -->
+<!-- Forks of Paper receive no support here. Please make sure that this problem also affects Paper. -->
+
 ###  Timings or Profile link:
 ___We ask that all timings/profiles are a link, not a screenshot. Screenshots inhibit our ability to figure out the real cause of the issue.___
 
@@ -20,5 +23,5 @@ ___Gist/pastebin/hastebin links___
 ___The more information we receive, the quicker and more effective we can be at finding the solution to the
 issue.___
 
-### Paper build number:
+### Paper version:
-___This can be found by running `/version` on your server. `latest` is not a proper version number; we require the output of `/version` so we can properly track down the issue.___
+___Paste the output of running `/version` on your server WITH the Minecraft version. `latest` is not a version; we require the output of `/version` so we can properly track down the issue.___

.github/ISSUE_TEMPLATE/server-crash---stacktrace.md

@@ -4,6 +4,9 @@ about: Report server crashes and/or scary stacktraces
 
 ---
 
+<!-- Before reporting a crash here, please make sure you are on the latest version of Paper.  -->
+<!-- Forks of Paper receive no support here. Please make sure that this crash also happens when using Paper.  -->
+
 ### Link/paste of stack trace
 
     You can also simply just use code formatting in markdown!
@@ -18,5 +21,5 @@ ___A list of your plugins___
 ### Actions to reproduce (if known):
 ___This may include a build schematic, a video, or detailed instructions to help reconstruct the issue___
 
-### Paper build number:
+### Paper version:
-___This can be found by running `/version` on your server. `latest` is not a proper version number; we require the output of `/version` so we can properly track down the issue.___
+___Paste the output of running `/version` on your server WITH the Minecraft version. `latest` is not a version; we require the output of `/version` so we can properly track down the issue.___

.travis.yml

@@ -1,6 +1,6 @@
 language: java
-sudo: required
+dist: focal
-dist: trusty
+os: linux
 jdk:
   - oraclejdk8
   - openjdk11

Paper-MojangAPI/pom.xml

@@ -10,7 +10,7 @@
 
     <groupId>com.destroystokyo.paper</groupId>
     <artifactId>paper-mojangapi</artifactId>
-    <version>1.16.1-R0.1-SNAPSHOT</version>
+    <version>1.16.2-R0.1-SNAPSHOT</version>
     <packaging>jar</packaging>
 
     <name>Paper-MojangAPI</name>

SHIT_TO_CHECK.md

@@ -5,4 +5,5 @@
 * Make sure the flat bedrock setting doesn't do anything stupid
 * Check DataBits foreach
 * lighting is bork (load chunk, fly away, come back, everything or parts are black)
-* chunk generation seems slow with a lot of it happening
+* chunk generation seems slow with a lot of it happening
+* Fix IDE Debug JVM Flag for new versions of minecraft

Spigot-API-Patches/Add-API-methods-to-control-if-armour-stands-can-move.patch

@@ -9,10 +9,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/entity/ArmorStand.java
 +++ b/src/main/java/org/bukkit/entity/ArmorStand.java
 @@ -0,0 +0,0 @@ public interface ArmorStand extends LivingEntity {
-      * @param marker whether this is a marker
+          */
-      */
+         ADDING;
-     void setMarker(boolean marker);
+     }
-+
 +    // Paper start
 +    /**
 +     * Tests if this armor stand can move.

Spigot-API-Patches/Add-Material-Tags.patch

@@ -518,7 +518,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    public static final MaterialSetTag SPAWN_EGGS = new MaterialSetTag(keyFor("spawn_eggs"))
 +        .endsWith("_SPAWN_EGG")
-+        .ensureSize("SPAWN_EGGS", 63);
++        .ensureSize("SPAWN_EGGS", 64);
 +
 +    /**
 +     * Covers all colors of stained glass.

Spigot-API-Patches/Add-Mob-Goal-API.patch

@@ -356,6 +356,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    GoalKey<Slime> SLIME_RANDOM_JUMP = GoalKey.of(Slime.class, NamespacedKey.minecraft("slime_random_jump"));
 +    GoalKey<Spider> SPIDER_MELEE_ATTACK = GoalKey.of(Spider.class, NamespacedKey.minecraft("spider_melee_attack"));
 +    GoalKey<Spider> SPIDER_NEAREST_ATTACKABLE_TARGET = GoalKey.of(Spider.class, NamespacedKey.minecraft("spider_nearest_attackable_target"));
++    GoalKey<Strider> STRIDER_GO_TO_LAVA = GoalKey.of(Strider.class, NamespacedKey.minecraft("strider_go_to_lava"));
 +    GoalKey<Squid> SQUID = GoalKey.of(Squid.class, NamespacedKey.minecraft("squid"));
 +    GoalKey<Squid> SQUID_FLEE = GoalKey.of(Squid.class, NamespacedKey.minecraft("squid_flee"));
 +    GoalKey<Turtle> TURTLE_BREED = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_breed"));

Spigot-API-Patches/Add-item-slot-convenience-methods.patch

@@ -177,6 +177,80 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +    // Paper end
  }
+diff --git a/src/main/java/org/bukkit/inventory/SmithingInventory.java b/src/main/java/org/bukkit/inventory/SmithingInventory.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/inventory/SmithingInventory.java
++++ b/src/main/java/org/bukkit/inventory/SmithingInventory.java
+@@ -0,0 +0,0 @@
+ package org.bukkit.inventory;
+ 
++import org.jetbrains.annotations.Nullable; // Paper
++
+ /**
+  * Interface to the inventory of a Smithing table.
+  */
+-public interface SmithingInventory extends Inventory { }
++public interface SmithingInventory extends Inventory {
++
++    // Paper start
++    /**
++     * Gets the input equipment (first slot).
++     *
++     * @return input equipment item
++     */
++    @Nullable
++    default ItemStack getInputEquipment() {
++        return getItem(0);
++    }
++
++    /**
++     * Sets the input equipment (first slot).
++     *
++     * @param itemStack item to set
++     */
++    default void setInputEquipment(@Nullable ItemStack itemStack) {
++        setItem(0, itemStack);
++    }
++
++    /**
++     * Gets the input mineral (second slot).
++     *
++     * @return input mineral item
++     */
++    @Nullable
++    default ItemStack getInputMineral() {
++        return getItem(1);
++    }
++
++    /**
++     * Sets the input mineral (second slot).
++     *
++     * @param itemStack item to set
++     */
++    default void setInputMineral(@Nullable ItemStack itemStack) {
++        setItem(1, itemStack);
++    }
++
++    /**
++     * Gets the result item.
++     *
++     * @return result
++     */
++    @Nullable
++    default ItemStack getResult() {
++        return getItem(2);
++    }
++
++    /**
++     * Sets the result item.
++     *
++     * @param itemStack item to set
++     */
++    default void setResult(@Nullable ItemStack itemStack) {
++        setItem(2, itemStack);
++    }
++    // Paper end
++}
 diff --git a/src/main/java/org/bukkit/inventory/StonecutterInventory.java b/src/main/java/org/bukkit/inventory/StonecutterInventory.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/inventory/StonecutterInventory.java

Spigot-API-Patches/Add-method-to-open-already-placed-sign.patch

@@ -12,7 +12,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
       */
      @Deprecated
      public void setShoulderEntityRight(@Nullable Entity entity);
-+
 +    // Paper start - Add method to open already placed sign
 +    /**
 +     * Opens an editor window for the specified sign
@@ -21,4 +20,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     */
 +    void openSign(@NotNull org.bukkit.block.Sign sign);
 +    // Paper end
- }
+ 
+     /**
+      * Make the entity drop the item in their hand.

Spigot-API-Patches/Add-moon-phase-API.patch

@@ -0,0 +1,65 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Sun, 23 Aug 2020 16:32:03 +0200
+Subject: [PATCH] Add moon phase API
+
+
+diff --git a/src/main/java/io/papermc/paper/world/MoonPhase.java b/src/main/java/io/papermc/paper/world/MoonPhase.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/world/MoonPhase.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.world;
++
++import org.jetbrains.annotations.NotNull;
++
++import java.util.HashMap;
++import java.util.Map;
++
++public enum MoonPhase {
++    FULL_MOON(0L),
++    WANING_GIBBOUS(1L),
++    LAST_QUARTER(2L),
++    WANING_CRESCENT(3L),
++    NEW_MOON(4L),
++    WAXING_CRESCENT(5L),
++    FIRST_QUARTER(6L),
++    WAXING_GIBBOUS(7L);
++
++    private final long day;
++
++    MoonPhase(long day) {
++        this.day = day;
++    }
++
++    private static final Map<Long, MoonPhase> BY_DAY = new HashMap<>();
++
++    static {
++        for (MoonPhase phase : values()) {
++            BY_DAY.put(phase.day, phase);
++        }
++    }
++
++    @NotNull
++    public static MoonPhase getPhase(long day) {
++        return BY_DAY.get(day % 8L);
++    }
++}
+diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/World.java
++++ b/src/main/java/org/bukkit/World.java
+@@ -0,0 +0,0 @@ public interface World extends PluginMessageRecipient, Metadatable {
+      * @return The amount of Players in this world
+      */
+     int getPlayerCount();
++
++    /**
++     * @return the current moon phase at the current time in the world
++     */
++    @NotNull
++    io.papermc.paper.world.MoonPhase getMoonPhase();
+     // Paper end
+ 
+     /**

Spigot-API-Patches/Add-more-Zombie-API.patch

@@ -8,7 +8,7 @@ diff --git a/src/main/java/org/bukkit/entity/Zombie.java b/src/main/java/org/buk
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/entity/Zombie.java
 +++ b/src/main/java/org/bukkit/entity/Zombie.java
-@@ -0,0 +0,0 @@ public interface Zombie extends Monster {
+@@ -0,0 +0,0 @@ public interface Zombie extends Monster, Ageable {
       * @param time new conversion time
       */
      void setConversionTime(int time);

Spigot-API-Patches/Add-setMaxPlayers-API.patch

@@ -0,0 +1,48 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mariell Hoversholm <proximyst@proximyst.com>
+Date: Sat, 22 Aug 2020 23:59:25 +0200
+Subject: [PATCH] Add #setMaxPlayers API
+
+
+diff --git a/src/main/java/org/bukkit/Bukkit.java b/src/main/java/org/bukkit/Bukkit.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/Bukkit.java
++++ b/src/main/java/org/bukkit/Bukkit.java
+@@ -0,0 +0,0 @@ public final class Bukkit {
+         return server.getMaxPlayers();
+     }
+ 
++    // Paper start
++    /**
++     * Set the maximum amount of players which can login to this server.
++     *
++     * @param maxPlayers the amount of players this server allows
++     */
++    public static void setMaxPlayers(int maxPlayers) {
++        server.setMaxPlayers(maxPlayers);
++    }
++    // Paper end
++
+     /**
+      * Get the game port that the server runs on.
+      *
+diff --git a/src/main/java/org/bukkit/Server.java b/src/main/java/org/bukkit/Server.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/Server.java
++++ b/src/main/java/org/bukkit/Server.java
+@@ -0,0 +0,0 @@ public interface Server extends PluginMessageRecipient {
+      */
+     public int getMaxPlayers();
+ 
++    // Paper start
++    /**
++     * Set the maximum amount of players which can login to this server.
++     *
++     * @param maxPlayers the amount of players this server allows
++     */
++    public void setMaxPlayers(int maxPlayers);
++    // Paper end
++
+     /**
+      * Get the game port that the server runs on.
+      *

Spigot-API-Patches/Expand-ArmorStand-API.patch

@@ -11,14 +11,6 @@ diff --git a/src/main/java/org/bukkit/entity/ArmorStand.java b/src/main/java/org
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/entity/ArmorStand.java
 +++ b/src/main/java/org/bukkit/entity/ArmorStand.java
-@@ -0,0 +0,0 @@
- package org.bukkit.entity;
- 
- import org.bukkit.inventory.EntityEquipment;
-+import org.bukkit.inventory.EquipmentSlot;
- import org.bukkit.inventory.ItemStack;
- import org.bukkit.util.EulerAngle;
- import org.jetbrains.annotations.NotNull;
 @@ -0,0 +0,0 @@ public interface ArmorStand extends LivingEntity {
       * Returns the item the armor stand is currently holding.
       *

Spigot-API-Patches/Make-plugins-list-alphabetical.patch

@@ -56,26 +56,5 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return "(" + plugins.size() + "): " + pluginList.toString();
 +        // Paper end
      }
- 
++
-     // Spigot start
+ }
-     @NotNull
-     private BaseComponent[] getPluginListSpigot() {
--        Plugin[] plugins = Bukkit.getPluginManager().getPlugins();
--        ComponentBuilder pluginList = new ComponentBuilder("Plugins (" + plugins.length + "): ");
-+        // Paper start
-+        TreeMap<String, Plugin> plugins = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
-+        for (Plugin plugin : Bukkit.getPluginManager().getPlugins()) {
-+            plugins.put(plugin.getDescription().getName(), plugin);
-+        }
-+        ComponentBuilder pluginList = new ComponentBuilder("Plugins (" + plugins.size() + "): ");
-+        // Paper end
- 
-         int index = 0;
--        for (Plugin plugin : plugins) {
-+        // Paper start
-+        for (Map.Entry<String, Plugin> entry : plugins.entrySet()) {
-+            Plugin plugin = entry.getValue();
-+            // Paper end
-             if (index++ > 0) {
-                 pluginList.append(", ", FormatRetention.NONE).color(net.md_5.bungee.api.ChatColor.WHITE);
-             }

Spigot-API-Patches/POM-changes.patch

@@ -22,7 +22,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -    <artifactId>spigot-api</artifactId>
 +    <groupId>com.destroystokyo.paper</groupId>
 +    <artifactId>paper-api</artifactId>
-     <version>1.16.1-R0.1-SNAPSHOT</version>
+     <version>1.16.2-R0.1-SNAPSHOT</version>
      <packaging>jar</packaging>
  
 -    <name>Spigot-API</name>

Spigot-API-Patches/Remove-Precondition-on-name-for-AttributeModifier.patch

@@ -1,24 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sat, 22 Sep 2018 18:41:01 -0400
-Subject: [PATCH] Remove Precondition on name for AttributeModifier
-
-Vanilla allows empty names
-
-diff --git a/src/main/java/org/bukkit/attribute/AttributeModifier.java b/src/main/java/org/bukkit/attribute/AttributeModifier.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/attribute/AttributeModifier.java
-+++ b/src/main/java/org/bukkit/attribute/AttributeModifier.java
-@@ -0,0 +0,0 @@ public class AttributeModifier implements ConfigurationSerializable {
- 
-     public AttributeModifier(@NotNull UUID uuid, @NotNull String name, double amount, @NotNull Operation operation, @Nullable EquipmentSlot slot) {
-         Validate.notNull(uuid, "UUID cannot be null");
--        Validate.notEmpty(name, "Name cannot be empty");
-+        //Validate.notEmpty(name, "Name cannot be empty"); // Paper
-         Validate.notNull(operation, "Operation cannot be null");
-         this.uuid = uuid;
--        this.name = name;
-+        this.name = name != null ? name : ""; // Paper
-         this.amount = amount;
-         this.operation = operation;
-         this.slot = slot;

Spigot-Server-Patches/0563-Brand-support.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: DigitalRegent <misterwener@gmail.com>
+Date: Sat, 11 Apr 2020 13:10:58 +0200
+Subject: [PATCH] Brand support
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     // Paper start - brand support
+     @Override
+     public String getClientBrandName() {
+-        return getHandle().playerConnection.getClientBrandName();
++        return getHandle().playerConnection != null ? getHandle().playerConnection.getClientBrandName() : null;
+     }
+     // Paper end
+ 

Spigot-Server-Patches/Add-API-methods-to-control-if-armour-stands-can-move.patch

@@ -17,8 +17,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public EntityArmorStand(EntityTypes<? extends EntityArmorStand> entitytypes, World world) {
          super(entitytypes, world);
 @@ -0,0 +0,0 @@ public class EntityArmorStand extends EntityLiving {
- 
+     private EntitySize s(boolean flag) {
-         return this.getEntityType().l().a(f);
+         return flag ? EntityArmorStand.bp : (this.isBaby() ? EntityArmorStand.bq : this.getEntityType().l());
      }
 +
 +    // Paper start
@@ -35,10 +35,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
 @@ -0,0 +0,0 @@ public class CraftArmorStand extends CraftLivingEntity implements ArmorStand {
-     public void setMarker(boolean marker) {
+     public boolean hasEquipmentLock(EquipmentSlot equipmentSlot, LockType lockType) {
-         getHandle().setMarker(marker);
+         return (getHandle().bv & (1 << CraftEquipmentSlot.getNMS(equipmentSlot).c() + lockType.ordinal() * 8)) != 0;
      }
-+
 +    // Paper start
 +    @Override
 +    public boolean canMove() {

Spigot-Server-Patches/Add-EntityZapEvent.patch

@@ -26,7 +26,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/net/minecraft/server/EntityVillager.java
 @@ -0,0 +0,0 @@ public class EntityVillager extends EntityVillagerAbstract implements Reputation
              EntityVillager.LOGGER.info("Villager {} was struck by lightning {}.", this, entitylightning);
-             EntityWitch entitywitch = (EntityWitch) EntityTypes.WITCH.a(this.world);
+             EntityWitch entitywitch = (EntityWitch) EntityTypes.WITCH.a((World) worldserver);
  
 +            // Paper start
 +            if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityZapEvent(this, entitylightning, entitywitch).isCancelled()) {
@@ -35,7 +35,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            // Paper end
 +
              entitywitch.setPositionRotation(this.locX(), this.locY(), this.locZ(), this.yaw, this.pitch);
-             entitywitch.prepare(this.world, this.world.getDamageScaler(entitywitch.getChunkCoordinates()), EnumMobSpawn.CONVERSION, (GroupDataEntity) null, (NBTTagCompound) null);
+             entitywitch.prepare(worldserver, worldserver.getDamageScaler(entitywitch.getChunkCoordinates()), EnumMobSpawn.CONVERSION, (GroupDataEntity) null, (NBTTagCompound) null);
              entitywitch.setNoAI(this.isNoAI());
 diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644

Spigot-Server-Patches/Add-LivingEntity-getTargetEntity.patch

@@ -61,8 +61,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          return this.getPassengers().size() < 1;
      }
  
-+    public final float getCollisionBorderSize() { return bc(); } // Paper - OBFHELPER
++    public final float getCollisionBorderSize() { return bf(); } // Paper - OBFHELPER
-     public float bc() {
+     public float bf() {
          return 0.0F;
      }
 diff --git a/src/main/java/net/minecraft/server/EntityLiving.java b/src/main/java/net/minecraft/server/EntityLiving.java

Spigot-Server-Patches/Add-MinecraftKey-Information-to-Objects.patch

@@ -74,7 +74,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 +    public boolean isPersistable() { return a(); } // Paper - OBFHELPER
      public boolean a() {
-         return this.bh;
+         return this.bi;
      }
 diff --git a/src/main/java/net/minecraft/server/KeyedObject.java b/src/main/java/net/minecraft/server/KeyedObject.java
 new file mode 100644

Spigot-Server-Patches/Add-More-Creeper-API.patch

@@ -11,12 +11,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class EntityCreeper extends EntityMonster {
      private static final DataWatcherObject<Boolean> POWERED = DataWatcher.a(EntityCreeper.class, DataWatcherRegistry.i);
      private static final DataWatcherObject<Boolean> d = DataWatcher.a(EntityCreeper.class, DataWatcherRegistry.i); private static final DataWatcherObject<Boolean> isIgnitedDW = d; // Paper OBFHELPER
-     private int bv;
+     private int bo;
 -    private int fuseTicks;
 +    public int fuseTicks; // Paper - public
      public int maxFuseTicks = 30;
      public int explosionRadius = 3;
-     private int bz;
+     private int bs;
 @@ -0,0 +0,0 @@ public class EntityCreeper extends EntityMonster {
      }
  

Spigot-Server-Patches/Add-PhantomPreSpawnEvent.patch

@@ -69,7 +69,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                                                entityphantom.spawningEntity = entityhuman.uniqueID; // Paper
                                                  entityphantom.setPositionRotation(blockposition1, 0.0F, 0.0F);
                                                  groupdataentity = entityphantom.prepare(worldserver, difficultydamagescaler, EnumMobSpawn.NATURAL, groupdataentity, (NBTTagCompound) null);
-                                                 worldserver.addEntity(entityphantom, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL); // CraftBukkit
+                                                 worldserver.addAllEntities(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 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPhantom.java

Spigot-Server-Patches/Add-PlayerConnectionCloseEvent.patch

@@ -54,11 +54,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/NetworkManager.java
 +++ b/src/main/java/net/minecraft/server/NetworkManager.java
 @@ -0,0 +0,0 @@ public class NetworkManager extends SimpleChannelInboundHandler<Packet<?>> {
-                     this.i().a(new ChatMessage("multiplayer.disconnect.generic"));
+                     this.j().a(new ChatMessage("multiplayer.disconnect.generic"));
                  }
                  this.packetQueue.clear(); // Free up packet queue.
 +                // Paper start - Add PlayerConnectionCloseEvent
-+                final PacketListener packetListener = this.i();
++                final PacketListener packetListener = this.j();
 +                if (packetListener instanceof PlayerConnection) {
 +                    /* Player was logged in */
 +                    final PlayerConnection playerConnection = (PlayerConnection) packetListener;

Spigot-Server-Patches/Add-ProjectileCollideEvent.patch

@@ -32,7 +32,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/net/minecraft/server/EntityFireball.java
 @@ -0,0 +0,0 @@ public abstract class EntityFireball extends IProjectile {
  
-             MovingObjectPosition movingobjectposition = ProjectileHelper.a(this, this::a, RayTrace.BlockCollisionOption.COLLIDER);
+             MovingObjectPosition movingobjectposition = ProjectileHelper.a((Entity) this, this::a);
  
 -            if (movingobjectposition.getType() != MovingObjectPosition.EnumMovingObjectType.MISS) {
 +            // Paper start - Call ProjectileCollideEvent
@@ -69,7 +69,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            } // Paper
          }
  
-         Vec3D vec3d = this.getMot();
+         this.checkBlockCollisions();
 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

Spigot-Server-Patches/Add-Raw-Byte-ItemStack-Serialization.patch

@@ -33,16 +33,16 @@ diff --git a/src/main/java/net/minecraft/server/NBTCompressedStreamTools.java b/
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/NBTCompressedStreamTools.java
 +++ b/src/main/java/net/minecraft/server/NBTCompressedStreamTools.java
-@@ -0,0 +0,0 @@ import io.netty.buffer.ByteBufInputStream; // Paper
+@@ -0,0 +0,0 @@ public class NBTCompressedStreamTools {
- 
+         return nbttagcompound;
- public class NBTCompressedStreamTools {
+     }
  
 +    public static NBTTagCompound readNBT(InputStream inputstream) throws IOException { return a(inputstream); } // Paper - OBFHELPER
      public static NBTTagCompound a(InputStream inputstream) throws IOException {
          DataInputStream datainputstream = new DataInputStream(new BufferedInputStream(new GZIPInputStream(inputstream)));
          Throwable throwable = null;
 @@ -0,0 +0,0 @@ public class NBTCompressedStreamTools {
-         return nbttagcompound;
+ 
      }
  
 +    public static void writeNBT(NBTTagCompound nbttagcompound, OutputStream outputstream) throws IOException { a(nbttagcompound, outputstream); } // Paper - OBFHELPER

Spigot-Server-Patches/Add-TNTPrimeEvent.patch

@@ -9,13 +9,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/BlockFire.java
 +++ b/src/main/java/net/minecraft/server/BlockFire.java
 @@ -0,0 +0,0 @@ package net.minecraft.server;
- 
+ import com.google.common.collect.ImmutableMap;
  import it.unimi.dsi.fastutil.objects.Object2IntMap;
  import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
 +import com.destroystokyo.paper.event.block.TNTPrimeEvent; // Paper - TNTPrimeEvent
  import java.util.Map;
  import java.util.Random;
- 
+ import java.util.function.Function;
 @@ -0,0 +0,0 @@ public class BlockFire extends BlockFireAbstract {
  
                  world.setTypeAndData(blockposition, this.a(world, blockposition, l), 3);
@@ -128,7 +128,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  public class EntityEnderDragon extends EntityInsentient implements IMonster {
 @@ -0,0 +0,0 @@ public class EntityEnderDragon extends EntityInsentient implements IMonster {
                      });
-                     craftBlock.getNMS().dropNaturally(world, blockposition, ItemStack.b);
+                     craftBlock.getNMS().dropNaturally((WorldServer) world, blockposition, ItemStack.b);
                  }
 +                // Paper start - TNTPrimeEvent
 +                org.bukkit.block.Block tntBlock = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());

Spigot-Server-Patches/Add-and-implement-PlayerRecipeBookClickEvent.patch

@@ -12,14 +12,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          PlayerConnectionUtils.ensureMainThread(packetplayinautorecipe, this, this.player.getWorldServer());
          this.player.resetIdleTimer();
          if (!this.player.isSpectator() && this.player.activeContainer.windowId == packetplayinautorecipe.b() && this.player.activeContainer.c(this.player) && this.player.activeContainer instanceof ContainerRecipeBook) {
--            this.minecraftServer.getCraftingManager().a(packetplayinautorecipe.c()).ifPresent((irecipe) -> {
+-            this.minecraftServer.getCraftingManager().getRecipe(packetplayinautorecipe.c()).ifPresent((irecipe) -> {
 -                ((ContainerRecipeBook) this.player.activeContainer).a(packetplayinautorecipe.d(), irecipe, this.player);
 -            });
 +            // Paper start - fire event for clicking recipes in the recipe book
 +            com.destroystokyo.paper.event.player.PlayerRecipeBookClickEvent event = new com.destroystokyo.paper.event.player.PlayerRecipeBookClickEvent(
 +                player.getBukkitEntity(), org.bukkit.craftbukkit.util.CraftNamespacedKey.fromMinecraft(packetplayinautorecipe.c()), packetplayinautorecipe.d());
 +            if (event.callEvent()) {
-+                this.minecraftServer.getCraftingManager().a(org.bukkit.craftbukkit.util.CraftNamespacedKey.toMinecraft(event.getRecipe())).ifPresent((irecipe) -> {
++                this.minecraftServer.getCraftingManager().getRecipe(org.bukkit.craftbukkit.util.CraftNamespacedKey.toMinecraft(event.getRecipe())).ifPresent((irecipe) -> {
 +                    ((ContainerRecipeBook) this.player.activeContainer).a(event.isMakeAll(), irecipe, this.player);
 +                });
 +            }

Spigot-Server-Patches/Add-configurable-portal-search-radius.patch

@@ -25,11 +25,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/Entity.java
 +++ b/src/main/java/net/minecraft/server/Entity.java
 @@ -0,0 +0,0 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, Ke
- 
+                 double d4 = DimensionManager.a(this.world.getDimensionManager(), worldserver.getDimensionManager());
-                 blockposition = new BlockPosition(d0, this.locY(), d1);
+                 BlockPosition blockposition = new BlockPosition(MathHelper.a(this.locX() * d4, d0, d2), this.locY(), MathHelper.a(this.locZ() * d4, d1, d3));
                  // CraftBukkit start
--                EntityPortalEvent event = CraftEventFactory.callEntityPortalEvent(this, worldserver, blockposition, 128);
+-                CraftPortalEvent event = callPortalEvent(this, worldserver, blockposition, PlayerTeleportEvent.TeleportCause.NETHER_PORTAL, flag2 ? 16 : 128, 16);
-+                EntityPortalEvent event = CraftEventFactory.callEntityPortalEvent(this, worldserver, blockposition, worldserver.paperConfig.portalSearchRadius); // Paper - use portal search radius
++                CraftPortalEvent event = callPortalEvent(this, worldserver, blockposition, PlayerTeleportEvent.TeleportCause.NETHER_PORTAL, worldserver.paperConfig.portalSearchRadius, worldserver.paperConfig.portalCreateRadius); // Paper start - configurable portal radius
                  if (event == null) {
                      return null;
                  }
@@ -38,34 +38,24 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/EntityPlayer.java
 +++ b/src/main/java/net/minecraft/server/EntityPlayer.java
 @@ -0,0 +0,0 @@ public class EntityPlayer extends EntityHuman implements ICrafting {
-             // CraftBukkit start
+     protected CraftPortalEvent callPortalEvent(Entity entity, WorldServer exitWorldServer, BlockPosition exitPosition, TeleportCause cause, int searchRadius, int creationRadius) {
-             Location enter = this.getBukkitEntity().getLocation();
+         Location enter = this.getBukkitEntity().getLocation();
-             Location exit = (worldserver == null) ? null : new Location(worldserver.getWorld(), d0, d1, d2, f1, f);
+         Location exit = new Location(exitWorldServer.getWorld(), exitPosition.getX(), exitPosition.getY(), exitPosition.getZ(), yaw, pitch);
--            PlayerPortalEvent event = new PlayerPortalEvent(this.getBukkitEntity(), enter, exit, cause, 128, true, resourcekey == DimensionManager.THE_END ? 0 : 16);
+-        PlayerPortalEvent event = new PlayerPortalEvent(this.getBukkitEntity(), enter, exit, cause, 128, true, creationRadius);
-+            com.destroystokyo.paper.PaperWorldConfig config = worldserver != null ? worldserver.paperConfig : worldserver1.paperConfig; // Paper - portal radius
++        PlayerPortalEvent event = new PlayerPortalEvent(this.getBukkitEntity(), enter, exit, cause, searchRadius, true, creationRadius); // Paper - use searchRadius
-+            PlayerPortalEvent event = new PlayerPortalEvent(this.getBukkitEntity(), enter, exit, cause, config.portalSearchRadius, true, resourcekey == DimensionManager.THE_END ? 0 : config.portalCreateRadius); // Paper - portal radius
+         Bukkit.getServer().getPluginManager().callEvent(event);
-             Bukkit.getServer().getPluginManager().callEvent(event);
+         if (event.isCancelled() || event.getTo() == null || event.getTo().getWorld() == null) {
-             if (event.isCancelled() || event.getTo() == null) {
+             return null;
-                 return null;
 diff --git a/src/main/java/net/minecraft/server/PortalTravelAgent.java b/src/main/java/net/minecraft/server/PortalTravelAgent.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/PortalTravelAgent.java
 +++ b/src/main/java/net/minecraft/server/PortalTravelAgent.java
 @@ -0,0 +0,0 @@ public class PortalTravelAgent {
-     @Nullable
+ 
-     public ShapeDetector.Shape a(BlockPosition blockposition, Vec3D vec3d, EnumDirection enumdirection, double d0, double d1, boolean flag) { // PAIL: rename to findPortal, d0 = portal offset x, d1 = portal offset z, flag = instanceof EntityHuman
+     public Optional<BlockUtil.Rectangle> findPortal(BlockPosition blockposition, boolean flag) {
          // CraftBukkit start
--        return findPortal(blockposition, vec3d, enumdirection, d0, d1, flag, 128);
+-        return findPortal(blockposition, flag ? 16 : 128); // Search Radius
-+        return findPortal(blockposition, vec3d, enumdirection, d0, d1, flag, world.paperConfig.portalSearchRadius); // Paper
++        return findPortal(blockposition, flag ? world.paperConfig.portalCreateRadius : world.paperConfig.portalSearchRadius); // Paper - search Radius
      }
  
-     @Nullable
+     public Optional<BlockUtil.Rectangle> findPortal(BlockPosition blockposition, int i) {
-@@ -0,0 +0,0 @@ public class PortalTravelAgent {
-         // CraftBukkit end
-         VillagePlace villageplace = this.world.x();
- 
--        villageplace.a(this.world, blockposition, 128);
-+        villageplace.a(this.world, blockposition, searchRadius); // Paper - This impacts the # of chunks searched for entries
-         List<VillagePlaceRecord> list = (List) villageplace.b((villageplacetype) -> {
-             return villageplacetype == VillagePlaceType.v;
-         }, blockposition, searchRadius, VillagePlace.Occupancy.ANY).collect(Collectors.toList()); // CraftBukkit - searchRadius

Spigot-Server-Patches/Add-effect-to-block-break-naturally.patch

@@ -24,7 +24,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          net.minecraft.server.Block block = iblockdata.getBlock();
 @@ -0,0 +0,0 @@ public class CraftBlock implements Block {
          // Modelled off EntityHuman#hasBlock
-         if (block != Blocks.AIR && (item == null || !iblockdata.isAlwaysDestroyable() || nmsItem.canDestroySpecialBlock(iblockdata))) {
+         if (block != Blocks.AIR && (item == null || !iblockdata.isRequiresSpecialTool() || nmsItem.canDestroySpecialBlock(iblockdata))) {
              net.minecraft.server.Block.dropItems(iblockdata, world.getMinecraftWorld(), position, world.getTileEntity(position), null, nmsItem);
 +            if (triggerEffect) world.triggerEffect(org.bukkit.Effect.STEP_SOUND.getId(), position, net.minecraft.server.Block.getCombinedId(block.getBlockData())); // Paper
              result = true;

Spigot-Server-Patches/Add-entity-liquid-API.patch

@@ -16,7 +16,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    public boolean isInRain() { // Paper - private -> public
          BlockPosition blockposition = this.getChunkCoordinates();
  
-         return this.world.isRainingAt(blockposition) || this.world.isRainingAt(blockposition.a(0.0D, (double) this.size.height, 0.0D));
+         return this.world.isRainingAt(blockposition) || this.world.isRainingAt(new BlockPosition((double) blockposition.getX(), this.getBoundingBox().maxY, (double) blockposition.getZ()));
      }
  
 +    public final boolean isInBubbleColumn() { return k(); } // Paper - OBFHELPER
@@ -27,17 +27,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          return this.isInWater() || this.isInRain() || this.k();
      }
  
-+    public final boolean isInWaterOrBubbleColumn() { return aD(); } // Paper - OBFHELPER
++    public final boolean isInWaterOrBubbleColumn() { return aG(); } // Paper - OBFHELPER
-     public boolean aD() {
+     public boolean aG() {
          return this.isInWater() || this.k();
      }
 @@ -0,0 +0,0 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, Ke
-         this.inLava = true;
+         return this.O == tag;
      }
  
-+    public final boolean isInLava() { return aN(); } // Paper - OBFHELPER
++    public final boolean isInLava() { return aP(); } // Paper - OBFHELPER
-     public boolean aN() {
+     public boolean aP() {
-         return this.inLava;
+         return !this.justCreated && this.M.getDouble(TagsFluid.LAVA) > 0.0D;
      }
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644

Spigot-Server-Patches/Add-exception-reporting-event.patch

@@ -79,20 +79,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              // CraftBukkit end
          }
      }
-diff --git a/src/main/java/net/minecraft/server/ChunkProviderServer.java b/src/main/java/net/minecraft/server/ChunkProviderServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/ChunkProviderServer.java
-+++ b/src/main/java/net/minecraft/server/ChunkProviderServer.java
-@@ -0,0 +0,0 @@ import java.util.function.Consumer;
- import java.util.function.Function;
- import java.util.function.Supplier;
- import javax.annotation.Nullable;
-+import com.destroystokyo.paper.exception.ServerInternalException;
-+import org.apache.logging.log4j.LogManager;
-+import org.apache.logging.log4j.Logger;
- 
- public class ChunkProviderServer extends IChunkProvider {
- 
 diff --git a/src/main/java/net/minecraft/server/NameReferencingFileConverter.java b/src/main/java/net/minecraft/server/NameReferencingFileConverter.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/NameReferencingFileConverter.java
@@ -173,7 +159,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
      }
 @@ -0,0 +0,0 @@ public final class SpawnerCreature {
-                                 entity = biomebase_biomemeta.c.a(generatoraccess.getMinecraftWorld());
+                                 entity = biomesettingsmobs_c.c.a((World) worldaccess.getMinecraftWorld());
                              } catch (Exception exception) {
                                  SpawnerCreature.LOGGER.warn("Failed to create mob", exception);
 +                                ServerInternalException.reportInternalException(exception); // Paper
@@ -191,11 +177,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
  import java.util.Iterator;
  import javax.annotation.Nullable;
- 
+ import org.apache.logging.log4j.LogManager;
 @@ -0,0 +0,0 @@ public class VillageSiege implements MobSpawner {
                  entityzombie.prepare(worldserver, worldserver.getDamageScaler(entityzombie.getChunkCoordinates()), EnumMobSpawn.EVENT, (GroupDataEntity) null, (NBTTagCompound) null);
              } catch (Exception exception) {
-                 exception.printStackTrace();
+                 VillageSiege.LOGGER.warn("Failed to create zombie for village siege at {}", vec3d, exception);
 +                ServerInternalException.reportInternalException(exception); // Paper
                  return;
              }
@@ -245,13 +231,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/WorldPersistentData.java
 +++ b/src/main/java/net/minecraft/server/WorldPersistentData.java
 @@ -0,0 +0,0 @@ public class WorldPersistentData {
-             nbttagcompound = GameProfileSerializer.a(this.c, DataFixTypes.SAVED_DATA, nbttagcompound1, j, i);
+             }
-         } catch (Throwable throwable4) {
+         } catch (Throwable throwable6) {
-             throwable = throwable4;
+             throwable = throwable6;
 +            com.destroystokyo.paper.exception.ServerInternalException.reportInternalException(throwable); // Paper
-             throw throwable4;
+             throw throwable6;
          } finally {
-             if (pushbackinputstream != null) {
+             if (fileinputstream != null) {
 diff --git a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java

Spigot-Server-Patches/Add-hand-to-bucket-events.patch

@@ -99,7 +99,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/WorldServer.java
 +++ b/src/main/java/net/minecraft/server/WorldServer.java
 @@ -0,0 +0,0 @@ public class WorldServer extends World implements GeneratorAccessSeed {
-         this.getMinecraftServer().getPlayerList().sendAll(new PacketPlayOutSpawnPosition(blockposition));
+         this.getMinecraftServer().getPlayerList().sendAll(new PacketPlayOutSpawnPosition(blockposition, f));
      }
  
 -    public BlockPosition getSpawn() {
@@ -123,8 +123,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    //}
 +    // Paper end
  
-     public LongSet getForceLoadedChunks() {
+     public float v() {
-         ForcedChunk forcedchunk = (ForcedChunk) this.getWorldPersistentData().b(ForcedChunk::new, "chunks");
+         return this.worldData.d();
 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

Spigot-Server-Patches/Add-method-to-open-already-placed-sign.patch

@@ -9,10 +9,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
 @@ -0,0 +0,0 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
-             entity.remove();
          }
      }
-+
+ 
 +    // Paper start - Add method to open already placed sign
 +    @Override
 +    public void openSign(org.bukkit.block.Sign sign) {
@@ -21,8 +20,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        net.minecraft.server.TileEntitySign teSign = craftSign.getTileEntity();
 +        // Make sign editable temporarily, will be set back to false in PlayerConnection later
 +        teSign.isEditable = true;
-+
 +        getHandle().openSign(teSign);
 +    }
 +    // Paper end
- }
+     @Override
+     public boolean dropItem(boolean dropAll) {
+         return getHandle().dropItem(dropAll);

Spigot-Server-Patches/Add-moon-phase-API.patch

@@ -0,0 +1,22 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@GMail.com>
+Date: Sun, 23 Aug 2020 16:32:11 +0200
+Subject: [PATCH] Add moon phase API
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -0,0 +0,0 @@ public class CraftWorld implements World {
+     public int getPlayerCount() {
+         return world.players.size();
+     }
++
++    @Override
++    public io.papermc.paper.world.MoonPhase getMoonPhase() {
++        return io.papermc.paper.world.MoonPhase.getPhase(getFullTime() / 24000L);
++    }
+     // Paper end
+ 
+     private static final Random rand = new Random();

Spigot-Server-Patches/Add-more-Witch-API.patch

@@ -20,17 +20,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  import java.util.Iterator;
  import java.util.List;
  import java.util.UUID;
-@@ -0,0 +0,0 @@ import java.util.function.Predicate;
+@@ -0,0 +0,0 @@ public class EntityWitch extends EntityRaider implements IRangedEntity {
- public class EntityWitch extends EntityRaider implements IRangedEntity {
- 
      private static final UUID b = UUID.fromString("5CD17E52-A79A-43D3-A529-90FDE04B181E");
--    private static final AttributeModifier bv = new AttributeModifier(EntityWitch.b, "Drinking speed penalty", -0.25D, AttributeModifier.Operation.ADDITION);
+     private static final AttributeModifier bo = new AttributeModifier(EntityWitch.b, "Drinking speed penalty", -0.25D, AttributeModifier.Operation.ADDITION);
-+    private static final AttributeModifier bv = new AttributeModifier(EntityWitch.b, "Drinking speed penalty", -0.25D, AttributeModifier.Operation.ADDITION); private static final AttributeModifier DRINKING_SPEED = bv; // Paper - OBFHELPER
+     private static final DataWatcherObject<Boolean> bp = DataWatcher.a(EntityWitch.class, DataWatcherRegistry.i);
-     private static final DataWatcherObject<Boolean> bw = DataWatcher.a(EntityWitch.class, DataWatcherRegistry.i);
+-    private int bq;
--    private int bx;
++    private int bq; public int getPotionUseTimeLeft() { return bq; } public void setPotionUseTimeLeft(int timeLeft) { bq = timeLeft; } // Paper - OBFHELPER
-+    private int bx; public int getPotionUseTimeLeft() { return bx; } public void setPotionUseTimeLeft(int timeLeft) { bx = timeLeft; } // Paper - OBFHELPER
+     private PathfinderGoalNearestHealableRaider<EntityRaider> br;
-     private PathfinderGoalNearestHealableRaider<EntityRaider> by;
+     private PathfinderGoalNearestAttackableTargetWitch<EntityHuman> bs;
-     private PathfinderGoalNearestAttackableTargetWitch<EntityHuman> bz;
  
 @@ -0,0 +0,0 @@ public class EntityWitch extends EntityRaider implements IRangedEntity {
          return SoundEffects.ENTITY_WITCH_DEATH;
@@ -38,48 +35,47 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 +    public void setDrinkingPotion(boolean drinkingPotion) { v(drinkingPotion); } // Paper - OBFHELPER
      public void v(boolean flag) {
-         this.getDataWatcher().set(EntityWitch.bw, flag);
+         this.getDataWatcher().set(EntityWitch.bp, flag);
      }
  
 +    public boolean isDrinkingPotion() { return m(); } // Paper - OBFHELPER
      public boolean m() {
-         return (Boolean) this.getDataWatcher().get(EntityWitch.bw);
+         return (Boolean) this.getDataWatcher().get(EntityWitch.bp);
      }
 @@ -0,0 +0,0 @@ public class EntityWitch extends EntityRaider implements IRangedEntity {
                  }
  
                  if (potionregistry != null) {
 -                    // Paper start
--                    ItemStack potion = PotionUtil.a(new ItemStack(Items.POTION), potionregistry);
+                     ItemStack potion = PotionUtil.a(new ItemStack(Items.POTION), potionregistry);
 -                    org.bukkit.inventory.ItemStack bukkitStack = com.destroystokyo.paper.event.entity.WitchReadyPotionEvent.process((org.bukkit.entity.Witch) this.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(potion));
 -                    this.setSlot(EnumItemSlot.MAINHAND, org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(bukkitStack));
--                    // Paper end
++                    // Paper start - logic moved into setDrinkingPotion, copy exact impl into the method and then comment out
--                    this.bx = this.getItemInMainHand().k();
++                    this.setDrinkingPotion(potion);
++//                    org.bukkit.inventory.ItemStack bukkitStack = com.destroystokyo.paper.event.entity.WitchReadyPotionEvent.process((org.bukkit.entity.Witch) this.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(potion));
++//                    this.setSlot(EnumItemSlot.MAINHAND, org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(bukkitStack));
++//                    // Paper end
++//                    this.bq = this.getItemInMainHand().k();
++//                    this.v(true);
++//                    if (!this.isSilent()) {
++//                        this.world.playSound((EntityHuman) null, this.locX(), this.locY(), this.locZ(), SoundEffects.ENTITY_WITCH_DRINK, this.getSoundCategory(), 1.0F, 0.8F + this.random.nextFloat() * 0.4F);
++//                    }
++//
++//                    AttributeModifiable attributemodifiable = this.getAttributeInstance(GenericAttributes.MOVEMENT_SPEED);
++//
++//                    attributemodifiable.removeModifier(EntityWitch.bo);
++//                    attributemodifiable.b(EntityWitch.bo);
+                     // Paper end
+-                    this.bq = this.getItemInMainHand().k();
 -                    this.v(true);
 -                    if (!this.isSilent()) {
 -                        this.world.playSound((EntityHuman) null, this.locX(), this.locY(), this.locZ(), SoundEffects.ENTITY_WITCH_DRINK, this.getSoundCategory(), 1.0F, 0.8F + this.random.nextFloat() * 0.4F);
 -                    }
--
+ 
 -                    AttributeModifiable attributemodifiable = this.getAttributeInstance(GenericAttributes.MOVEMENT_SPEED);
 -
--                    attributemodifiable.removeModifier(EntityWitch.bv);
+-                    attributemodifiable.removeModifier(EntityWitch.bo);
--                    attributemodifiable.b(EntityWitch.bv);
+-                    attributemodifiable.b(EntityWitch.bo);
-+                    //// Paper start
-+                    //ItemStack potion = PotionUtil.a(new ItemStack(Items.POTION), potionregistry);
-+                    //org.bukkit.inventory.ItemStack bukkitStack = com.destroystokyo.paper.event.entity.WitchReadyPotionEvent.process((org.bukkit.entity.Witch) this.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(potion));
-+                    //this.setSlot(EnumItemSlot.MAINHAND, org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(bukkitStack));
-+                    //// Paper end
-+                    //this.bx = this.getItemInMainHand().k();
-+                    //this.v(true);
-+                    //if (!this.isSilent()) {
-+                    //    this.world.playSound((EntityHuman) null, this.locX(), this.locY(), this.locZ(), SoundEffects.ENTITY_WITCH_DRINK, this.getSoundCategory(), 1.0F, 0.8F + this.random.nextFloat() * 0.4F);
-+                    //}
-+                    //
-+                    //AttributeModifiable attributemodifiable = this.getAttributeInstance(GenericAttributes.MOVEMENT_SPEED);
-+                    //
-+                    //attributemodifiable.removeModifier(EntityWitch.bv);
-+                    //attributemodifiable.b(EntityWitch.bv);
-+                    this.setDrinkingPotion(PotionUtil.addPotionToItemStack(new ItemStack(Items.POTION), potionregistry));
                  }
              }
  
@@ -89,20 +85,24 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 +    // Paper start - moved to its own method
 +    public void setDrinkingPotion(ItemStack potion) {
-+        setSlot(EnumItemSlot.MAINHAND, CraftItemStack.asNMSCopy(WitchReadyPotionEvent.process((Witch) getBukkitEntity(), CraftItemStack.asCraftMirror(potion))));
++        org.bukkit.inventory.ItemStack bukkitStack = com.destroystokyo.paper.event.entity.WitchReadyPotionEvent.process((org.bukkit.entity.Witch) this.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(potion));
-+        setPotionUseTimeLeft(getItemInMainHand().getItemUseMaxDuration());
++        this.setSlot(EnumItemSlot.MAINHAND, org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(bukkitStack));
-+        setDrinkingPotion(true);
++        // Paper end
++        this.bq = this.getItemInMainHand().k();
++        this.v(true);
 +        if (!this.isSilent()) {
 +            this.world.playSound((EntityHuman) null, this.locX(), this.locY(), this.locZ(), SoundEffects.ENTITY_WITCH_DRINK, this.getSoundCategory(), 1.0F, 0.8F + this.random.nextFloat() * 0.4F);
 +        }
++
 +        AttributeModifiable attributemodifiable = this.getAttributeInstance(GenericAttributes.MOVEMENT_SPEED);
-+        attributemodifiable.removeModifier(EntityWitch.bv);
++
-+        attributemodifiable.b(EntityWitch.bv);
++        attributemodifiable.removeModifier(EntityWitch.bo);
++        attributemodifiable.b(EntityWitch.bo);
 +    }
 +    // Paper end
 +
      @Override
-     public SoundEffect eM() {
+     public SoundEffect eL() {
          return SoundEffects.ENTITY_WITCH_CELEBRATE;
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
@@ -124,11 +124,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.inventory.ItemStack;
 +// Paper end
  
--public class CraftWitch extends CraftRaider implements Witch, CraftRangedEntity<EntityWitch> { // Paper
+ public class CraftWitch extends CraftRaider implements Witch, CraftRangedEntity<EntityWitch> { // Paper
-+public class CraftWitch extends CraftRaider implements Witch, CraftRangedEntity<EntityWitch> {
      public CraftWitch(CraftServer server, EntityWitch entity) {
-         super(server, entity);
-     }
 @@ -0,0 +0,0 @@ public class CraftWitch extends CraftRaider implements Witch, CraftRangedEntity<
      public EntityType getType() {
          return EntityType.WITCH;

Spigot-Server-Patches/Add-more-Zombie-API.patch

@@ -9,7 +9,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/EntityZombie.java
 +++ b/src/main/java/net/minecraft/server/EntityZombie.java
 @@ -0,0 +0,0 @@ public class EntityZombie extends EntityMonster {
-     private int bA;
+     private int bt;
      public int drownedConversionTime;
      private int lastTick = MinecraftServer.currentTick; // CraftBukkit - add field
 +    private boolean shouldBurnInDay = true; // Paper
@@ -17,7 +17,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public EntityZombie(EntityTypes<? extends EntityZombie> entitytypes, World world) {
          super(entitytypes, world);
 @@ -0,0 +0,0 @@ public class EntityZombie extends EntityMonster {
-         this.getDataWatcher().set(EntityZombie.DROWN_CONVERTING, true);
+         super.movementTick();
      }
  
 +    // Paper start
@@ -26,18 +26,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        this.getDataWatcher().set(EntityZombie.DROWN_CONVERTING, false);
 +    }
 +    // Paper end
-+
+     public void startDrownedConversion(int i) {
-     protected void eQ() {
+         this.lastTick = MinecraftServer.currentTick; // CraftBukkit
-         this.c(EntityTypes.DROWNED);
+         this.drownedConversionTime = i;
-         if (!this.isSilent()) {
 @@ -0,0 +0,0 @@ public class EntityZombie extends EntityMonster {
  
      }
  
-+    public boolean shouldBurnInDay() { return U_(); } // Paper - OBFHELPER
++    public boolean shouldBurnInDay() { return T_(); } // Paper - OBFHELPER
-     protected boolean U_() {
+     protected boolean T_() {
--        return true;
+         return true;
-+        return shouldBurnInDay;
      }
  
 +    // Paper start
@@ -48,10 +46,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
      @Override
      public boolean damageEntity(DamageSource damagesource, float f) {
-         if (super.damageEntity(damagesource, f)) {
+         if (!super.damageEntity(damagesource, f)) {
 @@ -0,0 +0,0 @@ public class EntityZombie extends EntityMonster {
-         nbttagcompound.setBoolean("CanBreakDoors", this.eV());
+         nbttagcompound.setBoolean("CanBreakDoors", this.eU());
-         nbttagcompound.setInt("InWaterTime", this.isInWater() ? this.bA : -1);
+         nbttagcompound.setInt("InWaterTime", this.isInWater() ? this.bt : -1);
          nbttagcompound.setInt("DrownedConversionTime", this.isDrownConverting() ? this.drownedConversionTime : -1);
 +        nbttagcompound.setBoolean("Paper.ShouldBurnInDay", shouldBurnInDay); // Paper
      }
@@ -75,10 +73,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftZombie.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftZombie.java
 @@ -0,0 +0,0 @@ public class CraftZombie extends CraftMonster implements Zombie {
-             getHandle().startDrownedConversion(time);
+     @Override
-         }
+     public void setAgeLock(boolean b) {
      }
-+
 +    // Paper start
 +    @Override
 +    public boolean isDrowning() {
@@ -115,4 +112,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        getHandle().setShouldBurnInDay(shouldBurnInDay);
 +    }
 +    // Paper end
- }
+ 
+     @Override
+     public boolean getAgeLock() {

Spigot-Server-Patches/Add-option-to-allow-iron-golems-to-spawn-in-air.patch

@@ -17,9 +17,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        ironGolemsCanSpawnInAir = getBoolean("iron-golems-can-spawn-in-air", ironGolemsCanSpawnInAir);
 +    }
 +
-     public int bedSearchRadius = 1;
+     public boolean armorStandEntityLookups = true;
-     private void bedSearchRadius() {
+     private void armorStandEntityLookups() {
-         bedSearchRadius = getInt("bed-search-radius", 1);
+         armorStandEntityLookups = getBoolean("armor-stands-do-collision-entity-lookups", true);
 diff --git a/src/main/java/net/minecraft/server/EntityIronGolem.java b/src/main/java/net/minecraft/server/EntityIronGolem.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/EntityIronGolem.java

Spigot-Server-Patches/Add-option-to-nerf-pigmen-from-nether-portals.patch

@@ -25,7 +25,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class BlockPortal extends Block {
  
                  if (entity != null) {
-                     entity.portalCooldown = entity.getDefaultPortalCooldown();
+                     entity.resetPortalCooldown();
 +                    entity.fromNetherPortal = true; // Paper
 +                    if (worldserver.paperConfig.nerfNetherPortalPigmen) ((EntityInsentient) entity).aware = false; // Paper
                  }

Spigot-Server-Patches/Add-phantom-creative-and-insomniac-controls.patch

@@ -56,4 +56,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                        if (!entityhuman.isSpectator() && (!worldserver.paperConfig.phantomIgnoreCreative || !entityhuman.isCreative())) { // Paper
                              BlockPosition blockposition = entityhuman.getChunkCoordinates();
  
-                             if (!worldserver.getDimensionManager().hasSkyLight() || blockposition.getY() >= worldserver.getSeaLevel() && worldserver.f(blockposition)) {
+                             if (!worldserver.getDimensionManager().hasSkyLight() || blockposition.getY() >= worldserver.getSeaLevel() && worldserver.e(blockposition)) {

Spigot-Server-Patches/Add-setMaxPlayers-API.patch

@@ -0,0 +1,37 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mariell Hoversholm <proximyst@proximyst.com>
+Date: Sat, 22 Aug 2020 23:59:30 +0200
+Subject: [PATCH] Add #setMaxPlayers API
+
+
+diff --git a/src/main/java/net/minecraft/server/PlayerList.java b/src/main/java/net/minecraft/server/PlayerList.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/server/PlayerList.java
++++ b/src/main/java/net/minecraft/server/PlayerList.java
+@@ -0,0 +0,0 @@ public abstract class PlayerList {
+     public final WorldNBTStorage playerFileData;
+     private boolean hasWhitelist;
+     private final IRegistryCustom.Dimension s;
+-    protected final int maxPlayers;
++    protected int maxPlayers; public final void setMaxPlayers(int maxPlayers) { this.maxPlayers = maxPlayers; } // Paper - remove final and add setter
+     private int viewDistance;
+     private EnumGamemode u;
+     private boolean v;
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- 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 {
+         return playerList.getMaxPlayers();
+     }
+ 
++    // Paper start
++    @Override
++    public void setMaxPlayers(int maxPlayers) {
++        this.playerList.setMaxPlayers(maxPlayers);
++    }
++    // Paper end
++
+     // NOTE: These are dependent on the corresponding call in MinecraftServer
+     // so if that changes this will need to as well
+     @Override

Spigot-Server-Patches/Add-sun-related-API.patch

@@ -12,10 +12,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      }
  
-+    public boolean isInDaylight() { return this.eH(); } // Paper - OBFHELPER
++    public boolean isInDaylight() { return this.eG(); } // Paper - OBFHELPER
-     protected boolean eH() {
+     protected boolean eG() {
          if (this.world.isDay() && !this.world.isClientSide) {
-             float f = this.aO();
+             float f = this.aQ();
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java

Spigot-Server-Patches/Add-tick-times-API-and-mspt-command.patch

@@ -116,8 +116,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          this.methodProfiler.exit();
          org.spigotmc.WatchdogThread.tick(); // Spigot
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends IAsyncTaskHandlerReentrant<TickTas
-     public SaveData getSaveData() {
+     public IRegistryCustom aX() {
-         return this.saveData;
+         return this.f;
      }
 +
 +    // Paper start

Spigot-Server-Patches/Add-villager-reputation-API.patch

@@ -24,12 +24,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/EntityVillager.java
 +++ b/src/main/java/net/minecraft/server/EntityVillager.java
 @@ -0,0 +0,0 @@ public class EntityVillager extends EntityVillagerAbstract implements Reputation
-         this.bK = 0;
+         this.bD = 0;
      }
  
 +    public Reputation getReputation() { return this.fj(); } // Paper - OBFHELPER
      public Reputation fj() {
-         return this.bF;
+         return this.by;
      }
 diff --git a/src/main/java/net/minecraft/server/Reputation.java b/src/main/java/net/minecraft/server/Reputation.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644

Spigot-Server-Patches/Allow-Saving-of-Oversized-Chunks.patch

@@ -38,9 +38,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      }
  
-+    public static NBTTagCompound readNBT(DataInputStream datainputstream) throws IOException { return a(datainputstream); } // Paper - OBFHELPER
++    public static NBTTagCompound readNBT(DataInput datainput) throws IOException { return a(datainput); } // Paper - OBFHELPER
-     public static NBTTagCompound a(DataInputStream datainputstream) throws IOException {
+     public static NBTTagCompound a(DataInput datainput) throws IOException {
-         return a((DataInput) datainputstream, NBTReadLimiter.a);
+         return a(datainput, NBTReadLimiter.a);
      }
 @@ -0,0 +0,0 @@ public class NBTCompressedStreamTools {
          }
@@ -64,26 +64,27 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  import org.apache.logging.log4j.LogManager;
  import org.apache.logging.log4j.Logger;
 @@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable {
-     private final IntBuffer g;
+     private final IntBuffer i;
-     private final IntBuffer h;
+     @VisibleForTesting
-     private final RegionFileBitSet freeSectors;
+     protected final RegionFileBitSet freeSectors;
-+    public final File file;
++    public final File file; // Paper
  
      public RegionFile(File file, File file1, boolean flag) throws IOException {
          this(file.toPath(), file1.toPath(), RegionFileCompression.b, flag);
-     }
+@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable {
  
      public RegionFile(java.nio.file.Path java_nio_file_path, java.nio.file.Path java_nio_file_path1, RegionFileCompression regionfilecompression, boolean flag) throws IOException {
+         this.g = ByteBuffer.allocateDirect(8192);
 +        this.file = java_nio_file_path.toFile(); // Paper
-         this.f = ByteBuffer.allocateDirect(8192);
++        initOversizedState(); // Paper
-+        initOversizedState();
          this.freeSectors = new RegionFileBitSet();
-         this.e = regionfilecompression;
+         this.f = regionfilecompression;
          if (!Files.isDirectory(java_nio_file_path1, new LinkOption[0])) {
 @@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable {
          void run() throws IOException;
      }
  
++    // Paper start
 +    private final byte[] oversized = new byte[1024];
 +    private int oversizedCount = 0;
 +
@@ -146,12 +147,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    synchronized NBTTagCompound getOversizedData(int x, int z) throws IOException {
 +        File file = getOversizedFile(x, z);
 +        try (DataInputStream out = new DataInputStream(new BufferedInputStream(new InflaterInputStream(new java.io.FileInputStream(file))))) {
-+            return NBTCompressedStreamTools.readNBT(out);
++            return NBTCompressedStreamTools.readNBT((java.io.DataInput) out);
 +        }
 +
 +    }
 +    // Paper end
-+
      class ChunkBuffer extends ByteArrayOutputStream {
  
          private final ChunkCoordIntPair b;
@@ -188,7 +188,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        synchronized (regionfile) {
 +            try (DataInputStream datainputstream = regionfile.getReadStream(chunkCoordinate)) {
 +                NBTTagCompound oversizedData = regionfile.getOversizedData(chunkCoordinate.x, chunkCoordinate.z);
-+                NBTTagCompound chunk = NBTCompressedStreamTools.readNBT(datainputstream);
++                NBTTagCompound chunk = NBTCompressedStreamTools.readNBT((DataInput) datainputstream);
 +                if (oversizedData == null) {
 +                    return chunk;
 +                }
@@ -251,7 +251,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
          try {
              NBTCompressedStreamTools.a(nbttagcompound, (DataOutput) dataoutputstream);
-+            regionfile.setOversized(chunkcoordintpair.x, chunkcoordintpair.z, false); // We don't do this anymore
++            regionfile.setOversized(chunkcoordintpair.x, chunkcoordintpair.z, false); // Paper - We don't do this anymore, mojang stores differently, but clear old meta flag if it exists to get rid of our own meta file once last oversized is gone
          } catch (Throwable throwable1) {
              throwable = throwable1;
              throw throwable1;

Spigot-Server-Patches/Allow-delegation-to-vanilla-chunk-gen.patch

@@ -47,7 +47,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        net.minecraft.server.RegionLimitedWorldAccess genRegion = new net.minecraft.server.RegionLimitedWorldAccess(nmsWorld, list);
 +        // call vanilla generator, one feature after another. Order here is important!
 +        net.minecraft.server.ChunkGenerator chunkGenerator = nmsWorld.getChunkProvider().chunkGenerator;
-+        chunkGenerator.createBiomes(protoChunk);
++        chunkGenerator.createBiomes(nmsWorld.r().b(IRegistry.ay), protoChunk);
 +        chunkGenerator.buildNoise(genRegion, nmsWorld.getStructureManager(), protoChunk);
 +        chunkGenerator.buildBase(genRegion, protoChunk);
 +        // copy over generated sections

Spigot-Server-Patches/Allow-disabling-armour-stand-ticking.patch

@@ -36,14 +36,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public EntityArmorStand(EntityTypes<? extends EntityArmorStand> entitytypes, World world) {
          super(entitytypes, world);
-@@ -0,0 +0,0 @@ public class EntityArmorStand extends EntityLiving {
-         this.rightArmPose = EntityArmorStand.bt;
-         this.leftLegPose = EntityArmorStand.bu;
-         this.rightLegPose = EntityArmorStand.bv;
 +        if (world != null) this.canTick = world.paperConfig.armorStandTick; // Paper - armour stand ticking
-         this.G = 0.0F;
+         this.handItems = NonNullList.a(2, ItemStack.b);
-     }
+         this.armorItems = NonNullList.a(4, ItemStack.b);
- 
+         this.headPose = EntityArmorStand.bj;
 @@ -0,0 +0,0 @@ public class EntityArmorStand extends EntityLiving {
                  this.armorItems.set(enumitemslot.b(), itemstack);
          }
@@ -129,18 +125,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      public void setLeftLegPose(Vector3f vector3f) {
++        this.noTickPoseDirty = true; // Paper - Allow updates when not ticking
          this.leftLegPose = vector3f;
          this.datawatcher.set(EntityArmorStand.g, vector3f);
-+        this.noTickPoseDirty = true; // Paper - Allow updates when not ticking
++
      }
  
      public void setRightLegPose(Vector3f vector3f) {
-         this.rightLegPose = vector3f;
-         this.datawatcher.set(EntityArmorStand.bo, vector3f);
 +        this.noTickPoseDirty = true; // Paper - Allow updates when not ticking
+         this.rightLegPose = vector3f;
+         this.datawatcher.set(EntityArmorStand.bh, vector3f);
      }
- 
-     public Vector3f r() {
 diff --git a/src/main/java/net/minecraft/server/EntityLiving.java b/src/main/java/net/minecraft/server/EntityLiving.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/EntityLiving.java
@@ -149,9 +144,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
      }
  
-+    public void updateEntityEquipment() { q(); }; // Paper
++    public final void updateEntityEquipment() { p(); }; // Paper - OBFHELPER
-     private void q() {
+     private void p() {
-         Map<EnumItemSlot, ItemStack> map = this.r();
+         Map<EnumItemSlot, ItemStack> map = this.q();
  
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644

Spigot-Server-Patches/Allow-nerfed-mobs-to-jump-and-take-water-damage.patch

@@ -38,8 +38,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          return this.isInWater() || this.isInRain();
      }
  
-+    public final boolean isInWaterOrRainOrBubble() { return aC(); } // Paper - OBFHELPER
++    public final boolean isInWaterOrRainOrBubble() { return aF(); } // Paper - OBFHELPER
-     public boolean aC() {
+     public boolean aF() {
          return this.isInWater() || this.isInRain() || this.k();
      }
 diff --git a/src/main/java/net/minecraft/server/EntityInsentient.java b/src/main/java/net/minecraft/server/EntityInsentient.java
@@ -53,7 +53,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @Nullable public PathfinderGoalFloat goalFloat; // Paper
      public PathfinderGoalSelector targetSelector;
      private EntityLiving goalTarget;
-     private final EntitySenses bv;
+     private final EntitySenses bo;
 @@ -0,0 +0,0 @@ public abstract class EntityInsentient extends EntityLiving {
      @Override
      protected final void doTick() {
@@ -71,7 +71,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        }
 +        // Paper end
          this.world.getMethodProfiler().enter("sensing");
-         this.bv.a();
+         this.bo.a();
          this.world.getMethodProfiler().exit();
 diff --git a/src/main/java/net/minecraft/server/PathfinderGoalFloat.java b/src/main/java/net/minecraft/server/PathfinderGoalFloat.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
@@ -89,7 +89,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    public final boolean validConditions() { return this.a(); } // Paper - OBFHELPER
      @Override
      public boolean a() {
-         return this.a.isInWater() && this.a.b((Tag) TagsFluid.WATER) > this.a.cw() || this.a.aN();
+         return this.a.isInWater() && this.a.b((Tag) TagsFluid.WATER) > this.a.cw() || this.a.aP();
      }
  
 +    public void update() { this.e(); } // Paper - OBFHELPER

Spigot-Server-Patches/Anti-Xray.patch

@@ -135,7 +135,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private final ChunkSection[] emptyNearbyChunkSections = {Chunk.EMPTY_CHUNK_SECTION, Chunk.EMPTY_CHUNK_SECTION, Chunk.EMPTY_CHUNK_SECTION, Chunk.EMPTY_CHUNK_SECTION};
 +    private final int maxBlockYUpdatePosition;
 +
-+    public ChunkPacketBlockControllerAntiXray(PaperWorldConfig paperWorldConfig, Executor executor) {
++    public ChunkPacketBlockControllerAntiXray(World world, Executor executor) {
++        PaperWorldConfig paperWorldConfig = world.paperConfig;
 +        engineMode = paperWorldConfig.engineMode;
 +        maxChunkSectionIndex = paperWorldConfig.maxChunkSectionIndex;
 +        updateRadius = paperWorldConfig.updateRadius;
@@ -185,12 +186,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        for (String id : toObfuscate) {
 +            Block block = IRegistry.BLOCK.getOptional(new MinecraftKey(id)).orElse(null);
 +
-+            if (block != null) {
++            // Don't obfuscate air because air causes unnecessary block updates and causes block updates to fail in the void
++            if (block != null && !block.getBlockData().isAir()) {
 +                obfuscateGlobal[ChunkSection.GLOBAL_PALETTE.getOrCreateIdFor(block.getBlockData())] = true;
 +            }
 +        }
 +
-+        ChunkEmpty emptyChunk = new ChunkEmpty(null, new ChunkCoordIntPair(0, 0));
++        ChunkEmpty emptyChunk = new ChunkEmpty(world, new ChunkCoordIntPair(0, 0));
 +        BlockPosition zeroPos = new BlockPosition(0, 0, 0);
 +
 +        for (int i = 0; i < solidGlobal.length; i++) {
@@ -1000,6 +1002,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              this.sections[j >> 4] = chunksection;
          }
  
+diff --git a/src/main/java/net/minecraft/server/ChunkEmpty.java b/src/main/java/net/minecraft/server/ChunkEmpty.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/server/ChunkEmpty.java
++++ b/src/main/java/net/minecraft/server/ChunkEmpty.java
+@@ -0,0 +0,0 @@ public class ChunkEmpty extends Chunk {
+     });
+ 
+     public ChunkEmpty(World world, ChunkCoordIntPair chunkcoordintpair) {
+-        super(world, chunkcoordintpair, new BiomeStorage(world.r().b(IRegistry.ay), ChunkEmpty.b));
++        super(world, chunkcoordintpair, new BiomeStorage(MinecraftServer.getServer().getCustomRegistry().b(IRegistry.ay), ChunkEmpty.b)); // Paper - world isnt ready yet for anti xray use here, use server singleton for registry
+     }
+ 
+     // Paper start
 diff --git a/src/main/java/net/minecraft/server/ChunkRegionLoader.java b/src/main/java/net/minecraft/server/ChunkRegionLoader.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/ChunkRegionLoader.java
@@ -1036,7 +1051,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  public class ChunkSection {
 @@ -0,0 +0,0 @@ public class ChunkSection {
      private short e;
-     final DataPaletteBlock<IBlockData> blockIds;
+     final DataPaletteBlock<IBlockData> blockIds; // Paper - package-private
  
 -    public ChunkSection(int i) {
 -        this(i, (short) 0, (short) 0, (short) 0);
@@ -1200,6 +1215,18 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          int j = along.length * 64 / 4096;
  
          if (this.h == this.b) {
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends IAsyncTaskHandlerReentrant<TickTas
+         return this.saveData;
+     }
+ 
++    public final IRegistryCustom getCustomRegistry() { return aX(); } // Paper - OBFHELPER
+     public IRegistryCustom aX() {
+         return this.f;
+     }
 diff --git a/src/main/java/net/minecraft/server/PacketPlayOutMapChunk.java b/src/main/java/net/minecraft/server/PacketPlayOutMapChunk.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/PacketPlayOutMapChunk.java
@@ -1212,8 +1239,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  import io.netty.buffer.ByteBuf;
  import io.netty.buffer.Unpooled;
 @@ -0,0 +0,0 @@ public class PacketPlayOutMapChunk implements Packet<PacketListenerPlayOut> {
+     private List<NBTTagCompound> g;
      private boolean h;
-     private boolean i;
  
 -    public PacketPlayOutMapChunk() {}
 +    // Paper start - Async-Anti-Xray - Set the ready flag to true
@@ -1222,13 +1249,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        this.ready = true;
 +    }
 +    // Paper end
- 
++
      // Paper start
      private final java.util.List<Packet> extraPackets = new java.util.ArrayList<>();
+     private static final int TE_LIMIT = Integer.getInteger("Paper.excessiveTELimit", 750);
 @@ -0,0 +0,0 @@ public class PacketPlayOutMapChunk implements Packet<PacketListenerPlayOut> {
      }
      // Paper end
-     public PacketPlayOutMapChunk(Chunk chunk, int i, boolean flag) {
+     public PacketPlayOutMapChunk(Chunk chunk, int i) {
 +        ChunkPacketInfo<IBlockData> chunkPacketInfo = chunk.world.chunkPacketBlockController.getChunkPacketInfo(this, chunk, i); // Paper - Anti-Xray - Add chunk packet info
          ChunkCoordIntPair chunkcoordintpair = chunk.getPos();
  
@@ -1237,12 +1265,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
  
          this.f = new byte[this.a(chunk, i)];
--        this.c = this.a(new PacketDataSerializer(this.k()), chunk, i);
+-        this.c = this.a(new PacketDataSerializer(this.j()), chunk, i);
 +        // Paper start - Anti-Xray - Add chunk packet info
 +        if (chunkPacketInfo != null) {
 +            chunkPacketInfo.setData(this.getData());
 +        }
-+        this.c = this.writeChunk(new PacketDataSerializer(this.k()), chunk, i, chunkPacketInfo);
++        this.c = this.writeChunk(new PacketDataSerializer(this.j()), chunk, i, chunkPacketInfo);
 +        // Paper end
          this.g = Lists.newArrayList();
          iterator = chunk.getTileEntities().entrySet().iterator();
@@ -1393,14 +1421,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public final co.aikar.timings.WorldTimingsHandler timings; // Paper
      public static BlockPosition lastPhysicsProblem; // Spigot
 @@ -0,0 +0,0 @@ public abstract class World implements GeneratorAccess, AutoCloseable {
-         return (CraftServer) Bukkit.getServer();
+         return typeKey;
      }
  
--    protected World(WorldDataMutable worlddatamutable, ResourceKey<World> resourcekey, ResourceKey<DimensionManager> resourcekey1, DimensionManager dimensionmanager, Supplier<GameProfilerFiller> supplier, boolean flag, boolean flag1, long i, org.bukkit.generator.ChunkGenerator gen, org.bukkit.World.Environment env) {
+-    protected World(WorldDataMutable worlddatamutable, ResourceKey<World> resourcekey, final DimensionManager dimensionmanager, Supplier<GameProfilerFiller> supplier, boolean flag, boolean flag1, long i, org.bukkit.generator.ChunkGenerator gen, org.bukkit.World.Environment env) {
-+    protected World(WorldDataMutable worlddatamutable, ResourceKey<World> resourcekey, ResourceKey<DimensionManager> resourcekey1, DimensionManager dimensionmanager, Supplier<GameProfilerFiller> supplier, boolean flag, boolean flag1, long i, org.bukkit.generator.ChunkGenerator gen, org.bukkit.World.Environment env, java.util.concurrent.Executor executor) {
++    protected World(WorldDataMutable worlddatamutable, ResourceKey<World> resourcekey, final DimensionManager dimensionmanager, Supplier<GameProfilerFiller> supplier, boolean flag, boolean flag1, long i, org.bukkit.generator.ChunkGenerator gen, org.bukkit.World.Environment env, java.util.concurrent.Executor executor) { // Paper
          this.spigotConfig = new org.spigotmc.SpigotWorldConfig(((WorldDataServer) worlddatamutable).getName()); // Spigot
          this.paperConfig = new com.destroystokyo.paper.PaperWorldConfig((((WorldDataServer)worlddatamutable).getName()), this.spigotConfig); // Paper
-+        this.chunkPacketBlockController = this.paperConfig.antiXray ? new ChunkPacketBlockControllerAntiXray(this.paperConfig, executor) : ChunkPacketBlockController.NO_OPERATION_INSTANCE; // Paper - Anti-Xray
++        this.chunkPacketBlockController = this.paperConfig.antiXray ? new ChunkPacketBlockControllerAntiXray(this, executor) : ChunkPacketBlockController.NO_OPERATION_INSTANCE; // Paper - Anti-Xray
          this.generator = gen;
          this.world = new CraftWorld((WorldServer) this, gen, env);
          this.ticksPerAnimalSpawns = this.getServer().getTicksPerAnimalSpawns(); // CraftBukkit
@@ -1419,9 +1447,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class WorldServer extends World implements GeneratorAccessSeed {
  
      // Add env and gen to constructor, WorldData -> WorldDataServer
-     public WorldServer(MinecraftServer minecraftserver, Executor executor, Convertable.ConversionSession convertable_conversionsession, IWorldDataServer iworlddataserver, ResourceKey<World> resourcekey, ResourceKey<DimensionManager> resourcekey1, DimensionManager dimensionmanager, WorldLoadListener worldloadlistener, ChunkGenerator chunkgenerator, boolean flag, long i, List<MobSpawner> list, boolean flag1, org.bukkit.World.Environment env, org.bukkit.generator.ChunkGenerator gen) {
+     public WorldServer(MinecraftServer minecraftserver, Executor executor, Convertable.ConversionSession convertable_conversionsession, IWorldDataServer iworlddataserver, ResourceKey<World> resourcekey, DimensionManager dimensionmanager, WorldLoadListener worldloadlistener, ChunkGenerator chunkgenerator, boolean flag, long i, List<MobSpawner> list, boolean flag1, org.bukkit.World.Environment env, org.bukkit.generator.ChunkGenerator gen) {
--        super(iworlddataserver, resourcekey, resourcekey1, dimensionmanager, minecraftserver::getMethodProfiler, false, flag, i, gen, env);
+-        super(iworlddataserver, resourcekey, dimensionmanager, minecraftserver::getMethodProfiler, false, flag, i, gen, env);
-+        super(iworlddataserver, resourcekey, resourcekey1, dimensionmanager, minecraftserver::getMethodProfiler, false, flag, i, gen, env, executor); // Paper pass executor
++        super(iworlddataserver, resourcekey, dimensionmanager, minecraftserver::getMethodProfiler, false, flag, i, gen, env, executor); // Paper pass executor
          this.pvpMode = minecraftserver.getPVP();
          convertable = convertable_conversionsession;
          uuid = WorldUUID.getUUID(convertable_conversionsession.folder.toFile());

Spigot-Server-Patches/Asynchronous-chunk-IO-and-loading.patch

@@ -2954,7 +2954,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
 +++ b/src/main/java/net/minecraft/server/MinecraftServer.java
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends IAsyncTaskHandlerReentrant<TickTas
-             this.getUserCache().c(false); // Paper
+             this.getUserCache().b(false); // Paper
          }
          // Spigot end
 -
@@ -3527,8 +3527,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/RegionFile.java
 +++ b/src/main/java/net/minecraft/server/RegionFile.java
 @@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable {
-     private final RegionFileBitSet freeSectors;
+     protected final RegionFileBitSet freeSectors;
-     public final File file;
+     public final File file; // Paper
  
 +    public final java.util.concurrent.locks.ReentrantLock fileLock = new java.util.concurrent.locks.ReentrantLock(true); // Paper
 +
@@ -3991,8 +3991,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    // Paper end
 +
      // Add env and gen to constructor, WorldData -> WorldDataServer
-     public WorldServer(MinecraftServer minecraftserver, Executor executor, Convertable.ConversionSession convertable_conversionsession, IWorldDataServer iworlddataserver, ResourceKey<World> resourcekey, ResourceKey<DimensionManager> resourcekey1, DimensionManager dimensionmanager, WorldLoadListener worldloadlistener, ChunkGenerator chunkgenerator, boolean flag, long i, List<MobSpawner> list, boolean flag1, org.bukkit.World.Environment env, org.bukkit.generator.ChunkGenerator gen) {
+     public WorldServer(MinecraftServer minecraftserver, Executor executor, Convertable.ConversionSession convertable_conversionsession, IWorldDataServer iworlddataserver, ResourceKey<World> resourcekey, DimensionManager dimensionmanager, WorldLoadListener worldloadlistener, ChunkGenerator chunkgenerator, boolean flag, long i, List<MobSpawner> list, boolean flag1, org.bukkit.World.Environment env, org.bukkit.generator.ChunkGenerator gen) {
-         super(iworlddataserver, resourcekey, resourcekey1, dimensionmanager, minecraftserver::getMethodProfiler, false, flag, i, gen, env, executor); // Paper pass executor
+         super(iworlddataserver, resourcekey, dimensionmanager, minecraftserver::getMethodProfiler, false, flag, i, gen, env, executor); // Paper pass executor
 @@ -0,0 +0,0 @@ public class WorldServer extends World implements GeneratorAccessSeed {
              this.dragonBattle = null;
          }
@@ -4018,9 +4018,9 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/jav
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -0,0 +0,0 @@ import net.minecraft.server.GroupDataEntity;
+@@ -0,0 +0,0 @@ import net.minecraft.server.IBlockData;
- import net.minecraft.server.IBlockData;
  import net.minecraft.server.IChunkAccess;
+ import net.minecraft.server.IRegistry;
  import net.minecraft.server.MinecraftKey;
 +import net.minecraft.server.MinecraftServer;
  import net.minecraft.server.MovingObjectPosition;

Spigot-Server-Patches/Avoid-blocking-on-Network-Manager-creation.patch

@@ -26,13 +26,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public ServerConnection(MinecraftServer minecraftserver) {
          this.e = minecraftserver;
 @@ -0,0 +0,0 @@ public class ServerConnection {
-                     channel.pipeline().addLast("timeout", new ReadTimeoutHandler(30)).addLast("legacy_query", new LegacyPingHandler(ServerConnection.this)).addLast("splitter", new PacketSplitter()).addLast("decoder", new PacketDecoder(EnumProtocolDirection.SERVERBOUND)).addLast("prepender", new PacketPrepender()).addLast("encoder", new PacketEncoder(EnumProtocolDirection.CLIENTBOUND));
+                     int j = ServerConnection.this.e.k();
-                     NetworkManager networkmanager = new NetworkManager(EnumProtocolDirection.SERVERBOUND);
+                     Object object = j > 0 ? new NetworkManagerServer(j) : new NetworkManager(EnumProtocolDirection.SERVERBOUND);
  
--                    ServerConnection.this.connectedChannels.add(networkmanager);
+-                    ServerConnection.this.connectedChannels.add((NetworkManager) object); // CraftBukkit - decompile error
-+                    pending.add(networkmanager); // Paper
++                    //ServerConnection.this.connectedChannels.add((NetworkManager) object); // CraftBukkit - decompile error
-                     channel.pipeline().addLast("packet_handler", networkmanager);
++                    pending.add((NetworkManager) object); // Paper
-                     networkmanager.setPacketListener(new HandshakeListener(ServerConnection.this.e, networkmanager));
+                     channel.pipeline().addLast("packet_handler", (ChannelHandler) object);
+                     ((NetworkManager) object).setPacketListener(new HandshakeListener(ServerConnection.this.e, (NetworkManager) object));
                  }
 @@ -0,0 +0,0 @@ public class ServerConnection {
  

Spigot-Server-Patches/Basic-PlayerProfile-API.patch

@@ -433,6 +433,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import com.destroystokyo.paper.profile.CraftPlayerProfile;
 +import com.destroystokyo.paper.profile.PlayerProfile;
  import com.google.common.util.concurrent.ThreadFactoryBuilder;
+ import it.unimi.dsi.fastutil.objects.ObjectRBTreeSet;
  import org.apache.commons.lang.exception.ExceptionUtils;
 +import com.mojang.authlib.GameProfile;
  import org.bukkit.Location;
@@ -468,23 +469,23 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/net/minecraft/server/UserCache.java
 @@ -0,0 +0,0 @@ public class UserCache {
  
-     public static final SimpleDateFormat a = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z");
+     private static final Logger LOGGER = LogManager.getLogger();
-     private static boolean c;
+     private static boolean b;
--    private final Map<String, UserCache.UserCacheEntry> d = new java.util.concurrent.ConcurrentHashMap<>(); // Paper
+-    private final Map<String, UserCache.UserCacheEntry> c = Maps.newConcurrentMap();
-+    private final Map<String, UserCache.UserCacheEntry> d = new java.util.concurrent.ConcurrentHashMap<>();private final Map<String, UserCache.UserCacheEntry> nameCache = d; // Paper - OBFHELPER // Paper
++    private final Map<String, UserCache.UserCacheEntry> c = Maps.newConcurrentMap();private final Map<String, UserCache.UserCacheEntry> nameCache = c; // Paper - OBFHELPER // Paper
-     private final Map<UUID, UserCache.UserCacheEntry> e = new java.util.concurrent.ConcurrentHashMap<>(); // Paper
+     private final Map<UUID, UserCache.UserCacheEntry> d = Maps.newConcurrentMap();
-     private final Deque<GameProfile> f = new java.util.concurrent.LinkedBlockingDeque<GameProfile>(); // CraftBukkit
+     private final GameProfileRepository e;
-     private final GameProfileRepository g;
+     private final Gson f = (new GsonBuilder()).create();
 @@ -0,0 +0,0 @@ public class UserCache {
-         return UserCache.c;
+         return UserCache.b;
      }
  
 +    public void saveProfile(GameProfile gameprofile) { a(gameprofile); } // Paper - OBFHELPER
-     public void a(GameProfile gameprofile) {
+     public synchronized void a(GameProfile gameprofile) { // Paper - synchronize
-         this.a(gameprofile, (Date) null);
+         Calendar calendar = Calendar.getInstance();
-     }
+ 
 @@ -0,0 +0,0 @@ public class UserCache {
-         return usercache_usercacheentry == null ? null : usercache_usercacheentry.a();
+         return gameprofile;
      }
  
 +    // Paper start
@@ -496,16 +497,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
      @Nullable
      public GameProfile getProfile(UUID uuid) {
-         UserCache.UserCacheEntry usercache_usercacheentry = (UserCache.UserCacheEntry) this.e.get(uuid);
+         UserCache.UserCacheEntry usercache_usercacheentry = (UserCache.UserCacheEntry) this.d.get(uuid);
 @@ -0,0 +0,0 @@ public class UserCache {
  
-     class UserCacheEntry {
+     static class UserCacheEntry {
  
--        private final GameProfile b;
+-        private final GameProfile a;
-+        private final GameProfile b;public GameProfile getProfile() { return b; } // Paper - OBFHELPER
++        private final GameProfile a;public GameProfile getProfile() { return a; } // Paper - OBFHELPER
-         private final Date c;
+         private final Date b;
+         private volatile long c;
  
-         private UserCacheEntry(GameProfile gameprofile, Date date) {
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java

Spigot-Server-Patches/Cache-user-authenticator-threads.patch

@@ -17,7 +17,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import java.util.Deque; // Paper
  import java.util.Iterator;
  import java.util.List;
- import java.util.OptionalInt;
+ import java.util.Optional;
 @@ -0,0 +0,0 @@ public class EntityPlayer extends EntityHuman implements ICrafting {
      public PlayerConnection playerConnection;
      public final MinecraftServer server;
@@ -58,11 +58,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        // Paper start - Optimize remove queue - vanilla copies player objects, but CB doesn't. This method currently only
 +        // Applies to the same player, so we need to not duplicate our removal queue. The rest of this method does "resetting"
 +        // type logic so it does need to be called, maybe? This is silly.
-+        //this.removeQueue.addAll(entityplayer.removeQueue);
++        // this.removeQueue.addAll(entityplayer.removeQueue);
 +        if (this.removeQueue != entityplayer.removeQueue) {
 +            this.removeQueue.addAll(entityplayer.removeQueue);
 +        }
 +        // Paper end
-         this.ck = entityplayer.ck;
+         this.cd = entityplayer.cd;
-         this.cp = entityplayer.cp;
+         this.ci = entityplayer.ci;
          this.setShoulderEntityLeft(entityplayer.getShoulderEntityLeft());

Spigot-Server-Patches/Catch-exceptions-from-dispenser-entity-spawns.patch

@@ -16,7 +16,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  entitytypes.spawnCreature(isourceblock.getWorld(), itemstack, (EntityHuman) null, isourceblock.getBlockPosition().shift(enumdirection), EnumMobSpawn.DISPENSER, enumdirection != EnumDirection.UP, false);
 +                    // Paper start
 +                } catch (Exception ex){
-+                    MinecraftServer.LOGGER.warn("An exception occurred dispensing entity at {}[{}]", world.getWorld().getName(), isourceblock.getBlockPosition(), ex);
++                    MinecraftServer.LOGGER.warn("An exception occurred dispensing entity at {}[{}]", worldserver.getWorld().getName(), isourceblock.getBlockPosition(), ex);
 +                }
 +                // Paper end
 +

Spigot-Server-Patches/Check-Drowned-for-Villager-Aggression-Config.patch

@@ -11,9 +11,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class EntityDrowned extends EntityZombie implements IRangedEntity {
          this.goalSelector.a(7, new PathfinderGoalRandomStroll(this, 1.0D));
          this.targetSelector.a(1, (new PathfinderGoalHurtByTarget(this, new Class[]{EntityDrowned.class})).a(EntityPigZombie.class));
-         this.targetSelector.a(2, new PathfinderGoalNearestAttackableTarget<>(this, EntityHuman.class, 10, true, false, this::j));
+         this.targetSelector.a(2, new PathfinderGoalNearestAttackableTarget<>(this, EntityHuman.class, 10, true, false, this::i));
 -        this.targetSelector.a(3, new PathfinderGoalNearestAttackableTarget<>(this, EntityVillagerAbstract.class, false));
 +        if ( world.spigotConfig.zombieAggressiveTowardsVillager ) this.targetSelector.a(3, new PathfinderGoalNearestAttackableTarget<>(this, EntityVillagerAbstract.class, false)); // Paper
          this.targetSelector.a(3, new PathfinderGoalNearestAttackableTarget<>(this, EntityIronGolem.class, true));
-         this.targetSelector.a(5, new PathfinderGoalNearestAttackableTarget<>(this, EntityTurtle.class, 10, true, false, EntityTurtle.bv));
+         this.targetSelector.a(5, new PathfinderGoalNearestAttackableTarget<>(this, EntityTurtle.class, 10, true, false, EntityTurtle.bo));
      }

Spigot-Server-Patches/Chunk-debug-command.patch

@@ -201,9 +201,9 @@ diff --git a/src/main/java/net/minecraft/server/MCUtil.java b/src/main/java/net/
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/MCUtil.java
 +++ b/src/main/java/net/minecraft/server/MCUtil.java
-@@ -0,0 +0,0 @@ import com.destroystokyo.paper.profile.CraftPlayerProfile;
+@@ -0,0 +0,0 @@ import com.destroystokyo.paper.profile.PlayerProfile;
- import com.destroystokyo.paper.profile.PlayerProfile;
  import com.google.common.util.concurrent.ThreadFactoryBuilder;
+ import it.unimi.dsi.fastutil.objects.ObjectRBTreeSet;
  import org.apache.commons.lang.exception.ExceptionUtils;
 +import com.google.gson.JsonArray;
 +import com.google.gson.JsonObject;
@@ -408,8 +408,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      private int n;
 -    private final ChunkCoordIntPair location;
 +    final ChunkCoordIntPair location; // Paper - private -> package
-     private final short[] dirtyBlocks;
+     private boolean p;
-     private int dirtyCount;
+     private final ShortSet[] dirtyBlocks;
      private int r;
 diff --git a/src/main/java/net/minecraft/server/PlayerChunkMap.java b/src/main/java/net/minecraft/server/PlayerChunkMap.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644

Spigot-Server-Patches/ChunkMapDistance-CME.patch

@@ -60,6 +60,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              return true;
          } else {
              if (!this.l.isEmpty()) {
+@@ -0,0 +0,0 @@ public abstract class ChunkMapDistance {
+             ObjectIterator objectiterator = this.a.long2ByteEntrySet().iterator();
+ 
+             while (objectiterator.hasNext()) {
+-                it.unimi.dsi.fastutil.longs.Long2ByteMap.Entry it_unimi_dsi_fastutil_longs_long2bytemap_entry = (it.unimi.dsi.fastutil.longs.Long2ByteMap.Entry) objectiterator.next();
++                Long2ByteMap.Entry it_unimi_dsi_fastutil_longs_long2bytemap_entry = (Long2ByteMap.Entry) objectiterator.next(); // Paper - decompile fix
+                 byte b0 = it_unimi_dsi_fastutil_longs_long2bytemap_entry.getByteValue();
+                 long j = it_unimi_dsi_fastutil_longs_long2bytemap_entry.getLongKey();
+ 
 diff --git a/src/main/java/net/minecraft/server/PlayerChunk.java b/src/main/java/net/minecraft/server/PlayerChunk.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/PlayerChunk.java

Spigot-Server-Patches/Configurable-Bed-Search-Radius.patch

@@ -1,159 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Wed, 4 Jul 2018 15:22:06 -0400
-Subject: [PATCH] Configurable Bed Search Radius
-
-Allows you to increase how far to check for a safe place to respawn
-a player near their bed, allowing a better chance to respawn the
-player at their bed should it of became obstructed.
-
-Defaults to vanilla 1.
-
-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 {
-     private void scanForLegacyEnderDragon() {
-         scanForLegacyEnderDragon = getBoolean("game-mechanics.scan-for-legacy-ender-dragon", true);
-     }
-+
-+    public int bedSearchRadius = 1;
-+    private void bedSearchRadius() {
-+        bedSearchRadius = getInt("bed-search-radius", 1);
-+        if (bedSearchRadius < 1) {
-+            bedSearchRadius = 1;
-+        }
-+        if (bedSearchRadius > 1) {
-+            log("Bed Search Radius: " + bedSearchRadius);
-+        }
-+    }
- }
-diff --git a/src/main/java/net/minecraft/server/BlockBed.java b/src/main/java/net/minecraft/server/BlockBed.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/BlockBed.java
-+++ b/src/main/java/net/minecraft/server/BlockBed.java
-@@ -0,0 +0,0 @@ public class BlockBed extends BlockFacingHorizontal implements ITileEntity {
- 
-     public static Optional<Vec3D> a(EntityTypes<?> entitytypes, IWorldReader iworldreader, BlockPosition blockposition, int i) {
-         EnumDirection enumdirection = (EnumDirection) iworldreader.getType(blockposition).get(BlockBed.FACING);
-+        // Paper start - configurable bed search radius
-+        if (entitytypes == EntityTypes.PLAYER) return findSafePosition(entitytypes, (World) iworldreader, enumdirection, blockposition);
-         int j = blockposition.getX();
-         int k = blockposition.getY();
-         int l = blockposition.getZ();
-@@ -0,0 +0,0 @@ public class BlockBed extends BlockFacingHorizontal implements ITileEntity {
-         return Optional.empty();
-     }
- 
--    public static Optional<Vec3D> a(EntityTypes<?> entitytypes, IWorldReader iworldreader, BlockPosition blockposition) {
-+    private static Optional<Vec3D> findSafePosition(EntityTypes<?> entitytypes, World world, EnumDirection updirection, BlockPosition blockposition){
-+        int radius = world.paperConfig.bedSearchRadius;
-+        double angle = Math.PI / 2;
-+        int tmpX = (int)(updirection.getAdjacentX() * Math.cos(angle) - updirection.getAdjacentZ() * Math.sin(angle));
-+        int tmpZ = (int)(updirection.getAdjacentX() * Math.sin(angle) + updirection.getAdjacentZ() * Math.cos(angle));
-+
-+        EnumDirection rightDirection = EnumDirection.a(tmpX, 0, tmpZ);
-+        EnumDirection downDirection = updirection.opposite();
-+        EnumDirection leftDirection = rightDirection.opposite();
-+
-+        EnumDirection[] corePositionOutDirection = new EnumDirection[6];
-+        corePositionOutDirection[0] = updirection;
-+        corePositionOutDirection[1] = leftDirection;
-+        corePositionOutDirection[2] = leftDirection;
-+        corePositionOutDirection[3] = downDirection;
-+        corePositionOutDirection[4] = rightDirection;
-+        corePositionOutDirection[5] = rightDirection;
-+
-+        BlockPosition[] corePosition = new BlockPosition[6];
-+        corePosition[0] = blockposition.add(updirection.getAdjacentX(), 0, updirection.getAdjacentZ());
-+        corePosition[1] = blockposition.add(leftDirection.getAdjacentX(), 0, leftDirection.getAdjacentZ());
-+        corePosition[2] = corePosition[1].add(downDirection.getAdjacentX(), 0, downDirection.getAdjacentZ());
-+        corePosition[3] = blockposition.add(2 * downDirection.getAdjacentX(), 0, 2 * downDirection.getAdjacentZ());
-+        corePosition[5] = blockposition.add(rightDirection.getAdjacentX(), 0, rightDirection.getAdjacentZ());
-+        corePosition[4] = corePosition[5].add(downDirection.getAdjacentX(), 0, downDirection.getAdjacentZ());
-+
-+        BlockPosition[] tmpPosition = new BlockPosition[8];
-+        EnumDirection[] tmpPositionDirection = new EnumDirection[8];
-+        tmpPositionDirection[0] = rightDirection;
-+        tmpPositionDirection[1] = leftDirection;
-+        tmpPositionDirection[2] = updirection;
-+        tmpPositionDirection[3] = downDirection;
-+        tmpPositionDirection[4] = leftDirection;
-+        tmpPositionDirection[5] = rightDirection;
-+        tmpPositionDirection[6] = downDirection;
-+        tmpPositionDirection[7] = updirection;
-+
-+        BlockPosition pos;
-+        Optional<Vec3D> vector;
-+        for (int r = 1; r <= radius; r++) {
-+            int h = 0;
-+            while (h <= 1) {
-+                int numIterated = 0;
-+                for (int index = (int)(Math.random() * corePosition.length); numIterated < corePosition.length; index = (index+1) % corePosition.length) {
-+                    numIterated++;
-+
-+                    pos = corePosition[index].add(0, h, 0);
-+                    vector = isSafeRespawn(entitytypes, world, pos, 0);
-+                    if (vector.isPresent()) {
-+                        return vector;
-+                    }
-+                }
-+                tmpPosition[0] = corePosition[0].add(0, h, 0);
-+                tmpPosition[1] = corePosition[0].add(0, h, 0);
-+                tmpPosition[2] = corePosition[1].add(0, h, 0);
-+                tmpPosition[3] = corePosition[2].add(0, h, 0);
-+                tmpPosition[4] = corePosition[3].add(0, h, 0);
-+                tmpPosition[5] = corePosition[3].add(0, h, 0);
-+                tmpPosition[6] = corePosition[4].add(0, h, 0);
-+                tmpPosition[7] = corePosition[5].add(0, h, 0);
-+                for (int rr = 1; rr <= r; rr++){
-+                    numIterated = 0;
-+                    for (int index = (int)(Math.random() * tmpPosition.length); numIterated < tmpPosition.length; index = (index+1) % tmpPosition.length) {
-+                        numIterated++;
-+                        tmpPosition[index] = tmpPosition[index].add(tmpPositionDirection[index].getAdjacentX(), 0, tmpPositionDirection[index].getAdjacentZ());
-+                        pos = tmpPosition[index];
-+
-+                        vector = isSafeRespawn(entitytypes, world, pos, 0);
-+                        if (vector.isPresent()) {
-+                            return vector;
-+                        }
-+                    }
-+                }
-+                switch (h) {
-+                    case 0:
-+                        h = -1;
-+                        break;
-+                    case -1:
-+                        h = -2;
-+                        break;
-+                    case -2:
-+                        h = Integer.MAX_VALUE;
-+                        break;
-+                }
-+            }
-+            for (int index = 0; index < corePosition.length; index++) {
-+                EnumDirection tmp = corePositionOutDirection[index];
-+                corePosition[index] = corePosition[index].add(tmp.getAdjacentX(), 0, tmp.getAdjacentZ());
-+            }
-+        }
-+        return Optional.empty();
-+    }
-+    // Paper end
-+
-+    // Paper start -- add maxBelow param
-+    public static Optional<Vec3D> a(EntityTypes<?> entitytypes, IWorldReader iworldreader, BlockPosition blockposition)  { return isSafeRespawn(entitytypes, iworldreader, blockposition, 2); }
-+    public static Optional<Vec3D> isSafeRespawn(EntityTypes<?> entitytypes, IWorldReader iworldreader, BlockPosition blockposition, int maxBelow) {
-+    // Paper end
-         VoxelShape voxelshape = iworldreader.getType(blockposition).getCollisionShape(iworldreader, blockposition);
- 
-         if (voxelshape.c(EnumDirection.EnumAxis.Y) > 0.4375D) {
-@@ -0,0 +0,0 @@ public class BlockBed extends BlockFacingHorizontal implements ITileEntity {
-         } else {
-             BlockPosition.MutableBlockPosition blockposition_mutableblockposition = blockposition.i();
- 
--            while (blockposition_mutableblockposition.getY() >= 0 && blockposition.getY() - blockposition_mutableblockposition.getY() <= 2 && iworldreader.getType(blockposition_mutableblockposition).getCollisionShape(iworldreader, blockposition_mutableblockposition).isEmpty()) {
-+            while (blockposition_mutableblockposition.getY() >= 0 && blockposition.getY() - blockposition_mutableblockposition.getY() <= maxBelow && iworldreader.getType(blockposition_mutableblockposition).getCollisionShape(iworldreader, blockposition_mutableblockposition).isEmpty()) { // Paper -- configurable max distance to search below
-                 blockposition_mutableblockposition.c(EnumDirection.DOWN);
-             }
- 

Spigot-Server-Patches/Configurable-Cartographer-Treasure-Maps.patch

@@ -33,7 +33,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/net/minecraft/server/LootItemFunctionExplorationMap.java
 @@ -0,0 +0,0 @@ public class LootItemFunctionExplorationMap extends LootItemFunctionConditional
  
-             if (blockposition != null) {
+             if (vec3d != null) {
                  WorldServer worldserver = loottableinfo.getWorld();
 +                // Paper start
 +                if (!worldserver.paperConfig.enableTreasureMaps) {
@@ -44,9 +44,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                    return itemstack;
 +                }
 +                // Paper end
-                 BlockPosition blockposition1 = worldserver.a(this.e, blockposition, this.h, this.i);
+                 BlockPosition blockposition = worldserver.a(this.e, new BlockPosition(vec3d), this.h, this.i);
  
-                 if (blockposition1 != null) {
+                 if (blockposition != null) {
 diff --git a/src/main/java/net/minecraft/server/VillagerTrades.java b/src/main/java/net/minecraft/server/VillagerTrades.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/VillagerTrades.java

Spigot-Server-Patches/Configurable-Keep-Spawn-Loaded-range-per-world.patch

@@ -106,7 +106,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/WorldServer.java
 +++ b/src/main/java/net/minecraft/server/WorldServer.java
 @@ -0,0 +0,0 @@ public class WorldServer extends World implements GeneratorAccessSeed {
-         return ((PersistentIdCounts) this.getMinecraftServer().D().getWorldPersistentData().a(PersistentIdCounts::new, "idcounts")).a();
+         return ((PersistentIdCounts) this.getMinecraftServer().E().getWorldPersistentData().a(PersistentIdCounts::new, "idcounts")).a();
      }
  
 +    // Paper start - helper function for configurable spawn radius
@@ -180,13 +180,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +    // Paper end
 +
-     public void a_(BlockPosition blockposition) {
+     public void a(BlockPosition blockposition, float f) {
 -        ChunkCoordIntPair chunkcoordintpair = new ChunkCoordIntPair(new BlockPosition(this.worldData.a(), 0, this.worldData.c()));
 +        // Paper - configurable spawn radius
 +        BlockPosition prevSpawn = this.getSpawn();
 +        //ChunkCoordIntPair chunkcoordintpair = new ChunkCoordIntPair(new BlockPosition(this.worldData.a(), 0, this.worldData.c()));
  
-         this.worldData.setSpawn(blockposition);
+         this.worldData.setSpawn(blockposition, f);
 -        this.getChunkProvider().removeTicket(TicketType.START, chunkcoordintpair, 11, Unit.INSTANCE);
 -        this.getChunkProvider().addTicket(TicketType.START, new ChunkCoordIntPair(blockposition), 11, Unit.INSTANCE);
 +        if (this.keepSpawnInMemory) {
@@ -194,7 +194,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            this.removeTicketsForSpawn(this.paperConfig.keepLoadedRange, prevSpawn);
 +            this.addTicketsForSpawn(this.paperConfig.keepLoadedRange, blockposition);
 +        }
-         this.getMinecraftServer().getPlayerList().sendAll(new PacketPlayOutSpawnPosition(blockposition));
+         this.getMinecraftServer().getPlayerList().sendAll(new PacketPlayOutSpawnPosition(blockposition, f));
      }
  
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java

Spigot-Server-Patches/Configurable-RCON-IP-address.patch

@@ -16,19 +16,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    public final String rconIp; // Paper - Add rcon ip
 +
      // CraftBukkit start
-     public DedicatedServerProperties(Properties properties, OptionSet optionset) {
+     public DedicatedServerProperties(Properties properties, IRegistryCustom iregistrycustom, OptionSet optionset) {
          super(properties, optionset);
 @@ -0,0 +0,0 @@ public class DedicatedServerProperties extends PropertyManager<DedicatedServerPr
+         }, 100);
          this.playerIdleTimeout = this.b("player-idle-timeout", 0);
          this.whiteList = this.b("white-list", false);
-         this.generatorSettings = GeneratorSettings.a(properties);
 +        // Paper start - Configurable rcon ip
 +        final String rconIp = this.getSettingIfExists("rcon.ip");
 +        this.rconIp = rconIp == null ? this.serverIp : rconIp;
 +        // Paper end
+         this.generatorSettings = GeneratorSettings.a(iregistrycustom, properties);
      }
  
-     // CraftBukkit start
 diff --git a/src/main/java/net/minecraft/server/PropertyManager.java b/src/main/java/net/minecraft/server/PropertyManager.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/PropertyManager.java
@@ -49,11 +49,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/RemoteControlListener.java
 +++ b/src/main/java/net/minecraft/server/RemoteControlListener.java
 @@ -0,0 +0,0 @@ public class RemoteControlListener extends RemoteConnectionThread {
+     @Nullable
+     public static RemoteControlListener a(IMinecraftServer iminecraftserver) {
+         DedicatedServerProperties dedicatedserverproperties = iminecraftserver.getDedicatedServerProperties();
+-        String s = iminecraftserver.h_();
++        String s = dedicatedserverproperties.rconIp; // Paper - Configurable rcon ip
  
-         this.e = dedicatedserverproperties.rconPort;
+         if (s.isEmpty()) {
-         this.h = dedicatedserverproperties.rconPassword;
+             s = "0.0.0.0";
--        this.f = iminecraftserver.h_();
-+        this.f = dedicatedserverproperties.rconIp; // Paper - Configurable rcon ip
-         if (this.f.isEmpty()) {
-             this.f = "0.0.0.0";
-         }

Spigot-Server-Patches/Configurable-baby-zombie-movement-speed.patch

@@ -35,7 +35,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -    private static final AttributeModifier c = new AttributeModifier(EntityZombie.b, "Baby speed boost", 0.5D, AttributeModifier.Operation.MULTIPLY_BASE);
 +    private final AttributeModifier c = new AttributeModifier(EntityZombie.b, "Baby speed boost", 0.5D, AttributeModifier.Operation.MULTIPLY_BASE); private final AttributeModifier babyModifier = this.c; // Paper - remove static - Make baby speed configurable
      private static final DataWatcherObject<Boolean> d = DataWatcher.a(EntityZombie.class, DataWatcherRegistry.i);
-     private static final DataWatcherObject<Integer> bv = DataWatcher.a(EntityZombie.class, DataWatcherRegistry.b);
+     private static final DataWatcherObject<Integer> bo = DataWatcher.a(EntityZombie.class, DataWatcherRegistry.b);
      public static final DataWatcherObject<Boolean> DROWN_CONVERTING = DataWatcher.a(EntityZombie.class, DataWatcherRegistry.i);
 @@ -0,0 +0,0 @@ public class EntityZombie extends EntityMonster {
          if (this.world != null && !this.world.isClientSide) {

Spigot-Server-Patches/Configurable-chance-of-villager-zombie-infection.patch

@@ -27,13 +27,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/net/minecraft/server/EntityZombie.java
 @@ -0,0 +0,0 @@ public class EntityZombie extends EntityMonster {
      @Override
-     public void a_(EntityLiving entityliving) {
+     public void a(WorldServer worldserver, EntityLiving entityliving) {
-         super.a_(entityliving);
+         super.a(worldserver, entityliving);
--        if ((this.world.getDifficulty() == EnumDifficulty.NORMAL || this.world.getDifficulty() == EnumDifficulty.HARD) && entityliving instanceof EntityVillager) {
+-        if ((worldserver.getDifficulty() == EnumDifficulty.NORMAL || worldserver.getDifficulty() == EnumDifficulty.HARD) && entityliving instanceof EntityVillager) {
--            if (this.world.getDifficulty() != EnumDifficulty.HARD && this.random.nextBoolean()) {
+-            if (worldserver.getDifficulty() != EnumDifficulty.HARD && this.random.nextBoolean()) {
 +        // Paper start
-+        if (world.paperConfig.zombieVillagerInfectionChance != 0.0 && (world.paperConfig.zombieVillagerInfectionChance != -1.0 || this.world.getDifficulty() == EnumDifficulty.NORMAL || this.world.getDifficulty() == EnumDifficulty.HARD) && entityliving instanceof EntityVillager) {
++        if (world.paperConfig.zombieVillagerInfectionChance != 0.0 && (world.paperConfig.zombieVillagerInfectionChance != -1.0 || worldserver.getDifficulty() == EnumDifficulty.NORMAL || worldserver.getDifficulty() == EnumDifficulty.HARD) && entityliving instanceof EntityVillager) {
-+            if (world.paperConfig.zombieVillagerInfectionChance == -1.0 && this.world.getDifficulty() != EnumDifficulty.HARD && this.random.nextBoolean()) {
++            if (world.paperConfig.zombieVillagerInfectionChance == -1.0 && worldserver.getDifficulty() != EnumDifficulty.HARD && this.random.nextBoolean()) {
                  return;
              }
 +            if (world.paperConfig.zombieVillagerInfectionChance != -1.0 && (this.random.nextDouble() * 100.0) > world.paperConfig.zombieVillagerInfectionChance) {
@@ -41,4 +41,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            } // Paper end
  
              EntityVillager entityvillager = (EntityVillager) entityliving;
-             EntityZombieVillager entityzombievillager = (EntityZombieVillager) EntityTypes.ZOMBIE_VILLAGER.a(this.world);
+             // CraftBukkit start

Spigot-Server-Patches/Configurable-end-credits.patch

@@ -24,19 +24,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/EntityPlayer.java
 +++ b/src/main/java/net/minecraft/server/EntityPlayer.java
 @@ -0,0 +0,0 @@ public class EntityPlayer extends EntityHuman implements ICrafting {
-     private long ch = SystemUtils.getMonotonicMillis();
+     private long ca = SystemUtils.getMonotonicMillis();
      private Entity spectatedEntity;
      public boolean worldChangeInvuln;
--    private boolean ck;
+-    private boolean cd;
-+    private boolean ck; private void setHasSeenCredits(boolean has) { this.ck = has; } // Paper - OBFHELPER
++    private boolean cd; private void setHasSeenCredits(boolean has) { this.cd = has; } // Paper - OBFHELPER
      private final RecipeBookServer recipeBook = new RecipeBookServer();
-     private Vec3D cm;
+     private Vec3D cf;
-     private int cn;
+     private int cg;
 @@ -0,0 +0,0 @@ public class EntityPlayer extends EntityHuman implements ICrafting {
+             this.decouple();
              this.getWorldServer().removePlayer(this);
              if (!this.viewingCredits) {
-                 this.viewingCredits = true;
 +                if (world.paperConfig.disableEndCredits) this.setHasSeenCredits(true); // Paper - Toggle to always disable end credits
-                 this.playerConnection.sendPacket(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.e, this.ck ? 0.0F : 1.0F));
+                 this.viewingCredits = true;
-                 this.ck = true;
+                 this.playerConnection.sendPacket(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.e, this.cd ? 0.0F : 1.0F));
-             }
+                 this.cd = true;

Spigot-Server-Patches/Configurable-fishing-time-ranges.patch

@@ -26,13 +26,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/EntityFishingHook.java
 +++ b/src/main/java/net/minecraft/server/EntityFishingHook.java
 @@ -0,0 +0,0 @@ public class EntityFishingHook extends IProjectile {
-                     this.ap = MathHelper.nextInt(this.random, 20, 80);
+                     this.ai = MathHelper.nextInt(this.random, 20, 80);
                  }
              } else {
--                this.ao = MathHelper.nextInt(this.random, 100, 600);
+-                this.ah = MathHelper.nextInt(this.random, 100, 600);
-+                this.ao = MathHelper.nextInt(this.random, world.paperConfig.fishingMinTicks, world.paperConfig.fishingMaxTicks); // Paper
++                this.ah = MathHelper.nextInt(this.random, world.paperConfig.fishingMinTicks, world.paperConfig.fishingMaxTicks); // Paper
-                 this.ao -= this.av * 20 * 5;
+                 this.ah -= this.ao * 20 * 5;
-+                this.ao = Math.max(0, this.ao); // Paper - Don't allow negative values;
              }
          }
- 

Spigot-Server-Patches/Configurable-top-of-nether-void-damage.patch

@@ -41,7 +41,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        // Extracted to own function
 +        /*
          if (this.locY() < -64.0D) {
-             this.ai();
+             this.am();
          }
 +        */
 +        this.performVoidDamage();
@@ -50,7 +50,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (!this.world.isClientSide) {
              this.setFlag(0, this.fireTicks > 0);
 @@ -0,0 +0,0 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, Ke
-         this.world.getMethodProfiler().exit();
+         this.setFireTicks(0);
      }
  
 +    // Paper start
@@ -58,21 +58,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        if (this.locY() < -64.0D || (this.world.getWorld().getEnvironment() == org.bukkit.World.Environment.NETHER
 +            && world.paperConfig.doNetherTopVoidDamage()
 +            && this.locY() >= world.paperConfig.netherVoidTopDamageHeight)) {
-+
 +            this.doVoidDamage();
 +        }
 +    }
 +    // Paper end
-+
++    protected final void doVoidDamage() { this.am(); } // Paper - OBFHELPER
-     protected void E() {
+     protected void am() {
-         if (this.portalCooldown > 0) {
-             --this.portalCooldown;
-@@ -0,0 +0,0 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, Ke
-         this.setFireTicks(0);
-     }
- 
-+    protected final void doVoidDamage() { this.ai(); } // Paper - OBFHELPER
-     protected void ai() {
          this.die();
      }
 diff --git a/src/main/java/net/minecraft/server/EntityMinecartAbstract.java b/src/main/java/net/minecraft/server/EntityMinecartAbstract.java
@@ -87,7 +78,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        // Extracted to own function
 +        /*
          if (this.locY() < -64.0D) {
-             this.ai();
+             this.am();
          }
 +        */
 +        this.performVoidDamage();

Spigot-Server-Patches/Custom-replacement-for-eaten-items.patch

@@ -21,17 +21,22 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
                      if (event.isCancelled()) {
 @@ -0,0 +0,0 @@ public abstract class EntityLiving extends Entity {
+                 } else {
                      itemstack = this.activeItem.a(this.world, this);
                  }
- 
++
 +                // Paper start - save the default replacement item and change it if necessary
 +                final ItemStack defaultReplacement = itemstack;
 +                if (event != null && event.getReplacement() != null) {
 +                    itemstack = CraftItemStack.asNMSCopy(event.getReplacement());
 +                }
 +                // Paper end
-                 this.a(this.getRaisedHand(), itemstack);
                  // CraftBukkit end
+ 
+                 if (itemstack != this.activeItem) {
+@@ -0,0 +0,0 @@ public abstract class EntityLiving extends Entity {
+                 }
+ 
                  this.clearActiveItem();
 +                // Paper start - if the replacement is anything but the default, update the client inventory
 +                if (this instanceof EntityPlayer && !com.google.common.base.Objects.equal(defaultReplacement, itemstack)) {

Spigot-Server-Patches/Disable-explosion-knockback.patch

@@ -64,6 +64,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 -                            if (!entityhuman.isSpectator() && (!entityhuman.isCreative() || !entityhuman.abilities.isFlying)) {
 +                            if (!entityhuman.isSpectator() && (!entityhuman.isCreative() || !entityhuman.abilities.isFlying) && !world.paperConfig.disableExplosionKnockback) { // Paper - Disable explosion knockback
-                                 this.m.put(entityhuman, new Vec3D(d8 * d13, d9 * d13, d10 * d13));
+                                 this.n.put(entityhuman, new Vec3D(d8 * d13, d9 * d13, d10 * d13));
                              }
                          }

Spigot-Server-Patches/Disable-thunder.patch

@@ -26,8 +26,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          gameprofilerfiller.enter("thunder");
          BlockPosition blockposition;
  
--        if (flag && this.T() && this.random.nextInt(100000) == 0) {
+-        if (flag && this.V() && this.random.nextInt(100000) == 0) {
-+        if (!this.paperConfig.disableThunder && flag && this.T() && this.random.nextInt(100000) == 0) { // Paper - Disable thunder
++        if (!this.paperConfig.disableThunder && flag && this.V() && this.random.nextInt(100000) == 0) { // Paper - Disable thunder
              blockposition = this.a(this.a(j, 0, k, 15));
              if (this.isRainingAt(blockposition)) {
                  DifficultyDamageScaler difficultydamagescaler = this.getDamageScaler(blockposition);

Spigot-Server-Patches/Do-less-work-if-we-have-a-custom-Bukkit-generator.patch

@@ -12,12 +12,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/net/minecraft/server/MinecraftServer.java
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends IAsyncTaskHandlerReentrant<TickTas
          } else if (flag1) {
-             iworlddataserver.setSpawn(BlockPosition.ZERO.up());
+             iworlddataserver.setSpawn(BlockPosition.ZERO.up(), 0.0F);
          } else {
 -            WorldChunkManager worldchunkmanager = chunkgenerator.getWorldChunkManager();
--            List<BiomeBase> list = worldchunkmanager.b();
 -            Random random = new Random(worldserver.getSeed());
--            BlockPosition blockposition = worldchunkmanager.a(0, worldserver.getSeaLevel(), 0, 256, list, random);
+-            BlockPosition blockposition = worldchunkmanager.a(0, worldserver.getSeaLevel(), 0, 256, (biomebase) -> {
+-                return biomebase.b().b();
+-            }, random);
 -            ChunkCoordIntPair chunkcoordintpair = blockposition == null ? new ChunkCoordIntPair(0, 0) : new ChunkCoordIntPair(blockposition);
 +            // Paper start - moved down
              // CraftBukkit start
@@ -30,9 +31,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            // Paper start - if the generator created a spawn for us, then there is no need for us to also create a spawn -
 +            // only do it if the generator did not
 +            WorldChunkManager worldchunkmanager = chunkgenerator.getWorldChunkManager();
-+            List<BiomeBase> list = worldchunkmanager.b();
 +            Random random = new Random(worldserver.getSeed());
-+            BlockPosition blockposition = worldchunkmanager.a(0, worldserver.getSeaLevel(), 0, 256, list, random);
++            BlockPosition blockposition = worldchunkmanager.a(0, worldserver.getSeaLevel(), 0, 256, (biomebase) -> {
++                return biomebase.b().b();
++            }, random);
 +            ChunkCoordIntPair chunkcoordintpair = blockposition == null ? new ChunkCoordIntPair(0, 0) : new ChunkCoordIntPair(blockposition);
 +            // Paper end
  

Spigot-Server-Patches/Do-not-allow-bees-to-load-chunks-for-beehives.patch

@@ -27,7 +27,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class EntityBee extends EntityAnimal implements IEntityAngerable, EntityB
          @Override
          public boolean g() {
-             if (EntityBee.this.hasHivePos() && EntityBee.this.fe() && EntityBee.this.hivePos.a((IPosition) EntityBee.this.getPositionVector(), 2.0D)) {
+             if (EntityBee.this.hasHivePos() && EntityBee.this.fd() && EntityBee.this.hivePos.a((IPosition) EntityBee.this.getPositionVector(), 2.0D)) {
 +                if (!EntityBee.this.world.isLoadedAndInBounds(EntityBee.this.hivePos)) return false; // Paper
                  TileEntity tileentity = EntityBee.this.world.getTileEntity(EntityBee.this.hivePos);
  

Spigot-Server-Patches/Do-not-load-chunks-for-Pathfinding.patch

@@ -49,8 +49,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                          if (iblockdata.a(Blocks.CACTUS)) {
                              return PathType.DANGER_CACTUS;
 @@ -0,0 +0,0 @@ public class PathfinderNormal extends PathfinderAbstract {
-                         if (fluid.a((Tag) TagsFluid.LAVA)) {
+                         if (iblockaccess.getFluid(blockposition_mutableblockposition).a((Tag) TagsFluid.WATER)) {
-                             return PathType.LAVA;
+                             return PathType.WATER_BORDER;
                          }
 +                        } // Paper
                      }

Spigot-Server-Patches/Don-t-change-the-Entity-Random-seed-for-squids.patch

@@ -14,6 +14,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          super(entitytypes, world);
 -        this.random.setSeed((long) this.getId());
 +        //this.random.setSeed((long) this.getId()); // Paper
-         this.bB = 1.0F / (this.random.nextFloat() + 1.0F) * 0.2F;
+         this.bu = 1.0F / (this.random.nextFloat() + 1.0F) * 0.2F;
      }
  

Spigot-Server-Patches/Don-t-check-ConvertSigns-boolean-every-sign-save.patch

@@ -11,7 +11,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/TileEntitySign.java
 +++ b/src/main/java/net/minecraft/server/TileEntitySign.java
 @@ -0,0 +0,0 @@ public class TileEntitySign extends TileEntity implements ICommandListener { //
-     private final IChatFormatted[] g;
+     private final FormattedString[] g;
      private EnumColor color;
      public java.util.UUID signEditor; // Paper
 +    private static final boolean CONVERT_LEGACY_SIGNS = Boolean.getBoolean("convertLegacySigns"); // Paper

Spigot-Server-Patches/Don-t-let-fishinghooks-use-portals.patch

@@ -4,19 +4,6 @@ Date: Fri, 16 Dec 2016 16:03:19 -0600
 Subject: [PATCH] Don't let fishinghooks use portals
 
 
-diff --git a/src/main/java/net/minecraft/server/Entity.java b/src/main/java/net/minecraft/server/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/Entity.java
-+++ b/src/main/java/net/minecraft/server/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, Ke
-     public boolean ac;
-     public boolean impulse;
-     public int portalCooldown;
--    protected boolean inPortal;
-+    protected boolean inPortal; public final boolean inPortal() { return this.inPortal; } // Paper - OBFHELPER
-     protected int portalTicks;
-     protected BlockPosition ah;
-     protected Vec3D ai;
 diff --git a/src/main/java/net/minecraft/server/EntityFishingHook.java b/src/main/java/net/minecraft/server/EntityFishingHook.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/EntityFishingHook.java
@@ -24,8 +11,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class EntityFishingHook extends IProjectile {
  
              this.setMot(this.getMot().a(0.92D));
-             this.ac();
+             this.ae();
-+
 +            // Paper start - These shouldn't be going through portals
 +            if (this.inPortal) {
 +                this.die();

Spigot-Server-Patches/Don-t-lookup-game-profiles-that-have-no-UUID-and-no-.patch

@@ -9,11 +9,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/UserCache.java
 +++ b/src/main/java/net/minecraft/server/UserCache.java
 @@ -0,0 +0,0 @@ public class UserCache {
-         };
- 
          gameprofilerepository.findProfilesByNames(new String[]{s}, Agent.MINECRAFT, profilelookupcallback);
--        if (!d() && agameprofile[0] == null) {
+         GameProfile gameprofile = (GameProfile) atomicreference.get();
-+        if (!d() && agameprofile[0] == null && !org.apache.commons.lang3.StringUtils.isBlank(s)) { // Paper - Don't lookup a profile with a blank name
-             UUID uuid = EntityHuman.a(new GameProfile((UUID) null, s));
-             GameProfile gameprofile = new GameProfile(uuid, s);
  
+-        if (!c() && gameprofile == null) {
++        if (!c() && gameprofile == null && !org.apache.commons.lang3.StringUtils.isBlank(s)) { // Paper - Don't lookup a profile with a blank name
+             UUID uuid = EntityHuman.a(new GameProfile((UUID) null, s));
+ 
+             gameprofile = new GameProfile(uuid, s);

Spigot-Server-Patches/Don-t-mark-null-chunk-sections-for-block-updates.patch

@@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mariell Hoversholm <proximyst@proximyst.com>
+Date: Fri, 14 Aug 2020 23:41:19 +0200
+Subject: [PATCH] Don't mark null chunk sections for block updates
+
+
+diff --git a/src/main/java/net/minecraft/server/PlayerChunk.java b/src/main/java/net/minecraft/server/PlayerChunk.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/server/PlayerChunk.java
++++ b/src/main/java/net/minecraft/server/PlayerChunk.java
+@@ -0,0 +0,0 @@ public class PlayerChunk {
+                         this.a(world, blockposition, iblockdata);
+                     } else {
+                         ChunkSection chunksection = chunk.getSections()[sectionposition.getY()];
++                        if (chunksection == null) chunksection = new ChunkSection(sectionposition.getY(), chunk, world, true); // Paper - make a new chunk section if none was found
+                         PacketPlayOutMultiBlockChange packetplayoutmultiblockchange = new PacketPlayOutMultiBlockChange(sectionposition, shortset, chunksection, this.x);
+ 
+                         this.a(packetplayoutmultiblockchange, false);

Spigot-Server-Patches/Don-t-move-existing-players-to-world-spawn.patch

@@ -17,8 +17,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          this.serverStatisticManager = minecraftserver.getPlayerList().getStatisticManager(this);
          this.advancementDataPlayer = minecraftserver.getPlayerList().f(this);
          this.G = 1.0F;
--        this.b(worldserver);
+-        this.c(worldserver);
-+        //this.b(worldserver); // Paper - don't move to spawn on login, only first join
++        //this.c(worldserver); // Paper - don't move to spawn on login, only first join
  
          this.cachedSingleHashSet = new com.destroystokyo.paper.util.misc.PooledLinkedHashSets.PooledObjectLinkedOpenHashSet<>(this); // Paper
  
@@ -26,8 +26,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
      // CraftBukkit end
  
-+    public final void moveToSpawn(WorldServer worldserver) { b(worldserver); } // Paper - OBFHELPER
++    public final void moveToSpawn(WorldServer worldserver) { c(worldserver); } // Paper - OBFHELPER
-     private void b(WorldServer worldserver) {
+     private void c(WorldServer worldserver) {
          BlockPosition blockposition = worldserver.getSpawn();
  
 @@ -0,0 +0,0 @@ public class EntityPlayer extends EntityHuman implements ICrafting {

Spigot-Server-Patches/Don-t-require-FACING-data.patch

@@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mariell Hoversholm <proximyst@proximyst.com>
+Date: Sun, 23 Aug 2020 19:01:04 +0200
+Subject: [PATCH] Don't require FACING data
+
+
+diff --git a/src/main/java/net/minecraft/server/DispenseBehaviorItem.java b/src/main/java/net/minecraft/server/DispenseBehaviorItem.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/net/minecraft/server/DispenseBehaviorItem.java
++++ b/src/main/java/net/minecraft/server/DispenseBehaviorItem.java
+@@ -0,0 +0,0 @@ import org.bukkit.event.block.BlockDispenseEvent;
+ // CraftBukkit end
+ 
+ public class DispenseBehaviorItem implements IDispenseBehavior {
++    private EnumDirection enumdirection; // Paper
+ 
+     public DispenseBehaviorItem() {}
+ 
+     @Override
+     public final ItemStack dispense(ISourceBlock isourceblock, ItemStack itemstack) {
++        enumdirection = isourceblock.getBlockData().get(BlockDispenser.FACING); // Paper - cache facing direction
+         ItemStack itemstack1 = this.a(isourceblock, itemstack);
+ 
+         this.a(isourceblock);
+-        this.a(isourceblock, (EnumDirection) isourceblock.getBlockData().get(BlockDispenser.FACING));
++        this.a(isourceblock, enumdirection); // Paper - cache facing direction
+         return itemstack1;
+     }
+ 
+     protected ItemStack a(ISourceBlock isourceblock, ItemStack itemstack) {
+-        EnumDirection enumdirection = (EnumDirection) isourceblock.getBlockData().get(BlockDispenser.FACING);
++        // Paper - cached enum direction
+         IPosition iposition = BlockDispenser.a(isourceblock);
+         ItemStack itemstack1 = itemstack.cloneAndSubtract(1);
+ 

Spigot-Server-Patches/Duplicate-UUID-Resolve-Option.patch

@@ -103,7 +103,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    public final void setUUID(UUID uuid) { a_(uuid); } // Paper - OBFHELPER
      public void a_(UUID uuid) {
          this.uniqueID = uuid;
-         this.al = this.uniqueID.toString();
+         this.ae = this.uniqueID.toString();
 diff --git a/src/main/java/net/minecraft/server/PlayerChunkMap.java b/src/main/java/net/minecraft/server/PlayerChunkMap.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/PlayerChunkMap.java
@@ -200,7 +200,7 @@ diff --git a/src/main/java/net/minecraft/server/WorldServer.java b/src/main/java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/WorldServer.java
 +++ b/src/main/java/net/minecraft/server/WorldServer.java
-@@ -0,0 +0,0 @@ import com.google.common.collect.ImmutableList;
+@@ -0,0 +0,0 @@ import com.google.common.annotations.VisibleForTesting;
  import com.google.common.collect.Iterables;
  import co.aikar.timings.TimingHistory; // Paper
  import co.aikar.timings.Timings; // Paper
@@ -213,16 +213,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (entity1 == null) {
              return false;
          } else {
--            WorldServer.LOGGER.error("Keeping entity {} that already exists with UUID {}", EntityTypes.getName(entity1.getEntityType()), entity.getUniqueID().toString()); // CraftBukkit // paper
 +            // Paper start
 +            if (entity1.dead) {
 +                unregisterEntity(entity1); // remove the existing entity
 +                return false;
 +            }
 +            // Paper end
-+            WorldServer.LOGGER.error("Keeping entity {} that already exists with UUID {}", entity1, entity.getUniqueID().toString()); // CraftBukkit // paper
+             WorldServer.LOGGER.warn("Trying to add entity with duplicated UUID {}. Existing {}#{}, new: {}#{}", uuid, EntityTypes.getName(entity1.getEntityType()), entity1.getId(), EntityTypes.getName(entity.getEntityType()), entity.getId()); // CraftBukkit // Paper
-             WorldServer.LOGGER.error("Deleting duplicate entity {}", entity); // CraftBukkit // paper
-+
 +            // Paper start
 +            if (DEBUG_ENTITIES && entity.world.paperConfig.duplicateUUIDMode != PaperWorldConfig.DuplicateUUIDMode.NOTHING) {
 +                if (entity1.addedToWorldStack != null) {

Spigot-Server-Patches/EnderDragon-Events.patch

@@ -44,7 +44,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                        else entitydragonfireball.die(); // Paper
                          this.c = 0;
                          if (this.d != null) {
-                             while (!this.d.b()) {
+                             while (!this.d.c()) {
 diff --git a/src/main/java/net/minecraft/server/EntityDragonFireball.java b/src/main/java/net/minecraft/server/EntityDragonFireball.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/EntityDragonFireball.java

Spigot-Server-Patches/Enderman.teleportRandomly.patch

@@ -13,8 +13,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          super.mobTick();
      }
  
-+    public final boolean teleportRandomly() { return this.eM(); } // Paper - OBFHELPER
++    public final boolean teleportRandomly() { return this.eL(); } // Paper - OBFHELPER
-     protected boolean eM() {
+     protected boolean eL() {
          if (!this.world.s_() && this.isAlive()) {
              double d0 = this.locX() + (this.random.nextDouble() - 0.5D) * 64.0D;
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEnderman.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEnderman.java

Spigot-Server-Patches/EndermanEscapeEvent.patch

@@ -33,13 +33,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public boolean setGoalTarget(EntityLiving entityliving, org.bukkit.event.entity.EntityTargetEvent.TargetReason reason, boolean fireEvent) {
          if (!super.setGoalTarget(entityliving, reason, fireEvent)) {
 @@ -0,0 +0,0 @@ public class EntityEnderman extends EntityMonster implements IEntityAngerable {
-         if (this.world.isDay() && this.ticksLived >= this.bz + 600) {
+         if (this.world.isDay() && this.ticksLived >= this.bs + 600) {
-             float f = this.aO();
+             float f = this.aQ();
  
--            if (f > 0.5F && this.world.f(this.getChunkCoordinates()) && this.random.nextFloat() * 30.0F < (f - 0.4F) * 2.0F) {
+-            if (f > 0.5F && this.world.e(this.getChunkCoordinates()) && this.random.nextFloat() * 30.0F < (f - 0.4F) * 2.0F) {
-+            if (f > 0.5F && this.world.f(this.getChunkCoordinates()) && this.random.nextFloat() * 30.0F < (f - 0.4F) * 2.0F && this.tryEscape(EndermanEscapeEvent.Reason.RUNAWAY)) { // Paper
++            if (f > 0.5F && this.world.e(this.getChunkCoordinates()) && this.random.nextFloat() * 30.0F < (f - 0.4F) * 2.0F && this.tryEscape(EndermanEscapeEvent.Reason.RUNAWAY)) { // Paper
                  this.setGoalTarget((EntityLiving) null);
-                 this.eM();
+                 this.eL();
              }
 @@ -0,0 +0,0 @@ public class EntityEnderman extends EntityMonster implements IEntityAngerable {
          if (this.isInvulnerable(damagesource)) {
@@ -47,7 +47,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          } else if (damagesource instanceof EntityDamageSourceIndirect) {
 +            if (this.tryEscape(EndermanEscapeEvent.Reason.INDIRECT)) { // Paper start
              for (int i = 0; i < 64; ++i) {
-                 if (this.eM()) {
+                 if (this.eL()) {
                      return true;
                  }
              }
@@ -57,9 +57,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          } else {
              boolean flag = super.damageEntity(damagesource, f);
  
--            if (!this.world.s_() && this.random.nextInt(10) != 0) {
+-            if (!this.world.s_() && !(damagesource.getEntity() instanceof EntityLiving) && this.random.nextInt(10) != 0) {
-+            if (!this.world.s_() && this.random.nextInt(10) != 0 && this.tryEscape(damagesource == DamageSource.DROWN ? EndermanEscapeEvent.Reason.DROWN : EndermanEscapeEvent.Reason.CRITICAL_HIT)) { // Paper
++            if (!this.world.s_() && !(damagesource.getEntity() instanceof EntityLiving) && this.random.nextInt(10) != 0 && this.tryEscape(damagesource == DamageSource.DROWN ? EndermanEscapeEvent.Reason.DROWN : EndermanEscapeEvent.Reason.INDIRECT)) { // Paper - use to be critical hits as else, but mojang removed critical hits in 1.16.2 due to MC-185684
-                 this.eM();
+                 this.eL();
              }
  
 @@ -0,0 +0,0 @@ public class EntityEnderman extends EntityMonster implements IEntityAngerable {
@@ -76,7 +76,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  if (this.c != null && !this.i.isPassenger()) {
                      if (this.i.g((EntityHuman) this.c)) {
 -                        if (this.c.h((Entity) this.i) < 16.0D) {
-+                        if (this.c.h((Entity) this.i) < 16.0D && this.getEnderman().tryEscape(EndermanEscapeEvent.Reason.STARE)) {
++                        if (this.c.h((Entity) this.i) < 16.0D && this.getEnderman().tryEscape(EndermanEscapeEvent.Reason.STARE)) { // Paper
-                             this.i.eM();
+                             this.i.eL();
                          }
  

Spigot-Server-Patches/Ensure-Entity-AABB-s-are-never-invalid.patch

@@ -8,99 +8,12 @@ diff --git a/src/main/java/net/minecraft/server/Entity.java b/src/main/java/net/
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/Entity.java
 +++ b/src/main/java/net/minecraft/server/Entity.java
-@@ -0,0 +0,0 @@
- package net.minecraft.server;
- 
-+import co.aikar.timings.MinecraftTimings;
-+import co.aikar.timings.Timing;
- import com.google.common.collect.Iterables;
- import com.google.common.collect.Lists;
- import com.google.common.collect.Sets;
- import it.unimi.dsi.fastutil.objects.Object2DoubleArrayMap;
- import it.unimi.dsi.fastutil.objects.Object2DoubleMap;
--import java.util.Arrays;
--import java.util.Collection;
--import java.util.Collections;
--import java.util.Iterator;
--import java.util.List;
--import java.util.Locale;
--import java.util.Optional;
--import java.util.Random;
--import java.util.Set;
--import java.util.UUID;
--import java.util.concurrent.atomic.AtomicInteger;
--import java.util.stream.Stream;
--import javax.annotation.Nullable;
- import org.apache.logging.log4j.LogManager;
- import org.apache.logging.log4j.Logger;
--
--// CraftBukkit start
- import org.bukkit.Bukkit;
- import org.bukkit.Server;
- import org.bukkit.block.BlockFace;
- import org.bukkit.command.CommandSender;
--import org.bukkit.entity.Hanging;
--import org.bukkit.entity.LivingEntity;
--import org.bukkit.entity.Vehicle;
--import co.aikar.timings.MinecraftTimings; // Paper
--import co.aikar.timings.Timing; // Paper
--import org.bukkit.event.entity.EntityCombustByEntityEvent;
--import org.bukkit.event.hanging.HangingBreakByEntityEvent;
--import org.bukkit.event.vehicle.VehicleBlockCollisionEvent;
--import org.bukkit.event.vehicle.VehicleEnterEvent;
--import org.bukkit.event.vehicle.VehicleExitEvent;
- import org.bukkit.craftbukkit.CraftWorld;
- import org.bukkit.craftbukkit.entity.CraftEntity;
- import org.bukkit.craftbukkit.entity.CraftPlayer;
- import org.bukkit.craftbukkit.event.CraftEventFactory;
-+import org.bukkit.entity.Hanging;
-+import org.bukkit.entity.LivingEntity;
- import org.bukkit.entity.Pose;
-+import org.bukkit.entity.Vehicle;
- import org.bukkit.event.entity.EntityAirChangeEvent;
-+import org.bukkit.event.entity.EntityCombustByEntityEvent;
- import org.bukkit.event.entity.EntityCombustEvent;
- import org.bukkit.event.entity.EntityDropItemEvent;
- import org.bukkit.event.entity.EntityPortalEvent;
- import org.bukkit.event.entity.EntityPoseChangeEvent;
-+import org.bukkit.event.hanging.HangingBreakByEntityEvent;
- import org.bukkit.event.player.PlayerTeleportEvent;
-+import org.bukkit.event.vehicle.VehicleBlockCollisionEvent;
-+import org.bukkit.event.vehicle.VehicleEnterEvent;
-+import org.bukkit.event.vehicle.VehicleExitEvent;
- import org.bukkit.plugin.PluginManager;
-+
-+import javax.annotation.Nullable;
-+import java.util.Arrays;
-+import java.util.Collection;
-+import java.util.Collections;
-+import java.util.Iterator;
-+import java.util.List;
-+import java.util.Locale;
-+import java.util.Optional;
-+import java.util.Random;
-+import java.util.Set;
-+import java.util.UUID;
-+import java.util.concurrent.atomic.AtomicInteger;
-+import java.util.stream.Stream;
-+
-+// CraftBukkit start
- // CraftBukkit end
- 
- public abstract class Entity implements INamableTileEntity, ICommandListener, KeyedObject { // Paper
 @@ -0,0 +0,0 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, Ke
  
      public void setPosition(double d0, double d1, double d2) {
          this.setPositionRaw(d0, d1, d2);
--        float f = this.size.width / 2.0F;
+-        this.a(this.size.a(d0, d1, d2));
--        float f1 = this.size.height;
++        //this.a(this.size.a(d0, d1, d2)); // Paper - move into setPositionRaw
-+        // Paper start - move into setPositionRaw
-+        //float f = this.size.width / 2.0F;
-+        //float f1 = this.size.height;
- 
--        this.a(new AxisAlignedBB(d0 - (double) f, d1, d2 - (double) f, d0 + (double) f, d1 + (double) f1, d2 + (double) f));
-+        //this.a(new AxisAlignedBB(d0 - (double) f, d1, d2 - (double) f, d0 + (double) f, d1 + (double) f1, d2 + (double) f));
-+        // Paper end
          if (valid) ((WorldServer) world).chunkCheck(this); // CraftBukkit
      }
  
@@ -119,9 +32,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        // Paper start - never allow AABB to become desynced from position
 +        // hanging has its own special logic
 +        if (!(this instanceof EntityHanging) && (this.loc.x != d0 || this.loc.y != d1 || this.loc.z != d2)) {
-+            float f = this.size.width / 2.0F;
++            this.setBoundingBox(this.size.a(d0, d1, d2));
-+            float f1 = this.size.height;
-+            this.setBoundingBox(new AxisAlignedBB(d0 - (double) f, d1, d2 - (double) f, d0 + (double) f, d1 + (double) f1, d2 + (double) f));
 +        }
 +        // Paper end
          if (this.loc.x != d0 || this.loc.y != d1 || this.loc.z != d2) {

Spigot-Server-Patches/Ensure-Entity-is-never-double-registered.patch

@@ -76,4 +76,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            entity.isQueuedForRegister = false; // Paper
              this.entitiesById.put(entity.getId(), entity);
              if (entity instanceof EntityEnderDragon) {
-                 EntityComplexPart[] aentitycomplexpart = ((EntityEnderDragon) entity).eK();
+                 EntityComplexPart[] aentitycomplexpart = ((EntityEnderDragon) entity).eJ();

Spigot-Server-Patches/Ensure-EntityRaider-respects-game-and-entity-rules-f.patch

@@ -23,6 +23,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          @Override
          public boolean a() {
 +            if (!getRaider().world.getGameRules().getBoolean(GameRules.MOB_GRIEFING) || !getRaider().canPickupLoot()) return false; // Paper - respect game and entity rules for picking up items
-             Raid raid = this.b.fb();
+             Raid raid = this.b.fa();
  
-             if (this.b.fc() && !this.b.fb().a() && this.b.eO() && !ItemStack.matches(this.b.getEquipment(EnumItemSlot.HEAD), Raid.s())) {
+             if (this.b.fb() && !this.b.fa().a() && this.b.eN() && !ItemStack.matches(this.b.getEquipment(EnumItemSlot.HEAD), Raid.s())) {

Spigot-Server-Patches/Ensure-safe-gateway-teleport.patch

@@ -9,16 +9,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/TileEntityEndGateway.java
 +++ b/src/main/java/net/minecraft/server/TileEntityEndGateway.java
 @@ -0,0 +0,0 @@ public class TileEntityEndGateway extends TileEntityEnderPortal implements ITick
-             --this.c;
          } else if (!this.world.isClientSide) {
-             List<Entity> list = this.world.a(Entity.class, new AxisAlignedBB(this.getPosition()));
+             List<Entity> list = this.world.a(Entity.class, new AxisAlignedBB(this.getPosition()), TileEntityEndGateway::a);
--
+ 
 -            if (!list.isEmpty()) {
--                this.a((Entity) list.get(this.world.random.nextInt(list.size())));
+-                this.b((Entity) list.get(this.world.random.nextInt(list.size())));
 +            // Paper start
 +            for (Entity entity : list) {
 +                if (entity.canPortal()) {
-+                    this.a(entity);
++                    this.b(entity);
 +                    break;
 +                }
              }

Spigot-Server-Patches/Entity-Activation-Range-2.0.patch

@@ -18,14 +18,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/Entity.java
 +++ b/src/main/java/net/minecraft/server/Entity.java
 @@ -0,0 +0,0 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, Ke
-     public boolean ac;
+     public boolean Y;
      public boolean impulse;
      public int portalCooldown;
--    protected boolean inPortal; public final boolean inPortal() { return this.inPortal; } // Paper - OBFHELPER
+-    protected boolean inPortal;
 +    public boolean inPortal; // Paper - public
      protected int portalTicks;
-     protected BlockPosition ah;
+     protected BlockPosition ac;
-     protected Vec3D ai;
+     private boolean invulnerable;
 @@ -0,0 +0,0 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, Ke
      public final org.spigotmc.ActivationRange.ActivationType activationType = org.spigotmc.ActivationRange.initializeEntityActivationType(this);
      public final boolean defaultActivationState;
@@ -39,7 +39,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          } else {
              if (enummovetype == EnumMoveType.PISTON) {
 +                this.activatedTick = MinecraftServer.currentTick + 20; // Paper
-                 vec3d = this.a(vec3d);
+                 vec3d = this.b(vec3d);
                  if (vec3d.equals(Vec3D.a)) {
                      return;
 @@ -0,0 +0,0 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, Ke
@@ -55,9 +55,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            // Paper end
  
              vec3d = this.a(vec3d, enummovetype);
-             Vec3D vec3d1 = this.f(vec3d);
+             Vec3D vec3d1 = this.g(vec3d);
 @@ -0,0 +0,0 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, Ke
-         return this.al;
+         return this.ae;
      }
  
 +    public final boolean isPushedByWater() { return this.bU(); } // Paper - OBFHELPER - the below is not an obfhelper, don't use it!
@@ -86,9 +86,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Nullable
 -    private Entity leashHolder;
 +    public Entity leashHolder; // Paper - private -> public
-     private int bE;
+     private int bx;
      @Nullable
-     private NBTTagCompound bF;
+     private NBTTagCompound by;
 @@ -0,0 +0,0 @@ public abstract class EntityInsentient extends EntityLiving {
          return this.lookController;
      }
@@ -112,25 +112,25 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/EntityLiving.java
 +++ b/src/main/java/net/minecraft/server/EntityLiving.java
 @@ -0,0 +0,0 @@ public abstract class EntityLiving extends Entity {
-     protected float aU;
+     protected float aN;
-     protected int aV; protected int getKillCount() { return this.aV; } // Paper - OBFHELPER
+     protected int aO;protected int getKillCount() { return this.aO; } // Paper - OBFHELPER
      public float lastDamage;
 -    protected boolean jumping;
 +    public boolean jumping; // Paper protected -> public
-     public float aY;
+     public float aR;
-     public float aZ;
+     public float aS;
-     public float ba;
+     public float aT;
 diff --git a/src/main/java/net/minecraft/server/EntityLlama.java b/src/main/java/net/minecraft/server/EntityLlama.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/EntityLlama.java
 +++ b/src/main/java/net/minecraft/server/EntityLlama.java
 @@ -0,0 +0,0 @@ public class EntityLlama extends EntityHorseChestedAbstract implements IRangedEn
-         return this.bJ != null;
+         return this.bC != null;
      }
  
-+    public final boolean inCaravan() { return this.fD(); } // Paper - OBFHELPER
++    public final boolean inCaravan() { return this.fC(); } // Paper - OBFHELPER
-     public boolean fD() {
+     public boolean fC() {
-         return this.bI != null;
+         return this.bB != null;
      }
 diff --git a/src/main/java/net/minecraft/server/EntityVillager.java b/src/main/java/net/minecraft/server/EntityVillager.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
@@ -166,22 +166,21 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    protected void mobTick(boolean inactive) {
          this.world.getMethodProfiler().enter("villagerBrain");
 -        this.getBehaviorController().a((WorldServer) this.world, this); // CraftBukkit - decompile error
--        this.world.getMethodProfiler().exit();
 +        if (!inactive) this.getBehaviorController().a((WorldServer) this.world, this); // CraftBukkit - decompile error // Paper
-         if (this.bM) {
+         this.world.getMethodProfiler().exit();
-             this.bM = false;
+         if (this.bF) {
-         }
+             this.bF = false;
 @@ -0,0 +0,0 @@ public class EntityVillager extends EntityVillagerAbstract implements Reputation
-             this.bC = null;
+             this.bv = null;
          }
  
 -        if (!this.isNoAI() && this.random.nextInt(100) == 0) {
 +        if (!inactive && !this.isNoAI() && this.random.nextInt(100) == 0) { // Paper
-             Raid raid = ((WorldServer) this.world).c_(this.getChunkCoordinates());
+             Raid raid = ((WorldServer) this.world).b_(this.getChunkCoordinates());
  
              if (raid != null && raid.v() && !raid.a()) {
 @@ -0,0 +0,0 @@ public class EntityVillager extends EntityVillagerAbstract implements Reputation
-         if (this.getVillagerData().getProfession() == VillagerProfession.NONE && this.eO()) {
+         if (this.getVillagerData().getProfession() == VillagerProfession.NONE && this.eN()) {
              this.eT();
          }
 +        if (inactive) return; // Paper
@@ -192,8 +191,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
      }
  
-+    private void doReputationTick() { fv(); } // Paper - OBFHELPER
++    private void doReputationTick() { fw(); } // Paper - OBFHELPER
-     private void fv() {
+     private void fw() {
          long i = this.world.getTime();
  
 diff --git a/src/main/java/net/minecraft/server/EntityVillagerAbstract.java b/src/main/java/net/minecraft/server/EntityVillagerAbstract.java
@@ -201,17 +200,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/EntityVillagerAbstract.java
 +++ b/src/main/java/net/minecraft/server/EntityVillagerAbstract.java
 @@ -0,0 +0,0 @@ public abstract class EntityVillagerAbstract extends EntityAgeable implements NP
-         return super.prepare(generatoraccess, difficultydamagescaler, enummobspawn, (GroupDataEntity) groupdataentity, nbttagcompound);
+         return super.prepare(worldaccess, difficultydamagescaler, enummobspawn, (GroupDataEntity) groupdataentity, nbttagcompound);
      }
  
-+    public final int getUnhappy() { return eL(); } // Paper - OBFHELPER
++    public final int getUnhappy() { return eK(); } // Paper - OBFHELPER
-     public int eL() {
+     public int eK() {
-         return (Integer) this.datawatcher.get(EntityVillagerAbstract.bw);
+         return (Integer) this.datawatcher.get(EntityVillagerAbstract.bp);
      }
  
 +    public final void setUnhappy(int i) { s(i); } // Paper - OBFHELPER
      public void s(int i) {
-         this.datawatcher.set(EntityVillagerAbstract.bw, i);
+         this.datawatcher.set(EntityVillagerAbstract.bp, i);
      }
 diff --git a/src/main/java/net/minecraft/server/PathfinderGoal.java b/src/main/java/net/minecraft/server/PathfinderGoal.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
@@ -243,8 +242,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      protected int c;
      protected int d;
      private int g;
--    protected BlockPosition e;
+-    protected BlockPosition e;public final BlockPosition getTargetPosition() { return this.e; } // Paper - OBFHELPER
-+    protected BlockPosition e; public BlockPosition getTarget() { return e; } public void setTarget(BlockPosition pos) { this.e = pos; getEntity().movingTarget = pos != BlockPosition.ZERO ? pos : null; } // Paper - OBFHELPER
++    protected BlockPosition e; public final BlockPosition getTargetPosition() { return this.e; } public void setTargetPosition(BlockPosition pos) { this.e = pos; getEntity().movingTarget = pos != BlockPosition.ZERO ? pos : null; } // Paper - OBFHELPER
      private boolean h;
      private final int i;
      private final int j;
@@ -256,7 +255,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @Override
 +    public void onTaskReset() {
 +        super.onTaskReset();
-+        setTarget(BlockPosition.ZERO);
++        setTargetPosition(BlockPosition.ZERO);
 +    }
 +    // Paper end
  
@@ -266,7 +265,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                          blockposition_mutableblockposition.a((BaseBlockPosition) blockposition, i1, k - 1, j1);
                          if (this.a.a((BlockPosition) blockposition_mutableblockposition) && this.a(this.a.world, blockposition_mutableblockposition)) {
                              this.e = blockposition_mutableblockposition;
-+                            setTarget(blockposition_mutableblockposition.immutableCopy()); // Paper
++                            setTargetPosition(blockposition_mutableblockposition.immutableCopy()); // Paper
                              return true;
                          }
                      }

Spigot-Server-Patches/Entity-Jump-API.patch

@@ -9,7 +9,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/EntityLiving.java
 +++ b/src/main/java/net/minecraft/server/EntityLiving.java
 @@ -0,0 +0,0 @@ public abstract class EntityLiving extends Entity {
-             } else if (this.aN() && (!this.onGround || d7 > d8)) {
+             } else if (this.aP() && (!this.onGround || d7 > d8)) {
                  this.c((Tag) TagsFluid.LAVA);
              } else if ((this.onGround || flag && d7 <= d8) && this.jumpTicks == 0) {
 +                if (new com.destroystokyo.paper.event.entity.EntityJumpEvent(getBukkitLivingEntity()).callEvent()) { // Paper
@@ -26,7 +26,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class EntityPanda extends EntityAnimal {
              EntityPanda entitypanda = (EntityPanda) iterator.next();
  
-             if (!entitypanda.isBaby() && entitypanda.onGround && !entitypanda.isInWater() && entitypanda.fi()) {
+             if (!entitypanda.isBaby() && entitypanda.onGround && !entitypanda.isInWater() && entitypanda.fh()) {
 +                if (new com.destroystokyo.paper.event.entity.EntityJumpEvent(getBukkitLivingEntity()).callEvent()) { // Paper
                  entitypanda.jump();
 +                } else { this.setJumping(false); } // Paper - setJumping(false) stops a potential loop

Spigot-Server-Patches/Entity-fromMobSpawner.patch

@@ -41,13 +41,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/MobSpawnerAbstract.java
 +++ b/src/main/java/net/minecraft/server/MobSpawnerAbstract.java
 @@ -0,0 +0,0 @@ public abstract class MobSpawnerAbstract {
+                                 }
+                                 // Spigot End
                              }
-                             // Spigot End
-                         }
 +                        entity.spawnedViaMobSpawner = true; // Paper
-                         // Spigot Start
+                             // Spigot Start
-                         if (org.bukkit.craftbukkit.event.CraftEventFactory.callSpawnerSpawnEvent(entity, blockposition).isCancelled()) {
+                             if (org.bukkit.craftbukkit.event.CraftEventFactory.callSpawnerSpawnEvent(entity, blockposition).isCancelled()) {
-                             Entity vehicle = entity.getVehicle();
+                                 Entity vehicle = entity.getVehicle();
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java

Spigot-Server-Patches/Entity-getEntitySpawnReason.patch

@@ -63,13 +63,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/MobSpawnerAbstract.java
 +++ b/src/main/java/net/minecraft/server/MobSpawnerAbstract.java
 @@ -0,0 +0,0 @@ public abstract class MobSpawnerAbstract {
-                             // Spigot End
+                                 // Spigot End
-                         }
+                             }
                          entity.spawnedViaMobSpawner = true; // Paper
-+                        entity.spawnReason = org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.SPAWNER; // Paper
++                            entity.spawnReason = org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.SPAWNER; // Paper
-                         // Spigot Start
+                             flag = true; // Paper
-                         flag = true; // Paper
+                             // Spigot Start
-                         if (org.bukkit.craftbukkit.event.CraftEventFactory.callSpawnerSpawnEvent(entity, blockposition).isCancelled()) {
+                             if (org.bukkit.craftbukkit.event.CraftEventFactory.callSpawnerSpawnEvent(entity, blockposition).isCancelled()) {
 diff --git a/src/main/java/net/minecraft/server/PlayerList.java b/src/main/java/net/minecraft/server/PlayerList.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/server/PlayerList.java

Spigot-Server-Patches/EntityPathfindEvent.patch

@@ -61,7 +61,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              return null;
          } else if (this.a.locY() < 0.0D) {
 @@ -0,0 +0,0 @@ public abstract class NavigationAbstract {
-         } else if (this.c != null && !this.c.b() && set.contains(this.p)) {
+         } else if (this.c != null && !this.c.c() && set.contains(this.p)) {
              return this.c;
          } else {
 +            // Paper start - Pathfind event

Spigot-Server-Patches/EntityTransformedEvent.patch

@@ -1,66 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Anthony MacAllister <anthonymmacallister@gmail.com>
-Date: Thu, 26 Jul 2018 15:30:03 -0400
-Subject: [PATCH] EntityTransformedEvent
-
-
-diff --git a/src/main/java/net/minecraft/server/EntityInsentient.java b/src/main/java/net/minecraft/server/EntityInsentient.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/EntityInsentient.java
-+++ b/src/main/java/net/minecraft/server/EntityInsentient.java
-@@ -0,0 +0,0 @@ public abstract class EntityInsentient extends EntityLiving {
-             if (CraftEventFactory.callEntityTransformEvent(this, t0, EntityTransformEvent.TransformReason.DROWNED).isCancelled()) {
-                 return null;
-             }
-+            if (!new com.destroystokyo.paper.event.entity.EntityTransformedEvent(this.getBukkitEntity(), t0.getBukkitEntity(), com.destroystokyo.paper.event.entity.EntityTransformedEvent.TransformedReason.DROWNED).callEvent()) return null; // Paper
-             this.world.addEntity(t0, CreatureSpawnEvent.SpawnReason.DROWNED);
-             // CraftBukkit end
-             this.die();
-diff --git a/src/main/java/net/minecraft/server/EntityMushroomCow.java b/src/main/java/net/minecraft/server/EntityMushroomCow.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/EntityMushroomCow.java
-+++ b/src/main/java/net/minecraft/server/EntityMushroomCow.java
-@@ -0,0 +0,0 @@ public class EntityMushroomCow extends EntityCow implements IShearable {
-             if (CraftEventFactory.callEntityTransformEvent(this, entitycow, EntityTransformEvent.TransformReason.SHEARED).isCancelled()) {
-                 return;
-             }
-+            if (!new com.destroystokyo.paper.event.entity.EntityTransformedEvent(this.getBukkitEntity(), entitycow.getBukkitEntity(), com.destroystokyo.paper.event.entity.EntityTransformedEvent.TransformedReason.SHEARED).callEvent()) return; // Paper
-             this.world.addEntity(entitycow, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.SHEARED);
- 
-             this.die(); // CraftBukkit - from above
-diff --git a/src/main/java/net/minecraft/server/EntityVillager.java b/src/main/java/net/minecraft/server/EntityVillager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/EntityVillager.java
-+++ b/src/main/java/net/minecraft/server/EntityVillager.java
-@@ -0,0 +0,0 @@ public class EntityVillager extends EntityVillagerAbstract implements Reputation
-             if (CraftEventFactory.callEntityTransformEvent(this, entitywitch, EntityTransformEvent.TransformReason.LIGHTNING).isCancelled()) {
-                 return;
-             }
-+            if (!new com.destroystokyo.paper.event.entity.EntityTransformedEvent(this.getBukkitEntity(), entitywitch.getBukkitEntity(), com.destroystokyo.paper.event.entity.EntityTransformedEvent.TransformedReason.LIGHTNING).callEvent()) return; // Paper
-             this.world.addEntity(entitywitch, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.LIGHTNING);
-             // CraftBukkit end
-             this.die();
-diff --git a/src/main/java/net/minecraft/server/EntityZombie.java b/src/main/java/net/minecraft/server/EntityZombie.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/EntityZombie.java
-+++ b/src/main/java/net/minecraft/server/EntityZombie.java
-@@ -0,0 +0,0 @@ public class EntityZombie extends EntityMonster {
-             if (CraftEventFactory.callEntityTransformEvent(this, entityzombievillager, EntityTransformEvent.TransformReason.INFECTION).isCancelled()) {
-                 return;
-             }
-+            if (!new com.destroystokyo.paper.event.entity.EntityTransformedEvent(this.getBukkitEntity(), entityvillager.getBukkitEntity(), com.destroystokyo.paper.event.entity.EntityTransformedEvent.TransformedReason.INFECTED).callEvent()) return; // Paper
-             entityvillager.die(); // CraftBukkit - from above
-             this.world.addEntity(entityzombievillager, CreatureSpawnEvent.SpawnReason.INFECTION); // CraftBukkit - add SpawnReason
-             // CraftBukkit end
-diff --git a/src/main/java/net/minecraft/server/EntityZombieVillager.java b/src/main/java/net/minecraft/server/EntityZombieVillager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/EntityZombieVillager.java
-+++ b/src/main/java/net/minecraft/server/EntityZombieVillager.java
-@@ -0,0 +0,0 @@ public class EntityZombieVillager extends EntityZombie implements VillagerDataHo
-             ((ZombieVillager) getBukkitEntity()).setConversionTime(-1); // SPIGOT-5208: End conversion to stop event spam
-             return;
-         }
-+        if (!new com.destroystokyo.paper.event.entity.EntityTransformedEvent(this.getBukkitEntity(), entityvillager.getBukkitEntity(), com.destroystokyo.paper.event.entity.EntityTransformedEvent.TransformedReason.CURED).callEvent()) return; // Paper
-         this.die(); // CraftBukkit - from above
-         worldserver.addEntity(entityvillager, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.CURED); // CraftBukkit - add SpawnReason
-         // CraftBukkit end

Spigot-Server-Patches/ExperienceOrbs-API-for-Reason-Source-Triggering-play.patch

@@ -15,15 +15,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
      }
  
--    protected void dropExperience(World world, BlockPosition blockposition, int i) {
+-    protected void dropExperience(WorldServer worldserver, BlockPosition blockposition, int i) {
-+    protected void dropExperience(World world, BlockPosition blockposition, int i, EntityPlayer player) { // Paper
++    protected void dropExperience(WorldServer worldserver, BlockPosition blockposition, int i, EntityPlayer player) { // Paper
-         if (!world.isClientSide && world.getGameRules().getBoolean(GameRules.DO_TILE_DROPS)) {
+         if (worldserver.getGameRules().getBoolean(GameRules.DO_TILE_DROPS)) {
              while (i > 0) {
                  int j = EntityExperienceOrb.getOrbValue(i);
  
                  i -= j;
--                world.addEntity(new EntityExperienceOrb(world, (double) blockposition.getX() + 0.5D, (double) blockposition.getY() + 0.5D, (double) blockposition.getZ() + 0.5D, j));
+-                worldserver.addEntity(new EntityExperienceOrb(worldserver, (double) blockposition.getX() + 0.5D, (double) blockposition.getY() + 0.5D, (double) blockposition.getZ() + 0.5D, j));
-+                world.addEntity(new EntityExperienceOrb(world, (double) blockposition.getX() + 0.5D, (double) blockposition.getY() + 0.5D, (double) blockposition.getZ() + 0.5D, j, org.bukkit.entity.ExperienceOrb.SpawnReason.BLOCK_BREAK, player)); // Paper
++                worldserver.addEntity(new EntityExperienceOrb(worldserver, (double) blockposition.getX() + 0.5D, (double) blockposition.getY() + 0.5D, (double) blockposition.getZ() + 0.5D, j, org.bukkit.entity.ExperienceOrb.SpawnReason.BLOCK_BREAK, player)); // Paper
              }
          }
  
@@ -45,11 +45,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/EntityAnimal.java
 +++ b/src/main/java/net/minecraft/server/EntityAnimal.java
 @@ -0,0 +0,0 @@ public abstract class EntityAnimal extends EntityAgeable {
-             if (world.getGameRules().getBoolean(GameRules.DO_MOB_LOOT)) {
+             if (worldserver.getGameRules().getBoolean(GameRules.DO_MOB_LOOT)) {
                  // CraftBukkit start - use event experience
                  if (experience > 0) {
--                    world.addEntity(new EntityExperienceOrb(world, this.locX(), this.locY(), this.locZ(), experience));
+-                    worldserver.addEntity(new EntityExperienceOrb(worldserver, this.locX(), this.locY(), this.locZ(), experience));
-+                    world.addEntity(new EntityExperienceOrb(world, this.locX(), this.locY(), this.locZ(), experience, org.bukkit.entity.ExperienceOrb.SpawnReason.BREED, entityplayer, entityageable)); // Paper
++                    worldserver.addEntity(new EntityExperienceOrb(worldserver, this.locX(), this.locY(), this.locZ(), experience, org.bukkit.entity.ExperienceOrb.SpawnReason.BREED, entityplayer, entityageable)); // Paper
                  }
                  // CraftBukkit end
              }

Spigot-Server-Patches/Expose-attack-cooldown-methods-for-Player.patch

@@ -9,11 +9,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/EntityHuman.java
 +++ b/src/main/java/net/minecraft/server/EntityHuman.java
 @@ -0,0 +0,0 @@ public abstract class EntityHuman extends EntityLiving {
-         this.datawatcher.set(EntityHuman.bs, nbttagcompound);
+         this.datawatcher.set(EntityHuman.bl, nbttagcompound);
      }
  
-+    public float getCooldownPeriod() { return this.eR(); } // Paper - OBFHELPER
++    public float getCooldownPeriod() { return this.eQ(); } // Paper - OBFHELPER
-     public float eR() {
+     public float eQ() {
          return (float) (1.0D / this.b(GenericAttributes.ATTACK_SPEED) * 20.0D);
      }
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java

Spigot-Server-Patches/Fix-MC-124320.patch

@@ -1,50 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Thu, 23 Aug 2018 09:25:30 -0500
-Subject: [PATCH] Fix MC-124320
-
-
-diff --git a/src/main/java/net/minecraft/server/Block.java b/src/main/java/net/minecraft/server/Block.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/Block.java
-+++ b/src/main/java/net/minecraft/server/Block.java
-@@ -0,0 +0,0 @@ public class Block extends BlockBase implements IMaterial {
-         return this == block;
-     }
- 
-+    public static IBlockData getValidBlockForPosition(IBlockData iblockdata, GeneratorAccess generatoraccess, BlockPosition blockposition) { return Block.b(iblockdata, generatoraccess, blockposition); } // Paper - OBFHELPER
-     public static IBlockData b(IBlockData iblockdata, GeneratorAccess generatoraccess, BlockPosition blockposition) {
-         IBlockData iblockdata1 = iblockdata;
-         BlockPosition.MutableBlockPosition blockposition_mutableblockposition = new BlockPosition.MutableBlockPosition();
-diff --git a/src/main/java/net/minecraft/server/EntityEnderman.java b/src/main/java/net/minecraft/server/EntityEnderman.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/EntityEnderman.java
-+++ b/src/main/java/net/minecraft/server/EntityEnderman.java
-@@ -0,0 +0,0 @@ public class EntityEnderman extends EntityMonster implements IEntityAngerable {
-             if (block.a((Tag) TagsBlock.ENDERMAN_HOLDABLE) && flag) {
-                 // CraftBukkit start - Pickup event
-                 if (!org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(this.enderman, blockposition, Blocks.AIR.getBlockData()).isCancelled()) {
--                    this.enderman.setCarried(iblockdata);
-+                    //this.enderman.setCarried(iblockdata); // Paper - moved down
-                     world.a(blockposition, false);
-+                    this.enderman.setCarried(Block.getValidBlockForPosition(iblockdata, this.enderman.world, blockposition)); // Paper - Fix MC-124320
-                 }
-                 // CraftBukkit end
-             }
-@@ -0,0 +0,0 @@ public class EntityEnderman extends EntityMonster implements IEntityAngerable {
- 
-     static class PathfinderGoalEndermanPlaceBlock extends PathfinderGoal {
- 
-+        private EntityEnderman getEnderman() { return this.a; } // Paper - OBFHELPER
-         private final EntityEnderman a;
- 
-         public PathfinderGoalEndermanPlaceBlock(EntityEnderman entityenderman) {
-@@ -0,0 +0,0 @@ public class EntityEnderman extends EntityMonster implements IEntityAngerable {
-             IBlockData iblockdata = world.getType(blockposition);
-             BlockPosition blockposition1 = blockposition.down();
-             IBlockData iblockdata1 = world.getType(blockposition1);
--            IBlockData iblockdata2 = this.a.getCarried();
-+            IBlockData iblockdata2 = Block.getValidBlockForPosition(getEnderman().getCarried(), getEnderman().world, blockposition); // Paper - Fix MC-124320
- 
-             if (iblockdata2 != null && this.a(world, blockposition, iblockdata2, iblockdata, iblockdata1, blockposition1)) {
-                 // CraftBukkit start - Place event