More work

patches/unapplied/server/API-to-get-a-BlockState-without-a-snapshot.patch

@@ -1,165 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Mon, 6 Nov 2017 21:08:22 -0500
-Subject: [PATCH] API to get a BlockState without a snapshot
-
-This allows you to get a BlockState without creating a snapshot, operating
-on the real tile entity.
-
-This is useful for where performance is needed
-
-also Avoid NPE during CraftBlockEntityState load if could not get TE
-
-If Tile Entity was null, correct Sign to return empty lines instead of null
-
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/BlockEntity.java
-@@ -0,0 +0,0 @@ public abstract class BlockEntity {
-         this.worldPosition = pos.immutable();
-         this.validateBlockState(state);
-         this.blockState = state;
-+        this.persistentDataContainer = new CraftPersistentDataContainer(DATA_TYPE_REGISTRY); // Paper - always init
-     }
- 
-     private void validateBlockState(BlockState state) {
-@@ -0,0 +0,0 @@ public abstract class BlockEntity {
- 
-     // CraftBukkit start - read container
-     protected void loadAdditional(CompoundTag nbt, HolderLookup.Provider registries) {
--        this.persistentDataContainer = new CraftPersistentDataContainer(BlockEntity.DATA_TYPE_REGISTRY);
-+        this.persistentDataContainer.clear(); // Paper - clear instead of init
- 
-         net.minecraft.nbt.Tag persistentDataTag = nbt.get("PublicBukkitValues");
-         if (persistentDataTag instanceof CompoundTag) {
-@@ -0,0 +0,0 @@ public abstract class BlockEntity {
- 
-     // CraftBukkit start - add method
-     public InventoryHolder getOwner() {
-+        // Paper start
-+        return getOwner(true);
-+    }
-+    public InventoryHolder getOwner(boolean useSnapshot) {
-+        // Paper end
-         if (this.level == null) return null;
--        org.bukkit.block.BlockState state = this.level.getWorld().getBlockAt(this.worldPosition.getX(), this.worldPosition.getY(), this.worldPosition.getZ()).getState();
-+        org.bukkit.block.Block block = this.level.getWorld().getBlockAt(this.worldPosition.getX(), this.worldPosition.getY(), this.worldPosition.getZ());
-+        if (block.getType() == org.bukkit.Material.AIR) return null;
-+        org.bukkit.block.BlockState state = block.getState(useSnapshot); // Paper
-         if (state instanceof InventoryHolder) return (InventoryHolder) state;
-         return null;
-     }
-diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
-+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
-@@ -0,0 +0,0 @@ public class CraftBlock implements Block {
-         return CraftBlockStates.getBlockState(this);
-     }
- 
-+    // Paper start
-+    @Override
-+    public BlockState getState(boolean useSnapshot) {
-+        return CraftBlockStates.getBlockState(this, useSnapshot);
-+    }
-+    // Paper end
-+
-     @Override
-     public Biome getBiome() {
-         return this.getWorld().getBiome(this.getX(), this.getY(), this.getZ());
-diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockEntityState.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockEntityState.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockEntityState.java
-+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockEntityState.java
-@@ -0,0 +0,0 @@ public class CraftBlockEntityState<T extends BlockEntity> extends CraftBlockStat
- 
-     private final T tileEntity;
-     private final T snapshot;
-+    public boolean snapshotDisabled; // Paper
-+    public static boolean DISABLE_SNAPSHOT = false; // Paper
- 
-     public CraftBlockEntityState(World world, T tileEntity) {
-         super(world, tileEntity.getBlockPos(), tileEntity.getBlockState());
- 
-         this.tileEntity = tileEntity;
- 
-+        // Paper start
-+        this.snapshotDisabled = DISABLE_SNAPSHOT;
-+        if (DISABLE_SNAPSHOT) {
-+            this.snapshot = this.tileEntity;
-+        } else {
-+            this.snapshot = this.createSnapshot(tileEntity);
-+        }
-         // copy tile entity data:
--        this.snapshot = this.createSnapshot(tileEntity);
--        this.load(this.snapshot);
-+        if (this.snapshot != null) {
-+            this.load(this.snapshot);
-+        }
-+        // Paper end
-     }
- 
-     protected CraftBlockEntityState(CraftBlockEntityState<T> state, Location location) {
-@@ -0,0 +0,0 @@ public class CraftBlockEntityState<T extends BlockEntity> extends CraftBlockStat
-     public CraftBlockEntityState<T> copy(Location location) {
-         return new CraftBlockEntityState<>(this, location);
-     }
-+
-+    // Paper start
-+    @Override
-+    public boolean isSnapshot() {
-+        return !this.snapshotDisabled;
-+    }
-+    // Paper end
- }
-diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockStates.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockStates.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockStates.java
-+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockStates.java
-@@ -0,0 +0,0 @@ public final class CraftBlockStates {
-     }
- 
-     public static BlockState getBlockState(Block block) {
-+        // Paper start
-+        return CraftBlockStates.getBlockState(block, true);
-+    }
-+    public static BlockState getBlockState(Block block, boolean useSnapshot) {
-+        // Paper end
-         Preconditions.checkNotNull(block, "block is null");
-         CraftBlock craftBlock = (CraftBlock) block;
-         CraftWorld world = (CraftWorld) block.getWorld();
-         BlockPos blockPosition = craftBlock.getPosition();
-         net.minecraft.world.level.block.state.BlockState blockData = craftBlock.getNMS();
-         BlockEntity tileEntity = craftBlock.getHandle().getBlockEntity(blockPosition);
-+        // Paper start - block state snapshots
-+        boolean prev = CraftBlockEntityState.DISABLE_SNAPSHOT;
-+        CraftBlockEntityState.DISABLE_SNAPSHOT = !useSnapshot;
-+        try {
-+        // Paper end
-         CraftBlockState blockState = CraftBlockStates.getBlockState(world, blockPosition, blockData, tileEntity);
-         blockState.setWorldHandle(craftBlock.getHandle()); // Inject the block's generator access
-         return blockState;
-+        // Paper start
-+        } finally {
-+            CraftBlockEntityState.DISABLE_SNAPSHOT = prev;
-+        }
-+        // Paper end
-     }
- 
-     @Deprecated
-diff --git a/src/main/java/org/bukkit/craftbukkit/persistence/CraftPersistentDataContainer.java b/src/main/java/org/bukkit/craftbukkit/persistence/CraftPersistentDataContainer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/persistence/CraftPersistentDataContainer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/persistence/CraftPersistentDataContainer.java
-@@ -0,0 +0,0 @@ public class CraftPersistentDataContainer implements PersistentDataContainer {
-     public String serialize() {
-         return CraftNBTTagConfigSerializer.serialize(this.toTagCompound());
-     }
-+
-+    // Paper start
-+    public void clear() {
-+        this.customDataTags.clear();
-+    }
-+    // Paper end
- }

patches/unapplied/server/Ability-to-apply-mending-to-XP-API.patch

@@ -1,62 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Wed, 20 Dec 2017 17:36:49 -0500
-Subject: [PATCH] Ability to apply mending to XP API
-
-This allows plugins that give players the ability to apply the experience
-points to the Item Mending formula, which will repair an item instead
-of giving the player experience points.
-
-Both an API To standalone mend, and apply mending logic to .giveExp has been added.
-
-== AT ==
-public net.minecraft.world.entity.ExperienceOrb durabilityToXp(I)I
-public net.minecraft.world.entity.ExperienceOrb xpToDurability(I)I
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-     }
- 
-     @Override
--    public void giveExp(int exp) {
-+    // Paper start - ability to apply mending
-+    public int applyMending(int amount) {
-+        ServerPlayer handle = this.getHandle();
-+        // Logic copied from EntityExperienceOrb and remapped to unobfuscated methods/properties
-+
-+        final Optional<net.minecraft.world.item.enchantment.EnchantedItemInUse> stackEntry = net.minecraft.world.item.enchantment.EnchantmentHelper
-+            .getRandomItemWith(net.minecraft.world.item.enchantment.EnchantmentEffectComponents.REPAIR_WITH_XP, handle, net.minecraft.world.item.ItemStack::isDamaged);
-+        final net.minecraft.world.item.ItemStack itemstack = stackEntry.map(net.minecraft.world.item.enchantment.EnchantedItemInUse::itemStack).orElse(net.minecraft.world.item.ItemStack.EMPTY);
-+        if (!itemstack.isEmpty() && itemstack.getItem().components().has(net.minecraft.core.component.DataComponents.MAX_DAMAGE)) {
-+            net.minecraft.world.entity.ExperienceOrb orb = net.minecraft.world.entity.EntityType.EXPERIENCE_ORB.create(handle.level(), net.minecraft.world.entity.EntitySpawnReason.COMMAND);
-+            orb.value = amount;
-+            orb.spawnReason = org.bukkit.entity.ExperienceOrb.SpawnReason.CUSTOM;
-+            orb.setPosRaw(handle.getX(), handle.getY(), handle.getZ());
-+
-+            final int possibleDurabilityFromXp = net.minecraft.world.item.enchantment.EnchantmentHelper.modifyDurabilityToRepairFromXp(
-+                handle.serverLevel(), itemstack, amount
-+            );
-+            int i = Math.min(possibleDurabilityFromXp, itemstack.getDamageValue());
-+            org.bukkit.event.player.PlayerItemMendEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerItemMendEvent(handle, orb, itemstack, stackEntry.get().inSlot(), i);
-+            i = event.getRepairAmount();
-+            orb.discard(org.bukkit.event.entity.EntityRemoveEvent.Cause.DESPAWN);
-+            if (!event.isCancelled()) {
-+                amount -= i * amount / possibleDurabilityFromXp;
-+                itemstack.setDamageValue(itemstack.getDamageValue() - i);
-+            }
-+        }
-+        return amount;
-+    }
-+
-+    @Override
-+    public void giveExp(int exp, boolean applyMending) {
-+        if (applyMending) {
-+            exp = this.applyMending(exp);
-+        }
-+    // Paper end - ability to apply mending
-         this.getHandle().giveExperiencePoints(exp);
-     }
- 

patches/unapplied/server/Ability-to-get-block-entities-from-a-chunk-without-s.patch

@@ -1,55 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Wed, 15 Aug 2018 01:16:34 -0400
-Subject: [PATCH] Ability to get block entities from a chunk without snapshots
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
-@@ -0,0 +0,0 @@ public class CraftChunk implements Chunk {
- 
-     @Override
-     public BlockState[] getTileEntities() {
-+        // Paper start
-+        return getTileEntities(true);
-+    }
-+
-+    @Override
-+    public BlockState[] getTileEntities(boolean useSnapshot) {
-+        // Paper end
-         if (!this.isLoaded()) {
-             this.getWorld().getChunkAt(this.x, this.z); // Transient load for this tick
-         }
-@@ -0,0 +0,0 @@ public class CraftChunk implements Chunk {
-         BlockState[] entities = new BlockState[chunk.blockEntities.size()];
- 
-         for (BlockPos position : chunk.blockEntities.keySet()) {
--            entities[index++] = this.worldServer.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ()).getState();
-+            // Paper start
-+            entities[index++] = this.worldServer.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ()).getState(useSnapshot);
-+        }
-+
-+        return entities;
-+    }
-+
-+    @Override
-+    public Collection<BlockState> getTileEntities(Predicate<? super Block> blockPredicate, boolean useSnapshot) {
-+        Preconditions.checkNotNull(blockPredicate, "blockPredicate");
-+        if (!this.isLoaded()) {
-+            this.getWorld().getChunkAt(this.x, this.z); // Transient load for this tick
-+        }
-+        ChunkAccess chunk = this.getHandle(ChunkStatus.FULL);
-+
-+        java.util.List<BlockState> entities = new java.util.ArrayList<>();
-+
-+        for (BlockPos position : chunk.blockEntities.keySet()) {
-+            Block block = this.worldServer.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ());
-+            if (blockPredicate.test(block)) {
-+                entities.add(block.getState(useSnapshot));
-+            }
-+            // Paper end
-         }
- 
-         return entities;

patches/unapplied/server/Add-API-methods-to-control-if-armor-stands-can-move.patch

@@ -1,52 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Riley Park <rileysebastianpark@gmail.com>
-Date: Wed, 21 Dec 2016 11:47:25 -0600
-Subject: [PATCH] Add API methods to control if armor stands can move
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-+++ b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
-     public Rotations rightArmPose;
-     public Rotations leftLegPose;
-     public Rotations rightLegPose;
-+    public boolean canMove = true; // Paper
- 
-     public ArmorStand(EntityType<? extends ArmorStand> type, Level world) {
-         super(type, world);
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
-     public boolean canBeSeenByAnyone() {
-         return !this.isInvisible() && !this.isMarker();
-     }
-+
-+    // Paper start
-+    @Override
-+    public void move(net.minecraft.world.entity.MoverType type, Vec3 movement) {
-+        if (this.canMove) {
-+            super.move(type, movement);
-+        }
-+    }
-+    // Paper end
- }
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
-@@ -0,0 +0,0 @@ public class CraftArmorStand extends CraftLivingEntity implements ArmorStand {
-     public boolean hasEquipmentLock(EquipmentSlot equipmentSlot, LockType lockType) {
-         return (this.getHandle().disabledSlots & (1 << CraftEquipmentSlot.getNMS(equipmentSlot).getFilterBit(lockType.ordinal() * 8))) != 0;
-     }
-+    // Paper start
-+    @Override
-+    public boolean canMove() {
-+        return getHandle().canMove;
-+    }
-+
-+    @Override
-+    public void setCanMove(boolean move) {
-+        getHandle().canMove = move;
-+    }
-+    // Paper end
- }

patches/unapplied/server/Add-ArmorStand-Item-Meta.patch

@@ -1,238 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Zach Brown <1254957+zachbr@users.noreply.github.com>
-Date: Sat, 27 Jan 2018 17:04:14 -0500
-Subject: [PATCH] Add ArmorStand Item Meta
-
-This is adds basic item meta for armor stands. It does not add all
-possible metadata however.
-
-There are armor, hand, and equipment types, as well as position data
-that can also be added here. This initial addition should serve a
-starting point for future additions in this area.
-
-Fixes GH-559
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java
-@@ -0,0 +0,0 @@
- package org.bukkit.craftbukkit.inventory;
- 
-+import com.destroystokyo.paper.inventory.meta.ArmorStandMeta;
- import java.util.function.BiFunction;
- import java.util.function.Function;
- import net.minecraft.world.item.BannerItem;
-@@ -0,0 +0,0 @@ public final class CraftItemMetas {
-             item -> new CraftMetaSpawnEgg(item.getComponentsPatch()),
-             (type, meta) -> meta instanceof CraftMetaSpawnEgg spawnEgg ? spawnEgg : new CraftMetaSpawnEgg(meta));
- 
--    private static final ItemMetaData<ItemMeta> ARMOR_STAND_META_DATA = new ItemMetaData<>(ItemMeta.class,
-+    private static final ItemMetaData<ArmorStandMeta> ARMOR_STAND_META_DATA = new ItemMetaData<>(ArmorStandMeta.class, // paper
-             item -> new CraftMetaArmorStand(item.getComponentsPatch()),
-             (type, meta) -> meta instanceof CraftMetaArmorStand armorStand ? armorStand : new CraftMetaArmorStand(meta));
- 
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaArmorStand.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaArmorStand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaArmorStand.java
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaArmorStand.java
-@@ -0,0 +0,0 @@ import org.bukkit.Material;
- import org.bukkit.configuration.serialization.DelegateDeserialization;
- 
- @DelegateDeserialization(SerializableMeta.class)
--public class CraftMetaArmorStand extends CraftMetaItem {
-+public class CraftMetaArmorStand extends CraftMetaItem implements com.destroystokyo.paper.inventory.meta.ArmorStandMeta { // Paper
- 
-     static final ItemMetaKeyType<CustomData> ENTITY_TAG = new ItemMetaKeyType<>(DataComponents.ENTITY_DATA, "entity-tag");
-+    // Paper start
-+    static final ItemMetaKey ENTITY_ID = new ItemMetaKey("id", "entity-id");
-+    static final ItemMetaKey INVISIBLE = new ItemMetaKey("Invisible", "invisible");
-+    static final ItemMetaKey NO_BASE_PLATE = new ItemMetaKey("NoBasePlate", "no-base-plate");
-+    static final ItemMetaKey SHOW_ARMS = new ItemMetaKey("ShowArms", "show-arms");
-+    static final ItemMetaKey SMALL = new ItemMetaKey("Small", "small");
-+    static final ItemMetaKey MARKER = new ItemMetaKey("Marker", "marker");
-+    // Paper end
-     CompoundTag entityTag;
- 
-     CraftMetaArmorStand(CraftMetaItem meta) {
-@@ -0,0 +0,0 @@ public class CraftMetaArmorStand extends CraftMetaItem {
- 
-     CraftMetaArmorStand(Map<String, Object> map) {
-         super(map);
-+        // Paper start
-+        String entityTag = SerializableMeta.getString(map, ENTITY_TAG.BUKKIT, true);
-+        if (entityTag != null) {
-+            java.io.ByteArrayInputStream buf = new java.io.ByteArrayInputStream(java.util.Base64.getDecoder().decode(entityTag));
-+            try {
-+                this.entityTag = net.minecraft.nbt.NbtIo.readCompressed(buf, net.minecraft.nbt.NbtAccounter.unlimitedHeap());
-+            } catch (java.io.IOException ex) {
-+                java.util.logging.Logger.getLogger(CraftMetaItem.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
-+            }
-+            return;
-+        }
-+        SerializableMeta.getObjectOptionally(Boolean.class, map, INVISIBLE.BUKKIT, true).ifPresent((value) -> {
-+            populateTagIfNull();
-+            this.entityTag.putBoolean(INVISIBLE.NBT, value);
-+        });
-+        SerializableMeta.getObjectOptionally(Boolean.class, map, NO_BASE_PLATE.BUKKIT, true).ifPresent((value) -> {
-+            populateTagIfNull();
-+            this.entityTag.putBoolean(NO_BASE_PLATE.NBT, value);
-+        });
-+        SerializableMeta.getObjectOptionally(Boolean.class, map, SHOW_ARMS.BUKKIT, true).ifPresent((value) -> {
-+            populateTagIfNull();
-+            this.entityTag.putBoolean(SHOW_ARMS.NBT, value);
-+        });
-+        SerializableMeta.getObjectOptionally(Boolean.class, map, SMALL.BUKKIT, true).ifPresent((value) -> {
-+            populateTagIfNull();
-+            this.entityTag.putBoolean(SMALL.NBT, value);
-+        });
-+        SerializableMeta.getObjectOptionally(Boolean.class, map, MARKER.BUKKIT, true).ifPresent((value) -> {
-+            populateTagIfNull();
-+            this.entityTag.putBoolean(MARKER.NBT, value);
-+        });
-+        SerializableMeta.getObjectOptionally(String.class, map, ENTITY_ID, true).ifPresent((value) -> {
-+            populateTagIfNull();
-+            this.entityTag.putString(ENTITY_ID.NBT, value);
-+        });
-+        // Paper end
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class CraftMetaArmorStand extends CraftMetaItem {
- 
-         if (tag.contains(CraftMetaArmorStand.ENTITY_TAG.NBT)) {
-             this.entityTag = tag.getCompound(CraftMetaArmorStand.ENTITY_TAG.NBT);
-+            if (!this.entityTag.contains(ENTITY_ID.NBT)) entityTag.putString(ENTITY_ID.NBT, "minecraft:armor_stand"); // Paper - fixup legacy armorstand metas that did not include this.
-         }
-     }
- 
-     @Override
-     void serializeInternal(Map<String, Tag> internalTags) {
--        if (this.entityTag != null && !this.entityTag.isEmpty()) {
-+        if (false && this.entityTag != null && !this.entityTag.isEmpty()) { // Paper - now correctly serialised as entity tag
-             internalTags.put(CraftMetaArmorStand.ENTITY_TAG.NBT, this.entityTag);
-         }
-     }
-@@ -0,0 +0,0 @@ public class CraftMetaArmorStand extends CraftMetaItem {
-     }
- 
-     boolean isArmorStandEmpty() {
--        return !(this.entityTag != null);
-+        return entityTag == null || entityTag.isEmpty(); // Paper - consider armor stand empty if tag is empty.
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class CraftMetaArmorStand extends CraftMetaItem {
-         if (meta instanceof CraftMetaArmorStand) {
-             CraftMetaArmorStand that = (CraftMetaArmorStand) meta;
- 
--            return this.entityTag != null ? that.entityTag != null && this.entityTag.equals(that.entityTag) : this.entityTag == null;
-+            // Paper start
-+            return java.util.Objects.equals(this.entityTag, that.entityTag);
-+            // Paper end
-         }
-         return true;
-     }
-@@ -0,0 +0,0 @@ public class CraftMetaArmorStand extends CraftMetaItem {
-     Builder<String, Object> serialize(Builder<String, Object> builder) {
-         super.serialize(builder);
- 
-+        // Paper start
-+        if (entityTag == null) {
-+            return builder;
-+        } else if (true) {
-+            java.io.ByteArrayOutputStream buf = new java.io.ByteArrayOutputStream();
-+            try {
-+                net.minecraft.nbt.NbtIo.writeCompressed(entityTag, buf);
-+            } catch (java.io.IOException ex) {
-+                java.util.logging.Logger.getLogger(CraftMetaItem.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
-+            }
-+            builder.put(ENTITY_TAG.BUKKIT, java.util.Base64.getEncoder().encodeToString(buf.toByteArray()));
-+            return builder;
-+        }
-+        // Paper end
-+
-         return builder;
-     }
- 
-@@ -0,0 +0,0 @@ public class CraftMetaArmorStand extends CraftMetaItem {
- 
-         return clone;
-     }
-+
-+    // Paper start
-+    private void populateTagIfNull() {
-+        if (this.entityTag == null) {
-+            this.entityTag = new CompoundTag();
-+            this.entityTag.putString(ENTITY_ID.NBT, "minecraft:armor_stand");
-+        }
-+    }
-+
-+    @Override
-+    public boolean isInvisible() {
-+        return entityTag != null && entityTag.contains(INVISIBLE.NBT) && entityTag.getBoolean(INVISIBLE.NBT);
-+    }
-+
-+    @Override
-+    public boolean hasNoBasePlate() {
-+        return entityTag != null && entityTag.contains(NO_BASE_PLATE.NBT) && entityTag.getBoolean(NO_BASE_PLATE.NBT);
-+    }
-+
-+    @Override
-+    public boolean shouldShowArms() {
-+        return entityTag != null && entityTag.contains(SHOW_ARMS.NBT) && entityTag.getBoolean(SHOW_ARMS.NBT);
-+    }
-+
-+    @Override
-+    public boolean isSmall() {
-+        return entityTag != null && entityTag.contains(SMALL.NBT) && entityTag.getBoolean(SMALL.NBT);
-+    }
-+
-+    @Override
-+    public boolean isMarker() {
-+        return entityTag != null && entityTag.contains(MARKER.NBT) && entityTag.getBoolean(MARKER.NBT);
-+    }
-+
-+    @Override
-+    public void setInvisible(boolean invisible) {
-+        populateTagIfNull();
-+        entityTag.putBoolean(INVISIBLE.NBT, invisible);
-+    }
-+
-+    @Override
-+    public void setNoBasePlate(boolean noBasePlate) {
-+        populateTagIfNull();
-+        entityTag.putBoolean(NO_BASE_PLATE.NBT, noBasePlate);
-+    }
-+
-+    @Override
-+    public void setShowArms(boolean showArms) {
-+        populateTagIfNull();
-+        entityTag.putBoolean(SHOW_ARMS.NBT, showArms);
-+    }
-+
-+    @Override
-+    public void setSmall(boolean small) {
-+        populateTagIfNull();
-+        entityTag.putBoolean(SMALL.NBT, small);
-+    }
-+
-+    @Override
-+    public void setMarker(boolean marker) {
-+        populateTagIfNull();
-+        entityTag.putBoolean(MARKER.NBT, marker);
-+    }
-+    // Paper end
- }
-diff --git a/src/test/java/org/bukkit/craftbukkit/inventory/ItemMetaTest.java b/src/test/java/org/bukkit/craftbukkit/inventory/ItemMetaTest.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/test/java/org/bukkit/craftbukkit/inventory/ItemMetaTest.java
-+++ b/src/test/java/org/bukkit/craftbukkit/inventory/ItemMetaTest.java
-@@ -0,0 +0,0 @@ public class ItemMetaTest {
-                     final CraftMetaArmorStand meta = (CraftMetaArmorStand) cleanStack.getItemMeta();
-                     meta.entityTag = new CompoundTag();
-                     meta.entityTag.putBoolean("Small", true);
-+                    meta.setInvisible(true); // Paper
-                     cleanStack.setItemMeta(meta);
-                     return cleanStack;
-                 }

patches/unapplied/server/Add-Debug-Entities-option-to-debug-dupe-uuid-issues.patch

@@ -1,42 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sat, 21 Jul 2018 08:25:40 -0400
-Subject: [PATCH] Add Debug Entities option to debug dupe uuid issues
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
-     // CraftBukkit start
-     private boolean addEntity(Entity entity, CreatureSpawnEvent.SpawnReason spawnReason) {
-         org.spigotmc.AsyncCatcher.catchOp("entity add"); // Spigot
-+        // Paper start - extra debug info
-+        if (entity.valid) {
-+            MinecraftServer.LOGGER.error("Attempted Double World add on {}", entity, new Throwable());
-+            return true;
-+        }
-+        // Paper end - extra debug info
-         if (entity.isRemoved()) {
-             // WorldServer.LOGGER.warn("Tried to add entity {} but it was marked as removed already", EntityTypes.getKey(entity.getType())); // CraftBukkit
-             return false;
-diff --git a/src/main/java/net/minecraft/world/level/entity/EntityLookup.java b/src/main/java/net/minecraft/world/level/entity/EntityLookup.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/entity/EntityLookup.java
-+++ b/src/main/java/net/minecraft/world/level/entity/EntityLookup.java
-@@ -0,0 +0,0 @@ public class EntityLookup<T extends EntityAccess> {
-         UUID uUID = entity.getUUID();
-         if (this.byUuid.containsKey(uUID)) {
-             LOGGER.warn("Duplicate entity UUID {}: {}", uUID, entity);
-+            // Paper start - extra debug info
-+            if (entity instanceof net.minecraft.world.entity.Entity) {
-+                final T old = this.byUuid.get(entity.getUUID());
-+                if (old instanceof net.minecraft.world.entity.Entity oldCast && oldCast.getId() != entity.getId() && oldCast.valid) {
-+                    LOGGER.error("Overwrote an existing entity {} with {}", oldCast, entity);
-+                }
-+            }
-+            // Paper end - extra debug info
-         } else {
-             this.byUuid.put(uUID, entity);
-             this.byId.put(entity.getId(), entity);

patches/unapplied/server/Add-Early-Warning-Feature-to-WatchDog.patch

@@ -1,159 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: miclebrick <miclebrick@outlook.com>
-Date: Wed, 8 Aug 2018 15:30:52 -0400
-Subject: [PATCH] Add Early Warning Feature to WatchDog
-
-Detect when the server has been hung for a long duration, and start printing
-thread dumps at an interval until the point of crash.
-
-This will help diagnose what was going on in that time before the crash.
-
-diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-             this.status = this.buildServerStatus();
- 
-             // Spigot start
-+            org.spigotmc.WatchdogThread.hasStarted = true; // Paper
-             Arrays.fill( this.recentTps, 20 );
-             // Paper start - further improve server tick loop
-             long tickSection = Util.getNanos();
-diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-+++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-@@ -0,0 +0,0 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
-         this.paperConfigurations.initializeGlobalConfiguration(this.registryAccess());
-         this.paperConfigurations.initializeWorldDefaultsConfiguration(this.registryAccess());
-         // Paper end - initialize global and world-defaults configuration
-+        org.spigotmc.WatchdogThread.doStart(org.spigotmc.SpigotConfig.timeoutTime, org.spigotmc.SpigotConfig.restartOnCrash); // Paper - start watchdog thread
-         io.papermc.paper.command.PaperCommands.registerCommands(this); // Paper - setup /paper command
-         com.destroystokyo.paper.Metrics.PaperMetrics.startMetrics(); // Paper - start metrics
-         com.destroystokyo.paper.VersionHistoryManager.INSTANCE.getClass(); // Paper - load version history now
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
- 
-     @Override
-     public void reload() {
-+        org.spigotmc.WatchdogThread.hasStarted = false; // Paper - Disable watchdog early timeout on reload
-         this.reloadCount++;
-         this.configuration = YamlConfiguration.loadConfiguration(this.getConfigFile());
-         this.commandsConfiguration = YamlConfiguration.loadConfiguration(this.getCommandsConfigFile());
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-         this.enablePlugins(PluginLoadOrder.POSTWORLD);
-         if (io.papermc.paper.plugin.PluginInitializerManager.instance().pluginRemapper != null) io.papermc.paper.plugin.PluginInitializerManager.instance().pluginRemapper.pluginsEnabled(); // Paper - Remap plugins
-         this.getPluginManager().callEvent(new ServerLoadEvent(ServerLoadEvent.LoadType.RELOAD));
-+        org.spigotmc.WatchdogThread.hasStarted = true; // Paper - Disable watchdog early timeout on reload
-     }
- 
-     @Override
-diff --git a/src/main/java/org/spigotmc/SpigotConfig.java b/src/main/java/org/spigotmc/SpigotConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/spigotmc/SpigotConfig.java
-+++ b/src/main/java/org/spigotmc/SpigotConfig.java
-@@ -0,0 +0,0 @@ public class SpigotConfig
-         SpigotConfig.restartScript = SpigotConfig.getString( "settings.restart-script", SpigotConfig.restartScript );
-         SpigotConfig.restartMessage = SpigotConfig.transform( SpigotConfig.getString( "messages.restart", "Server is restarting" ) );
-         SpigotConfig.commands.put( "restart", new RestartCommand( "restart" ) );
--        WatchdogThread.doStart( SpigotConfig.timeoutTime, SpigotConfig.restartOnCrash );
-+        // WatchdogThread.doStart( SpigotConfig.timeoutTime, SpigotConfig.restartOnCrash ); // Paper - moved to after paper config initialization
-     }
- 
-     public static boolean bungee;
-diff --git a/src/main/java/org/spigotmc/WatchdogThread.java b/src/main/java/org/spigotmc/WatchdogThread.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/spigotmc/WatchdogThread.java
-+++ b/src/main/java/org/spigotmc/WatchdogThread.java
-@@ -0,0 +0,0 @@ public class WatchdogThread extends Thread
-     private static WatchdogThread instance;
-     private long timeoutTime;
-     private boolean restart;
-+    private final long earlyWarningEvery; // Paper - Timeout time for just printing a dump but not restarting
-+    private final long earlyWarningDelay; // Paper
-+    public static volatile boolean hasStarted; // Paper
-+    private long lastEarlyWarning; // Paper - Keep track of short dump times to avoid spamming console with short dumps
-     private volatile long lastTick;
-     private volatile boolean stopping;
- 
-@@ -0,0 +0,0 @@ public class WatchdogThread extends Thread
-         super( "Paper Watchdog Thread" );
-         this.timeoutTime = timeoutTime;
-         this.restart = restart;
-+        earlyWarningEvery = Math.min(io.papermc.paper.configuration.GlobalConfiguration.get().watchdog.earlyWarningEvery, timeoutTime); // Paper
-+        earlyWarningDelay = Math.min(io.papermc.paper.configuration.GlobalConfiguration.get().watchdog.earlyWarningDelay, timeoutTime); // Paper
-     }
- 
-     private static long monotonicMillis()
-@@ -0,0 +0,0 @@ public class WatchdogThread extends Thread
-         while ( !this.stopping )
-         {
-             //
--            if ( this.lastTick != 0 && this.timeoutTime > 0 && WatchdogThread.monotonicMillis() > this.lastTick + this.timeoutTime && !Boolean.getBoolean("disable.watchdog")) // Paper - Add property to disable
-+            // Paper start
-+            Logger log = Bukkit.getServer().getLogger();
-+            long currentTime = WatchdogThread.monotonicMillis();
-+            if ( this.lastTick != 0 && this.timeoutTime > 0 && currentTime > this.lastTick + this.earlyWarningEvery && !Boolean.getBoolean("disable.watchdog")) // Paper - Add property to disable
-             {
--                Logger log = Bukkit.getServer().getLogger();
-+                boolean isLongTimeout = currentTime > lastTick + timeoutTime;
-+                // Don't spam early warning dumps
-+                if ( !isLongTimeout && (earlyWarningEvery <= 0 || !hasStarted || currentTime < lastEarlyWarning + earlyWarningEvery || currentTime < lastTick + earlyWarningDelay)) continue;
-+                if ( !isLongTimeout && MinecraftServer.getServer().hasStopped()) continue; // Don't spam early watchdog warnings during shutdown, we'll come back to this...
-+                lastEarlyWarning = currentTime;
-+                if (isLongTimeout) {
-+                // Paper end
-                 log.log( Level.SEVERE, "------------------------------" );
-                 log.log( Level.SEVERE, "The server has stopped responding! This is (probably) not a Paper bug." ); // Paper
-                 log.log( Level.SEVERE, "If you see a plugin in the Server thread dump below, then please report it to that author" );
-@@ -0,0 +0,0 @@ public class WatchdogThread extends Thread
-                     }
-                 }
-                 // Paper end
-+                } else
-+                {
-+                    log.log(Level.SEVERE, "--- DO NOT REPORT THIS TO PAPER - THIS IS NOT A BUG OR A CRASH  - " + Bukkit.getServer().getVersion() + " ---");
-+                    log.log(Level.SEVERE, "The server has not responded for " + (currentTime - lastTick) / 1000 + " seconds! Creating thread dump");
-+                }
-+                // Paper end - Different message for short timeout
-                 log.log( Level.SEVERE, "------------------------------" );
-                 log.log( Level.SEVERE, "Server thread dump (Look for plugins here before reporting to Paper!):" ); // Paper
-                 WatchdogThread.dumpThread( ManagementFactory.getThreadMXBean().getThreadInfo( MinecraftServer.getServer().serverThread.getId(), Integer.MAX_VALUE ), log );
-                 log.log( Level.SEVERE, "------------------------------" );
-                 //
-+                // Paper start - Only print full dump on long timeouts
-+                if ( isLongTimeout )
-+                {
-                 log.log( Level.SEVERE, "Entire Thread Dump:" );
-                 ThreadInfo[] threads = ManagementFactory.getThreadMXBean().dumpAllThreads( true, true );
-                 for ( ThreadInfo thread : threads )
-                 {
-                     WatchdogThread.dumpThread( thread, log );
-                 }
-+                } else {
-+                    log.log(Level.SEVERE, "--- DO NOT REPORT THIS TO PAPER - THIS IS NOT A BUG OR A CRASH ---");
-+                }
-+
-                 log.log( Level.SEVERE, "------------------------------" );
- 
-+                if ( isLongTimeout )
-+                {
-                 if ( this.restart && !MinecraftServer.getServer().hasStopped() )
-                 {
-                     RestartCommand.restart();
-                 }
-                 break;
-+                } // Paper end
-             }
- 
-             try
-             {
--                sleep( 10000 );
-+                sleep( 1000 ); // Paper - Reduce check time to every second instead of every ten seconds, more consistent and allows for short timeout
-             } catch ( InterruptedException ex )
-             {
-                 this.interrupt();

patches/unapplied/server/Add-EntityTeleportEndGatewayEvent.patch

@@ -1,29 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Shane Freeder <theboyetronic@gmail.com>
-Date: Sat, 9 Jun 2018 14:08:39 +0200
-Subject: [PATCH] Add EntityTeleportEndGatewayEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-                 // CraftBukkit start
-                 PositionMoveRotation absolutePosition = PositionMoveRotation.calculateAbsolute(PositionMoveRotation.of(this), PositionMoveRotation.of(teleportTarget), teleportTarget.relatives());
-                 Location to = CraftLocation.toBukkit(absolutePosition.position(), teleportTarget.newLevel().getWorld(), absolutePosition.yRot(), absolutePosition.xRot());
--                EntityTeleportEvent teleEvent = CraftEventFactory.callEntityTeleportEvent(this, to);
--                if (teleEvent.isCancelled()) {
-+                // Paper start - gateway-specific teleport event
-+                final EntityTeleportEvent teleEvent;
-+                if (this.portalProcess != null && this.portalProcess.isSamePortal(((net.minecraft.world.level.block.EndGatewayBlock) net.minecraft.world.level.block.Blocks.END_GATEWAY)) && this.level.getBlockEntity(this.portalProcess.getEntryPosition()) instanceof net.minecraft.world.level.block.entity.TheEndGatewayBlockEntity theEndGatewayBlockEntity) {
-+                    teleEvent = new com.destroystokyo.paper.event.entity.EntityTeleportEndGatewayEvent(this.getBukkitEntity(), this.getBukkitEntity().getLocation(), to, new org.bukkit.craftbukkit.block.CraftEndGateway(to.getWorld(), theEndGatewayBlockEntity));
-+                    teleEvent.callEvent();
-+                } else {
-+                    teleEvent = CraftEventFactory.callEntityTeleportEvent(this, to);
-+                }
-+                // Paper end - gateway-specific teleport event
-+                if (teleEvent.isCancelled() || teleEvent.getTo() == null) {
-                     return null;
-                 }
-                 if (!to.equals(teleEvent.getTo())) {

patches/unapplied/server/Add-EntityZapEvent.patch

@@ -1,103 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: AlphaBlend <whizkid3000@hotmail.com>
-Date: Sun, 16 Oct 2016 23:19:30 -0700
-Subject: [PATCH] Add EntityZapEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/ConversionParams.java b/src/main/java/net/minecraft/world/entity/ConversionParams.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ConversionParams.java
-+++ b/src/main/java/net/minecraft/world/entity/ConversionParams.java
-@@ -0,0 +0,0 @@ public record ConversionParams(ConversionType type, boolean keepEquipment, boole
-     public interface AfterConversion<T extends Mob> {
-         void finalizeConversion(T convertedEntity);
-     }
-+
-+    // Paper start - entity zap event - allow conversion to be cancelled during finalization
-+    @FunctionalInterface
-+    public interface CancellingAfterConversion<T extends Mob> {
-+        boolean finalizeConversionOrCancel(final T convertedEntity);
-+    }
-+    // Paper start - entity zap event - allow conversion to be cancelled during finalization
- }
-diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/Mob.java
-+++ b/src/main/java/net/minecraft/world/entity/Mob.java
-@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
- 
-     @Nullable
-     public <T extends Mob> T convertTo(EntityType<T> entitytypes, ConversionParams conversionparams, EntitySpawnReason entityspawnreason, ConversionParams.AfterConversion<T> conversionparams_a, EntityTransformEvent.TransformReason transformReason, CreatureSpawnEvent.SpawnReason spawnReason) {
-+    // Paper start - entity zap event - allow cancellation of conversion post creation
-+        return this.convertTo(entitytypes, conversionparams, entityspawnreason, e -> { conversionparams_a.finalizeConversion(e); return true; }, transformReason, spawnReason);
-+    }
-+    @Nullable
-+    public <T extends Mob> T convertTo(EntityType<T> entitytypes, ConversionParams conversionparams, EntitySpawnReason entityspawnreason, ConversionParams.CancellingAfterConversion<T> conversionparams_a, EntityTransformEvent.TransformReason transformReason, CreatureSpawnEvent.SpawnReason spawnReason) {
-+    // Paper end - entity zap event - allow cancellation of conversion post creation
-         // CraftBukkit end
-         if (this.isRemoved()) {
-             return null;
-@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
-                 return null;
-             } else {
-                 conversionparams.type().convert(this, t0, conversionparams);
--                conversionparams_a.finalizeConversion(t0);
-+                if (!conversionparams_a.finalizeConversionOrCancel(t0)) return null; // Paper - entity zap event - return null if conversion was cancelled
-                 Level world = this.level();
- 
-                 // CraftBukkit start
-@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
- 
-     @Nullable
-     public <T extends Mob> T convertTo(EntityType<T> entitytypes, ConversionParams conversionparams, ConversionParams.AfterConversion<T> conversionparams_a, EntityTransformEvent.TransformReason transformReason, CreatureSpawnEvent.SpawnReason spawnReason) {
-+    // Paper start - entity zap event - allow cancellation of conversion post creation
-+        return this.convertTo(entitytypes, conversionparams, e -> { conversionparams_a.finalizeConversion(e); return true; }, transformReason, spawnReason);
-+    }
-+    public <T extends Mob> T convertTo(EntityType<T> entitytypes, ConversionParams conversionparams, ConversionParams.CancellingAfterConversion<T> conversionparams_a, EntityTransformEvent.TransformReason transformReason, CreatureSpawnEvent.SpawnReason spawnReason) {
-+    // Paper start - entity zap event - allow cancellation of conversion post creation
-         return this.convertTo(entitytypes, conversionparams, EntitySpawnReason.CONVERSION, conversionparams_a, transformReason, spawnReason);
-         // CraftBukkit end
-     }
-diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
-+++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
-@@ -0,0 +0,0 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
-     @Override
-     public void thunderHit(ServerLevel world, LightningBolt lightning) {
-         if (world.getDifficulty() != Difficulty.PEACEFUL) {
--            Villager.LOGGER.info("Villager {} was struck by lightning {}.", this, lightning);
-+            // Paper - Add EntityZapEvent; move log down, event can cancel
-             Witch entitywitch = (Witch) this.convertTo(EntityType.WITCH, ConversionParams.single(this, false, false), (entitywitch1) -> {
-+               // Paper start - Add EntityZapEvent
-+               if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityZapEvent(this, lightning, entitywitch1).isCancelled()) {
-+                   return false;
-+               }
-+               if (org.spigotmc.SpigotConfig.logVillagerDeaths) Villager.LOGGER.info("Villager {} was struck by lightning {}.", this, lightning); // Move down
-+               // Paper end - Add EntityZapEvent
-                 entitywitch1.finalizeSpawn(world, world.getCurrentDifficultyAt(entitywitch1.blockPosition()), EntitySpawnReason.CONVERSION, (SpawnGroupData) null);
-                 entitywitch1.setPersistenceRequired();
-                 this.releaseAllPois();
-+                return true; // Paper start - Add EntityZapEvent
-             }, EntityTransformEvent.TransformReason.LIGHTNING, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.LIGHTNING); // CraftBukkit
- 
-             if (entitywitch == null) {
-diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
-         return !event.isCancelled();
-     }
- 
-+    // Paper start
-+    public static com.destroystokyo.paper.event.entity.EntityZapEvent callEntityZapEvent(Entity entity, Entity lightning, Entity changedEntity) {
-+        com.destroystokyo.paper.event.entity.EntityZapEvent event = new com.destroystokyo.paper.event.entity.EntityZapEvent(entity.getBukkitEntity(), (LightningStrike) lightning.getBukkitEntity(), changedEntity.getBukkitEntity());
-+        entity.getBukkitEntity().getServer().getPluginManager().callEvent(event);
-+        return event;
-+    }
-+    // Paper end
-+
-     public static boolean callEntityChangeBlockEvent(Entity entity, BlockPos position, net.minecraft.world.level.block.state.BlockState newBlock) {
-         return CraftEventFactory.callEntityChangeBlockEvent(entity, position, newBlock, false);
-     }

patches/unapplied/server/Add-LivingEntity-getTargetEntity.patch

@@ -1,93 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Sat, 22 Sep 2018 00:33:08 -0500
-Subject: [PATCH] Add LivingEntity#getTargetEntity
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-         return this.level().clip(raytrace);
-     }
- 
-+    public @Nullable net.minecraft.world.phys.EntityHitResult getTargetEntity(int maxDistance) {
-+        if (maxDistance < 1 || maxDistance > 120) {
-+            throw new IllegalArgumentException("maxDistance must be between 1-120");
-+        }
-+
-+        Vec3 start = this.getEyePosition(1.0F);
-+        Vec3 direction = this.getLookAngle();
-+        Vec3 end = start.add(direction.x * maxDistance, direction.y * maxDistance, direction.z * maxDistance);
-+
-+        List<Entity> entityList = this.level().getEntities(this, getBoundingBox().expandTowards(direction.x * maxDistance, direction.y * maxDistance, direction.z * maxDistance).inflate(1.0D, 1.0D, 1.0D), EntitySelector.NO_SPECTATORS.and(Entity::isPickable));
-+
-+        double distance = 0.0D;
-+        net.minecraft.world.phys.EntityHitResult result = null;
-+
-+        for (Entity entity : entityList) {
-+            final double inflationAmount = (double) entity.getPickRadius();
-+            AABB aabb = entity.getBoundingBox().inflate(inflationAmount, inflationAmount, inflationAmount);
-+            Optional<Vec3> rayTraceResult = aabb.clip(start, end);
-+
-+            if (rayTraceResult.isPresent()) {
-+                Vec3 rayTrace = rayTraceResult.get();
-+                double distanceTo = start.distanceToSqr(rayTrace);
-+                if (distanceTo < distance || distance == 0.0D) {
-+                    result = new net.minecraft.world.phys.EntityHitResult(entity, rayTrace);
-+                    distance = distanceTo;
-+                }
-+            }
-+        }
-+
-+        return result;
-+    }
-+
-     public int shieldBlockingDelay = this.level().paperConfig().misc.shieldBlockingDelay;
- 
-     public int getShieldBlockingDelay() {
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-@@ -0,0 +0,0 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
-         }
-         return null;
-     }
-+
-+    public Entity getTargetEntity(int maxDistance, boolean ignoreBlocks) {
-+        net.minecraft.world.phys.EntityHitResult rayTrace = rayTraceEntity(maxDistance, ignoreBlocks);
-+        return rayTrace == null ? null : rayTrace.getEntity().getBukkitEntity();
-+    }
-+
-+    public com.destroystokyo.paper.entity.TargetEntityInfo getTargetEntityInfo(int maxDistance, boolean ignoreBlocks) {
-+        net.minecraft.world.phys.EntityHitResult rayTrace = rayTraceEntity(maxDistance, ignoreBlocks);
-+        return rayTrace == null ? null : new com.destroystokyo.paper.entity.TargetEntityInfo(rayTrace.getEntity().getBukkitEntity(), new org.bukkit.util.Vector(rayTrace.getLocation().x, rayTrace.getLocation().y, rayTrace.getLocation().z));
-+    }
-+
-+    @Override
-+    public RayTraceResult rayTraceEntities(int maxDistance, boolean ignoreBlocks) {
-+        net.minecraft.world.phys.EntityHitResult rayTrace = this.rayTraceEntity(maxDistance, ignoreBlocks);
-+        return rayTrace == null ? null : new org.bukkit.util.RayTraceResult(org.bukkit.craftbukkit.util.CraftVector.toBukkit(rayTrace.getLocation()), rayTrace.getEntity().getBukkitEntity());
-+    }
-+
-+    public net.minecraft.world.phys.EntityHitResult rayTraceEntity(int maxDistance, boolean ignoreBlocks) {
-+        net.minecraft.world.phys.EntityHitResult rayTrace = getHandle().getTargetEntity(maxDistance);
-+        if (rayTrace == null) {
-+            return null;
-+        }
-+        if (!ignoreBlocks) {
-+            net.minecraft.world.phys.HitResult rayTraceBlocks = getHandle().getRayTrace(maxDistance, net.minecraft.world.level.ClipContext.Fluid.NONE);
-+            if (rayTraceBlocks != null) {
-+                net.minecraft.world.phys.Vec3 eye = getHandle().getEyePosition(1.0F);
-+                if (eye.distanceToSqr(rayTraceBlocks.getLocation()) <= eye.distanceToSqr(rayTrace.getLocation())) {
-+                    return null;
-+                }
-+            }
-+        }
-+        return rayTrace;
-+    }
-     // Paper end
- 
-     @Override

patches/unapplied/server/Add-More-Creeper-API.patch

@@ -1,60 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Fri, 24 Aug 2018 11:50:26 -0500
-Subject: [PATCH] Add More Creeper API
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/monster/Creeper.java b/src/main/java/net/minecraft/world/entity/monster/Creeper.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/Creeper.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/Creeper.java
-@@ -0,0 +0,0 @@ public class Creeper extends Monster {
-         }
- 
-         if (nbt.getBoolean("ignited")) {
--            this.ignite();
-+            this.entityData.set(Creeper.DATA_IS_IGNITED, true); // Paper - set directly to avoid firing event
-         }
- 
-     }
-@@ -0,0 +0,0 @@ public class Creeper extends Monster {
-     }
- 
-     public void ignite() {
--        this.entityData.set(Creeper.DATA_IS_IGNITED, true);
-+        // Paper start - CreeperIgniteEvent
-+        setIgnited(true);
-+    }
-+
-+    public void setIgnited(boolean ignited) {
-+        if (isIgnited() != ignited) {
-+            com.destroystokyo.paper.event.entity.CreeperIgniteEvent event = new com.destroystokyo.paper.event.entity.CreeperIgniteEvent((org.bukkit.entity.Creeper) getBukkitEntity(), ignited);
-+            if (event.callEvent()) {
-+                this.entityData.set(Creeper.DATA_IS_IGNITED, event.isIgnited());
-+            }
-+        }
-+        // Paper end - CreeperIgniteEvent
-     }
- 
-     public boolean canDropMobsSkull() {
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java
-@@ -0,0 +0,0 @@ public class CraftCreeper extends CraftMonster implements Creeper {
-     public String toString() {
-         return "CraftCreeper";
-     }
-+
-+    // Paper start
-+    @Override
-+    public void setIgnited(boolean ignited) {
-+        getHandle().setIgnited(ignited);
-+    }
-+
-+    @Override
-+    public boolean isIgnited() {
-+        return getHandle().isIgnited();
-+    }
-+    // Paper end
- }

patches/unapplied/server/Add-PhantomPreSpawnEvent.patch

@@ -1,92 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Sat, 25 Aug 2018 19:56:51 -0500
-Subject: [PATCH] Add PhantomPreSpawnEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/monster/Phantom.java b/src/main/java/net/minecraft/world/entity/monster/Phantom.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/Phantom.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/Phantom.java
-@@ -0,0 +0,0 @@ public class Phantom extends FlyingMob implements Enemy {
-         }
- 
-         this.setPhantomSize(nbt.getInt("Size"));
-+        // Paper start
-+        if (nbt.hasUUID("Paper.SpawningEntity")) {
-+            this.spawningEntity = nbt.getUUID("Paper.SpawningEntity");
-+        }
-+        // Paper end
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class Phantom extends FlyingMob implements Enemy {
-         nbt.putInt("AY", this.anchorPoint.getY());
-         nbt.putInt("AZ", this.anchorPoint.getZ());
-         nbt.putInt("Size", this.getPhantomSize());
-+        // Paper start
-+        if (this.spawningEntity != null) {
-+            nbt.putUUID("Paper.SpawningEntity", this.spawningEntity);
-+        }
-+        // Paper end
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class Phantom extends FlyingMob implements Enemy {
-         return predicate.test(world, this, target);
-     }
- 
-+    // Paper start
-+    @Nullable
-+    java.util.UUID spawningEntity;
-+
-+    @Nullable
-+    public java.util.UUID getSpawningEntity() {
-+        return this.spawningEntity;
-+    }
-+    public void setSpawningEntity(java.util.UUID entity) { this.spawningEntity = entity; }
-+    // Paper end
-+
-     private static enum AttackPhase {
- 
-         CIRCLE, SWOOP;
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java b/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
-@@ -0,0 +0,0 @@ public class PhantomSpawner implements CustomSpawner {
-                                             int k = 1 + randomsource.nextInt(difficultydamagescaler.getDifficulty().getId() + 1);
- 
-                                             for (int l = 0; l < k; ++l) {
-+                                                // Paper start - PhantomPreSpawnEvent
-+                                                com.destroystokyo.paper.event.entity.PhantomPreSpawnEvent event = new com.destroystokyo.paper.event.entity.PhantomPreSpawnEvent(io.papermc.paper.util.MCUtil.toLocation(world, blockposition1), entityplayer.getBukkitEntity(), org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL);
-+                                                if (!event.callEvent()) {
-+                                                    if (event.shouldAbortSpawn()) {
-+                                                        break;
-+                                                    }
-+                                                    continue;
-+                                                }
-+                                                // Paper end - PhantomPreSpawnEvent
-                                                 Phantom entityphantom = (Phantom) EntityType.PHANTOM.create(world, EntitySpawnReason.NATURAL);
- 
-                                                 if (entityphantom != null) {
-+                                                    entityphantom.setSpawningEntity(entityplayer.getUUID()); // Paper - PhantomPreSpawnEvent
-                                                     entityphantom.moveTo(blockposition1, 0.0F, 0.0F);
-                                                     groupdataentity = entityphantom.finalizeSpawn(world, difficultydamagescaler, EntitySpawnReason.NATURAL, groupdataentity);
-                                                     world.addFreshEntityWithPassengers(entityphantom, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL); // CraftBukkit
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPhantom.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPhantom.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPhantom.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPhantom.java
-@@ -0,0 +0,0 @@ public class CraftPhantom extends CraftFlying implements Phantom, CraftEnemy {
-     public String toString() {
-         return "CraftPhantom";
-     }
-+
-+    // Paper start
-+    @Override
-+    public java.util.UUID getSpawningEntity() {
-+        return getHandle().getSpawningEntity();
-+    }
-+    // Paper end
- }

patches/unapplied/server/Add-PlayerAdvancementCriterionGrantEvent.patch

@@ -1,23 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Fri, 19 Jan 2018 08:15:29 -0600
-Subject: [PATCH] Add PlayerAdvancementCriterionGrantEvent
-
-
-diff --git a/src/main/java/net/minecraft/server/PlayerAdvancements.java b/src/main/java/net/minecraft/server/PlayerAdvancements.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/PlayerAdvancements.java
-+++ b/src/main/java/net/minecraft/server/PlayerAdvancements.java
-@@ -0,0 +0,0 @@ public class PlayerAdvancements {
-         boolean flag1 = advancementprogress.isDone();
- 
-         if (advancementprogress.grantProgress(criterionName)) {
-+            // Paper start - Add PlayerAdvancementCriterionGrantEvent
-+            if (!new com.destroystokyo.paper.event.player.PlayerAdvancementCriterionGrantEvent(this.player.getBukkitEntity(), advancement.toBukkit(), criterionName).callEvent()) {
-+                advancementprogress.revokeProgress(criterionName);
-+                return false;
-+            }
-+            // Paper end - Add PlayerAdvancementCriterionGrantEvent
-             this.unregisterListeners(advancement);
-             this.progressChanged.add(advancement);
-             flag = true;

patches/unapplied/server/Add-PlayerArmorChangeEvent.patch

@@ -1,111 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: pkt77 <parkerkt77@gmail.com>
-Date: Fri, 10 Nov 2017 23:46:34 -0500
-Subject: [PATCH] Add PlayerArmorChangeEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-                     throw new MatchException((String) null, (Throwable) null);
-             }
- 
--            ItemStack itemstack2 = itemstack1;
-+            ItemStack itemstack2 = itemstack1; final ItemStack oldEquipment = itemstack2; // Paper - PlayerArmorChangeEvent - obfhelper 
- 
--            itemstack = this.getItemBySlot(enumitemslot);
-+            itemstack = this.getItemBySlot(enumitemslot); final ItemStack newEquipment = itemstack;// Paper - PlayerArmorChangeEvent - obfhelper
-             if (this.equipmentHasChanged(itemstack2, itemstack)) {
-+                // Paper start - PlayerArmorChangeEvent
-+                if (this instanceof ServerPlayer && enumitemslot.getType() == EquipmentSlot.Type.HUMANOID_ARMOR) {
-+                    final org.bukkit.inventory.ItemStack oldItem = CraftItemStack.asBukkitCopy(oldEquipment);
-+                    final org.bukkit.inventory.ItemStack newItem = CraftItemStack.asBukkitCopy(newEquipment);
-+                    new com.destroystokyo.paper.event.player.PlayerArmorChangeEvent((Player) this.getBukkitEntity(), com.destroystokyo.paper.event.player.PlayerArmorChangeEvent.SlotType.valueOf(enumitemslot.name()), oldItem, newItem).callEvent();
-+                }
-+                // Paper end - PlayerArmorChangeEvent
-                 if (map == null) {
-                     map = Maps.newEnumMap(EquipmentSlot.class);
-                 }
-diff --git a/src/test/java/io/papermc/paper/inventory/item/ArmorSlotTypeMaterialTest.java b/src/test/java/io/papermc/paper/inventory/item/ArmorSlotTypeMaterialTest.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/test/java/io/papermc/paper/inventory/item/ArmorSlotTypeMaterialTest.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.inventory.item;
-+
-+import com.destroystokyo.paper.event.player.PlayerArmorChangeEvent;
-+import java.util.ArrayList;
-+import java.util.List;
-+import java.util.stream.Stream;
-+import net.minecraft.core.component.DataComponents;
-+import net.minecraft.world.entity.EquipmentSlot;
-+import net.minecraft.world.item.Item;
-+import net.minecraft.world.item.equipment.Equippable;
-+import org.bukkit.Material;
-+import org.bukkit.craftbukkit.util.CraftMagicNumbers;
-+import org.bukkit.support.environment.AllFeatures;
-+import org.junit.jupiter.params.ParameterizedTest;
-+import org.junit.jupiter.params.provider.MethodSource;
-+
-+import static org.junit.jupiter.api.Assertions.assertEquals;
-+import static org.junit.jupiter.api.Assertions.assertNotNull;
-+import static org.junit.jupiter.api.Assertions.assertTrue;
-+
-+@AllFeatures
-+public class ArmorSlotTypeMaterialTest {
-+
-+    public static Stream<Object[]> slotTypeParams() {
-+        final List<Object[]> parameters = new ArrayList<>();
-+        for (final PlayerArmorChangeEvent.SlotType slotType : PlayerArmorChangeEvent.SlotType.values()) {
-+            for (final Material item : slotType.getTypes()) {
-+                parameters.add(new Object[]{ slotType, item });
-+            }
-+        }
-+        return parameters.stream();
-+    }
-+
-+    @ParameterizedTest(name = "{argumentsWithNames}")
-+    @MethodSource("slotTypeParams")
-+    public void testSlotType(PlayerArmorChangeEvent.SlotType slotType, Material item) {
-+        final Item nmsItem = CraftMagicNumbers.getItem(item);
-+        final Equippable equippable = nmsItem.components().get(DataComponents.EQUIPPABLE);
-+        assertNotNull(equippable, item + " isn't equipable");
-+        final EquipmentSlot slot = switch (slotType) {
-+            case HEAD -> EquipmentSlot.HEAD;
-+            case CHEST -> EquipmentSlot.CHEST;
-+            case LEGS -> EquipmentSlot.LEGS;
-+            case FEET -> EquipmentSlot.FEET;
-+        };
-+        assertEquals(equippable.slot(), slot, item + " isn't set to the right slot");
-+    }
-+
-+    public static Stream<Object[]> equipableParams() {
-+        final List<Object[]> parameters = new ArrayList<>();
-+        for (final Item item : net.minecraft.core.registries.BuiltInRegistries.ITEM) {
-+            final Equippable equippable = item.components().get(DataComponents.EQUIPPABLE);
-+            if (equippable != null) {
-+                parameters.add(new Object[]{equippable, item});
-+            }
-+        }
-+        return parameters.stream();
-+    }
-+
-+    @ParameterizedTest(name = "{argumentsWithNames}")
-+    @MethodSource("equipableParams")
-+    public void testEquipable(Equippable equipable, Item item) {
-+        final EquipmentSlot equipmentSlot = equipable.slot();
-+        PlayerArmorChangeEvent.SlotType slotType = switch (equipmentSlot) {
-+            case HEAD -> PlayerArmorChangeEvent.SlotType.HEAD;
-+            case CHEST -> PlayerArmorChangeEvent.SlotType.CHEST;
-+            case LEGS -> PlayerArmorChangeEvent.SlotType.LEGS;
-+            case FEET -> PlayerArmorChangeEvent.SlotType.FEET;
-+            default -> null;
-+        };
-+        if (slotType != null) {
-+            assertTrue(slotType.getTypes().contains(CraftMagicNumbers.getMaterial(item)), "SlotType " + slotType + " doesn't include " + item);
-+        }
-+    }
-+}

patches/unapplied/server/Add-PlayerJumpEvent.patch

@@ -1,46 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Zach Brown <1254957+zachbr@users.noreply.github.com>
-Date: Thu, 28 Sep 2017 17:21:44 -0400
-Subject: [PATCH] Add PlayerJumpEvent
-
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-                             boolean flag1 = d7 > 0.0D;
- 
-                             if (this.player.onGround() && !packet.isOnGround() && flag1) {
--                                this.player.jumpFromGround();
-+                                // Paper start - Add PlayerJumpEvent
-+                                Player player = this.getCraftPlayer();
-+                                Location from = new Location(player.getWorld(), lastPosX, lastPosY, lastPosZ, lastYaw, lastPitch); // Get the Players previous Event location.
-+                                Location to = player.getLocation().clone(); // Start off the To location as the Players current location.
-+
-+                                // If the packet contains movement information then we update the To location with the correct XYZ.
-+                                if (packet.hasPos) {
-+                                    to.setX(packet.x);
-+                                    to.setY(packet.y);
-+                                    to.setZ(packet.z);
-+                                }
-+
-+                                // If the packet contains look information then we update the To location with the correct Yaw & Pitch.
-+                                if (packet.hasRot) {
-+                                    to.setYaw(packet.yRot);
-+                                    to.setPitch(packet.xRot);
-+                                }
-+
-+                                com.destroystokyo.paper.event.player.PlayerJumpEvent event = new com.destroystokyo.paper.event.player.PlayerJumpEvent(player, from, to);
-+
-+                                if (event.callEvent()) {
-+                                    this.player.jumpFromGround();
-+                                } else {
-+                                    from = event.getFrom();
-+                                    this.internalTeleport(new PositionMoveRotation(org.bukkit.craftbukkit.util.CraftLocation.toVec3D(from), Vec3.ZERO, from.getYaw(), from.getPitch()), Collections.emptySet());
-+                                    return;
-+                                }
-+                                // Paper end - Add PlayerJumpEvent
-                             }
- 
-                             boolean flag2 = this.player.verticalCollisionBelow;

patches/unapplied/server/Add-ProjectileCollideEvent.patch

@@ -1,44 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Techcable <Techcable@outlook.com>
-Date: Fri, 16 Dec 2016 21:25:39 -0600
-Subject: [PATCH] Add ProjectileCollideEvent
-
-Deprecated now and replaced with ProjectileHitEvent
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
-         Bukkit.getPluginManager().callEvent(crafterCraftEvent);
-         return crafterCraftEvent;
-     }
-+    // Paper start
-+    @Deprecated
-+    public static com.destroystokyo.paper.event.entity.ProjectileCollideEvent callProjectileCollideEvent(Entity entity, EntityHitResult position) {
-+        Projectile projectile = (Projectile) entity.getBukkitEntity();
-+        org.bukkit.entity.Entity collided = position.getEntity().getBukkitEntity();
-+        com.destroystokyo.paper.event.entity.ProjectileCollideEvent event = new com.destroystokyo.paper.event.entity.ProjectileCollideEvent(projectile, collided);
-+        Bukkit.getPluginManager().callEvent(event);
-+        return event;
-+    }
-+    // Paper end
- 
-     public static ProjectileLaunchEvent callProjectileLaunchEvent(Entity entity) {
-         Projectile bukkitEntity = (Projectile) entity.getBukkitEntity();
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
-         if (position.getType() == HitResult.Type.ENTITY) {
-             hitEntity = ((EntityHitResult) position).getEntity().getBukkitEntity();
-         }
-+        // Paper start - legacy event
-+        boolean cancelled = false;
-+        if (hitEntity != null && position instanceof EntityHitResult entityHitResult) {
-+            cancelled = callProjectileCollideEvent(entity, entityHitResult).isCancelled();
-+        }
-+        // Paper end
- 
-         ProjectileHitEvent event = new ProjectileHitEvent((Projectile) entity.getBukkitEntity(), hitEntity, hitBlock, hitFace);
-+        event.setCancelled(cancelled); // Paper - propagate legacy event cancellation to modern event
-         entity.level().getCraftServer().getPluginManager().callEvent(event);
-         return event;
-     }

patches/unapplied/server/Add-TNTPrimeEvent.patch

@@ -1,117 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Mark Vainomaa <mikroskeem@mikroskeem.eu>
-Date: Mon, 16 Jul 2018 00:05:05 +0300
-Subject: [PATCH] Add TNTPrimeEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
-+++ b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
-@@ -0,0 +0,0 @@ public class EnderDragon extends Mob implements Enemy {
-                     });
-                     craftBlock.getNMS().spawnAfterBreak((ServerLevel) this.level(), blockposition, ItemStack.EMPTY, false);
-                 }
-+                // Paper start - TNTPrimeEvent
-+                org.bukkit.block.Block tntBlock = CraftBlock.at(this.level(), blockposition);
-+                if (!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.EXPLOSION, explosionSource.getIndirectSourceEntity().getBukkitEntity()).callEvent())
-+                    continue;
-+                // Paper end - TNTPrimeEvent
-                 nmsBlock.wasExploded((ServerLevel) this.level(), blockposition, this.explosionSource);
- 
-                 this.level().removeBlock(blockposition, false);
-diff --git a/src/main/java/net/minecraft/world/level/block/FireBlock.java b/src/main/java/net/minecraft/world/level/block/FireBlock.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/FireBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/FireBlock.java
-@@ -0,0 +0,0 @@ public class FireBlock extends BaseFireBlock {
- 
-                 world.setBlock(blockposition, this.getStateWithAge(world, blockposition, l), 3);
-             } else {
--                world.removeBlock(blockposition, false);
-+                if(iblockdata.getBlock() != Blocks.TNT) world.removeBlock(blockposition, false); // Paper - TNTPrimeEvent; We might be cancelling it below, move the setAir down
-             }
- 
-             Block block = iblockdata.getBlock();
- 
-             if (block instanceof TntBlock) {
-+                // Paper start - TNTPrimeEvent
-+                org.bukkit.block.Block tntBlock = org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition);
-+                if (!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.FIRE, null).callEvent()) {
-+                    return;
-+                }
-+                world.removeBlock(blockposition, false);
-+                // Paper end - TNTPrimeEvent
-                 TntBlock.explode(world, blockposition);
-             }
-         }
-diff --git a/src/main/java/net/minecraft/world/level/block/TntBlock.java b/src/main/java/net/minecraft/world/level/block/TntBlock.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/TntBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/TntBlock.java
-@@ -0,0 +0,0 @@ public class TntBlock extends Block {
-     protected void onPlace(BlockState state, Level world, BlockPos pos, BlockState oldState, boolean notify) {
-         if (!oldState.is(state.getBlock())) {
-             if (world.hasNeighborSignal(pos) && CraftEventFactory.callTNTPrimeEvent(world, pos, PrimeCause.REDSTONE, null, null)) { // CraftBukkit - TNTPrimeEvent
-+                // Paper start - TNTPrimeEvent
-+                org.bukkit.block.Block tntBlock = org.bukkit.craftbukkit.block.CraftBlock.at(world, pos);
-+                if (!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.REDSTONE, null).callEvent()) {
-+                    return;
-+                }
-+                // Paper end - TNTPrimeEvent
-                 TntBlock.explode(world, pos);
-                 world.removeBlock(pos, false);
-             }
-@@ -0,0 +0,0 @@ public class TntBlock extends Block {
-     @Override
-     protected void neighborChanged(BlockState state, Level world, BlockPos pos, Block sourceBlock, @Nullable Orientation wireOrientation, boolean notify) {
-         if (world.hasNeighborSignal(pos) && CraftEventFactory.callTNTPrimeEvent(world, pos, PrimeCause.REDSTONE, null, null)) { // CraftBukkit - TNTPrimeEvent
-+            // Paper start - TNTPrimeEvent
-+            org.bukkit.block.Block tntBlock = org.bukkit.craftbukkit.block.CraftBlock.at(world, pos);
-+            if (!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.REDSTONE, null).callEvent()) {
-+                return;
-+            }
-+            // Paper end - TNTPrimeEvent
-             TntBlock.explode(world, pos);
-             world.removeBlock(pos, false);
-         }
-@@ -0,0 +0,0 @@ public class TntBlock extends Block {
- 
-     @Override
-     public void wasExploded(ServerLevel world, BlockPos pos, Explosion explosion) {
-+        // Paper start - TNTPrimeEvent
-+        org.bukkit.block.Block tntBlock = org.bukkit.craftbukkit.block.CraftBlock.at(world, pos);
-+        org.bukkit.entity.Entity source = explosion.getDirectSourceEntity() != null ? explosion.getDirectSourceEntity().getBukkitEntity() : null;
-+        if (!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.EXPLOSION, source).callEvent()) {
-+            return;
-+        }
-+        // Paper end - TNTPrimeEvent
-         PrimedTnt entitytntprimed = new PrimedTnt(world, (double) pos.getX() + 0.5D, (double) pos.getY(), (double) pos.getZ() + 0.5D, explosion.getIndirectSourceEntity());
-         int i = entitytntprimed.getFuse();
- 
-@@ -0,0 +0,0 @@ public class TntBlock extends Block {
-                 return InteractionResult.CONSUME;
-             }
-             // CraftBukkit end
-+            // Paper start - TNTPrimeEvent
-+            org.bukkit.block.Block tntBlock = org.bukkit.craftbukkit.block.CraftBlock.at(world, pos);
-+            if (!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.ITEM, player.getBukkitEntity()).callEvent()) {
-+                return InteractionResult.FAIL;
-+            }
-+            // Paper end - TNTPrimeEvent
-             TntBlock.explode(world, pos, player);
-             world.setBlock(pos, Blocks.AIR.defaultBlockState(), 11);
-             Item item = stack.getItem();
-@@ -0,0 +0,0 @@ public class TntBlock extends Block {
-                     return;
-                 }
-                 // CraftBukkit end
-+                // Paper start - TNTPrimeEvent
-+                org.bukkit.block.Block tntBlock = org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition);
-+                if (!new com.destroystokyo.paper.event.block.TNTPrimeEvent(tntBlock, com.destroystokyo.paper.event.block.TNTPrimeEvent.PrimeReason.PROJECTILE, projectile.getBukkitEntity()).callEvent()) {
-+                    return;
-+                }
-+                // Paper end - TNTPrimeEvent
-                 TntBlock.explode(world, blockposition, entity instanceof LivingEntity ? (LivingEntity) entity : null);
-                 world.removeBlock(blockposition, false);
-             }

patches/unapplied/server/Add-UnknownCommandEvent.patch

@@ -1,98 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Sweepyoface <github@sweepy.pw>
-Date: Sat, 17 Jun 2017 18:48:21 -0400
-Subject: [PATCH] Add UnknownCommandEvent
-
-Co-authored-by: Jake Potrebic <jake.m.potrebic@gmail.com>
-
-diff --git a/src/main/java/net/minecraft/commands/CommandSourceStack.java b/src/main/java/net/minecraft/commands/CommandSourceStack.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/commands/CommandSourceStack.java
-+++ b/src/main/java/net/minecraft/commands/CommandSourceStack.java
-@@ -0,0 +0,0 @@ public class CommandSourceStack implements ExecutionCommandSource<CommandSourceS
-     }
- 
-     public void sendFailure(Component message) {
-+        // Paper start - Add UnknownCommandEvent
-+        this.sendFailure(message, true);
-+    }
-+    public void sendFailure(Component message, boolean withStyle) {
-+        // Paper end - Add UnknownCommandEvent
-         if (this.source.acceptsFailure() && !this.silent) {
--            this.source.sendSystemMessage(Component.empty().append(message).withStyle(ChatFormatting.RED));
-+            this.source.sendSystemMessage(withStyle ? Component.empty().append(message).withStyle(ChatFormatting.RED) : message); // Paper - Add UnknownCommandEvent
-         }
- 
-     }
-diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/commands/Commands.java
-+++ b/src/main/java/net/minecraft/commands/Commands.java
-@@ -0,0 +0,0 @@ public class Commands {
-         Profiler.get().push(() -> {
-             return "/" + s;
-         });
--        ContextChain<CommandSourceStack> contextchain = Commands.finishParsing(parseresults, s, commandlistenerwrapper, label); // CraftBukkit
-+        ContextChain contextchain = this.finishParsing(parseresults, s, commandlistenerwrapper, label); // CraftBukkit // Paper - Add UnknownCommandEvent
- 
-         try {
-             if (contextchain != null) {
-@@ -0,0 +0,0 @@ public class Commands {
-     }
- 
-     @Nullable
--    private static ContextChain<CommandSourceStack> finishParsing(ParseResults<CommandSourceStack> parseresults, String s, CommandSourceStack commandlistenerwrapper, String label) { // CraftBukkit
-+    private ContextChain<CommandSourceStack> finishParsing(ParseResults<CommandSourceStack> parseresults, String s, CommandSourceStack commandlistenerwrapper, String label) { // CraftBukkit // Paper - Add UnknownCommandEvent
-         try {
-             Commands.validateParseResults(parseresults);
-             return (ContextChain) ContextChain.tryFlatten(parseresults.getContext().build(s)).orElseThrow(() -> {
-                 return CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownCommand().createWithContext(parseresults.getReader());
-             });
-         } catch (CommandSyntaxException commandsyntaxexception) {
--            commandlistenerwrapper.sendFailure(ComponentUtils.fromMessage(commandsyntaxexception.getRawMessage()));
-+            // Paper start - Add UnknownCommandEvent
-+            final net.kyori.adventure.text.TextComponent.Builder builder = net.kyori.adventure.text.Component.text();
-+            // commandlistenerwrapper.sendFailure(ComponentUtils.fromMessage(commandsyntaxexception.getRawMessage()));
-+            builder.color(net.kyori.adventure.text.format.NamedTextColor.RED).append(io.papermc.paper.brigadier.PaperBrigadier.componentFromMessage(commandsyntaxexception.getRawMessage()));
-+            // Paper end - Add UnknownCommandEvent
-             if (commandsyntaxexception.getInput() != null && commandsyntaxexception.getCursor() >= 0) {
-                 int i = Math.min(commandsyntaxexception.getInput().length(), commandsyntaxexception.getCursor());
-                 MutableComponent ichatmutablecomponent = Component.empty().withStyle(ChatFormatting.GRAY).withStyle((chatmodifier) -> {
-@@ -0,0 +0,0 @@ public class Commands {
-                 }
- 
-                 ichatmutablecomponent.append((Component) Component.translatable("command.context.here").withStyle(ChatFormatting.RED, ChatFormatting.ITALIC));
--                commandlistenerwrapper.sendFailure(ichatmutablecomponent);
-+                // Paper start - Add UnknownCommandEvent
-+                // commandlistenerwrapper.sendFailure(ichatmutablecomponent);
-+                builder
-+                    .append(net.kyori.adventure.text.Component.newline())
-+                    .append(io.papermc.paper.adventure.PaperAdventure.asAdventure(ichatmutablecomponent));
-+            }
-+            org.bukkit.event.command.UnknownCommandEvent event = new org.bukkit.event.command.UnknownCommandEvent(commandlistenerwrapper.getBukkitSender(), s, org.spigotmc.SpigotConfig.unknownCommandMessage.isEmpty() ? null : builder.build());
-+            org.bukkit.Bukkit.getServer().getPluginManager().callEvent(event);
-+            if (event.message() != null) {
-+                commandlistenerwrapper.sendFailure(io.papermc.paper.adventure.PaperAdventure.asVanilla(event.message()), false);
-+                // Paper end - Add UnknownCommandEvent
-             }
- 
-             return null;
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
- 
-         // Spigot start
-         if (!org.spigotmc.SpigotConfig.unknownCommandMessage.isEmpty()) {
--            sender.sendMessage(org.spigotmc.SpigotConfig.unknownCommandMessage);
-+            // Paper start
-+            org.bukkit.event.command.UnknownCommandEvent event = new org.bukkit.event.command.UnknownCommandEvent(sender, commandLine, net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(org.spigotmc.SpigotConfig.unknownCommandMessage));
-+            this.getPluginManager().callEvent(event);
-+            if (event.message() != null) {
-+                sender.sendMessage(event.message());
-+            }
-+            // Paper end
-         }
-         // Spigot end
- 

patches/unapplied/server/Add-config-to-disable-ender-dragon-legacy-check.patch

@@ -1,23 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Fri, 22 Jun 2018 10:38:31 -0500
-Subject: [PATCH] Add config to disable ender dragon legacy check
-
-
-diff --git a/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java b/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
-+++ b/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
-@@ -0,0 +0,0 @@ public class EndDragonFight {
-         if (data.isRespawning) {
-             this.respawnStage = DragonRespawnAnimation.START;
-         }
-+        // Paper start - Add config to disable ender dragon legacy check
-+        if (data == EndDragonFight.Data.DEFAULT && !world.paperConfig().entities.spawning.scanForLegacyEnderDragon) {
-+            this.needsStateScanning = false;
-+            this.dragonKilled = true;
-+        }
-+        // Paper end - Add config to disable ender dragon legacy check
- 
-         this.portalLocation = (BlockPos) data.exitPortalLocation.orElse(null); // CraftBukkit - decompile error
-         this.gateways.addAll((Collection) data.gateways.orElseGet(() -> {

patches/unapplied/server/Add-configuration-option-to-prevent-player-names-fro.patch

@@ -1,22 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Riley Park <rileysebastianpark@gmail.com>
-Date: Fri, 9 Jun 2017 07:24:34 -0700
-Subject: [PATCH] Add configuration option to prevent player names from being
- suggested
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-         commandMap.registerServerAliases();
-         return true;
-     }
-+
-+    @Override
-+    public boolean suggestPlayerNamesWhenNullTabCompletions() {
-+        return io.papermc.paper.configuration.GlobalConfiguration.get().commands.suggestPlayerNamesWhenNullTabCompletions;
-+    }
-     // Paper end
- }

patches/unapplied/server/Add-entity-knockback-events.patch

@@ -1,319 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Brokkonaut <hannos17@gmx.de>
-Date: Mon, 18 Jun 2018 15:46:23 +0200
-Subject: [PATCH] Add entity knockback events
-
-- EntityKnockbackEvent
-- EntityPushedByEntityAttackEvent
-- EntityKnockbackByEntityEvent
-
-Co-authored-by: aerulion <aerulion@gmail.com>
-Co-authored-by: Jake Potrebic <jake.m.potrebic@gmail.com>
-
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-     }
- 
-     public void push(double deltaX, double deltaY, double deltaZ) {
--        this.setDeltaMovement(this.getDeltaMovement().add(deltaX, deltaY, deltaZ));
-+        // Paper start - Add EntityKnockbackByEntityEvent and EntityPushedByEntityAttackEvent
-+        this.push(deltaX, deltaY, deltaZ, null);
-+    }
-+
-+    public void push(double deltaX, double deltaY, double deltaZ, @org.jetbrains.annotations.Nullable Entity pushingEntity) {
-+        org.bukkit.util.Vector delta = new org.bukkit.util.Vector(deltaX, deltaY, deltaZ);
-+        if (pushingEntity != null) {
-+            io.papermc.paper.event.entity.EntityPushedByEntityAttackEvent event = new io.papermc.paper.event.entity.EntityPushedByEntityAttackEvent(this.getBukkitEntity(), io.papermc.paper.event.entity.EntityKnockbackEvent.Cause.PUSH, pushingEntity.getBukkitEntity(), delta);
-+            if (!event.callEvent()) {
-+                return;
-+            }
-+            delta = event.getKnockback();
-+        }
-+        this.setDeltaMovement(this.getDeltaMovement().add(delta.getX(), delta.getY(), delta.getZ()));
-+        // Paper end - Add EntityKnockbackByEntityEvent and EntityPushedByEntityAttackEvent
-         this.hasImpulse = true;
-     }
- 
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-                         d1 = source.getSourcePosition().z() - this.getZ();
-                     }
- 
--                    this.knockback(0.4000000059604645D, d0, d1, entity1, entity1 == null ? EntityKnockbackEvent.KnockbackCause.DAMAGE : EntityKnockbackEvent.KnockbackCause.ENTITY_ATTACK); // CraftBukkit
-+                    this.knockback(0.4000000059604645D, d0, d1, entity1, entity1 == null ? io.papermc.paper.event.entity.EntityKnockbackEvent.Cause.DAMAGE : io.papermc.paper.event.entity.EntityKnockbackEvent.Cause.ENTITY_ATTACK); // CraftBukkit // Paper - knockback events
-                     if (!flag) {
-                         this.indicateDamage(d0, d1);
-                     }
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-     }
- 
-     protected void blockedByShield(LivingEntity target) {
--        target.knockback(0.5D, target.getX() - this.getX(), target.getZ() - this.getZ(), null, EntityKnockbackEvent.KnockbackCause.SHIELD_BLOCK); // CraftBukkit
-+        target.knockback(0.5D, target.getX() - this.getX(), target.getZ() - this.getZ(), this, io.papermc.paper.event.entity.EntityKnockbackEvent.Cause.SHIELD_BLOCK); // CraftBukkit // Paper - fix attacker & knockback events
-     }
- 
-     private boolean checkTotemDeathProtection(DamageSource source) {
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
- 
-     public void knockback(double strength, double x, double z) {
-         // CraftBukkit start - EntityKnockbackEvent
--        this.knockback(strength, x, z, null, EntityKnockbackEvent.KnockbackCause.UNKNOWN);
-+        this.knockback(strength, x, z, null, io.papermc.paper.event.entity.EntityKnockbackEvent.Cause.UNKNOWN); // Paper - knockback events
-     }
- 
--    public void knockback(double d0, double d1, double d2, Entity attacker, EntityKnockbackEvent.KnockbackCause cause) {
-+    public void knockback(double d0, double d1, double d2, @Nullable Entity attacker, io.papermc.paper.event.entity.EntityKnockbackEvent.Cause cause) { // Paper - knockback events
-         d0 *= 1.0D - this.getAttributeValue(Attributes.KNOCKBACK_RESISTANCE);
-         if (true || d0 > 0.0D) { // CraftBukkit - Call event even when force is 0
-             //this.hasImpulse = true; // CraftBukkit - Move down
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
- 
-             Vec3 vec3d1 = (new Vec3(d1, 0.0D, d2)).normalize().scale(d0);
- 
--            EntityKnockbackEvent event = CraftEventFactory.callEntityKnockbackEvent((org.bukkit.craftbukkit.entity.CraftLivingEntity) this.getBukkitEntity(), attacker, cause, d0, vec3d1, vec3d.x / 2.0D - vec3d1.x, this.onGround() ? Math.min(0.4D, vec3d.y / 2.0D + d0) : vec3d.y, vec3d.z / 2.0D - vec3d1.z);
-+            // Paper start - knockback events
-+            Vec3 finalVelocity = new Vec3(vec3d.x / 2.0D - vec3d1.x, this.onGround() ? Math.min(0.4D, vec3d.y / 2.0D + d0) : vec3d.y, vec3d.z / 2.0D - vec3d1.z);
-+            Vec3 diff = finalVelocity.subtract(vec3d);
-+            io.papermc.paper.event.entity.EntityKnockbackEvent event = CraftEventFactory.callEntityKnockbackEvent((org.bukkit.craftbukkit.entity.CraftLivingEntity) this.getBukkitEntity(), attacker, attacker, cause, d0, diff);
-+            // Paper end - knockback events
-             if (event.isCancelled()) {
-                 return;
-             }
- 
-             this.hasImpulse = true;
--            this.setDeltaMovement(event.getFinalKnockback().getX(), event.getFinalKnockback().getY(), event.getFinalKnockback().getZ());
-+            this.setDeltaMovement(vec3d.add(event.getKnockback().getX(), event.getKnockback().getY(), event.getKnockback().getZ())); // Paper - knockback events
-             // CraftBukkit end
-         }
-     }
-diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/Mob.java
-+++ b/src/main/java/net/minecraft/world/entity/Mob.java
-@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
- 
-             if (f1 > 0.0F && target instanceof LivingEntity) {
-                 entityliving = (LivingEntity) target;
--                entityliving.knockback((double) (f1 * 0.5F), (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)), this, org.bukkit.event.entity.EntityKnockbackEvent.KnockbackCause.ENTITY_ATTACK); // CraftBukkit
-+                entityliving.knockback((double) (f1 * 0.5F), (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)), this, io.papermc.paper.event.entity.EntityKnockbackEvent.Cause.ENTITY_ATTACK); // CraftBukkit // Paper - knockback events
-                 this.setDeltaMovement(this.getDeltaMovement().multiply(0.6D, 1.0D, 0.6D));
-             }
- 
-diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/RamTarget.java b/src/main/java/net/minecraft/world/entity/ai/behavior/RamTarget.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ai/behavior/RamTarget.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/behavior/RamTarget.java
-@@ -0,0 +0,0 @@ public class RamTarget extends Behavior<Goat> {
-             float f = 0.25F * (float)(i - j);
-             float g = Mth.clamp(entity.getSpeed() * 1.65F, 0.2F, 3.0F) + f;
-             float h = livingEntity.isDamageSourceBlocked(world.damageSources().mobAttack(entity)) ? 0.5F : 1.0F;
--            livingEntity.knockback((double)(h * g) * this.getKnockbackForce.applyAsDouble(entity), this.ramDirection.x(), this.ramDirection.z());
-+            livingEntity.knockback(h * g * this.getKnockbackForce.applyAsDouble(entity), this.ramDirection.x(), this.ramDirection.z(), entity, io.papermc.paper.event.entity.EntityKnockbackEvent.Cause.ENTITY_ATTACK); // Paper - Add EntityKnockbackByEntityEvent and EntityPushedByEntityAttackEvent
-             this.finishRam(world, entity);
-             world.playSound(null, entity, this.getImpactSound.apply(entity), SoundSource.NEUTRAL, 1.0F, 1.0F);
-         } else if (this.hasRammedHornBreakingBlock(world, entity)) {
-diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/warden/SonicBoom.java b/src/main/java/net/minecraft/world/entity/ai/behavior/warden/SonicBoom.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ai/behavior/warden/SonicBoom.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/behavior/warden/SonicBoom.java
-@@ -0,0 +0,0 @@ public class SonicBoom extends Behavior<Warden> {
-                     if (target.hurtServer(world, world.damageSources().sonicBoom(entity), 10.0F)) {
-                         double d = 0.5 * (1.0 - target.getAttributeValue(Attributes.KNOCKBACK_RESISTANCE));
-                         double e = 2.5 * (1.0 - target.getAttributeValue(Attributes.KNOCKBACK_RESISTANCE));
--                        target.push(vec33.x() * e, vec33.y() * d, vec33.z() * e);
-+                        target.push(vec33.x() * e, vec33.y() * d, vec33.z() * e, entity); // Paper - Add EntityKnockbackByEntityEvent and EntityPushedByEntityAttackEvent
-                     }
-                 });
-         }
-diff --git a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
-+++ b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
-@@ -0,0 +0,0 @@ public class EnderDragon extends Mob implements Enemy {
-                 double d3 = entity.getZ() - d1;
-                 double d4 = Math.max(d2 * d2 + d3 * d3, 0.1D);
- 
--                entity.push(d2 / d4 * 4.0D, 0.20000000298023224D, d3 / d4 * 4.0D);
-+                entity.push(d2 / d4 * 4.0D, 0.20000000298023224D, d3 / d4 * 4.0D, this); // Paper - Add EntityKnockbackByEntityEvent and EntityPushedByEntityAttackEvent
-                 if (!this.phaseManager.getCurrentPhase().isSitting() && entityliving.getLastHurtByMobTimestamp() < entity.tickCount - 2) {
-                     DamageSource damagesource = this.damageSources().mobAttack(this);
- 
-diff --git a/src/main/java/net/minecraft/world/entity/decoration/BlockAttachedEntity.java b/src/main/java/net/minecraft/world/entity/decoration/BlockAttachedEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/decoration/BlockAttachedEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/decoration/BlockAttachedEntity.java
-@@ -0,0 +0,0 @@ public abstract class BlockAttachedEntity extends Entity {
-     }
- 
-     @Override
--    public void push(double deltaX, double deltaY, double deltaZ) {
-+    public void push(double deltaX, double deltaY, double deltaZ, @Nullable Entity pushingEntity) { // Paper - override correct overload
-         Level world = this.level();
- 
-         if (world instanceof ServerLevel worldserver) {
-diff --git a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
-+++ b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
-@@ -0,0 +0,0 @@ public class ItemFrame extends HangingEntity {
-     }
- 
-     @Override
--    public void push(double deltaX, double deltaY, double deltaZ) {
-+    public void push(double deltaX, double deltaY, double deltaZ, @org.jetbrains.annotations.Nullable Entity pushingEntity) { // Paper - add push source entity param
-         if (!this.fixed) {
--            super.push(deltaX, deltaY, deltaZ);
-+            super.push(deltaX, deltaY, deltaZ, pushingEntity); // Paper - add push source entity param
-         }
- 
-     }
-diff --git a/src/main/java/net/minecraft/world/entity/monster/Ravager.java b/src/main/java/net/minecraft/world/entity/monster/Ravager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/Ravager.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/Ravager.java
-@@ -0,0 +0,0 @@ public class Ravager extends Raider {
-         double d1 = entity.getZ() - this.getZ();
-         double d2 = Math.max(d0 * d0 + d1 * d1, 0.001D);
- 
--        entity.push(d0 / d2 * 4.0D, 0.2D, d1 / d2 * 4.0D);
-+        entity.push(d0 / d2 * 4.0D, 0.2D, d1 / d2 * 4.0D, this); // Paper - Add EntityKnockbackByEntityEvent and EntityPushedByEntityAttackEvent
-     }
- 
-     @Override
-diff --git a/src/main/java/net/minecraft/world/entity/monster/hoglin/HoglinBase.java b/src/main/java/net/minecraft/world/entity/monster/hoglin/HoglinBase.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/hoglin/HoglinBase.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/hoglin/HoglinBase.java
-@@ -0,0 +0,0 @@ public interface HoglinBase {
-             double j = f * (double)(attacker.level().random.nextFloat() * 0.5F + 0.2F);
-             Vec3 vec3 = new Vec3(g, 0.0, h).normalize().scale(j).yRot(i);
-             double k = f * (double)attacker.level().random.nextFloat() * 0.5;
--            target.push(vec3.x, k, vec3.z);
-+            target.push(vec3.x, k, vec3.z, attacker); // Paper - Add EntityKnockbackByEntityEvent and EntityPushedByEntityAttackEvent
-             target.hurtMarked = true;
-         }
-     }
-diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/player/Player.java
-+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
-@@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
-                             if (target instanceof LivingEntity) {
-                                 LivingEntity entityliving1 = (LivingEntity) target;
- 
--                                entityliving1.knockback((double) (f5 * 0.5F), (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)));
-+                                entityliving1.knockback((double) (f5 * 0.5F), (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)), this, io.papermc.paper.event.entity.EntityKnockbackEvent.Cause.ENTITY_ATTACK); // Paper - knockback events
-                             } else {
--                                target.push((double) (-Mth.sin(this.getYRot() * 0.017453292F) * f5 * 0.5F), 0.1D, (double) (Mth.cos(this.getYRot() * 0.017453292F) * f5 * 0.5F));
-+                                target.push((double) (-Mth.sin(this.getYRot() * 0.017453292F) * f5 * 0.5F), 0.1D, (double) (Mth.cos(this.getYRot() * 0.017453292F) * f5 * 0.5F), this); // Paper - Add EntityKnockbackByEntityEvent and EntityPushedByEntityAttackEvent
-                             }
- 
-                             this.setDeltaMovement(this.getDeltaMovement().multiply(0.6D, 1.0D, 0.6D));
-@@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
-                                         continue;
-                                     }
-                                     // CraftBukkit end
--                                    entityliving2.knockback(0.4000000059604645D, (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)));
-+                                    entityliving2.knockback(0.4000000059604645D, (double) Mth.sin(this.getYRot() * 0.017453292F), (double) (-Mth.cos(this.getYRot() * 0.017453292F)), this, io.papermc.paper.event.entity.EntityKnockbackEvent.Cause.SWEEP_ATTACK); // CraftBukkit // Paper - knockback events
-                                     // entityliving2.hurt(damagesource, f7); // CraftBukkit - moved up
-                                     Level world = this.level();
- 
-diff --git a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
-@@ -0,0 +0,0 @@ public abstract class AbstractArrow extends Projectile {
-             Vec3 vec3d = this.getDeltaMovement().multiply(1.0D, 0.0D, 1.0D).normalize().scale(d0 * 0.6D * d1);
- 
-             if (vec3d.lengthSqr() > 0.0D) {
--                target.push(vec3d.x, 0.1D, vec3d.z);
-+                target.push(vec3d.x, 0.1D, vec3d.z, this); // Paper - Add EntityKnockbackByEntityEvent and EntityPushedByEntityAttackEvent
-             }
-         }
- 
-diff --git a/src/main/java/net/minecraft/world/entity/projectile/windcharge/AbstractWindCharge.java b/src/main/java/net/minecraft/world/entity/projectile/windcharge/AbstractWindCharge.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/projectile/windcharge/AbstractWindCharge.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/windcharge/AbstractWindCharge.java
-@@ -0,0 +0,0 @@ public abstract class AbstractWindCharge extends AbstractHurtingProjectile imple
-     }
- 
-     @Override
--    public void push(double deltaX, double deltaY, double deltaZ) {}
-+    public void push(double deltaX, double deltaY, double deltaZ, @org.jetbrains.annotations.Nullable Entity pushingEntity) {} // Paper - Add EntityKnockbackByEntityEvent and EntityPushedByEntityAttackEvent
- 
-     public abstract void explode(Vec3 pos);
- 
-diff --git a/src/main/java/net/minecraft/world/level/ServerExplosion.java b/src/main/java/net/minecraft/world/level/ServerExplosion.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/ServerExplosion.java
-+++ b/src/main/java/net/minecraft/world/level/ServerExplosion.java
-@@ -0,0 +0,0 @@ public class ServerExplosion implements Explosion {
- 
-                         // CraftBukkit start - Call EntityKnockbackEvent
-                         if (entity instanceof LivingEntity) {
--                            Vec3 result = entity.getDeltaMovement().add(vec3d);
--                            org.bukkit.event.entity.EntityKnockbackEvent event = CraftEventFactory.callEntityKnockbackEvent((org.bukkit.craftbukkit.entity.CraftLivingEntity) entity.getBukkitEntity(), this.source, org.bukkit.event.entity.EntityKnockbackEvent.KnockbackCause.EXPLOSION, d6, vec3d, result.x, result.y, result.z);
--
--                            // SPIGOT-7640: Need to subtract entity movement from the event result,
--                            // since the code below (the setDeltaMovement call as well as the hitPlayers map)
--                            // want the vector to be the relative velocity will the event provides the absolute velocity
--                            vec3d = (event.isCancelled()) ? Vec3.ZERO : new Vec3(event.getFinalKnockback().getX(), event.getFinalKnockback().getY(), event.getFinalKnockback().getZ()).subtract(entity.getDeltaMovement());
-+                           // Paper start - knockback events
-+                           io.papermc.paper.event.entity.EntityKnockbackEvent event = CraftEventFactory.callEntityKnockbackEvent((org.bukkit.craftbukkit.entity.CraftLivingEntity) entity.getBukkitEntity(), this.source, this.damageSource.getEntity() != null ? this.damageSource.getEntity() : this.source, io.papermc.paper.event.entity.EntityKnockbackEvent.Cause.EXPLOSION, d6, vec3d);
-+                            vec3d = event.isCancelled() ? Vec3.ZERO : org.bukkit.craftbukkit.util.CraftVector.toNMS(event.getKnockback());
-+                           // Paper end - knockback events
-                         }
-                         // CraftBukkit end
-                         entity.setDeltaMovement(entity.getDeltaMovement().add(vec3d));
-diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
-         return event;
-     }
- 
--    public static EntityKnockbackEvent callEntityKnockbackEvent(CraftLivingEntity entity, Entity attacker, EntityKnockbackEvent.KnockbackCause cause, double force, Vec3 raw, double x, double y, double z) {
--        Vector bukkitRaw = new Vector(-raw.x, raw.y, -raw.z); // Due to how the knockback calculation works, we need to invert x and z.
-+    // Paper start - replace knockback events
-+    public static io.papermc.paper.event.entity.EntityKnockbackEvent callEntityKnockbackEvent(CraftLivingEntity entity, Entity pusher, Entity attacker, io.papermc.paper.event.entity.EntityKnockbackEvent.Cause cause, double force, Vec3 knockback) {
-+        Vector apiKnockback = CraftVector.toBukkit(knockback);
-+
-+        final Vector currentVelocity = entity.getVelocity();
-+        final Vector legacyFinalKnockback = currentVelocity.clone().add(apiKnockback);
-+        final org.bukkit.event.entity.EntityKnockbackEvent.KnockbackCause legacyCause = org.bukkit.event.entity.EntityKnockbackEvent.KnockbackCause.valueOf(cause.name());
-+        EntityKnockbackEvent legacyEvent;
-+        if (pusher != null) {
-+            legacyEvent = new EntityKnockbackByEntityEvent(entity, pusher.getBukkitEntity(), legacyCause, force, apiKnockback, legacyFinalKnockback);
-+        } else {
-+            legacyEvent = new EntityKnockbackEvent(entity, legacyCause, force, apiKnockback, legacyFinalKnockback);
-+        }
-+        legacyEvent.callEvent();
- 
--        EntityKnockbackEvent event;
-+        final io.papermc.paper.event.entity.EntityKnockbackEvent event;
-+        apiKnockback = legacyEvent.getFinalKnockback().subtract(currentVelocity);
-         if (attacker != null) {
--            event = new EntityKnockbackByEntityEvent(entity, attacker.getBukkitEntity(), cause, force, new Vector(-raw.x, raw.y, -raw.z), new Vector(x, y, z));
-+            event = new com.destroystokyo.paper.event.entity.EntityKnockbackByEntityEvent(entity, attacker.getBukkitEntity(), cause, (float) force, apiKnockback);
-         } else {
--            event = new EntityKnockbackEvent(entity, cause, force, new Vector(-raw.x, raw.y, -raw.z), new Vector(x, y, z));
-+            event = new io.papermc.paper.event.entity.EntityKnockbackEvent(entity, cause, apiKnockback);
-         }
--
--        Bukkit.getPluginManager().callEvent(event);
-+        event.setCancelled(legacyEvent.isCancelled());
-+        event.callEvent();
-         return event;
-     }
-+    // Paper end - replace knockback events
- 
-     public static void callEntityRemoveEvent(Entity entity, EntityRemoveEvent.Cause cause) {
-         if (entity instanceof ServerPlayer) {

patches/unapplied/server/Add-more-Witch-API.patch

@@ -1,101 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Fri, 12 Oct 2018 14:10:46 -0500
-Subject: [PATCH] Add more Witch API
-
-== AT ==
-public net.minecraft.world.entity.monster.Witch usingTime
-
-diff --git a/src/main/java/net/minecraft/world/entity/monster/Witch.java b/src/main/java/net/minecraft/world/entity/monster/Witch.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/Witch.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/Witch.java
-@@ -0,0 +0,0 @@ public class Witch extends Raider implements RangedAttackMob {
-                 }
- 
-                 if (holder != null) {
--                    // Paper start
--                    ItemStack potion = PotionContents.createItemStack(Items.POTION, holder);
--                    potion = org.bukkit.craftbukkit.event.CraftEventFactory.handleWitchReadyPotionEvent(this, potion);
--                    this.setItemSlot(EquipmentSlot.MAINHAND, potion);
--                    // Paper end
--                    this.usingTime = this.getMainHandItem().getUseDuration(this);
--                    this.setUsingItem(true);
--                    if (!this.isSilent()) {
--                        this.level().playSound((Player) null, this.getX(), this.getY(), this.getZ(), SoundEvents.WITCH_DRINK, this.getSoundSource(), 1.0F, 0.8F + this.random.nextFloat() * 0.4F);
--                    }
--
--                    AttributeInstance attributemodifiable = this.getAttribute(Attributes.MOVEMENT_SPEED);
--
--                    attributemodifiable.removeModifier(Witch.SPEED_MODIFIER_DRINKING_ID);
--                    attributemodifiable.addTransientModifier(Witch.SPEED_MODIFIER_DRINKING);
-+                    this.setDrinkingPotion(PotionContents.createItemStack(Items.POTION, holder)); // Paper - logic moved into setDrinkingPotion, copy exact impl into the method and then comment out
-                 }
-             }
- 
-@@ -0,0 +0,0 @@ public class Witch extends Raider implements RangedAttackMob {
-         super.aiStep();
-     }
- 
-+    // Paper start - moved to its own method
-+    public void setDrinkingPotion(ItemStack potion) {
-+        potion = org.bukkit.craftbukkit.event.CraftEventFactory.handleWitchReadyPotionEvent(this, potion);
-+        this.setItemSlot(EquipmentSlot.MAINHAND, potion);
-+        this.usingTime = this.getMainHandItem().getUseDuration(this);
-+        this.setUsingItem(true);
-+        if (!this.isSilent()) {
-+            this.level().playSound((Player) null, this.getX(), this.getY(), this.getZ(), SoundEvents.WITCH_DRINK, this.getSoundSource(), 1.0F, 0.8F + this.random.nextFloat() * 0.4F);
-+        }
-+
-+        AttributeInstance attributemodifiable = this.getAttribute(Attributes.MOVEMENT_SPEED);
-+
-+        attributemodifiable.removeModifier(Witch.SPEED_MODIFIER_DRINKING_ID);
-+        attributemodifiable.addTransientModifier(Witch.SPEED_MODIFIER_DRINKING);
-+    }
-+    // Paper end
-+
-     @Override
-     public SoundEvent getCelebrateSound() {
-         return SoundEvents.WITCH_CELEBRATE;
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java
-@@ -0,0 +0,0 @@ package org.bukkit.craftbukkit.entity;
- 
- import org.bukkit.craftbukkit.CraftServer;
- import org.bukkit.entity.Witch;
-+// Paper start
-+import com.destroystokyo.paper.entity.CraftRangedEntity;
-+import com.google.common.base.Preconditions;
-+import org.bukkit.Material;
-+import org.bukkit.craftbukkit.inventory.CraftItemStack;
-+import org.bukkit.inventory.ItemStack;
-+// Paper end
- 
- public class CraftWitch extends CraftRaider implements Witch, com.destroystokyo.paper.entity.CraftRangedEntity<net.minecraft.world.entity.monster.Witch> { // Paper
-     public CraftWitch(CraftServer server, net.minecraft.world.entity.monster.Witch entity) {
-@@ -0,0 +0,0 @@ public class CraftWitch extends CraftRaider implements Witch, com.destroystokyo.
-     public boolean isDrinkingPotion() {
-         return this.getHandle().isDrinkingPotion();
-     }
-+    // Paper start
-+    public int getPotionUseTimeLeft() {
-+        return getHandle().usingTime;
-+    }
-+
-+    @Override
-+    public void setPotionUseTimeLeft(int ticks) {
-+        getHandle().usingTime = ticks;
-+    }
-+
-+    public ItemStack getDrinkingPotion() {
-+        return CraftItemStack.asCraftMirror(getHandle().getMainHandItem());
-+    }
-+
-+    public void setDrinkingPotion(ItemStack potion) {
-+        Preconditions.checkArgument(potion == null || potion.getType().isEmpty() || potion.getType() == Material.POTION, "must be potion, air, or null");
-+        getHandle().setDrinkingPotion(CraftItemStack.asNMSCopy(potion));
-+    }
-+    // Paper end
- }

patches/unapplied/server/Add-more-fields-to-AsyncPreLoginEvent.patch

@@ -1,72 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sun, 18 Mar 2018 11:45:57 -0400
-Subject: [PATCH] Add more fields to AsyncPreLoginEvent
-
-Co-authored-by: Connor Linfoot <connorlinfoot@me.com>
-Co-authored-by: MCMDEV <john-m.1@gmx.de>
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
-                         try {
-                             GameProfile gameprofile = ServerLoginPacketListenerImpl.this.createOfflineProfile(ServerLoginPacketListenerImpl.this.requestedUsername); // Spigot
- 
--                            ServerLoginPacketListenerImpl.this.callPlayerPreLoginEvents(gameprofile);
-+                            gameprofile = ServerLoginPacketListenerImpl.this.callPlayerPreLoginEvents(gameprofile); // Paper - Add more fields to AsyncPlayerPreLoginEvent
-                             ServerLoginPacketListenerImpl.LOGGER.info("UUID of player {} is {}", gameprofile.getName(), gameprofile.getId());
-                             ServerLoginPacketListenerImpl.this.startClientVerification(gameprofile);
-                         } catch (Exception ex) {
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
-                         if (!ServerLoginPacketListenerImpl.this.connection.isConnected()) {
-                             return;
-                         }
--                        ServerLoginPacketListenerImpl.this.callPlayerPreLoginEvents(gameprofile);
-+                        gameprofile = ServerLoginPacketListenerImpl.this.callPlayerPreLoginEvents(gameprofile); // Paper - Add more fields to AsyncPlayerPreLoginEvent
-                         // CraftBukkit end
-                         ServerLoginPacketListenerImpl.LOGGER.info("UUID of player {} is {}", gameprofile.getName(), gameprofile.getId());
-                         ServerLoginPacketListenerImpl.this.startClientVerification(gameprofile);
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
-     }
- 
-     // CraftBukkit start
--    private void callPlayerPreLoginEvents(GameProfile gameprofile) throws Exception {
-+    private GameProfile callPlayerPreLoginEvents(GameProfile gameprofile) throws Exception { // Paper - Add more fields to AsyncPlayerPreLoginEvent
-         String playerName = gameprofile.getName();
-         java.net.InetAddress address = ((java.net.InetSocketAddress) this.connection.getRemoteAddress()).getAddress();
-         java.util.UUID uniqueId = gameprofile.getId();
-         final org.bukkit.craftbukkit.CraftServer server = ServerLoginPacketListenerImpl.this.server.server;
- 
--        AsyncPlayerPreLoginEvent asyncEvent = new AsyncPlayerPreLoginEvent(playerName, address, uniqueId, this.transferred);
-+        // Paper start - Add more fields to AsyncPlayerPreLoginEvent
-+        final InetAddress rawAddress = ((InetSocketAddress) this.connection.channel.remoteAddress()).getAddress();
-+        com.destroystokyo.paper.profile.PlayerProfile profile = org.bukkit.Bukkit.createProfile(uniqueId, playerName);
-+        AsyncPlayerPreLoginEvent asyncEvent = new AsyncPlayerPreLoginEvent(playerName, address, rawAddress, uniqueId, this.transferred, profile, this.connection.hostname);
-         server.getPluginManager().callEvent(asyncEvent);
-+        profile = asyncEvent.getPlayerProfile();
-+        profile.complete();
-+        gameprofile = com.destroystokyo.paper.profile.CraftPlayerProfile.asAuthlibCopy(profile);
-+        playerName = gameprofile.getName();
-+        uniqueId = gameprofile.getId();
-+        // Paper end - Add more fields to AsyncPlayerPreLoginEvent
- 
-         if (PlayerPreLoginEvent.getHandlerList().getRegisteredListeners().length != 0) {
-             final PlayerPreLoginEvent event = new PlayerPreLoginEvent(playerName, address, uniqueId);
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
-             ServerLoginPacketListenerImpl.this.server.processQueue.add(waitable);
-             if (waitable.get() != PlayerPreLoginEvent.Result.ALLOWED) {
-                 this.disconnect(io.papermc.paper.adventure.PaperAdventure.asVanilla(event.kickMessage())); // Paper - Adventure
--                return;
-             }
-         } else {
-             if (asyncEvent.getLoginResult() != AsyncPlayerPreLoginEvent.Result.ALLOWED) {
-                 this.disconnect(io.papermc.paper.adventure.PaperAdventure.asVanilla(asyncEvent.kickMessage())); // Paper - Adventure
--                return;
-             }
-         }
-+        return gameprofile; // Paper - Add more fields to AsyncPlayerPreLoginEvent
-     }
-     // CraftBukkit end
- 

patches/unapplied/server/Add-openSign-method-to-HumanEntity.patch

@@ -1,23 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Mark Vainomaa <mikroskeem@mikroskeem.eu>
-Date: Sun, 1 Apr 2018 02:29:37 +0300
-Subject: [PATCH] Add openSign method to HumanEntity
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
-@@ -0,0 +0,0 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
-         }
-     }
- 
-+    // Paper start - move open sign method to HumanEntity
-+    @Override
-+    public void openSign(final org.bukkit.block.Sign sign, final org.bukkit.block.sign.Side side) {
-+        org.bukkit.craftbukkit.block.CraftSign.openSign(sign, (CraftPlayer) this, side);
-+    }
-+    // Paper end
-     @Override
-     public boolean dropItem(boolean dropAll) {
-         if (!(this.getHandle() instanceof ServerPlayer)) return false;

patches/unapplied/server/Add-option-to-make-parrots-stay-on-shoulders-despite.patch

@@ -1,45 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Zach Brown <1254957+zachbr@users.noreply.github.com>
-Date: Tue, 16 May 2017 21:29:08 -0500
-Subject: [PATCH] Add option to make parrots stay on shoulders despite movement
-
-Makes parrots not fall off whenever the player changes height, or touches water, or gets hit by a passing leaf.
-Instead, switches the behavior so that players have to sneak to make the birds leave.
-
-I suspect Mojang may switch to this behavior before full release.
-
-To be converted into a Paper-API event at some point in the future?
-
-== AT ==
-public net.minecraft.world.entity.player.Player removeEntitiesOnShoulder()V
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-         switch (packet.getAction()) {
-             case PRESS_SHIFT_KEY:
-                 this.player.setShiftKeyDown(true);
-+
-+                // Paper start - Add option to make parrots stay
-+                if (this.player.level().paperConfig().entities.behavior.parrotsAreUnaffectedByPlayerMovement) {
-+                    this.player.removeEntitiesOnShoulder();
-+                }
-+                // Paper end - Add option to make parrots stay
-+
-                 break;
-             case RELEASE_SHIFT_KEY:
-                 this.player.setShiftKeyDown(false);
-diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/player/Player.java
-+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
-@@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
-         this.playShoulderEntityAmbientSound(this.getShoulderEntityLeft());
-         this.playShoulderEntityAmbientSound(this.getShoulderEntityRight());
-         if (!this.level().isClientSide && (this.fallDistance > 0.5F || this.isInWater()) || this.abilities.flying || this.isSleeping() || this.isInPowderSnow) {
-+            if (!this.level().paperConfig().entities.behavior.parrotsAreUnaffectedByPlayerMovement) // Paper - Add option to make parrots stay
-             this.removeEntitiesOnShoulder();
-         }
- 

patches/unapplied/server/Add-option-to-prevent-players-from-moving-into-unloa.patch

@@ -1,67 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Gabriele C <sgdc3.mail@gmail.com>
-Date: Mon, 22 Oct 2018 17:34:10 +0200
-Subject: [PATCH] Add option to prevent players from moving into unloaded
- chunks #1551
-
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-                 double d0 = entity.getX();
-                 double d1 = entity.getY();
-                 double d2 = entity.getZ();
--                double d3 = ServerGamePacketListenerImpl.clampHorizontal(packet.getX());
--                double d4 = ServerGamePacketListenerImpl.clampVertical(packet.getY());
--                double d5 = ServerGamePacketListenerImpl.clampHorizontal(packet.getZ());
-+                double d3 = ServerGamePacketListenerImpl.clampHorizontal(packet.getX()); final double toX = d3; // Paper - OBFHELPER
-+                double d4 = ServerGamePacketListenerImpl.clampVertical(packet.getY()); final double toY = d4; // Paper - OBFHELPER
-+                double d5 = ServerGamePacketListenerImpl.clampHorizontal(packet.getZ()); final double toZ = d5; // Paper - OBFHELPER
-                 float f = Mth.wrapDegrees(packet.getYRot());
-                 float f1 = Mth.wrapDegrees(packet.getXRot());
-                 double d6 = d3 - this.vehicleFirstGoodX;
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-                 }
-                 speed *= 2f; // TODO: Get the speed of the vehicle instead of the player
- 
-+                // Paper start - Prevent moving into unloaded chunks
-+                if (this.player.level().paperConfig().chunks.preventMovingIntoUnloadedChunks && (
-+                    !worldserver.areChunksLoadedForMove(this.player.getBoundingBox().expandTowards(new Vec3(toX, toY, toZ).subtract(this.player.position()))) ||
-+                        !worldserver.areChunksLoadedForMove(entity.getBoundingBox().expandTowards(new Vec3(toX, toY, toZ).subtract(entity.position())))
-+                    )) {
-+                    this.connection.send(new ClientboundMoveVehiclePacket(entity));
-+                    return;
-+                }
-+                // Paper end - Prevent moving into unloaded chunks
-+
-                 if (d10 - d9 > Math.max(100.0D, Math.pow((double) (org.spigotmc.SpigotConfig.movedTooQuicklyMultiplier * (float) i * speed), 2)) && !this.isSingleplayerOwner()) {
-                 // CraftBukkit end
-                     ServerGamePacketListenerImpl.LOGGER.warn("{} (vehicle of {}) moved too quickly! {},{},{}", new Object[]{entity.getName().getString(), this.player.getName().getString(), d6, d7, d8});
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-                 }
- 
-                 if (!this.updateAwaitingTeleport()) {
--                    double d0 = ServerGamePacketListenerImpl.clampHorizontal(packet.getX(this.player.getX()));
--                    double d1 = ServerGamePacketListenerImpl.clampVertical(packet.getY(this.player.getY()));
--                    double d2 = ServerGamePacketListenerImpl.clampHorizontal(packet.getZ(this.player.getZ()));
-+                    double d0 = ServerGamePacketListenerImpl.clampHorizontal(packet.getX(this.player.getX())); final double toX = d0; // Paper - OBFHELPER
-+                    double d1 = ServerGamePacketListenerImpl.clampVertical(packet.getY(this.player.getY())); final double toY = d1; // Paper - OBFHELPER
-+                    double d2 = ServerGamePacketListenerImpl.clampHorizontal(packet.getZ(this.player.getZ())); final double toZ = d2; // Paper - OBFHELPER
-                     float f = Mth.wrapDegrees(packet.getYRot(this.player.getYRot()));
-                     float f1 = Mth.wrapDegrees(packet.getXRot(this.player.getXRot()));
- 
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-                                 } else {
-                                     speed = this.player.getAbilities().walkingSpeed * 10f;
-                                 }
-+                                // Paper start - Prevent moving into unloaded chunks
-+                                if (this.player.level().paperConfig().chunks.preventMovingIntoUnloadedChunks && (this.player.getX() != toX || this.player.getZ() != toZ) && !worldserver.areChunksLoadedForMove(this.player.getBoundingBox().expandTowards(new Vec3(toX, toY, toZ).subtract(this.player.position())))) {
-+                                    this.internalTeleport(PositionMoveRotation.of(this.player), Collections.emptySet());
-+                                    return;
-+                                }
-+                                // Paper end - Prevent moving into unloaded chunks
- 
-                                 if (this.shouldCheckPlayerMovement(flag)) {
-                                     float f2 = flag ? 300.0F : 100.0F;

patches/unapplied/server/Add-ray-tracing-methods-to-LivingEntity.patch

@@ -1,68 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Mon, 3 Sep 2018 18:20:03 -0500
-Subject: [PATCH] Add ray tracing methods to LivingEntity
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-     }
- 
-     // Paper start - Make shield blocking delay configurable
-+    public HitResult getRayTrace(int maxDistance, ClipContext.Fluid fluidCollisionOption) {
-+        if (maxDistance < 1 || maxDistance > 120) {
-+            throw new IllegalArgumentException("maxDistance must be between 1-120");
-+        }
-+
-+        Vec3 start = new Vec3(getX(), getY() + getEyeHeight(), getZ());
-+        org.bukkit.util.Vector dir = getBukkitEntity().getLocation().getDirection().multiply(maxDistance);
-+        Vec3 end = new Vec3(start.x + dir.getX(), start.y + dir.getY(), start.z + dir.getZ());
-+        ClipContext raytrace = new ClipContext(start, end, ClipContext.Block.OUTLINE, fluidCollisionOption, this);
-+
-+        return this.level().clip(raytrace);
-+    }
-+
-     public int shieldBlockingDelay = this.level().paperConfig().misc.shieldBlockingDelay;
- 
-     public int getShieldBlockingDelay() {
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-@@ -0,0 +0,0 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
-         return blocks.get(0);
-     }
- 
-+    // Paper start
-+    @Override
-+    public Block getTargetBlock(int maxDistance, com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode) {
-+        return this.getTargetBlockExact(maxDistance, fluidMode.bukkit);
-+    }
-+
-+    @Override
-+    public org.bukkit.block.BlockFace getTargetBlockFace(int maxDistance, com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode) {
-+        return this.getTargetBlockFace(maxDistance, fluidMode.bukkit);
-+    }
-+
-+    @Override
-+    public org.bukkit.block.BlockFace getTargetBlockFace(int maxDistance, org.bukkit.FluidCollisionMode fluidMode) {
-+        RayTraceResult result = this.rayTraceBlocks(maxDistance, fluidMode);
-+        return result != null ? result.getHitBlockFace() : null;
-+    }
-+
-+    @Override
-+    public com.destroystokyo.paper.block.TargetBlockInfo getTargetBlockInfo(int maxDistance, com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode) {
-+        RayTraceResult result = this.rayTraceBlocks(maxDistance, fluidMode.bukkit);
-+        if (result != null && result.getHitBlock() != null && result.getHitBlockFace() != null) {
-+            return new com.destroystokyo.paper.block.TargetBlockInfo(result.getHitBlock(), result.getHitBlockFace());
-+        }
-+        return null;
-+    }
-+    // Paper end
-+
-     @Override
-     public List<Block> getLastTwoTargetBlocks(Set<Material> transparent, int maxDistance) {
-         return this.getLineOfSight(transparent, maxDistance, 2);

patches/unapplied/server/Add-setPlayerProfile-API-for-Skulls.patch

@@ -1,103 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Fri, 19 Jan 2018 00:36:25 -0500
-Subject: [PATCH] Add setPlayerProfile API for Skulls
-
-This allows you to create already filled textures on Skulls to avoid texture lookups
-which commonly cause rate limit issues with Mojang API
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftSkull.java b/src/main/java/org/bukkit/craftbukkit/block/CraftSkull.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/block/CraftSkull.java
-+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftSkull.java
-@@ -0,0 +0,0 @@ public class CraftSkull extends CraftBlockEntityState<SkullBlockEntity> implemen
-         }
-     }
- 
-+    // Paper start
-     @Override
-+    public void setPlayerProfile(com.destroystokyo.paper.profile.PlayerProfile profile) {
-+        Preconditions.checkNotNull(profile, "profile");
-+        this.profile = com.destroystokyo.paper.profile.CraftPlayerProfile.asResolvableProfileCopy(profile);
-+    }
-+
-+    @javax.annotation.Nullable
-+    @Override
-+    public com.destroystokyo.paper.profile.PlayerProfile getPlayerProfile() {
-+        return profile != null ? new com.destroystokyo.paper.profile.CraftPlayerProfile(profile) : null;
-+    }
-+    // Paper end
-+
-+    @Override
-+    @Deprecated // Paper
-     public PlayerProfile getOwnerProfile() {
-         if (!this.hasOwner()) {
-             return null;
-@@ -0,0 +0,0 @@ public class CraftSkull extends CraftBlockEntityState<SkullBlockEntity> implemen
-     }
- 
-     @Override
-+    @Deprecated // Paper
-     public void setOwnerProfile(PlayerProfile profile) {
-         if (profile == null) {
-             this.profile = null;
-         } else {
--            this.profile = new ResolvableProfile(CraftPlayerProfile.validateSkullProfile(((CraftPlayerProfile) profile).buildGameProfile()));
-+            this.profile = CraftPlayerProfile.validateSkullProfile(((com.destroystokyo.paper.profile.SharedPlayerProfile) profile).buildResolvableProfile()); // Paper
-         }
-     }
- 
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaSkull.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaSkull.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaSkull.java
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaSkull.java
-@@ -0,0 +0,0 @@ class CraftMetaSkull extends CraftMetaItem implements SkullMeta {
-         return this.hasOwner() ? this.profile.name().orElse(null) : null;
-     }
- 
-+    // Paper start
-+    @Override
-+    public void setPlayerProfile(@org.jetbrains.annotations.Nullable com.destroystokyo.paper.profile.PlayerProfile profile) {
-+        setProfile((profile == null) ? null : com.destroystokyo.paper.profile.CraftPlayerProfile.asResolvableProfileCopy(profile));
-+    }
-+
-+    @org.jetbrains.annotations.Nullable
-+    @Override
-+    public com.destroystokyo.paper.profile.PlayerProfile getPlayerProfile() {
-+        return profile != null ? new com.destroystokyo.paper.profile.CraftPlayerProfile(profile) : null;
-+    }
-+    // Paper end
-+
-     @Override
-     public OfflinePlayer getOwningPlayer() {
-         if (this.hasOwner()) {
-@@ -0,0 +0,0 @@ class CraftMetaSkull extends CraftMetaItem implements SkullMeta {
-     }
- 
-     @Override
-+    @Deprecated // Paper
-     public PlayerProfile getOwnerProfile() {
-         if (!this.hasOwner()) {
-             return null;
-@@ -0,0 +0,0 @@ class CraftMetaSkull extends CraftMetaItem implements SkullMeta {
-     }
- 
-     @Override
-+    @Deprecated // Paper
-     public void setOwnerProfile(PlayerProfile profile) {
--        if (profile instanceof CraftPlayerProfile craftPlayerProfile) {
--            this.setProfile(CraftPlayerProfile.validateSkullProfile(craftPlayerProfile.buildResolvableProfile()));
-+        if (profile instanceof final com.destroystokyo.paper.profile.SharedPlayerProfile sharedProfile) {
-+            this.setProfile(CraftPlayerProfile.validateSkullProfile(sharedProfile.buildResolvableProfile())); // Paper
-         } else {
-             this.setProfile(null);
-         }
-@@ -0,0 +0,0 @@ class CraftMetaSkull extends CraftMetaItem implements SkullMeta {
-         super.serialize(builder);
- 
-         if (this.hasOwner()) {
--            builder.put(CraftMetaSkull.SKULL_OWNER.BUKKIT, new CraftPlayerProfile(this.profile));
-+            builder.put(CraftMetaSkull.SKULL_OWNER.BUKKIT, new com.destroystokyo.paper.profile.CraftPlayerProfile(this.profile)); // Paper
-         }
- 
-         NamespacedKey namespacedKeyNB = this.getNoteBlockSound();

patches/unapplied/server/Add-setting-for-proxy-online-mode-status.patch

@@ -1,74 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Gabriele C <sgdc3.mail@gmail.com>
-Date: Fri, 5 Aug 2016 01:03:08 +0200
-Subject: [PATCH] Add setting for proxy online mode status
-
-TODO: Add isProxyOnlineMode check to Metrics
-
-diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-+++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-@@ -0,0 +0,0 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
-     public boolean enforceSecureProfile() {
-         DedicatedServerProperties dedicatedserverproperties = this.getProperties();
- 
--        return dedicatedserverproperties.enforceSecureProfile && dedicatedserverproperties.onlineMode && this.services.canValidateProfileKeys();
-+        // Paper start - Add setting for proxy online mode status
-+        return dedicatedserverproperties.enforceSecureProfile
-+            && io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode()
-+            && this.services.canValidateProfileKeys();
-+        // Paper end - Add setting for proxy online mode status
-     }
- 
-     @Override
-diff --git a/src/main/java/net/minecraft/server/players/GameProfileCache.java b/src/main/java/net/minecraft/server/players/GameProfileCache.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/players/GameProfileCache.java
-+++ b/src/main/java/net/minecraft/server/players/GameProfileCache.java
-@@ -0,0 +0,0 @@ public class GameProfileCache {
-                 }
-             };
- 
--        if (!org.apache.commons.lang3.StringUtils.isBlank(name)) // Paper - Don't lookup a profile with a blank name
-+        if (!org.apache.commons.lang3.StringUtils.isBlank(name) // Paper - Don't lookup a profile with a blank name
-+                && io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode()) // Paper - Add setting for proxy online mode status
-             repository.findProfilesByNames(new String[]{name}, profilelookupcallback);
-             GameProfile gameprofile = (GameProfile) atomicreference.get();
- 
-@@ -0,0 +0,0 @@ public class GameProfileCache {
-     }
- 
-     private static boolean usesAuthentication() {
--        return GameProfileCache.usesAuthentication;
-+        return io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode(); // Paper - Add setting for proxy online mode status
-     }
- 
-     public void add(GameProfile profile) {
-diff --git a/src/main/java/net/minecraft/server/players/OldUsersConverter.java b/src/main/java/net/minecraft/server/players/OldUsersConverter.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/players/OldUsersConverter.java
-+++ b/src/main/java/net/minecraft/server/players/OldUsersConverter.java
-@@ -0,0 +0,0 @@ public class OldUsersConverter {
-             return new String[i];
-         });
- 
--        if (server.usesAuthentication() || org.spigotmc.SpigotConfig.bungee) { // Spigot: bungee = online mode, for now.
-+        if (server.usesAuthentication() ||
-+            (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode())) { // Spigot: bungee = online mode, for now.  // Paper - Add setting for proxy online mode status
-             server.getProfileRepository().findProfilesByNames(astring, callback);
-         } else {
-             String[] astring1 = astring;
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-         if (result == null) {
-             GameProfile profile = null;
-             // Only fetch an online UUID in online mode
--            if (this.getOnlineMode() || org.spigotmc.SpigotConfig.bungee) { // Spigot: bungee = online mode, for now.
-+            if (this.getOnlineMode() || io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode()) { // Paper - Add setting for proxy online mode status
-                 // This is potentially blocking :(
-                 profile = this.console.getProfileCache().get(name).orElse(null);
-             }

patches/unapplied/server/Add-source-to-PlayerExpChangeEvent.patch

@@ -1,41 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: AlphaBlend <whizkid3000@hotmail.com>
-Date: Thu, 8 Sep 2016 08:48:33 -0700
-Subject: [PATCH] Add source to PlayerExpChangeEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-+++ b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-@@ -0,0 +0,0 @@ public class ExperienceOrb extends Entity {
-                 int i = this.repairPlayerItems(entityplayer, this.value);
- 
-                 if (i > 0) {
--                    player.giveExperiencePoints(CraftEventFactory.callPlayerExpChangeEvent(player, i).getAmount()); // CraftBukkit - this.value -> event.getAmount()
-+                    player.giveExperiencePoints(CraftEventFactory.callPlayerExpChangeEvent(player, this).getAmount()); // CraftBukkit - this.value -> event.getAmount() // Paper - supply experience orb object
-                 }
- 
-                 --this.count;
-diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
-         return event;
-     }
- 
-+    // Paper start - Add orb
-+    public static PlayerExpChangeEvent callPlayerExpChangeEvent(net.minecraft.world.entity.player.Player entity, net.minecraft.world.entity.ExperienceOrb entityOrb) {
-+        Player player = (Player) entity.getBukkitEntity();
-+        ExperienceOrb source = (ExperienceOrb) entityOrb.getBukkitEntity();
-+        int expAmount = source.getExperience();
-+        PlayerExpChangeEvent event = new PlayerExpChangeEvent(player, source, expAmount);
-+        Bukkit.getPluginManager().callEvent(event);
-+        return event;
-+    }
-+    // Paper end
-+
-     public static boolean handleBlockGrowEvent(Level world, BlockPos pos, net.minecraft.world.level.block.state.BlockState block) {
-         return CraftEventFactory.handleBlockGrowEvent(world, pos, block, 3);
-     }

patches/unapplied/server/Add-sun-related-API.patch

@@ -1,42 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Sun, 7 Oct 2018 00:54:21 -0500
-Subject: [PATCH] Add sun related API
-
-== AT ==
-public net.minecraft.world.entity.Mob isSunBurnTick()Z
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor implements World {
-         }
-     }
- 
-+    // Paper start
-+    @Override
-+    public boolean isDayTime() {
-+        return getHandle().isDay();
-+    }
-+    // Paper end
-+
-     @Override
-     public long getGameTime() {
-         return this.world.levelData.getGameTime();
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftMob.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftMob.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftMob.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftMob.java
-@@ -0,0 +0,0 @@ public abstract class CraftMob extends CraftLivingEntity implements Mob {
-     public long getSeed() {
-         return this.getHandle().lootTableSeed;
-     }
-+
-+    // Paper start
-+    @Override
-+    public boolean isInDaylight() {
-+        return getHandle().isSunBurnTick();
-+    }
-+    // Paper end
- }

patches/unapplied/server/Allow-Reloading-of-Command-Aliases.patch

@@ -1,36 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: willies952002 <admin@domnian.com>
-Date: Mon, 28 Nov 2016 10:21:52 -0500
-Subject: [PATCH] Allow Reloading of Command Aliases
-
-Reload the aliases stored in commands.yml
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-         DefaultPermissions.registerCorePermissions();
-         CraftDefaultPermissions.registerCorePermissions();
-     }
-+
-+    @Override
-+    public boolean reloadCommandAliases() {
-+        Set<String> removals = getCommandAliases().keySet().stream()
-+                .map(key -> key.toLowerCase(java.util.Locale.ENGLISH))
-+                .collect(java.util.stream.Collectors.toSet());
-+        getCommandMap().getKnownCommands().keySet().removeIf(removals::contains);
-+        File file = getCommandsConfigFile();
-+        try {
-+            commandsConfiguration.load(file);
-+        } catch (FileNotFoundException ex) {
-+            return false;
-+        } catch (IOException | org.bukkit.configuration.InvalidConfigurationException ex) {
-+            Bukkit.getLogger().log(Level.SEVERE, "Cannot load " + file, ex);
-+            return false;
-+        }
-+        commandMap.registerServerAliases();
-+        return true;
-+    }
-     // Paper end
- }

patches/unapplied/server/Allow-chests-to-be-placed-with-NBT-data.patch

@@ -1,31 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Sat, 8 Sep 2018 18:43:31 -0500
-Subject: [PATCH] Allow chests to be placed with NBT data
-
-
-diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/item/ItemStack.java
-+++ b/src/main/java/net/minecraft/world/item/ItemStack.java
-@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
-                         enuminteractionresult = InteractionResult.FAIL; // cancel placement
-                         // PAIL: Remove this when MC-99075 fixed
-                         placeEvent.getPlayer().updateInventory();
-+                    world.capturedTileEntities.clear(); // Paper - Allow chests to be placed with NBT data; clear out block entities as chests and such will pop loot
-                         // revert back all captured blocks
-                         world.preventPoiUpdated = true; // CraftBukkit - SPIGOT-5710
-                         for (BlockState blockstate : blocks) {
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/ChestBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/ChestBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/ChestBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/ChestBlockEntity.java
-@@ -0,0 +0,0 @@ public class ChestBlockEntity extends RandomizableContainerBlockEntity implement
-     // CraftBukkit start
-     @Override
-     public boolean onlyOpCanSetNbt() {
--        return true;
-+        return false; // Paper - Allow chests to be placed with NBT data
-     }
-     // CraftBukkit end
- }

patches/unapplied/server/Allow-disabling-armor-stand-ticking.patch

@@ -1,145 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Riley Park <rileysebastianpark@gmail.com>
-Date: Wed, 15 Aug 2018 01:26:09 -0700
-Subject: [PATCH] Allow disabling armor stand ticking
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-+++ b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
-     public Rotations leftLegPose;
-     public Rotations rightLegPose;
-     public boolean canMove = true; // Paper
-+    // Paper start - Allow ArmorStands not to tick
-+    public boolean canTick = true;
-+    public boolean canTickSetByAPI = false;
-+    private boolean noTickPoseDirty = false;
-+    private boolean noTickEquipmentDirty = false;
-+    // Paper end - Allow ArmorStands not to tick
- 
-     public ArmorStand(EntityType<? extends ArmorStand> type, Level world) {
-         super(type, world);
-+        if (world != null) this.canTick = world.paperConfig().entities.armorStands.tick; // Paper - Allow ArmorStands not to tick
-         this.handItems = NonNullList.withSize(2, ItemStack.EMPTY);
-         this.armorItems = NonNullList.withSize(4, ItemStack.EMPTY);
-         this.headPose = ArmorStand.DEFAULT_HEAD_POSE;
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
-                 this.onEquipItem(enumitemslot, (ItemStack) this.armorItems.set(enumitemslot.getIndex(), itemstack), itemstack, silent); // CraftBukkit
-         }
- 
-+        this.noTickEquipmentDirty = true; // Paper - Allow ArmorStands not to tick; Still update equipment
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
-         }
- 
-         nbt.put("Pose", this.writePose());
-+        if (this.canTickSetByAPI) nbt.putBoolean("Paper.CanTickOverride", this.canTick); // Paper - Allow ArmorStands not to tick
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
-         this.setNoBasePlate(nbt.getBoolean("NoBasePlate"));
-         this.setMarker(nbt.getBoolean("Marker"));
-         this.noPhysics = !this.hasPhysics();
-+        // Paper start - Allow ArmorStands not to tick
-+        if (nbt.contains("Paper.CanTickOverride")) {
-+            this.canTick = nbt.getBoolean("Paper.CanTickOverride");
-+            this.canTickSetByAPI = true;
-+        }
-+        // Paper end - Allow ArmorStands not to tick
-         CompoundTag nbttagcompound2 = nbt.getCompound("Pose");
- 
-         this.readPose(nbttagcompound2);
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
- 
-     @Override
-     public void tick() {
-+        // Paper start - Allow ArmorStands not to tick
-+        if (!this.canTick) {
-+            if (this.noTickPoseDirty) {
-+                this.noTickPoseDirty = false;
-+                this.updatePose();
-+            }
-+
-+            if (this.noTickEquipmentDirty) {
-+                this.noTickEquipmentDirty = false;
-+                this.detectEquipmentUpdatesPublic();
-+            }
-+
-+            return;
-+        }
-+        // Paper end - Allow ArmorStands not to tick
-+
-         super.tick();
-+        // Paper start - Allow ArmorStands not to tick
-+        updatePose();
-+    }
-+
-+    public void updatePose() {
-+        // Paper end - Allow ArmorStands not to tick
-         Rotations vector3f = (Rotations) this.entityData.get(ArmorStand.DATA_HEAD_POSE);
- 
-         if (!this.headPose.equals(vector3f)) {
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
-     public void setHeadPose(Rotations angle) {
-         this.headPose = angle;
-         this.entityData.set(ArmorStand.DATA_HEAD_POSE, angle);
-+        this.noTickPoseDirty = true; // Paper - Allow updates when not ticking
-     }
- 
-     public void setBodyPose(Rotations angle) {
-         this.bodyPose = angle;
-         this.entityData.set(ArmorStand.DATA_BODY_POSE, angle);
-+        this.noTickPoseDirty = true; // Paper - Allow updates when not ticking
-     }
- 
-     public void setLeftArmPose(Rotations angle) {
-         this.leftArmPose = angle;
-         this.entityData.set(ArmorStand.DATA_LEFT_ARM_POSE, angle);
-+        this.noTickPoseDirty = true; // Paper - Allow updates when not ticking
-     }
- 
-     public void setRightArmPose(Rotations angle) {
-         this.rightArmPose = angle;
-         this.entityData.set(ArmorStand.DATA_RIGHT_ARM_POSE, angle);
-+        this.noTickPoseDirty = true; // Paper - Allow updates when not ticking
-     }
- 
-     public void setLeftLegPose(Rotations angle) {
-         this.leftLegPose = angle;
-         this.entityData.set(ArmorStand.DATA_LEFT_LEG_POSE, angle);
-+        this.noTickPoseDirty = true; // Paper - Allow updates when not ticking
-     }
- 
-     public void setRightLegPose(Rotations angle) {
-         this.rightLegPose = angle;
-         this.entityData.set(ArmorStand.DATA_RIGHT_LEG_POSE, angle);
-+        this.noTickPoseDirty = true; // Paper - Allow updates when not ticking
-     }
- 
-     public Rotations getHeadPose() {
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
-@@ -0,0 +0,0 @@ public class CraftArmorStand extends CraftLivingEntity implements ArmorStand {
-     public void setCanMove(boolean move) {
-         getHandle().canMove = move;
-     }
-+
-+    @Override
-+    public boolean canTick() {
-+        return this.getHandle().canTick;
-+    }
-+
-+    @Override
-+    public void setCanTick(final boolean tick) {
-+        this.getHandle().canTick = tick;
-+        this.getHandle().canTickSetByAPI = true;
-+    }
-     // Paper end
- }

patches/unapplied/server/Allow-specifying-a-custom-authentication-servers-dow.patch

@@ -1,20 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Riley Park <rileysebastianpark@gmail.com>
-Date: Thu, 17 Aug 2017 16:08:20 -0700
-Subject: [PATCH] Allow specifying a custom "authentication servers down" kick
- message
-
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
-                         ServerLoginPacketListenerImpl.LOGGER.warn("Authentication servers are down but will let them in anyway!");
-                         ServerLoginPacketListenerImpl.this.startClientVerification(ServerLoginPacketListenerImpl.this.createOfflineProfile(s1)); // Spigot
-                     } else {
--                        ServerLoginPacketListenerImpl.this.disconnect(Component.translatable("multiplayer.disconnect.authservers_down"));
-+                        ServerLoginPacketListenerImpl.this.disconnect(io.papermc.paper.adventure.PaperAdventure.asVanilla(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.authenticationServersDown)); // Paper - Configurable kick message
-                         ServerLoginPacketListenerImpl.LOGGER.error("Couldn't verify username because servers are unavailable");
-                     }
-                     // CraftBukkit start - catch all exceptions

patches/unapplied/server/AnvilDamageEvent.patch

@@ -1,27 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Fri, 20 Jul 2018 23:37:03 -0500
-Subject: [PATCH] AnvilDamageEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/inventory/AnvilMenu.java b/src/main/java/net/minecraft/world/inventory/AnvilMenu.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/inventory/AnvilMenu.java
-+++ b/src/main/java/net/minecraft/world/inventory/AnvilMenu.java
-@@ -0,0 +0,0 @@ public class AnvilMenu extends ItemCombinerMenu {
-             if (!player.hasInfiniteMaterials() && iblockdata.is(BlockTags.ANVIL) && player.getRandom().nextFloat() < 0.12F) {
-                 BlockState iblockdata1 = AnvilBlock.damage(iblockdata);
- 
-+                // Paper start - AnvilDamageEvent
-+                com.destroystokyo.paper.event.block.AnvilDamagedEvent event = new com.destroystokyo.paper.event.block.AnvilDamagedEvent(getBukkitView(), iblockdata1 != null ? org.bukkit.craftbukkit.block.data.CraftBlockData.fromData(iblockdata1) : null);
-+                if (!event.callEvent()) {
-+                    return;
-+                } else if (event.getDamageState() == com.destroystokyo.paper.event.block.AnvilDamagedEvent.DamageState.BROKEN) {
-+                    iblockdata1 = null;
-+                } else {
-+                    iblockdata1 = ((org.bukkit.craftbukkit.block.data.CraftBlockData) event.getDamageState().getMaterial().createBlockData()).getState().setValue(AnvilBlock.FACING, iblockdata.getValue(AnvilBlock.FACING));
-+                }
-+                // Paper end - AnvilDamageEvent
-                 if (iblockdata1 == null) {
-                     world.removeBlock(blockposition, false);
-                     world.levelEvent(1029, blockposition, 0);

patches/unapplied/server/AsyncTabCompleteEvent.patch

@@ -1,176 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
-Date: Sun, 26 Nov 2017 13:19:58 -0500
-Subject: [PATCH] AsyncTabCompleteEvent
-
-Let plugins be able to control tab completion of commands and chat async.
-
-This will be useful for frameworks like ACF so we can define async safe completion handlers,
-and avoid going to main for tab completions.
-
-Especially useful if you need to query a database in order to obtain the results for tab
-completion, such as offline players.
-
-Also adds isCommand and getLocation to the sync TabCompleteEvent
-
-Co-authored-by: Aikar <aikar@aikar.co>
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
- 
-     }
- 
-+    // Paper start - AsyncTabCompleteEvent
-+    private static final java.util.concurrent.ExecutorService TAB_COMPLETE_EXECUTOR = java.util.concurrent.Executors.newFixedThreadPool(4,
-+        new com.google.common.util.concurrent.ThreadFactoryBuilder().setDaemon(true).setNameFormat("Async Tab Complete Thread - #%d").setUncaughtExceptionHandler(new net.minecraft.DefaultUncaughtExceptionHandlerWithName(net.minecraft.server.MinecraftServer.LOGGER)).build());
-+    // Paper end - AsyncTabCompleteEvent
-     @Override
-     public void handleCustomCommandSuggestions(ServerboundCommandSuggestionPacket packet) {
--        PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel());
-+        // PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel()); // Paper - AsyncTabCompleteEvent; run this async
-         // CraftBukkit start
-         if (!this.chatSpamThrottler.isIncrementAndUnderThreshold(1, 500) && !this.server.getPlayerList().isOp(this.player.getGameProfile()) && !this.server.isSingleplayerOwner(this.player.getGameProfile())) {
-             this.disconnect(Component.translatable("disconnect.spam"));
-             return;
-         }
-         // CraftBukkit end
-+        // Paper start - AsyncTabCompleteEvent
-+        TAB_COMPLETE_EXECUTOR.execute(() -> this.handleCustomCommandSuggestions0(packet));
-+    }
-+
-+    private void handleCustomCommandSuggestions0(final ServerboundCommandSuggestionPacket packet) {
-         StringReader stringreader = new StringReader(packet.getCommand());
- 
-         if (stringreader.canRead() && stringreader.peek() == '/') {
-             stringreader.skip();
-         }
- 
-+        final com.destroystokyo.paper.event.server.AsyncTabCompleteEvent event = new com.destroystokyo.paper.event.server.AsyncTabCompleteEvent(this.getCraftPlayer(), packet.getCommand(), true, null);
-+        event.callEvent();
-+        final List<com.destroystokyo.paper.event.server.AsyncTabCompleteEvent.Completion> completions = event.isCancelled() ? com.google.common.collect.ImmutableList.of() : event.completions();
-+        // If the event isn't handled, we can assume that we have no completions, and so we'll ask the server
-+        if (!event.isHandled()) {
-+            if (event.isCancelled()) {
-+                return;
-+            }
-+
-+            // This needs to be on main
-+            this.server.scheduleOnMain(() -> this.sendServerSuggestions(packet, stringreader));
-+        } else if (!completions.isEmpty()) {
-+            final com.mojang.brigadier.suggestion.SuggestionsBuilder builder0 = new com.mojang.brigadier.suggestion.SuggestionsBuilder(packet.getCommand(), stringreader.getTotalLength());
-+            final com.mojang.brigadier.suggestion.SuggestionsBuilder builder = builder0.createOffset(builder0.getInput().lastIndexOf(' ') + 1);
-+            for (final com.destroystokyo.paper.event.server.AsyncTabCompleteEvent.Completion completion : completions) {
-+                final Integer intSuggestion = com.google.common.primitives.Ints.tryParse(completion.suggestion());
-+                if (intSuggestion != null) {
-+                    builder.suggest(intSuggestion, PaperAdventure.asVanilla(completion.tooltip()));
-+                } else {
-+                    builder.suggest(completion.suggestion(), PaperAdventure.asVanilla(completion.tooltip()));
-+                }
-+            }
-+            this.connection.send(new ClientboundCommandSuggestionsPacket(packet.getId(), builder.buildFuture().join()));
-+        }
-+    }
-+
-+    private void sendServerSuggestions(final ServerboundCommandSuggestionPacket packet, final StringReader stringreader) {
-+        // Paper end - AsyncTabCompleteEvent
-         ParseResults<CommandSourceStack> parseresults = this.server.getCommands().getDispatcher().parse(stringreader, this.player.createCommandSourceStack());
- 
-         this.server.getCommands().getDispatcher().getCompletionSuggestions(parseresults).thenAccept((suggestions) -> {
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-             offers = this.tabCompleteChat(player, message);
-         }
- 
--        TabCompleteEvent tabEvent = new TabCompleteEvent(player, message, offers);
-+        TabCompleteEvent tabEvent = new TabCompleteEvent(player, message, offers, message.startsWith("/") || forceCommand, pos != null ? io.papermc.paper.util.MCUtil.toLocation(((CraftWorld) player.getWorld()).getHandle(), BlockPos.containing(pos)) : null); // Paper - AsyncTabCompleteEvent
-         this.getPluginManager().callEvent(tabEvent);
- 
-         return tabEvent.isCancelled() ? Collections.EMPTY_LIST : tabEvent.getCompletions();
-diff --git a/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java b/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java
-+++ b/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java
-@@ -0,0 +0,0 @@ public class ConsoleCommandCompleter implements Completer {
-     public void complete(LineReader reader, ParsedLine line, List<Candidate> candidates) {
-         final CraftServer server = this.server.server;
-         final String buffer = "/" + line.line();
-+        // Async Tab Complete
-+        final com.destroystokyo.paper.event.server.AsyncTabCompleteEvent event =
-+            new com.destroystokyo.paper.event.server.AsyncTabCompleteEvent(server.getConsoleSender(), buffer, true, null);
-+        event.callEvent();
-+        final List<com.destroystokyo.paper.event.server.AsyncTabCompleteEvent.Completion> completions = event.isCancelled() ? com.google.common.collect.ImmutableList.of() : event.completions();
-+
-+        if (event.isCancelled() || event.isHandled()) {
-+            // Still fire sync event with the provided completions, if someone is listening
-+            if (!event.isCancelled() && TabCompleteEvent.getHandlerList().getRegisteredListeners().length > 0) {
-+                List<com.destroystokyo.paper.event.server.AsyncTabCompleteEvent.Completion> finalCompletions = new java.util.ArrayList<>(completions);
-+                Waitable<List<String>> syncCompletions = new Waitable<List<String>>() {
-+                    @Override
-+                    protected List<String> evaluate() {
-+                        org.bukkit.event.server.TabCompleteEvent syncEvent = new org.bukkit.event.server.TabCompleteEvent(server.getConsoleSender(), buffer,
-+                            finalCompletions.stream()
-+                                .map(com.destroystokyo.paper.event.server.AsyncTabCompleteEvent.Completion::suggestion)
-+                                .collect(java.util.stream.Collectors.toList()));
-+                        return syncEvent.callEvent() ? syncEvent.getCompletions() : com.google.common.collect.ImmutableList.of();
-+                    }
-+                };
-+                server.getServer().processQueue.add(syncCompletions);
-+                try {
-+                    final List<String> legacyCompletions = syncCompletions.get();
-+                    completions.removeIf(it -> !legacyCompletions.contains(it.suggestion())); // remove any suggestions that were removed
-+                    // add any new suggestions
-+                    for (final String completion : legacyCompletions) {
-+                        if (notNewSuggestion(completions, completion)) {
-+                            continue;
-+                        }
-+                        completions.add(com.destroystokyo.paper.event.server.AsyncTabCompleteEvent.Completion.completion(completion));
-+                    }
-+                } catch (InterruptedException | ExecutionException e1) {
-+                    e1.printStackTrace();
-+                }
-+            }
-+
-+            if (!completions.isEmpty()) {
-+                for (final com.destroystokyo.paper.event.server.AsyncTabCompleteEvent.Completion completion : completions) {
-+                    if (completion.suggestion().isEmpty()) {
-+                        continue;
-+                    }
-+                    candidates.add(new Candidate(
-+                        completion.suggestion(),
-+                        completion.suggestion(),
-+                        null,
-+                        io.papermc.paper.adventure.PaperAdventure.PLAIN.serializeOr(completion.tooltip(), null),
-+                        null,
-+                        null,
-+                        false
-+                    ));
-+                }
-+            }
-+            return;
-+        }
-+
-         // Paper end
-         Waitable<List<String>> waitable = new Waitable<List<String>>() {
-             @Override
-@@ -0,0 +0,0 @@ public class ConsoleCommandCompleter implements Completer {
-             Thread.currentThread().interrupt();
-         }
-     }
-+
-+    // Paper start
-+    private boolean notNewSuggestion(final List<com.destroystokyo.paper.event.server.AsyncTabCompleteEvent.Completion> completions, final String completion) {
-+        for (final com.destroystokyo.paper.event.server.AsyncTabCompleteEvent.Completion it : completions) {
-+            if (it.suggestion().equals(completion)) {
-+                return true;
-+            }
-+        }
-+        return false;
-+    }
-+    // Paper end
- }

patches/unapplied/server/Avoid-blocking-on-Network-Manager-creation.patch

@@ -1,45 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Mon, 16 May 2016 23:19:16 -0400
-Subject: [PATCH] Avoid blocking on Network Manager creation
-
-Per Paper issue 294
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerConnectionListener.java b/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
-+++ b/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
-@@ -0,0 +0,0 @@ public class ServerConnectionListener {
-     public volatile boolean running;
-     private final List<ChannelFuture> channels = Collections.synchronizedList(Lists.newArrayList());
-     final List<Connection> connections = Collections.synchronizedList(Lists.newArrayList());
-+    // Paper start - prevent blocking on adding a new connection while the server is ticking
-+    private final java.util.Queue<Connection> pending = new java.util.concurrent.ConcurrentLinkedQueue<>();
-+    private final void addPending() {
-+        Connection connection;
-+        while ((connection = pending.poll()) != null) {
-+            connections.add(connection);
-+        }
-+    }
-+    // Paper end - prevent blocking on adding a new connection while the server is ticking
- 
-     public ServerConnectionListener(MinecraftServer server) {
-         this.server = server;
-@@ -0,0 +0,0 @@ public class ServerConnectionListener {
-                     int j = ServerConnectionListener.this.server.getRateLimitPacketsPerSecond();
-                     Connection object = j > 0 ? new RateKickingConnection(j) : new Connection(PacketFlow.SERVERBOUND); // CraftBukkit - decompile error
- 
--                    ServerConnectionListener.this.connections.add(object);
-+                    //ServerConnectionListener.this.connections.add(object); // Paper
-+                    pending.add(object); // Paper - prevent blocking on adding a new connection while the server is ticking
-                     ((Connection) object).configurePacketHandler(channelpipeline);
-                     ((Connection) object).setListenerForServerboundHandshake(new ServerHandshakePacketListenerImpl(ServerConnectionListener.this.server, (Connection) object));
-                 }
-@@ -0,0 +0,0 @@ public class ServerConnectionListener {
- 
-         synchronized (this.connections) {
-             // Spigot Start
-+            this.addPending(); // Paper - prevent blocking on adding a new connection while the server is ticking
-             // This prevents players from 'gaming' the server, and strategically relogging to increase their position in the tick order
-             if ( org.spigotmc.SpigotConfig.playerShuffle > 0 && MinecraftServer.currentTick % org.spigotmc.SpigotConfig.playerShuffle == 0 )
-             {

patches/unapplied/server/Basic-PlayerProfile-API.patch

@@ -1,767 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Mon, 15 Jan 2018 22:11:48 -0500
-Subject: [PATCH] Basic PlayerProfile API
-
-Establishes base extension of profile systems for future edits too
-
-== AT ==
-public org.bukkit.craftbukkit.profile.CraftProfileProperty
-public org.bukkit.craftbukkit.profile.CraftPlayerTextures
-public org.bukkit.craftbukkit.profile.CraftPlayerTextures copyFrom(Lorg/bukkit/profile/PlayerTextures;)V
-public org.bukkit.craftbukkit.profile.CraftPlayerTextures rebuildPropertyIfDirty()V
-public org.bukkit.craftbukkit.profile.CraftPlayerProfile toString(Lcom/mojang/authlib/properties/PropertyMap;)Ljava/lang/String;
-public org.bukkit.craftbukkit.profile.CraftPlayerProfile getProperty(Ljava/lang/String;)Lcom/mojang/authlib/properties/Property;
-public org.bukkit.craftbukkit.profile.CraftPlayerProfile setProperty(Ljava/lang/String;Lcom/mojang/authlib/properties/Property;)V
-
-diff --git a/src/main/java/com/destroystokyo/paper/profile/CraftPlayerProfile.java b/src/main/java/com/destroystokyo/paper/profile/CraftPlayerProfile.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/profile/CraftPlayerProfile.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.profile;
-+
-+import com.google.common.base.Preconditions;
-+import com.mojang.authlib.yggdrasil.ProfileResult;
-+import io.papermc.paper.configuration.GlobalConfiguration;
-+import com.google.common.base.Charsets;
-+import com.google.common.collect.Iterables;
-+import com.mojang.authlib.GameProfile;
-+import com.mojang.authlib.properties.Property;
-+import com.mojang.authlib.properties.PropertyMap;
-+import net.minecraft.Util;
-+import net.minecraft.server.MinecraftServer;
-+import net.minecraft.server.players.GameProfileCache;
-+import net.minecraft.util.StringUtil;
-+import net.minecraft.world.item.component.ResolvableProfile;
-+import org.apache.commons.lang3.StringUtils;
-+import org.apache.commons.lang3.Validate;
-+import org.bukkit.configuration.serialization.SerializableAs;
-+import org.bukkit.craftbukkit.configuration.ConfigSerializationUtil;
-+import org.bukkit.craftbukkit.entity.CraftPlayer;
-+import org.bukkit.craftbukkit.profile.CraftPlayerTextures;
-+import org.bukkit.craftbukkit.profile.CraftProfileProperty;
-+import org.bukkit.profile.PlayerTextures;
-+import org.jetbrains.annotations.NotNull;
-+
-+import javax.annotation.Nonnull;
-+import javax.annotation.Nullable;
-+import java.util.*;
-+import java.util.concurrent.CompletableFuture;
-+
-+@SerializableAs("PlayerProfile")
-+public class CraftPlayerProfile implements PlayerProfile, SharedPlayerProfile {
-+
-+    private boolean emptyName;
-+    private boolean emptyUUID;
-+    private GameProfile profile;
-+    private final PropertySet properties = new PropertySet();
-+
-+    public CraftPlayerProfile(CraftPlayer player) {
-+        this.profile = player.getHandle().getGameProfile();
-+    }
-+
-+    public CraftPlayerProfile(UUID id, String name) {
-+        this.profile = createAuthLibProfile(id, name);
-+        this.emptyName = name == null;
-+        this.emptyUUID = id == null;
-+    }
-+
-+    public CraftPlayerProfile(GameProfile profile) {
-+        Validate.notNull(profile, "GameProfile cannot be null!");
-+        this.profile = profile;
-+    }
-+
-+    public CraftPlayerProfile(ResolvableProfile resolvableProfile) {
-+        this(resolvableProfile.id().orElse(null), resolvableProfile.name().orElse(null));
-+        copyProfileProperties(resolvableProfile.gameProfile(), this.profile);
-+    }
-+
-+    @Override
-+    public boolean hasProperty(String property) {
-+        return profile.getProperties().containsKey(property);
-+    }
-+
-+    @Override
-+    public void setProperty(ProfileProperty property) {
-+        String name = property.getName();
-+        PropertyMap properties = profile.getProperties();
-+        properties.removeAll(name);
-+
-+        Preconditions.checkArgument(properties.size() < 16, "Cannot add more than 16 properties to a profile");
-+        properties.put(name, new Property(name, property.getValue(), property.getSignature()));
-+    }
-+
-+    @Override
-+    public CraftPlayerTextures getTextures() {
-+        return new CraftPlayerTextures(this);
-+    }
-+
-+    @Override
-+    public void setTextures(@Nullable PlayerTextures textures) {
-+        if (textures == null) {
-+            this.removeProperty("textures");
-+        } else {
-+            CraftPlayerTextures craftPlayerTextures = new CraftPlayerTextures(this);
-+            craftPlayerTextures.copyFrom(textures);
-+            craftPlayerTextures.rebuildPropertyIfDirty();
-+        }
-+    }
-+
-+    public GameProfile getGameProfile() {
-+        return profile;
-+    }
-+
-+    @Nullable
-+    @Override
-+    public UUID getId() {
-+        return this.emptyUUID ? null : this.profile.getId();
-+    }
-+
-+    @Override
-+    @Deprecated(forRemoval = true)
-+    public UUID setId(@Nullable UUID uuid) {
-+        final GameProfile previousProfile = this.profile;
-+        final UUID previousId = this.getId();
-+        this.profile = createAuthLibProfile(uuid, previousProfile.getName());
-+        copyProfileProperties(previousProfile, this.profile);
-+        this.emptyUUID = uuid == null;
-+        return previousId;
-+    }
-+
-+    @Override
-+    public UUID getUniqueId() {
-+        return getId();
-+    }
-+
-+    @Nullable
-+    @Override
-+    public String getName() {
-+        return this.emptyName ? null : this.profile.getName();
-+    }
-+
-+    @Override
-+    @Deprecated(forRemoval = true)
-+    public String setName(@Nullable String name) {
-+        GameProfile prev = this.profile;
-+        this.profile = createAuthLibProfile(prev.getId(), name);
-+        copyProfileProperties(prev, this.profile);
-+        this.emptyName = name == null;
-+        return prev.getName();
-+    }
-+
-+    @Nonnull
-+    @Override
-+    public Set<ProfileProperty> getProperties() {
-+        return properties;
-+    }
-+
-+    @Override
-+    public void setProperties(Collection<ProfileProperty> properties) {
-+        properties.forEach(this::setProperty);
-+    }
-+
-+    @Override
-+    public void clearProperties() {
-+        profile.getProperties().clear();
-+    }
-+
-+    @Override
-+    public boolean removeProperty(String property) {
-+        return !profile.getProperties().removeAll(property).isEmpty();
-+    }
-+
-+    @Nullable
-+    @Override
-+    public Property getProperty(String property) {
-+        return Iterables.getFirst(this.profile.getProperties().get(property), null);
-+    }
-+
-+    @Nullable
-+    @Override
-+    public void setProperty(@NotNull String propertyName, @Nullable Property property) {
-+        if (property != null) {
-+            this.setProperty(new ProfileProperty(propertyName, property.value(), property.signature()));
-+        } else {
-+            profile.getProperties().removeAll(propertyName);
-+        }
-+    }
-+
-+    @Override
-+    public @NotNull GameProfile buildGameProfile() {
-+        GameProfile profile = new GameProfile(this.profile.getId(), this.profile.getName());
-+        profile.getProperties().putAll(this.profile.getProperties());
-+        return profile;
-+    }
-+
-+    @Override
-+    public @NotNull ResolvableProfile buildResolvableProfile() {
-+        if (this.emptyName || this.emptyUUID) {
-+            return new ResolvableProfile(this.emptyName ? Optional.empty() : Optional.of(this.profile.getName()), this.emptyUUID ? Optional.empty() : Optional.of(this.profile.getId()), this.profile.getProperties());
-+        } else {
-+            return new ResolvableProfile(this.buildGameProfile());
-+        }
-+    }
-+
-+    @Override
-+    public CraftPlayerProfile clone() {
-+        CraftPlayerProfile clone = new CraftPlayerProfile(this.getId(), this.getName());
-+        clone.setProperties(getProperties());
-+        return clone;
-+    }
-+
-+    @Override
-+    public boolean isComplete() {
-+        return this.getId() != null && StringUtils.isNotBlank(this.getName());
-+    }
-+
-+    @Override
-+    public @NotNull CompletableFuture<PlayerProfile> update() {
-+        return CompletableFuture.supplyAsync(() -> {
-+            final CraftPlayerProfile clone = clone();
-+            clone.complete(true);
-+            return clone;
-+        }, Util.PROFILE_EXECUTOR);
-+    }
-+
-+    @Override
-+    public boolean completeFromCache() {
-+        return completeFromCache(false, GlobalConfiguration.get().proxies.isProxyOnlineMode());
-+    }
-+
-+    public boolean completeFromCache(boolean onlineMode) {
-+        return completeFromCache(false, onlineMode);
-+    }
-+
-+    public boolean completeFromCache(boolean lookupUUID, boolean onlineMode) {
-+        MinecraftServer server = MinecraftServer.getServer();
-+        String name = profile.getName();
-+        GameProfileCache userCache = server.getProfileCache();
-+        if (this.getId() == null) {
-+            final GameProfile profile;
-+            if (onlineMode) {
-+                profile = lookupUUID ? userCache.get(name).orElse(null) : userCache.getProfileIfCached(name);
-+            } else {
-+                // Make an OfflinePlayer using an offline mode UUID since the name has no profile
-+                profile = new GameProfile(UUID.nameUUIDFromBytes(("OfflinePlayer:" + name).getBytes(Charsets.UTF_8)), name);
-+            }
-+            if (profile != null) {
-+                // if old has it, assume its newer, so overwrite, else use cached if it was set and ours wasn't
-+                copyProfileProperties(this.profile, profile);
-+                this.profile = profile;
-+                this.emptyUUID = false; // UUID was just retrieved from user cache and profile isn't null (so a completed profile was found)
-+            }
-+        }
-+
-+        if ((profile.getName().isEmpty() || !hasTextures()) && this.getId() != null) {
-+            Optional<GameProfile> optProfile = userCache.get(this.profile.getId());
-+            if (optProfile.isPresent()) {
-+                GameProfile profile = optProfile.get();
-+                if (this.profile.getName().isEmpty()) {
-+                    // if old has it, assume its newer, so overwrite, else use cached if it was set and ours wasn't
-+                    copyProfileProperties(this.profile, profile);
-+                    this.profile = profile;
-+                    this.emptyName = false; // Name was just retrieved via the userCache
-+                } else if (profile != this.profile) {
-+                    copyProfileProperties(profile, this.profile);
-+                }
-+            }
-+        }
-+        return this.isComplete();
-+    }
-+
-+    public boolean complete(boolean textures) {
-+        return complete(textures, GlobalConfiguration.get().proxies.isProxyOnlineMode());
-+    }
-+
-+    public boolean complete(boolean textures, boolean onlineMode) {
-+        if (this.isComplete() && (!textures || hasTextures())) { // Don't do lookup if we already have everything
-+            return true;
-+        }
-+
-+        MinecraftServer server = MinecraftServer.getServer();
-+        boolean isCompleteFromCache = this.completeFromCache(true, onlineMode);
-+        if (onlineMode && (!isCompleteFromCache || (textures && !hasTextures()))) {
-+            ProfileResult result = server.getSessionService().fetchProfile(this.profile.getId(), true);
-+            if (result != null && result.profile() != null) {
-+                copyProfileProperties(result.profile(), this.profile, true);
-+            }
-+            if (this.isComplete()) {
-+                server.getProfileCache().add(this.profile);
-+            }
-+        }
-+        return this.isComplete() && (!onlineMode || !textures || hasTextures());
-+    }
-+
-+    private static void copyProfileProperties(GameProfile source, GameProfile target) {
-+        copyProfileProperties(source, target, false);
-+    }
-+
-+    private static void copyProfileProperties(GameProfile source, GameProfile target, boolean clearTarget) {
-+        if (source == target) {
-+            throw new IllegalArgumentException("Source and target profiles are the same (" + source + ")");
-+        }
-+        PropertyMap sourceProperties = source.getProperties();
-+        PropertyMap targetProperties = target.getProperties();
-+        if (clearTarget) targetProperties.clear();
-+        if (sourceProperties.isEmpty()) {
-+            return;
-+        }
-+
-+        for (Property property : sourceProperties.values()) {
-+            targetProperties.removeAll(property.name());
-+            targetProperties.put(property.name(), property);
-+        }
-+    }
-+
-+    private static GameProfile createAuthLibProfile(UUID uniqueId, String name) {
-+        Preconditions.checkArgument(name == null || name.length() <= 16, "Name cannot be longer than 16 characters");
-+        Preconditions.checkArgument(name == null || StringUtil.isValidPlayerName(name), "The name of the profile contains invalid characters: %s", name);
-+        return new GameProfile(
-+            uniqueId != null ? uniqueId : Util.NIL_UUID,
-+            name != null ? name : ""
-+        );
-+    }
-+
-+    private static ProfileProperty toBukkit(Property property) {
-+        return new ProfileProperty(property.name(), property.value(), property.signature());
-+    }
-+
-+    public static PlayerProfile asBukkitCopy(GameProfile gameProfile) {
-+        CraftPlayerProfile profile = new CraftPlayerProfile(gameProfile.getId(), gameProfile.getName());
-+        copyProfileProperties(gameProfile, profile.profile);
-+        return profile;
-+    }
-+
-+    public static PlayerProfile asBukkitMirror(GameProfile profile) {
-+        return new CraftPlayerProfile(profile);
-+    }
-+
-+    public static Property asAuthlib(ProfileProperty property) {
-+        return new Property(property.getName(), property.getValue(), property.getSignature());
-+    }
-+
-+    public static GameProfile asAuthlibCopy(PlayerProfile profile) {
-+        CraftPlayerProfile craft = ((CraftPlayerProfile) profile);
-+        return asAuthlib(craft.clone());
-+    }
-+
-+    public static GameProfile asAuthlib(PlayerProfile profile) {
-+        CraftPlayerProfile craft = ((CraftPlayerProfile) profile);
-+        return craft.getGameProfile();
-+    }
-+
-+    public static ResolvableProfile asResolvableProfileCopy(PlayerProfile profile) {
-+        return ((SharedPlayerProfile) profile).buildResolvableProfile();
-+    }
-+
-+    @Override
-+    public @NotNull Map<String, Object> serialize() {
-+        Map<String, Object> map = new LinkedHashMap<>();
-+        if (!this.emptyUUID) {
-+            map.put("uniqueId", this.getId().toString());
-+        }
-+        if (!this.emptyName) {
-+            map.put("name", getName());
-+        }
-+        if (!this.properties.isEmpty()) {
-+            List<Object> propertiesData = new ArrayList<>();
-+            for (ProfileProperty property : properties) {
-+                propertiesData.add(CraftProfileProperty.serialize(new Property(property.getName(), property.getValue(), property.getSignature())));
-+            }
-+            map.put("properties", propertiesData);
-+        }
-+        return map;
-+    }
-+
-+    public static CraftPlayerProfile deserialize(Map<String, Object> map) {
-+        UUID uniqueId = ConfigSerializationUtil.getUuid(map, "uniqueId", true);
-+        String name = ConfigSerializationUtil.getString(map, "name", true);
-+
-+        // This also validates the deserialized unique id and name (ensures that not both are null):
-+        CraftPlayerProfile profile = new CraftPlayerProfile(uniqueId, name);
-+
-+        if (map.containsKey("properties")) {
-+            for (Object propertyData : (List<?>) map.get("properties")) {
-+                if (!(propertyData instanceof Map)) {
-+                    throw new IllegalArgumentException("Property data (" + propertyData + ") is not a valid Map");
-+                }
-+                Property property = CraftProfileProperty.deserialize((Map<?, ?>) propertyData);
-+                profile.profile.getProperties().put(property.name(), property);
-+            }
-+        }
-+
-+        return profile;
-+    }
-+
-+    @Override
-+    public boolean equals(final Object o) {
-+        if (this == o) return true;
-+        if (o == null || this.getClass() != o.getClass()) return false;
-+        final CraftPlayerProfile that = (CraftPlayerProfile) o;
-+        return this.emptyName == that.emptyName && this.emptyUUID == that.emptyUUID && Objects.equals(this.profile, that.profile);
-+    }
-+
-+    @Override
-+    public int hashCode() {
-+        return Objects.hash(this.emptyName, this.emptyUUID, this.profile);
-+    }
-+
-+    @Override
-+    public String toString() {
-+        return "CraftPlayerProfile [uniqueId=" + getId() +
-+            ", name=" + getName() +
-+            ", properties=" + org.bukkit.craftbukkit.profile.CraftPlayerProfile.toString(this.profile.getProperties()) +
-+            "]";
-+    }
-+
-+    private class PropertySet extends AbstractSet<ProfileProperty> {
-+
-+        @Override
-+        @Nonnull
-+        public Iterator<ProfileProperty> iterator() {
-+            return new ProfilePropertyIterator(profile.getProperties().values().iterator());
-+        }
-+
-+        @Override
-+        public int size() {
-+            return profile.getProperties().size();
-+        }
-+
-+        @Override
-+        public boolean add(ProfileProperty property) {
-+            setProperty(property);
-+            return true;
-+        }
-+
-+        @Override
-+        public boolean addAll(Collection<? extends ProfileProperty> c) {
-+            //noinspection unchecked
-+            setProperties((Collection<ProfileProperty>) c);
-+            return true;
-+        }
-+
-+        @Override
-+        public boolean contains(Object o) {
-+            return o instanceof ProfileProperty && profile.getProperties().containsKey(((ProfileProperty) o).getName());
-+        }
-+
-+        private class ProfilePropertyIterator implements Iterator<ProfileProperty> {
-+            private final Iterator<Property> iterator;
-+
-+            ProfilePropertyIterator(Iterator<Property> iterator) {
-+                this.iterator = iterator;
-+            }
-+
-+            @Override
-+            public boolean hasNext() {
-+                return iterator.hasNext();
-+            }
-+
-+            @Override
-+            public ProfileProperty next() {
-+                return toBukkit(iterator.next());
-+            }
-+
-+            @Override
-+            public void remove() {
-+                iterator.remove();
-+            }
-+        }
-+    }
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/profile/PaperAuthenticationService.java b/src/main/java/com/destroystokyo/paper/profile/PaperAuthenticationService.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/profile/PaperAuthenticationService.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.profile;
-+
-+import com.mojang.authlib.Environment;
-+import com.mojang.authlib.EnvironmentParser;
-+import com.mojang.authlib.GameProfileRepository;
-+import com.mojang.authlib.minecraft.MinecraftSessionService;
-+import com.mojang.authlib.yggdrasil.YggdrasilAuthenticationService;
-+import com.mojang.authlib.yggdrasil.YggdrasilEnvironment;
-+
-+import java.net.Proxy;
-+
-+public class PaperAuthenticationService extends YggdrasilAuthenticationService {
-+
-+    private final Environment environment;
-+
-+    public PaperAuthenticationService(Proxy proxy) {
-+        super(proxy);
-+        this.environment = EnvironmentParser.getEnvironmentFromProperties().orElse(YggdrasilEnvironment.PROD.getEnvironment());
-+    }
-+
-+    @Override
-+    public MinecraftSessionService createMinecraftSessionService() {
-+        return new PaperMinecraftSessionService(this.getServicesKeySet(),  this.getProxy(), this.environment);
-+    }
-+
-+    @Override
-+    public GameProfileRepository createProfileRepository() {
-+        return new PaperGameProfileRepository(this.getProxy(), this.environment);
-+    }
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/profile/PaperGameProfileRepository.java b/src/main/java/com/destroystokyo/paper/profile/PaperGameProfileRepository.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/profile/PaperGameProfileRepository.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.profile;
-+
-+import com.mojang.authlib.Environment;
-+import com.mojang.authlib.ProfileLookupCallback;
-+import com.mojang.authlib.yggdrasil.YggdrasilGameProfileRepository;
-+import java.net.Proxy;
-+
-+public class PaperGameProfileRepository extends YggdrasilGameProfileRepository {
-+    public PaperGameProfileRepository(Proxy proxy, Environment environment) {
-+        super(proxy, environment);
-+    }
-+
-+    @Override
-+    public void findProfilesByNames(String[] names, ProfileLookupCallback callback) {
-+        super.findProfilesByNames(names, callback);
-+    }
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/profile/PaperMinecraftSessionService.java b/src/main/java/com/destroystokyo/paper/profile/PaperMinecraftSessionService.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/profile/PaperMinecraftSessionService.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.profile;
-+
-+import com.mojang.authlib.Environment;
-+import com.mojang.authlib.yggdrasil.ProfileResult;
-+import com.mojang.authlib.yggdrasil.ServicesKeySet;
-+import com.mojang.authlib.yggdrasil.YggdrasilMinecraftSessionService;
-+
-+import java.net.Proxy;
-+import java.util.UUID;
-+import org.jetbrains.annotations.Nullable;
-+
-+public class PaperMinecraftSessionService extends YggdrasilMinecraftSessionService {
-+
-+    protected PaperMinecraftSessionService(ServicesKeySet servicesKeySet, Proxy proxy, Environment environment) {
-+        super(servicesKeySet, proxy, environment);
-+    }
-+
-+    @Override
-+    public @Nullable ProfileResult fetchProfile(final UUID profileId, final boolean requireSecure) {
-+        return super.fetchProfile(profileId, requireSecure);
-+    }
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/profile/SharedPlayerProfile.java b/src/main/java/com/destroystokyo/paper/profile/SharedPlayerProfile.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/profile/SharedPlayerProfile.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.profile;
-+
-+import com.mojang.authlib.GameProfile;
-+import com.mojang.authlib.properties.Property;
-+import net.minecraft.world.item.component.ResolvableProfile;
-+import org.jetbrains.annotations.NotNull;
-+import org.jetbrains.annotations.Nullable;
-+
-+import java.util.UUID;
-+
-+public interface SharedPlayerProfile {
-+
-+    @Nullable UUID getUniqueId();
-+
-+    @Nullable String getName();
-+
-+    boolean removeProperty(@NotNull String property);
-+
-+    @Nullable Property getProperty(@NotNull String propertyName);
-+
-+    @Nullable void setProperty(@NotNull String propertyName, @Nullable Property property);
-+
-+    @NotNull GameProfile buildGameProfile();
-+
-+    @NotNull ResolvableProfile buildResolvableProfile();
-+}
-diff --git a/src/main/java/net/minecraft/server/Main.java b/src/main/java/net/minecraft/server/Main.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/Main.java
-+++ b/src/main/java/net/minecraft/server/Main.java
-@@ -0,0 +0,0 @@ public class Main {
-             }
- 
-             File file = (File) optionset.valueOf("universe"); // CraftBukkit
--            Services services = Services.create(new YggdrasilAuthenticationService(Proxy.NO_PROXY), file, optionset); // Paper - pass OptionSet to load paper config files
-+            Services services = Services.create(new com.destroystokyo.paper.profile.PaperAuthenticationService(Proxy.NO_PROXY), file, optionset); // Paper - pass OptionSet to load paper config files; override authentication service
-             // CraftBukkit start
-             String s = (String) Optional.ofNullable((String) optionset.valueOf("world")).orElse(dedicatedserversettings.getProperties().levelName);
-             LevelStorageSource convertable = LevelStorageSource.createDefault(file.toPath());
-diff --git a/src/main/java/net/minecraft/server/players/GameProfileCache.java b/src/main/java/net/minecraft/server/players/GameProfileCache.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/players/GameProfileCache.java
-+++ b/src/main/java/net/minecraft/server/players/GameProfileCache.java
-@@ -0,0 +0,0 @@ public class GameProfileCache {
-         return this.operationCount.incrementAndGet();
-     }
- 
-+    // Paper start
-+    public @Nullable GameProfile getProfileIfCached(String name) {
-+        GameProfileCache.GameProfileInfo entry = this.profilesByName.get(name.toLowerCase(Locale.ROOT));
-+        if (entry == null) {
-+            return null;
-+        }
-+        entry.setLastAccess(this.getNextOperation());
-+        return entry.getProfile();
-+    }
-+    // Paper end
-+
-     public Optional<GameProfile> get(String name) {
-         String s1 = name.toLowerCase(Locale.ROOT);
-         GameProfileCache.GameProfileInfo usercache_usercacheentry = (GameProfileCache.GameProfileInfo) this.profilesByName.get(s1);
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ import org.yaml.snakeyaml.error.MarkedYAMLException;
- 
- import net.md_5.bungee.api.chat.BaseComponent; // Spigot
- 
-+import javax.annotation.Nullable; // Paper
-+import javax.annotation.Nonnull; // Paper
-+
- public final class CraftServer implements Server {
-     private final String serverName = io.papermc.paper.ServerBuildInfo.buildInfo().brandName(); // Paper
-     private final String serverVersion;
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-     static {
-         ConfigurationSerialization.registerClass(CraftOfflinePlayer.class);
-         ConfigurationSerialization.registerClass(CraftPlayerProfile.class);
-+        ConfigurationSerialization.registerClass(com.destroystokyo.paper.profile.CraftPlayerProfile.class); // Paper
-         CraftItemFactory.instance();
-         CraftEntityFactory.instance();
-     }
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-     public boolean suggestPlayerNamesWhenNullTabCompletions() {
-         return io.papermc.paper.configuration.GlobalConfiguration.get().commands.suggestPlayerNamesWhenNullTabCompletions;
-     }
-+
-+    @Override
-+    public com.destroystokyo.paper.profile.PlayerProfile createProfile(@Nonnull UUID uuid) {
-+        return createProfile(uuid, null);
-+    }
-+
-+    @Override
-+    public com.destroystokyo.paper.profile.PlayerProfile createProfile(@Nonnull String name) {
-+        return createProfile(null, name);
-+    }
-+
-+    @Override
-+    public com.destroystokyo.paper.profile.PlayerProfile createProfile(@Nullable UUID uuid, @Nullable String name) {
-+        Player player = uuid != null ? Bukkit.getPlayer(uuid) : (name != null ? Bukkit.getPlayerExact(name) : null);
-+        if (player != null) return new com.destroystokyo.paper.profile.CraftPlayerProfile((CraftPlayer) player);
-+
-+        return new com.destroystokyo.paper.profile.CraftPlayerProfile(uuid, name);
-+    }
-+
-+    @Override
-+    public com.destroystokyo.paper.profile.PlayerProfile createProfileExact(@Nullable UUID uuid, @Nullable String name) {
-+        Player player = uuid != null ? Bukkit.getPlayer(uuid) : (name != null ? Bukkit.getPlayerExact(name) : null);
-+        if (player == null) {
-+            return new com.destroystokyo.paper.profile.CraftPlayerProfile(uuid, name);
-+        }
-+
-+        if (java.util.Objects.equals(uuid, player.getUniqueId()) && java.util.Objects.equals(name, player.getName())) {
-+            return new com.destroystokyo.paper.profile.CraftPlayerProfile((CraftPlayer) player);
-+        }
-+
-+        final com.destroystokyo.paper.profile.CraftPlayerProfile profile = new com.destroystokyo.paper.profile.CraftPlayerProfile(uuid, name);
-+        profile.getGameProfile().getProperties().putAll(((CraftPlayer) player).getHandle().getGameProfile().getProperties());
-+        return profile;
-+    }
-     // Paper end
- }
-diff --git a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
-+++ b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
-@@ -0,0 +0,0 @@ import org.bukkit.profile.PlayerTextures;
- import org.jetbrains.annotations.ApiStatus;
- 
- @SerializableAs("PlayerProfile")
--public final class CraftPlayerProfile implements PlayerProfile {
-+public final class CraftPlayerProfile implements PlayerProfile, com.destroystokyo.paper.profile.SharedPlayerProfile { // Paper
- 
-     @Nonnull
-     public static GameProfile validateSkullProfile(@Nonnull GameProfile gameProfile) {
-@@ -0,0 +0,0 @@ public final class CraftPlayerProfile implements PlayerProfile {
-         }
-     }
- 
--    void removeProperty(String propertyName) {
--        this.properties.removeAll(propertyName);
-+    // Paper start - change return value for shared interface
-+    public boolean removeProperty(String propertyName) {
-+        return !this.properties.removeAll(propertyName).isEmpty();
-+        // Paper end
-     }
- 
-     void rebuildDirtyProperties() {
-@@ -0,0 +0,0 @@ public final class CraftPlayerProfile implements PlayerProfile {
- 
-     @Override
-     public Map<String, Object> serialize() {
-+        // Paper - diff on change
-         Map<String, Object> map = new LinkedHashMap<>();
-         if (this.uniqueId != null) {
-             map.put("uniqueId", this.uniqueId.toString());
-@@ -0,0 +0,0 @@ public final class CraftPlayerProfile implements PlayerProfile {
-             this.properties.forEach((propertyName, property) -> propertiesData.add(CraftProfileProperty.serialize(property)));
-             map.put("properties", propertiesData);
-         }
-+        // Paper - diff on change
-         return map;
-     }
- 
-     public static CraftPlayerProfile deserialize(Map<String, Object> map) {
-+        // Paper - diff on change
-         UUID uniqueId = ConfigSerializationUtil.getUuid(map, "uniqueId", true);
-         String name = ConfigSerializationUtil.getString(map, "name", true);
- 
-@@ -0,0 +0,0 @@ public final class CraftPlayerProfile implements PlayerProfile {
-                 profile.properties.put(property.name(), property);
-             }
-         }
--
-+        // Paper - diff on change
-         return profile;
-     }
- }
-diff --git a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerTextures.java b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerTextures.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerTextures.java
-+++ b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerTextures.java
-@@ -0,0 +0,0 @@ public final class CraftPlayerTextures implements PlayerTextures {
-         }
-     }
- 
--    private final CraftPlayerProfile profile;
-+    private final com.destroystokyo.paper.profile.SharedPlayerProfile profile; // Paper
- 
-     // The textures data is loaded lazily:
-     private boolean loaded = false;
-@@ -0,0 +0,0 @@ public final class CraftPlayerTextures implements PlayerTextures {
-     // GameProfiles (even if these modifications are later reverted).
-     private boolean dirty = false;
- 
--    CraftPlayerTextures(@Nonnull CraftPlayerProfile profile) {
-+    public CraftPlayerTextures(@Nonnull com.destroystokyo.paper.profile.SharedPlayerProfile profile) { // Paper
-         this.profile = profile;
-     }
- 

patches/unapplied/server/Block-player-logins-during-server-shutdown.patch

@@ -1,23 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Zach Brown <1254957+zachbr@users.noreply.github.com>
-Date: Sun, 2 Jul 2017 21:35:56 -0500
-Subject: [PATCH] Block player logins during server shutdown
-
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
- 
-     @Override
-     public void tick() {
-+        // Paper start - Do not allow logins while the server is shutting down
-+        if (!MinecraftServer.getServer().isRunning()) {
-+            this.disconnect(org.bukkit.craftbukkit.util.CraftChatMessage.fromString(org.spigotmc.SpigotConfig.restartMessage)[0]);
-+            return;
-+        }
-+        // Paper end - Do not allow logins while the server is shutting down
-         if (this.state == ServerLoginPacketListenerImpl.State.VERIFYING) {
-             this.verifyLoginAndFinishConnectionSetup((GameProfile) Objects.requireNonNull(this.authenticatedProfile));
-         }

patches/unapplied/server/Bound-Treasure-Maps-to-World-Border.patch

@@ -1,47 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Tue, 20 Dec 2016 15:15:11 -0500
-Subject: [PATCH] Bound Treasure Maps to World Border
-
-Make it so a Treasure Map does not target a structure outside of the
-World Border, where players are not even able to reach.
-
-This also would help the case where a players close to the border, and one
-that is outside happens to be closer, but unreachable, yet another reachable
-one is in border that would of been missed.
-
-diff --git a/src/main/java/net/minecraft/world/level/border/WorldBorder.java b/src/main/java/net/minecraft/world/level/border/WorldBorder.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/border/WorldBorder.java
-+++ b/src/main/java/net/minecraft/world/level/border/WorldBorder.java
-@@ -0,0 +0,0 @@ public class WorldBorder {
-         return this.isWithinBounds((double) chunkPos.getMinBlockX(), (double) chunkPos.getMinBlockZ()) && this.isWithinBounds((double) chunkPos.getMaxBlockX(), (double) chunkPos.getMaxBlockZ());
-     }
- 
-+    // Paper start - Bound treasure maps to world border
-+    private final BlockPos.MutableBlockPos mutPos = new BlockPos.MutableBlockPos();
-+    public boolean isBlockInBounds(int chunkX, int chunkZ) {
-+        this.mutPos.set(chunkX, 64, chunkZ);
-+        return this.isWithinBounds(this.mutPos);
-+    }
-+    public boolean isChunkInBounds(int chunkX, int chunkZ) {
-+        this.mutPos.set(((chunkX << 4) + 15), 64, (chunkZ << 4) + 15);
-+        return this.isWithinBounds(this.mutPos);
-+    }
-+    // Paper end - Bound treasure maps to world border
-+
-     public boolean isWithinBounds(AABB box) {
-         return this.isWithinBounds(box.minX, box.minZ, box.maxX - 9.999999747378752E-6D, box.maxZ - 9.999999747378752E-6D);
-     }
-diff --git a/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java b/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
-@@ -0,0 +0,0 @@ public abstract class ChunkGenerator {
- 
-             while (iterator.hasNext()) {
-                 ChunkPos chunkcoordintpair = (ChunkPos) iterator.next();
-+                if (!world.paperConfig().environment.locateStructuresOutsideWorldBorder && !world.getWorldBorder().isChunkInBounds(chunkcoordintpair.x, chunkcoordintpair.z)) { continue; } // Paper - Bound treasure maps to world border
- 
-                 blockposition_mutableblockposition.set(SectionPos.sectionToBlockCoord(chunkcoordintpair.x, 8), 32, SectionPos.sectionToBlockCoord(chunkcoordintpair.z, 8));
-                 double d1 = blockposition_mutableblockposition.distSqr(center);

patches/unapplied/server/Break-up-and-make-tab-spam-limits-configurable.patch

@@ -1,52 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Shane Freeder <theboyetronic@gmail.com>
-Date: Sun, 29 Jul 2018 05:02:15 +0100
-Subject: [PATCH] Break up and make tab spam limits configurable
-
-Due to the changes in 1.13, clients will send a tab completion request
-for all bukkit commands in order to factor in the lack of support for
-brigadier and provide backwards support in the API.
-
-Craftbukkit, however; has moved the chat spam limiter to also interact
-with the tab completion request, which while good for avoiding abuse,
-causes 1.13 clients to easilly be kicked from a server in bukkit due
-to this. Removing the spam limit could cause issues for servers, however,
-there is no way for servers to manipulate this without blindly cancelling
-kick events, which only causes additional complications. This also causes
-issues in that the tab spam limit and chat share the same field but different
-limits, meaning that a player having typed a long command may be kicked from
-the server.
-
-Splitting the field up and making it configurable allows for server owners
-to take the burden of this into their own hand without having to rely on
-plugins doing unsafe things.
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-     private int tickCount;
-     private int ackBlockChangesUpTo = -1;
-     private final TickThrottler chatSpamThrottler = new TickThrottler(20, 200);
-+    private final TickThrottler tabSpamThrottler = new TickThrottler(io.papermc.paper.configuration.GlobalConfiguration.get().spamLimiter.tabSpamIncrement, io.papermc.paper.configuration.GlobalConfiguration.get().spamLimiter.tabSpamLimit); // Paper - configurable tab spam limits
-     private final TickThrottler dropSpamThrottler = new TickThrottler(20, 1480);
-     private double firstGoodX;
-     private double firstGoodY;
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
- 
-         this.keepConnectionAlive();
-         this.chatSpamThrottler.tick();
-+        this.tabSpamThrottler.tick(); // Paper - configurable tab spam limits
-         this.dropSpamThrottler.tick();
-         if (this.player.getLastActionTime() > 0L && this.server.getPlayerIdleTimeout() > 0 && Util.getMillis() - this.player.getLastActionTime() > (long) this.server.getPlayerIdleTimeout() * 1000L * 60L) {
-             this.player.resetLastActionTime(); // CraftBukkit - SPIGOT-854
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-     public void handleCustomCommandSuggestions(ServerboundCommandSuggestionPacket packet) {
-         // PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel()); // Paper - AsyncTabCompleteEvent; run this async
-         // CraftBukkit start
--        if (!this.chatSpamThrottler.isIncrementAndUnderThreshold(1, 500) && !this.server.getPlayerList().isOp(this.player.getGameProfile()) && !this.server.isSingleplayerOwner(this.player.getGameProfile())) {
-+        if (!this.tabSpamThrottler.isIncrementAndUnderThreshold() && !this.server.getPlayerList().isOp(this.player.getGameProfile()) && !this.server.isSingleplayerOwner(this.player.getGameProfile())) { // Paper - configurable tab spam limits
-             this.disconnect(Component.translatable("disconnect.spam"));
-             return;
-         }

patches/unapplied/server/Cache-user-authenticator-threads.patch

@@ -1,64 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Alfie Cleveland <alfeh@me.com>
-Date: Fri, 25 Nov 2016 13:22:40 +0000
-Subject: [PATCH] Cache user authenticator threads
-
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
-     // CraftBukkit end
-     private static final AtomicInteger UNIQUE_THREAD_ID = new AtomicInteger(0);
-     static final Logger LOGGER = LogUtils.getLogger();
-+    private static final java.util.concurrent.ExecutorService authenticatorPool = java.util.concurrent.Executors.newCachedThreadPool(new com.google.common.util.concurrent.ThreadFactoryBuilder().setNameFormat("User Authenticator #%d").setUncaughtExceptionHandler(new DefaultUncaughtExceptionHandler(LOGGER)).build()); // Paper - Cache authenticator threads
-     private static final int MAX_TICKS_BEFORE_LOGIN = 600;
-     private final byte[] challenge;
-     final MinecraftServer server;
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
-                 this.connection.send(new ClientboundHelloPacket("", this.server.getKeyPair().getPublic().getEncoded(), this.challenge, true));
-             } else {
-                 // CraftBukkit start
--                Thread thread = new Thread("User Authenticator #" + ServerLoginPacketListenerImpl.UNIQUE_THREAD_ID.incrementAndGet()) {
-+                // Paper start - Cache authenticator threads
-+                authenticatorPool.execute(new Runnable() {
- 
-                     @Override
-                     public void run() {
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
-                             ServerLoginPacketListenerImpl.this.server.server.getLogger().log(java.util.logging.Level.WARNING, "Exception verifying " + ServerLoginPacketListenerImpl.this.requestedUsername, ex);
-                         }
-                     }
--                };
--
--                thread.setUncaughtExceptionHandler(new DefaultUncaughtExceptionHandler(ServerLoginPacketListenerImpl.LOGGER));
--                thread.start();
-+                });
-+                // Paper end - Cache authenticator threads
-                 // CraftBukkit end
-             }
- 
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
-             throw new IllegalStateException("Protocol error", cryptographyexception);
-         }
- 
--        Thread thread = new Thread("User Authenticator #" + ServerLoginPacketListenerImpl.UNIQUE_THREAD_ID.incrementAndGet()) {
-+        // Paper start - Cache authenticator threads
-+        authenticatorPool.execute(new Runnable() {
-             public void run() {
-                 String s1 = (String) Objects.requireNonNull(ServerLoginPacketListenerImpl.this.requestedUsername, "Player name not initialized");
- 
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
- 
-                 return ServerLoginPacketListenerImpl.this.server.getPreventProxyConnections() && socketaddress instanceof InetSocketAddress ? ((InetSocketAddress) socketaddress).getAddress() : null;
-             }
--        };
--
--        thread.setUncaughtExceptionHandler(new DefaultUncaughtExceptionHandler(ServerLoginPacketListenerImpl.LOGGER));
--        thread.start();
-+        });
-+        // Paper end - Cache authenticator threads
-     }
- 
-     // CraftBukkit start

patches/unapplied/server/Call-PaperServerListPingEvent-for-legacy-pings.patch

@@ -1,155 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Minecrell <minecrell@minecrell.net>
-Date: Wed, 11 Oct 2017 19:30:51 +0200
-Subject: [PATCH] Call PaperServerListPingEvent for legacy pings
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/network/PaperLegacyStatusClient.java b/src/main/java/com/destroystokyo/paper/network/PaperLegacyStatusClient.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/network/PaperLegacyStatusClient.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.network;
-+
-+import com.destroystokyo.paper.event.server.PaperServerListPingEvent;
-+import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
-+import net.minecraft.ChatFormatting;
-+import net.minecraft.server.MinecraftServer;
-+import org.apache.commons.lang3.StringUtils;
-+
-+import java.net.InetSocketAddress;
-+
-+import javax.annotation.Nullable;
-+
-+public final class PaperLegacyStatusClient implements StatusClient {
-+
-+    private final InetSocketAddress address;
-+    private final int protocolVersion;
-+    @Nullable private final InetSocketAddress virtualHost;
-+
-+    private PaperLegacyStatusClient(InetSocketAddress address, int protocolVersion, @Nullable InetSocketAddress virtualHost) {
-+        this.address = address;
-+        this.protocolVersion = protocolVersion;
-+        this.virtualHost = virtualHost;
-+    }
-+
-+    @Override
-+    public InetSocketAddress getAddress() {
-+        return this.address;
-+    }
-+
-+    @Override
-+    public int getProtocolVersion() {
-+        return this.protocolVersion;
-+    }
-+
-+    @Nullable
-+    @Override
-+    public InetSocketAddress getVirtualHost() {
-+        return this.virtualHost;
-+    }
-+
-+    @Override
-+    public boolean isLegacy() {
-+        return true;
-+    }
-+
-+    public static PaperServerListPingEvent processRequest(MinecraftServer server,
-+            InetSocketAddress address, int protocolVersion, @Nullable InetSocketAddress virtualHost) {
-+
-+        PaperServerListPingEvent event =  new PaperServerListPingEventImpl(server,
-+                new PaperLegacyStatusClient(address, protocolVersion, virtualHost), Byte.MAX_VALUE, null);
-+        server.server.getPluginManager().callEvent(event);
-+
-+        if (event.isCancelled()) {
-+            return null;
-+        }
-+
-+        return event;
-+    }
-+
-+    @SuppressWarnings("deprecation") // Valid as this is the legacy status client
-+    public static String getMotd(PaperServerListPingEvent event) {
-+        return getFirstLine(event.getMotd());
-+    }
-+
-+    public static String getUnformattedMotd(PaperServerListPingEvent event) {
-+        // Strip color codes and all other occurrences of the color char (because it's used as delimiter)
-+        return getFirstLine(StringUtils.remove(PlainTextComponentSerializer.plainText().serialize(event.motd()), ChatFormatting.PREFIX_CODE));
-+    }
-+
-+    private static String getFirstLine(String s) {
-+        int pos = s.indexOf('\n');
-+        return pos >= 0 ? s.substring(0, pos) : s;
-+    }
-+
-+}
-diff --git a/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java b/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java
-+++ b/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java
-@@ -0,0 +0,0 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
-                 SocketAddress socketaddress = channelhandlercontext.channel().remoteAddress();
-                 int i = bytebuf.readableBytes();
-                 String s = null; // Paper
--                org.bukkit.event.server.ServerListPingEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callServerListPingEvent(socketaddress, this.server.getMotd(), this.server.getPlayerCount(), this.server.getMaxPlayers()); // CraftBukkit
-+                // org.bukkit.event.server.ServerListPingEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callServerListPingEvent(socketaddress, this.server.getMotd(), this.server.getPlayerCount(), this.server.getMaxPlayers()); // CraftBukkit // Paper
-+                com.destroystokyo.paper.event.server.PaperServerListPingEvent event; // Paper
- 
-                 if (i == 0) {
-                     LegacyQueryHandler.LOGGER.debug("Ping: (<1.3.x) from {}", socketaddress);
--                    s = LegacyQueryHandler.createVersion0Response(this.server, event); // CraftBukkit
-+
-+                    // Paper start - Call PaperServerListPingEvent and use results
-+                    event = com.destroystokyo.paper.network.PaperLegacyStatusClient.processRequest(net.minecraft.server.MinecraftServer.getServer(), (java.net.InetSocketAddress) socketaddress, 39, null);
-+                    if (event == null) {
-+                        channelhandlercontext.close();
-+                        bytebuf.release();
-+                        flag = false;
-+                        return;
-+                    }
-+                    s = String.format(Locale.ROOT, "%s\u00a7%d\u00a7%d", com.destroystokyo.paper.network.PaperLegacyStatusClient.getUnformattedMotd(event), event.getNumPlayers(), event.getMaxPlayers());
-+                    // Paper end
-                     LegacyQueryHandler.sendFlushAndClose(channelhandlercontext, LegacyQueryHandler.createLegacyDisconnectPacket(channelhandlercontext.alloc(), s));
-                 } else {
-                     if (bytebuf.readUnsignedByte() != 1) {
-@@ -0,0 +0,0 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
-                         LegacyQueryHandler.LOGGER.debug("Ping: (1.4-1.5.x) from {}", socketaddress);
-                     }
- 
--                    if (s == null) s = LegacyQueryHandler.createVersion1Response(this.server, event); // CraftBukkit // Paper
-+                    if (s == null) {
-+                        // Paper start - Call PaperServerListPingEvent and use results
-+                        event = com.destroystokyo.paper.network.PaperLegacyStatusClient.processRequest(net.minecraft.server.MinecraftServer.getServer(), (java.net.InetSocketAddress) socketaddress, 127, null); // Paper
-+                        if (event == null) {
-+                            channelhandlercontext.close();
-+                            bytebuf.release();
-+                            flag = false;
-+                            return;
-+                        }
-+                        s = String.format(Locale.ROOT, "\u00a71\u0000%d\u0000%s\u0000%s\u0000%d\u0000%d", new Object[] { event.getProtocolVersion(), this.server.getServerVersion(), event.getMotd(), event.getNumPlayers(), event.getMaxPlayers()}); // CraftBukkit
-+                        // Paper end
-+                    }
-                     LegacyQueryHandler.sendFlushAndClose(channelhandlercontext, LegacyQueryHandler.createLegacyDisconnectPacket(channelhandlercontext.alloc(), s));
-                 }
- 
-@@ -0,0 +0,0 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
- 
-         LOGGER.debug("Ping: (1.6) from {}", ctx.channel().remoteAddress());
- 
--        String response = String.format("\u00a71\u0000%d\u0000%s\u0000%s\u0000%d\u0000%d",
--            Byte.MAX_VALUE, server.getServerVersion(), server.getMotd(), server.getPlayerCount(), server.getMaxPlayers());
-+        java.net.InetSocketAddress virtualHost = com.destroystokyo.paper.network.PaperNetworkClient.prepareVirtualHost(host, port);
-+        com.destroystokyo.paper.event.server.PaperServerListPingEvent event = com.destroystokyo.paper.network.PaperLegacyStatusClient.processRequest(
-+                server, (java.net.InetSocketAddress) ctx.channel().remoteAddress(), protocolVersion, virtualHost);
-+        if (event == null) {
-+            ctx.close();
-+            return null;
-+        }
-+
-+        String response = String.format("\u00a71\u0000%d\u0000%s\u0000%s\u0000%d\u0000%d", event.getProtocolVersion(), event.getVersion(),
-+            com.destroystokyo.paper.network.PaperLegacyStatusClient.getMotd(event), event.getNumPlayers(), event.getMaxPlayers());
-         return response;
-     }
- 

patches/unapplied/server/Call-player-spectator-target-events-and-improve-impl.patch

@@ -1,46 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Caleb Bassham <caleb.bassham@gmail.com>
-Date: Fri, 28 Sep 2018 02:32:19 -0500
-Subject: [PATCH] Call player spectator target events and improve
- implementation
-
-Use a proper teleport for teleporting to entities in different
-worlds.
-
-Implementation improvements authored by Spottedleaf <Spottedleaf@users.noreply.github.com>
-Validate that the target entity is valid and deny spectate
-requests from frozen players.
-
-Also, make sure the entity is spawned to the client before
-sending the camera packet. If the entity isn't spawned clientside
-when it receives the camera packet, then the client will not
-spectate the target entity.
-
-Co-authored-by: Spottedleaf <Spottedleaf@users.noreply.github.com>
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player {
- 
-         this.camera = (Entity) (entity == null ? this : entity);
-         if (entity1 != this.camera) {
-+            // Paper start - Add PlayerStartSpectatingEntityEvent and PlayerStopSpectatingEntity
-+            if (this.camera == this) {
-+                com.destroystokyo.paper.event.player.PlayerStopSpectatingEntityEvent playerStopSpectatingEntityEvent = new com.destroystokyo.paper.event.player.PlayerStopSpectatingEntityEvent(this.getBukkitEntity(), entity1.getBukkitEntity());
-+                if (!playerStopSpectatingEntityEvent.callEvent()) {
-+                    this.camera = entity1; // rollback camera entity again
-+                    return;
-+                }
-+            } else {
-+                com.destroystokyo.paper.event.player.PlayerStartSpectatingEntityEvent playerStartSpectatingEntityEvent = new com.destroystokyo.paper.event.player.PlayerStartSpectatingEntityEvent(this.getBukkitEntity(), entity1.getBukkitEntity(), entity.getBukkitEntity());
-+                if (!playerStartSpectatingEntityEvent.callEvent()) {
-+                    this.camera = entity1; // rollback camera entity again
-+                    return;
-+                }
-+            }
-+            // Paper end - Add PlayerStartSpectatingEntityEvent and PlayerStopSpectatingEntity
-             Level world = this.camera.level();
- 
-             if (world instanceof ServerLevel) {

patches/unapplied/server/Cap-Entity-Collisions.patch

@@ -1,44 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sun, 22 Jan 2017 18:07:56 -0500
-Subject: [PATCH] Cap Entity Collisions
-
-Limit a single entity to colliding a max of configurable times per tick.
-This will alleviate issues where living entities are hoarded in 1x1 pens
-
-This is not tied to the maxEntityCramming rule. Cramming will still apply
-just as it does in Vanilla, but entity pushing logic will be capped.
-
-You can set this to 0 to disable collisions.
-
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-     public long activatedTick = Integer.MIN_VALUE;
-     public void inactiveTick() { }
-     // Spigot end
-+    protected int numCollisions = 0; // Paper - Cap entity collisions
-     // Paper start - Entity origin API
-     @javax.annotation.Nullable
-     private org.bukkit.util.Vector origin;
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-                 }
- 
-                 Iterator iterator1 = list.iterator();
-+                this.numCollisions = Math.max(0, this.numCollisions - this.level().paperConfig().collisions.maxEntityCollisions); // Paper - Cap entity collisions
- 
--                while (iterator1.hasNext()) {
-+                while (iterator1.hasNext() && this.numCollisions < this.level().paperConfig().collisions.maxEntityCollisions) { // Paper - Cap entity collisions
-                     Entity entity1 = (Entity) iterator1.next();
--
-+                    entity1.numCollisions++; // Paper - Cap entity collisions
-+                    this.numCollisions++; // Paper - Cap entity collisions
-                     this.doPush(entity1);
-                 }
-             }

patches/unapplied/server/Check-Drowned-for-Villager-Aggression-Config.patch

@@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Wed, 10 Oct 2018 21:22:44 -0500
-Subject: [PATCH] Check Drowned for Villager Aggression Config
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/monster/Drowned.java b/src/main/java/net/minecraft/world/entity/monster/Drowned.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/Drowned.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/Drowned.java
-@@ -0,0 +0,0 @@ public class Drowned extends Zombie implements RangedAttackMob {
-         this.goalSelector.addGoal(7, new RandomStrollGoal(this, 1.0));
-         this.targetSelector.addGoal(1, new HurtByTargetGoal(this, Drowned.class).setAlertOthers(ZombifiedPiglin.class));
-         this.targetSelector.addGoal(2, new NearestAttackableTargetGoal<>(this, Player.class, 10, true, false, (target, world) -> this.okTarget(target)));
--        this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, AbstractVillager.class, false));
-+        if (this.level().spigotConfig.zombieAggressiveTowardsVillager) this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, AbstractVillager.class, false));  // Paper - Check drowned for villager aggression config
-         this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, IronGolem.class, true));
-         this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, Axolotl.class, true, false));
-         this.targetSelector.addGoal(5, new NearestAttackableTargetGoal<>(this, Turtle.class, 10, true, false, Turtle.BABY_ON_LAND_SELECTOR));

patches/unapplied/server/Configurable-Cartographer-Treasure-Maps.patch

@@ -1,47 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Tue, 20 Dec 2016 15:26:27 -0500
-Subject: [PATCH] Configurable Cartographer Treasure Maps
-
-Allow configuring for cartographers to return the same map location
-
-Also allow turning off treasure maps all together as they can eat up Map ID's
-which are limited in quantity.
-
-diff --git a/src/main/java/net/minecraft/world/entity/npc/VillagerTrades.java b/src/main/java/net/minecraft/world/entity/npc/VillagerTrades.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/npc/VillagerTrades.java
-+++ b/src/main/java/net/minecraft/world/entity/npc/VillagerTrades.java
-@@ -0,0 +0,0 @@ public class VillagerTrades {
-                 return null;
-             } else {
-                 ServerLevel serverLevel = (ServerLevel)entity.level();
--                BlockPos blockPos = serverLevel.findNearestMapStructure(this.destination, entity.blockPosition(), 100, true);
-+                if (!serverLevel.paperConfig().environment.treasureMaps.enabled) return null; // Paper - Configurable cartographer treasure maps
-+                BlockPos blockPos = serverLevel.findNearestMapStructure(this.destination, entity.blockPosition(), 100, !serverLevel.paperConfig().environment.treasureMaps.findAlreadyDiscoveredVillager); // Paper - Configurable cartographer treasure maps
-                 if (blockPos != null) {
-                     ItemStack itemStack = MapItem.create(serverLevel, blockPos.getX(), blockPos.getZ(), (byte)2, true, true);
-                     MapItem.renderBiomePreviewMap(serverLevel, itemStack);
-diff --git a/src/main/java/net/minecraft/world/level/storage/loot/functions/ExplorationMapFunction.java b/src/main/java/net/minecraft/world/level/storage/loot/functions/ExplorationMapFunction.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/storage/loot/functions/ExplorationMapFunction.java
-+++ b/src/main/java/net/minecraft/world/level/storage/loot/functions/ExplorationMapFunction.java
-@@ -0,0 +0,0 @@ public class ExplorationMapFunction extends LootItemConditionalFunction {
-             Vec3 vec3 = context.getOptionalParameter(LootContextParams.ORIGIN);
-             if (vec3 != null) {
-                 ServerLevel serverLevel = context.getLevel();
-+                // Paper start - Configurable cartographer treasure maps
-+                if (!serverLevel.paperConfig().environment.treasureMaps.enabled) {
-+                    /*
-+                     * NOTE: I fear users will just get a plain map as their "treasure"
-+                     * This is preferable to disrespecting the config.
-+                     */
-+                    return stack;
-+                }
-+                // Paper end - Configurable cartographer treasure maps
-                 BlockPos blockPos = serverLevel.findNearestMapStructure(
--                    this.destination, BlockPos.containing(vec3), this.searchRadius, this.skipKnownStructures
-+                    this.destination, BlockPos.containing(vec3), this.searchRadius, !serverLevel.paperConfig().environment.treasureMaps.findAlreadyDiscoveredLootTable.or(!this.skipKnownStructures) // Paper - Configurable cartographer treasure maps
-                 );
-                 if (blockPos != null) {
-                     ItemStack itemStack = MapItem.create(serverLevel, blockPos.getX(), blockPos.getZ(), this.zoom, true, true);

patches/unapplied/server/Configurable-LootPool-luck-formula.patch

@@ -1,78 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Fri, 15 Jun 2018 00:30:32 -0400
-Subject: [PATCH] Configurable LootPool luck formula
-
-Rewrites the Vanilla luck application formula so that luck can be
-applied to items that do not have any quality defined.
-
-See: https://luckformula.emc.gs for data and details
------------
-
-The rough summary is:
-My goal was that in a pool, when luck was applied, the pool
-rebalances so the percentages for bigger items is
-lowered and smaller items is boosted.
-
-Do this by boosting and then reducing the weight value,
-so that larger numbers are penalized more than smaller numbers.
-resulting in a larger reduction of entries for more common
-items than the reduction on small weights,
-giving smaller weights more of a chance
-
------------
-
-This work kind of obsoletes quality, but quality would be useful
-for 2 items with same weight that you want luck to impact
-in varying directions.
-
-Fishing still falls into that as the weights are closer, so luck
-will invalidate junk more.
-
-This change will result in some major changes to fishing formulas.
-
------------
-
-I would love to see this change in Vanilla, so Mojang please pull :)
-
-diff --git a/src/main/java/net/minecraft/world/level/storage/loot/entries/LootPoolSingletonContainer.java b/src/main/java/net/minecraft/world/level/storage/loot/entries/LootPoolSingletonContainer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/storage/loot/entries/LootPoolSingletonContainer.java
-+++ b/src/main/java/net/minecraft/world/level/storage/loot/entries/LootPoolSingletonContainer.java
-@@ -0,0 +0,0 @@ public abstract class LootPoolSingletonContainer extends LootPoolEntryContainer
-     protected abstract class EntryBase implements LootPoolEntry {
-         @Override
-         public int getWeight(float luck) {
--            return Math.max(Mth.floor((float)LootPoolSingletonContainer.this.weight + (float)LootPoolSingletonContainer.this.quality * luck), 0);
-+            // Paper start - Configurable LootPool luck formula
-+            // SEE: https://luckformula.emc.gs for details and data
-+            if (LootPoolSingletonContainer.this.lastLuck != null && LootPoolSingletonContainer.this.lastLuck == luck) {
-+                return lastWeight;
-+            }
-+            // This is vanilla
-+            float qualityModifer = (float) LootPoolSingletonContainer.this.quality * luck;
-+            double baseWeight = (LootPoolSingletonContainer.this.weight + qualityModifer);
-+            if (io.papermc.paper.configuration.GlobalConfiguration.get().misc.useAlternativeLuckFormula) {
-+                // Random boost to avoid losing precision in the final int cast on return
-+                final int weightBoost = 100;
-+                baseWeight *= weightBoost;
-+                // If we have vanilla 1, bump that down to 0 so nothing is is impacted
-+                // vanilla 3 = 300, 200 basis = impact 2%
-+                // =($B2*(($B2-100)/100/100))
-+                double impacted = baseWeight * ((baseWeight - weightBoost) / weightBoost / 100);
-+                // =($B$7/100)
-+                float luckModifier = Math.min(100, luck * 10) / 100;
-+                // =B2 - (C2 *($B$7/100))
-+                baseWeight = Math.ceil(baseWeight - (impacted * luckModifier));
-+            }
-+            LootPoolSingletonContainer.this.lastLuck = luck;
-+            LootPoolSingletonContainer.this.lastWeight = (int) Math.max(Math.floor(baseWeight), 0);
-+            return lastWeight;
-         }
-     }
-+    private Float lastLuck = null;
-+    private int lastWeight = 0;
-+    // Paper end - Configurable LootPool luck formula
- 
-     @FunctionalInterface
-     protected interface EntryConstructor {

patches/unapplied/server/Configurable-connection-throttle-kick-message.patch

@@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Shane Freeder <theboyetronic@gmail.com>
-Date: Tue, 2 Oct 2018 09:57:50 +0100
-Subject: [PATCH] Configurable connection throttle kick message
-
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerHandshakePacketListenerImpl implements ServerHandshakePacketL
-             synchronized (ServerHandshakePacketListenerImpl.throttleTracker) {
-                 if (ServerHandshakePacketListenerImpl.throttleTracker.containsKey(address) && !"127.0.0.1".equals(address.getHostAddress()) && currentTime - ServerHandshakePacketListenerImpl.throttleTracker.get(address) < connectionThrottle) {
-                     ServerHandshakePacketListenerImpl.throttleTracker.put(address, currentTime);
--                    MutableComponent chatmessage = Component.literal("Connection throttled! Please wait before reconnecting.");
-+                            Component chatmessage = io.papermc.paper.adventure.PaperAdventure.asVanilla(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.connectionThrottle); // Paper - Configurable connection throttle kick message
-                     this.connection.send(new ClientboundLoginDisconnectPacket(chatmessage));
-                     this.connection.disconnect(chatmessage);
-                     return;

patches/unapplied/server/Configurable-flying-kick-messages.patch

@@ -1,28 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Riley Park <rileysebastianpark@gmail.com>
-Date: Tue, 20 Sep 2016 00:58:01 +0000
-Subject: [PATCH] Configurable flying kick messages
-
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-         if (this.clientIsFloating && !this.player.isSleeping() && !this.player.isPassenger() && !this.player.isDeadOrDying()) {
-             if (++this.aboveGroundTickCount > this.getMaximumFlyingTicks(this.player)) {
-                 ServerGamePacketListenerImpl.LOGGER.warn("{} was kicked for floating too long!", this.player.getName().getString());
--                this.disconnect((Component) Component.translatable("multiplayer.disconnect.flying"));
-+                this.disconnect(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.flyingPlayer); // Paper - use configurable kick message
-                 return;
-             }
-         } else {
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-             if (this.clientVehicleIsFloating && this.lastVehicle.getControllingPassenger() == this.player) {
-                 if (++this.aboveGroundVehicleTickCount > this.getMaximumFlyingTicks(this.lastVehicle)) {
-                     ServerGamePacketListenerImpl.LOGGER.warn("{} was kicked for floating a vehicle too long!", this.player.getName().getString());
--                    this.disconnect((Component) Component.translatable("multiplayer.disconnect.flying"));
-+                    this.disconnect(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.flyingVehicle); // Paper - use configurable kick message
-                     return;
-                 }
-             } else {

patches/unapplied/server/Configurable-packet-in-spam-threshold.patch

@@ -1,27 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Zach Brown <1254957+zachbr@users.noreply.github.com>
-Date: Sun, 11 Sep 2016 14:30:57 -0500
-Subject: [PATCH] Configurable packet in spam threshold
-
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-     // Spigot start - limit place/interactions
-     private int limitedPackets;
-     private long lastLimitedPacket = -1;
-+    private static int getSpamThreshold() { return io.papermc.paper.configuration.GlobalConfiguration.get().spamLimiter.incomingPacketThreshold; } // Paper - Configurable threshold
- 
-     private boolean checkLimit(long timestamp) {
--        if (this.lastLimitedPacket != -1 && timestamp - this.lastLimitedPacket < 30 && this.limitedPackets++ >= 4) {
-+        if (this.lastLimitedPacket != -1 && timestamp - this.lastLimitedPacket < getSpamThreshold() && this.limitedPackets++ >= 8) { // Paper - Configurable threshold; raise packet limit to 8
-             return false;
-         }
- 
--        if (this.lastLimitedPacket == -1 || timestamp - this.lastLimitedPacket >= 30) {
-+        if (this.lastLimitedPacket == -1 || timestamp - this.lastLimitedPacket >= getSpamThreshold()) { // Paper - Configurable threshold
-             this.lastLimitedPacket = timestamp;
-             this.limitedPackets = 0;
-             return true;

patches/unapplied/server/Configurable-speed-for-water-flowing-over-lava.patch

@@ -1,52 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Byteflux <byte@byteflux.net>
-Date: Wed, 8 Aug 2018 16:33:21 -0600
-Subject: [PATCH] Configurable speed for water flowing over lava
-
-
-diff --git a/src/main/java/net/minecraft/world/level/block/LiquidBlock.java b/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
-@@ -0,0 +0,0 @@ public class LiquidBlock extends Block implements BucketPickup {
-     @Override
-     protected void onPlace(BlockState state, Level world, BlockPos pos, BlockState oldState, boolean notify) {
-         if (this.shouldSpreadLiquid(world, pos, state)) {
--            world.scheduleTick(pos, state.getFluidState().getType(), this.fluid.getTickDelay(world));
-+            world.scheduleTick(pos, state.getFluidState().getType(), this.getFlowSpeed(world, pos)); // Paper - Configurable speed for water flowing over lava
-         }
- 
-     }
- 
-+    // Paper start - Configurable speed for water flowing over lava
-+    public int getFlowSpeed(Level world, BlockPos blockposition) {
-+        if (net.minecraft.core.registries.BuiltInRegistries.FLUID.wrapAsHolder(this.fluid).is(FluidTags.WATER)) {
-+            if (
-+                isLava(world, blockposition.north(1)) ||
-+                isLava(world, blockposition.south(1)) ||
-+                isLava(world, blockposition.west(1)) ||
-+                isLava(world, blockposition.east(1))
-+            ) {
-+                return world.paperConfig().environment.waterOverLavaFlowSpeed;
-+            }
-+        }
-+        return this.fluid.getTickDelay(world);
-+    }
-+    private static boolean isLava(Level world, BlockPos blockPos) {
-+        final FluidState fluidState = world.getFluidIfLoaded(blockPos);
-+        return fluidState != null && fluidState.is(FluidTags.LAVA);
-+    }
-+    // Paper end - Configurable speed for water flowing over lava
-+
-     @Override
-     protected BlockState updateShape(BlockState state, LevelReader world, ScheduledTickAccess tickView, BlockPos pos, Direction direction, BlockPos neighborPos, BlockState neighborState, RandomSource random) {
-         if (state.getFluidState().isSource() || neighborState.getFluidState().isSource()) {
-@@ -0,0 +0,0 @@ public class LiquidBlock extends Block implements BucketPickup {
-     @Override
-     protected void neighborChanged(BlockState state, Level world, BlockPos pos, Block sourceBlock, @Nullable Orientation wireOrientation, boolean notify) {
-         if (this.shouldSpreadLiquid(world, pos, state)) {
--            world.scheduleTick(pos, state.getFluidState().getType(), this.fluid.getTickDelay(world));
-+            world.scheduleTick(pos, state.getFluidState().getType(), this.getFlowSpeed(world, pos)); // Paper - Configurable speed for water flowing over lava
-         }
- 
-     }

patches/unapplied/server/Configurable-sprint-interruption-on-attack.patch

@@ -1,23 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Brokkonaut <hannos17@gmx.de>
-Date: Sat, 14 Apr 2018 20:20:46 +0200
-Subject: [PATCH] Configurable sprint interruption on attack
-
-If the sprint interruption is disabled players continue sprinting when they attack entities.
-
-diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/player/Player.java
-+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
-@@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
-                             }
- 
-                             this.setDeltaMovement(this.getDeltaMovement().multiply(0.6D, 1.0D, 0.6D));
-+                            // Paper start - Configurable sprint interruption on attack
-+                            if (!this.level().paperConfig().misc.disableSprintInterruptionOnAttack) {
-                             this.setSprinting(false);
-+                            }
-+                            // Paper end - Configurable sprint interruption on attack
-                         }
- 
-                         LivingEntity entityliving2;

patches/unapplied/server/Disable-Explicit-Network-Manager-Flushing.patch

@@ -1,34 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sun, 11 Mar 2018 14:13:33 -0400
-Subject: [PATCH] Disable Explicit Network Manager Flushing
-
-This seems completely pointless, as packet dispatch uses .writeAndFlush.
-
-Things seem to work fine without explicit flushing, but incase issues arise,
-provide a System property to re-enable it using improved logic of doing the
-flushing on the netty event loop, so it won't do the flush on the main thread.
-
-Renable flushing by passing -Dpaper.explicit-flush=true
-
-diff --git a/src/main/java/net/minecraft/network/Connection.java b/src/main/java/net/minecraft/network/Connection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/Connection.java
-+++ b/src/main/java/net/minecraft/network/Connection.java
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
-     // Paper start - NetworkClient implementation
-     public int protocolVersion;
-     public java.net.InetSocketAddress virtualHost;
-+    private static boolean enableExplicitFlush = Boolean.getBoolean("paper.explicit-flush"); // Paper - Disable explicit network manager flushing
-     // Paper end
- 
-     // Paper start - add utility methods
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
-         }
- 
-         if (this.channel != null) {
--            this.channel.flush();
-+            if (enableExplicitFlush) this.channel.eventLoop().execute(() -> this.channel.flush()); // Paper - Disable explicit network manager flushing; we don't need to explicit flush here, but allow opt in incase issues are found to a better version
-         }
- 
-         if (this.tickCount++ % 20 == 0) {

patches/unapplied/server/Do-not-submit-profile-lookups-to-worldgen-threads.patch

@@ -1,77 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Sun, 8 Aug 2021 16:26:46 -0700
-Subject: [PATCH] Do not submit profile lookups to worldgen threads
-
-They block. On network I/O.
-
-If enough tasks are submitted the server will eventually stall
-out due to a sync load, as the worldgen threads will be
-stalling on profile lookups.
-
-diff --git a/src/main/java/net/minecraft/Util.java b/src/main/java/net/minecraft/Util.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/Util.java
-+++ b/src/main/java/net/minecraft/Util.java
-@@ -0,0 +0,0 @@ public class Util {
-     private static final TracingExecutor BACKGROUND_EXECUTOR = makeExecutor("Main");
-     private static final TracingExecutor IO_POOL = makeIoExecutor("IO-Worker-", false);
-     private static final TracingExecutor DOWNLOAD_POOL = makeIoExecutor("Download-", true);
-+    // Paper start - don't submit BLOCKING PROFILE LOOKUPS to the world gen thread
-+    public static final ExecutorService PROFILE_EXECUTOR = Executors.newFixedThreadPool(2, new java.util.concurrent.ThreadFactory() {
-+
-+        private final AtomicInteger count = new AtomicInteger();
-+
-+        @Override
-+        public Thread newThread(Runnable run) {
-+            Thread ret = new Thread(run);
-+            ret.setName("Profile Lookup Executor #" + this.count.getAndIncrement());
-+            ret.setUncaughtExceptionHandler((Thread thread, Throwable throwable) -> {
-+                LOGGER.error("Uncaught exception in thread " + thread.getName(), throwable);
-+            });
-+            return ret;
-+        }
-+    });
-+    // Paper end - don't submit BLOCKING PROFILE LOOKUPS to the world gen thread
-     private static final DateTimeFormatter FILENAME_DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd_HH.mm.ss", Locale.ROOT);
-     public static final int LINEAR_LOOKUP_THRESHOLD = 8;
-     private static final Set<String> ALLOWED_UNTRUSTED_LINK_PROTOCOLS = Set.of("http", "https");
-diff --git a/src/main/java/net/minecraft/server/players/GameProfileCache.java b/src/main/java/net/minecraft/server/players/GameProfileCache.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/players/GameProfileCache.java
-+++ b/src/main/java/net/minecraft/server/players/GameProfileCache.java
-@@ -0,0 +0,0 @@ public class GameProfileCache {
-             } else {
-                 CompletableFuture<Optional<GameProfile>> completablefuture1 = CompletableFuture.supplyAsync(() -> {
-                     return this.get(username);
--                }, Util.backgroundExecutor().forName("getProfile")).whenCompleteAsync((optional, throwable) -> {
-+                }, Util.PROFILE_EXECUTOR).whenCompleteAsync((optional, throwable) -> { // Paper - don't submit BLOCKING PROFILE LOOKUPS to the world gen thread
-                     this.requests.remove(username);
-                 }, this.executor);
- 
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java
-@@ -0,0 +0,0 @@ public class SkullBlockEntity extends BlockEntity {
-                 ProfileResult profileResult = apiServices.sessionService().fetchProfile(uuid, true);
-                 return Optional.ofNullable(profileResult).map(ProfileResult::profile);
-             }
--        }, Util.backgroundExecutor().forName("fetchProfile"));
-+        }, Util.PROFILE_EXECUTOR); // Paper - don't submit BLOCKING PROFILE LOOKUPS to the world gen thread
-     }
- 
-     public static void clear() {
-diff --git a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
-+++ b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
-@@ -0,0 +0,0 @@ public final class CraftPlayerProfile implements PlayerProfile {
- 
-     @Override
-     public CompletableFuture<PlayerProfile> update() {
--        return CompletableFuture.supplyAsync(this::getUpdatedProfile, Util.backgroundExecutor());
-+        return CompletableFuture.supplyAsync(this::getUpdatedProfile, Util.PROFILE_EXECUTOR); // Paper - don't submit BLOCKING PROFILE LOOKUPS to the world gen thread
-     }
- 
-     private CraftPlayerProfile getUpdatedProfile() {

patches/unapplied/server/Don-t-lookup-game-profiles-that-have-no-UUID-and-no-.patch

@@ -1,18 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Zach Brown <1254957+zachbr@users.noreply.github.com>
-Date: Sat, 16 Jul 2016 19:11:17 -0500
-Subject: [PATCH] Don't lookup game profiles that have no UUID and no name
-
-
-diff --git a/src/main/java/net/minecraft/server/players/GameProfileCache.java b/src/main/java/net/minecraft/server/players/GameProfileCache.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/players/GameProfileCache.java
-+++ b/src/main/java/net/minecraft/server/players/GameProfileCache.java
-@@ -0,0 +0,0 @@ public class GameProfileCache {
-                 }
-             };
- 
-+        if (!org.apache.commons.lang3.StringUtils.isBlank(name)) // Paper - Don't lookup a profile with a blank name
-             repository.findProfilesByNames(new String[]{name}, profilelookupcallback);
-             GameProfile gameprofile = (GameProfile) atomicreference.get();
- 

patches/unapplied/server/EnderDragon-Events.patch

@@ -1,53 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Sat, 21 Jul 2018 01:51:27 -0500
-Subject: [PATCH] EnderDragon Events
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/boss/enderdragon/phases/DragonSittingFlamingPhase.java b/src/main/java/net/minecraft/world/entity/boss/enderdragon/phases/DragonSittingFlamingPhase.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/boss/enderdragon/phases/DragonSittingFlamingPhase.java
-+++ b/src/main/java/net/minecraft/world/entity/boss/enderdragon/phases/DragonSittingFlamingPhase.java
-@@ -0,0 +0,0 @@ public class DragonSittingFlamingPhase extends AbstractDragonSittingPhase {
-             this.flame.setDuration(200);
-             this.flame.setParticle(ParticleTypes.DRAGON_BREATH);
-             this.flame.addEffect(new MobEffectInstance(MobEffects.HARM));
-+            if (new com.destroystokyo.paper.event.entity.EnderDragonFlameEvent((org.bukkit.entity.EnderDragon) this.dragon.getBukkitEntity(), (org.bukkit.entity.AreaEffectCloud) this.flame.getBukkitEntity()).callEvent()) { // Paper - EnderDragon Events
-             world.addFreshEntity(this.flame);
-+            // Paper start - EnderDragon Events
-+            } else {
-+                this.end();
-+            }
-+            // Paper end - EnderDragon Events
-         }
- 
-     }
-diff --git a/src/main/java/net/minecraft/world/entity/boss/enderdragon/phases/DragonStrafePlayerPhase.java b/src/main/java/net/minecraft/world/entity/boss/enderdragon/phases/DragonStrafePlayerPhase.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/boss/enderdragon/phases/DragonStrafePlayerPhase.java
-+++ b/src/main/java/net/minecraft/world/entity/boss/enderdragon/phases/DragonStrafePlayerPhase.java
-@@ -0,0 +0,0 @@ public class DragonStrafePlayerPhase extends AbstractDragonPhaseInstance {
- 
-                         DragonFireball dragonFireball = new DragonFireball(world, this.dragon, vec34.normalize());
-                         dragonFireball.moveTo(o, p, q, 0.0F, 0.0F);
-+                        if (new com.destroystokyo.paper.event.entity.EnderDragonShootFireballEvent((org.bukkit.entity.EnderDragon) dragon.getBukkitEntity(), (org.bukkit.entity.DragonFireball) dragonFireball.getBukkitEntity()).callEvent()) // Paper - EnderDragon Events
-                         world.addFreshEntity(dragonFireball);
-+                        else dragonFireball.discard(null); // Paper - EnderDragon Events
-                         this.fireballCharge = 0;
-                         if (this.currentPath != null) {
-                             while (!this.currentPath.isDone()) {
-diff --git a/src/main/java/net/minecraft/world/entity/projectile/DragonFireball.java b/src/main/java/net/minecraft/world/entity/projectile/DragonFireball.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/projectile/DragonFireball.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/DragonFireball.java
-@@ -0,0 +0,0 @@ public class DragonFireball extends AbstractHurtingProjectile {
-                     }
-                 }
- 
-+                if (new com.destroystokyo.paper.event.entity.EnderDragonFireballHitEvent((org.bukkit.entity.DragonFireball) this.getBukkitEntity(), list.stream().map(LivingEntity::getBukkitLivingEntity).collect(java.util.stream.Collectors.toList()), (org.bukkit.entity.AreaEffectCloud) entityareaeffectcloud.getBukkitEntity()).callEvent()) { // Paper - EnderDragon Events
-                 this.level().levelEvent(2006, this.blockPosition(), this.isSilent() ? -1 : 1);
-                 this.level().addFreshEntity(entityareaeffectcloud);
-+                } else entityareaeffectcloud.discard(null); // Paper - EnderDragon Events
-                 this.discard(EntityRemoveEvent.Cause.HIT); // CraftBukkit - add Bukkit remove cause
-             }
- 

patches/unapplied/server/Enderman.teleportRandomly.patch

@@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Mon, 30 Apr 2018 13:29:44 -0400
-Subject: [PATCH] Enderman.teleportRandomly()
-
-Ability to trigger the vanilla "teleport randomly" mechanic of an enderman.
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEnderman.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEnderman.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEnderman.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEnderman.java
-@@ -0,0 +0,0 @@ public class CraftEnderman extends CraftMonster implements Enderman {
-         super(server, entity);
-     }
- 
-+    @Override public boolean teleportRandomly() { return getHandle().teleport(); } // Paper
-     @Override
-     public MaterialData getCarriedMaterial() {
-         BlockState blockData = this.getHandle().getCarriedBlock();

patches/unapplied/server/EndermanAttackPlayerEvent.patch

@@ -1,28 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Tue, 1 May 2018 20:18:54 -0400
-Subject: [PATCH] EndermanAttackPlayerEvent
-
-Allow control over whether or not an enderman aggros a player.
-
-This allows you to override/extend the pumpkin/stare logic.
-
-diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
-@@ -0,0 +0,0 @@ public class EnderMan extends Monster implements NeutralMob {
-     }
- 
-     boolean isBeingStaredBy(Player player) {
-+    // Paper start - EndermanAttackPlayerEvent
-+        boolean shouldAttack = isBeingStaredBy0(player);
-+        com.destroystokyo.paper.event.entity.EndermanAttackPlayerEvent event = new com.destroystokyo.paper.event.entity.EndermanAttackPlayerEvent((org.bukkit.entity.Enderman) getBukkitEntity(), (org.bukkit.entity.Player) player.getBukkitEntity());
-+        event.setCancelled(!shouldAttack);
-+        return event.callEvent();
-+    }
-+    private boolean isBeingStaredBy0(Player player) {
-+    // Paper end - EndermanAttackPlayerEvent
-         return this.isLookingAtMe(player, 0.025D, true, false, LivingEntity.PLAYER_NOT_WEARING_DISGUISE_ITEM, new DoubleSupplier[]{this::getEyeY});
-     }
- 

patches/unapplied/server/EndermanEscapeEvent.patch

@@ -1,58 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Mon, 30 Apr 2018 13:15:55 -0400
-Subject: [PATCH] EndermanEscapeEvent
-
-Fires an event anytime an enderman intends to teleport away from the player
-
-You may cancel this, enabling ranged attacks to damage the enderman for example.
-
-diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
-@@ -0,0 +0,0 @@ public class EnderMan extends Monster implements NeutralMob {
-         this.setTarget(target, EntityTargetEvent.TargetReason.UNKNOWN, true);
-     }
- 
-+    // Paper start - EndermanEscapeEvent
-+    private boolean tryEscape(com.destroystokyo.paper.event.entity.EndermanEscapeEvent.Reason reason) {
-+        return new com.destroystokyo.paper.event.entity.EndermanEscapeEvent((org.bukkit.craftbukkit.entity.CraftEnderman) this.getBukkitEntity(), reason).callEvent();
-+    }
-+    // Paper end - EndermanEscapeEvent
-+
-     @Override
-     public boolean setTarget(LivingEntity entityliving, EntityTargetEvent.TargetReason reason, boolean fireEvent) {
-         if (!super.setTarget(entityliving, reason, fireEvent)) {
-@@ -0,0 +0,0 @@ public class EnderMan extends Monster implements NeutralMob {
-         if (world.isDay() && this.tickCount >= this.targetChangeTime + 600) {
-             float f = this.getLightLevelDependentMagicValue();
- 
--            if (f > 0.5F && world.canSeeSky(this.blockPosition()) && this.random.nextFloat() * 30.0F < (f - 0.4F) * 2.0F) {
-+            if (f > 0.5F && world.canSeeSky(this.blockPosition()) && this.random.nextFloat() * 30.0F < (f - 0.4F) * 2.0F && this.tryEscape(com.destroystokyo.paper.event.entity.EndermanEscapeEvent.Reason.RUNAWAY)) { // Paper - EndermanEscapeEvent
-                 this.setTarget((LivingEntity) null);
-                 this.teleport();
-             }
-@@ -0,0 +0,0 @@ public class EnderMan extends Monster implements NeutralMob {
-             } else {
-                 flag1 = flag && this.hurtWithCleanWater(world, source, (ThrownPotion) source.getDirectEntity(), amount);
- 
-+                if (this.tryEscape(com.destroystokyo.paper.event.entity.EndermanEscapeEvent.Reason.INDIRECT)) { // Paper - EndermanEscapeEvent
-                 for (int i = 0; i < 64; ++i) {
-                     if (this.teleport()) {
-                         return true;
-                     }
-                 }
-+                } // Paper - EndermanEscapeEvent
- 
-                 return flag1;
-             }
-@@ -0,0 +0,0 @@ public class EnderMan extends Monster implements NeutralMob {
-             } else {
-                 if (this.target != null && !this.enderman.isPassenger()) {
-                     if (this.enderman.isBeingStaredBy((Player) this.target)) {
--                        if (this.target.distanceToSqr((Entity) this.enderman) < 16.0D) {
-+                        if (this.target.distanceToSqr((Entity) this.enderman) < 16.0D && this.enderman.tryEscape(com.destroystokyo.paper.event.entity.EndermanEscapeEvent.Reason.STARE)) { // Paper - EndermanEscapeEvent
-                             this.enderman.teleport();
-                         }
- 

patches/unapplied/server/Enforce-Sync-Player-Saves.patch

@@ -1,25 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sat, 7 Jan 2017 15:41:58 -0500
-Subject: [PATCH] Enforce Sync Player Saves
-
-Saving players async is extremely dangerous. This will force it to main
-the same way we handle async chunk loads.
-
-diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/players/PlayerList.java
-+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-     }
- 
-     public void saveAll() {
-+        io.papermc.paper.util.MCUtil.ensureMain("Save Players" , () -> { // Paper - Ensure main
-         for (int i = 0; i < this.players.size(); ++i) {
-             this.save((ServerPlayer) this.players.get(i));
-         }
- 
-+        return null; }); // Paper - ensure main
-     }
- 
-     public UserWhiteList getWhiteList() {

patches/unapplied/server/Entity-fromMobSpawner.patch

@@ -1,78 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Sun, 18 Jun 2017 18:17:05 -0500
-Subject: [PATCH] Entity#fromMobSpawner()
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-     public void inactiveTick() { }
-     // Spigot end
-     protected int numCollisions = 0; // Paper - Cap entity collisions
-+    public boolean spawnedViaMobSpawner; // Paper - Yes this name is similar to above, upstream took the better one
-     // Paper start - Entity origin API
-     @javax.annotation.Nullable
-     private org.bukkit.util.Vector origin;
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-                 }
-                 nbttagcompound.put("Paper.Origin", this.newDoubleList(origin.getX(), origin.getY(), origin.getZ()));
-             }
-+            // Save entity's from mob spawner status
-+            if (spawnedViaMobSpawner) {
-+                nbttagcompound.putBoolean("Paper.FromMobSpawner", true);
-+            }
-             // Paper end
-             return nbttagcompound;
-         } catch (Throwable throwable) {
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-                 this.originWorld = originWorld;
-                 origin = new org.bukkit.util.Vector(originTag.getDouble(0), originTag.getDouble(1), originTag.getDouble(2));
-             }
-+
-+            spawnedViaMobSpawner = nbt.getBoolean("Paper.FromMobSpawner"); // Restore entity's from mob spawner status
-             // Paper end
- 
-         } catch (Throwable throwable) {
-diff --git a/src/main/java/net/minecraft/world/level/BaseSpawner.java b/src/main/java/net/minecraft/world/level/BaseSpawner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/BaseSpawner.java
-+++ b/src/main/java/net/minecraft/world/level/BaseSpawner.java
-@@ -0,0 +0,0 @@ public abstract class BaseSpawner {
-                             // Spigot End
-                         }
- 
-+                        entity.spawnedViaMobSpawner = true; // Paper
-                         // CraftBukkit start
-                         if (org.bukkit.craftbukkit.event.CraftEventFactory.callSpawnerSpawnEvent(entity, pos).isCancelled()) {
-                             continue;
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/trialspawner/TrialSpawner.java b/src/main/java/net/minecraft/world/level/block/entity/trialspawner/TrialSpawner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/trialspawner/TrialSpawner.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/trialspawner/TrialSpawner.java
-@@ -0,0 +0,0 @@ public final class TrialSpawner {
-                                 optional1.ifPresent(entityinsentient::equip);
-                             }
- 
-+                            entity.spawnedViaMobSpawner = true; // Paper
-                             // CraftBukkit start
-                             if (org.bukkit.craftbukkit.event.CraftEventFactory.callTrialSpawnerSpawnEvent(entity, pos).isCancelled()) {
-                                 return Optional.empty();
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-@@ -0,0 +0,0 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
-         return originVector.toLocation(world);
-     }
-     // Paper end - entity origin API
-+
-+    // Paper start - Entity#fromMobSpawner
-+    @Override
-+    public boolean fromMobSpawner() {
-+        return this.getHandle().spawnedViaMobSpawner;
-+    }
-+    // Paper end - Entity#fromMobSpawner
- }

patches/unapplied/server/Expand-ArmorStand-API.patch

@@ -1,169 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: willies952002 <admin@domnian.com>
-Date: Thu, 26 Jul 2018 02:25:46 -0400
-Subject: [PATCH] Expand ArmorStand API
-
-Adds the following:
-- Add proper methods for getting and setting items in both hands. Deprecates old methods
-- Enable/Disable slot interactions
-- Allow using degrees for ArmorStand rotations (via new Rotations class)
-
-== AT ==
-public net.minecraft.world.entity.decoration.ArmorStand isDisabled(Lnet/minecraft/world/entity/EquipmentSlot;)Z
-
-Co-authored-by: SoSeDiK <mrsosedik@gmail.com>
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
-@@ -0,0 +0,0 @@ public class CraftArmorStand extends CraftLivingEntity implements ArmorStand {
-         getHandle().canMove = move;
-     }
- 
-+    @Override
-+    public ItemStack getItem(org.bukkit.inventory.EquipmentSlot slot) {
-+        com.google.common.base.Preconditions.checkArgument(slot != null, "slot");
-+        com.google.common.base.Preconditions.checkArgument(slot != EquipmentSlot.BODY, "Cannot get body item");
-+        return getHandle().getItemBySlot(org.bukkit.craftbukkit.CraftEquipmentSlot.getNMS(slot)).asBukkitMirror();
-+    }
-+
-+    @Override
-+    public void setItem(org.bukkit.inventory.EquipmentSlot slot, ItemStack item) {
-+        com.google.common.base.Preconditions.checkArgument(slot != null, "slot");
-+        com.google.common.base.Preconditions.checkArgument(slot != EquipmentSlot.BODY, "Cannot set body item");
-+        switch (slot) {
-+            case HAND:
-+                getEquipment().setItemInMainHand(item);
-+                return;
-+            case OFF_HAND:
-+                getEquipment().setItemInOffHand(item);
-+                return;
-+            case FEET:
-+                setBoots(item);
-+                return;
-+            case LEGS:
-+                setLeggings(item);
-+                return;
-+            case CHEST:
-+                setChestplate(item);
-+                return;
-+            case HEAD:
-+                setHelmet(item);
-+                return;
-+        }
-+        throw new UnsupportedOperationException(slot.name());
-+    }
-+
-+    @Override
-+    public java.util.Set<org.bukkit.inventory.EquipmentSlot> getDisabledSlots() {
-+        java.util.Set<org.bukkit.inventory.EquipmentSlot> disabled = new java.util.HashSet<>();
-+        for (org.bukkit.inventory.EquipmentSlot slot : org.bukkit.inventory.EquipmentSlot.values()) {
-+            if (this.isSlotDisabled(slot)) {
-+                disabled.add(slot);
-+            }
-+        }
-+        return disabled;
-+    }
-+
-+    @Override
-+    public void setDisabledSlots(org.bukkit.inventory.EquipmentSlot... slots) {
-+        int disabled = 0;
-+        for (org.bukkit.inventory.EquipmentSlot slot : slots) {
-+            if (slot == org.bukkit.inventory.EquipmentSlot.OFF_HAND) continue;
-+            net.minecraft.world.entity.EquipmentSlot nmsSlot = org.bukkit.craftbukkit.CraftEquipmentSlot.getNMS(slot);
-+            disabled += (1 << nmsSlot.getFilterBit(0)) + (1 << nmsSlot.getFilterBit(8)) + (1 << nmsSlot.getFilterBit(16));
-+        }
-+        getHandle().disabledSlots = disabled;
-+    }
-+
-+    @Override
-+    public void addDisabledSlots(org.bukkit.inventory.EquipmentSlot... slots) {
-+        java.util.Set<org.bukkit.inventory.EquipmentSlot> disabled = getDisabledSlots();
-+        java.util.Collections.addAll(disabled, slots);
-+        setDisabledSlots(disabled.toArray(new org.bukkit.inventory.EquipmentSlot[0]));
-+    }
-+
-+    @Override
-+    public void removeDisabledSlots(org.bukkit.inventory.EquipmentSlot... slots) {
-+        java.util.Set<org.bukkit.inventory.EquipmentSlot> disabled = getDisabledSlots();
-+        for (final org.bukkit.inventory.EquipmentSlot slot : slots) disabled.remove(slot);
-+        setDisabledSlots(disabled.toArray(new org.bukkit.inventory.EquipmentSlot[0]));
-+    }
-+
-+    @Override
-+    public boolean isSlotDisabled(org.bukkit.inventory.EquipmentSlot slot) {
-+        return getHandle().isDisabled(org.bukkit.craftbukkit.CraftEquipmentSlot.getNMS(slot));
-+    }
-+
-+    @Override
-+    public io.papermc.paper.math.Rotations getBodyRotations() {
-+        return fromNMSRotations(getHandle().bodyPose);
-+    }
-+
-+    @Override
-+    public void setBodyRotations(io.papermc.paper.math.Rotations rotations) {
-+        getHandle().setBodyPose(toNMSRotations(rotations));
-+    }
-+
-+    @Override
-+    public io.papermc.paper.math.Rotations getLeftArmRotations() {
-+        return fromNMSRotations(getHandle().leftArmPose);
-+    }
-+
-+    @Override
-+    public void setLeftArmRotations(io.papermc.paper.math.Rotations rotations) {
-+        getHandle().setLeftArmPose(toNMSRotations(rotations));
-+    }
-+
-+    @Override
-+    public io.papermc.paper.math.Rotations getRightArmRotations() {
-+        return fromNMSRotations(getHandle().rightArmPose);
-+    }
-+
-+    @Override
-+    public void setRightArmRotations(io.papermc.paper.math.Rotations rotations) {
-+        getHandle().setRightArmPose(toNMSRotations(rotations));
-+    }
-+
-+    @Override
-+    public io.papermc.paper.math.Rotations getLeftLegRotations() {
-+        return fromNMSRotations(getHandle().leftLegPose);
-+    }
-+
-+    @Override
-+    public void setLeftLegRotations(io.papermc.paper.math.Rotations rotations) {
-+        getHandle().setLeftLegPose(toNMSRotations(rotations));
-+    }
-+
-+    @Override
-+    public io.papermc.paper.math.Rotations getRightLegRotations() {
-+        return fromNMSRotations(getHandle().rightLegPose);
-+    }
-+
-+    @Override
-+    public void setRightLegRotations(io.papermc.paper.math.Rotations rotations) {
-+        getHandle().setRightLegPose(toNMSRotations(rotations));
-+    }
-+
-+    @Override
-+    public io.papermc.paper.math.Rotations getHeadRotations() {
-+        return fromNMSRotations(getHandle().headPose);
-+    }
-+
-+    @Override
-+    public void setHeadRotations(io.papermc.paper.math.Rotations rotations) {
-+        getHandle().setHeadPose(toNMSRotations(rotations));
-+    }
-+
-+    private static io.papermc.paper.math.Rotations fromNMSRotations(Rotations old) {
-+        return io.papermc.paper.math.Rotations.ofDegrees(old.getX(), old.getY(), old.getZ());
-+    }
-+
-+    private static Rotations toNMSRotations(io.papermc.paper.math.Rotations old) {
-+        return new Rotations((float) old.x(), (float) old.y(), (float) old.z());
-+    }
-+
-     @Override
-     public boolean canTick() {
-         return this.getHandle().canTick;

patches/unapplied/server/Expand-Explosions-API.patch

@@ -1,87 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Wed, 20 Jun 2018 23:17:24 -0400
-Subject: [PATCH] Expand Explosions API
-
-Add Entity as a Source capability, and add more API choices, and on Location.
-
-Co-authored-by: Esoteric Enderman <90862990+EsotericEnderman@users.noreply.github.com>
-Co-authored-by: Bjarne Koll <git@lynxplay.dev>
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
-     }
- 
-     public ServerExplosion explode0(@Nullable Entity entity, @Nullable DamageSource damagesource, @Nullable ExplosionDamageCalculator explosiondamagecalculator, double d0, double d1, double d2, float f, boolean flag, Level.ExplosionInteraction world_a, ParticleOptions particleparam, ParticleOptions particleparam1, Holder<SoundEvent> holder) {
-+    // Paper start - Allow explosions to damage source
-+        return this.explode0(entity, damagesource, explosiondamagecalculator, d0, d1, d2, f, flag, world_a, particleparam, particleparam1, holder, null);
-+    }
-+    public ServerExplosion explode0(@Nullable Entity entity, @Nullable DamageSource damagesource, @Nullable ExplosionDamageCalculator explosiondamagecalculator, double d0, double d1, double d2, float f, boolean flag, Level.ExplosionInteraction world_a, ParticleOptions particleparam, ParticleOptions particleparam1, Holder<SoundEvent> holder, java.util.function.Consumer<ServerExplosion> configurator) {
-+    // Paper end - Allow explosions to damage source
-         // CraftBukkit end
-         Explosion.BlockInteraction explosion_effect;
- 
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
-         Explosion.BlockInteraction explosion_effect1 = explosion_effect;
-         Vec3 vec3d = new Vec3(d0, d1, d2);
-         ServerExplosion serverexplosion = new ServerExplosion(this, entity, damagesource, explosiondamagecalculator, vec3d, f, flag, explosion_effect1);
-+        if (configurator != null) configurator.accept(serverexplosion);// Paper - Allow explosions to damage source
- 
-         serverexplosion.explode();
-         // CraftBukkit start
-diff --git a/src/main/java/net/minecraft/world/level/ServerExplosion.java b/src/main/java/net/minecraft/world/level/ServerExplosion.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/ServerExplosion.java
-+++ b/src/main/java/net/minecraft/world/level/ServerExplosion.java
-@@ -0,0 +0,0 @@ public class ServerExplosion implements Explosion {
-     public boolean wasCanceled = false;
-     public float yield;
-     // CraftBukkit end
-+    public boolean excludeSourceFromDamage = true; // Paper - Allow explosions to damage source
- 
-     public ServerExplosion(ServerLevel world, @Nullable Entity entity, @Nullable DamageSource damageSource, @Nullable ExplosionDamageCalculator behavior, Vec3 pos, float power, boolean createFire, Explosion.BlockInteraction destructionType) {
-         this.level = world;
-@@ -0,0 +0,0 @@ public class ServerExplosion implements Explosion {
-         int l = Mth.floor(this.center.y + (double) f + 1.0D);
-         int i1 = Mth.floor(this.center.z - (double) f - 1.0D);
-         int j1 = Mth.floor(this.center.z + (double) f + 1.0D);
--        List<Entity> list = this.level.getEntities(this.source, new AABB((double) i, (double) k, (double) i1, (double) j, (double) l, (double) j1), (com.google.common.base.Predicate<Entity>) entity -> entity.isAlive() && !entity.isSpectator()); // Paper - Fix lag from explosions processing dead entities
-+        List<Entity> list = this.level.getEntities(excludeSourceFromDamage ? this.source : null, new AABB((double) i, (double) k, (double) i1, (double) j, (double) l, (double) j1), (com.google.common.base.Predicate<Entity>) entity -> entity.isAlive() && !entity.isSpectator()); // Paper - Fix lag from explosions processing dead entities, Allow explosions to damage source
-         Iterator iterator = list.iterator();
- 
-         while (iterator.hasNext()) {
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor implements World {
- 
-     @Override
-     public boolean createExplosion(double x, double y, double z, float power, boolean setFire, boolean breakBlocks, Entity source) {
-+    // Paper start - expand explosion API
-+        return this.createExplosion(x, y, z, power, setFire, breakBlocks, source, null);
-+    }
-+    public boolean createExplosion(double x, double y, double z, float power, boolean setFire, boolean breakBlocks, Entity source, Consumer<net.minecraft.world.level.ServerExplosion> configurator) {
-+    // Paper end - expand explosion API
-         net.minecraft.world.level.Level.ExplosionInteraction explosionType;
-         if (!breakBlocks) {
-             explosionType = net.minecraft.world.level.Level.ExplosionInteraction.NONE; // Don't break blocks
-@@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor implements World {
-         }
- 
-         net.minecraft.world.entity.Entity entity = (source == null) ? null : ((CraftEntity) source).getHandle();
--        return !this.world.explode0(entity, Explosion.getDefaultDamageSource(this.world, entity), null, x, y, z, power, setFire, explosionType, ParticleTypes.EXPLOSION, ParticleTypes.EXPLOSION_EMITTER, SoundEvents.GENERIC_EXPLODE).wasCanceled;
-+        return !this.world.explode0(entity, Explosion.getDefaultDamageSource(this.world, entity), null, x, y, z, power, setFire, explosionType, ParticleTypes.EXPLOSION, ParticleTypes.EXPLOSION_EMITTER, SoundEvents.GENERIC_EXPLODE, configurator).wasCanceled; // Paper - expand explosion API
-     }
-+    // Paper start
-+    @Override
-+    public boolean createExplosion(Entity source, Location loc, float power, boolean setFire, boolean breakBlocks, boolean excludeSourceFromDamage) {
-+        return this.createExplosion(loc.x(), loc.getY(), loc.getZ(), power, setFire, breakBlocks, source, e -> e.excludeSourceFromDamage = excludeSourceFromDamage);
-+    }
-+    // Paper end
- 
-     @Override
-     public boolean createExplosion(Location loc, float power) {

patches/unapplied/server/Expand-World.spawnParticle-API-and-add-Builder.patch

@@ -1,60 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Tue, 15 Aug 2017 22:29:12 -0400
-Subject: [PATCH] Expand World.spawnParticle API and add Builder
-
-Adds ability to control who receives it and who is the source/sender (vanish API)
-the standard API is to send the packet to everyone in the world, which is ineffecient.
-Adds an option to control the force mode of the particle.
-
-This adds a new Builder API which is much friendlier to use.
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
-     }
- 
-     public <T extends ParticleOptions> int sendParticles(ServerPlayer sender, T t0, double d0, double d1, double d2, int i, double d3, double d4, double d5, double d6, boolean force) {
-+        // Paper start - Particle API
-+        return sendParticles(players, sender, t0, d0, d1, d2, i, d3, d4, d5, d6, force);
-+    }
-+    public <T extends ParticleOptions> int sendParticles(List<ServerPlayer> receivers, @Nullable ServerPlayer sender, T t0, double d0, double d1, double d2, int i, double d3, double d4, double d5, double d6, boolean force) {
-+        // Paper end - Particle API
-         ClientboundLevelParticlesPacket packetplayoutworldparticles = new ClientboundLevelParticlesPacket(t0, force, d0, d1, d2, (float) d3, (float) d4, (float) d5, (float) d6, i);
-         // CraftBukkit end
-         int j = 0;
- 
--        for (int k = 0; k < this.players.size(); ++k) {
--            ServerPlayer entityplayer = (ServerPlayer) this.players.get(k);
-+        for (Player entityhuman : receivers) { // Paper - Particle API
-+            ServerPlayer entityplayer = (ServerPlayer) entityhuman; // Paper - Particle API
-             if (sender != null && !entityplayer.getBukkitEntity().canSee(sender.getBukkitEntity())) continue; // CraftBukkit
- 
-             if (this.sendParticles(entityplayer, force, d0, d1, d2, packetplayoutworldparticles)) { // CraftBukkit
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor implements World {
- 
-     @Override
-     public <T> void spawnParticle(Particle particle, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ, double extra, T data, boolean force) {
-+        // Paper start - Particle API
-+        this.spawnParticle(particle, null, null, x, y, z, count, offsetX, offsetY, offsetZ, extra, data, force);
-+    }
-+    @Override
-+    public <T> void spawnParticle(Particle particle, List<Player> receivers, Player sender, double x, double y, double z, int count, double offsetX, double offsetY, double offsetZ, double extra, T data, boolean force) {
-+        // Paper end - Particle API
-+        data = CraftParticle.convertLegacy(data);
-+        if (data != null) {
-+            Preconditions.checkArgument(particle.getDataType().isInstance(data), "data (%s) should be %s", data.getClass(), particle.getDataType());
-+        }
-         this.getHandle().sendParticles(
--                null, // Sender
-+                receivers == null ? this.getHandle().players() : receivers.stream().map(player -> ((CraftPlayer) player).getHandle()).collect(java.util.stream.Collectors.toList()), // Paper -  Particle API
-+                sender != null ? ((CraftPlayer) sender).getHandle() : null, // Sender // Paper - Particle API
-                 CraftParticle.createParticleParam(particle, data), // Particle
-                 x, y, z, // Position
-                 count,  // Count

patches/unapplied/server/ExperienceOrbs-API-for-Reason-Source-Triggering-play.patch

@@ -1,354 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Tue, 19 Dec 2017 16:31:46 -0500
-Subject: [PATCH] ExperienceOrbs API for Reason/Source/Triggering player
-
-Adds lots of information about why this orb exists.
-
-Replaces isFromBottle() with logic that persists entity reloads too.
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-@@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
- 
-                 // Drop event experience
-                 if (flag && event != null) {
--                    iblockdata.getBlock().popExperience(this.level, pos, event.getExpToDrop());
-+                    iblockdata.getBlock().popExperience(this.level, pos, event.getExpToDrop(), this.player); // Paper
-                 }
- 
-                 return true;
-diff --git a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-+++ b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-@@ -0,0 +0,0 @@ public class ExperienceOrb extends Entity {
-     public int value;
-     public int count;
-     private Player followingPlayer;
-+    // Paper start
-+    @javax.annotation.Nullable
-+    public java.util.UUID sourceEntityId;
-+    @javax.annotation.Nullable
-+    public java.util.UUID triggerEntityId;
-+    public org.bukkit.entity.ExperienceOrb.SpawnReason spawnReason = org.bukkit.entity.ExperienceOrb.SpawnReason.UNKNOWN;
-+
-+    private void loadPaperNBT(CompoundTag tag) {
-+        if (!tag.contains("Paper.ExpData", net.minecraft.nbt.Tag.TAG_COMPOUND)) {
-+            return;
-+        }
-+        CompoundTag comp = tag.getCompound("Paper.ExpData");
-+        if (comp.hasUUID("source")) {
-+            this.sourceEntityId = comp.getUUID("source");
-+        }
-+        if (comp.hasUUID("trigger")) {
-+            this.triggerEntityId = comp.getUUID("trigger");
-+        }
-+        if (comp.contains("reason")) {
-+            String reason = comp.getString("reason");
-+            try {
-+                this.spawnReason = org.bukkit.entity.ExperienceOrb.SpawnReason.valueOf(reason);
-+            } catch (Exception e) {
-+                this.level().getCraftServer().getLogger().warning("Invalid spawnReason set for experience orb: " + e.getMessage() + " - " + reason);
-+            }
-+        }
-+    }
-+    private void savePaperNBT(CompoundTag tag) {
-+        CompoundTag comp = new CompoundTag();
-+        if (this.sourceEntityId != null) {
-+            comp.putUUID("source", this.sourceEntityId);
-+        }
-+        if (this.triggerEntityId != null) {
-+            comp.putUUID("trigger", triggerEntityId);
-+        }
-+        if (this.spawnReason != null && this.spawnReason != org.bukkit.entity.ExperienceOrb.SpawnReason.UNKNOWN) {
-+            comp.putString("reason", this.spawnReason.name());
-+        }
-+        tag.put("Paper.ExpData", comp);
-+    }
- 
-+    @io.papermc.paper.annotation.DoNotUse
-+    @Deprecated
-     public ExperienceOrb(Level world, double x, double y, double z, int amount) {
-+        this(world, x, y, z, amount, null, null);
-+    }
-+
-+    public ExperienceOrb(Level world, double x, double y, double z, int amount, @javax.annotation.Nullable org.bukkit.entity.ExperienceOrb.SpawnReason reason, @javax.annotation.Nullable Entity triggerId) {
-+        this(world, x, y, z, amount, reason, triggerId, null);
-+    }
-+
-+    public ExperienceOrb(Level world, double x, double y, double z, int amount, @javax.annotation.Nullable org.bukkit.entity.ExperienceOrb.SpawnReason reason, @javax.annotation.Nullable Entity triggerId, @javax.annotation.Nullable Entity sourceId) {
-         this(EntityType.EXPERIENCE_ORB, world);
-+        this.sourceEntityId = sourceId != null ? sourceId.getUUID() : null;
-+        this.triggerEntityId = triggerId != null ? triggerId.getUUID() : null;
-+        this.spawnReason = reason != null ? reason : org.bukkit.entity.ExperienceOrb.SpawnReason.UNKNOWN;
-+        // Paper end
-         this.setPos(x, y, z);
-         this.setYRot((float) (this.random.nextDouble() * 360.0D));
-         this.setDeltaMovement((this.random.nextDouble() * 0.20000000298023224D - 0.10000000149011612D) * 2.0D, this.random.nextDouble() * 0.2D * 2.0D, (this.random.nextDouble() * 0.20000000298023224D - 0.10000000149011612D) * 2.0D);
-@@ -0,0 +0,0 @@ public class ExperienceOrb extends Entity {
-     }
- 
-     public static void award(ServerLevel world, Vec3 pos, int amount) {
-+        // Paper start - add reasons for orbs
-+        award(world, pos, amount, null, null, null);
-+    }
-+    public static void award(ServerLevel world, Vec3 pos, int amount, org.bukkit.entity.ExperienceOrb.SpawnReason reason, Entity triggerId) {
-+        award(world, pos, amount, reason, triggerId, null);
-+    }
-+    public static void award(ServerLevel world, Vec3 pos, int amount, org.bukkit.entity.ExperienceOrb.SpawnReason reason, Entity triggerId, Entity sourceId) {
-+        // Paper end - add reasons for orbs
-         while (amount > 0) {
-             int j = ExperienceOrb.getExperienceValue(amount);
- 
-             amount -= j;
-             if (!ExperienceOrb.tryMergeToExisting(world, pos, j)) {
--                world.addFreshEntity(new ExperienceOrb(world, pos.x(), pos.y(), pos.z(), j));
-+                world.addFreshEntity(new ExperienceOrb(world, pos.x(), pos.y(), pos.z(), j, reason, triggerId, sourceId)); // Paper - add reason
-             }
-         }
- 
-@@ -0,0 +0,0 @@ public class ExperienceOrb extends Entity {
-         nbt.putShort("Age", (short) this.age);
-         nbt.putShort("Value", (short) this.value);
-         nbt.putInt("Count", this.count);
-+        this.savePaperNBT(nbt); // Paper
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class ExperienceOrb extends Entity {
-         this.age = nbt.getShort("Age");
-         this.value = nbt.getShort("Value");
-         this.count = Math.max(nbt.getInt("Count"), 1);
-+        this.loadPaperNBT(nbt); // Paper
-     }
- 
-     @Override
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-     protected void dropExperience(ServerLevel world, @Nullable Entity attacker) {
-         // CraftBukkit start - Update getExpReward() above if the removed if() changes!
-         if (!(this instanceof net.minecraft.world.entity.boss.enderdragon.EnderDragon)) { // CraftBukkit - SPIGOT-2420: Special case ender dragon will drop the xp over time
--            ExperienceOrb.award(world, this.position(), this.expToDrop);
-+            ExperienceOrb.award(world, this.position(), this.expToDrop, this instanceof ServerPlayer ? org.bukkit.entity.ExperienceOrb.SpawnReason.PLAYER_DEATH : org.bukkit.entity.ExperienceOrb.SpawnReason.ENTITY_DEATH, attacker, this); // Paper
-             this.expToDrop = 0;
-         }
-         // CraftBukkit end
-diff --git a/src/main/java/net/minecraft/world/entity/animal/Animal.java b/src/main/java/net/minecraft/world/entity/animal/Animal.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/animal/Animal.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/Animal.java
-@@ -0,0 +0,0 @@ public abstract class Animal extends AgeableMob {
- 
-     public void finalizeSpawnChildFromBreeding(ServerLevel worldserver, Animal entityanimal, @Nullable AgeableMob entityageable, int experience) {
-         // CraftBukkit end
--        Optional.ofNullable(this.getLoveCause()).or(() -> {
--            return Optional.ofNullable(entityanimal.getLoveCause());
--        }).ifPresent((entityplayer) -> {
-+        // Paper start
-+        ServerPlayer entityplayer = this.getLoveCause();
-+        if (entityplayer == null) entityplayer = entityanimal.getLoveCause();
-+        if (entityplayer != null) {
-+            // Paper end
-             entityplayer.awardStat(Stats.ANIMALS_BRED);
-             CriteriaTriggers.BRED_ANIMALS.trigger(entityplayer, this, entityanimal, entityageable);
--        });
-+        } // Paper
-         this.setAge(6000);
-         entityanimal.setAge(6000);
-         this.resetLove();
-@@ -0,0 +0,0 @@ public abstract class Animal extends AgeableMob {
-         if (worldserver.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
-             // CraftBukkit start - use event experience
-             if (experience > 0) {
--                worldserver.addFreshEntity(new ExperienceOrb(worldserver, this.getX(), this.getY(), this.getZ(), experience));
-+                worldserver.addFreshEntity(new ExperienceOrb(worldserver, this.getX(), this.getY(), this.getZ(), experience, org.bukkit.entity.ExperienceOrb.SpawnReason.BREED, entityplayer, entityageable)); // Paper
-             }
-             // CraftBukkit end
-         }
-diff --git a/src/main/java/net/minecraft/world/entity/animal/Fox.java b/src/main/java/net/minecraft/world/entity/animal/Fox.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/animal/Fox.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/Fox.java
-@@ -0,0 +0,0 @@ public class Fox extends Animal implements VariantHolder<Fox.Variant> {
-                 if (worldserver.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
-                     // CraftBukkit start - use event experience
-                     if (experience > 0) {
--                        this.level.addFreshEntity(new ExperienceOrb(this.level, this.animal.getX(), this.animal.getY(), this.animal.getZ(), experience));
-+                        this.level.addFreshEntity(new ExperienceOrb(this.level, this.animal.getX(), this.animal.getY(), this.animal.getZ(), experience, org.bukkit.entity.ExperienceOrb.SpawnReason.BREED, entityplayer, entityfox)); // Paper
-                     }
-                     // CraftBukkit end
-                 }
-diff --git a/src/main/java/net/minecraft/world/entity/animal/Turtle.java b/src/main/java/net/minecraft/world/entity/animal/Turtle.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/animal/Turtle.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/Turtle.java
-@@ -0,0 +0,0 @@ public class Turtle extends Animal {
-             RandomSource randomsource = this.animal.getRandom();
- 
-             if (getServerLevel((Level) this.level).getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
--                this.level.addFreshEntity(new ExperienceOrb(this.level, this.animal.getX(), this.animal.getY(), this.animal.getZ(), randomsource.nextInt(7) + 1));
-+                this.level.addFreshEntity(new ExperienceOrb(this.level, this.animal.getX(), this.animal.getY(), this.animal.getZ(), randomsource.nextInt(7) + 1, org.bukkit.entity.ExperienceOrb.SpawnReason.BREED, entityplayer)); // Paper;
-             }
- 
-         }
-diff --git a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
-+++ b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
-@@ -0,0 +0,0 @@ public class EnderDragon extends Mob implements Enemy {
- 
-         if (world instanceof ServerLevel worldserver) {
-             if (this.dragonDeathTime > 150 && this.dragonDeathTime % 5 == 0 && true) {  // CraftBukkit - SPIGOT-2420: Already checked for the game rule when calculating the xp
--                ExperienceOrb.award(worldserver, this.position(), Mth.floor((float) short0 * 0.08F));
-+                ExperienceOrb.award(worldserver, this.position(), Mth.floor((float) short0 * 0.08F), org.bukkit.entity.ExperienceOrb.SpawnReason.ENTITY_DEATH, this.lastHurtByPlayer, this); // Paper
-             }
- 
-             if (this.dragonDeathTime == 1 && !this.isSilent()) {
-@@ -0,0 +0,0 @@ public class EnderDragon extends Mob implements Enemy {
-             if (world instanceof ServerLevel) {
-                 ServerLevel worldserver = (ServerLevel) world; // CraftBukkit - decompile error
-                 if (true) { // CraftBukkit - SPIGOT-2420: Already checked for the game rule when calculating the xp
--                    ExperienceOrb.award(worldserver, this.position(), Mth.floor((float) short0 * 0.2F));
-+                    ExperienceOrb.award(worldserver, this.position(), Mth.floor((float) short0 * 0.2F), org.bukkit.entity.ExperienceOrb.SpawnReason.ENTITY_DEATH, this.lastHurtByPlayer, this); // Paper
-                 }
- 
-                 if (this.dragonFight != null) {
-diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
-+++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
-@@ -0,0 +0,0 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
-         }
- 
-         if (offer.shouldRewardExp()) {
--            this.level().addFreshEntity(new ExperienceOrb(this.level(), this.getX(), this.getY() + 0.5D, this.getZ(), i));
-+            this.level().addFreshEntity(new ExperienceOrb(this.level(), this.getX(), this.getY() + 0.5D, this.getZ(), i, org.bukkit.entity.ExperienceOrb.SpawnReason.VILLAGER_TRADE, this.getTradingPlayer(), this)); // Paper
-         }
- 
-     }
-diff --git a/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java b/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
-+++ b/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
-@@ -0,0 +0,0 @@ public class WanderingTrader extends net.minecraft.world.entity.npc.AbstractVill
-         if (offer.shouldRewardExp()) {
-             int i = 3 + this.random.nextInt(4);
- 
--            this.level().addFreshEntity(new ExperienceOrb(this.level(), this.getX(), this.getY() + 0.5D, this.getZ(), i));
-+            this.level().addFreshEntity(new ExperienceOrb(this.level(), this.getX(), this.getY() + 0.5D, this.getZ(), i, org.bukkit.entity.ExperienceOrb.SpawnReason.VILLAGER_TRADE, this.getTradingPlayer(), this)); // Paper
-         }
- 
-     }
-diff --git a/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java b/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/FishingHook.java
-@@ -0,0 +0,0 @@ public class FishingHook extends Projectile {
-                     this.level().addFreshEntity(entityitem);
-                     // CraftBukkit start - this.random.nextInt(6) + 1 -> playerFishEvent.getExpToDrop()
-                     if (playerFishEvent.getExpToDrop() > 0) {
--                        entityhuman.level().addFreshEntity(new ExperienceOrb(entityhuman.level(), entityhuman.getX(), entityhuman.getY() + 0.5D, entityhuman.getZ() + 0.5D, playerFishEvent.getExpToDrop()));
-+                        entityhuman.level().addFreshEntity(new ExperienceOrb(entityhuman.level(), entityhuman.getX(), entityhuman.getY() + 0.5D, entityhuman.getZ() + 0.5D, playerFishEvent.getExpToDrop(), org.bukkit.entity.ExperienceOrb.SpawnReason.FISHING, this.getPlayerOwner(), this)); // Paper
-                     }
-                     // CraftBukkit end
-                     if (itemstack1.is(ItemTags.FISHES)) {
-diff --git a/src/main/java/net/minecraft/world/entity/projectile/ThrownExperienceBottle.java b/src/main/java/net/minecraft/world/entity/projectile/ThrownExperienceBottle.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/projectile/ThrownExperienceBottle.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/ThrownExperienceBottle.java
-@@ -0,0 +0,0 @@ public class ThrownExperienceBottle extends ThrowableItemProjectile {
-             }
-             // CraftBukkit end
- 
--            ExperienceOrb.award((ServerLevel) this.level(), this.position(), i);
-+            ExperienceOrb.award((ServerLevel) this.level(), this.position(), i, org.bukkit.entity.ExperienceOrb.SpawnReason.EXP_BOTTLE, this.getOwner(), this); // Paper
-             this.discard(EntityRemoveEvent.Cause.HIT); // CraftBukkit - add Bukkit remove cause
-         }
- 
-diff --git a/src/main/java/net/minecraft/world/inventory/GrindstoneMenu.java b/src/main/java/net/minecraft/world/inventory/GrindstoneMenu.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/inventory/GrindstoneMenu.java
-+++ b/src/main/java/net/minecraft/world/inventory/GrindstoneMenu.java
-@@ -0,0 +0,0 @@ public class GrindstoneMenu extends AbstractContainerMenu {
-             public void onTake(net.minecraft.world.entity.player.Player player, ItemStack stack) {
-                 context.execute((world, blockposition) -> {
-                     if (world instanceof ServerLevel) {
--                        ExperienceOrb.award((ServerLevel) world, Vec3.atCenterOf(blockposition), this.getExperienceAmount(world));
-+                        ExperienceOrb.award((ServerLevel) world, Vec3.atCenterOf(blockposition), this.getExperienceAmount(world), org.bukkit.entity.ExperienceOrb.SpawnReason.GRINDSTONE, player); // Paper
-                     }
- 
-                     world.levelEvent(1042, blockposition, 0);
-diff --git a/src/main/java/net/minecraft/world/level/block/Block.java b/src/main/java/net/minecraft/world/level/block/Block.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/Block.java
-+++ b/src/main/java/net/minecraft/world/level/block/Block.java
-@@ -0,0 +0,0 @@ public class Block extends BlockBehaviour implements ItemLike {
-     }
- 
-     public void popExperience(ServerLevel world, BlockPos pos, int size) {
-+        // Paper start - add entity parameter
-+        popExperience(world, pos, size, null);
-+    }
-+    public void popExperience(ServerLevel world, BlockPos pos, int size, net.minecraft.world.entity.Entity entity) {
-+        // Paper end - add entity parameter
-         if (world.getGameRules().getBoolean(GameRules.RULE_DOBLOCKDROPS)) {
--            ExperienceOrb.award(world, Vec3.atCenterOf(pos), size);
-+            ExperienceOrb.award(world, Vec3.atCenterOf(pos), size, org.bukkit.entity.ExperienceOrb.SpawnReason.BLOCK_BREAK, entity); // Paper
-         }
- 
-     }
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
-@@ -0,0 +0,0 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
-         j = event.getExpToDrop();
-         // CraftBukkit end
- 
--        ExperienceOrb.award(worldserver, vec3d, j);
-+        ExperienceOrb.award(worldserver, vec3d, j, org.bukkit.entity.ExperienceOrb.SpawnReason.FURNACE, entityhuman); // Paper
-     }
- 
-     @Override
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntityTypes.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntityTypes.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntityTypes.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntityTypes.java
-@@ -0,0 +0,0 @@ public final class CraftEntityTypes {
-             return item;
-         }));
-         register(new EntityTypeData<>(EntityType.EXPERIENCE_ORB, ExperienceOrb.class, CraftExperienceOrb::new,
--                spawnData -> new net.minecraft.world.entity.ExperienceOrb(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), 0)
-+                spawnData -> new net.minecraft.world.entity.ExperienceOrb(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), 0, org.bukkit.entity.ExperienceOrb.SpawnReason.CUSTOM, null, null) // Paper
-         ));
-         register(new EntityTypeData<>(EntityType.AREA_EFFECT_CLOUD, AreaEffectCloud.class, CraftAreaEffectCloud::new, spawnData -> new net.minecraft.world.entity.AreaEffectCloud(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z())));
-         register(new EntityTypeData<>(EntityType.EGG, Egg.class, CraftEgg::new, spawnData -> new ThrownEgg(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), new net.minecraft.world.item.ItemStack(Items.EGG))));
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftExperienceOrb.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftExperienceOrb.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftExperienceOrb.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftExperienceOrb.java
-@@ -0,0 +0,0 @@ public class CraftExperienceOrb extends CraftEntity implements ExperienceOrb {
-         this.getHandle().value = value;
-     }
- 
-+    // Paper start
-+    public java.util.UUID getTriggerEntityId() {
-+        return getHandle().triggerEntityId;
-+    }
-+    public java.util.UUID getSourceEntityId() {
-+        return getHandle().sourceEntityId;
-+    }
-+    public SpawnReason getSpawnReason() {
-+        return getHandle().spawnReason;
-+    }
-+    // Paper end
-+
-     @Override
-     public net.minecraft.world.entity.ExperienceOrb getHandle() {
-         return (net.minecraft.world.entity.ExperienceOrb) this.entity;

patches/unapplied/server/Expose-attack-cooldown-methods-for-Player.patch

@@ -1,32 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Tue, 4 Sep 2018 15:02:00 -0500
-Subject: [PATCH] Expose attack cooldown methods for Player
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
- 
-         return this.adventure$pointers;
-     }
-+
-+    @Override
-+    public float getCooldownPeriod() {
-+        return getHandle().getCurrentItemAttackStrengthDelay();
-+    }
-+
-+    @Override
-+    public float getCooledAttackStrength(float adjustTicks) {
-+        return getHandle().getAttackStrengthScale(adjustTicks);
-+    }
-+
-+    @Override
-+    public void resetCooldown() {
-+        getHandle().resetAttackStrengthTicker();
-+    }
-     // Paper end
-     // Spigot start
-     private final Player.Spigot spigot = new Player.Spigot()

patches/unapplied/server/Expose-client-protocol-version-and-virtual-host.patch

@@ -1,116 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Minecrell <minecrell@minecrell.net>
-Date: Tue, 10 Oct 2017 18:45:20 +0200
-Subject: [PATCH] Expose client protocol version and virtual host
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/network/PaperNetworkClient.java b/src/main/java/com/destroystokyo/paper/network/PaperNetworkClient.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/network/PaperNetworkClient.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.network;
-+
-+import java.net.InetSocketAddress;
-+
-+import javax.annotation.Nullable;
-+import net.minecraft.network.Connection;
-+
-+public class PaperNetworkClient implements NetworkClient {
-+
-+    private final Connection networkManager;
-+
-+    PaperNetworkClient(Connection networkManager) {
-+        this.networkManager = networkManager;
-+    }
-+
-+    @Override
-+    public InetSocketAddress getAddress() {
-+        return (InetSocketAddress) this.networkManager.getRemoteAddress();
-+    }
-+
-+    @Override
-+    public int getProtocolVersion() {
-+        return this.networkManager.protocolVersion;
-+    }
-+
-+    @Nullable
-+    @Override
-+    public InetSocketAddress getVirtualHost() {
-+        return this.networkManager.virtualHost;
-+    }
-+
-+    public static InetSocketAddress prepareVirtualHost(String host, int port) {
-+        int len = host.length();
-+
-+        // FML appends a marker to the host to recognize FML clients (\0FML\0)
-+        int pos = host.indexOf('\0');
-+        if (pos >= 0) {
-+            len = pos;
-+        }
-+
-+        // When clients connect with a SRV record, their host contains a trailing '.'
-+        if (len > 0 && host.charAt(len -  1) == '.') {
-+            len--;
-+        }
-+
-+        return InetSocketAddress.createUnresolved(host.substring(0, len), port);
-+    }
-+
-+}
-diff --git a/src/main/java/net/minecraft/network/Connection.java b/src/main/java/net/minecraft/network/Connection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/Connection.java
-+++ b/src/main/java/net/minecraft/network/Connection.java
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
-     @Nullable
-     BandwidthDebugMonitor bandwidthDebugMonitor;
-     public String hostname = ""; // CraftBukkit - add field
-+    // Paper start - NetworkClient implementation
-+    public int protocolVersion;
-+    public java.net.InetSocketAddress virtualHost;
-+    // Paper end
- 
-     // Paper start - add utility methods
-     public final net.minecraft.server.level.ServerPlayer getPlayer() {
-diff --git a/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerHandshakePacketListenerImpl implements ServerHandshakePacketL
-                 throw new UnsupportedOperationException("Invalid intention " + String.valueOf(packet.intention()));
-         }
- 
-+        // Paper start - NetworkClient implementation
-+        this.connection.protocolVersion = packet.protocolVersion();
-+        this.connection.virtualHost = com.destroystokyo.paper.network.PaperNetworkClient.prepareVirtualHost(packet.hostName(), packet.port());
-+        // Paper end
-     }
- 
-     private void beginLogin(ClientIntentionPacket packet, boolean transfer) {
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-         this.getHandle().transferCookieConnection.sendPacket(new ClientboundTransferPacket(host, port));
-     }
- 
-+    // Paper start - Implement NetworkClient
-+    @Override
-+    public int getProtocolVersion() {
-+        if (getHandle().connection == null) return -1;
-+        return getHandle().connection.connection.protocolVersion;
-+    }
-+
-+    @Override
-+    public InetSocketAddress getVirtualHost() {
-+        if (getHandle().connection == null) return null;
-+        return getHandle().connection.connection.virtualHost;
-+    }
-+    // Paper end
-+
-     @Override
-     public double getEyeHeight(boolean ignorePose) {
-         if (ignorePose) {

patches/unapplied/server/Extend-Player-Interact-cancellation.patch

@@ -1,27 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Shane Freeder <theboyetronic@gmail.com>
-Date: Sun, 11 Feb 2018 10:43:46 +0000
-Subject: [PATCH] Extend Player Interact cancellation
-
-GUIs are opened on the client, meaning that the server cannot block them from opening,
-However, it is possible to close these GUIs from the server.
-
-Flower pots are also not updated on the client when interaction is cancelled, this patch
-also resolves this.
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-@@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
- 
-                 // send a correcting update to the client for the block above as well, this because of replaceable blocks (such as grass, sea grass etc)
-                 player.connection.send(new ClientboundBlockUpdatePacket(world, blockposition.above()));
-+            // Paper start - extend Player Interact cancellation // TODO: consider merging this into the extracted method
-+            } else if (iblockdata.is(Blocks.JIGSAW) || iblockdata.is(Blocks.STRUCTURE_BLOCK) || iblockdata.getBlock() instanceof net.minecraft.world.level.block.CommandBlock) {
-+                player.connection.send(new net.minecraft.network.protocol.game.ClientboundContainerClosePacket(this.player.containerMenu.containerId));
-             }
-+            // Paper end - extend Player Interact cancellation
-             player.getBukkitEntity().updateInventory(); // SPIGOT-2867
-             return (event.useItemInHand() != Event.Result.ALLOW) ? InteractionResult.SUCCESS : InteractionResult.PASS;
-         } else if (this.gameModeForPlayer == GameType.SPECTATOR) {

patches/unapplied/server/Fill-Profile-Property-Events.patch

@@ -1,131 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Tue, 2 Jan 2018 00:31:26 -0500
-Subject: [PATCH] Fill Profile Property Events
-
-Allows plugins to populate profile properties from local sources to avoid calls out to Mojang API
-to fill in textures for example.
-
-If Mojang API does need to be hit, event fire so you can get the results.
-
-This is useful for implementing a ProfileCache for Player Skulls
-
-diff --git a/src/main/java/com/destroystokyo/paper/profile/PaperMinecraftSessionService.java b/src/main/java/com/destroystokyo/paper/profile/PaperMinecraftSessionService.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/profile/PaperMinecraftSessionService.java
-+++ b/src/main/java/com/destroystokyo/paper/profile/PaperMinecraftSessionService.java
-@@ -0,0 +0,0 @@
- package com.destroystokyo.paper.profile;
- 
- import com.mojang.authlib.Environment;
-+import com.mojang.authlib.GameProfile;
- import com.mojang.authlib.yggdrasil.ProfileResult;
- import com.mojang.authlib.yggdrasil.ServicesKeySet;
- import com.mojang.authlib.yggdrasil.YggdrasilMinecraftSessionService;
-@@ -0,0 +0,0 @@ public class PaperMinecraftSessionService extends YggdrasilMinecraftSessionServi
-         super(servicesKeySet, proxy, environment);
-     }
- 
--    @Override
-+    public @Nullable ProfileResult fetchProfile(GameProfile profile, final boolean requireSecure) {
-+        CraftPlayerProfile playerProfile = (CraftPlayerProfile) CraftPlayerProfile.asBukkitMirror(profile);
-+        new com.destroystokyo.paper.event.profile.PreFillProfileEvent(playerProfile).callEvent();
-+        profile = playerProfile.getGameProfile();
-+        if (profile.getProperties().containsKey("textures")) {
-+            return new ProfileResult(profile, java.util.Collections.emptySet());
-+        }
-+        ProfileResult result = super.fetchProfile(profile.getId(), requireSecure);
-+        if (result != null) {
-+            new com.destroystokyo.paper.event.profile.FillProfileEvent(CraftPlayerProfile.asBukkitMirror(result.profile())).callEvent();
-+        }
-+        return result;
-+    }
-+
-+    @Override @io.papermc.paper.annotation.DoNotUse @Deprecated
-     public @Nullable ProfileResult fetchProfile(final UUID profileId, final boolean requireSecure) {
-         return super.fetchProfile(profileId, requireSecure);
-     }
-diff --git a/src/main/java/net/minecraft/world/item/component/ResolvableProfile.java b/src/main/java/net/minecraft/world/item/component/ResolvableProfile.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/item/component/ResolvableProfile.java
-+++ b/src/main/java/net/minecraft/world/item/component/ResolvableProfile.java
-@@ -0,0 +0,0 @@ public record ResolvableProfile(Optional<String> name, Optional<UUID> id, Proper
-         if (this.isResolved()) {
-             return CompletableFuture.completedFuture(this);
-         } else {
--            return this.id.isPresent() ? SkullBlockEntity.fetchGameProfile(this.id.get()).thenApply(optional -> {
-+            return this.id.isPresent() ? SkullBlockEntity.fetchGameProfile(this.id.get(), this.name.orElse(null)).thenApply(optional -> { // Paper - player profile events
-                 GameProfile gameProfile = optional.orElseGet(() -> new GameProfile(this.id.get(), this.name.orElse("")));
-                 return new ResolvableProfile(gameProfile);
-             }) : SkullBlockEntity.fetchGameProfile(this.name.orElseThrow()).thenApply(profile -> {
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java
-@@ -0,0 +0,0 @@ public class SkullBlockEntity extends BlockEntity {
-     @Nullable
-     private static LoadingCache<String, CompletableFuture<Optional<GameProfile>>> profileCacheByName;
-     @Nullable
--    private static LoadingCache<UUID, CompletableFuture<Optional<GameProfile>>> profileCacheById;
-+    private static LoadingCache<com.mojang.datafixers.util.Pair<java.util.UUID,  @org.jetbrains.annotations.Nullable GameProfile>, CompletableFuture<Optional<GameProfile>>> profileCacheById; // Paper - player profile events
-     public static final Executor CHECKED_MAIN_THREAD_EXECUTOR = runnable -> {
-         Executor executor = mainThreadExecutor;
-         if (executor != null) {
-@@ -0,0 +0,0 @@ public class SkullBlockEntity extends BlockEntity {
-         profileCacheById = CacheBuilder.newBuilder()
-             .expireAfterAccess(Duration.ofMinutes(10L))
-             .maximumSize(256L)
--            .build(new CacheLoader<UUID, CompletableFuture<Optional<GameProfile>>>() {
-+            .build(new CacheLoader<>() { // Paper - player profile events
-                 @Override
--                public CompletableFuture<Optional<GameProfile>> load(UUID uUID) {
-+                public CompletableFuture<Optional<GameProfile>> load(com.mojang.datafixers.util.Pair<java.util.UUID, @org.jetbrains.annotations.Nullable GameProfile> uUID) { // Paper - player profile events
-                     return SkullBlockEntity.fetchProfileById(uUID, apiServices, booleanSupplier);
-                 }
-             });
-@@ -0,0 +0,0 @@ public class SkullBlockEntity extends BlockEntity {
-             .getAsync(name)
-             .thenCompose(
-                 optional -> {
--                    LoadingCache<UUID, CompletableFuture<Optional<GameProfile>>> loadingCache = profileCacheById;
-+                    LoadingCache<com.mojang.datafixers.util.Pair<java.util.UUID, @org.jetbrains.annotations.Nullable GameProfile>, CompletableFuture<Optional<GameProfile>>> loadingCache = profileCacheById; // Paper - player profile events
-                     return loadingCache != null && !optional.isEmpty()
--                        ? loadingCache.getUnchecked(optional.get().getId()).thenApply(optional2 -> optional2.or(() -> optional))
-+                        ? loadingCache.getUnchecked(new com.mojang.datafixers.util.Pair<>(optional.get().getId(), optional.get())).thenApply(optional2 -> optional2.or(() -> optional)) // Paper - player profile events
-                         : CompletableFuture.completedFuture(Optional.empty());
-                 }
-             );
-     }
- 
--    static CompletableFuture<Optional<GameProfile>> fetchProfileById(UUID uuid, Services apiServices, BooleanSupplier booleanSupplier) {
-+    static CompletableFuture<Optional<GameProfile>> fetchProfileById(com.mojang.datafixers.util.Pair<java.util.UUID, @org.jetbrains.annotations.Nullable GameProfile> pair, Services apiServices, BooleanSupplier booleanSupplier) { // Paper
-         return CompletableFuture.supplyAsync(() -> {
-             if (booleanSupplier.getAsBoolean()) {
-                 return Optional.empty();
-             } else {
--                ProfileResult profileResult = apiServices.sessionService().fetchProfile(uuid, true);
-+                // Paper start - fill player profile events
-+                if (apiServices.sessionService() instanceof com.destroystokyo.paper.profile.PaperMinecraftSessionService paperService) {
-+                    final GameProfile profile = pair.getSecond() != null ? pair.getSecond() : new com.mojang.authlib.GameProfile(pair.getFirst(), "");
-+                    return Optional.ofNullable(paperService.fetchProfile(profile, true)).map(ProfileResult::profile);
-+                }
-+                ProfileResult profileResult = apiServices.sessionService().fetchProfile(pair.getFirst(), true);
-+                // Paper end - fill player profile events
-                 return Optional.ofNullable(profileResult).map(ProfileResult::profile);
-             }
-         }, Util.PROFILE_EXECUTOR); // Paper - don't submit BLOCKING PROFILE LOOKUPS to the world gen thread
-@@ -0,0 +0,0 @@ public class SkullBlockEntity extends BlockEntity {
-             : CompletableFuture.completedFuture(Optional.empty());
-     }
- 
--    public static CompletableFuture<Optional<GameProfile>> fetchGameProfile(UUID uuid) {
--        LoadingCache<UUID, CompletableFuture<Optional<GameProfile>>> loadingCache = profileCacheById;
--        return loadingCache != null ? loadingCache.getUnchecked(uuid) : CompletableFuture.completedFuture(Optional.empty());
-+    // Paper start - player profile events
-+    public static CompletableFuture<Optional<GameProfile>> fetchGameProfile(UUID uuid, @Nullable String name) {
-+        LoadingCache<com.mojang.datafixers.util.Pair<java.util.UUID,  @org.jetbrains.annotations.Nullable GameProfile>, CompletableFuture<Optional<GameProfile>>> loadingCache = profileCacheById;
-+        return loadingCache != null ? loadingCache.getUnchecked(new com.mojang.datafixers.util.Pair<>(uuid, name != null ? new com.mojang.authlib.GameProfile(uuid, name) : null)) : CompletableFuture.completedFuture(Optional.empty());
-+        // Paper end - player profile events
-     }
- 
-     @Override

patches/unapplied/server/Filter-bad-block-entity-nbt-data-from-falling-blocks.patch

@@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Zach Brown <1254957+zachbr@users.noreply.github.com>
-Date: Sat, 12 Nov 2016 23:25:22 -0600
-Subject: [PATCH] Filter bad block entity nbt data from falling blocks
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java b/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java
-@@ -0,0 +0,0 @@ public class FallingBlockEntity extends Entity {
-             this.dropItem = nbt.getBoolean("DropItem");
-         }
- 
--        if (nbt.contains("TileEntityData", 10)) {
-+        if (nbt.contains("TileEntityData", 10) && !(this.level().paperConfig().entities.spawning.filterBadTileEntityNbtFromFallingBlocks && this.blockState.getBlock() instanceof net.minecraft.world.level.block.GameMasterBlock)) { // Paper - Filter bad block entity nbt data from falling blocks
-             this.blockData = nbt.getCompound("TileEntityData").copy();
-         }
- 

patches/unapplied/server/Firework-API-s.patch

@@ -1,100 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Wed, 28 Dec 2016 07:18:33 +0100
-Subject: [PATCH] Firework API's
-
-== AT ==
-public net.minecraft.world.entity.projectile.FireworkRocketEntity attachedToEntity
-
-diff --git a/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java b/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/FireworkRocketEntity.java
-@@ -0,0 +0,0 @@ public class FireworkRocketEntity extends Projectile implements ItemSupplier {
-     public int lifetime;
-     @Nullable
-     public LivingEntity attachedToEntity;
-+    @Nullable public java.util.UUID spawningEntity; // Paper
- 
-     public FireworkRocketEntity(EntityType<? extends FireworkRocketEntity> type, Level world) {
-         super(type, world);
-@@ -0,0 +0,0 @@ public class FireworkRocketEntity extends Projectile implements ItemSupplier {
-         nbt.putInt("LifeTime", this.lifetime);
-         nbt.put("FireworksItem", this.getItem().save(this.registryAccess()));
-         nbt.putBoolean("ShotAtAngle", (Boolean) this.entityData.get(FireworkRocketEntity.DATA_SHOT_AT_ANGLE));
-+        // Paper start
-+        if (this.spawningEntity != null) {
-+            nbt.putUUID("SpawningEntity", this.spawningEntity);
-+        }
-+        // Paper end
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class FireworkRocketEntity extends Projectile implements ItemSupplier {
-         if (nbt.contains("ShotAtAngle")) {
-             this.entityData.set(FireworkRocketEntity.DATA_SHOT_AT_ANGLE, nbt.getBoolean("ShotAtAngle"));
-         }
--
-+        // Paper start
-+        if (nbt.hasUUID("SpawningEntity")) {
-+            this.spawningEntity = nbt.getUUID("SpawningEntity");
-+        }
-+        // Paper end
-     }
- 
-     private List<FireworkExplosion> getExplosions() {
-diff --git a/src/main/java/net/minecraft/world/item/CrossbowItem.java b/src/main/java/net/minecraft/world/item/CrossbowItem.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/item/CrossbowItem.java
-+++ b/src/main/java/net/minecraft/world/item/CrossbowItem.java
-@@ -0,0 +0,0 @@ public class CrossbowItem extends ProjectileWeaponItem {
-     @Override
-     protected Projectile createProjectile(Level world, LivingEntity shooter, ItemStack weaponStack, ItemStack projectileStack, boolean critical) {
-         if (projectileStack.is(Items.FIREWORK_ROCKET)) {
--            return new FireworkRocketEntity(world, projectileStack, shooter, shooter.getX(), shooter.getEyeY() - 0.15F, shooter.getZ(), true);
-+            // Paper start
-+            FireworkRocketEntity entity =  new FireworkRocketEntity(world, projectileStack, shooter, shooter.getX(), shooter.getEyeY() - 0.15F, shooter.getZ(), true);
-+            entity.spawningEntity = shooter.getUUID(); // Paper
-+            return entity;
-+            // Paper end
-         } else {
-             Projectile projectile = super.createProjectile(world, shooter, weaponStack, projectileStack, critical);
-             if (projectile instanceof AbstractArrow abstractArrow) {
-diff --git a/src/main/java/net/minecraft/world/item/FireworkRocketItem.java b/src/main/java/net/minecraft/world/item/FireworkRocketItem.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/item/FireworkRocketItem.java
-+++ b/src/main/java/net/minecraft/world/item/FireworkRocketItem.java
-@@ -0,0 +0,0 @@ public class FireworkRocketItem extends Item implements ProjectileItem {
-                     itemStack
-                 ),
-                 serverLevel,
--                itemStack
-+                itemStack, f -> f.spawningEntity = context.getPlayer() == null ? null : context.getPlayer().getUUID()  // Paper - firework api - assign spawning entity uuid
-             );
-             itemStack.shrink(1);
-         }
-@@ -0,0 +0,0 @@ public class FireworkRocketItem extends Item implements ProjectileItem {
-         if (user.isFallFlying()) {
-             ItemStack itemStack = user.getItemInHand(hand);
-             if (world instanceof ServerLevel serverLevel) {
--                Projectile.spawnProjectile(new FireworkRocketEntity(world, itemStack, user), serverLevel, itemStack);
-+                Projectile.spawnProjectile(new FireworkRocketEntity(world, itemStack, user), serverLevel, itemStack, f -> f.spawningEntity = user.getUUID());  // Paper - firework api - assign spawning entity uuid
-                 itemStack.consume(1, user);
-                 user.awardStat(Stats.ITEM_USED.get(this));
-             }
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftFirework.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftFirework.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftFirework.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftFirework.java
-@@ -0,0 +0,0 @@ public class CraftFirework extends CraftProjectile implements Firework {
-     public void setShotAtAngle(boolean shotAtAngle) {
-         this.getHandle().getEntityData().set(FireworkRocketEntity.DATA_SHOT_AT_ANGLE, shotAtAngle);
-     }
-+
-+    // Paper start
-+    @Override
-+    public java.util.UUID getSpawningEntity() {
-+        return getHandle().spawningEntity;
-+    }
-+    // Paper end
- }

patches/unapplied/server/Fix-MC-117075-Block-entity-unload-lag-spike.patch

@@ -1,34 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: mezz <tehgeek@gmail.com>
-Date: Wed, 9 Aug 2017 17:51:22 -0500
-Subject: [PATCH] Fix MC-117075: Block entity unload lag spike
-
-
-diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/Level.java
-+++ b/src/main/java/net/minecraft/world/level/Level.java
-@@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
-         boolean flag = this.tickRateManager().runsNormally();
- 
-         int tilesThisCycle = 0;
-+        var toRemove = new it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet<TickingBlockEntity>(); // Paper - Fix MC-117075; use removeAll
-+        toRemove.add(null); // Paper - Fix MC-117075
-         for (tileTickPosition = 0; tileTickPosition < this.blockEntityTickers.size(); tileTickPosition++) { // Paper - Disable tick limiters
-             this.tileTickPosition = (this.tileTickPosition < this.blockEntityTickers.size()) ? this.tileTickPosition : 0;
-             TickingBlockEntity tickingblockentity = (TickingBlockEntity) this.blockEntityTickers.get(this.tileTickPosition);
-@@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
-             if (tickingblockentity.isRemoved()) {
-                 // Spigot start
-                 tilesThisCycle--;
--                this.blockEntityTickers.remove(this.tileTickPosition--);
-+                toRemove.add(tickingblockentity); // Paper - Fix MC-117075; use removeAll
-                 // Spigot end
-             } else if (flag && this.shouldTickBlocksAt(tickingblockentity.getPos())) {
-                 tickingblockentity.tick();
-             }
-         }
-+        this.blockEntityTickers.removeAll(toRemove); // Paper - Fix MC-117075
- 
-         this.tickingBlockEntities = false;
-         gameprofilerfiller.pop();

patches/unapplied/server/Fix-NBT-type-issues.patch

@@ -1,44 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Fri, 3 Aug 2018 00:04:54 -0400
-Subject: [PATCH] Fix NBT type issues
-
-Addresses two issues:
-- MC-135506: Experience should save as Integers
-- Allay duplication cooldown is saved and exposed as a long, but loaded as an int
-
-diff --git a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-+++ b/src/main/java/net/minecraft/world/entity/ExperienceOrb.java
-@@ -0,0 +0,0 @@ public class ExperienceOrb extends Entity {
-     public void addAdditionalSaveData(CompoundTag nbt) {
-         nbt.putShort("Health", (short) this.health);
-         nbt.putShort("Age", (short) this.age);
--        nbt.putShort("Value", (short) this.value);
-+        nbt.putInt("Value", this.value); // Paper - save as Integer
-         nbt.putInt("Count", this.count);
-         this.savePaperNBT(nbt); // Paper
-     }
-@@ -0,0 +0,0 @@ public class ExperienceOrb extends Entity {
-     public void readAdditionalSaveData(CompoundTag nbt) {
-         this.health = nbt.getShort("Health");
-         this.age = nbt.getShort("Age");
--        this.value = nbt.getShort("Value");
-+        this.value = nbt.getInt("Value"); // Paper - load as Integer
-         this.count = Math.max(nbt.getInt("Count"), 1);
-         this.loadPaperNBT(nbt); // Paper
-     }
-diff --git a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java
-@@ -0,0 +0,0 @@ public class Allay extends PathfinderMob implements InventoryCarrier, VibrationS
-             });
-         }
- 
--        this.duplicationCooldown = (long) nbt.getInt("DuplicationCooldown");
-+        this.duplicationCooldown = nbt.getLong("DuplicationCooldown"); // Paper - Load as long
-         this.entityData.set(Allay.DATA_CAN_DUPLICATE, nbt.getBoolean("CanDuplicate"));
-     }
- 

patches/unapplied/server/Fix-exploit-that-allowed-colored-signs-to-be-created.patch

@@ -1,22 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: 0x22 <0x22@futureclient.net>
-Date: Thu, 26 Apr 2018 04:41:11 -0400
-Subject: [PATCH] Fix exploit that allowed colored signs to be created
-
-
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
-@@ -0,0 +0,0 @@ public class SignBlockEntity extends BlockEntity {
-             Style chatmodifier = signtext.getMessage(i, entityhuman.isTextFilteringEnabled()).getStyle();
- 
-             if (entityhuman.isTextFilteringEnabled()) {
--                signtext = signtext.setMessage(i, Component.literal(filteredtext.filteredOrEmpty()).setStyle(chatmodifier));
-+                signtext = signtext.setMessage(i, Component.literal(net.minecraft.util.StringUtil.filterText(filteredtext.filteredOrEmpty())).setStyle(chatmodifier)); // Paper - filter sign text to chat only
-             } else {
--                signtext = signtext.setMessage(i, Component.literal(filteredtext.raw()).setStyle(chatmodifier), Component.literal(filteredtext.filteredOrEmpty()).setStyle(chatmodifier));
-+                signtext = signtext.setMessage(i, Component.literal(net.minecraft.util.StringUtil.filterText(filteredtext.raw())).setStyle(chatmodifier), Component.literal(net.minecraft.util.StringUtil.filterText(filteredtext.filteredOrEmpty())).setStyle(chatmodifier)); // Paper - filter sign text to chat only
-             }
-         }
- 

patches/unapplied/server/Fix-this-stupid-bullshit.patch

@@ -1,52 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Kyle Wood <kyle@denwav.dev>
-Date: Sun, 6 Aug 2017 17:17:53 -0500
-Subject: [PATCH] Fix this stupid bullshit
-
-Disable the 15 second sleep when the server jar hasn't been rebuilt within a period of time.
-
-modified in order to prevent merge conflicts when Spigot changes/disables the warning,
-and to provide some level of hint without being disruptive.
-
-diff --git a/src/main/java/net/minecraft/server/Bootstrap.java b/src/main/java/net/minecraft/server/Bootstrap.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/Bootstrap.java
-+++ b/src/main/java/net/minecraft/server/Bootstrap.java
-@@ -0,0 +0,0 @@ public class Bootstrap {
-     public static void bootStrap() {
-         if (!Bootstrap.isBootstrapped) {
-             // CraftBukkit start
--            String name = Bootstrap.class.getSimpleName();
-+            /*String name = Bootstrap.class.getSimpleName(); // Paper
-             switch (name) {
-                 case "DispenserRegistry":
-                     break;
-@@ -0,0 +0,0 @@ public class Bootstrap {
-                     System.err.println("*** WARNING: This server jar is unsupported, use at your own risk. ***");
-                     System.err.println("**********************************************************************");
-                     break;
--            }
-+            }*/ // Paper
-             // CraftBukkit end
-             Bootstrap.isBootstrapped = true;
-             Instant instant = Instant.now();
-diff --git a/src/main/java/org/bukkit/craftbukkit/Main.java b/src/main/java/org/bukkit/craftbukkit/Main.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/Main.java
-+++ b/src/main/java/org/bukkit/craftbukkit/Main.java
-@@ -0,0 +0,0 @@ public class Main {
-                     Calendar deadline = Calendar.getInstance();
-                     deadline.add(Calendar.DAY_OF_YEAR, -14);
-                     if (buildDate.before(deadline.getTime())) {
--                        System.err.println("*** Error, this build is outdated ***");
-+                        // Paper start - This is some stupid bullshit
-+                        System.err.println("*** Warning, you've not updated in a while! ***");
-                         System.err.println("*** Please download a new build as per instructions from https://papermc.io/downloads/paper ***"); // Paper
--                        System.err.println("*** Server will start in 20 seconds ***");
--                        Thread.sleep(TimeUnit.SECONDS.toMillis(20));
-+                        //System.err.println("*** Server will start in 20 seconds ***");
-+                        //Thread.sleep(TimeUnit.SECONDS.toMillis(20));
-+                        // Paper end
-                     }
-                 }
- 

patches/unapplied/server/Flag-to-disable-the-channel-limit.patch

@@ -1,31 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Shane Freeder <theboyetronic@gmail.com>
-Date: Sat, 31 Mar 2018 17:04:26 +0100
-Subject: [PATCH] Flag to disable the channel limit
-
-In some enviroments, the channel limit set by spigot can cause issues,
-e.g. servers which allow and support the usage of mod packs.
-
-provide an optional flag to disable this check, at your own risk.
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-     private CraftWorldBorder clientWorldBorder = null;
-     private BorderChangeListener clientWorldBorderListener = this.createWorldBorderListener();
-     public org.bukkit.event.player.PlayerResourcePackStatusEvent.Status resourcePackStatus; // Paper - more resource pack API
-+    private static final boolean DISABLE_CHANNEL_LIMIT = System.getProperty("paper.disableChannelLimit") != null; // Paper - add a flag to disable the channel limit
- 
-     public CraftPlayer(CraftServer server, ServerPlayer entity) {
-         super(server, entity);
-@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-     }
- 
-     public void addChannel(String channel) {
--        Preconditions.checkState(this.channels.size() < 128, "Cannot register channel '%s'. Too many channels registered!", channel);
-+        Preconditions.checkState(DISABLE_CHANNEL_LIMIT || this.channels.size() < 128, "Cannot register channel. Too many channels registered!"); // Paper - flag to disable channel limit
-         channel = StandardMessenger.validateAndCorrectChannel(channel);
-         if (this.channels.add(channel)) {
-             this.server.getPluginManager().callEvent(new PlayerRegisterChannelEvent(this, channel));

patches/unapplied/server/Honor-EntityAgeable.ageLock.patch

@@ -1,38 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Sun, 23 Sep 2018 20:59:53 -0500
-Subject: [PATCH] Honor EntityAgeable.ageLock
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/AgeableMob.java b/src/main/java/net/minecraft/world/entity/AgeableMob.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/AgeableMob.java
-+++ b/src/main/java/net/minecraft/world/entity/AgeableMob.java
-@@ -0,0 +0,0 @@ public abstract class AgeableMob extends PathfinderMob {
-     }
- 
-     public void ageUp(int age, boolean overGrow) {
-+        if (this.ageLocked) return; // Paper - Honor ageLock
-         int j = this.getAge();
-         int k = j;
- 
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/BeehiveBlockEntity.java
-@@ -0,0 +0,0 @@ public class BeehiveBlockEntity extends BlockEntity {
-         }
- 
-         private static void setBeeReleaseData(int ticksInHive, Bee beeEntity) {
-+            if (!beeEntity.ageLocked) { // Paper - Honor ageLock
-             int j = beeEntity.getAge();
- 
-             if (j < 0) {
-@@ -0,0 +0,0 @@ public class BeehiveBlockEntity extends BlockEntity {
-             }
- 
-             beeEntity.setInLoveTime(Math.max(0, beeEntity.getInLoveTime() - ticksInHive));
-+            } // Paper - Honor ageLock
-         }
-     }
- 

patches/unapplied/server/Implement-World.getEntity-UUID-API.patch

@@ -1,26 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Brokkonaut <hannos17@gmx.de>
-Date: Tue, 3 Jul 2018 16:08:14 +0200
-Subject: [PATCH] Implement World.getEntity(UUID) API
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor implements World {
-         return list;
-     }
- 
-+    // Paper start - getEntity by UUID API
-+    @Override
-+    public Entity getEntity(UUID uuid) {
-+        Preconditions.checkArgument(uuid != null, "UUID cannot be null");
-+        net.minecraft.world.entity.Entity entity = world.getEntity(uuid);
-+        return entity == null ? null : entity.getBukkitEntity();
-+    }
-+    // Paper end
-+
-     @Override
-     public void save() {
-         org.spigotmc.AsyncCatcher.catchOp("world save"); // Spigot

patches/unapplied/server/Implement-extended-PaperServerListPingEvent.patch

@@ -1,230 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Minecrell <minecrell@minecrell.net>
-Date: Wed, 11 Oct 2017 15:56:26 +0200
-Subject: [PATCH] Implement extended PaperServerListPingEvent
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/network/PaperServerListPingEventImpl.java b/src/main/java/com/destroystokyo/paper/network/PaperServerListPingEventImpl.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/network/PaperServerListPingEventImpl.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.network;
-+
-+import com.destroystokyo.paper.event.server.PaperServerListPingEvent;
-+import net.minecraft.server.MinecraftServer;
-+import net.minecraft.server.level.ServerPlayer;
-+import org.bukkit.entity.Player;
-+import org.bukkit.util.CachedServerIcon;
-+
-+import javax.annotation.Nullable;
-+
-+class PaperServerListPingEventImpl extends PaperServerListPingEvent {
-+
-+    private final MinecraftServer server;
-+
-+    PaperServerListPingEventImpl(MinecraftServer server, StatusClient client, int protocolVersion, @Nullable CachedServerIcon icon) {
-+        super(client, server.motd(), server.getPlayerCount(), server.getMaxPlayers(),
-+                server.getServerModName() + ' ' + server.getServerVersion(), protocolVersion, icon);
-+        this.server = server;
-+    }
-+
-+    @Override
-+    protected final Object[] getOnlinePlayers() {
-+        return this.server.getPlayerList().players.toArray();
-+    }
-+
-+    @Override
-+    protected final Player getBukkitPlayer(Object player) {
-+        return ((ServerPlayer) player).getBukkitEntity();
-+    }
-+
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/network/PaperStatusClient.java b/src/main/java/com/destroystokyo/paper/network/PaperStatusClient.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/network/PaperStatusClient.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.network;
-+
-+import net.minecraft.network.Connection;
-+
-+class PaperStatusClient extends PaperNetworkClient implements StatusClient {
-+
-+    PaperStatusClient(Connection networkManager) {
-+        super(networkManager);
-+    }
-+
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/network/StandardPaperServerListPingEventImpl.java b/src/main/java/com/destroystokyo/paper/network/StandardPaperServerListPingEventImpl.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/network/StandardPaperServerListPingEventImpl.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.network;
-+
-+import com.destroystokyo.paper.profile.PlayerProfile;
-+import com.mojang.authlib.GameProfile;
-+import io.papermc.paper.adventure.AdventureComponent;
-+import java.util.ArrayList;
-+import java.util.Collections;
-+import java.util.List;
-+import java.util.Optional;
-+import javax.annotation.Nonnull;
-+import net.minecraft.network.Connection;
-+import net.minecraft.network.chat.Component;
-+import net.minecraft.network.protocol.status.ClientboundStatusResponsePacket;
-+import net.minecraft.network.protocol.status.ServerStatus;
-+import net.minecraft.server.MinecraftServer;
-+import org.bukkit.craftbukkit.util.CraftIconCache;
-+import org.jetbrains.annotations.NotNull;
-+
-+public final class StandardPaperServerListPingEventImpl extends PaperServerListPingEventImpl {
-+
-+    private List<GameProfile> originalSample;
-+
-+    private StandardPaperServerListPingEventImpl(MinecraftServer server, Connection networkManager, ServerStatus ping) {
-+        super(server, new PaperStatusClient(networkManager), ping.version().map(ServerStatus.Version::protocol).orElse(-1), server.server.getServerIcon());
-+        this.originalSample = ping.players().map(ServerStatus.Players::sample).orElse(null); // GH-1473 - pre-tick race condition NPE
-+    }
-+
-+    @Nonnull
-+    @Override
-+    public List<ListedPlayerInfo> getListedPlayers() {
-+        List<ListedPlayerInfo> sample = super.getListedPlayers();
-+
-+        if (this.originalSample != null) {
-+            for (GameProfile profile : this.originalSample) {
-+                sample.add(new ListedPlayerInfo(profile.getName(), profile.getId()));
-+            }
-+            this.originalSample = null;
-+        }
-+
-+        return sample;
-+    }
-+
-+    @Override
-+    public @NotNull List<PlayerProfile> getPlayerSample() {
-+        this.getListedPlayers(); // Populate the backing list for the transforming view, and null out originalSample (see getListedPlayers and processRequest)
-+        return super.getPlayerSample();
-+    }
-+
-+    private List<GameProfile> getPlayerSampleHandle() {
-+        if (this.originalSample != null) {
-+            return this.originalSample;
-+        }
-+
-+        List<ListedPlayerInfo> entries = super.getListedPlayers();
-+        if (entries.isEmpty()) {
-+            return Collections.emptyList();
-+        }
-+
-+        final List<GameProfile> profiles = new ArrayList<>();
-+        for (ListedPlayerInfo playerInfo : entries) {
-+            profiles.add(new GameProfile(playerInfo.id(), playerInfo.name()));
-+        }
-+        return profiles;
-+    }
-+
-+    public static void processRequest(MinecraftServer server, Connection networkManager) {
-+        StandardPaperServerListPingEventImpl event = new StandardPaperServerListPingEventImpl(server, networkManager, server.getStatus());
-+        server.server.getPluginManager().callEvent(event);
-+
-+        // Close connection immediately if event is cancelled
-+        if (event.isCancelled()) {
-+            networkManager.disconnect((Component) null);
-+            return;
-+        }
-+
-+        // Setup response
-+
-+        // Description
-+        final Component description = new AdventureComponent(event.motd());
-+
-+        // Players
-+        final Optional<ServerStatus.Players> players;
-+        if (!event.shouldHidePlayers()) {
-+            players = Optional.of(new ServerStatus.Players(event.getMaxPlayers(), event.getNumPlayers(), event.getPlayerSampleHandle()));
-+        } else {
-+            players = Optional.empty();
-+        }
-+
-+        // Version
-+        final ServerStatus.Version version = new ServerStatus.Version(event.getVersion(), event.getProtocolVersion());
-+
-+        // Favicon
-+        final Optional<ServerStatus.Favicon> favicon;
-+        if (event.getServerIcon() != null) {
-+            favicon = Optional.of(new ServerStatus.Favicon(((CraftIconCache) event.getServerIcon()).value));
-+        } else {
-+            favicon = Optional.empty();
-+        }
-+        final ServerStatus ping = new ServerStatus(description, players, Optional.of(version), favicon, server.enforceSecureProfile());
-+
-+        // Send response
-+        networkManager.send(new ClientboundStatusResponsePacket(ping));
-+    }
-+
-+}
-diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -0,0 +0,0 @@ package net.minecraft.server;
- import com.google.common.base.Preconditions;
- import com.google.common.base.Splitter;
- import com.google.common.collect.ImmutableList;
-+import co.aikar.timings.Timings;
-+import com.destroystokyo.paper.event.server.PaperServerListPingEvent;
-+import com.google.common.base.Stopwatch;
- import com.google.common.collect.Lists;
- import com.google.common.collect.Maps;
- import com.google.common.collect.Sets;
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         if (this.hidesOnlinePlayers()) {
-             return new ServerStatus.Players(i, list.size(), List.of());
-         } else {
--            int j = Math.min(list.size(), 12);
-+            int j = Math.min(list.size(), org.spigotmc.SpigotConfig.playerSample); // Paper - PaperServerListPingEvent
-             ObjectArrayList<GameProfile> objectarraylist = new ObjectArrayList(j);
-             int k = Mth.nextInt(this.random, 0, list.size() - j);
- 
-diff --git a/src/main/java/net/minecraft/server/network/ServerStatusPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerStatusPacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerStatusPacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerStatusPacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerStatusPacketListenerImpl implements ServerStatusPacketListene
-             this.connection.disconnect(ServerStatusPacketListenerImpl.DISCONNECT_REASON);
-         } else {
-             this.hasRequestedStatus = true;
-+            // Paper start - Replace everything
-+            /*
-             // CraftBukkit start
-             // this.connection.send(new PacketStatusOutServerInfo(this.status));
-             MinecraftServer server = MinecraftServer.getServer();
-@@ -0,0 +0,0 @@ public class ServerStatusPacketListenerImpl implements ServerStatusPacketListene
- 
-             this.connection.send(new ClientboundStatusResponsePacket(ping));
-             // CraftBukkit end
-+            */
-+            com.destroystokyo.paper.network.StandardPaperServerListPingEventImpl.processRequest(MinecraftServer.getServer(), this.connection);
-+            // Paper end
-         }
-     }
- 
-diff --git a/src/main/java/org/spigotmc/SpigotConfig.java b/src/main/java/org/spigotmc/SpigotConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/spigotmc/SpigotConfig.java
-+++ b/src/main/java/org/spigotmc/SpigotConfig.java
-@@ -0,0 +0,0 @@ public class SpigotConfig
-     public static int playerSample;
-     private static void playerSample()
-     {
--        SpigotConfig.playerSample = SpigotConfig.getInt( "settings.sample-count", 12 );
-+        SpigotConfig.playerSample = Math.max( SpigotConfig.getInt( "settings.sample-count", 12 ), 0 ); // Paper - Avoid negative counts
-         Bukkit.getLogger().log( Level.INFO, "Server Ping Player Sample Count: {0}", playerSample ); // Paper - Use logger
-     }
- 

patches/unapplied/server/Implement-furnace-cook-speed-multiplier-API.patch

@@ -1,139 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Tassu <git@tassu.me>
-Date: Thu, 13 Sep 2018 08:45:21 +0300
-Subject: [PATCH] Implement furnace cook speed multiplier API
-
-Fixed an issue where a furnace's cook-speed multiplier rounds down
-to the nearest Integer when updating its current cook time.
-
-== AT ==
-public net.minecraft.world.level.block.entity.AbstractFurnaceBlockEntity getTotalCookTime(Lnet/minecraft/server/level/ServerLevel;Lnet/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity;)I
-
-Co-authored-by: Eric Su <ericsu@alumni.usc.edu>
-
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/AbstractFurnaceBlockEntity.java
-@@ -0,0 +0,0 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
-     protected NonNullList<ItemStack> items;
-     public int litTime;
-     int litDuration;
-+    public double cookSpeedMultiplier = 1.0; // Paper - cook speed multiplier API
-     public int cookingProgress;
-     public int cookingTotalTime;
-     protected final ContainerData dataAccess;
-     public final Reference2IntOpenHashMap<ResourceKey<Recipe<?>>> recipesUsed;
-     private final RecipeManager.CachedCheck<SingleRecipeInput, ? extends AbstractCookingRecipe> quickCheck;
-+    public final RecipeType<? extends AbstractCookingRecipe> recipeType; // Paper - cook speed multiplier API
- 
-     protected AbstractFurnaceBlockEntity(BlockEntityType<?> blockEntityType, BlockPos pos, BlockState state, RecipeType<? extends AbstractCookingRecipe> recipeType) {
-         super(blockEntityType, pos, state);
-@@ -0,0 +0,0 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
-         };
-         this.recipesUsed = new Reference2IntOpenHashMap();
-         this.quickCheck = RecipeManager.createCheck((RecipeType<AbstractCookingRecipe>) recipeType); // CraftBukkit - decompile error // Eclipse fail
-+        this.recipeType = recipeType; // Paper - cook speed multiplier API
-     }
- 
-     // CraftBukkit start - add fields and methods
-@@ -0,0 +0,0 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
-             this.recipesUsed.put(ResourceKey.create(Registries.RECIPE, ResourceLocation.parse(s)), nbttagcompound1.getInt(s));
-         }
- 
-+        // Paper start - cook speed multiplier API
-+        if (nbt.contains("Paper.CookSpeedMultiplier")) {
-+            this.cookSpeedMultiplier = nbt.getDouble("Paper.CookSpeedMultiplier");
-+        }
-+        // Paper end - cook speed multiplier API
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
-         nbt.putShort("BurnTime", (short) this.litTime);
-         nbt.putShort("CookTime", (short) this.cookingProgress);
-         nbt.putShort("CookTimeTotal", (short) this.cookingTotalTime);
-+        nbt.putDouble("Paper.CookSpeedMultiplier", this.cookSpeedMultiplier); // Paper - cook speed multiplier API
-         ContainerHelper.saveAllItems(nbt, this.items, registries);
-         CompoundTag nbttagcompound1 = new CompoundTag();
- 
-@@ -0,0 +0,0 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
-                     CraftItemStack source = CraftItemStack.asCraftMirror(blockEntity.items.get(0));
-                     CookingRecipe<?> recipe = (CookingRecipe<?>) recipeholder.toBukkitRecipe();
- 
--                    FurnaceStartSmeltEvent event = new FurnaceStartSmeltEvent(CraftBlock.at(world, pos), source, recipe);
-+                    FurnaceStartSmeltEvent event = new FurnaceStartSmeltEvent(CraftBlock.at(world, pos), source, recipe, AbstractFurnaceBlockEntity.getTotalCookTime(world, blockEntity, blockEntity.recipeType, blockEntity.cookSpeedMultiplier)); // Paper - cook speed multiplier API
-                     world.getCraftServer().getPluginManager().callEvent(event);
- 
-                     blockEntity.cookingTotalTime = event.getTotalCookTime();
-@@ -0,0 +0,0 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
-                 // CraftBukkit end
- 
-                 ++blockEntity.cookingProgress;
--                if (blockEntity.cookingProgress == blockEntity.cookingTotalTime) {
-+                if (blockEntity.cookingProgress >= blockEntity.cookingTotalTime) { // Paper - cook speed multiplier API
-                     blockEntity.cookingProgress = 0;
--                    blockEntity.cookingTotalTime = AbstractFurnaceBlockEntity.getTotalCookTime(world, blockEntity);
-+                    blockEntity.cookingTotalTime = AbstractFurnaceBlockEntity.getTotalCookTime(world, blockEntity, blockEntity.recipeType, blockEntity.cookSpeedMultiplier); // Paper - cook speed multiplier API
-                     if (AbstractFurnaceBlockEntity.burn(blockEntity.level, blockEntity.worldPosition, world.registryAccess(), recipeholder, singlerecipeinput, blockEntity.items, i)) { // CraftBukkit
-                         blockEntity.setRecipeUsed(recipeholder);
-                     }
-@@ -0,0 +0,0 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
-         return fuelRegistry.burnDuration(stack);
-     }
- 
--    public static int getTotalCookTime(ServerLevel world, AbstractFurnaceBlockEntity furnace) {
--        if (world == null) return 200; // CraftBukkit - SPIGOT-4302
-+    public static int getTotalCookTime(@Nullable ServerLevel world, AbstractFurnaceBlockEntity furnace, RecipeType<? extends AbstractCookingRecipe> recipeType, double cookSpeedMultiplier) { // Paper - cook speed multiplier API
-         SingleRecipeInput singlerecipeinput = new SingleRecipeInput(furnace.getItem(0));
- 
--        return (Integer) furnace.quickCheck.getRecipeFor(singlerecipeinput, world).map((recipeholder) -> {
--            return ((AbstractCookingRecipe) recipeholder.value()).cookingTime();
--        }).orElse(200);
-+        // Paper start - cook speed multiplier API
-+        /* Scale the recipe's cooking time to the current cookSpeedMultiplier */
-+        int cookTime = world != null ? furnace.quickCheck.getRecipeFor(singlerecipeinput, world).map(holder -> holder.value().cookingTime()).orElse(200) : (net.minecraft.server.MinecraftServer.getServer().getRecipeManager().getRecipeFor(recipeType, singlerecipeinput, world /* passing a null level here is safe. world is only used for map extending recipes which won't happen here */).map(holder -> holder.value().cookingTime()).orElse(200));
-+        return (int) Math.ceil (cookTime / cookSpeedMultiplier);
-+        // Paper end - cook speed multiplier API
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public abstract class AbstractFurnaceBlockEntity extends BaseContainerBlockEntit
-             if (world instanceof ServerLevel) {
-                 ServerLevel worldserver = (ServerLevel) world;
- 
--                this.cookingTotalTime = AbstractFurnaceBlockEntity.getTotalCookTime(worldserver, this);
-+                this.cookingTotalTime = AbstractFurnaceBlockEntity.getTotalCookTime(worldserver, this, this.recipeType, this.cookSpeedMultiplier); // Paper - cook speed multiplier API
-                 this.cookingProgress = 0;
-                 this.setChanged();
-             }
-         }
--
-     }
- 
-     @Override
-diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftFurnace.java b/src/main/java/org/bukkit/craftbukkit/block/CraftFurnace.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/block/CraftFurnace.java
-+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftFurnace.java
-@@ -0,0 +0,0 @@ public abstract class CraftFurnace<T extends AbstractFurnaceBlockEntity> extends
- 
-     @Override
-     public abstract CraftFurnace<T> copy(Location location);
-+
-+    // Paper start - cook speed multiplier API
-+    @Override
-+    public double getCookSpeedMultiplier() {
-+        return this.getSnapshot().cookSpeedMultiplier;
-+    }
-+
-+    @Override
-+    public void setCookSpeedMultiplier(double multiplier) {
-+        com.google.common.base.Preconditions.checkArgument(multiplier >= 0, "Furnace speed multiplier cannot be negative");
-+        com.google.common.base.Preconditions.checkArgument(multiplier <= 200, "Furnace speed multiplier cannot more than 200");
-+        T snapshot = this.getSnapshot();
-+        snapshot.cookSpeedMultiplier = multiplier;
-+        snapshot.cookingTotalTime = AbstractFurnaceBlockEntity.getTotalCookTime(this.isPlaced() ? this.world.getHandle() : null, snapshot, snapshot.recipeType, snapshot.cookSpeedMultiplier); // Update the snapshot's current total cook time to scale with the newly set multiplier
-+    }
-+    // Paper end
- }

patches/unapplied/server/Implement-getI18NDisplayName.patch

@@ -1,33 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Wed, 4 May 2016 23:59:38 -0400
-Subject: [PATCH] Implement getI18NDisplayName
-
-Gets the Display name as seen in the Client.
-Currently the server only supports the English language. To override this,
-You must replace the language file embedded in the server jar.
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java
-@@ -0,0 +0,0 @@ public final class CraftItemFactory implements ItemFactory {
-         return CraftItemStack.asCraftMirror(CraftItemStack.asNMSCopy(item));
-     }
-     // Paper end - ensure server conversions API
-+
-+    // Paper start - add getI18NDisplayName
-+    @Override
-+    public String getI18NDisplayName(ItemStack item) {
-+        net.minecraft.world.item.ItemStack nms = null;
-+        if (item instanceof CraftItemStack) {
-+            nms = ((CraftItemStack) item).handle;
-+        }
-+        if (nms == null) {
-+            nms = CraftItemStack.asNMSCopy(item);
-+        }
-+
-+        return nms != null ? nms.getItem().getName(nms).getString() : null;
-+    }
-+    // Paper end - add getI18NDisplayName
- }

patches/unapplied/server/Improve-BlockPosition-inlining.patch

@@ -1,60 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Techcable <Techcable@outlook.com>
-Date: Wed, 30 Nov 2016 20:56:58 -0600
-Subject: [PATCH] Improve BlockPosition inlining
-
-Normally the JVM can inline virtual getters by having two sets of code, one is the 'optimized' code and the other is the 'deoptimized' code.
-If a single type is used 99% of the time, then its worth it to inline, and to revert to 'deoptimized' the 1% of the time we encounter other types.
-But if two types are encountered commonly, then the JVM can't inline them both, and the call overhead remains.
-
-This scenario also occurs with BlockPos and MutableBlockPos.
-The variables in BlockPos are final, so MutableBlockPos can't modify them.
-MutableBlockPos fixes this by adding custom mutable variables, and overriding the getters to access them.
-
-This approach with utility methods that operate on MutableBlockPos and BlockPos.
-Specific examples are BlockPosition.up(), and World.isValidLocation().
-It makes these simple methods much slower than they need to be.
-
-This should result in an across the board speedup in anything that accesses blocks or does logic with positions.
-
-This is based upon conclusions drawn from inspecting the assenmbly generated bythe JIT compiler on my microbenchmarks.
-They had 'callq' (invoke) instead of 'mov' (get from memory) instructions.
-
-diff --git a/src/main/java/net/minecraft/core/Vec3i.java b/src/main/java/net/minecraft/core/Vec3i.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/core/Vec3i.java
-+++ b/src/main/java/net/minecraft/core/Vec3i.java
-@@ -0,0 +0,0 @@ public class Vec3i implements Comparable<Vec3i> {
-     }
- 
-     @Override
--    public boolean equals(Object object) {
-+    public final boolean equals(Object object) { // Paper - Perf: Final for inline
-         return this == object || object instanceof Vec3i vec3i && this.getX() == vec3i.getX() && this.getY() == vec3i.getY() && this.getZ() == vec3i.getZ();
-     }
- 
-     @Override
--    public int hashCode() {
-+    public final int hashCode() { // Paper - Perf: Final for inline
-         return (this.getY() + this.getZ() * 31) * 31 + this.getX();
-     }
- 
-@@ -0,0 +0,0 @@ public class Vec3i implements Comparable<Vec3i> {
-         }
-     }
- 
--    public int getX() {
-+    public final int getX() { // Paper - Perf: Final for inline
-         return this.x;
-     }
- 
--    public int getY() {
-+    public final int getY() { // Paper - Perf: Final for inline
-         return this.y;
-     }
- 
--    public int getZ() {
-+    public final int getZ() { // Paper - Perf: Final for inline
-         return this.z;
-     }
- 

patches/unapplied/server/Improve-CraftEntity-and-CraftPlayer-equals-and-hashC.patch

@@ -1,94 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Nassim Jahnke <nassim@njahnke.dev>
-Date: Sat, 9 Nov 2024 21:10:45 +0100
-Subject: [PATCH] Improve CraftEntity and CraftPlayer equals and hashCode
-
-Make sure the hash code does not change and also remove outdated
-equals logic from CraftPlayer. Long-term, the override there should
-be entirely removed, but this is good enough for now.
-
-Replacing some getHandle method calls with direct field access will
-also reduce overhead from casts that the overridden methods come with,
-at least until those are changed later on as well.
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-@@ -0,0 +0,0 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
- 
-     @Override
-     public UUID getUniqueId() {
--        return this.getHandle().getUUID();
-+        return this.entity.getUUID();
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
- 
-     @Override
-     public boolean equals(Object obj) {
--        if (obj == null) {
--            return false;
--        }
--        if (this.getClass() != obj.getClass()) {
--            return false;
--        }
-+        if (this == obj) return true;
-+        if (obj == null || getClass() != obj.getClass()) return false;
-+
-         final CraftEntity other = (CraftEntity) obj;
--        return (this.getEntityId() == other.getEntityId());
-+        return this.entity == other.entity; // There should never be duplicate entities with differing references
-     }
- 
-     @Override
-     public int hashCode() {
--        int hash = 7;
--        hash = 29 * hash + this.getEntityId();
--        return hash;
-+        // The UUID and thus hash code should never change (unlike the entity id)
-+        return this.getUniqueId().hashCode();
-     }
- 
-     @Override
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
- 
-     @Override
-     public boolean equals(Object obj) {
--        if (!(obj instanceof OfflinePlayer)) {
--            return false;
--        }
--        OfflinePlayer other = (OfflinePlayer) obj;
--        if ((this.getUniqueId() == null) || (other.getUniqueId() == null)) {
--            return false;
--        }
--
--        boolean uuidEquals = this.getUniqueId().equals(other.getUniqueId());
--        boolean idEquals = true;
--
--        if (other instanceof CraftPlayer) {
--            idEquals = this.getEntityId() == ((CraftPlayer) other).getEntityId();
--        }
--
--        return uuidEquals && idEquals;
-+        // Long-term, this should just use the super equals... for now, check the UUID
-+        if (obj == this) return true;
-+        if (!(obj instanceof OfflinePlayer other)) return false;
-+        return this.getUniqueId().equals(other.getUniqueId());
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-     @Override
-     public int hashCode() {
-         if (this.hash == 0 || this.hash == 485) {
--            this.hash = 97 * 5 + (this.getUniqueId() != null ? this.getUniqueId().hashCode() : 0);
-+            this.hash = 97 * 5 + this.getUniqueId().hashCode();
-         }
-         return this.hash;
-     }

patches/unapplied/server/Improve-EntityShootBowEvent.patch

@@ -1,45 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sat, 15 Jun 2013 19:51:17 -0400
-Subject: [PATCH] Improve EntityShootBowEvent
-
-Adds missing call to Illagers and also adds Arrow ItemStack to skeletons
-
-== AT ==
-public net.minecraft.world.entity.projectile.AbstractArrow getPickupItem()Lnet.minecraft.world.item.ItemStack;
-
-diff --git a/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java b/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java
-@@ -0,0 +0,0 @@ public abstract class AbstractSkeleton extends Monster implements RangedAttackMo
- 
-         if (world instanceof ServerLevel worldserver) {
-             // CraftBukkit start
--            org.bukkit.event.entity.EntityShootBowEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityShootBowEvent(this, this.getMainHandItem(), null, entityarrow, net.minecraft.world.InteractionHand.MAIN_HAND, 0.8F, true);
-+            org.bukkit.event.entity.EntityShootBowEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityShootBowEvent(this, this.getMainHandItem(), entityarrow.getPickupItem(), entityarrow, net.minecraft.world.InteractionHand.MAIN_HAND, 0.8F, true); // Paper - improve entity shhot bow event - add arrow stack to event
-             if (event.isCancelled()) {
-                 event.getProjectile().remove();
-                 return;
-diff --git a/src/main/java/net/minecraft/world/entity/monster/Illusioner.java b/src/main/java/net/minecraft/world/entity/monster/Illusioner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/Illusioner.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/Illusioner.java
-@@ -0,0 +0,0 @@ public class Illusioner extends SpellcasterIllager implements RangedAttackMob {
-         Level world = this.level();
- 
-         if (world instanceof ServerLevel worldserver) {
-+            // Paper start - EntityShootBowEvent
-+            org.bukkit.event.entity.EntityShootBowEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityShootBowEvent(this, this.getMainHandItem(), entityarrow.getPickupItem(), entityarrow, target.getUsedItemHand(), 0.8F, true);
-+            if (event.isCancelled()) {
-+                event.getProjectile().remove();
-+                return;
-+            }
-+
-+            if (event.getProjectile() == entityarrow.getBukkitEntity()) {
-             Projectile.spawnProjectileUsingShoot(entityarrow, worldserver, itemstack1, d0, d1 + d3 * 0.20000000298023224D, d2, 1.6F, (float) (14 - worldserver.getDifficulty().getId() * 4));
-+            }
-+            // Paper end - EntityShootBowEvent
-         }
- 
-         this.playSound(SoundEvents.SKELETON_SHOOT, 1.0F, 1.0F / (this.getRandom().nextFloat() * 0.4F + 0.8F));

patches/unapplied/server/Improve-death-events.patch

@@ -1,508 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Phoenix616 <mail@moep.tv>
-Date: Tue, 21 Aug 2018 01:39:35 +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.
-
-== AT ==
-public net.minecraft.world.entity.LivingEntity getDeathSound()Lnet/minecraft/sounds/SoundEvent;
-public net.minecraft.world.entity.LivingEntity getSoundVolume()F
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player {
-     private int containerCounter;
-     public boolean wonGame;
-     private int containerUpdateDelay; // Paper - Configurable container update tick rate
-+    // Paper start - cancellable death event
-+    public boolean queueHealthUpdatePacket;
-+    public net.minecraft.network.protocol.game.ClientboundSetHealthPacket queuedHealthUpdatePacket;
-+    // Paper end - cancellable death event
- 
-     // CraftBukkit start
-     public CraftPlayer.TransferCookieConnection transferCookieConnection;
-@@ -0,0 +0,0 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player {
- 
-     @Override
-     public void die(DamageSource damageSource) {
--        this.gameEvent(GameEvent.ENTITY_DIE);
-+        // this.gameEvent(GameEvent.ENTITY_DIE); // Paper - move below event cancellation check
-         boolean flag = this.serverLevel().getGameRules().getBoolean(GameRules.RULE_SHOWDEATHMESSAGES);
-         // CraftBukkit start - fire PlayerDeathEvent
-         if (this.isRemoved()) {
-@@ -0,0 +0,0 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player {
-         String deathmessage = defaultMessage.getString();
-         this.keepLevel = keepInventory; // SPIGOT-2222: pre-set keepLevel
-         org.bukkit.event.entity.PlayerDeathEvent event = CraftEventFactory.callPlayerDeathEvent(this, damageSource, loot, PaperAdventure.asAdventure(defaultMessage), keepInventory); // Paper - Adventure
-+        // Paper start - cancellable death event
-+        if (event.isCancelled()) {
-+            // make compatible with plugins that might have already set the health in an event listener
-+            if (this.getHealth() <= 0) {
-+                this.setHealth((float) event.getReviveHealth());
-+            }
-+            return;
-+        }
-+        this.gameEvent(GameEvent.ENTITY_DIE); // moved from the top of this method
-+        // Paper end
- 
-         // SPIGOT-943 - only call if they have an inventory open
-         if (this.containerMenu != this.inventoryMenu) {
-@@ -0,0 +0,0 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player {
-                     }
-                 }
- 
--                return super.hurtServer(world, source, amount);
-+                // Paper start - cancellable death events
-+                //return super.hurt(source, amount);
-+                this.queueHealthUpdatePacket = true;
-+                boolean damaged = super.hurtServer(world, source, amount);
-+                this.queueHealthUpdatePacket = false;
-+                if (this.queuedHealthUpdatePacket != null) {
-+                    this.connection.send(this.queuedHealthUpdatePacket);
-+                    this.queuedHealthUpdatePacket = null;
-+                }
-+                return damaged;
-+                // Paper end
-             }
-         }
-     }
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-     public Set<UUID> collidableExemptions = new HashSet<>();
-     public boolean bukkitPickUpLoot;
-     public org.bukkit.craftbukkit.entity.CraftLivingEntity getBukkitLivingEntity() { return (org.bukkit.craftbukkit.entity.CraftLivingEntity) super.getBukkitEntity(); } // Paper
-+    public boolean silentDeath = false; // Paper - mark entity as dying silently for cancellable death event
- 
-     @Override
-     public float getBukkitYaw() {
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
- 
-             if (this.isDeadOrDying()) {
-                 if (!this.checkTotemDeathProtection(source)) {
--                    if (flag1) {
--                        this.makeSound(this.getDeathSound());
--                    }
-+                    // Paper start - moved into CraftEventFactory event caller for cancellable death event
-+                    this.silentDeath = !flag1; // mark entity as dying silently
-+                    // Paper end
- 
-                     this.die(source);
-+                    this.silentDeath = false; // Paper - cancellable death event - reset to default
-                 }
-             } else if (flag1) {
-                 this.playHurtSound(source);
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-             Entity entity = damageSource.getEntity();
-             LivingEntity entityliving = this.getKillCredit();
- 
-+            /* // Paper - move down to make death event cancellable - this is the awardKillScore below
-             if (this.deathScore >= 0 && entityliving != null) {
-                 entityliving.awardKillScore(this, this.deathScore, damageSource);
-             }
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-             if (!this.level().isClientSide && this.hasCustomName()) {
-                 if (org.spigotmc.SpigotConfig.logNamedDeaths) LivingEntity.LOGGER.info("Named entity {} died: {}", this, this.getCombatTracker().getDeathMessage().getString()); // Spigot
-             }
-+             */ // Paper - move down to make death event cancellable - this is the awardKillScore below
- 
-             this.dead = true;
--            this.getCombatTracker().recheckStatus();
-+            // Paper - moved into if below
-             Level world = this.level();
- 
-             if (world instanceof ServerLevel) {
-                 ServerLevel worldserver = (ServerLevel) world;
-+                // Paper - move below into if for onKill
-+
-+                // Paper start
-+                org.bukkit.event.entity.EntityDeathEvent deathEvent = this.dropAllDeathLoot(worldserver, damageSource);
-+                if (deathEvent == null || !deathEvent.isCancelled()) {
-+                    if (this.deathScore >= 0 && entityliving != null) {
-+                        entityliving.awardKillScore(this, this.deathScore, damageSource);
-+                    }
-+                    // Paper start - clear equipment if event is not cancelled
-+                    if (this instanceof Mob) {
-+                        for (EquipmentSlot slot : this.clearedEquipmentSlots) {
-+                            this.setItemSlot(slot, ItemStack.EMPTY);
-+                        }
-+                        this.clearedEquipmentSlots.clear();
-+                    }
-+                    // Paper end
-+
-+                    if (this.isSleeping()) {
-+                        this.stopSleeping();
-+                    }
- 
--                if (entity == null || entity.killedEntity(worldserver, this)) {
-+                    if (!this.level().isClientSide && this.hasCustomName()) {
-+                        if (org.spigotmc.SpigotConfig.logNamedDeaths) LivingEntity.LOGGER.info("Named entity {} died: {}", this, this.getCombatTracker().getDeathMessage().getString()); // Spigot
-+                    }
-+
-+                    this.getCombatTracker().recheckStatus();
-+                    if (entity != null) {
-+                        entity.killedEntity((ServerLevel) this.level(), this);
-+                    }
-                     this.gameEvent(GameEvent.ENTITY_DIE);
--                    this.dropAllDeathLoot(worldserver, damageSource);
-+                } else {
-+                    this.dead = false;
-+                    this.setHealth((float) deathEvent.getReviveHealth());
-+                }
-+                // Paper end
-                     this.createWitherRose(entityliving);
-                 }
- 
-+            // Paper start
-+            if (this.dead) { // Paper
-                 this.level().broadcastEntityEvent(this, (byte) 3);
--            }
- 
-             this.setPose(Pose.DYING);
-+            }
-+            // Paper end
-         }
-     }
- 
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-         if (world instanceof ServerLevel worldserver) {
-             boolean flag = false;
- 
--            if (adversary instanceof WitherBoss) {
-+            if (this.dead && adversary instanceof WitherBoss) { // Paper
-                 if (worldserver.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING)) {
-                     BlockPos blockposition = this.blockPosition();
-                     BlockState iblockdata = Blocks.WITHER_ROSE.defaultBlockState();
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-         }
-     }
- 
--    protected void dropAllDeathLoot(ServerLevel world, DamageSource damageSource) {
-+    // Paper start
-+    protected boolean clearEquipmentSlots = true;
-+    protected Set<EquipmentSlot> clearedEquipmentSlots = new java.util.HashSet<>();
-+    protected org.bukkit.event.entity.EntityDeathEvent dropAllDeathLoot(ServerLevel world, DamageSource damageSource) {
-+        // Paper end
-         boolean flag = this.lastHurtByPlayerTime > 0;
- 
-         this.dropEquipment(world); // CraftBukkit - from below
-         if (this.shouldDropLoot() && world.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
-             this.dropFromLootTable(world, damageSource, flag);
-+            // Paper start
-+            final boolean prev = this.clearEquipmentSlots;
-+            this.clearEquipmentSlots = false;
-+            this.clearedEquipmentSlots.clear();
-+            // Paper end
-             this.dropCustomDeathLoot(world, damageSource, flag);
-+            this.clearEquipmentSlots = prev; // Paper
-         }
-         // CraftBukkit start - Call death event
--        CraftEventFactory.callEntityDeathEvent(this, damageSource, this.drops);
-+        org.bukkit.event.entity.EntityDeathEvent deathEvent = CraftEventFactory.callEntityDeathEvent(this, damageSource, this.drops); // Paper
-+        this.postDeathDropItems(deathEvent); // Paper
-         this.drops = new ArrayList<>();
-         // CraftBukkit end
- 
-         // this.dropEquipment(worldserver);// CraftBukkit - moved up
-         this.dropExperience(world, damageSource.getEntity());
-+        return deathEvent; // Paper
-     }
- 
-     protected void dropEquipment(ServerLevel world) {}
-+    protected void postDeathDropItems(org.bukkit.event.entity.EntityDeathEvent event) {} // Paper - method for post death logic that cannot be ran before the event is potentially cancelled
- 
-     public int getExpReward(ServerLevel worldserver, @Nullable Entity entity) { // CraftBukkit
-         if (!this.wasExperienceConsumed() && (this.isAlwaysExperienceDropper() || this.lastHurtByPlayerTime > 0 && this.shouldDropExperience() && worldserver.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT))) {
-diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/Mob.java
-+++ b/src/main/java/net/minecraft/world/entity/Mob.java
-@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
- 
-     }
- 
-+    // Paper start
-+    protected boolean shouldSkipLoot(EquipmentSlot slot) { // method to avoid to fallback into the global mob loot logic (i.e fox)
-+        return false;
-+    }
-+    // Paper end
-+
-     @Override
-     protected void dropCustomDeathLoot(ServerLevel world, DamageSource source, boolean causedByPlayer) {
-         super.dropCustomDeathLoot(world, source, causedByPlayer);
-@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
- 
-         while (iterator.hasNext()) {
-             EquipmentSlot enumitemslot = (EquipmentSlot) iterator.next();
-+            if (this.shouldSkipLoot(enumitemslot)) continue; // Paper
-             ItemStack itemstack = this.getItemBySlot(enumitemslot);
-             float f = this.getEquipmentDropChance(enumitemslot);
- 
-@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
-                     }
- 
-                     this.spawnAtLocation(world, itemstack);
-+                    if (this.clearEquipmentSlots) { // Paper
-                     this.setItemSlot(enumitemslot, ItemStack.EMPTY);
-+                    // Paper start
-+                    } else {
-+                        this.clearedEquipmentSlots.add(enumitemslot);
-+                    }
-+                    // Paper end
-                 }
-             }
-         }
-diff --git a/src/main/java/net/minecraft/world/entity/animal/Fox.java b/src/main/java/net/minecraft/world/entity/animal/Fox.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/animal/Fox.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/Fox.java
-@@ -0,0 +0,0 @@ public class Fox extends Animal implements VariantHolder<Fox.Variant> {
-         return this.getTrustedUUIDs().contains(uuid);
-     }
- 
-+    // Paper start - handle the bitten item separately like vanilla
-     @Override
--    protected void dropAllDeathLoot(ServerLevel world, DamageSource damageSource) {
-+    protected boolean shouldSkipLoot(EquipmentSlot slot) {
-+        return slot == EquipmentSlot.MAINHAND;
-+    }
-+    // Paper end
-+
-+    @Override
-+    // Paper start - Cancellable death event
-+    protected org.bukkit.event.entity.EntityDeathEvent dropAllDeathLoot(ServerLevel world, DamageSource damageSource) {
-         ItemStack itemstack = this.getItemBySlot(EquipmentSlot.MAINHAND);
- 
--        if (!itemstack.isEmpty()) {
-+        boolean releaseMouth = false;
-+        if (!itemstack.isEmpty() && world.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) { // Fix MC-153010
-             this.spawnAtLocation(world, itemstack);
-+            releaseMouth = true;
-+        }
-+
-+        org.bukkit.event.entity.EntityDeathEvent deathEvent = super.dropAllDeathLoot(world, damageSource);
-+
-+        // Below is code to drop
-+
-+        if (deathEvent == null || deathEvent.isCancelled()) {
-+            return deathEvent;
-+        }
-+
-+        if (releaseMouth) {
-+            // Paper end - Cancellable death event
-             this.setItemSlot(EquipmentSlot.MAINHAND, ItemStack.EMPTY);
-         }
- 
--        super.dropAllDeathLoot(world, damageSource);
-+        return deathEvent; // Paper - Cancellable death event
-     }
- 
-     public static boolean isPathClear(Fox fox, LivingEntity chasedEntity) {
-diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/AbstractChestedHorse.java b/src/main/java/net/minecraft/world/entity/animal/horse/AbstractChestedHorse.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/animal/horse/AbstractChestedHorse.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/horse/AbstractChestedHorse.java
-@@ -0,0 +0,0 @@ public abstract class AbstractChestedHorse extends AbstractHorse {
-         super.dropEquipment(world);
-         if (this.hasChest()) {
-             this.spawnAtLocation(world, Blocks.CHEST);
-+            //this.setChest(false); // Paper - moved to post death logic
-+        }
-+    }
-+    // Paper start
-+    protected void postDeathDropItems(org.bukkit.event.entity.EntityDeathEvent event) {
-+        if (this.hasChest() && (event == null || !event.isCancelled())) {
-             this.setChest(false);
-         }
-     }
-+    // Paper end
- 
-     @Override
-     public void addAdditionalSaveData(CompoundTag nbt) {
-diff --git a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-+++ b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
-             }
-             // CraftBukkit end
-             if (source.is(DamageTypeTags.IS_EXPLOSION)) {
--                this.brokenByAnything(world, source);
--                this.kill(world, source); // CraftBukkit
-+                // Paper start - avoid duplicate event call
-+                org.bukkit.event.entity.EntityDeathEvent event = this.brokenByAnything(world, source);
-+                if (!event.isCancelled()) this.kill(source, false); // CraftBukkit
-+                // Paper end
-                 return false;
-             } else if (source.is(DamageTypeTags.IGNITES_ARMOR_STANDS)) {
-                 if (this.isOnFire()) {
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
-                             this.gameEvent(GameEvent.ENTITY_DAMAGE, source.getEntity());
-                             this.lastHit = i;
-                         } else {
--                            this.brokenByPlayer(world, source);
-+                            org.bukkit.event.entity.EntityDeathEvent event = this.brokenByPlayer(world, source); // Paper
-                             this.showBreakingParticles();
--                            this.discard(EntityRemoveEvent.Cause.DEATH); // CraftBukkit - SPIGOT-4890: remain as this.discard() since above damagesource method will call death event
-+                            if (!event.isCancelled()) this.kill(source, false); // Paper - we still need to kill to follow vanilla logic (emit the game event etc...)
-                         }
- 
-                         return true;
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
-         f1 -= amount;
-         if (f1 <= 0.5F) {
-             this.brokenByAnything(world, damageSource);
--            this.kill(world, damageSource); // CraftBukkit
-+            // Paper start - avoid duplicate event call
-+            org.bukkit.event.entity.EntityDeathEvent event = this.brokenByAnything(world, damageSource);
-+            if (!event.isCancelled()) this.kill(damageSource, false); // CraftBukkit
-+            // Paper end
-         } else {
-             this.setHealth(f1);
-             this.gameEvent(GameEvent.ENTITY_DAMAGE, damageSource.getEntity());
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
- 
-     }
- 
--    private void brokenByPlayer(ServerLevel world, DamageSource damageSource) {
-+    private org.bukkit.event.entity.EntityDeathEvent brokenByPlayer(ServerLevel world, DamageSource damageSource) { // Paper
-         ItemStack itemstack = new ItemStack(Items.ARMOR_STAND);
- 
-         itemstack.set(DataComponents.CUSTOM_NAME, this.getCustomName());
-         this.drops.add(org.bukkit.craftbukkit.inventory.CraftItemStack.asBukkitCopy(itemstack)); // CraftBukkit - add to drops
--        this.brokenByAnything(world, damageSource);
-+        return this.brokenByAnything(world, damageSource); // Paper
-     }
- 
--    private void brokenByAnything(ServerLevel world, DamageSource damageSource) {
-+    private org.bukkit.event.entity.EntityDeathEvent brokenByAnything(ServerLevel world, DamageSource damageSource) { // Paper
-         this.playBrokenSound();
-         // this.dropAllDeathLoot(worldserver, damagesource); // CraftBukkit - moved down
- 
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
-                 this.armorItems.set(i, ItemStack.EMPTY);
-             }
-         }
--        this.dropAllDeathLoot(world, damageSource); // CraftBukkit - moved from above
-+        return this.dropAllDeathLoot(world, damageSource); // CraftBukkit - moved from above // Paper
- 
-     }
- 
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
-     }
- 
-     public void kill(ServerLevel worldserver, DamageSource damageSource) {
--        org.bukkit.craftbukkit.event.CraftEventFactory.callEntityDeathEvent(this, (damageSource == null ? this.damageSources().genericKill() : damageSource), this.drops); // CraftBukkit - call event
-+        // Paper start - make cancellable
-+        this.kill(damageSource, true);
-+    }
-+    public void kill(DamageSource damageSource, boolean callEvent) {
-+        if (callEvent) {
-+            org.bukkit.event.entity.EntityDeathEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityDeathEvent(this, (damageSource == null ? this.damageSources().genericKill() : damageSource), this.drops); // CraftBukkit - call event
-+            if (event.isCancelled()) return;
-+        }
-+        // Paper end
-         this.remove(Entity.RemovalReason.KILLED, EntityRemoveEvent.Cause.DEATH); // CraftBukkit - add Bukkit remove cause
-         // CraftBukkit end
-         this.gameEvent(GameEvent.ENTITY_DIE);
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-     @Override
-     public void sendHealthUpdate() {
-         FoodData foodData = this.getHandle().getFoodData();
--        this.sendHealthUpdate(this.getScaledHealth(), foodData.getFoodLevel(), foodData.getSaturationLevel());
-+        // Paper start - cancellable death event
-+        ClientboundSetHealthPacket packet = new ClientboundSetHealthPacket(this.getScaledHealth(), foodData.getFoodLevel(), foodData.getSaturationLevel());
-+        if (this.getHandle().queueHealthUpdatePacket) {
-+            this.getHandle().queuedHealthUpdatePacket = packet;
-+        } else {
-+            this.getHandle().connection.send(packet);
-+        }
-+        // Paper end
-     }
- 
-     public void injectScaledMaxHealth(Collection<AttributeInstance> collection, boolean force) {
-diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
-         CraftDamageSource bukkitDamageSource = new CraftDamageSource(damageSource);
-         CraftWorld world = (CraftWorld) entity.getWorld();
-         EntityDeathEvent event = new EntityDeathEvent(entity, bukkitDamageSource, drops, victim.getExpReward(world.getHandle(), damageSource.getEntity()));
-+        populateFields(victim, event); // Paper - make cancellable
-         Bukkit.getServer().getPluginManager().callEvent(event);
- 
-+        // Paper start - make cancellable
-+        if (event.isCancelled()) {
-+            return event;
-+        }
-+        playDeathSound(victim, event);
-+        // Paper end
-         victim.expToDrop = event.getDroppedExp();
- 
-         for (org.bukkit.inventory.ItemStack stack : event.getDrops()) {
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
-         PlayerDeathEvent event = new PlayerDeathEvent(entity, bukkitDamageSource, drops, victim.getExpReward(victim.serverLevel(), damageSource.getEntity()), 0, deathMessage);
-         event.setKeepInventory(keepInventory);
-         event.setKeepLevel(victim.keepLevel); // SPIGOT-2222: pre-set keepLevel
-+        populateFields(victim, event); // Paper - make cancellable
-         Bukkit.getServer().getPluginManager().callEvent(event);
-+        // Paper start - make cancellable
-+        if (event.isCancelled()) {
-+            return event;
-+        }
-+        playDeathSound(victim, event);
-+        // Paper end
- 
-         victim.keepLevel = event.getKeepLevel();
-         victim.newLevel = event.getNewLevel();
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
-         return event;
-     }
- 
-+    // Paper start - helper methods for making death event cancellable
-+    // Add information to death event
-+    private static void populateFields(net.minecraft.world.entity.LivingEntity victim, EntityDeathEvent event) {
-+        event.setReviveHealth(event.getEntity().getAttribute(org.bukkit.attribute.Attribute.MAX_HEALTH).getValue());
-+        event.setShouldPlayDeathSound(!victim.silentDeath && !victim.isSilent());
-+        net.minecraft.sounds.SoundEvent soundEffect = victim.getDeathSound();
-+        event.setDeathSound(soundEffect != null ? org.bukkit.craftbukkit.CraftSound.minecraftToBukkit(soundEffect) : null);
-+        event.setDeathSoundCategory(org.bukkit.SoundCategory.valueOf(victim.getSoundSource().name()));
-+        event.setDeathSoundVolume(victim.getSoundVolume());
-+        event.setDeathSoundPitch(victim.getVoicePitch());
-+    }
-+
-+    // Play death sound manually
-+    private static void playDeathSound(net.minecraft.world.entity.LivingEntity victim, EntityDeathEvent event) {
-+        if (event.shouldPlayDeathSound() && event.getDeathSound() != null && event.getDeathSoundCategory() != null) {
-+            net.minecraft.world.entity.player.Player source = victim instanceof net.minecraft.world.entity.player.Player ? (net.minecraft.world.entity.player.Player) victim : null;
-+            double x = event.getEntity().getLocation().getX();
-+            double y = event.getEntity().getLocation().getY();
-+            double z = event.getEntity().getLocation().getZ();
-+            net.minecraft.sounds.SoundEvent soundEffect = org.bukkit.craftbukkit.CraftSound.bukkitToMinecraft(event.getDeathSound());
-+            net.minecraft.sounds.SoundSource soundCategory = net.minecraft.sounds.SoundSource.valueOf(event.getDeathSoundCategory().name());
-+            victim.level().playSound(source, x, y, z, soundEffect, soundCategory, event.getDeathSoundVolume(), event.getDeathSoundPitch());
-+        }
-+    }
-+    // Paper end
-     /**
-      * Server methods
-      */

patches/unapplied/server/Improve-the-Saddle-API-for-Horses.patch

@@ -1,59 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sat, 10 Dec 2016 16:24:06 -0500
-Subject: [PATCH] Improve the Saddle API for Horses
-
-Not all horses with Saddles have armor. This lets us break up the horses with saddles
-and access their saddle state separately from an interface shared with Armor.
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftAbstractHorse.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftAbstractHorse.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftAbstractHorse.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftAbstractHorse.java
-@@ -0,0 +0,0 @@ import java.util.UUID;
- import net.minecraft.world.entity.ai.attributes.Attributes;
- import org.bukkit.craftbukkit.CraftServer;
- import org.bukkit.craftbukkit.inventory.CraftInventoryAbstractHorse;
-+import org.bukkit.craftbukkit.inventory.CraftSaddledInventory;
- import org.bukkit.entity.AbstractHorse;
- import org.bukkit.entity.AnimalTamer;
- import org.bukkit.entity.Horse;
-@@ -0,0 +0,0 @@ public abstract class CraftAbstractHorse extends CraftAnimals implements Abstrac
- 
-     @Override
-     public AbstractHorseInventory getInventory() {
--        return new CraftInventoryAbstractHorse(this.getHandle().inventory);
-+        return new CraftSaddledInventory(getHandle().inventory);
-     }
- }
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryHorse.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryHorse.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryHorse.java
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventoryHorse.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.Container;
- import org.bukkit.inventory.HorseInventory;
- import org.bukkit.inventory.ItemStack;
- 
--public class CraftInventoryHorse extends CraftInventoryAbstractHorse implements HorseInventory {
-+public class CraftInventoryHorse extends CraftSaddledInventory implements HorseInventory {
- 
-     private final Container bodyArmorInventory;
- 
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftSaddledInventory.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftSaddledInventory.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftSaddledInventory.java
-@@ -0,0 +0,0 @@
-+package org.bukkit.craftbukkit.inventory;
-+
-+import net.minecraft.world.Container;
-+import org.bukkit.inventory.SaddledHorseInventory;
-+
-+public class CraftSaddledInventory extends CraftInventoryAbstractHorse implements SaddledHorseInventory {
-+
-+    public CraftSaddledInventory(Container inventory) {
-+        super(inventory);
-+    }
-+
-+}

patches/unapplied/server/Improved-Async-Task-Scheduler.patch

@@ -1,356 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Fri, 16 Mar 2018 22:59:43 -0400
-Subject: [PATCH] Improved Async Task Scheduler
-
-The Craft Scheduler still uses the primary thread for task scheduling.
-This results in the main thread still having to do work as part of the
-dispatching of async tasks.
-
-If plugins make use of lots of async tasks, such as particle emitters
-that want to keep the logic off the main thread, the main thread still
-receives quite a bit of load from processing all of these queued tasks.
-
-Additionally, resizing and managing the pending entries for all of
-these asynchronous tasks takes up time on the main thread too.
-
-This commit replaces the implementation of the scheduler when working
-with asynchronous tasks, by forwarding calls to the new scheduler.
-
-The Async Scheduler uses a single thread executor for "management" tasks.
-The Management Thread is responsible for all adding and dispatching of
-scheduled tasks.
-
-The mainThreadHeartbeat will send a heartbeat task to the management thread
-with the currentTick value, so that it can find which tasks to execute.
-
-Scheduling of an async tasks also dispatches a management task, ensuring
-that any Queue resizing operation occurs off of the main thread.
-
-The async queue uses a complete separate PriorityQueue, ensuring that resize
-operations are decoupled from the sync tasks queue.
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftAsyncScheduler.java b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftAsyncScheduler.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftAsyncScheduler.java
-@@ -0,0 +0,0 @@
-+/*
-+ * Copyright (c) 2018 Daniel Ennis (Aikar) MIT License
-+ *
-+ *  Permission is hereby granted, free of charge, to any person obtaining
-+ *  a copy of this software and associated documentation files (the
-+ *  "Software"), to deal in the Software without restriction, including
-+ *  without limitation the rights to use, copy, modify, merge, publish,
-+ *  distribute, sublicense, and/or sell copies of the Software, and to
-+ *  permit persons to whom the Software is furnished to do so, subject to
-+ *  the following conditions:
-+ *
-+ *  The above copyright notice and this permission notice shall be
-+ *  included in all copies or substantial portions of the Software.
-+ *
-+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-+ */
-+
-+package org.bukkit.craftbukkit.scheduler;
-+
-+import com.destroystokyo.paper.ServerSchedulerReportingWrapper;
-+import com.google.common.util.concurrent.ThreadFactoryBuilder;
-+import org.bukkit.plugin.Plugin;
-+
-+import java.util.ArrayList;
-+import java.util.Iterator;
-+import java.util.List;
-+import java.util.concurrent.Executor;
-+import java.util.concurrent.Executors;
-+import java.util.concurrent.SynchronousQueue;
-+import java.util.concurrent.ThreadPoolExecutor;
-+import java.util.concurrent.TimeUnit;
-+
-+public class CraftAsyncScheduler extends CraftScheduler {
-+
-+    private final ThreadPoolExecutor executor = new ThreadPoolExecutor(
-+            4, Integer.MAX_VALUE,30L, TimeUnit.SECONDS, new SynchronousQueue<>(),
-+            new ThreadFactoryBuilder().setNameFormat("Craft Scheduler Thread - %1$d").build());
-+    private final Executor management = Executors.newSingleThreadExecutor(new ThreadFactoryBuilder()
-+            .setNameFormat("Craft Async Scheduler Management Thread").build());
-+    private final List<CraftTask> temp = new ArrayList<>();
-+
-+    CraftAsyncScheduler() {
-+        super(true);
-+        executor.allowCoreThreadTimeOut(true);
-+        executor.prestartAllCoreThreads();
-+    }
-+
-+    @Override
-+    public void cancelTask(int taskId) {
-+        this.management.execute(() -> this.removeTask(taskId));
-+    }
-+
-+    private synchronized void removeTask(int taskId) {
-+        parsePending();
-+        this.pending.removeIf((task) -> {
-+            if (task.getTaskId() == taskId) {
-+                task.cancel0();
-+                return true;
-+            }
-+            return false;
-+        });
-+    }
-+
-+    @Override
-+    public void mainThreadHeartbeat() {
-+        this.currentTick++;
-+        this.management.execute(() -> this.runTasks(currentTick));
-+    }
-+
-+    private synchronized void runTasks(int currentTick) {
-+        parsePending();
-+        while (!this.pending.isEmpty() && this.pending.peek().getNextRun() <= currentTick) {
-+            CraftTask task = this.pending.remove();
-+            if (executeTask(task)) {
-+                final long period = task.getPeriod();
-+                if (period > 0) {
-+                    task.setNextRun(currentTick + period);
-+                    temp.add(task);
-+                }
-+            }
-+            parsePending();
-+        }
-+        this.pending.addAll(temp);
-+        temp.clear();
-+    }
-+
-+    private boolean executeTask(CraftTask task) {
-+        if (isValid(task)) {
-+            this.runners.put(task.getTaskId(), task);
-+            this.executor.execute(new ServerSchedulerReportingWrapper(task));
-+            return true;
-+        }
-+        return false;
-+    }
-+
-+    @Override
-+    public synchronized void cancelTasks(Plugin plugin) {
-+        parsePending();
-+        for (Iterator<CraftTask> iterator = this.pending.iterator(); iterator.hasNext(); ) {
-+            CraftTask task = iterator.next();
-+            if (task.getTaskId() != -1 && (plugin == null || task.getOwner().equals(plugin))) {
-+                task.cancel0();
-+                iterator.remove();
-+            }
-+        }
-+    }
-+
-+    /**
-+     * Task is not cancelled
-+     * @param runningTask
-+     * @return
-+     */
-+    static boolean isValid(CraftTask runningTask) {
-+        return runningTask.getPeriod() >= CraftTask.NO_REPEATING;
-+    }
-+}
-diff --git a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
-+++ b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftScheduler.java
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
-     /**
-      * Main thread logic only
-      */
--    private final PriorityQueue<CraftTask> pending = new PriorityQueue<CraftTask>(10,
-+    final PriorityQueue<CraftTask> pending = new PriorityQueue<CraftTask>(10, // Paper
-             new Comparator<CraftTask>() {
-                 @Override
-                 public int compare(final CraftTask o1, final CraftTask o2) {
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
-     /**
-      * These are tasks that are currently active. It's provided for 'viewing' the current state.
-      */
--    private final ConcurrentHashMap<Integer, CraftTask> runners = new ConcurrentHashMap<Integer, CraftTask>();
-+    final ConcurrentHashMap<Integer, CraftTask> runners = new ConcurrentHashMap<Integer, CraftTask>(); // Paper
-     /**
-      * The sync task that is currently running on the main thread.
-      */
-     private volatile CraftTask currentTask = null;
--    private volatile int currentTick = -1;
-+    // Paper start - Improved Async Task Scheduler
-+    volatile int currentTick = -1;/*
-     private final Executor executor = Executors.newCachedThreadPool(new ThreadFactoryBuilder().setNameFormat("Craft Scheduler Thread - %d").build());
-     private CraftAsyncDebugger debugHead = new CraftAsyncDebugger(-1, null, null) {
-         @Override
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
-         }
-     };
-     private CraftAsyncDebugger debugTail = this.debugHead;
-+
-+    */ // Paper end
-     private static final int RECENT_TICKS;
- 
-     static {
-         RECENT_TICKS = 30;
-     }
- 
-+
-+    // Paper start
-+    private final CraftScheduler asyncScheduler;
-+    private final boolean isAsyncScheduler;
-+    public CraftScheduler() {
-+        this(false);
-+    }
-+
-+    public CraftScheduler(boolean isAsync) {
-+        this.isAsyncScheduler = isAsync;
-+        if (isAsync) {
-+            this.asyncScheduler = this;
-+        } else {
-+            this.asyncScheduler = new CraftAsyncScheduler();
-+        }
-+    }
-+    // Paper end
-     @Override
-     public int scheduleSyncDelayedTask(final Plugin plugin, final Runnable task) {
-         return this.scheduleSyncDelayedTask(plugin, task, 0L);
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
-         } else if (period < CraftTask.NO_REPEATING) {
-             period = CraftTask.NO_REPEATING;
-         }
--        return this.handle(new CraftAsyncTask(this.runners, plugin, runnable, this.nextId(), period), delay);
-+        return this.handle(new CraftAsyncTask(this.asyncScheduler.runners, plugin, runnable, this.nextId(), period), delay); // Paper
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
-         if (taskId <= 0) {
-             return;
-         }
-+        // Paper start
-+        if (!this.isAsyncScheduler) {
-+            this.asyncScheduler.cancelTask(taskId);
-+        }
-+        // Paper end
-         CraftTask task = this.runners.get(taskId);
-         if (task != null) {
-             task.cancel0();
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
-     @Override
-     public void cancelTasks(final Plugin plugin) {
-         Preconditions.checkArgument(plugin != null, "Cannot cancel tasks of null plugin");
-+        // Paper start
-+        if (!this.isAsyncScheduler) {
-+            this.asyncScheduler.cancelTasks(plugin);
-+        }
-+        // Paper end
-         final CraftTask task = new CraftTask(
-                 new Runnable() {
-                     @Override
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
- 
-     @Override
-     public boolean isCurrentlyRunning(final int taskId) {
-+        // Paper start
-+        if (!this.isAsyncScheduler) {
-+            if (this.asyncScheduler.isCurrentlyRunning(taskId)) {
-+                return true;
-+            }
-+        }
-+        // Paper end
-         final CraftTask task = this.runners.get(taskId);
-         if (task == null) {
-             return false;
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
-         if (taskId <= 0) {
-             return false;
-         }
-+        // Paper start
-+        if (!this.isAsyncScheduler && this.asyncScheduler.isQueued(taskId)) {
-+            return true;
-+        }
-+        // Paper end
-         for (CraftTask task = this.head.getNext(); task != null; task = task.getNext()) {
-             if (task.getTaskId() == taskId) {
-                 return task.getPeriod() >= CraftTask.NO_REPEATING; // The task will run
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
- 
-     @Override
-     public List<BukkitWorker> getActiveWorkers() {
-+        // Paper start
-+        if (!isAsyncScheduler) {
-+            //noinspection TailRecursion
-+            return this.asyncScheduler.getActiveWorkers();
-+        }
-+        // Paper end
-         final ArrayList<BukkitWorker> workers = new ArrayList<BukkitWorker>();
-         for (final CraftTask taskObj : this.runners.values()) {
-             // Iterator will be a best-effort (may fail to grab very new values) if called from an async thread
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
-                 pending.add(task);
-             }
-         }
-+        // Paper start
-+        if (!this.isAsyncScheduler) {
-+            pending.addAll(this.asyncScheduler.getPendingTasks());
-+        }
-+        // Paper end
-         return pending;
-     }
- 
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
-      */
-     public void mainThreadHeartbeat() {
-         this.currentTick++;
-+        // Paper start
-+        if (!this.isAsyncScheduler) {
-+            this.asyncScheduler.mainThreadHeartbeat();
-+        }
-+        // Paper end
-         final List<CraftTask> temp = this.temp;
-         this.parsePending();
-         while (this.isReady(this.currentTick)) {
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
-                 this.parsePending();
-             } else {
-                 // this.debugTail = this.debugTail.setNext(new CraftAsyncDebugger(this.currentTick + CraftScheduler.RECENT_TICKS, task.getOwner(), task.getTaskClass())); // Paper
--                this.executor.execute(new com.destroystokyo.paper.ServerSchedulerReportingWrapper(task)); // Paper
-+                task.getOwner().getLogger().log(Level.SEVERE, "Unexpected Async Task in the Sync Scheduler. Report this to Paper"); // Paper
-                 // We don't need to parse pending
-                 // (async tasks must live with race-conditions if they attempt to cancel between these few lines of code)
-             }
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
-         //this.debugHead = this.debugHead.getNextHead(this.currentTick); // Paper
-     }
- 
--    private void addTask(final CraftTask task) {
-+    protected void addTask(final CraftTask task) {
-         final CraftTask tailTask = this.tail.getAndSet(task);
-         tailTask.setNext(task);
-     }
- 
--    private CraftTask handle(final CraftTask task, final long delay) {
-+    protected CraftTask handle(final CraftTask task, final long delay) { // Paper
-+        // Paper start
-+        if (!this.isAsyncScheduler && !task.isSync()) {
-+            this.asyncScheduler.handle(task, delay);
-+            return task;
-+        }
-+        // Paper end
-         task.setNextRun(this.currentTick + delay);
-         this.addTask(task);
-         return task;
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
-         return id;
-     }
- 
--    private void parsePending() {
-+    void parsePending() { // Paper
-         CraftTask head = this.head;
-         CraftTask task = head.getNext();
-         CraftTask lastTask = head;

patches/unapplied/server/Inventory-removeItemAnySlot.patch

@@ -1,58 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Zach Brown <1254957+zachbr@users.noreply.github.com>
-Date: Tue, 28 Aug 2018 23:04:15 -0400
-Subject: [PATCH] Inventory#removeItemAnySlot
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
-@@ -0,0 +0,0 @@ public class CraftInventory implements Inventory {
-     }
- 
-     private int first(ItemStack item, boolean withAmount) {
-+        // Paper start
-+        return first(item, withAmount, getStorageContents());
-+    }
-+
-+    private int first(ItemStack item, boolean withAmount, ItemStack[] inventory) {
-+        // Paper end
-         if (item == null) {
-             return -1;
-         }
--        ItemStack[] inventory = this.getStorageContents();
-+        // ItemStack[] inventory = this.getStorageContents(); // Paper - let param deal
-         for (int i = 0; i < inventory.length; i++) {
-             if (inventory[i] == null) continue;
- 
-@@ -0,0 +0,0 @@ public class CraftInventory implements Inventory {
- 
-     @Override
-     public HashMap<Integer, ItemStack> removeItem(ItemStack... items) {
-+        // Paper start
-+        return removeItem(false, items);
-+    }
-+
-+    @Override
-+    public HashMap<Integer, ItemStack> removeItemAnySlot(ItemStack... items) {
-+        return removeItem(true, items);
-+    }
-+
-+    private HashMap<Integer, ItemStack> removeItem(boolean searchEntire, ItemStack... items) {
-+        // Paper end
-         Preconditions.checkArgument(items != null, "items cannot be null");
-         HashMap<Integer, ItemStack> leftover = new HashMap<Integer, ItemStack>();
- 
-@@ -0,0 +0,0 @@ public class CraftInventory implements Inventory {
-             int toDelete = item.getAmount();
- 
-             while (true) {
--                int first = this.first(item, false);
-+                // Paper start - Allow searching entire contents
-+                ItemStack[] toSearch = searchEntire ? getContents() : getStorageContents();
-+                int first = this.first(item, false, toSearch);
-+                // Paper end
- 
-                 // Drat! we don't have this type in the inventory
-                 if (first == -1) {

patches/unapplied/server/InventoryCloseEvent-Reason-API.patch

@@ -1,212 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Tue, 3 Jul 2018 21:56:23 -0400
-Subject: [PATCH] InventoryCloseEvent Reason API
-
-Allows you to determine why an inventory was closed, enabling plugin developers
-to "confirm" things based on if it was player triggered close or not.
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
-         for (net.minecraft.world.level.block.entity.BlockEntity tileentity : chunk.getBlockEntities().values()) {
-             if (tileentity instanceof net.minecraft.world.Container) {
-                 for (org.bukkit.entity.HumanEntity h : Lists.newArrayList(((net.minecraft.world.Container) tileentity).getViewers())) {
--                    h.closeInventory();
-+                    h.closeInventory(org.bukkit.event.inventory.InventoryCloseEvent.Reason.UNLOADED); // Paper - Inventory close reason
-                 }
-             }
-         }
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
-             // Spigot Start
-             if (entity.getBukkitEntity() instanceof org.bukkit.inventory.InventoryHolder && (!(entity instanceof ServerPlayer) || entity.getRemovalReason() != Entity.RemovalReason.KILLED)) { // SPIGOT-6876: closeInventory clears death message
-                 for (org.bukkit.entity.HumanEntity h : Lists.newArrayList(((org.bukkit.inventory.InventoryHolder) entity.getBukkitEntity()).getInventory().getViewers())) {
--                    h.closeInventory();
-+                    h.closeInventory(org.bukkit.event.inventory.InventoryCloseEvent.Reason.UNLOADED); // Paper - Inventory close reason
-                 }
-             }
-             // Spigot End
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player {
-         }
-         // Paper end - Configurable container update tick rate
-         if (!this.level().isClientSide && !this.containerMenu.stillValid(this)) {
--            this.closeContainer();
-+            this.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.CANT_USE); // Paper - Inventory close reason
-             this.containerMenu = this.inventoryMenu;
-         }
- 
-@@ -0,0 +0,0 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player {
- 
-         // SPIGOT-943 - only call if they have an inventory open
-         if (this.containerMenu != this.inventoryMenu) {
--            this.closeContainer();
-+            this.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.DEATH); // Paper - Inventory close reason
-         }
- 
-         net.kyori.adventure.text.Component deathMessage = event.deathMessage() != null ? event.deathMessage() : net.kyori.adventure.text.Component.empty(); // Paper - Adventure
-@@ -0,0 +0,0 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player {
-         }
-         // CraftBukkit end
-         if (this.containerMenu != this.inventoryMenu) {
--            this.closeContainer();
-+            this.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.OPEN_NEW); // Paper - Inventory close reason
-         }
- 
-         // this.nextContainerCounter(); // CraftBukkit - moved up
-@@ -0,0 +0,0 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player {
- 
-     @Override
-     public void closeContainer() {
--        CraftEventFactory.handleInventoryCloseEvent(this); // CraftBukkit
-+        // Paper start - Inventory close reason
-+        this.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.UNKNOWN);
-+    }
-+    @Override
-+    public void closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason reason) {
-+        CraftEventFactory.handleInventoryCloseEvent(this, reason); // CraftBukkit
-+        // Paper end - Inventory close reason
-         this.connection.send(new ClientboundContainerClosePacket(this.containerMenu.containerId));
-         this.doCloseContainer();
-     }
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
- 
-     @Override
-     public void handleContainerClose(ServerboundContainerClosePacket packet) {
-+        // Paper start - Inventory close reason
-+        this.handleContainerClose(packet, org.bukkit.event.inventory.InventoryCloseEvent.Reason.PLAYER);
-+    }
-+    public void handleContainerClose(ServerboundContainerClosePacket packet, org.bukkit.event.inventory.InventoryCloseEvent.Reason reason) {
-+        // Paper end - Inventory close reason
-         PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel());
- 
-         if (this.player.isImmobile()) return; // CraftBukkit
--        CraftEventFactory.handleInventoryCloseEvent(this.player); // CraftBukkit
-+        CraftEventFactory.handleInventoryCloseEvent(this.player, reason); // CraftBukkit // Paper
- 
-         this.player.doCloseContainer();
-     }
-diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/players/PlayerList.java
-+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-         // CraftBukkit start - Quitting must be before we do final save of data, in case plugins need to modify it
-         // See SPIGOT-5799, SPIGOT-6145
-         if (entityplayer.containerMenu != entityplayer.inventoryMenu) {
--            entityplayer.closeContainer();
-+            entityplayer.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.DISCONNECT); // Paper - Inventory close reason
-         }
- 
-         PlayerQuitEvent playerQuitEvent = new PlayerQuitEvent(entityplayer.getBukkitEntity(), net.kyori.adventure.text.Component.translatable("multiplayer.player.left", net.kyori.adventure.text.format.NamedTextColor.YELLOW, io.papermc.paper.configuration.GlobalConfiguration.get().messages.useDisplayNameInQuitMessage ? entityplayer.getBukkitEntity().displayName() : io.papermc.paper.adventure.PaperAdventure.asAdventure(entityplayer.getDisplayName()))); // Paper - Adventure
-diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/player/Player.java
-+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
-@@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
-         this.updateIsUnderwater();
-         super.tick();
-         if (!this.level().isClientSide && this.containerMenu != null && !this.containerMenu.stillValid(this)) {
--            this.closeContainer();
-+            this.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.CANT_USE); // Paper - Inventory close reason
-             this.containerMenu = this.inventoryMenu;
-         }
- 
-@@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
- 
-     }
- 
-+    // Paper start - Inventory close reason; unused code, but to keep signatures aligned
-+    public void closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason reason) {
-+        closeContainer();
-+        this.containerMenu = this.inventoryMenu;
-+    }
-+    // Paper end - Inventory close reason
-+
-     public void closeContainer() {
-         this.containerMenu = this.inventoryMenu;
-     }
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
-@@ -0,0 +0,0 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
-         if (((ServerPlayer) this.getHandle()).connection == null) return;
-         if (this.getHandle().containerMenu != this.getHandle().inventoryMenu) {
-             // fire INVENTORY_CLOSE if one already open
--            ((ServerPlayer) this.getHandle()).connection.handleContainerClose(new ServerboundContainerClosePacket(this.getHandle().containerMenu.containerId));
-+            ((ServerPlayer) this.getHandle()).connection.handleContainerClose(new ServerboundContainerClosePacket(this.getHandle().containerMenu.containerId), org.bukkit.event.inventory.InventoryCloseEvent.Reason.OPEN_NEW); // Paper - Inventory close reason
-         }
-         ServerPlayer player = (ServerPlayer) this.getHandle();
-         AbstractContainerMenu container;
-@@ -0,0 +0,0 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
- 
-     @Override
-     public void closeInventory() {
--        this.getHandle().closeContainer();
-+        // Paper start - Inventory close reason
-+        this.getHandle().closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.PLUGIN);
-     }
-+    @Override
-+    public void closeInventory(org.bukkit.event.inventory.InventoryCloseEvent.Reason reason) {
-+        getHandle().closeContainer(reason);
-+    }
-+    // Paper end - Inventory close reason
- 
-     @Override
-     public boolean isBlocking() {
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
- 
-         // Close any foreign inventory
-         if (this.getHandle().containerMenu != this.getHandle().inventoryMenu) {
--            this.getHandle().closeContainer();
-+            this.getHandle().closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.TELEPORT); // Paper - Inventory close reason
-         }
- 
-         // Check if the fromWorld and toWorld are the same.
-diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
- 
-     public static AbstractContainerMenu callInventoryOpenEvent(ServerPlayer player, AbstractContainerMenu container, boolean cancelled) {
-         if (player.containerMenu != player.inventoryMenu) { // fire INVENTORY_CLOSE if one already open
--            player.connection.handleContainerClose(new ServerboundContainerClosePacket(player.containerMenu.containerId));
-+            player.connection.handleContainerClose(new ServerboundContainerClosePacket(player.containerMenu.containerId), InventoryCloseEvent.Reason.OPEN_NEW); // Paper - Inventory close reason
-         }
- 
-         CraftServer server = player.level().getCraftServer();
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
-         return event;
-     }
- 
-+    // Paper start
-+    /**
-+     * Incase plugins hooked into this or Spigot adds a new inventory close event. Prefer to pass a reason
-+     * @param human
-+     */
-+    @Deprecated
-     public static void handleInventoryCloseEvent(net.minecraft.world.entity.player.Player human) {
--        InventoryCloseEvent event = new InventoryCloseEvent(human.containerMenu.getBukkitView());
-+        handleInventoryCloseEvent(human, org.bukkit.event.inventory.InventoryCloseEvent.Reason.UNKNOWN);
-+    }
-+    public static void handleInventoryCloseEvent(net.minecraft.world.entity.player.Player human, org.bukkit.event.inventory.InventoryCloseEvent.Reason reason) {
-+        // Paper end
-+        InventoryCloseEvent event = new InventoryCloseEvent(human.containerMenu.getBukkitView(), reason); // Paper
-         human.level().getCraftServer().getPluginManager().callEvent(event);
-         human.containerMenu.transferTo(human.inventoryMenu, human.getBukkitEntity());
-     }

patches/unapplied/server/Item-canEntityPickup.patch

@@ -1,57 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Fri, 5 May 2017 03:57:17 -0500
-Subject: [PATCH] Item#canEntityPickup
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/Mob.java
-+++ b/src/main/java/net/minecraft/world/entity/Mob.java
-@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
-                     ItemEntity entityitem = (ItemEntity) iterator.next();
- 
-                     if (!entityitem.isRemoved() && !entityitem.getItem().isEmpty() && !entityitem.hasPickUpDelay() && this.wantsToPickUp(worldserver, entityitem.getItem())) {
-+                        // Paper start - Item#canEntityPickup
-+                        if (!entityitem.canMobPickup) {
-+                            continue;
-+                        }
-+                        // Paper end - Item#canEntityPickup
-                         this.pickUpItem(worldserver, entityitem);
-                     }
-                 }
-diff --git a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/item/ItemEntity.java
-@@ -0,0 +0,0 @@ public class ItemEntity extends Entity implements TraceableEntity {
-     public UUID target;
-     public final float bobOffs;
-     private int lastTick = MinecraftServer.currentTick - 1; // CraftBukkit
-+    public boolean canMobPickup = true; // Paper - Item#canEntityPickup
- 
-     public ItemEntity(EntityType<? extends ItemEntity> type, Level world) {
-         super(type, world);
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftItem.java
-@@ -0,0 +0,0 @@ public class CraftItem extends CraftEntity implements Item {
-         }
-     }
- 
-+    // Paper start
-+    @Override
-+    public boolean canMobPickup() {
-+        return this.getHandle().canMobPickup;
-+    }
-+
-+    @Override
-+    public void setCanMobPickup(boolean canMobPickup) {
-+        this.getHandle().canMobPickup = canMobPickup;
-+    }
-+    // Paper end
-+
-     @Override
-     public void setOwner(UUID uuid) {
-         this.getHandle().setTarget(uuid);

patches/unapplied/server/ItemStack-getMaxItemUseDuration.patch

@@ -1,33 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Tue, 5 Jun 2018 23:00:29 -0400
-Subject: [PATCH] ItemStack#getMaxItemUseDuration
-
-Allows you to determine how long it takes to use a usable/consumable item
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
-@@ -0,0 +0,0 @@ public final class CraftItemStack extends ItemStack {
-         return (this.handle == null) ? Material.AIR.getMaxStackSize() : this.handle.getMaxStackSize();
-     }
- 
-+    // Paper start
-+    @Override
-+    public int getMaxItemUseDuration(final org.bukkit.entity.LivingEntity entity) {
-+        if (handle == null) {
-+            return 0;
-+        }
-+
-+        // Make sure plugins calling the old method don't blow up
-+        if (entity == null && (handle.is(net.minecraft.world.item.Items.CROSSBOW) || handle.is(net.minecraft.world.item.Items.GOAT_HORN))) {
-+            throw new UnsupportedOperationException("This item requires an entity to determine the max use duration");
-+        }
-+        return handle.getUseDuration(entity != null ? ((org.bukkit.craftbukkit.entity.CraftLivingEntity) entity).getHandle() : null);
-+    }
-+    // Paper end
-+
-     @Override
-     public void addUnsafeEnchantment(Enchantment ench, int level) {
-         Preconditions.checkArgument(ench != null, "Enchantment cannot be null");

patches/unapplied/server/LivingEntity-Active-Item-API.patch

@@ -1,72 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Fri, 29 Jun 2018 00:21:28 -0400
-Subject: [PATCH] LivingEntity Active Item API
-
-API relating to items being actively used by a LivingEntity
-such as a bow or eating food.
-
-== AT ==
-public net/minecraft/world/entity/LivingEntity completeUsingItem()V
-public net/minecraft/server/level/ServerPlayer completeUsingItem()V
-
-Co-authored-by: Jake Potrebic <jake.m.potrebic@gmail.com>
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-@@ -0,0 +0,0 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
-         getHandle().setShieldBlockingDelay(delay);
-     }
-     // Paper end
-+
-+    // Paper start - active item API
-+    @Override
-+    public void startUsingItem(org.bukkit.inventory.EquipmentSlot hand) {
-+        Preconditions.checkArgument(hand != null, "hand must not be null");
-+        switch (hand) {
-+            case HAND -> getHandle().startUsingItem(InteractionHand.MAIN_HAND);
-+            case OFF_HAND -> getHandle().startUsingItem(InteractionHand.OFF_HAND);
-+            default -> throw new IllegalArgumentException("hand may only be HAND or OFF_HAND");
-+        }
-+    }
-+
-+    @Override
-+    public void completeUsingActiveItem() {
-+        getHandle().completeUsingItem();
-+    }
-+
-+    @Override
-+    public ItemStack getActiveItem() {
-+        return this.getHandle().getUseItem().asBukkitMirror();
-+    }
-+
-+    @Override
-+    public int getActiveItemRemainingTime() {
-+        return this.getHandle().getUseItemRemainingTicks();
-+    }
-+
-+    @Override
-+    public void setActiveItemRemainingTime(final int ticks) {
-+        Preconditions.checkArgument(ticks >= 0, "ticks must be >= 0");
-+        Preconditions.checkArgument(ticks <= this.getHandle().getUseItem().getUseDuration(this.getHandle()), "ticks must be <= item use duration");
-+        this.getHandle().useItemRemaining = ticks;
-+    }
-+
-+    @Override
-+    public int getActiveItemUsedTime() {
-+        return this.getHandle().getTicksUsingItem();
-+    }
-+
-+    @Override
-+    public boolean hasActiveItem() {
-+        return this.getHandle().isUsingItem();
-+    }
-+
-+    @Override
-+    public org.bukkit.inventory.EquipmentSlot getActiveItemHand() {
-+        return org.bukkit.craftbukkit.CraftEquipmentSlot.getHand(this.getHandle().getUsedItemHand());
-+    }
-+    // Paper end - active item API
- }

patches/unapplied/server/LivingEntity-setKiller.patch

@@ -1,29 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Mon, 31 Jul 2017 01:49:48 -0500
-Subject: [PATCH] LivingEntity#setKiller
-
-== AT ==
-public net.minecraft.world.entity.LivingEntity lastHurtByPlayerTime
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-@@ -0,0 +0,0 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
-         return this.getHandle().lastHurtByPlayer == null ? null : (Player) this.getHandle().lastHurtByPlayer.getBukkitEntity();
-     }
- 
-+    // Paper start
-+    @Override
-+    public void setKiller(Player killer) {
-+        net.minecraft.server.level.ServerPlayer entityPlayer = killer == null ? null : ((CraftPlayer) killer).getHandle();
-+        getHandle().lastHurtByPlayer = entityPlayer;
-+        getHandle().lastHurtByMob = entityPlayer;
-+        getHandle().lastHurtByPlayerTime = entityPlayer == null ? 0 : 100; // 100 value taken from EntityLiving#damageEntity
-+    }
-+    // Paper end
-+
-     @Override
-     public boolean addPotionEffect(PotionEffect effect) {
-         return this.addPotionEffect(effect, false);

patches/unapplied/server/Make-CraftWorld-loadChunk-int-int-false-load-unconve.patch

@@ -1,20 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Sun, 2 Sep 2018 19:34:33 -0700
-Subject: [PATCH] Make CraftWorld#loadChunk(int, int, false) load unconverted
- chunks
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor implements World {
-     @Override
-     public boolean loadChunk(int x, int z, boolean generate) {
-         org.spigotmc.AsyncCatcher.catchOp("chunk load"); // Spigot
--        ChunkAccess chunk = this.world.getChunkSource().getChunk(x, z, generate ? ChunkStatus.FULL : ChunkStatus.EMPTY, true);
-+        ChunkAccess chunk = this.world.getChunkSource().getChunk(x, z, generate || isChunkGenerated(x, z) ? ChunkStatus.FULL : ChunkStatus.EMPTY, true); // Paper
- 
-         // If generate = false, but the chunk already exists, we will get this back.
-         if (chunk instanceof ImposterProtoChunk) {

patches/unapplied/server/Make-legacy-ping-handler-more-reliable.patch

@@ -1,188 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Minecrell <minecrell@minecrell.net>
-Date: Wed, 11 Oct 2017 18:22:50 +0200
-Subject: [PATCH] Make legacy ping handler more reliable
-
-The Minecraft server often fails to respond to old ("legacy") pings
-from old Minecraft versions using the protocol used before the switch
-to Netty in Minecraft 1.7.
-
-Due to packet fragmentation[1], we might not have all needed bytes
-available when the LegacyPingHandler is called. In this case, it will
-run into an error, remove the handler and continue using the modern
-protocol.
-
-This is unlikely to happen for the first two revisions of the legacy
-ping protocol (used in Minecraft 1.5.x and older) since the request
-consists of only one or two bytes, but happens frequently for the
-last/third revision introduced in Minecraft 1.6.
-
-It has much larger, variable packet sizes due to the inclusion of
-the virtual host (the hostname/port used to connect to the server).
-
-The solution[2] is simple: If we find more than two matching bytes,
-we buffer the remaining bytes until we have enough to fully read and
-respond to the request.
-
-[1]: https://netty.io/wiki/user-guide-for-4.x.html#wiki-h3-11
-[2]: https://netty.io/wiki/user-guide-for-4.x.html#wiki-h4-13
-
-diff --git a/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java b/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java
-+++ b/src/main/java/net/minecraft/server/network/LegacyQueryHandler.java
-@@ -0,0 +0,0 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
- 
-     private static final Logger LOGGER = LogUtils.getLogger();
-     private final ServerInfo server;
-+    private ByteBuf buf; // Paper
- 
-     public LegacyQueryHandler(ServerInfo server) {
-         this.server = server;
-@@ -0,0 +0,0 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
-     public void channelRead(ChannelHandlerContext channelhandlercontext, Object object) {
-         ByteBuf bytebuf = (ByteBuf) object;
- 
-+        // Paper start - Make legacy ping handler more reliable
-+        if (this.buf != null) {
-+            try {
-+                readLegacy1_6(channelhandlercontext, bytebuf);
-+            } finally {
-+                bytebuf.release();
-+            }
-+            return;
-+        }
-+        // Paper end
-         bytebuf.markReaderIndex();
-         boolean flag = true;
- 
-@@ -0,0 +0,0 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
- 
-                 SocketAddress socketaddress = channelhandlercontext.channel().remoteAddress();
-                 int i = bytebuf.readableBytes();
--                String s;
-+                String s = null; // Paper
-                 org.bukkit.event.server.ServerListPingEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callServerListPingEvent(socketaddress, this.server.getMotd(), this.server.getPlayerCount(), this.server.getMaxPlayers()); // CraftBukkit
- 
-                 if (i == 0) {
-@@ -0,0 +0,0 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
-                     }
- 
-                     if (bytebuf.isReadable()) {
--                        if (!LegacyQueryHandler.readCustomPayloadPacket(bytebuf)) {
--                            return;
-+                        // Paper start - Replace with improved version below
-+                        if (bytebuf.readUnsignedByte() != 250) {
-+                            s = this.readLegacy1_6(channelhandlercontext, bytebuf);
-+                            if (s == null) {
-+                                return;
-+                            }
-                         }
--
--                        LegacyQueryHandler.LOGGER.debug("Ping: (1.6) from {}", socketaddress);
-+                        // if (!LegacyQueryHandler.readCustomPayloadPacket(bytebuf)) {
-+                        //     return;
-+                        // }
-+                        //
-+                        // LegacyQueryHandler.LOGGER.debug("Ping: (1.6) from {}", socketaddress);
-+                        // Paper end
-                     } else {
-                         LegacyQueryHandler.LOGGER.debug("Ping: (1.4-1.5.x) from {}", socketaddress);
-                     }
- 
--                    s = LegacyQueryHandler.createVersion1Response(this.server, event); // CraftBukkit
-+                    if (s == null) s = LegacyQueryHandler.createVersion1Response(this.server, event); // CraftBukkit // Paper
-                     LegacyQueryHandler.sendFlushAndClose(channelhandlercontext, LegacyQueryHandler.createLegacyDisconnectPacket(channelhandlercontext.alloc(), s));
-                 }
- 
-@@ -0,0 +0,0 @@ public class LegacyQueryHandler extends ChannelInboundHandlerAdapter {
-         }
-     }
- 
-+    // Paper start
-+    private static String readLegacyString(ByteBuf buf) {
-+        int size = buf.readShort() * Character.BYTES;
-+        if (!buf.isReadable(size)) {
-+            return null;
-+        }
-+
-+        String result = buf.toString(buf.readerIndex(), size, java.nio.charset.StandardCharsets.UTF_16BE);
-+        buf.skipBytes(size); // toString doesn't increase readerIndex automatically
-+        return result;
-+    }
-+
-+    private String readLegacy1_6(ChannelHandlerContext ctx, ByteBuf part) {
-+        ByteBuf buf = this.buf;
-+
-+        if (buf == null) {
-+            this.buf = buf = ctx.alloc().buffer();
-+            buf.markReaderIndex();
-+        } else {
-+            buf.resetReaderIndex();
-+        }
-+
-+        buf.writeBytes(part);
-+
-+        if (!buf.isReadable(Short.BYTES + Short.BYTES + Byte.BYTES + Short.BYTES + Integer.BYTES)) {
-+            return null;
-+        }
-+
-+        String s = readLegacyString(buf);
-+        if (s == null) {
-+            return null;
-+        }
-+
-+        if (!s.equals("MC|PingHost")) {
-+            removeHandler(ctx);
-+            return null;
-+        }
-+
-+        if (!buf.isReadable(Short.BYTES) || !buf.isReadable(buf.readShort())) {
-+            return null;
-+        }
-+
-+        net.minecraft.server.MinecraftServer server = net.minecraft.server.MinecraftServer.getServer();
-+        int protocolVersion = buf.readByte();
-+        String host = readLegacyString(buf);
-+        if (host == null) {
-+            removeHandler(ctx);
-+            return null;
-+        }
-+        int port = buf.readInt();
-+
-+        if (buf.isReadable()) {
-+            removeHandler(ctx);
-+            return null;
-+        }
-+
-+        buf.release();
-+        this.buf = null;
-+
-+        LOGGER.debug("Ping: (1.6) from {}", ctx.channel().remoteAddress());
-+
-+        String response = String.format("\u00a71\u0000%d\u0000%s\u0000%s\u0000%d\u0000%d",
-+            Byte.MAX_VALUE, server.getServerVersion(), server.getMotd(), server.getPlayerCount(), server.getMaxPlayers());
-+        return response;
-+    }
-+
-+    private void removeHandler(ChannelHandlerContext ctx) {
-+        ByteBuf buf = this.buf;
-+        this.buf = null;
-+
-+        buf.resetReaderIndex();
-+        ctx.pipeline().remove(this);
-+        ctx.fireChannelRead(buf);
-+    }
-+
-+    @Override
-+    public void handlerRemoved(ChannelHandlerContext ctx) {
-+        if (this.buf != null) {
-+            this.buf.release();
-+            this.buf = null;
-+        }
-+    }
-+    // Paper end
-+
-     // CraftBukkit start
-     private static String createVersion0Response(ServerInfo serverinfo, org.bukkit.event.server.ServerListPingEvent event) {
-         return String.format(Locale.ROOT, "%s\u00a7%d\u00a7%d", event.getMotd(), event.getNumPlayers(), event.getMaxPlayers());

patches/unapplied/server/Make-shield-blocking-delay-configurable.patch

@@ -1,56 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Sat, 16 Jun 2018 01:18:16 -0500
-Subject: [PATCH] Make shield blocking delay configurable
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-         if (this.isUsingItem() && !this.useItem.isEmpty()) {
-             Item item = this.useItem.getItem();
- 
--            return item.getUseAnimation(this.useItem) != ItemUseAnimation.BLOCK ? null : (item.getUseDuration(this.useItem, this) - this.useItemRemaining < 5 ? null : this.useItem);
-+            return item.getUseAnimation(this.useItem) != ItemUseAnimation.BLOCK ? null : (item.getUseDuration(this.useItem, this) - this.useItemRemaining < getShieldBlockingDelay() ? null : this.useItem); // Paper - Make shield blocking delay configurable
-         } else {
-             return null;
-         }
-     }
- 
-+    // Paper start - Make shield blocking delay configurable
-+    public int shieldBlockingDelay = this.level().paperConfig().misc.shieldBlockingDelay;
-+
-+    public int getShieldBlockingDelay() {
-+        return shieldBlockingDelay;
-+    }
-+
-+    public void setShieldBlockingDelay(int shieldBlockingDelay) {
-+        this.shieldBlockingDelay = shieldBlockingDelay;
-+    }
-+    // Paper end - Make shield blocking delay configurable
-+
-     public boolean isSuppressingSlidingDownLadder() {
-         return this.isShiftKeyDown();
-     }
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-@@ -0,0 +0,0 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
-     public void setArrowsStuck(final int arrows) {
-         this.getHandle().setArrowCount(arrows);
-     }
-+
-+    @Override
-+    public int getShieldBlockingDelay() {
-+        return getHandle().getShieldBlockingDelay();
-+    }
-+
-+    @Override
-+    public void setShieldBlockingDelay(int delay) {
-+        getHandle().setShieldBlockingDelay(delay);
-+    }
-     // Paper end
- }

patches/unapplied/server/Mob-Pathfinding-API.patch

@@ -1,209 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sun, 9 Sep 2018 13:30:00 -0400
-Subject: [PATCH] Mob Pathfinding API
-
-Implements Pathfinding API for mobs
-
-== AT ==
-public net.minecraft.world.entity.ai.navigation.PathNavigation pathFinder
-public net.minecraft.world.level.pathfinder.PathFinder nodeEvaluator
-public net.minecraft.world.level.pathfinder.Path nodes
-
-diff --git a/src/main/java/com/destroystokyo/paper/entity/PaperPathfinder.java b/src/main/java/com/destroystokyo/paper/entity/PaperPathfinder.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/entity/PaperPathfinder.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.entity;
-+
-+import org.apache.commons.lang.Validate;
-+import org.bukkit.Location;
-+import org.bukkit.craftbukkit.entity.CraftLivingEntity;
-+import org.bukkit.entity.LivingEntity;
-+import org.bukkit.entity.Mob;
-+import javax.annotation.Nonnull;
-+import javax.annotation.Nullable;
-+import net.minecraft.world.level.pathfinder.Node;
-+import net.minecraft.world.level.pathfinder.Path;
-+import java.util.ArrayList;
-+import java.util.List;
-+
-+public class PaperPathfinder implements com.destroystokyo.paper.entity.Pathfinder {
-+
-+    private net.minecraft.world.entity.Mob entity;
-+
-+    public PaperPathfinder(net.minecraft.world.entity.Mob entity) {
-+        this.entity = entity;
-+    }
-+
-+    @Override
-+    public Mob getEntity() {
-+        return (Mob) entity.getBukkitEntity();
-+    }
-+
-+    public void setHandle(net.minecraft.world.entity.Mob entity) {
-+        this.entity = entity;
-+    }
-+
-+    @Override
-+    public void stopPathfinding() {
-+        entity.getNavigation().stop();
-+    }
-+
-+    @Override
-+    public boolean hasPath() {
-+        return entity.getNavigation().getPath() != null && !entity.getNavigation().getPath().isDone();
-+    }
-+
-+    @Nullable
-+    @Override
-+    public PathResult getCurrentPath() {
-+        Path path = entity.getNavigation().getPath();
-+        return path != null && !path.isDone() ? new PaperPathResult(path) : null;
-+    }
-+
-+    @Nullable
-+    @Override
-+    public PathResult findPath(Location loc) {
-+        Validate.notNull(loc, "Location can not be null");
-+        Path path = entity.getNavigation().createPath(loc.getX(), loc.getY(), loc.getZ(), 0);
-+        return path != null ? new PaperPathResult(path) : null;
-+    }
-+
-+    @Nullable
-+    @Override
-+    public PathResult findPath(LivingEntity target) {
-+        Validate.notNull(target, "Target can not be null");
-+        Path path = entity.getNavigation().createPath(((CraftLivingEntity) target).getHandle(), 0);
-+        return path != null ? new PaperPathResult(path) : null;
-+    }
-+
-+    @Override
-+    public boolean moveTo(@Nonnull PathResult path, double speed) {
-+        Validate.notNull(path, "PathResult can not be null");
-+        Path pathEntity = ((PaperPathResult) path).path;
-+        return entity.getNavigation().moveTo(pathEntity, speed);
-+    }
-+
-+    @Override
-+    public boolean canOpenDoors() {
-+        return entity.getNavigation().pathFinder.nodeEvaluator.canOpenDoors();
-+    }
-+
-+    @Override
-+    public void setCanOpenDoors(boolean canOpenDoors) {
-+        entity.getNavigation().pathFinder.nodeEvaluator.setCanOpenDoors(canOpenDoors);
-+    }
-+
-+    @Override
-+    public boolean canPassDoors() {
-+        return entity.getNavigation().pathFinder.nodeEvaluator.canPassDoors();
-+    }
-+
-+    @Override
-+    public void setCanPassDoors(boolean canPassDoors) {
-+        entity.getNavigation().pathFinder.nodeEvaluator.setCanPassDoors(canPassDoors);
-+    }
-+
-+    @Override
-+    public boolean canFloat() {
-+        return entity.getNavigation().pathFinder.nodeEvaluator.canFloat();
-+    }
-+
-+    @Override
-+    public void setCanFloat(boolean canFloat) {
-+        entity.getNavigation().pathFinder.nodeEvaluator.setCanFloat(canFloat);
-+    }
-+
-+    public class PaperPathResult implements com.destroystokyo.paper.entity.PaperPathfinder.PathResult {
-+
-+        private final Path path;
-+        PaperPathResult(Path path) {
-+            this.path = path;
-+        }
-+
-+        @Nullable
-+        @Override
-+        public Location getFinalPoint() {
-+            Node point = path.getEndNode();
-+            return point != null ? toLoc(point) : null;
-+        }
-+
-+        @Override
-+        public boolean canReachFinalPoint() {
-+            return path.canReach();
-+        }
-+
-+        @Override
-+        public List<Location> getPoints() {
-+            List<Location> points = new ArrayList<>();
-+            for (Node point : path.nodes) {
-+                points.add(toLoc(point));
-+            }
-+            return points;
-+        }
-+
-+        @Override
-+        public int getNextPointIndex() {
-+            return path.getNextNodeIndex();
-+        }
-+
-+        @Nullable
-+        @Override
-+        public Location getNextPoint() {
-+            if (!path.hasNext()) {
-+                return null;
-+            }
-+            return toLoc(path.nodes.get(path.getNextNodeIndex()));
-+        }
-+    }
-+
-+    private Location toLoc(Node point) {
-+        return new Location(entity.level().getWorld(), point.x, point.y, point.z);
-+    }
-+}
-diff --git a/src/main/java/net/minecraft/world/level/pathfinder/Path.java b/src/main/java/net/minecraft/world/level/pathfinder/Path.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/pathfinder/Path.java
-+++ b/src/main/java/net/minecraft/world/level/pathfinder/Path.java
-@@ -0,0 +0,0 @@ public class Path {
-     private final BlockPos target;
-     private final float distToTarget;
-     private final boolean reached;
-+    public boolean hasNext() { return getNextNodeIndex() < this.nodes.size(); } // Paper - Mob Pathfinding API
- 
-     public Path(List<Node> nodes, BlockPos target, boolean reachesTarget) {
-         this.nodes = nodes;
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftMob.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftMob.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftMob.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftMob.java
-@@ -0,0 +0,0 @@ import org.bukkit.loot.LootTable;
- public abstract class CraftMob extends CraftLivingEntity implements Mob {
-     public CraftMob(CraftServer server, net.minecraft.world.entity.Mob entity) {
-         super(server, entity);
-+         paperPathfinder = new com.destroystokyo.paper.entity.PaperPathfinder(entity); // Paper - Mob Pathfinding API
-     }
- 
-+    private final com.destroystokyo.paper.entity.PaperPathfinder paperPathfinder; // Paper - Mob Pathfinding API
-+    @Override public com.destroystokyo.paper.entity.Pathfinder getPathfinder() { return paperPathfinder; } // Paper - Mob Pathfinding API
-     @Override
-     public void setTarget(LivingEntity target) {
-         Preconditions.checkState(!this.getHandle().generation, "Cannot set target during world generation");
-@@ -0,0 +0,0 @@ public abstract class CraftMob extends CraftLivingEntity implements Mob {
-         return (net.minecraft.world.entity.Mob) this.entity;
-     }
- 
-+    // Paper start - Mob Pathfinding API
-+    @Override
-+    public void setHandle(net.minecraft.world.entity.Entity entity) {
-+        super.setHandle(entity);
-+        paperPathfinder.setHandle(getHandle());
-+    }
-+    // Paper end - Mob Pathfinding API
-+
-     @Override
-     public String toString() {
-         return "CraftMob";

patches/unapplied/server/Ocelot-despawns-should-honor-nametags-and-leash.patch

@@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Mon, 31 Jul 2017 01:54:40 -0500
-Subject: [PATCH] Ocelot despawns should honor nametags and leash
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/animal/Ocelot.java b/src/main/java/net/minecraft/world/entity/animal/Ocelot.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/animal/Ocelot.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/Ocelot.java
-@@ -0,0 +0,0 @@ public class Ocelot extends Animal {
- 
-     @Override
-     public boolean removeWhenFarAway(double distanceSquared) {
--        return !this.isTrusting() && this.tickCount > 2400;
-+        return !this.isTrusting() && this.tickCount > 2400 && !this.hasCustomName() && !this.isLeashed(); // Paper - honor name and leash
-     }
- 
-     public static AttributeSupplier.Builder createAttributes() {