Merge remote-tracking branch 'leaf/dev/1.17' into dev/1.17
This commit is contained in:
commit
5e9c53b5b7
30 changed files with 672 additions and 1483 deletions
534
patches/api/0134-Async-Chunks-API.patch
Normal file
534
patches/api/0134-Async-Chunks-API.patch
Normal file
|
@ -0,0 +1,534 @@
|
|||
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 a7bd869fb5b8e35274eee0d8dae9dd6fe3c1c540..e88c98528ca9e8d636e0b30f4209f7205c5eb9f6 100644
|
||||
--- a/src/main/java/org/bukkit/World.java
|
||||
+++ b/src/main/java/org/bukkit/World.java
|
||||
@@ -910,6 +910,482 @@ public interface World extends PluginMessageRecipient, Metadatable, net.kyori.ad
|
||||
}
|
||||
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 - (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, @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 - (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, @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 - (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
|
||||
+ * @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
|
||||
+ * @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
|
||||
+ * @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
|
||||
+ * @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
|
||||
+ * @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 X Coord
|
||||
+ * @param z Z Coord
|
||||
+ * @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 - (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
|
||||
+ */
|
||||
+ @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
|
||||
+ * @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
|
||||
+ * @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 ef95afb92f7a6fea77fe483e26ee3cf6d1bdd041..896b86c212767264c81eb1868a061979e4536c6c 100644
|
||||
--- a/src/main/java/org/bukkit/entity/Entity.java
|
||||
+++ b/src/main/java/org/bukkit/entity/Entity.java
|
||||
@@ -163,6 +163,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
|
|
@ -44,7 +44,7 @@ index beac1439c71fb28f1a3baecf56157237e12ccfd5..fa576096e908f8fbdbef53e1bd91215a
|
|||
* 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 a7bd869fb5b8e35274eee0d8dae9dd6fe3c1c540..85c9ea1241d580386be00fb85ea1446addd376c4 100644
|
||||
index e88c98528ca9e8d636e0b30f4209f7205c5eb9f6..f45bea24a350c3700bdbf4c44aeb1c0562e57d9e 100644
|
||||
--- a/src/main/java/org/bukkit/World.java
|
||||
+++ b/src/main/java/org/bukkit/World.java
|
||||
@@ -207,6 +207,22 @@ public interface World extends PluginMessageRecipient, Metadatable, net.kyori.ad
|
|
@ -48,7 +48,7 @@ index 369ce9ff6c8bb97a64a8e229115564412e6e7654..e700875beb76dadd55b585aca748338d
|
|||
* @return A new location where X/Y/Z are the center of the block
|
||||
*/
|
||||
diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
|
||||
index 85c9ea1241d580386be00fb85ea1446addd376c4..4f563c6afc3568a5a45594bcc87790eeefc4148d 100644
|
||||
index f45bea24a350c3700bdbf4c44aeb1c0562e57d9e..a653a09968123724f9ec5501760257b3944b49c9 100644
|
||||
--- a/src/main/java/org/bukkit/World.java
|
||||
+++ b/src/main/java/org/bukkit/World.java
|
||||
@@ -90,6 +90,38 @@ public interface World extends PluginMessageRecipient, Metadatable, net.kyori.ad
|
|
@ -34,7 +34,7 @@ index e700875beb76dadd55b585aca748338def286908..9c91c49ed7302c12fcb1d8e9bc58712e
|
|||
/**
|
||||
* 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 4f563c6afc3568a5a45594bcc87790eeefc4148d..868e34482a3a5773dfbdc80b36adcee25239614a 100644
|
||||
index a653a09968123724f9ec5501760257b3944b49c9..1264c65235e622f648d71ef10d804ef5193da973 100644
|
||||
--- a/src/main/java/org/bukkit/World.java
|
||||
+++ b/src/main/java/org/bukkit/World.java
|
||||
@@ -253,6 +253,17 @@ public interface World extends PluginMessageRecipient, Metadatable, net.kyori.ad
|
148
patches/api/0146-Add-ray-tracing-methods-to-LivingEntity.patch
Normal file
148
patches/api/0146-Add-ray-tracing-methods-to-LivingEntity.patch
Normal file
|
@ -0,0 +1,148 @@
|
|||
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
||||
From: BillyGalbreath <Blake.Galbreath@GMail.com>
|
||||
Date: Mon, 3 Sep 2018 18:13:53 -0500
|
||||
Subject: [PATCH] Add ray tracing methods to LivingEntity
|
||||
|
||||
|
||||
diff --git a/src/main/java/com/destroystokyo/paper/block/TargetBlockInfo.java b/src/main/java/com/destroystokyo/paper/block/TargetBlockInfo.java
|
||||
new file mode 100644
|
||||
index 0000000000000000000000000000000000000000..18a96dbb01d3b34476652264b2d6be3782a154ec
|
||||
--- /dev/null
|
||||
+++ b/src/main/java/com/destroystokyo/paper/block/TargetBlockInfo.java
|
||||
@@ -0,0 +1,54 @@
|
||||
+package com.destroystokyo.paper.block;
|
||||
+
|
||||
+import org.bukkit.block.Block;
|
||||
+import org.bukkit.block.BlockFace;
|
||||
+import org.jetbrains.annotations.NotNull;
|
||||
+
|
||||
+/**
|
||||
+ * Represents information about a targeted block
|
||||
+ */
|
||||
+public class TargetBlockInfo {
|
||||
+ private final Block block;
|
||||
+ private final BlockFace blockFace;
|
||||
+
|
||||
+ public TargetBlockInfo(@NotNull Block block, @NotNull BlockFace blockFace) {
|
||||
+ this.block = block;
|
||||
+ this.blockFace = blockFace;
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Get the block that is targeted
|
||||
+ *
|
||||
+ * @return Targeted block
|
||||
+ */
|
||||
+ @NotNull
|
||||
+ public Block getBlock() {
|
||||
+ return block;
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Get the targeted BlockFace
|
||||
+ *
|
||||
+ * @return Targeted blockface
|
||||
+ */
|
||||
+ @NotNull
|
||||
+ public BlockFace getBlockFace() {
|
||||
+ return blockFace;
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Get the relative Block to the targeted block on the side it is targeted at
|
||||
+ *
|
||||
+ * @return Block relative to targeted block
|
||||
+ */
|
||||
+ @NotNull
|
||||
+ public Block getRelativeBlock() {
|
||||
+ return block.getRelative(blockFace);
|
||||
+ }
|
||||
+
|
||||
+ public enum FluidMode {
|
||||
+ NEVER,
|
||||
+ SOURCE_ONLY,
|
||||
+ ALWAYS
|
||||
+ }
|
||||
+}
|
||||
diff --git a/src/main/java/org/bukkit/entity/LivingEntity.java b/src/main/java/org/bukkit/entity/LivingEntity.java
|
||||
index 4f62a49e7b0538f0ce9cecd2c1b645f40ce17b3d..05992ade1bca42a6233373b44513b89986d89c5a 100644
|
||||
--- a/src/main/java/org/bukkit/entity/LivingEntity.java
|
||||
+++ b/src/main/java/org/bukkit/entity/LivingEntity.java
|
||||
@@ -82,6 +82,77 @@ public interface LivingEntity extends Attributable, Damageable, ProjectileSource
|
||||
@NotNull
|
||||
public Block getTargetBlock(@Nullable Set<Material> transparent, int maxDistance);
|
||||
|
||||
+ // Paper start
|
||||
+ /**
|
||||
+ * Gets the block that the living entity has targeted, ignoring fluids
|
||||
+ *
|
||||
+ * @param maxDistance this is the maximum distance to scan
|
||||
+ * @return block that the living entity has targeted,
|
||||
+ * or null if no block is within maxDistance
|
||||
+ */
|
||||
+ @Nullable
|
||||
+ public default Block getTargetBlock(int maxDistance) {
|
||||
+ return getTargetBlock(maxDistance, com.destroystokyo.paper.block.TargetBlockInfo.FluidMode.NEVER);
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Gets the block that the living entity has targeted
|
||||
+ *
|
||||
+ * @param maxDistance this is the maximum distance to scan
|
||||
+ * @param fluidMode whether to check fluids or not
|
||||
+ * @return block that the living entity has targeted,
|
||||
+ * or null if no block is within maxDistance
|
||||
+ */
|
||||
+ @Nullable
|
||||
+ public Block getTargetBlock(int maxDistance, @NotNull com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode);
|
||||
+
|
||||
+ /**
|
||||
+ * Gets the blockface of that block that the living entity has targeted, ignoring fluids
|
||||
+ *
|
||||
+ * @param maxDistance this is the maximum distance to scan
|
||||
+ * @return blockface of the block that the living entity has targeted,
|
||||
+ * or null if no block is targeted
|
||||
+ */
|
||||
+ @Nullable
|
||||
+ public default org.bukkit.block.BlockFace getTargetBlockFace(int maxDistance) {
|
||||
+ return getTargetBlockFace(maxDistance, com.destroystokyo.paper.block.TargetBlockInfo.FluidMode.NEVER);
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Gets the blockface of that block that the living entity has targeted
|
||||
+ *
|
||||
+ * @param maxDistance this is the maximum distance to scan
|
||||
+ * @param fluidMode whether to check fluids or not
|
||||
+ * @return blockface of the block that the living entity has targeted,
|
||||
+ * or null if no block is targeted
|
||||
+ */
|
||||
+ @Nullable
|
||||
+ public org.bukkit.block.BlockFace getTargetBlockFace(int maxDistance, @NotNull com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode);
|
||||
+
|
||||
+ /**
|
||||
+ * Gets information about the block the living entity has targeted, ignoring fluids
|
||||
+ *
|
||||
+ * @param maxDistance this is the maximum distance to scan
|
||||
+ * @return TargetBlockInfo about the block the living entity has targeted,
|
||||
+ * or null if no block is targeted
|
||||
+ */
|
||||
+ @Nullable
|
||||
+ public default com.destroystokyo.paper.block.TargetBlockInfo getTargetBlockInfo(int maxDistance) {
|
||||
+ return getTargetBlockInfo(maxDistance, com.destroystokyo.paper.block.TargetBlockInfo.FluidMode.NEVER);
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Gets information about the block the living entity has targeted
|
||||
+ *
|
||||
+ * @param maxDistance this is the maximum distance to scan
|
||||
+ * @param fluidMode whether to check fluids or not
|
||||
+ * @return TargetBlockInfo about the block the living entity has targeted,
|
||||
+ * or null if no block is targeted
|
||||
+ */
|
||||
+ @Nullable
|
||||
+ public com.destroystokyo.paper.block.TargetBlockInfo getTargetBlockInfo(int maxDistance, @NotNull com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode);
|
||||
+ // Paper end
|
||||
+
|
||||
/**
|
||||
* Gets the last two blocks along the living entity's line of sight.
|
||||
* <p>
|
|
@ -0,0 +1,37 @@
|
|||
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
||||
From: BillyGalbreath <Blake.Galbreath@GMail.com>
|
||||
Date: Tue, 4 Sep 2018 15:01:54 -0500
|
||||
Subject: [PATCH] Expose attack cooldown methods for Player
|
||||
|
||||
|
||||
diff --git a/src/main/java/org/bukkit/entity/Player.java b/src/main/java/org/bukkit/entity/Player.java
|
||||
index 257bf4a75393d1e25839bcae0ca5551ee832c627..ec87c78d0f9379511467b6d13b9cdfa4c19d15ca 100644
|
||||
--- a/src/main/java/org/bukkit/entity/Player.java
|
||||
+++ b/src/main/java/org/bukkit/entity/Player.java
|
||||
@@ -1889,6 +1889,26 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
|
||||
* @param profile The new profile to use
|
||||
*/
|
||||
void setPlayerProfile(@NotNull PlayerProfile profile);
|
||||
+
|
||||
+ /**
|
||||
+ * Returns the amount of ticks the current cooldown lasts
|
||||
+ *
|
||||
+ * @return Amount of ticks cooldown will last
|
||||
+ */
|
||||
+ float getCooldownPeriod();
|
||||
+
|
||||
+ /**
|
||||
+ * Returns the percentage of attack power available based on the cooldown (zero to one).
|
||||
+ *
|
||||
+ * @param adjustTicks Amount of ticks to add to cooldown counter for this calculation
|
||||
+ * @return Percentage of attack power available
|
||||
+ */
|
||||
+ float getCooledAttackStrength(float adjustTicks);
|
||||
+
|
||||
+ /**
|
||||
+ * Reset the cooldown counter to 0, effectively starting the cooldown period.
|
||||
+ */
|
||||
+ void resetCooldown();
|
||||
// Paper end
|
||||
|
||||
// Spigot start
|
181
patches/api/0148-Improve-death-events.patch
Normal file
181
patches/api/0148-Improve-death-events.patch
Normal file
|
@ -0,0 +1,181 @@
|
|||
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
||||
From: Phoenix616 <mail@moep.tv>
|
||||
Date: Tue, 21 Aug 2018 01:32:28 +0100
|
||||
Subject: [PATCH] Improve death events
|
||||
|
||||
This adds the ability to cancel the death events and to modify the sound
|
||||
an entity makes when dying. (In cases were no sound should it will be
|
||||
called with shouldPlaySound set to false allowing unsilencing of silent
|
||||
entities)
|
||||
|
||||
It makes handling of entity deaths a lot nicer as you no longer need
|
||||
to listen on the damage event and calculate if the entity dies yourself
|
||||
to cancel the death which has the benefit of also receiving the dropped
|
||||
items and experience which is otherwise only properly possible by using
|
||||
internal code.
|
||||
|
||||
diff --git a/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java b/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java
|
||||
index a5984ab06cce95d30e70511e125f69339b574c04..e19a3df9aa2204b44c0b029bda141ae6306f60a1 100644
|
||||
--- a/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java
|
||||
+++ b/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java
|
||||
@@ -5,14 +5,24 @@ import org.bukkit.entity.LivingEntity;
|
||||
import org.bukkit.event.HandlerList;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
+import org.jetbrains.annotations.Nullable;
|
||||
|
||||
/**
|
||||
* Thrown whenever a LivingEntity dies
|
||||
*/
|
||||
-public class EntityDeathEvent extends EntityEvent {
|
||||
+public class EntityDeathEvent extends EntityEvent implements org.bukkit.event.Cancellable { // Paper - make cancellable
|
||||
private static final HandlerList handlers = new HandlerList();
|
||||
private final List<ItemStack> drops;
|
||||
private int dropExp = 0;
|
||||
+ // Paper start - make cancellable
|
||||
+ private boolean cancelled;
|
||||
+ private double reviveHealth = 0;
|
||||
+ private boolean shouldPlayDeathSound;
|
||||
+ @Nullable private org.bukkit.Sound deathSound;
|
||||
+ @Nullable private org.bukkit.SoundCategory deathSoundCategory;
|
||||
+ private float deathSoundVolume;
|
||||
+ private float deathSoundPitch;
|
||||
+ // Paper end
|
||||
|
||||
public EntityDeathEvent(@NotNull final LivingEntity entity, @NotNull final List<ItemStack> drops) {
|
||||
this(entity, drops, 0);
|
||||
@@ -74,4 +84,134 @@ public class EntityDeathEvent extends EntityEvent {
|
||||
public static HandlerList getHandlerList() {
|
||||
return handlers;
|
||||
}
|
||||
+
|
||||
+ // Paper start - make cancellable
|
||||
+ @Override
|
||||
+ public boolean isCancelled() {
|
||||
+ return cancelled;
|
||||
+ }
|
||||
+
|
||||
+ @Override
|
||||
+ public void setCancelled(boolean cancel) {
|
||||
+ cancelled = cancel;
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Get the amount of health that the entity should revive with after cancelling the event.
|
||||
+ * Set to the entity's max health by default.
|
||||
+ *
|
||||
+ * @return The amount of health
|
||||
+ */
|
||||
+ public double getReviveHealth() {
|
||||
+ return reviveHealth;
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Set the amount of health that the entity should revive with after cancelling the event.
|
||||
+ * Revive health value must be between 0 (exclusive) and the entity's max health (inclusive).
|
||||
+ *
|
||||
+ * @param reviveHealth The amount of health
|
||||
+ * @throws IllegalArgumentException Thrown if the health is {@literal <= 0 or >} max health
|
||||
+ */
|
||||
+ public void setReviveHealth(double reviveHealth) throws IllegalArgumentException {
|
||||
+ double maxHealth = ((LivingEntity) entity).getAttribute(org.bukkit.attribute.Attribute.GENERIC_MAX_HEALTH).getValue();
|
||||
+ if ((maxHealth != 0 && reviveHealth <= 0) || (reviveHealth > maxHealth)) {
|
||||
+ throw new IllegalArgumentException("Health must be between 0 (exclusive) and " + maxHealth + " (inclusive), but was " + reviveHealth);
|
||||
+ }
|
||||
+ this.reviveHealth = reviveHealth;
|
||||
+ }
|
||||
+
|
||||
+
|
||||
+ /**
|
||||
+ * Whether or not the death sound should play when the entity dies. If the event is cancelled it does not play!
|
||||
+ *
|
||||
+ * @return Whether or not the death sound should play. Event is called with this set to false if the entity is silent.
|
||||
+ */
|
||||
+ public boolean shouldPlayDeathSound() {
|
||||
+ return shouldPlayDeathSound;
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Set whether or not the death sound should play when the entity dies. If the event is cancelled it does not play!
|
||||
+ *
|
||||
+ * @param playDeathSound Enable or disable the death sound
|
||||
+ */
|
||||
+ public void setShouldPlayDeathSound(boolean playDeathSound) {
|
||||
+ this.shouldPlayDeathSound = playDeathSound;
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Get the sound that the entity makes when dying
|
||||
+ *
|
||||
+ * @return The sound that the entity makes
|
||||
+ */
|
||||
+ @Nullable
|
||||
+ public org.bukkit.Sound getDeathSound() {
|
||||
+ return deathSound;
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Set the sound that the entity makes when dying
|
||||
+ *
|
||||
+ * @param sound The sound that the entity should make when dying
|
||||
+ */
|
||||
+ public void setDeathSound(@Nullable org.bukkit.Sound sound) {
|
||||
+ deathSound = sound;
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Get the sound category that the death sound should play in
|
||||
+ *
|
||||
+ * @return The sound category
|
||||
+ */
|
||||
+ @Nullable
|
||||
+ public org.bukkit.SoundCategory getDeathSoundCategory() {
|
||||
+ return deathSoundCategory;
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Set the sound category that the death sound should play in.
|
||||
+ *
|
||||
+ * @param soundCategory The sound category
|
||||
+ */
|
||||
+ public void setDeathSoundCategory(@Nullable org.bukkit.SoundCategory soundCategory) {
|
||||
+ this.deathSoundCategory = soundCategory;
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Get the volume that the death sound will play at.
|
||||
+ *
|
||||
+ * @return The volume the death sound will play at
|
||||
+ */
|
||||
+ public float getDeathSoundVolume() {
|
||||
+ return deathSoundVolume;
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Set the volume the death sound should play at. If the event is cancelled this will not play the sound!
|
||||
+ *
|
||||
+ * @param volume The volume the death sound should play at
|
||||
+ */
|
||||
+ public void setDeathSoundVolume(float volume) {
|
||||
+ this.deathSoundVolume = volume;
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Get the pitch that the death sound will play with.
|
||||
+ *
|
||||
+ * @return The pitch the death sound will play with
|
||||
+ */
|
||||
+ public float getDeathSoundPitch() {
|
||||
+ return deathSoundPitch;
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * GSetet the pitch that the death sound should play with.
|
||||
+ *
|
||||
+ * @param pitch The pitch the death sound should play with
|
||||
+ */
|
||||
+ public void setDeathSoundPitch(float pitch) {
|
||||
+ this.deathSoundPitch = pitch;
|
||||
+ }
|
||||
+ // Paper end
|
||||
}
|
259
patches/api/0149-Mob-Pathfinding-API.patch
Normal file
259
patches/api/0149-Mob-Pathfinding-API.patch
Normal file
|
@ -0,0 +1,259 @@
|
|||
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
||||
From: Aikar <aikar@aikar.co>
|
||||
Date: Sun, 9 Sep 2018 12:39:06 -0400
|
||||
Subject: [PATCH] Mob Pathfinding API
|
||||
|
||||
Adds an API to allow plugins to instruct a Mob to Pathfind to a Location or Entity
|
||||
|
||||
This does not do anything to stop other AI rules from changing the location, so
|
||||
it is still up to the plugin to control that or override after another goal changed
|
||||
the location.
|
||||
|
||||
You can use EntityPathfindEvent to cancel new pathfinds from overriding your current.
|
||||
|
||||
diff --git a/src/main/java/com/destroystokyo/paper/entity/Pathfinder.java b/src/main/java/com/destroystokyo/paper/entity/Pathfinder.java
|
||||
new file mode 100644
|
||||
index 0000000000000000000000000000000000000000..e2a6f9c3881ff9d7373ac30e60009200432555aa
|
||||
--- /dev/null
|
||||
+++ b/src/main/java/com/destroystokyo/paper/entity/Pathfinder.java
|
||||
@@ -0,0 +1,212 @@
|
||||
+package com.destroystokyo.paper.entity;
|
||||
+
|
||||
+import org.bukkit.Location;
|
||||
+import org.bukkit.entity.LivingEntity;
|
||||
+import org.bukkit.entity.Mob;
|
||||
+
|
||||
+import java.util.List;
|
||||
+import org.jetbrains.annotations.NotNull;
|
||||
+import org.jetbrains.annotations.Nullable;
|
||||
+
|
||||
+/**
|
||||
+ * Handles pathfinding operations for an Entity
|
||||
+ */
|
||||
+public interface Pathfinder {
|
||||
+
|
||||
+ /**
|
||||
+ *
|
||||
+ * @return The entity that is controlled by this pathfinder
|
||||
+ */
|
||||
+ @NotNull
|
||||
+ Mob getEntity();
|
||||
+
|
||||
+ /**
|
||||
+ * Instructs the Entity to stop trying to navigate to its current desired location
|
||||
+ */
|
||||
+ void stopPathfinding();
|
||||
+
|
||||
+ /**
|
||||
+ * If the entity is currently trying to navigate to a destination, this will return true
|
||||
+ * @return true if the entity is navigating to a destination
|
||||
+ */
|
||||
+ boolean hasPath();
|
||||
+
|
||||
+ /**
|
||||
+ * @return The location the entity is trying to navigate to, or null if there is no destination
|
||||
+ */
|
||||
+ @Nullable
|
||||
+ PathResult getCurrentPath();
|
||||
+
|
||||
+ /**
|
||||
+ * Calculates a destination for the Entity to navigate to, but does not set it
|
||||
+ * as the current target. Useful for calculating what would happen before setting it.
|
||||
+ * @param loc Location to navigate to
|
||||
+ * @return The closest Location the Entity can get to for this navigation, or null if no path could be calculated
|
||||
+ */
|
||||
+ @Nullable PathResult findPath(@NotNull Location loc);
|
||||
+
|
||||
+ /**
|
||||
+ * Calculates a destination for the Entity to navigate to to reach the target entity,
|
||||
+ * but does not set it as the current target.
|
||||
+ * Useful for calculating what would happen before setting it.
|
||||
+ *
|
||||
+ * The behavior of this PathResult is subject to the games pathfinding rules, and may
|
||||
+ * result in the pathfinding automatically updating to follow the target Entity.
|
||||
+ *
|
||||
+ * However, this behavior is not guaranteed, and is subject to the games behavior.
|
||||
+ *
|
||||
+ * @param target the Entity to navigate to
|
||||
+ * @return The closest Location the Entity can get to for this navigation, or null if no path could be calculated
|
||||
+ */
|
||||
+ @Nullable PathResult findPath(@NotNull LivingEntity target);
|
||||
+
|
||||
+ /**
|
||||
+ * Calculates a destination for the Entity to navigate to, and sets it with default speed
|
||||
+ * as the current target.
|
||||
+ * @param loc Location to navigate to
|
||||
+ * @return If the pathfinding was successfully started
|
||||
+ */
|
||||
+ default boolean moveTo(@NotNull Location loc) {
|
||||
+ return moveTo(loc, 1);
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Calculates a destination for the Entity to navigate to, with desired speed
|
||||
+ * as the current target.
|
||||
+ * @param loc Location to navigate to
|
||||
+ * @param speed Speed multiplier to navigate at, where 1 is 'normal'
|
||||
+ * @return If the pathfinding was successfully started
|
||||
+ */
|
||||
+ default boolean moveTo(@NotNull Location loc, double speed) {
|
||||
+ PathResult path = findPath(loc);
|
||||
+ return path != null && moveTo(path, speed);
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Calculates a destination for the Entity to navigate to to reach the target entity,
|
||||
+ * and sets it with default speed.
|
||||
+ *
|
||||
+ * The behavior of this PathResult is subject to the games pathfinding rules, and may
|
||||
+ * result in the pathfinding automatically updating to follow the target Entity.
|
||||
+ *
|
||||
+ * However, this behavior is not guaranteed, and is subject to the games behavior.
|
||||
+ *
|
||||
+ * @param target the Entity to navigate to
|
||||
+ * @return If the pathfinding was successfully started
|
||||
+ */
|
||||
+ default boolean moveTo(@NotNull LivingEntity target) {
|
||||
+ return moveTo(target, 1);
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Calculates a destination for the Entity to navigate to to reach the target entity,
|
||||
+ * and sets it with specified speed.
|
||||
+ *
|
||||
+ * The behavior of this PathResult is subject to the games pathfinding rules, and may
|
||||
+ * result in the pathfinding automatically updating to follow the target Entity.
|
||||
+ *
|
||||
+ * However, this behavior is not guaranteed, and is subject to the games behavior.
|
||||
+ *
|
||||
+ * @param target the Entity to navigate to
|
||||
+ * @param speed Speed multiplier to navigate at, where 1 is 'normal'
|
||||
+ * @return If the pathfinding was successfully started
|
||||
+ */
|
||||
+ default boolean moveTo(@NotNull LivingEntity target, double speed) {
|
||||
+ PathResult path = findPath(target);
|
||||
+ return path != null && moveTo(path, speed);
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Takes the result of a previous pathfinding calculation and sets it
|
||||
+ * as the active pathfinding with default speed.
|
||||
+ *
|
||||
+ * @param path The Path to start following
|
||||
+ * @return If the pathfinding was successfully started
|
||||
+ */
|
||||
+ default boolean moveTo(@NotNull PathResult path) {
|
||||
+ return moveTo(path, 1);
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Takes the result of a previous pathfinding calculation and sets it
|
||||
+ * as the active pathfinding,
|
||||
+ *
|
||||
+ * @param path The Path to start following
|
||||
+ * @param speed Speed multiplier to navigate at, where 1 is 'normal'
|
||||
+ * @return If the pathfinding was successfully started
|
||||
+ */
|
||||
+ boolean moveTo(@NotNull PathResult path, double speed);
|
||||
+
|
||||
+ /**
|
||||
+ * Checks if this pathfinder allows passing through closed doors.
|
||||
+ *
|
||||
+ * @return if this pathfinder allows passing through closed doors
|
||||
+ */
|
||||
+ boolean canOpenDoors();
|
||||
+
|
||||
+ /**
|
||||
+ * Allows this pathfinder to pass through closed doors, or not
|
||||
+ *
|
||||
+ * @param canOpenDoors if the mob can pass through closed doors, or not
|
||||
+ */
|
||||
+ void setCanOpenDoors(boolean canOpenDoors);
|
||||
+
|
||||
+ /**
|
||||
+ * Checks if this pathfinder allows passing through open doors.
|
||||
+ *
|
||||
+ * @return if this pathfinder allows passing through open doors
|
||||
+ */
|
||||
+ boolean canPassDoors();
|
||||
+
|
||||
+ /**
|
||||
+ * Allows this pathfinder to pass through open doors, or not
|
||||
+ *
|
||||
+ * @param canPassDoors if the mob can pass through open doors, or not
|
||||
+ */
|
||||
+ void setCanPassDoors(boolean canPassDoors);
|
||||
+
|
||||
+ /**
|
||||
+ * Checks if this pathfinder assumes that the mob can float
|
||||
+ *
|
||||
+ * @return if this pathfinder assumes that the mob can float
|
||||
+ */
|
||||
+ boolean canFloat();
|
||||
+
|
||||
+ /**
|
||||
+ * Makes this pathfinder assume that the mob can float, or not
|
||||
+ *
|
||||
+ * @param canFloat if the mob can float, or not
|
||||
+ */
|
||||
+ void setCanFloat(boolean canFloat);
|
||||
+
|
||||
+ /**
|
||||
+ * Represents the result of a pathfinding calculation
|
||||
+ */
|
||||
+ interface PathResult {
|
||||
+
|
||||
+ /**
|
||||
+ * All currently calculated points to follow along the path to reach the destination location
|
||||
+ *
|
||||
+ * Will return points the entity has already moved past, see {@link #getNextPointIndex()}
|
||||
+ * @return List of points
|
||||
+ */
|
||||
+ @NotNull
|
||||
+ List<Location> getPoints();
|
||||
+
|
||||
+ /**
|
||||
+ * @return Returns the index of the current point along the points returned in {@link #getPoints()} the entity
|
||||
+ * is trying to reach, or null if we are done with this pathfinding.
|
||||
+ */
|
||||
+ int getNextPointIndex();
|
||||
+
|
||||
+ /**
|
||||
+ * @return The next location in the path points the entity is trying to reach, or null if there is no next point
|
||||
+ */
|
||||
+ @Nullable Location getNextPoint();
|
||||
+
|
||||
+ /**
|
||||
+ * @return The closest point the path can get to the target location
|
||||
+ */
|
||||
+ @Nullable Location getFinalPoint();
|
||||
+ }
|
||||
+}
|
||||
diff --git a/src/main/java/org/bukkit/entity/Mob.java b/src/main/java/org/bukkit/entity/Mob.java
|
||||
index be9334a8b5fba9181ad63c211697e798be63da25..b132287817d35579ca5128a1ed5c242bf229771a 100644
|
||||
--- a/src/main/java/org/bukkit/entity/Mob.java
|
||||
+++ b/src/main/java/org/bukkit/entity/Mob.java
|
||||
@@ -1,6 +1,7 @@
|
||||
package org.bukkit.entity;
|
||||
|
||||
import org.bukkit.loot.Lootable;
|
||||
+import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
/**
|
||||
@@ -8,6 +9,15 @@ import org.jetbrains.annotations.Nullable;
|
||||
*/
|
||||
public interface Mob extends LivingEntity, Lootable {
|
||||
|
||||
+ // Paper start
|
||||
+ /**
|
||||
+ * Enables access to control the pathing of an Entity
|
||||
+ * @return Pathfinding Manager for this entity
|
||||
+ */
|
||||
+ @NotNull
|
||||
+ com.destroystokyo.paper.entity.Pathfinder getPathfinder();
|
||||
+ // Paper end
|
||||
+
|
||||
/**
|
||||
* Instructs this Mob to set the specified LivingEntity as its target.
|
||||
* <p>
|
|
@ -0,0 +1,319 @@
|
|||
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
||||
From: Mark Vainomaa <mikroskeem@mikroskeem.eu>
|
||||
Date: Wed, 12 Sep 2018 18:53:35 +0300
|
||||
Subject: [PATCH] Add an API for CanPlaceOn and CanDestroy NBT values
|
||||
|
||||
|
||||
diff --git a/src/main/java/com/destroystokyo/paper/Namespaced.java b/src/main/java/com/destroystokyo/paper/Namespaced.java
|
||||
new file mode 100644
|
||||
index 0000000000000000000000000000000000000000..cd1a34b82870684e09e18c47169bd472ecbbb91f
|
||||
--- /dev/null
|
||||
+++ b/src/main/java/com/destroystokyo/paper/Namespaced.java
|
||||
@@ -0,0 +1,40 @@
|
||||
+package com.destroystokyo.paper;
|
||||
+
|
||||
+import org.jetbrains.annotations.NotNull;
|
||||
+
|
||||
+/**
|
||||
+ * Represents a namespaced resource, see {@link org.bukkit.NamespacedKey} for single elements
|
||||
+ * or {@link com.destroystokyo.paper.NamespacedTag} for a collection of elements
|
||||
+ *
|
||||
+ * Namespaces may only contain lowercase alphanumeric characters, periods,
|
||||
+ * underscores, and hyphens.
|
||||
+ * <p>
|
||||
+ * Keys may only contain lowercase alphanumeric characters, periods,
|
||||
+ * underscores, hyphens, and forward slashes.
|
||||
+ * <p>
|
||||
+ * You should not be implementing this interface yourself, use {@link org.bukkit.NamespacedKey}
|
||||
+ * or {@link com.destroystokyo.paper.NamespacedTag} as needed instead.
|
||||
+ */
|
||||
+public interface Namespaced {
|
||||
+ /**
|
||||
+ * Gets the namespace this resource is a part of
|
||||
+ * <p>
|
||||
+ * This is contractually obligated to only contain lowercase alphanumeric characters,
|
||||
+ * periods, underscores, and hyphens.
|
||||
+ *
|
||||
+ * @return resource namespace
|
||||
+ */
|
||||
+ @NotNull
|
||||
+ String getNamespace();
|
||||
+
|
||||
+ /**
|
||||
+ * Gets the key corresponding to this resource
|
||||
+ * <p>
|
||||
+ * This is contractually obligated to only contain lowercase alphanumeric characters,
|
||||
+ * periods, underscores, hyphens, and forward slashes.
|
||||
+ *
|
||||
+ * @return resource key
|
||||
+ */
|
||||
+ @NotNull
|
||||
+ String getKey();
|
||||
+}
|
||||
diff --git a/src/main/java/com/destroystokyo/paper/NamespacedTag.java b/src/main/java/com/destroystokyo/paper/NamespacedTag.java
|
||||
new file mode 100644
|
||||
index 0000000000000000000000000000000000000000..28f3fda950999a9c964a3608042ca60567ae1d6a
|
||||
--- /dev/null
|
||||
+++ b/src/main/java/com/destroystokyo/paper/NamespacedTag.java
|
||||
@@ -0,0 +1,142 @@
|
||||
+package com.destroystokyo.paper;
|
||||
+
|
||||
+import com.google.common.base.Preconditions;
|
||||
+import java.util.Locale;
|
||||
+import java.util.UUID;
|
||||
+import java.util.regex.Pattern;
|
||||
+import org.bukkit.plugin.Plugin;
|
||||
+import org.jetbrains.annotations.NotNull;
|
||||
+
|
||||
+/**
|
||||
+ * Represents a String based key pertaining to a tagged entry. Consists of two components - a namespace
|
||||
+ * and a key.
|
||||
+ * <p>
|
||||
+ * Namespaces may only contain lowercase alphanumeric characters, periods,
|
||||
+ * underscores, and hyphens.
|
||||
+ * <p>
|
||||
+ * Keys may only contain lowercase alphanumeric characters, periods,
|
||||
+ * underscores, hyphens, and forward slashes.
|
||||
+ *
|
||||
+ */
|
||||
+// Paper - entire class, based on org.bukkit.NamespacedKey
|
||||
+public final class NamespacedTag implements com.destroystokyo.paper.Namespaced {
|
||||
+
|
||||
+ /**
|
||||
+ * The namespace representing all inbuilt keys.
|
||||
+ */
|
||||
+ public static final String MINECRAFT = "minecraft";
|
||||
+ /**
|
||||
+ * The namespace representing all keys generated by Bukkit for backwards
|
||||
+ * compatibility measures.
|
||||
+ */
|
||||
+ public static final String BUKKIT = "bukkit";
|
||||
+ //
|
||||
+ private static final Pattern VALID_NAMESPACE = Pattern.compile("[a-z0-9._-]+");
|
||||
+ private static final Pattern VALID_KEY = Pattern.compile("[a-z0-9/._-]+");
|
||||
+ //
|
||||
+ private final String namespace;
|
||||
+ private final String key;
|
||||
+
|
||||
+ /**
|
||||
+ * Create a key in a specific namespace.
|
||||
+ *
|
||||
+ * @param namespace String representing a grouping of keys
|
||||
+ * @param key Name for this specific key
|
||||
+ * @deprecated should never be used by plugins, for internal use only!!
|
||||
+ */
|
||||
+ @Deprecated
|
||||
+ public NamespacedTag(@NotNull String namespace, @NotNull String key) {
|
||||
+ Preconditions.checkArgument(namespace != null && VALID_NAMESPACE.matcher(namespace).matches(), "Invalid namespace. Must be [a-z0-9._-]: %s", namespace);
|
||||
+ Preconditions.checkArgument(key != null && VALID_KEY.matcher(key).matches(), "Invalid key. Must be [a-z0-9/._-]: %s", key);
|
||||
+
|
||||
+ this.namespace = namespace;
|
||||
+ this.key = key;
|
||||
+
|
||||
+ String string = toString();
|
||||
+ Preconditions.checkArgument(string.length() < 256, "NamespacedTag must be less than 256 characters", string);
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Create a key in the plugin's namespace.
|
||||
+ * <p>
|
||||
+ * Namespaces may only contain lowercase alphanumeric characters, periods,
|
||||
+ * underscores, and hyphens.
|
||||
+ * <p>
|
||||
+ * Keys may only contain lowercase alphanumeric characters, periods,
|
||||
+ * underscores, hyphens, and forward slashes.
|
||||
+ *
|
||||
+ * @param plugin the plugin to use for the namespace
|
||||
+ * @param key the key to create
|
||||
+ */
|
||||
+ public NamespacedTag(@NotNull Plugin plugin, @NotNull String key) {
|
||||
+ Preconditions.checkArgument(plugin != null, "Plugin cannot be null");
|
||||
+ Preconditions.checkArgument(key != null, "Key cannot be null");
|
||||
+
|
||||
+ this.namespace = plugin.getName().toLowerCase(Locale.ROOT);
|
||||
+ this.key = key.toLowerCase().toLowerCase(Locale.ROOT);
|
||||
+
|
||||
+ // Check validity after normalization
|
||||
+ Preconditions.checkArgument(VALID_NAMESPACE.matcher(this.namespace).matches(), "Invalid namespace. Must be [a-z0-9._-]: %s", this.namespace);
|
||||
+ Preconditions.checkArgument(VALID_KEY.matcher(this.key).matches(), "Invalid key. Must be [a-z0-9/._-]: %s", this.key);
|
||||
+
|
||||
+ String string = toString();
|
||||
+ Preconditions.checkArgument(string.length() < 256, "NamespacedTag must be less than 256 characters (%s)", string);
|
||||
+ }
|
||||
+
|
||||
+ @NotNull
|
||||
+ public String getNamespace() {
|
||||
+ return namespace;
|
||||
+ }
|
||||
+
|
||||
+ @NotNull
|
||||
+ public String getKey() {
|
||||
+ return key;
|
||||
+ }
|
||||
+
|
||||
+ @Override
|
||||
+ public int hashCode() {
|
||||
+ int hash = 7;
|
||||
+ hash = 47 * hash + this.namespace.hashCode();
|
||||
+ hash = 47 * hash + this.key.hashCode();
|
||||
+ return hash;
|
||||
+ }
|
||||
+
|
||||
+ @Override
|
||||
+ public boolean equals(Object obj) {
|
||||
+ if (obj == null) {
|
||||
+ return false;
|
||||
+ }
|
||||
+ if (getClass() != obj.getClass()) {
|
||||
+ return false;
|
||||
+ }
|
||||
+ final NamespacedTag other = (NamespacedTag) obj;
|
||||
+ return this.namespace.equals(other.namespace) && this.key.equals(other.key);
|
||||
+ }
|
||||
+
|
||||
+ @Override
|
||||
+ public String toString() {
|
||||
+ return "#" + this.namespace + ":" + this.key;
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Return a new random key in the {@link #BUKKIT} namespace.
|
||||
+ *
|
||||
+ * @return new key
|
||||
+ * @deprecated should never be used by plugins, for internal use only!!
|
||||
+ */
|
||||
+ @Deprecated
|
||||
+ public static NamespacedTag randomKey() {
|
||||
+ return new NamespacedTag(BUKKIT, UUID.randomUUID().toString());
|
||||
+ }
|
||||
+
|
||||
+ /**
|
||||
+ * Get a key in the Minecraft namespace.
|
||||
+ *
|
||||
+ * @param key the key to use
|
||||
+ * @return new key in the Minecraft namespace
|
||||
+ */
|
||||
+ @NotNull
|
||||
+ public static NamespacedTag minecraft(@NotNull String key) {
|
||||
+ return new NamespacedTag(MINECRAFT, key);
|
||||
+ }
|
||||
+}
|
||||
diff --git a/src/main/java/org/bukkit/NamespacedKey.java b/src/main/java/org/bukkit/NamespacedKey.java
|
||||
index c65f0d6569c130b4920a9e71ad24af6427f1f030..01bcb3a1bdb5accdf844d0178cec3d25746b3eaa 100644
|
||||
--- a/src/main/java/org/bukkit/NamespacedKey.java
|
||||
+++ b/src/main/java/org/bukkit/NamespacedKey.java
|
||||
@@ -19,7 +19,7 @@ import org.jetbrains.annotations.Nullable;
|
||||
* underscores, hyphens, and forward slashes.
|
||||
*
|
||||
*/
|
||||
-public final class NamespacedKey implements net.kyori.adventure.key.Key { // Paper - implement Key
|
||||
+public final class NamespacedKey implements net.kyori.adventure.key.Key, com.destroystokyo.paper.Namespaced { // Paper - implement Key and Namespaced
|
||||
|
||||
/**
|
||||
* The namespace representing all inbuilt keys.
|
||||
@@ -84,11 +84,13 @@ public final class NamespacedKey implements net.kyori.adventure.key.Key { // Pap
|
||||
}
|
||||
|
||||
@NotNull
|
||||
+ @Override // Paper
|
||||
public String getNamespace() {
|
||||
return namespace;
|
||||
}
|
||||
|
||||
@NotNull
|
||||
+ @Override // Paper
|
||||
public String getKey() {
|
||||
return key;
|
||||
}
|
||||
diff --git a/src/main/java/org/bukkit/inventory/meta/ItemMeta.java b/src/main/java/org/bukkit/inventory/meta/ItemMeta.java
|
||||
index 1c362636c56db0e6c118171ba367c43c4f7cff33..01b462fccce71cef3398dd43944046f322b8e57e 100644
|
||||
--- a/src/main/java/org/bukkit/inventory/meta/ItemMeta.java
|
||||
+++ b/src/main/java/org/bukkit/inventory/meta/ItemMeta.java
|
||||
@@ -432,4 +432,87 @@ public interface ItemMeta extends Cloneable, ConfigurationSerializable, Persiste
|
||||
@SuppressWarnings("javadoc")
|
||||
@NotNull
|
||||
ItemMeta clone();
|
||||
+
|
||||
+ // Paper start - Add an API for CanPlaceOn and CanDestroy NBT values
|
||||
+ /**
|
||||
+ * Gets set of materials what given item can destroy in {@link org.bukkit.GameMode#ADVENTURE}
|
||||
+ *
|
||||
+ * @return Set of materials
|
||||
+ * @deprecated Minecraft does not limit this to the material enum, Use {@link #getDestroyableKeys()} as a replacement
|
||||
+ */
|
||||
+ @Deprecated
|
||||
+ Set<org.bukkit.Material> getCanDestroy();
|
||||
+
|
||||
+ /**
|
||||
+ * Sets set of materials what given item can destroy in {@link org.bukkit.GameMode#ADVENTURE}
|
||||
+ *
|
||||
+ * @param canDestroy Set of materials
|
||||
+ * @deprecated Minecraft does not limit this to the material enum, Use {@link #setDestroyableKeys(Collection)} as a replacement
|
||||
+ */
|
||||
+ @Deprecated
|
||||
+ void setCanDestroy(Set<org.bukkit.Material> canDestroy);
|
||||
+
|
||||
+ /**
|
||||
+ * Gets set of materials where given item can be placed on in {@link org.bukkit.GameMode#ADVENTURE}
|
||||
+ *
|
||||
+ * @return Set of materials
|
||||
+ * @deprecated Minecraft does not limit this to the material enum, Use {@link #getPlaceableKeys()} as a replacement
|
||||
+ */
|
||||
+ @Deprecated
|
||||
+ Set<org.bukkit.Material> getCanPlaceOn();
|
||||
+
|
||||
+ /**
|
||||
+ * Sets set of materials where given item can be placed on in {@link org.bukkit.GameMode#ADVENTURE}
|
||||
+ *
|
||||
+ * @param canPlaceOn Set of materials
|
||||
+ * @deprecated Minecraft does not limit this to the material enum, Use {@link #setPlaceableKeys(Collection)} as a replacement
|
||||
+ */
|
||||
+ @Deprecated
|
||||
+ void setCanPlaceOn(Set<org.bukkit.Material> canPlaceOn);
|
||||
+
|
||||
+ /**
|
||||
+ * Gets the collection of namespaced keys that the item can destroy in {@link org.bukkit.GameMode#ADVENTURE}
|
||||
+ *
|
||||
+ * @return Set of {@link com.destroystokyo.paper.Namespaced}
|
||||
+ */
|
||||
+ @NotNull
|
||||
+ Set<com.destroystokyo.paper.Namespaced> getDestroyableKeys();
|
||||
+
|
||||
+ /**
|
||||
+ * Sets the collection of namespaced keys that the item can destroy in {@link org.bukkit.GameMode#ADVENTURE}
|
||||
+ *
|
||||
+ * @param canDestroy Collection of {@link com.destroystokyo.paper.Namespaced}
|
||||
+ */
|
||||
+ void setDestroyableKeys(@NotNull Collection<com.destroystokyo.paper.Namespaced> canDestroy);
|
||||
+
|
||||
+ /**
|
||||
+ * Gets the collection of namespaced keys that the item can be placed on in {@link org.bukkit.GameMode#ADVENTURE}
|
||||
+ *
|
||||
+ * @return Set of {@link com.destroystokyo.paper.Namespaced}
|
||||
+ */
|
||||
+ @NotNull
|
||||
+ Set<com.destroystokyo.paper.Namespaced> getPlaceableKeys();
|
||||
+
|
||||
+ /**
|
||||
+ * Sets the set of namespaced keys that the item can be placed on in {@link org.bukkit.GameMode#ADVENTURE}
|
||||
+ *
|
||||
+ * @param canPlaceOn Collection of {@link com.destroystokyo.paper.Namespaced}
|
||||
+ */
|
||||
+ @NotNull
|
||||
+ void setPlaceableKeys(@NotNull Collection<com.destroystokyo.paper.Namespaced> canPlaceOn);
|
||||
+
|
||||
+ /**
|
||||
+ * Checks for the existence of any keys that the item can be placed on
|
||||
+ *
|
||||
+ * @return true if this item has placeable keys
|
||||
+ */
|
||||
+ boolean hasPlaceableKeys();
|
||||
+
|
||||
+ /**
|
||||
+ * Checks for the existence of any keys that the item can destroy
|
||||
+ *
|
||||
+ * @return true if this item has destroyable keys
|
||||
+ */
|
||||
+ boolean hasDestroyableKeys();
|
||||
+ // Paper end
|
||||
}
|
Loading…
Add table
Add a link
Reference in a new issue