From 4ce0958029619affb663d92f8045c53286e445e1 Mon Sep 17 00:00:00 2001
From: Aikar <aikar@aikar.co>
Date: Fri, 21 Sep 2018 16:56:08 -0400
Subject: [PATCH] Rework Async Chunks API in prep for merge, add utility

This adds a new Future based, Consumer<Chunk> based, and ability
to control whether or not to generate to the Async Chunk API.

Until Async Chunks merges, these API's are still synchronous, but
this commit will allow plugins to start using the API's in use
with the Async Chunks beta.
---
 ...ile-Entities-from-a-chunk-without-sn.patch |   2 +-
 .../Add-Force-Loaded-Chunk-API.patch          |  12 +-
 Spigot-API-Patches/Add-TNTPrimeEvent.patch    |   2 +-
 .../Add-async-chunk-load-API.patch            |  90 ----
 .../Add-hand-to-bucket-events.patch           |   6 +-
 ...Allow-disabling-armour-stand-ticking.patch |   2 +-
 Spigot-API-Patches/AnvilDamageEvent.patch     |   2 +-
 Spigot-API-Patches/Async-Chunks-API.patch     | 397 ++++++++++++++++++
 Spigot-API-Patches/EnderDragon-Events.patch   |   6 +-
 .../EntityTransformedEvent.patch              |   2 +-
 .../Expand-ArmorStand-API.patch               |   2 +-
 .../Expand-Location-Manipulation-API.patch    |   2 +-
 .../PlayerElytraBoostEvent.patch              |   2 +-
 .../PlayerLaunchProjectileEvent.patch         |   2 +-
 ...vide-Chunk-Coordinates-as-a-Long-API.patch |  27 +-
 ...deadlock-risk-in-firing-async-events.patch |   4 +-
 .../SkeletonHorse-Additions.patch             |   4 +-
 Spigot-API-Patches/isChunkGenerated-API.patch |  13 +-
 .../Add-async-chunk-load-API.patch            |  25 +-
 ...ead-Entities-in-entityList-iteration.patch |   2 +-
 .../Implement-Force-Loaded-Chunk-API.patch    |   2 +-
 ...loadChunk-int-int-false-load-unconve.patch |   2 +-
 ...Optimize-getChunkIfLoaded-type-calls.patch |   2 +-
 ...ets-from-world-player-list-not-serve.patch |   2 +-
 .../isChunkGenerated-API.patch                |   4 +-
 25 files changed, 465 insertions(+), 151 deletions(-)
 delete mode 100644 Spigot-API-Patches/Add-async-chunk-load-API.patch
 create mode 100644 Spigot-API-Patches/Async-Chunks-API.patch

diff --git a/Spigot-API-Patches/Ability-to-get-Tile-Entities-from-a-chunk-without-sn.patch b/Spigot-API-Patches/Ability-to-get-Tile-Entities-from-a-chunk-without-sn.patch
index ac98f63d6b..65accef4f7 100644
--- a/Spigot-API-Patches/Ability-to-get-Tile-Entities-from-a-chunk-without-sn.patch
+++ b/Spigot-API-Patches/Ability-to-get-Tile-Entities-from-a-chunk-without-sn.patch
@@ -5,7 +5,7 @@ Subject: [PATCH] Ability to get Tile Entities from a chunk without snapshots
 
 
 diff --git a/src/main/java/org/bukkit/Chunk.java b/src/main/java/org/bukkit/Chunk.java
