patches

patches/api/0199-Add-item-slot-convenience-methods.patch

@@ -0,0 +1,283 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: KennyTV <jahnke.nassim@gmail.com>
+Date: Sat, 25 Apr 2020 23:31:28 +0200
+Subject: [PATCH] Add item slot convenience methods
+
+
+diff --git a/src/main/java/org/bukkit/inventory/AnvilInventory.java b/src/main/java/org/bukkit/inventory/AnvilInventory.java
+index 4af562426aa38faeb6822abb0c878a3ac346b383..b95e563b5454306a9188ae3295309ee86a756477 100644
+--- a/src/main/java/org/bukkit/inventory/AnvilInventory.java
++++ b/src/main/java/org/bukkit/inventory/AnvilInventory.java
+@@ -49,4 +49,64 @@ public interface AnvilInventory extends Inventory {
+      * @param levels the maximum experience cost
+      */
+     void setMaximumRepairCost(int levels);
++
++    // Paper start
++    /**
++     * Gets the item in the left input slot.
++     *
++     * @return item in the first slot
++     */
++    @Nullable
++    default ItemStack getFirstItem() {
++        return getItem(0);
++    }
++
++    /**
++     * Sets the item in the left input slot.
++     *
++     * @param firstItem item to set
++     */
++    default void setFirstItem(@Nullable ItemStack firstItem) {
++        setItem(0, firstItem);
++    }
++
++    /**
++     * Gets the item in the right input slot.
++     *
++     * @return item in the second slot
++     */
++    @Nullable
++    default ItemStack getSecondItem() {
++        return getItem(1);
++    }
++
++    /**
++     * Sets the item in the right input slot.
++     *
++     * @param secondItem item to set
++     */
++    default void setSecondItem(@Nullable ItemStack secondItem) {
++        setItem(1, secondItem);
++    }
++
++    /**
++     * Gets the item in the result slot.
++     *
++     * @return item in the result slot
++     */
++    @Nullable
++    default ItemStack getResult() {
++        return getItem(2);
++    }
++
++    /**
++     * Sets the item in the result slot.
++     * Note that the client might not be able to take out the item if it does not match the input items.
++     *
++     * @param result item to set
++     */
++    default void setResult(@Nullable ItemStack result) {
++        setItem(2, result);
++    }
++    // Paper end
+ }
+diff --git a/src/main/java/org/bukkit/inventory/GrindstoneInventory.java b/src/main/java/org/bukkit/inventory/GrindstoneInventory.java
+index 9048892c8768c6b4d6cea03da73339f13bfbe82e..1c750108f55a0a31ad23433b333e0ea486a63ff2 100644
+--- a/src/main/java/org/bukkit/inventory/GrindstoneInventory.java
++++ b/src/main/java/org/bukkit/inventory/GrindstoneInventory.java
+@@ -1,6 +1,68 @@
+ package org.bukkit.inventory;
+ 
++import org.jetbrains.annotations.Nullable; // Paper
++
+ /**
+  * Interface to the inventory of a Grindstone.
+  */
+-public interface GrindstoneInventory extends Inventory { }
++public interface GrindstoneInventory extends Inventory {
++
++    // Paper start
++    /**
++     * Gets the upper input item.
++     *
++     * @return upper input item
++     */
++    @Nullable
++    default ItemStack getUpperItem() {
++        return getItem(0);
++    }
++
++    /**
++     * Sets the upper input item.
++     *
++     * @param upperItem item to set
++     */
++    default void setUpperItem(@Nullable ItemStack upperItem) {
++        setItem(0, upperItem);
++    }
++
++    /**
++     * Gets the lower input item.
++     *
++     * @return lower input item
++     */
++    @Nullable
++    default ItemStack getLowerItem() {
++        return getItem(1);
++    }
++
++    /**
++     * Sets the lower input item.
++     *
++     * @param lowerItem item to set
++     */
++    default void setLowerItem(@Nullable ItemStack lowerItem) {
++        setItem(1, lowerItem);
++    }
++
++    /**
++     * Gets the result.
++     *
++     * @return result
++     */
++    @Nullable
++    default ItemStack getResult() {
++        return getItem(2);
++    }
++
++    /**
++     * Sets the result.
++     *
++     * @param result item to set
++     */
++    default void setResult(@Nullable ItemStack result) {
++        setItem(2, result);
++    }
++    // Paper end
++}
+diff --git a/src/main/java/org/bukkit/inventory/LecternInventory.java b/src/main/java/org/bukkit/inventory/LecternInventory.java
+index 4a0c43acc2714e095973eb78536041bb1a179ddc..acf2244f77133df53eb5f862c8e713c85192f13d 100644
+--- a/src/main/java/org/bukkit/inventory/LecternInventory.java
++++ b/src/main/java/org/bukkit/inventory/LecternInventory.java
+@@ -11,4 +11,25 @@ public interface LecternInventory extends Inventory {
+     @Nullable
+     @Override
+     public Lectern getHolder();
++
++    // Paper start
++    /**
++     * Gets the lectern's held book.
++     *
++     * @return book set in the lectern
++     */
++    @Nullable
++    default ItemStack getBook() {
++        return getItem(0);
++    }
++
++    /**
++     * Sets the lectern's held book.
++     *
++     * @param book the new book
++     */
++    default void setBook(@Nullable ItemStack book) {
++        setItem(0, book);
++    }
++    // Paper end
+ }
+diff --git a/src/main/java/org/bukkit/inventory/SmithingInventory.java b/src/main/java/org/bukkit/inventory/SmithingInventory.java
+index 96d526b7b153e56c9a97de42ce3270b6638510e4..a41ca6bd2672db2810dd70c4925b84a4f081af05 100644
+--- a/src/main/java/org/bukkit/inventory/SmithingInventory.java
++++ b/src/main/java/org/bukkit/inventory/SmithingInventory.java
+@@ -30,4 +30,44 @@ public interface SmithingInventory extends Inventory {
+      */
+     @Nullable
+     Recipe getRecipe();
++
++    // Paper start
++    /**
++     * Gets the input equipment (first slot).
++     *
++     * @return input equipment item
++     */
++    @Nullable
++    default ItemStack getInputEquipment() {
++        return getItem(0);
++    }
++
++    /**
++     * Sets the input equipment (first slot).
++     *
++     * @param itemStack item to set
++     */
++    default void setInputEquipment(@Nullable ItemStack itemStack) {
++        setItem(0, itemStack);
++    }
++
++    /**
++     * Gets the input mineral (second slot).
++     *
++     * @return input mineral item
++     */
++    @Nullable
++    default ItemStack getInputMineral() {
++        return getItem(1);
++    }
++
++    /**
++     * Sets the input mineral (second slot).
++     *
++     * @param itemStack item to set
++     */
++    default void setInputMineral(@Nullable ItemStack itemStack) {
++        setItem(1, itemStack);
++    }
++    // Paper end
+ }
+diff --git a/src/main/java/org/bukkit/inventory/StonecutterInventory.java b/src/main/java/org/bukkit/inventory/StonecutterInventory.java
+index dbb034fae3b8bfaf40e6341460e274c21e321a3b..e7a8e7188bf8b9840de56dc80c2b79d64a9389cb 100644
+--- a/src/main/java/org/bukkit/inventory/StonecutterInventory.java
++++ b/src/main/java/org/bukkit/inventory/StonecutterInventory.java
+@@ -1,6 +1,49 @@
+ package org.bukkit.inventory;
+ 
++import org.jetbrains.annotations.Nullable; // Paper
++
+ /**
+  * Interface to the inventory of a Stonecutter.
+  */
+-public interface StonecutterInventory extends Inventory { }
++public interface StonecutterInventory extends Inventory {
++
++    // Paper start
++    /**
++     * Gets the input item.
++     *
++     * @return input item
++     */
++    @Nullable
++    default ItemStack getInputItem() {
++        return getItem(0);
++    }
++
++    /**
++     * Sets the input item.
++     *
++     * @param itemStack item to set
++     */
++    default void setInputItem(@Nullable ItemStack itemStack) {
++        setItem(0, itemStack);
++    }
++
++    /**
++     * Gets the result item.
++     *
++     * @return result
++     */
++    @Nullable
++    default ItemStack getResult() {
++        return getItem(1);
++    }
++
++    /**
++     * Sets the result item.
++     *
++     * @param itemStack item to set
++     */
++    default void setResult(@Nullable ItemStack itemStack) {
++        setItem(1, itemStack);
++    }
++    // Paper end
++}

