mirror of
https://github.com/PaperMC/Paper.git
synced 2024-12-01 04:31:58 +01:00
90fe0d58a5
Upstream has released updates that appear to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: 897a0a23 SPIGOT-5753: Back PotionType by a minecraft registry 255b2aa1 SPIGOT-7080: Add World#locateNearestBiome ff984826 Remove javadoc.io doc links CraftBukkit Changes: 71b0135cc SPIGOT-5753: Back PotionType by a minecraft registry a6bcb8489 SPIGOT-7080: Add World#locateNearestBiome ad0e57434 SPIGOT-7502: CraftMetaItem - cannot deserialize BlockStateTag b3efca57a SPIGOT-6400: Use Mockito instead of InvocationHandler 38c599f9d PR-1272: Only allow one entity in CraftItem instead of two f065271ac SPIGOT-7498: ChunkSnapshot.getBlockEmittedLight() gets 64 blocks upper in Overworld Spigot Changes: e0e223fe Remove javadoc.io doc links
534 lines
24 KiB
Diff
534 lines
24 KiB
Diff
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 880ff5ee1237096ac2da115b665dc663c677e57b..fc6b99e4f37179b15254bf0b398b1a800de1b73f 100644
|
|
--- a/src/main/java/org/bukkit/World.java
|
|
+++ b/src/main/java/org/bukkit/World.java
|
|
@@ -955,6 +955,482 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
|
|
}
|
|
return nearby;
|
|
}
|
|
+
|
|
+ /**
|
|
+ * 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(@NotNull Chunk chunk);
|
|
+
|
|
+ // backwards compat to old api
|
|
+ @Override
|
|
+ default void accept(@NotNull 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 - floor(world coordinate / 16)
|
|
+ * @param z Chunk Z-coordinate of the chunk - floor(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, @NotNull ChunkLoadCallback cb) {
|
|
+ getChunkAtAsync(x, z, true).thenAccept(cb::onLoad).exceptionally((ex) -> {
|
|
+ Bukkit.getLogger().log(java.util.logging.Level.WARNING, "Exception in chunk load callback", ex);
|
|
+ return null;
|
|
+ });
|
|
+ }
|
|
+
|
|
+ /**
|
|
+ * 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(@NotNull Location loc, @NotNull ChunkLoadCallback cb) {
|
|
+ getChunkAtAsync(loc, true).thenAccept(cb::onLoad).exceptionally((ex) -> {
|
|
+ Bukkit.getLogger().log(java.util.logging.Level.WARNING, "Exception in chunk load callback", ex);
|
|
+ return null;
|
|
+ });
|
|
+ }
|
|
+
|
|
+ /**
|
|
+ * 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(@NotNull Block block, @NotNull ChunkLoadCallback cb) {
|
|
+ getChunkAtAsync(block, true).thenAccept(cb::onLoad).exceptionally((ex) -> {
|
|
+ Bukkit.getLogger().log(java.util.logging.Level.WARNING, "Exception in chunk load callback", ex);
|
|
+ return null;
|
|
+ });
|
|
+ }
|
|
+
|
|
+ /**
|
|
+ * 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} will always be executed synchronously
|
|
+ * on the main Server Thread.
|
|
+ *
|
|
+ * @param x Chunk X-coordinate of the chunk - floor(world coordinate / 16)
|
|
+ * @param z Chunk Z-coordinate of the chunk - floor(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, @NotNull java.util.function.Consumer<Chunk> cb) {
|
|
+ getChunkAtAsync(x, z, true).thenAccept(cb).exceptionally((ex) -> {
|
|
+ Bukkit.getLogger().log(java.util.logging.Level.WARNING, "Exception in chunk load callback", ex);
|
|
+ return null;
|
|
+ });
|
|
+ }
|
|
+
|
|
+ /**
|
|
+ * 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} will always be executed synchronously
|
|
+ * on the main Server Thread.
|
|
+ *
|
|
+ * @param x Chunk X-coordinate of the chunk - floor(world coordinate / 16)
|
|
+ * @param z Chunk Z-coordinate of the chunk - floor(world coordinate / 16)
|
|
+ * @param gen Should we generate a chunk if it doesn't exist or not
|
|
+ * @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, @NotNull java.util.function.Consumer<Chunk> cb) {
|
|
+ getChunkAtAsync(x, z, gen).thenAccept(cb).exceptionally((ex) -> {
|
|
+ Bukkit.getLogger().log(java.util.logging.Level.WARNING, "Exception in chunk load callback", ex);
|
|
+ return null;
|
|
+ });
|
|
+ }
|
|
+
|
|
+ /**
|
|
+ * 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} 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(@NotNull Location loc, @NotNull java.util.function.Consumer<Chunk> cb) {
|
|
+ getChunkAtAsync((int)Math.floor(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} will always be executed synchronously
|
|
+ * on the main Server Thread.
|
|
+ *
|
|
+ * @param loc Location of the chunk
|
|
+ * @param gen Should the chunk generate if it doesn't exist
|
|
+ * @param cb Callback to receive the chunk when it is loaded.
|
|
+ * will be executed synchronously
|
|
+ */
|
|
+ public default void getChunkAtAsync(@NotNull Location loc, boolean gen, @NotNull java.util.function.Consumer<Chunk> cb) {
|
|
+ getChunkAtAsync((int)Math.floor(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} 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(@NotNull Block block, @NotNull 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} will always be executed synchronously
|
|
+ * on the main Server Thread.
|
|
+ *
|
|
+ * @param block Block to get the containing chunk from
|
|
+ * @param gen Should the chunk generate if it doesn't exist
|
|
+ * @param cb Callback to receive the chunk when it is loaded.
|
|
+ * will be executed synchronously
|
|
+ */
|
|
+ public default void getChunkAtAsync(@NotNull Block block, boolean gen, @NotNull 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
|
|
+ */
|
|
+ @NotNull
|
|
+ public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(@NotNull Location loc) {
|
|
+ return getChunkAtAsync((int)Math.floor(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 if it doesn't exist
|
|
+ * @return Future that will resolve when the chunk is loaded
|
|
+ */
|
|
+ @NotNull
|
|
+ public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(@NotNull Location loc, boolean gen) {
|
|
+ return getChunkAtAsync((int)Math.floor(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
|
|
+ */
|
|
+ @NotNull
|
|
+ public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(@NotNull 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 if it doesn't exist
|
|
+ * @return Future that will resolve when the chunk is loaded
|
|
+ */
|
|
+ @NotNull
|
|
+ public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(@NotNull 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 Chunk X-coordinate of the chunk - floor(world coordinate / 16)
|
|
+ * @param z Chunk Z-coordinate of the chunk - floor(world coordinate / 16)
|
|
+ * @return Future that will resolve when the chunk is loaded
|
|
+ */
|
|
+ @NotNull
|
|
+ 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 - floor(world coordinate / 16)
|
|
+ * @param z Chunk Z-coordinate of the chunk - floor(world coordinate / 16)
|
|
+ * @param gen Should we generate a chunk if it doesn't exist or not
|
|
+ * @return Future that will resolve when the chunk is loaded
|
|
+ */
|
|
+ @NotNull
|
|
+ public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(int x, int z, boolean gen) {
|
|
+ return getChunkAtAsync(x, z, gen, false);
|
|
+ }
|
|
+
|
|
+ /**
|
|
+ * 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
|
|
+ */
|
|
+ @NotNull
|
|
+ public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsyncUrgently(@NotNull Location loc) {
|
|
+ return getChunkAtAsync((int)Math.floor(loc.getX()) >> 4, (int)Math.floor(loc.getZ()) >> 4, true, 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 if it doesn't exist
|
|
+ * @return Future that will resolve when the chunk is loaded
|
|
+ */
|
|
+ @NotNull
|
|
+ public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsyncUrgently(@NotNull Location loc, boolean gen) {
|
|
+ return getChunkAtAsync((int)Math.floor(loc.getX()) >> 4, (int)Math.floor(loc.getZ()) >> 4, gen, 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
|
|
+ * @return Future that will resolve when the chunk is loaded
|
|
+ */
|
|
+ @NotNull
|
|
+ public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsyncUrgently(@NotNull Block block) {
|
|
+ return getChunkAtAsync(block.getX() >> 4, block.getZ() >> 4, true, 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 if it doesn't exist
|
|
+ * @return Future that will resolve when the chunk is loaded
|
|
+ */
|
|
+ @NotNull
|
|
+ public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsyncUrgently(@NotNull Block block, boolean gen) {
|
|
+ return getChunkAtAsync(block.getX() >> 4, block.getZ() >> 4, gen, 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 X Coord
|
|
+ * @param z Z Coord
|
|
+ * @return Future that will resolve when the chunk is loaded
|
|
+ */
|
|
+ @NotNull
|
|
+ public default java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsyncUrgently(int x, int z) {
|
|
+ return getChunkAtAsync(x, z, true, true);
|
|
+ }
|
|
+
|
|
+ @NotNull
|
|
+ java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsync(int x, int z, boolean gen, boolean urgent);
|
|
// Paper end
|
|
|
|
/**
|
|
diff --git a/src/main/java/org/bukkit/entity/Entity.java b/src/main/java/org/bukkit/entity/Entity.java
|
|
index 5fc085f785719933eef7ab1b3cf173579c64739b..711d95bfafac0d415895023bdaac4059395667ab 100644
|
|
--- a/src/main/java/org/bukkit/entity/Entity.java
|
|
+++ b/src/main/java/org/bukkit/entity/Entity.java
|
|
@@ -165,6 +165,33 @@ public interface Entity extends Metadatable, CommandSender, Nameable, Persistent
|
|
*/
|
|
public boolean teleport(@NotNull Entity destination, @NotNull 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
|
|
+ */
|
|
+ @NotNull
|
|
+ public default java.util.concurrent.CompletableFuture<Boolean> teleportAsync(@NotNull 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
|
|
+ */
|
|
+ @NotNull
|
|
+ public default java.util.concurrent.CompletableFuture<Boolean> teleportAsync(@NotNull Location loc, @NotNull TeleportCause cause) {
|
|
+ java.util.concurrent.CompletableFuture<Boolean> future = new java.util.concurrent.CompletableFuture<>();
|
|
+ loc.getWorld().getChunkAtAsyncUrgently(loc).thenAccept((chunk) -> future.complete(teleport(loc, cause))).exceptionally(ex -> {
|
|
+ future.completeExceptionally(ex);
|
|
+ return null;
|
|
+ });
|
|
+ return future;
|
|
+ }
|
|
+ // Paper end
|
|
+
|
|
/**
|
|
* Returns a list of entities within a bounding box centered around this
|
|
* entity
|