-index c75bce07..dc847340 100644
+index b347a3ccf..8a8043351 100644
 --- a/src/main/java/org/bukkit/Chunk.java
 +++ b/src/main/java/org/bukkit/Chunk.java
 @@ -0,0 +0,0 @@ public interface Chunk {
diff --git a/Spigot-API-Patches/Add-Force-Loaded-Chunk-API.patch b/Spigot-API-Patches/Add-Force-Loaded-Chunk-API.patch
index 1f7b90f579..bfcb16173d 100644
--- a/Spigot-API-Patches/Add-Force-Loaded-Chunk-API.patch
+++ b/Spigot-API-Patches/Add-Force-Loaded-Chunk-API.patch
@@ -5,7 +5,7 @@ Subject: [PATCH] Add Force-Loaded Chunk API
 
 
 diff --git a/src/main/java/org/bukkit/Chunk.java b/src/main/java/org/bukkit/Chunk.java
-index dc847340..51bc051f 100644
+index 8a8043351..4b9e0ca46 100644
 --- a/src/main/java/org/bukkit/Chunk.java
 +++ b/src/main/java/org/bukkit/Chunk.java
 @@ -0,0 +0,0 @@ public interface Chunk {
@@ -30,14 +30,13 @@ index dc847340..51bc051f 100644
 +    // Paper end
  }
 diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
-index 53764fae..00b02e36 100644
+index 9c06fc163..5379a649e 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 true if the chunk has been generated, otherwise false
       */
      public boolean isChunkGenerated(int x, int z);
-+
+ 
 +    /**
 +     * Checks if a chunk is force-loaded.
 +     * Note: This will only return true if the chunk is also generated
@@ -47,7 +46,8 @@ index 53764fae..00b02e36 100644
 +     * @return true if the chunk is force-loaded. otherwise false
 +     */
 +    public boolean isChunkForceLoaded(int x, int z);
-     // Paper end
- 
++
      /**
+      * This is the Legacy API before Java 8 was supported. Java 8 Consumer is provided,
+      * as well as future support
 --
\ No newline at end of file
diff --git a/Spigot-API-Patches/Add-TNTPrimeEvent.patch b/Spigot-API-Patches/Add-TNTPrimeEvent.patch
index e7ec2b09ff..e77176f7ed 100644
--- a/Spigot-API-Patches/Add-TNTPrimeEvent.patch
+++ b/Spigot-API-Patches/Add-TNTPrimeEvent.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] Add TNTPrimeEvent
 
 diff --git a/src/main/java/com/destroystokyo/paper/event/block/TNTPrimeEvent.java b/src/main/java/com/destroystokyo/paper/event/block/TNTPrimeEvent.java
 new file mode 100644
-index 00000000..2ae8826b
+index 000000000..2ae8826bb
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/block/TNTPrimeEvent.java
 @@ -0,0 +0,0 @@
diff --git a/Spigot-API-Patches/Add-async-chunk-load-API.patch b/Spigot-API-Patches/Add-async-chunk-load-API.patch
deleted file mode 100644
index b64688d08e..0000000000
--- a/Spigot-API-Patches/Add-async-chunk-load-API.patch
+++ /dev/null
@@ -1,90 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Mon, 29 Feb 2016 17:43:33 -0600
-Subject: [PATCH] Add async chunk load API
-
-
-diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
-index 5e6cb56a..dbbcfec9 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 {
-      */
-     public Chunk getChunkAt(Block block);
- 
-+    /**
-+     * Used by {@link World#getChunkAtAsync(Location,ChunkLoadCallback)} methods
-+     * to request a {@link Chunk} to be loaded, with this callback receiving
-+     * the chunk when it is finished.
-+     *
-+     * This callback will be executed on synchronously on the main thread.
-+     *
-+     * Timing and order this callback is fired is intentionally not defined and
-+     * and subject to change.
-+     */
-+    public static interface ChunkLoadCallback {
-+        public void onLoad(Chunk chunk);
-+    }
-+
-+    /**
-+     * Requests a {@link Chunk} to be loaded at the given coordinates
-+     *
-+     * This method makes no guarantee on how fast the chunk will load,
-+     * and will return the chunk to the callback at a later time.
-+     *
-+     * You should use this method if you need a chunk but do not need it
-+     * immediately, and you wish to let the server control the speed
-+     * of chunk loads, keeping performance in mind.
-+     *
-+     * The {@link ChunkLoadCallback} will always be executed synchronously
-+     * on the main Server Thread.
-+     *
-+     * @param x Chunk X-coordinate of the chunk - (world coordinate / 16)
-+     * @param z Chunk Z-coordinate of the chunk - (world coordinate / 16)
-+     * @param cb Callback to receive the chunk when it is loaded.
-+     *           will be executed synchronously
-+     */
-+    public void getChunkAtAsync(int x, int z, ChunkLoadCallback cb);
-+
-+    /**
-+     * Requests a {@link Chunk} to be loaded at the given {@link Location}
-+     *
-+     * This method makes no guarantee on how fast the chunk will load,
-+     * and will return the chunk to the callback at a later time.
-+     *
-+     * You should use this method if you need a chunk but do not need it
-+     * immediately, and you wish to let the server control the speed
-+     * of chunk loads, keeping performance in mind.
-+     *
-+     * The {@link ChunkLoadCallback} will always be executed synchronously
-+     * on the main Server Thread.
-+     *
-+     * @param location Location of the chunk
-+     * @param cb Callback to receive the chunk when it is loaded.
-+     *           will be executed synchronously
-+     */
-+    public void getChunkAtAsync(Location location, ChunkLoadCallback cb);
-+
-+    /**
-+     * Requests {@link Chunk} to be loaded that contains the given {@link Block}
-+     *
-+     * This method makes no guarantee on how fast the chunk will load,
-+     * and will return the chunk to the callback at a later time.
-+     *
-+     * You should use this method if you need a chunk but do not need it
-+     * immediately, and you wish to let the server control the speed
-+     * of chunk loads, keeping performance in mind.
-+     *
-+     * The {@link ChunkLoadCallback} will always be executed synchronously
-+     * on the main Server Thread.
-+     *
-+     * @param block Block to get the containing chunk from
-+     * @param cb Callback to receive the chunk when it is loaded.
-+     *           will be executed synchronously
-+     */
-+    public void getChunkAtAsync(Block block, ChunkLoadCallback cb);
-+
-     /**
-      * Checks if the specified {@link Chunk} is loaded
-      *
---
\ No newline at end of file
diff --git a/Spigot-API-Patches/Add-hand-to-bucket-events.patch b/Spigot-API-Patches/Add-hand-to-bucket-events.patch
index d402920ad1..7a76b8fb74 100644
--- a/Spigot-API-Patches/Add-hand-to-bucket-events.patch
+++ b/Spigot-API-Patches/Add-hand-to-bucket-events.patch
@@ -5,7 +5,7 @@ Subject: [PATCH] Add hand to bucket events
 
 
 diff --git a/src/main/java/org/bukkit/event/player/PlayerBucketEmptyEvent.java b/src/main/java/org/bukkit/event/player/PlayerBucketEmptyEvent.java
-index 8fb121a9..7b9596f3 100644
+index 8fb121a91..7b9596f30 100644
 --- a/src/main/java/org/bukkit/event/player/PlayerBucketEmptyEvent.java
 +++ b/src/main/java/org/bukkit/event/player/PlayerBucketEmptyEvent.java
 @@ -0,0 +0,0 @@ import org.bukkit.block.Block;
@@ -30,7 +30,7 @@ index 8fb121a9..7b9596f3 100644
      public HandlerList getHandlers() {
          return handlers;
 diff --git a/src/main/java/org/bukkit/event/player/PlayerBucketEvent.java b/src/main/java/org/bukkit/event/player/PlayerBucketEvent.java
-index 56584687..3dbe428b 100644
+index 56584687f..3dbe428ba 100644
 --- a/src/main/java/org/bukkit/event/player/PlayerBucketEvent.java
 +++ b/src/main/java/org/bukkit/event/player/PlayerBucketEvent.java
 @@ -0,0 +0,0 @@ import org.bukkit.block.Block;
@@ -82,7 +82,7 @@ index 56584687..3dbe428b 100644
          return cancelled;
      }
 diff --git a/src/main/java/org/bukkit/event/player/PlayerBucketFillEvent.java b/src/main/java/org/bukkit/event/player/PlayerBucketFillEvent.java
-index 94e042a3..884b9240 100644
+index 94e042a36..884b9240b 100644
 --- a/src/main/java/org/bukkit/event/player/PlayerBucketFillEvent.java
 +++ b/src/main/java/org/bukkit/event/player/PlayerBucketFillEvent.java
 @@ -0,0 +0,0 @@ import org.bukkit.block.Block;
diff --git a/Spigot-API-Patches/Allow-disabling-armour-stand-ticking.patch b/Spigot-API-Patches/Allow-disabling-armour-stand-ticking.patch
index 67092293db..27c13d816d 100644
--- a/Spigot-API-Patches/Allow-disabling-armour-stand-ticking.patch
+++ b/Spigot-API-Patches/Allow-disabling-armour-stand-ticking.patch
@@ -5,7 +5,7 @@ Subject: [PATCH] Allow disabling armour stand ticking
 
 
 diff --git a/src/main/java/org/bukkit/entity/ArmorStand.java b/src/main/java/org/bukkit/entity/ArmorStand.java
-index 099da6ce..859f166f 100644
+index 099da6ce1..859f166fb 100644
 --- 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 {
diff --git a/Spigot-API-Patches/AnvilDamageEvent.patch b/Spigot-API-Patches/AnvilDamageEvent.patch
index d6d5ec79e7..76879f6245 100644
--- a/Spigot-API-Patches/AnvilDamageEvent.patch
+++ b/Spigot-API-Patches/AnvilDamageEvent.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] AnvilDamageEvent
 
 diff --git a/src/main/java/com/destroystokyo/paper/event/block/AnvilDamagedEvent.java b/src/main/java/com/destroystokyo/paper/event/block/AnvilDamagedEvent.java
 new file mode 100644
-index 00000000..fd3c5c02
+index 000000000..fd3c5c02e
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/block/AnvilDamagedEvent.java
 @@ -0,0 +0,0 @@
diff --git a/Spigot-API-Patches/Async-Chunks-API.patch b/Spigot-API-Patches/Async-Chunks-API.patch
new file mode 100644
index 0000000000..31716ec834
--- /dev/null
+++ b/Spigot-API-Patches/Async-Chunks-API.patch
@@ -0,0 +1,397 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Mon, 29 Feb 2016 17:43:33 -0600
+Subject: [PATCH] Async Chunks API
+
+Adds API's to load or generate chunks asynchronously.
+
+Also adds utility methods to Entity to teleport asynchronously.
+
+diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
+index e451ca611..bf5c21814 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 {
+     public default Chunk getChunkAt(long chunkKey) {
+         return getChunkAt((int) chunkKey, (int) (chunkKey >> 32));
+     }
++
++    /**
++     * This is the Legacy API before Java 8 was supported. Java 8 Consumer is provided,
++     * as well as future support
++     *
++     * Used by {@link World#getChunkAtAsync(Location,ChunkLoadCallback)} methods
++     * to request a {@link Chunk} to be loaded, with this callback receiving
++     * the chunk when it is finished.
++     *
++     * This callback will be executed on synchronously on the main thread.
++     *
++     * Timing and order this callback is fired is intentionally not defined and
++     * and subject to change.
++     *
++     * @deprecated Use either the Future or the Consumer based methods
++     */
++    @Deprecated
++    public static interface ChunkLoadCallback extends java.util.function.Consumer<Chunk> {
++        public void onLoad(Chunk chunk);
++
++        // backwards compat to old api
++        @Override
++        default void accept(Chunk chunk) {
++            onLoad(chunk);
++        }
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link ChunkLoadCallback} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @deprecated Use either the Future or the Consumer based methods
++     * @param x Chunk X-coordinate of the chunk - (world coordinate / 16)
++     * @param z Chunk Z-coordinate of the chunk - (world coordinate / 16)
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    @Deprecated
++    public default void getChunkAtAsync(int x, int z, ChunkLoadCallback cb) {
++        getChunkAtAsync(x, z, true).thenAccept(cb::onLoad);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given {@link Location}
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link ChunkLoadCallback} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @deprecated Use either the Future or the Consumer based methods
++     * @param loc Location of the chunk
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    @Deprecated
++    public default void getChunkAtAsync(Location loc, ChunkLoadCallback cb) {
++        getChunkAtAsync(loc, true).thenAccept(cb::onLoad);
++    }
++
++    /**
++     * Requests {@link Chunk} to be loaded that contains the given {@link Block}
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link ChunkLoadCallback} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @deprecated Use either the Future or the Consumer based methods
++     * @param block Block to get the containing chunk from
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    @Deprecated
++    public default void getChunkAtAsync(Block block, ChunkLoadCallback cb) {
++        getChunkAtAsync(block, true).thenAccept(cb::onLoad);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link java.util.function.Consumer<Chunk>} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @param x Chunk X-coordinate of the chunk - (world coordinate / 16)
++     * @param z Chunk Z-coordinate of the chunk - (world coordinate / 16)
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    public default void getChunkAtAsync(int x, int z, java.util.function.Consumer<Chunk> cb) {
++        getChunkAtAsync(x, z, true).thenAccept(cb);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link java.util.function.Consumer<Chunk>} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @param x Chunk X-coordinate of the chunk - (world coordinate / 16)
++     * @param z Chunk Z-coordinate of the chunk - (world coordinate / 16)
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    public default void getChunkAtAsync(int x, int z, boolean gen, java.util.function.Consumer<Chunk> cb) {
++        getChunkAtAsync(x, z, gen).thenAccept(cb);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given {@link Location}
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link java.util.function.Consumer<Chunk>} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @param loc Location of the chunk
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    public default void getChunkAtAsync(Location loc, java.util.function.Consumer<Chunk> cb) {
++        getChunkAtAsync((int)loc.getX() >> 4, (int)Math.floor(loc.getZ()) >> 4, true, cb);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given {@link Location}
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link java.util.function.Consumer<Chunk>} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @param loc Location of the chunk
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    public default void getChunkAtAsync(Location loc, boolean gen, java.util.function.Consumer<Chunk> cb) {
++        getChunkAtAsync((int)loc.getX() >> 4, (int)Math.floor(loc.getZ()) >> 4, gen, cb);
++    }
++
++    /**
++     * Requests {@link Chunk} to be loaded that contains the given {@link Block}
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link java.util.function.Consumer<Chunk>} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @param block Block to get the containing chunk from
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    public default void getChunkAtAsync(Block block, java.util.function.Consumer<Chunk> cb) {
++        getChunkAtAsync(block.getX() >> 4, block.getZ() >> 4, true, cb);
++    }
++
++    /**
++     * Requests {@link Chunk} to be loaded that contains the given {@link Block}
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The {@link java.util.function.Consumer<Chunk>} will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @param block Block to get the containing chunk from
++     * @param cb Callback to receive the chunk when it is loaded.
++     *           will be executed synchronously
++     */
++    public default void getChunkAtAsync(Block block, boolean gen, java.util.function.Consumer<Chunk> cb) {
++        getChunkAtAsync(block.getX() >> 4, block.getZ() >> 4, gen, cb);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The future will always be executed synchronously
++     * on the main Server Thread.
++     * @param loc Location to load the corresponding chunk from
++     * @return Future that will resolve when the chunk is loaded
++     */
++    public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(Location loc) {
++        return getChunkAtAsync((int)loc.getX() >> 4, (int)Math.floor(loc.getZ()) >> 4, true);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The future will always be executed synchronously
++     * on the main Server Thread.
++     * @param loc Location to load the corresponding chunk from
++     * @param gen Should the chunk generate
++     * @return Future that will resolve when the chunk is loaded
++     */
++    public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(Location loc, boolean gen) {
++        return getChunkAtAsync((int)loc.getX() >> 4, (int)Math.floor(loc.getZ()) >> 4, gen);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The future will always be executed synchronously
++     * on the main Server Thread.
++     * @param block Block to load the corresponding chunk from
++     * @return Future that will resolve when the chunk is loaded
++     */
++    public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(Block block) {
++        return getChunkAtAsync(block.getX() >> 4, block.getZ() >> 4, true);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The future will always be executed synchronously
++     * on the main Server Thread.
++     * @param block Block to load the corresponding chunk from
++     * @param gen Should the chunk generate
++     * @return Future that will resolve when the chunk is loaded
++     */
++    public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(Block block, boolean gen) {
++        return getChunkAtAsync(block.getX() >> 4, block.getZ() >> 4, gen);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The future will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @param x X Coord
++     * @param z Z Coord
++     * @return Future that will resolve when the chunk is loaded
++     */
++    public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(int x, int z) {
++        return getChunkAtAsync(x, z, true);
++    }
++
++    /**
++     * Requests a {@link Chunk} to be loaded at the given coordinates
++     *
++     * This method makes no guarantee on how fast the chunk will load,
++     * and will return the chunk to the callback at a later time.
++     *
++     * You should use this method if you need a chunk but do not need it
++     * immediately, and you wish to let the server control the speed
++     * of chunk loads, keeping performance in mind.
++     *
++     * The future will always be executed synchronously
++     * on the main Server Thread.
++     *
++     * @param x Chunk X-coordinate of the chunk - (world coordinate / 16)
++     * @param z Chunk Z-coordinate of the chunk - (world coordinate / 16)
++     * @param gen Should we generate a chunk if it doesn't exists or not
++     * @return Future that will resolve when the chunk is loaded
++     */
++    public java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(int x, int z, boolean gen);
+     // Paper end
+ 
+     /**
+diff --git a/src/main/java/org/bukkit/entity/Entity.java b/src/main/java/org/bukkit/entity/Entity.java
+index 72ebe35fb..cd835edce 100644
+--- a/src/main/java/org/bukkit/entity/Entity.java
++++ b/src/main/java/org/bukkit/entity/Entity.java
+@@ -0,0 +0,0 @@ public interface Entity extends Metadatable, CommandSender, Nameable {
+      */
+     public boolean teleport(Entity destination, TeleportCause cause);
+ 
++    // Paper start
++    /**
++     * Loads/Generates(in 1.13+) the Chunk asynchronously, and then teleports the entity when the chunk is ready.
++     * @param loc Location to teleport to
++     * @return A future that will be completed with the result of the teleport
++     */
++    public default java.util.concurrent.CompletableFuture<Boolean> teleportAsync(Location loc) {
++        return teleportAsync(loc, TeleportCause.PLUGIN);
++    }
++    /**
++     * Loads/Generates(in 1.13+) the Chunk asynchronously, and then teleports the entity when the chunk is ready.
++     * @param loc Location to teleport to
++     * @param cause Reason for teleport
++     * @return A future that will be completed with the result of the teleport
++     */
++    public default java.util.concurrent.CompletableFuture<Boolean> teleportAsync(Location loc, TeleportCause cause) {
++        java.util.concurrent.CompletableFuture<Boolean> future = new java.util.concurrent.CompletableFuture<>();
++        loc.getWorld().getChunkAtAsync(loc).thenAccept((chunk) -> future.complete(teleport(loc, cause)));
++        return future;
++    }
++    // Paper end
++
+     /**
+      * Returns a list of entities within a bounding box centered around this
+      * entity
+--
\ No newline at end of file
diff --git a/Spigot-API-Patches/EnderDragon-Events.patch b/Spigot-API-Patches/EnderDragon-Events.patch
index 62125a9d5a..891cdfd29a 100644
--- a/Spigot-API-Patches/EnderDragon-Events.patch
+++ b/Spigot-API-Patches/EnderDragon-Events.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] EnderDragon Events
 
 diff --git a/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonFireballHitEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonFireballHitEvent.java
 new file mode 100644
-index 00000000..ef2a8dab
+index 000000000..ef2a8dab9
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonFireballHitEvent.java
 @@ -0,0 +0,0 @@
@@ -84,7 +84,7 @@ index 00000000..ef2a8dab
 +}
 diff --git a/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonFlameEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonFlameEvent.java
 new file mode 100644
-index 00000000..d8c3ab33
+index 000000000..d8c3ab330
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonFlameEvent.java
 @@ -0,0 +0,0 @@
@@ -146,7 +146,7 @@ index 00000000..d8c3ab33
 +}
 diff --git a/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonShootFireballEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonShootFireballEvent.java
 new file mode 100644
-index 00000000..aa70dda1
+index 000000000..aa70dda10
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/entity/EnderDragonShootFireballEvent.java
 @@ -0,0 +0,0 @@
diff --git a/Spigot-API-Patches/EntityTransformedEvent.patch b/Spigot-API-Patches/EntityTransformedEvent.patch
index 65681a00c5..8e824fcfe4 100644
--- a/Spigot-API-Patches/EntityTransformedEvent.patch
+++ b/Spigot-API-Patches/EntityTransformedEvent.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] EntityTransformedEvent
 
 diff --git a/src/main/java/com/destroystokyo/paper/event/entity/EntityTransformedEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/EntityTransformedEvent.java
 new file mode 100644
-index 00000000..d9e5cab9
+index 000000000..d9e5cab95
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/entity/EntityTransformedEvent.java
 @@ -0,0 +0,0 @@
diff --git a/Spigot-API-Patches/Expand-ArmorStand-API.patch b/Spigot-API-Patches/Expand-ArmorStand-API.patch
index 8f4cc2b8e7..de79323a33 100644
--- a/Spigot-API-Patches/Expand-ArmorStand-API.patch
+++ b/Spigot-API-Patches/Expand-ArmorStand-API.patch
@@ -8,7 +8,7 @@ Add the following:
 - Enable/Disable slot interactions
 
 diff --git a/src/main/java/org/bukkit/entity/ArmorStand.java b/src/main/java/org/bukkit/entity/ArmorStand.java
-index 859f166f..eda4873d 100644
+index 859f166fb..eda4873d5 100644
 --- a/src/main/java/org/bukkit/entity/ArmorStand.java
 +++ b/src/main/java/org/bukkit/entity/ArmorStand.java
 @@ -0,0 +0,0 @@
diff --git a/Spigot-API-Patches/Expand-Location-Manipulation-API.patch b/Spigot-API-Patches/Expand-Location-Manipulation-API.patch
index 871d24565d..d6fc5e59de 100644
--- a/Spigot-API-Patches/Expand-Location-Manipulation-API.patch
+++ b/Spigot-API-Patches/Expand-Location-Manipulation-API.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] Expand Location Manipulation API
 Adds set(x, y, z), add(base, x, y, z), subtract(base, x, y, z);
 
 diff --git a/src/main/java/org/bukkit/Location.java b/src/main/java/org/bukkit/Location.java
-index 056a4d6b..8dcb15fb 100644
+index 056a4d6bb..8dcb15fb8 100644
 --- a/src/main/java/org/bukkit/Location.java
 +++ b/src/main/java/org/bukkit/Location.java
 @@ -0,0 +0,0 @@ public class Location implements Cloneable, ConfigurationSerializable {
diff --git a/Spigot-API-Patches/PlayerElytraBoostEvent.patch b/Spigot-API-Patches/PlayerElytraBoostEvent.patch
index a0079e2839..b55b338c3b 100644
--- a/Spigot-API-Patches/PlayerElytraBoostEvent.patch
+++ b/Spigot-API-Patches/PlayerElytraBoostEvent.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] PlayerElytraBoostEvent
 
 diff --git a/src/main/java/com/destroystokyo/paper/event/player/PlayerElytraBoostEvent.java b/src/main/java/com/destroystokyo/paper/event/player/PlayerElytraBoostEvent.java
 new file mode 100644
-index 00000000..cecb2182
+index 000000000..cecb2182c
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerElytraBoostEvent.java
 @@ -0,0 +0,0 @@
diff --git a/Spigot-API-Patches/PlayerLaunchProjectileEvent.patch b/Spigot-API-Patches/PlayerLaunchProjectileEvent.patch
index 2fc6099b14..8e9ed08bab 100644
--- a/Spigot-API-Patches/PlayerLaunchProjectileEvent.patch
+++ b/Spigot-API-Patches/PlayerLaunchProjectileEvent.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] PlayerLaunchProjectileEvent
 
 diff --git a/src/main/java/com/destroystokyo/paper/event/player/PlayerLaunchProjectileEvent.java b/src/main/java/com/destroystokyo/paper/event/player/PlayerLaunchProjectileEvent.java
 new file mode 100644
-index 00000000..d2b244a4
+index 000000000..d2b244a41
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/player/PlayerLaunchProjectileEvent.java
 @@ -0,0 +0,0 @@
diff --git a/Spigot-API-Patches/Provide-Chunk-Coordinates-as-a-Long-API.patch b/Spigot-API-Patches/Provide-Chunk-Coordinates-as-a-Long-API.patch
index e1ef532510..8aa2328980 100644
--- a/Spigot-API-Patches/Provide-Chunk-Coordinates-as-a-Long-API.patch
+++ b/Spigot-API-Patches/Provide-Chunk-Coordinates-as-a-Long-API.patch
@@ -7,7 +7,7 @@ Allows you to easily access the chunks X/z as a long, and a method
 to look up by the long key too.
 
 diff --git a/src/main/java/org/bukkit/Chunk.java b/src/main/java/org/bukkit/Chunk.java
-index 079b9feb..c75bce07 100644
+index 079b9febe..b347a3ccf 100644
 --- a/src/main/java/org/bukkit/Chunk.java
 +++ b/src/main/java/org/bukkit/Chunk.java
 @@ -0,0 +0,0 @@ public interface Chunk {
@@ -19,7 +19,24 @@ index 079b9feb..c75bce07 100644
 +     * @return The Chunks X and Z coordinates packed into a long
 +     */
 +    default long getChunkKey() {
-+        return (long) getX() & 0xffffffffL | ((long) getZ() & 0xffffffffL) << 32;
++        return getChunkKey(getX(), getZ());
++    }
++
++    /**
++     * @param loc Location to get chunk key
++     * @return Location's chunk coordinates packed into a long
++     */
++    static long getChunkKey(Location loc) {
++        return getChunkKey((int) Math.floor(loc.getX()) << 4, (int) Math.floor(loc.getZ()) << 4);
++    }
++
++    /**
++     * @param x X Coordinate
++     * @param z Z Coordinate
++     * @return Chunk coordinates packed into a long
++     */
++    static long getChunkKey(int x, int z) {
++        return (long) x & 0xffffffffL | ((long) z & 0xffffffffL) << 32;
 +    }
 +    // Paper end
 +
@@ -27,7 +44,7 @@ index 079b9feb..c75bce07 100644
       * Gets the world containing this chunk
       *
 diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
-index dbbcfec9..724088ec 100644
+index 5e6cb56ab..e451ca611 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 {
@@ -50,6 +67,6 @@ index dbbcfec9..724088ec 100644
 +    // Paper end
 +
      /**
-      * Used by {@link World#getChunkAtAsync(Location,ChunkLoadCallback)} methods
-      * to request a {@link Chunk} to be loaded, with this callback receiving
+      * Checks if the specified {@link Chunk} is loaded
+      *
 --
\ No newline at end of file
diff --git a/Spigot-API-Patches/Remove-deadlock-risk-in-firing-async-events.patch b/Spigot-API-Patches/Remove-deadlock-risk-in-firing-async-events.patch
index b52582cd9e..ada45a3bee 100644
--- a/Spigot-API-Patches/Remove-deadlock-risk-in-firing-async-events.patch
+++ b/Spigot-API-Patches/Remove-deadlock-risk-in-firing-async-events.patch
@@ -16,7 +16,7 @@ which results in a hard crash.
 This change removes the synchronize and adds some protection around enable/disable
 
 diff --git a/src/main/java/org/bukkit/plugin/SimplePluginManager.java b/src/main/java/org/bukkit/plugin/SimplePluginManager.java
-index cb2b0b9c..a7dd902f 100644
+index cb2b0b9cb..a7dd902fb 100644
 --- a/src/main/java/org/bukkit/plugin/SimplePluginManager.java
 +++ b/src/main/java/org/bukkit/plugin/SimplePluginManager.java
 @@ -0,0 +0,0 @@ public final class SimplePluginManager implements PluginManager {
@@ -79,7 +79,7 @@ index cb2b0b9c..a7dd902f 100644
          RegisteredListener[] listeners = handlers.getRegisteredListeners();
  
 diff --git a/src/test/java/org/bukkit/plugin/PluginManagerTest.java b/src/test/java/org/bukkit/plugin/PluginManagerTest.java
-index 6b86128e..56308c0c 100644
+index 6b86128e1..56308c0c6 100644
 --- a/src/test/java/org/bukkit/plugin/PluginManagerTest.java
 +++ b/src/test/java/org/bukkit/plugin/PluginManagerTest.java
 @@ -0,0 +0,0 @@ public class PluginManagerTest {
diff --git a/Spigot-API-Patches/SkeletonHorse-Additions.patch b/Spigot-API-Patches/SkeletonHorse-Additions.patch
index 718d5499b6..58c1e84788 100644
--- a/Spigot-API-Patches/SkeletonHorse-Additions.patch
+++ b/Spigot-API-Patches/SkeletonHorse-Additions.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] SkeletonHorse Additions
 
 diff --git a/src/main/java/com/destroystokyo/paper/event/entity/SkeletonHorseTrapEvent.java b/src/main/java/com/destroystokyo/paper/event/entity/SkeletonHorseTrapEvent.java
 new file mode 100644
-index 00000000..55bae018
+index 000000000..55bae018e
 --- /dev/null
 +++ b/src/main/java/com/destroystokyo/paper/event/entity/SkeletonHorseTrapEvent.java
 @@ -0,0 +0,0 @@
@@ -54,7 +54,7 @@ index 00000000..55bae018
 +}
 +
 diff --git a/src/main/java/org/bukkit/entity/SkeletonHorse.java b/src/main/java/org/bukkit/entity/SkeletonHorse.java
-index b2c6b6a8..ba998346 100644
+index b2c6b6a86..ba9983463 100644
 --- a/src/main/java/org/bukkit/entity/SkeletonHorse.java
 +++ b/src/main/java/org/bukkit/entity/SkeletonHorse.java
 @@ -0,0 +0,0 @@ package org.bukkit.entity;
diff --git a/Spigot-API-Patches/isChunkGenerated-API.patch b/Spigot-API-Patches/isChunkGenerated-API.patch
index f7d3712077..0f4bfc67e0 100644
--- a/Spigot-API-Patches/isChunkGenerated-API.patch
+++ b/Spigot-API-Patches/isChunkGenerated-API.patch
@@ -3,10 +3,9 @@ From: cswhite2000 <18whitechristop@gmail.com>
 Date: Tue, 21 Aug 2018 19:39:46 -0700
 Subject: [PATCH] isChunkGenerated API
 
-Resolves #1329
 
 diff --git a/src/main/java/org/bukkit/Location.java b/src/main/java/org/bukkit/Location.java
-index 7e1ee875..9457832b 100644
+index 7e1ee875e..9457832bc 100644
 --- a/src/main/java/org/bukkit/Location.java
 +++ b/src/main/java/org/bukkit/Location.java
 @@ -0,0 +0,0 @@ import org.bukkit.util.NumberConversions;
@@ -34,14 +33,13 @@ index 7e1ee875..9457832b 100644
      /**
       * Sets the position of this Location and returns itself
 diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
-index d4bfbad3..53764fae 100644
+index 348f1c98d..9c06fc163 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 {
-     public default Chunk getChunkAt(long chunkKey) {
          return getChunkAt((int) chunkKey, (int) (chunkKey >> 32));
      }
-+
+ 
 +    /**
 +     * Checks if a {@link Chunk} has been generated at the specified chunk key,
 +     * which is the X and Z packed into a long.
@@ -61,7 +59,8 @@ index d4bfbad3..53764fae 100644
 +     * @return true if the chunk has been generated, otherwise false
 +     */
 +    public boolean isChunkGenerated(int x, int z);
-     // Paper end
- 
++
      /**
+      * This is the Legacy API before Java 8 was supported. Java 8 Consumer is provided,
+      * as well as future support
 --
\ No newline at end of file
diff --git a/Spigot-Server-Patches/Add-async-chunk-load-API.patch b/Spigot-Server-Patches/Add-async-chunk-load-API.patch
index 25054be153..ac48175a62 100644
--- a/Spigot-Server-Patches/Add-async-chunk-load-API.patch
+++ b/Spigot-Server-Patches/Add-async-chunk-load-API.patch
@@ -5,7 +5,7 @@ Subject: [PATCH] Add async chunk load API
 
 
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index e4c4cdb980..af977b171a 100644
+index e4c4cdb980..c2aa3917bf 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 {
@@ -13,23 +13,14 @@ index e4c4cdb980..af977b171a 100644
      }
  
 +    // Paper start - Async chunk load API
-+    public void getChunkAtAsync(final int x, final int z, final ChunkLoadCallback callback) {
++    @Override
++    public java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(final int x, final int z, final boolean gen) {
 +        final ChunkProviderServer cps = this.world.getChunkProviderServer();
-+        callback.onLoad(cps.getChunkAt(x, z, true, true).bukkitChunk); // TODO: Add back async variant
-+        /*cps.getChunkAt(x, z, new Runnable() {
-+            @Override
-+            public void run() {
-+                callback.onLoad(cps.getChunkAt(x, z).bukkitChunk);
-+            }
-+        });*/
-+    }
-+
-+    public void getChunkAtAsync(Block block, ChunkLoadCallback callback) {
-+        getChunkAtAsync(block.getX() >> 4, block.getZ() >> 4, callback);
-+    }
-+
-+    public void getChunkAtAsync(Location location, ChunkLoadCallback callback) {
-+        getChunkAtAsync(location.getBlockX() >> 4, location.getBlockZ() >> 4, callback);
++        java.util.concurrent.CompletableFuture<Chunk> future = new java.util.concurrent.CompletableFuture<>();
++        net.minecraft.server.Chunk chunk = cps.getChunkAt(x, z, true, gen);
++        // TODO: Add back async variant
++        future.complete(chunk != null ? chunk.bukkitChunk : null);
++        return future;
 +    }
 +    // Paper end
 +
diff --git a/Spigot-Server-Patches/Ignore-Dead-Entities-in-entityList-iteration.patch b/Spigot-Server-Patches/Ignore-Dead-Entities-in-entityList-iteration.patch
index b5a74c18ae..05467591b4 100644
--- a/Spigot-Server-Patches/Ignore-Dead-Entities-in-entityList-iteration.patch
+++ b/Spigot-Server-Patches/Ignore-Dead-Entities-in-entityList-iteration.patch
@@ -71,7 +71,7 @@ index 597169b4cc..b18ea7154f 100644
              if (entity instanceof EntityInsentient) {
                  EntityInsentient entityinsentient = (EntityInsentient) entity;
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index af977b171a..80fd49b6e1 100644
+index c2aa3917bf..edf2e39e3d 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 {
diff --git a/Spigot-Server-Patches/Implement-Force-Loaded-Chunk-API.patch b/Spigot-Server-Patches/Implement-Force-Loaded-Chunk-API.patch
index 9d93b8c12a..581676c6f3 100644
--- a/Spigot-Server-Patches/Implement-Force-Loaded-Chunk-API.patch
+++ b/Spigot-Server-Patches/Implement-Force-Loaded-Chunk-API.patch
@@ -40,7 +40,7 @@ index 12c6d850d2..55394e0c15 100644
          Arrays.fill(emptySkyLight, (byte) 0xFF);
      }
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 1ccf2a7609..755d2632fd 100644
+index 99d8199996..f8ef782f14 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 {
diff --git a/Spigot-Server-Patches/Make-CraftWorld-loadChunk-int-int-false-load-unconve.patch b/Spigot-Server-Patches/Make-CraftWorld-loadChunk-int-int-false-load-unconve.patch
index 5534cf03ba..1f0c775bf6 100644
--- a/Spigot-Server-Patches/Make-CraftWorld-loadChunk-int-int-false-load-unconve.patch
+++ b/Spigot-Server-Patches/Make-CraftWorld-loadChunk-int-int-false-load-unconve.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] Make CraftWorld#loadChunk(int, int, false) load unconverted
 
 
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 585a0c7fd2..b38e394f83 100644
+index b411776c3c..262363999d 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 {
diff --git a/Spigot-Server-Patches/Optimize-getChunkIfLoaded-type-calls.patch b/Spigot-Server-Patches/Optimize-getChunkIfLoaded-type-calls.patch
index 6e927ce963..fd65f77a2b 100644
--- a/Spigot-Server-Patches/Optimize-getChunkIfLoaded-type-calls.patch
+++ b/Spigot-Server-Patches/Optimize-getChunkIfLoaded-type-calls.patch
@@ -55,7 +55,7 @@ index 2ff8536d59..0c42d042b1 100644
              return chunk != null && !chunk.isEmpty();
          }
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 755d2632fd..585a0c7fd2 100644
+index f8ef782f14..b411776c3c 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 {
diff --git a/Spigot-Server-Patches/Send-nearby-packets-from-world-player-list-not-serve.patch b/Spigot-Server-Patches/Send-nearby-packets-from-world-player-list-not-serve.patch
index 571d3b7464..6bc4de4aa0 100644
--- a/Spigot-Server-Patches/Send-nearby-packets-from-world-player-list-not-serve.patch
+++ b/Spigot-Server-Patches/Send-nearby-packets-from-world-player-list-not-serve.patch
@@ -119,7 +119,7 @@ index 911d03c70b..f837e6c36c 100644
          }
  
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 80fd49b6e1..ba2e768594 100644
+index edf2e39e3d..2611971575 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 {
diff --git a/Spigot-Server-Patches/isChunkGenerated-API.patch b/Spigot-Server-Patches/isChunkGenerated-API.patch
index c67c611523..3eb6a4c043 100644
--- a/Spigot-Server-Patches/isChunkGenerated-API.patch
+++ b/Spigot-Server-Patches/isChunkGenerated-API.patch
@@ -6,7 +6,7 @@ Subject: [PATCH] isChunkGenerated API
 Resolves #1329
 
 diff --git a/src/main/java/net/minecraft/server/ChunkProviderServer.java b/src/main/java/net/minecraft/server/ChunkProviderServer.java
-index 0ca071b879..96d49b469a 100644
+index 60f249a031..fc621911e0 100644
 --- a/src/main/java/net/minecraft/server/ChunkProviderServer.java
 +++ b/src/main/java/net/minecraft/server/ChunkProviderServer.java
 @@ -0,0 +0,0 @@ public class ChunkProviderServer implements IChunkProvider {
@@ -20,7 +20,7 @@ index 0ca071b879..96d49b469a 100644
      public final Long2ObjectMap<Chunk> chunks = Long2ObjectMaps.synchronize(new ChunkMap(8192));
      private Chunk lastChunk;
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index ba2e768594..1ccf2a7609 100644
+index 2611971575..99d8199996 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 {