Move patches

Spigot-Server-Patches/0545-Brand-support.patch

@@ -1,92 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: DigitalRegent <misterwener@gmail.com>
-Date: Sat, 11 Apr 2020 13:10:58 +0200
-Subject: [PATCH] Brand support
-
-
-diff --git a/src/main/java/net/minecraft/server/network/PlayerConnection.java b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/PlayerConnection.java
-+++ b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-@@ -0,0 +0,0 @@ import com.google.common.primitives.Doubles;
- import com.google.common.primitives.Floats;
- import com.mojang.brigadier.ParseResults;
- import com.mojang.brigadier.StringReader;
-+import io.netty.buffer.Unpooled;
- import io.netty.util.concurrent.Future;
- import io.netty.util.concurrent.GenericFutureListener;
- import it.unimi.dsi.fastutil.ints.Int2ShortMap;
-@@ -0,0 +0,0 @@ import net.minecraft.nbt.NBTTagCompound;
- import net.minecraft.nbt.NBTTagList;
- import net.minecraft.nbt.NBTTagString;
- import net.minecraft.network.NetworkManager;
-+import net.minecraft.network.PacketDataSerializer;
- import net.minecraft.network.chat.ChatComponentText;
- import net.minecraft.network.chat.ChatMessage;
- import net.minecraft.network.chat.ChatMessageType;
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-     private static final int MAX_SIGN_LINE_LENGTH = Integer.getInteger("Paper.maxSignLength", 80);
-     private static final long KEEPALIVE_LIMIT = Long.getLong("paper.playerconnection.keepalive", 30) * 1000; // Paper - provide property to set keepalive limit
- 
-+    private String clientBrandName = null; // Paper - Brand name
-+
-     public PlayerConnection(MinecraftServer minecraftserver, NetworkManager networkmanager, EntityPlayer entityplayer) {
-         this.minecraftServer = minecraftserver;
-         this.networkManager = networkmanager;
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-     private static final MinecraftKey CUSTOM_REGISTER = new MinecraftKey("register");
-     private static final MinecraftKey CUSTOM_UNREGISTER = new MinecraftKey("unregister");
- 
-+    private static final MinecraftKey MINECRAFT_BRAND = new MinecraftKey("brand"); // Paper - Brand support
-+
-     @Override
-     public void a(PacketPlayInCustomPayload packetplayincustompayload) {
-         PlayerConnectionUtils.ensureMainThread(packetplayincustompayload, this, this.player.getWorldServer());
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-             try {
-                 byte[] data = new byte[packetplayincustompayload.data.readableBytes()];
-                 packetplayincustompayload.data.readBytes(data);
-+
-+                // Paper start - Brand support
-+                if (packetplayincustompayload.tag.equals(MINECRAFT_BRAND)) {
-+                    try {
-+                        this.clientBrandName = new PacketDataSerializer(Unpooled.copiedBuffer(data)).readUTF(256);
-+                    } catch (StringIndexOutOfBoundsException ex) {
-+                        this.clientBrandName = "illegal";
-+                    }
-+                }
-+                // Paper end
-                 server.getMessenger().dispatchIncomingMessage(player.getBukkitEntity(), packetplayincustompayload.tag.toString(), data);
-             } catch (Exception ex) {
-                 PlayerConnection.LOGGER.error("Couldn\'t dispatch custom payload", ex);
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
- 
-     }
- 
-+    // Paper start - brand support
-+    public String getClientBrandName() {
-+        return clientBrandName;
-+    }
-+    // Paper end
-+
-     public final boolean isDisconnected() {
-         return (!this.player.joining && !this.networkManager.isConnected()) || this.processedDisconnect; // Paper
-     }
-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 {
-         // Paper end
-     };
- 
-+    // Paper start - brand support
-+    @Override
-+    public String getClientBrandName() {
-+        return getHandle().playerConnection != null ? getHandle().playerConnection.getClientBrandName() : null;
-+    }
-+    // Paper end
-+
-     public Player.Spigot spigot()
-     {
-         return spigot;

Spigot-Server-Patches/API-to-get-a-BlockState-without-a-snapshot.patch

@@ -1,147 +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/TileEntity.java b/src/main/java/net/minecraft/world/level/block/entity/TileEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/TileEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/TileEntity.java
-@@ -0,0 +0,0 @@ public abstract class TileEntity implements net.minecraft.server.KeyedObject { /
-     public TileEntity(TileEntityTypes<?> tileentitytypes) {
-         this.position = BlockPosition.ZERO;
-         this.tileType = tileentitytypes;
-+        persistentDataContainer = new CraftPersistentDataContainer(DATA_TYPE_REGISTRY); // Paper - always init
-     }
- 
-     // Paper start
-@@ -0,0 +0,0 @@ public abstract class TileEntity implements net.minecraft.server.KeyedObject { /
-     public void load(IBlockData iblockdata, NBTTagCompound nbttagcompound) {
-         this.position = new BlockPosition(nbttagcompound.getInt("x"), nbttagcompound.getInt("y"), nbttagcompound.getInt("z"));
-         // CraftBukkit start - read container
--        this.persistentDataContainer = new CraftPersistentDataContainer(DATA_TYPE_REGISTRY);
-+        this.persistentDataContainer.clear(); // Paper - clear instead of reinit
- 
-         net.minecraft.nbt.NBTBase persistentDataTag = nbttagcompound.get("PublicBukkitValues");
-         if (persistentDataTag instanceof NBTTagCompound) {
-@@ -0,0 +0,0 @@ public abstract class TileEntity implements net.minecraft.server.KeyedObject { /
-     }
- 
-     // CraftBukkit start - add method
-+    // Paper start
-     public InventoryHolder getOwner() {
-+        return getOwner(true);
-+    }
-+    public InventoryHolder getOwner(boolean useSnapshot) {
-+        // Paper end
-         if (world == null) return null;
-         // Spigot start
-         org.bukkit.block.Block block = world.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ());
-@@ -0,0 +0,0 @@ public abstract class TileEntity implements net.minecraft.server.KeyedObject { /
-             return null;
-         }
-         // Spigot end
--        org.bukkit.block.BlockState state = block.getState();
-+        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 {
- 
-     @Override
-     public BlockState getState() {
-+        // Paper start - allow disabling the use of snapshots
-+        return getState(true);
-+    }
-+    public BlockState getState(boolean useSnapshot) {
-+        boolean prev = CraftBlockEntityState.DISABLE_SNAPSHOT;
-+        CraftBlockEntityState.DISABLE_SNAPSHOT = !useSnapshot;
-+        try {
-+            return getState0();
-+        } finally {
-+            CraftBlockEntityState.DISABLE_SNAPSHOT = prev;
-+        }
-+    }
-+    public BlockState getState0() {
-+        // Paper end
-         Material material = getType();
- 
-         switch (material) {
-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 TileEntity> extends CraftBlockState
-         this.tileEntity = tileEntityClass.cast(world.getHandle().getTileEntity(this.getPosition()));
-         Preconditions.checkState(this.tileEntity != null, "Tile is null, asynchronous access? %s", block);
- 
-+        // Paper start
-+        this.snapshotDisabled = DISABLE_SNAPSHOT;
-+        if (DISABLE_SNAPSHOT) {
-+            this.snapshot = this.tileEntity;
-+        } else {
-+            this.snapshot = this.createSnapshot(this.tileEntity);
-+        }
-         // copy tile entity data:
--        this.snapshot = this.createSnapshot(tileEntity);
--        this.load(snapshot);
-+        if(this.snapshot != null) {
-+            this.load(this.snapshot);
-+        }
-+        // Paper end
-     }
- 
-+    public final boolean snapshotDisabled; // Paper
-+    public static boolean DISABLE_SNAPSHOT = false; // Paper
-+
-     public CraftBlockEntityState(Material material, T tileEntity) {
-         super(material);
- 
-         this.tileEntityClass = (Class<T>) tileEntity.getClass();
-         this.tileEntity = tileEntity;
--
-+        // Paper start
-+        this.snapshotDisabled = DISABLE_SNAPSHOT;
-+        if (DISABLE_SNAPSHOT) {
-+            this.snapshot = this.tileEntity;
-+        } else {
-+            this.snapshot = this.createSnapshot(this.tileEntity);
-+        }
-         // copy tile entity data:
--        this.snapshot = this.createSnapshot(tileEntity);
--        this.load(snapshot);
-+        if(this.snapshot != null) {
-+            this.load(this.snapshot);
-+        }
-+        // Paper end
-     }
- 
-     private T createSnapshot(T tileEntity) {
-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 final class CraftPersistentDataContainer implements PersistentDataContain
-     public Map<String, Object> serialize() {
-         return (Map<String, Object>) CraftNBTTagConfigSerializer.serialize(toTagCompound());
-     }
-+
-+    // Paper start
-+    public void clear() {
-+        this.customDataTags.clear();
-+    }
-+    // Paper end
- }

Spigot-Server-Patches/Ability-to-apply-mending-to-XP-API.patch

@@ -1,104 +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.
-
-diff --git a/src/main/java/net/minecraft/world/entity/EntityExperienceOrb.java b/src/main/java/net/minecraft/world/entity/EntityExperienceOrb.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/EntityExperienceOrb.java
-+++ b/src/main/java/net/minecraft/world/entity/EntityExperienceOrb.java
-@@ -0,0 +0,0 @@ public class EntityExperienceOrb extends Entity {
-         }
-     }
- 
-+    public final int durToXp(int i) { return b(i); } // Paper OBFHELPER
-     private int b(int i) {
-         return i / 2;
-     }
- 
-+    public final int xpToDur(int i) { return c(i); } // Paper OBFHELPER
-     private int c(int i) {
-         return i * 2;
-     }
-diff --git a/src/main/java/net/minecraft/world/item/enchantment/EnchantmentManager.java b/src/main/java/net/minecraft/world/item/enchantment/EnchantmentManager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/item/enchantment/EnchantmentManager.java
-+++ b/src/main/java/net/minecraft/world/item/enchantment/EnchantmentManager.java
-@@ -0,0 +0,0 @@ public class EnchantmentManager {
-         return getEnchantmentLevel(Enchantments.CHANNELING, itemstack) > 0;
-     }
- 
--    @Nullable
--    public static Entry<EnumItemSlot, ItemStack> b(Enchantment enchantment, EntityLiving entityliving) {
-+    public static @javax.annotation.Nonnull ItemStack getRandomEquippedItemWithEnchant(Enchantment enchantment, EntityLiving entityliving) { Entry<EnumItemSlot, ItemStack> entry = b(enchantment, entityliving); return entry != null ? entry.getValue() : ItemStack.NULL_ITEM; } // Paper - OBFHELPER
-+    @Nullable public static Entry<EnumItemSlot, ItemStack> b(Enchantment enchantment, EntityLiving entityliving) {
-         return a(enchantment, entityliving, (itemstack) -> {
-             return true;
-         });
-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 @@ import net.minecraft.server.level.WorldServer;
- import net.minecraft.server.network.PlayerConnection;
- import net.minecraft.server.players.WhiteListEntry;
- import net.minecraft.world.entity.Entity;
-+import net.minecraft.world.entity.EntityExperienceOrb;
- import net.minecraft.world.entity.EntityLiving;
-+import net.minecraft.world.entity.EntityTypes;
- import net.minecraft.world.entity.ai.attributes.AttributeMapBase;
- import net.minecraft.world.entity.ai.attributes.AttributeModifiable;
- import net.minecraft.world.entity.ai.attributes.GenericAttributes;
- import net.minecraft.world.entity.player.EntityHuman;
- import net.minecraft.world.inventory.Container;
- import net.minecraft.world.item.EnumColor;
-+import net.minecraft.world.item.enchantment.EnchantmentManager;
-+import net.minecraft.world.item.enchantment.Enchantments;
- import net.minecraft.world.level.EnumGamemode;
- import net.minecraft.world.level.block.entity.TileEntitySign;
- import net.minecraft.world.level.saveddata.maps.MapIcon;
-@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-         return GameMode.getByValue(getHandle().playerInteractManager.getGameMode().getId());
-     }
- 
-+    // Paper start
-     @Override
--    public void giveExp(int exp) {
-+    public int applyMending(int amount) {
-+        EntityPlayer handle = getHandle();
-+        // Logic copied from EntityExperienceOrb and remapped to unobfuscated methods/properties
-+        net.minecraft.world.item.ItemStack itemstack = EnchantmentManager.getRandomEquippedItemWithEnchant(Enchantments.MENDING, handle);
-+        if (!itemstack.isEmpty() && itemstack.getItem().usesDurability()) {
-+
-+            EntityExperienceOrb orb = EntityTypes.EXPERIENCE_ORB.create(handle.world);
-+            orb.value = amount;
-+            orb.spawnReason = org.bukkit.entity.ExperienceOrb.SpawnReason.CUSTOM;
-+            orb.setPositionRaw(handle.locX(), handle.locY(), handle.locZ());
-+
-+            int i = Math.min(orb.xpToDur(amount), itemstack.getDamage());
-+            org.bukkit.event.player.PlayerItemMendEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerItemMendEvent(handle, orb, itemstack, i);
-+            i = event.getRepairAmount();
-+            orb.dead = true;
-+            if (!event.isCancelled()) {
-+                amount -= orb.durToXp(i);
-+                itemstack.setDamage(itemstack.getDamage() - i);
-+            }
-+        }
-+        return amount;
-+    }
-+
-+    @Override
-+    public void giveExp(int exp, boolean applyMending) {
-+        if (applyMending) {
-+            exp = this.applyMending(exp);
-+        }
-+        // Paper end
-         getHandle().giveExp(exp);
-     }
- 

Spigot-Server-Patches/Ability-to-change-PlayerProfile-in-AsyncPreLoginEven.patch

@@ -1,45 +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] Ability to change PlayerProfile in AsyncPreLoginEvent
-
-This will allow you to change the players name or skin on login.
-
-diff --git a/src/main/java/net/minecraft/server/network/LoginListener.java b/src/main/java/net/minecraft/server/network/LoginListener.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/LoginListener.java
-+++ b/src/main/java/net/minecraft/server/network/LoginListener.java
-@@ -0,0 +0,0 @@
- package net.minecraft.server.network;
- 
-+import com.destroystokyo.paper.profile.CraftPlayerProfile;
-+import com.destroystokyo.paper.profile.PlayerProfile;
- import com.mojang.authlib.GameProfile;
- import com.mojang.authlib.exceptions.AuthenticationUnavailableException;
- import java.math.BigInteger;
-@@ -0,0 +0,0 @@ import org.apache.logging.log4j.Logger;
- // CraftBukkit start
- import net.minecraft.network.chat.ChatComponentText;
- import io.papermc.paper.adventure.PaperAdventure; // Paper
-+import org.bukkit.Bukkit;
- import org.bukkit.craftbukkit.util.Waitable;
- import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
- import org.bukkit.event.player.PlayerPreLoginEvent;
-@@ -0,0 +0,0 @@ public class LoginListener implements PacketLoginInListener {
-                         java.util.UUID uniqueId = i.getId();
-                         final org.bukkit.craftbukkit.CraftServer server = LoginListener.this.server.server;
- 
--                        AsyncPlayerPreLoginEvent asyncEvent = new AsyncPlayerPreLoginEvent(playerName, address, uniqueId);
-+                            // Paper start
-+                            PlayerProfile profile = Bukkit.createProfile(uniqueId, playerName);
-+                            AsyncPlayerPreLoginEvent asyncEvent = new AsyncPlayerPreLoginEvent(playerName, address, uniqueId, profile);
-                         server.getPluginManager().callEvent(asyncEvent);
-+                            profile = asyncEvent.getPlayerProfile();
-+                            profile.complete();
-+                            i = CraftPlayerProfile.asAuthlibCopy(profile);
-+                            playerName = i.getName();
-+                            uniqueId = i.getId();
-+                            // Paper end
- 
-                         if (PlayerPreLoginEvent.getHandlerList().getRegisteredListeners().length != 0) {
-                             final PlayerPreLoginEvent event = new PlayerPreLoginEvent(playerName, address, uniqueId);

Spigot-Server-Patches/Ability-to-get-Tile-Entities-from-a-chunk-without-sn.patch

@@ -1,73 +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 Tile 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 @@ package org.bukkit.craftbukkit;
- import com.google.common.base.Preconditions;
- import com.google.common.base.Predicates;
- import java.lang.ref.WeakReference;
-+import java.util.ArrayList;
- import java.util.Arrays;
- import java.util.Collection;
-+import java.util.List;
- import java.util.function.Predicate;
- import net.minecraft.core.BlockPosition;
- import net.minecraft.core.IRegistry;
-@@ -0,0 +0,0 @@ public class CraftChunk implements Chunk {
- 
-     @Override
-     public BlockState[] getTileEntities() {
-+        // Paper start
-+        return getTileEntities(true);
-+    }
-+
-+    @Override
-+    public BlockState[] getTileEntities(boolean useSnapshot) {
-         if (!isLoaded()) {
-             getWorld().getChunkAt(x, z); // Transient load for this tick
-         }
-+        // Paper end
-         int index = 0;
-         net.minecraft.world.level.chunk.Chunk chunk = getHandle();
- 
-@@ -0,0 +0,0 @@ public class CraftChunk implements Chunk {
-             }
- 
-             BlockPosition position = (BlockPosition) obj;
--            entities[index++] = worldServer.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ()).getState();
-+            entities[index++] = worldServer.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ()).getState(useSnapshot); // Paper
-+        }
-+
-+        return entities;
-+    }
-+
-+    // Paper start
-+    @Override
-+    public Collection<BlockState> getTileEntities(Predicate<Block> blockPredicate, boolean useSnapshot) {
-+        Preconditions.checkNotNull(blockPredicate, "blockPredicate");
-+        if (!isLoaded()) {
-+            getWorld().getChunkAt(x, z); // Transient load for this tick
-+        }
-+        net.minecraft.world.level.chunk.Chunk chunk = getHandle();
-+
-+        List<BlockState> entities = new ArrayList<>();
-+
-+        for (BlockPosition position : chunk.tileEntities.keySet()) {
-+            Block block = worldServer.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ());
-+            if (blockPredicate.test(block)) {
-+                entities.add(block.getState(useSnapshot));
-+            }
-         }
- 
-         return entities;
-     }
-+    // Paper end
- 
-     @Override
-     public boolean isLoaded() {

Spigot-Server-Patches/Add-API-for-quit-reason.patch

@@ -1,63 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Mariell Hoversholm <proximyst@proximyst.com>
-Date: Sat, 14 Nov 2020 16:19:52 +0100
-Subject: [PATCH] Add API for quit reason
-
-
-diff --git a/src/main/java/net/minecraft/network/NetworkManager.java b/src/main/java/net/minecraft/network/NetworkManager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/NetworkManager.java
-+++ b/src/main/java/net/minecraft/network/NetworkManager.java
-@@ -0,0 +0,0 @@ public class NetworkManager extends SimpleChannelInboundHandler<Packet<?>> {
- 
-             this.u = true;
-             if (this.channel.isOpen()) {
-+                EntityPlayer player = this.getPlayer(); // Paper
-                 if (throwable instanceof TimeoutException) {
-                     NetworkManager.LOGGER.debug("Timeout", throwable);
-+                    if (player != null) player.quitReason = org.bukkit.event.player.PlayerQuitEvent.QuitReason.TIMED_OUT; // Paper
-                     this.close(new ChatMessage("disconnect.timeout"));
-                 } else {
-                     ChatMessage chatmessage = new ChatMessage("disconnect.genericReason", new Object[]{"Internal Exception: " + throwable});
- 
-+                    if (player != null) player.quitReason = org.bukkit.event.player.PlayerQuitEvent.QuitReason.ERRONEOUS_STATE; // Paper
-                     if (flag) {
-                         NetworkManager.LOGGER.debug("Failed to sent packet", throwable);
-                         this.sendPacket(new PacketPlayOutKickDisconnect(chatmessage), (future) -> {
-diff --git a/src/main/java/net/minecraft/server/level/EntityPlayer.java b/src/main/java/net/minecraft/server/level/EntityPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/EntityPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/EntityPlayer.java
-@@ -0,0 +0,0 @@ public class EntityPlayer extends EntityHuman implements ICrafting {
-     double lastEntitySpawnRadiusSquared; // Paper - optimise isOutsideRange, this field is in blocks
- 
-     boolean needsChunkCenterUpdate; // Paper - no-tick view distance
-+    public org.bukkit.event.player.PlayerQuitEvent.QuitReason quitReason = null; // Paper - there are a lot of changes to do if we change all methods leading to the event
- 
-     public EntityPlayer(MinecraftServer minecraftserver, WorldServer worldserver, GameProfile gameprofile, PlayerInteractManager playerinteractmanager) {
-         super(worldserver, worldserver.getSpawn(), worldserver.v(), gameprofile);
-diff --git a/src/main/java/net/minecraft/server/network/PlayerConnection.java b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/PlayerConnection.java
-+++ b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-         final IChatBaseComponent ichatbasecomponent = PaperAdventure.asVanilla(event.reason()); // Paper - Adventure
-         // CraftBukkit end
- 
-+        this.player.quitReason = org.bukkit.event.player.PlayerQuitEvent.QuitReason.KICKED; // Paper
-         this.networkManager.sendPacket(new PacketPlayOutKickDisconnect(ichatbasecomponent), (future) -> {
-             this.networkManager.close(ichatbasecomponent);
-         });
-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 {
-             entityplayer.closeInventory(org.bukkit.event.inventory.InventoryCloseEvent.Reason.DISCONNECT); // Paper
-         }
- 
--        PlayerQuitEvent playerQuitEvent = new PlayerQuitEvent(cserver.getPlayer(entityplayer), net.kyori.adventure.text.Component.translatable("multiplayer.player.left", net.kyori.adventure.text.format.NamedTextColor.YELLOW, com.destroystokyo.paper.PaperConfig.useDisplayNameInQuit ? entityplayer.getBukkitEntity().displayName() : net.kyori.adventure.text.Component.text(entityplayer.getName())));
-+        PlayerQuitEvent playerQuitEvent = new PlayerQuitEvent(cserver.getPlayer(entityplayer), net.kyori.adventure.text.Component.translatable("multiplayer.player.left", net.kyori.adventure.text.format.NamedTextColor.YELLOW, com.destroystokyo.paper.PaperConfig.useDisplayNameInQuit ? entityplayer.getBukkitEntity().displayName() : net.kyori.adventure.text.Component.text(entityplayer.getName())), entityplayer.quitReason); // Paper - quit reason
-         if (entityplayer.didPlayerJoinEvent) cserver.getPluginManager().callEvent(playerQuitEvent); // Paper - if we disconnected before join ever fired, don't fire quit
-         entityplayer.getBukkitEntity().disconnect(playerQuitEvent.getQuitMessage());
- 

Spigot-Server-Patches/Add-API-methods-to-control-if-armour-stands-can-move.patch

@@ -1,81 +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 armour stands can move
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/EntityInsentient.java b/src/main/java/net/minecraft/world/entity/EntityInsentient.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/EntityInsentient.java
-+++ b/src/main/java/net/minecraft/world/entity/EntityInsentient.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.entity.ai.control.ControllerLook;
- import net.minecraft.world.entity.ai.control.ControllerMove;
- import net.minecraft.world.entity.ai.control.EntityAIBodyControl;
- import net.minecraft.world.entity.ai.goal.PathfinderGoal;
-+import net.minecraft.world.entity.ai.goal.PathfinderGoalFloat;
- import net.minecraft.world.entity.ai.goal.PathfinderGoalSelector;
- import net.minecraft.world.entity.ai.navigation.Navigation;
- import net.minecraft.world.entity.ai.navigation.NavigationAbstract;
-@@ -0,0 +0,0 @@ import net.minecraft.world.entity.ai.sensing.EntitySenses;
- import net.minecraft.world.entity.decoration.EntityHanging;
- import net.minecraft.world.entity.decoration.EntityLeash;
- import net.minecraft.world.entity.item.EntityItem;
-+import net.minecraft.world.entity.monster.EntityBlaze;
-+import net.minecraft.world.entity.monster.EntityEnderman;
- import net.minecraft.world.entity.monster.IMonster;
- import net.minecraft.world.entity.player.EntityHuman;
- import net.minecraft.world.entity.vehicle.EntityBoat;
-diff --git a/src/main/java/net/minecraft/world/entity/decoration/EntityArmorStand.java b/src/main/java/net/minecraft/world/entity/decoration/EntityArmorStand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/decoration/EntityArmorStand.java
-+++ b/src/main/java/net/minecraft/world/entity/decoration/EntityArmorStand.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.entity.EntitySize;
- import net.minecraft.world.entity.EntityTypes;
- import net.minecraft.world.entity.EnumItemSlot;
- import net.minecraft.world.entity.EnumMainHand;
-+import net.minecraft.world.entity.EnumMoveType;
- import net.minecraft.world.entity.player.EntityHuman;
- import net.minecraft.world.entity.projectile.EntityArrow;
- import net.minecraft.world.entity.vehicle.EntityMinecartAbstract;
-@@ -0,0 +0,0 @@ public class EntityArmorStand extends EntityLiving {
-     public Vector3f rightArmPose;
-     public Vector3f leftLegPose;
-     public Vector3f rightLegPose;
-+    public boolean canMove = true; // Paper
- 
-     public EntityArmorStand(EntityTypes<? extends EntityArmorStand> entitytypes, World world) {
-         super(entitytypes, world);
-@@ -0,0 +0,0 @@ public class EntityArmorStand extends EntityLiving {
-     private EntitySize s(boolean flag) {
-         return flag ? EntityArmorStand.bp : (this.isBaby() ? EntityArmorStand.bq : this.getEntityType().l());
-     }
-+
-+    // Paper start
-+    @Override
-+    public void move(EnumMoveType moveType, Vec3D vec3d) {
-+        if (this.canMove) {
-+            super.move(moveType, vec3d);
-+        }
-+    }
-+    // 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 (getHandle().disabledSlots & (1 << CraftEquipmentSlot.getNMS(equipmentSlot).getSlotFlag() + lockType.ordinal() * 8)) != 0;
-     }
-+    // Paper start
-+    @Override
-+    public boolean canMove() {
-+        return getHandle().canMove;
-+    }
-+
-+    @Override
-+    public void setCanMove(boolean move) {
-+        getHandle().canMove = move;
-+    }
-+    // Paper end
- }

Spigot-Server-Patches/Add-APIs-to-replace-OfflinePlayer-getLastPlayed.patch

@@ -1,164 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Zach Brown <1254957+zachbr@users.noreply.github.com>
-Date: Wed, 2 Jan 2019 00:35:43 -0600
-Subject: [PATCH] Add APIs to replace OfflinePlayer#getLastPlayed
-
-Currently OfflinePlayer#getLastPlayed could more accurately be described
-as "OfflinePlayer#getLastTimeTheirDataWasSaved".
-
-The API doc says it should return the last time the server "witnessed"
-the player, whilst also saying it should return the last time they
-logged in. The current implementation does neither.
-
-Given this interesting contradiction in the API documentation and the
-current defacto implementation, I've elected to deprecate (with no
-intent to remove) and replace it with two new methods, clearly named and
-documented as to their purpose.
-
-diff --git a/src/main/java/net/minecraft/server/level/EntityPlayer.java b/src/main/java/net/minecraft/server/level/EntityPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/EntityPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/EntityPlayer.java
-@@ -0,0 +0,0 @@ public class EntityPlayer extends EntityHuman implements ICrafting {
-     public int ping;
-     public boolean viewingCredits;
-     private int containerUpdateDelay; // Paper
-+    public long loginTime; // Paper
-     // Paper start - cancellable death event
-     public boolean queueHealthUpdatePacket = false;
-     public net.minecraft.network.protocol.game.PacketPlayOutUpdateHealth queuedHealthUpdatePacket;
-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 a(NetworkManager networkmanager, EntityPlayer entityplayer) {
-+        entityplayer.loginTime = System.currentTimeMillis(); // Paper
-         GameProfile gameprofile = entityplayer.getProfile();
-         UserCache usercache = this.server.getUserCache();
-         GameProfile gameprofile1 = usercache.getProfile(gameprofile.getId());
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java b/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
-@@ -0,0 +0,0 @@ public class CraftOfflinePlayer implements OfflinePlayer, ConfigurationSerializa
-         return getData() != null;
-     }
- 
-+    // Paper start
-+    @Override
-+    public long getLastLogin() {
-+        Player player = getPlayer();
-+        if (player != null) return player.getLastLogin();
-+
-+        NBTTagCompound data = getPaperData();
-+
-+        if (data != null) {
-+            if (data.hasKey("LastLogin")) {
-+                return data.getLong("LastLogin");
-+            } else {
-+                // if the player file cannot provide accurate data, this is probably the closest we can approximate
-+                File file = getDataFile();
-+                return file.lastModified();
-+            }
-+        } else {
-+            return 0;
-+        }
-+    }
-+
-+    @Override
-+    public long getLastSeen() {
-+        Player player = getPlayer();
-+        if (player != null) return player.getLastSeen();
-+
-+        NBTTagCompound data = getPaperData();
-+
-+        if (data != null) {
-+            if (data.hasKey("LastSeen")) {
-+                return data.getLong("LastSeen");
-+            } else {
-+                // if the player file cannot provide accurate data, this is probably the closest we can approximate
-+                File file = getDataFile();
-+                return file.lastModified();
-+            }
-+        } else {
-+            return 0;
-+        }
-+    }
-+
-+    private NBTTagCompound getPaperData() {
-+        NBTTagCompound result = getData();
-+
-+        if (result != null) {
-+            if (!result.hasKey("Paper")) {
-+                result.set("Paper", new NBTTagCompound());
-+            }
-+            result = result.getCompound("Paper");
-+        }
-+
-+        return result;
-+    }
-+    // Paper end
-+
-     @Override
-     public Location getBedSpawnLocation() {
-         NBTTagCompound data = getData();
-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 org.bukkit.event.player.PlayerResourcePackStatusEvent.Status resourcePackStatus;
-     private String resourcePackHash;
-     private static final boolean DISABLE_CHANNEL_LIMIT = System.getProperty("paper.disableChannelLimit") != null; // Paper - add a flag to disable the channel limit
-+    private long lastSaveTime;
-     // Paper end
- 
-     public CraftPlayer(CraftServer server, EntityPlayer entity) {
-@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-         this.firstPlayed = firstPlayed;
-     }
- 
-+    // Paper start
-+    @Override
-+    public long getLastLogin() {
-+        return getHandle().loginTime;
-+    }
-+
-+    @Override
-+    public long getLastSeen() {
-+        return isOnline() ? System.currentTimeMillis() : this.lastSaveTime;
-+    }
-+    // Paper end
-+
-     public void readExtraData(NBTTagCompound nbttagcompound) {
-         hasPlayedBefore = true;
-         if (nbttagcompound.hasKey("bukkit")) {
-@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-     }
- 
-     public void setExtraData(NBTTagCompound nbttagcompound) {
-+        this.lastSaveTime = System.currentTimeMillis(); // Paper
-+
-         if (!nbttagcompound.hasKey("bukkit")) {
-             nbttagcompound.set("bukkit", new NBTTagCompound());
-         }
-@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-         data.setLong("firstPlayed", getFirstPlayed());
-         data.setLong("lastPlayed", System.currentTimeMillis());
-         data.setString("lastKnownName", handle.getName());
-+
-+        // Paper start - persist for use in offline save data
-+        if (!nbttagcompound.hasKey("Paper")) {
-+            nbttagcompound.set("Paper", new NBTTagCompound());
-+        }
-+
-+        NBTTagCompound paper = nbttagcompound.getCompound("Paper");
-+        paper.setLong("LastLogin", handle.loginTime);
-+        paper.setLong("LastSeen", System.currentTimeMillis());
-+        // Paper end
-     }
- 
-     @Override

Spigot-Server-Patches/Add-Adventure-message-to-PlayerAdvancementDoneEvent.patch

@@ -1,89 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Alvinn8 <42838560+Alvinn8@users.noreply.github.com>
-Date: Fri, 8 Jan 2021 20:31:13 +0100
-Subject: [PATCH] Add Adventure message to PlayerAdvancementDoneEvent
-
-
-diff --git a/src/main/java/net/minecraft/advancements/Advancement.java b/src/main/java/net/minecraft/advancements/Advancement.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/advancements/Advancement.java
-+++ b/src/main/java/net/minecraft/advancements/Advancement.java
-@@ -0,0 +0,0 @@ public class Advancement {
-         return this.parent;
-     }
- 
-+    public final @Nullable AdvancementDisplay getAdvancementDisplay() { return this.c(); } // Paper - OBFHELPER
-     @Nullable
-     public AdvancementDisplay c() {
-         return this.display;
-@@ -0,0 +0,0 @@ public class Advancement {
-         return this.requirements;
-     }
- 
-+    public final IChatBaseComponent getChatComponent() { return this.j(); } // Paper - OBFHELPER
-     public IChatBaseComponent j() {
-         return this.chatComponent;
-     }
-diff --git a/src/main/java/net/minecraft/advancements/AdvancementDisplay.java b/src/main/java/net/minecraft/advancements/AdvancementDisplay.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/advancements/AdvancementDisplay.java
-+++ b/src/main/java/net/minecraft/advancements/AdvancementDisplay.java
-@@ -0,0 +0,0 @@ public class AdvancementDisplay {
-         return this.b;
-     }
- 
-+    public final AdvancementFrameType getFrameType() { return this.e(); } // Paper - OBFHELPER
-     public AdvancementFrameType e() {
-         return this.e;
-     }
- 
-+    public final boolean shouldAnnounceToChat() { return this.i(); } // Paper - OBFHELPER
-     public boolean i() {
-         return this.g;
-     }
-diff --git a/src/main/java/net/minecraft/advancements/AdvancementFrameType.java b/src/main/java/net/minecraft/advancements/AdvancementFrameType.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/advancements/AdvancementFrameType.java
-+++ b/src/main/java/net/minecraft/advancements/AdvancementFrameType.java
-@@ -0,0 +0,0 @@ public enum AdvancementFrameType {
-         this.g = new ChatMessage("advancements.toast." + s);
-     }
- 
-+    public final String getId() { return this.a(); } // Paper - OBFHELPER
-     public String a() {
-         return this.d;
-     }
-diff --git a/src/main/java/net/minecraft/server/AdvancementDataPlayer.java b/src/main/java/net/minecraft/server/AdvancementDataPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/AdvancementDataPlayer.java
-+++ b/src/main/java/net/minecraft/server/AdvancementDataPlayer.java
-@@ -0,0 +0,0 @@ import net.minecraft.util.datafix.DataFixTypes;
- import net.minecraft.world.level.GameRules;
- import org.apache.logging.log4j.LogManager;
- import org.apache.logging.log4j.Logger;
-+import io.papermc.paper.adventure.PaperAdventure; // Paper
- 
- public class AdvancementDataPlayer {
- 
-@@ -0,0 +0,0 @@ public class AdvancementDataPlayer {
-             this.j.add(advancement);
-             flag = true;
-             if (!flag1 && advancementprogress.isDone()) {
--                this.player.world.getServer().getPluginManager().callEvent(new org.bukkit.event.player.PlayerAdvancementDoneEvent(this.player.getBukkitEntity(), advancement.bukkit)); // CraftBukkit
-+                // Paper start - Add Adventure message to PlayerAdvancementDoneEvent
-+                boolean announceToChat = advancement.getAdvancementDisplay() != null && advancement.getAdvancementDisplay().shouldAnnounceToChat();
-+                net.kyori.adventure.text.Component message = announceToChat ? PaperAdventure.asAdventure(new ChatMessage("chat.type.advancement." + advancement.getAdvancementDisplay().getFrameType().getId(), this.player.getScoreboardDisplayName(), advancement.getChatComponent())) : null;
-+                org.bukkit.event.player.PlayerAdvancementDoneEvent event = new org.bukkit.event.player.PlayerAdvancementDoneEvent(this.player.getBukkitEntity(), advancement.bukkit, message);
-+                this.player.world.getServer().getPluginManager().callEvent(event);
-+                message = event.message();
-+                // Paper end
-                 advancement.d().a(this.player);
--                if (advancement.c() != null && advancement.c().i() && this.player.world.getGameRules().getBoolean(GameRules.ANNOUNCE_ADVANCEMENTS)) {
--                    this.e.sendMessage(new ChatMessage("chat.type.advancement." + advancement.c().e().a(), new Object[]{this.player.getScoreboardDisplayName(), advancement.j()}), ChatMessageType.SYSTEM, SystemUtils.b);
-+                // Paper start - Add Adventure message to PlayerAdvancementDoneEvent
-+                if (message != null && this.player.world.getGameRules().getBoolean(GameRules.ANNOUNCE_ADVANCEMENTS)) {
-+                    this.e.sendMessage(PaperAdventure.asVanilla(message), ChatMessageType.SYSTEM, SystemUtils.getNullUUID());
-+                    // Paper end
-                 }
-             }
-         }

Spigot-Server-Patches/Add-ArmorStand-Item-Meta.patch

@@ -1,296 +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/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.configuration.serialization.DelegateDeserialization;
- import org.bukkit.craftbukkit.inventory.CraftMetaItem.ItemMetaKey;
- 
- @DelegateDeserialization(CraftMetaItem.SerializableMeta.class)
--public class CraftMetaArmorStand extends CraftMetaItem {
-+public class CraftMetaArmorStand extends CraftMetaItem implements com.destroystokyo.paper.inventory.meta.ArmorStandMeta { // Paper
- 
-     static final ItemMetaKey ENTITY_TAG = new ItemMetaKey("EntityTag", "entity-tag");
-+    // Paper start
-+    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");
-+
-+    private boolean invisible;
-+    private boolean noBasePlate;
-+    private boolean showArms;
-+    private boolean small;
-+    private boolean marker;
-+    // Paper end
-     NBTTagCompound entityTag;
- 
-     CraftMetaArmorStand(CraftMetaItem meta) {
-@@ -0,0 +0,0 @@ public class CraftMetaArmorStand extends CraftMetaItem {
-         }
- 
-         CraftMetaArmorStand armorStand = (CraftMetaArmorStand) meta;
-+        // Paper start
-+        this.invisible = armorStand.invisible;
-+        this.noBasePlate = armorStand.noBasePlate;
-+        this.showArms = armorStand.showArms;
-+        this.small = armorStand.small;
-+        this.marker = armorStand.marker;
-+        // Paper end
-         this.entityTag = armorStand.entityTag;
-     }
- 
-@@ -0,0 +0,0 @@ public class CraftMetaArmorStand extends CraftMetaItem {
- 
-         if (tag.hasKey(ENTITY_TAG.NBT)) {
-             entityTag = tag.getCompound(ENTITY_TAG.NBT);
-+
-+            // Paper start
-+            if (entityTag.hasKey(INVISIBLE.NBT)) {
-+                invisible = entityTag.getBoolean(INVISIBLE.NBT);
-+            }
-+
-+            if (entityTag.hasKey(NO_BASE_PLATE.NBT)) {
-+                noBasePlate = entityTag.getBoolean(NO_BASE_PLATE.NBT);
-+            }
-+
-+            if (entityTag.hasKey(SHOW_ARMS.NBT)) {
-+                showArms = entityTag.getBoolean(SHOW_ARMS.NBT);
-+            }
-+
-+            if (entityTag.hasKey(SMALL.NBT)) {
-+                small = entityTag.getBoolean(SMALL.NBT);
-+            }
-+
-+            if (entityTag.hasKey(MARKER.NBT)) {
-+                marker = entityTag.getBoolean(MARKER.NBT);
-+            }
-+            // Paper end
-         }
-     }
- 
-     CraftMetaArmorStand(Map<String, Object> map) {
-         super(map);
-+
-+        // Paper start
-+        boolean invis = SerializableMeta.getBoolean(map, INVISIBLE.BUKKIT);
-+        boolean noBase = SerializableMeta.getBoolean(map, NO_BASE_PLATE.BUKKIT);
-+        boolean showArms = SerializableMeta.getBoolean(map, SHOW_ARMS.BUKKIT);
-+        boolean small = SerializableMeta.getBoolean(map, SMALL.BUKKIT);
-+        boolean marker = SerializableMeta.getBoolean(map, MARKER.BUKKIT);
-+
-+        this.invisible = invis;
-+        this.noBasePlate = noBase;
-+        this.showArms = showArms;
-+        this.small = small;
-+        this.marker = marker;
-+        // Paper end
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class CraftMetaArmorStand extends CraftMetaItem {
-     void applyToItem(NBTTagCompound tag) {
-         super.applyToItem(tag);
- 
-+        // Paper start
-+        if (!isArmorStandEmpty() && entityTag == null) {
-+            entityTag = new NBTTagCompound();
-+        }
-+
-+        if (isInvisible()) {
-+            entityTag.setBoolean(INVISIBLE.NBT, invisible);
-+        }
-+
-+        if (hasNoBasePlate()) {
-+            entityTag.setBoolean(NO_BASE_PLATE.NBT, noBasePlate);
-+        }
-+
-+        if (shouldShowArms()) {
-+            entityTag.setBoolean(SHOW_ARMS.NBT, showArms);
-+        }
-+
-+        if (isSmall()) {
-+            entityTag.setBoolean(SMALL.NBT, small);
-+        }
-+
-+        if (isMarker()) {
-+            entityTag.setBoolean(MARKER.NBT, marker);
-+        }
-+        // Paper end
-+
-         if (entityTag != null) {
-             tag.set(ENTITY_TAG.NBT, entityTag);
-         }
-@@ -0,0 +0,0 @@ public class CraftMetaArmorStand extends CraftMetaItem {
-     }
- 
-     boolean isArmorStandEmpty() {
--        return !(entityTag != null);
-+        return !(isInvisible() || hasNoBasePlate() || shouldShowArms() || isSmall() || isMarker() || entityTag != null);
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class CraftMetaArmorStand extends CraftMetaItem {
-         if (meta instanceof CraftMetaArmorStand) {
-             CraftMetaArmorStand that = (CraftMetaArmorStand) meta;
- 
--            return entityTag != null ? that.entityTag != null && this.entityTag.equals(that.entityTag) : entityTag == null;
-+            // Paper start
-+            return invisible == that.invisible &&
-+                noBasePlate == that.noBasePlate &&
-+                showArms == that.showArms &&
-+                small == that.small &&
-+                marker == that.marker;
-+            // Paper end
-         }
-         return true;
-     }
-@@ -0,0 +0,0 @@ public class CraftMetaArmorStand extends CraftMetaItem {
-         final int original;
-         int hash = original = super.applyHash();
- 
--        if (entityTag != null) {
--            hash = 73 * hash + entityTag.hashCode();
--        }
-+        // Paper start
-+        hash += entityTag != null ? 73 * hash + entityTag.hashCode() : 0;
-+        hash += isInvisible() ? 61 * hash + 1231 : 0;
-+        hash += hasNoBasePlate() ? 61 * hash + 1231 : 0;
-+        hash += shouldShowArms() ? 61 * hash + 1231 : 0;
-+        hash += isSmall() ? 61 * hash + 1231 : 0;
-+        hash += isMarker() ? 61 * hash + 1231 : 0;
-+        // Paper end
- 
-         return original != hash ? CraftMetaArmorStand.class.hashCode() ^ hash : hash;
-     }
-@@ -0,0 +0,0 @@ public class CraftMetaArmorStand extends CraftMetaItem {
-     Builder<String, Object> serialize(Builder<String, Object> builder) {
-         super.serialize(builder);
- 
-+        // Paper start
-+        if (isInvisible()) {
-+            builder.put(INVISIBLE.BUKKIT, invisible);
-+        }
-+
-+        if (hasNoBasePlate()) {
-+            builder.put(NO_BASE_PLATE.BUKKIT, noBasePlate);
-+        }
-+
-+        if (shouldShowArms()) {
-+            builder.put(SHOW_ARMS.BUKKIT, showArms);
-+        }
-+
-+        if (isSmall()) {
-+            builder.put(SMALL.BUKKIT, small);
-+        }
-+
-+        if (isMarker()) {
-+            builder.put(MARKER.BUKKIT, marker);
-+        }
-+        // Paper end
-+
-         return builder;
-     }
- 
-@@ -0,0 +0,0 @@ public class CraftMetaArmorStand extends CraftMetaItem {
- 
-         return clone;
-     }
-+
-+    // Paper start
-+    @Override
-+    public boolean isInvisible() {
-+        return invisible;
-+    }
-+
-+    @Override
-+    public boolean hasNoBasePlate() {
-+        return noBasePlate;
-+    }
-+
-+    @Override
-+    public boolean shouldShowArms() {
-+        return showArms;
-+    }
-+
-+    @Override
-+    public boolean isSmall() {
-+        return small;
-+    }
-+
-+    @Override
-+    public boolean isMarker() {
-+        return marker;
-+    }
-+
-+    @Override
-+    public void setInvisible(boolean invisible) {
-+        this.invisible = invisible;
-+    }
-+
-+    @Override
-+    public void setNoBasePlate(boolean noBasePlate) {
-+        this.noBasePlate = noBasePlate;
-+    }
-+
-+    @Override
-+    public void setShowArms(boolean showArms) {
-+        this.showArms = showArms;
-+    }
-+
-+    @Override
-+    public void setSmall(boolean small) {
-+        this.small = small;
-+    }
-+
-+    @Override
-+    public void setMarker(boolean marker) {
-+        this.marker = marker;
-+    }
-+    // Paper end
- }
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
-@@ -0,0 +0,0 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
-                         CraftMetaCrossbow.CHARGED.NBT,
-                         CraftMetaCrossbow.CHARGED_PROJECTILES.NBT,
-                         CraftMetaSuspiciousStew.EFFECTS.NBT,
-+                        // Paper start
-+                        CraftMetaArmorStand.ENTITY_TAG.NBT,
-+                        CraftMetaArmorStand.INVISIBLE.NBT,
-+                        CraftMetaArmorStand.NO_BASE_PLATE.NBT,
-+                        CraftMetaArmorStand.SHOW_ARMS.NBT,
-+                        CraftMetaArmorStand.SMALL.NBT,
-+                        CraftMetaArmorStand.MARKER.NBT,
-+                        // Paper end
-                         CraftMetaCompass.LODESTONE_DIMENSION.NBT,
-                         CraftMetaCompass.LODESTONE_POS.NBT,
-                         CraftMetaCompass.LODESTONE_TRACKED.NBT
-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 extends AbstractTestingBase {
-                     final CraftMetaArmorStand meta = (CraftMetaArmorStand) cleanStack.getItemMeta();
-                     meta.entityTag = new NBTTagCompound();
-                     meta.entityTag.setBoolean("Small", true);
-+                    meta.setInvisible(true); // Paper
-                     cleanStack.setItemMeta(meta);
-                     return cleanStack;
-                 }

Spigot-Server-Patches/Add-BeaconEffectEvent.patch

@@ -1,67 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Byteflux <byte@byteflux.net>
-Date: Wed, 2 Mar 2016 23:30:53 -0600
-Subject: [PATCH] Add BeaconEffectEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/TileEntityBeacon.java b/src/main/java/net/minecraft/world/level/block/entity/TileEntityBeacon.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/TileEntityBeacon.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/TileEntityBeacon.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.phys.AxisAlignedBB;
- import org.bukkit.craftbukkit.potion.CraftPotionUtil;
- import org.bukkit.potion.PotionEffect;
- // CraftBukkit end
-+// Paper start
-+import org.bukkit.craftbukkit.event.CraftEventFactory;
-+import org.bukkit.entity.Player;
-+import com.destroystokyo.paper.event.block.BeaconEffectEvent;
-+// Paper end
- 
- public class TileEntityBeacon extends TileEntity implements ITileInventory, ITickable {
- 
-@@ -0,0 +0,0 @@ public class TileEntityBeacon extends TileEntity implements ITileInventory, ITic
-     }
- 
-     private void applyEffect(List list, MobEffectList effects, int i, int b0) {
-+        // Paper - BeaconEffectEvent
-+        applyEffect(list, effects, i, b0, true);
-+    }
-+
-+    private void applyEffect(List list, MobEffectList effects, int i, int b0, boolean isPrimary) {
-+        // Paper - BeaconEffectEvent
-         {
-             Iterator iterator = list.iterator();
- 
-             EntityHuman entityhuman;
- 
-+            // Paper start - BeaconEffectEvent
-+            org.bukkit.block.Block block = world.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ());
-+            PotionEffect effect = CraftPotionUtil.toBukkit(new MobEffect(effects, i, b0, true, true));
-+            // Paper end
-+
-             while (iterator.hasNext()) {
-                 entityhuman = (EntityHuman) iterator.next();
--                entityhuman.addEffect(new MobEffect(effects, i, b0, true, true), org.bukkit.event.entity.EntityPotionEffectEvent.Cause.BEACON);
-+
-+                // Paper start - BeaconEffectEvent
-+                BeaconEffectEvent event = new BeaconEffectEvent(block, effect, (Player) entityhuman.getBukkitEntity(), isPrimary);
-+                if (CraftEventFactory.callEvent(event).isCancelled()) continue;
-+                entityhuman.addEffect(new MobEffect(CraftPotionUtil.fromBukkit(event.getEffect())), org.bukkit.event.entity.EntityPotionEffectEvent.Cause.BEACON);
-+                // Paper end
-             }
-         }
-     }
-@@ -0,0 +0,0 @@ public class TileEntityBeacon extends TileEntity implements ITileInventory, ITic
-             int i = getLevel();
-             List list = getHumansInRange();
- 
--            applyEffect(list, this.primaryEffect, i, b0);
-+            applyEffect(list, this.primaryEffect, i, b0, true); // Paper - BeaconEffectEvent
- 
-             if (hasSecondaryEffect()) {
--                applyEffect(list, this.secondaryEffect, i, 0);
-+                applyEffect(list, this.secondaryEffect, i, 0, false); // Paper - BeaconEffectEvent
-             }
-         }
- 

Spigot-Server-Patches/Add-BellRevealRaiderEvent.patch

@@ -1,26 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
-Date: Wed, 26 May 2021 17:09:07 -0400
-Subject: [PATCH] Add BellRevealRaiderEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/TileEntityBell.java b/src/main/java/net/minecraft/world/level/block/entity/TileEntityBell.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/TileEntityBell.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/TileEntityBell.java
-@@ -0,0 +0,0 @@ import net.minecraft.core.BlockPosition;
- import net.minecraft.core.EnumDirection;
- import net.minecraft.core.IPosition;
- import net.minecraft.core.particles.Particles;
-+import net.minecraft.server.MCUtil;
- import net.minecraft.sounds.SoundCategory;
- import net.minecraft.sounds.SoundEffects;
- import net.minecraft.tags.Tag;
-@@ -0,0 +0,0 @@ public class TileEntityBell extends TileEntity implements ITickable {
-     }
- 
-     private void b(EntityLiving entityliving) {
-+        if (!new io.papermc.paper.event.block.BellRevealRaiderEvent(world.getWorld().getBlockAt(MCUtil.toLocation(world, position)), entityliving.getBukkitEntity()).callEvent()) return; // Paper - BellRevealRaiderEvent
-         entityliving.addEffect(new MobEffect(MobEffects.GLOWING, 60));
-     }
- }

Spigot-Server-Patches/Add-BellRingEvent.patch

@@ -1,53 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Eearslya Sleiarion <eearslya@gmail.com>
-Date: Sun, 23 Aug 2020 13:04:02 +0200
-Subject: [PATCH] Add BellRingEvent
-
-Add a new event, BellRingEvent, to trigger whenever a player rings a
-village bell. Passes along the bell block and the player who rang it.
-
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockBell.java b/src/main/java/net/minecraft/world/level/block/BlockBell.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockBell.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockBell.java
-@@ -0,0 +0,0 @@
- package net.minecraft.world.level.block;
- 
-+import io.papermc.paper.event.block.BellRingEvent;
-+
- import javax.annotation.Nullable;
- import net.minecraft.core.BlockPosition;
- import net.minecraft.core.EnumDirection;
-+import net.minecraft.server.MCUtil;
- import net.minecraft.sounds.SoundCategory;
- import net.minecraft.sounds.SoundEffects;
- import net.minecraft.stats.StatisticList;
-@@ -0,0 +0,0 @@ public class BlockBell extends BlockTileEntity {
-         boolean flag1 = !flag || this.a(iblockdata, enumdirection, movingobjectpositionblock.getPos().y - (double) blockposition.getY());
- 
-         if (flag1) {
--            boolean flag2 = this.a(world, blockposition, enumdirection);
-+            boolean flag2 = this.handleBellRing(world, blockposition, enumdirection, entityhuman); // Paper
- 
-             if (flag2 && entityhuman != null) {
-                 entityhuman.a(StatisticList.BELL_RING);
-@@ -0,0 +0,0 @@ public class BlockBell extends BlockTileEntity {
-     }
- 
-     public boolean a(World world, BlockPosition blockposition, @Nullable EnumDirection enumdirection) {
-+        // Paper start - add ringer param
-+        return this.handleBellRing(world, blockposition, enumdirection, null);
-+    }
-+    public boolean handleBellRing(World world, BlockPosition blockposition, @Nullable EnumDirection enumdirection, @Nullable Entity ringer) {
-+        // Paper end
-         TileEntity tileentity = world.getTileEntity(blockposition);
- 
-         if (!world.isClientSide && tileentity instanceof TileEntityBell) {
-@@ -0,0 +0,0 @@ public class BlockBell extends BlockTileEntity {
-                 enumdirection = (EnumDirection) world.getType(blockposition).get(BlockBell.a);
-             }
- 
-+            if (!new BellRingEvent(world.getWorld().getBlockAt(MCUtil.toLocation(world, blockposition)), ringer == null ? null : ringer.getBukkitEntity()).callEvent()) return false; // Paper - BellRingEvent
-             ((TileEntityBell) tileentity).a(enumdirection);
-             world.playSound((EntityHuman) null, blockposition, SoundEffects.BLOCK_BELL_USE, SoundCategory.BLOCKS, 2.0F, 1.0F);
-             return true;

Spigot-Server-Patches/Add-Block-isValidTool.patch

@@ -1,20 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Mon, 6 Jul 2020 12:44:31 -0700
-Subject: [PATCH] Add Block#isValidTool
-
-
-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 speed;
-     }
-+
-+    public boolean isValidTool(ItemStack itemStack) {
-+        return getDrops(itemStack).size() != 0;
-+    }
-     // Paper end
- }

Spigot-Server-Patches/Add-Channel-initialization-listeners.patch

@@ -1,119 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Nassim Jahnke <nassim@njahnke.dev>
-Date: Thu, 29 Apr 2021 21:19:33 +0200
-Subject: [PATCH] Add Channel initialization listeners
-
-
-diff --git a/src/main/java/io/papermc/paper/network/ChannelInitializeListener.java b/src/main/java/io/papermc/paper/network/ChannelInitializeListener.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/io/papermc/paper/network/ChannelInitializeListener.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.network;
-+
-+import io.netty.channel.Channel;
-+import org.checkerframework.checker.nullness.qual.NonNull;
-+
-+/**
-+ * Internal API to register channel initialization listeners.
-+ * <p>
-+ * This is not officially supported API and we make no guarantees to the existence or state of this interface.
-+ */
-+@FunctionalInterface
-+public interface ChannelInitializeListener {
-+
-+    void afterInitChannel(@NonNull Channel channel);
-+}
-diff --git a/src/main/java/io/papermc/paper/network/ChannelInitializeListenerHolder.java b/src/main/java/io/papermc/paper/network/ChannelInitializeListenerHolder.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/io/papermc/paper/network/ChannelInitializeListenerHolder.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.network;
-+
-+import io.netty.channel.Channel;
-+import net.kyori.adventure.key.Key;
-+import org.checkerframework.checker.nullness.qual.NonNull;
-+import org.checkerframework.checker.nullness.qual.Nullable;
-+
-+import java.util.Collections;
-+import java.util.HashMap;
-+import java.util.Map;
-+
-+/**
-+ * Internal API to register channel initialization listeners.
-+ * <p>
-+ * This is not officially supported API and we make no guarantees to the existence or state of this class.
-+ */
-+public final class ChannelInitializeListenerHolder {
-+
-+    private static final Map<Key, ChannelInitializeListener> LISTENERS = new HashMap<>();
-+    private static final Map<Key, ChannelInitializeListener> IMMUTABLE_VIEW = Collections.unmodifiableMap(LISTENERS);
-+
-+    private ChannelInitializeListenerHolder() {
-+    }
-+
-+    /**
-+     * Registers whether an initialization listener is registered under the given key.
-+     *
-+     * @param key key
-+     * @return whether an initialization listener is registered under the given key
-+     */
-+    public static boolean hasListener(@NonNull Key key) {
-+        return LISTENERS.containsKey(key);
-+    }
-+
-+    /**
-+     * Registers a channel initialization listener called after ServerConnection is initialized.
-+     *
-+     * @param key      key
-+     * @param listener initialization listeners
-+     */
-+    public static void addListener(@NonNull Key key, @NonNull ChannelInitializeListener listener) {
-+        LISTENERS.put(key, listener);
-+    }
-+
-+    /**
-+     * Removes and returns an initialization listener registered by the given key if present.
-+     *
-+     * @param key key
-+     * @return removed initialization listener if present
-+     */
-+    public static @Nullable ChannelInitializeListener removeListener(@NonNull Key key) {
-+        return LISTENERS.remove(key);
-+    }
-+
-+    /**
-+     * Returns an immutable map of registered initialization listeners.
-+     *
-+     * @return immutable map of registered initialization listeners
-+     */
-+    public static @NonNull Map<Key, ChannelInitializeListener> getListeners() {
-+        return IMMUTABLE_VIEW;
-+    }
-+
-+    /**
-+     * Calls the registered listeners with the given channel.
-+     *
-+     * @param channel channel
-+     */
-+    public static void callListeners(@NonNull Channel channel) {
-+        for (ChannelInitializeListener listener : LISTENERS.values()) {
-+            listener.afterInitChannel(channel);
-+        }
-+    }
-+}
-diff --git a/src/main/java/net/minecraft/server/network/ServerConnection.java b/src/main/java/net/minecraft/server/network/ServerConnection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerConnection.java
-+++ b/src/main/java/net/minecraft/server/network/ServerConnection.java
-@@ -0,0 +0,0 @@ public class ServerConnection {
-                     pending.add((NetworkManager) object); // Paper
-                     channel.pipeline().addLast("packet_handler", (ChannelHandler) object);
-                     ((NetworkManager) object).setPacketListener(new HandshakeListener(ServerConnection.this.e, (NetworkManager) object));
-+                    io.papermc.paper.network.ChannelInitializeListenerHolder.callListeners(channel); // Paper
-                 }
-             }).group((EventLoopGroup) lazyinitvar.a()).localAddress(inetaddress, i)).option(ChannelOption.AUTO_READ, false).bind().syncUninterruptibly()); // CraftBukkit
-         }

Spigot-Server-Patches/Add-CraftMagicNumbers.isSupportedApiVersion.patch

@@ -1,22 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BlackHole <black-hole@live.com>
-Date: Sun, 15 Dec 2019 19:12:39 +0100
-Subject: [PATCH] Add CraftMagicNumbers.isSupportedApiVersion()
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
-+++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
-@@ -0,0 +0,0 @@ public final class CraftMagicNumbers implements UnsafeValues {
-     public com.destroystokyo.paper.util.VersionFetcher getVersionFetcher() {
-         return new com.destroystokyo.paper.PaperVersionFetcher();
-     }
-+
-+    @Override
-+    public boolean isSupportedApiVersion(String apiVersion) {
-+        return apiVersion != null && SUPPORTED_API.contains(apiVersion);
-+    }
-     // Paper end
- 
-     /**

Spigot-Server-Patches/Add-Debug-Entities-option-to-debug-dupe-uuid-issues.patch

@@ -1,131 +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
-
-Add -Ddebug.entities=true to your JVM flags to gain more information
-
-diff --git a/src/main/java/net/minecraft/server/level/PlayerChunkMap.java b/src/main/java/net/minecraft/server/level/PlayerChunkMap.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/PlayerChunkMap.java
-+++ b/src/main/java/net/minecraft/server/level/PlayerChunkMap.java
-@@ -0,0 +0,0 @@ public class PlayerChunkMap extends IChunkLoader implements PlayerChunk.d {
-             } else {
-                 PlayerChunkMap.EntityTracker playerchunkmap_entitytracker = new PlayerChunkMap.EntityTracker(entity, i, j, entitytypes.isDeltaTracking());
- 
-+                entity.tracker = playerchunkmap_entitytracker; // Paper - Fast access to tracker
-                 this.trackedEntities.put(entity.getId(), playerchunkmap_entitytracker);
-                 playerchunkmap_entitytracker.track(this.world.getPlayers());
-                 if (entity instanceof EntityPlayer) {
-@@ -0,0 +0,0 @@ public class PlayerChunkMap extends IChunkLoader implements PlayerChunk.d {
-         if (playerchunkmap_entitytracker1 != null) {
-             playerchunkmap_entitytracker1.a();
-         }
--
-+        entity.tracker = null; // Paper - We're no longer tracked
-     }
- 
-     protected void g() {
-diff --git a/src/main/java/net/minecraft/server/level/WorldServer.java b/src/main/java/net/minecraft/server/level/WorldServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/WorldServer.java
-+++ b/src/main/java/net/minecraft/server/level/WorldServer.java
-@@ -0,0 +0,0 @@ public class WorldServer extends World implements GeneratorAccessSeed {
-     public final Convertable.ConversionSession convertable;
-     public final UUID uuid;
-     public boolean hasPhysicsEvent = true; // Paper
-+    private static Throwable getAddToWorldStackTrace(Entity entity) {
-+        return new Throwable(entity + " Added to world at " + new java.util.Date());
-+    }
- 
-     @Override public Chunk getChunkIfLoaded(int x, int z) { // Paper - this was added in world too but keeping here for NMS ABI
-         return this.chunkProvider.getChunkAt(x, z, false);
-@@ -0,0 +0,0 @@ public class WorldServer extends World implements GeneratorAccessSeed {
-     // CraftBukkit start
-     private boolean addEntity0(Entity entity, CreatureSpawnEvent.SpawnReason spawnReason) {
-         org.spigotmc.AsyncCatcher.catchOp("entity add"); // Spigot
--        if (entity.valid) { MinecraftServer.LOGGER.error("Attempted Double World add on " + entity, new Throwable()); return true; } // Paper
-+        // Paper start
-+        if (entity.valid) {
-+            MinecraftServer.LOGGER.error("Attempted Double World add on " + entity, new Throwable());
-+
-+            if (DEBUG_ENTITIES) {
-+                Throwable thr = entity.addedToWorldStack;
-+                if (thr == null) {
-+                    MinecraftServer.LOGGER.error("Double add entity has no add stacktrace");
-+                } else {
-+                    MinecraftServer.LOGGER.error("Double add stacktrace: ", thr);
-+                }
-+            }
-+            return true;
-+        }
-+        // Paper end
-         if (entity.dead) {
-+            // Paper start
-+            if (DEBUG_ENTITIES) {
-+                new Throwable("Tried to add entity " + entity + " but it was marked as removed already").printStackTrace(); // CraftBukkit
-+                getAddToWorldStackTrace(entity).printStackTrace();
-+            }
-+            // Paper end
-             // WorldServer.LOGGER.warn("Tried to add entity {} but it was marked as removed already", EntityTypes.getName(entity.getEntityType())); // CraftBukkit
-             return false;
-         } else if (this.isUUIDTaken(entity)) {
-@@ -0,0 +0,0 @@ public class WorldServer extends World implements GeneratorAccessSeed {
-                 }
-             }
- 
--            this.entitiesByUUID.put(entity.getUniqueID(), entity);
-+            if (DEBUG_ENTITIES) {
-+                entity.addedToWorldStack = getAddToWorldStackTrace(entity);
-+            }
-+
-+            Entity old = this.entitiesByUUID.put(entity.getUniqueID(), entity);
-+            if (old != null && old.getId() != entity.getId() && old.valid) {
-+                Logger logger = LogManager.getLogger();
-+                logger.error("Overwrote an existing entity " + old + " with " + entity);
-+                if (DEBUG_ENTITIES) {
-+                    if (old.addedToWorldStack != null) {
-+                        old.addedToWorldStack.printStackTrace();
-+                    } else {
-+                        logger.error("Oddly, the old entity was not added to the world in the normal way. Plugins?");
-+                    }
-+                    entity.addedToWorldStack.printStackTrace();
-+                }
-+            }
-+
-             this.getChunkProvider().addEntity(entity);
-             // CraftBukkit start - SPIGOT-5278
-             if (entity instanceof EntityDrowned) {
-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 @@ import net.minecraft.resources.MinecraftKey;
- import net.minecraft.resources.ResourceKey;
- import net.minecraft.server.MinecraftServer;
- import net.minecraft.server.level.EntityPlayer;
-+import net.minecraft.server.level.PlayerChunkMap;
- import net.minecraft.server.level.TicketType;
- import net.minecraft.server.level.WorldServer;
- import net.minecraft.sounds.SoundCategory;
-@@ -0,0 +0,0 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, ne
-     public com.destroystokyo.paper.loottable.PaperLootableInventoryData lootableData; // Paper
-     private CraftEntity bukkitEntity;
- 
-+    PlayerChunkMap.EntityTracker tracker; // Paper
-+    public Throwable addedToWorldStack; // Paper - entity debug
-     public CraftEntity getBukkitEntity() {
-         if (bukkitEntity == null) {
-             bukkitEntity = CraftEntity.getEntity(world.getServer(), this);
-diff --git a/src/main/java/net/minecraft/world/level/World.java b/src/main/java/net/minecraft/world/level/World.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/World.java
-+++ b/src/main/java/net/minecraft/world/level/World.java
-@@ -0,0 +0,0 @@ public abstract class World implements GeneratorAccess, AutoCloseable {
-     public boolean pvpMode;
-     public boolean keepSpawnInMemory = true;
-     public org.bukkit.generator.ChunkGenerator generator;
-+    public static final boolean DEBUG_ENTITIES = Boolean.getBoolean("debug.entities"); // Paper
- 
-     public boolean captureBlockStates = false;
-     public boolean captureTreeGeneration = false;

Spigot-Server-Patches/Add-Destroy-Speed-API.patch

@@ -1,35 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Ineusia <ineusia@yahoo.com>
-Date: Mon, 26 Oct 2020 11:48:06 -0500
-Subject: [PATCH] Add Destroy Speed API
-
-Co-authored-by: Jake Potrebic <jake.m.potrebic@gmail.com>
-
-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 {
-     public String getTranslationKey() {
-         return org.bukkit.Bukkit.getUnsafe().getTranslationKey(this);
-     }
-+
-+    @Override
-+    public float getDestroySpeed(ItemStack itemStack, boolean considerEnchants) {
-+        net.minecraft.world.item.ItemStack nmsItemStack;
-+        if (itemStack instanceof CraftItemStack) {
-+            nmsItemStack = ((CraftItemStack) itemStack).getHandle();
-+        } else {
-+            nmsItemStack = CraftItemStack.asNMSCopy(itemStack);
-+        }
-+        float speed = nmsItemStack.getItem().getDestroySpeed(nmsItemStack, this.getNMSBlock().getBlockData());
-+        if (speed > 1.0F && considerEnchants) {
-+            int enchantLevel = net.minecraft.world.item.enchantment.EnchantmentManager.getEnchantmentLevel(net.minecraft.world.item.enchantment.Enchantments.DIG_SPEED, nmsItemStack);
-+            if (enchantLevel > 0) {
-+                speed += enchantLevel * enchantLevel + 1;
-+            }
-+        }
-+        return speed;
-+    }
-     // Paper end
- }

Spigot-Server-Patches/Add-Early-Warning-Feature-to-WatchDog.patch

@@ -1,184 +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/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ import org.bukkit.configuration.file.YamlConfiguration;
- import co.aikar.timings.Timings;
- import co.aikar.timings.TimingsManager;
- import org.spigotmc.SpigotConfig;
-+import org.spigotmc.WatchdogThread;
- 
- public class PaperConfig {
- 
-@@ -0,0 +0,0 @@ public class PaperConfig {
-         }
-     }
- 
-+    public static int watchdogPrintEarlyWarningEvery = 5000;
-+    public static int watchdogPrintEarlyWarningDelay = 10000;
-+    private static void watchdogEarlyWarning() {
-+        watchdogPrintEarlyWarningEvery = getInt("settings.watchdog.early-warning-every", 5000);
-+        watchdogPrintEarlyWarningDelay = getInt("settings.watchdog.early-warning-delay", 10000);
-+        WatchdogThread.doStart(SpigotConfig.timeoutTime, SpigotConfig.restartOnCrash );
-+    }
-+
-     public static int tabSpamIncrement = 1;
-     public static int tabSpamLimit = 500;
-     private static void tabSpamLimiters() {
-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 IAsyncTaskHandlerReentrant<TickTas
-                 this.a(this.serverPing);
- 
-                 // Spigot start
-+                org.spigotmc.WatchdogThread.hasStarted = true; // Paper
-                 Arrays.fill( recentTps, 20 );
-                 long start = System.nanoTime(), curTime, tickSection = start; // Paper - Further improve server tick loop
-                 lastTick = start - TICK_TIME; // Paper
-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
-         reloadCount++;
-         configuration = YamlConfiguration.loadConfiguration(getConfigFile());
-         commandsConfiguration = YamlConfiguration.loadConfiguration(getCommandsConfigFile());
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-         enablePlugins(PluginLoadOrder.STARTUP);
-         enablePlugins(PluginLoadOrder.POSTWORLD);
-         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
-         restartScript = getString( "settings.restart-script", restartScript );
-         restartMessage = transform( getString( "messages.restart", "Server is restarting" ) );
-         commands.put( "restart", new RestartCommand( "restart" ) );
--        WatchdogThread.doStart( timeoutTime, restartOnCrash );
-+        //WatchdogThread.doStart( timeoutTime, restartOnCrash ); // Paper - moved to PaperConfig
-     }
- 
-     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 @@ import java.lang.management.MonitorInfo;
- import java.lang.management.ThreadInfo;
- import java.util.logging.Level;
- import java.util.logging.Logger;
-+import com.destroystokyo.paper.PaperConfig;
- import net.minecraft.server.MinecraftServer;
- import org.bukkit.Bukkit;
- 
-@@ -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(PaperConfig.watchdogPrintEarlyWarningEvery, timeoutTime); // Paper
-+        earlyWarningDelay = Math.min(PaperConfig.watchdogPrintEarlyWarningDelay, timeoutTime); // Paper
-     }
- 
-     private static long monotonicMillis()
-@@ -0,0 +0,0 @@ public class WatchdogThread extends Thread
-     {
-         while ( !stopping )
-         {
--            //
--            if ( lastTick != 0 && timeoutTime > 0 && monotonicMillis() > lastTick + timeoutTime && !Boolean.getBoolean("disable.watchdog")) // Paper - Add property to disable
-+            // Paper start
-+            Logger log = Bukkit.getServer().getLogger();
-+            long currentTime = monotonicMillis();
-+            if ( lastTick != 0 && timeoutTime > 0 && currentTime > lastTick + earlyWarningEvery && !Boolean.getBoolean("disable.watchdog") )
-             {
--                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
-                 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 )
-                 {
-                     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 ( 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 )
-             {
-                 interrupt();

Spigot-Server-Patches/Add-ElderGuardianAppearanceEvent.patch

@@ -1,23 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
-Date: Fri, 19 Mar 2021 23:39:09 -0400
-Subject: [PATCH] Add ElderGuardianAppearanceEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/monster/EntityGuardianElder.java b/src/main/java/net/minecraft/world/entity/monster/EntityGuardianElder.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/EntityGuardianElder.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/EntityGuardianElder.java
-@@ -0,0 +0,0 @@ public class EntityGuardianElder extends EntityGuardian {
-             while (iterator.hasNext()) {
-                 EntityPlayer entityplayer = (EntityPlayer) iterator.next();
- 
-+                if (new io.papermc.paper.event.entity.ElderGuardianAppearanceEvent(getBukkitEntity(), entityplayer.getBukkitEntity()).callEvent()) { // Paper - Add Guardian Appearance Event
-                 if (!entityplayer.hasEffect(mobeffectlist) || entityplayer.getEffect(mobeffectlist).getAmplifier() < 2 || entityplayer.getEffect(mobeffectlist).getDuration() < 1200) {
-                     entityplayer.playerConnection.sendPacket(new PacketPlayOutGameStateChange(PacketPlayOutGameStateChange.k, this.isSilent() ? 0.0F : 1.0F));
-                     entityplayer.addEffect(new MobEffect(mobeffectlist, 6000, 2), org.bukkit.event.entity.EntityPotionEffectEvent.Cause.ATTACK); // CraftBukkit
-                 }
-+            } // Paper - Add Guardian Appearance Event
-             }
-         }
- 

Spigot-Server-Patches/Add-EntityBlockStorage-clearEntities.patch

@@ -1,37 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
-Date: Mon, 5 Apr 2021 18:12:29 -0400
-Subject: [PATCH] Add EntityBlockStorage#clearEntities()
-
-
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/TileEntityBeehive.java b/src/main/java/net/minecraft/world/level/block/entity/TileEntityBeehive.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/TileEntityBeehive.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/TileEntityBeehive.java
-@@ -0,0 +0,0 @@ public class TileEntityBeehive extends TileEntity implements ITickable {
-         return this.bees.size();
-     }
- 
-+    // Paper start - Add EntityBlockStorage clearEntities
-+    public void clearBees() {
-+        this.bees.clear();
-+    }
-+    // Paper end
-     public static int a(IBlockData iblockdata) {
-         return (Integer) iblockdata.get(BlockBeehive.b);
-     }
-diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBeehive.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBeehive.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/block/CraftBeehive.java
-+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBeehive.java
-@@ -0,0 +0,0 @@ public class CraftBeehive extends CraftBlockEntityState<TileEntityBeehive> imple
- 
-         getSnapshot().addBee(((CraftBee) entity).getHandle(), false);
-     }
-+    // Paper start - Add EntityBlockStorage clearEntities
-+    @Override
-+    public void clearEntities() {
-+        getSnapshot().clearBees();
-+    }
-+    // Paper end
- }

Spigot-Server-Patches/Add-EntityInsideBlockEvent.patch

@@ -1,222 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Sat, 8 May 2021 18:02:36 -0700
-Subject: [PATCH] Add EntityInsideBlockEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockBubbleColumn.java b/src/main/java/net/minecraft/world/level/block/BlockBubbleColumn.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockBubbleColumn.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockBubbleColumn.java
-@@ -0,0 +0,0 @@ public class BlockBubbleColumn extends Block implements IFluidSource {
- 
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         IBlockData iblockdata1 = world.getType(blockposition.up());
- 
-         if (iblockdata1.isAir()) {
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockButtonAbstract.java b/src/main/java/net/minecraft/world/level/block/BlockButtonAbstract.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockButtonAbstract.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockButtonAbstract.java
-@@ -0,0 +0,0 @@ public abstract class BlockButtonAbstract extends BlockAttachable {
- 
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         if (!world.isClientSide && this.v && !(Boolean) iblockdata.get(BlockButtonAbstract.POWERED)) {
-             this.e(iblockdata, world, blockposition);
-         }
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockCactus.java b/src/main/java/net/minecraft/world/level/block/BlockCactus.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockCactus.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockCactus.java
-@@ -0,0 +0,0 @@ public class BlockCactus extends Block {
- 
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         CraftEventFactory.blockDamage = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ()); // CraftBukkit
-         entity.damageEntity(DamageSource.CACTUS, 1.0F);
-         CraftEventFactory.blockDamage = null; // CraftBukkit
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockCampfire.java b/src/main/java/net/minecraft/world/level/block/BlockCampfire.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockCampfire.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockCampfire.java
-@@ -0,0 +0,0 @@ public class BlockCampfire extends BlockTileEntity implements IBlockWaterlogged
- 
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         if (!entity.isFireProof() && (Boolean) iblockdata.get(BlockCampfire.LIT) && entity instanceof EntityLiving && !EnchantmentManager.i((EntityLiving) entity)) {
-             entity.damageEntity(DamageSource.FIRE, (float) this.h);
-         }
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockCauldron.java b/src/main/java/net/minecraft/world/level/block/BlockCauldron.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockCauldron.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockCauldron.java
-@@ -0,0 +0,0 @@ public class BlockCauldron extends Block {
- 
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         int i = (Integer) iblockdata.get(BlockCauldron.LEVEL);
-         float f = (float) blockposition.getY() + (6.0F + (float) (3 * i)) / 16.0F;
- 
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockCrops.java b/src/main/java/net/minecraft/world/level/block/BlockCrops.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockCrops.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockCrops.java
-@@ -0,0 +0,0 @@ public class BlockCrops extends BlockPlant implements IBlockFragilePlantElement
- 
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         if (entity instanceof EntityRavager && !CraftEventFactory.callEntityChangeBlockEvent(entity, blockposition, Blocks.AIR.getBlockData(), !world.getGameRules().getBoolean(GameRules.MOB_GRIEFING)).isCancelled()) { // CraftBukkit
-             world.a(blockposition, true, entity);
-         }
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockEnderPortal.java b/src/main/java/net/minecraft/world/level/block/BlockEnderPortal.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockEnderPortal.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockEnderPortal.java
-@@ -0,0 +0,0 @@ public class BlockEnderPortal extends BlockTileEntity {
- 
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         if (world instanceof WorldServer && !entity.isPassenger() && !entity.isVehicle() && entity.canPortal() && VoxelShapes.c(VoxelShapes.a(entity.getBoundingBox().d((double) (-blockposition.getX()), (double) (-blockposition.getY()), (double) (-blockposition.getZ()))), iblockdata.getShape(world, blockposition), OperatorBoolean.AND)) {
-             ResourceKey<World> resourcekey = world.getTypeKey() == DimensionManager.THE_END ? World.OVERWORLD : World.THE_END; // CraftBukkit - SPIGOT-6152: send back to main overworld in custom ends
-             WorldServer worldserver = ((WorldServer) world).getMinecraftServer().getWorldServer(resourcekey);
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockFireAbstract.java b/src/main/java/net/minecraft/world/level/block/BlockFireAbstract.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockFireAbstract.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockFireAbstract.java
-@@ -0,0 +0,0 @@ public abstract class BlockFireAbstract extends Block {
- 
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         if (!entity.isFireProof()) {
-             entity.setFireTicks(entity.getFireTicks() + 1);
-             if (entity.getFireTicks() == 0) {
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockHoney.java b/src/main/java/net/minecraft/world/level/block/BlockHoney.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockHoney.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockHoney.java
-@@ -0,0 +0,0 @@ public class BlockHoney extends BlockHalfTransparent {
- 
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         if (this.a(blockposition, entity)) {
-             this.a(entity, blockposition);
-             this.d(entity);
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockHopper.java b/src/main/java/net/minecraft/world/level/block/BlockHopper.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockHopper.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockHopper.java
-@@ -0,0 +0,0 @@ public class BlockHopper extends BlockTileEntity {
- 
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         TileEntity tileentity = world.getTileEntity(blockposition);
- 
-         if (tileentity instanceof TileEntityHopper) {
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockMinecartDetector.java b/src/main/java/net/minecraft/world/level/block/BlockMinecartDetector.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockMinecartDetector.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockMinecartDetector.java
-@@ -0,0 +0,0 @@ public class BlockMinecartDetector extends BlockMinecartTrackAbstract {
- 
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         if (!world.isClientSide) {
-             if (!(Boolean) iblockdata.get(BlockMinecartDetector.POWERED)) {
-                 this.a(world, blockposition, iblockdata);
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockPortal.java b/src/main/java/net/minecraft/world/level/block/BlockPortal.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockPortal.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockPortal.java
-@@ -0,0 +0,0 @@ public class BlockPortal extends Block {
- 
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         if (!entity.isPassenger() && !entity.isVehicle() && entity.canPortal()) {
-             // CraftBukkit start - Entity in portal
-             EntityPortalEnterEvent event = new EntityPortalEnterEvent(entity.getBukkitEntity(), new org.bukkit.Location(world.getWorld(), blockposition.getX(), blockposition.getY(), blockposition.getZ()));
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockPressurePlateAbstract.java b/src/main/java/net/minecraft/world/level/block/BlockPressurePlateAbstract.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockPressurePlateAbstract.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockPressurePlateAbstract.java
-@@ -0,0 +0,0 @@ public abstract class BlockPressurePlateAbstract extends Block {
- 
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         if (!world.isClientSide) {
-             int i = this.getPower(iblockdata);
- 
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockSweetBerryBush.java b/src/main/java/net/minecraft/world/level/block/BlockSweetBerryBush.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockSweetBerryBush.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockSweetBerryBush.java
-@@ -0,0 +0,0 @@ public class BlockSweetBerryBush extends BlockPlant implements IBlockFragilePlan
- 
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         if (entity instanceof EntityLiving && entity.getEntityType() != EntityTypes.FOX && entity.getEntityType() != EntityTypes.BEE) {
-             entity.a(iblockdata, new Vec3D(0.800000011920929D, 0.75D, 0.800000011920929D));
-             if (!world.isClientSide && (Integer) iblockdata.get(BlockSweetBerryBush.a) > 0 && (entity.D != entity.locX() || entity.F != entity.locZ())) {
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockTripwire.java b/src/main/java/net/minecraft/world/level/block/BlockTripwire.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockTripwire.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockTripwire.java
-@@ -0,0 +0,0 @@ public class BlockTripwire extends Block {
- 
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         if (!world.isClientSide) {
-             if (!(Boolean) iblockdata.get(BlockTripwire.POWERED)) {
-                 this.a(world, blockposition);
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockWaterLily.java b/src/main/java/net/minecraft/world/level/block/BlockWaterLily.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockWaterLily.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockWaterLily.java
-@@ -0,0 +0,0 @@ public class BlockWaterLily extends BlockPlant {
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-         super.a(iblockdata, world, blockposition, entity);
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         if (world instanceof WorldServer && entity instanceof EntityBoat && !org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(entity, blockposition, Blocks.AIR.getBlockData()).isCancelled()) { // CraftBukkit
-             world.a(new BlockPosition(blockposition), true, entity);
-         }
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockWeb.java b/src/main/java/net/minecraft/world/level/block/BlockWeb.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockWeb.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockWeb.java
-@@ -0,0 +0,0 @@ public class BlockWeb extends Block {
- 
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         entity.a(iblockdata, new Vec3D(0.25D, 0.05000000074505806D, 0.25D));
-     }
- }
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockWitherRose.java b/src/main/java/net/minecraft/world/level/block/BlockWitherRose.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockWitherRose.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockWitherRose.java
-@@ -0,0 +0,0 @@ public class BlockWitherRose extends BlockFlowers {
- 
-     @Override
-     public void a(IBlockData iblockdata, World world, BlockPosition blockposition, Entity entity) {
-+        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, blockposition)).callEvent()) { return; } // Paper
-         if (!world.isClientSide && world.getDifficulty() != EnumDifficulty.PEACEFUL) {
-             if (entity instanceof EntityLiving) {
-                 EntityLiving entityliving = (EntityLiving) entity;

Spigot-Server-Patches/Add-EntityLoadCrossbowEvent.patch

@@ -1,48 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Josh Roy <10731363+JRoy@users.noreply.github.com>
-Date: Wed, 7 Oct 2020 12:04:01 -0400
-Subject: [PATCH] Add EntityLoadCrossbowEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/item/ItemCrossbow.java b/src/main/java/net/minecraft/world/item/ItemCrossbow.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/item/ItemCrossbow.java
-+++ b/src/main/java/net/minecraft/world/item/ItemCrossbow.java
-@@ -0,0 +0,0 @@ package net.minecraft.world.item;
- import com.google.common.collect.Lists;
- import com.mojang.math.Quaternion;
- import com.mojang.math.Vector3fa;
-+import org.bukkit.inventory.EquipmentSlot; // Paper
-+import io.papermc.paper.event.entity.EntityLoadCrossbowEvent; // Paper - EntityLoadCrossbowEvent namespace conflicts
- import java.util.List;
- import java.util.Random;
- import java.util.function.Predicate;
-@@ -0,0 +0,0 @@ public class ItemCrossbow extends ItemProjectileWeapon implements ItemVanishable
-         int j = this.e_(itemstack) - i;
-         float f = a(j, itemstack);
- 
--        if (f >= 1.0F && !d(itemstack) && a(entityliving, itemstack)) {
-+        // Paper start - EntityLoadCrossbowEvent
-+        if (f >= 1.0F && !d(itemstack) /*&& a(entityliving, itemstack)*/) {
-+            final EntityLoadCrossbowEvent event = new EntityLoadCrossbowEvent(entityliving.getBukkitLivingEntity(), itemstack.asBukkitMirror(), entityliving.getRaisedHand() == EnumHand.MAIN_HAND ? EquipmentSlot.HAND : EquipmentSlot.OFF_HAND);
-+            if (!event.callEvent() || !attemptProjectileLoad(entityliving, itemstack, event.shouldConsumeItem())) return;
-+        // Paper end
-             a(itemstack, true);
-             SoundCategory soundcategory = entityliving instanceof EntityHuman ? SoundCategory.PLAYERS : SoundCategory.HOSTILE;
- 
-@@ -0,0 +0,0 @@ public class ItemCrossbow extends ItemProjectileWeapon implements ItemVanishable
- 
-     }
- 
--    private static boolean a(EntityLiving entityliving, ItemStack itemstack) {
-+    private static boolean attemptProjectileLoad(EntityLiving ent, ItemStack bow) { return a(ent, bow); } // Paper - EntityLoadCrossbowEvent - OBFHELPER
-+    private static boolean attemptProjectileLoad(EntityLiving ent, ItemStack bow, boolean consume) { return a(ent, bow, consume); } // Paper - EntityLoadCrossbowEvent - OBFHELPER
-+    private static boolean a(EntityLiving entityliving, ItemStack itemstack) { return a(entityliving, itemstack, true); };// Paper - add consume
-+    private static boolean a(EntityLiving entityliving, ItemStack itemstack, boolean consume) { // Paper - add consume
-         int i = EnchantmentManager.getEnchantmentLevel(Enchantments.MULTISHOT, itemstack);
-         int j = i == 0 ? 1 : 3;
--        boolean flag = entityliving instanceof EntityHuman && ((EntityHuman) entityliving).abilities.canInstantlyBuild;
-+        boolean flag = !consume || entityliving instanceof EntityHuman && ((EntityHuman) entityliving).abilities.canInstantlyBuild; // Paper - add consme
-         ItemStack itemstack1 = entityliving.f(itemstack);
-         ItemStack itemstack2 = itemstack1.cloneItemStack();
- 

Spigot-Server-Patches/Add-EntityZapEvent.patch

@@ -1,58 +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/animal/EntityPig.java b/src/main/java/net/minecraft/world/entity/animal/EntityPig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/animal/EntityPig.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/EntityPig.java
-@@ -0,0 +0,0 @@ public class EntityPig extends EntityAnimal implements ISteerable, ISaddleable {
-             }
- 
-             entitypigzombie.setPersistent();
-+            // Paper start
-+            if (CraftEventFactory.callEntityZapEvent(this, entitylightning, entitypigzombie).isCancelled()) {
-+                return;
-+            }
-+            // Paper end
-             // CraftBukkit start
-             if (CraftEventFactory.callPigZapEvent(this, entitylightning, entitypigzombie).isCancelled()) {
-                 return;
-diff --git a/src/main/java/net/minecraft/world/entity/npc/EntityVillager.java b/src/main/java/net/minecraft/world/entity/npc/EntityVillager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/npc/EntityVillager.java
-+++ b/src/main/java/net/minecraft/world/entity/npc/EntityVillager.java
-@@ -0,0 +0,0 @@ public class EntityVillager extends EntityVillagerAbstract implements Reputation
-             EntityVillager.LOGGER.info("Villager {} was struck by lightning {}.", this, entitylightning);
-             EntityWitch entitywitch = (EntityWitch) EntityTypes.WITCH.a((World) worldserver);
- 
-+            // Paper start
-+            if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityZapEvent(this, entitylightning, entitywitch).isCancelled()) {
-+                return;
-+            }
-+            // Paper end
-+
-             entitywitch.setPositionRotation(this.locX(), this.locY(), this.locZ(), this.yaw, this.pitch);
-             entitywitch.prepare(worldserver, worldserver.getDamageScaler(entitywitch.getChunkCoordinates()), EnumMobSpawn.CONVERSION, (GroupDataEntity) null, (NBTTagCompound) null);
-             entitywitch.setNoAI(this.isNoAI());
-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
-+    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 HorseJumpEvent callHorseJumpEvent(Entity horse, float power) {
-         HorseJumpEvent event = new HorseJumpEvent((AbstractHorse) horse.getBukkitEntity(), power);
-         horse.getBukkitEntity().getServer().getPluginManager().callEvent(event);

Spigot-Server-Patches/Add-Heightmap-API.patch

@@ -1,55 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Tue, 1 Jan 2019 02:22:01 -0800
-Subject: [PATCH] Add Heightmap API
-
-
-diff --git a/src/main/java/net/minecraft/world/level/World.java b/src/main/java/net/minecraft/world/level/World.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/World.java
-+++ b/src/main/java/net/minecraft/world/level/World.java
-@@ -0,0 +0,0 @@ public abstract class World implements GeneratorAccess, AutoCloseable {
-         }
-     }
- 
--    @Override
--    public int a(HeightMap.Type heightmap_type, int i, int j) {
-+    public final int getHighestBlockY(final HeightMap.Type heightmap, final int x, final int z) { return this.a(heightmap, x, z); } // Paper - OBFHELPER
-+    @Override public int a(HeightMap.Type heightmap_type, int i, int j) { // Paper - OBFHELPER
-         int k;
- 
-         if (i >= -30000000 && j >= -30000000 && i < 30000000 && j < 30000000) {
-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 implements World {
-         return getHighestBlockYAt(x, z, org.bukkit.HeightMap.MOTION_BLOCKING);
-     }
- 
-+    // Paper start - Implement heightmap api
-+    @Override
-+    public int getHighestBlockYAt(final int x, final int z, final com.destroystokyo.paper.HeightmapType heightmap) throws UnsupportedOperationException {
-+        this.getChunkAt(x >> 4, z >> 4); // heightmap will ret 0 on unloaded areas
-+
-+        switch (heightmap) {
-+            case LIGHT_BLOCKING:
-+                throw new UnsupportedOperationException(); // TODO
-+                //return this.world.getHighestBlockY(HeightMap.Type.LIGHT_BLOCKING, x, z);
-+            case ANY:
-+                return this.world.getHighestBlockY(net.minecraft.world.level.levelgen.HeightMap.Type.WORLD_SURFACE, x, z);
-+            case SOLID:
-+                return this.world.getHighestBlockY(net.minecraft.world.level.levelgen.HeightMap.Type.OCEAN_FLOOR, x, z);
-+            case SOLID_OR_LIQUID:
-+                return this.world.getHighestBlockY(net.minecraft.world.level.levelgen.HeightMap.Type.MOTION_BLOCKING, x, z);
-+            case SOLID_OR_LIQUID_NO_LEAVES:
-+                return this.world.getHighestBlockY(net.minecraft.world.level.levelgen.HeightMap.Type.MOTION_BLOCKING_NO_LEAVES, x, z);
-+            default:
-+                throw new UnsupportedOperationException();
-+        }
-+    }
-+    // Paper end
-+
-     @Override
-     public Location getSpawnLocation() {
-         BlockPosition spawn = world.getSpawn();

Spigot-Server-Patches/Add-LivingEntity-clearActiveItem.patch

@@ -1,24 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Anrza <andrzejrzeczycki314@gmail.com>
-Date: Wed, 15 Jul 2020 12:08:49 +0200
-Subject: [PATCH] Add LivingEntity#clearActiveItem
-
-
-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 getHandle().activeItem.asBukkitMirror();
-     }
- 
-+    // Paper start
-+    @Override
-+    public void clearActiveItem() {
-+        getHandle().clearActiveItem();
-+    }
-+    // Paper end
-+
-     @Override
-     public int getItemUseRemainingTime() {
-         return getHandle().getItemUseRemainingTime();

Spigot-Server-Patches/Add-LivingEntity-getTargetEntity.patch

@@ -1,187 +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/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 INamableTileEntity, ICommandListener, ne
-         return this.c(f - 90.0F, f1);
-     }
- 
-+    public final Vec3D getEyePosition(float partialTicks) { return j(partialTicks); } // Paper - OBFHELPER
-     public final Vec3D j(float f) {
-         if (f == 1.0F) {
-             return new Vec3D(this.locX(), this.getHeadY(), this.locZ());
-@@ -0,0 +0,0 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, ne
-         return this.getPassengers().size() < 1;
-     }
- 
-+    public final float getCollisionBorderSize() { return bg(); } // Paper - OBFHELPER
-     public float bg() {
-         return 0.0F;
-     }
-diff --git a/src/main/java/net/minecraft/world/entity/EntityLiving.java b/src/main/java/net/minecraft/world/entity/EntityLiving.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/EntityLiving.java
-+++ b/src/main/java/net/minecraft/world/entity/EntityLiving.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.level.storage.loot.parameters.LootContextParameterSet
- import net.minecraft.world.level.storage.loot.parameters.LootContextParameters;
- import net.minecraft.world.phys.AxisAlignedBB;
- import net.minecraft.world.phys.MovingObjectPosition;
-+import net.minecraft.world.phys.MovingObjectPositionEntity;
- import net.minecraft.world.phys.Vec3D;
- import net.minecraft.world.scores.ScoreboardTeam;
- import org.apache.logging.log4j.Logger;
-@@ -0,0 +0,0 @@ public abstract class EntityLiving extends Entity {
-         return world.rayTrace(raytrace);
-     }
- 
-+    public MovingObjectPositionEntity getTargetEntity(int maxDistance) {
-+        if (maxDistance < 1 || maxDistance > 120) {
-+            throw new IllegalArgumentException("maxDistance must be between 1-120");
-+        }
-+
-+        Vec3D start = this.getEyePosition(1.0F);
-+        Vec3D direction = this.getLookDirection();
-+        Vec3D end = start.add(direction.x * maxDistance, direction.y * maxDistance, direction.z * maxDistance);
-+
-+        List<Entity> entityList = world.getEntities(this, getBoundingBox().expand(direction.x * maxDistance, direction.y * maxDistance, direction.z * maxDistance).grow(1.0D, 1.0D, 1.0D), IEntitySelector.canAITarget().and(Entity::isInteractable));
-+
-+        double distance = 0.0D;
-+        MovingObjectPositionEntity result = null;
-+
-+        for (Entity entity : entityList) {
-+            AxisAlignedBB aabb = entity.getBoundingBox().grow((double) entity.getCollisionBorderSize());
-+            Optional<Vec3D> rayTraceResult = aabb.calculateIntercept(start, end);
-+
-+            if (rayTraceResult.isPresent()) {
-+                Vec3D rayTrace = rayTraceResult.get();
-+                double distanceTo = start.distanceSquared(rayTrace);
-+                if (distanceTo < distance || distance == 0.0D) {
-+                    result = new MovingObjectPositionEntity(entity, rayTrace);
-+                    distance = distanceTo;
-+                }
-+            }
-+        }
-+
-+        return result;
-+    }
-+
-     public int shieldBlockingDelay = world.paperConfig.shieldBlockingDelay;
- 
-     public int getShieldBlockingDelay() {
-diff --git a/src/main/java/net/minecraft/world/entity/IEntitySelector.java b/src/main/java/net/minecraft/world/entity/IEntitySelector.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/IEntitySelector.java
-+++ b/src/main/java/net/minecraft/world/entity/IEntitySelector.java
-@@ -0,0 +0,0 @@ public final class IEntitySelector {
-     public static final Predicate<Entity> e = (entity) -> {
-         return !(entity instanceof EntityHuman) || !entity.isSpectator() && !((EntityHuman) entity).isCreative();
-     };
-+    public static Predicate<Entity> canAITarget() { return f; } // Paper - OBFHELPER
-     public static final Predicate<Entity> f = (entity) -> {
-         return !(entity instanceof EntityHuman) || !entity.isSpectator() && !((EntityHuman) entity).isCreative() && entity.world.getDifficulty() != EnumDifficulty.PEACEFUL;
-     };
-diff --git a/src/main/java/net/minecraft/world/phys/AxisAlignedBB.java b/src/main/java/net/minecraft/world/phys/AxisAlignedBB.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/phys/AxisAlignedBB.java
-+++ b/src/main/java/net/minecraft/world/phys/AxisAlignedBB.java
-@@ -0,0 +0,0 @@ public class AxisAlignedBB {
-         return this.b(vec3d.x, vec3d.y, vec3d.z);
-     }
- 
-+    public final AxisAlignedBB expand(double x, double y, double z) { return b(x, y, z); } // Paper - OBFHELPER
-     public AxisAlignedBB b(double d0, double d1, double d2) {
-         double d3 = this.minX;
-         double d4 = this.minY;
-@@ -0,0 +0,0 @@ public class AxisAlignedBB {
-         return new AxisAlignedBB(d3, d4, d5, d6, d7, d8);
-     }
- 
-+    // Paper start
-+    public AxisAlignedBB grow(double d0) {
-+        return grow(d0, d0, d0);
-+    }
-+    // Paper end
-+
-     public AxisAlignedBB grow(double d0, double d1, double d2) {
-         double d3 = this.minX - d0;
-         double d4 = this.minY - d1;
-@@ -0,0 +0,0 @@ public class AxisAlignedBB {
-         return this.minX < d3 && this.maxX > d0 && this.minY < d4 && this.maxY > d1 && this.minZ < d5 && this.maxZ > d2;
-     }
- 
-+    public final boolean contains(Vec3D vec3d) { return d(vec3d); } // Paper - OBFHELPER
-     public boolean d(Vec3D vec3d) {
-         return this.e(vec3d.x, vec3d.y, vec3d.z);
-     }
-@@ -0,0 +0,0 @@ public class AxisAlignedBB {
-         return this.g(-d0);
-     }
- 
-+    public final Optional<Vec3D> calculateIntercept(Vec3D vec3d, Vec3D vec3d1) { return b(vec3d, vec3d1); } // Paper - OBFHELPER
-     public Optional<Vec3D> b(Vec3D vec3d, Vec3D vec3d1) {
-         double[] adouble = new double[]{1.0D};
-         double d0 = vec3d1.x - vec3d.x;
-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 @@
- package org.bukkit.craftbukkit.entity;
- 
- import com.destroystokyo.paper.block.TargetBlockInfo;
-+import com.destroystokyo.paper.entity.TargetEntityInfo;
- import com.google.common.base.Preconditions;
- import com.google.common.collect.Sets;
- import java.util.ArrayList;
-@@ -0,0 +0,0 @@ import net.minecraft.world.entity.projectile.EntityThrownExpBottle;
- import net.minecraft.world.entity.projectile.EntityThrownTrident;
- import net.minecraft.world.entity.projectile.EntityTippedArrow;
- import net.minecraft.world.entity.projectile.EntityWitherSkull;
-+import net.minecraft.world.level.RayTrace;
- import net.minecraft.world.phys.MovingObjectPosition;
- import net.minecraft.world.phys.MovingObjectPositionBlock;
-+import net.minecraft.world.phys.MovingObjectPositionEntity;
-+import net.minecraft.world.phys.Vec3D;
- import org.apache.commons.lang.Validate;
- import org.bukkit.FluidCollisionMode;
- import org.bukkit.Location;
-@@ -0,0 +0,0 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
-             new TargetBlockInfo(CraftBlock.at(getHandle().world, ((MovingObjectPositionBlock)rayTrace).getBlockPosition()),
-                 MCUtil.toBukkitBlockFace(((MovingObjectPositionBlock)rayTrace).getDirection()));
-     }
-+
-+    public Entity getTargetEntity(int maxDistance, boolean ignoreBlocks) {
-+        MovingObjectPositionEntity rayTrace = rayTraceEntity(maxDistance, ignoreBlocks);
-+        return rayTrace == null ? null : rayTrace.getEntity().getBukkitEntity();
-+    }
-+
-+    public TargetEntityInfo getTargetEntityInfo(int maxDistance, boolean ignoreBlocks) {
-+        MovingObjectPositionEntity rayTrace = rayTraceEntity(maxDistance, ignoreBlocks);
-+        return rayTrace == null ? null : new TargetEntityInfo(rayTrace.getEntity().getBukkitEntity(), new org.bukkit.util.Vector(rayTrace.getPos().x, rayTrace.getPos().y, rayTrace.getPos().z));
-+    }
-+
-+    public MovingObjectPositionEntity rayTraceEntity(int maxDistance, boolean ignoreBlocks) {
-+        MovingObjectPositionEntity rayTrace = getHandle().getTargetEntity(maxDistance);
-+        if (rayTrace == null) {
-+            return null;
-+        }
-+        if (!ignoreBlocks) {
-+            MovingObjectPosition rayTraceBlocks = getHandle().getRayTrace(maxDistance, RayTrace.FluidCollisionOption.NONE);
-+            if (rayTraceBlocks != null) {
-+                Vec3D eye = getHandle().getEyePosition(1.0F);
-+                if (eye.distanceSquared(rayTraceBlocks.getPos()) <= eye.distanceSquared(rayTrace.getPos())) {
-+                    return null;
-+                }
-+            }
-+        }
-+        return rayTrace;
-+    }
-     // Paper end
- 
-     @Override

Spigot-Server-Patches/Add-MinecraftKey-Information-to-Objects.patch

@@ -1,144 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Wed, 4 Jul 2018 01:40:13 -0400
-Subject: [PATCH] Add MinecraftKey Information to Objects
-
-Stores the reference to the objects respective MinecraftKey
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperCommand.java b/src/main/java/com/destroystokyo/paper/PaperCommand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperCommand.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperCommand.java
-@@ -0,0 +0,0 @@ public class PaperCommand extends Command {
- 
-                 Collection<Entity> entities = world.entitiesById.values();
-                 entities.forEach(e -> {
--                    MinecraftKey key = new MinecraftKey(""); // TODO: update in next patch
-+                    MinecraftKey key = e.getMinecraftKey();
- 
-                     MutablePair<Integer, Map<ChunkCoordIntPair, Integer>> info = list.computeIfAbsent(key, k -> MutablePair.of(0, Maps.newHashMap()));
-                     ChunkCoordIntPair chunk = new ChunkCoordIntPair(e.chunkX, e.chunkZ);
-diff --git a/src/main/java/net/minecraft/server/KeyedObject.java b/src/main/java/net/minecraft/server/KeyedObject.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/net/minecraft/server/KeyedObject.java
-@@ -0,0 +0,0 @@
-+package net.minecraft.server;
-+
-+import net.minecraft.resources.MinecraftKey;
-+
-+public interface KeyedObject {
-+    MinecraftKey getMinecraftKey();
-+    default String getMinecraftKeyString() {
-+        MinecraftKey key = getMinecraftKey();
-+        return key != null ? key.toString() : null;
-+    }
-+}
-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 @@ import org.bukkit.event.player.PlayerTeleportEvent;
- import org.bukkit.plugin.PluginManager;
- // CraftBukkit end
- 
--public abstract class Entity implements INamableTileEntity, ICommandListener {
-+public abstract class Entity implements INamableTileEntity, ICommandListener, net.minecraft.server.KeyedObject { // Paper
- 
-     // CraftBukkit start
-     private static final int CURRENT_LEVEL = 2;
-@@ -0,0 +0,0 @@ public abstract class Entity implements INamableTileEntity, ICommandListener {
-         return true;
-     }
- 
-+    // Paper start
-+    private MinecraftKey entityKey;
-+    private String entityKeyString;
-+
-+    @Override
-+    public MinecraftKey getMinecraftKey() {
-+        if (entityKey == null) {
-+            this.entityKey = EntityTypes.getName(this.getEntityType());
-+            this.entityKeyString = this.entityKey != null ? this.entityKey.toString() : null;
-+        }
-+        return entityKey;
-+    }
-+
-+    @Override
-+    public String getMinecraftKeyString() {
-+        getMinecraftKey(); // Try to load if it doesn't exists. see: https://github.com/PaperMC/Paper/issues/1280
-+        return entityKeyString;
-+    }
-     @Nullable
-     public final String getSaveID() {
-         EntityTypes<?> entitytypes = this.getEntityType();
-         MinecraftKey minecraftkey = EntityTypes.getName(entitytypes);
- 
--        return entitytypes.a() && minecraftkey != null ? minecraftkey.toString() : null;
-+        return entitytypes != null && entitytypes.isPersistable() ? getMinecraftKeyString() : null;
-+        // Paper end
-     }
- 
-     protected abstract void loadData(NBTTagCompound nbttagcompound);
-diff --git a/src/main/java/net/minecraft/world/entity/EntityTypes.java b/src/main/java/net/minecraft/world/entity/EntityTypes.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/EntityTypes.java
-+++ b/src/main/java/net/minecraft/world/entity/EntityTypes.java
-@@ -0,0 +0,0 @@ public class EntityTypes<T extends Entity> {
-         }
-     }
- 
-+    public boolean isPersistable() { return a(); } // Paper - OBFHELPER
-     public boolean a() {
-         return this.bi;
-     }
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/TileEntity.java b/src/main/java/net/minecraft/world/level/block/entity/TileEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/TileEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/TileEntity.java
-@@ -0,0 +0,0 @@ import org.bukkit.inventory.InventoryHolder;
- 
- import org.spigotmc.CustomTimingsHandler; // Spigot
- 
--public abstract class TileEntity {
-+public abstract class TileEntity implements net.minecraft.server.KeyedObject { // Paper
- 
-     public CustomTimingsHandler tickTimer = org.bukkit.craftbukkit.SpigotTimings.getTileEntityTimings(this); // Spigot
-     // CraftBukkit start - data containers
-@@ -0,0 +0,0 @@ public abstract class TileEntity {
-     public CraftPersistentDataContainer persistentDataContainer;
-     // CraftBukkit end
-     private static final Logger LOGGER = LogManager.getLogger();
--    private final TileEntityTypes<?> tileType;
-+    private final TileEntityTypes<?> tileType; public TileEntityTypes getTileEntityType() { return tileType; } // Paper - OBFHELPER
-     @Nullable
-     protected World world;
-     protected BlockPosition position;
-@@ -0,0 +0,0 @@ public abstract class TileEntity {
-         this.tileType = tileentitytypes;
-     }
- 
-+    // Paper start
-+    private String tileEntityKeyString = null;
-+    private MinecraftKey tileEntityKey = null;
-+
-+    @Override
-+    public MinecraftKey getMinecraftKey() {
-+        if (tileEntityKey == null) {
-+            tileEntityKey = TileEntityTypes.a(this.getTileEntityType());
-+            tileEntityKeyString = tileEntityKey != null ? tileEntityKey.toString() : null;
-+        }
-+        return tileEntityKey;
-+    }
-+
-+    @Override
-+    public String getMinecraftKeyString() {
-+        getMinecraftKey(); // Try to load if it doesn't exists.
-+        return tileEntityKeyString;
-+    }
-+    // Paper end
-+
-     @Nullable
-     public World getWorld() {
-         return this.world;

Spigot-Server-Patches/Add-Mob-lookAt-API.patch

@@ -1,127 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <blake.galbreath@gmail.com>
-Date: Fri, 14 May 2021 13:42:17 -0500
-Subject: [PATCH] Add Mob#lookAt API
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/EntityInsentient.java b/src/main/java/net/minecraft/world/entity/EntityInsentient.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/EntityInsentient.java
-+++ b/src/main/java/net/minecraft/world/entity/EntityInsentient.java
-@@ -0,0 +0,0 @@ public abstract class EntityInsentient extends EntityLiving {
- 
-     protected void mobTick() {}
- 
-+    public int getMaxHeadXRot() { return O(); } // Paper - OBFHELPER
-     public int O() {
-         return 40;
-     }
- 
-+    public int getMaxHeadYRot() { return Q(); } // Paper - OBFHELPER
-     public int Q() {
-         return 75;
-     }
- 
-+    public int getHeadRotSpeed() { return ep(); } // Paper - OBFHELPER
-     public int ep() {
-         return 10;
-     }
-diff --git a/src/main/java/net/minecraft/world/entity/ai/control/ControllerLook.java b/src/main/java/net/minecraft/world/entity/ai/control/ControllerLook.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ai/control/ControllerLook.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/control/ControllerLook.java
-@@ -0,0 +0,0 @@ public class ControllerLook {
-         this.a = entityinsentient;
-     }
- 
-+    public void lookAt(Vec3D vec3d) { a(vec3d); } // Paper - OBFHELPER
-     public void a(Vec3D vec3d) {
-         this.a(vec3d.x, vec3d.y, vec3d.z);
-     }
- 
-+    // Paper start
-+    public void lookAt(Entity entity) {
-+        this.lookAt(entity.locX(), getWantedY(entity), entity.locZ());
-+    }
-+    // Paper end
-+
-+    public void lookAt(Entity entity, float f, float f1) { a(entity, f, f1); } // Paper - OBFHELPER
-     public void a(Entity entity, float f, float f1) {
-         this.a(entity.locX(), b(entity), entity.locZ(), f, f1);
-     }
- 
-+    public void lookAt(double d0, double d1, double d2) { a(d0, d1, d2); } // Paper - OBFHELPER
-     public void a(double d0, double d1, double d2) {
-         this.a(d0, d1, d2, (float) this.a.ep(), (float) this.a.O());
-     }
- 
-+    public void lookAt(double d0, double d1, double d2, float f, float f1) { a(d0, d1, d2, f, f1); } // Paper - OBFHELPER
-     public void a(double d0, double d1, double d2, float f, float f1) {
-         this.e = d0;
-         this.f = d1;
-@@ -0,0 +0,0 @@ public class ControllerLook {
-         return f + f4;
-     }
- 
-+    public static double getWantedY(Entity entity) { return b(entity); } // Paper - OBFHELPER
-     private static double b(Entity entity) {
-         return entity instanceof EntityLiving ? entity.getHeadY() : (entity.getBoundingBox().minY + entity.getBoundingBox().maxY) / 2.0D;
-     }
-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 boolean isInDaylight() {
-         return getHandle().isInDaylight();
-     }
-+
-+    @Override
-+    public void lookAt(@org.jetbrains.annotations.NotNull org.bukkit.Location location) {
-+        com.google.common.base.Preconditions.checkNotNull(location, "location cannot be null");
-+        com.google.common.base.Preconditions.checkArgument(location.getWorld().equals(getWorld()), "location in a different world");
-+        getHandle().getControllerLook().lookAt(location.getX(), location.getY(), location.getZ());
-+    }
-+
-+    @Override
-+    public void lookAt(@org.jetbrains.annotations.NotNull org.bukkit.Location location, float headRotationSpeed, float maxHeadPitch) {
-+        com.google.common.base.Preconditions.checkNotNull(location, "location cannot be null");
-+        com.google.common.base.Preconditions.checkArgument(location.getWorld().equals(getWorld()), "location in a different world");
-+        getHandle().getControllerLook().lookAt(location.getX(), location.getY(), location.getZ(), headRotationSpeed, maxHeadPitch);
-+    }
-+
-+    @Override
-+    public void lookAt(@org.jetbrains.annotations.NotNull org.bukkit.entity.Entity entity) {
-+        com.google.common.base.Preconditions.checkNotNull(entity, "entity cannot be null");
-+        com.google.common.base.Preconditions.checkArgument(entity.getWorld().equals(getWorld()), "entity in a different world");
-+        getHandle().getControllerLook().lookAt(((CraftEntity) entity).getHandle());
-+    }
-+
-+    @Override
-+    public void lookAt(@org.jetbrains.annotations.NotNull org.bukkit.entity.Entity entity, float headRotationSpeed, float maxHeadPitch) {
-+        com.google.common.base.Preconditions.checkNotNull(entity, "entity cannot be null");
-+        com.google.common.base.Preconditions.checkArgument(entity.getWorld().equals(getWorld()), "entity in a different world");
-+        getHandle().getControllerLook().lookAt(((CraftEntity) entity).getHandle(), headRotationSpeed, maxHeadPitch);
-+    }
-+
-+    @Override
-+    public void lookAt(double x, double y, double z) {
-+        getHandle().getControllerLook().lookAt(x, y, z);
-+    }
-+
-+    @Override
-+    public void lookAt(double x, double y, double z, float headRotationSpeed, float maxHeadPitch) {
-+        getHandle().getControllerLook().lookAt(x, y, z, headRotationSpeed, maxHeadPitch);
-+    }
-+
-+    @Override
-+    public int getHeadRotationSpeed() {
-+        return getHandle().getHeadRotSpeed();
-+    }
-+
-+    @Override
-+    public int getMaxHeadPitch() {
-+        return getHandle().getMaxHeadXRot();
-+    }
-     // Paper end
- }

Spigot-Server-Patches/Add-More-Creeper-API.patch

@@ -1,49 +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/EntityCreeper.java b/src/main/java/net/minecraft/world/entity/monster/EntityCreeper.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/EntityCreeper.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/EntityCreeper.java
-@@ -0,0 +0,0 @@ public class EntityCreeper extends EntityMonster {
-     }
- 
-     public void ignite() {
--        this.datawatcher.set(EntityCreeper.d, true);
-+        // Paper start
-+        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.datawatcher.set(EntityCreeper.d, event.isIgnited());
-+            }
-+        }
-+        // Paper end
-     }
- 
-     public boolean canCauseHeadDrop() {
-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 EntityType getType() {
-         return EntityType.CREEPER;
-     }
-+
-+    // Paper start
-+    public void setIgnited(boolean ignited) {
-+        getHandle().setIgnited(ignited);
-+    }
-+
-+    public boolean isIgnited() {
-+        return getHandle().isIgnited();
-+    }
-+    // Paper end
- }

Spigot-Server-Patches/Add-OBSTRUCTED-reason-to-BedEnterResult.patch

@@ -1,21 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Thu, 24 Dec 2020 12:43:39 -0800
-Subject: [PATCH] Add OBSTRUCTED reason to BedEnterResult
-
-
-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 BedEnterResult.TOO_FAR_AWAY;
-                     case NOT_SAFE:
-                         return BedEnterResult.NOT_SAFE;
-+                        // Paper start
-+                    case OBSTRUCTED:
-+                        return BedEnterResult.OBSTRUCTED;
-+                        // Paper end
-                     default:
-                         return BedEnterResult.OTHER_PROBLEM;
-                 }

Spigot-Server-Patches/Add-PhantomPreSpawnEvent.patch

@@ -1,96 +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/EntityPhantom.java b/src/main/java/net/minecraft/world/entity/monster/EntityPhantom.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/EntityPhantom.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/EntityPhantom.java
-@@ -0,0 +0,0 @@ public class EntityPhantom extends EntityFlying implements IMonster {
-         }
- 
-         this.setSize(nbttagcompound.getInt("Size"));
-+        // Paper start
-+        if (nbttagcompound.hasUUID("Paper.SpawningEntity")) {
-+            this.spawningEntity = nbttagcompound.getUUID("Paper.SpawningEntity");
-+        }
-+        // Paper end
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class EntityPhantom extends EntityFlying implements IMonster {
-         nbttagcompound.setInt("AY", this.d.getY());
-         nbttagcompound.setInt("AZ", this.d.getZ());
-         nbttagcompound.setInt("Size", this.getSize());
-+        // Paper start
-+        if (this.spawningEntity != null) {
-+            nbttagcompound.setUUID("Paper.SpawningEntity", this.spawningEntity);
-+        }
-+        // Paper end
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class EntityPhantom extends EntityFlying implements IMonster {
-         return entitysize.a(f);
-     }
- 
-+    // Paper start
-+    java.util.UUID spawningEntity;
-+
-+    public java.util.UUID getSpawningEntity() {
-+        return spawningEntity;
-+    }
-+    public void setSpawningEntity(java.util.UUID entity) { this.spawningEntity = entity; }
-+    // Paper end
-+
-     class b extends PathfinderGoal {
- 
-         private final PathfinderTargetCondition b;
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/MobSpawnerPhantom.java b/src/main/java/net/minecraft/world/level/levelgen/MobSpawnerPhantom.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/levelgen/MobSpawnerPhantom.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/MobSpawnerPhantom.java
-@@ -0,0 +0,0 @@ import java.util.Iterator;
- import java.util.Random;
- import net.minecraft.core.BlockPosition;
- import net.minecraft.nbt.NBTTagCompound;
-+import net.minecraft.server.MCUtil;
- import net.minecraft.server.level.EntityPlayer;
- import net.minecraft.server.level.WorldServer;
- import net.minecraft.stats.ServerStatisticManager;
-@@ -0,0 +0,0 @@ public class MobSpawnerPhantom implements MobSpawner {
-                                             int k = 1 + random.nextInt(difficultydamagescaler.a().a() + 1);
- 
-                                             for (int l = 0; l < k; ++l) {
-+                                                // Paper start
-+                                                com.destroystokyo.paper.event.entity.PhantomPreSpawnEvent event = new com.destroystokyo.paper.event.entity.PhantomPreSpawnEvent(MCUtil.toLocation(worldserver, blockposition1), ((EntityPlayer) entityhuman).getBukkitEntity(), org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL);
-+                                                if (!event.callEvent()) {
-+                                                    if (event.shouldAbortSpawn()) {
-+                                                        break;
-+                                                    }
-+                                                    continue;
-+                                                }
-+                                                // Paper end
-                                                 EntityPhantom entityphantom = (EntityPhantom) EntityTypes.PHANTOM.a((World) worldserver);
--
-+                                                entityphantom.setSpawningEntity(entityhuman.getUniqueID()); // Paper
-                                                 entityphantom.setPositionRotation(blockposition1, 0.0F, 0.0F);
-                                                 groupdataentity = entityphantom.prepare(worldserver, difficultydamagescaler, EnumMobSpawn.NATURAL, groupdataentity, (NBTTagCompound) null);
-                                                 worldserver.addAllEntities(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 {
-     public EntityType getType() {
-         return EntityType.PHANTOM;
-     }
-+
-+    // Paper start
-+    public java.util.UUID getSpawningEntity() {
-+        return getHandle().getSpawningEntity();
-+    }
-+    // Paper end
- }

Spigot-Server-Patches/Add-PlayerArmorChangeEvent.patch

@@ -1,43 +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/EntityLiving.java b/src/main/java/net/minecraft/world/entity/EntityLiving.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/EntityLiving.java
-+++ b/src/main/java/net/minecraft/world/entity/EntityLiving.java
-@@ -0,0 +0,0 @@
- package net.minecraft.world.entity;
- 
-+import com.destroystokyo.paper.event.player.PlayerArmorChangeEvent; // Paper
- import com.google.common.base.Objects;
- import com.google.common.collect.ImmutableList;
- import com.google.common.collect.ImmutableMap;
-@@ -0,0 +0,0 @@ public abstract class EntityLiving extends Entity {
-             ItemStack itemstack1 = this.getEquipment(enumitemslot);
- 
-             if (!ItemStack.matches(itemstack1, itemstack)) {
-+                // Paper start - PlayerArmorChangeEvent
-+                if (this instanceof EntityPlayer && enumitemslot.getType() == EnumItemSlot.Function.ARMOR) {
-+                    final org.bukkit.inventory.ItemStack oldItem = CraftItemStack.asBukkitCopy(itemstack);
-+                    final org.bukkit.inventory.ItemStack newItem = CraftItemStack.asBukkitCopy(itemstack1);
-+                    new PlayerArmorChangeEvent((Player) this.getBukkitEntity(), PlayerArmorChangeEvent.SlotType.valueOf(enumitemslot.name()), oldItem, newItem).callEvent();
-+                }
-+                // Paper end
-                 if (map == null) {
-                     map = Maps.newEnumMap(EnumItemSlot.class);
-                 }
-diff --git a/src/main/java/net/minecraft/world/entity/EnumItemSlot.java b/src/main/java/net/minecraft/world/entity/EnumItemSlot.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/EnumItemSlot.java
-+++ b/src/main/java/net/minecraft/world/entity/EnumItemSlot.java
-@@ -0,0 +0,0 @@ public enum EnumItemSlot {
-         this.j = s;
-     }
- 
-+    public EnumItemSlot.Function getType() { return this.a(); } // Paper - OBFHELPER
-     public EnumItemSlot.Function a() {
-         return this.g;
-     }

Spigot-Server-Patches/Add-PlayerAttackEntityCooldownResetEvent.patch

@@ -1,28 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: nossr50 <nossr50@gmail.com>
-Date: Thu, 26 Mar 2020 19:44:50 -0700
-Subject: [PATCH] Add PlayerAttackEntityCooldownResetEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/EntityLiving.java b/src/main/java/net/minecraft/world/entity/EntityLiving.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/EntityLiving.java
-+++ b/src/main/java/net/minecraft/world/entity/EntityLiving.java
-@@ -0,0 +0,0 @@ public abstract class EntityLiving extends Entity {
- 
-             EntityDamageEvent event = CraftEventFactory.handleLivingEntityDamageEvent(this, damagesource, originalDamage, hardHatModifier, blockingModifier, armorModifier, resistanceModifier, magicModifier, absorptionModifier, hardHat, blocking, armor, resistance, magic, absorption);
-             if (damagesource.getEntity() instanceof EntityHuman) {
--                ((EntityHuman) damagesource.getEntity()).resetAttackCooldown(); // Moved from EntityHuman in order to make the cooldown reset get called after the damage event is fired
-+                // Paper start - PlayerAttackEntityCooldownResetEvent
-+                if (damagesource.getEntity() instanceof EntityPlayer) {
-+                    EntityPlayer player = (EntityPlayer) damagesource.getEntity();
-+                    if (new com.destroystokyo.paper.event.player.PlayerAttackEntityCooldownResetEvent(player.getBukkitEntity(), this.getBukkitEntity(), player.getAttackCooldown(0F)).callEvent()) {
-+                        player.resetAttackCooldown();
-+                    }
-+                } else {
-+                    ((EntityHuman) damagesource.getEntity()).resetAttackCooldown();
-+                }
-+                // Paper end
-             }
-             if (event.isCancelled()) {
-                 return false;

Spigot-Server-Patches/Add-PlayerConnectionCloseEvent.patch

@@ -1,82 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Sun, 7 Oct 2018 12:05:28 -0700
-Subject: [PATCH] Add PlayerConnectionCloseEvent
-
-This event is invoked when a player has disconnected. It is guaranteed that,
-if the server is in online-mode, that the provided uuid and username have been
-validated.
-
-The event is invoked for players who have not yet logged into the world, whereas
-PlayerQuitEvent is only invoked on players who have logged into the world.
-
-The event is invoked for players who have already logged into the world,
-although whether or not the player exists in the world at the time of
-firing is undefined. (That is, whether the plugin can retrieve a Player object
-using the event parameters is undefined). However, it is guaranteed that this
-event is invoked AFTER PlayerQuitEvent, if the player has already logged into
-the world.
-
-This event is guaranteed to never fire unless AsyncPlayerPreLoginEvent has
-been called beforehand, and this event may not be called in parallel with
-AsyncPlayerPreLoginEvent for the same connection.
-
-Cancelling the AsyncPlayerPreLoginEvent guarantees the corresponding
-PlayerConnectionCloseEvent is never called.
-
-The event may be invoked asynchronously or synchronously. As it stands,
-it is never invoked asynchronously. However, plugins should check
-Event#isAsynchronous to be future-proof.
-
-On purpose, the deprecated PlayerPreLoginEvent event is left out of the
-API spec for this event. Plugins should not be using that event, and
-how PlayerPreLoginEvent interacts with PlayerConnectionCloseEvent
-is undefined.
-
-diff --git a/src/main/java/net/minecraft/network/NetworkManager.java b/src/main/java/net/minecraft/network/NetworkManager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/NetworkManager.java
-+++ b/src/main/java/net/minecraft/network/NetworkManager.java
-@@ -0,0 +0,0 @@ public class NetworkManager extends SimpleChannelInboundHandler<Packet<?>> {
-                     this.j().a(new ChatMessage("multiplayer.disconnect.generic"));
-                 }
-                 this.packetQueue.clear(); // Free up packet queue.
-+                // Paper start - Add PlayerConnectionCloseEvent
-+                final PacketListener packetListener = this.j();
-+                if (packetListener instanceof PlayerConnection) {
-+                    /* Player was logged in */
-+                    final PlayerConnection playerConnection = (PlayerConnection) packetListener;
-+                    new com.destroystokyo.paper.event.player.PlayerConnectionCloseEvent(playerConnection.player.getUniqueID(),
-+                        playerConnection.player.getName(), ((java.net.InetSocketAddress)socketAddress).getAddress(), false).callEvent();
-+                } else if (packetListener instanceof LoginListener) {
-+                    /* Player is login stage */
-+                    final LoginListener loginListener = (LoginListener) packetListener;
-+                    switch (loginListener.getLoginState()) {
-+                        case READY_TO_ACCEPT:
-+                        case DELAY_ACCEPT:
-+                        case ACCEPTED:
-+                            final com.mojang.authlib.GameProfile profile = loginListener.getGameProfile(); /* Should be non-null at this stage */
-+                            new com.destroystokyo.paper.event.player.PlayerConnectionCloseEvent(profile.getId(), profile.getName(),
-+                                ((java.net.InetSocketAddress)socketAddress).getAddress(), false).callEvent();
-+                    }
-+                }
-+                // Paper end
-             }
- 
-         }
-diff --git a/src/main/java/net/minecraft/server/network/LoginListener.java b/src/main/java/net/minecraft/server/network/LoginListener.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/LoginListener.java
-+++ b/src/main/java/net/minecraft/server/network/LoginListener.java
-@@ -0,0 +0,0 @@ public class LoginListener implements PacketLoginInListener {
-     private final byte[] e = new byte[4];
-     private final MinecraftServer server;
-     public final NetworkManager networkManager;
--    private LoginListener.EnumProtocolState g;
-+    private LoginListener.EnumProtocolState g; public final LoginListener.EnumProtocolState getLoginState() { return this.g; }; // Paper - OBFHELPER
-     private int h;
--    private GameProfile i; private void setGameProfile(final GameProfile profile) { this.i = profile; } private GameProfile getGameProfile() { return this.i; } // Paper - OBFHELPER
-+    private GameProfile i; private void setGameProfile(final GameProfile profile) { this.i = profile; } public GameProfile getGameProfile() { return this.i; } // Paper - OBFHELPER
-     private final String j;
-     private SecretKey loginKey;
-     private EntityPlayer l;

Spigot-Server-Patches/Add-PlayerInitialSpawnEvent.patch

@@ -1,48 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Steve Anton <anxuiz.nx@gmail.com>
-Date: Thu, 3 Mar 2016 00:09:38 -0600
-Subject: [PATCH] Add PlayerInitialSpawnEvent
-
-For modifying a player's initial spawn location as they join the server
-
-This is a duplicate API from spigot, so use our duplicate subclass and
-improve setPosition to use raw
-
-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 {
- 
-         // Spigot start - spawn location event
-         Player bukkitPlayer = entityplayer.getBukkitEntity();
--        org.spigotmc.event.player.PlayerSpawnLocationEvent ev = new org.spigotmc.event.player.PlayerSpawnLocationEvent(bukkitPlayer, bukkitPlayer.getLocation());
-+        org.spigotmc.event.player.PlayerSpawnLocationEvent ev = new com.destroystokyo.paper.event.player.PlayerInitialSpawnEvent(bukkitPlayer, bukkitPlayer.getLocation()); // Paper use our duplicate event
-         cserver.getPluginManager().callEvent(ev);
- 
-         Location loc = ev.getSpawnLocation();
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
- 
-         entityplayer.spawnIn(worldserver1);
-         entityplayer.playerInteractManager.a((WorldServer) entityplayer.world);
--        entityplayer.setLocation(loc.getX(), loc.getY(), loc.getZ(), loc.getYaw(), loc.getPitch());
-+        // Paper start - set raw so we aren't fully joined to the world (not added to chunk or world)
-+        entityplayer.setPositionRaw(loc.getX(), loc.getY(), loc.getZ());
-+        entityplayer.setYawPitch(loc.getYaw(), loc.getPitch());
-+        // Paper end
-         // Spigot end
- 
-         // CraftBukkit - Moved message to after join
-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 INamableTileEntity, ICommandListener, ne
-         return d1 * d1 + d2 * d2 + d3 * d3 < d0 * d0;
-     }
- 
--    protected void setYawPitch(float f, float f1) {
-+    public void setYawPitch(float f, float f1) { // Paper - protected -> public
-         // CraftBukkit start - yaw was sometimes set to NaN, so we need to set it back to 0
-         if (Float.isNaN(f)) {
-             f = 0;

Spigot-Server-Patches/Add-PlayerItemCooldownEvent.patch

@@ -1,38 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Nassim Jahnke <nassim@njahnke.dev>
-Date: Tue, 25 Aug 2020 13:48:33 +0200
-Subject: [PATCH] Add PlayerItemCooldownEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/item/ItemCooldownPlayer.java b/src/main/java/net/minecraft/world/item/ItemCooldownPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/item/ItemCooldownPlayer.java
-+++ b/src/main/java/net/minecraft/world/item/ItemCooldownPlayer.java
-@@ -0,0 +0,0 @@ package net.minecraft.world.item;
- import net.minecraft.network.protocol.game.PacketPlayOutSetCooldown;
- import net.minecraft.server.level.EntityPlayer;
- 
-+import io.papermc.paper.event.player.PlayerItemCooldownEvent; // Paper
-+
- public class ItemCooldownPlayer extends ItemCooldown {
- 
--    private final EntityPlayer a;
-+    private final EntityPlayer a; public EntityPlayer getEntityPlayer() { return a; } // Paper - OBFHELPER
- 
-     public ItemCooldownPlayer(EntityPlayer entityplayer) {
-         this.a = entityplayer;
-     }
- 
-+    // Paper start
-+    @Override
-+    public void setCooldown(Item item, int ticks) {
-+        PlayerItemCooldownEvent event = new PlayerItemCooldownEvent(getEntityPlayer().getBukkitEntity(), org.bukkit.craftbukkit.util.CraftMagicNumbers.getMaterial(item), ticks);
-+        if (event.callEvent()) {
-+            super.setCooldown(item, event.getCooldown());
-+        }
-+    }
-+    // Paper end
-+
-     @Override
-     protected void b(Item item, int i) {
-         super.b(item, i);

Spigot-Server-Patches/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/PlayerConnection.java b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/PlayerConnection.java
-+++ b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-                             boolean flag = d8 > 0.0D;
- 
-                             if (this.player.isOnGround() && !packetplayinflying.b() && flag) {
--                                this.player.jump();
-+                                // Paper start - Add player jump event
-+                                Player player = this.getPlayer();
-+                                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 (packetplayinflying.hasPos) {
-+                                    to.setX(packetplayinflying.x);
-+                                    to.setY(packetplayinflying.y);
-+                                    to.setZ(packetplayinflying.z);
-+                                }
-+
-+                                // If the packet contains look information then we update the To location with the correct Yaw & Pitch.
-+                                if (packetplayinflying.hasLook) {
-+                                    to.setYaw(packetplayinflying.yaw);
-+                                    to.setPitch(packetplayinflying.pitch);
-+                                }
-+
-+                                com.destroystokyo.paper.event.player.PlayerJumpEvent event = new com.destroystokyo.paper.event.player.PlayerJumpEvent(player, from, to);
-+
-+                                if (event.callEvent()) {
-+                                    this.player.jump();
-+                                } else {
-+                                    from = event.getFrom();
-+                                    this.internalTeleport(from.getX(), from.getY(), from.getZ(), from.getYaw(), from.getPitch(), Collections.emptySet());
-+                                    return;
-+                                }
-+                                // Paper end
-                             }
- 
-                             this.player.move(EnumMoveType.PLAYER, new Vec3D(d7, d8, d9));

Spigot-Server-Patches/Add-PlayerKickEvent-causes.patch

@@ -1,393 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Sat, 15 May 2021 20:30:45 -0700
-Subject: [PATCH] Add PlayerKickEvent causes
-
-
-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 IAsyncTaskHandlerReentrant<TickTas
-                 EntityPlayer entityplayer = (EntityPlayer) iterator.next();
- 
-                 if (!whitelist.isWhitelisted(entityplayer.getProfile())) {
--                    entityplayer.playerConnection.disconnect(org.spigotmc.SpigotConfig.whitelistMessage); // Paper - use configurable message
-+                    entityplayer.playerConnection.disconnect(org.spigotmc.SpigotConfig.whitelistMessage, org.bukkit.event.player.PlayerKickEvent.Cause.WHITELIST); // Paper - use configurable message
-                 }
-             }
- 
-diff --git a/src/main/java/net/minecraft/server/commands/CommandBan.java b/src/main/java/net/minecraft/server/commands/CommandBan.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/commands/CommandBan.java
-+++ b/src/main/java/net/minecraft/server/commands/CommandBan.java
-@@ -0,0 +0,0 @@ public class CommandBan {
-                 EntityPlayer entityplayer = commandlistenerwrapper.getServer().getPlayerList().getPlayer(gameprofile.getId());
- 
-                 if (entityplayer != null) {
--                    entityplayer.playerConnection.disconnect(new ChatMessage("multiplayer.disconnect.banned"));
-+                    entityplayer.playerConnection.disconnect(new ChatMessage("multiplayer.disconnect.banned"), org.bukkit.event.player.PlayerKickEvent.Cause.BANNED); // Paper - kick event cause
-                 }
-             }
-         }
-diff --git a/src/main/java/net/minecraft/server/commands/CommandBanIp.java b/src/main/java/net/minecraft/server/commands/CommandBanIp.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/commands/CommandBanIp.java
-+++ b/src/main/java/net/minecraft/server/commands/CommandBanIp.java
-@@ -0,0 +0,0 @@ public class CommandBanIp {
-             while (iterator.hasNext()) {
-                 EntityPlayer entityplayer = (EntityPlayer) iterator.next();
- 
--                entityplayer.playerConnection.disconnect(new ChatMessage("multiplayer.disconnect.ip_banned"));
-+                entityplayer.playerConnection.disconnect(new ChatMessage("multiplayer.disconnect.ip_banned"), org.bukkit.event.player.PlayerKickEvent.Cause.IP_BANNED); // Paper - kick event cause
-             }
- 
-             return list.size();
-diff --git a/src/main/java/net/minecraft/server/commands/CommandKick.java b/src/main/java/net/minecraft/server/commands/CommandKick.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/commands/CommandKick.java
-+++ b/src/main/java/net/minecraft/server/commands/CommandKick.java
-@@ -0,0 +0,0 @@ public class CommandKick {
-         while (iterator.hasNext()) {
-             EntityPlayer entityplayer = (EntityPlayer) iterator.next();
- 
--            entityplayer.playerConnection.disconnect(ichatbasecomponent);
-+            entityplayer.playerConnection.disconnect(ichatbasecomponent, org.bukkit.event.player.PlayerKickEvent.Cause.KICK_COMMAND); // Paper - kick event cause
-             commandlistenerwrapper.sendMessage(new ChatMessage("commands.kick.success", new Object[]{entityplayer.getScoreboardDisplayName(), ichatbasecomponent}), true);
-         }
- 
-diff --git a/src/main/java/net/minecraft/server/network/PlayerConnection.java b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/PlayerConnection.java
-+++ b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-         if (this.B && !this.player.isSleeping()) {
-             if (++this.C > 80) {
-                 PlayerConnection.LOGGER.warn("{} was kicked for floating too long!", this.player.getDisplayName().getString());
--                this.disconnect(com.destroystokyo.paper.PaperConfig.flyingKickPlayerMessage); // Paper - use configurable kick message
-+                this.disconnect(com.destroystokyo.paper.PaperConfig.flyingKickPlayerMessage, org.bukkit.event.player.PlayerKickEvent.Cause.FLYING_PLAYER); // Paper - use configurable kick message & kick event cause
-                 return;
-             }
-         } else {
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-             if (this.D && this.player.getRootVehicle().getRidingPassenger() == this.player) {
-                 if (++this.E > 80) {
-                     PlayerConnection.LOGGER.warn("{} was kicked for floating a vehicle too long!", this.player.getDisplayName().getString());
--                    this.disconnect(com.destroystokyo.paper.PaperConfig.flyingKickVehicleMessage); // Paper - use configurable kick message
-+                    this.disconnect(com.destroystokyo.paper.PaperConfig.flyingKickVehicleMessage, org.bukkit.event.player.PlayerKickEvent.Cause.FLYING_VEHICLE); // Paper - use configurable kick message & kick event cause
-                     return;
-                 }
-             } else {
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-         if (this.isPendingPing()) {
-             if (!this.processedDisconnect && elapsedTime >= KEEPALIVE_LIMIT) { // check keepalive limit, don't fire if already disconnected
-                 PlayerConnection.LOGGER.warn("{} was kicked due to keepalive timeout!", this.player.getName()); // more info
--                this.disconnect(new ChatMessage("disconnect.timeout", new Object[0]));
-+                this.disconnect(new ChatMessage("disconnect.timeout", new Object[0]), org.bukkit.event.player.PlayerKickEvent.Cause.TIMEOUT); // Paper - kick event cause
-             }
-         } else {
-             if (elapsedTime >= 15000L) { // 15 seconds
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
- 
-         if (this.player.F() > 0L && this.minecraftServer.getIdleTimeout() > 0 && SystemUtils.getMonotonicMillis() - this.player.F() > (long) (this.minecraftServer.getIdleTimeout() * 1000 * 60)) {
-             this.player.resetIdleTimer(); // CraftBukkit - SPIGOT-854
--            this.disconnect(new ChatMessage("multiplayer.disconnect.idling"));
-+            this.disconnect(new ChatMessage("multiplayer.disconnect.idling"), org.bukkit.event.player.PlayerKickEvent.Cause.IDLING); // Paper - kick event cause
-         }
- 
-     }
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
- 
-     public void disconnect(String s) {
-         // Paper start
--        this.disconnect(PaperAdventure.LEGACY_SECTION_UXRC.deserialize(s));
-+        this.disconnect(PaperAdventure.LEGACY_SECTION_UXRC.deserialize(s), org.bukkit.event.player.PlayerKickEvent.Cause.UNKNOWN);
-+    }
-+
-+    public void disconnect(String s, PlayerKickEvent.Cause cause) {
-+        this.disconnect(PaperAdventure.LEGACY_SECTION_UXRC.deserialize(s), cause);
-     }
- 
-     public void disconnect(final IChatBaseComponent reason) {
--        this.disconnect(PaperAdventure.asAdventure(reason));
-+        this.disconnect(PaperAdventure.asAdventure(reason), org.bukkit.event.player.PlayerKickEvent.Cause.UNKNOWN);
-+    }
-+
-+    public void disconnect(final IChatBaseComponent reason, PlayerKickEvent.Cause cause) {
-+        this.disconnect(PaperAdventure.asAdventure(reason), cause);
-     }
- 
--    public void disconnect(net.kyori.adventure.text.Component reason) {
-+    public void disconnect(net.kyori.adventure.text.Component reason, org.bukkit.event.player.PlayerKickEvent.Cause cause) {
-         // Paper end
-         // CraftBukkit start - fire PlayerKickEvent
-         if (this.processedDisconnect) {
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-         }
-         net.kyori.adventure.text.Component leaveMessage = net.kyori.adventure.text.Component.translatable("multiplayer.player.left", net.kyori.adventure.text.format.NamedTextColor.YELLOW, this.player.getBukkitEntity().displayName()); // Paper - Adventure
- 
--        PlayerKickEvent event = new PlayerKickEvent(this.server.getPlayer(this.player), reason, leaveMessage); // Paper - Adventure
-+        PlayerKickEvent event = new PlayerKickEvent(this.server.getPlayer(this.player), reason, leaveMessage, cause); // Paper - Adventure & kick event reason
- 
-         if (this.server.getServer().isRunning()) {
-             this.server.getPluginManager().callEvent(event);
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-     public void a(PacketPlayInVehicleMove packetplayinvehiclemove) {
-         PlayerConnectionUtils.ensureMainThread(packetplayinvehiclemove, this, this.player.getWorldServer());
-         if (b(packetplayinvehiclemove)) {
--            this.disconnect(new ChatMessage("multiplayer.disconnect.invalid_vehicle_movement"));
-+            this.disconnect(new ChatMessage("multiplayer.disconnect.invalid_vehicle_movement"), org.bukkit.event.player.PlayerKickEvent.Cause.INVALID_VEHICLE_MOVEMENT); // Paper - kick event cause
-         } else {
-             Entity entity = this.player.getRootVehicle();
- 
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-         // PlayerConnectionUtils.ensureMainThread(packetplayintabcomplete, this, this.player.getWorldServer()); // Paper - run this async
-         // CraftBukkit start
-         if (tabSpamLimiter.addAndGet(com.destroystokyo.paper.PaperConfig.tabSpamIncrement) > com.destroystokyo.paper.PaperConfig.tabSpamLimit && !this.minecraftServer.getPlayerList().isOp(this.player.getProfile())) { // Paper start - split and make configurable
--            minecraftServer.scheduleOnMain(() -> this.disconnect(new ChatMessage("disconnect.spam", new Object[0]))); // Paper
-+            minecraftServer.scheduleOnMain(() -> this.disconnect(new ChatMessage("disconnect.spam", new Object[0]), org.bukkit.event.player.PlayerKickEvent.Cause.SPAM)); // Paper - kick event cause
-             return;
-         }
-         // Paper start
-         String str = packetplayintabcomplete.c(); int index = -1;
-         if (str.length() > 64 && ((index = str.indexOf(' ')) == -1 || index >= 64)) {
--            minecraftServer.scheduleOnMain(() -> this.disconnect(new ChatMessage("disconnect.spam", new Object[0]))); // Paper
-+            minecraftServer.scheduleOnMain(() -> this.disconnect(new ChatMessage("disconnect.spam", new Object[0]), org.bukkit.event.player.PlayerKickEvent.Cause.SPAM)); // Paper - kick event cause
-             return;
-         }
-         // Paper end
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-         // Paper start - validate pick item position
-         if (!(packetplayinpickitem.b() >= 0 && packetplayinpickitem.b() < this.player.inventory.items.size())) {
-             PlayerConnection.LOGGER.warn("{} tried to set an invalid carried item", this.player.getDisplayName().getString());
--            this.disconnect("Invalid hotbar selection (Hacking?)");
-+            this.disconnect("Invalid hotbar selection (Hacking?)", org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_ACTION); // Paper - kick event cause
-             return;
-         }
-         this.player.inventory.c(packetplayinpickitem.b()); // Paper - Diff above if changed
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-             NBTTagList pageList = testStack.getTag().getList("pages", 8);
-             if (pageList.size() > 100) {
-                 PlayerConnection.LOGGER.warn(this.player.getName() + " tried to send a book with too many pages");
--                minecraftServer.scheduleOnMain(() -> this.disconnect("Book too large!"));
-+                minecraftServer.scheduleOnMain(() -> this.disconnect("Book too large!", org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_ACTION)); // Paper - kick event cause
-                 return;
-             }
-             long byteTotal = 0;
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-                 int byteLength = testString.getBytes(java.nio.charset.StandardCharsets.UTF_8).length;
-                 if (byteLength > 256 * 4) {
-                     PlayerConnection.LOGGER.warn(this.player.getName() + " tried to send a book with with a page too large!");
--                    minecraftServer.scheduleOnMain(() -> this.disconnect("Book too large!"));
-+                    minecraftServer.scheduleOnMain(() -> this.disconnect("Book too large!", org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_ACTION)); // Paper - kick event cause
-                     return;
-                 }
-                 byteTotal += byteLength;
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
- 
-             if (byteTotal > byteAllowed) {
-                 PlayerConnection.LOGGER.warn(this.player.getName() + " tried to send too large of a book. Book Size: " + byteTotal + " - Allowed:  "+ byteAllowed + " - Pages: " + pageList.size());
--                minecraftServer.scheduleOnMain(() -> this.disconnect("Book too large!"));
-+                minecraftServer.scheduleOnMain(() -> this.disconnect("Book too large!", org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_ACTION)); // Paper - kick event cause
-                 return;
-             }
-         }
-         // Paper end
-         // CraftBukkit start
-         if (this.lastBookTick + 20 > MinecraftServer.currentTick) {
--            this.disconnect("Book edited too quickly!");
-+            this.disconnect("Book edited too quickly!", org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_ACTION); // Paper - kick event cause
-             return;
-         }
-         this.lastBookTick = MinecraftServer.currentTick;
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-     public void a(PacketPlayInFlying packetplayinflying) {
-         PlayerConnectionUtils.ensureMainThread(packetplayinflying, this, this.player.getWorldServer());
-         if (b(packetplayinflying)) {
--            this.disconnect(new ChatMessage("multiplayer.disconnect.invalid_player_movement"));
-+            this.disconnect(new ChatMessage("multiplayer.disconnect.invalid_player_movement"), org.bukkit.event.player.PlayerKickEvent.Cause.INVALID_PLAYER_MOVEMENT); // Paper - kick event cause
-         } else {
-             WorldServer worldserver = this.player.getWorldServer();
- 
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-                         this.dropCount++;
-                         if (this.dropCount >= 20) {
-                             LOGGER.warn(this.player.getName() + " dropped their items too quickly!");
--                            this.disconnect("You dropped your items too quickly (Hacking?)");
-+                            this.disconnect("You dropped your items too quickly (Hacking?)", org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_ACTION); // Paper - kick event cause
-                             return;
-                         }
-                     }
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-             this.player.resetIdleTimer();
-         } else {
-             PlayerConnection.LOGGER.warn("{} tried to set an invalid carried item", this.player.getDisplayName().getString());
--            this.disconnect("Invalid hotbar selection (Hacking?)"); // CraftBukkit
-+            this.disconnect("Invalid hotbar selection (Hacking?)", org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_ACTION); // CraftBukkit // Paper - kick event cause
-         }
-     }
- 
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-                         Waitable waitable = new Waitable() {
-                             @Override
-                             protected Object evaluate() {
--                                PlayerConnection.this.disconnect(new ChatMessage("multiplayer.disconnect.illegal_characters"));
-+                                PlayerConnection.this.disconnect(new ChatMessage("multiplayer.disconnect.illegal_characters"), org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_CHARACTERS); // Paper - kick event cause
-                                 return null;
-                             }
-                         };
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-                             throw new RuntimeException(e);
-                         }
-                     } else {
--                        this.disconnect(new ChatMessage("multiplayer.disconnect.illegal_characters"));
-+                        this.disconnect(new ChatMessage("multiplayer.disconnect.illegal_characters"), org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_CHARACTERS); // Paper - kick event cause
-                     }
-                     // CraftBukkit end
-                     return;
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-                     Waitable waitable = new Waitable() {
-                         @Override
-                         protected Object evaluate() {
--                            PlayerConnection.this.disconnect(new ChatMessage("disconnect.spam"));
-+                            PlayerConnection.this.disconnect(new ChatMessage("disconnect.spam"), org.bukkit.event.player.PlayerKickEvent.Cause.SPAM); // Paper - kick event cause
-                             return null;
-                         }
-                     };
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-                         throw new RuntimeException(e);
-                     }
-                 } else {
--                    this.disconnect(new ChatMessage("disconnect.spam"));
-+                    this.disconnect(new ChatMessage("disconnect.spam"), org.bukkit.event.player.PlayerKickEvent.Cause.SPAM); // Paper - kick event cause
-                 }
-                 // CraftBukkit end
-             }
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-         // Spigot Start
-         if ( entity == player && !player.isSpectator() )
-         {
--            disconnect( "Cannot interact with self!" );
-+            disconnect( "Cannot interact with self!", org.bukkit.event.player.PlayerKickEvent.Cause.SELF_INTERACTION ); // Paper - kick event cause
-             return;
-         }
-         // Spigot End
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-                     // CraftBukkit end
-                 } else if (packetplayinuseentity.b() == PacketPlayInUseEntity.EnumEntityUseAction.ATTACK) {
-                     if (entity instanceof EntityItem || entity instanceof EntityExperienceOrb || entity instanceof EntityArrow || (entity == this.player && !player.isSpectator())) { // CraftBukkit
--                        this.disconnect(new ChatMessage("multiplayer.disconnect.invalid_entity_attacked"));
-+                        this.disconnect(new ChatMessage("multiplayer.disconnect.invalid_entity_attacked"), org.bukkit.event.player.PlayerKickEvent.Cause.INVALID_ENTITY_ATTACKED); // Paper - kick event cause
-                         PlayerConnection.LOGGER.warn("Player {} tried to attack an invalid entity", this.player.getDisplayName().getString());
-                         return;
-                     }
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-         // Paper start
-         if (!Bukkit.isPrimaryThread()) {
-             if (recipeSpamPackets.addAndGet(PaperConfig.autoRecipeIncrement) > PaperConfig.autoRecipeLimit) {
--                minecraftServer.scheduleOnMain(() -> this.disconnect(new ChatMessage("disconnect.spam", new Object[0]))); // Paper
-+                minecraftServer.scheduleOnMain(() -> this.disconnect(new ChatMessage("disconnect.spam", new Object[0]), org.bukkit.event.player.PlayerKickEvent.Cause.SPAM)); // Paper - kick event cause
-                 return;
-             }
-         }
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-         } else if (!this.isExemptPlayer()) {
-             // Paper start - This needs to be handled on the main thread for plugins
-             minecraftServer.scheduleOnMain(() -> {
--            this.disconnect(new ChatMessage("disconnect.timeout"));
-+            this.disconnect(new ChatMessage("disconnect.timeout"), org.bukkit.event.player.PlayerKickEvent.Cause.TIMEOUT); // Paper - kick event cause
-             });
-             // Paper end
-         }
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-                 }
-             } catch (Exception ex) {
-                 PlayerConnection.LOGGER.error("Couldn\'t register custom payload", ex);
--                this.disconnect("Invalid payload REGISTER!");
-+                this.disconnect("Invalid payload REGISTER!", org.bukkit.event.player.PlayerKickEvent.Cause.INVALID_PAYLOAD); // Paper - kick event cause
-             }
-         } else if (packetplayincustompayload.tag.equals(CUSTOM_UNREGISTER)) {
-             try {
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-                 }
-             } catch (Exception ex) {
-                 PlayerConnection.LOGGER.error("Couldn\'t unregister custom payload", ex);
--                this.disconnect("Invalid payload UNREGISTER!");
-+                this.disconnect("Invalid payload UNREGISTER!", org.bukkit.event.player.PlayerKickEvent.Cause.INVALID_PAYLOAD); // Paper - kick event cause
-             }
-         } else {
-             try {
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-                 server.getMessenger().dispatchIncomingMessage(player.getBukkitEntity(), packetplayincustompayload.tag.toString(), data);
-             } catch (Exception ex) {
-                 PlayerConnection.LOGGER.error("Couldn\'t dispatch custom payload", ex);
--                this.disconnect("Invalid custom payload!");
-+                this.disconnect("Invalid custom payload!", org.bukkit.event.player.PlayerKickEvent.Cause.INVALID_PAYLOAD); // Paper - kick event cause
-             }
-         }
- 
-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 {
-         while (iterator.hasNext()) {
-             entityplayer = (EntityPlayer) iterator.next();
-             savePlayerFile(entityplayer); // CraftBukkit - Force the player's inventory to be saved
--            entityplayer.playerConnection.disconnect(new ChatMessage("multiplayer.disconnect.duplicate_login", new Object[0]));
-+            entityplayer.playerConnection.disconnect(new ChatMessage("multiplayer.disconnect.duplicate_login", new Object[0]), org.bukkit.event.player.PlayerKickEvent.Cause.DUPLICATE_LOGIN); // Paper - kick event cause
-         }
- 
-         // Instead of kicking then returning, we need to store the kick reason
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-     public void shutdown(boolean isRestarting) {
-         // CraftBukkit start - disconnect safely
-         for (EntityPlayer player : this.players) {
--            if (isRestarting) player.playerConnection.disconnect(org.spigotmc.SpigotConfig.restartMessage); else // Paper
--            player.playerConnection.disconnect(this.server.server.shutdownMessage()); // CraftBukkit - add custom shutdown message // Paper - Adventure
-+            if (isRestarting) player.playerConnection.disconnect(org.spigotmc.SpigotConfig.restartMessage, org.bukkit.event.player.PlayerKickEvent.Cause.UNKNOWN); else // Paper - kick event cause (cause is never used here)
-+            player.playerConnection.disconnect(this.server.server.shutdownMessage(), org.bukkit.event.player.PlayerKickEvent.Cause.UNKNOWN); // CraftBukkit - add custom shutdown message // Paper - Adventure & KickEventCause (cause is never used here)
-         }
-         // CraftBukkit end
- 
-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 {
-         org.spigotmc.AsyncCatcher.catchOp("player kick"); // Spigot
-         if (getHandle().playerConnection == null) return;
- 
--        getHandle().playerConnection.disconnect(message == null ? "" : message);
-+        getHandle().playerConnection.disconnect(message == null ? "" : message, org.bukkit.event.player.PlayerKickEvent.Cause.PLUGIN); // Paper - kick event cause
-     }
- 
-     // Paper start
-     @Override
-     public void kick(final net.kyori.adventure.text.Component message) {
-+        kick(message, org.bukkit.event.player.PlayerKickEvent.Cause.PLUGIN);
-+    }
-+
-+    @Override
-+    public void kick(net.kyori.adventure.text.Component message, org.bukkit.event.player.PlayerKickEvent.Cause cause) {
-         org.spigotmc.AsyncCatcher.catchOp("player kick");
-         final PlayerConnection connection = this.getHandle().playerConnection;
-         if (connection != null) {
--            connection.disconnect(message == null ? net.kyori.adventure.text.Component.empty() : message);
-+            connection.disconnect(message == null ? net.kyori.adventure.text.Component.empty() : message, cause);
-         }
-     }
-     // Paper end
-diff --git a/src/main/java/org/spigotmc/RestartCommand.java b/src/main/java/org/spigotmc/RestartCommand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/spigotmc/RestartCommand.java
-+++ b/src/main/java/org/spigotmc/RestartCommand.java
-@@ -0,0 +0,0 @@ public class RestartCommand extends Command
-             // Kick all players
-             for ( EntityPlayer p : com.google.common.collect.ImmutableList.copyOf( MinecraftServer.getServer().getPlayerList().players ) )
-             {
--                p.playerConnection.disconnect(SpigotConfig.restartMessage);
-+                p.playerConnection.disconnect(SpigotConfig.restartMessage, org.bukkit.event.player.PlayerKickEvent.Cause.RESTART_COMMAND); // Paper - kick event reason (cause is never used))
-             }
-             // Give the socket a chance to send the packets
-             try

Spigot-Server-Patches/Add-PlayerShearBlockEvent.patch

@@ -1,109 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Josh Roy <10731363+JRoy@users.noreply.github.com>
-Date: Thu, 27 Aug 2020 15:02:48 -0400
-Subject: [PATCH] Add PlayerShearBlockEvent
-
-
-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 BlockBase implements IMaterial {
- 
-     }
- 
--    public static void a(World world, BlockPosition blockposition, ItemStack itemstack) {
-+    public static void a(World world, BlockPosition blockposition, ItemStack itemstack) { dropItem(world, blockposition, itemstack); } public static void dropItem(World world, BlockPosition blockposition, ItemStack itemstack) { // Paper - OBFHELPER
-         if (!world.isClientSide && !itemstack.isEmpty() && world.getGameRules().getBoolean(GameRules.DO_TILE_DROPS)) {
-             float f = 0.5F;
-             double d0 = (double) (world.random.nextFloat() * 0.5F) + 0.25D;
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockBeehive.java b/src/main/java/net/minecraft/world/level/block/BlockBeehive.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockBeehive.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockBeehive.java
-@@ -0,0 +0,0 @@
- package net.minecraft.world.level.block;
- 
-+import io.papermc.paper.event.block.PlayerShearBlockEvent; // Paper - PlayerShearBlockEvent namespace conflicts
-+
- import java.util.Iterator;
- import java.util.List;
- import java.util.Random;
-@@ -0,0 +0,0 @@ import net.minecraft.core.BlockPosition;
- import net.minecraft.core.EnumDirection;
- import net.minecraft.nbt.NBTBase;
- import net.minecraft.nbt.NBTTagCompound;
-+import net.minecraft.server.MCUtil;
- import net.minecraft.server.level.EntityPlayer;
- import net.minecraft.sounds.SoundCategory;
- import net.minecraft.sounds.SoundEffects;
-@@ -0,0 +0,0 @@ public class BlockBeehive extends BlockTileEntity {
- 
-         if (i >= 5) {
-             if (itemstack.getItem() == Items.SHEARS) {
-+                // Paper start - Add PlayerShearBlockEvent
-+                PlayerShearBlockEvent event = new PlayerShearBlockEvent((org.bukkit.entity.Player) entityhuman.getBukkitEntity(), MCUtil.toBukkitBlock(world, blockposition), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemstack), (enumhand == EnumHand.OFF_HAND ? org.bukkit.inventory.EquipmentSlot.OFF_HAND : org.bukkit.inventory.EquipmentSlot.HAND), new java.util.ArrayList<>());
-+                event.getDrops().add(org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(new ItemStack(Items.HONEYCOMB, 3)));
-+                if (!event.callEvent()) {
-+                    return EnumInteractionResult.PASS;
-+                }
-+                // Paper end
-                 world.playSound(entityhuman, entityhuman.locX(), entityhuman.locY(), entityhuman.locZ(), SoundEffects.BLOCK_BEEHIVE_SHEAR, SoundCategory.NEUTRAL, 1.0F, 1.0F);
--                a(world, blockposition);
-+                // Paper start - Add PlayerShearBlockEvent
-+                for (org.bukkit.inventory.ItemStack item : event.getDrops()) {
-+                    dropItem(world, blockposition, org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(item));
-+                }
-+                // Paper end
-                 itemstack.damage(1, entityhuman, (entityhuman1) -> {
-                     entityhuman1.broadcastItemBreak(enumhand);
-                 });
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockPumpkin.java b/src/main/java/net/minecraft/world/level/block/BlockPumpkin.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockPumpkin.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockPumpkin.java
-@@ -0,0 +0,0 @@ package net.minecraft.world.level.block;
- 
- import net.minecraft.core.BlockPosition;
- import net.minecraft.core.EnumDirection;
-+import net.minecraft.server.MCUtil;
- import net.minecraft.sounds.SoundCategory;
- import net.minecraft.sounds.SoundEffects;
- import net.minecraft.world.EnumHand;
-@@ -0,0 +0,0 @@ import net.minecraft.world.level.block.state.BlockBase;
- import net.minecraft.world.level.block.state.IBlockData;
- import net.minecraft.world.phys.MovingObjectPositionBlock;
- 
-+import io.papermc.paper.event.block.PlayerShearBlockEvent; // Paper - PlayerShearBlockEvent namespace conflicts
-+
- public class BlockPumpkin extends BlockStemmed {
- 
-     protected BlockPumpkin(BlockBase.Info blockbase_info) {
-@@ -0,0 +0,0 @@ public class BlockPumpkin extends BlockStemmed {
- 
-         if (itemstack.getItem() == Items.SHEARS) {
-             if (!world.isClientSide) {
-+                // Paper start - Add PlayerShearBlockEvent
-+                PlayerShearBlockEvent event = new PlayerShearBlockEvent((org.bukkit.entity.Player) entityhuman.getBukkitEntity(), MCUtil.toBukkitBlock(world, blockposition), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(itemstack), (enumhand == EnumHand.OFF_HAND ? org.bukkit.inventory.EquipmentSlot.OFF_HAND : org.bukkit.inventory.EquipmentSlot.HAND), new java.util.ArrayList<>());
-+                event.getDrops().add(org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(new ItemStack(Items.PUMPKIN_SEEDS, 4)));
-+                if (!event.callEvent()) {
-+                    return EnumInteractionResult.PASS;
-+                }
-+                // Paper end
-                 EnumDirection enumdirection = movingobjectpositionblock.getDirection();
-                 EnumDirection enumdirection1 = enumdirection.n() == EnumDirection.EnumAxis.Y ? entityhuman.getDirection().opposite() : enumdirection;
- 
-                 world.playSound((EntityHuman) null, blockposition, SoundEffects.BLOCK_PUMPKIN_CARVE, SoundCategory.BLOCKS, 1.0F, 1.0F);
-                 world.setTypeAndData(blockposition, (IBlockData) Blocks.CARVED_PUMPKIN.getBlockData().set(BlockPumpkinCarved.a, enumdirection1), 11);
--                EntityItem entityitem = new EntityItem(world, (double) blockposition.getX() + 0.5D + (double) enumdirection1.getAdjacentX() * 0.65D, (double) blockposition.getY() + 0.1D, (double) blockposition.getZ() + 0.5D + (double) enumdirection1.getAdjacentZ() * 0.65D, new ItemStack(Items.PUMPKIN_SEEDS, 4));
-+                // Paper start - Add PlayerShearBlockEvent
-+                for (org.bukkit.inventory.ItemStack item : event.getDrops()) {
-+                EntityItem entityitem = new EntityItem(world, (double) blockposition.getX() + 0.5D + (double) enumdirection1.getAdjacentX() * 0.65D, (double) blockposition.getY() + 0.1D, (double) blockposition.getZ() + 0.5D + (double) enumdirection1.getAdjacentZ() * 0.65D, org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(item));
-+                // Paper end
- 
-                 entityitem.setMot(0.05D * (double) enumdirection1.getAdjacentX() + world.random.nextDouble() * 0.02D, 0.05D, 0.05D * (double) enumdirection1.getAdjacentZ() + world.random.nextDouble() * 0.02D);
-                 world.addEntity(entityitem);
-+                } // Paper - Add PlayerShearBlockEvent
-                 itemstack.damage(1, entityhuman, (entityhuman1) -> {
-                     entityhuman1.broadcastItemBreak(enumhand);
-                 });

Spigot-Server-Patches/Add-PlayerUseUnknownEntityEvent.patch

@@ -1,40 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jedediah Smith <jedediah@silencegreys.com>
-Date: Sat, 2 Apr 2016 05:09:16 -0400
-Subject: [PATCH] Add PlayerUseUnknownEntityEvent
-
-
-diff --git a/src/main/java/net/minecraft/network/protocol/game/PacketPlayInUseEntity.java b/src/main/java/net/minecraft/network/protocol/game/PacketPlayInUseEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/protocol/game/PacketPlayInUseEntity.java
-+++ b/src/main/java/net/minecraft/network/protocol/game/PacketPlayInUseEntity.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.phys.Vec3D;
- 
- public class PacketPlayInUseEntity implements Packet<PacketListenerPlayIn> {
- 
--    private int a;
-+    private int a; public int getEntityId() { return this.a; } // Paper - add accessor
-     private PacketPlayInUseEntity.EnumEntityUseAction action;
-     private Vec3D c;
-     private EnumHand d;
-diff --git a/src/main/java/net/minecraft/server/network/PlayerConnection.java b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/PlayerConnection.java
-+++ b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-                 }
-             }
-         }
-+        // Paper start - fire event
-+        else {
-+            this.server.getPluginManager().callEvent(new com.destroystokyo.paper.event.player.PlayerUseUnknownEntityEvent(
-+                this.getPlayer(),
-+                packetplayinuseentity.getEntityId(),
-+                packetplayinuseentity.b() == PacketPlayInUseEntity.EnumEntityUseAction.ATTACK,
-+                packetplayinuseentity.c() == EnumHand.MAIN_HAND ? EquipmentSlot.HAND : EquipmentSlot.OFF_HAND
-+            ));
-+        }
-+        // Paper end
- 
-     }
- 

Spigot-Server-Patches/Add-Plugin-Tickets-to-API-Chunk-Methods.patch

@@ -1,129 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Tue, 9 Jun 2020 03:33:03 -0400
-Subject: [PATCH] Add Plugin Tickets to API Chunk Methods
-
-Like previous versions, plugins loading chunks kept them loaded until
-they garbage collected to avoid constant spamming of chunk loads
-
-This adds tickets to a few more places so that they can be unloaded.
-
-Additionally, this drops their ticket level to BORDER so they wont be ticking
-so they will just sit inactive instead.
-
-Using .loadChunk to keep a chunk ticking was a horrible idea for upstream
-when we have TWO methods that are able to do that already in the API.
-
-Also reduce their collection count down to a maximum of 1 second. Barely
-anyone knows what chunk-gc is in bukkit.yml as its less relevant now, and
-since this wasn't spigot behavior, this is safe to mostly ignore (unless someone
-wants it to collect even faster, they can restore that setting back to 1 instead of 20+)
-
-Not adding it to .getType() though to keep behavior consistent with vanilla for performance reasons.
-
-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 {
-         ambientSpawn = configuration.getInt("spawn-limits.ambient");
-         console.autosavePeriod = configuration.getInt("ticks-per.autosave");
-         warningState = WarningState.value(configuration.getString("settings.deprecated-verbose"));
--        TicketType.PLUGIN.loadPeriod = configuration.getInt("chunk-gc.period-in-ticks");
-+        TicketType.PLUGIN.loadPeriod = Math.min(20, configuration.getInt("chunk-gc.period-in-ticks")); // Paper - cap plugin loads to 1 second
-         minimumAPI = configuration.getString("settings.minimum-api");
-         loadIcon();
-     }
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-         waterAmbientSpawn = configuration.getInt("spawn-limits.water-ambient");
-         ambientSpawn = configuration.getInt("spawn-limits.ambient");
-         warningState = WarningState.value(configuration.getString("settings.deprecated-verbose"));
--        TicketType.PLUGIN.loadPeriod = configuration.getInt("chunk-gc.period-in-ticks");
-+        TicketType.PLUGIN.loadPeriod = Math.min(20, configuration.getInt("chunk-gc.period-in-ticks")); // Paper - cap plugin loads to 1 second
-         minimumAPI = configuration.getString("settings.minimum-api");
-         printSaveWarning = false;
-         console.autosavePeriod = configuration.getInt("ticks-per.autosave");
-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 @@ import net.minecraft.network.protocol.game.PacketPlayOutCustomSoundEffect;
- import net.minecraft.network.protocol.game.PacketPlayOutUpdateTime;
- import net.minecraft.network.protocol.game.PacketPlayOutWorldEvent;
- import net.minecraft.resources.MinecraftKey;
-+import net.minecraft.server.MCUtil;
- import net.minecraft.server.level.ChunkMapDistance;
- import net.minecraft.server.level.PlayerChunk;
- import net.minecraft.server.level.PlayerChunkMap;
-@@ -0,0 +0,0 @@ public class CraftWorld implements World {
- 
-     @Override
-     public Chunk getChunkAt(int x, int z) {
--        return this.world.getChunkProvider().getChunkAt(x, z, true).bukkitChunk;
-+        // Paper start - add ticket to hold chunk for a little while longer if plugin accesses it
-+        net.minecraft.world.level.chunk.Chunk chunk = world.getChunkProvider().getChunkAtIfLoadedImmediately(x, z);
-+        if (chunk == null) {
-+            addTicket(x, z);
-+            chunk = this.world.getChunkProvider().getChunkAt(x, z, true);
-+        }
-+        return chunk.bukkitChunk;
-+        // Paper end
-+    }
-+
-+    // Paper start
-+    private void addTicket(int x, int z) {
-+        MCUtil.MAIN_EXECUTOR.execute(() -> world.getChunkProvider().addTicket(TicketType.PLUGIN, new ChunkCoordIntPair(x, z), 0, Unit.INSTANCE)); // Paper
-     }
-+    // Paper end
- 
-     @Override
-     public Chunk getChunkAt(Block block) {
-@@ -0,0 +0,0 @@ public class CraftWorld implements World {
-     public boolean unloadChunkRequest(int x, int z) {
-         org.spigotmc.AsyncCatcher.catchOp("chunk unload"); // Spigot
-         if (isChunkLoaded(x, z)) {
--            world.getChunkProvider().removeTicket(TicketType.PLUGIN, new ChunkCoordIntPair(x, z), 1, Unit.INSTANCE);
-+            world.getChunkProvider().removeTicket(TicketType.PLUGIN, new ChunkCoordIntPair(x, z), 0, Unit.INSTANCE); // Paper
-         }
- 
-         return true;
-@@ -0,0 +0,0 @@ public class CraftWorld implements World {
-         org.spigotmc.AsyncCatcher.catchOp("chunk load"); // Spigot
-         // Paper start - Optimize this method
-         ChunkCoordIntPair chunkPos = new ChunkCoordIntPair(x, z);
-+        IChunkAccess immediate = world.getChunkProvider().getChunkAtIfLoadedImmediately(x, z); // Paper
-+        if (immediate != null) return true; // Paper
- 
-         if (!generate) {
--            IChunkAccess immediate = world.getChunkProvider().getChunkAtImmediately(x, z);
-+
-+            //IChunkAccess immediate = world.getChunkProvider().getChunkAtImmediately(x, z); // Paper
-             if (immediate == null) {
-                 immediate = world.getChunkProvider().playerChunkMap.getUnloadingChunk(x, z);
-             }
-@@ -0,0 +0,0 @@ public class CraftWorld implements World {
-                 if (!(immediate instanceof ProtoChunkExtension) && !(immediate instanceof net.minecraft.world.level.chunk.Chunk)) {
-                     return false; // not full status
-                 }
--                world.getChunkProvider().addTicket(TicketType.PLUGIN, chunkPos, 1, Unit.INSTANCE);
-+                world.getChunkProvider().addTicket(TicketType.PLUGIN, chunkPos, 0, Unit.INSTANCE); // Paper
-                 world.getChunkAt(x, z); // make sure we're at ticket level 32 or lower
-                 return true;
-             }
-@@ -0,0 +0,0 @@ public class CraftWorld implements World {
-             // we do this so we do not re-read the chunk data on disk
-         }
- 
--        world.getChunkProvider().addTicket(TicketType.PLUGIN, chunkPos, 1, Unit.INSTANCE);
-+        world.getChunkProvider().addTicket(TicketType.PLUGIN, chunkPos, 0, Unit.INSTANCE); // Paper
-         world.getChunkProvider().getChunkAt(x, z, ChunkStatus.FULL, true);
-         return true;
-         // Paper end
-@@ -0,0 +0,0 @@ public class CraftWorld implements World {
-         }
-         return this.world.getChunkProvider().getChunkAtAsynchronously(x, z, gen, urgent).thenComposeAsync((either) -> {
-             net.minecraft.world.level.chunk.Chunk chunk = (net.minecraft.world.level.chunk.Chunk) either.left().orElse(null);
-+            if (chunk != null) addTicket(x, z); // Paper
-             return CompletableFuture.completedFuture(chunk == null ? null : chunk.getBukkitChunk());
-         }, net.minecraft.server.MinecraftServer.getServer());
-     }

Spigot-Server-Patches/Add-PrepareResultEvent.patch

@@ -1,164 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <Blake.Galbreath@GMail.com>
-Date: Fri, 3 Jul 2020 11:58:56 -0500
-Subject: [PATCH] Add PrepareResultEvent
-
-Adds a new event for all crafting stations that generate a result slot item
-
-Anvil, Grindstone and Smithing now extend this event
-
-diff --git a/src/main/java/net/minecraft/world/inventory/Container.java b/src/main/java/net/minecraft/world/inventory/Container.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/inventory/Container.java
-+++ b/src/main/java/net/minecraft/world/inventory/Container.java
-@@ -0,0 +0,0 @@ public abstract class Container {
-         return nonnulllist;
-     }
- 
-+    public final void notifyListeners() { this.c(); } // Paper - OBFHELPER
-     public void c() {
-         int i;
- 
-diff --git a/src/main/java/net/minecraft/world/inventory/ContainerAnvil.java b/src/main/java/net/minecraft/world/inventory/ContainerAnvil.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/inventory/ContainerAnvil.java
-+++ b/src/main/java/net/minecraft/world/inventory/ContainerAnvil.java
-@@ -0,0 +0,0 @@ public class ContainerAnvil extends ContainerAnvilAbstract {
-         }
- 
-         this.e();
-+        org.bukkit.craftbukkit.event.CraftEventFactory.callPrepareResultEvent(this, 2); // Paper
-     }
- 
-     // CraftBukkit start
-diff --git a/src/main/java/net/minecraft/world/inventory/ContainerAnvilAbstract.java b/src/main/java/net/minecraft/world/inventory/ContainerAnvilAbstract.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/inventory/ContainerAnvilAbstract.java
-+++ b/src/main/java/net/minecraft/world/inventory/ContainerAnvilAbstract.java
-@@ -0,0 +0,0 @@ public abstract class ContainerAnvilAbstract extends Container {
-         super.a(iinventory);
-         if (iinventory == this.repairInventory) {
-             this.e();
-+            org.bukkit.craftbukkit.event.CraftEventFactory.callPrepareResultEvent(this, 2); // Paper
-         }
- 
-     }
-diff --git a/src/main/java/net/minecraft/world/inventory/ContainerCartography.java b/src/main/java/net/minecraft/world/inventory/ContainerCartography.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/inventory/ContainerCartography.java
-+++ b/src/main/java/net/minecraft/world/inventory/ContainerCartography.java
-@@ -0,0 +0,0 @@ public class ContainerCartography extends Container {
-             this.a(itemstack, itemstack1, itemstack2);
-         }
- 
-+        org.bukkit.craftbukkit.event.CraftEventFactory.callPrepareResultEvent(this, 2); // Paper
-     }
- 
-     private void a(ItemStack itemstack, ItemStack itemstack1, ItemStack itemstack2) {
-diff --git a/src/main/java/net/minecraft/world/inventory/ContainerGrindstone.java b/src/main/java/net/minecraft/world/inventory/ContainerGrindstone.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/inventory/ContainerGrindstone.java
-+++ b/src/main/java/net/minecraft/world/inventory/ContainerGrindstone.java
-@@ -0,0 +0,0 @@ public class ContainerGrindstone extends Container {
-         super.a(iinventory);
-         if (iinventory == this.craftInventory) {
-             this.e();
-+            org.bukkit.craftbukkit.event.CraftEventFactory.callPrepareResultEvent(this, 2); // Paper
-         }
- 
-     }
-diff --git a/src/main/java/net/minecraft/world/inventory/ContainerLoom.java b/src/main/java/net/minecraft/world/inventory/ContainerLoom.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/inventory/ContainerLoom.java
-+++ b/src/main/java/net/minecraft/world/inventory/ContainerLoom.java
-@@ -0,0 +0,0 @@ public class ContainerLoom extends Container {
-         }
- 
-         this.j();
--        this.c();
-+        //this.c(); // Paper - done below
-+        org.bukkit.craftbukkit.event.CraftEventFactory.callPrepareResultEvent(this, 3); // Paper
-     }
- 
-     @Override
-diff --git a/src/main/java/net/minecraft/world/inventory/ContainerSmithing.java b/src/main/java/net/minecraft/world/inventory/ContainerSmithing.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/inventory/ContainerSmithing.java
-+++ b/src/main/java/net/minecraft/world/inventory/ContainerSmithing.java
-@@ -0,0 +0,0 @@ public class ContainerSmithing extends ContainerAnvilAbstract {
-             // CraftBukkit end
-         }
- 
-+        org.bukkit.craftbukkit.event.CraftEventFactory.callPrepareResultEvent(this, 2); // Paper
-     }
- 
-     @Override
-diff --git a/src/main/java/net/minecraft/world/inventory/ContainerStonecutter.java b/src/main/java/net/minecraft/world/inventory/ContainerStonecutter.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/inventory/ContainerStonecutter.java
-+++ b/src/main/java/net/minecraft/world/inventory/ContainerStonecutter.java
-@@ -0,0 +0,0 @@ public class ContainerStonecutter extends Container {
-             this.a(iinventory, itemstack);
-         }
- 
-+        org.bukkit.craftbukkit.event.CraftEventFactory.callPrepareResultEvent(this, 1); // Paper
-     }
- 
-     private void a(IInventory iinventory, ItemStack itemstack) {
-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 PrepareAnvilEvent callPrepareAnvilEvent(InventoryView view, ItemStack item) {
--        PrepareAnvilEvent event = new PrepareAnvilEvent(view, CraftItemStack.asCraftMirror(item).clone());
--        event.getView().getPlayer().getServer().getPluginManager().callEvent(event);
-+    // Paper start - disable this method, handled below
-+    public static void callPrepareAnvilEvent(InventoryView view, ItemStack item) { // Paper - verify nothing uses return - handled below in PrepareResult
-+        PrepareAnvilEvent event = new PrepareAnvilEvent(view, CraftItemStack.asCraftMirror(item)); // Paper - remove clone
-+        //event.getView().getPlayer().getServer().getPluginManager().callEvent(event); // disable event
-         event.getInventory().setItem(2, event.getResult());
--        return event;
-+        //return event; // Paper
-     }
-+    // Paper end
- 
--    public static PrepareSmithingEvent callPrepareSmithingEvent(InventoryView view, ItemStack item) {
--        PrepareSmithingEvent event = new PrepareSmithingEvent(view, CraftItemStack.asCraftMirror(item).clone());
--        event.getView().getPlayer().getServer().getPluginManager().callEvent(event);
-+    // Paper start - disable this method, handled in callPrepareResultEvent
-+    public static void callPrepareSmithingEvent(InventoryView view, ItemStack item) { // Paper - verify nothing uses return - handled below in PrepareResult
-+        PrepareSmithingEvent event = new PrepareSmithingEvent(view, CraftItemStack.asCraftMirror(item)); // Paper - remove clone
-+        //event.getView().getPlayer().getServer().getPluginManager().callEvent(event); // Paper - disable event
-         event.getInventory().setItem(2, event.getResult());
--        return event;
-+        //return event; // Paper
-     }
-+    // Paper end
-+
-+    // Paper start - support specific overrides for prepare result
-+    public static void callPrepareResultEvent(Container container, int resultSlot) {
-+        com.destroystokyo.paper.event.inventory.PrepareResultEvent event;
-+        InventoryView view = container.getBukkitView();
-+        org.bukkit.inventory.ItemStack origItem = view.getTopInventory().getItem(resultSlot);
-+        CraftItemStack result = origItem != null ? CraftItemStack.asCraftCopy(origItem) : null;
-+        if (view.getTopInventory() instanceof org.bukkit.inventory.AnvilInventory) {
-+            event = new PrepareAnvilEvent(view, result);
-+        } else if (view.getTopInventory() instanceof org.bukkit.inventory.GrindstoneInventory) {
-+            event = new com.destroystokyo.paper.event.inventory.PrepareGrindstoneEvent(view, result);
-+        } else if (view.getTopInventory() instanceof org.bukkit.inventory.SmithingInventory) {
-+            event = new PrepareSmithingEvent(view, result);
-+        } else {
-+            event = new com.destroystokyo.paper.event.inventory.PrepareResultEvent(view, result);
-+        }
-+        event.callEvent();
-+        event.getInventory().setItem(resultSlot, event.getResult());
-+        container.notifyListeners();
-+    }
-+    // Paper end
- 
-     /**
-      * Mob spawner event.

Spigot-Server-Patches/Add-ProjectileCollideEvent.patch

@@ -1,109 +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
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/projectile/EntityArrow.java b/src/main/java/net/minecraft/world/entity/projectile/EntityArrow.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/projectile/EntityArrow.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/EntityArrow.java
-@@ -0,0 +0,0 @@ public abstract class EntityArrow extends IProjectile {
-                     }
-                 }
- 
-+                // Paper start - Call ProjectileCollideEvent
-+                // TODO: flag - noclip - call cancelled?
-+                if (object instanceof MovingObjectPositionEntity) {
-+                    com.destroystokyo.paper.event.entity.ProjectileCollideEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callProjectileCollideEvent(this, (MovingObjectPositionEntity)object);
-+                    if (event.isCancelled()) {
-+                        object = null;
-+                        movingobjectpositionentity = null;
-+                    }
-+                }
-+                // Paper end
-+
-                 if (object != null && !flag) {
-                     this.preOnHit((MovingObjectPosition) object); // CraftBukkit - projectile hit event
-                     this.impulse = true;
-diff --git a/src/main/java/net/minecraft/world/entity/projectile/EntityFireball.java b/src/main/java/net/minecraft/world/entity/projectile/EntityFireball.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/projectile/EntityFireball.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/EntityFireball.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.entity.EntityLiving;
- import net.minecraft.world.entity.EntityTypes;
- import net.minecraft.world.level.World;
- import net.minecraft.world.phys.MovingObjectPosition;
-+import net.minecraft.world.phys.MovingObjectPositionEntity;
- import net.minecraft.world.phys.Vec3D;
- 
- import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
-@@ -0,0 +0,0 @@ public abstract class EntityFireball extends IProjectile {
- 
-             MovingObjectPosition movingobjectposition = ProjectileHelper.a((Entity) this, this::a);
- 
--            if (movingobjectposition.getType() != MovingObjectPosition.EnumMovingObjectType.MISS) {
-+            // Paper start - Call ProjectileCollideEvent
-+            if (movingobjectposition instanceof MovingObjectPositionEntity) {
-+                com.destroystokyo.paper.event.entity.ProjectileCollideEvent event = CraftEventFactory.callProjectileCollideEvent(this, (MovingObjectPositionEntity)movingobjectposition);
-+                if (event.isCancelled()) {
-+                    movingobjectposition = null;
-+                }
-+            }
-+            // Paper end
-+
-+            if (movingobjectposition != null && movingobjectposition.getType() != MovingObjectPosition.EnumMovingObjectType.MISS) { // Paper - add null check in case cancelled
-                 this.preOnHit(movingobjectposition); // CraftBukkit - projectile hit event
- 
-                 // CraftBukkit start - Fire ProjectileHitEvent
-diff --git a/src/main/java/net/minecraft/world/entity/projectile/EntityProjectile.java b/src/main/java/net/minecraft/world/entity/projectile/EntityProjectile.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/projectile/EntityProjectile.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/EntityProjectile.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.level.block.entity.TileEntityEndGateway;
- import net.minecraft.world.level.block.state.IBlockData;
- import net.minecraft.world.phys.MovingObjectPosition;
- import net.minecraft.world.phys.MovingObjectPositionBlock;
-+import net.minecraft.world.phys.MovingObjectPositionEntity;
- import net.minecraft.world.phys.Vec3D;
- 
- public abstract class EntityProjectile extends IProjectile {
-@@ -0,0 +0,0 @@ public abstract class EntityProjectile extends IProjectile {
-         }
- 
-         if (movingobjectposition.getType() != MovingObjectPosition.EnumMovingObjectType.MISS && !flag) {
-+            // Paper start - Call ProjectileCollideEvent
-+            if (movingobjectposition instanceof MovingObjectPositionEntity) {
-+                com.destroystokyo.paper.event.entity.ProjectileCollideEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callProjectileCollideEvent(this, (MovingObjectPositionEntity)movingobjectposition);
-+                if (event.isCancelled()) {
-+                    movingobjectposition = null;
-+                }
-+            }
-+            if (movingobjectposition != null) {
-+            // Paper end
-             this.preOnHit(movingobjectposition); // CraftBukkit - projectile hit event
-+            } // Paper
-         }
- 
-         this.checkBlockCollisions();
-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 CraftItemStack.asNMSCopy(bitem);
-     }
- 
-+    // Paper start
-+    public static com.destroystokyo.paper.event.entity.ProjectileCollideEvent callProjectileCollideEvent(Entity entity, MovingObjectPositionEntity 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();
-         ProjectileLaunchEvent event = new ProjectileLaunchEvent(bukkitEntity);

Spigot-Server-Patches/Add-PufferFishStateChangeEvent.patch

@@ -1,50 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: HexedHero <6012891+HexedHero@users.noreply.github.com>
-Date: Mon, 10 May 2021 16:59:05 +0100
-Subject: [PATCH] Add PufferFishStateChangeEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/animal/EntityPufferFish.java b/src/main/java/net/minecraft/world/entity/animal/EntityPufferFish.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/animal/EntityPufferFish.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/EntityPufferFish.java
-@@ -0,0 +0,0 @@ public class EntityPufferFish extends EntityFish {
-     public void tick() {
-         if (!this.world.isClientSide && this.isAlive() && this.doAITick()) {
-             if (this.c > 0) {
-+                boolean increase = true; // Paper - Add PufferFishStateChangeEvent
-                 if (this.getPuffState() == 0) {
-+                    if (new io.papermc.paper.event.entity.PufferFishStateChangeEvent((org.bukkit.entity.PufferFish) getBukkitEntity(), 1).callEvent()) { // Paper - Add PufferFishStateChangeEvent
-                     this.playSound(SoundEffects.ENTITY_PUFFER_FISH_BLOW_UP, this.getSoundVolume(), this.dH());
-                     this.setPuffState(1);
-+                    } else { increase = false; } // Paper - Add PufferFishStateChangeEvent
-                 } else if (this.c > 40 && this.getPuffState() == 1) {
-+                    if (new io.papermc.paper.event.entity.PufferFishStateChangeEvent((org.bukkit.entity.PufferFish) getBukkitEntity(), 2).callEvent()) { // Paper - Add PufferFishStateChangeEvent
-                     this.playSound(SoundEffects.ENTITY_PUFFER_FISH_BLOW_UP, this.getSoundVolume(), this.dH());
-                     this.setPuffState(2);
-+                    } else { increase = false; } // Paper - Add PufferFishStateChangeEvent
-                 }
- 
-+                if (increase) { // Paper - Add PufferFishStateChangeEvent
-                 ++this.c;
-+                } // Paper - Add PufferFishStateChangeEvent
-             } else if (this.getPuffState() != 0) {
-+                boolean increase = true; // Paper - Add PufferFishStateChangeEvent
-                 if (this.d > 60 && this.getPuffState() == 2) {
-+                    if (new io.papermc.paper.event.entity.PufferFishStateChangeEvent((org.bukkit.entity.PufferFish) getBukkitEntity(), 1).callEvent()) { // Paper - Add PufferFishStateChangeEvent
-                     this.playSound(SoundEffects.ENTITY_PUFFER_FISH_BLOW_OUT, this.getSoundVolume(), this.dH());
-                     this.setPuffState(1);
-+                    } else { increase = false; } // Paper - Add PufferFishStateChangeEvent
-                 } else if (this.d > 100 && this.getPuffState() == 1) {
-+                    if (new io.papermc.paper.event.entity.PufferFishStateChangeEvent((org.bukkit.entity.PufferFish) getBukkitEntity(), 0).callEvent()) { // Paper - Add PufferFishStateChangeEvent
-                     this.playSound(SoundEffects.ENTITY_PUFFER_FISH_BLOW_OUT, this.getSoundVolume(), this.dH());
-                     this.setPuffState(0);
-+                    } else { increase = false; } // Paper - Add PufferFishStateChangeEvent
-                 }
- 
-+                if (increase) { // Paper - Add PufferFishStateChangeEvent
-                 ++this.d;
-+                } // Paper - Add PufferFishStateChangeEvent
-             }
-         }
- 

Spigot-Server-Patches/Add-Raw-Byte-ItemStack-Serialization.patch

@@ -1,102 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Mariell Hoversholm <proximyst@proximyst.com>
-Date: Thu, 30 Apr 2020 16:56:54 +0200
-Subject: [PATCH] Add Raw Byte ItemStack Serialization
-
-Serializes using NBT which is safer for server data migrations than bukkits format.
-
-diff --git a/src/main/java/net/minecraft/nbt/NBTCompressedStreamTools.java b/src/main/java/net/minecraft/nbt/NBTCompressedStreamTools.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/nbt/NBTCompressedStreamTools.java
-+++ b/src/main/java/net/minecraft/nbt/NBTCompressedStreamTools.java
-@@ -0,0 +0,0 @@ public class NBTCompressedStreamTools {
-         return nbttagcompound;
-     }
- 
-+    public static NBTTagCompound readNBT(InputStream inputstream) throws IOException { return a(inputstream); } // Paper - OBFHELPER
-     public static NBTTagCompound a(InputStream inputstream) throws IOException {
-         DataInputStream datainputstream = new DataInputStream(new BufferedInputStream(new GZIPInputStream(inputstream)));
-         Throwable throwable = null;
-@@ -0,0 +0,0 @@ public class NBTCompressedStreamTools {
- 
-     }
- 
-+    public static void writeNBT(NBTTagCompound nbttagcompound, OutputStream outputstream) throws IOException { a(nbttagcompound, outputstream); } // Paper - OBFHELPER
-     public static void a(NBTTagCompound nbttagcompound, OutputStream outputstream) throws IOException {
-         DataOutputStream dataoutputstream = new DataOutputStream(new BufferedOutputStream(new GZIPOutputStream(outputstream)));
-         Throwable throwable = null;
-diff --git a/src/main/java/net/minecraft/util/datafix/DataConverterRegistry.java b/src/main/java/net/minecraft/util/datafix/DataConverterRegistry.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/util/datafix/DataConverterRegistry.java
-+++ b/src/main/java/net/minecraft/util/datafix/DataConverterRegistry.java
-@@ -0,0 +0,0 @@ public class DataConverterRegistry {
-         return datafixerbuilder.build(SystemUtils.e());
-     }
- 
-+    public static DataFixer getDataFixer() { return a(); } // Paper - OBFHELPER
-     public static DataFixer a() {
-         return DataConverterRegistry.c;
-     }
-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 {
-         this.checkEmpty();
-     }
- 
-+    public static ItemStack fromCompound(NBTTagCompound nbttagcompound) { return a(nbttagcompound); } // Paper - OBFHELPER
-     public static ItemStack a(NBTTagCompound nbttagcompound) {
-         try {
-             return new ItemStack(nbttagcompound);
-diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
-+++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
-@@ -0,0 +0,0 @@ public final class CraftMagicNumbers implements UnsafeValues {
-     public boolean isSupportedApiVersion(String apiVersion) {
-         return apiVersion != null && SUPPORTED_API.contains(apiVersion);
-     }
-+
-+    @Override
-+    public byte[] serializeItem(ItemStack item) {
-+        Preconditions.checkNotNull(item, "null cannot be serialized");
-+        Preconditions.checkArgument(item.getType() != Material.AIR, "air cannot be serialized");
-+
-+        java.io.ByteArrayOutputStream outputStream = new java.io.ByteArrayOutputStream();
-+        NBTTagCompound compound = (item instanceof CraftItemStack ? ((CraftItemStack) item).getHandle() : CraftItemStack.asNMSCopy(item)).save(new NBTTagCompound());
-+        compound.setInt("DataVersion", getDataVersion());
-+        try {
-+            net.minecraft.nbt.NBTCompressedStreamTools.writeNBT(
-+                compound,
-+                outputStream
-+            );
-+        } catch (IOException ex) {
-+            throw new RuntimeException(ex);
-+        }
-+
-+        return outputStream.toByteArray();
-+    }
-+
-+    @Override
-+    public ItemStack deserializeItem(byte[] data) {
-+        Preconditions.checkNotNull(data, "null cannot be deserialized");
-+        Preconditions.checkArgument(data.length > 0, "cannot deserialize nothing");
-+
-+        try {
-+            NBTTagCompound compound = net.minecraft.nbt.NBTCompressedStreamTools.readNBT(
-+                new java.io.ByteArrayInputStream(data)
-+            );
-+            int dataVersion = compound.getInt("DataVersion");
-+
-+            Preconditions.checkArgument(dataVersion <= getDataVersion(), "Newer version! Server downgrades are not supported!");
-+            Dynamic<NBTBase> converted = DataConverterRegistry.getDataFixer().update(DataConverterTypes.ITEM_STACK, new Dynamic<NBTBase>(DynamicOpsNBT.a, compound), dataVersion, getDataVersion());
-+            return CraftItemStack.asCraftMirror(net.minecraft.world.item.ItemStack.fromCompound((NBTTagCompound) converted.getValue()));
-+        } catch (IOException ex) {
-+            com.destroystokyo.paper.util.SneakyThrow.sneaky(ex);
-+            throw new RuntimeException();
-+        }
-+    }
-     // Paper end
- 
-     /**

Spigot-Server-Patches/Add-StructureLocateEvent.patch

@@ -1,41 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: dfsek <dfsek@protonmail.com>
-Date: Wed, 16 Sep 2020 01:12:29 -0700
-Subject: [PATCH] Add StructureLocateEvent
-
-
-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 @@ package net.minecraft.world.level.chunk;
- 
- import com.google.common.collect.Lists;
- import com.mojang.serialization.Codec;
-+import io.papermc.paper.event.world.StructureLocateEvent; // Paper - Add import due to naming conflict.
- import java.util.BitSet;
- import java.util.Iterator;
- import java.util.List;
-@@ -0,0 +0,0 @@ public abstract class ChunkGenerator {
- 
-     @Nullable
-     public BlockPosition findNearestMapFeature(WorldServer worldserver, StructureGenerator<?> structuregenerator, BlockPosition blockposition, int i, boolean flag) {
-+        // Paper start
-+        org.bukkit.World world = worldserver.getWorld();
-+        org.bukkit.Location originLocation = new org.bukkit.Location(world, blockposition.getX(), blockposition.getY(), blockposition.getZ());
-+        StructureLocateEvent event = new StructureLocateEvent(world, originLocation, org.bukkit.StructureType.getStructureTypes().get(structuregenerator.i()), i, flag);
-+        if(!event.callEvent()) return null;
-+        // If event call set a final location, skip structure finding and just return set result.
-+        if(event.getResult() != null) return new BlockPosition(event.getResult().getBlockX(), event.getResult().getBlockY(), event.getResult().getBlockZ());
-+        // Get origin location (re)defined by event call.
-+        blockposition = new BlockPosition(event.getOrigin().getBlockX(), event.getOrigin().getBlockY(), event.getOrigin().getBlockZ());
-+        // Get world (re)defined by event call.
-+        worldserver = ((org.bukkit.craftbukkit.CraftWorld) event.getOrigin().getWorld()).getHandle();
-+        // Get radius and whether to find unexplored structures (re)defined by event call.
-+        i = event.getRadius();
-+        flag = event.shouldFindUnexplored();
-+        structuregenerator = StructureGenerator.a.get(event.getType().getName());
-+        // Paper end
-         if (!this.b.a(structuregenerator)) {
-             return null;
-         } else if (structuregenerator == StructureGenerator.STRONGHOLD) {

Spigot-Server-Patches/Add-TNTPrimeEvent.patch

@@ -1,148 +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/EntityEnderDragon.java b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EntityEnderDragon.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EntityEnderDragon.java
-+++ b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EntityEnderDragon.java
-@@ -0,0 +0,0 @@ import org.bukkit.craftbukkit.block.CraftBlock;
- import org.bukkit.event.entity.EntityExplodeEvent;
- import org.bukkit.event.entity.EntityRegainHealthEvent;
- // CraftBukkit end
-+import com.destroystokyo.paper.event.block.TNTPrimeEvent; // Paper - TNTPrimeEvent
- 
- public class EntityEnderDragon extends EntityInsentient implements IMonster {
- 
-@@ -0,0 +0,0 @@ public class EntityEnderDragon extends EntityInsentient implements IMonster {
-                     });
-                     craftBlock.getNMS().dropNaturally((WorldServer) world, blockposition, ItemStack.b);
-                 }
-+                // Paper start - TNTPrimeEvent
-+                org.bukkit.block.Block tntBlock = world.getWorld().getBlockAt(blockposition.getX(), blockposition.getY(), blockposition.getZ());
-+                if(!new TNTPrimeEvent(tntBlock, TNTPrimeEvent.PrimeReason.EXPLOSION, explosionSource.getSource().getBukkitEntity()).callEvent())
-+                    continue;
-+                // Paper end
-                 nmsBlock.wasExploded(world, blockposition, explosionSource);
- 
-                 this.world.a(blockposition, false);
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockFire.java b/src/main/java/net/minecraft/world/level/block/BlockFire.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockFire.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockFire.java
-@@ -0,0 +0,0 @@ package net.minecraft.world.level.block;
- import com.google.common.collect.ImmutableMap;
- import it.unimi.dsi.fastutil.objects.Object2IntMap;
- import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
-+import com.destroystokyo.paper.event.block.TNTPrimeEvent; // Paper - TNTPrimeEvent
- import java.util.Map;
- import java.util.Random;
- import java.util.function.Function;
-@@ -0,0 +0,0 @@ import net.minecraft.SystemUtils;
- import net.minecraft.core.BaseBlockPosition;
- import net.minecraft.core.BlockPosition;
- import net.minecraft.core.EnumDirection;
-+import net.minecraft.server.MCUtil;
- import net.minecraft.server.level.WorldServer;
- import net.minecraft.world.item.context.BlockActionContext;
- import net.minecraft.world.level.GameRules;
-@@ -0,0 +0,0 @@ public class BlockFire extends BlockFireAbstract {
- 
-                 world.setTypeAndData(blockposition, this.a(world, blockposition, l), 3);
-             } else {
--                world.a(blockposition, false);
-+                if(iblockdata.getBlock() != Blocks.TNT) world.a(blockposition, false); // Paper - TNTPrimeEvent - We might be cancelling it below, move the setAir down
-             }
- 
-             Block block = iblockdata.getBlock();
-@@ -0,0 +0,0 @@ public class BlockFire extends BlockFireAbstract {
-             if (block instanceof BlockTNT) {
-                 BlockTNT blocktnt = (BlockTNT) block;
- 
-+                // Paper start - TNTPrimeEvent
-+                org.bukkit.block.Block tntBlock = MCUtil.toBukkitBlock(world, blockposition);
-+                if (!new TNTPrimeEvent(tntBlock, TNTPrimeEvent.PrimeReason.FIRE, null).callEvent()) {
-+                    return;
-+                }
-+                world.setAir(blockposition, false);
-+                // Paper end
-                 BlockTNT.a(world, blockposition);
-             }
-         }
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockTNT.java b/src/main/java/net/minecraft/world/level/block/BlockTNT.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockTNT.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockTNT.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.level.block.state.IBlockData;
- import net.minecraft.world.level.block.state.properties.BlockProperties;
- import net.minecraft.world.level.block.state.properties.BlockStateBoolean;
- import net.minecraft.world.phys.MovingObjectPositionBlock;
-+import com.destroystokyo.paper.event.block.TNTPrimeEvent; // Paper - TNTPrimeEvent
- 
- public class BlockTNT extends Block {
- 
-@@ -0,0 +0,0 @@ public class BlockTNT extends Block {
-     public void onPlace(IBlockData iblockdata, World world, BlockPosition blockposition, IBlockData iblockdata1, boolean flag) {
-         if (!iblockdata1.a(iblockdata.getBlock())) {
-             if (world.isBlockIndirectlyPowered(blockposition)) {
-+                // Paper start - TNTPrimeEvent
-+                org.bukkit.block.Block tntBlock = net.minecraft.server.MCUtil.toBukkitBlock(world, blockposition);;
-+                if(!new TNTPrimeEvent(tntBlock, TNTPrimeEvent.PrimeReason.REDSTONE, null).callEvent())
-+                    return;
-+                // Paper end
-                 a(world, blockposition);
-                 world.a(blockposition, false);
-             }
-@@ -0,0 +0,0 @@ public class BlockTNT extends Block {
-     @Override
-     public void doPhysics(IBlockData iblockdata, World world, BlockPosition blockposition, Block block, BlockPosition blockposition1, boolean flag) {
-         if (world.isBlockIndirectlyPowered(blockposition)) {
-+            // Paper start - TNTPrimeEvent
-+            org.bukkit.block.Block tntBlock = net.minecraft.server.MCUtil.toBukkitBlock(world, blockposition);;
-+            if(!new TNTPrimeEvent(tntBlock, TNTPrimeEvent.PrimeReason.REDSTONE, null).callEvent())
-+                return;
-+            // Paper end
-             a(world, blockposition);
-             world.a(blockposition, false);
-         }
-@@ -0,0 +0,0 @@ public class BlockTNT extends Block {
-     @Override
-     public void wasExploded(World world, BlockPosition blockposition, Explosion explosion) {
-         if (!world.isClientSide) {
-+            // Paper start - TNTPrimeEvent
-+            org.bukkit.block.Block tntBlock = net.minecraft.server.MCUtil.toBukkitBlock(world, blockposition);
-+            org.bukkit.entity.Entity source = explosion.source != null ? explosion.source.getBukkitEntity() : null;
-+            if(!new TNTPrimeEvent(tntBlock, TNTPrimeEvent.PrimeReason.EXPLOSION, source).callEvent())
-+                return;
-+            // Paper end
-             EntityTNTPrimed entitytntprimed = new EntityTNTPrimed(world, (double) blockposition.getX() + 0.5D, (double) blockposition.getY(), (double) blockposition.getZ() + 0.5D, explosion.getSource());
- 
-             entitytntprimed.setFuseTicks((short) (world.random.nextInt(entitytntprimed.getFuseTicks() / 4) + entitytntprimed.getFuseTicks() / 8));
-@@ -0,0 +0,0 @@ public class BlockTNT extends Block {
-         if (item != Items.FLINT_AND_STEEL && item != Items.FIRE_CHARGE) {
-             return super.interact(iblockdata, world, blockposition, entityhuman, enumhand, movingobjectpositionblock);
-         } else {
-+            // Paper start - TNTPrimeEvent
-+            org.bukkit.block.Block tntBlock = net.minecraft.server.MCUtil.toBukkitBlock(world, blockposition);
-+            if(!new TNTPrimeEvent(tntBlock, TNTPrimeEvent.PrimeReason.ITEM, entityhuman.getBukkitEntity()).callEvent())
-+                return EnumInteractionResult.FAIL;
-+            // Paper end
-             a(world, blockposition, (EntityLiving) entityhuman);
-             world.setTypeAndData(blockposition, Blocks.AIR.getBlockData(), 11);
-             if (!entityhuman.isCreative()) {
-@@ -0,0 +0,0 @@ public class BlockTNT extends Block {
-                 }
-                 // CraftBukkit end
- 
-+                // Paper start - TNTPrimeEvent
-+                org.bukkit.block.Block tntBlock = net.minecraft.server.MCUtil.toBukkitBlock(world, blockposition);
-+                if (!new TNTPrimeEvent(tntBlock, TNTPrimeEvent.PrimeReason.PROJECTILE, iprojectile.getBukkitEntity()).callEvent()) {
-+                    return;
-+                }
-+                // Paper end
-+
-                 a(world, blockposition, entity instanceof EntityLiving ? (EntityLiving) entity : null);
-                 world.a(blockposition, false);
-             }

Spigot-Server-Patches/Add-ThrownEggHatchEvent.patch

@@ -1,29 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <blake.galbreath@gmail.com>
-Date: Sun, 9 Feb 2020 00:19:05 -0600
-Subject: [PATCH] Add ThrownEggHatchEvent
-
-Adds a new event similar to PlayerEggThrowEvent, but without the Player requirement
-(dispensers can throw eggs to hatch them, too).
-
-diff --git a/src/main/java/net/minecraft/world/entity/projectile/EntityEgg.java b/src/main/java/net/minecraft/world/entity/projectile/EntityEgg.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/projectile/EntityEgg.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/EntityEgg.java
-@@ -0,0 +0,0 @@ public class EntityEgg extends EntityProjectileThrowable {
-                     hatchingType = event.getHatchingType();
-                 }
- 
-+                // Paper start
-+                com.destroystokyo.paper.event.entity.ThrownEggHatchEvent event = new com.destroystokyo.paper.event.entity.ThrownEggHatchEvent((org.bukkit.entity.Egg) getBukkitEntity(), hatching, b0, hatchingType);
-+                event.callEvent();
-+
-+                b0 = event.getNumHatches();
-+                hatching = event.isHatching();
-+                hatchingType = event.getHatchingType();
-+                // Paper end
-+
-+
-                 if (hatching) {
-                     for (int i = 0; i < b0; ++i) {
-                         Entity entity = world.getWorld().createEntity(new org.bukkit.Location(world.getWorld(), this.locX(), this.locY(), this.locZ(), this.yaw, 0.0F), hatchingType.getEntityClass());

Spigot-Server-Patches/Add-Unix-domain-socket-support.patch

@@ -1,141 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Andrew Steinborn <git@steinborn.me>
-Date: Tue, 11 May 2021 17:39:22 -0400
-Subject: [PATCH] Add Unix domain socket support
-
-For Windows and ARM support, JEP-380 is required:
-https://inside.java/2021/02/03/jep380-unix-domain-sockets-channels/
-This will be possible as of the Minecraft 1.17 Java version bump.
-
-Tested-by: Mariell Hoversholm <proximyst@proximyst.com>
-Reviewed-by: Mariell Hoversholm <proximyst@proximyst.com>
-
-diff --git a/src/main/java/net/minecraft/network/NetworkManager.java b/src/main/java/net/minecraft/network/NetworkManager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/NetworkManager.java
-+++ b/src/main/java/net/minecraft/network/NetworkManager.java
-@@ -0,0 +0,0 @@ public class NetworkManager extends SimpleChannelInboundHandler<Packet<?>> {
-     // Spigot Start
-     public SocketAddress getRawAddress()
-     {
-+        // Paper start - this can be nullable in the case of a Unix domain socket, so if it is, fake something
-+        if (this.channel.remoteAddress() == null) {
-+            return new java.net.InetSocketAddress(java.net.InetAddress.getLoopbackAddress(), 0);
-+        }
-+        // Paper end
-         return this.channel.remoteAddress();
-     }
-     // Spigot End
-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 IMinecraftServer
-         this.i(dedicatedserverproperties.enforceWhitelist);
-         // this.saveData.setGameType(dedicatedserverproperties.gamemode); // CraftBukkit - moved to world loading
-         DedicatedServer.LOGGER.info("Default game type: {}", dedicatedserverproperties.gamemode);
-+        // Paper start - Unix domain socket support
-+        java.net.SocketAddress bindAddress;
-+        if (this.getServerIp().startsWith("unix:")) {
-+            if (!io.netty.channel.epoll.Epoll.isAvailable()) {
-+                DedicatedServer.LOGGER.fatal("**** INVALID CONFIGURATION!");
-+                DedicatedServer.LOGGER.fatal("You are trying to use a Unix domain socket but you're not on a supported OS.");
-+                return false;
-+            } else if (!com.destroystokyo.paper.PaperConfig.velocitySupport && !org.spigotmc.SpigotConfig.bungee) {
-+                DedicatedServer.LOGGER.fatal("**** INVALID CONFIGURATION!");
-+                DedicatedServer.LOGGER.fatal("Unix domain sockets require IPs to be forwarded from a proxy.");
-+                return false;
-+            }
-+            bindAddress = new io.netty.channel.unix.DomainSocketAddress(this.getServerIp().substring("unix:".length()));
-+        } else {
-         InetAddress inetaddress = null;
- 
-         if (!this.getServerIp().isEmpty()) {
-@@ -0,0 +0,0 @@ public class DedicatedServer extends MinecraftServer implements IMinecraftServer
-         if (this.getPort() < 0) {
-             this.setPort(dedicatedserverproperties.serverPort);
-         }
-+        bindAddress = new java.net.InetSocketAddress(inetaddress, this.getPort());
-+        }
-+        // Paper end
- 
-         this.P();
-         DedicatedServer.LOGGER.info("Starting Minecraft server on {}:{}", this.getServerIp().isEmpty() ? "*" : this.getServerIp(), this.getPort());
- 
-         try {
--            this.getServerConnection().a(inetaddress, this.getPort());
-+            this.getServerConnection().bind(bindAddress); // Paper - Unix domain socket support
-         } catch (IOException ioexception) {
-             DedicatedServer.LOGGER.warn("**** FAILED TO BIND TO PORT!");
-             DedicatedServer.LOGGER.warn("The exception was: {}", ioexception.toString());
-diff --git a/src/main/java/net/minecraft/server/network/HandshakeListener.java b/src/main/java/net/minecraft/server/network/HandshakeListener.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/HandshakeListener.java
-+++ b/src/main/java/net/minecraft/server/network/HandshakeListener.java
-@@ -0,0 +0,0 @@ public class HandshakeListener implements PacketHandshakingInListener {
-                 this.c.setProtocol(EnumProtocol.LOGIN);
-                 // CraftBukkit start - Connection throttle
-                 try {
-+                    if (!(this.c.channel.localAddress() instanceof io.netty.channel.unix.DomainSocketAddress)) { // Paper - the connection throttle is useless when you have a Unix domain socket
-                     long currentTime = System.currentTimeMillis();
-                     long connectionThrottle = this.b.server.getConnectionThrottle();
-                     InetAddress address = ((java.net.InetSocketAddress) this.c.getSocketAddress()).getAddress();
-@@ -0,0 +0,0 @@ public class HandshakeListener implements PacketHandshakingInListener {
-                             }
-                         }
-                     }
-+                    } // Paper - add closing bracket for if check above
-                 } catch (Throwable t) {
-                     org.apache.logging.log4j.LogManager.getLogger().debug("Failed to check connection throttle", t);
-                 }
-@@ -0,0 +0,0 @@ public class HandshakeListener implements PacketHandshakingInListener {
-                 //if (org.spigotmc.SpigotConfig.bungee) { // Paper - comment out, we check above!
-                         String[] split = packethandshakinginsetprotocol.hostname.split("\00");
-                         if ( ( split.length == 3 || split.length == 4 ) && ( BYPASS_HOSTCHECK || HOST_PATTERN.matcher( split[1] ).matches() ) ) { // Paper
-+                            // Paper start - Unix domain socket support
-+                            java.net.SocketAddress socketAddress = c.getSocketAddress();
-                             packethandshakinginsetprotocol.hostname = split[0];
--                            c.socketAddress = new java.net.InetSocketAddress(split[1], ((java.net.InetSocketAddress) c.getSocketAddress()).getPort());
-+                            c.socketAddress = new java.net.InetSocketAddress(split[1], socketAddress instanceof java.net.InetSocketAddress ? ((java.net.InetSocketAddress) socketAddress).getPort() : 0);
-+                            // Paper end
-                             c.spoofedUUID = com.mojang.util.UUIDTypeAdapter.fromString( split[2] );
-                         } else
-                         {
-diff --git a/src/main/java/net/minecraft/server/network/ServerConnection.java b/src/main/java/net/minecraft/server/network/ServerConnection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerConnection.java
-+++ b/src/main/java/net/minecraft/server/network/ServerConnection.java
-@@ -0,0 +0,0 @@ public class ServerConnection {
-         this.c = true;
-     }
- 
-+    // Paper start
-     public void a(@Nullable InetAddress inetaddress, int i) throws IOException {
-+        bind(new java.net.InetSocketAddress(inetaddress, i));
-+    }
-+    public void bind(java.net.SocketAddress address) throws IOException {
-+    // Paper end
-         List list = this.listeningChannels;
- 
-         synchronized (this.listeningChannels) {
-@@ -0,0 +0,0 @@ public class ServerConnection {
-             LazyInitVar lazyinitvar;
- 
-             if (Epoll.isAvailable() && this.e.l()) {
-+                if (address instanceof io.netty.channel.unix.DomainSocketAddress) {
-+                    oclass = io.netty.channel.epoll.EpollServerDomainSocketChannel.class;
-+                } else {
-                 oclass = EpollServerSocketChannel.class;
-+                }
-                 lazyinitvar = ServerConnection.b;
-                 ServerConnection.LOGGER.info("Using epoll channel type");
-             } else {
-@@ -0,0 +0,0 @@ public class ServerConnection {
-                     ((NetworkManager) object).setPacketListener(new HandshakeListener(ServerConnection.this.e, (NetworkManager) object));
-                     io.papermc.paper.network.ChannelInitializeListenerHolder.callListeners(channel); // Paper
-                 }
--            }).group((EventLoopGroup) lazyinitvar.a()).localAddress(inetaddress, i)).option(ChannelOption.AUTO_READ, false).bind().syncUninterruptibly()); // CraftBukkit
-+            }).group((EventLoopGroup) lazyinitvar.a()).localAddress(address)).option(ChannelOption.AUTO_READ, false).bind().syncUninterruptibly()); // CraftBukkit // Paper
-         }
-     }
- 

Spigot-Server-Patches/Add-UnknownCommandEvent.patch

@@ -1,25 +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
-
-
-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, org.spigotmc.SpigotConfig.unknownCommandMessage);
-+            Bukkit.getServer().getPluginManager().callEvent(event);
-+            if (event.message() != null) {
-+                sender.sendMessage(event.message());
-+            }
-+            // Paper end
-         }
-         // Spigot end
- 

Spigot-Server-Patches/Add-Velocity-IP-Forwarding-Support.patch

@@ -1,307 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Andrew Steinborn <git@steinborn.me>
-Date: Mon, 8 Oct 2018 14:36:14 -0400
-Subject: [PATCH] Add Velocity IP Forwarding Support
-
-While Velocity supports BungeeCord-style IP forwarding, it is not secure. Users
-have a lot of problems setting up firewalls or setting up plugins like IPWhitelist.
-Further, the BungeeCord IP forwarding protocol still retains essentially its original
-form, when there is brand new support for custom login plugin messages in 1.13.
-
-Velocity's modern IP forwarding uses an HMAC-SHA256 code to ensure authenticity
-of messages, is packed into a binary format that is smaller than BungeeCord's
-forwarding, and is integrated into the Minecraft login process by using the 1.13
-login plugin message packet.
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ import java.io.IOException;
- import java.lang.reflect.InvocationTargetException;
- import java.lang.reflect.Method;
- import java.lang.reflect.Modifier;
-+import java.nio.charset.StandardCharsets;
- import java.util.HashMap;
- import java.util.List;
- import java.util.Map;
-@@ -0,0 +0,0 @@ public class PaperConfig {
-     }
- 
-     public static boolean isProxyOnlineMode() {
--        return Bukkit.getOnlineMode() || (SpigotConfig.bungee && bungeeOnlineMode);
-+        return Bukkit.getOnlineMode() || (SpigotConfig.bungee && bungeeOnlineMode) || (velocitySupport && velocityOnlineMode);
-     }
- 
-     public static int packetInSpamThreshold = 300;
-@@ -0,0 +0,0 @@ public class PaperConfig {
-         }
-         tabSpamLimit = getInt("settings.spam-limiter.tab-spam-limit", tabSpamLimit);
-     }
-+
-+    public static boolean velocitySupport;
-+    public static boolean velocityOnlineMode;
-+    public static byte[] velocitySecretKey;
-+    private static void velocitySupport() {
-+        velocitySupport = getBoolean("settings.velocity-support.enabled", false);
-+        velocityOnlineMode = getBoolean("settings.velocity-support.online-mode", false);
-+        String secret = getString("settings.velocity-support.secret", "");
-+        if (velocitySupport && secret.isEmpty()) {
-+            fatal("Velocity support is enabled, but no secret key was specified. A secret key is required!");
-+        } else {
-+            velocitySecretKey = secret.getBytes(StandardCharsets.UTF_8);
-+        }
-+    }
- }
-diff --git a/src/main/java/com/destroystokyo/paper/proxy/VelocityProxy.java b/src/main/java/com/destroystokyo/paper/proxy/VelocityProxy.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/proxy/VelocityProxy.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.proxy;
-+
-+import com.destroystokyo.paper.PaperConfig;
-+import com.google.common.net.InetAddresses;
-+import com.mojang.authlib.GameProfile;
-+import com.mojang.authlib.properties.Property;
-+import net.minecraft.network.PacketDataSerializer;
-+import net.minecraft.resources.MinecraftKey;
-+
-+import java.net.InetAddress;
-+import java.security.InvalidKeyException;
-+import java.security.MessageDigest;
-+import java.security.NoSuchAlgorithmException;
-+
-+import javax.crypto.Mac;
-+import javax.crypto.spec.SecretKeySpec;
-+
-+public class VelocityProxy {
-+    private static final int SUPPORTED_FORWARDING_VERSION = 1;
-+    public static final MinecraftKey PLAYER_INFO_CHANNEL = new MinecraftKey("velocity", "player_info");
-+
-+    public static boolean checkIntegrity(final PacketDataSerializer buf) {
-+        final byte[] signature = new byte[32];
-+        buf.readBytes(signature);
-+
-+        final byte[] data = new byte[buf.readableBytes()];
-+        buf.getBytes(buf.readerIndex(), data);
-+
-+        try {
-+            final Mac mac = Mac.getInstance("HmacSHA256");
-+            mac.init(new SecretKeySpec(PaperConfig.velocitySecretKey, "HmacSHA256"));
-+            final byte[] mySignature = mac.doFinal(data);
-+            if (!MessageDigest.isEqual(signature, mySignature)) {
-+                return false;
-+            }
-+        } catch (final InvalidKeyException | NoSuchAlgorithmException e) {
-+            throw new AssertionError(e);
-+        }
-+
-+        int version = buf.readVarInt();
-+        if (version != SUPPORTED_FORWARDING_VERSION) {
-+            throw new IllegalStateException("Unsupported forwarding version " + version + ", wanted " + SUPPORTED_FORWARDING_VERSION);
-+        }
-+
-+        return true;
-+    }
-+
-+    public static InetAddress readAddress(final PacketDataSerializer buf) {
-+        return InetAddresses.forString(buf.readUTF(Short.MAX_VALUE));
-+    }
-+
-+    public static GameProfile createProfile(final PacketDataSerializer buf) {
-+        final GameProfile profile = new GameProfile(buf.readUUID(), buf.readUTF(16));
-+        readProperties(buf, profile);
-+        return profile;
-+    }
-+
-+    private static void readProperties(final PacketDataSerializer buf, final GameProfile profile) {
-+        final int properties = buf.readVarInt();
-+        for (int i1 = 0; i1 < properties; i1++) {
-+            final String name = buf.readUTF(Short.MAX_VALUE);
-+            final String value = buf.readUTF(Short.MAX_VALUE);
-+            final String signature = buf.readBoolean() ? buf.readUTF(Short.MAX_VALUE) : null;
-+            profile.getProperties().put(name, new Property(name, value, signature));
-+        }
-+    }
-+}
-diff --git a/src/main/java/net/minecraft/network/PacketDataSerializer.java b/src/main/java/net/minecraft/network/PacketDataSerializer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/PacketDataSerializer.java
-+++ b/src/main/java/net/minecraft/network/PacketDataSerializer.java
-@@ -0,0 +0,0 @@ public class PacketDataSerializer extends ByteBuf {
-         return this.d(oenum.ordinal());
-     }
- 
-+    public int readVarInt() { return i(); } // Paper - OBFHELPER
-     public int i() {
-         int i = 0;
-         int j = 0;
-@@ -0,0 +0,0 @@ public class PacketDataSerializer extends ByteBuf {
-         return this;
-     }
- 
-+    public UUID readUUID() { return k(); } // Paper - OBFHELPER
-     public UUID k() {
-         return new UUID(this.readLong(), this.readLong());
-     }
-@@ -0,0 +0,0 @@ public class PacketDataSerializer extends ByteBuf {
-         }
-     }
- 
-+    public String readUTF(int maxLength) { return this.e(maxLength); } // Paper - OBFHELPER
-     public String e(int i) {
-         int j = this.i();
- 
-diff --git a/src/main/java/net/minecraft/network/protocol/login/PacketLoginInCustomPayload.java b/src/main/java/net/minecraft/network/protocol/login/PacketLoginInCustomPayload.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/protocol/login/PacketLoginInCustomPayload.java
-+++ b/src/main/java/net/minecraft/network/protocol/login/PacketLoginInCustomPayload.java
-@@ -0,0 +0,0 @@ import net.minecraft.network.protocol.Packet;
- 
- public class PacketLoginInCustomPayload implements Packet<PacketLoginInListener> {
- 
--    private int a;
--    private PacketDataSerializer b;
-+    private int a; public int getId() { return a; } // Paper - OBFHELPER
-+    private PacketDataSerializer b; public PacketDataSerializer getBuf() { return b; } // Paper - OBFHELPER
- 
-     public PacketLoginInCustomPayload() {}
- 
-diff --git a/src/main/java/net/minecraft/network/protocol/login/PacketLoginOutCustomPayload.java b/src/main/java/net/minecraft/network/protocol/login/PacketLoginOutCustomPayload.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/protocol/login/PacketLoginOutCustomPayload.java
-+++ b/src/main/java/net/minecraft/network/protocol/login/PacketLoginOutCustomPayload.java
-@@ -0,0 +0,0 @@ public class PacketLoginOutCustomPayload implements Packet<PacketLoginOutListene
- 
-     public PacketLoginOutCustomPayload() {}
- 
-+    // Paper start
-+    public PacketLoginOutCustomPayload(int id, MinecraftKey channel, PacketDataSerializer buf) {
-+        this.a = id;
-+        this.b = channel;
-+        this.c = buf;
-+    }
-+    // Paper end
-+
-     @Override
-     public void a(PacketDataSerializer packetdataserializer) throws IOException {
-         this.a = packetdataserializer.i();
-diff --git a/src/main/java/net/minecraft/server/network/LoginListener.java b/src/main/java/net/minecraft/server/network/LoginListener.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/LoginListener.java
-+++ b/src/main/java/net/minecraft/server/network/LoginListener.java
-@@ -0,0 +0,0 @@ import javax.crypto.Cipher;
- import javax.crypto.SecretKey;
- import net.minecraft.DefaultUncaughtExceptionHandler;
- import net.minecraft.network.NetworkManager;
-+import net.minecraft.network.PacketDataSerializer;
- import net.minecraft.network.chat.ChatMessage;
- import net.minecraft.network.chat.IChatBaseComponent;
- import net.minecraft.network.protocol.login.PacketLoginInCustomPayload;
- import net.minecraft.network.protocol.login.PacketLoginInEncryptionBegin;
- import net.minecraft.network.protocol.login.PacketLoginInListener;
- import net.minecraft.network.protocol.login.PacketLoginInStart;
-+import net.minecraft.network.protocol.login.PacketLoginOutCustomPayload;
- import net.minecraft.network.protocol.login.PacketLoginOutDisconnect;
- import net.minecraft.network.protocol.login.PacketLoginOutEncryptionBegin;
- import net.minecraft.network.protocol.login.PacketLoginOutSetCompression;
-@@ -0,0 +0,0 @@ import org.bukkit.craftbukkit.util.Waitable;
- import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
- import org.bukkit.event.player.PlayerPreLoginEvent;
- // CraftBukkit end
-+import io.netty.buffer.Unpooled; // Paper
- 
- public class LoginListener implements PacketLoginInListener {
- 
-@@ -0,0 +0,0 @@ public class LoginListener implements PacketLoginInListener {
-     private SecretKey loginKey;
-     private EntityPlayer l;
-     public String hostname = ""; // CraftBukkit - add field
-+    private int velocityLoginMessageId = -1; // Paper - Velocity support
- 
-     public LoginListener(MinecraftServer minecraftserver, NetworkManager networkmanager) {
-         this.g = LoginListener.EnumProtocolState.HELLO;
-@@ -0,0 +0,0 @@ public class LoginListener implements PacketLoginInListener {
-             this.g = LoginListener.EnumProtocolState.KEY;
-             this.networkManager.sendPacket(new PacketLoginOutEncryptionBegin("", this.server.getKeyPair().getPublic().getEncoded(), this.e));
-         } else {
-+            // Paper start - Velocity support
-+            if (com.destroystokyo.paper.PaperConfig.velocitySupport) {
-+                this.velocityLoginMessageId = java.util.concurrent.ThreadLocalRandom.current().nextInt();
-+                PacketLoginOutCustomPayload packet = new PacketLoginOutCustomPayload(this.velocityLoginMessageId, com.destroystokyo.paper.proxy.VelocityProxy.PLAYER_INFO_CHANNEL, new PacketDataSerializer(Unpooled.EMPTY_BUFFER));
-+                this.networkManager.sendPacket(packet);
-+                return;
-+            }
-+            // Paper end
-             // Spigot start
-             // Paper start - Cache authenticator threads
-             authenticatorPool.execute(new Runnable() {
-@@ -0,0 +0,0 @@ public class LoginListener implements PacketLoginInListener {
-     public class LoginHandler {
- 
-         public void fireEvents() throws Exception {
-+                        // Paper start - Velocity support
-+                        if (LoginListener.this.velocityLoginMessageId == -1 && com.destroystokyo.paper.PaperConfig.velocitySupport) {
-+                            disconnect("This server requires you to connect with Velocity.");
-+                            return;
-+                        }
-+                        // Paper end
-                         String playerName = i.getName();
-                         java.net.InetAddress address = ((java.net.InetSocketAddress) networkManager.getSocketAddress()).getAddress();
-                         java.util.UUID uniqueId = i.getId();
-@@ -0,0 +0,0 @@ public class LoginListener implements PacketLoginInListener {
-     // Spigot end
- 
-     public void a(PacketLoginInCustomPayload packetloginincustompayload) {
-+        // Paper start - Velocity support
-+        if (com.destroystokyo.paper.PaperConfig.velocitySupport && packetloginincustompayload.getId() == this.velocityLoginMessageId) {
-+            PacketDataSerializer buf = packetloginincustompayload.getBuf();
-+            if (buf == null) {
-+                this.disconnect("This server requires you to connect with Velocity.");
-+                return;
-+            }
-+
-+            if (!com.destroystokyo.paper.proxy.VelocityProxy.checkIntegrity(buf)) {
-+                this.disconnect("Unable to verify player details");
-+                return;
-+            }
-+
-+            java.net.SocketAddress listening = this.networkManager.getSocketAddress();
-+            int port = 0;
-+            if (listening instanceof java.net.InetSocketAddress) {
-+                port = ((java.net.InetSocketAddress) listening).getPort();
-+            }
-+            this.networkManager.socketAddress = new java.net.InetSocketAddress(com.destroystokyo.paper.proxy.VelocityProxy.readAddress(buf), port);
-+
-+            this.setGameProfile(com.destroystokyo.paper.proxy.VelocityProxy.createProfile(buf));
-+
-+            // Proceed with login
-+            authenticatorPool.execute(() -> {
-+                try {
-+                    new LoginHandler().fireEvents();
-+                } catch (Exception ex) {
-+                    disconnect("Failed to verify username!");
-+                    server.server.getLogger().log(java.util.logging.Level.WARNING, "Exception verifying " + i.getName(), ex);
-+                }
-+            });
-+            return;
-+        }
-+        // Paper end
-         this.disconnect(new ChatMessage("multiplayer.disconnect.unexpected_query_response"));
-     }
- 
-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 long getConnectionThrottle() {
-         // Spigot Start - Automatically set connection throttle for bungee configurations
--        if (org.spigotmc.SpigotConfig.bungee) {
-+        if (org.spigotmc.SpigotConfig.bungee || com.destroystokyo.paper.PaperConfig.velocitySupport) { // Paper - Velocity support
-             return -1;
-         } else {
-             return this.configuration.getInt("settings.connection-throttle");

Spigot-Server-Patches/Add-Wandering-Trader-spawn-rate-config-options.patch

@@ -1,120 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
-Date: Thu, 20 Aug 2020 11:20:12 -0700
-Subject: [PATCH] Add Wandering Trader spawn rate config options
-
-Adds config options for modifying the spawn rates of Wandering Traders.
-These values are all easy to understand and configure after a quick read of this
-page on the Minecraft wiki: https://minecraft.gamepedia.com/Wandering_Trader#Spawning
-Usages of the vanilla WanderingTraderSpawnDelay and WanderingTraderSpawnChance values
-in IWorldServerData are removed as they were only used in certain places, with hardcoded
-values used in other places.
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-             log("The Ender Dragon will be removed if she already exists without a portal.");
-         }
-     }
-+
-+    public int wanderingTraderSpawnMinuteTicks = 1200;
-+    public int wanderingTraderSpawnDayTicks = 24000;
-+    public int wanderingTraderSpawnChanceFailureIncrement = 25;
-+    public int wanderingTraderSpawnChanceMin = 25;
-+    public int wanderingTraderSpawnChanceMax = 75;
-+    private void wanderingTraderSettings() {
-+        wanderingTraderSpawnMinuteTicks = getInt("wandering-trader.spawn-minute-length", wanderingTraderSpawnMinuteTicks);
-+        wanderingTraderSpawnDayTicks = getInt("wandering-trader.spawn-day-length", wanderingTraderSpawnDayTicks);
-+        wanderingTraderSpawnChanceFailureIncrement = getInt("wandering-trader.spawn-chance-failure-increment", wanderingTraderSpawnChanceFailureIncrement);
-+        wanderingTraderSpawnChanceMin = getInt("wandering-trader.spawn-chance-min", wanderingTraderSpawnChanceMin);
-+        wanderingTraderSpawnChanceMax = getInt("wandering-trader.spawn-chance-max", wanderingTraderSpawnChanceMax);
-+    }
- }
-diff --git a/src/main/java/net/minecraft/world/entity/npc/MobSpawnerTrader.java b/src/main/java/net/minecraft/world/entity/npc/MobSpawnerTrader.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/npc/MobSpawnerTrader.java
-+++ b/src/main/java/net/minecraft/world/entity/npc/MobSpawnerTrader.java
-@@ -0,0 +0,0 @@ public class MobSpawnerTrader implements MobSpawner {
- 
-     private final Random a = new Random();
-     private final IWorldDataServer b;
--    private int c;
--    private int d;
--    private int e;
-+    private int c; public final int getMinuteTimer() { return this.c; } public final void setMinuteTimer(int x) { this.c = x; } // Paper - OBFHELPER
-+    private int d; public final int getDayTimer() { return this.d; } public final void setDayTimer(int x) { this.d = x; } // Paper - OBFHELPER
-+    private int e; public final int getSpawnChance() { return this.e; } public final void setSpawnChance(int x) { this.e = x; } // Paper - OBFHELPER
- 
-     public MobSpawnerTrader(IWorldDataServer iworlddataserver) {
-         this.b = iworlddataserver;
--        this.c = 1200;
--        this.d = iworlddataserver.v();
--        this.e = iworlddataserver.w();
--        if (this.d == 0 && this.e == 0) {
--            this.d = 24000;
--            iworlddataserver.g(this.d);
--            this.e = 25;
--            iworlddataserver.h(this.e);
--        }
-+        // Paper start
-+        this.setMinuteTimer(Integer.MIN_VALUE);
-+        //this.d = iworlddataserver.v(); // Paper - This value is read from the world file only for the first spawn, after which vanilla uses a hardcoded value
-+        //this.e = iworlddataserver.w(); // Paper - This value is read from the world file only for the first spawn, after which vanilla uses a hardcoded value
-+        //if (this.d == 0 && this.e == 0) {
-+        //    this.d = 24000;
-+        //    iworlddataserver.g(this.d);
-+        //    this.e = 25;
-+        //    iworlddataserver.h(this.e);
-+        //}
-+        // Paper end
- 
-     }
- 
-     @Override
-     public int a(WorldServer worldserver, boolean flag, boolean flag1) {
-+        // Paper start
-+        if (this.getMinuteTimer() == Integer.MIN_VALUE) {
-+            this.setMinuteTimer(worldserver.paperConfig.wanderingTraderSpawnMinuteTicks);
-+            this.setDayTimer(worldserver.paperConfig.wanderingTraderSpawnDayTicks);
-+            this.setSpawnChance(worldserver.paperConfig.wanderingTraderSpawnChanceMin);
-+        }
-         if (!worldserver.getGameRules().getBoolean(GameRules.DO_TRADER_SPAWNING)) {
-             return 0;
--        } else if (--this.c > 0) {
-+        } else if (this.getMinuteTimer() - 1 > 0) {
-+            this.setMinuteTimer(this.getMinuteTimer() - 1);
-             return 0;
-         } else {
--            this.c = 1200;
--            this.d -= 1200;
--            this.b.g(this.d);
--            if (this.d > 0) {
-+            this.setMinuteTimer(worldserver.paperConfig.wanderingTraderSpawnMinuteTicks);
-+            this.setDayTimer(getDayTimer() - worldserver.paperConfig.wanderingTraderSpawnMinuteTicks);
-+            //this.b.g(this.d); // Paper - We don't need to save this value to disk if it gets set back to a hardcoded value anyways
-+            if (this.getDayTimer() > 0) {
-                 return 0;
-             } else {
--                this.d = 24000;
-+                this.setDayTimer(worldserver.paperConfig.wanderingTraderSpawnDayTicks);
-                 if (!worldserver.getGameRules().getBoolean(GameRules.DO_MOB_SPAWNING)) {
-                     return 0;
-                 } else {
--                    int i = this.e;
-+                    int i = this.getSpawnChance();
- 
--                    this.e = MathHelper.clamp(this.e + 25, 25, 75);
--                    this.b.h(this.e);
-+                    this.setSpawnChance(MathHelper.clamp(i + worldserver.paperConfig.wanderingTraderSpawnChanceFailureIncrement, worldserver.paperConfig.wanderingTraderSpawnChanceMin, worldserver.paperConfig.wanderingTraderSpawnChanceMax));
-+                    //this.b.h(this.e); // Paper - We don't need to save this value to disk if it gets set back to a hardcoded value anyways
-                     if (this.a.nextInt(100) > i) {
-                         return 0;
-                     } else if (this.a(worldserver)) {
--                        this.e = 25;
-+                        this.setSpawnChance(worldserver.paperConfig.wanderingTraderSpawnChanceMin);
-+                        // Paper end
-                         return 1;
-                     } else {
-                         return 0;

Spigot-Server-Patches/Add-World-Util-Methods.patch

@@ -1,65 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Fri, 18 Mar 2016 20:16:03 -0400
-Subject: [PATCH] Add World Util Methods
-
-Methods that can be used for other patches to help improve logic.
-
-diff --git a/src/main/java/net/minecraft/server/level/WorldServer.java b/src/main/java/net/minecraft/server/level/WorldServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/WorldServer.java
-+++ b/src/main/java/net/minecraft/server/level/WorldServer.java
-@@ -0,0 +0,0 @@ public class WorldServer extends World implements GeneratorAccessSeed {
-     public final Convertable.ConversionSession convertable;
-     public final UUID uuid;
- 
--    public Chunk getChunkIfLoaded(int x, int z) {
-+    @Override public Chunk getChunkIfLoaded(int x, int z) { // Paper - this was added in world too but keeping here for NMS ABI
-         return this.chunkProvider.getChunkAt(x, z, false);
-     }
- 
-diff --git a/src/main/java/net/minecraft/world/level/World.java b/src/main/java/net/minecraft/world/level/World.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/World.java
-+++ b/src/main/java/net/minecraft/world/level/World.java
-@@ -0,0 +0,0 @@ public abstract class World implements GeneratorAccess, AutoCloseable {
-     }
- 
-     @Override
--    public Fluid getFluidIfLoaded(BlockPosition blockposition) {
-+    public final Fluid getFluidIfLoaded(BlockPosition blockposition) {
-         IChunkAccess chunk = this.getChunkIfLoadedImmediately(blockposition.getX() >> 4, blockposition.getZ() >> 4);
- 
-         return chunk == null ? null : chunk.getFluid(blockposition);
-     }
-+
-+    public final boolean isLoadedAndInBounds(BlockPosition blockposition) { // Paper - final for inline
-+        return getWorldBorder().isInBounds(blockposition) && getChunkIfLoadedImmediately(blockposition.getX() >> 4, blockposition.getZ() >> 4) != null;
-+    }
-+
-+    public Chunk getChunkIfLoaded(int x, int z) { // Overridden in WorldServer for ABI compat which has final
-+        return ((WorldServer) this).getChunkProvider().getChunkAtIfLoadedImmediately(x, z);
-+    }
-+    public final Chunk getChunkIfLoaded(BlockPosition blockposition) {
-+        return ((WorldServer) this).getChunkProvider().getChunkAtIfLoadedImmediately(blockposition.getX() >> 4, blockposition.getZ() >> 4);
-+    }
-+
-+    //  reduces need to do isLoaded before getType
-+    public final IBlockData getTypeIfLoadedAndInBounds(BlockPosition blockposition) {
-+        return getWorldBorder().isInBounds(blockposition) ? getTypeIfLoaded(blockposition) : null;
-+    }
-     // Paper end
- 
-     @Override
-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 {
- 
-     public WorldBorder() {}
- 
-+    public final boolean isInBounds(BlockPosition blockposition) { return this.a(blockposition); } // Paper - OBFHELPER
-     public boolean a(BlockPosition blockposition) {
-         return (double) (blockposition.getX() + 1) > this.e() && (double) blockposition.getX() < this.g() && (double) (blockposition.getZ() + 1) > this.f() && (double) blockposition.getZ() < this.h();
-     }

Spigot-Server-Patches/Add-a-should-burn-in-sunlight-API-for-Phantoms-and-S.patch

@@ -1,126 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MeFisto94 <MeFisto94@users.noreply.github.com>
-Date: Tue, 11 May 2021 00:48:33 +0200
-Subject: [PATCH] Add a "should burn in sunlight" API for Phantoms and
- Skeletons
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/monster/EntityPhantom.java b/src/main/java/net/minecraft/world/entity/monster/EntityPhantom.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/EntityPhantom.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/EntityPhantom.java
-@@ -0,0 +0,0 @@ public class EntityPhantom extends EntityFlying implements IMonster {
- 
-     @Override
-     public void movementTick() {
--        if (this.isAlive() && this.eG()) {
-+        if (this.isAlive() && shouldBurnInDay && this.eG()) { // Paper - Configurable Burning
-             this.setOnFire(8);
-         }
- 
-@@ -0,0 +0,0 @@ public class EntityPhantom extends EntityFlying implements IMonster {
-         if (nbttagcompound.hasUUID("Paper.SpawningEntity")) {
-             this.spawningEntity = nbttagcompound.getUUID("Paper.SpawningEntity");
-         }
-+        this.shouldBurnInDay = nbttagcompound.getBoolean("Paper.ShouldBurnInDay");
-         // Paper end
-     }
- 
-@@ -0,0 +0,0 @@ public class EntityPhantom extends EntityFlying implements IMonster {
-         if (this.spawningEntity != null) {
-             nbttagcompound.setUUID("Paper.SpawningEntity", this.spawningEntity);
-         }
-+        nbttagcompound.setBoolean("Paper.ShouldBurnInDay", shouldBurnInDay);
-         // Paper end
-     }
- 
-@@ -0,0 +0,0 @@ public class EntityPhantom extends EntityFlying implements IMonster {
-         return spawningEntity;
-     }
-     public void setSpawningEntity(java.util.UUID entity) { this.spawningEntity = entity; }
-+
-+    private boolean shouldBurnInDay = true;
-+    public boolean shouldBurnInDay() { return shouldBurnInDay; }
-+    public void setShouldBurnInDay(boolean shouldBurnInDay) { this.shouldBurnInDay = shouldBurnInDay; }
-     // Paper end
- 
-     class b extends PathfinderGoal {
-diff --git a/src/main/java/net/minecraft/world/entity/monster/EntitySkeletonAbstract.java b/src/main/java/net/minecraft/world/entity/monster/EntitySkeletonAbstract.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/EntitySkeletonAbstract.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/EntitySkeletonAbstract.java
-@@ -0,0 +0,0 @@ public abstract class EntitySkeletonAbstract extends EntityMonster implements IR
-         return EnumMonsterType.UNDEAD;
-     }
- 
-+    // Paper start
-+    private boolean shouldBurnInDay = true;
-+    public boolean shouldBurnInDay() { return shouldBurnInDay; }
-+    public void setShouldBurnInDay(boolean shouldBurnInDay) { this.shouldBurnInDay = shouldBurnInDay; }
-+    // Paper end
-+
-     @Override
-     public void movementTick() {
--        boolean flag = this.eG();
-+        boolean flag = shouldBurnInDay && this.eG(); // Paper - Configurable Burning
- 
-         if (flag) {
-             ItemStack itemstack = this.getEquipment(EnumItemSlot.HEAD);
-@@ -0,0 +0,0 @@ public abstract class EntitySkeletonAbstract extends EntityMonster implements IR
-     public void loadData(NBTTagCompound nbttagcompound) {
-         super.loadData(nbttagcompound);
-         this.eL();
-+        this.shouldBurnInDay = nbttagcompound.getBoolean("Paper.ShouldBurnInDay"); // Paper
-+    }
-+
-+    // Paper start
-+    @Override
-+    public void saveData(NBTTagCompound nbttagcompound) {
-+        super.saveData(nbttagcompound);
-+        nbttagcompound.setBoolean("Paper.ShouldBurnInDay", shouldBurnInDay);
-     }
-+    // Paper end
- 
-     @Override
-     public void setSlot(EnumItemSlot enumitemslot, ItemStack itemstack) {
-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 {
-     public java.util.UUID getSpawningEntity() {
-         return getHandle().getSpawningEntity();
-     }
-+
-+    @Override
-+    public boolean shouldBurnInDay() {
-+        return getHandle().shouldBurnInDay();
-+    }
-+
-+    @Override
-+    public void setShouldBurnInDay(boolean shouldBurnInDay) {
-+        getHandle().setShouldBurnInDay(shouldBurnInDay);
-+    }
-     // Paper end
- }
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftSkeleton.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftSkeleton.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftSkeleton.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftSkeleton.java
-@@ -0,0 +0,0 @@ public class CraftSkeleton extends CraftMonster implements Skeleton, com.destroy
-     public void setSkeletonType(SkeletonType type) {
-         throw new UnsupportedOperationException("Not supported.");
-     }
-+
-+    // Paper start
-+    @Override
-+    public boolean shouldBurnInDay() {
-+        return getHandle().shouldBurnInDay();
-+    }
-+
-+    @Override
-+    public void setShouldBurnInDay(boolean shouldBurnInDay) {
-+        getHandle().setShouldBurnInDay(shouldBurnInDay);
-+    }
-+    // Paper end
- }

Spigot-Server-Patches/Add-a-way-to-get-translation-keys-for-blocks-entitie.patch

@@ -1,126 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MeFisto94 <MeFisto94@users.noreply.github.com>
-Date: Tue, 11 Aug 2020 19:16:09 +0200
-Subject: [PATCH] Add a way to get translation keys for blocks, entities and
- materials
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/EntityTypes.java b/src/main/java/net/minecraft/world/entity/EntityTypes.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/EntityTypes.java
-+++ b/src/main/java/net/minecraft/world/entity/EntityTypes.java
-@@ -0,0 +0,0 @@ public class EntityTypes<T extends Entity> {
-         return IRegistry.ENTITY_TYPE.getKey(entitytypes);
-     }
- 
-+    public static Optional<EntityTypes<?>> getByName(String name) { return a(name); } // Paper - OBFHELPER
-     public static Optional<EntityTypes<?>> a(String s) {
-         return IRegistry.ENTITY_TYPE.getOptional(MinecraftKey.a(s));
-     }
-@@ -0,0 +0,0 @@ public class EntityTypes<T extends Entity> {
-         return this.bg;
-     }
- 
-+    public String getDescriptionId() { return f(); } // Paper - OBFHELPER
-     public String f() {
-         if (this.bo == null) {
-             this.bo = SystemUtils.a("entity", IRegistry.ENTITY_TYPE.getKey(this));
-diff --git a/src/main/java/net/minecraft/world/item/Item.java b/src/main/java/net/minecraft/world/item/Item.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/item/Item.java
-+++ b/src/main/java/net/minecraft/world/item/Item.java
-@@ -0,0 +0,0 @@ public class Item implements IMaterial {
-     private final FoodInfo foodInfo;
- 
-     public static int getId(Item item) {
--        return item == null ? 0 : IRegistry.ITEM.a((Object) item);
-+        return item == null ? 0 : IRegistry.ITEM.a(item);  // Paper - Fix Decompiler Issue
-     }
- 
-     public static Item getById(int i) {
-@@ -0,0 +0,0 @@ public class Item implements IMaterial {
-         return IRegistry.ITEM.getKey(this).getKey();
-     }
- 
-+    public String getOrCreateDescriptionId() { return m(); } // Paper - OBFHELPER
-     protected String m() {
-         if (this.name == null) {
-             this.name = SystemUtils.a("item", IRegistry.ITEM.getKey(this));
-@@ -0,0 +0,0 @@ public class Item implements IMaterial {
-         return this.m();
-     }
- 
-+    public String getDescriptionId(ItemStack itemStack) { return f(itemStack); } // Paper - OBFHELPER
-     public String f(ItemStack itemstack) {
-         return this.getName();
-     }
-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 BlockBase implements IMaterial {
-         return !this.material.isBuildable() && !this.material.isLiquid();
-     }
- 
-+    public String getOrCreateDescriptionId() { return i(); } // Paper - OBFHELPER
-     public String i() {
-         if (this.name == null) {
-             this.name = SystemUtils.a("block", IRegistry.BLOCK.getKey(this));
-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 {
-     public com.destroystokyo.paper.block.BlockSoundGroup getSoundGroup() {
-         return new com.destroystokyo.paper.block.CraftBlockSoundGroup(getNMSBlock().getBlockData().getStepSound());
-     }
-+
-+    @Override
-+    public String getTranslationKey() {
-+        return org.bukkit.Bukkit.getUnsafe().getTranslationKey(this);
-+    }
-     // Paper end
- }
-diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
-+++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
-@@ -0,0 +0,0 @@ import org.bukkit.Registry;
- import org.bukkit.UnsafeValues;
- import org.bukkit.advancement.Advancement;
- import org.bukkit.block.data.BlockData;
-+import org.bukkit.craftbukkit.block.CraftBlock;
- import org.bukkit.craftbukkit.block.data.CraftBlockData;
- import org.bukkit.craftbukkit.inventory.CraftItemStack;
- import org.bukkit.craftbukkit.legacy.CraftLegacy;
-@@ -0,0 +0,0 @@ public final class CraftMagicNumbers implements UnsafeValues {
-             throw new RuntimeException();
-         }
-     }
-+
-+    @Override
-+    public String getTranslationKey(Material mat) {
-+        if (mat.isBlock()) {
-+            return getBlock(mat).getOrCreateDescriptionId();
-+        }
-+        return getItem(mat).getName();
-+    }
-+
-+    @Override
-+    public String getTranslationKey(org.bukkit.block.Block block) {
-+        return ((org.bukkit.craftbukkit.block.CraftBlock)block).getNMS().getBlock().getOrCreateDescriptionId();
-+    }
-+
-+    @Override
-+    public String getTranslationKey(org.bukkit.entity.EntityType type) {
-+        return net.minecraft.world.entity.EntityTypes.getByName(type.getName()).map(net.minecraft.world.entity.EntityTypes::getDescriptionId).orElse(null);
-+    }
-+
-+    @Override
-+    public String getTranslationKey(org.bukkit.inventory.ItemStack itemStack) {
-+        net.minecraft.world.item.ItemStack nmsItemStack = CraftItemStack.asNMSCopy(itemStack);
-+        return nmsItemStack.getItem().getDescriptionId(nmsItemStack);
-+    }
-     // Paper end
- 
-     /**

Spigot-Server-Patches/Add-ability-to-configure-frosted_ice-properties.patch

@@ -1,52 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Riley Park <rileysebastianpark@gmail.com>
-Date: Thu, 21 Apr 2016 23:51:55 -0700
-Subject: [PATCH] Add ability to configure frosted_ice properties
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void useVanillaScoreboardColoring() {
-         useVanillaScoreboardColoring = getBoolean("use-vanilla-world-scoreboard-name-coloring", false);
-     }
-+
-+    public boolean frostedIceEnabled = true;
-+    public int frostedIceDelayMin = 20;
-+    public int frostedIceDelayMax = 40;
-+    private void frostedIce() {
-+        this.frostedIceEnabled = this.getBoolean("frosted-ice.enabled", this.frostedIceEnabled);
-+        this.frostedIceDelayMin = this.getInt("frosted-ice.delay.min", this.frostedIceDelayMin);
-+        this.frostedIceDelayMax = this.getInt("frosted-ice.delay.max", this.frostedIceDelayMax);
-+        log("Frosted Ice: " + (this.frostedIceEnabled ? "enabled" : "disabled") + " / delay: min=" + this.frostedIceDelayMin + ", max=" + this.frostedIceDelayMax);
-+    }
- }
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockIceFrost.java b/src/main/java/net/minecraft/world/level/block/BlockIceFrost.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockIceFrost.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockIceFrost.java
-@@ -0,0 +0,0 @@ public class BlockIceFrost extends BlockIce {
- 
-     @Override
-     public void tickAlways(IBlockData iblockdata, WorldServer worldserver, BlockPosition blockposition, Random random) {
-+        if (!worldserver.paperConfig.frostedIceEnabled) return; // Paper - add ability to disable frosted ice
-         if ((random.nextInt(3) == 0 || this.a(worldserver, blockposition, 4)) && worldserver.getLightLevel(blockposition) > 11 - (Integer) iblockdata.get(BlockIceFrost.a) - iblockdata.b((IBlockAccess) worldserver, blockposition) && this.e(iblockdata, (World) worldserver, blockposition)) {
-             BlockPosition.MutableBlockPosition blockposition_mutableblockposition = new BlockPosition.MutableBlockPosition();
-             EnumDirection[] aenumdirection = EnumDirection.values();
-@@ -0,0 +0,0 @@ public class BlockIceFrost extends BlockIce {
-                 IBlockData iblockdata1 = worldserver.getType(blockposition_mutableblockposition);
- 
-                 if (iblockdata1.a((Block) this) && !this.e(iblockdata1, (World) worldserver, blockposition_mutableblockposition)) {
--                    worldserver.getBlockTickList().a(blockposition_mutableblockposition, this, MathHelper.nextInt(random, 20, 40));
-+                    worldserver.getBlockTickList().a(blockposition_mutableblockposition, this, MathHelper.nextInt(random, worldserver.paperConfig.frostedIceDelayMin, worldserver.paperConfig.frostedIceDelayMax)); // Paper - use configurable min/max delay
-                 }
-             }
- 
-         } else {
--            worldserver.getBlockTickList().a(blockposition, this, MathHelper.nextInt(random, 20, 40));
-+            worldserver.getBlockTickList().a(blockposition, this, MathHelper.nextInt(random, worldserver.paperConfig.frostedIceDelayMin, worldserver.paperConfig.frostedIceDelayMax)); // Paper - use configurable min/max delay
-         }
-     }
- 

Spigot-Server-Patches/Add-additional-open-container-api-to-HumanEntity.patch

@@ -1,81 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Josh Roy <10731363+JRoy@users.noreply.github.com>
-Date: Wed, 26 Aug 2020 02:12:31 -0400
-Subject: [PATCH] Add additional open container api 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 {
-         return this.getHandle().activeContainer.getBukkitView();
-     }
- 
-+    // Paper start - Add additional containers
-+    @Override
-+    public InventoryView openAnvil(Location location, boolean force) {
-+        return openInventory(location, force, Material.ANVIL);
-+    }
-+
-+    @Override
-+    public InventoryView openCartographyTable(Location location, boolean force) {
-+        return openInventory(location, force, Material.CARTOGRAPHY_TABLE);
-+    }
-+
-+    @Override
-+    public InventoryView openGrindstone(Location location, boolean force) {
-+        return openInventory(location, force, Material.GRINDSTONE);
-+    }
-+
-+    @Override
-+    public InventoryView openLoom(Location location, boolean force) {
-+        return openInventory(location, force, Material.LOOM);
-+    }
-+
-+    @Override
-+    public InventoryView openSmithingTable(Location location, boolean force) {
-+        return openInventory(location, force, Material.SMITHING_TABLE);
-+    }
-+
-+    @Override
-+    public InventoryView openStonecutter(Location location, boolean force) {
-+        return openInventory(location, force, Material.STONECUTTER);
-+    }
-+
-+    private InventoryView openInventory(Location location, boolean force, Material material) {
-+        org.spigotmc.AsyncCatcher.catchOp("open" + material);
-+        if (location == null) {
-+            location = getLocation();
-+        }
-+        if (!force) {
-+            Block block = location.getBlock();
-+            if (block.getType() != material) {
-+                return null;
-+            }
-+        }
-+        net.minecraft.world.level.block.Block block;
-+        if (material == Material.ANVIL) {
-+            block = Blocks.ANVIL;
-+        } else if (material == Material.CARTOGRAPHY_TABLE) {
-+            block = Blocks.CARTOGRAPHY_TABLE;
-+        } else if (material == Material.GRINDSTONE) {
-+            block = Blocks.GRINDSTONE;
-+        } else if (material == Material.LOOM) {
-+            block = Blocks.LOOM;
-+        } else if (material == Material.SMITHING_TABLE) {
-+            block = Blocks.SMITHING_TABLE;
-+        } else if (material == Material.STONECUTTER) {
-+            block = Blocks.STONECUTTER;
-+        } else {
-+            throw new IllegalArgumentException("Unsupported inventory type: " + material);
-+        }
-+        getHandle().openContainer(block.getInventory(null, getHandle().world, new BlockPosition(location.getBlockX(), location.getBlockY(), location.getBlockZ())));
-+        getHandle().activeContainer.checkReachable = !force;
-+        return getHandle().activeContainer.getBukkitView();
-+    }
-+    // Paper end
-+
-     @Override
-     public void closeInventory() {
-         // Paper start

Spigot-Server-Patches/Add-and-implement-PlayerRecipeBookClickEvent.patch

@@ -1,29 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Josh Roy <10731363+JRoy@users.noreply.github.com>
-Date: Fri, 5 Jun 2020 18:24:06 -0400
-Subject: [PATCH] Add and implement PlayerRecipeBookClickEvent
-
-
-diff --git a/src/main/java/net/minecraft/server/network/PlayerConnection.java b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/PlayerConnection.java
-+++ b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-         PlayerConnectionUtils.ensureMainThread(packetplayinautorecipe, this, this.player.getWorldServer());
-         this.player.resetIdleTimer();
-         if (!this.player.isSpectator() && this.player.activeContainer.windowId == packetplayinautorecipe.b() && this.player.activeContainer.c(this.player) && this.player.activeContainer instanceof ContainerRecipeBook) {
--            this.minecraftServer.getCraftingManager().getRecipe(packetplayinautorecipe.c()).ifPresent((irecipe) -> {
--                ((ContainerRecipeBook) this.player.activeContainer).a(packetplayinautorecipe.d(), irecipe, this.player);
--            });
-+            // Paper start - fire event for clicking recipes in the recipe book
-+            com.destroystokyo.paper.event.player.PlayerRecipeBookClickEvent event = new com.destroystokyo.paper.event.player.PlayerRecipeBookClickEvent(
-+                player.getBukkitEntity(), org.bukkit.craftbukkit.util.CraftNamespacedKey.fromMinecraft(packetplayinautorecipe.c()), packetplayinautorecipe.d());
-+            if (event.callEvent()) {
-+                this.minecraftServer.getCraftingManager().getRecipe(org.bukkit.craftbukkit.util.CraftNamespacedKey.toMinecraft(event.getRecipe())).ifPresent((irecipe) -> {
-+                    ((ContainerRecipeBook) this.player.activeContainer).a(event.isMakeAll(), irecipe, this.player);
-+                });
-+            }
-+            // Paper end
-         }
-     }
- 

Spigot-Server-Patches/Add-basic-Datapack-API.patch

@@ -1,175 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Connor Linfoot <connorlinfoot@me.com>
-Date: Sun, 16 May 2021 15:07:34 +0100
-Subject: [PATCH] Add basic Datapack API
-
-
-diff --git a/src/main/java/io/papermc/paper/datapack/PaperDatapack.java b/src/main/java/io/papermc/paper/datapack/PaperDatapack.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/io/papermc/paper/datapack/PaperDatapack.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.datapack;
-+
-+import io.papermc.paper.event.server.ServerResourcesReloadedEvent;
-+import net.minecraft.server.MinecraftServer;
-+import net.minecraft.server.packs.repository.ResourcePackLoader;
-+
-+import java.util.List;
-+import java.util.stream.Collectors;
-+
-+public class PaperDatapack implements Datapack {
-+    private final String name;
-+    private final Compatibility compatibility;
-+    private final boolean enabled;
-+
-+    PaperDatapack(ResourcePackLoader loader, boolean enabled) {
-+        this.name = loader.getName();
-+        this.compatibility = Compatibility.valueOf(loader.getVersion().name());
-+        this.enabled = enabled;
-+    }
-+
-+    @Override
-+    public String getName() {
-+        return name;
-+    }
-+
-+    @Override
-+    public Compatibility getCompatibility() {
-+        return compatibility;
-+    }
-+
-+    @Override
-+    public boolean isEnabled() {
-+        return enabled;
-+    }
-+
-+    @Override
-+    public void setEnabled(boolean enabled) {
-+        if (enabled == this.enabled) {
-+            return;
-+        }
-+
-+        MinecraftServer server = MinecraftServer.getServer();
-+        List<String> enabledKeys = server.getResourcePackRepository().getEnabledPacks().stream().map(ResourcePackLoader::getName).collect(Collectors.toList());
-+        if (enabled) {
-+            enabledKeys.add(this.name);
-+        } else {
-+            enabledKeys.remove(this.name);
-+        }
-+        server.reloadServerResources(enabledKeys, ServerResourcesReloadedEvent.Cause.PLUGIN);
-+    }
-+}
-diff --git a/src/main/java/io/papermc/paper/datapack/PaperDatapackManager.java b/src/main/java/io/papermc/paper/datapack/PaperDatapackManager.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/io/papermc/paper/datapack/PaperDatapackManager.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.datapack;
-+
-+import net.minecraft.server.packs.repository.ResourcePackLoader;
-+import net.minecraft.server.packs.repository.ResourcePackRepository;
-+
-+import java.util.Collection;
-+import java.util.stream.Collectors;
-+
-+public class PaperDatapackManager implements DatapackManager {
-+    private final ResourcePackRepository repository;
-+
-+    public PaperDatapackManager(ResourcePackRepository repository) {
-+        this.repository = repository;
-+    }
-+
-+    @Override
-+    public Collection<Datapack> getPacks() {
-+        Collection<ResourcePackLoader> enabledPacks = repository.getEnabledPacks();
-+        return repository.getPacks().stream().map(loader -> new PaperDatapack(loader, enabledPacks.contains(loader))).collect(Collectors.toList());
-+    }
-+
-+    @Override
-+    public Collection<Datapack> getEnabledPacks() {
-+        return repository.getEnabledPacks().stream().map(loader -> new PaperDatapack(loader, true)).collect(Collectors.toList());
-+    }
-+}
-diff --git a/src/main/java/net/minecraft/server/packs/repository/ResourcePackLoader.java b/src/main/java/net/minecraft/server/packs/repository/ResourcePackLoader.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/packs/repository/ResourcePackLoader.java
-+++ b/src/main/java/net/minecraft/server/packs/repository/ResourcePackLoader.java
-@@ -0,0 +0,0 @@ public class ResourcePackLoader implements AutoCloseable {
-         });
-     }
- 
-+    public final EnumResourcePackVersion getVersion() { return this.c(); } // Paper - OBFHELPER
-     public EnumResourcePackVersion c() {
-         return this.g;
-     }
-@@ -0,0 +0,0 @@ public class ResourcePackLoader implements AutoCloseable {
-         return (IResourcePack) this.d.get();
-     }
- 
-+    public final String getName() { return this.e(); } // Paper - OBFHELPER
-     public String e() {
-         return this.c;
-     }
-diff --git a/src/main/java/net/minecraft/server/packs/repository/ResourcePackRepository.java b/src/main/java/net/minecraft/server/packs/repository/ResourcePackRepository.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/packs/repository/ResourcePackRepository.java
-+++ b/src/main/java/net/minecraft/server/packs/repository/ResourcePackRepository.java
-@@ -0,0 +0,0 @@ public class ResourcePackRepository implements AutoCloseable {
-         return this.b.keySet();
-     }
- 
-+    public final Collection<ResourcePackLoader> getPacks() { return this.c(); } // Paper - OBFHELPER
-     public Collection<ResourcePackLoader> c() {
-         return this.b.values();
-     }
-@@ -0,0 +0,0 @@ public class ResourcePackRepository implements AutoCloseable {
-         return (Collection) this.c.stream().map(ResourcePackLoader::e).collect(ImmutableSet.toImmutableSet());
-     }
- 
-+    public final Collection<ResourcePackLoader> getEnabledPacks() { return this.e(); } // Paper - OBFHELPER
-     public Collection<ResourcePackLoader> e() {
-         return this.c;
-     }
-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 com.mojang.serialization.Lifecycle;
- import io.netty.buffer.ByteBuf;
- import io.netty.buffer.ByteBufOutputStream;
- import io.netty.buffer.Unpooled;
-+import io.papermc.paper.datapack.PaperDatapackManager; // Paper
- import io.papermc.paper.util.TraceUtil;
- import it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap;
- import java.awt.image.BufferedImage;
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-     public boolean ignoreVanillaPermissions = false;
-     private final List<CraftPlayer> playerView;
-     public int reloadCount;
-+    private final PaperDatapackManager datapackManager; // Paper
-     public static Exception excessiveVelEx; // Paper - Velocity warnings
- 
-     static {
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-         TicketType.PLUGIN.loadPeriod = Math.min(20, configuration.getInt("chunk-gc.period-in-ticks")); // Paper - cap plugin loads to 1 second
-         minimumAPI = configuration.getString("settings.minimum-api");
-         loadIcon();
-+        datapackManager = new PaperDatapackManager(console.getResourcePackRepository()); // Paper
-     }
- 
-     public boolean getCommandBlockOverride(String command) {
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-     public com.destroystokyo.paper.entity.ai.MobGoals getMobGoals() {
-         return mobGoals;
-     }
-+
-+    @Override
-+    public PaperDatapackManager getDatapackManager() {
-+        return datapackManager;
-+    }
-+
-     // Paper end
- }

Spigot-Server-Patches/Add-bypass-host-check.patch

@@ -1,30 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Shane Freeder <theboyetronic@gmail.com>
-Date: Sun, 18 Apr 2021 21:27:01 +0100
-Subject: [PATCH] Add bypass host check
-
-Paper.bypassHostCheck
-
-Seriously, fix your firewalls. -.-
-
-diff --git a/src/main/java/net/minecraft/server/network/HandshakeListener.java b/src/main/java/net/minecraft/server/network/HandshakeListener.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/HandshakeListener.java
-+++ b/src/main/java/net/minecraft/server/network/HandshakeListener.java
-@@ -0,0 +0,0 @@ public class HandshakeListener implements PacketHandshakingInListener {
-     private static final IChatBaseComponent a = new ChatComponentText("Ignoring status request");
-     private final MinecraftServer b;
-     private final NetworkManager c; final NetworkManager getNetworkManager() { return this.c; } // Paper - OBFHELPER
-+    private static final boolean BYPASS_HOSTCHECK = Boolean.getBoolean("Paper.bypassHostCheck"); // Paper
- 
-     public HandshakeListener(MinecraftServer minecraftserver, NetworkManager networkmanager) {
-         this.b = minecraftserver;
-@@ -0,0 +0,0 @@ public class HandshakeListener implements PacketHandshakingInListener {
-                     // Spigot Start
-                 //if (org.spigotmc.SpigotConfig.bungee) { // Paper - comment out, we check above!
-                         String[] split = packethandshakinginsetprotocol.hostname.split("\00");
--                        if ( ( split.length == 3 || split.length == 4 ) && ( HOST_PATTERN.matcher( split[1] ).matches() ) ) {
-+                        if ( ( split.length == 3 || split.length == 4 ) && ( BYPASS_HOSTCHECK || HOST_PATTERN.matcher( split[1] ).matches() ) ) { // Paper
-                             packethandshakinginsetprotocol.hostname = split[0];
-                             c.socketAddress = new java.net.InetSocketAddress(split[1], ((java.net.InetSocketAddress) c.getSocketAddress()).getPort());
-                             c.spoofedUUID = com.mojang.util.UUIDTypeAdapter.fromString( split[2] );

Spigot-Server-Patches/Add-cause-to-Weather-ThunderChangeEvents.patch

@@ -1,118 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Wed, 2 Dec 2020 18:23:26 -0800
-Subject: [PATCH] Add cause to Weather/ThunderChangeEvents
-
-
-diff --git a/src/main/java/net/minecraft/server/level/WorldServer.java b/src/main/java/net/minecraft/server/level/WorldServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/WorldServer.java
-+++ b/src/main/java/net/minecraft/server/level/WorldServer.java
-@@ -0,0 +0,0 @@ public class WorldServer extends World implements GeneratorAccessSeed {
-         this.worldDataServer.setClearWeatherTime(i);
-         this.worldDataServer.setWeatherDuration(j);
-         this.worldDataServer.setThunderDuration(j);
--        this.worldDataServer.setStorm(flag);
--        this.worldDataServer.setThundering(flag1);
-+        this.worldDataServer.setStorm(flag, org.bukkit.event.weather.WeatherChangeEvent.Cause.COMMAND); // Paper
-+        this.worldDataServer.setThundering(flag1, org.bukkit.event.weather.ThunderChangeEvent.Cause.COMMAND); // Paper
-     }
- 
-     public BiomeBase getBiomeBySeed(int i, int j, int k) { return a(i, j, k); } // Paper - OBFHELPER
-@@ -0,0 +0,0 @@ public class WorldServer extends World implements GeneratorAccessSeed {
-                 this.worldDataServer.setThunderDuration(j);
-                 this.worldDataServer.setWeatherDuration(k);
-                 this.worldDataServer.setClearWeatherTime(i);
--                this.worldDataServer.setThundering(flag1);
--                this.worldDataServer.setStorm(flag2);
-+                this.worldDataServer.setThundering(flag1, org.bukkit.event.weather.ThunderChangeEvent.Cause.NATURAL); // Paper
-+                this.worldDataServer.setStorm(flag2, org.bukkit.event.weather.WeatherChangeEvent.Cause.NATURAL); // Paper
-             }
- 
-             this.lastThunderLevel = this.thunderLevel;
-@@ -0,0 +0,0 @@ public class WorldServer extends World implements GeneratorAccessSeed {
- 
-     private void clearWeather() {
-         // CraftBukkit start
--        this.worldDataServer.setStorm(false);
-+        this.worldDataServer.setStorm(false, org.bukkit.event.weather.WeatherChangeEvent.Cause.SLEEP); // Paper - when passing the night
-         // If we stop due to everyone sleeping we should reset the weather duration to some other random value.
-         // Not that everyone ever manages to get the whole server to sleep at the same time....
-         if (!this.worldDataServer.hasStorm()) {
-             this.worldDataServer.setWeatherDuration(0);
-         }
-         // CraftBukkit end
--        this.worldDataServer.setThundering(false);
-+        this.worldDataServer.setThundering(false, org.bukkit.event.weather.ThunderChangeEvent.Cause.SLEEP); // Paper - when passing the night
-         // CraftBukkit start
-         // If we stop due to everyone sleeping we should reset the weather duration to some other random value.
-         // Not that everyone ever manages to get the whole server to sleep at the same time....
-diff --git a/src/main/java/net/minecraft/world/level/storage/WorldDataServer.java b/src/main/java/net/minecraft/world/level/storage/WorldDataServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/storage/WorldDataServer.java
-+++ b/src/main/java/net/minecraft/world/level/storage/WorldDataServer.java
-@@ -0,0 +0,0 @@ public class WorldDataServer implements IWorldDataServer, SaveData {
- 
-     @Override
-     public void setThundering(boolean flag) {
-+        // Paper start
-+        this.setThundering(flag, org.bukkit.event.weather.ThunderChangeEvent.Cause.UNKNOWN);
-+    }
-+    public void setThundering(boolean flag, org.bukkit.event.weather.ThunderChangeEvent.Cause cause) {
-+        // Paper end
-         // CraftBukkit start
-         if (this.thundering == flag) {
-             return;
-@@ -0,0 +0,0 @@ public class WorldDataServer implements IWorldDataServer, SaveData {
- 
-         org.bukkit.World world = Bukkit.getWorld(getName());
-         if (world != null) {
--            ThunderChangeEvent thunder = new ThunderChangeEvent(world, flag);
-+            ThunderChangeEvent thunder = new ThunderChangeEvent(world, flag, cause); // Paper
-             Bukkit.getServer().getPluginManager().callEvent(thunder);
-             if (thunder.isCancelled()) {
-                 return;
-@@ -0,0 +0,0 @@ public class WorldDataServer implements IWorldDataServer, SaveData {
- 
-     @Override
-     public void setStorm(boolean flag) {
-+        // Paper start
-+        this.setStorm(flag, org.bukkit.event.weather.WeatherChangeEvent.Cause.UNKNOWN);
-+    }
-+
-+    public void setStorm(boolean flag, org.bukkit.event.weather.WeatherChangeEvent.Cause cause) {
-+        // Paper end
-         // CraftBukkit start
-         if (this.raining == flag) {
-             return;
-@@ -0,0 +0,0 @@ public class WorldDataServer implements IWorldDataServer, SaveData {
- 
-         org.bukkit.World world = Bukkit.getWorld(getName());
-         if (world != null) {
--            WeatherChangeEvent weather = new WeatherChangeEvent(world, flag);
-+            WeatherChangeEvent weather = new WeatherChangeEvent(world, flag, cause); // Paper
-             Bukkit.getServer().getPluginManager().callEvent(weather);
-             if (weather.isCancelled()) {
-                 return;
-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 implements World {
- 
-     @Override
-     public void setStorm(boolean hasStorm) {
--        world.worldData.setStorm(hasStorm);
-+        world.worldDataServer.setStorm(hasStorm, org.bukkit.event.weather.WeatherChangeEvent.Cause.PLUGIN); // Paper
-         setWeatherDuration(0); // Reset weather duration (legacy behaviour)
-         setClearWeatherDuration(0); // Reset clear weather duration (reset "/weather clear" commands)
-     }
-@@ -0,0 +0,0 @@ public class CraftWorld implements World {
- 
-     @Override
-     public void setThundering(boolean thundering) {
--        world.worldDataServer.setThundering(thundering);
-+        world.worldDataServer.setThundering(thundering, org.bukkit.event.weather.ThunderChangeEvent.Cause.PLUGIN); // Paper
-         setThunderDuration(0); // Reset weather duration (legacy behaviour)
-         setClearWeatherDuration(0); // Reset clear weather duration (reset "/weather clear" commands)
-     }

Spigot-Server-Patches/Add-command-line-option-to-load-extra-plugin-jars-no.patch

@@ -1,64 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
-Date: Tue, 18 May 2021 14:39:44 -0700
-Subject: [PATCH] Add command line option to load extra plugin jars not in the
- plugins folder
-
-ex: java -jar paperclip.jar nogui -add-plugin=/path/to/plugin.jar -add-plugin=/path/to/another/plugin_jar.jar
-
-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 {
- 
-         File pluginFolder = (File) console.options.valueOf("plugins");
- 
--        if (pluginFolder.exists()) {
--            Plugin[] plugins = pluginManager.loadPlugins(pluginFolder);
-+        // Paper start
-+        if (true || pluginFolder.exists()) {
-+            if (!pluginFolder.exists()) {
-+                pluginFolder.mkdirs();
-+            }
-+            Plugin[] plugins = pluginManager.loadPlugins(pluginFolder, this.extraPluginJars());
-+            // Paper end
-             for (Plugin plugin : plugins) {
-                 try {
-                     String message = String.format("Loading %s", plugin.getDescription().getFullName());
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-         }
-     }
- 
-+    // Paper start
-+    private List<File> extraPluginJars() {
-+        @SuppressWarnings("unchecked")
-+        final List<File> jars = (List<File>) this.console.options.valuesOf("add-plugin");
-+        return jars.stream()
-+            .filter(File::exists)
-+            .filter(File::isFile)
-+            .filter(file -> file.getName().endsWith(".jar"))
-+            .collect(java.util.stream.Collectors.toList());
-+    }
-+    // Paper end
-+
-     public void enablePlugins(PluginLoadOrder type) {
-         if (type == PluginLoadOrder.STARTUP) {
-             helpMap.clear();
-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 {
-                         .ofType(String.class)
-                         .defaultsTo("Unknown Server")
-                         .describedAs("Name");
-+
-+                acceptsAll(asList("add-plugin", "add-extra-plugin-jar"))
-+                        .withRequiredArg()
-+                        .ofType(File.class)
-+                        .defaultsTo(new File[] {})
-+                        .describedAs("Specify paths to extra plugin jars to be loaded in addition to those in the plugins folder. This argument can be specified multiple times, once for each extra plugin jar path.");
-                 // Paper end
-             }
-         };

Spigot-Server-Patches/Add-config-to-disable-ender-dragon-legacy-check.patch

@@ -1,44 +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/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void shieldBlockingDelay() {
-         shieldBlockingDelay = getInt("game-mechanics.shield-blocking-delay", 5);
-     }
-+
-+    public boolean scanForLegacyEnderDragon = true;
-+    private void scanForLegacyEnderDragon() {
-+        scanForLegacyEnderDragon = getBoolean("game-mechanics.scan-for-legacy-ender-dragon", true);
-+    }
- }
-diff --git a/src/main/java/net/minecraft/world/level/dimension/end/EnderDragonBattle.java b/src/main/java/net/minecraft/world/level/dimension/end/EnderDragonBattle.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/dimension/end/EnderDragonBattle.java
-+++ b/src/main/java/net/minecraft/world/level/dimension/end/EnderDragonBattle.java
-@@ -0,0 +0,0 @@ public class EnderDragonBattle {
-     private boolean dragonKilled;
-     private boolean previouslyKilled;
-     public UUID dragonUUID;
--    private boolean n;
-+    private boolean n; private void setScanForLegacyFight(boolean scanForLegacyFight) { this.n = scanForLegacyFight; } private boolean scanForLegacyFight() { return this.n; } // Paper - OBFHELPER
-     public BlockPosition exitPortalLocation;
-     public EnumDragonRespawn respawnPhase;
-     private int q;
-@@ -0,0 +0,0 @@ public class EnderDragonBattle {
-         this.bossBattle = (BossBattleServer) (new BossBattleServer(new ChatMessage("entity.minecraft.ender_dragon"), BossBattle.BarColor.PINK, BossBattle.BarStyle.PROGRESS)).setPlayMusic(true).c(true);
-         this.gateways = Lists.newArrayList();
-         this.n = true;
-+        // Paper start
-+        setScanForLegacyFight(worldserver.paperConfig.scanForLegacyEnderDragon);
-+        if (!scanForLegacyFight()) dragonKilled = true;
-+        // Paper end
-         this.world = worldserver;
-         if (nbttagcompound.hasKeyOfType("DragonKilled", 99)) {
-             if (nbttagcompound.b("Dragon")) {

Spigot-Server-Patches/Add-configurable-despawn-distances-for-living-entiti.patch

@@ -1,55 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Suddenly <suddenly@suddenly.coffee>
-Date: Tue, 1 Mar 2016 13:51:54 -0600
-Subject: [PATCH] Add configurable despawn distances for living entities
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void nerfedMobsShouldJump() {
-         nerfedMobsShouldJump = getBoolean("spawner-nerfed-mobs-should-jump", false);
-     }
-+
-+    public int softDespawnDistance;
-+    public int hardDespawnDistance;
-+    private void despawnDistances() {
-+        softDespawnDistance = getInt("despawn-ranges.soft", 32); // 32^2 = 1024, Minecraft Default
-+        hardDespawnDistance = getInt("despawn-ranges.hard", 128); // 128^2 = 16384, Minecraft Default
-+
-+        if (softDespawnDistance > hardDespawnDistance) {
-+            softDespawnDistance = hardDespawnDistance;
-+        }
-+
-+        log("Living Entity Despawn Ranges:  Soft: " + softDespawnDistance + " Hard: " + hardDespawnDistance);
-+
-+        softDespawnDistance = softDespawnDistance*softDespawnDistance;
-+        hardDespawnDistance = hardDespawnDistance*hardDespawnDistance;
-+    }
- }
-diff --git a/src/main/java/net/minecraft/world/entity/EntityInsentient.java b/src/main/java/net/minecraft/world/entity/EntityInsentient.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/EntityInsentient.java
-+++ b/src/main/java/net/minecraft/world/entity/EntityInsentient.java
-@@ -0,0 +0,0 @@ public abstract class EntityInsentient extends EntityLiving {
-                 int i = this.getEntityType().e().f();
-                 int j = i * i;
- 
--                if (d0 > (double) j) { // CraftBukkit - remove isTypeNotPersistent() check
-+                if (d0 > (double) world.paperConfig.hardDespawnDistance) { // CraftBukkit - remove isTypeNotPersistent() check // Paper - custom despawn distances
-                     this.die();
-                 }
- 
-                 int k = this.getEntityType().e().g();
-                 int l = k * k;
- 
--                if (this.ticksFarFromPlayer > 600 && this.random.nextInt(800) == 0 && d0 > (double) l) { // CraftBukkit - remove isTypeNotPersistent() check
-+                if (this.ticksFarFromPlayer > 600 && this.random.nextInt(800) == 0 && d0 > world.paperConfig.softDespawnDistance) { // CraftBukkit - remove isTypeNotPersistent() check // Paper - custom despawn distances
-                     this.die();
--                } else if (d0 < (double) l) {
-+                } else if (d0 < world.paperConfig.softDespawnDistance) { // Paper - custom despawn distances
-                     this.ticksFarFromPlayer = 0;
-                 }
-             }

Spigot-Server-Patches/Add-configurable-portal-search-radius.patch

@@ -1,56 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Joseph Hirschfeld <joe@ibj.io>
-Date: Thu, 3 Mar 2016 02:46:17 -0600
-Subject: [PATCH] Add configurable portal search radius
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void allChunksAreSlimeChunks() {
-         allChunksAreSlimeChunks = getBoolean("all-chunks-are-slime-chunks", false);
-     }
-+
-+    public int portalSearchRadius;
-+    public int portalCreateRadius;
-+    public boolean portalSearchVanillaDimensionScaling;
-+    private void portalSearchRadius() {
-+        portalSearchRadius = getInt("portal-search-radius", 128);
-+        portalCreateRadius = getInt("portal-create-radius", 16);
-+        portalSearchVanillaDimensionScaling = getBoolean("portal-search-vanilla-dimension-scaling", true);
-+    }
- }
-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 INamableTileEntity, ICommandListener, ne
-                 double d4 = DimensionManager.a(this.world.getDimensionManager(), worldserver.getDimensionManager());
-                 BlockPosition blockposition = new BlockPosition(MathHelper.a(this.locX() * d4, d0, d2), this.locY(), MathHelper.a(this.locZ() * d4, d1, d3));
-                 // CraftBukkit start
--                CraftPortalEvent event = callPortalEvent(this, worldserver, blockposition, PlayerTeleportEvent.TeleportCause.NETHER_PORTAL, flag2 ? 16 : 128, 16);
-+                // Paper start
-+                int portalSearchRadius = worldserver.paperConfig.portalSearchRadius;
-+                if (world.paperConfig.portalSearchVanillaDimensionScaling && flag2) { // == THE_NETHER
-+                    portalSearchRadius = (int) (portalSearchRadius / worldserver.getDimensionManager().getCoordinateScale());
-+                }
-+                // Paper end
-+                CraftPortalEvent event = callPortalEvent(this, worldserver, blockposition, PlayerTeleportEvent.TeleportCause.NETHER_PORTAL, portalSearchRadius, worldserver.paperConfig.portalCreateRadius); // Paper start - configurable portal radius
-                 if (event == null) {
-                     return null;
-                 }
-diff --git a/src/main/java/net/minecraft/world/level/portal/PortalTravelAgent.java b/src/main/java/net/minecraft/world/level/portal/PortalTravelAgent.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/portal/PortalTravelAgent.java
-+++ b/src/main/java/net/minecraft/world/level/portal/PortalTravelAgent.java
-@@ -0,0 +0,0 @@ public class PortalTravelAgent {
- 
-     public Optional<BlockUtil.Rectangle> findPortal(BlockPosition blockposition, boolean flag) {
-         // CraftBukkit start
--        return findPortal(blockposition, flag ? 16 : 128); // Search Radius
-+        return findPortal(blockposition, flag ? world.paperConfig.portalCreateRadius : world.paperConfig.portalSearchRadius); // Paper - search Radius
-     }
- 
-     public Optional<BlockUtil.Rectangle> findPortal(BlockPosition blockposition, int i) {

Spigot-Server-Patches/Add-configuration-option-to-prevent-player-names-fro.patch

@@ -1,36 +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/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-         flyingKickPlayerMessage = getString("messages.kick.flying-player", flyingKickPlayerMessage);
-         flyingKickVehicleMessage = getString("messages.kick.flying-vehicle", flyingKickVehicleMessage);
-     }
-+
-+    public static boolean suggestPlayersWhenNullTabCompletions = true;
-+    private static void suggestPlayersWhenNull() {
-+        suggestPlayersWhenNullTabCompletions = getBoolean("settings.suggest-player-names-when-null-tab-completions", suggestPlayersWhenNullTabCompletions);
-+    }
- }
-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 com.destroystokyo.paper.PaperConfig.suggestPlayersWhenNullTabCompletions;
-+    }
-     // Paper end
- }

Spigot-Server-Patches/Add-dropLeash-variable-to-EntityUnleashEvent.patch

@@ -1,156 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Nassim Jahnke <nassim@njahnke.dev>
-Date: Fri, 29 Jan 2021 15:13:11 +0100
-Subject: [PATCH] Add dropLeash variable to EntityUnleashEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/EntityCreature.java b/src/main/java/net/minecraft/world/entity/EntityCreature.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/EntityCreature.java
-+++ b/src/main/java/net/minecraft/world/entity/EntityCreature.java
-@@ -0,0 +0,0 @@ public abstract class EntityCreature extends EntityInsentient {
- 
-             if (this instanceof EntityTameableAnimal && ((EntityTameableAnimal) this).isSitting()) {
-                 if (f > entity.world.paperConfig.maxLeashDistance) { // Paper
--                    this.world.getServer().getPluginManager().callEvent(new EntityUnleashEvent(this.getBukkitEntity(), EntityUnleashEvent.UnleashReason.DISTANCE)); // CraftBukkit
--                    this.unleash(true, true);
-+                    // Paper start - drop leash variable
-+                    EntityUnleashEvent event = new EntityUnleashEvent(this.getBukkitEntity(), EntityUnleashEvent.UnleashReason.DISTANCE, true);
-+                    this.world.getServer().getPluginManager().callEvent(event); // CraftBukkit
-+                    this.unleash(true, event.isDropLeash());
-+                    // Paper end
-                 }
- 
-                 return;
-@@ -0,0 +0,0 @@ public abstract class EntityCreature extends EntityInsentient {
- 
-             this.x(f);
-             if (f > entity.world.paperConfig.maxLeashDistance) { // Paper
--                this.world.getServer().getPluginManager().callEvent(new EntityUnleashEvent(this.getBukkitEntity(), EntityUnleashEvent.UnleashReason.DISTANCE)); // CraftBukkit
--                this.unleash(true, true);
-+                // Paper start - drop leash variable
-+                EntityUnleashEvent event = new EntityUnleashEvent(this.getBukkitEntity(), EntityUnleashEvent.UnleashReason.DISTANCE, true);
-+                this.world.getServer().getPluginManager().callEvent(event); // CraftBukkit
-+                this.unleash(true, event.isDropLeash());
-+                // Paper end
-                 this.goalSelector.a(PathfinderGoal.Type.MOVE);
-             } else if (f > 6.0F) {
-                 double d0 = (entity.locX() - this.locX()) / (double) f;
-diff --git a/src/main/java/net/minecraft/world/entity/EntityInsentient.java b/src/main/java/net/minecraft/world/entity/EntityInsentient.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/EntityInsentient.java
-+++ b/src/main/java/net/minecraft/world/entity/EntityInsentient.java
-@@ -0,0 +0,0 @@ import org.bukkit.event.entity.EntityTargetEvent;
- import org.bukkit.event.entity.EntityTransformEvent;
- import org.bukkit.event.entity.EntityUnleashEvent;
- import org.bukkit.event.entity.EntityUnleashEvent.UnleashReason;
-+import org.bukkit.event.player.PlayerUnleashEntityEvent; // Paper
- // CraftBukkit end
- 
- public abstract class EntityInsentient extends EntityLiving {
-@@ -0,0 +0,0 @@ public abstract class EntityInsentient extends EntityLiving {
-             return EnumInteractionResult.PASS;
-         } else if (this.getLeashHolder() == entityhuman) {
-             // CraftBukkit start - fire PlayerUnleashEntityEvent
--            if (CraftEventFactory.callPlayerUnleashEntityEvent(this, entityhuman).isCancelled()) {
-+            // Paper start - drop leash variable
-+            PlayerUnleashEntityEvent event = CraftEventFactory.callPlayerUnleashEntityEvent(this, entityhuman, !entityhuman.abilities.canInstantlyBuild);
-+            if (event.isCancelled()) {
-+                // Paper end
-                 ((EntityPlayer) entityhuman).playerConnection.sendPacket(new PacketPlayOutAttachEntity(this, this.getLeashHolder()));
-                 return EnumInteractionResult.PASS;
-             }
-             // CraftBukkit end
--            this.unleash(true, !entityhuman.abilities.canInstantlyBuild);
-+            this.unleash(true, event.isDropLeash()); // Paper - drop leash variable
-             return EnumInteractionResult.a(this.world.isClientSide);
-         } else {
-             EnumInteractionResult enuminteractionresult = this.c(entityhuman, enumhand);
-@@ -0,0 +0,0 @@ public abstract class EntityInsentient extends EntityLiving {
- 
-         if (this.leashHolder != null) {
-             if (!this.isAlive() || !this.leashHolder.isAlive()) {
--                this.world.getServer().getPluginManager().callEvent(new EntityUnleashEvent(this.getBukkitEntity(), (!this.isAlive()) ? UnleashReason.PLAYER_UNLEASH : UnleashReason.HOLDER_GONE)); // CraftBukkit
--                this.unleash(true, true);
-+                // Paper start - drop leash variable
-+                EntityUnleashEvent event = new EntityUnleashEvent(this.getBukkitEntity(), (!this.isAlive()) ? UnleashReason.PLAYER_UNLEASH : UnleashReason.HOLDER_GONE, true);
-+                this.world.getServer().getPluginManager().callEvent(event); // CraftBukkit
-+                this.unleash(true, event.isDropLeash());
-+                // Paper end
-             }
- 
-         }
-@@ -0,0 +0,0 @@ public abstract class EntityInsentient extends EntityLiving {
-         boolean flag1 = super.a(entity, flag);
- 
-         if (flag1 && this.isLeashed()) {
--            this.world.getServer().getPluginManager().callEvent(new EntityUnleashEvent(this.getBukkitEntity(), UnleashReason.UNKNOWN)); // CraftBukkit
--            this.unleash(true, true);
-+            // Paper start - drop leash variable
-+            EntityUnleashEvent event = new EntityUnleashEvent(this.getBukkitEntity(), UnleashReason.UNKNOWN, true);
-+            this.world.getServer().getPluginManager().callEvent(event); // CraftBukkit
-+            this.unleash(true, event.isDropLeash());
-+            // Paper end
-         }
- 
-         return flag1;
-@@ -0,0 +0,0 @@ public abstract class EntityInsentient extends EntityLiving {
-     @Override
-     protected void bN() {
-         super.bN();
--        this.world.getServer().getPluginManager().callEvent(new EntityUnleashEvent(this.getBukkitEntity(), UnleashReason.UNKNOWN)); // CraftBukkit
--        this.unleash(true, false);
-+        // Paper start - drop leash variable
-+        EntityUnleashEvent event = new EntityUnleashEvent(this.getBukkitEntity(), UnleashReason.UNKNOWN, false);
-+        this.world.getServer().getPluginManager().callEvent(event); // CraftBukkit
-+        this.unleash(true, event.isDropLeash());
-+        // Paper end
-     }
- }
-diff --git a/src/main/java/net/minecraft/world/entity/decoration/EntityLeash.java b/src/main/java/net/minecraft/world/entity/decoration/EntityLeash.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/decoration/EntityLeash.java
-+++ b/src/main/java/net/minecraft/world/entity/decoration/EntityLeash.java
-@@ -0,0 +0,0 @@ import net.minecraft.server.level.WorldServer;
- import org.bukkit.craftbukkit.event.CraftEventFactory;
- // CraftBukkit end
- 
-+import org.bukkit.event.player.PlayerUnleashEntityEvent; // Paper
-+
- public class EntityLeash extends EntityHanging {
- 
-     public EntityLeash(EntityTypes<? extends EntityLeash> entitytypes, World world) {
-@@ -0,0 +0,0 @@ public class EntityLeash extends EntityHanging {
-                         entityinsentient = (EntityInsentient) iterator.next();
-                         if (entityinsentient.isLeashed() && entityinsentient.getLeashHolder() == this) {
-                             // CraftBukkit start
--                            if (CraftEventFactory.callPlayerUnleashEntityEvent(entityinsentient, entityhuman).isCancelled()) {
-+                            // Paper start - drop leash variable
-+                            PlayerUnleashEntityEvent event = CraftEventFactory.callPlayerUnleashEntityEvent(entityinsentient, entityhuman, !entityhuman.abilities.canInstantlyBuild);
-+                            if (event.isCancelled()) {
-+                                // Paper end
-                                 die = false;
-                                 continue;
-                             }
--                            entityinsentient.unleash(true, !entityhuman.abilities.canInstantlyBuild); // false -> survival mode boolean
-+                            entityinsentient.unleash(true, event.isDropLeash()); // false -> survival mode boolean // Paper - drop leash variable
-                             // CraftBukkit end
-                         }
-                     }
-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 itemInHand;
-     }
- 
--    public static PlayerUnleashEntityEvent callPlayerUnleashEntityEvent(EntityInsentient entity, EntityHuman player) {
--        PlayerUnleashEntityEvent event = new PlayerUnleashEntityEvent(entity.getBukkitEntity(), (Player) player.getBukkitEntity());
-+    // Paper start - drop leash variable
-+    public static PlayerUnleashEntityEvent callPlayerUnleashEntityEvent(EntityInsentient entity, EntityHuman player, boolean dropLeash) {
-+        PlayerUnleashEntityEvent event = new PlayerUnleashEntityEvent(entity.getBukkitEntity(), (Player) player.getBukkitEntity(), dropLeash);
-+        // Paper end
-         entity.world.getServer().getPluginManager().callEvent(event);
-         return event;
-     }

Spigot-Server-Patches/Add-effect-to-block-break-naturally.patch

@@ -1,32 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <Blake.Galbreath@GMail.com>
-Date: Thu, 2 Jan 2020 12:25:07 -0600
-Subject: [PATCH] Add effect to block break naturally
-
-
-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 {
- 
-     @Override
-     public boolean breakNaturally(ItemStack item) {
-+        // Paper start
-+        return breakNaturally(item, false);
-+    }
-+
-+    @Override
-+    public boolean breakNaturally(ItemStack item, boolean triggerEffect) {
-+        // Paper end
-         // Order matters here, need to drop before setting to air so skulls can get their data
-         net.minecraft.world.level.block.state.IBlockData iblockdata = this.getNMS();
-         net.minecraft.world.level.block.Block block = iblockdata.getBlock();
-@@ -0,0 +0,0 @@ public class CraftBlock implements Block {
-         // Modelled off EntityHuman#hasBlock
-         if (block != Blocks.AIR && (item == null || !iblockdata.isRequiresSpecialTool() || nmsItem.canDestroySpecialBlock(iblockdata))) {
-             net.minecraft.world.level.block.Block.dropItems(iblockdata, world.getMinecraftWorld(), position, world.getTileEntity(position), null, nmsItem);
-+            if (triggerEffect) world.triggerEffect(org.bukkit.Effect.STEP_SOUND.getId(), position, net.minecraft.world.level.block.Block.getCombinedId(block.getBlockData())); // Paper
-             result = true;
-         }
- 

Spigot-Server-Patches/Add-entity-liquid-API.patch

@@ -1,75 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <Blake.Galbreath@GMail.com>
-Date: Thu, 2 Jul 2020 18:11:43 -0500
-Subject: [PATCH] Add entity liquid API
-
-
-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 INamableTileEntity, ICommandListener, ne
-         return this.inWater;
-     }
- 
--    private boolean isInRain() {
-+    public boolean isInRain() { // Paper - private -> public
-         BlockPosition blockposition = this.getChunkCoordinates();
- 
-         return this.world.isRainingAt(blockposition) || this.world.isRainingAt(new BlockPosition((double) blockposition.getX(), this.getBoundingBox().maxY, (double) blockposition.getZ()));
-     }
- 
-+    public final boolean isInBubbleColumn() { return k(); } // Paper - OBFHELPER
-     private boolean k() {
-         return this.world.getType(this.getChunkCoordinates()).a(Blocks.BUBBLE_COLUMN);
-     }
-@@ -0,0 +0,0 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, ne
-         return this.isInWater() || this.isInRain() || this.k();
-     }
- 
-+    public final boolean isInWaterOrBubbleColumn() { return aH(); } // Paper - OBFHELPER
-     public boolean aH() {
-         return this.isInWater() || this.k();
-     }
-@@ -0,0 +0,0 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, ne
-         return this.O == tag;
-     }
- 
-+    public final boolean isInLava() { return aQ(); } // Paper - OBFHELPER
-     public boolean aQ() {
-         return !this.justCreated && this.M.getDouble(TagsFluid.LAVA) > 0.0D;
-     }
-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 {
-     public org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason getEntitySpawnReason() {
-         return getHandle().spawnReason;
-     }
-+
-+    public boolean isInRain() {
-+        return getHandle().isInRain();
-+    }
-+
-+    public boolean isInBubbleColumn() {
-+        return getHandle().isInBubbleColumn();
-+    }
-+
-+    public boolean isInWaterOrRain() {
-+        return getHandle().isInWaterOrRain();
-+    }
-+
-+    public boolean isInWaterOrBubbleColumn() {
-+        return getHandle().isInWaterOrBubbleColumn();
-+    }
-+    
-+    public boolean isInWaterOrRainOrBubbleColumn() {
-+        return getHandle().isInWaterOrRainOrBubble();
-+    }
-+
-+    public boolean isInLava() {
-+        return getHandle().isInLava();
-+    }
-     // Paper end
- }

Spigot-Server-Patches/Add-environment-variable-to-disable-server-gui.patch

@@ -1,18 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Riley Park <rileysebastianpark@gmail.com>
-Date: Mon, 17 May 2021 00:34:55 -0700
-Subject: [PATCH] Add environment variable to disable server gui
-
-
-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 {
-                 */
-                 boolean flag1 = !optionset.has("nogui") && !optionset.nonOptionArguments().contains("nogui");
- 
-+                if(!Boolean.parseBoolean(System.getenv().getOrDefault("PAPER_DISABLE_SERVER_GUI", String.valueOf(false)))) // Paper
-                 if (flag1 && !GraphicsEnvironment.isHeadless()) {
-                     dedicatedserver1.bd();
-                 }

Spigot-Server-Patches/Add-exception-reporting-event.patch

@@ -1,264 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Joseph Hirschfeld <joe@ibj.io>
-Date: Thu, 3 Mar 2016 03:15:41 -0600
-Subject: [PATCH] Add exception reporting event
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/ServerSchedulerReportingWrapper.java b/src/main/java/com/destroystokyo/paper/ServerSchedulerReportingWrapper.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/ServerSchedulerReportingWrapper.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper;
-+
-+import com.google.common.base.Preconditions;
-+import org.bukkit.craftbukkit.scheduler.CraftTask;
-+import com.destroystokyo.paper.event.server.ServerExceptionEvent;
-+import com.destroystokyo.paper.exception.ServerSchedulerException;
-+
-+/**
-+ * Reporting wrapper to catch exceptions not natively
-+ */
-+public class ServerSchedulerReportingWrapper implements Runnable {
-+
-+    private final CraftTask internalTask;
-+
-+    public ServerSchedulerReportingWrapper(CraftTask internalTask) {
-+        this.internalTask = Preconditions.checkNotNull(internalTask, "internalTask");
-+    }
-+
-+    @Override
-+    public void run() {
-+        try {
-+            internalTask.run();
-+        } catch (RuntimeException e) {
-+            internalTask.getOwner().getServer().getPluginManager().callEvent(
-+                    new ServerExceptionEvent(new ServerSchedulerException(e, internalTask))
-+            );
-+            throw e;
-+        } catch (Throwable t) {
-+            internalTask.getOwner().getServer().getPluginManager().callEvent(
-+                    new ServerExceptionEvent(new ServerSchedulerException(t, internalTask))
-+            ); //Do not rethrow, since it is not permitted with Runnable#run
-+        }
-+    }
-+
-+    public CraftTask getInternalTask() {
-+        return internalTask;
-+    }
-+}
-diff --git a/src/main/java/net/minecraft/server/level/PlayerChunkMap.java b/src/main/java/net/minecraft/server/level/PlayerChunkMap.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/PlayerChunkMap.java
-+++ b/src/main/java/net/minecraft/server/level/PlayerChunkMap.java
-@@ -0,0 +0,0 @@ public class PlayerChunkMap extends IChunkLoader implements PlayerChunk.d {
-                 return true;
-             } catch (Exception exception) {
-                 PlayerChunkMap.LOGGER.error("Failed to save chunk {},{}", chunkcoordintpair.x, chunkcoordintpair.z, exception);
-+                com.destroystokyo.paper.exception.ServerInternalException.reportInternalException(exception); // Paper
-                 return false;
-             }
-         }
-diff --git a/src/main/java/net/minecraft/server/players/NameReferencingFileConverter.java b/src/main/java/net/minecraft/server/players/NameReferencingFileConverter.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/players/NameReferencingFileConverter.java
-+++ b/src/main/java/net/minecraft/server/players/NameReferencingFileConverter.java
-@@ -0,0 +0,0 @@
- package net.minecraft.server.players;
- 
-+import com.destroystokyo.paper.exception.ServerInternalException;
- import com.google.common.collect.Lists;
- import com.google.common.collect.Maps;
- import com.google.common.io.Files;
-@@ -0,0 +0,0 @@ public class NameReferencingFileConverter {
-                             root = NBTCompressedStreamTools.a(new java.io.FileInputStream(file5));
-                         } catch (Exception exception) {
-                             exception.printStackTrace();
-+                            ServerInternalException.reportInternalException(exception); // Paper
-                         }
- 
-                         if (root != null) {
-@@ -0,0 +0,0 @@ public class NameReferencingFileConverter {
-                                 NBTCompressedStreamTools.a(root, new java.io.FileOutputStream(file2));
-                             } catch (Exception exception) {
-                                 exception.printStackTrace();
-+                                ServerInternalException.reportInternalException(exception); // Paper
-                             }
-                        }
-                         // CraftBukkit end
-diff --git a/src/main/java/net/minecraft/world/entity/ai/village/VillageSiege.java b/src/main/java/net/minecraft/world/entity/ai/village/VillageSiege.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ai/village/VillageSiege.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/village/VillageSiege.java
-@@ -0,0 +0,0 @@
- package net.minecraft.world.entity.ai.village;
- 
-+import com.destroystokyo.paper.exception.ServerInternalException;
-+
- import java.util.Iterator;
- import javax.annotation.Nullable;
- import net.minecraft.core.BaseBlockPosition;
-@@ -0,0 +0,0 @@ public class VillageSiege implements MobSpawner {
-                 entityzombie.prepare(worldserver, worldserver.getDamageScaler(entityzombie.getChunkCoordinates()), EnumMobSpawn.EVENT, (GroupDataEntity) null, (NBTTagCompound) null);
-             } catch (Exception exception) {
-                 VillageSiege.LOGGER.warn("Failed to create zombie for village siege at {}", vec3d, exception);
-+                ServerInternalException.reportInternalException(exception); // Paper
-                 return;
-             }
- 
-diff --git a/src/main/java/net/minecraft/world/level/SpawnerCreature.java b/src/main/java/net/minecraft/world/level/SpawnerCreature.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/SpawnerCreature.java
-+++ b/src/main/java/net/minecraft/world/level/SpawnerCreature.java
-@@ -0,0 +0,0 @@ public final class SpawnerCreature {
-             }
-         } catch (Exception exception) {
-             SpawnerCreature.LOGGER.warn("Failed to create mob", exception);
-+            com.destroystokyo.paper.exception.ServerInternalException.reportInternalException(exception); // Paper
-             return null;
-         }
-     }
-@@ -0,0 +0,0 @@ public final class SpawnerCreature {
-                                 entity = biomesettingsmobs_c.c.a((World) worldaccess.getMinecraftWorld());
-                             } catch (Exception exception) {
-                                 SpawnerCreature.LOGGER.warn("Failed to create mob", exception);
-+                                com.destroystokyo.paper.exception.ServerInternalException.reportInternalException(exception); // Paper
-                                 continue;
-                             }
- 
-diff --git a/src/main/java/net/minecraft/world/level/World.java b/src/main/java/net/minecraft/world/level/World.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/World.java
-+++ b/src/main/java/net/minecraft/world/level/World.java
-@@ -0,0 +0,0 @@
- package net.minecraft.world.level;
- 
-+import co.aikar.timings.Timing;
-+import co.aikar.timings.Timings;
-+import com.destroystokyo.paper.event.server.ServerExceptionEvent;
-+import com.destroystokyo.paper.exception.ServerInternalException;
-+import com.google.common.base.MoreObjects;
- import com.google.common.collect.Lists;
- import com.mojang.serialization.Codec;
- import java.io.IOException;
-@@ -0,0 +0,0 @@ public abstract class World implements GeneratorAccess, AutoCloseable {
-                         gameprofilerfiller.exit();
-                     } catch (Throwable throwable) {
-                         // Paper start - Prevent tile entity and entity crashes
--                        System.err.println("TileEntity threw exception at " + tileentity.world.getWorld().getName() + ":" + tileentity.position.getX() + "," + tileentity.position.getY() + "," + tileentity.position.getZ());
-+                        String msg = "TileEntity threw exception at " + tileentity.getWorld().getWorld().getName() + ":" + tileentity.getPosition().getX() + "," + tileentity.getPosition().getY() + "," + tileentity.getPosition().getZ();
-+                        System.err.println(msg);
-                         throwable.printStackTrace();
-+                        getServer().getPluginManager().callEvent(new ServerExceptionEvent(new ServerInternalException(msg, throwable)));
-+                        // Paper end
-                         tilesThisCycle--;
-                         this.tileEntityListTick.remove(tileTickPosition--);
-                         continue;
-@@ -0,0 +0,0 @@ public abstract class World implements GeneratorAccess, AutoCloseable {
-             consumer.accept(entity);
-         } catch (Throwable throwable) {
-             // Paper start - Prevent tile entity and entity crashes
--            System.err.println("Entity threw exception at " + entity.world.getWorld().getName() + ":" + entity.locX() + "," + entity.locY() + "," + entity.locZ());
-+            String msg = "Entity threw exception at " + entity.world.getWorld().getName() + ":" + entity.locX() + "," + entity.locY() + "," + entity.locZ();
-+            System.err.println(msg);
-             throwable.printStackTrace();
-+            getServer().getPluginManager().callEvent(new ServerExceptionEvent(new ServerInternalException(msg, throwable)));
-             entity.dead = true;
-             return;
-             // Paper end
-diff --git a/src/main/java/net/minecraft/world/level/chunk/Chunk.java b/src/main/java/net/minecraft/world/level/chunk/Chunk.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/chunk/Chunk.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/Chunk.java
-@@ -0,0 +0,0 @@
- package net.minecraft.world.level.chunk;
- 
-+import com.destroystokyo.paper.exception.ServerInternalException;
- import com.google.common.collect.Maps;
- import com.google.common.collect.Sets;
- import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
-@@ -0,0 +0,0 @@ public class Chunk implements IChunkAccess {
-             this.tileEntities.remove(blockposition);
-             // Paper end
-         } else {
--            System.out.println("Attempted to place a tile entity (" + tileentity + ") at " + tileentity.getPosition().getX() + "," + tileentity.getPosition().getY() + "," + tileentity.getPosition().getZ()
--                + " (" + getType(blockposition) + ") where there was no entity tile!");
--            System.out.println("Chunk coordinates: " + (this.loc.x * 16) + "," + (this.loc.z * 16));
--            new Exception().printStackTrace();
-+            // Paper start
-+            ServerInternalException e = new ServerInternalException(
-+                    "Attempted to place a tile entity (" + tileentity + ") at " + tileentity.getPosition().getX() + ","
-+                            + tileentity.getPosition().getY() + "," + tileentity.getPosition().getZ()
-+                            + " (" + getType(blockposition) + ") where there was no entity tile!\n" +
-+                            "Chunk coordinates: " + (this.loc.x * 16) + "," + (this.loc.z * 16));
-+            e.printStackTrace();
-+            ServerInternalException.reportInternalException(e);
-+            // Paper end
-             // CraftBukkit end
-         }
-     }
-diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable {
-                     return true;
-                 }
-             } catch (IOException ioexception) {
-+                com.destroystokyo.paper.exception.ServerInternalException.reportInternalException(ioexception); // Paper
-                 return false;
-             }
-         }
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable {
-             filechannel.write(bytebuffer);
-         } catch (Throwable throwable1) {
-             throwable = throwable1;
-+            com.destroystokyo.paper.exception.ServerInternalException.reportInternalException(throwable); // Paper
-             throw throwable1;
-         } finally {
-             if (filechannel != null) {
-diff --git a/src/main/java/net/minecraft/world/level/storage/WorldPersistentData.java b/src/main/java/net/minecraft/world/level/storage/WorldPersistentData.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/storage/WorldPersistentData.java
-+++ b/src/main/java/net/minecraft/world/level/storage/WorldPersistentData.java
-@@ -0,0 +0,0 @@ public class WorldPersistentData {
-             }
-         } catch (Throwable throwable6) {
-             throwable = throwable6;
-+            com.destroystokyo.paper.exception.ServerInternalException.reportInternalException(throwable); // Paper
-             throw throwable6;
-         } finally {
-             if (fileinputstream != null) {
-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 @@ import java.util.concurrent.atomic.AtomicInteger;
- import java.util.concurrent.atomic.AtomicReference;
- import java.util.function.Consumer;
- import java.util.logging.Level;
-+import com.destroystokyo.paper.ServerSchedulerReportingWrapper;
-+import com.destroystokyo.paper.event.server.ServerExceptionEvent;
-+import com.destroystokyo.paper.exception.ServerSchedulerException;
- import org.apache.commons.lang.Validate;
- import org.bukkit.plugin.IllegalPluginAccessException;
- import org.bukkit.plugin.Plugin;
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
-                             msg,
-                             throwable);
-                     }
-+                    org.bukkit.Bukkit.getServer().getPluginManager().callEvent(
-+                        new ServerExceptionEvent(new ServerSchedulerException(msg, throwable, task)));
-                     // Paper end
-                 } finally {
-                     currentTask = null;
-@@ -0,0 +0,0 @@ public class CraftScheduler implements BukkitScheduler {
-                 parsePending();
-             } else {
-                 debugTail = debugTail.setNext(new CraftAsyncDebugger(currentTick + RECENT_TICKS, task.getOwner(), task.getTaskClass()));
--                executor.execute(task);
-+                executor.execute(new ServerSchedulerReportingWrapper(task)); // 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)
-             }

Spigot-Server-Patches/Add-fast-alternative-constructor-for-Vector3f.patch

@@ -1,30 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Irmo van den Berge <irmo.vandenberge@ziggo.nl>
-Date: Wed, 10 Mar 2021 21:26:31 +0100
-Subject: [PATCH] Add fast alternative constructor for Vector3f
-
-Signed-off-by: Irmo van den Berge <irmo.vandenberge@ziggo.nl>
-
-diff --git a/src/main/java/net/minecraft/core/Vector3f.java b/src/main/java/net/minecraft/core/Vector3f.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/core/Vector3f.java
-+++ b/src/main/java/net/minecraft/core/Vector3f.java
-@@ -0,0 +0,0 @@ public class Vector3f {
-         this(nbttaglist.i(0), nbttaglist.i(1), nbttaglist.i(2));
-     }
- 
-+    // Paper start - faster alternative constructor
-+    private Vector3f(float x, float y, float z, Void dummy_var) {
-+        this.x = x;
-+        this.y = y;
-+        this.z = z;
-+    }
-+
-+    public static Vector3f createWithoutValidityChecks(float x, float y, float z) {
-+        return new Vector3f(x, y, z, null);
-+    }
-+    // Paper end
-+
-     public NBTTagList a() {
-         NBTTagList nbttaglist = new NBTTagList();
- 

Spigot-Server-Patches/Add-getMainThreadExecutor-to-BukkitScheduler.patch

@@ -1,26 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aleksander Jagiello <themolkapl@gmail.com>
-Date: Sun, 24 Jan 2021 22:17:54 +0100
-Subject: [PATCH] Add getMainThreadExecutor to BukkitScheduler
-
-
-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 {
-     public BukkitTask runTaskTimerAsynchronously(Plugin plugin, BukkitRunnable task, long delay, long period) throws IllegalArgumentException {
-         throw new UnsupportedOperationException("Use BukkitRunnable#runTaskTimerAsynchronously(Plugin, long, long)");
-     }
-+
-+    // Paper start - add getMainThreadExecutor
-+    @Override
-+    public Executor getMainThreadExecutor(Plugin plugin) {
-+        Validate.notNull(plugin, "Plugin cannot be null");
-+        return command -> {
-+            Validate.notNull(command, "Command cannot be null");
-+            this.runTask(plugin, command);
-+        };
-+    }
-+    // Paper end
- }

Spigot-Server-Patches/Add-getOfflinePlayerIfCached-String.patch

@@ -1,39 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: oxygencraft <21054297+oxygencraft@users.noreply.github.com>
-Date: Sun, 25 Oct 2020 18:34:50 +1100
-Subject: [PATCH] Add getOfflinePlayerIfCached(String)
-
-
-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 {
-         return result;
-     }
- 
-+    // Paper start
-+    @Override
-+    @Nullable
-+    public OfflinePlayer getOfflinePlayerIfCached(String name) {
-+        Validate.notNull(name, "Name cannot be null");
-+        Validate.notEmpty(name, "Name cannot be empty");
-+
-+        OfflinePlayer result = getPlayerExact(name);
-+        if (result == null) {
-+            GameProfile profile = console.getUserCache().getProfileIfCached(name);
-+
-+            if (profile != null) {
-+                result = getOfflinePlayer(profile);
-+            }
-+        } else {
-+            offlinePlayers.remove(result.getUniqueId());
-+        }
-+
-+        return result;
-+    }
-+    // Paper end
-+
-     @Override
-     public OfflinePlayer getOfflinePlayer(UUID id) {
-         Validate.notNull(id, "UUID cannot be null");

Spigot-Server-Patches/Add-hand-to-bucket-events.patch

@@ -1,174 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Thu, 2 Aug 2018 08:44:35 -0500
-Subject: [PATCH] Add hand to bucket events
-
-
-diff --git a/src/main/java/net/minecraft/server/level/WorldServer.java b/src/main/java/net/minecraft/server/level/WorldServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/WorldServer.java
-+++ b/src/main/java/net/minecraft/server/level/WorldServer.java
-@@ -0,0 +0,0 @@ public class WorldServer extends World implements GeneratorAccessSeed {
-         this.getMinecraftServer().getPlayerList().sendAll(new PacketPlayOutSpawnPosition(blockposition, f));
-     }
- 
--    public BlockPosition getSpawn() {
--        BlockPosition blockposition = new BlockPosition(this.worldData.a(), this.worldData.b(), this.worldData.c());
--
--        if (!this.getWorldBorder().a(blockposition)) {
--            blockposition = this.getHighestBlockYAt(HeightMap.Type.MOTION_BLOCKING, new BlockPosition(this.getWorldBorder().getCenterX(), 0.0D, this.getWorldBorder().getCenterZ()));
--        }
--
--        return blockposition;
--    }
-+    // Paper - moved up to World
-+    //public BlockPosition getSpawn() {
-+    //    BlockPosition blockposition = new BlockPosition(this.worldData.a(), this.worldData.b(), this.worldData.c());
-+    //
-+    //    if (!this.getWorldBorder().a(blockposition)) {
-+    //        blockposition = this.getHighestBlockYAt(HeightMap.Type.MOTION_BLOCKING, new BlockPosition(this.getWorldBorder().getCenterX(), 0.0D, this.getWorldBorder().getCenterZ()));
-+    //    }
-+    //
-+    //    return blockposition;
-+    //}
-+    // Paper end
- 
-     public float v() {
-         return this.worldData.d();
-diff --git a/src/main/java/net/minecraft/world/entity/animal/EntityCow.java b/src/main/java/net/minecraft/world/entity/animal/EntityCow.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/animal/EntityCow.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/EntityCow.java
-@@ -0,0 +0,0 @@ public class EntityCow extends EntityAnimal {
- 
-         if (itemstack.getItem() == Items.BUCKET && !this.isBaby()) {
-             // CraftBukkit start - Got milk?
--            org.bukkit.event.player.PlayerBucketFillEvent event = CraftEventFactory.callPlayerBucketFillEvent((WorldServer) entityhuman.world, entityhuman, this.getChunkCoordinates(), this.getChunkCoordinates(), null, itemstack, Items.MILK_BUCKET);
-+            org.bukkit.event.player.PlayerBucketFillEvent event = CraftEventFactory.callPlayerBucketFillEvent((WorldServer) entityhuman.world, entityhuman, this.getChunkCoordinates(), this.getChunkCoordinates(), null, itemstack, Items.MILK_BUCKET, enumhand); // Paper - add enumHand
- 
-             if (event.isCancelled()) {
-                 return EnumInteractionResult.PASS;
-diff --git a/src/main/java/net/minecraft/world/item/ItemBucket.java b/src/main/java/net/minecraft/world/item/ItemBucket.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/item/ItemBucket.java
-+++ b/src/main/java/net/minecraft/world/item/ItemBucket.java
-@@ -0,0 +0,0 @@ public class ItemBucket extends Item {
-                     if (iblockdata.getBlock() instanceof IFluidSource) {
-                         // CraftBukkit start
-                         FluidType dummyFluid = ((IFluidSource) iblockdata.getBlock()).removeFluid(DummyGeneratorAccess.INSTANCE, blockposition, iblockdata);
--                        PlayerBucketFillEvent event = CraftEventFactory.callPlayerBucketFillEvent((WorldServer) world, entityhuman, blockposition, blockposition, movingobjectpositionblock.getDirection(), itemstack, dummyFluid.a());
-+                        PlayerBucketFillEvent event = CraftEventFactory.callPlayerBucketFillEvent((WorldServer) world, entityhuman, blockposition, blockposition, movingobjectpositionblock.getDirection(), itemstack, dummyFluid.a(), enumhand); // Paper - add enumhand
- 
-                         if (event.isCancelled()) {
-                             ((EntityPlayer) entityhuman).playerConnection.sendPacket(new PacketPlayOutBlockChange(world, blockposition)); // SPIGOT-5163 (see PlayerInteractManager)
-@@ -0,0 +0,0 @@ public class ItemBucket extends Item {
-                     iblockdata = world.getType(blockposition);
-                     BlockPosition blockposition2 = iblockdata.getBlock() instanceof IFluidContainer && this.fluidType == FluidTypes.WATER ? blockposition : blockposition1;
- 
--                    if (this.a(entityhuman, world, blockposition2, movingobjectpositionblock1, movingobjectpositionblock1.getDirection(), blockposition, itemstack)) { // CraftBukkit
-+                    if (this.a(entityhuman, world, blockposition2, movingobjectpositionblock1, movingobjectpositionblock1.getDirection(), blockposition, itemstack, enumhand)) { // CraftBukkit // Paper - add enumhand
-                         this.a(world, itemstack, blockposition2);
-                         if (entityhuman instanceof EntityPlayer) {
-                             CriterionTriggers.y.a((EntityPlayer) entityhuman, blockposition2, itemstack);
-@@ -0,0 +0,0 @@ public class ItemBucket extends Item {
-     public void a(World world, ItemStack itemstack, BlockPosition blockposition) {}
- 
-     public boolean a(@Nullable EntityHuman entityhuman, World world, BlockPosition blockposition, @Nullable MovingObjectPositionBlock movingobjectpositionblock) {
--        return a(entityhuman, world, blockposition, movingobjectpositionblock, null, null, null);
-+        // Paper start - add enumHand
-+        return a(entityhuman, world, blockposition, movingobjectpositionblock, null, null, null, null);
-     }
- 
--    public boolean a(EntityHuman entityhuman, World world, BlockPosition blockposition, @Nullable MovingObjectPositionBlock movingobjectpositionblock, EnumDirection enumdirection, BlockPosition clicked, ItemStack itemstack) {
-+    public boolean a(EntityHuman entityhuman, World world, BlockPosition blockposition, @Nullable MovingObjectPositionBlock movingobjectpositionblock, EnumDirection enumdirection, BlockPosition clicked, ItemStack itemstack, EnumHand enumhand) {
-+        // Paper end
-         // CraftBukkit end
-         if (!(this.fluidType instanceof FluidTypeFlowing)) {
-             return false;
-@@ -0,0 +0,0 @@ public class ItemBucket extends Item {
- 
-             // CraftBukkit start
-             if (flag1 && entityhuman != null) {
--                PlayerBucketEmptyEvent event = CraftEventFactory.callPlayerBucketEmptyEvent((WorldServer) world, entityhuman, blockposition, clicked, enumdirection, itemstack);
-+                PlayerBucketEmptyEvent event = CraftEventFactory.callPlayerBucketEmptyEvent((WorldServer) world, entityhuman, blockposition, clicked, enumdirection, itemstack, enumhand); // Paper - add enumhand
-                 if (event.isCancelled()) {
-                     ((EntityPlayer) entityhuman).playerConnection.sendPacket(new PacketPlayOutBlockChange(world, blockposition)); // SPIGOT-4238: needed when looking through entity
-                     ((EntityPlayer) entityhuman).getBukkitEntity().updateInventory(); // SPIGOT-4541
-@@ -0,0 +0,0 @@ public class ItemBucket extends Item {
-             }
-             // CraftBukkit end
-             if (!flag1) {
--                return movingobjectpositionblock != null && this.a(entityhuman, world, movingobjectpositionblock.getBlockPosition().shift(movingobjectpositionblock.getDirection()), (MovingObjectPositionBlock) null, enumdirection, clicked, itemstack); // CraftBukkit
-+                return movingobjectpositionblock != null && this.a(entityhuman, world, movingobjectpositionblock.getBlockPosition().shift(movingobjectpositionblock.getDirection()), (MovingObjectPositionBlock) null, enumdirection, clicked, itemstack, enumhand); // CraftBukkit // Paper - add enumhand
-             } else if (world.getDimensionManager().isNether() && this.fluidType.a((Tag) TagsFluid.WATER)) {
-                 int i = blockposition.getX();
-                 int j = blockposition.getY();
-diff --git a/src/main/java/net/minecraft/world/level/World.java b/src/main/java/net/minecraft/world/level/World.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/World.java
-+++ b/src/main/java/net/minecraft/world/level/World.java
-@@ -0,0 +0,0 @@ public abstract class World implements GeneratorAccess, AutoCloseable {
-     }
-     // Paper end
- 
-+    // Paper start - moved up from WorldServer
-+    public BlockPosition getSpawn() {
-+        BlockPosition blockposition = new BlockPosition(this.worldData.a(), this.worldData.b(), this.worldData.c());
-+
-+        if (!this.getWorldBorder().a(blockposition)) {
-+            blockposition = this.getHighestBlockYAt(HeightMap.Type.MOTION_BLOCKING, new BlockPosition(this.getWorldBorder().getCenterX(), 0.0D, this.getWorldBorder().getCenterZ()));
-+        }
-+
-+        return blockposition;
-+    }
-+    // Paper end
-     @Override
-     public boolean s_() {
-         return this.isClientSide;
-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 Entity entityDamage; // For use in EntityDamageByEntityEvent
- 
-     // helper methods
--    private static boolean canBuild(WorldServer world, Player player, int x, int z) {
-+    private static boolean canBuild(World world, Player player, int x, int z) {
-         int spawnSize = Bukkit.getServer().getSpawnRadius();
- 
-         if (world.getDimensionKey() != World.OVERWORLD) return true;
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
-     }
- 
-     private static PlayerEvent getPlayerBucketEvent(boolean isFilling, WorldServer world, EntityHuman who, BlockPosition changed, BlockPosition clicked, EnumDirection clickedFace, ItemStack itemstack, net.minecraft.world.item.Item item) {
-+        // Paper start - add enumHand
-+        return getPlayerBucketEvent(isFilling, world, who, changed, clicked, clickedFace, itemstack, item, null);
-+    }
-+
-+    public static PlayerBucketEmptyEvent callPlayerBucketEmptyEvent(World world, EntityHuman who, BlockPosition changed, BlockPosition clicked, EnumDirection clickedFace, ItemStack itemstack, EnumHand enumHand) {
-+        return (PlayerBucketEmptyEvent) getPlayerBucketEvent(false, world, who, changed, clicked, clickedFace, itemstack, Items.BUCKET, enumHand);
-+    }
-+
-+    public static PlayerBucketFillEvent callPlayerBucketFillEvent(World world, EntityHuman who, BlockPosition changed, BlockPosition clicked, EnumDirection clickedFace, ItemStack itemInHand, net.minecraft.world.item.Item bucket, EnumHand enumHand) {
-+        return (PlayerBucketFillEvent) getPlayerBucketEvent(true, world, who, clicked, changed, clickedFace, itemInHand, bucket, enumHand);
-+    }
-+
-+    private static PlayerEvent getPlayerBucketEvent(boolean isFilling, World world, EntityHuman who, BlockPosition changed, BlockPosition clicked, EnumDirection clickedFace, ItemStack itemstack, net.minecraft.world.item.Item item, EnumHand enumHand) {
-+        // Paper end
-         Player player = (Player) who.getBukkitEntity();
-         CraftItemStack itemInHand = CraftItemStack.asNewCraftStack(item);
-         Material bucket = CraftMagicNumbers.getMaterial(itemstack.getItem());
-@@ -0,0 +0,0 @@ public class CraftEventFactory {
- 
-         PlayerEvent event;
-         if (isFilling) {
--            event = new PlayerBucketFillEvent(player, block, blockClicked, blockFace, bucket, itemInHand);
-+            event = new PlayerBucketFillEvent(player, block, blockClicked, blockFace, bucket, itemInHand, enumHand == null ? null : enumHand == EnumHand.OFF_HAND ? EquipmentSlot.OFF_HAND : EquipmentSlot.HAND); // Paper - add enumHand
-             ((PlayerBucketFillEvent) event).setCancelled(!canBuild(world, player, changed.getX(), changed.getZ()));
-         } else {
--            event = new PlayerBucketEmptyEvent(player, block, blockClicked, blockFace, bucket, itemInHand);
-+            event = new PlayerBucketEmptyEvent(player, block, blockClicked, blockFace, bucket, itemInHand, enumHand == null ? null : enumHand == EnumHand.OFF_HAND ? EquipmentSlot.OFF_HAND : EquipmentSlot.HAND); // Paper - add enumHand
-             ((PlayerBucketEmptyEvent) event).setCancelled(!canBuild(world, player, changed.getX(), changed.getZ()));
-         }
- 

Spigot-Server-Patches/Add-handshake-event-to-allow-plugins-to-handle-clien.patch

@@ -1,57 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Riley Park <rileysebastianpark@gmail.com>
-Date: Wed, 13 Apr 2016 20:21:38 -0700
-Subject: [PATCH] Add handshake event to allow plugins to handle client
- handshaking logic themselves
-
-
-diff --git a/src/main/java/net/minecraft/server/network/HandshakeListener.java b/src/main/java/net/minecraft/server/network/HandshakeListener.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/HandshakeListener.java
-+++ b/src/main/java/net/minecraft/server/network/HandshakeListener.java
-@@ -0,0 +0,0 @@ public class HandshakeListener implements PacketHandshakingInListener {
-     // CraftBukkit end
-     private static final IChatBaseComponent a = new ChatComponentText("Ignoring status request");
-     private final MinecraftServer b;
--    private final NetworkManager c;
-+    private final NetworkManager c; final NetworkManager getNetworkManager() { return this.c; } // Paper - OBFHELPER
- 
-     public HandshakeListener(MinecraftServer minecraftserver, NetworkManager networkmanager) {
-         this.b = minecraftserver;
-@@ -0,0 +0,0 @@ public class HandshakeListener implements PacketHandshakingInListener {
-                     this.c.close(chatmessage);
-                 } else {
-                     this.c.setPacketListener(new LoginListener(this.b, this.c));
-+                // Paper start - handshake event
-+                boolean proxyLogicEnabled = org.spigotmc.SpigotConfig.bungee;
-+                boolean handledByEvent = false;
-+                // Try and handle the handshake through the event
-+                if (com.destroystokyo.paper.event.player.PlayerHandshakeEvent.getHandlerList().getRegisteredListeners().length != 0) { // Hello? Can you hear me?
-+                    java.net.SocketAddress socketAddress = this.getNetworkManager().socketAddress;
-+                    String hostnameOfRemote = socketAddress instanceof java.net.InetSocketAddress ? ((java.net.InetSocketAddress) socketAddress).getHostString() : InetAddress.getLoopbackAddress().getHostAddress();
-+                    com.destroystokyo.paper.event.player.PlayerHandshakeEvent event = new com.destroystokyo.paper.event.player.PlayerHandshakeEvent(packethandshakinginsetprotocol.hostname, hostnameOfRemote, !proxyLogicEnabled);
-+                    if (event.callEvent()) {
-+                        // If we've failed somehow, let the client know so and go no further.
-+                        if (event.isFailed()) {
-+                            chatmessage = new ChatMessage(event.getFailMessage());
-+                            this.getNetworkManager().sendPacket(new PacketLoginOutDisconnect(chatmessage));
-+                            this.getNetworkManager().close(chatmessage);
-+                            return;
-+                        }
-+
-+                        if (event.getServerHostname() != null) packethandshakinginsetprotocol.hostname = event.getServerHostname();
-+                        if (event.getSocketAddressHostname() != null) this.getNetworkManager().socketAddress = new java.net.InetSocketAddress(event.getSocketAddressHostname(), socketAddress instanceof java.net.InetSocketAddress ? ((java.net.InetSocketAddress) socketAddress).getPort() : 0);
-+                        this.getNetworkManager().spoofedUUID = event.getUniqueId();
-+                        this.getNetworkManager().spoofedProfile = gson.fromJson(event.getPropertiesJson(), com.mojang.authlib.properties.Property[].class);
-+                        handledByEvent = true; // Hooray, we did it!
-+                    }
-+                }
-+                // Don't try and handle default logic if it's been handled by the event.
-+                if (!handledByEvent && proxyLogicEnabled) {
-+                // Paper end
-                     // Spigot Start
--                    if (org.spigotmc.SpigotConfig.bungee) {
-+                //if (org.spigotmc.SpigotConfig.bungee) { // Paper - comment out, we check above!
-                         String[] split = packethandshakinginsetprotocol.hostname.split("\00");
-                         if ( ( split.length == 3 || split.length == 4 ) && ( HOST_PATTERN.matcher( split[1] ).matches() ) ) {
-                             packethandshakinginsetprotocol.hostname = split[0];

Spigot-Server-Patches/Add-ignore-discounts-API.patch

@@ -1,143 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Mariell Hoversholm <proximyst@proximyst.com>
-Date: Mon, 9 Nov 2020 20:44:51 +0100
-Subject: [PATCH] Add ignore discounts API
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/npc/EntityVillager.java b/src/main/java/net/minecraft/world/entity/npc/EntityVillager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/npc/EntityVillager.java
-+++ b/src/main/java/net/minecraft/world/entity/npc/EntityVillager.java
-@@ -0,0 +0,0 @@ public class EntityVillager extends EntityVillagerAbstract implements Reputation
- 
-             while (iterator.hasNext()) {
-                 MerchantRecipe merchantrecipe = (MerchantRecipe) iterator.next();
-+                if (merchantrecipe.ignoreDiscounts) continue; // Paper
- 
-                 // CraftBukkit start
-                 int bonus = -MathHelper.d((float) i * merchantrecipe.getPriceMultiplier());
-@@ -0,0 +0,0 @@ public class EntityVillager extends EntityVillagerAbstract implements Reputation
- 
-             while (iterator1.hasNext()) {
-                 MerchantRecipe merchantrecipe1 = (MerchantRecipe) iterator1.next();
-+                if (merchantrecipe1.ignoreDiscounts) continue; // Paper
-                 double d0 = 0.3D + 0.0625D * (double) j;
-                 int k = (int) Math.floor(d0 * (double) merchantrecipe1.a().getCount());
- 
-diff --git a/src/main/java/net/minecraft/world/item/trading/MerchantRecipe.java b/src/main/java/net/minecraft/world/item/trading/MerchantRecipe.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/item/trading/MerchantRecipe.java
-+++ b/src/main/java/net/minecraft/world/item/trading/MerchantRecipe.java
-@@ -0,0 +0,0 @@ public class MerchantRecipe {
-     private int demand;
-     public float priceMultiplier;
-     public int xp;
-+    public boolean ignoreDiscounts; // Paper
-     // CraftBukkit start
-     private CraftMerchantRecipe bukkitHandle;
- 
-@@ -0,0 +0,0 @@ public class MerchantRecipe {
-     }
- 
-     public MerchantRecipe(ItemStack itemstack, ItemStack itemstack1, ItemStack itemstack2, int uses, int maxUses, int experience, float priceMultiplier, CraftMerchantRecipe bukkit) {
--        this(itemstack, itemstack1, itemstack2, uses, maxUses, experience, priceMultiplier);
-+        // Paper start - add ignoreDiscounts param
-+        this(itemstack, itemstack1, itemstack2, uses, maxUses, experience, priceMultiplier, false, bukkit);
-+    }
-+    public MerchantRecipe(ItemStack itemstack, ItemStack itemstack1, ItemStack itemstack2, int uses, int maxUses, int experience, float priceMultiplier, boolean ignoreDiscounts, CraftMerchantRecipe bukkit) {
-+        this(itemstack, itemstack1, itemstack2, uses, maxUses, experience, priceMultiplier, ignoreDiscounts);
-+        // Paper end
-         this.bukkitHandle = bukkit;
-     }
-     // CraftBukkit end
-@@ -0,0 +0,0 @@ public class MerchantRecipe {
- 
-         this.specialPrice = nbttagcompound.getInt("specialPrice");
-         this.demand = nbttagcompound.getInt("demand");
-+        this.ignoreDiscounts = nbttagcompound.getBoolean("Paper.IgnoreDiscounts"); // Paper
-     }
- 
-     public MerchantRecipe(ItemStack itemstack, ItemStack itemstack1, int i, int j, float f) {
-@@ -0,0 +0,0 @@ public class MerchantRecipe {
-     }
- 
-     public MerchantRecipe(ItemStack itemstack, ItemStack itemstack1, ItemStack itemstack2, int i, int j, int k, float f) {
--        this(itemstack, itemstack1, itemstack2, i, j, k, f, 0);
-+        // Paper start - add ignoreDiscounts param
-+        this(itemstack, itemstack1, itemstack2, i, j, k, f, false);
-+    }
-+    public MerchantRecipe(ItemStack itemstack, ItemStack itemstack1, ItemStack itemstack2, int i, int j, int k, float f, boolean ignoreDiscounts) {
-+        this(itemstack, itemstack1, itemstack2, i, j, k, f, 0, ignoreDiscounts);
-     }
- 
-     public MerchantRecipe(ItemStack itemstack, ItemStack itemstack1, ItemStack itemstack2, int i, int j, int k, float f, int l) {
-+        this(itemstack, itemstack1, itemstack2, i, j, k, f, l, false);
-+    }
-+    public MerchantRecipe(ItemStack itemstack, ItemStack itemstack1, ItemStack itemstack2, int i, int j, int k, float f, int l, boolean ignoreDiscounts) {
-+        this.ignoreDiscounts = ignoreDiscounts;
-+        // Paper end
-         this.rewardExp = true;
-         this.xp = 1;
-         this.buyingItem1 = itemstack;
-@@ -0,0 +0,0 @@ public class MerchantRecipe {
-         nbttagcompound.setFloat("priceMultiplier", this.priceMultiplier);
-         nbttagcompound.setInt("specialPrice", this.specialPrice);
-         nbttagcompound.setInt("demand", this.demand);
-+        nbttagcompound.setBoolean("Paper.IgnoreDiscounts", this.ignoreDiscounts); // Paper
-         return nbttagcompound;
-     }
- 
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMerchantRecipe.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMerchantRecipe.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMerchantRecipe.java
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMerchantRecipe.java
-@@ -0,0 +0,0 @@ public class CraftMerchantRecipe extends MerchantRecipe {
-     }
- 
-     public CraftMerchantRecipe(ItemStack result, int uses, int maxUses, boolean experienceReward, int experience, float priceMultiplier) {
--        super(result, uses, maxUses, experienceReward, experience, priceMultiplier);
-+        // Paper start - add ignoreDiscounts param
-+        this(result, uses, maxUses, experienceReward, experience, priceMultiplier, false);
-+    }
-+    public CraftMerchantRecipe(ItemStack result, int uses, int maxUses, boolean experienceReward, int experience, float priceMultiplier, boolean ignoreDiscounts) {
-+        super(result, uses, maxUses, experienceReward, experience, priceMultiplier, ignoreDiscounts);
-+        // Paper end
-         this.handle = new net.minecraft.world.item.trading.MerchantRecipe(
-                 net.minecraft.world.item.ItemStack.b,
-                 net.minecraft.world.item.ItemStack.b,
-@@ -0,0 +0,0 @@ public class CraftMerchantRecipe extends MerchantRecipe {
-                 maxUses,
-                 experience,
-                 priceMultiplier,
-+                ignoreDiscounts, // Paper - add ignoreDiscounts param
-                 this
-         );
-         this.setExperienceReward(experienceReward);
-@@ -0,0 +0,0 @@ public class CraftMerchantRecipe extends MerchantRecipe {
-         handle.priceMultiplier = priceMultiplier;
-     }
- 
-+    // Paper start
-+    @Override
-+    public boolean shouldIgnoreDiscounts() {
-+        return this.handle.ignoreDiscounts;
-+    }
-+
-+    @Override
-+    public void setIgnoreDiscounts(boolean ignoreDiscounts) {
-+        this.handle.ignoreDiscounts = ignoreDiscounts;
-+    }
-+    // Paper end
-+
-     public net.minecraft.world.item.trading.MerchantRecipe toMinecraft() {
-         List<ItemStack> ingredients = getIngredients();
-         Preconditions.checkState(!ingredients.isEmpty(), "No offered ingredients");
-@@ -0,0 +0,0 @@ public class CraftMerchantRecipe extends MerchantRecipe {
-         if (recipe instanceof CraftMerchantRecipe) {
-             return (CraftMerchantRecipe) recipe;
-         } else {
--            CraftMerchantRecipe craft = new CraftMerchantRecipe(recipe.getResult(), recipe.getUses(), recipe.getMaxUses(), recipe.hasExperienceReward(), recipe.getVillagerExperience(), recipe.getPriceMultiplier());
-+            CraftMerchantRecipe craft = new CraftMerchantRecipe(recipe.getResult(), recipe.getUses(), recipe.getMaxUses(), recipe.hasExperienceReward(), recipe.getVillagerExperience(), recipe.getPriceMultiplier(), recipe.shouldIgnoreDiscounts()); // Paper - shouldIgnoreDiscounts
-             craft.setIngredients(recipe.getIngredients());
- 
-             return craft;

Spigot-Server-Patches/Add-method-to-open-already-placed-sign.patch

@@ -1,36 +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 method to open already placed sign
-
-
-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 @@ import net.minecraft.world.level.block.BlockEnchantmentTable;
- import net.minecraft.world.level.block.BlockWorkbench;
- import net.minecraft.world.level.block.Blocks;
- import net.minecraft.world.level.block.entity.TileEntity;
-+import net.minecraft.world.level.block.entity.TileEntitySign;
- import net.minecraft.world.level.block.state.IBlockData;
- import org.bukkit.GameMode;
- import org.bukkit.Location;
-@@ -0,0 +0,0 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
-         }
-     }
- 
-+    // Paper start - Add method to open already placed sign
-+    @Override
-+    public void openSign(org.bukkit.block.Sign sign) {
-+        org.apache.commons.lang.Validate.isTrue(sign.getWorld().equals(this.getWorld()), "Sign must be in the same world as player is in");
-+        org.bukkit.craftbukkit.block.CraftSign craftSign = (org.bukkit.craftbukkit.block.CraftSign) sign;
-+        TileEntitySign teSign = craftSign.getTileEntity();
-+        // Make sign editable temporarily, will be set back to false in PlayerConnection later
-+        teSign.isEditable = true;
-+        getHandle().openSign(teSign);
-+    }
-+    // Paper end
-     @Override
-     public boolean dropItem(boolean dropAll) {
-         return getHandle().dropItem(dropAll);

Spigot-Server-Patches/Add-methods-for-working-with-arrows-stuck-in-living-.patch

@@ -1,27 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: mrapple <tony@oc.tc>
-Date: Sun, 25 Nov 2012 13:43:39 -0600
-Subject: [PATCH] Add methods for working with arrows stuck in living entities
-
-
-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().persistentInvisibility = invisible;
-         getHandle().setFlag(5, invisible);
-     }
-+
-+    // Paper start
-+    @Override
-+    public int getArrowsStuck() {
-+        return getHandle().getArrowCount();
-+    }
-+
-+    @Override
-+    public void setArrowsStuck(int arrows) {
-+        getHandle().setArrowCount(arrows);
-+    }
-+    // Paper end
- }

Spigot-Server-Patches/Add-missing-strikeLighting-call-to-World-spigot-stri.patch

@@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Shane Freeder <theboyetronic@gmail.com>
-Date: Sun, 26 Jul 2020 12:11:39 +0100
-Subject: [PATCH] Add missing strikeLighting call to
- World#spigot()#strikeLightningEffect
-
-
-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 implements World {
-             lightning.teleportAndSync( loc.getX(), loc.getY(), loc.getZ() );
-             lightning.isEffect = true;
-             lightning.isSilent = isSilent;
-+            world.strikeLightning( lightning );
-             return (LightningStrike) lightning.getBukkitEntity();
-         }
-     };

Spigot-Server-Patches/Add-moon-phase-API.patch

@@ -1,22 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Sun, 23 Aug 2020 16:32:11 +0200
-Subject: [PATCH] Add moon phase 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 implements World {
-     public int getPlayerCount() {
-         return world.players.size();
-     }
-+
-+    @Override
-+    public io.papermc.paper.world.MoonPhase getMoonPhase() {
-+        return io.papermc.paper.world.MoonPhase.getPhase(getFullTime() / 24000L);
-+    }
-     // Paper end
- 
-     private static final Random rand = new Random();

Spigot-Server-Patches/Add-more-Evoker-API.patch

@@ -1,57 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Sun, 23 Aug 2020 15:28:35 +0200
-Subject: [PATCH] Add more Evoker API
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/monster/EntityEvoker.java b/src/main/java/net/minecraft/world/entity/monster/EntityEvoker.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/EntityEvoker.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/EntityEvoker.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.phys.shapes.VoxelShape;
- 
- public class EntityEvoker extends EntityIllagerWizard {
- 
--    private EntitySheep bo;
-+    private EntitySheep bo; public final EntitySheep getWololoTarget() { return this.bo; } public final void setWololoTarget(EntitySheep sheep) { this.bo = sheep; } // Paper - OBFHELPER
- 
-     public EntityEvoker(EntityTypes<? extends EntityEvoker> entitytypes, World world) {
-         super(entitytypes, world);
-@@ -0,0 +0,0 @@ public class EntityEvoker extends EntityIllagerWizard {
-         this.goalSelector.a(8, new PathfinderGoalRandomStroll(this, 0.6D));
-         this.goalSelector.a(9, new PathfinderGoalLookAtPlayer(this, EntityHuman.class, 3.0F, 1.0F));
-         this.goalSelector.a(10, new PathfinderGoalLookAtPlayer(this, EntityInsentient.class, 8.0F));
--        this.targetSelector.a(1, (new PathfinderGoalHurtByTarget(this, new Class[]{EntityRaider.class})).a());
-+        this.targetSelector.a(1, (new PathfinderGoalHurtByTarget(this, new Class[]{EntityRaider.class})).a(new Class[0])); // Paper - decompile fix
-         this.targetSelector.a(2, (new PathfinderGoalNearestAttackableTarget<>(this, EntityHuman.class, true)).a(300));
-         this.targetSelector.a(3, (new PathfinderGoalNearestAttackableTarget<>(this, EntityVillagerAbstract.class, false)).a(300));
-         this.targetSelector.a(3, new PathfinderGoalNearestAttackableTarget<>(this, EntityIronGolem.class, false));
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEvoker.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEvoker.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEvoker.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEvoker.java
-@@ -0,0 +0,0 @@
- package org.bukkit.craftbukkit.entity;
- 
-+import net.minecraft.world.entity.animal.EntitySheep;
- import net.minecraft.world.entity.monster.EntityEvoker;
- import net.minecraft.world.entity.monster.EntityIllagerWizard;
- import org.bukkit.craftbukkit.CraftServer;
-@@ -0,0 +0,0 @@ public class CraftEvoker extends CraftSpellcaster implements Evoker {
-     public void setCurrentSpell(Evoker.Spell spell) {
-         getHandle().setSpell(spell == null ? EntityIllagerWizard.Spell.NONE : EntityIllagerWizard.Spell.a(spell.ordinal()));
-     }
-+
-+    // Paper start
-+    @Override
-+    public org.bukkit.entity.Sheep getWololoTarget() {
-+        EntitySheep sheep = getHandle().getWololoTarget();
-+        return sheep == null ? null : (org.bukkit.entity.Sheep) sheep.getBukkitEntity();
-+    }
-+
-+    @Override
-+    public void setWololoTarget(org.bukkit.entity.Sheep sheep) {
-+        getHandle().setWololoTarget(sheep == null ? null : ((org.bukkit.craftbukkit.entity.CraftSheep) sheep).getHandle());
-+    }
-+    // Paper end
- }

Spigot-Server-Patches/Add-more-WanderingTrader-API.patch

@@ -1,65 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: HexedHero <6012891+HexedHero@users.noreply.github.com>
-Date: Thu, 6 May 2021 14:56:43 +0100
-Subject: [PATCH] Add more WanderingTrader API
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/npc/EntityVillagerTrader.java b/src/main/java/net/minecraft/world/entity/npc/EntityVillagerTrader.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/npc/EntityVillagerTrader.java
-+++ b/src/main/java/net/minecraft/world/entity/npc/EntityVillagerTrader.java
-@@ -0,0 +0,0 @@ public class EntityVillagerTrader extends EntityVillagerAbstract {
-     @Nullable
-     private BlockPosition bp;
-     private int despawnDelay;
-+    // Paper start - Add more WanderingTrader API
-+    public boolean canDrinkPotion = true;
-+    public boolean canDrinkMilk = true;
-+    // Paper end
- 
-     public EntityVillagerTrader(EntityTypes<? extends EntityVillagerTrader> entitytypes, World world) {
-         super(entitytypes, world);
-@@ -0,0 +0,0 @@ public class EntityVillagerTrader extends EntityVillagerAbstract {
-     protected void initPathfinder() {
-         this.goalSelector.a(0, new PathfinderGoalFloat(this));
-         this.goalSelector.a(0, new PathfinderGoalUseItem<>(this, PotionUtil.a(new ItemStack(Items.POTION), Potions.INVISIBILITY), SoundEffects.ENTITY_WANDERING_TRADER_DISAPPEARED, (entityvillagertrader) -> {
--            return this.world.isNight() && !entityvillagertrader.isInvisible();
-+            return canDrinkPotion && this.world.isNight() && !entityvillagertrader.isInvisible(); // Paper - Add more WanderingTrader API
-         }));
-         this.goalSelector.a(0, new PathfinderGoalUseItem<>(this, new ItemStack(Items.MILK_BUCKET), SoundEffects.ENTITY_WANDERING_TRADER_REAPPEARED, (entityvillagertrader) -> {
--            return this.world.isDay() && entityvillagertrader.isInvisible();
-+            return canDrinkMilk && this.world.isDay() && entityvillagertrader.isInvisible(); // Paper - Add more WanderingTrader API
-         }));
-         this.goalSelector.a(1, new PathfinderGoalTradeWithPlayer(this));
-         this.goalSelector.a(1, new PathfinderGoalAvoidTarget<>(this, EntityZombie.class, 8.0F, 0.5D, 0.5D));
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftWanderingTrader.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftWanderingTrader.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftWanderingTrader.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftWanderingTrader.java
-@@ -0,0 +0,0 @@ public class CraftWanderingTrader extends CraftAbstractVillager implements Wande
-     public void setDespawnDelay(int despawnDelay) {
-         getHandle().setDespawnDelay(despawnDelay);
-     }
-+
-+    // Paper start - Add more WanderingTrader API
-+    @Override
-+    public void setCanDrinkPotion(boolean bool) {
-+        getHandle().canDrinkPotion = bool;
-+    }
-+
-+    @Override
-+    public boolean canDrinkPotion() {
-+        return getHandle().canDrinkPotion;
-+    }
-+
-+    @Override
-+    public void setCanDrinkMilk(boolean bool) {
-+        getHandle().canDrinkMilk = bool;
-+    }
-+
-+    @Override
-+    public boolean canDrinkMilk() {
-+        return getHandle().canDrinkMilk;
-+    }
-+    // Paper end
- }

Spigot-Server-Patches/Add-more-Witch-API.patch

@@ -1,153 +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
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/monster/EntityWitch.java b/src/main/java/net/minecraft/world/entity/monster/EntityWitch.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/EntityWitch.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/EntityWitch.java
-@@ -0,0 +0,0 @@
- package net.minecraft.world.entity.monster;
- 
-+// Paper start
-+import com.destroystokyo.paper.event.entity.WitchReadyPotionEvent;
-+import org.bukkit.craftbukkit.inventory.CraftItemStack;
-+import org.bukkit.entity.Witch;
-+// Paper end
-+
- import java.util.Iterator;
- import java.util.List;
- import java.util.UUID;
-@@ -0,0 +0,0 @@ public class EntityWitch extends EntityRaider implements IRangedEntity {
-     private static final UUID b = UUID.fromString("5CD17E52-A79A-43D3-A529-90FDE04B181E");
-     private static final AttributeModifier bo = new AttributeModifier(EntityWitch.b, "Drinking speed penalty", -0.25D, AttributeModifier.Operation.ADDITION);
-     private static final DataWatcherObject<Boolean> bp = DataWatcher.a(EntityWitch.class, DataWatcherRegistry.i);
--    private int bq;
-+    private int bq; public int getPotionUseTimeLeft() { return bq; } public void setPotionUseTimeLeft(int timeLeft) { bq = timeLeft; } // Paper - OBFHELPER
-     private PathfinderGoalNearestHealableRaider<EntityRaider> br;
-     private PathfinderGoalNearestAttackableTargetWitch<EntityHuman> bs;
- 
-@@ -0,0 +0,0 @@ public class EntityWitch extends EntityRaider implements IRangedEntity {
-         return SoundEffects.ENTITY_WITCH_DEATH;
-     }
- 
-+    public void setDrinkingPotion(boolean drinkingPotion) { v(drinkingPotion); } // Paper - OBFHELPER
-     public void v(boolean flag) {
-         this.getDataWatcher().set(EntityWitch.bp, flag);
-     }
- 
-+    public boolean isDrinkingPotion() { return m(); } // Paper - OBFHELPER
-     public boolean m() {
-         return (Boolean) this.getDataWatcher().get(EntityWitch.bp);
-     }
-@@ -0,0 +0,0 @@ public class EntityWitch extends EntityRaider implements IRangedEntity {
-                 }
- 
-                 if (potionregistry != null) {
--                    // Paper start
-                     ItemStack potion = PotionUtil.a(new ItemStack(Items.POTION), potionregistry);
--                    org.bukkit.inventory.ItemStack bukkitStack = com.destroystokyo.paper.event.entity.WitchReadyPotionEvent.process((org.bukkit.entity.Witch) this.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(potion));
--                    this.setSlot(EnumItemSlot.MAINHAND, org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(bukkitStack));
-+                    // Paper start - logic moved into setDrinkingPotion, copy exact impl into the method and then comment out
-+                    this.setDrinkingPotion(potion);
-+//                    org.bukkit.inventory.ItemStack bukkitStack = com.destroystokyo.paper.event.entity.WitchReadyPotionEvent.process((org.bukkit.entity.Witch) this.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(potion));
-+//                    this.setSlot(EnumItemSlot.MAINHAND, org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(bukkitStack));
-+//                    // Paper end
-+//                    this.bq = this.getItemInMainHand().k();
-+//                    this.v(true);
-+//                    if (!this.isSilent()) {
-+//                        this.world.playSound((EntityHuman) null, this.locX(), this.locY(), this.locZ(), SoundEffects.ENTITY_WITCH_DRINK, this.getSoundCategory(), 1.0F, 0.8F + this.random.nextFloat() * 0.4F);
-+//                    }
-+//
-+//                    AttributeModifiable attributemodifiable = this.getAttributeInstance(GenericAttributes.MOVEMENT_SPEED);
-+//
-+//                    attributemodifiable.removeModifier(EntityWitch.bo);
-+//                    attributemodifiable.b(EntityWitch.bo);
-                     // Paper end
--                    this.bq = this.getItemInMainHand().k();
--                    this.v(true);
--                    if (!this.isSilent()) {
--                        this.world.playSound((EntityHuman) null, this.locX(), this.locY(), this.locZ(), SoundEffects.ENTITY_WITCH_DRINK, this.getSoundCategory(), 1.0F, 0.8F + this.random.nextFloat() * 0.4F);
--                    }
- 
--                    AttributeModifiable attributemodifiable = this.getAttributeInstance(GenericAttributes.MOVEMENT_SPEED);
--
--                    attributemodifiable.removeModifier(EntityWitch.bo);
--                    attributemodifiable.b(EntityWitch.bo);
-                 }
-             }
- 
-@@ -0,0 +0,0 @@ public class EntityWitch extends EntityRaider implements IRangedEntity {
-         super.movementTick();
-     }
- 
-+    // Paper start - moved to its own method
-+    public void setDrinkingPotion(ItemStack potion) {
-+        org.bukkit.inventory.ItemStack bukkitStack = com.destroystokyo.paper.event.entity.WitchReadyPotionEvent.process((org.bukkit.entity.Witch) this.getBukkitEntity(), org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(potion));
-+        this.setSlot(EnumItemSlot.MAINHAND, org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(bukkitStack));
-+        // Paper end
-+        this.bq = this.getItemInMainHand().k();
-+        this.v(true);
-+        if (!this.isSilent()) {
-+            this.world.playSound((EntityHuman) null, this.locX(), this.locY(), this.locZ(), SoundEffects.ENTITY_WITCH_DRINK, this.getSoundCategory(), 1.0F, 0.8F + this.random.nextFloat() * 0.4F);
-+        }
-+
-+        AttributeModifiable attributemodifiable = this.getAttributeInstance(GenericAttributes.MOVEMENT_SPEED);
-+
-+        attributemodifiable.removeModifier(EntityWitch.bo);
-+        attributemodifiable.b(EntityWitch.bo);
-+    }
-+    // Paper end
-+
-     @Override
-     public SoundEffect eL() {
-         return SoundEffects.ENTITY_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 @@ import net.minecraft.world.entity.monster.EntityWitch;
- import org.bukkit.craftbukkit.CraftServer;
- import org.bukkit.entity.EntityType;
- 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<EntityWitch> { // Paper
-     public CraftWitch(CraftServer server, EntityWitch entity) {
-@@ -0,0 +0,0 @@ public class CraftWitch extends CraftRaider implements Witch, com.destroystokyo.
-     public EntityType getType() {
-         return EntityType.WITCH;
-     }
-+
-+    // Paper start
-+    public boolean isDrinkingPotion() {
-+        return getHandle().isDrinkingPotion();
-+    }
-+
-+    public int getPotionUseTimeLeft() {
-+        return getHandle().getPotionUseTimeLeft();
-+    }
-+
-+    @Override
-+    public void setPotionUseTimeLeft(int ticks) {
-+        getHandle().setPotionUseTimeLeft(ticks);
-+    }
-+
-+    public ItemStack getDrinkingPotion() {
-+        return CraftItemStack.asCraftMirror(getHandle().getItemInMainHand());
-+    }
-+
-+    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
- }

Spigot-Server-Patches/Add-more-Zombie-API.patch

@@ -1,117 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Sun, 7 Oct 2018 04:29:59 -0500
-Subject: [PATCH] Add more Zombie API
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/monster/EntityZombie.java b/src/main/java/net/minecraft/world/entity/monster/EntityZombie.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/EntityZombie.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/EntityZombie.java
-@@ -0,0 +0,0 @@ public class EntityZombie extends EntityMonster {
-     private int bt;
-     public int drownedConversionTime;
-     private int lastTick = MinecraftServer.currentTick; // CraftBukkit - add field
-+    private boolean shouldBurnInDay = true; // Paper
- 
-     public EntityZombie(EntityTypes<? extends EntityZombie> entitytypes, World world) {
-         super(entitytypes, world);
-@@ -0,0 +0,0 @@ public class EntityZombie extends EntityMonster {
-         super.movementTick();
-     }
- 
-+    // Paper start
-+    public void stopDrowning() {
-+        this.drownedConversionTime = -1;
-+        this.getDataWatcher().set(EntityZombie.DROWN_CONVERTING, false);
-+    }
-+    // Paper end
-     public void startDrownedConversion(int i) {
-         this.lastTick = MinecraftServer.currentTick; // CraftBukkit
-         this.drownedConversionTime = i;
-@@ -0,0 +0,0 @@ public class EntityZombie extends EntityMonster {
- 
-     }
- 
-+    public boolean shouldBurnInDay() { return T_(); } // Paper - OBFHELPER
-     protected boolean T_() {
--        return true;
-+        return this.shouldBurnInDay; // Paper - use api value instead
-+    }
-+
-+    // Paper start
-+    public void setShouldBurnInDay(boolean shouldBurnInDay) {
-+        this.shouldBurnInDay = shouldBurnInDay;
-     }
-+    // Paper end
- 
-     @Override
-     public boolean damageEntity(DamageSource damagesource, float f) {
-@@ -0,0 +0,0 @@ public class EntityZombie extends EntityMonster {
-         nbttagcompound.setBoolean("CanBreakDoors", this.eU());
-         nbttagcompound.setInt("InWaterTime", this.isInWater() ? this.bt : -1);
-         nbttagcompound.setInt("DrownedConversionTime", this.isDrownConverting() ? this.drownedConversionTime : -1);
-+        nbttagcompound.setBoolean("Paper.ShouldBurnInDay", shouldBurnInDay); // Paper
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class EntityZombie extends EntityMonster {
-         if (nbttagcompound.hasKeyOfType("DrownedConversionTime", 99) && nbttagcompound.getInt("DrownedConversionTime") > -1) {
-             this.startDrownedConversion(nbttagcompound.getInt("DrownedConversionTime"));
-         }
--
-+        // Paper start
-+        if (nbttagcompound.hasKey("Paper.ShouldBurnInDay")) {
-+            shouldBurnInDay = nbttagcompound.getBoolean("Paper.ShouldBurnInDay");
-+        }
-+        // Paper end
-     }
- 
-     @Override
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftZombie.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftZombie.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftZombie.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftZombie.java
-@@ -0,0 +0,0 @@ public class CraftZombie extends CraftMonster implements Zombie {
-     @Override
-     public void setAgeLock(boolean b) {
-     }
-+    // Paper start
-+    @Override
-+    public boolean isDrowning() {
-+        return getHandle().isDrownConverting();
-+    }
-+
-+    @Override
-+    public void startDrowning(int drownedConversionTime) {
-+        getHandle().startDrownedConversion(drownedConversionTime);
-+    }
-+
-+    @Override
-+    public void stopDrowning() {
-+        getHandle().stopDrowning();
-+    }
-+
-+    @Override
-+    public boolean shouldBurnInDay() {
-+        return getHandle().shouldBurnInDay();
-+    }
-+
-+    @Override
-+    public boolean isArmsRaised() {
-+        return getHandle().isAggressive();
-+    }
-+
-+    @Override
-+    public void setArmsRaised(final boolean raised) {
-+        getHandle().setAggressive(raised);
-+    }
-+
-+    @Override
-+    public void setShouldBurnInDay(boolean shouldBurnInDay) {
-+        getHandle().setShouldBurnInDay(shouldBurnInDay);
-+    }
-+    // Paper end
- 
-     @Override
-     public boolean getAgeLock() {

Spigot-Server-Patches/Add-more-line-of-sight-methods.patch

@@ -1,62 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: TwoLeggedCat <80929284+TwoLeggedCat@users.noreply.github.com>
-Date: Sat, 29 May 2021 14:33:25 -0500
-Subject: [PATCH] Add more line of sight methods
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/EntityLiving.java b/src/main/java/net/minecraft/world/entity/EntityLiving.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/EntityLiving.java
-+++ b/src/main/java/net/minecraft/world/entity/EntityLiving.java
-@@ -0,0 +0,0 @@ public abstract class EntityLiving extends Entity {
-         Vec3D vec3d = new Vec3D(this.locX(), this.getHeadY(), this.locZ());
-         Vec3D vec3d1 = new Vec3D(entity.locX(), entity.getHeadY(), entity.locZ());
- 
-+        // Paper - diff on change - used in CraftLivingEntity#hasLineOfSight(Location) and CraftWorld#lineOfSightExists
-         return this.world.rayTrace(new RayTrace(vec3d, vec3d1, RayTrace.BlockCollisionOption.COLLIDER, RayTrace.FluidCollisionOption.NONE, this)).getType() == MovingObjectPosition.EnumMovingObjectType.MISS;
-     }
- 
-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 implements World {
-     public io.papermc.paper.world.MoonPhase getMoonPhase() {
-         return io.papermc.paper.world.MoonPhase.getPhase(getFullTime() / 24000L);
-     }
-+
-+    @Override
-+    public boolean lineOfSightExists(Location from, Location to) {
-+        Validate.notNull(from, "from parameter in lineOfSightExists cannot be null");
-+        Validate.notNull(to, "to parameter in lineOfSightExists cannot be null");
-+        if (from.getWorld() != to.getWorld()) return false;
-+        Vec3D vec3d = new Vec3D(from.getX(), from.getY(), from.getZ());
-+        Vec3D vec3d1 = new Vec3D(to.getX(), to.getY(), to.getZ());
-+
-+        return this.getHandle().rayTrace(new RayTrace(vec3d, vec3d1, RayTrace.BlockCollisionOption.COLLIDER, RayTrace.FluidCollisionOption.NONE, null)).getType() == MovingObjectPosition.EnumMovingObjectType.MISS;
-+    }
-     // Paper end
- 
-     private static final Random rand = new Random();
-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 getHandle().hasLineOfSight(((CraftEntity) other).getHandle());
-     }
- 
-+    // Paper start
-+    @Override
-+    public boolean hasLineOfSight(Location loc) {
-+        if (this.getHandle().world != ((CraftWorld) loc.getWorld()).getHandle()) return false;
-+        Vec3D vec3d = new Vec3D(this.getHandle().locX(), this.getHandle().getHeadY(), this.getHandle().locZ());
-+        Vec3D vec3d1 = new Vec3D(loc.getX(), loc.getY(), loc.getZ());
-+
-+        return this.getHandle().world.rayTrace(new RayTrace(vec3d, vec3d1, RayTrace.BlockCollisionOption.COLLIDER, RayTrace.FluidCollisionOption.NONE, this.getHandle())).getType() == MovingObjectPosition.EnumMovingObjectType.MISS;
-+    }
-+    // Paper end
-+
-     @Override
-     public boolean getRemoveWhenFarAway() {
-         return getHandle() instanceof EntityInsentient && !((EntityInsentient) getHandle()).persistent;

Spigot-Server-Patches/Add-option-for-console-having-all-permissions.patch

@@ -1,74 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Mariell Hoversholm <proximyst@proximyst.com>
-Date: Sat, 16 May 2020 10:12:15 +0200
-Subject: [PATCH] Add option for console having all permissions
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
- 
-     }
- 
-+    public static boolean consoleHasAllPermissions = false;
-+    private static void consoleHasAllPermissions() {
-+        consoleHasAllPermissions = getBoolean("settings.console-has-all-permissions", consoleHasAllPermissions);
-+    }
-+
- }
-diff --git a/src/main/java/net/minecraft/world/entity/player/EntityHuman.java b/src/main/java/net/minecraft/world/entity/player/EntityHuman.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/player/EntityHuman.java
-+++ b/src/main/java/net/minecraft/world/entity/player/EntityHuman.java
-@@ -0,0 +0,0 @@ public abstract class EntityHuman extends EntityLiving {
-         }
-     }
- 
--    protected void releaseShoulderEntities() {
-+    public void releaseShoulderEntities() { // Paper - protected -> public
-         if (this.e + 20L < this.world.getTime()) {
-             // CraftBukkit start
-             if (this.spawnEntityFromShoulder(this.getShoulderEntityLeft())) {
-diff --git a/src/main/java/org/bukkit/craftbukkit/command/CraftConsoleCommandSender.java b/src/main/java/org/bukkit/craftbukkit/command/CraftConsoleCommandSender.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/command/CraftConsoleCommandSender.java
-+++ b/src/main/java/org/bukkit/craftbukkit/command/CraftConsoleCommandSender.java
-@@ -0,0 +0,0 @@ public class CraftConsoleCommandSender extends ServerCommandSender implements Co
-     public void sendMessage(final net.kyori.adventure.identity.Identity identity, final net.kyori.adventure.text.Component message, final net.kyori.adventure.audience.MessageType type) {
-         this.sendRawMessage(org.bukkit.craftbukkit.util.CraftChatMessage.fromComponent(io.papermc.paper.adventure.PaperAdventure.asVanilla(message)));
-     }
-+
-+    @Override
-+    public boolean hasPermission(String name) {
-+        return com.destroystokyo.paper.PaperConfig.consoleHasAllPermissions || super.hasPermission(name);
-+    }
-+
-+    @Override
-+    public boolean hasPermission(org.bukkit.permissions.Permission perm) {
-+        return com.destroystokyo.paper.PaperConfig.consoleHasAllPermissions || super.hasPermission(perm);
-+    }
-     // Paper end
- }
-diff --git a/src/main/java/org/bukkit/craftbukkit/command/CraftRemoteConsoleCommandSender.java b/src/main/java/org/bukkit/craftbukkit/command/CraftRemoteConsoleCommandSender.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/command/CraftRemoteConsoleCommandSender.java
-+++ b/src/main/java/org/bukkit/craftbukkit/command/CraftRemoteConsoleCommandSender.java
-@@ -0,0 +0,0 @@ public class CraftRemoteConsoleCommandSender extends ServerCommandSender impleme
-     public void setOp(boolean value) {
-         throw new UnsupportedOperationException("Cannot change operator status of remote controller.");
-     }
-+
-+    // Paper start
-+    @Override
-+    public boolean hasPermission(String name) {
-+        return com.destroystokyo.paper.PaperConfig.consoleHasAllPermissions || super.hasPermission(name);
-+    }
-+
-+    @Override
-+    public boolean hasPermission(org.bukkit.permissions.Permission perm) {
-+        return com.destroystokyo.paper.PaperConfig.consoleHasAllPermissions || super.hasPermission(perm);
-+    }
-+    // Paper end
- }

Spigot-Server-Patches/Add-option-to-allow-iron-golems-to-spawn-in-air.patch

@@ -1,35 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <blake.galbreath@gmail.com>
-Date: Sat, 13 Apr 2019 16:50:58 -0500
-Subject: [PATCH] Add option to allow iron golems to spawn in air
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         scanForLegacyEnderDragon = getBoolean("game-mechanics.scan-for-legacy-ender-dragon", true);
-     }
- 
-+    public boolean ironGolemsCanSpawnInAir = false;
-+    private void ironGolemsCanSpawnInAir() {
-+        ironGolemsCanSpawnInAir = getBoolean("iron-golems-can-spawn-in-air", ironGolemsCanSpawnInAir);
-+    }
-+
-     public boolean armorStandEntityLookups = true;
-     private void armorStandEntityLookups() {
-         armorStandEntityLookups = getBoolean("armor-stands-do-collision-entity-lookups", true);
-diff --git a/src/main/java/net/minecraft/world/entity/animal/EntityIronGolem.java b/src/main/java/net/minecraft/world/entity/animal/EntityIronGolem.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/animal/EntityIronGolem.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/EntityIronGolem.java
-@@ -0,0 +0,0 @@ public class EntityIronGolem extends EntityGolem implements IEntityAngerable {
-         BlockPosition blockposition1 = blockposition.down();
-         IBlockData iblockdata = iworldreader.getType(blockposition1);
- 
--        if (!iblockdata.a((IBlockAccess) iworldreader, blockposition1, (Entity) this)) {
-+        if (!iblockdata.a((IBlockAccess) iworldreader, blockposition1, (Entity) this) && !world.paperConfig.ironGolemsCanSpawnInAir) { // Paper
-             return false;
-         } else {
-             for (int i = 1; i < 3; ++i) {

Spigot-Server-Patches/Add-option-to-disable-pillager-patrols.patch

@@ -1,32 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <blake.galbreath@gmail.com>
-Date: Wed, 9 Oct 2019 21:46:15 -0500
-Subject: [PATCH] Add option to disable pillager patrols
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void generatorSettings() {
-         generateFlatBedrock = getBoolean("generator-settings.flat-bedrock", false);
-     }
-+
-+    public boolean disablePillagerPatrols = false;
-+    private void pillagerSettings() {
-+        disablePillagerPatrols = getBoolean("game-mechanics.disable-pillager-patrols", disablePillagerPatrols);
-+    }
- }
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/MobSpawnerPatrol.java b/src/main/java/net/minecraft/world/level/levelgen/MobSpawnerPatrol.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/levelgen/MobSpawnerPatrol.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/MobSpawnerPatrol.java
-@@ -0,0 +0,0 @@ public class MobSpawnerPatrol implements MobSpawner {
- 
-     @Override
-     public int a(WorldServer worldserver, boolean flag, boolean flag1) {
-+        if (worldserver.paperConfig.disablePillagerPatrols) return 0; // Paper
-         if (!flag) {
-             return 0;
-         } else if (!worldserver.getGameRules().getBoolean(GameRules.DO_PATROL_SPAWNING)) {

Spigot-Server-Patches/Add-option-to-fix-items-merging-through-walls.patch

@@ -1,39 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: GioSDA <gsdambrosio@gmail.com>
-Date: Wed, 10 Mar 2021 10:06:45 -0800
-Subject: [PATCH] Add option to fix items merging through walls
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void mapItemFrameCursorLimit() {
-         mapItemFrameCursorLimit = getInt("map-item-frame-cursor-limit", mapItemFrameCursorLimit);
-     }
-+
-+    public boolean fixItemsMergingThroughWalls;
-+    private void fixItemsMergingThroughWalls() {
-+        fixItemsMergingThroughWalls = getBoolean("fix-items-merging-through-walls", fixItemsMergingThroughWalls);
-+    }
- }
-diff --git a/src/main/java/net/minecraft/world/entity/item/EntityItem.java b/src/main/java/net/minecraft/world/entity/item/EntityItem.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/item/EntityItem.java
-+++ b/src/main/java/net/minecraft/world/entity/item/EntityItem.java
-@@ -0,0 +0,0 @@ public class EntityItem extends Entity {
-                 EntityItem entityitem = (EntityItem) iterator.next();
- 
-                 if (entityitem.z()) {
-+                    // Paper Start - Fix items merging through walls
-+                        if (this.world.paperConfig.fixItemsMergingThroughWalls) {
-+                            net.minecraft.world.level.RayTrace rayTrace = new net.minecraft.world.level.RayTrace(this.getPositionVector(), entityitem.getPositionVector(),
-+                                net.minecraft.world.level.RayTrace.BlockCollisionOption.COLLIDER, net.minecraft.world.level.RayTrace.FluidCollisionOption.NONE, this);
-+                            net.minecraft.world.phys.MovingObjectPositionBlock rayTraceResult = world.rayTrace(rayTrace);
-+                            if (rayTraceResult.getType() == net.minecraft.world.phys.MovingObjectPosition.EnumMovingObjectType.BLOCK) continue;
-+                        }
-+                    // Paper End
-                     this.a(entityitem);
-                     if (this.dead) {
-                         break;

Spigot-Server-Patches/Add-option-to-make-parrots-stay-on-shoulders-despite.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, 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?
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         maxCollisionsPerEntity = getInt( "max-entity-collisions", this.spigotConfig.getInt("max-entity-collisions", 8) );
-         log( "Max Entity Collisions: " + maxCollisionsPerEntity );
-     }
-+
-+    public boolean parrotsHangOnBetter;
-+    private void parrotsHangOnBetter() {
-+        parrotsHangOnBetter = getBoolean("parrots-are-unaffected-by-player-movement", false);
-+        log("Parrots are unaffected by player movement: " + parrotsHangOnBetter);
-+    }
- }
-diff --git a/src/main/java/net/minecraft/server/network/PlayerConnection.java b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/PlayerConnection.java
-+++ b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-         switch (packetplayinentityaction.c()) {
-             case PRESS_SHIFT_KEY:
-                 this.player.setSneaking(true);
-+
-+            // Paper start - Hang on!
-+            if (this.player.world.paperConfig.parrotsHangOnBetter) {
-+                this.player.releaseShoulderEntities();
-+            }
-+            // Paper end
-+
-                 break;
-             case RELEASE_SHIFT_KEY:
-                 this.player.setSneaking(false);
-diff --git a/src/main/java/net/minecraft/world/entity/player/EntityHuman.java b/src/main/java/net/minecraft/world/entity/player/EntityHuman.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/player/EntityHuman.java
-+++ b/src/main/java/net/minecraft/world/entity/player/EntityHuman.java
-@@ -0,0 +0,0 @@ public abstract class EntityHuman extends EntityLiving {
-         this.j(this.getShoulderEntityLeft());
-         this.j(this.getShoulderEntityRight());
-         if (!this.world.isClientSide && (this.fallDistance > 0.5F || this.isInWater()) || this.abilities.isFlying || this.isSleeping()) {
--            this.releaseShoulderEntities();
-+            if (!this.world.paperConfig.parrotsHangOnBetter) this.releaseShoulderEntities(); // Paper - Hang on!
-         }
- 
-     }

Spigot-Server-Patches/Add-option-to-nerf-pigmen-from-nether-portals.patch

@@ -1,71 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <Blake.Galbreath@GMail.com>
-Date: Fri, 7 Feb 2020 14:36:56 -0600
-Subject: [PATCH] Add option to nerf pigmen from nether portals
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         disableHopperMoveEvents = getBoolean("hopper.disable-move-event", disableHopperMoveEvents);
-         log("Hopper Move Item Events: " + (disableHopperMoveEvents ? "disabled" : "enabled"));
-     }
-+
-+    public boolean nerfNetherPortalPigmen = false;
-+    private void nerfNetherPortalPigmen() {
-+        nerfNetherPortalPigmen = getBoolean("game-mechanics.nerf-pigmen-from-nether-portals", nerfNetherPortalPigmen);
-+    }
- }
-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 INamableTileEntity, ICommandListener, ne
-     public long activatedTick = Integer.MIN_VALUE;
-     public boolean isTemporarilyActive = false; // Paper
-     public boolean spawnedViaMobSpawner; // Paper - Yes this name is similar to above, upstream took the better one
-+    public boolean fromNetherPortal; // Paper
-     protected int numCollisions = 0; // Paper
-     public void inactiveTick() { }
-     // Spigot end
-@@ -0,0 +0,0 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, ne
-             if (spawnedViaMobSpawner) {
-                 nbttagcompound.setBoolean("Paper.FromMobSpawner", true);
-             }
-+            if (fromNetherPortal) {
-+                nbttagcompound.setBoolean("Paper.FromNetherPortal", true);
-+            }
-             // Paper end
-             return nbttagcompound;
-         } catch (Throwable throwable) {
-@@ -0,0 +0,0 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, ne
-             }
- 
-             spawnedViaMobSpawner = nbttagcompound.getBoolean("Paper.FromMobSpawner"); // Restore entity's from mob spawner status
-+            fromNetherPortal = nbttagcompound.getBoolean("Paper.FromNetherPortal");
-             if (nbttagcompound.hasKey("Paper.SpawnReason")) {
-                 String spawnReasonName = nbttagcompound.getString("Paper.SpawnReason");
-                 try {
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockPortal.java b/src/main/java/net/minecraft/world/level/block/BlockPortal.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockPortal.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockPortal.java
-@@ -0,0 +0,0 @@ import net.minecraft.nbt.NBTTagCompound;
- import net.minecraft.network.chat.IChatBaseComponent;
- import net.minecraft.server.level.WorldServer;
- import net.minecraft.world.entity.Entity;
-+import net.minecraft.world.entity.EntityInsentient;
- import net.minecraft.world.entity.EntityTypes;
- import net.minecraft.world.entity.EnumMobSpawn;
- import net.minecraft.world.entity.player.EntityHuman;
-@@ -0,0 +0,0 @@ public class BlockPortal extends Block {
- 
-                 if (entity != null) {
-                     entity.resetPortalCooldown();
-+                    entity.fromNetherPortal = true; // Paper
-+                    if (worldserver.paperConfig.nerfNetherPortalPigmen) ((EntityInsentient) entity).aware = false; // Paper
-                 }
-             }
-         }

Spigot-Server-Patches/Add-option-to-prevent-players-from-moving-into-unloa.patch

@@ -1,64 +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/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-         waterOverLavaFlowSpeed = getInt("water-over-lava-flow-speed", 5);
-         log("Water over lava flow speed: " + waterOverLavaFlowSpeed);
-     }
-+
-+    public boolean preventMovingIntoUnloadedChunks = false;
-+    private void preventMovingIntoUnloadedChunks() {
-+        preventMovingIntoUnloadedChunks = getBoolean("prevent-moving-into-unloaded-chunks", false);
-+    }
- }
-diff --git a/src/main/java/net/minecraft/server/network/PlayerConnection.java b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/PlayerConnection.java
-+++ b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-                 }
-                 speed *= 2f; // TODO: Get the speed of the vehicle instead of the player
- 
-+                // Paper start - Prevent moving into unloaded chunks
-+                if (player.world.paperConfig.preventMovingIntoUnloadedChunks && worldserver.getChunkIfLoadedImmediately((int) Math.floor(packetplayinvehiclemove.getX()) >> 4, (int) Math.floor(packetplayinvehiclemove.getZ()) >> 4) == null) {
-+                    this.networkManager.sendPacket(new PacketPlayOutVehicleMove(entity));
-+                    return;
-+                }
-+                // Paper end
-+
-                 if (d10 - d9 > Math.max(100.0D, Math.pow((double) (org.spigotmc.SpigotConfig.movedTooQuicklyMultiplier * (float) i * speed), 2)) && !this.isExemptPlayer()) {
-                 // CraftBukkit end
-                     PlayerConnection.LOGGER.warn("{} (vehicle of {}) moved too quickly! {},{},{}", entity.getDisplayName().getString(), this.player.getDisplayName().getString(), d6, d7, d8);
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-                         double d1 = this.player.locY();
-                         double d2 = this.player.locZ();
-                         double d3 = this.player.locY();
--                        double d4 = packetplayinflying.a(this.player.locX());
-+                        double d4 = packetplayinflying.a(this.player.locX());double toX = d4; // Paper - OBFHELPER
-                         double d5 = packetplayinflying.b(this.player.locY());
--                        double d6 = packetplayinflying.c(this.player.locZ());
-+                        double d6 = packetplayinflying.c(this.player.locZ());double toZ = d6; // Paper - OBFHELPER
-                         float f = packetplayinflying.a(this.player.yaw);
-                         float f1 = packetplayinflying.b(this.player.pitch);
-                         double d7 = d4 - this.l;
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-                             } else {
-                                 speed = player.abilities.walkSpeed * 10f;
-                             }
-+                            // Paper start - Prevent moving into unloaded chunks
-+                            if (player.world.paperConfig.preventMovingIntoUnloadedChunks && (this.player.locX() != toX || this.player.locZ() != toZ) && !worldserver.isChunkLoaded((int) Math.floor(toX) >> 4, (int) Math.floor(toZ) >> 4)) {
-+                                this.internalTeleport(this.player.locX(), this.player.locY(), this.player.locZ(), this.player.yaw, this.player.pitch, Collections.emptySet());
-+                                return;
-+                            }
-+                            // Paper end
- 
-                             if (!this.player.H() && (!this.player.getWorldServer().getGameRules().getBoolean(GameRules.DISABLE_ELYTRA_MOVEMENT_CHECK) || !this.player.isGliding())) {
-                                 float f2 = this.player.isGliding() ? 300.0F : 100.0F;

Spigot-Server-Patches/Add-permission-for-command-blocks.patch

@@ -1,79 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Mariell Hoversholm <proximyst@proximyst.com>
-Date: Sat, 16 May 2020 10:05:30 +0200
-Subject: [PATCH] Add permission for command blocks
-
-
-diff --git a/src/main/java/net/minecraft/server/level/PlayerInteractManager.java b/src/main/java/net/minecraft/server/level/PlayerInteractManager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/PlayerInteractManager.java
-+++ b/src/main/java/net/minecraft/server/level/PlayerInteractManager.java
-@@ -0,0 +0,0 @@ public class PlayerInteractManager {
-             TileEntity tileentity = this.world.getTileEntity(blockposition);
-             Block block = iblockdata.getBlock();
- 
--            if ((block instanceof BlockCommand || block instanceof BlockStructure || block instanceof BlockJigsaw) && !this.player.isCreativeAndOp()) {
-+            if ((block instanceof BlockCommand || block instanceof BlockStructure || block instanceof BlockJigsaw) && !this.player.isCreativeAndOp() && !(block instanceof BlockCommand && (this.player.isCreative() && this.player.getBukkitEntity().hasPermission("minecraft.commandblock")))) { // Paper - command block permission
-                 this.world.notify(blockposition, iblockdata, iblockdata, 3);
-                 return false;
-             } else if (this.player.a((World) this.world, blockposition, this.gamemode)) {
-diff --git a/src/main/java/net/minecraft/server/network/PlayerConnection.java b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/PlayerConnection.java
-+++ b/src/main/java/net/minecraft/server/network/PlayerConnection.java
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-         PlayerConnectionUtils.ensureMainThread(packetplayinsetcommandblock, this, this.player.getWorldServer());
-         if (!this.minecraftServer.getEnableCommandBlock()) {
-             this.player.sendMessage(new ChatMessage("advMode.notEnabled"), SystemUtils.b);
--        } else if (!this.player.isCreativeAndOp()) {
-+        } else if (!this.player.isCreativeAndOp() && !this.player.isCreative() && !this.player.getBukkitEntity().hasPermission("minecraft.commandblock")) { // Paper - command block permission
-             this.player.sendMessage(new ChatMessage("advMode.notAllowed"), SystemUtils.b);
-         } else {
-             CommandBlockListenerAbstract commandblocklistenerabstract = null;
-@@ -0,0 +0,0 @@ public class PlayerConnection implements PacketListenerPlayIn {
-         PlayerConnectionUtils.ensureMainThread(packetplayinsetcommandminecart, this, this.player.getWorldServer());
-         if (!this.minecraftServer.getEnableCommandBlock()) {
-             this.player.sendMessage(new ChatMessage("advMode.notEnabled"), SystemUtils.b);
--        } else if (!this.player.isCreativeAndOp()) {
-+        } else if (!this.player.isCreativeAndOp() && !this.player.isCreative() && !this.player.getBukkitEntity().hasPermission("minecraft.commandblock")) { // Paper - command block permission
-             this.player.sendMessage(new ChatMessage("advMode.notAllowed"), SystemUtils.b);
-         } else {
-             CommandBlockListenerAbstract commandblocklistenerabstract = packetplayinsetcommandminecart.a(this.player.world);
-diff --git a/src/main/java/net/minecraft/world/level/CommandBlockListenerAbstract.java b/src/main/java/net/minecraft/world/level/CommandBlockListenerAbstract.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/CommandBlockListenerAbstract.java
-+++ b/src/main/java/net/minecraft/world/level/CommandBlockListenerAbstract.java
-@@ -0,0 +0,0 @@ public abstract class CommandBlockListenerAbstract implements ICommandListener {
-     }
- 
-     public EnumInteractionResult a(EntityHuman entityhuman) {
--        if (!entityhuman.isCreativeAndOp()) {
-+        if (!entityhuman.isCreativeAndOp() && !entityhuman.isCreative() && !entityhuman.getBukkitEntity().hasPermission("minecraft.commandblock")) { // Paper - command block permission
-             return EnumInteractionResult.PASS;
-         } else {
-             if (entityhuman.getWorld().isClientSide) {
-diff --git a/src/main/java/net/minecraft/world/level/block/BlockCommand.java b/src/main/java/net/minecraft/world/level/block/BlockCommand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/BlockCommand.java
-+++ b/src/main/java/net/minecraft/world/level/block/BlockCommand.java
-@@ -0,0 +0,0 @@ public class BlockCommand extends BlockTileEntity {
-     public EnumInteractionResult interact(IBlockData iblockdata, World world, BlockPosition blockposition, EntityHuman entityhuman, EnumHand enumhand, MovingObjectPositionBlock movingobjectpositionblock) {
-         TileEntity tileentity = world.getTileEntity(blockposition);
- 
--        if (tileentity instanceof TileEntityCommand && entityhuman.isCreativeAndOp()) {
-+        if (tileentity instanceof TileEntityCommand && (entityhuman.isCreativeAndOp() || (entityhuman.isCreative() && entityhuman.getBukkitEntity().hasPermission("minecraft.commandblock")))) { // Paper - command block permission
-             entityhuman.a((TileEntityCommand) tileentity);
-             return EnumInteractionResult.a(world.isClientSide);
-         } else {
-diff --git a/src/main/java/org/bukkit/craftbukkit/util/permissions/CraftDefaultPermissions.java b/src/main/java/org/bukkit/craftbukkit/util/permissions/CraftDefaultPermissions.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/util/permissions/CraftDefaultPermissions.java
-+++ b/src/main/java/org/bukkit/craftbukkit/util/permissions/CraftDefaultPermissions.java
-@@ -0,0 +0,0 @@ public final class CraftDefaultPermissions {
-         DefaultPermissions.registerPermission(ROOT + ".nbt.copy", "Gives the user the ability to copy NBT in creative", org.bukkit.permissions.PermissionDefault.TRUE, parent);
-         DefaultPermissions.registerPermission(ROOT + ".debugstick", "Gives the user the ability to use the debug stick in creative", org.bukkit.permissions.PermissionDefault.OP, parent);
-         DefaultPermissions.registerPermission(ROOT + ".debugstick.always", "Gives the user the ability to use the debug stick in all game modes", org.bukkit.permissions.PermissionDefault.FALSE, parent);
-+        DefaultPermissions.registerPermission(ROOT + ".commandblock", "Gives the user the ability to use command blocks.", org.bukkit.permissions.PermissionDefault.OP, parent); // Paper
-         // Spigot end
-         parent.recalculatePermissibles();
-     }

Spigot-Server-Patches/Add-phantom-creative-and-insomniac-controls.patch

@@ -1,69 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <Blake.Galbreath@GMail.com>
-Date: Sat, 25 Apr 2020 15:13:41 -0500
-Subject: [PATCH] Add phantom creative and insomniac controls
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
-@@ -0,0 +0,0 @@ public class PaperWorldConfig {
-     private void lightQueueSize() {
-         lightQueueSize = getInt("light-queue-size", lightQueueSize);
-     }
-+
-+    public boolean phantomIgnoreCreative = true;
-+    public boolean phantomOnlyAttackInsomniacs = true;
-+    private void phantomSettings() {
-+        phantomIgnoreCreative = getBoolean("phantoms-do-not-spawn-on-creative-players", phantomIgnoreCreative);
-+        phantomOnlyAttackInsomniacs = getBoolean("phantoms-only-attack-insomniacs", phantomOnlyAttackInsomniacs);
-+    }
- }
-diff --git a/src/main/java/net/minecraft/world/entity/IEntitySelector.java b/src/main/java/net/minecraft/world/entity/IEntitySelector.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/IEntitySelector.java
-+++ b/src/main/java/net/minecraft/world/entity/IEntitySelector.java
-@@ -0,0 +0,0 @@ package net.minecraft.world.entity;
- import com.google.common.base.Predicates;
- import java.util.function.Predicate;
- import javax.annotation.Nullable;
-+import net.minecraft.server.level.EntityPlayer;
-+import net.minecraft.stats.StatisticList;
-+import net.minecraft.util.MathHelper;
- import net.minecraft.world.EnumDifficulty;
- import net.minecraft.world.IInventory;
- import net.minecraft.world.entity.player.EntityHuman;
-@@ -0,0 +0,0 @@ public final class IEntitySelector {
-     public static final Predicate<Entity> g = (entity) -> {
-         return !entity.isSpectator();
-     };
-+    public static Predicate<EntityHuman> isInsomniac = (player) -> MathHelper.clamp(((EntityPlayer) player).getStatisticManager().getStatisticValue(StatisticList.CUSTOM.get(StatisticList.TIME_SINCE_REST)), 1, Integer.MAX_VALUE) >= 72000; // Paper
- 
-     // Paper start
-     public static final Predicate<Entity> affectsSpawning = (entity) -> {
-diff --git a/src/main/java/net/minecraft/world/entity/monster/EntityPhantom.java b/src/main/java/net/minecraft/world/entity/monster/EntityPhantom.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/EntityPhantom.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/EntityPhantom.java
-@@ -0,0 +0,0 @@ public class EntityPhantom extends EntityFlying implements IMonster {
-                         EntityHuman entityhuman = (EntityHuman) iterator.next();
- 
-                         if (EntityPhantom.this.a((EntityLiving) entityhuman, PathfinderTargetCondition.a)) {
-+                            if (!world.paperConfig.phantomOnlyAttackInsomniacs || IEntitySelector.isInsomniac.test(entityhuman)) // Paper
-                             EntityPhantom.this.setGoalTarget(entityhuman, org.bukkit.event.entity.EntityTargetEvent.TargetReason.CLOSEST_PLAYER, true); // CraftBukkit - reason
-                             return true;
-                         }
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/MobSpawnerPhantom.java b/src/main/java/net/minecraft/world/level/levelgen/MobSpawnerPhantom.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/levelgen/MobSpawnerPhantom.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/MobSpawnerPhantom.java
-@@ -0,0 +0,0 @@ public class MobSpawnerPhantom implements MobSpawner {
-                     while (iterator.hasNext()) {
-                         EntityHuman entityhuman = (EntityHuman) iterator.next();
- 
--                        if (!entityhuman.isSpectator()) {
-+                        if (!entityhuman.isSpectator() && (!worldserver.paperConfig.phantomIgnoreCreative || !entityhuman.isCreative())) { // Paper
-                             BlockPosition blockposition = entityhuman.getChunkCoordinates();
- 
-                             if (!worldserver.getDimensionManager().hasSkyLight() || blockposition.getY() >= worldserver.getSeaLevel() && worldserver.e(blockposition)) {

Spigot-Server-Patches/Add-playPickupItemAnimation-to-LivingEntity.patch

@@ -1,21 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William Blake Galbreath <blake.galbreath@gmail.com>
-Date: Sun, 23 Aug 2020 19:36:22 +0200
-Subject: [PATCH] Add playPickupItemAnimation to LivingEntity
-
-
-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 {
-             ((EntityInsentient) getHandle()).getControllerJump().jump();
-         }
-     }
-+
-+    @Override
-+    public void playPickupItemAnimation(org.bukkit.entity.Item item, int quantity) {
-+        getHandle().receive(((CraftItem) item).getHandle(), quantity);
-+    }
-     // Paper end
- }

Spigot-Server-Patches/Add-raw-address-to-AsyncPlayerPreLoginEvent.patch

@@ -1,25 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Connor Linfoot <connorlinfoot@me.com>
-Date: Wed, 12 May 2021 08:09:19 +0100
-Subject: [PATCH] Add raw address to AsyncPlayerPreLoginEvent
-
-
-diff --git a/src/main/java/net/minecraft/server/network/LoginListener.java b/src/main/java/net/minecraft/server/network/LoginListener.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/LoginListener.java
-+++ b/src/main/java/net/minecraft/server/network/LoginListener.java
-@@ -0,0 +0,0 @@ public class LoginListener implements PacketLoginInListener {
-                         // Paper end
-                         String playerName = i.getName();
-                         java.net.InetAddress address = ((java.net.InetSocketAddress) networkManager.getSocketAddress()).getAddress();
-+                        java.net.InetAddress rawAddress = ((java.net.InetSocketAddress) networkManager.getRawAddress()).getAddress(); // Paper
-                         java.util.UUID uniqueId = i.getId();
-                         final org.bukkit.craftbukkit.CraftServer server = LoginListener.this.server.server;
- 
-                             // Paper start
-                             PlayerProfile profile = CraftPlayerProfile.asBukkitMirror(getGameProfile());
--                            AsyncPlayerPreLoginEvent asyncEvent = new AsyncPlayerPreLoginEvent(playerName, address, uniqueId, profile);
-+                            AsyncPlayerPreLoginEvent asyncEvent = new AsyncPlayerPreLoginEvent(playerName, address, rawAddress, uniqueId, profile);
-                         server.getPluginManager().callEvent(asyncEvent);
-                             profile = asyncEvent.getPlayerProfile();
-                             profile.complete(true);

Spigot-Server-Patches/Add-ray-tracing-methods-to-LivingEntity.patch

@@ -1,99 +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/EntityLiving.java b/src/main/java/net/minecraft/world/entity/EntityLiving.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/EntityLiving.java
-+++ b/src/main/java/net/minecraft/world/entity/EntityLiving.java
-@@ -0,0 +0,0 @@ public abstract class EntityLiving extends Entity {
-         this.broadcastItemBreak(enumhand == EnumHand.MAIN_HAND ? EnumItemSlot.MAINHAND : EnumItemSlot.OFFHAND);
-     }
-     // Paper start
-+    public MovingObjectPosition getRayTrace(int maxDistance) {
-+        return getRayTrace(maxDistance, RayTrace.FluidCollisionOption.NONE);
-+    }
-+
-+    public MovingObjectPosition getRayTrace(int maxDistance, RayTrace.FluidCollisionOption fluidCollisionOption) {
-+        if (maxDistance < 1 || maxDistance > 120) {
-+            throw new IllegalArgumentException("maxDistance must be between 1-120");
-+        }
-+
-+        Vec3D start = new Vec3D(locX(), locY() + getHeadHeight(), locZ());
-+        org.bukkit.util.Vector dir = getBukkitEntity().getLocation().getDirection().multiply(maxDistance);
-+        Vec3D end = new Vec3D(start.x + dir.getX(), start.y + dir.getY(), start.z + dir.getZ());
-+        RayTrace raytrace = new RayTrace(start, end, RayTrace.BlockCollisionOption.OUTLINE, fluidCollisionOption, this);
-+
-+        return world.rayTrace(raytrace);
-+    }
-+
-     public int shieldBlockingDelay = world.paperConfig.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 @@
- package org.bukkit.craftbukkit.entity;
- 
-+import com.destroystokyo.paper.block.TargetBlockInfo;
- import com.google.common.base.Preconditions;
- import com.google.common.collect.Sets;
- import java.util.ArrayList;
-@@ -0,0 +0,0 @@ import java.util.Iterator;
- import java.util.List;
- import java.util.Set;
- import java.util.UUID;
-+import net.minecraft.server.MCUtil;
- import net.minecraft.server.level.EntityPlayer;
- import net.minecraft.world.EnumHand;
- import net.minecraft.world.damagesource.DamageSource;
-@@ -0,0 +0,0 @@ import net.minecraft.world.entity.projectile.EntityThrownExpBottle;
- import net.minecraft.world.entity.projectile.EntityThrownTrident;
- import net.minecraft.world.entity.projectile.EntityTippedArrow;
- import net.minecraft.world.entity.projectile.EntityWitherSkull;
-+import net.minecraft.world.phys.MovingObjectPosition;
-+import net.minecraft.world.phys.MovingObjectPositionBlock;
- import org.apache.commons.lang.Validate;
- import org.bukkit.FluidCollisionMode;
- import org.bukkit.Location;
-@@ -0,0 +0,0 @@ import org.bukkit.attribute.AttributeInstance;
- import org.bukkit.block.Block;
- import org.bukkit.craftbukkit.CraftServer;
- import org.bukkit.craftbukkit.CraftWorld;
-+import org.bukkit.craftbukkit.block.CraftBlock;
- import org.bukkit.craftbukkit.entity.memory.CraftMemoryKey;
- import org.bukkit.craftbukkit.entity.memory.CraftMemoryMapper;
- import org.bukkit.craftbukkit.inventory.CraftEntityEquipment;
-@@ -0,0 +0,0 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
-         return blocks.get(0);
-     }
- 
-+    // Paper start
-+    @Override
-+    public Block getTargetBlock(int maxDistance, TargetBlockInfo.FluidMode fluidMode) {
-+        MovingObjectPosition rayTrace = getHandle().getRayTrace(maxDistance, MCUtil.getNMSFluidCollisionOption(fluidMode));
-+        return !(rayTrace instanceof MovingObjectPositionBlock) ? null : CraftBlock.at(getHandle().world, ((MovingObjectPositionBlock)rayTrace).getBlockPosition());
-+    }
-+
-+    @Override
-+    public org.bukkit.block.BlockFace getTargetBlockFace(int maxDistance, TargetBlockInfo.FluidMode fluidMode) {
-+        MovingObjectPosition rayTrace = getHandle().getRayTrace(maxDistance, MCUtil.getNMSFluidCollisionOption(fluidMode));
-+        return !(rayTrace instanceof MovingObjectPositionBlock) ? null : MCUtil.toBukkitBlockFace(((MovingObjectPositionBlock)rayTrace).getDirection());
-+    }
-+
-+    @Override
-+    public TargetBlockInfo getTargetBlockInfo(int maxDistance, TargetBlockInfo.FluidMode fluidMode) {
-+        MovingObjectPosition rayTrace = getHandle().getRayTrace(maxDistance, MCUtil.getNMSFluidCollisionOption(fluidMode));
-+        return !(rayTrace instanceof MovingObjectPositionBlock) ? null :
-+            new TargetBlockInfo(CraftBlock.at(getHandle().world, ((MovingObjectPositionBlock)rayTrace).getBlockPosition()),
-+                MCUtil.toBukkitBlockFace(((MovingObjectPositionBlock)rayTrace).getDirection()));
-+    }
-+    // Paper end
-+
-     @Override
-     public List<Block> getLastTwoTargetBlocks(Set<Material> transparent, int maxDistance) {
-         return getLineOfSight(transparent, maxDistance, 2);

Spigot-Server-Patches/Add-recipe-to-cook-events.patch

@@ -1,44 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Thonk <30448663+ExcessiveAmountsOfZombies@users.noreply.github.com>
-Date: Wed, 6 Jan 2021 12:04:03 -0800
-Subject: [PATCH] Add recipe to cook events
-
-
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/TileEntityCampfire.java b/src/main/java/net/minecraft/world/level/block/entity/TileEntityCampfire.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/TileEntityCampfire.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/TileEntityCampfire.java
-@@ -0,0 +0,0 @@ public class TileEntityCampfire extends TileEntity implements Clearable, ITickab
- 
-                 if (this.cookingTimes[i] >= this.cookingTotalTimes[i]) {
-                     InventorySubcontainer inventorysubcontainer = new InventorySubcontainer(new ItemStack[]{itemstack});
--                    ItemStack itemstack1 = (ItemStack) this.world.getCraftingManager().craft(Recipes.CAMPFIRE_COOKING, inventorysubcontainer, this.world).map((recipecampfire) -> {
-+                    // Paper start
-+                    Optional<RecipeCampfire> recipe = this.world.getCraftingManager().craft(Recipes.CAMPFIRE_COOKING, inventorysubcontainer, this.world);
-+                    ItemStack itemstack1 = (ItemStack) recipe.map((recipecampfire) -> {
-+                        // Paper end
-                         return recipecampfire.a(inventorysubcontainer);
-                     }).orElse(itemstack);
-                     BlockPosition blockposition = this.getPosition();
-@@ -0,0 +0,0 @@ public class TileEntityCampfire extends TileEntity implements Clearable, ITickab
-                     CraftItemStack source = CraftItemStack.asCraftMirror(itemstack);
-                     org.bukkit.inventory.ItemStack result = CraftItemStack.asBukkitCopy(itemstack1);
- 
--                    BlockCookEvent blockCookEvent = new BlockCookEvent(CraftBlock.at(this.world, this.position), source, result);
-+                    BlockCookEvent blockCookEvent = new BlockCookEvent(CraftBlock.at(this.world, this.position), source, result, (org.bukkit.inventory.CookingRecipe<?>) recipe.map(RecipeCampfire::toBukkitRecipe).orElse(null)); // Paper
-                     this.world.getServer().getPluginManager().callEvent(blockCookEvent);
- 
-                     if (blockCookEvent.isCancelled()) {
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/TileEntityFurnace.java b/src/main/java/net/minecraft/world/level/block/entity/TileEntityFurnace.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/TileEntityFurnace.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/TileEntityFurnace.java
-@@ -0,0 +0,0 @@ public abstract class TileEntityFurnace extends TileEntityContainer implements I
-             CraftItemStack source = CraftItemStack.asCraftMirror(itemstack);
-             org.bukkit.inventory.ItemStack result = CraftItemStack.asBukkitCopy(itemstack1);
- 
--            FurnaceSmeltEvent furnaceSmeltEvent = new FurnaceSmeltEvent(this.world.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ()), source, result);
-+            FurnaceSmeltEvent furnaceSmeltEvent = new FurnaceSmeltEvent(this.world.getWorld().getBlockAt(position.getX(), position.getY(), position.getZ()), source, result, (org.bukkit.inventory.CookingRecipe<?>) irecipe.toBukkitRecipe()); // Paper
-             this.world.getServer().getPluginManager().callEvent(furnaceSmeltEvent);
- 
-             if (furnaceSmeltEvent.isCancelled()) {