diff options
Diffstat (limited to 'patches/api/0298-Missing-Entity-API.patch')
| -rw-r--r-- | patches/api/0298-Missing-Entity-API.patch | 1483 |
1 files changed, 1483 insertions, 0 deletions
diff --git a/patches/api/0298-Missing-Entity-API.patch b/patches/api/0298-Missing-Entity-API.patch new file mode 100644 index 0000000000..7dff1ccf46 --- /dev/null +++ b/patches/api/0298-Missing-Entity-API.patch @@ -0,0 +1,1483 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Owen1212055 <[email protected]> +Date: Fri, 28 May 2021 21:06:59 -0400 +Subject: [PATCH] Missing Entity API + +Co-authored-by: Nassim Jahnke <[email protected]> +Co-authored-by: Jake Potrebic <[email protected]> +Co-authored-by: William Blake Galbreath <[email protected]> +Co-authored-by: SoSeDiK <[email protected]> +Co-authored-by: booky10 <[email protected]> +Co-authored-by: Amin <[email protected]> + +diff --git a/src/main/java/io/papermc/paper/entity/SchoolableFish.java b/src/main/java/io/papermc/paper/entity/SchoolableFish.java +new file mode 100644 +index 0000000000000000000000000000000000000000..39ad7d283609d7e427a2ab35b6fad839e032fe92 +--- /dev/null ++++ b/src/main/java/io/papermc/paper/entity/SchoolableFish.java +@@ -0,0 +1,47 @@ ++package io.papermc.paper.entity; ++ ++import org.bukkit.entity.Fish; ++import org.jetbrains.annotations.NotNull; ++import org.jetbrains.annotations.Nullable; ++ ++/** ++ * Represents a fish that can school with other fish. ++ */ ++public interface SchoolableFish extends Fish { ++ ++ /** ++ * Forces this fish to follow the given fish. ++ * ++ * @param leader fish to follow ++ */ ++ void startFollowing(@NotNull SchoolableFish leader); ++ ++ /** ++ * Causes the fish to stop following their current ++ * leader. ++ */ ++ void stopFollowing(); ++ ++ /** ++ * Gets the amount of fish currently following this fish. ++ * ++ * @return school size ++ */ ++ int getSchoolSize(); ++ ++ /** ++ * Gets the maximum number of fish that will naturally follow this fish. ++ * ++ * @return max school size ++ */ ++ int getMaxSchoolSize(); ++ ++ /** ++ * Gets the fish that this entity is currently following. ++ * ++ * @return following fish ++ */ ++ @Nullable ++ SchoolableFish getSchoolLeader(); ++ ++} +diff --git a/src/main/java/io/papermc/paper/potion/SuspiciousEffectEntry.java b/src/main/java/io/papermc/paper/potion/SuspiciousEffectEntry.java +new file mode 100644 +index 0000000000000000000000000000000000000000..c8446678e39e777bd2c9992d5c577f4c7606ce15 +--- /dev/null ++++ b/src/main/java/io/papermc/paper/potion/SuspiciousEffectEntry.java +@@ -0,0 +1,37 @@ ++package io.papermc.paper.potion; ++ ++import org.bukkit.potion.PotionEffectType; ++import org.jetbrains.annotations.Contract; ++import org.jetbrains.annotations.NotNull; ++ ++/** ++ * Represents a {@link PotionEffectType} paired with a duration. ++ */ ++public sealed interface SuspiciousEffectEntry permits SuspiciousEffectEntryImpl { ++ ++ /** ++ * Gets the effect type. ++ * ++ * @return type ++ */ ++ @NotNull PotionEffectType effect(); ++ ++ /** ++ * Gets the duration for this effect instance. ++ * ++ * @return duration (in ticks) ++ */ ++ int duration(); ++ ++ /** ++ * Creates a new instance of SuspiciousEffectEntry. ++ * ++ * @param effectType effect type ++ * @param duration duration (in ticks) ++ * @return new instance of an entry ++ */ ++ @Contract(value = "_, _ -> new", pure = true) ++ static @NotNull SuspiciousEffectEntry create(final @NotNull PotionEffectType effectType, final int duration) { ++ return new SuspiciousEffectEntryImpl(effectType, duration); ++ } ++} +diff --git a/src/main/java/io/papermc/paper/potion/SuspiciousEffectEntryImpl.java b/src/main/java/io/papermc/paper/potion/SuspiciousEffectEntryImpl.java +new file mode 100644 +index 0000000000000000000000000000000000000000..e5002ccaef9ea7a9db94296ad0d66cdae050cdd1 +--- /dev/null ++++ b/src/main/java/io/papermc/paper/potion/SuspiciousEffectEntryImpl.java +@@ -0,0 +1,7 @@ ++package io.papermc.paper.potion; ++ ++import org.bukkit.potion.PotionEffectType; ++import org.jetbrains.annotations.NotNull; ++ ++record SuspiciousEffectEntryImpl(@NotNull PotionEffectType effect, int duration) implements SuspiciousEffectEntry { ++} +diff --git a/src/main/java/org/bukkit/entity/AbstractHorse.java b/src/main/java/org/bukkit/entity/AbstractHorse.java +index 0d88dce9978243a1f995c5fb448c5d71b01136eb..8b1048c94dffd058eb9fd9144f7f59fc9bd219ad 100644 +--- a/src/main/java/org/bukkit/entity/AbstractHorse.java ++++ b/src/main/java/org/bukkit/entity/AbstractHorse.java +@@ -106,17 +106,71 @@ public interface AbstractHorse extends Vehicle, InventoryHolder, Tameable { + * Gets whether the horse is currently grazing hay. + * + * @return true if eating hay ++ * @deprecated use {@link #isEatingGrass()}, this name is incorrect + */ ++ @Deprecated // Paper - Horse API + boolean isEatingHaystack(); + + /** + * Sets whether the horse is grazing hay. + * + * @param eatingHaystack new hay grazing status ++ * @deprecated use {@link #setEatingGrass(boolean)}, this name is incorrect + */ ++ @Deprecated // Paper - Horse API + void setEatingHaystack(boolean eatingHaystack); + + @NotNull + @Override + public AbstractHorseInventory getInventory(); ++ ++ // Paper start - Horse API ++ /** ++ * Gets if a horse is in their eating grass animation. ++ * ++ * @return eating grass animation is active ++ */ ++ public boolean isEatingGrass(); ++ ++ /** ++ * Sets if a horse is in their eating grass animation. ++ * ++ * <p>When true, the horse will lower its neck.</p> ++ * ++ * @param eating eating grass animation is active ++ */ ++ public void setEatingGrass(boolean eating); ++ ++ /** ++ * Gets if a horse is in their rearing animation. ++ * ++ * @return rearing animation is active ++ */ ++ public boolean isRearing(); ++ ++ /** ++ * Sets if a horse is in their rearing animation. ++ * ++ * <p>When true, the horse will stand on its hind legs.</p> ++ * ++ * @param rearing rearing animation is active ++ */ ++ public void setRearing(boolean rearing); ++ ++ /** ++ * Gets if a horse is in their eating animation. ++ * ++ * @return eating animation is active ++ */ ++ public boolean isEating(); ++ ++ /** ++ * Sets if a horse is in their eating animation. ++ * ++ * <p>When true, the horse will bob its head.</p> ++ * ++ * @param eating eating animation is active ++ */ ++ public void setEating(boolean eating); ++ // Paper end - Horse API + } +diff --git a/src/main/java/org/bukkit/entity/AreaEffectCloud.java b/src/main/java/org/bukkit/entity/AreaEffectCloud.java +index 8d6caae8ba11e1fe73cd5f88657eaac5f66c9d3d..fc59d6d4c2d43b09aef3a6f30b73d26280e831fa 100644 +--- a/src/main/java/org/bukkit/entity/AreaEffectCloud.java ++++ b/src/main/java/org/bukkit/entity/AreaEffectCloud.java +@@ -259,4 +259,20 @@ public interface AreaEffectCloud extends Entity { + * @param source the {@link ProjectileSource} that threw the LingeringPotion + */ + public void setSource(@Nullable ProjectileSource source); ++ ++ // Paper start - owner API ++ /** ++ * Get the entity UUID for the owner of this area effect cloud. ++ * ++ * @return the entity owner uuid or null ++ */ ++ @Nullable java.util.UUID getOwnerUniqueId(); ++ ++ /** ++ * Sets the entity UUID for the owner of this area effect cloud. ++ * ++ * @param ownerUuid the entity owner uuid or null to clear ++ */ ++ void setOwnerUniqueId(@Nullable java.util.UUID ownerUuid); ++ // Paper end + } +diff --git a/src/main/java/org/bukkit/entity/Bat.java b/src/main/java/org/bukkit/entity/Bat.java +index bd73f22ef7e79e1ade69e860e7ae1d3dcd6fc858..b9f8b14d90a758672642222675d2f5664d4f67b4 100644 +--- a/src/main/java/org/bukkit/entity/Bat.java ++++ b/src/main/java/org/bukkit/entity/Bat.java +@@ -24,4 +24,23 @@ public interface Bat extends Ambient { + * @param state the new state + */ + void setAwake(boolean state); ++ ++ // Paper start ++ /** ++ * Gets the location that this bat is currently trying to move towards. ++ * ++ * @return target location, or null if it's going to find a new location ++ */ ++ @org.jetbrains.annotations.Nullable ++ org.bukkit.Location getTargetLocation(); ++ ++ /** ++ * Sets the location that this bat is currently trying to move towards. ++ * <p> ++ * This can be set to null to cause the bat to recalculate its target location ++ * ++ * @param location location to move towards (world is ignored, will always use the entity's world) ++ */ ++ void setTargetLocation(@org.jetbrains.annotations.Nullable org.bukkit.Location location); ++ // Paper end + } +diff --git a/src/main/java/org/bukkit/entity/Bee.java b/src/main/java/org/bukkit/entity/Bee.java +index adb20a9abba33c32d553f620fa82b27dff64ab5f..1f6702b0de00b87dbed7f6d93e911655e8667b0b 100644 +--- a/src/main/java/org/bukkit/entity/Bee.java ++++ b/src/main/java/org/bukkit/entity/Bee.java +@@ -93,4 +93,56 @@ public interface Bee extends Animals { + * @param ticks Ticks the bee cannot enter a hive for + */ + void setCannotEnterHiveTicks(int ticks); ++ ++ // Paper start ++ /** ++ * Sets the override for if the bee is currently rolling. ++ * ++ * @param rolling is rolling, or unset for vanilla behavior ++ */ ++ void setRollingOverride(@org.jetbrains.annotations.NotNull net.kyori.adventure.util.TriState rolling); ++ ++ /** ++ * Gets the plugin set override for if the bee is currently rolling. ++ * ++ * @return plugin set rolling override ++ */ ++ @org.jetbrains.annotations.NotNull ++ net.kyori.adventure.util.TriState getRollingOverride(); ++ ++ /** ++ * Gets if the bee is currently rolling. ++ * ++ * @return is rolling ++ */ ++ boolean isRolling(); ++ ++ /** ++ * Sets how many crops this bee has grown since it last ++ * pollinated. ++ * @param crops number of crops ++ */ ++ void setCropsGrownSincePollination(int crops); ++ ++ /** ++ * Gets how many crops this bee has grown since it last ++ * pollinated. ++ * @return number of crops ++ */ ++ int getCropsGrownSincePollination(); ++ ++ /** ++ * Sets how many ticks this bee has gone without pollinating. ++ * ++ * @param ticks number of ticks ++ */ ++ void setTicksSincePollination(int ticks); ++ ++ /** ++ * Gets how many ticks this bee has gone without pollinating ++ * ++ * @return number of ticks ++ */ ++ int getTicksSincePollination(); ++ // Paper end + } +diff --git a/src/main/java/org/bukkit/entity/Cat.java b/src/main/java/org/bukkit/entity/Cat.java +index d1327761a4b95eba97877f1991fc19b298b48eaf..0534fbc228f64cf3b361ab097d9b88212bdb0f36 100644 +--- a/src/main/java/org/bukkit/entity/Cat.java ++++ b/src/main/java/org/bukkit/entity/Cat.java +@@ -68,4 +68,36 @@ public interface Cat extends Tameable, Sittable { + return key; + } + } ++ ++ // Paper start - More cat api ++ /** ++ * Sets if the cat is lying down. ++ * This is visual and does not affect the behaviour of the cat. ++ * ++ * @param lyingDown whether the cat should lie down ++ */ ++ public void setLyingDown(boolean lyingDown); ++ ++ /** ++ * Gets if the cat is lying down. ++ * ++ * @return whether the cat is lying down ++ */ ++ public boolean isLyingDown(); ++ ++ /** ++ * Sets if the cat has its head up. ++ * This is visual and does not affect the behaviour of the cat. ++ * ++ * @param headUp head is up ++ */ ++ public void setHeadUp(boolean headUp); ++ ++ /** ++ * Gets if the cat has its head up. ++ * ++ * @return head is up ++ */ ++ public boolean isHeadUp(); ++ // Paper end - More cat api + } +diff --git a/src/main/java/org/bukkit/entity/Chicken.java b/src/main/java/org/bukkit/entity/Chicken.java +index cb3ec6ef6c38c2071cb6ad91da094fca2de8d5c6..b4c1a262602d4ca5ffc9fcc21d6aa79af8c040a7 100644 +--- a/src/main/java/org/bukkit/entity/Chicken.java ++++ b/src/main/java/org/bukkit/entity/Chicken.java +@@ -3,4 +3,35 @@ package org.bukkit.entity; + /** + * Represents a Chicken. + */ +-public interface Chicken extends Animals {} ++// Paper start ++public interface Chicken extends Animals { ++ ++ /** ++ * Gets if this chicken was spawned as a chicken jockey. ++ * ++ * @return is chicken jockey ++ */ ++ boolean isChickenJockey(); ++ ++ /** ++ * Sets if this chicken was spawned as a chicken jockey. ++ * ++ * @param isChickenJockey is chicken jockey ++ */ ++ void setIsChickenJockey(boolean isChickenJockey); ++ ++ /** ++ * Gets the number of ticks till this chicken lays an egg. ++ * ++ * @return ticks till the chicken lays an egg ++ */ ++ int getEggLayTime(); ++ ++ /** ++ * Sets the number of ticks till this chicken lays an egg. ++ * ++ * @param eggLayTime ticks till the chicken lays an egg ++ */ ++ void setEggLayTime(int eggLayTime); ++} ++// Paper end +diff --git a/src/main/java/org/bukkit/entity/Cod.java b/src/main/java/org/bukkit/entity/Cod.java +index 191ce6c0e32ab3d05b1376e0fa56d1292c2d442c..8de09075e14a08a6c68f9c24e8960cc04a018036 100644 +--- a/src/main/java/org/bukkit/entity/Cod.java ++++ b/src/main/java/org/bukkit/entity/Cod.java +@@ -4,4 +4,4 @@ package org.bukkit.entity; + /** + * Represents a cod fish. + */ +-public interface Cod extends Fish { } ++public interface Cod extends io.papermc.paper.entity.SchoolableFish { } // Paper - Schooling Fish API +diff --git a/src/main/java/org/bukkit/entity/Enderman.java b/src/main/java/org/bukkit/entity/Enderman.java +index 58191017244f3949f6174fb108e3a245738a53c4..61672c6faf94aa497145aadd634bb10103c7b05a 100644 +--- a/src/main/java/org/bukkit/entity/Enderman.java ++++ b/src/main/java/org/bukkit/entity/Enderman.java +@@ -86,4 +86,36 @@ public interface Enderman extends Monster { + * @return true if the teleport succeeded. + */ + public boolean teleportTowards(@NotNull Entity entity); ++ ++ // Paper start ++ /** ++ * Returns whether the enderman is screaming/angry. ++ * ++ * @return whether the enderman is screaming ++ */ ++ boolean isScreaming(); ++ ++ /** ++ * Sets whether the enderman is screaming/angry. ++ * ++ * @param screaming whether the enderman is screaming ++ */ ++ void setScreaming(boolean screaming); ++ ++ /** ++ * Returns whether the enderman has been stared at. ++ * If set to true, players will hear an ambient sound. ++ * ++ * @return whether the enderman has been stared at ++ */ ++ boolean hasBeenStaredAt(); ++ ++ /** ++ * Sets whether the enderman has been stared at. ++ * If set to true, players will hear an ambient sound. ++ * ++ * @param hasBeenStaredAt whether the enderman has been stared at ++ */ ++ void setHasBeenStaredAt(boolean hasBeenStaredAt); ++ // Paper end + } +diff --git a/src/main/java/org/bukkit/entity/Endermite.java b/src/main/java/org/bukkit/entity/Endermite.java +index 9e7f42caab1204036f4203354c115fd40c6def92..138d2530de2410f4a9424dabd3e5ce0cd1c1dcd2 100644 +--- a/src/main/java/org/bukkit/entity/Endermite.java ++++ b/src/main/java/org/bukkit/entity/Endermite.java +@@ -23,4 +23,22 @@ public interface Endermite extends Monster { + */ + @Deprecated + void setPlayerSpawned(boolean playerSpawned); ++ // Paper start ++ /** ++ * Sets how many ticks this endermite has been living for. ++ * If this value is greater than 2400, this endermite will despawn. ++ * ++ * @param ticks lifetime ticks ++ */ ++ void setLifetimeTicks(int ticks); ++ ++ /** ++ * Gets how long this endermite has been living for. ++ * This value will tick up while {@link LivingEntity#getRemoveWhenFarAway()} is false. ++ * If this value is greater than 2400, this endermite will despawn. ++ * ++ * @return lifetime ticks ++ */ ++ int getLifetimeTicks(); ++ // Paper end + } +diff --git a/src/main/java/org/bukkit/entity/Fox.java b/src/main/java/org/bukkit/entity/Fox.java +index c61a473453f33f9d10c330fc46cfa9d52251fe49..473a7e36ad64f866d1d2e09e2ecb2e9881668faf 100644 +--- a/src/main/java/org/bukkit/entity/Fox.java ++++ b/src/main/java/org/bukkit/entity/Fox.java +@@ -92,4 +92,55 @@ public interface Fox extends Animals, Sittable { + RED, + SNOW; + } ++ ++ // Paper start - Add more fox behavior API ++ /** ++ * Sets if the fox is interested. ++ * ++ * @param interested is interested ++ */ ++ public void setInterested(boolean interested); ++ ++ /** ++ * Gets if the fox is interested. ++ * ++ * @return fox is interested ++ */ ++ public boolean isInterested(); ++ ++ /** ++ * Sets if the fox is leaping. ++ * ++ * @param leaping is leaping ++ */ ++ public void setLeaping(boolean leaping); ++ ++ /** ++ * Gets if the fox is leaping. ++ * ++ * @return fox is leaping ++ */ ++ public boolean isLeaping(); ++ ++ /** ++ * Sets if the fox is defending. ++ * ++ * @param defending is defending ++ */ ++ public void setDefending(boolean defending); ++ ++ /** ++ * Gets if the fox is defending. ++ * ++ * @return fox is defending ++ */ ++ public boolean isDefending(); ++ ++ /** ++ * Sets if the fox face planted. ++ * ++ * @param faceplanted face planted ++ */ ++ public void setFaceplanted(boolean faceplanted); ++ // Paper end - Add more fox behavior API + } +diff --git a/src/main/java/org/bukkit/entity/Ghast.java b/src/main/java/org/bukkit/entity/Ghast.java +index 6b3c9bef9a8a34ddc6ff42cf358541a2665bf5e3..9c618a27d590f186f29c5d9094fc565efd40ca49 100644 +--- a/src/main/java/org/bukkit/entity/Ghast.java ++++ b/src/main/java/org/bukkit/entity/Ghast.java +@@ -18,4 +18,21 @@ public interface Ghast extends Flying, Enemy { + * @param flag Whether the Ghast is charging + */ + void setCharging(boolean flag); ++ ++ // Paper start ++ /** ++ * Returns the explosion power of shot fireballs. ++ * ++ * @return explosion power of shot fireballs ++ */ ++ int getExplosionPower(); ++ ++ /** ++ * Sets the explosion power of shot fireballs. ++ * ++ * @param explosionPower explosion power of shot fireballs ++ * @throws IllegalArgumentException if the explosion power is less than 0 or greater than 127 ++ */ ++ void setExplosionPower(int explosionPower); ++ // Paper end + } +diff --git a/src/main/java/org/bukkit/entity/LivingEntity.java b/src/main/java/org/bukkit/entity/LivingEntity.java +index b1fb059fc2249814c9e509c219da2aed84d34fe0..6e6b80843a8669b422f93e98343e1da9f8546ee7 100644 +--- a/src/main/java/org/bukkit/entity/LivingEntity.java ++++ b/src/main/java/org/bukkit/entity/LivingEntity.java +@@ -1016,6 +1016,57 @@ public interface LivingEntity extends Attributable, Damageable, ProjectileSource + void clearActiveItem(); + // Paper end + ++ // Paper start ++ /** ++ * Retrieves the sideways movement direction of the entity. ++ * <p> ++ * The returned value ranges from -1 to 1, where: ++ * - Positive 1 represents movement to the left. ++ * - Negative 1 represents movement to the right. ++ * <p> ++ * Please note that for entities of type {@link Player}, this value is updated only when riding another entity. ++ * <p> ++ * This method specifically provides information about the entity's sideways movement, whereas {@link #getVelocity()} returns ++ * a vector representing the entity's overall current momentum. ++ * ++ * @return Sideways movement direction, ranging from -1 (right) to 1 (left). ++ */ ++ float getSidewaysMovement(); ++ ++ /** ++ * Retrieves the upwards movement direction of the entity. ++ * <p> ++ * The returned value ranges from -1 to 1, where: ++ * - Positive 1 represents upward movement. ++ * - Negative 1 represents downward movement. ++ * <p> ++ * Please note that for entities of type {@link Player}, this value is never updated. ++ * <p> ++ * This method specifically provides information about the entity's vertical movement, ++ * whereas {@link #getVelocity()} returns a vector representing the entity's overall ++ * current momentum. ++ * ++ * @return Upwards movement direction, ranging from -1 (downward) to 1 (upward). ++ */ ++ float getUpwardsMovement(); ++ ++ /** ++ * Retrieves the forwards movement direction of the entity. ++ * <p> ++ * The returned value ranges from -1 to 1, where: ++ * - Positive 1 represents movement forwards. ++ * - Negative 1 represents movement backwards. ++ * <p> ++ * Please note that for entities of type {@link Player}, this value is updated only when riding another entity. ++ * <p> ++ * This method specifically provides information about the entity's forward and backward movement, ++ * whereas {@link #getVelocity()} returns a vector representing the entity's overall current momentum. ++ * ++ * @return Forwards movement direction, ranging from -1 (backward) to 1 (forward). ++ */ ++ float getForwardsMovement(); ++ // Paper end ++ + /** + * Get's remaining time a player needs to keep hands raised with an item to finish using it. + * @return Remaining ticks to use the item +diff --git a/src/main/java/org/bukkit/entity/Llama.java b/src/main/java/org/bukkit/entity/Llama.java +index d23226ccb0f6c25028f000ce31346cd0a8898e6a..bc84b892cae5fe7019a3ad481e9da79956efa1fe 100644 +--- a/src/main/java/org/bukkit/entity/Llama.java ++++ b/src/main/java/org/bukkit/entity/Llama.java +@@ -67,4 +67,56 @@ public interface Llama extends ChestedHorse, RangedEntity { // Paper + @NotNull + @Override + LlamaInventory getInventory(); ++ ++ // Paper start ++ /** ++ * Checks if this llama is in a caravan. ++ * This means that this llama is currently following ++ * another llama. ++ * ++ * @return is in caravan ++ */ ++ boolean inCaravan(); ++ ++ /** ++ * Joins a caravan, with the provided llama being the leader ++ * of the caravan. ++ * This llama will then follow the provided llama. ++ * ++ * @param llama head of caravan to join ++ */ ++ void joinCaravan(@NotNull Llama llama); ++ ++ /** ++ * Leaves the current caravan that they are in. ++ */ ++ void leaveCaravan(); ++ ++ /** ++ * Get the llama that this llama is following. ++ * <p> ++ * Does not necessarily mean the leader of the entire caravan. ++ * ++ * @return the llama currently being followed ++ */ ++ @org.jetbrains.annotations.Nullable ++ Llama getCaravanHead(); ++ ++ /** ++ * Checks if another llama is currently following behind ++ * this llama. ++ * ++ * @return true if being followed in the caravan ++ */ ++ boolean hasCaravanTail(); ++ ++ /** ++ * Gets the llama that is currently following behind ++ * this llama. ++ * ++ * @return the llama following this llama, or null if none is following them ++ */ ++ @org.jetbrains.annotations.Nullable ++ Llama getCaravanTail(); ++ // Paper end + } +diff --git a/src/main/java/org/bukkit/entity/Mob.java b/src/main/java/org/bukkit/entity/Mob.java +index 11b6d1aba7d1f6ae1f3c822193486f5a1478e105..709c8fc3dde786f45ff13d6ee6c405ffdc765282 100644 +--- a/src/main/java/org/bukkit/entity/Mob.java ++++ b/src/main/java/org/bukkit/entity/Mob.java +@@ -162,4 +162,38 @@ public interface Mob extends LivingEntity, Lootable { + */ + @Nullable + public Sound getAmbientSound(); ++ ++ // Paper start ++ /** ++ * Some mobs will raise their arm(s) when aggressive: ++ * <ul> ++ * <li>{@link Drowned}</li> ++ * <li>{@link Piglin}</li> ++ * <li>{@link Skeleton}</li> ++ * <li>{@link Zombie}</li> ++ * <li>{@link ZombieVillager}</li> ++ * <li>{@link Illusioner}</li> ++ * <li>{@link Vindicator}</li> ++ * <li>{@link Panda}</li> ++ * <li>{@link Pillager}</li> ++ * <li>{@link PiglinBrute}</li> ++ * </ul> ++ * <p> ++ * Note: This doesn't always show the actual aggressive state as ++ * set by {@link #setAggressive(boolean)}. {@link Panda}'s are always ++ * aggressive if their combined {@link Panda.Gene} is {@link Panda.Gene#AGGRESSIVE}. ++ * ++ * @return wether the mob is aggressive or not ++ */ ++ boolean isAggressive(); ++ ++ /** ++ * Some mobs will raise their arm(s) when aggressive, ++ * see {@link #isAggressive()} for full list. ++ * ++ * @param aggressive wether the mob should be aggressive or not ++ * @see #isAggressive() ++ */ ++ void setAggressive(boolean aggressive); ++ // Paper end + } +diff --git a/src/main/java/org/bukkit/entity/MushroomCow.java b/src/main/java/org/bukkit/entity/MushroomCow.java +index cef1700834643fe28ed5737578d91ecefbe99e2f..794b7b4a870a0d289476074e3a3f46552604c954 100644 +--- a/src/main/java/org/bukkit/entity/MushroomCow.java ++++ b/src/main/java/org/bukkit/entity/MushroomCow.java +@@ -95,4 +95,75 @@ public interface MushroomCow extends Cow { + */ + BROWN; + } ++ // Paper start ++ /** ++ * Gets how long the effect applied to stew ++ * from this mushroom cow is. ++ * ++ * @return duration of the effect (in ticks) ++ * @deprecated Mushroom cows can now hold multiple effects, use {@link #getStewEffects()} ++ */ ++ @Deprecated(forRemoval = true) ++ @org.jetbrains.annotations.Contract("-> fail") ++ default int getStewEffectDuration() { ++ throw new UnsupportedOperationException("Mushroom cows can now hold multiple effects. Use #getStewEffects"); ++ } ++ ++ /** ++ * Sets how long the effect applied to stew ++ * from this mushroom cow is. ++ * ++ * @param duration duration of the effect (in ticks) ++ * @deprecated Mushroom cows can now hold multiple effects, use {@link #setStewEffects(java.util.List)} ++ */ ++ @Deprecated(forRemoval = true) ++ @org.jetbrains.annotations.Contract("_ -> fail") ++ default void setStewEffectDuration(int duration) { ++ throw new UnsupportedOperationException("Mushroom cows can now hold multiple effects. Use #setStewEffects"); ++ } ++ ++ /** ++ * Gets the type of effect applied to stew ++ * from this mushroom cow is. ++ * ++ * @return effect type, or null if an effect is currently not set ++ * @deprecated Mushroom cows can now hold multiple effects, use {@link #getStewEffects()} ++ * @throws UnsupportedOperationException ++ */ ++ @Deprecated(forRemoval = true) ++ @org.jetbrains.annotations.Contract("-> fail") ++ default org.bukkit.potion.PotionEffectType getStewEffectType() { ++ throw new UnsupportedOperationException("Mushroom cows can now hold multiple effects. Use #getStewEffects"); ++ } ++ ++ /** ++ * Sets the type of effect applied to stew ++ * from this mushroom cow is. ++ * ++ * @param type new effect type ++ * or null if this cow does not give effects ++ * @deprecated Mushroom cows can now hold multiple effects, use {@link #setStewEffects(java.util.List)} ++ * @throws UnsupportedOperationException ++ */ ++ @Deprecated(forRemoval = true) ++ @org.jetbrains.annotations.Contract("_ -> fail") ++ default void setStewEffect(@org.jetbrains.annotations.Nullable org.bukkit.potion.PotionEffectType type) { ++ throw new UnsupportedOperationException("Mushroom cows can now hold multiple effects. Use #setStewEffects"); ++ } ++ ++ /** ++ * Returns an immutable collection of the effects applied to stew ++ * items for this mushroom cow. ++ * ++ * @return immutable effect entry collection ++ */ ++ java.util.@NotNull @org.jetbrains.annotations.Unmodifiable List<io.papermc.paper.potion.SuspiciousEffectEntry> getStewEffects(); ++ ++ /** ++ * Sets effects applied to stew items for this mushroom cow. ++ * ++ * @param effects effect entry list ++ */ ++ void setStewEffects(java.util.@NotNull List<io.papermc.paper.potion.SuspiciousEffectEntry> effects); ++ // Paper end + } +diff --git a/src/main/java/org/bukkit/entity/Panda.java b/src/main/java/org/bukkit/entity/Panda.java +index 1f027927a1194f4f8e86c1375a2772e6e261c151..aa5686df134185334a74429576ff0709a604dbfd 100644 +--- a/src/main/java/org/bukkit/entity/Panda.java ++++ b/src/main/java/org/bukkit/entity/Panda.java +@@ -107,6 +107,98 @@ public interface Panda extends Animals, Sittable { + */ + int getUnhappyTicks(); + ++ // Paper start - Panda API ++ /** ++ * Sets the sneeze progress in this animation. ++ * This value counts up only if {@link Panda#isSneezing()} is true ++ * ++ * @param ticks sneeze progress ++ */ ++ void setSneezeTicks(int ticks); ++ ++ /** ++ * Gets the current sneeze progress, or how many ticks this panda will sneeze for. ++ * ++ * @return sneeze progress ++ */ ++ int getSneezeTicks(); ++ ++ /** ++ * Sets the eating ticks for this panda. ++ * <p> ++ * ++ * This starts counting up as long as it is greater than 0. ++ * ++ * @param ticks eating ticks ++ */ ++ void setEatingTicks(int ticks); ++ ++ /** ++ * Gets the current eating progress, or how many ticks this panda has been eating for. ++ * ++ * @return eating progress ++ */ ++ int getEatingTicks(); ++ ++ /** ++ * Sets the number of ticks this panda will be unhappy for. ++ * <p> ++ * This value counts down. ++ * ++ * @param ticks unhappy ticks ++ */ ++ void setUnhappyTicks(int ticks); ++ ++ /** ++ * Sets if this panda is currently on its back. ++ * ++ * @param onBack is on its back ++ * @deprecated use {@link #setOnBack(boolean)} ++ */ ++ @Deprecated(forRemoval = true) ++ default void setIsOnBack(boolean onBack) { ++ this.setOnBack(onBack); ++ } ++ ++ /** ++ * Sets if this panda is currently sitting. ++ * ++ * @param sitting is currently sitting ++ * @deprecated use {@link #setSitting(boolean)} ++ */ ++ @Deprecated(forRemoval = true) ++ default void setIsSitting(boolean sitting) { ++ this.setSitting(sitting); ++ } ++ ++ /** ++ * Sets if this panda is currently sitting. ++ * ++ * @param sitting is currently sitting ++ */ ++ @Override ++ void setSitting(boolean sitting); ++ ++ /** ++ * Gets if this panda is sitting. ++ * ++ * @return is sitting ++ */ ++ @Override ++ boolean isSitting(); ++ ++ /** ++ * Gets this Panda's combined gene. ++ * <p> ++ * The combined gene can be modified using ++ * {@link #setMainGene(Gene)} or {@link #setHiddenGene(Gene)}. ++ * ++ * @return combined gene ++ */ ++ @NotNull ++ Gene getCombinedGene(); ++ // Paper end - Panda API ++ + public enum Gene { + + NORMAL(false), +diff --git a/src/main/java/org/bukkit/entity/Phantom.java b/src/main/java/org/bukkit/entity/Phantom.java +index 3dafdf14ced991ae1179ef1ca455da62f8c3243e..2fe8e8868f12bd9e846baf8858cd2c333c00a0d8 100644 +--- a/src/main/java/org/bukkit/entity/Phantom.java ++++ b/src/main/java/org/bukkit/entity/Phantom.java +@@ -40,5 +40,21 @@ public interface Phantom extends Flying, Enemy { + * @param shouldBurnInDay True to burn in sunlight + */ + public void setShouldBurnInDay(boolean shouldBurnInDay); ++ ++ /** ++ * Gets the location that this phantom circles around when not attacking a player ++ * This will be changed after attacking a player. ++ * ++ * @return circling location ++ */ ++ @org.jetbrains.annotations.NotNull ++ org.bukkit.Location getAnchorLocation(); ++ ++ /** ++ * Sets the location that this phantom circles around when not attacking a player ++ * ++ * @param location circling location (world is ignored, will always use the entity's world) ++ */ ++ void setAnchorLocation(@org.jetbrains.annotations.NotNull org.bukkit.Location location); + // Paper end + } +diff --git a/src/main/java/org/bukkit/entity/Piglin.java b/src/main/java/org/bukkit/entity/Piglin.java +index 6fdc0e0bb62189dbf3cf9ce7a87b7fbb995956a3..eb0b7c18c1266748ff1e8e18e49b6c4f6e078b83 100644 +--- a/src/main/java/org/bukkit/entity/Piglin.java ++++ b/src/main/java/org/bukkit/entity/Piglin.java +@@ -90,4 +90,47 @@ public interface Piglin extends PiglinAbstract, InventoryHolder, com.destroystok + */ + @NotNull + public Set<Material> getBarterList(); ++ ++ // Paper start ++ /** ++ * Causes the piglin to appear as if they are charging ++ * a crossbow. ++ * <p> ++ * This works with any item currently held in the piglin's hand. ++ * ++ * @param chargingCrossbow is charging ++ */ ++ void setChargingCrossbow(boolean chargingCrossbow); ++ ++ /** ++ * Gets if the piglin is currently charging the ++ * item in their hand. ++ * ++ * @return is charging ++ */ ++ boolean isChargingCrossbow(); ++ ++ /** ++ * Sets whether the Piglin is dancing or not ++ * ++ * @param dancing is dancing ++ */ ++ void setDancing(boolean dancing); ++ ++ /** ++ * Causes the piglin to dance for a ++ * specified amount of time ++ * ++ * @param duration duration of the dance in ticks ++ */ ++ void setDancing(long duration); ++ ++ /** ++ * Gets if the piglin is currently dancing ++ * ++ * @return is dancing ++ */ ++ boolean isDancing(); ++ // Paper end ++ + } +diff --git a/src/main/java/org/bukkit/entity/PolarBear.java b/src/main/java/org/bukkit/entity/PolarBear.java +index 479f7a7c54c85cb685f56e60906650d1989c03ff..4e526ba6aa462a484984fb9f0512b8db113086fe 100644 +--- a/src/main/java/org/bukkit/entity/PolarBear.java ++++ b/src/main/java/org/bukkit/entity/PolarBear.java +@@ -3,4 +3,22 @@ package org.bukkit.entity; + /** + * Represents a polar bear. + */ +-public interface PolarBear extends Animals {} ++// Paper start ++public interface PolarBear extends Animals { ++ ++ /** ++ * Returns whether the polar bear is standing. ++ * ++ * @return whether the polar bear is standing ++ */ ++ boolean isStanding(); ++ ++ /** ++ * Sets whether the polar bear is standing. ++ * ++ * @param standing whether the polar bear should be standing ++ */ ++ void setStanding(boolean standing); ++ ++} ++// Paper end +diff --git a/src/main/java/org/bukkit/entity/Rabbit.java b/src/main/java/org/bukkit/entity/Rabbit.java +index e88154283a8ef594e160d25005870053de15568a..979062aa476e3bd75166458d8831894fba8778cd 100644 +--- a/src/main/java/org/bukkit/entity/Rabbit.java ++++ b/src/main/java/org/bukkit/entity/Rabbit.java +@@ -14,6 +14,23 @@ public interface Rabbit extends Animals { + * @param type Sets the type of rabbit for this entity. + */ + public void setRabbitType(@NotNull Type type); ++ // Paper start ++ /** ++ * Sets how many ticks this rabbit will wait ++ * until trying to find more carrots. ++ * ++ * @param ticks ticks ++ */ ++ void setMoreCarrotTicks(int ticks); ++ ++ /** ++ * Returns how many ticks this rabbit ++ * will wait until trying to find more carrots. ++ * ++ * @return ticks ++ */ ++ int getMoreCarrotTicks(); ++ // Paper end + + /** + * Represents the various types a Rabbit might be. +diff --git a/src/main/java/org/bukkit/entity/Ravager.java b/src/main/java/org/bukkit/entity/Ravager.java +index 4374d5206d4d15a4d8d228c137ed9a96821a1f02..0eb7214472f3a43641a3526000af6beeefb7b36f 100644 +--- a/src/main/java/org/bukkit/entity/Ravager.java ++++ b/src/main/java/org/bukkit/entity/Ravager.java +@@ -3,4 +3,61 @@ package org.bukkit.entity; + /** + * Illager beast. + */ +-public interface Ravager extends Raider { } ++// Paper start - Missing Entity Behavior ++public interface Ravager extends Raider { ++ ++ /** ++ * Gets how many ticks this ravager is attacking for. ++ * When attacking, the ravager cannot move. ++ * ++ * @return ticks attacking or -1 if they are currently not attacking ++ */ ++ int getAttackTicks(); ++ ++ /** ++ * Sets how many ticks this ravager is attacking for. ++ * When attacking, the ravager cannot move. ++ * This will tick down till it gets to -1, where this ravager will no longer be attacking. ++ * ++ * @param ticks ticks attacking or -1 if they should no longer be attacking ++ */ ++ void setAttackTicks(int ticks); ++ ++ /** ++ * Gets how many ticks the ravager is stunned for. ++ * The ravager cannot move or attack while stunned. ++ * At 0, this will cause the ravager to roar. ++ * ++ * @return ticks stunned or -1 if they are currently not stunned ++ */ ++ int getStunnedTicks(); ++ ++ /** ++ * Sets how many ticks the ravager is stunned for. ++ * The ravager cannot move or attack while stunned. ++ * At 0, this will cause the ravager to roar. ++ * ++ * @param ticks ticks stunned or -1 if they should no longer be stunned ++ */ ++ void setStunnedTicks(int ticks); ++ ++ /** ++ * Gets how many ticks the ravager is roaring for. ++ * While roaring, the ravager cannot move ++ * ++ * @return ticks roaring or -1 if they are currently not roaring ++ */ ++ int getRoarTicks(); ++ ++ /** ++ * Sets how many ticks the ravager is roaring for. ++ * While roaring, the ravager cannot move ++ * This will tick down till it gets to -1, where it is no longer active. ++ * If set to 11, this will play a sound and hurt nearby players. ++ * ++ * @param ticks ticks roaring or -1 if they should no longer be roaring ++ */ ++ void setRoarTicks(int ticks); ++ ++} ++// Paper end +diff --git a/src/main/java/org/bukkit/entity/Salmon.java b/src/main/java/org/bukkit/entity/Salmon.java +index a52a7af219633d575dcbe8ac4b219834bfd4d4d2..1e839b247182af6873a4d74b236d6412817c18bf 100644 +--- a/src/main/java/org/bukkit/entity/Salmon.java ++++ b/src/main/java/org/bukkit/entity/Salmon.java +@@ -4,4 +4,4 @@ package org.bukkit.entity; + /** + * Represents a salmon fish. + */ +-public interface Salmon extends Fish { } ++public interface Salmon extends io.papermc.paper.entity.SchoolableFish { } // Paper - Schooling Fish API +diff --git a/src/main/java/org/bukkit/entity/TNTPrimed.java b/src/main/java/org/bukkit/entity/TNTPrimed.java +index 0813bd913c8fdb2001963ce3e82c07c2af105418..87e717c9ea61b0cbf536bc62fa829ddcfae5ad8c 100644 +--- a/src/main/java/org/bukkit/entity/TNTPrimed.java ++++ b/src/main/java/org/bukkit/entity/TNTPrimed.java +@@ -64,4 +64,26 @@ public interface TNTPrimed extends Explosive { + default org.bukkit.Location getSourceLoc() { + return this.getOrigin(); + } ++ ++ // Paper start ++ /** ++ * Sets the visual block data of this ++ * primed tnt. ++ * <br> ++ * The explosion of the tnt stays the ++ * same and is not affected by this change. ++ * ++ * @param data the visual block data ++ */ ++ void setBlockData(@org.jetbrains.annotations.NotNull org.bukkit.block.data.BlockData data); ++ ++ /** ++ * Gets the visual block data of this ++ * primed tnt. ++ * ++ * @return the visual block data ++ */ ++ @org.jetbrains.annotations.NotNull ++ org.bukkit.block.data.BlockData getBlockData(); ++ // Paper end + } +diff --git a/src/main/java/org/bukkit/entity/Tadpole.java b/src/main/java/org/bukkit/entity/Tadpole.java +index d64979ebdd018f0f63b6115809b48374ba454249..8e097ad55d208a6980c320e2a849efdcc504cff1 100644 +--- a/src/main/java/org/bukkit/entity/Tadpole.java ++++ b/src/main/java/org/bukkit/entity/Tadpole.java +@@ -18,4 +18,21 @@ public interface Tadpole extends Fish { + * @param age New age + */ + public void setAge(int age); ++ ++ // Paper start - Tadpole age lock api ++ /** ++ * Lock the age of the animal, setting this will prevent the animal from ++ * maturing. ++ * ++ * @param lock new lock ++ */ ++ void setAgeLock(boolean lock); ++ ++ /** ++ * Gets the current agelock. ++ * ++ * @return the current agelock ++ */ ++ boolean getAgeLock(); ++ // Paper end + } +diff --git a/src/main/java/org/bukkit/entity/Trident.java b/src/main/java/org/bukkit/entity/Trident.java +index 28cdb3b544572ba7aeb9061e3163e3895ac7d4e6..c8015ff610e3c1222cb368ea1d8a0c2f3785d9c7 100644 +--- a/src/main/java/org/bukkit/entity/Trident.java ++++ b/src/main/java/org/bukkit/entity/Trident.java +@@ -3,4 +3,40 @@ package org.bukkit.entity; + /** + * Represents a thrown trident. + */ +-public interface Trident extends AbstractArrow, ThrowableProjectile { } ++// Paper start ++public interface Trident extends AbstractArrow, ThrowableProjectile { ++ ++ /** ++ * Returns whether the trident has an enchanted glow. ++ * This can be separate from the underlying item having any enchantments. ++ * ++ * @return whether the trident has an enchanted glow ++ */ ++ boolean hasGlint(); ++ ++ /** ++ * Sets whether the trident has an enchanted glow. ++ * This is separate from the underlying item having any enchantments. ++ * ++ * @param glint whether the trident should have an enchanted glow ++ */ ++ void setGlint(boolean glint); ++ ++ /** ++ * Returns the loyalty level of the trident. ++ * This can be separate from the underlying item's enchantments. ++ * ++ * @return loyalty level of the trident ++ */ ++ int getLoyaltyLevel(); ++ ++ /** ++ * Sets the loyalty level of the trident. ++ * This is separate from the underlying item's enchantments. ++ * ++ * @param loyaltyLevel loyalty level ++ * @throws IllegalArgumentException if the loyalty level is lower than 0 or greater than 127 ++ */ ++ void setLoyaltyLevel(int loyaltyLevel); ++} ++// Paper end +diff --git a/src/main/java/org/bukkit/entity/TropicalFish.java b/src/main/java/org/bukkit/entity/TropicalFish.java +index ab31289bb0f9c8e581537a88e1db22bcdbd3d484..84bba32e80d755f094975b667f1bf2a132087f4f 100644 +--- a/src/main/java/org/bukkit/entity/TropicalFish.java ++++ b/src/main/java/org/bukkit/entity/TropicalFish.java +@@ -6,7 +6,7 @@ import org.jetbrains.annotations.NotNull; + /** + * Tropical fish. + */ +-public interface TropicalFish extends Fish { ++public interface TropicalFish extends io.papermc.paper.entity.SchoolableFish { // Paper - Schooling Fish API + + /** + * Gets the color of the fish's pattern. +diff --git a/src/main/java/org/bukkit/entity/Vex.java b/src/main/java/org/bukkit/entity/Vex.java +index 627e3c1a96ae3331f5aa2dd7803dd2a31c7204be..3c447d2300c866ae605eeca97bd869f400d6be6f 100644 +--- a/src/main/java/org/bukkit/entity/Vex.java ++++ b/src/main/java/org/bukkit/entity/Vex.java +@@ -57,21 +57,30 @@ public interface Vex extends Monster { + * Gets the remaining lifespan of this entity. + * + * @return life in ticks ++ * @deprecated This API duplicates existing API which uses the more ++ * preferable name due to mirroring internals better + */ ++ @Deprecated + int getLifeTicks(); + + /** + * Sets the remaining lifespan of this entity. + * + * @param lifeTicks life in ticks, or negative for unlimited lifepan ++ * @deprecated This API duplicates existing API which uses the more ++ * preferable name due to mirroring internals better + */ ++ @Deprecated + void setLifeTicks(int lifeTicks); + + /** + * Gets if the entity has a limited life. + * + * @return true if the entity has limited life ++ * @deprecated This API duplicates existing API which uses the more ++ * preferable name due to mirroring internals better + */ ++ @Deprecated + boolean hasLimitedLife(); + // Paper start + +@@ -89,5 +98,37 @@ public interface Vex extends Monster { + * @param summoner New summoner + */ + void setSummoner(@Nullable Mob summoner); ++ ++ /** ++ * Gets if this vex should start to take damage ++ * once {@link Vex#getLimitedLifetimeTicks()} is less than or equal to 0. ++ * ++ * @return will take damage ++ */ ++ boolean hasLimitedLifetime(); ++ ++ /** ++ * Sets if this vex should start to take damage ++ * once {@link Vex#getLimitedLifetimeTicks()} is less than or equal to 0. ++ * ++ * @param hasLimitedLifetime should take damage ++ */ ++ void setLimitedLifetime(boolean hasLimitedLifetime); ++ ++ /** ++ * Gets the number of ticks remaining until the vex will start ++ * to take damage. ++ * ++ * @return ticks until the vex will start to take damage ++ */ ++ int getLimitedLifetimeTicks(); ++ ++ /** ++ * Sets the number of ticks remaining until the vex takes damage. ++ * This number is ticked down only if {@link Vex#hasLimitedLifetime()} is true. ++ * ++ * @param ticks ticks remaining ++ */ ++ void setLimitedLifetimeTicks(int ticks); + // Paper end + } +diff --git a/src/main/java/org/bukkit/entity/WanderingTrader.java b/src/main/java/org/bukkit/entity/WanderingTrader.java +index da76e1ed5406322073dd8c7a89ca55aa68620ac4..9f25774659b29d8fcca3eb9d9487edff42dbad13 100644 +--- a/src/main/java/org/bukkit/entity/WanderingTrader.java ++++ b/src/main/java/org/bukkit/entity/WanderingTrader.java +@@ -53,5 +53,26 @@ public interface WanderingTrader extends AbstractVillager { + * @return whether the mob will drink + */ + public boolean canDrinkMilk(); ++ ++ /** ++ * Gets the location that this wandering trader is currently ++ * wandering towards. ++ * <p> ++ * This will return null if the wandering trader has finished ++ * wandering towards the given location. ++ * ++ * @return the location currently wandering towards, or null if not wandering ++ */ ++ @org.jetbrains.annotations.Nullable ++ org.bukkit.Location getWanderingTowards(); ++ ++ /** ++ * Sets the location that this wandering trader is currently wandering towards. ++ * <p> ++ * This can be set to null to prevent the wandering trader from wandering further. ++ * ++ * @param location location to wander towards (world is ignored, will always use the entity's world) ++ */ ++ void setWanderingTowards(@org.jetbrains.annotations.Nullable org.bukkit.Location location); + // Paper end + } +diff --git a/src/main/java/org/bukkit/entity/Warden.java b/src/main/java/org/bukkit/entity/Warden.java +index 3794db8867b53f3b3735ad82fdd8765a26df2bfb..efaa45f41bc1dc8df6665c55b4e5ade343d60d4c 100644 +--- a/src/main/java/org/bukkit/entity/Warden.java ++++ b/src/main/java/org/bukkit/entity/Warden.java +@@ -30,6 +30,18 @@ public interface Warden extends Monster { + */ + int getAnger(@NotNull Entity entity); + ++ // Paper start ++ /** ++ * Gets the highest anger level of this warden. ++ * <p> ++ * Anger is an integer from 0 to 150. Once a Warden reaches 80 anger at a ++ * target it will actively pursue it. ++ * ++ * @return highest anger level ++ */ ++ int getHighestAnger(); ++ // Paper end ++ + /** + * Increases the anger level of this warden. + * +diff --git a/src/main/java/org/bukkit/entity/Wither.java b/src/main/java/org/bukkit/entity/Wither.java +index 87a814f63c3f35be35bfa210c9248ad211c0dd8f..14543c2238b45c526dd9aebea2aa5c22f5df54dc 100644 +--- a/src/main/java/org/bukkit/entity/Wither.java ++++ b/src/main/java/org/bukkit/entity/Wither.java +@@ -43,7 +43,9 @@ public interface Wither extends Monster, Boss, com.destroystokyo.paper.entity.Ra + * Returns the wither's current invulnerability ticks. + * + * @return amount of invulnerability ticks ++ * @deprecated Duplicate api, use {@link #getInvulnerableTicks()} + */ ++ @Deprecated(forRemoval = true) // Paper + int getInvulnerabilityTicks(); + + /** +@@ -52,7 +54,9 @@ public interface Wither extends Monster, Boss, com.destroystokyo.paper.entity.Ra + * When invulnerability ticks reach 0, the wither will trigger an explosion. + * + * @param ticks amount of invulnerability ticks ++ * @deprecated Duplicate api, use {@link #setInvulnerableTicks(int)} + */ ++ @Deprecated(forRemoval = true) // Paper + void setInvulnerabilityTicks(int ticks); + + /** +@@ -64,4 +68,43 @@ public interface Wither extends Monster, Boss, com.destroystokyo.paper.entity.Ra + LEFT, + RIGHT + } ++ ++ // Paper start ++ /** ++ * @return whether the wither is charged ++ */ ++ boolean isCharged(); ++ ++ /** ++ * @return ticks the wither is invulnerable for ++ */ ++ int getInvulnerableTicks(); ++ ++ /** ++ * Sets for how long in the future, the wither should be invulnerable. ++ * ++ * @param ticks ticks the wither is invulnerable for ++ */ ++ void setInvulnerableTicks(int ticks); ++ ++ /** ++ * @return whether the wither can travel through portals ++ */ ++ boolean canTravelThroughPortals(); ++ ++ /** ++ * Sets whether the wither can travel through portals. ++ * ++ * @param value whether the wither can travel through portals ++ */ ++ void setCanTravelThroughPortals(boolean value); ++ ++ /** ++ * Makes the wither invulnerable for 11 seconds and ++ * sets the health to one third of the max health. ++ * <br> ++ * This is called in vanilla directly after spawning the wither. ++ */ ++ void enterInvulnerabilityPhase(); ++ // Paper end + } +diff --git a/src/main/java/org/bukkit/entity/ZombieVillager.java b/src/main/java/org/bukkit/entity/ZombieVillager.java +index 7cc1d9a966454af70b7c25735fe474fe3eb97eb4..ac6fd8ca95771c185c145f4589ddd5b2a6e8c2da 100644 +--- a/src/main/java/org/bukkit/entity/ZombieVillager.java ++++ b/src/main/java/org/bukkit/entity/ZombieVillager.java +@@ -90,4 +90,22 @@ public interface ZombieVillager extends Zombie { + * @param conversionPlayer the player + */ + void setConversionPlayer(@Nullable OfflinePlayer conversionPlayer); ++ ++ // Paper start - missing entity behaviour api - converting without entity event ++ /** ++ * Sets the amount of ticks until this entity will be converted to a ++ * Villager as a result of being cured. ++ * <p> ++ * When this reaches 0, the entity will be converted. A value of less than 0 ++ * will stop the current conversion process without converting the current ++ * entity. ++ * ++ * @param time new conversion time ++ * @param broadcastEntityEvent whether this conversion time mutation should broadcast the ++ * org.bukkit.{@link org.bukkit.EntityEffect#ZOMBIE_TRANSFORM} entity event to the ++ * world. If false, no entity event is published, preventing for example the ++ * org.bukkit.{@link org.bukkit.Sound#ENTITY_ZOMBIE_VILLAGER_CURE} from playing. ++ */ ++ void setConversionTime(int time, boolean broadcastEntityEvent); ++ // Paper end - missing entity behaviour api - converting without entity event + } +diff --git a/src/main/java/org/bukkit/entity/minecart/HopperMinecart.java b/src/main/java/org/bukkit/entity/minecart/HopperMinecart.java +index db69687a7ad4b18d17ab1677cae5d8dd4dcd3678..304b05aeaea5febf493fc40d433a23acb384b4f0 100644 +--- a/src/main/java/org/bukkit/entity/minecart/HopperMinecart.java ++++ b/src/main/java/org/bukkit/entity/minecart/HopperMinecart.java +@@ -24,4 +24,23 @@ public interface HopperMinecart extends Minecart, InventoryHolder, LootableEntit + * @param enabled new enabled state + */ + void setEnabled(boolean enabled); ++ // Paper start ++ /** ++ * Gets the number of ticks that this hopper minecart cannot pickup items up for. ++ * ++ * @return ticks left on cooldown ++ * @deprecated Hopper minecarts don't have cooldowns anymore ++ */ ++ @Deprecated(forRemoval = true) ++ int getPickupCooldown(); ++ ++ /** ++ * Sets the number of ticks that this hopper minecart cannot pickup items for. ++ * ++ * @param cooldown cooldown length in ticks ++ * @deprecated Hopper minecarts don't have cooldowns anymore ++ */ ++ @Deprecated(forRemoval = true) ++ void setPickupCooldown(int cooldown); ++ // Paper end + } |