patches/api/0201-Add-Mob-Goal-API.patch

@@ -0,0 +1,481 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MiniDigger <admin@minidigger.me>
+Date: Fri, 3 Jan 2020 16:24:46 +0100
+Subject: [PATCH] Add Mob Goal API
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/entity/ai/Goal.java b/src/main/java/com/destroystokyo/paper/entity/ai/Goal.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..c57c5416c88e2070a082403ab0dda9d7f08d2a57
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/entity/ai/Goal.java
+@@ -0,0 +1,66 @@
++package com.destroystokyo.paper.entity.ai;
++
++import org.jetbrains.annotations.NotNull;
++
++import java.util.EnumSet;
++
++import org.bukkit.entity.Mob;
++
++/**
++ * Represents an AI goal of an entity
++ */
++public interface Goal<T extends Mob> {
++
++    /**
++     * Checks if this goal should be activated
++     *
++     * @return if this goal should be activated
++     */
++    boolean shouldActivate();
++
++    /**
++     * Checks if this goal should stay active, defaults to {@link Goal#shouldActivate()}
++     *
++     * @return if this goal should stay active
++     */
++    default boolean shouldStayActive() {
++        return shouldActivate();
++    }
++
++    /**
++     * Called when this goal gets activated
++     */
++    default void start() {
++    }
++
++    /**
++     * Called when this goal gets stopped
++     */
++    default void stop() {
++    }
++
++    /**
++     * Called each tick the goal is activated
++     */
++    default void tick() {
++    }
++
++    /**
++     * A unique key that identifies this type of goal. Plugins should use their own namespace, not the minecraft
++     * namespace. Additionally, this key also specifies to what mobs this goal can be applied to
++     *
++     * @return the goal key
++     */
++    @NotNull
++    GoalKey<T> getKey();
++
++    /**
++     * Returns a list of all applicable flags for this goal.<br>
++     *
++     * This method is only called on construction.
++     *
++     * @return the subtypes.
++     */
++    @NotNull
++    EnumSet<GoalType> getTypes();
++}
+diff --git a/src/main/java/com/destroystokyo/paper/entity/ai/GoalKey.java b/src/main/java/com/destroystokyo/paper/entity/ai/GoalKey.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..9cd98c6fcfa3eb439d9013ef76ef4661175a0e5a
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/entity/ai/GoalKey.java
+@@ -0,0 +1,64 @@
++package com.destroystokyo.paper.entity.ai;
++
++import com.google.common.base.Objects;
++
++import org.jetbrains.annotations.NotNull;
++
++import java.util.StringJoiner;
++
++import org.bukkit.NamespacedKey;
++import org.bukkit.entity.Mob;
++
++/**
++ *
++ * Used to identify a Goal. Consists of a {@link NamespacedKey} and the type of mob the goal can be applied to
++ *
++ * @param <T> the type of mob the goal can be applied to
++ */
++public class GoalKey<T extends Mob> {
++
++    private final Class<T> entityClass;
++    private final NamespacedKey namespacedKey;
++
++    private GoalKey(@NotNull Class<T> entityClass, @NotNull NamespacedKey namespacedKey) {
++        this.entityClass = entityClass;
++        this.namespacedKey = namespacedKey;
++    }
++
++    @NotNull
++    public Class<T> getEntityClass() {
++        return entityClass;
++    }
++
++    @NotNull
++    public NamespacedKey getNamespacedKey() {
++        return namespacedKey;
++    }
++
++    @Override
++    public boolean equals(Object o) {
++        if (this == o) return true;
++        if (o == null || getClass() != o.getClass()) return false;
++        GoalKey<?> goalKey = (GoalKey<?>) o;
++        return Objects.equal(entityClass, goalKey.entityClass) &&
++               Objects.equal(namespacedKey, goalKey.namespacedKey);
++    }
++
++    @Override
++    public int hashCode() {
++        return Objects.hashCode(entityClass, namespacedKey);
++    }
++
++    @Override
++    public String toString() {
++        return new StringJoiner(", ", GoalKey.class.getSimpleName() + "[", "]")
++            .add("entityClass=" + entityClass)
++            .add("namespacedKey=" + namespacedKey)
++            .toString();
++    }
++
++    @NotNull
++    public static <A extends Mob> GoalKey<A> of(@NotNull Class<A> entityClass, @NotNull NamespacedKey namespacedKey) {
++        return new GoalKey<>(entityClass, namespacedKey);
++    }
++}
+diff --git a/src/main/java/com/destroystokyo/paper/entity/ai/GoalType.java b/src/main/java/com/destroystokyo/paper/entity/ai/GoalType.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..7024c8f484d2460abf3abfe65a29771d814105ec
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/entity/ai/GoalType.java
+@@ -0,0 +1,17 @@
++package com.destroystokyo.paper.entity.ai;
++
++/**
++ * Represents the subtype of a goal. Used by minecraft to disable certain types of goals if needed.
++ */
++public enum GoalType {
++
++    MOVE,
++    LOOK,
++    JUMP,
++    TARGET,
++    /**
++     * Used to map vanilla goals, that are a behavior goal but don't have a type set...
++     */
++    UNKNOWN_BEHAVIOR,
++
++}
+diff --git a/src/main/java/com/destroystokyo/paper/entity/ai/MobGoals.java b/src/main/java/com/destroystokyo/paper/entity/ai/MobGoals.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..e21f7574763dd4f13794f91bbef192ef66a8f5e9
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/entity/ai/MobGoals.java
+@@ -0,0 +1,50 @@
++package com.destroystokyo.paper.entity.ai;
++
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++import java.util.Collection;
++
++import org.bukkit.entity.Mob;
++
++/**
++ * Represents a part of the "brain" of a mob. It tracks all tasks (running or not), allows adding and removing goals
++ */
++public interface MobGoals {
++
++    <T extends Mob> void addGoal(@NotNull T mob, int priority, @NotNull Goal<T> goal);
++
++    <T extends Mob> void removeGoal(@NotNull T mob, @NotNull Goal<T> goal);
++
++    <T extends Mob> void removeAllGoals(@NotNull T mob);
++
++    <T extends Mob> void removeAllGoals(@NotNull T mob, @NotNull GoalType type);
++
++    <T extends Mob> void removeGoal(@NotNull T mob, @NotNull GoalKey<T> key);
++
++    <T extends Mob> boolean hasGoal(@NotNull T mob, @NotNull GoalKey<T> key);
++
++    @Nullable
++    <T extends Mob> Goal<T> getGoal(@NotNull T mob, @NotNull GoalKey<T> key);
++
++    @NotNull
++    <T extends Mob> Collection<Goal<T>> getGoals(@NotNull T mob, @NotNull GoalKey<T> key);
++
++    @NotNull
++    <T extends Mob> Collection<Goal<T>> getAllGoals(@NotNull T mob);
++
++    @NotNull
++    <T extends Mob> Collection<Goal<T>> getAllGoals(@NotNull T mob, @NotNull GoalType type);
++
++    @NotNull
++    <T extends Mob> Collection<Goal<T>> getAllGoalsWithout(@NotNull T mob, @NotNull GoalType type);
++
++    @NotNull
++    <T extends Mob> Collection<Goal<T>> getRunningGoals(@NotNull T mob);
++
++    @NotNull
++    <T extends Mob> Collection<Goal<T>> getRunningGoals(@NotNull T mob, @NotNull GoalType type);
++
++    @NotNull
++    <T extends Mob> Collection<Goal<T>> getRunningGoalsWithout(@NotNull T mob, @NotNull GoalType type);
++}
+diff --git a/src/main/java/com/destroystokyo/paper/entity/ai/VanillaGoal.java b/src/main/java/com/destroystokyo/paper/entity/ai/VanillaGoal.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..b42091752981a1f309ab350e9a394092cb334824
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/entity/ai/VanillaGoal.java
+@@ -0,0 +1,209 @@
++package com.destroystokyo.paper.entity.ai;
++
++import com.destroystokyo.paper.entity.RangedEntity;
++
++import org.bukkit.NamespacedKey;
++import org.bukkit.entity.*;
++
++/**
++ * Represents a vanilla goal. Plugins should never implement this.<br>
++ * Generated by VanillaPathfinderTest in paper-server
++ */
++public interface VanillaGoal<T extends Mob> extends Goal<T> {
++
++    GoalKey<Bee> BEE_ATTACK = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_attack"));
++    GoalKey<Bee> BEE_BECOME_ANGRY = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_become_angry"));
++    GoalKey<Bee> BEE_ENTER_HIVE = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_enter_hive"));
++    GoalKey<Bee> BEE_GO_TO_HIVE = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_go_to_hive"));
++    GoalKey<Bee> BEE_GO_TO_KNOWN_FLOWER = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_go_to_known_flower"));
++    GoalKey<Bee> BEE_GROW_CROP = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_grow_crop"));
++    GoalKey<Bee> BEE_HURT_BY_OTHER = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_hurt_by_other"));
++    GoalKey<Bee> BEE_LOCATE_HIVE = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_locate_hive"));
++    GoalKey<Bee> BEE_POLLINATE = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_pollinate"));
++    GoalKey<Bee> BEE_WANDER = GoalKey.of(Bee.class, NamespacedKey.minecraft("bee_wander"));
++    GoalKey<Blaze> BLAZE_FIREBALL = GoalKey.of(Blaze.class, NamespacedKey.minecraft("blaze_fireball"));
++    GoalKey<Cat> TEMPT_CHANCE = GoalKey.of(Cat.class, NamespacedKey.minecraft("tempt_chance"));
++    GoalKey<Cat> CAT_AVOID_ENTITY = GoalKey.of(Cat.class, NamespacedKey.minecraft("cat_avoid_entity"));
++    GoalKey<Cat> CAT_RELAX_ON_OWNER = GoalKey.of(Cat.class, NamespacedKey.minecraft("cat_relax_on_owner"));
++    GoalKey<Dolphin> DOLPHIN_SWIM_TO_TREASURE = GoalKey.of(Dolphin.class, NamespacedKey.minecraft("dolphin_swim_to_treasure"));
++    GoalKey<Dolphin> DOLPHIN_SWIM_WITH_PLAYER = GoalKey.of(Dolphin.class, NamespacedKey.minecraft("dolphin_swim_with_player"));
++    GoalKey<Dolphin> DOLPHIN_PLAY_WITH_ITEMS = GoalKey.of(Dolphin.class, NamespacedKey.minecraft("dolphin_play_with_items"));
++    GoalKey<Drowned> DROWNED_ATTACK = GoalKey.of(Drowned.class, NamespacedKey.minecraft("drowned_attack"));
++    GoalKey<Drowned> DROWNED_GOTO_BEACH = GoalKey.of(Drowned.class, NamespacedKey.minecraft("drowned_goto_beach"));
++    GoalKey<Creature> DROWNED_GOTO_WATER = GoalKey.of(Creature.class, NamespacedKey.minecraft("drowned_goto_water"));
++    GoalKey<Drowned> DROWNED_SWIM_UP = GoalKey.of(Drowned.class, NamespacedKey.minecraft("drowned_swim_up"));
++    GoalKey<RangedEntity> DROWNED_TRIDENT_ATTACK = GoalKey.of(RangedEntity.class, NamespacedKey.minecraft("drowned_trident_attack"));
++    GoalKey<Enderman> ENDERMAN_PICKUP_BLOCK = GoalKey.of(Enderman.class, NamespacedKey.minecraft("enderman_pickup_block"));
++    GoalKey<Enderman> ENDERMAN_PLACE_BLOCK = GoalKey.of(Enderman.class, NamespacedKey.minecraft("enderman_place_block"));
++    GoalKey<Enderman> PLAYER_WHO_LOOKED_AT_TARGET = GoalKey.of(Enderman.class, NamespacedKey.minecraft("player_who_looked_at_target"));
++    GoalKey<Enderman> ENDERMAN_FREEZE_WHEN_LOOKED_AT = GoalKey.of(Enderman.class, NamespacedKey.minecraft("enderman_freeze_when_looked_at"));
++    GoalKey<Evoker> EVOKER_ATTACK_SPELL = GoalKey.of(Evoker.class, NamespacedKey.minecraft("evoker_attack_spell"));
++    GoalKey<Evoker> EVOKER_CAST_SPELL = GoalKey.of(Evoker.class, NamespacedKey.minecraft("evoker_cast_spell"));
++    GoalKey<Evoker> EVOKER_SUMMON_SPELL = GoalKey.of(Evoker.class, NamespacedKey.minecraft("evoker_summon_spell"));
++    GoalKey<Evoker> EVOKER_WOLOLO_SPELL = GoalKey.of(Evoker.class, NamespacedKey.minecraft("evoker_wololo_spell"));
++    GoalKey<Fish> FISH_SWIM = GoalKey.of(Fish.class, NamespacedKey.minecraft("fish_swim"));
++    GoalKey<Fox> FOX_DEFEND_TRUSTED = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_defend_trusted"));
++    GoalKey<Fox> FOX_FACEPLANT = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_faceplant"));
++    GoalKey<Fox> FOX_BREED = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_breed"));
++    GoalKey<Fox> FOX_EAT_BERRIES = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_eat_berries"));
++    GoalKey<Fox> FOX_FLOAT = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_float"));
++    GoalKey<Fox> FOX_FOLLOW_PARENT = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_follow_parent"));
++    GoalKey<Fox> FOX_LOOK_AT_PLAYER = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_look_at_player"));
++    GoalKey<Fox> FOX_MELEE_ATTACK = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_melee_attack"));
++    GoalKey<Fox> FOX_PANIC = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_panic"));
++    GoalKey<Fox> FOX_PERCH_AND_SEARCH = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_perch_and_search"));
++    GoalKey<Fox> FOX_POUNCE = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_pounce"));
++    GoalKey<Fox> FOX_SEARCH_FOR_ITEMS = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_search_for_items"));
++    GoalKey<Fox> FOX_SLEEP = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_sleep"));
++    GoalKey<Fox> FOX_STROLL_THROUGH_VILLAGE = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_stroll_through_village"));
++    GoalKey<Fox> FOX_SEEK_SHELTER = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_seek_shelter"));
++    GoalKey<Fox> FOX_STALK_PREY = GoalKey.of(Fox.class, NamespacedKey.minecraft("fox_stalk_prey"));
++    GoalKey<Ghast> GHAST_ATTACK_TARGET = GoalKey.of(Ghast.class, NamespacedKey.minecraft("ghast_attack_target"));
++    GoalKey<Ghast> GHAST_IDLE_MOVE = GoalKey.of(Ghast.class, NamespacedKey.minecraft("ghast_idle_move"));
++    GoalKey<Ghast> GHAST_MOVE_TOWARDS_TARGET = GoalKey.of(Ghast.class, NamespacedKey.minecraft("ghast_move_towards_target"));
++    GoalKey<Guardian> GUARDIAN_ATTACK = GoalKey.of(Guardian.class, NamespacedKey.minecraft("guardian_attack"));
++    GoalKey<Illager> RAIDER_OPEN_DOOR = GoalKey.of(Illager.class, NamespacedKey.minecraft("raider_open_door"));
++    GoalKey<Illusioner> ILLUSIONER_BLINDNESS_SPELL = GoalKey.of(Illusioner.class, NamespacedKey.minecraft("illusioner_blindness_spell"));
++    GoalKey<Illusioner> ILLUSIONER_MIRROR_SPELL = GoalKey.of(Illusioner.class, NamespacedKey.minecraft("illusioner_mirror_spell"));
++    GoalKey<Spellcaster> SPELLCASTER_CAST_SPELL = GoalKey.of(Spellcaster.class, NamespacedKey.minecraft("spellcaster_cast_spell"));
++    GoalKey<Llama> LLAMA_ATTACK_WOLF = GoalKey.of(Llama.class, NamespacedKey.minecraft("llama_attack_wolf"));
++    GoalKey<Llama> LLAMA_HURT_BY = GoalKey.of(Llama.class, NamespacedKey.minecraft("llama_hurt_by"));
++    GoalKey<TraderLlama> LLAMATRADER_DEFENDED_WANDERING_TRADER = GoalKey.of(TraderLlama.class, NamespacedKey.minecraft("llamatrader_defended_wandering_trader"));
++    GoalKey<Monster> LONG_DISTANCE_PATROL = GoalKey.of(Monster.class, NamespacedKey.minecraft("long_distance_patrol"));
++    GoalKey<Ocelot> OCELOT_AVOID_ENTITY = GoalKey.of(Ocelot.class, NamespacedKey.minecraft("ocelot_avoid_entity"));
++    GoalKey<Ocelot> OCELOT_TEMPT = GoalKey.of(Ocelot.class, NamespacedKey.minecraft("ocelot_tempt"));
++    GoalKey<Panda> PANDA_ATTACK = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_attack"));
++    GoalKey<Panda> PANDA_AVOID = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_avoid"));
++    GoalKey<Panda> PANDA_BREED = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_breed"));
++    GoalKey<Panda> PANDA_HURT_BY_TARGET = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_hurt_by_target"));
++    GoalKey<Panda> PANDA_LIE_ON_BACK = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_lie_on_back"));
++    GoalKey<Panda> PANDA_LOOK_AT_PLAYER = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_look_at_player"));
++    GoalKey<Panda> PANDA_PANIC = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_panic"));
++    GoalKey<Panda> PANDA_ROLL = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_roll"));
++    GoalKey<Panda> PANDA_SIT = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_sit"));
++    GoalKey<Panda> PANDA_SNEEZE = GoalKey.of(Panda.class, NamespacedKey.minecraft("panda_sneeze"));
++    GoalKey<Phantom> PHANTOM_ATTACK_PLAYER = GoalKey.of(Phantom.class, NamespacedKey.minecraft("phantom_attack_player"));
++    GoalKey<Phantom> PHANTOM_ATTACK_STRATEGY = GoalKey.of(Phantom.class, NamespacedKey.minecraft("phantom_attack_strategy"));
++    GoalKey<Phantom> PHANTOM_CIRCLE_AROUND_ANCHOR = GoalKey.of(Phantom.class, NamespacedKey.minecraft("phantom_circle_around_anchor"));
++    GoalKey<Phantom> PHANTOM_SWEEP_ATTACK = GoalKey.of(Phantom.class, NamespacedKey.minecraft("phantom_sweep_attack"));
++    /**
++     * @deprecated removed in 1.16
++     */
++    @Deprecated
++    GoalKey<PigZombie> ANGER = GoalKey.of(PigZombie.class, NamespacedKey.minecraft("anger"));
++    /**
++     * @deprecated removed in 1.16
++     */
++    @Deprecated
++    GoalKey<PigZombie> ANGER_OTHER = GoalKey.of(PigZombie.class, NamespacedKey.minecraft("anger_other"));
++    GoalKey<PolarBear> POLARBEAR_ATTACK_PLAYERS = GoalKey.of(PolarBear.class, NamespacedKey.minecraft("polarbear_attack_players"));
++    GoalKey<PolarBear> POLARBEAR_HURT_BY = GoalKey.of(PolarBear.class, NamespacedKey.minecraft("polarbear_hurt_by"));
++    GoalKey<PolarBear> POLARBEAR_MELEE = GoalKey.of(PolarBear.class, NamespacedKey.minecraft("polarbear_melee"));
++    GoalKey<PolarBear> POLARBEAR_PANIC = GoalKey.of(PolarBear.class, NamespacedKey.minecraft("polarbear_panic"));
++    GoalKey<PufferFish> PUFFERFISH_PUFF = GoalKey.of(PufferFish.class, NamespacedKey.minecraft("pufferfish_puff"));
++    GoalKey<Rabbit> EAT_CARROTS = GoalKey.of(Rabbit.class, NamespacedKey.minecraft("eat_carrots"));
++    GoalKey<Rabbit> KILLER_RABBIT_MELEE_ATTACK = GoalKey.of(Rabbit.class, NamespacedKey.minecraft("killer_rabbit_melee_attack"));
++    GoalKey<Rabbit> RABBIT_AVOID_TARGET = GoalKey.of(Rabbit.class, NamespacedKey.minecraft("rabbit_avoid_target"));
++    GoalKey<Rabbit> RABBIT_PANIC = GoalKey.of(Rabbit.class, NamespacedKey.minecraft("rabbit_panic"));
++    GoalKey<Raider> RAIDER_HOLD_GROUND = GoalKey.of(Raider.class, NamespacedKey.minecraft("raider_hold_ground"));
++    GoalKey<Raider> RAIDER_OBTAIN_BANNER = GoalKey.of(Raider.class, NamespacedKey.minecraft("raider_obtain_banner"));
++    GoalKey<Raider> RAIDER_CELEBRATION = GoalKey.of(Raider.class, NamespacedKey.minecraft("raider_celebration"));
++    GoalKey<Raider> RAIDER_MOVE_THROUGH_VILLAGE = GoalKey.of(Raider.class, NamespacedKey.minecraft("raider_move_through_village"));
++    GoalKey<Ravager> RAVAGER_MELEE_ATTACK = GoalKey.of(Ravager.class, NamespacedKey.minecraft("ravager_melee_attack"));
++    GoalKey<Shulker> SHULKER_ATTACK = GoalKey.of(Shulker.class, NamespacedKey.minecraft("shulker_attack"));
++    GoalKey<Shulker> SHULKER_DEFENSE = GoalKey.of(Shulker.class, NamespacedKey.minecraft("shulker_defense"));
++    GoalKey<Shulker> SHULKER_NEAREST = GoalKey.of(Shulker.class, NamespacedKey.minecraft("shulker_nearest"));
++    GoalKey<Shulker> SHULKER_PEEK = GoalKey.of(Shulker.class, NamespacedKey.minecraft("shulker_peek"));
++    GoalKey<Silverfish> SILVERFISH_HIDE_IN_BLOCK = GoalKey.of(Silverfish.class, NamespacedKey.minecraft("silverfish_hide_in_block"));
++    GoalKey<Silverfish> SILVERFISH_WAKE_OTHERS = GoalKey.of(Silverfish.class, NamespacedKey.minecraft("silverfish_wake_others"));
++    GoalKey<Skeleton> SKELETON_MELEE = GoalKey.of(Skeleton.class, NamespacedKey.minecraft("skeleton_melee"));
++    GoalKey<Slime> SLIME_IDLE = GoalKey.of(Slime.class, NamespacedKey.minecraft("slime_idle"));
++    GoalKey<Slime> SLIME_NEAREST_PLAYER = GoalKey.of(Slime.class, NamespacedKey.minecraft("slime_nearest_player"));
++    GoalKey<Slime> SLIME_RANDOM_DIRECTION = GoalKey.of(Slime.class, NamespacedKey.minecraft("slime_random_direction"));
++    GoalKey<Slime> SLIME_RANDOM_JUMP = GoalKey.of(Slime.class, NamespacedKey.minecraft("slime_random_jump"));
++    GoalKey<Spider> SPIDER_MELEE_ATTACK = GoalKey.of(Spider.class, NamespacedKey.minecraft("spider_melee_attack"));
++    GoalKey<Spider> SPIDER_NEAREST_ATTACKABLE_TARGET = GoalKey.of(Spider.class, NamespacedKey.minecraft("spider_nearest_attackable_target"));
++    GoalKey<Strider> STRIDER_GO_TO_LAVA = GoalKey.of(Strider.class, NamespacedKey.minecraft("strider_go_to_lava"));
++    GoalKey<Squid> SQUID = GoalKey.of(Squid.class, NamespacedKey.minecraft("squid"));
++    GoalKey<Squid> SQUID_FLEE = GoalKey.of(Squid.class, NamespacedKey.minecraft("squid_flee"));
++    GoalKey<Turtle> TURTLE_BREED = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_breed"));
++    GoalKey<Turtle> TURTLE_GO_HOME = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_go_home"));
++    GoalKey<Turtle> TURTLE_GOTO_WATER = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_goto_water"));
++    GoalKey<Turtle> TURTLE_LAY_EGG = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_lay_egg"));
++    GoalKey<Turtle> TURTLE_PANIC = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_panic"));
++    GoalKey<Turtle> TURTLE_RANDOM_STROLL = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_random_stroll"));
++    GoalKey<Turtle> TURTLE_TEMPT = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_tempt"));
++    GoalKey<Turtle> TURTLE_TRAVEL = GoalKey.of(Turtle.class, NamespacedKey.minecraft("turtle_travel"));
++    GoalKey<Vex> VEX_CHARGE_ATTACK = GoalKey.of(Vex.class, NamespacedKey.minecraft("vex_charge_attack"));
++    GoalKey<Vex> VEX_COPY_TARGET_OF_OWNER = GoalKey.of(Vex.class, NamespacedKey.minecraft("vex_copy_target_of_owner"));
++    GoalKey<Vex> VEX_RANDOM_MOVE = GoalKey.of(Vex.class, NamespacedKey.minecraft("vex_random_move"));
++    GoalKey<WanderingTrader> VILLAGERTRADER_WANDER_TO_POSITION = GoalKey.of(WanderingTrader.class, NamespacedKey.minecraft("villagertrader_wander_to_position"));
++    GoalKey<Mob> VINDICATOR_BREAK_DOOR = GoalKey.of(Mob.class, NamespacedKey.minecraft("vindicator_break_door"));
++    GoalKey<Vindicator> VINDICATOR_JOHNNY_ATTACK = GoalKey.of(Vindicator.class, NamespacedKey.minecraft("vindicator_johnny_attack"));
++    GoalKey<Vindicator> VINDICATOR_MELEE_ATTACK = GoalKey.of(Vindicator.class, NamespacedKey.minecraft("vindicator_melee_attack"));
++    GoalKey<Wither> WITHER_DO_NOTHING = GoalKey.of(Wither.class, NamespacedKey.minecraft("wither_do_nothing"));
++    GoalKey<Wolf> WOLF_AVOID_ENTITY = GoalKey.of(Wolf.class, NamespacedKey.minecraft("wolf_avoid_entity"));
++    GoalKey<Zombie> ZOMBIE_ATTACK_TURTLE_EGG = GoalKey.of(Zombie.class, NamespacedKey.minecraft("zombie_attack_turtle_egg"));
++    GoalKey<RangedEntity> ARROW_ATTACK = GoalKey.of(RangedEntity.class, NamespacedKey.minecraft("arrow_attack"));
++    GoalKey<Creature> AVOID_TARGET = GoalKey.of(Creature.class, NamespacedKey.minecraft("avoid_target"));
++    GoalKey<Wolf> BEG = GoalKey.of(Wolf.class, NamespacedKey.minecraft("beg"));
++    GoalKey<Monster> BOW_SHOOT = GoalKey.of(Monster.class, NamespacedKey.minecraft("bow_shoot"));
++    GoalKey<Mob> BREAK_DOOR = GoalKey.of(Mob.class, NamespacedKey.minecraft("break_door"));
++    GoalKey<Creature> BREATH = GoalKey.of(Creature.class, NamespacedKey.minecraft("breath"));
++    GoalKey<Animals> BREED = GoalKey.of(Animals.class, NamespacedKey.minecraft("breed"));
++    GoalKey<Cat> CAT_SIT_ON_BED = GoalKey.of(Cat.class, NamespacedKey.minecraft("cat_sit_on_bed"));
++    GoalKey<Monster> CROSSBOW_ATTACK = GoalKey.of(Monster.class, NamespacedKey.minecraft("crossbow_attack"));
++    GoalKey<IronGolem> DEFEND_VILLAGE = GoalKey.of(IronGolem.class, NamespacedKey.minecraft("defend_village"));
++    GoalKey<Mob> DOOR_OPEN = GoalKey.of(Mob.class, NamespacedKey.minecraft("door_open"));
++    GoalKey<Mob> EAT_TILE = GoalKey.of(Mob.class, NamespacedKey.minecraft("eat_tile"));
++    GoalKey<Fish> FISH_SCHOOL = GoalKey.of(Fish.class, NamespacedKey.minecraft("fish_school"));
++    GoalKey<Creature> FLEE_SUN = GoalKey.of(Creature.class, NamespacedKey.minecraft("flee_sun"));
++    GoalKey<Mob> FLOAT = GoalKey.of(Mob.class, NamespacedKey.minecraft("float"));
++    GoalKey<Creature> FOLLOW_BOAT = GoalKey.of(Creature.class, NamespacedKey.minecraft("follow_boat"));
++    GoalKey<Mob> FOLLOW_ENTITY = GoalKey.of(Mob.class, NamespacedKey.minecraft("follow_entity"));
++    GoalKey<Tameable> FOLLOW_OWNER = GoalKey.of(Tameable.class, NamespacedKey.minecraft("follow_owner"));
++    GoalKey<Animals> FOLLOW_PARENT = GoalKey.of(Animals.class, NamespacedKey.minecraft("follow_parent"));
++    GoalKey<SkeletonHorse> HORSE_TRAP = GoalKey.of(SkeletonHorse.class, NamespacedKey.minecraft("horse_trap"));
++    GoalKey<Creature> HURT_BY_TARGET = GoalKey.of(Creature.class, NamespacedKey.minecraft("hurt_by_target"));
++    GoalKey<Mob> INTERACT = GoalKey.of(Mob.class, NamespacedKey.minecraft("interact"));
++    GoalKey<Cat> JUMP_ON_BLOCK = GoalKey.of(Cat.class, NamespacedKey.minecraft("jump_on_block"));
++    GoalKey<Mob> LEAP_AT_TARGET = GoalKey.of(Mob.class, NamespacedKey.minecraft("leap_at_target"));
++    GoalKey<Llama> LLAMA_FOLLOW = GoalKey.of(Llama.class, NamespacedKey.minecraft("llama_follow"));
++    GoalKey<Mob> LOOK_AT_PLAYER = GoalKey.of(Mob.class, NamespacedKey.minecraft("look_at_player"));
++    GoalKey<AbstractVillager> LOOK_AT_TRADING_PLAYER = GoalKey.of(AbstractVillager.class, NamespacedKey.minecraft("look_at_trading_player"));
++    GoalKey<Creature> MELEE_ATTACK = GoalKey.of(Creature.class, NamespacedKey.minecraft("melee_attack"));
++    GoalKey<Creature> MOVE_THROUGH_VILLAGE = GoalKey.of(Creature.class, NamespacedKey.minecraft("move_through_village"));
++    GoalKey<Creature> MOVE_TOWARDS_RESTRICTION = GoalKey.of(Creature.class, NamespacedKey.minecraft("move_towards_restriction"));
++    GoalKey<Creature> MOVE_TOWARDS_TARGET = GoalKey.of(Creature.class, NamespacedKey.minecraft("move_towards_target"));
++    GoalKey<Mob> NEAREST_ATTACKABLE_TARGET = GoalKey.of(Mob.class, NamespacedKey.minecraft("nearest_attackable_target"));
++    GoalKey<Raider> NEAREST_ATTACKABLE_TARGET_WITCH = GoalKey.of(Raider.class, NamespacedKey.minecraft("nearest_attackable_target_witch"));
++    GoalKey<Raider> NEAREST_HEALABLE_RAIDER = GoalKey.of(Raider.class, NamespacedKey.minecraft("nearest_healable_raider"));
++    GoalKey<Creature> NEAREST_VILLAGE = GoalKey.of(Creature.class, NamespacedKey.minecraft("nearest_village"));
++    GoalKey<Mob> OCELOT_ATTACK = GoalKey.of(Mob.class, NamespacedKey.minecraft("ocelot_attack"));
++    GoalKey<IronGolem> OFFER_FLOWER = GoalKey.of(IronGolem.class, NamespacedKey.minecraft("offer_flower"));
++    GoalKey<Tameable> OWNER_HURT_BY_TARGET = GoalKey.of(Tameable.class, NamespacedKey.minecraft("owner_hurt_by_target"));
++    GoalKey<Tameable> OWNER_HURT_TARGET = GoalKey.of(Tameable.class, NamespacedKey.minecraft("owner_hurt_target"));
++    GoalKey<Creature> PANIC = GoalKey.of(Creature.class, NamespacedKey.minecraft("panic"));
++    GoalKey<Parrot> PERCH = GoalKey.of(Parrot.class, NamespacedKey.minecraft("perch"));
++    GoalKey<Raider> RAID = GoalKey.of(Raider.class, NamespacedKey.minecraft("raid"));
++    GoalKey<Creature> RANDOM_FLY = GoalKey.of(Creature.class, NamespacedKey.minecraft("random_fly"));
++    GoalKey<Mob> RANDOM_LOOKAROUND = GoalKey.of(Mob.class, NamespacedKey.minecraft("random_lookaround"));
++    GoalKey<Creature> RANDOM_STROLL = GoalKey.of(Creature.class, NamespacedKey.minecraft("random_stroll"));
++    GoalKey<Creature> RANDOM_STROLL_LAND = GoalKey.of(Creature.class, NamespacedKey.minecraft("random_stroll_land"));
++    GoalKey<Creature> RANDOM_SWIM = GoalKey.of(Creature.class, NamespacedKey.minecraft("random_swim"));
++    GoalKey<Tameable> RANDOM_TARGET_NON_TAMED = GoalKey.of(Tameable.class, NamespacedKey.minecraft("random_target_non_tamed"));
++    GoalKey<Creature> REMOVE_BLOCK = GoalKey.of(Creature.class, NamespacedKey.minecraft("remove_block"));
++    GoalKey<Creature> RESTRICT_SUN = GoalKey.of(Creature.class, NamespacedKey.minecraft("restrict_sun"));
++    GoalKey<Tameable> SIT = GoalKey.of(Tameable.class, NamespacedKey.minecraft("sit"));
++    GoalKey<Creature> STROLL_VILLAGE = GoalKey.of(Creature.class, NamespacedKey.minecraft("stroll_village"));
++    GoalKey<Creeper> SWELL = GoalKey.of(Creeper.class, NamespacedKey.minecraft("swell"));
++    GoalKey<AbstractHorse> TAME = GoalKey.of(AbstractHorse.class, NamespacedKey.minecraft("tame"));
++    GoalKey<Creature> TEMPT = GoalKey.of(Creature.class, NamespacedKey.minecraft("tempt"));
++    GoalKey<AbstractVillager> TRADE_WITH_PLAYER = GoalKey.of(AbstractVillager.class, NamespacedKey.minecraft("trade_with_player"));
++    GoalKey<Mob> USE_ITEM = GoalKey.of(Mob.class, NamespacedKey.minecraft("use_item"));
++    GoalKey<Creature> WATER = GoalKey.of(Creature.class, NamespacedKey.minecraft("water"));
++    GoalKey<Dolphin> WATER_JUMP = GoalKey.of(Dolphin.class, NamespacedKey.minecraft("water_jump"));
++    GoalKey<Zombie> ZOMBIE_ATTACK = GoalKey.of(Zombie.class, NamespacedKey.minecraft("zombie_attack"));
++    GoalKey<Creature> STROLL_VILLAGE_GOLEM = GoalKey.of(Creature.class, NamespacedKey.minecraft("stroll_village_golem"));
++    GoalKey<Mob> UNIVERSAL_ANGER_RESET = GoalKey.of(Mob.class, NamespacedKey.minecraft("universal_anger_reset"));
++}
+diff --git a/src/main/java/org/bukkit/Bukkit.java b/src/main/java/org/bukkit/Bukkit.java
+index 847ba5143660d5c56ff8f2cae2169a51b8927757..17553703d6dcb0c7852cc35b08da05075af435f2 100644
+--- a/src/main/java/org/bukkit/Bukkit.java
++++ b/src/main/java/org/bukkit/Bukkit.java
+@@ -1867,6 +1867,16 @@ public final class Bukkit {
+     public static boolean isStopping() {
+         return server.isStopping();
+     }
++
++    /**
++     * Returns the {@link com.destroystokyo.paper.entity.ai.MobGoals} manager
++     *
++     * @return the mob goals manager
++     */
++    @NotNull
++    public static com.destroystokyo.paper.entity.ai.MobGoals getMobGoals() {
++        return server.getMobGoals();
++    }
+     // Paper end
+ 
+     @NotNull
+diff --git a/src/main/java/org/bukkit/Server.java b/src/main/java/org/bukkit/Server.java
+index e6b62ba32e089e2fd8563ec8430b72196f6680e0..0a109e9157d9a9f15f71d2fa96d31b7f8eb3fde2 100644
+--- a/src/main/java/org/bukkit/Server.java
++++ b/src/main/java/org/bukkit/Server.java
+@@ -1638,5 +1638,13 @@ public interface Server extends PluginMessageRecipient, net.kyori.adventure.audi
+      * @return true if server is in the process of being shutdown
+      */
+     boolean isStopping();
++
++    /**
++     * Returns the {@link com.destroystokyo.paper.entity.ai.MobGoals} manager
++     *
++     * @return the mob goals manager
++     */
++    @NotNull
++    com.destroystokyo.paper.entity.ai.MobGoals getMobGoals();
+     // Paper end
+ }

patches/api/0202-Expose-game-version.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Expose game version
 
 
 diff --git a/src/main/java/org/bukkit/Bukkit.java b/src/main/java/org/bukkit/Bukkit.java
-index 847ba5143660d5c56ff8f2cae2169a51b8927757..2c9d2739e78d5c422574f5ddda078ca395c0fa6d 100644
+index 17553703d6dcb0c7852cc35b08da05075af435f2..4eb60f2772c80f9917e88c40ed2214993709e443 100644
 --- a/src/main/java/org/bukkit/Bukkit.java
 +++ b/src/main/java/org/bukkit/Bukkit.java
 @@ -118,6 +118,18 @@ public final class Bukkit {
@@ -28,7 +28,7 @@ index 847ba5143660d5c56ff8f2cae2169a51b8927757..2c9d2739e78d5c422574f5ddda078ca3
       * Gets a view of all currently logged in players. This {@linkplain
       * Collections#unmodifiableCollection(Collection) view} is a reused
 diff --git a/src/main/java/org/bukkit/Server.java b/src/main/java/org/bukkit/Server.java
-index e6b62ba32e089e2fd8563ec8430b72196f6680e0..46d1086bd7d7f91b4337c8463974d4b9d501cbf0 100644
+index 0a109e9157d9a9f15f71d2fa96d31b7f8eb3fde2..22495f576b05e3f0161bfd2c4ea5e5622fdb6302 100644
 --- a/src/main/java/org/bukkit/Server.java
 +++ b/src/main/java/org/bukkit/Server.java
 @@ -97,6 +97,16 @@ public interface Server extends PluginMessageRecipient, net.kyori.adventure.audi