More work

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

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

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

@@ -1,54 +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/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-     }
- 
-     @Override
--    public void giveExp(int exp) {
-+    // Paper start
-+    public int applyMending(int amount) {
-+        ServerPlayer handle = this.getHandle();
-+        // Logic copied from EntityExperienceOrb and remapped to unobfuscated methods/properties
-+        final var stackEntry = net.minecraft.world.item.enchantment.EnchantmentHelper
-+            .getRandomItemWith(net.minecraft.world.item.enchantment.Enchantments.MENDING, handle);
-+        final net.minecraft.world.item.ItemStack itemstack = stackEntry != null ? stackEntry.getValue() : net.minecraft.world.item.ItemStack.EMPTY;
-+        if (!itemstack.isEmpty() && itemstack.getItem().canBeDepleted()) {
-+            net.minecraft.world.entity.ExperienceOrb orb = net.minecraft.world.entity.EntityType.EXPERIENCE_ORB.create(handle.level);
-+            orb.value = amount;
-+            orb.spawnReason = org.bukkit.entity.ExperienceOrb.SpawnReason.CUSTOM;
-+            orb.setPosRaw(handle.getX(), handle.getY(), handle.getZ());
-+
-+            int i = Math.min(orb.xpToDurability(amount), itemstack.getDamageValue());
-+            org.bukkit.event.player.PlayerItemMendEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerItemMendEvent(handle, orb, itemstack, i);
-+            i = event.getRepairAmount();
-+            orb.discard();
-+            if (!event.isCancelled()) {
-+                amount -= orb.durabilityToXp(i);
-+                itemstack.setDamageValue(itemstack.getDamageValue() - i);
-+            }
-+        }
-+        return amount;
-+    }
-+
-+    @Override
-+    public void giveExp(int exp, boolean applyMending) {
-+        if (applyMending) {
-+            exp = this.applyMending(exp);
-+        }
-+        // Paper end
-         this.getHandle().giveExperiencePoints(exp);
-     }
- 

patches/unapplied/server/Ability-to-change-PlayerProfile-in-AsyncPreLoginEven.patch

@@ -1,29 +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/ServerLoginPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener
-                         java.util.UUID uniqueId = ServerLoginPacketListenerImpl.this.gameProfile.getId();
-                         final org.bukkit.craftbukkit.CraftServer server = ServerLoginPacketListenerImpl.this.server.server;
- 
--                        AsyncPlayerPreLoginEvent asyncEvent = new AsyncPlayerPreLoginEvent(playerName, address, uniqueId);
-+                        // Paper start
-+                        com.destroystokyo.paper.profile.PlayerProfile profile = org.bukkit.Bukkit.createProfile(uniqueId, playerName);
-+                        AsyncPlayerPreLoginEvent asyncEvent = new AsyncPlayerPreLoginEvent(playerName, address, uniqueId, profile);
-                         server.getPluginManager().callEvent(asyncEvent);
-+                        profile = asyncEvent.getPlayerProfile();
-+                        profile.complete();
-+                        gameProfile = com.destroystokyo.paper.profile.CraftPlayerProfile.asAuthlibCopy(profile);
-+                        playerName = gameProfile.getName();
-+                        uniqueId = gameProfile.getId();
-+                        // Paper end
- 
-                         if (PlayerPreLoginEvent.getHandlerList().getRegisteredListeners().length != 0) {
-                             final PlayerPreLoginEvent event = new PlayerPreLoginEvent(playerName, address, uniqueId);

patches/unapplied/server/Ability-to-get-Tile-Entities-from-a-chunk-without-sn.patch

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

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

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

patches/unapplied/server/Add-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/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
-     public int latency;
-     public boolean wonGame;
-     private int containerUpdateDelay; // Paper
-+    public long loginTime; // Paper
-     // Paper start - cancellable death event
-     public boolean queueHealthUpdatePacket = false;
-     public net.minecraft.network.protocol.game.ClientboundSetHealthPacket 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 placeNewPlayer(Connection connection, ServerPlayer player) {
-+        player.loginTime = System.currentTimeMillis(); // Paper
-         GameProfile gameprofile = player.getGameProfile();
-         GameProfileCache usercache = this.server.getProfileCache();
-         Optional<GameProfile> optional = usercache.get(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 this.getData() != null;
-     }
- 
-+    // Paper start
-+    @Override
-+    public long getLastLogin() {
-+        Player player = getPlayer();
-+        if (player != null) return player.getLastLogin();
-+
-+        CompoundTag data = getPaperData();
-+
-+        if (data != null) {
-+            if (data.contains("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();
-+
-+        CompoundTag data = getPaperData();
-+
-+        if (data != null) {
-+            if (data.contains("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 CompoundTag getPaperData() {
-+        CompoundTag result = getData();
-+
-+        if (result != null) {
-+            if (!result.contains("Paper")) {
-+                result.put("Paper", new CompoundTag());
-+            }
-+            result = result.getCompound("Paper");
-+        }
-+
-+        return result;
-+    }
-+    // Paper end
-+
-     @Override
-     public Location getLastDeathLocation() {
-         if (this.getData().contains("LastDeathLocation", 10)) {
-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, ServerPlayer 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(CompoundTag nbttagcompound) {
-         this.hasPlayedBefore = true;
-         if (nbttagcompound.contains("bukkit")) {
-@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-     }
- 
-     public void setExtraData(CompoundTag nbttagcompound) {
-+        this.lastSaveTime = System.currentTimeMillis(); // Paper
-+
-         if (!nbttagcompound.contains("bukkit")) {
-             nbttagcompound.put("bukkit", new CompoundTag());
-         }
-@@ -0,0 +0,0 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
-         data.putLong("firstPlayed", this.getFirstPlayed());
-         data.putLong("lastPlayed", System.currentTimeMillis());
-         data.putString("lastKnownName", handle.getScoreboardName());
-+
-+        // Paper start - persist for use in offline save data
-+        if (!nbttagcompound.contains("Paper")) {
-+            nbttagcompound.put("Paper", new CompoundTag());
-+        }
-+
-+        CompoundTag paper = nbttagcompound.getCompound("Paper");
-+        paper.putLong("LastLogin", handle.loginTime);
-+        paper.putLong("LastSeen", System.currentTimeMillis());
-+        // Paper end
-     }
- 
-     @Override

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

@@ -1,287 +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
-     CompoundTag 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.contains(ENTITY_TAG.NBT)) {
-             this.entityTag = tag.getCompound(ENTITY_TAG.NBT).copy();
-+            // Paper start
-+            if (entityTag.contains(INVISIBLE.NBT)) {
-+                invisible = entityTag.getBoolean(INVISIBLE.NBT);
-+            }
-+
-+            if (entityTag.contains(NO_BASE_PLATE.NBT)) {
-+                noBasePlate = entityTag.getBoolean(NO_BASE_PLATE.NBT);
-+            }
-+
-+            if (entityTag.contains(SHOW_ARMS.NBT)) {
-+                showArms = entityTag.getBoolean(SHOW_ARMS.NBT);
-+            }
-+
-+            if (entityTag.contains(SMALL.NBT)) {
-+                small = entityTag.getBoolean(SMALL.NBT);
-+            }
-+
-+            if (entityTag.contains(MARKER.NBT)) {
-+                marker = entityTag.getBoolean(MARKER.NBT);
-+            }
-+            // Paper end
-         }
-     }
- 
-     CraftMetaArmorStand(Map<String, Object> map) {
-         super(map);
-+        // Paper start
-+        this.invisible = SerializableMeta.getBoolean(map, INVISIBLE.BUKKIT);
-+        this.noBasePlate = SerializableMeta.getBoolean(map, NO_BASE_PLATE.BUKKIT);
-+        this.showArms = SerializableMeta.getBoolean(map, SHOW_ARMS.BUKKIT);
-+        this.small = SerializableMeta.getBoolean(map, SMALL.BUKKIT);
-+        this.marker = SerializableMeta.getBoolean(map, MARKER.BUKKIT);
-+        // Paper end
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class CraftMetaArmorStand extends CraftMetaItem {
-     void applyToItem(CompoundTag tag) {
-         super.applyToItem(tag);
- 
-+        // Paper start
-+        if (!isArmorStandEmpty() && this.entityTag == null) {
-+            this.entityTag = new CompoundTag();
-+        }
-+
-+        if (isInvisible()) {
-+            this.entityTag.putBoolean(INVISIBLE.NBT, this.invisible);
-+        }
-+
-+        if (hasNoBasePlate()) {
-+            this.entityTag.putBoolean(NO_BASE_PLATE.NBT, this.noBasePlate);
-+        }
-+
-+        if (shouldShowArms()) {
-+            this.entityTag.putBoolean(SHOW_ARMS.NBT, this.showArms);
-+        }
-+
-+        if (isSmall()) {
-+            this.entityTag.putBoolean(SMALL.NBT, this.small);
-+        }
-+
-+        if (isMarker()) {
-+            this.entityTag.putBoolean(MARKER.NBT, this.marker);
-+        }
-+        // Paper end
-         if (this.entityTag != null) {
-             tag.put(ENTITY_TAG.NBT, entityTag);
-         }
-@@ -0,0 +0,0 @@ public class CraftMetaArmorStand extends CraftMetaItem {
-     }
- 
-     boolean isArmorStandEmpty() {
--        return !(this.entityTag != null);
-+        return !(this.isInvisible() || this.hasNoBasePlate() || this.shouldShowArms() || this.isSmall() || this.isMarker() || this.entityTag != null);
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class CraftMetaArmorStand extends CraftMetaItem {
-         if (meta instanceof CraftMetaArmorStand) {
-             CraftMetaArmorStand that = (CraftMetaArmorStand) meta;
- 
--            return this.entityTag != null ? that.entityTag != null && this.entityTag.equals(that.entityTag) : this.entityTag == null;
-+            // Paper start
-+            return this.invisible == that.invisible &&
-+                this.noBasePlate == that.noBasePlate &&
-+                this.showArms == that.showArms &&
-+                this.small == that.small &&
-+                this.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 (this.entityTag != null) {
--            hash = 73 * hash + this.entityTag.hashCode();
--        }
-+        // Paper start
-+        hash += this.entityTag != null ? 73 * hash + this.entityTag.hashCode() : 0;
-+        hash += this.isInvisible() ? 61 * hash + 1231 : 0;
-+        hash += this.hasNoBasePlate() ? 61 * hash + 1231 : 0;
-+        hash += this.shouldShowArms() ? 61 * hash + 1231 : 0;
-+        hash += this.isSmall() ? 61 * hash + 1231 : 0;
-+        hash += this.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 (this.isInvisible()) {
-+            builder.put(INVISIBLE.BUKKIT, invisible);
-+        }
-+
-+        if (this.hasNoBasePlate()) {
-+            builder.put(NO_BASE_PLATE.BUKKIT, noBasePlate);
-+        }
-+
-+        if (this.shouldShowArms()) {
-+            builder.put(SHOW_ARMS.BUKKIT, showArms);
-+        }
-+
-+        if (this.isSmall()) {
-+            builder.put(SMALL.BUKKIT, small);
-+        }
-+
-+        if (this.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 CompoundTag();
-                     meta.entityTag.putBoolean("Small", true);
-+                    meta.setInvisible(true); // Paper
-                     cleanStack.setItemMeta(meta);
-                     return cleanStack;
-                 }

patches/unapplied/server/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
- 
-     /**

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

@@ -1,129 +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
-
-1.17: Needs to be reworked for new entity storage system
-
-diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ChunkMap.java
-+++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
-@@ -0,0 +0,0 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
-                 } else {
-                     ChunkMap.TrackedEntity playerchunkmap_entitytracker = new ChunkMap.TrackedEntity(entity, i, j, entitytypes.trackDeltas());
- 
-+                    entity.tracker = playerchunkmap_entitytracker; // Paper - Fast access to tracker
-                     this.entityMap.put(entity.getId(), playerchunkmap_entitytracker);
-                     playerchunkmap_entitytracker.updatePlayers(this.level.players());
-                     if (entity instanceof ServerPlayer) {
-@@ -0,0 +0,0 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
-         if (playerchunkmap_entitytracker1 != null) {
-             playerchunkmap_entitytracker1.broadcastRemoved();
-         }
--
-+        entity.tracker = null; // Paper - We're no longer tracked
-     }
- 
-     protected void tick() {
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
-     public final LevelStorageSource.LevelStorageAccess convertable;
-     public final UUID uuid;
-     public boolean hasPhysicsEvent = true; // Paper
-+    public static Throwable getAddToWorldStackTrace(Entity entity) {
-+        return new Throwable(entity + " Added to world at " + new java.util.Date());
-+    }
- 
-     @Override public LevelChunk getChunkIfLoaded(int x, int z) { // Paper - this was added in world too but keeping here for NMS ABI
-         return this.chunkSource.getChunk(x, z, false);
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
-     // CraftBukkit start
-     private boolean addEntity(Entity entity, CreatureSpawnEvent.SpawnReason spawnReason) {
-         org.spigotmc.AsyncCatcher.catchOp("entity add"); // Spigot
-+        // 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.isRemoved()) {
-+            // 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.getKey(entity.getType())); // CraftBukkit
-             return false;
-         } else {
-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 Nameable, EntityAccess, CommandSource {
-     public com.destroystokyo.paper.loottable.PaperLootableInventoryData lootableData; // Paper
-     private CraftEntity bukkitEntity;
- 
-+    public @org.jetbrains.annotations.Nullable net.minecraft.server.level.ChunkMap.TrackedEntity tracker; // Paper
-+    public @Nullable Throwable addedToWorldStack; // Paper - entity debug
-     public CraftEntity getBukkitEntity() {
-         if (this.bukkitEntity == null) {
-             this.bukkitEntity = CraftEntity.getEntity(this.level.getCraftServer(), this);
-diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/Level.java
-+++ b/src/main/java/net/minecraft/world/level/Level.java
-@@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
-     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 preventPoiUpdated = false; // CraftBukkit - SPIGOT-5710
-     public boolean captureBlockStates = false;
-diff --git a/src/main/java/net/minecraft/world/level/entity/EntityLookup.java b/src/main/java/net/minecraft/world/level/entity/EntityLookup.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/entity/EntityLookup.java
-+++ b/src/main/java/net/minecraft/world/level/entity/EntityLookup.java
-@@ -0,0 +0,0 @@ public class EntityLookup<T extends EntityAccess> {
-         UUID uUID = entity.getUUID();
-         if (this.byUuid.containsKey(uUID)) {
-             LOGGER.warn("Duplicate entity UUID {}: {}", uUID, entity);
-+            // Paper start - extra debug info
-+            if (entity instanceof net.minecraft.world.entity.Entity entityCast) {
-+                if (net.minecraft.server.level.ServerLevel.DEBUG_ENTITIES) {
-+                    entityCast.addedToWorldStack = net.minecraft.server.level.ServerLevel.getAddToWorldStackTrace(entityCast);
-+                }
-+
-+                T old = this.byUuid.get(entity.getUUID());
-+                if (old instanceof net.minecraft.world.entity.Entity oldCast && old != null && oldCast.getId() != entity.getId() && oldCast.valid) {
-+                    LOGGER.error("Overwrote an existing entity " + oldCast + " with " + entity);
-+                    if (net.minecraft.server.level.ServerLevel.DEBUG_ENTITIES) {
-+                        if (oldCast.addedToWorldStack != null) {
-+                            oldCast.addedToWorldStack.printStackTrace();
-+                        } else {
-+                            LOGGER.error("Oddly, the old entity was not added to the world in the normal way. Plugins?");
-+                        }
-+                        entityCast.addedToWorldStack.printStackTrace();
-+                    }
-+                }
-+            }
-+            // Paper end
-         } else {
-             this.byUuid.put(uUID, entity);
-             this.byId.put(entity.getId(), entity);

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

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

patches/unapplied/server/Add-EntityZapEvent.patch

@@ -1,48 +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/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
-+++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
-@@ -0,0 +0,0 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
-     @Override
-     public void thunderHit(ServerLevel world, LightningBolt lightning) {
-         if (world.getDifficulty() != Difficulty.PEACEFUL) {
--            Villager.LOGGER.info("Villager {} was struck by lightning {}.", this, lightning);
-+            // Paper - move log down, event can cancel
-             Witch entitywitch = (Witch) EntityType.WITCH.create(world);
- 
-+            // Paper start
-+            if (org.bukkit.craftbukkit.event.CraftEventFactory.callEntityZapEvent(this, lightning, entitywitch).isCancelled()) {
-+                return;
-+            }
-+            // Paper end
-+
-+            if (org.spigotmc.SpigotConfig.logVillagerDeaths) Villager.LOGGER.info("Villager {} was struck by lightning {}.", this, lightning); // Paper - move log down, event can cancel
-+
-             entitywitch.moveTo(this.getX(), this.getY(), this.getZ(), this.getYRot(), this.getXRot());
-             entitywitch.finalizeSpawn(world, world.getCurrentDifficultyAt(entitywitch.blockPosition()), MobSpawnType.CONVERSION, (SpawnGroupData) null, (CompoundTag) 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);

patches/unapplied/server/Add-Heightmap-API.patch

@@ -1,40 +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/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor implements World {
-         return this.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.getHeight(net.minecraft.world.level.levelgen.Heightmap.Types.WORLD_SURFACE, x, z);
-+            case SOLID:
-+                return this.world.getHeight(net.minecraft.world.level.levelgen.Heightmap.Types.OCEAN_FLOOR, x, z);
-+            case SOLID_OR_LIQUID:
-+                return this.world.getHeight(net.minecraft.world.level.levelgen.Heightmap.Types.MOTION_BLOCKING, x, z);
-+            case SOLID_OR_LIQUID_NO_LEAVES:
-+                return this.world.getHeight(net.minecraft.world.level.levelgen.Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, x, z);
-+            default:
-+                throw new UnsupportedOperationException();
-+        }
-+    }
-+    // Paper end
-+
-     @Override
-     public Location getSpawnLocation() {
-         BlockPos spawn = this.world.getSharedSpawnPos();

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

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

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

@@ -1,51 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Fri, 24 Aug 2018 11:50:26 -0500
-Subject: [PATCH] Add More Creeper API
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/monster/Creeper.java b/src/main/java/net/minecraft/world/entity/monster/Creeper.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/Creeper.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/Creeper.java
-@@ -0,0 +0,0 @@ public class Creeper extends Monster implements PowerableMob {
-     }
- 
-     public void ignite() {
--        this.entityData.set(Creeper.DATA_IS_IGNITED, 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.entityData.set(Creeper.DATA_IS_IGNITED, event.isIgnited());
-+            }
-+        }
-+        // Paper end
-     }
- 
-     public boolean canDropMobsSkull() {
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftCreeper.java
-@@ -0,0 +0,0 @@ public class CraftCreeper extends CraftMonster implements Creeper {
-     public EntityType getType() {
-         return EntityType.CREEPER;
-     }
-+
-+    // Paper start
-+    @Override
-+    public void setIgnited(boolean ignited) {
-+        getHandle().setIgnited(ignited);
-+    }
-+
-+    @Override
-+    public boolean isIgnited() {
-+        return getHandle().isIgnited();
-+    }
-+    // Paper end
- }

patches/unapplied/server/Add-PhantomPreSpawnEvent.patch

@@ -1,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/Phantom.java b/src/main/java/net/minecraft/world/entity/monster/Phantom.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/Phantom.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/Phantom.java
-@@ -0,0 +0,0 @@ public class Phantom extends FlyingMob implements Enemy {
-         }
- 
-         this.setPhantomSize(nbt.getInt("Size"));
-+        // Paper start
-+        if (nbt.hasUUID("Paper.SpawningEntity")) {
-+            this.spawningEntity = nbt.getUUID("Paper.SpawningEntity");
-+        }
-+        // Paper end
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class Phantom extends FlyingMob implements Enemy {
-         nbt.putInt("AY", this.anchorPoint.getY());
-         nbt.putInt("AZ", this.anchorPoint.getZ());
-         nbt.putInt("Size", this.getPhantomSize());
-+        // Paper start
-+        if (this.spawningEntity != null) {
-+            nbt.putUUID("Paper.SpawningEntity", this.spawningEntity);
-+        }
-+        // Paper end
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class Phantom extends FlyingMob implements Enemy {
-         return entitysize.scale(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
-     private static enum AttackPhase {
- 
-         CIRCLE, SWOOP;
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java b/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
-@@ -0,0 +0,0 @@ package net.minecraft.world.level.levelgen;
- import java.util.Iterator;
- import net.minecraft.core.BlockPos;
- import net.minecraft.nbt.CompoundTag;
-+import net.minecraft.server.MCUtil;
- import net.minecraft.server.level.ServerLevel;
- import net.minecraft.server.level.ServerPlayer;
- import net.minecraft.stats.ServerStatsCounter;
-@@ -0,0 +0,0 @@ public class PhantomSpawner implements CustomSpawner {
-                                             int k = 1 + randomsource.nextInt(difficultydamagescaler.getDifficulty().getId() + 1);
- 
-                                             for (int l = 0; l < k; ++l) {
-+                                                // Paper start
-+                                                com.destroystokyo.paper.event.entity.PhantomPreSpawnEvent event = new com.destroystokyo.paper.event.entity.PhantomPreSpawnEvent(MCUtil.toLocation(world, blockposition1), ((ServerPlayer) entityhuman).getBukkitEntity(), org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL);
-+                                                if (!event.callEvent()) {
-+                                                    if (event.shouldAbortSpawn()) {
-+                                                        break;
-+                                                    }
-+                                                    continue;
-+                                                }
-+                                                // Paper end
-                                                 Phantom entityphantom = (Phantom) EntityType.PHANTOM.create(world);
--
-+                                                entityphantom.setSpawningEntity(entityhuman.getUUID()); // Paper
-                                                 entityphantom.moveTo(blockposition1, 0.0F, 0.0F);
-                                                 groupdataentity = entityphantom.finalizeSpawn(world, difficultydamagescaler, MobSpawnType.NATURAL, groupdataentity, (CompoundTag) null);
-                                                 world.addFreshEntityWithPassengers(entityphantom, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL); // CraftBukkit
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPhantom.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPhantom.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPhantom.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPhantom.java
-@@ -0,0 +0,0 @@ public class CraftPhantom extends CraftFlying implements Phantom {
-     public EntityType getType() {
-         return EntityType.PHANTOM;
-     }
-+
-+    // Paper start
-+    @Override
-+    public java.util.UUID getSpawningEntity() {
-+        return getHandle().getSpawningEntity();
-+    }
-+    // Paper end
- }

patches/unapplied/server/Add-PlayerArmorChangeEvent.patch

@@ -1,31 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: pkt77 <parkerkt77@gmail.com>
-Date: Fri, 10 Nov 2017 23:46:34 -0500
-Subject: [PATCH] Add PlayerArmorChangeEvent
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@
- 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 LivingEntity extends Entity {
-             ItemStack itemstack1 = this.getItemBySlot(enumitemslot);
- 
-             if (!ItemStack.matches(itemstack1, itemstack)) {
-+                // Paper start - PlayerArmorChangeEvent
-+                if (this instanceof ServerPlayer && enumitemslot.getType() == EquipmentSlot.Type.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(EquipmentSlot.class);
-                 }

patches/unapplied/server/Add-PlayerConnectionCloseEvent.patch

@@ -1,66 +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/Connection.java b/src/main/java/net/minecraft/network/Connection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/Connection.java
-+++ b/src/main/java/net/minecraft/network/Connection.java
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
-                     this.getPacketListener().onDisconnect(Component.translatable("multiplayer.disconnect.generic"));
-                 }
-                 this.queue.clear(); // Free up packet queue.
-+                // Paper start - Add PlayerConnectionCloseEvent
-+                final PacketListener packetListener = this.getPacketListener();
-+                if (packetListener instanceof ServerGamePacketListenerImpl) {
-+                    /* Player was logged in */
-+                    final ServerGamePacketListenerImpl playerConnection = (ServerGamePacketListenerImpl) packetListener;
-+                    new com.destroystokyo.paper.event.player.PlayerConnectionCloseEvent(playerConnection.player.getUUID(),
-+                        playerConnection.player.getScoreboardName(), ((java.net.InetSocketAddress)address).getAddress(), false).callEvent();
-+                } else if (packetListener instanceof ServerLoginPacketListenerImpl) {
-+                    /* Player is login stage */
-+                    final ServerLoginPacketListenerImpl loginListener = (ServerLoginPacketListenerImpl) packetListener;
-+                    switch (loginListener.state) {
-+                        case READY_TO_ACCEPT:
-+                        case DELAY_ACCEPT:
-+                        case ACCEPTED:
-+                            final com.mojang.authlib.GameProfile profile = loginListener.gameProfile; /* Should be non-null at this stage */
-+                            new com.destroystokyo.paper.event.player.PlayerConnectionCloseEvent(profile.getId(), profile.getName(),
-+                                ((java.net.InetSocketAddress)address).getAddress(), false).callEvent();
-+                    }
-+                }
-+                // Paper end
-             }
- 
-         }

patches/unapplied/server/Add-PlayerJumpEvent.patch

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

patches/unapplied/server/Add-PlayerUseUnknownEntityEvent.patch

@@ -1,63 +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/ServerboundInteractPacket.java b/src/main/java/net/minecraft/network/protocol/game/ServerboundInteractPacket.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/protocol/game/ServerboundInteractPacket.java
-+++ b/src/main/java/net/minecraft/network/protocol/game/ServerboundInteractPacket.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.entity.Entity;
- import net.minecraft.world.phys.Vec3;
- 
- public class ServerboundInteractPacket implements Packet<ServerGamePacketListener> {
--    private final int entityId;
--    private final ServerboundInteractPacket.Action action;
-+    private final int entityId; public final int getEntityId() { return this.entityId; } // Paper - add accessor
-+    private final ServerboundInteractPacket.Action action; public final ServerboundInteractPacket.ActionType getActionType() { return this.action.getType(); } // Paper - add accessor
-     private final boolean usingSecondaryAction;
-     static final ServerboundInteractPacket.Action ATTACK_ACTION = new ServerboundInteractPacket.Action() {
-         @Override
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
-                 });
-             }
-         }
-+        // Paper start - fire event
-+        else {
-+            packet.dispatch(new net.minecraft.network.protocol.game.ServerboundInteractPacket.Handler() {
-+                @Override
-+                public void onInteraction(net.minecraft.world.InteractionHand hand) {
-+                    ServerGamePacketListenerImpl.this.callPlayerUseUnknownEntityEvent(packet, hand);
-+                }
-+
-+                @Override
-+                public void onInteraction(net.minecraft.world.InteractionHand hand, net.minecraft.world.phys.Vec3 pos) {
-+                    ServerGamePacketListenerImpl.this.callPlayerUseUnknownEntityEvent(packet, hand);
-+                }
-+
-+                @Override
-+                public void onAttack() {
-+                    ServerGamePacketListenerImpl.this.callPlayerUseUnknownEntityEvent(packet, net.minecraft.world.InteractionHand.MAIN_HAND);
-+                }
-+            });
-+        }
-+
-+    }
- 
-+    private void callPlayerUseUnknownEntityEvent(ServerboundInteractPacket packet, InteractionHand hand) {
-+        this.cserver.getPluginManager().callEvent(new com.destroystokyo.paper.event.player.PlayerUseUnknownEntityEvent(
-+            this.getCraftPlayer(),
-+            packet.getEntityId(),
-+            packet.getActionType() == ServerboundInteractPacket.ActionType.ATTACK,
-+            hand == InteractionHand.MAIN_HAND ? EquipmentSlot.HAND : EquipmentSlot.OFF_HAND
-+        ));
-     }
-+    // Paper end
- 
-     @Override
-     public void handleClientCommand(ServerboundClientCommandPacket packet) {

patches/unapplied/server/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/AbstractArrow.java b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
-@@ -0,0 +0,0 @@ public abstract class AbstractArrow extends Projectile {
-                     }
-                 }
- 
-+                // Paper start - Call ProjectileCollideEvent
-+                // TODO: flag - noclip - call cancelled?
-+                if (object instanceof EntityHitResult) {
-+                    com.destroystokyo.paper.event.entity.ProjectileCollideEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callProjectileCollideEvent(this, (EntityHitResult)object);
-+                    if (event.isCancelled()) {
-+                        object = null;
-+                        movingobjectpositionentity = null;
-+                    }
-+                }
-+                // Paper end
-+
-                 if (object != null && !flag) {
-                     this.preOnHit((HitResult) object); // CraftBukkit - projectile hit event
-                     this.hasImpulse = true;
-diff --git a/src/main/java/net/minecraft/world/entity/projectile/AbstractHurtingProjectile.java b/src/main/java/net/minecraft/world/entity/projectile/AbstractHurtingProjectile.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/projectile/AbstractHurtingProjectile.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/AbstractHurtingProjectile.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.entity.Entity;
- import net.minecraft.world.entity.EntityType;
- import net.minecraft.world.entity.LivingEntity;
- import net.minecraft.world.level.Level;
-+import net.minecraft.world.phys.EntityHitResult;
- import net.minecraft.world.phys.HitResult;
- import net.minecraft.world.phys.Vec3;
- import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit
-@@ -0,0 +0,0 @@ public abstract class AbstractHurtingProjectile extends Projectile {
- 
-             HitResult movingobjectposition = ProjectileUtil.getHitResult(this, this::canHitEntity);
- 
--            if (movingobjectposition.getType() != HitResult.Type.MISS) {
-+            // Paper start - Call ProjectileCollideEvent
-+            if (movingobjectposition instanceof EntityHitResult) {
-+                com.destroystokyo.paper.event.entity.ProjectileCollideEvent event = CraftEventFactory.callProjectileCollideEvent(this, (EntityHitResult)movingobjectposition);
-+                if (event.isCancelled()) {
-+                    movingobjectposition = null;
-+                }
-+            }
-+            // Paper end
-+
-+            if (movingobjectposition != null && movingobjectposition.getType() != HitResult.Type.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/ThrowableProjectile.java b/src/main/java/net/minecraft/world/entity/projectile/ThrowableProjectile.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/projectile/ThrowableProjectile.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/ThrowableProjectile.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.level.block.entity.BlockEntity;
- import net.minecraft.world.level.block.entity.TheEndGatewayBlockEntity;
- import net.minecraft.world.level.block.state.BlockState;
- import net.minecraft.world.phys.BlockHitResult;
-+import net.minecraft.world.phys.EntityHitResult;
- import net.minecraft.world.phys.HitResult;
- import net.minecraft.world.phys.Vec3;
- 
-@@ -0,0 +0,0 @@ public abstract class ThrowableProjectile extends Projectile {
-         }
- 
-         if (movingobjectposition.getType() != HitResult.Type.MISS && !flag) {
-+            // Paper start - Call ProjectileCollideEvent
-+            if (movingobjectposition instanceof EntityHitResult) {
-+                com.destroystokyo.paper.event.entity.ProjectileCollideEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callProjectileCollideEvent(this, (EntityHitResult)movingobjectposition);
-+                if (event.isCancelled()) {
-+                    movingobjectposition = null;
-+                }
-+            }
-+            if (movingobjectposition != null) {
-+            // Paper end
-             this.preOnHit(movingobjectposition); // CraftBukkit - projectile hit event
-+            } // Paper
-         }
- 
-         this.checkInsideBlocks();
-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, EntityHitResult position) {
-+        Projectile projectile = (Projectile) entity.getBukkitEntity();
-+        org.bukkit.entity.Entity collided = position.getEntity().getBukkitEntity();
-+        com.destroystokyo.paper.event.entity.ProjectileCollideEvent event = new com.destroystokyo.paper.event.entity.ProjectileCollideEvent(projectile, collided);
-+        Bukkit.getPluginManager().callEvent(event);
-+        return event;
-+    }
-+    // Paper end
-+
-     public static ProjectileLaunchEvent callProjectileLaunchEvent(Entity entity) {
-         Projectile bukkitEntity = (Projectile) entity.getBukkitEntity();
-         ProjectileLaunchEvent event = new ProjectileLaunchEvent(bukkitEntity);

patches/unapplied/server/Add-TNTPrimeEvent.patch

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

patches/unapplied/server/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
- 

patches/unapplied/server/Add-Velocity-IP-Forwarding-Support.patch

@@ -1,203 +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/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 io.papermc.paper.configuration.GlobalConfiguration;
-+import com.google.common.net.InetAddresses;
-+import com.mojang.authlib.GameProfile;
-+import com.mojang.authlib.properties.Property;
-+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;
-+import net.minecraft.network.FriendlyByteBuf;
-+import net.minecraft.resources.ResourceLocation;
-+import net.minecraft.world.entity.player.ProfilePublicKey;
-+
-+public class VelocityProxy {
-+    private static final int SUPPORTED_FORWARDING_VERSION = 1;
-+    public static final int MODERN_FORWARDING_WITH_KEY = 2;
-+    public static final byte MAX_SUPPORTED_FORWARDING_VERSION = 2;
-+    public static final ResourceLocation PLAYER_INFO_CHANNEL = new ResourceLocation("velocity", "player_info");
-+
-+    public static boolean checkIntegrity(final FriendlyByteBuf 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(GlobalConfiguration.get().proxies.velocity.secret.getBytes(java.nio.charset.StandardCharsets.UTF_8), "HmacSHA256"));
-+            final byte[] mySignature = mac.doFinal(data);
-+            if (!MessageDigest.isEqual(signature, mySignature)) {
-+                return false;
-+            }
-+        } catch (final InvalidKeyException | NoSuchAlgorithmException e) {
-+            throw new AssertionError(e);
-+        }
-+
-+        return true;
-+    }
-+
-+    public static InetAddress readAddress(final FriendlyByteBuf buf) {
-+        return InetAddresses.forString(buf.readUtf(Short.MAX_VALUE));
-+    }
-+
-+    public static GameProfile createProfile(final FriendlyByteBuf buf) {
-+        final GameProfile profile = new GameProfile(buf.readUUID(), buf.readUtf(16));
-+        readProperties(buf, profile);
-+        return profile;
-+    }
-+
-+    private static void readProperties(final FriendlyByteBuf 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));
-+        }
-+    }
-+
-+    public static ProfilePublicKey.Data readForwardedKey(FriendlyByteBuf buf) {
-+        return new ProfilePublicKey.Data(buf);
-+    }
-+}
-diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener
-     @Nullable
-     private ProfilePublicKey playerProfilePublicKey;
-     public String hostname = ""; // CraftBukkit - add field
-+    private int velocityLoginMessageId = -1; // Paper - Velocity support
- 
-     public ServerLoginPacketListenerImpl(MinecraftServer server, Connection connection) {
-         this.state = ServerLoginPacketListenerImpl.State.HELLO;
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener
-                 this.state = ServerLoginPacketListenerImpl.State.KEY;
-                 this.connection.send(new ClientboundHelloPacket("", this.server.getKeyPair().getPublic().getEncoded(), this.nonce));
-             } else {
-+                // Paper start - Velocity support
-+                if (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled) {
-+                    this.velocityLoginMessageId = java.util.concurrent.ThreadLocalRandom.current().nextInt();
-+                    net.minecraft.network.FriendlyByteBuf buf = new net.minecraft.network.FriendlyByteBuf(io.netty.buffer.Unpooled.buffer());
-+                    buf.writeByte(com.destroystokyo.paper.proxy.VelocityProxy.MAX_SUPPORTED_FORWARDING_VERSION);
-+                    net.minecraft.network.protocol.login.ClientboundCustomQueryPacket packet1 = new net.minecraft.network.protocol.login.ClientboundCustomQueryPacket(this.velocityLoginMessageId, com.destroystokyo.paper.proxy.VelocityProxy.PLAYER_INFO_CHANNEL, buf);
-+                    this.connection.send(packet1);
-+                    return;
-+                }
-+                // Paper end
-                 // Spigot start
-             // Paper start - Cache authenticator threads
-             authenticatorPool.execute(new Runnable() {
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener
-     public class LoginHandler {
- 
-         public void fireEvents() throws Exception {
-+                            // Paper start - Velocity support
-+                            if (ServerLoginPacketListenerImpl.this.velocityLoginMessageId == -1 && io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled) {
-+                                disconnect("This server requires you to connect with Velocity.");
-+                                return;
-+                            }
-+                            // Paper end
-                         String playerName = ServerLoginPacketListenerImpl.this.gameProfile.getName();
-                         java.net.InetAddress address = ((java.net.InetSocketAddress) ServerLoginPacketListenerImpl.this.connection.getRemoteAddress()).getAddress();
-                         java.util.UUID uniqueId = ServerLoginPacketListenerImpl.this.gameProfile.getId();
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener
-     // Spigot end
- 
-     public void handleCustomQueryPacket(ServerboundCustomQueryPacket packet) {
-+        // Paper start - Velocity support
-+        if (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled && packet.getTransactionId() == this.velocityLoginMessageId) {
-+            net.minecraft.network.FriendlyByteBuf buf = packet.getData();
-+            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;
-+            }
-+
-+            int version = buf.readVarInt();
-+            if (version > com.destroystokyo.paper.proxy.VelocityProxy.MAX_SUPPORTED_FORWARDING_VERSION) {
-+                throw new IllegalStateException("Unsupported forwarding version " + version + ", wanted upto " + com.destroystokyo.paper.proxy.VelocityProxy.MAX_SUPPORTED_FORWARDING_VERSION);
-+            }
-+
-+            java.net.SocketAddress listening = this.connection.getRemoteAddress();
-+            int port = 0;
-+            if (listening instanceof java.net.InetSocketAddress) {
-+                port = ((java.net.InetSocketAddress) listening).getPort();
-+            }
-+            this.connection.address = new java.net.InetSocketAddress(com.destroystokyo.paper.proxy.VelocityProxy.readAddress(buf), port);
-+
-+            this.gameProfile = com.destroystokyo.paper.proxy.VelocityProxy.createProfile(buf);
-+
-+            // We should already have this, but, we'll read it out anyway
-+            //noinspection NonStrictComparisonCanBeEquality
-+            if (version >= com.destroystokyo.paper.proxy.VelocityProxy.MODERN_FORWARDING_WITH_KEY) {
-+                final ProfilePublicKey.Data forwardedKey = com.destroystokyo.paper.proxy.VelocityProxy.readForwardedKey(buf);
-+                if (this.playerProfilePublicKey == null) {
-+                    try {
-+                        this.playerProfilePublicKey = ProfilePublicKey.createValidated(this.server.getServiceSignatureValidator(), forwardedKey);
-+                    } catch (CryptException e) {
-+                        this.disconnect("Unable to validate forwarded player key");
-+                    }
-+                }
-+            }
-+
-+            // 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 " + gameProfile.getName(), ex);
-+                }
-+            });
-+            return;
-+        }
-+        // Paper end
-         this.disconnect(Component.translatable("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 || io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled) { // Paper - Velocity support
-             return -1;
-         } else {
-             return this.configuration.getInt("settings.connection-throttle");

patches/unapplied/server/Add-World-Util-Methods.patch

@@ -1,47 +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/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
-     public final LevelStorageSource.LevelStorageAccess convertable;
-     public final UUID uuid;
- 
--    public LevelChunk getChunkIfLoaded(int x, int z) {
-+    @Override public LevelChunk getChunkIfLoaded(int x, int z) { // Paper - this was added in world too but keeping here for NMS ABI
-         return this.chunkSource.getChunk(x, z, false);
-     }
- 
-diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/Level.java
-+++ b/src/main/java/net/minecraft/world/level/Level.java
-@@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
-         return chunk == null ? null : chunk.getFluidState(blockposition);
-     }
- 
-+    public final boolean isLoadedAndInBounds(BlockPos blockposition) { // Paper - final for inline
-+        return getWorldBorder().isWithinBounds(blockposition) && getChunkIfLoadedImmediately(blockposition.getX() >> 4, blockposition.getZ() >> 4) != null;
-+    }
-+
-+    public @Nullable LevelChunk getChunkIfLoaded(int x, int z) { // Overridden in WorldServer for ABI compat which has final
-+        return ((ServerLevel) this).getChunkSource().getChunkAtIfLoadedImmediately(x, z);
-+    }
-+    public final @Nullable LevelChunk getChunkIfLoaded(BlockPos blockposition) {
-+        return ((ServerLevel) this).getChunkSource().getChunkAtIfLoadedImmediately(blockposition.getX() >> 4, blockposition.getZ() >> 4);
-+    }
-+
-+    //  reduces need to do isLoaded before getType
-+    public final @Nullable BlockState getBlockStateIfLoadedAndInBounds(BlockPos blockposition) {
-+        return getWorldBorder().isWithinBounds(blockposition) ? getBlockStateIfLoaded(blockposition) : null;
-+    }
-+
-     @Override
-     public final ChunkAccess getChunk(int chunkX, int chunkZ, ChunkStatus leastStatus, boolean create) { // Paper - final for inline
-         // Paper end

patches/unapplied/server/Add-ability-to-configure-frosted_ice-properties.patch

@@ -1,33 +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/net/minecraft/world/level/block/FrostedIceBlock.java b/src/main/java/net/minecraft/world/level/block/FrostedIceBlock.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/FrostedIceBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/FrostedIceBlock.java
-@@ -0,0 +0,0 @@ public class FrostedIceBlock extends IceBlock {
- 
-     @Override
-     public void tick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
-+        if (!world.paperConfig().environment.frostedIce.enabled) return; // Paper - add ability to disable frosted ice
-         if ((random.nextInt(3) == 0 || this.fewerNeigboursThan(world, pos, 4)) && world.getMaxLocalRawBrightness(pos) > 11 - state.getValue(AGE) - state.getLightBlock(world, pos) && this.slightlyMelt(state, world, pos)) {
-             BlockPos.MutableBlockPos mutableBlockPos = new BlockPos.MutableBlockPos();
- 
-@@ -0,0 +0,0 @@ public class FrostedIceBlock extends IceBlock {
-                 mutableBlockPos.setWithOffset(pos, direction);
-                 BlockState blockState = world.getBlockState(mutableBlockPos);
-                 if (blockState.is(this) && !this.slightlyMelt(blockState, world, mutableBlockPos)) {
--                    world.scheduleTick(mutableBlockPos, this, Mth.nextInt(random, 20, 40));
-+                    world.scheduleTick(mutableBlockPos, this, Mth.nextInt(random, world.paperConfig().environment.frostedIce.delay.min, world.paperConfig().environment.frostedIce.delay.max)); // Paper - use configurable min/max delay
-                 }
-             }
- 
-         } else {
--            world.scheduleTick(pos, this, Mth.nextInt(random, 20, 40));
-+            world.scheduleTick(pos, this, Mth.nextInt(random, world.paperConfig().environment.frostedIce.delay.min, world.paperConfig().environment.frostedIce.delay.max)); // Paper - use configurable min/max delay
-         }
-     }
- 

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

@@ -1,21 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: BillyGalbreath <Blake.Galbreath@GMail.com>
-Date: Fri, 22 Jun 2018 10:38:31 -0500
-Subject: [PATCH] Add config to disable ender dragon legacy check
-
-
-diff --git a/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java b/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
-+++ b/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
-@@ -0,0 +0,0 @@ public class EndDragonFight {
-     private List<EndCrystal> respawnCrystals;
- 
-     public EndDragonFight(ServerLevel world, long gatewaysSeed, CompoundTag nbt) {
-+        // Paper start
-+        this.needsStateScanning = world.paperConfig().entities.spawning.scanForLegacyEnderDragon;
-+        if (!this.needsStateScanning) this.dragonKilled = true;
-+        // Paper end
-         this.level = world;
-         if (nbt.contains("NeedsStateScanning")) {
-             this.needsStateScanning = nbt.getBoolean("NeedsStateScanning");

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

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

patches/unapplied/server/Add-hand-to-bucket-events.patch

@@ -1,125 +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/world/entity/animal/Cow.java b/src/main/java/net/minecraft/world/entity/animal/Cow.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/animal/Cow.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/Cow.java
-@@ -0,0 +0,0 @@ public class Cow extends Animal {
- 
-         if (itemstack.is(Items.BUCKET) && !this.isBaby()) {
-             // CraftBukkit start - Got milk?
--            org.bukkit.event.player.PlayerBucketFillEvent event = CraftEventFactory.callPlayerBucketFillEvent((ServerLevel) player.level, player, this.blockPosition(), this.blockPosition(), null, itemstack, Items.MILK_BUCKET);
-+            org.bukkit.event.player.PlayerBucketFillEvent event = CraftEventFactory.callPlayerBucketFillEvent((ServerLevel) player.level, player, this.blockPosition(), this.blockPosition(), null, itemstack, Items.MILK_BUCKET, hand); // Paper - add enumHand
- 
-             if (event.isCancelled()) {
-                 return InteractionResult.PASS;
-diff --git a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
-@@ -0,0 +0,0 @@ public class Goat extends Animal {
- 
-         if (itemstack.is(Items.BUCKET) && !this.isBaby()) {
-             // CraftBukkit start - Got milk?
--            org.bukkit.event.player.PlayerBucketFillEvent event = CraftEventFactory.callPlayerBucketFillEvent((ServerLevel) player.level, player, this.blockPosition(), this.blockPosition(), null, itemstack, Items.MILK_BUCKET);
-+            org.bukkit.event.player.PlayerBucketFillEvent event = CraftEventFactory.callPlayerBucketFillEvent((ServerLevel) player.level, player, this.blockPosition(), this.blockPosition(), null, itemstack, Items.MILK_BUCKET, hand); // Paper - add enumHand
- 
-             if (event.isCancelled()) {
-                 return InteractionResult.PASS;
-diff --git a/src/main/java/net/minecraft/world/item/BucketItem.java b/src/main/java/net/minecraft/world/item/BucketItem.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/item/BucketItem.java
-+++ b/src/main/java/net/minecraft/world/item/BucketItem.java
-@@ -0,0 +0,0 @@ public class BucketItem extends Item implements DispensibleContainerItem {
-                         // CraftBukkit start
-                         ItemStack dummyFluid = ifluidsource.pickupBlock(DummyGeneratorAccess.INSTANCE, blockposition, iblockdata);
-                         if (dummyFluid.isEmpty()) return InteractionResultHolder.fail(itemstack); // Don't fire event if the bucket won't be filled.
--                        PlayerBucketFillEvent event = CraftEventFactory.callPlayerBucketFillEvent((ServerLevel) world, user, blockposition, blockposition, movingobjectpositionblock.getDirection(), itemstack, dummyFluid.getItem());
-+                        PlayerBucketFillEvent event = CraftEventFactory.callPlayerBucketFillEvent((ServerLevel) world, user, blockposition, blockposition, movingobjectpositionblock.getDirection(), itemstack, dummyFluid.getItem(), hand); // Paper - add enumhand
- 
-                         if (event.isCancelled()) {
-                             ((ServerPlayer) user).connection.send(new ClientboundBlockUpdatePacket(world, blockposition)); // SPIGOT-5163 (see PlayerInteractManager)
-@@ -0,0 +0,0 @@ public class BucketItem extends Item implements DispensibleContainerItem {
-                     iblockdata = world.getBlockState(blockposition);
-                     BlockPos blockposition2 = iblockdata.getBlock() instanceof LiquidBlockContainer && this.content == Fluids.WATER ? blockposition : blockposition1;
- 
--                    if (this.emptyContents(user, world, blockposition2, movingobjectpositionblock, movingobjectpositionblock.getDirection(), blockposition, itemstack)) { // CraftBukkit
-+                    if (this.emptyContents(user, world, blockposition2, movingobjectpositionblock, movingobjectpositionblock.getDirection(), blockposition, itemstack, hand)) { // CraftBukkit // Paper - add enumhand
-                         this.checkExtraContent(user, world, itemstack, blockposition2);
-                         if (user instanceof ServerPlayer) {
-                             CriteriaTriggers.PLACED_BLOCK.trigger((ServerPlayer) user, blockposition2, itemstack);
-@@ -0,0 +0,0 @@ public class BucketItem extends Item implements DispensibleContainerItem {
- 
-     @Override
-     public boolean emptyContents(@Nullable Player player, Level world, BlockPos pos, @Nullable BlockHitResult hitResult) {
--        return this.emptyContents(player, world, pos, hitResult, null, null, null);
-+        // Paper start - add enumHand
-+        return emptyContents(player, world, pos, hitResult, null, null, null, null);
-     }
- 
--    public boolean emptyContents(Player entityhuman, Level world, BlockPos blockposition, @Nullable BlockHitResult movingobjectpositionblock, Direction enumdirection, BlockPos clicked, ItemStack itemstack) {
-+    public boolean emptyContents(Player entityhuman, Level world, BlockPos blockposition, @Nullable BlockHitResult movingobjectpositionblock, Direction enumdirection, BlockPos clicked, ItemStack itemstack, InteractionHand enumhand) {
-+        // Paper end
-         // CraftBukkit end
-         if (!(this.content instanceof FlowingFluid)) {
-             return false;
-@@ -0,0 +0,0 @@ public class BucketItem extends Item implements DispensibleContainerItem {
- 
-             // CraftBukkit start
-             if (flag1 && entityhuman != null) {
--                PlayerBucketEmptyEvent event = CraftEventFactory.callPlayerBucketEmptyEvent((ServerLevel) world, entityhuman, blockposition, clicked, enumdirection, itemstack);
-+                PlayerBucketEmptyEvent event = CraftEventFactory.callPlayerBucketEmptyEvent((ServerLevel) world, entityhuman, blockposition, clicked, enumdirection, itemstack, enumhand); // Paper - add enumhand
-                 if (event.isCancelled()) {
-                     ((ServerPlayer) entityhuman).connection.send(new ClientboundBlockUpdatePacket(world, blockposition)); // SPIGOT-4238: needed when looking through entity
-                     ((ServerPlayer) entityhuman).getBukkitEntity().updateInventory(); // SPIGOT-4541
-@@ -0,0 +0,0 @@ public class BucketItem extends Item implements DispensibleContainerItem {
-             }
-             // CraftBukkit end
-             if (!flag1) {
--                return movingobjectpositionblock != null && this.emptyContents(entityhuman, world, movingobjectpositionblock.getBlockPos().relative(movingobjectpositionblock.getDirection()), (BlockHitResult) null, enumdirection, clicked, itemstack); // CraftBukkit
-+                return movingobjectpositionblock != null && this.emptyContents(entityhuman, world, movingobjectpositionblock.getBlockPos().relative(movingobjectpositionblock.getDirection()), (BlockHitResult) null, enumdirection, clicked, itemstack, enumhand); // CraftBukkit // Paper
-             } else if (world.dimensionType().ultraWarm() && this.content.is(FluidTags.WATER)) {
-                 int i = blockposition.getX();
-                 int j = blockposition.getY();
-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 {
-     }
- 
-     private static PlayerEvent getPlayerBucketEvent(boolean isFilling, ServerLevel world, net.minecraft.world.entity.player.Player who, BlockPos changed, BlockPos clicked, Direction 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(ServerLevel world, net.minecraft.world.entity.player.Player who, BlockPos changed, BlockPos clicked, Direction clickedFace, ItemStack itemstack, InteractionHand enumHand) {
-+        return (PlayerBucketEmptyEvent) getPlayerBucketEvent(false, world, who, changed, clicked, clickedFace, itemstack, Items.BUCKET, enumHand);
-+    }
-+
-+    public static PlayerBucketFillEvent callPlayerBucketFillEvent(ServerLevel world, net.minecraft.world.entity.player.Player who, BlockPos changed, BlockPos clicked, Direction clickedFace, ItemStack itemInHand, net.minecraft.world.item.Item bucket, InteractionHand enumHand) {
-+        return (PlayerBucketFillEvent) getPlayerBucketEvent(true, world, who, clicked, changed, clickedFace, itemInHand, bucket, enumHand);
-+    }
-+
-+    private static PlayerEvent getPlayerBucketEvent(boolean isFilling, ServerLevel world, net.minecraft.world.entity.player.Player who, BlockPos changed, BlockPos clicked, Direction clickedFace, ItemStack itemstack, net.minecraft.world.item.Item item, InteractionHand 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 == InteractionHand.OFF_HAND ? EquipmentSlot.OFF_HAND : EquipmentSlot.HAND); // Paper - add enumHand
-             ((PlayerBucketFillEvent) event).setCancelled(!CraftEventFactory.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 == InteractionHand.OFF_HAND ? EquipmentSlot.OFF_HAND : EquipmentSlot.HAND); // Paper - add enumHand
-             ((PlayerBucketEmptyEvent) event).setCancelled(!CraftEventFactory.canBuild(world, player, changed.getX(), changed.getZ()));
-         }
- 

patches/unapplied/server/Add-handshake-event-to-allow-plugins-to-handle-clien.patch

@@ -1,49 +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/ServerHandshakePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerHandshakePacketListenerImpl implements ServerHandshakePacketL
-                     this.connection.disconnect(ichatmutablecomponent);
-                 } else {
-                     this.connection.setListener(new ServerLoginPacketListenerImpl(this.server, this.connection));
-+                // 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.connection.address;
-+                    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(packet.hostName, hostnameOfRemote, !proxyLogicEnabled);
-+                    if (event.callEvent()) {
-+                        // If we've failed somehow, let the client know so and go no further.
-+                        if (event.isFailed()) {
-+                            Component component = io.papermc.paper.adventure.PaperAdventure.asVanilla(event.failMessage());
-+                            this.connection.send(new ClientboundLoginDisconnectPacket(component));
-+                            this.connection.disconnect(component);
-+                            return;
-+                        }
-+
-+                        if (event.getServerHostname() != null) packet.hostName = event.getServerHostname();
-+                        if (event.getSocketAddressHostname() != null) this.connection.address = new java.net.InetSocketAddress(event.getSocketAddressHostname(), socketAddress instanceof java.net.InetSocketAddress ? ((java.net.InetSocketAddress) socketAddress).getPort() : 0);
-+                        this.connection.spoofedUUID = event.getUniqueId();
-+                        this.connection.spoofedProfile = gson.fromJson(event.getPropertiesJson(), com.mojang.authlib.properties.Property[].class);
-+                        handledByEvent = true; // Hooray, we did it!
-+                    }
-+                }
-                     // Spigot Start
-                     String[] split = packet.hostName.split("\00");
--                    if (org.spigotmc.SpigotConfig.bungee) {
-+                    // Don't try and handle default logic if it's been handled by the event.
-+                    if (!handledByEvent && proxyLogicEnabled) {
-+                        // Paper end
-+                    // if (org.spigotmc.SpigotConfig.bungee) { // Paper - comment out, we check above!
-                         if ( ( split.length == 3 || split.length == 4 ) && ( ServerHandshakePacketListenerImpl.HOST_PATTERN.matcher( split[1] ).matches() ) ) {
-                             packet.hostName = split[0];
-                             connection.address = new java.net.InetSocketAddress(split[1], ((java.net.InetSocketAddress) this.connection.getRemoteAddress()).getPort());

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

@@ -1,114 +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/Witch.java b/src/main/java/net/minecraft/world/entity/monster/Witch.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/Witch.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/Witch.java
-@@ -0,0 +0,0 @@ public class Witch extends Raider implements RangedAttackMob {
-                 }
- 
-                 if (potionregistry != null) {
--                    // Paper start
-                     ItemStack potion = PotionUtils.setPotion(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.setItemSlot(EquipmentSlot.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.usingTime = this.getMainHandItem().getUseDuration();
--                    this.setUsingItem(true);
--                    if (!this.isSilent()) {
--                        this.level.playSound((Player) null, this.getX(), this.getY(), this.getZ(), SoundEvents.WITCH_DRINK, this.getSoundSource(), 1.0F, 0.8F + this.random.nextFloat() * 0.4F);
--                    }
--
--                    AttributeInstance attributemodifiable = this.getAttribute(Attributes.MOVEMENT_SPEED);
- 
--                    attributemodifiable.removeModifier(Witch.SPEED_MODIFIER_DRINKING);
--                    attributemodifiable.addTransientModifier(Witch.SPEED_MODIFIER_DRINKING);
-                 }
-             }
- 
-@@ -0,0 +0,0 @@ public class Witch extends Raider implements RangedAttackMob {
-         super.aiStep();
-     }
- 
-+    // Paper start - moved to its own method
-+    public void setDrinkingPotion(ItemStack potion) {
-+        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.setItemSlot(EquipmentSlot.MAINHAND, org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(bukkitStack));
-+        // Paper end
-+        this.usingTime = this.getMainHandItem().getUseDuration();
-+        this.setUsingItem(true);
-+        if (!this.isSilent()) {
-+            this.level.playSound((Player) null, this.getX(), this.getY(), this.getZ(), SoundEvents.WITCH_DRINK, this.getSoundSource(), 1.0F, 0.8F + this.random.nextFloat() * 0.4F);
-+        }
-+
-+        AttributeInstance attributemodifiable = this.getAttribute(Attributes.MOVEMENT_SPEED);
-+
-+        attributemodifiable.removeModifier(Witch.SPEED_MODIFIER_DRINKING);
-+        attributemodifiable.addTransientModifier(Witch.SPEED_MODIFIER_DRINKING);
-+    }
-+    // Paper end
-+
-     @Override
-     public SoundEvent getCelebrateSound() {
-         return SoundEvents.WITCH_CELEBRATE;
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftWitch.java
-@@ -0,0 +0,0 @@ package org.bukkit.craftbukkit.entity;
- import org.bukkit.craftbukkit.CraftServer;
- import org.bukkit.entity.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<net.minecraft.world.entity.monster.Witch> { // Paper
-     public CraftWitch(CraftServer server, net.minecraft.world.entity.monster.Witch entity) {
-@@ -0,0 +0,0 @@ public class CraftWitch extends CraftRaider implements Witch, com.destroystokyo.
-     public boolean isDrinkingPotion() {
-         return this.getHandle().isDrinkingPotion();
-     }
-+    // Paper start
-+    public int getPotionUseTimeLeft() {
-+        return getHandle().usingTime;
-+    }
-+
-+    @Override
-+    public void setPotionUseTimeLeft(int ticks) {
-+        getHandle().usingTime = ticks;
-+    }
-+
-+    public ItemStack getDrinkingPotion() {
-+        return CraftItemStack.asCraftMirror(getHandle().getMainHandItem());
-+    }
-+
-+    public void setDrinkingPotion(ItemStack potion) {
-+        Preconditions.checkArgument(potion == null || potion.getType().isEmpty() || potion.getType() == Material.POTION, "must be potion, air, or null");
-+        getHandle().setDrinkingPotion(CraftItemStack.asNMSCopy(potion));
-+    }
-+    // Paper end
- }

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

@@ -1,115 +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/Zombie.java b/src/main/java/net/minecraft/world/entity/monster/Zombie.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/monster/Zombie.java
-+++ b/src/main/java/net/minecraft/world/entity/monster/Zombie.java
-@@ -0,0 +0,0 @@ public class Zombie extends Monster {
-     private int inWaterTime;
-     public int conversionTime;
-     private int lastTick = MinecraftServer.currentTick; // CraftBukkit - add field
-+    private boolean shouldBurnInDay = true; // Paper
- 
-     public Zombie(EntityType<? extends Zombie> type, Level world) {
-         super(type, world);
-@@ -0,0 +0,0 @@ public class Zombie extends Monster {
-         super.aiStep();
-     }
- 
-+    // Paper start
-+    public void stopDrowning() {
-+        this.conversionTime = -1;
-+        this.getEntityData().set(Zombie.DATA_DROWNED_CONVERSION_ID, false);
-+    }
-+    // Paper end
-     public void startUnderWaterConversion(int ticksUntilWaterConversion) {
-         this.lastTick = MinecraftServer.currentTick; // CraftBukkit
-         this.conversionTime = ticksUntilWaterConversion;
-@@ -0,0 +0,0 @@ public class Zombie extends Monster {
-     }
- 
-     public boolean isSunSensitive() {
--        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 hurt(DamageSource source, float amount) {
-         if (!super.hurt(source, amount)) {
-@@ -0,0 +0,0 @@ public class Zombie extends Monster {
-         nbt.putBoolean("CanBreakDoors", this.canBreakDoors());
-         nbt.putInt("InWaterTime", this.isInWater() ? this.inWaterTime : -1);
-         nbt.putInt("DrownedConversionTime", this.isUnderWaterConverting() ? this.conversionTime : -1);
-+        nbt.putBoolean("Paper.ShouldBurnInDay", this.shouldBurnInDay); // Paper
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class Zombie extends Monster {
-         if (nbt.contains("DrownedConversionTime", 99) && nbt.getInt("DrownedConversionTime") > -1) {
-             this.startUnderWaterConversion(nbt.getInt("DrownedConversionTime"));
-         }
-+        // Paper start
-+        if (nbt.contains("Paper.ShouldBurnInDay")) {
-+            this.shouldBurnInDay = nbt.getBoolean("Paper.ShouldBurnInDay");
-+        }
-+        // Paper end
- 
-     }
- 
-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().isUnderWaterConverting();
-+    }
-+
-+    @Override
-+    public void startDrowning(int drownedConversionTime) {
-+        getHandle().startUnderWaterConversion(drownedConversionTime);
-+    }
-+
-+    @Override
-+    public void stopDrowning() {
-+        getHandle().stopDrowning();
-+    }
-+
-+    @Override
-+    public boolean shouldBurnInDay() {
-+        return getHandle().isSunSensitive();
-+    }
-+
-+    @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() {

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

@@ -1,46 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Mark Vainomaa <mikroskeem@mikroskeem.eu>
-Date: Sun, 1 Apr 2018 02:29:37 +0300
-Subject: [PATCH] Add openSign method to HumanEntity
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftSign.java b/src/main/java/org/bukkit/craftbukkit/block/CraftSign.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/block/CraftSign.java
-+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftSign.java
-@@ -0,0 +0,0 @@ public class CraftSign extends CraftBlockEntityState<SignBlockEntity> implements
-         }
-     }
- 
--    public static void openSign(Sign sign, Player player) {
-+    public static void openSign(Sign sign, org.bukkit.entity.HumanEntity player) { // Paper - change move open sign to HumanEntity
-         Preconditions.checkArgument(sign != null, "sign == null");
--        Preconditions.checkArgument(sign.isPlaced(), "Sign must be placed");
-+        // Preconditions.checkArgument(sign.isPlaced(), "Sign must be placed"); // Paper - don't require placed
-         Preconditions.checkArgument(sign.getWorld() == player.getWorld(), "Sign must be in same world as Player");
- 
-         SignBlockEntity handle = ((CraftSign) sign).getTileEntity();
-         handle.isEditable = true;
- 
--        ((CraftPlayer) player).getHandle().openTextEdit(handle);
-+        ((org.bukkit.craftbukkit.entity.CraftHumanEntity) player).getHandle().openTextEdit(handle); // Paper - change move open sign to HumanEntity
-     }
- 
-     // Paper start
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
-@@ -0,0 +0,0 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
-         }
-     }
- 
-+    // Paper start - move open sign method to HumanEntity
-+    @Override
-+    public void openSign(org.bukkit.block.Sign sign) {
-+        org.bukkit.craftbukkit.block.CraftSign.openSign(sign, this);
-+    }
-+    // Paper end
-     @Override
-     public boolean dropItem(boolean dropAll) {
-         if (!(this.getHandle() instanceof ServerPlayer)) return false;

patches/unapplied/server/Add-option-to-disable-pillager-patrols.patch

@@ -1,18 +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/net/minecraft/world/level/levelgen/PatrolSpawner.java b/src/main/java/net/minecraft/world/level/levelgen/PatrolSpawner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/levelgen/PatrolSpawner.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/PatrolSpawner.java
-@@ -0,0 +0,0 @@ public class PatrolSpawner implements CustomSpawner {
- 
-     @Override
-     public int tick(ServerLevel world, boolean spawnMonsters, boolean spawnAnimals) {
-+        if (world.paperConfig().entities.behavior.pillagerPatrols.disable) return 0; // Paper
-         if (!spawnMonsters) {
-             return 0;
-         } else if (!world.getGameRules().getBoolean(GameRules.RULE_DO_PATROL_SPAWNING)) {

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

@@ -1,43 +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/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
-         switch (packet.getAction()) {
-             case PRESS_SHIFT_KEY:
-                 this.player.setShiftKeyDown(true);
-+
-+                // Paper start - Hang on!
-+                if (this.player.level.paperConfig().entities.behavior.parrotsAreUnaffectedByPlayerMovement) {
-+                    this.player.removeEntitiesOnShoulder();
-+                }
-+                // Paper end
-+
-                 break;
-             case RELEASE_SHIFT_KEY:
-                 this.player.setShiftKeyDown(false);
-diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/player/Player.java
-+++ b/src/main/java/net/minecraft/world/entity/player/Player.java
-@@ -0,0 +0,0 @@ public abstract class Player extends LivingEntity {
-         this.playShoulderEntityAmbientSound(this.getShoulderEntityLeft());
-         this.playShoulderEntityAmbientSound(this.getShoulderEntityRight());
-         if (!this.level.isClientSide && (this.fallDistance > 0.5F || this.isInWater()) || this.abilities.flying || this.isSleeping() || this.isInPowderSnow) {
--            this.removeEntitiesOnShoulder();
-+            if (!this.level.paperConfig().entities.behavior.parrotsAreUnaffectedByPlayerMovement) this.removeEntitiesOnShoulder(); // Paper - Hang on!
-         }
- 
-     }

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

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

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

@@ -1,90 +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/server/MCUtil.java b/src/main/java/net/minecraft/server/MCUtil.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/MCUtil.java
-+++ b/src/main/java/net/minecraft/server/MCUtil.java
-@@ -0,0 +0,0 @@ public final class MCUtil {
-         return getNMSWorld(entity.getWorld());
-     }
- 
-+    public static ClipContext.Fluid getNMSFluidCollisionOption(com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode) {
-+        switch (fluidMode) {
-+            case NEVER:
-+                return ClipContext.Fluid.NONE;
-+            case SOURCE_ONLY:
-+                return ClipContext.Fluid.SOURCE_ONLY;
-+            case ALWAYS:
-+                return ClipContext.Fluid.ANY;
-+        }
-+        return null;
-+    }
-+
-     public static BlockFace toBukkitBlockFace(Direction enumDirection) {
-         switch (enumDirection) {
-             case DOWN:
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity {
-     }
- 
-     // Paper start
-+    public HitResult getRayTrace(int maxDistance) {
-+        return getRayTrace(maxDistance, ClipContext.Fluid.NONE);
-+    }
-+
-+    public HitResult getRayTrace(int maxDistance, ClipContext.Fluid fluidCollisionOption) {
-+        if (maxDistance < 1 || maxDistance > 120) {
-+            throw new IllegalArgumentException("maxDistance must be between 1-120");
-+        }
-+
-+        Vec3 start = new Vec3(getX(), getY() + getEyeHeight(), getZ());
-+        org.bukkit.util.Vector dir = getBukkitEntity().getLocation().getDirection().multiply(maxDistance);
-+        Vec3 end = new Vec3(start.x + dir.getX(), start.y + dir.getY(), start.z + dir.getZ());
-+        ClipContext raytrace = new ClipContext(start, end, ClipContext.Block.OUTLINE, fluidCollisionOption, this);
-+
-+        return level.clip(raytrace);
-+    }
-+
-     public int shieldBlockingDelay = level.paperConfig().misc.shieldBlockingDelay;
- 
-     public int getShieldBlockingDelay() {
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
-@@ -0,0 +0,0 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
-         return blocks.get(0);
-     }
- 
-+    // Paper start
-+    @Override
-+    public Block getTargetBlock(int maxDistance, com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode) {
-+        net.minecraft.world.phys.HitResult rayTrace = getHandle().getRayTrace(maxDistance, net.minecraft.server.MCUtil.getNMSFluidCollisionOption(fluidMode));
-+        return !(rayTrace instanceof net.minecraft.world.phys.BlockHitResult) ? null : org.bukkit.craftbukkit.block.CraftBlock.at(getHandle().level, ((net.minecraft.world.phys.BlockHitResult)rayTrace).getBlockPos());
-+    }
-+
-+    @Override
-+    public org.bukkit.block.BlockFace getTargetBlockFace(int maxDistance, com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode) {
-+        net.minecraft.world.phys.HitResult rayTrace = getHandle().getRayTrace(maxDistance, net.minecraft.server.MCUtil.getNMSFluidCollisionOption(fluidMode));
-+        return !(rayTrace instanceof net.minecraft.world.phys.BlockHitResult) ? null : net.minecraft.server.MCUtil.toBukkitBlockFace(((net.minecraft.world.phys.BlockHitResult)rayTrace).getDirection());
-+    }
-+
-+    @Override
-+    public com.destroystokyo.paper.block.TargetBlockInfo getTargetBlockInfo(int maxDistance, com.destroystokyo.paper.block.TargetBlockInfo.FluidMode fluidMode) {
-+        net.minecraft.world.phys.HitResult rayTrace = getHandle().getRayTrace(maxDistance, net.minecraft.server.MCUtil.getNMSFluidCollisionOption(fluidMode));
-+        return !(rayTrace instanceof net.minecraft.world.phys.BlockHitResult) ? null :
-+            new com.destroystokyo.paper.block.TargetBlockInfo(org.bukkit.craftbukkit.block.CraftBlock.at(getHandle().level, ((net.minecraft.world.phys.BlockHitResult)rayTrace).getBlockPos()),
-+                net.minecraft.server.MCUtil.toBukkitBlockFace(((net.minecraft.world.phys.BlockHitResult)rayTrace).getDirection()));
-+    }
-+    // Paper end
-+
-     @Override
-     public List<Block> getLastTwoTargetBlocks(Set<Material> transparent, int maxDistance) {
-         return this.getLineOfSight(transparent, maxDistance, 2);

patches/unapplied/server/Add-server-name-parameter.patch

@@ -1,25 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Martin Panzer <postremus1996@googlemail.com>
-Date: Sat, 28 May 2016 16:54:03 +0200
-Subject: [PATCH] Add server-name parameter
-
-
-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 {
-                         .defaultsTo(new File[] {})
-                         .describedAs("Jar file");
-                 // Paper end
-+
-+                // Paper start
-+                acceptsAll(asList("server-name"), "Name of the server")
-+                        .withRequiredArg()
-+                        .ofType(String.class)
-+                        .defaultsTo("Unknown Server")
-+                        .describedAs("Name");
-+                // Paper end
-             }
-         };
- 

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

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

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

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

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

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

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

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

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

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

patches/unapplied/server/Allow-Reloading-of-Custom-Permissions.patch

@@ -1,35 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: William <admin@domnian.com>
-Date: Fri, 18 Mar 2016 03:30:17 -0400
-Subject: [PATCH] Allow Reloading of Custom Permissions
-
-https://github.com/PaperMC/Paper/issues/49
-
-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 this.adventure$audiences;
-     }
-+
-+    @Override
-+    public void reloadPermissions() {
-+        pluginManager.clearPermissions();
-+        if (io.papermc.paper.configuration.GlobalConfiguration.get().misc.loadPermissionsYmlBeforePlugins) loadCustomPermissions();
-+        for (Plugin plugin : pluginManager.getPlugins()) {
-+            for (Permission perm : plugin.getDescription().getPermissions()) {
-+                try {
-+                    pluginManager.addPermission(perm);
-+                } catch (IllegalArgumentException ex) {
-+                    getLogger().log(Level.WARNING, "Plugin " + plugin.getDescription().getFullName() + " tried to register permission '" + perm.getName() + "' but it's already registered", ex);
-+                }
-+            }
-+        }
-+        if (!io.papermc.paper.configuration.GlobalConfiguration.get().misc.loadPermissionsYmlBeforePlugins) loadCustomPermissions();
-+        DefaultPermissions.registerCorePermissions();
-+        CraftDefaultPermissions.registerCorePermissions();
-+    }
-     // Paper end
- }

patches/unapplied/server/Allow-Saving-of-Oversized-Chunks.patch

@@ -1,251 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Fri, 15 Feb 2019 01:08:19 -0500
-Subject: [PATCH] Allow Saving of Oversized Chunks
-
-Note 1.17 update: With 1.17, Entities are no longer stored in chunk slices, so this needs updating!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-The Minecraft World Region File format has a hard cap of 1MB per chunk.
-This is due to the fact that the header of the file format only allocates
-a single byte for sector count, meaning a maximum of 256 sectors, at 4k per sector.
-
-This limit can be reached fairly easily with books, resulting in the chunk being unable
-to save to the world. Worse off, is that nothing printed when this occured, and silently
-performed a chunk rollback on next load.
-
-This leads to security risk with duplication and is being actively exploited.
-
-This patch catches the too large scenario, falls back and moves any large Entity
-or Tile Entity into a new compound, and this compound is saved into a different file.
-
-On Chunk Load, we check for oversized status, and if so, we load the extra file and
-merge the Entities and Tile Entities from the oversized chunk back into the level to
-then be loaded as normal.
-
-Once a chunk is returned back to normal size, the oversized flag will clear, and no
-extra data file will exist.
-
-This fix maintains compatability with all existing Anvil Region Format tools as it
-does not alter the save format. They will just not know about the extra entities.
-
-This fix also maintains compatability if someone switches server jars to one without
-this fix, as the data will remain in the oversized file. Once the server returns
-to a jar with this fix, the data will be restored.
-
-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 @@ import java.nio.file.LinkOption;
- import java.nio.file.Path;
- import java.nio.file.StandardCopyOption;
- import java.nio.file.StandardOpenOption;
-+import java.util.zip.InflaterInputStream; // Paper
-+
- import javax.annotation.Nullable;
- import net.minecraft.Util;
-+import net.minecraft.nbt.CompoundTag;
-+import net.minecraft.nbt.NbtIo;
- import net.minecraft.world.level.ChunkPos;
- import org.slf4j.Logger;
- 
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable {
-     @VisibleForTesting
-     protected final RegionBitmap usedSectors;
-     public final java.util.concurrent.locks.ReentrantLock fileLock = new java.util.concurrent.locks.ReentrantLock(true); // Paper
-+    public final Path regionFile; // Paper
- 
-     public RegionFile(Path file, Path directory, boolean dsync) throws IOException {
-         this(file, directory, RegionFileVersion.VERSION_DEFLATE, dsync);
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable {
- 
-     public RegionFile(Path file, Path directory, RegionFileVersion outputChunkStreamVersion, boolean dsync) throws IOException {
-         this.header = ByteBuffer.allocateDirect(8192);
-+        this.regionFile = file; // Paper
-+        initOversizedState(); // Paper
-         this.usedSectors = new RegionBitmap();
-         this.version = outputChunkStreamVersion;
-         if (!Files.isDirectory(directory, new LinkOption[0])) {
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable {
- 
-     }
- 
-+    // Paper start
-+    private final byte[] oversized = new byte[1024];
-+    private int oversizedCount = 0;
-+
-+    private synchronized void initOversizedState() throws IOException {
-+        Path metaFile = getOversizedMetaFile();
-+        if (Files.exists(metaFile)) {
-+            final byte[] read = java.nio.file.Files.readAllBytes(metaFile);
-+            System.arraycopy(read, 0, oversized, 0, oversized.length);
-+            for (byte temp : oversized) {
-+                oversizedCount += temp;
-+            }
-+        }
-+    }
-+
-+    private static int getChunkIndex(int x, int z) {
-+        return (x & 31) + (z & 31) * 32;
-+    }
-+    synchronized boolean isOversized(int x, int z) {
-+        return this.oversized[getChunkIndex(x, z)] == 1;
-+    }
-+    synchronized void setOversized(int x, int z, boolean oversized) throws IOException {
-+        final int offset = getChunkIndex(x, z);
-+        boolean previous = this.oversized[offset] == 1;
-+        this.oversized[offset] = (byte) (oversized ? 1 : 0);
-+        if (!previous && oversized) {
-+            oversizedCount++;
-+        } else if (!oversized && previous) {
-+            oversizedCount--;
-+        }
-+        if (previous && !oversized) {
-+            Path oversizedFile = getOversizedFile(x, z);
-+            if (Files.exists(oversizedFile)) {
-+                Files.delete(oversizedFile);
-+            }
-+        }
-+        if (oversizedCount > 0) {
-+            if (previous != oversized) {
-+                writeOversizedMeta();
-+            }
-+        } else if (previous) {
-+            Path oversizedMetaFile = getOversizedMetaFile();
-+            if (Files.exists(oversizedMetaFile)) {
-+                Files.delete(oversizedMetaFile);
-+            }
-+        }
-+    }
-+
-+    private void writeOversizedMeta() throws IOException {
-+        java.nio.file.Files.write(getOversizedMetaFile(), oversized);
-+    }
-+
-+    private Path getOversizedMetaFile() {
-+        return this.regionFile.getParent().resolve(this.regionFile.getFileName().toString().replaceAll("\\.mca$", "") + ".oversized.nbt");
-+    }
-+
-+    private Path getOversizedFile(int x, int z) {
-+        return this.regionFile.getParent().resolve(this.regionFile.getFileName().toString().replaceAll("\\.mca$", "") + "_oversized_" + x + "_" + z + ".nbt");
-+    }
-+
-+    synchronized CompoundTag getOversizedData(int x, int z) throws IOException {
-+        Path file = getOversizedFile(x, z);
-+        try (DataInputStream out = new DataInputStream(new java.io.BufferedInputStream(new InflaterInputStream(Files.newInputStream(file))))) {
-+            return NbtIo.read((java.io.DataInput) out);
-+        }
-+
-+    }
-+    // Paper end
-     private class ChunkBuffer extends ByteArrayOutputStream {
- 
-         private final ChunkPos pos;
-diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
-@@ -0,0 +0,0 @@ import java.nio.file.Files;
- import java.nio.file.Path;
- import javax.annotation.Nullable;
- import net.minecraft.nbt.CompoundTag;
-+import net.minecraft.nbt.ListTag;
- import net.minecraft.nbt.NbtIo;
- import net.minecraft.nbt.StreamTagVisitor;
-+import net.minecraft.nbt.Tag;
- import net.minecraft.util.ExceptionCollector;
- import net.minecraft.world.level.ChunkPos;
- 
-@@ -0,0 +0,0 @@ public class RegionFileStorage implements AutoCloseable {
-         }
-     }
- 
-+    // Paper start
-+    private static void printOversizedLog(String msg, Path file, int x, int z) {
-+        org.apache.logging.log4j.LogManager.getLogger().fatal(msg + " (" + file.toString().replaceAll(".+[\\\\/]", "") + " - " + x + "," + z + ") Go clean it up to remove this message. /minecraft:tp " + (x<<4)+" 128 "+(z<<4) + " - DO NOT REPORT THIS TO PAPER - You may ask for help on Discord, but do not file an issue. These error messages can not be removed.");
-+    }
-+
-+    private static final int DEFAULT_SIZE_THRESHOLD = 1024 * 8;
-+    private static final int OVERZEALOUS_TOTAL_THRESHOLD = 1024 * 64;
-+    private static final int OVERZEALOUS_THRESHOLD = 1024;
-+    private static int SIZE_THRESHOLD = DEFAULT_SIZE_THRESHOLD;
-+    private static void resetFilterThresholds() {
-+        SIZE_THRESHOLD = Math.max(1024 * 4, Integer.getInteger("Paper.FilterThreshhold", DEFAULT_SIZE_THRESHOLD));
-+    }
-+    static {
-+        resetFilterThresholds();
-+    }
-+
-+    static boolean isOverzealous() {
-+        return SIZE_THRESHOLD == OVERZEALOUS_THRESHOLD;
-+    }
-+
-+
-+    private static CompoundTag readOversizedChunk(RegionFile regionfile, ChunkPos chunkCoordinate) throws IOException {
-+        synchronized (regionfile) {
-+            try (DataInputStream datainputstream = regionfile.getChunkDataInputStream(chunkCoordinate)) {
-+                CompoundTag oversizedData = regionfile.getOversizedData(chunkCoordinate.x, chunkCoordinate.z);
-+                CompoundTag chunk = NbtIo.read((DataInput) datainputstream);
-+                if (oversizedData == null) {
-+                    return chunk;
-+                }
-+                CompoundTag oversizedLevel = oversizedData.getCompound("Level");
-+
-+                mergeChunkList(chunk.getCompound("Level"), oversizedLevel, "Entities", "Entities");
-+                mergeChunkList(chunk.getCompound("Level"), oversizedLevel, "TileEntities", "TileEntities");
-+
-+                return chunk;
-+            } catch (Throwable throwable) {
-+                throwable.printStackTrace();
-+                throw throwable;
-+            }
-+        }
-+    }
-+
-+    private static void mergeChunkList(CompoundTag level, CompoundTag oversizedLevel, String key, String oversizedKey) {
-+        ListTag levelList = level.getList(key, 10);
-+        ListTag oversizedList = oversizedLevel.getList(oversizedKey, 10);
-+
-+        if (!oversizedList.isEmpty()) {
-+            levelList.addAll(oversizedList);
-+            level.put(key, levelList);
-+        }
-+    }
-+
-+    private static int getNBTSize(Tag nbtBase) {
-+        DataOutputStream test = new DataOutputStream(new org.apache.commons.io.output.NullOutputStream());
-+        try {
-+            nbtBase.write(test);
-+            return test.size();
-+        } catch (IOException e) {
-+            e.printStackTrace();
-+            return 0;
-+        }
-+    }
-+
-+    // Paper End
-+
-     @Nullable
-     public CompoundTag read(ChunkPos pos) throws IOException {
-         // CraftBukkit start - SPIGOT-5680: There's no good reason to preemptively create files on read, save that for writing
-@@ -0,0 +0,0 @@ public class RegionFileStorage implements AutoCloseable {
-         try { // Paper
-         DataInputStream datainputstream = regionfile.getChunkDataInputStream(pos);
- 
-+        // Paper start
-+        if (regionfile.isOversized(pos.x, pos.z)) {
-+            printOversizedLog("Loading Oversized Chunk!", regionfile.regionFile, pos.x, pos.z);
-+            return readOversizedChunk(regionfile, pos);
-+        }
-+        // Paper end
-         CompoundTag nbttagcompound;
-         label43:
-         {
-@@ -0,0 +0,0 @@ public class RegionFileStorage implements AutoCloseable {
- 
-             try {
-                 NbtIo.write(nbt, (DataOutput) dataoutputstream);
-+                regionfile.setOversized(pos.x, pos.z, false); // Paper - We don't do this anymore, mojang stores differently, but clear old meta flag if it exists to get rid of our own meta file once last oversized is gone
-             } catch (Throwable throwable) {
-                 if (dataoutputstream != null) {
-                     try {

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

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

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

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

patches/unapplied/server/Allow-spawning-Item-entities-with-World.spawnEntity.patch

@@ -1,24 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Mon, 4 Jun 2018 20:39:20 -0400
-Subject: [PATCH] Allow spawning Item entities with World.spawnEntity
-
-This API has more capabilities than .dropItem with the Consumer function
-
-Item can be set inside of the Consumer pre spawn function.
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
-@@ -0,0 +0,0 @@ public abstract class CraftRegionAccessor implements RegionAccessor {
-                 entity = net.minecraft.world.entity.EntityType.BOAT.create(world);
-             }
-             entity.moveTo(x, y, z, yaw, pitch);
-+            // Paper start
-+        } else if (org.bukkit.entity.Item.class.isAssignableFrom(clazz)) {
-+            entity = new net.minecraft.world.entity.item.ItemEntity(world, x, y, z, new net.minecraft.world.item.ItemStack(net.minecraft.world.item.Item.byBlock(net.minecraft.world.level.block.Blocks.DIRT)));
-+            // Paper end
-         } else if (FallingBlock.class.isAssignableFrom(clazz)) {
-             BlockPos pos = new BlockPos(x, y, z);
-             entity = FallingBlockEntity.fall(world, pos, this.getHandle().getBlockState(pos));

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

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

patches/unapplied/server/AnvilDamageEvent.patch

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

patches/unapplied/server/Async-GameProfileCache-saving.patch

@@ -1,86 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Mon, 16 May 2016 20:47:41 -0400
-Subject: [PATCH] Async GameProfileCache saving
-
-
-diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         } catch (java.lang.InterruptedException ignored) {} // Paper
-         if (org.spigotmc.SpigotConfig.saveUserCacheOnStopOnly) {
-             MinecraftServer.LOGGER.info("Saving usercache.json");
--            this.getProfileCache().save();
-+            this.getProfileCache().save(false); // Paper
-         }
-         // 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 ServerInterface
-         }
- 
-         if (this.convertOldUsers()) {
--            this.getProfileCache().save();
-+            this.getProfileCache().save(false); // Paper
-         }
- 
-         if (!OldUsersConverter.serverReadyAfterUserconversion(this)) {
-diff --git a/src/main/java/net/minecraft/server/players/GameProfileCache.java b/src/main/java/net/minecraft/server/players/GameProfileCache.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/players/GameProfileCache.java
-+++ b/src/main/java/net/minecraft/server/players/GameProfileCache.java
-@@ -0,0 +0,0 @@ public class GameProfileCache {
-         GameProfileCache.GameProfileInfo usercache_usercacheentry = new GameProfileCache.GameProfileInfo(profile, date);
- 
-         this.safeAdd(usercache_usercacheentry);
--        if( !org.spigotmc.SpigotConfig.saveUserCacheOnStopOnly ) this.save(); // Spigot - skip saving if disabled
-+        if( !org.spigotmc.SpigotConfig.saveUserCacheOnStopOnly ) this.save(true); // Spigot - skip saving if disabled // Paper - async
-     }
- 
-     private long getNextOperation() {
-@@ -0,0 +0,0 @@ public class GameProfileCache {
-         }
- 
-         if (flag && !org.spigotmc.SpigotConfig.saveUserCacheOnStopOnly) { // Spigot - skip saving if disabled
--            this.save();
-+            this.save(true); // Paper
-         }
- 
-         return optional;
-@@ -0,0 +0,0 @@ public class GameProfileCache {
-         return arraylist;
-     }
- 
--    public void save() {
-+    public void save(boolean asyncSave) { // Paper
-         JsonArray jsonarray = new JsonArray();
-         DateFormat dateformat = GameProfileCache.createDateFormat();
- 
-@@ -0,0 +0,0 @@ public class GameProfileCache {
-             jsonarray.add(GameProfileCache.writeGameProfile(usercache_usercacheentry, dateformat));
-         });
-         String s = this.gson.toJson(jsonarray);
-+        Runnable save = () -> { // Paper
- 
-         try {
-             BufferedWriter bufferedwriter = Files.newWriter(this.file, StandardCharsets.UTF_8);
-@@ -0,0 +0,0 @@ public class GameProfileCache {
-         } catch (IOException ioexception) {
-             ;
-         }
-+        // Paper start
-+        };
-+        if (asyncSave) {
-+            net.minecraft.server.MCUtil.scheduleAsyncTask(save);
-+        } else {
-+            save.run();
-+        }
-+        // Paper end
- 
-     }
- 

patches/unapplied/server/Async-command-map-building.patch

@@ -1,46 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Callahan <mr.callahhh@gmail.com>
-Date: Wed, 8 Apr 2020 02:42:14 -0500
-Subject: [PATCH] Async command map building
-
-
-diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/commands/Commands.java
-+++ b/src/main/java/net/minecraft/commands/Commands.java
-@@ -0,0 +0,0 @@ import net.minecraft.network.chat.ComponentUtils;
- import net.minecraft.network.chat.HoverEvent;
- import net.minecraft.network.chat.MutableComponent;
- import net.minecraft.network.protocol.game.ClientboundCommandsPacket;
-+import net.minecraft.server.MinecraftServer;
- import net.minecraft.server.commands.AdvancementCommands;
- import net.minecraft.server.commands.AttributeCommand;
- import net.minecraft.server.commands.BanIpCommands;
-@@ -0,0 +0,0 @@ public class Commands {
-         if ( org.spigotmc.SpigotConfig.tabComplete < 0 ) return; // Spigot
-         // CraftBukkit start
-         // Register Vanilla commands into builtRoot as before
-+        // Paper start - Async command map building
-+        net.minecraft.server.MCUtil.scheduleAsyncTask(() -> this.sendAsync(player));
-+    }
-+
-+    private void sendAsync(ServerPlayer player) {
-+        // Paper end - Async command map building
-         Map<CommandNode<CommandSourceStack>, CommandNode<SharedSuggestionProvider>> map = Maps.newIdentityHashMap(); // Use identity to prevent aliasing issues
-         RootCommandNode vanillaRoot = new RootCommandNode();
- 
-@@ -0,0 +0,0 @@ public class Commands {
-         for (CommandNode node : rootcommandnode.getChildren()) {
-             bukkit.add(node.getName());
-         }
-+        // Paper start - Async command map building
-+        MinecraftServer.getServer().execute(() -> {
-+           runSync(player, bukkit, rootcommandnode);
-+        });
-+    }
- 
-+    private void runSync(ServerPlayer player, Collection<String> bukkit, RootCommandNode<SharedSuggestionProvider> rootcommandnode) {
-+        // Paper end - Async command map building
-         PlayerCommandSendEvent event = new PlayerCommandSendEvent(player.getBukkitEntity(), new LinkedHashSet<>(bukkit));
-         event.getPlayer().getServer().getPluginManager().callEvent(event);
- 

patches/unapplied/server/AsyncTabCompleteEvent.patch

@@ -1,130 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sun, 26 Nov 2017 13:19:58 -0500
-Subject: [PATCH] AsyncTabCompleteEvent
-
-Let plugins be able to control tab completion of commands and chat async.
-
-This will be useful for frameworks like ACF so we can define async safe completion handlers,
-and avoid going to main for tab completions.
-
-Especially useful if you need to query a database in order to obtain the results for tab
-completion, such as offline players.
-
-Also adds isCommand and getLocation to the sync TabCompleteEvent
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
- 
-     @Override
-     public void handleCustomCommandSuggestions(ServerboundCommandSuggestionPacket packet) {
--        PacketUtils.ensureRunningOnSameThread(packet, this, this.player.getLevel());
-+        // PacketUtils.ensureRunningOnSameThread(packet, this, this.player.getLevel()); // Paper - run this async
-         // CraftBukkit start
-         if (this.chatSpamTickCount.addAndGet(1) > 500 && !this.server.getPlayerList().isOp(this.player.getGameProfile())) {
--            this.disconnect(Component.translatable("disconnect.spam"));
-+            server.scheduleOnMain(() -> this.disconnect(Component.translatable("disconnect.spam", new Object[0]))); // Paper
-             return;
-         }
-         // CraftBukkit end
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
-             stringreader.skip();
-         }
- 
--        ParseResults<CommandSourceStack> parseresults = this.server.getCommands().getDispatcher().parse(stringreader, this.player.createCommandSourceStack());
-+        // Paper start - async tab completion
-+        com.destroystokyo.paper.event.server.AsyncTabCompleteEvent event;
-+        java.util.List<String> completions = new java.util.ArrayList<>();
-+        String buffer = packet.getCommand();
-+        event = new com.destroystokyo.paper.event.server.AsyncTabCompleteEvent(this.getCraftPlayer(), completions,
-+                buffer, true, null);
-+        event.callEvent();
-+        completions = event.isCancelled() ? com.google.common.collect.ImmutableList.of() : event.getCompletions();
-+        // If the event isn't handled, we can assume that we have no completions, and so we'll ask the server
-+        if (!event.isHandled()) {
-+            if (!event.isCancelled()) {
-+
-+                this.server.scheduleOnMain(() -> { // Paper - This needs to be on main
-+                    ParseResults<CommandSourceStack> parseresults = this.server.getCommands().getDispatcher().parse(stringreader, this.player.createCommandSourceStack());
- 
--        this.server.getCommands().getDispatcher().getCompletionSuggestions(parseresults).thenAccept((suggestions) -> {
--            if (suggestions.isEmpty()) return; // CraftBukkit - don't send through empty suggestions - prevents [<args>] from showing for plugins with nothing more to offer
--            this.connection.send(new ClientboundCommandSuggestionsPacket(packet.getId(), suggestions));
--        });
-+                    this.server.getCommands().getDispatcher().getCompletionSuggestions(parseresults).thenAccept((suggestions) -> {
-+                        if (suggestions.isEmpty()) return; // CraftBukkit - don't send through empty suggestions - prevents [<args>] from showing for plugins with nothing more to offer
-+                        this.connection.send(new ClientboundCommandSuggestionsPacket(packet.getId(), suggestions));
-+                    });
-+                });
-+            }
-+        } else if (!completions.isEmpty()) {
-+            com.mojang.brigadier.suggestion.SuggestionsBuilder builder = new com.mojang.brigadier.suggestion.SuggestionsBuilder(packet.getCommand(), stringreader.getTotalLength());
-+
-+            builder = builder.createOffset(builder.getInput().lastIndexOf(' ') + 1);
-+            completions.forEach(builder::suggest);
-+            player.connection.send(new ClientboundCommandSuggestionsPacket(packet.getId(), builder.buildFuture().join()));
-+        }
-+        // Paper end - async tab completion
-     }
- 
-     @Override
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-             offers = this.tabCompleteChat(player, message);
-         }
- 
--        TabCompleteEvent tabEvent = new TabCompleteEvent(player, message, offers);
-+        TabCompleteEvent tabEvent = new TabCompleteEvent(player, message, offers, message.startsWith("/") || forceCommand, pos != null ? net.minecraft.server.MCUtil.toLocation(((CraftWorld) player.getWorld()).getHandle(), new BlockPos(pos)) : null); // Paper
-         this.getPluginManager().callEvent(tabEvent);
- 
-         return tabEvent.isCancelled() ? Collections.EMPTY_LIST : tabEvent.getCompletions();
-diff --git a/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java b/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java
-+++ b/src/main/java/org/bukkit/craftbukkit/command/ConsoleCommandCompleter.java
-@@ -0,0 +0,0 @@ public class ConsoleCommandCompleter implements Completer {
-     public void complete(LineReader reader, ParsedLine line, List<Candidate> candidates) {
-         final CraftServer server = this.server.server;
-         final String buffer = line.line();
-+        // Async Tab Complete
-+        com.destroystokyo.paper.event.server.AsyncTabCompleteEvent event;
-+        java.util.List<String> completions = new java.util.ArrayList<>();
-+        event = new com.destroystokyo.paper.event.server.AsyncTabCompleteEvent(server.getConsoleSender(), completions,
-+            buffer, true, null);
-+        event.callEvent();
-+        completions = event.isCancelled() ? com.google.common.collect.ImmutableList.of() : event.getCompletions();
-+
-+        if (event.isCancelled() || event.isHandled()) {
-+            // Still fire sync event with the provided completions, if someone is listening
-+            if (!event.isCancelled() && TabCompleteEvent.getHandlerList().getRegisteredListeners().length > 0) {
-+                List<String> finalCompletions = completions;
-+                Waitable<List<String>> syncCompletions = new Waitable<List<String>>() {
-+                    @Override
-+                    protected List<String> evaluate() {
-+                        org.bukkit.event.server.TabCompleteEvent syncEvent = new org.bukkit.event.server.TabCompleteEvent(server.getConsoleSender(), buffer, finalCompletions);
-+                        return syncEvent.callEvent() ? syncEvent.getCompletions() : com.google.common.collect.ImmutableList.of();
-+                    }
-+                };
-+                server.getServer().processQueue.add(syncCompletions);
-+                try {
-+                    completions = syncCompletions.get();
-+                } catch (InterruptedException | ExecutionException e1) {
-+                    e1.printStackTrace();
-+                }
-+            }
-+
-+            if (!completions.isEmpty()) {
-+                candidates.addAll(completions.stream().map(Candidate::new).collect(java.util.stream.Collectors.toList()));
-+            }
-+            return;
-+        }
-+
-         // Paper end
-         Waitable<List<String>> waitable = new Waitable<List<String>>() {
-             @Override

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

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

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

@@ -1,760 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Mon, 15 Jan 2018 22:11:48 -0500
-Subject: [PATCH] Basic PlayerProfile API
-
-Establishes base extension of profile systems for future edits too
-
-diff --git a/src/main/java/com/destroystokyo/paper/profile/CraftPlayerProfile.java b/src/main/java/com/destroystokyo/paper/profile/CraftPlayerProfile.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/profile/CraftPlayerProfile.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.profile;
-+
-+import io.papermc.paper.configuration.GlobalConfiguration;
-+import com.google.common.base.Charsets;
-+import com.google.common.collect.Iterables;
-+import com.mojang.authlib.GameProfile;
-+import com.mojang.authlib.properties.Property;
-+import com.mojang.authlib.properties.PropertyMap;
-+import net.minecraft.Util;
-+import net.minecraft.server.MinecraftServer;
-+import net.minecraft.server.players.GameProfileCache;
-+import org.apache.commons.lang3.Validate;
-+import org.bukkit.configuration.serialization.SerializableAs;
-+import org.bukkit.craftbukkit.configuration.ConfigSerializationUtil;
-+import org.bukkit.craftbukkit.entity.CraftPlayer;
-+import org.bukkit.craftbukkit.profile.CraftPlayerTextures;
-+import org.bukkit.craftbukkit.profile.CraftProfileProperty;
-+import org.bukkit.profile.PlayerTextures;
-+import org.jetbrains.annotations.NotNull;
-+
-+import javax.annotation.Nonnull;
-+import javax.annotation.Nullable;
-+import java.util.*;
-+import java.util.concurrent.CompletableFuture;
-+
-+@SerializableAs("PlayerProfile")
-+public class CraftPlayerProfile implements PlayerProfile, SharedPlayerProfile {
-+
-+    private GameProfile profile;
-+    private final PropertySet properties = new PropertySet();
-+
-+    public CraftPlayerProfile(CraftPlayer player) {
-+        this.profile = player.getHandle().getGameProfile();
-+    }
-+
-+    public CraftPlayerProfile(UUID id, String name) {
-+        this.profile = new GameProfile(id, name);
-+    }
-+
-+    public CraftPlayerProfile(GameProfile profile) {
-+        Validate.notNull(profile, "GameProfile cannot be null!");
-+        this.profile = profile;
-+    }
-+
-+    @Override
-+    public boolean hasProperty(String property) {
-+        return profile.getProperties().containsKey(property);
-+    }
-+
-+    @Override
-+    public void setProperty(ProfileProperty property) {
-+        String name = property.getName();
-+        PropertyMap properties = profile.getProperties();
-+        properties.removeAll(name);
-+        properties.put(name, new Property(name, property.getValue(), property.getSignature()));
-+    }
-+
-+    @Override
-+    public CraftPlayerTextures getTextures() {
-+        return new CraftPlayerTextures(this);
-+    }
-+
-+    @Override
-+    public void setTextures(@Nullable PlayerTextures textures) {
-+        if (textures == null) {
-+            this.removeProperty("textures");
-+        } else {
-+            CraftPlayerTextures craftPlayerTextures = new CraftPlayerTextures(this);
-+            craftPlayerTextures.copyFrom(textures);
-+            craftPlayerTextures.rebuildPropertyIfDirty();
-+        }
-+    }
-+
-+    public GameProfile getGameProfile() {
-+        return profile;
-+    }
-+
-+    @Nullable
-+    @Override
-+    public UUID getId() {
-+        return profile.getId();
-+    }
-+
-+    @Override
-+    @Deprecated(forRemoval = true)
-+    public UUID setId(@Nullable UUID uuid) {
-+        GameProfile prev = this.profile;
-+        this.profile = new GameProfile(uuid, prev.getName());
-+        copyProfileProperties(prev, this.profile);
-+        return prev.getId();
-+    }
-+
-+    @Override
-+    public UUID getUniqueId() {
-+        return getId();
-+    }
-+
-+    @Nullable
-+    @Override
-+    public String getName() {
-+        return profile.getName();
-+    }
-+
-+    @Override
-+    @Deprecated(forRemoval = true)
-+    public String setName(@Nullable String name) {
-+        GameProfile prev = this.profile;
-+        this.profile = new GameProfile(prev.getId(), name);
-+        copyProfileProperties(prev, this.profile);
-+        return prev.getName();
-+    }
-+
-+    @Nonnull
-+    @Override
-+    public Set<ProfileProperty> getProperties() {
-+        return properties;
-+    }
-+
-+    @Override
-+    public void setProperties(Collection<ProfileProperty> properties) {
-+        properties.forEach(this::setProperty);
-+    }
-+
-+    @Override
-+    public void clearProperties() {
-+        profile.getProperties().clear();
-+    }
-+
-+    @Override
-+    public boolean removeProperty(String property) {
-+        return !profile.getProperties().removeAll(property).isEmpty();
-+    }
-+
-+    @Nullable
-+    @Override
-+    public Property getProperty(String property) {
-+        return Iterables.getFirst(this.profile.getProperties().get(property), null);
-+    }
-+
-+    @Nullable
-+    @Override
-+    public void setProperty(@NotNull String propertyName, @Nullable Property property) {
-+        PropertyMap properties = profile.getProperties();
-+        properties.removeAll(propertyName);
-+        if (property != null) {
-+            properties.put(propertyName, property);
-+        }
-+    }
-+
-+    @Override
-+    public @NotNull GameProfile buildGameProfile() {
-+        GameProfile profile = new GameProfile(this.profile.getId(), this.profile.getName());
-+        profile.getProperties().putAll(this.profile.getProperties());
-+        return profile;
-+    }
-+
-+    @Override
-+    public CraftPlayerProfile clone() {
-+        CraftPlayerProfile clone = new CraftPlayerProfile(this.getId(), this.getName());
-+        clone.setProperties(getProperties());
-+        return clone;
-+    }
-+
-+    @Override
-+    public boolean isComplete() {
-+        return profile.isComplete();
-+    }
-+
-+    @Override
-+    public @NotNull CompletableFuture<PlayerProfile> update() {
-+        return CompletableFuture.supplyAsync(() -> {
-+            final CraftPlayerProfile clone = clone();
-+            clone.complete(true);
-+            return clone;
-+        }, Util.PROFILE_EXECUTOR);
-+    }
-+
-+    @Override
-+    public boolean completeFromCache() {
-+        return completeFromCache(false, GlobalConfiguration.get().proxies.isProxyOnlineMode());
-+    }
-+
-+    public boolean completeFromCache(boolean onlineMode) {
-+        return completeFromCache(false, onlineMode);
-+    }
-+
-+    public boolean completeFromCache(boolean lookupUUID, boolean onlineMode) {
-+        MinecraftServer server = MinecraftServer.getServer();
-+        String name = profile.getName();
-+        GameProfileCache userCache = server.getProfileCache();
-+        if (profile.getId() == null) {
-+            final GameProfile profile;
-+            if (onlineMode) {
-+                profile = lookupUUID ? userCache.get(name).orElse(null) : userCache.getProfileIfCached(name);
-+            } else {
-+                // Make an OfflinePlayer using an offline mode UUID since the name has no profile
-+                profile = new GameProfile(UUID.nameUUIDFromBytes(("OfflinePlayer:" + name).getBytes(Charsets.UTF_8)), name);
-+            }
-+            if (profile != null) {
-+                // if old has it, assume its newer, so overwrite, else use cached if it was set and ours wasn't
-+                copyProfileProperties(this.profile, profile);
-+                this.profile = profile;
-+            }
-+        }
-+
-+        if ((profile.getName() == null || !hasTextures()) && profile.getId() != null) {
-+            Optional<GameProfile> optProfile = userCache.get(this.profile.getId());
-+            if (optProfile.isPresent()) {
-+                GameProfile profile = optProfile.get();
-+                if (this.profile.getName() == null) {
-+                    // if old has it, assume its newer, so overwrite, else use cached if it was set and ours wasn't
-+                    copyProfileProperties(this.profile, profile);
-+                    this.profile = profile;
-+                } else {
-+                    copyProfileProperties(profile, this.profile);
-+                }
-+            }
-+        }
-+        return this.profile.isComplete();
-+    }
-+
-+    public boolean complete(boolean textures) {
-+        return complete(textures, GlobalConfiguration.get().proxies.isProxyOnlineMode());
-+    }
-+    public boolean complete(boolean textures, boolean onlineMode) {
-+        MinecraftServer server = MinecraftServer.getServer();
-+        boolean isCompleteFromCache = this.completeFromCache(true, onlineMode);
-+        if (onlineMode && (!isCompleteFromCache || textures && !hasTextures())) {
-+            GameProfile result = server.getSessionService().fillProfileProperties(profile, true);
-+            if (result != null) {
-+                copyProfileProperties(result, this.profile, true);
-+            }
-+            if (this.profile.isComplete()) {
-+                server.getProfileCache().add(this.profile);
-+            }
-+        }
-+        return profile.isComplete() && (!onlineMode || !textures || hasTextures());
-+    }
-+
-+    private static void copyProfileProperties(GameProfile source, GameProfile target) {
-+        copyProfileProperties(source, target, false);
-+    }
-+
-+    private static void copyProfileProperties(GameProfile source, GameProfile target, boolean clearTarget) {
-+        PropertyMap sourceProperties = source.getProperties();
-+        PropertyMap targetProperties = target.getProperties();
-+        if (clearTarget) targetProperties.clear();
-+        if (sourceProperties.isEmpty()) {
-+            return;
-+        }
-+
-+        for (Property property : sourceProperties.values()) {
-+            targetProperties.removeAll(property.getName());
-+            targetProperties.put(property.getName(), property);
-+        }
-+    }
-+
-+    private static ProfileProperty toBukkit(Property property) {
-+        return new ProfileProperty(property.getName(), property.getValue(), property.getSignature());
-+    }
-+
-+    public static PlayerProfile asBukkitCopy(GameProfile gameProfile) {
-+        CraftPlayerProfile profile = new CraftPlayerProfile(gameProfile.getId(), gameProfile.getName());
-+        copyProfileProperties(gameProfile, profile.profile);
-+        return profile;
-+    }
-+
-+    public static PlayerProfile asBukkitMirror(GameProfile profile) {
-+        return new CraftPlayerProfile(profile);
-+    }
-+
-+    public static Property asAuthlib(ProfileProperty property) {
-+        return new Property(property.getName(), property.getValue(), property.getSignature());
-+    }
-+
-+    public static GameProfile asAuthlibCopy(PlayerProfile profile) {
-+        CraftPlayerProfile craft = ((CraftPlayerProfile) profile);
-+        return asAuthlib(craft.clone());
-+    }
-+
-+    public static GameProfile asAuthlib(PlayerProfile profile) {
-+        CraftPlayerProfile craft = ((CraftPlayerProfile) profile);
-+        return craft.getGameProfile();
-+    }
-+
-+    @Override
-+    public @NotNull Map<String, Object> serialize() {
-+        Map<String, Object> map = new LinkedHashMap<>();
-+        if (this.getId() != null) {
-+            map.put("uniqueId", this.getId().toString());
-+        }
-+        if (this.getName() != null) {
-+            map.put("name", getName());
-+        }
-+        if (!this.properties.isEmpty()) {
-+            List<Object> propertiesData = new ArrayList<>();
-+            for (ProfileProperty property : properties) {
-+                propertiesData.add(CraftProfileProperty.serialize(new Property(property.getName(), property.getValue(), property.getSignature())));
-+            }
-+            map.put("properties", propertiesData);
-+        }
-+        return map;
-+    }
-+
-+    public static CraftPlayerProfile deserialize(Map<String, Object> map) {
-+        UUID uniqueId = ConfigSerializationUtil.getUuid(map, "uniqueId", true);
-+        String name = ConfigSerializationUtil.getString(map, "name", true);
-+
-+        // This also validates the deserialized unique id and name (ensures that not both are null):
-+        CraftPlayerProfile profile = new CraftPlayerProfile(uniqueId, name);
-+
-+        if (map.containsKey("properties")) {
-+            for (Object propertyData : (List<?>) map.get("properties")) {
-+                if (!(propertyData instanceof Map)) {
-+                    throw new IllegalArgumentException("Property data (" + propertyData + ") is not a valid Map");
-+                }
-+                Property property = CraftProfileProperty.deserialize((Map<?, ?>) propertyData);
-+                profile.profile.getProperties().put(property.getName(), property);
-+            }
-+        }
-+
-+        return profile;
-+    }
-+
-+    @Override
-+    public boolean equals(Object obj) {
-+        if (this == obj) return true;
-+        if (!(obj instanceof CraftPlayerProfile otherProfile)) return false;
-+        return Objects.equals(this.profile, otherProfile.profile);
-+    }
-+
-+    @Override
-+    public String toString() {
-+        return "CraftPlayerProfile [uniqueId=" + getId() +
-+            ", name=" + getName() +
-+            ", properties=" + org.bukkit.craftbukkit.profile.CraftPlayerProfile.toString(this.profile.getProperties()) +
-+            "]";
-+    }
-+
-+    @Override
-+    public int hashCode() {
-+        return this.profile.hashCode();
-+    }
-+
-+    private class PropertySet extends AbstractSet<ProfileProperty> {
-+
-+        @Override
-+        @Nonnull
-+        public Iterator<ProfileProperty> iterator() {
-+            return new ProfilePropertyIterator(profile.getProperties().values().iterator());
-+        }
-+
-+        @Override
-+        public int size() {
-+            return profile.getProperties().size();
-+        }
-+
-+        @Override
-+        public boolean add(ProfileProperty property) {
-+            setProperty(property);
-+            return true;
-+        }
-+
-+        @Override
-+        public boolean addAll(Collection<? extends ProfileProperty> c) {
-+            //noinspection unchecked
-+            setProperties((Collection<ProfileProperty>) c);
-+            return true;
-+        }
-+
-+        @Override
-+        public boolean contains(Object o) {
-+            return o instanceof ProfileProperty && profile.getProperties().containsKey(((ProfileProperty) o).getName());
-+        }
-+
-+        private class ProfilePropertyIterator implements Iterator<ProfileProperty> {
-+            private final Iterator<Property> iterator;
-+
-+            ProfilePropertyIterator(Iterator<Property> iterator) {
-+                this.iterator = iterator;
-+            }
-+
-+            @Override
-+            public boolean hasNext() {
-+                return iterator.hasNext();
-+            }
-+
-+            @Override
-+            public ProfileProperty next() {
-+                return toBukkit(iterator.next());
-+            }
-+
-+            @Override
-+            public void remove() {
-+                iterator.remove();
-+            }
-+        }
-+    }
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/profile/PaperAuthenticationService.java b/src/main/java/com/destroystokyo/paper/profile/PaperAuthenticationService.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/profile/PaperAuthenticationService.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.profile;
-+
-+import com.mojang.authlib.*;
-+import com.mojang.authlib.minecraft.MinecraftSessionService;
-+import com.mojang.authlib.yggdrasil.YggdrasilAuthenticationService;
-+import com.mojang.authlib.yggdrasil.YggdrasilEnvironment;
-+
-+import java.net.Proxy;
-+
-+public class PaperAuthenticationService extends YggdrasilAuthenticationService {
-+    private final Environment environment;
-+    public PaperAuthenticationService(Proxy proxy) {
-+        super(proxy);
-+        this.environment = EnvironmentParser.getEnvironmentFromProperties().orElse(YggdrasilEnvironment.PROD.getEnvironment());
-+    }
-+
-+    @Override
-+    public UserAuthentication createUserAuthentication(Agent agent) {
-+        return new PaperUserAuthentication(this, agent);
-+    }
-+
-+    @Override
-+    public MinecraftSessionService createMinecraftSessionService() {
-+        return new PaperMinecraftSessionService(this, this.environment);
-+    }
-+
-+    @Override
-+    public GameProfileRepository createProfileRepository() {
-+        return new PaperGameProfileRepository(this, this.environment);
-+    }
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/profile/PaperGameProfileRepository.java b/src/main/java/com/destroystokyo/paper/profile/PaperGameProfileRepository.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/profile/PaperGameProfileRepository.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.profile;
-+
-+import com.mojang.authlib.Agent;
-+import com.mojang.authlib.Environment;
-+import com.mojang.authlib.ProfileLookupCallback;
-+import com.mojang.authlib.yggdrasil.YggdrasilAuthenticationService;
-+import com.mojang.authlib.yggdrasil.YggdrasilGameProfileRepository;
-+
-+public class PaperGameProfileRepository extends YggdrasilGameProfileRepository {
-+    public PaperGameProfileRepository(YggdrasilAuthenticationService authenticationService, Environment environment) {
-+        super(authenticationService, environment);
-+    }
-+
-+    @Override
-+    public void findProfilesByNames(String[] names, Agent agent, ProfileLookupCallback callback) {
-+        super.findProfilesByNames(names, agent, callback);
-+    }
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/profile/PaperMinecraftSessionService.java b/src/main/java/com/destroystokyo/paper/profile/PaperMinecraftSessionService.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/profile/PaperMinecraftSessionService.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.profile;
-+
-+import com.mojang.authlib.Environment;
-+import com.mojang.authlib.GameProfile;
-+import com.mojang.authlib.minecraft.MinecraftProfileTexture;
-+import com.mojang.authlib.yggdrasil.YggdrasilAuthenticationService;
-+import com.mojang.authlib.yggdrasil.YggdrasilMinecraftSessionService;
-+
-+import java.util.Map;
-+
-+public class PaperMinecraftSessionService extends YggdrasilMinecraftSessionService {
-+    protected PaperMinecraftSessionService(YggdrasilAuthenticationService authenticationService, Environment environment) {
-+        super(authenticationService, environment);
-+    }
-+
-+    @Override
-+    public Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> getTextures(GameProfile profile, boolean requireSecure) {
-+        return super.getTextures(profile, requireSecure);
-+    }
-+
-+    @Override
-+    public GameProfile fillProfileProperties(GameProfile profile, boolean requireSecure) {
-+        return super.fillProfileProperties(profile, requireSecure);
-+    }
-+
-+    @Override
-+    protected GameProfile fillGameProfile(GameProfile profile, boolean requireSecure) {
-+        return super.fillGameProfile(profile, requireSecure);
-+    }
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/profile/PaperUserAuthentication.java b/src/main/java/com/destroystokyo/paper/profile/PaperUserAuthentication.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/profile/PaperUserAuthentication.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.profile;
-+
-+import com.mojang.authlib.Agent;
-+import com.mojang.authlib.yggdrasil.YggdrasilAuthenticationService;
-+import com.mojang.authlib.yggdrasil.YggdrasilUserAuthentication;
-+import java.util.UUID;
-+
-+public class PaperUserAuthentication extends YggdrasilUserAuthentication {
-+    public PaperUserAuthentication(YggdrasilAuthenticationService authenticationService, Agent agent) {
-+        super(authenticationService, UUID.randomUUID().toString(), agent);
-+    }
-+}
-diff --git a/src/main/java/com/destroystokyo/paper/profile/SharedPlayerProfile.java b/src/main/java/com/destroystokyo/paper/profile/SharedPlayerProfile.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/com/destroystokyo/paper/profile/SharedPlayerProfile.java
-@@ -0,0 +0,0 @@
-+package com.destroystokyo.paper.profile;
-+
-+import com.mojang.authlib.GameProfile;
-+import com.mojang.authlib.properties.Property;
-+import org.jetbrains.annotations.NotNull;
-+import org.jetbrains.annotations.Nullable;
-+
-+import java.util.UUID;
-+
-+public interface SharedPlayerProfile {
-+
-+    @Nullable UUID getUniqueId();
-+
-+    @Nullable String getName();
-+
-+    boolean removeProperty(@NotNull String property);
-+
-+    @Nullable Property getProperty(@NotNull String propertyName);
-+
-+    @Nullable void setProperty(@NotNull String propertyName, @Nullable Property property);
-+
-+    @NotNull GameProfile buildGameProfile();
-+}
-diff --git a/src/main/java/net/minecraft/server/MCUtil.java b/src/main/java/net/minecraft/server/MCUtil.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/MCUtil.java
-+++ b/src/main/java/net/minecraft/server/MCUtil.java
-@@ -0,0 +0,0 @@
- package net.minecraft.server;
- 
-+import com.destroystokyo.paper.profile.CraftPlayerProfile;
-+import com.destroystokyo.paper.profile.PlayerProfile;
- import com.google.common.util.concurrent.ThreadFactoryBuilder;
- import it.unimi.dsi.fastutil.objects.ObjectRBTreeSet;
- import java.lang.ref.Cleaner;
-@@ -0,0 +0,0 @@ import net.minecraft.world.level.ChunkPos;
- import net.minecraft.world.level.ClipContext;
- import net.minecraft.world.level.Level;
- import org.apache.commons.lang.exception.ExceptionUtils;
-+import com.mojang.authlib.GameProfile;
- import org.bukkit.Location;
- import org.bukkit.block.BlockFace;
- import org.bukkit.craftbukkit.CraftWorld;
-@@ -0,0 +0,0 @@ public final class MCUtil {
-         return run.get();
-     }
- 
-+    public static PlayerProfile toBukkit(GameProfile profile) {
-+        return CraftPlayerProfile.asBukkitMirror(profile);
-+    }
-+
-     /**
-      * Calculates distance between 2 entities
-      * @param e1
-diff --git a/src/main/java/net/minecraft/server/Main.java b/src/main/java/net/minecraft/server/Main.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/Main.java
-+++ b/src/main/java/net/minecraft/server/Main.java
-@@ -0,0 +0,0 @@ public class Main {
-             }
- 
-             File file = (File) optionset.valueOf("universe"); // CraftBukkit
--            Services services = Services.create(new YggdrasilAuthenticationService(Proxy.NO_PROXY), file, optionset); // Paper
-+            Services services = Services.create(new com.destroystokyo.paper.profile.PaperAuthenticationService(Proxy.NO_PROXY), file, optionset); // Paper
-             // CraftBukkit start
-             String s = (String) Optional.ofNullable((String) optionset.valueOf("world")).orElse(dedicatedserversettings.getProperties().levelName);
-             LevelStorageSource convertable = LevelStorageSource.createDefault(file.toPath());
-diff --git a/src/main/java/net/minecraft/server/players/GameProfileCache.java b/src/main/java/net/minecraft/server/players/GameProfileCache.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/players/GameProfileCache.java
-+++ b/src/main/java/net/minecraft/server/players/GameProfileCache.java
-@@ -0,0 +0,0 @@ public class GameProfileCache {
-         return this.operationCount.incrementAndGet();
-     }
- 
-+    // Paper start
-+    public @Nullable GameProfile getProfileIfCached(String name) {
-+        GameProfileCache.GameProfileInfo entry = this.profilesByName.get(name.toLowerCase(Locale.ROOT));
-+        if (entry == null) {
-+            return null;
-+        }
-+        entry.setLastAccess(this.getNextOperation());
-+        return entry.getProfile();
-+    }
-+    // Paper end
-+
-     public Optional<GameProfile> get(String name) {
-         String s1 = name.toLowerCase(Locale.ROOT);
-         GameProfileCache.GameProfileInfo usercache_usercacheentry = (GameProfileCache.GameProfileInfo) this.profilesByName.get(s1);
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ import org.yaml.snakeyaml.error.MarkedYAMLException;
- 
- import net.md_5.bungee.api.chat.BaseComponent; // Spigot
- 
-+import javax.annotation.Nullable; // Paper
-+import javax.annotation.Nonnull; // Paper
-+
- public final class CraftServer implements Server {
-     private final String serverName = "Paper"; // Paper
-     private final String serverVersion;
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-     static {
-         ConfigurationSerialization.registerClass(CraftOfflinePlayer.class);
-         ConfigurationSerialization.registerClass(CraftPlayerProfile.class);
-+        ConfigurationSerialization.registerClass(com.destroystokyo.paper.profile.CraftPlayerProfile.class); // Paper
-         CraftItemFactory.instance();
-     }
- 
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-     public boolean suggestPlayerNamesWhenNullTabCompletions() {
-         return io.papermc.paper.configuration.GlobalConfiguration.get().commands.suggestPlayerNamesWhenNullTabCompletions;
-     }
-+
-+    @Override
-+    public com.destroystokyo.paper.profile.PlayerProfile createProfile(@Nonnull UUID uuid) {
-+        return createProfile(uuid, null);
-+    }
-+
-+    @Override
-+    public com.destroystokyo.paper.profile.PlayerProfile createProfile(@Nonnull String name) {
-+        return createProfile(null, name);
-+    }
-+
-+    @Override
-+    public com.destroystokyo.paper.profile.PlayerProfile createProfile(@Nullable UUID uuid, @Nullable String name) {
-+        Player player = uuid != null ? Bukkit.getPlayer(uuid) : (name != null ? Bukkit.getPlayerExact(name) : null);
-+        if (player != null) return new com.destroystokyo.paper.profile.CraftPlayerProfile((CraftPlayer) player);
-+
-+        return new com.destroystokyo.paper.profile.CraftPlayerProfile(uuid, name);
-+    }
-+
-+    @Override
-+    public com.destroystokyo.paper.profile.PlayerProfile createProfileExact(@Nullable UUID uuid, @Nullable String name) {
-+        Player player = uuid != null ? Bukkit.getPlayer(uuid) : (name != null ? Bukkit.getPlayerExact(name) : null);
-+        if (player == null) return new com.destroystokyo.paper.profile.CraftPlayerProfile(uuid, name);
-+
-+        if (Objects.equals(uuid, player.getUniqueId()) && Objects.equals(name, player.getName())) {
-+            return new com.destroystokyo.paper.profile.CraftPlayerProfile((CraftPlayer) player);
-+        }
-+
-+        final com.mojang.authlib.GameProfile profile = new com.mojang.authlib.GameProfile(uuid, name);
-+        profile.getProperties().putAll(((CraftPlayer)player).getHandle().getGameProfile().getProperties());
-+        return new com.destroystokyo.paper.profile.CraftPlayerProfile(profile);
-+    }
-     // Paper end
- }
-diff --git a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
-+++ b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
-@@ -0,0 +0,0 @@ import org.bukkit.profile.PlayerProfile;
- import org.bukkit.profile.PlayerTextures;
- 
- @SerializableAs("PlayerProfile")
--public final class CraftPlayerProfile implements PlayerProfile {
-+public final class CraftPlayerProfile implements PlayerProfile, com.destroystokyo.paper.profile.SharedPlayerProfile { // Paper
- 
-     @Nonnull
-     public static GameProfile validateSkullProfile(@Nonnull GameProfile gameProfile) {
-@@ -0,0 +0,0 @@ public final class CraftPlayerProfile implements PlayerProfile {
-         }
-     }
- 
--    void removeProperty(String propertyName) {
--        this.properties.removeAll(propertyName);
-+    // Paper start - change return value for shared interface
-+    public boolean removeProperty(String propertyName) {
-+        return !this.properties.removeAll(propertyName).isEmpty();
-+        // Paper end
-     }
- 
-     void rebuildDirtyProperties() {
-@@ -0,0 +0,0 @@ public final class CraftPlayerProfile implements PlayerProfile {
- 
-     @Override
-     public Map<String, Object> serialize() {
-+        // Paper - diff on change
-         Map<String, Object> map = new LinkedHashMap<>();
-         if (this.uniqueId != null) {
-             map.put("uniqueId", this.uniqueId.toString());
-@@ -0,0 +0,0 @@ public final class CraftPlayerProfile implements PlayerProfile {
-             });
-             map.put("properties", propertiesData);
-         }
-+        // Paper - diff on change
-         return map;
-     }
- 
-     public static CraftPlayerProfile deserialize(Map<String, Object> map) {
-+        // Paper - diff on change
-         UUID uniqueId = ConfigSerializationUtil.getUuid(map, "uniqueId", true);
-         String name = ConfigSerializationUtil.getString(map, "name", true);
- 
-@@ -0,0 +0,0 @@ public final class CraftPlayerProfile implements PlayerProfile {
-                 profile.properties.put(property.getName(), property);
-             }
-         }
--
-+        // Paper - diff on change
-         return profile;
-     }
- }
-diff --git a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerTextures.java b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerTextures.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerTextures.java
-+++ b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerTextures.java
-@@ -0,0 +0,0 @@ public final class CraftPlayerTextures implements PlayerTextures {
-         }
-     }
- 
--    private final CraftPlayerProfile profile;
-+    private final com.destroystokyo.paper.profile.SharedPlayerProfile profile; // Paper
- 
-     // The textures data is loaded lazily:
-     private boolean loaded = false;
-@@ -0,0 +0,0 @@ public final class CraftPlayerTextures implements PlayerTextures {
-     // GameProfiles (even if these modifications are later reverted).
-     private boolean dirty = false;
- 
--    CraftPlayerTextures(@Nonnull CraftPlayerProfile profile) {
-+    public CraftPlayerTextures(@Nonnull com.destroystokyo.paper.profile.SharedPlayerProfile profile) { // Paper
-         this.profile = profile;
-     }
- 

patches/unapplied/server/Block-Enderpearl-Travel-Exploit.patch

@@ -1,42 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Mon, 30 Apr 2018 17:15:26 -0400
-Subject: [PATCH] Block Enderpearl Travel Exploit
-
-Players are able to use alt accounts and enderpearls to travel
-long distances utilizing the pearls in unloaded chunks and loading
-the chunk later when convenient.
-
-This disables that by not saving the thrower when the chunk is unloaded.
-
-This is mainly useful for survival servers that do not allow freeform teleporting.
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
- 
-         public void onTickingEnd(Entity entity) {
-             ServerLevel.this.entityTickList.remove(entity);
-+            // Paper start - Reset pearls when they stop being ticked
-+            if (paperConfig().fixes.disableUnloadedChunkEnderpearlExploit && entity instanceof net.minecraft.world.entity.projectile.ThrownEnderpearl pearl) {
-+                pearl.cachedOwner = null;
-+                pearl.ownerUUID = null;
-+            }
-+            // Paper end
-         }
- 
-         public void onTrackingStart(Entity entity) {
-diff --git a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
-@@ -0,0 +0,0 @@ public abstract class Projectile extends Entity {
-     protected void readAdditionalSaveData(CompoundTag nbt) {
-         if (nbt.hasUUID("Owner")) {
-             this.ownerUUID = nbt.getUUID("Owner");
-+            if (this instanceof ThrownEnderpearl && this.level != null && this.level.paperConfig().fixes.disableUnloadedChunkEnderpearlExploit) { this.ownerUUID = null; } // Paper - Don't store shooter name for pearls to block enderpearl travel exploit
-         }
- 
-         this.leftOwner = nbt.getBoolean("LeftOwner");

patches/unapplied/server/Block-Entity-remove-from-being-called-on-Players.patch

@@ -1,33 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Zach Brown <1254957+zachbr@users.noreply.github.com>
-Date: Mon, 4 Feb 2019 23:33:24 -0500
-Subject: [PATCH] Block Entity#remove from being called on Players
-
-This doesn't result in the same behavior as other entities and causes
-several problems. Anyone ever complain about the "Cannot send chat
-message" thing? That's one of the issues this causes, among others.
-
-If a plugin developer can come up with a valid reason to call this on a
-Player we will look at limiting the scope of this change. It appears to
-be unintentional in the few cases we've seen so far.
-
-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 {
-     public void resetCooldown() {
-         getHandle().resetAttackStrengthTicker();
-     }
-+
-+    @Override
-+    public void remove() {
-+        if (this.getHandle().getClass().equals(ServerPlayer.class)) { // special case for NMS plugins inheriting
-+            throw new UnsupportedOperationException("Calling Entity#remove on players produces undefined (bad) behavior");
-+        } else {
-+            super.remove();
-+        }
-+    }
-     // Paper end
-     // Spigot start
-     private final Player.Spigot spigot = new Player.Spigot()

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

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

patches/unapplied/server/BlockDestroyEvent.patch

@@ -1,46 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Wed, 6 Feb 2019 00:20:33 -0500
-Subject: [PATCH] BlockDestroyEvent
-
-Adds an event for when the server is going to destroy a current block,
-potentially causing it to drop. This event can be cancelled to avoid
-the block destruction, such as preventing signs from popping when
-floating in the air.
-
-This can replace many uses of BlockPhysicsEvent
-
-diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/Level.java
-+++ b/src/main/java/net/minecraft/world/level/Level.java
-@@ -0,0 +0,0 @@ import net.minecraft.nbt.CompoundTag;
- import net.minecraft.network.protocol.Packet;
- import net.minecraft.resources.ResourceKey;
- import net.minecraft.resources.ResourceLocation;
-+import net.minecraft.server.MCUtil;
- import net.minecraft.server.MinecraftServer;
- import net.minecraft.server.level.ChunkHolder;
- import net.minecraft.server.level.ServerLevel;
-@@ -0,0 +0,0 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
-             return false;
-         } else {
-             FluidState fluid = this.getFluidState(pos);
-+            // Paper start - while the above setAir method is named same and looks very similar
-+            // they are NOT used with same intent and the above should not fire this event. The above method is more of a BlockSetToAirEvent,
-+            // it doesn't imply destruction of a block that plays a sound effect / drops an item.
-+            boolean playEffect = true;
-+            if (com.destroystokyo.paper.event.block.BlockDestroyEvent.getHandlerList().getRegisteredListeners().length > 0) {
-+                com.destroystokyo.paper.event.block.BlockDestroyEvent event = new com.destroystokyo.paper.event.block.BlockDestroyEvent(MCUtil.toBukkitBlock(this, pos), fluid.createLegacyBlock().createCraftBlockData(), drop);
-+                if (!event.callEvent()) {
-+                    return false;
-+                }
-+                playEffect = event.playEffect();
-+            }
-+            // Paper end
- 
--            if (!(iblockdata.getBlock() instanceof BaseFireBlock)) {
-+            if (playEffect && !(iblockdata.getBlock() instanceof BaseFireBlock)) { // Paper
-                 this.levelEvent(2001, pos, Block.getId(iblockdata));
-             }
- 

patches/unapplied/server/Book-Size-Limits.patch

@@ -1,57 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Fri, 16 Nov 2018 23:08:50 -0500
-Subject: [PATCH] Book Size Limits
-
-Puts some limits on the size of books.
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
- 
-     @Override
-     public void handleEditBook(ServerboundEditBookPacket packet) {
-+        // Paper start
-+        if (!this.cserver.isPrimaryThread()) {
-+            List<String> pageList = packet.getPages();
-+            long byteTotal = 0;
-+            int maxBookPageSize = io.papermc.paper.configuration.GlobalConfiguration.get().itemValidation.bookSize.pageMax;
-+            double multiplier = Math.max(0.3D, Math.min(1D, io.papermc.paper.configuration.GlobalConfiguration.get().itemValidation.bookSize.totalMultiplier));
-+            long byteAllowed = maxBookPageSize;
-+            for (String testString : pageList) {
-+                int byteLength = testString.getBytes(java.nio.charset.StandardCharsets.UTF_8).length;
-+                if (byteLength > 256 * 4) {
-+                    ServerGamePacketListenerImpl.LOGGER.warn(this.player.getScoreboardName() + " tried to send a book with with a page too large!");
-+                    server.scheduleOnMain(() -> this.disconnect("Book too large!"));
-+                    return;
-+                }
-+                byteTotal += byteLength;
-+                int length = testString.length();
-+                int multibytes = 0;
-+                if (byteLength != length) {
-+                    for (char c : testString.toCharArray()) {
-+                        if (c > 127) {
-+                            multibytes++;
-+                        }
-+                    }
-+                }
-+                byteAllowed += (maxBookPageSize * Math.min(1, Math.max(0.1D, (double) length / 255D))) * multiplier;
-+
-+                if (multibytes > 1) {
-+                    // penalize MB
-+                    byteAllowed -= multibytes;
-+                }
-+            }
-+
-+            if (byteTotal > byteAllowed) {
-+                ServerGamePacketListenerImpl.LOGGER.warn(this.player.getScoreboardName() + " tried to send too large of a book. Book Size: " + byteTotal + " - Allowed:  "+ byteAllowed + " - Pages: " + pageList.size());
-+                server.scheduleOnMain(() -> this.disconnect("Book too large!"));
-+                return;
-+            }
-+        }
-+        // Paper end
-         // CraftBukkit start
-         if (this.lastBookTick + 20 > MinecraftServer.currentTick) {
-             this.disconnect("Book edited too quickly!");

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

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

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

@@ -1,52 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Shane Freeder <theboyetronic@gmail.com>
-Date: Sun, 29 Jul 2018 05:02:15 +0100
-Subject: [PATCH] Break up and make tab spam limits configurable
-
-Due to the changes in 1.13, clients will send a tab completion request
-for all bukkit commands in order to factor in the lack of support for
-brigadier and provide backwards support in the API.
-
-Craftbukkit, however; has moved the chat spam limiter to also interact
-with the tab completion request, which while good for avoiding abuse,
-causes 1.13 clients to easilly be kicked from a server in bukkit due
-to this. Removing the spam limit could cause issues for servers, however,
-there is no way for servers to manipulate this without blindly cancelling
-kick events, which only causes additional complications. This also causes
-issues in that the tab spam limit and chat share the same field but different
-limits, meaning that a player having typed a long command may be kicked from
-the server.
-
-Splitting the field up and making it configurable allows for server owners
-to take the burden of this into their own hand without having to rely on
-plugins doing unsafe things.
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
-     private long keepAliveChallenge;
-     // CraftBukkit start - multithreaded fields
-     private final AtomicInteger chatSpamTickCount = new AtomicInteger();
-+    private final java.util.concurrent.atomic.AtomicInteger tabSpamLimiter = new java.util.concurrent.atomic.AtomicInteger(); // Paper - configurable tab spam limits
-     // CraftBukkit end
-     private int dropSpamTickCount;
-     private double firstGoodX;
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
-         this.server.getProfiler().pop();
-         // CraftBukkit start
-         for (int spam; (spam = this.chatSpamTickCount.get()) > 0 && !this.chatSpamTickCount.compareAndSet(spam, spam - 1); ) ;
-+        if (tabSpamLimiter.get() > 0) tabSpamLimiter.getAndDecrement(); // Paper - split to seperate variable
-         /* Use thread-safe field access instead
-         if (this.chatSpamTickCount > 0) {
-             --this.chatSpamTickCount;
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
-     public void handleCustomCommandSuggestions(ServerboundCommandSuggestionPacket packet) {
-         // PacketUtils.ensureRunningOnSameThread(packet, this, this.player.getLevel()); // Paper - run this async
-         // CraftBukkit start
--        if (this.chatSpamTickCount.addAndGet(1) > 500 && !this.server.getPlayerList().isOp(this.player.getGameProfile())) {
-+        if (this.chatSpamTickCount.addAndGet(io.papermc.paper.configuration.GlobalConfiguration.get().spamLimiter.tabSpamIncrement) > io.papermc.paper.configuration.GlobalConfiguration.get().spamLimiter.tabSpamLimit && !this.server.getPlayerList().isOp(this.player.getGameProfile())) { // Paper start - split and make configurable
-             server.scheduleOnMain(() -> this.disconnect(Component.translatable("disconnect.spam", new Object[0]))); // Paper
-             return;
-         }

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

@@ -1,73 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Alfie Cleveland <alfeh@me.com>
-Date: Fri, 25 Nov 2016 13:22:40 +0000
-Subject: [PATCH] Cache user authenticator threads
-
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener
- 
-     }
- 
-+    // Paper start - Cache authenticator threads
-+    private static final AtomicInteger threadId = new AtomicInteger(0);
-+    private static final java.util.concurrent.ExecutorService authenticatorPool = java.util.concurrent.Executors.newCachedThreadPool(
-+            r -> {
-+                Thread ret = new Thread(r, "User Authenticator #" + threadId.incrementAndGet());
-+
-+                ret.setUncaughtExceptionHandler(new DefaultUncaughtExceptionHandler(LOGGER));
-+
-+                return ret;
-+            }
-+    );
-+    // Paper end
-     // Spigot start
-     public void initUUID()
-     {
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener
-                 this.connection.send(new ClientboundHelloPacket("", this.server.getKeyPair().getPublic().getEncoded(), this.nonce));
-             } else {
-                 // Spigot start
--                new Thread("User Authenticator #" + ServerLoginPacketListenerImpl.UNIQUE_THREAD_ID.incrementAndGet()) {
--
-+            // Paper start - Cache authenticator threads
-+            authenticatorPool.execute(new Runnable() {
-                     @Override
-                     public void run() {
-                         try {
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener
-                             server.server.getLogger().log(java.util.logging.Level.WARNING, "Exception verifying " + ServerLoginPacketListenerImpl.this.gameProfile.getName(), ex);
-                         }
-                     }
--                }.start();
-+            });
-+            // Paper end
-                 // Spigot end
-             }
- 
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener
-             throw new IllegalStateException("Protocol error", cryptographyexception);
-         }
- 
--        Thread thread = new Thread("User Authenticator #" + ServerLoginPacketListenerImpl.UNIQUE_THREAD_ID.incrementAndGet()) {
-+        // Paper start - Cache authenticator threads
-+        authenticatorPool.execute(new Runnable() {
-             public void run() {
-                 GameProfile gameprofile = ServerLoginPacketListenerImpl.this.gameProfile;
- 
-@@ -0,0 +0,0 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener
- 
-                 return ServerLoginPacketListenerImpl.this.server.getPreventProxyConnections() && socketaddress instanceof InetSocketAddress ? ((InetSocketAddress) socketaddress).getAddress() : null;
-             }
--        };
--
--        thread.setUncaughtExceptionHandler(new DefaultUncaughtExceptionHandler(ServerLoginPacketListenerImpl.LOGGER));
--        thread.start();
-+        });
-+        // Paper end
-     }
- 
-     // Spigot start

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

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

patches/unapplied/server/Call-WhitelistToggleEvent-when-whitelist-is-toggled.patch

@@ -1,18 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Mark Vainomaa <mikroskeem@mikroskeem.eu>
-Date: Wed, 13 Mar 2019 20:08:09 +0200
-Subject: [PATCH] Call WhitelistToggleEvent when whitelist is toggled
-
-
-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 setUsingWhiteList(boolean whitelistEnabled) {
-+        new com.destroystokyo.paper.event.server.WhitelistToggleEvent(whitelistEnabled).callEvent();
-         this.doWhiteList = whitelistEnabled;
-     }
- 

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

@@ -1,87 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Caleb Bassham <caleb.bassham@gmail.com>
-Date: Fri, 28 Sep 2018 02:32:19 -0500
-Subject: [PATCH] Call player spectator target events and improve
- implementation
-
-Use a proper teleport for teleporting to entities in different
-worlds.
-
-Implementation improvements authored by Spottedleaf <Spottedleaf@users.noreply.github.com>
-Validate that the target entity is valid and deny spectate
-requests from frozen players.
-
-Also, make sure the entity is spawned to the client before
-sending the camera packet. If the entity isn't spawned clientside
-when it receives the camera packet, then the client will not
-spectate the target entity.
-
-Co-authored-by: Spottedleaf <Spottedleaf@users.noreply.github.com>
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
-     }
- 
-     public void setCamera(@Nullable Entity entity) {
-+        // Paper start - Add PlayerStartSpectatingEntityEvent and PlayerStopSpectatingEntity Event and improve implementation
-         Entity entity1 = this.getCamera();
- 
--        this.camera = (Entity) (entity == null ? this : entity);
--        if (entity1 != this.camera) {
--            this.connection.send(new ClientboundSetCameraPacket(this.camera));
--            this.connection.teleport(this.camera.getX(), this.camera.getY(), this.camera.getZ(), this.getYRot(), this.getXRot(), TeleportCause.SPECTATE); // CraftBukkit
-+        if (entity == null) {
-+            entity = this;
-+        }
-+
-+        if (entity1 == entity) return; // new spec target is the current spec target
-+
-+        if (entity == this) {
-+            com.destroystokyo.paper.event.player.PlayerStopSpectatingEntityEvent playerStopSpectatingEntityEvent = new com.destroystokyo.paper.event.player.PlayerStopSpectatingEntityEvent(this.getBukkitEntity(), entity1.getBukkitEntity());
-+
-+            if (!playerStopSpectatingEntityEvent.callEvent()) {
-+                return;
-+            }
-+        } else {
-+            com.destroystokyo.paper.event.player.PlayerStartSpectatingEntityEvent playerStartSpectatingEntityEvent = new com.destroystokyo.paper.event.player.PlayerStartSpectatingEntityEvent(this.getBukkitEntity(), entity1.getBukkitEntity(), entity.getBukkitEntity());
-+
-+            if (!playerStartSpectatingEntityEvent.callEvent()) {
-+                return;
-+            }
-+        }
-+        // Validate
-+        if (entity != this) {
-+            if (entity.isRemoved() || !entity.valid || entity.level == null) {
-+                MinecraftServer.LOGGER.info("Blocking player " + this + " from spectating invalid entity " + entity);
-+                return;
-+            }
-+            if (this.isImmobile()) {
-+                // use debug: clients might maliciously spam this
-+                MinecraftServer.LOGGER.debug("Blocking frozen player " + this + " from spectating entity " + entity);
-+                return;
-+            }
-         }
- 
-+        this.camera = entity; // only set after validating state
-+
-+        if (entity != this) {
-+            // Make sure we're in the right place
-+            this.ejectPassengers(); // teleport can fail if we have passengers...
-+            this.getBukkitEntity().teleport(new Location(entity.getCommandSenderWorld().getWorld(), entity.getX(), entity.getY(), entity.getZ(), this.getYRot(), this.getXRot()), TeleportCause.SPECTATE); // Correctly handle cross-world entities from api calls by using CB teleport
-+
-+            // Make sure we're tracking the entity before sending
-+            ChunkMap.TrackedEntity tracker = ((ServerLevel)entity.level).getChunkSource().chunkMap.entityMap.get(entity.getId());
-+            if (tracker != null) { // dumb plugins...
-+                tracker.updatePlayer(this);
-+            }
-+        } else {
-+            this.connection.teleport(this.camera.getX(), this.camera.getY(), this.camera.getZ(), this.getYRot(), this.getXRot(), TeleportCause.SPECTATE); // CraftBukkit
-+        }
-+        this.connection.send(new ClientboundSetCameraPacket(entity));
-+        // Paper end
-     }
- 
-     @Override

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

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

patches/unapplied/server/Catch-JsonParseException-in-Entity-and-TE-names.patch

@@ -1,114 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Zach Brown <1254957+zachbr@users.noreply.github.com>
-Date: Sat, 22 Sep 2018 15:56:59 -0400
-Subject: [PATCH] Catch JsonParseException in Entity and TE names
-
-As a result, data that no longer parses correctly will not crash the server
-instead just logging the exception and continuing (and in most cases should
-fix the data)
-
-Player data is fixed pretty much immediately but some block data (like
-Shulkers) may need to be changed in order for it to re-save properly
-
-No more crashing though.
-
-diff --git a/src/main/java/net/minecraft/server/MCUtil.java b/src/main/java/net/minecraft/server/MCUtil.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/MCUtil.java
-+++ b/src/main/java/net/minecraft/server/MCUtil.java
-@@ -0,0 +0,0 @@ import it.unimi.dsi.fastutil.objects.ObjectRBTreeSet;
- import java.lang.ref.Cleaner;
- import net.minecraft.core.BlockPos;
- import net.minecraft.core.Direction;
-+import net.minecraft.nbt.CompoundTag;
-+import net.minecraft.network.chat.Component;
- import net.minecraft.server.level.ServerLevel;
- import net.minecraft.world.entity.Entity;
- import net.minecraft.world.level.ChunkPos;
-@@ -0,0 +0,0 @@ public final class MCUtil {
-         }
-     }
- 
-+    @Nullable
-+    public static Component getBaseComponentFromNbt(String key, CompoundTag compound) {
-+        if (!compound.contains(key)) {
-+            return null;
-+        }
-+        String string = compound.getString(key);
-+        try {
-+            return Component.Serializer.fromJson(string);
-+        } catch (com.google.gson.JsonParseException e) {
-+            org.bukkit.Bukkit.getLogger().warning("Unable to parse " + key + " from " + compound +": " + e.getMessage());
-+        }
-+
-+        return null;
-+    }
-+
-     public static int getTicketLevelFor(net.minecraft.world.level.chunk.ChunkStatus status) {
-         return net.minecraft.server.level.ChunkMap.MAX_VIEW_DISTANCE + net.minecraft.world.level.chunk.ChunkStatus.getDistance(status);
-     }
-diff --git a/src/main/java/net/minecraft/world/level/BaseCommandBlock.java b/src/main/java/net/minecraft/world/level/BaseCommandBlock.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/BaseCommandBlock.java
-+++ b/src/main/java/net/minecraft/world/level/BaseCommandBlock.java
-@@ -0,0 +0,0 @@ public abstract class BaseCommandBlock implements CommandSource {
-         this.command = nbt.getString("Command");
-         this.successCount = nbt.getInt("SuccessCount");
-         if (nbt.contains("CustomName", 8)) {
--            this.setName(Component.Serializer.fromJson(nbt.getString("CustomName")));
-+            this.setName(net.minecraft.server.MCUtil.getBaseComponentFromNbt("CustomName", nbt)); // Paper - Catch ParseException
-         }
- 
-         if (nbt.contains("TrackOutput", 1)) {
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/BannerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BannerBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/BannerBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/BannerBlockEntity.java
-@@ -0,0 +0,0 @@ public class BannerBlockEntity extends BlockEntity implements Nameable {
-     public void load(CompoundTag nbt) {
-         super.load(nbt);
-         if (nbt.contains("CustomName", 8)) {
--            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"));
-+            this.name = net.minecraft.server.MCUtil.getBaseComponentFromNbt("CustomName", nbt); // Paper - Catch ParseException
-         }
- 
-         this.itemPatterns = nbt.getList("Patterns", 10);
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
-@@ -0,0 +0,0 @@ public abstract class BaseContainerBlockEntity extends BlockEntity implements Co
-         super.load(nbt);
-         this.lockKey = LockCode.fromTag(nbt);
-         if (nbt.contains("CustomName", 8)) {
--            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"));
-+            this.name = net.minecraft.server.MCUtil.getBaseComponentFromNbt("CustomName", nbt); // Paper - Catch ParseException
-         }
- 
-     }
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
-@@ -0,0 +0,0 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider {
-         this.levels = nbt.getInt("Levels"); // SPIGOT-5053, use where available
-         // CraftBukkit end
-         if (nbt.contains("CustomName", 8)) {
--            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"));
-+            this.name = net.minecraft.server.MCUtil.getBaseComponentFromNbt("CustomName", nbt); // Paper - Catch ParseException
-         }
- 
-         this.lockKey = LockCode.fromTag(nbt);
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/EnchantmentTableBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/EnchantmentTableBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/EnchantmentTableBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/EnchantmentTableBlockEntity.java
-@@ -0,0 +0,0 @@ public class EnchantmentTableBlockEntity extends BlockEntity implements Nameable
-     public void load(CompoundTag nbt) {
-         super.load(nbt);
-         if (nbt.contains("CustomName", 8)) {
--            this.name = Component.Serializer.fromJson(nbt.getString("CustomName"));
-+            this.name = net.minecraft.server.MCUtil.getBaseComponentFromNbt("CustomName", nbt); // Paper - Catch ParseException
-         }
- 
-     }

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

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

patches/unapplied/server/Chunk-debug-command.patch

@@ -1,441 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Sat, 1 Jun 2019 13:00:55 -0700
-Subject: [PATCH] Chunk debug command
-
-Prints all chunk information to a text file into the debug
-folder in the root server folder. The format is in JSON, and
-the data format is described in MCUtil#dumpChunks(File)
-
-The command will output server version and all online players to the
-file as well. We do not log anything but the location, world and
-username of the player.
-
-Also logs the value of these config values (note not all are paper's):
-- keep spawn loaded value
-- spawn radius
-- view distance
-
-Each chunk has the following logged:
-- Coordinate
-- Ticket level & its corresponding state
-- Whether it is queued for unload
-- Chunk status (may be unloaded)
-- All tickets on the chunk
-
-Example log:
-https://gist.githubusercontent.com/Spottedleaf/0131e7710ffd5d531e5fd246c3367380/raw/169ae1b2e240485f99bc7a6bd8e78d90e3af7397/chunks-2019-06-01_19.57.05.txt
-
-For references on certain keywords (ticket, status, etc), please see:
-
-https://bugs.mojang.com/browse/MC-141484?focusedCommentId=528273&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#comment-528273
-https://bugs.mojang.com/browse/MC-141484?focusedCommentId=528577&page=com.atlassian.jira.plugin.system.issuetabpanels%3Acomment-tabpanel#comment-528577
-
-diff --git a/src/main/java/io/papermc/paper/command/PaperCommand.java b/src/main/java/io/papermc/paper/command/PaperCommand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/io/papermc/paper/command/PaperCommand.java
-+++ b/src/main/java/io/papermc/paper/command/PaperCommand.java
-@@ -0,0 +0,0 @@
- package io.papermc.paper.command;
- 
-+import io.papermc.paper.command.subcommands.ChunkDebugCommand;
- import io.papermc.paper.command.subcommands.EntityCommand;
- import io.papermc.paper.command.subcommands.HeapDumpCommand;
- import io.papermc.paper.command.subcommands.ReloadCommand;
-@@ -0,0 +0,0 @@ public final class PaperCommand extends Command {
-         commands.put(Set.of("entity"), new EntityCommand());
-         commands.put(Set.of("reload"), new ReloadCommand());
-         commands.put(Set.of("version"), new VersionCommand());
-+        commands.put(Set.of("debug", "chunkinfo"), new ChunkDebugCommand());
- 
-         return commands.entrySet().stream()
-             .flatMap(entry -> entry.getKey().stream().map(s -> Map.entry(s, entry.getValue())))
-diff --git a/src/main/java/io/papermc/paper/command/subcommands/ChunkDebugCommand.java b/src/main/java/io/papermc/paper/command/subcommands/ChunkDebugCommand.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/io/papermc/paper/command/subcommands/ChunkDebugCommand.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.command.subcommands;
-+
-+import io.papermc.paper.command.CommandUtil;
-+import io.papermc.paper.command.PaperSubcommand;
-+import java.io.File;
-+import java.time.LocalDateTime;
-+import java.time.format.DateTimeFormatter;
-+import java.util.ArrayList;
-+import java.util.Collections;
-+import java.util.List;
-+import java.util.Locale;
-+import net.minecraft.server.MCUtil;
-+import net.minecraft.server.MinecraftServer;
-+import net.minecraft.server.level.ChunkHolder;
-+import net.minecraft.server.level.ServerLevel;
-+import org.bukkit.Bukkit;
-+import org.bukkit.command.CommandSender;
-+import org.bukkit.craftbukkit.CraftWorld;
-+import org.checkerframework.checker.nullness.qual.NonNull;
-+import org.checkerframework.checker.nullness.qual.Nullable;
-+import org.checkerframework.framework.qual.DefaultQualifier;
-+
-+import static net.kyori.adventure.text.Component.text;
-+import static net.kyori.adventure.text.format.NamedTextColor.BLUE;
-+import static net.kyori.adventure.text.format.NamedTextColor.DARK_AQUA;
-+import static net.kyori.adventure.text.format.NamedTextColor.GREEN;
-+import static net.kyori.adventure.text.format.NamedTextColor.RED;
-+
-+@DefaultQualifier(NonNull.class)
-+public final class ChunkDebugCommand implements PaperSubcommand {
-+    @Override
-+    public boolean execute(final CommandSender sender, final String subCommand, final String[] args) {
-+        switch (subCommand) {
-+            case "debug" -> this.doDebug(sender, args);
-+            case "chunkinfo" -> this.doChunkInfo(sender, args);
-+        }
-+        return true;
-+    }
-+
-+    @Override
-+    public List<String> tabComplete(final CommandSender sender, final String subCommand, final String[] args) {
-+        switch (subCommand) {
-+            case "debug" -> {
-+                if (args.length == 1) {
-+                    return CommandUtil.getListMatchingLast(sender, args, "help", "chunks");
-+                }
-+            }
-+            case "chunkinfo" -> {
-+                List<String> worldNames = new ArrayList<>();
-+                worldNames.add("*");
-+                for (org.bukkit.World world : Bukkit.getWorlds()) {
-+                    worldNames.add(world.getName());
-+                }
-+                if (args.length == 1) {
-+                    return CommandUtil.getListMatchingLast(sender, args, worldNames);
-+                }
-+            }
-+        }
-+        return Collections.emptyList();
-+    }
-+
-+    private void doChunkInfo(final CommandSender sender, final String[] args) {
-+        List<org.bukkit.World> worlds;
-+        if (args.length < 1 || args[0].equals("*")) {
-+            worlds = Bukkit.getWorlds();
-+        } else {
-+            worlds = new ArrayList<>(args.length);
-+            for (final String arg : args) {
-+                org.bukkit.@Nullable World world = Bukkit.getWorld(arg);
-+                if (world == null) {
-+                    sender.sendMessage(text("World '" + arg + "' is invalid", RED));
-+                    return;
-+                }
-+                worlds.add(world);
-+            }
-+        }
-+
-+        int accumulatedTotal = 0;
-+        int accumulatedInactive = 0;
-+        int accumulatedBorder = 0;
-+        int accumulatedTicking = 0;
-+        int accumulatedEntityTicking = 0;
-+
-+        for (final org.bukkit.World bukkitWorld : worlds) {
-+            final ServerLevel world = ((CraftWorld) bukkitWorld).getHandle();
-+
-+            int total = 0;
-+            int inactive = 0;
-+            int border = 0;
-+            int ticking = 0;
-+            int entityTicking = 0;
-+
-+            for (final ChunkHolder chunk : world.getChunkSource().chunkMap.updatingChunkMap.values()) {
-+                if (chunk.getFullChunkNowUnchecked() == null) {
-+                    continue;
-+                }
-+
-+                ++total;
-+
-+                ChunkHolder.FullChunkStatus state = ChunkHolder.getFullChunkStatus(chunk.getTicketLevel());
-+
-+                switch (state) {
-+                    case INACCESSIBLE -> ++inactive;
-+                    case BORDER -> ++border;
-+                    case TICKING -> ++ticking;
-+                    case ENTITY_TICKING -> ++entityTicking;
-+                }
-+            }
-+
-+            accumulatedTotal += total;
-+            accumulatedInactive += inactive;
-+            accumulatedBorder += border;
-+            accumulatedTicking += ticking;
-+            accumulatedEntityTicking += entityTicking;
-+
-+            sender.sendMessage(text().append(text("Chunks in ", BLUE), text(bukkitWorld.getName(), GREEN), text(":")));
-+            sender.sendMessage(text().color(DARK_AQUA).append(
-+                text("Total: ", BLUE), text(total),
-+                text(" Inactive: ", BLUE), text(inactive),
-+                text(" Border: ", BLUE), text(border),
-+                text(" Ticking: ", BLUE), text(ticking),
-+                text(" Entity: ", BLUE), text(entityTicking)
-+            ));
-+        }
-+        if (worlds.size() > 1) {
-+            sender.sendMessage(text().append(text("Chunks in ", BLUE), text("all listed worlds", GREEN), text(":", DARK_AQUA)));
-+            sender.sendMessage(text().color(DARK_AQUA).append(
-+                text("Total: ", BLUE), text(accumulatedTotal),
-+                text(" Inactive: ", BLUE), text(accumulatedInactive),
-+                text(" Border: ", BLUE), text(accumulatedBorder),
-+                text(" Ticking: ", BLUE), text(accumulatedTicking),
-+                text(" Entity: ", BLUE), text(accumulatedEntityTicking)
-+            ));
-+        }
-+    }
-+
-+    private void doDebug(final CommandSender sender, final String[] args) {
-+        if (args.length < 1) {
-+            sender.sendMessage(text("Use /paper debug [chunks] help for more information on a specific command", RED));
-+            return;
-+        }
-+
-+        final String debugType = args[0].toLowerCase(Locale.ENGLISH);
-+        switch (debugType) {
-+            case "chunks" -> {
-+                if (args.length >= 2 && args[1].toLowerCase(Locale.ENGLISH).equals("help")) {
-+                    sender.sendMessage(text("Use /paper debug chunks [world] to dump loaded chunk information to a file", RED));
-+                    break;
-+                }
-+                File file = new File(new File(new File("."), "debug"),
-+                    "chunks-" + DateTimeFormatter.ofPattern("yyyy-MM-dd_HH.mm.ss").format(LocalDateTime.now()) + ".txt");
-+                sender.sendMessage(text("Writing chunk information dump to " + file, GREEN));
-+                try {
-+                    MCUtil.dumpChunks(file);
-+                    sender.sendMessage(text("Successfully written chunk information!", GREEN));
-+                } catch (Throwable thr) {
-+                    MinecraftServer.LOGGER.warn("Failed to dump chunk information to file " + file.toString(), thr);
-+                    sender.sendMessage(text("Failed to dump chunk information, see console", RED));
-+                }
-+            }
-+            // "help" & default
-+            default -> sender.sendMessage(text("Use /paper debug [chunks] help for more information on a specific command", RED));
-+        }
-+    }
-+
-+}
-diff --git a/src/main/java/net/minecraft/server/MCUtil.java b/src/main/java/net/minecraft/server/MCUtil.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/MCUtil.java
-+++ b/src/main/java/net/minecraft/server/MCUtil.java
-@@ -0,0 +0,0 @@ import net.minecraft.core.BlockPos;
- import net.minecraft.core.Direction;
- import net.minecraft.nbt.CompoundTag;
- import net.minecraft.network.chat.Component;
-+import net.minecraft.server.level.ChunkHolder;
-+import net.minecraft.server.level.ChunkMap;
-+import net.minecraft.server.level.DistanceManager;
-+import net.minecraft.server.level.ServerChunkCache;
- import net.minecraft.server.level.ServerLevel;
-+import net.minecraft.server.level.ServerPlayer;
-+import net.minecraft.server.level.Ticket;
- import net.minecraft.world.entity.Entity;
- import net.minecraft.world.level.ChunkPos;
- import net.minecraft.world.level.ClipContext;
- import net.minecraft.world.level.Level;
-+import net.minecraft.world.level.chunk.ChunkAccess;
-+import net.minecraft.world.level.chunk.ChunkStatus;
- import org.apache.commons.lang.exception.ExceptionUtils;
-+import com.google.gson.JsonArray;
-+import com.google.gson.JsonObject;
-+import com.google.gson.internal.Streams;
-+import com.google.gson.stream.JsonWriter;
- import com.mojang.authlib.GameProfile;
-+import com.mojang.datafixers.util.Either;
-+import it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap;
- import org.bukkit.Location;
- import org.bukkit.block.BlockFace;
- import org.bukkit.craftbukkit.CraftWorld;
-@@ -0,0 +0,0 @@ import org.spigotmc.AsyncCatcher;
- 
- import javax.annotation.Nonnull;
- import javax.annotation.Nullable;
-+import java.io.*;
-+import java.util.ArrayList;
- import java.util.List;
- import java.util.Queue;
-+import java.util.Set;
- import java.util.concurrent.CompletableFuture;
- import java.util.concurrent.ExecutionException;
- import java.util.concurrent.LinkedBlockingQueue;
-@@ -0,0 +0,0 @@ public final class MCUtil {
-         return null;
-     }
- 
-+    public static ChunkStatus getChunkStatus(ChunkHolder chunk) {
-+        List<ChunkStatus> statuses = net.minecraft.server.level.ServerChunkCache.CHUNK_STATUSES;
-+        for (int i = statuses.size() - 1; i >= 0; --i) {
-+            ChunkStatus curr = statuses.get(i);
-+            CompletableFuture<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>> future = chunk.getFutureIfPresentUnchecked(curr);
-+            if (future != ChunkHolder.UNLOADED_CHUNK_FUTURE) {
-+                return curr;
-+            }
-+        }
-+        return null; // unloaded
-+    }
-+
-+    public static void dumpChunks(File file) throws IOException {
-+        file.getParentFile().mkdirs();
-+        file.createNewFile();
-+        /*
-+         * Json format:
-+         *
-+         * Main data format:
-+         *  -server-version:<string>
-+         *  -data-version:<int>
-+         *  -worlds:
-+         *    -name:<world name>
-+         *    -view-distance:<int>
-+         *    -keep-spawn-loaded:<boolean>
-+         *    -keep-spawn-loaded-range:<int>
-+         *    -visible-chunk-count:<int>
-+         *    -loaded-chunk-count:<int>
-+         *    -verified-fully-loaded-chunks:<int>
-+         *    -players:<array of player>
-+         *    -chunk-data:<array of chunks>
-+         *
-+         * Player format:
-+         *  -name:<string>
-+         *  -x:<double>
-+         *  -y:<double>
-+         *  -z:<double>
-+         *
-+         * Chunk Format:
-+         *  -x:<integer>
-+         *  -z:<integer>
-+         *  -ticket-level:<integer>
-+         *  -state:<string>
-+         *  -queued-for-unload:<boolean>
-+         *  -status:<string>
-+         *  -tickets:<array of tickets>
-+         *
-+         *
-+         * Ticket format:
-+         *  -ticket-type:<string>
-+         *  -ticket-level:<int>
-+         *  -add-tick:<long>
-+         *  -object-reason:<string> // This depends on the type of ticket. ie POST_TELEPORT -> entity id
-+         */
-+        List<org.bukkit.World> worlds = org.bukkit.Bukkit.getWorlds();
-+        JsonObject data = new JsonObject();
-+
-+        data.addProperty("server-version", org.bukkit.Bukkit.getVersion());
-+        data.addProperty("data-version", 0);
-+
-+        JsonArray worldsData = new JsonArray();
-+
-+        for (org.bukkit.World bukkitWorld : worlds) {
-+            JsonObject worldData = new JsonObject();
-+
-+            ServerLevel world = ((org.bukkit.craftbukkit.CraftWorld)bukkitWorld).getHandle();
-+            ChunkMap chunkMap = world.getChunkSource().chunkMap;
-+            Long2ObjectLinkedOpenHashMap<ChunkHolder> visibleChunks = chunkMap.visibleChunkMap;
-+            DistanceManager chunkMapDistance = chunkMap.distanceManager;
-+            List<ChunkHolder> allChunks = new ArrayList<>(visibleChunks.values());
-+            List<ServerPlayer> players = world.players;
-+
-+            int fullLoadedChunks = 0;
-+
-+            for (ChunkHolder chunk : allChunks) {
-+                if (chunk.getFullChunkNowUnchecked() != null) {
-+                    ++fullLoadedChunks;
-+                }
-+            }
-+
-+            // sorting by coordinate makes the log easier to read
-+            allChunks.sort((ChunkHolder v1, ChunkHolder v2) -> {
-+                if (v1.pos.x != v2.pos.x) {
-+                    return Integer.compare(v1.pos.x, v2.pos.x);
-+                }
-+                return Integer.compare(v1.pos.z, v2.pos.z);
-+            });
-+
-+            worldData.addProperty("name", world.getWorld().getName());
-+            worldData.addProperty("view-distance", world.spigotConfig.viewDistance);
-+            worldData.addProperty("keep-spawn-loaded", world.keepSpawnInMemory);
-+            worldData.addProperty("keep-spawn-loaded-range", world.paperConfig().spawn.keepSpawnLoadedRange * 16);
-+            worldData.addProperty("visible-chunk-count", visibleChunks.size());
-+            worldData.addProperty("loaded-chunk-count", chunkMap.entitiesInLevel.size());
-+            worldData.addProperty("verified-fully-loaded-chunks", fullLoadedChunks);
-+
-+            JsonArray playersData = new JsonArray();
-+
-+            for (ServerPlayer player : players) {
-+                JsonObject playerData = new JsonObject();
-+
-+                playerData.addProperty("name", player.getScoreboardName());
-+                playerData.addProperty("x", player.getX());
-+                playerData.addProperty("y", player.getY());
-+                playerData.addProperty("z", player.getZ());
-+
-+                playersData.add(playerData);
-+
-+            }
-+
-+            worldData.add("players", playersData);
-+
-+            JsonArray chunksData = new JsonArray();
-+
-+            for (ChunkHolder playerChunk : allChunks) {
-+                JsonObject chunkData = new JsonObject();
-+
-+                Set<Ticket<?>> tickets = chunkMapDistance.tickets.get(playerChunk.pos.longKey);
-+                ChunkStatus status = getChunkStatus(playerChunk);
-+
-+                chunkData.addProperty("x", playerChunk.pos.x);
-+                chunkData.addProperty("z", playerChunk.pos.z);
-+                chunkData.addProperty("ticket-level", playerChunk.getTicketLevel());
-+                chunkData.addProperty("state", ChunkHolder.getFullChunkStatus(playerChunk.getTicketLevel()).toString());
-+                chunkData.addProperty("queued-for-unload", chunkMap.toDrop.contains(playerChunk.pos.longKey));
-+                chunkData.addProperty("status", status == null ? "unloaded" : status.toString());
-+
-+                JsonArray ticketsData = new JsonArray();
-+
-+                if (tickets != null) {
-+                    for (Ticket<?> ticket : tickets) {
-+                        JsonObject ticketData = new JsonObject();
-+
-+                        ticketData.addProperty("ticket-type", ticket.getType().toString());
-+                        ticketData.addProperty("ticket-level", ticket.getTicketLevel());
-+                        ticketData.addProperty("object-reason", String.valueOf(ticket.key));
-+                        ticketData.addProperty("add-tick", ticket.createdTick);
-+
-+                        ticketsData.add(ticketData);
-+                    }
-+                }
-+
-+                chunkData.add("tickets", ticketsData);
-+                chunksData.add(chunkData);
-+            }
-+
-+
-+            worldData.add("chunk-data", chunksData);
-+            worldsData.add(worldData);
-+        }
-+
-+        data.add("worlds", worldsData);
-+
-+        StringWriter stringWriter = new StringWriter();
-+        JsonWriter jsonWriter = new JsonWriter(stringWriter);
-+        jsonWriter.setIndent(" ");
-+        jsonWriter.setLenient(false);
-+        Streams.write(data, jsonWriter);
-+
-+        String fileData = stringWriter.toString();
-+
-+        try (PrintStream out = new PrintStream(new FileOutputStream(file), false, "UTF-8")) {
-+            out.print(fileData);
-+        }
-+    }
-+
-     public static int getTicketLevelFor(net.minecraft.world.level.chunk.ChunkStatus status) {
-         return net.minecraft.server.level.ChunkMap.MAX_VIEW_DISTANCE + net.minecraft.world.level.chunk.ChunkStatus.getDistance(status);
-     }

patches/unapplied/server/ChunkMapDistance-CME.patch

@@ -1,84 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Shane Freeder <theboyetronic@gmail.com>
-Date: Wed, 29 May 2019 04:01:22 +0100
-Subject: [PATCH] ChunkMapDistance CME
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ChunkHolder.java b/src/main/java/net/minecraft/server/level/ChunkHolder.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ChunkHolder.java
-+++ b/src/main/java/net/minecraft/server/level/ChunkHolder.java
-@@ -0,0 +0,0 @@ public class ChunkHolder {
-     private boolean resendLight;
-     private CompletableFuture<Void> pendingFullStateConfirmation;
- 
-+    boolean isUpdateQueued = false; // Paper
-     private final ChunkMap chunkMap; // Paper
- 
-     public ChunkHolder(ChunkPos pos, int level, LevelHeightAccessor world, LevelLightEngine lightingProvider, ChunkHolder.LevelChangeListener levelUpdateListener, ChunkHolder.PlayerProvider playersWatchingChunkProvider) {
-diff --git a/src/main/java/net/minecraft/server/level/DistanceManager.java b/src/main/java/net/minecraft/server/level/DistanceManager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/DistanceManager.java
-+++ b/src/main/java/net/minecraft/server/level/DistanceManager.java
-@@ -0,0 +0,0 @@ public abstract class DistanceManager {
-     private final DistanceManager.FixedPlayerDistanceChunkTracker naturalSpawnChunkCounter = new DistanceManager.FixedPlayerDistanceChunkTracker(8);
-     private final TickingTracker tickingTicketsTracker = new TickingTracker();
-     private final DistanceManager.PlayerTicketTracker playerTicketManager = new DistanceManager.PlayerTicketTracker(33);
--    final Set<ChunkHolder> chunksToUpdateFutures = Sets.newHashSet();
-+    // Paper start use a queue, but still keep unique requirement
-+    public final java.util.Queue<ChunkHolder> pendingChunkUpdates = new java.util.ArrayDeque<ChunkHolder>() {
-+        @Override
-+        public boolean add(ChunkHolder o) {
-+            if (o.isUpdateQueued) return true;
-+            o.isUpdateQueued = true;
-+            return super.add(o);
-+        }
-+    };
-+    // Paper end
-     final ChunkTaskPriorityQueueSorter ticketThrottler;
-     final ProcessorHandle<ChunkTaskPriorityQueueSorter.Message<Runnable>> ticketThrottlerInput;
-     final ProcessorHandle<ChunkTaskPriorityQueueSorter.Release> ticketThrottlerReleaser;
-@@ -0,0 +0,0 @@ public abstract class DistanceManager {
-             ;
-         }
- 
--        if (!this.chunksToUpdateFutures.isEmpty()) {
--            // CraftBukkit start
--            // Iterate pending chunk updates with protection against concurrent modification exceptions
--            java.util.Iterator<ChunkHolder> iter = this.chunksToUpdateFutures.iterator();
--            int expectedSize = this.chunksToUpdateFutures.size();
--            do {
--                ChunkHolder playerchunk = iter.next();
--                iter.remove();
--                expectedSize--;
--
--                playerchunk.updateFutures(chunkStorage, this.mainThreadExecutor);
--
--                // Reset iterator if set was modified using add()
--                if (this.chunksToUpdateFutures.size() != expectedSize) {
--                    expectedSize = this.chunksToUpdateFutures.size();
--                    iter = this.chunksToUpdateFutures.iterator();
--                }
--            } while (iter.hasNext());
--            // CraftBukkit end
--
-+        // Paper start
-+        if (!this.pendingChunkUpdates.isEmpty()) {
-+            while(!this.pendingChunkUpdates.isEmpty()) {
-+                ChunkHolder remove = this.pendingChunkUpdates.remove();
-+                remove.isUpdateQueued = false;
-+                remove.updateFutures(chunkStorage, this.mainThreadExecutor);
-+            }
-+            // Paper end
-             return true;
-         } else {
-             if (!this.ticketsToRelease.isEmpty()) {
-@@ -0,0 +0,0 @@ public abstract class DistanceManager {
-             if (k != level) {
-                 playerchunk = DistanceManager.this.updateChunkScheduling(id, level, playerchunk, k);
-                 if (playerchunk != null) {
--                    DistanceManager.this.chunksToUpdateFutures.add(playerchunk);
-+                    DistanceManager.this.pendingChunkUpdates.add(playerchunk);
-                 }
- 
-             }

patches/unapplied/server/Configurable-Alternative-LootPool-Luck-Formula.patch

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

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

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

patches/unapplied/server/Configurable-Chunk-Inhabited-Time.patch

@@ -1,30 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Mon, 28 Mar 2016 20:46:14 -0400
-Subject: [PATCH] Configurable Chunk Inhabited Time
-
-Vanilla stores how long a chunk has been active on a server, and dynamically scales some
-aspects of vanilla gameplay to this factor.
-
-For people who want all chunks to be treated equally, you can chose a fixed value.
-
-This allows to fine-tune vanilla gameplay.
-
-diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
-@@ -0,0 +0,0 @@ public class LevelChunk extends ChunkAccess {
-         return new ChunkAccess.TicksToSave(this.blockTicks, this.fluidTicks);
-     }
- 
-+    // Paper start
-+    @Override
-+    public long getInhabitedTime() {
-+        return this.level.paperConfig().chunks.fixedChunkInhabitedTime < 0 ? super.getInhabitedTime() : this.level.paperConfig().chunks.fixedChunkInhabitedTime;
-+    }
-+    // Paper end
-+
-     @Override
-     public GameEventDispatcher getEventDispatcher(int ySectionCoord) {
-         Level world = this.level;

patches/unapplied/server/Configurable-Grass-Spread-Tick-Rate.patch

@@ -1,26 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sun, 3 Apr 2016 16:28:17 -0400
-Subject: [PATCH] Configurable Grass Spread Tick Rate
-
-
-diff --git a/src/main/java/net/minecraft/world/level/block/SpreadingSnowyDirtBlock.java b/src/main/java/net/minecraft/world/level/block/SpreadingSnowyDirtBlock.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/SpreadingSnowyDirtBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/SpreadingSnowyDirtBlock.java
-@@ -0,0 +0,0 @@ package net.minecraft.world.level.block;
- 
- import net.minecraft.core.BlockPos;
- import net.minecraft.core.Direction;
-+import net.minecraft.server.MinecraftServer;
- import net.minecraft.server.level.ServerLevel;
- import net.minecraft.tags.FluidTags;
- import net.minecraft.util.RandomSource;
-@@ -0,0 +0,0 @@ public abstract class SpreadingSnowyDirtBlock extends SnowyDirtBlock {
- 
-     @Override
-     public void randomTick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
-+        if (this instanceof GrassBlock && world.paperConfig().tickRates.grassSpread != 1 && (world.paperConfig().tickRates.grassSpread < 1 || (MinecraftServer.currentTick + pos.hashCode()) % world.paperConfig().tickRates.grassSpread != 0)) { return; } // Paper
-         if (!SpreadingSnowyDirtBlock.canBeGrass(state, world, pos)) {
-             // CraftBukkit start
-             if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, pos, Blocks.DIRT.defaultBlockState()).isCancelled()) {

patches/unapplied/server/Configurable-Keep-Spawn-Loaded-range-per-world.patch

@@ -1,231 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sat, 13 Sep 2014 23:14:43 -0400
-Subject: [PATCH] Configurable Keep Spawn Loaded range per world
-
-This lets you disable it for some worlds and lower it for others.
-
-diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
- 
-     // CraftBukkit start
-     public void prepareLevels(ChunkProgressListener worldloadlistener, ServerLevel worldserver) {
-+        ServerChunkCache chunkproviderserver = worldserver.getChunkSource(); // Paper
-         // WorldServer worldserver = this.overworld();
-         this.forceTicks = true;
-         // CraftBukkit end
-+        if (worldserver.getWorld().getKeepSpawnInMemory()) { // Paper
- 
-         MinecraftServer.LOGGER.info("Preparing start region for dimension {}", worldserver.dimension().location());
-         BlockPos blockposition = worldserver.getSharedSpawnPos();
- 
-         worldloadlistener.updateSpawnPos(new ChunkPos(blockposition));
--        ServerChunkCache chunkproviderserver = worldserver.getChunkSource();
-+        //ChunkProviderServer chunkproviderserver = worldserver.getChunkProvider(); // Paper - move up
- 
-         chunkproviderserver.getLightEngine().setTaskPerBatch(500);
-         this.nextTickTime = Util.getMillis();
--        // CraftBukkit start
--        if (worldserver.getWorld().getKeepSpawnInMemory()) {
--            chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(blockposition), 11, Unit.INSTANCE);
--
--            while (chunkproviderserver.getTickingGenerated() != 441) {
--                // this.nextTickTime = SystemUtils.getMillis() + 10L;
--                this.executeModerately();
--            }
--        }
-+        // Paper start - configurable spawn reason
-+        int radiusBlocks = worldserver.paperConfig().spawn.keepSpawnLoadedRange * 16;
-+        int radiusChunks = radiusBlocks / 16 + ((radiusBlocks & 15) != 0 ? 1 : 0);
-+        int totalChunks = ((radiusChunks) * 2 + 1);
-+        totalChunks *= totalChunks;
-+        worldloadlistener.setChunkRadius(radiusBlocks / 16);
-+
-+        worldserver.addTicketsForSpawn(radiusBlocks, blockposition);
-+        // Paper end
- 
-         // this.nextTickTime = SystemUtils.getMillis() + 10L;
-         this.executeModerately();
-         // Iterator iterator = this.levels.values().iterator();
-+        }
- 
-         if (true) {
-             ServerLevel worldserver1 = worldserver;
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         // this.nextTickTime = SystemUtils.getMillis() + 10L;
-         this.executeModerately();
-         // CraftBukkit end
--        worldloadlistener.stop();
-+        if (worldserver.getWorld().getKeepSpawnInMemory()) worldloadlistener.stop(); // Paper
-         chunkproviderserver.getLightEngine().setTaskPerBatch(5);
-         // CraftBukkit start
-         // this.updateMobSpawningFlags();
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ import net.minecraft.network.protocol.game.ClientboundSoundEntityPacket;
- import net.minecraft.network.protocol.game.ClientboundSoundPacket;
- import net.minecraft.network.protocol.game.DebugPackets;
- import net.minecraft.resources.ResourceKey;
-+import net.minecraft.server.MCUtil;
- import net.minecraft.server.MinecraftServer;
- import net.minecraft.server.ServerScoreboard;
- import net.minecraft.server.level.progress.ChunkProgressListener;
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
-         return ((MapIndex) this.getServer().overworld().getDataStorage().computeIfAbsent(MapIndex::load, MapIndex::new, "idcounts")).getFreeAuxValueForMap();
-     }
- 
-+    // Paper start - helper function for configurable spawn radius
-+    public void addTicketsForSpawn(int radiusInBlocks, BlockPos spawn) {
-+        // In order to respect vanilla behavior, which is ensuring everything but the spawn border can tick, we add tickets
-+        // with level 31 for the non-border spawn chunks
-+        ServerChunkCache chunkproviderserver = this.getChunkSource();
-+        int tickRadius = radiusInBlocks - 16;
-+
-+        // add ticking chunks
-+        for (int x = -tickRadius; x <= tickRadius; x += 16) {
-+            for (int z = -tickRadius; z <= tickRadius; z += 16) {
-+                // radius of 2 will have the current chunk be level 31
-+                chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, z)), 2, Unit.INSTANCE);
-+            }
-+        }
-+
-+        // add border chunks
-+
-+        // add border along x axis (including corner chunks)
-+        for (int x = -radiusInBlocks; x <= radiusInBlocks; x += 16) {
-+            // top
-+            chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, radiusInBlocks)), 1, Unit.INSTANCE); // level 32
-+            // bottom
-+            chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, -radiusInBlocks)), 1, Unit.INSTANCE); // level 32
-+        }
-+
-+        // add border along z axis (excluding corner chunks)
-+        for (int z = -radiusInBlocks + 16; z < radiusInBlocks; z += 16) {
-+            // right
-+            chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(spawn.offset(radiusInBlocks, 0, z)), 1, Unit.INSTANCE); // level 32
-+            // left
-+            chunkproviderserver.addRegionTicket(TicketType.START, new ChunkPos(spawn.offset(-radiusInBlocks, 0, z)), 1, Unit.INSTANCE); // level 32
-+        }
-+    }
-+    public void removeTicketsForSpawn(int radiusInBlocks, BlockPos spawn) {
-+        // In order to respect vanilla behavior, which is ensuring everything but the spawn border can tick, we added tickets
-+        // with level 31 for the non-border spawn chunks
-+        ServerChunkCache chunkproviderserver = this.getChunkSource();
-+        int tickRadius = radiusInBlocks - 16;
-+
-+        // remove ticking chunks
-+        for (int x = -tickRadius; x <= tickRadius; x += 16) {
-+            for (int z = -tickRadius; z <= tickRadius; z += 16) {
-+                // radius of 2 will have the current chunk be level 31
-+                chunkproviderserver.removeRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, z)), 2, Unit.INSTANCE);
-+            }
-+        }
-+
-+        // remove border chunks
-+
-+        // remove border along x axis (including corner chunks)
-+        for (int x = -radiusInBlocks; x <= radiusInBlocks; x += 16) {
-+            // top
-+            chunkproviderserver.removeRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, radiusInBlocks)), 1, Unit.INSTANCE); // level 32
-+            // bottom
-+            chunkproviderserver.removeRegionTicket(TicketType.START, new ChunkPos(spawn.offset(x, 0, -radiusInBlocks)), 1, Unit.INSTANCE); // level 32
-+        }
-+
-+        // remove border along z axis (excluding corner chunks)
-+        for (int z = -radiusInBlocks + 16; z < radiusInBlocks; z += 16) {
-+            // right
-+            chunkproviderserver.removeRegionTicket(TicketType.START, new ChunkPos(spawn.offset(radiusInBlocks, 0, z)), 1, Unit.INSTANCE); // level 32
-+            // left
-+            chunkproviderserver.removeRegionTicket(TicketType.START, new ChunkPos(spawn.offset(-radiusInBlocks, 0, z)), 1, Unit.INSTANCE); // level 32
-+        }
-+    }
-+    // Paper end
-+
-     public void setDefaultSpawnPos(BlockPos pos, float angle) {
--        ChunkPos chunkcoordintpair = new ChunkPos(new BlockPos(this.levelData.getXSpawn(), 0, this.levelData.getZSpawn()));
-+        // Paper - configurable spawn radius
-+        BlockPos prevSpawn = this.getSharedSpawnPos();
-+        //ChunkCoordIntPair chunkcoordintpair = new ChunkCoordIntPair(new BlockPosition(this.worldData.a(), 0, this.worldData.c()));
- 
-         this.levelData.setSpawn(pos, angle);
--        this.getChunkSource().removeRegionTicket(TicketType.START, chunkcoordintpair, 11, Unit.INSTANCE);
--        this.getChunkSource().addRegionTicket(TicketType.START, new ChunkPos(pos), 11, Unit.INSTANCE);
-+        if (this.keepSpawnInMemory) {
-+            // if this keepSpawnInMemory is false a plugin has already removed our tickets, do not re-add
-+            this.removeTicketsForSpawn(this.paperConfig().spawn.keepSpawnLoadedRange * 16, prevSpawn);
-+            this.addTicketsForSpawn(this.paperConfig().spawn.keepSpawnLoadedRange * 16, pos);
-+        }
-         this.getServer().getPlayerList().broadcastAll(new ClientboundSetDefaultSpawnPositionPacket(pos, angle));
-     }
- 
-diff --git a/src/main/java/net/minecraft/server/level/progress/ChunkProgressListener.java b/src/main/java/net/minecraft/server/level/progress/ChunkProgressListener.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/progress/ChunkProgressListener.java
-+++ b/src/main/java/net/minecraft/server/level/progress/ChunkProgressListener.java
-@@ -0,0 +0,0 @@ public interface ChunkProgressListener {
-     void start();
- 
-     void stop();
-+
-+    void setChunkRadius(int radius); // Paper - allow changing chunk radius
- }
-diff --git a/src/main/java/net/minecraft/server/level/progress/LoggerChunkProgressListener.java b/src/main/java/net/minecraft/server/level/progress/LoggerChunkProgressListener.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/progress/LoggerChunkProgressListener.java
-+++ b/src/main/java/net/minecraft/server/level/progress/LoggerChunkProgressListener.java
-@@ -0,0 +0,0 @@ import org.slf4j.Logger;
- 
- public class LoggerChunkProgressListener implements ChunkProgressListener {
-     private static final Logger LOGGER = LogUtils.getLogger();
--    private final int maxCount;
-+    private int maxCount;// Paper - remove final
-     private int count;
-     private long startTime;
-     private long nextTickTime = Long.MAX_VALUE;
- 
-     public LoggerChunkProgressListener(int radius) {
-+        // Paper start - Allow changing radius later for configurable spawn patch
-+        this.setChunkRadius(radius); // Move to method
-+    }
-+
-+    @Override
-+    public void setChunkRadius(int radius) {
-+        // Paper end
-         int i = radius * 2 + 1;
-         this.maxCount = i * i;
-     }
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -0,0 +0,0 @@ public class CraftWorld extends CraftRegionAccessor implements World {
- 
-     @Override
-     public void setKeepSpawnInMemory(boolean keepLoaded) {
--        world.keepSpawnInMemory = keepLoaded;
-+        // Paper start - Configurable spawn radius
-+        if (keepLoaded == world.keepSpawnInMemory) {
-+            // do nothing, nothing has changed
-+            return;
-+        }
-+        this.world.keepSpawnInMemory = keepLoaded;
-         // Grab the worlds spawn chunk
-         BlockPos chunkcoordinates = this.world.getSharedSpawnPos();
-         if (keepLoaded) {
--            this.world.getChunkSource().addRegionTicket(TicketType.START, new ChunkPos(chunkcoordinates), 11, Unit.INSTANCE);
-+            this.world.addTicketsForSpawn(this.world.paperConfig().spawn.keepSpawnLoadedRange * 16, chunkcoordinates);
-         } else {
--            // TODO: doesn't work well if spawn changed....
--            this.world.getChunkSource().removeRegionTicket(TicketType.START, new ChunkPos(chunkcoordinates), 11, Unit.INSTANCE);
-+            // TODO: doesn't work well if spawn changed.... // Paper - resolved
-+            this.world.removeTicketsForSpawn(this.world.paperConfig().spawn.keepSpawnLoadedRange * 16, chunkcoordinates);
-         }
-+        // Paper end
-     }
- 
-     @Override

patches/unapplied/server/Configurable-Non-Player-Arrow-Despawn-Rate.patch

@@ -1,20 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Fri, 18 Mar 2016 15:12:22 -0400
-Subject: [PATCH] Configurable Non Player Arrow Despawn Rate
-
-Can set a much shorter despawn rate for arrows that players can not pick up.
-
-diff --git a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
-@@ -0,0 +0,0 @@ public abstract class AbstractArrow extends Projectile {
- 
-     protected void tickDespawn() {
-         ++this.life;
--        if (this.life >= ((this instanceof ThrownTrident) ? level.spigotConfig.tridentDespawnRate : level.spigotConfig.arrowDespawnRate)) { // Spigot
-+        if (this.life >= (pickup == Pickup.CREATIVE_ONLY ? level.paperConfig().entities.spawning.creativeArrowDespawnRate.value() : (pickup == Pickup.DISALLOWED ? level.paperConfig().entities.spawning.nonPlayerArrowDespawnRate.value() : ((this instanceof ThrownTrident) ? level.spigotConfig.tridentDespawnRate : level.spigotConfig.arrowDespawnRate)))) { // Spigot // Paper - TODO: Extract this to init?
-             this.discard();
-         }
- 

patches/unapplied/server/Configurable-Player-Collision.patch

@@ -1,109 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Wed, 13 Apr 2016 02:10:49 -0400
-Subject: [PATCH] Configurable Player Collision
-
-
-diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetPlayerTeamPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetPlayerTeamPacket.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/protocol/game/ClientboundSetPlayerTeamPacket.java
-+++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundSetPlayerTeamPacket.java
-@@ -0,0 +0,0 @@ public class ClientboundSetPlayerTeamPacket implements Packet<ClientGamePacketLi
-             buf.writeComponent(this.displayName);
-             buf.writeByte(this.options);
-             buf.writeUtf(this.nametagVisibility);
--            buf.writeUtf(this.collisionRule);
-+            buf.writeUtf(!io.papermc.paper.configuration.GlobalConfiguration.get().collisions.enablePlayerCollisions ? "never" : this.collisionRule); // Paper
-             buf.writeEnum(this.color);
-             buf.writeComponent(this.playerPrefix);
-             buf.writeComponent(this.playerSuffix);
-diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-             this.server.getPluginManager().callEvent(new org.bukkit.event.world.WorldLoadEvent(worldserver.getWorld()));
-         }
- 
-+        // Paper start - Handle collideRule team for player collision toggle
-+        final ServerScoreboard scoreboard = this.getScoreboard();
-+        final java.util.Collection<String> toRemove = scoreboard.getPlayerTeams().stream().filter(team -> team.getName().startsWith("collideRule_")).map(net.minecraft.world.scores.PlayerTeam::getName).collect(java.util.stream.Collectors.toList());
-+        for (String teamName : toRemove) {
-+            scoreboard.removePlayerTeam(scoreboard.getPlayerTeam(teamName)); // Clean up after ourselves
-+        }
-+
-+        if (!io.papermc.paper.configuration.GlobalConfiguration.get().collisions.enablePlayerCollisions) {
-+            this.getPlayerList().collideRuleTeamName = org.apache.commons.lang3.StringUtils.left("collideRule_" + java.util.concurrent.ThreadLocalRandom.current().nextInt(), 16);
-+            net.minecraft.world.scores.PlayerTeam collideTeam = scoreboard.addPlayerTeam(this.getPlayerList().collideRuleTeamName);
-+            collideTeam.setSeeFriendlyInvisibles(false); // Because we want to mimic them not being on a team at all
-+        }
-+        // Paper end
-+
-         this.server.enablePlugins(org.bukkit.plugin.PluginLoadOrder.POSTWORLD);
-         this.server.getPluginManager().callEvent(new ServerLoadEvent(ServerLoadEvent.LoadType.STARTUP));
-         this.connection.acceptConnections();
-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 @@ import net.minecraft.world.level.storage.PlayerDataStorage;
- import net.minecraft.world.phys.Vec3;
- import net.minecraft.world.scores.Objective;
- import net.minecraft.world.scores.PlayerTeam;
-+import net.minecraft.world.scores.Scoreboard; // Paper
- import net.minecraft.world.scores.Team;
- import org.slf4j.Logger;
- 
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-     // CraftBukkit start
-     private CraftServer cserver;
-     private final Map<String,ServerPlayer> playersByName = new java.util.HashMap<>();
-+    public @Nullable String collideRuleTeamName; // Paper - Team name used for collideRule
- 
-     public PlayerList(MinecraftServer server, RegistryAccess.Frozen registryManager, PlayerDataStorage saveHandler, int maxPlayers) {
-         this.cserver = server.server = new CraftServer((DedicatedServer) server, this);
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
- 
-         player.initInventoryMenu();
-         // CraftBukkit - Moved from above, added world
-+        // Paper start - Add to collideRule team if needed
-+        final Scoreboard scoreboard = this.getServer().getLevel(Level.OVERWORLD).getScoreboard();
-+        final PlayerTeam collideRuleTeam = scoreboard.getPlayerTeam(this.collideRuleTeamName);
-+        if (this.collideRuleTeamName != null && collideRuleTeam != null && player.getTeam() == null) {
-+            scoreboard.addPlayerToTeam(player.getScoreboardName(), collideRuleTeam);
-+        }
-+        // Paper end
-         PlayerList.LOGGER.info("{}[{}] logged in with entity id {} at ([{}]{}, {}, {})", player.getName().getString(), s1, player.getId(), worldserver1.serverLevelData.getLevelName(), player.getX(), player.getY(), player.getZ());
-     }
- 
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-         entityplayer.doTick(); // SPIGOT-924
-         // CraftBukkit end
- 
-+        // Paper start - Remove from collideRule team if needed
-+        if (this.collideRuleTeamName != null) {
-+            final Scoreboard scoreBoard = this.server.getLevel(Level.OVERWORLD).getScoreboard();
-+            final PlayerTeam team = scoreBoard.getPlayersTeam(this.collideRuleTeamName);
-+            if (entityplayer.getTeam() == team && team != null) {
-+                scoreBoard.removePlayerFromTeam(entityplayer.getScoreboardName(), team);
-+            }
-+        }
-+        // Paper end
-+
-         this.save(entityplayer);
-         if (entityplayer.isPassenger()) {
-             Entity entity = entityplayer.getRootVehicle();
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-         }
-         // CraftBukkit end
- 
-+        // Paper start - Remove collideRule team if it exists
-+        if (this.collideRuleTeamName != null) {
-+            final Scoreboard scoreboard = this.getServer().getLevel(Level.OVERWORLD).getScoreboard();
-+            final PlayerTeam team = scoreboard.getPlayersTeam(this.collideRuleTeamName);
-+            if (team != null) scoreboard.removePlayerTeam(team);
-+        }
-+        // Paper end
-     }
- 
-     // CraftBukkit start

patches/unapplied/server/Configurable-RCON-IP-address.patch

@@ -1,44 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sat, 16 Apr 2016 00:39:33 -0400
-Subject: [PATCH] Configurable RCON IP address
-
-For servers with multiple IP's, ability to bind to a specific interface.
-
-diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServerProperties.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServerProperties.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/dedicated/DedicatedServerProperties.java
-+++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServerProperties.java
-@@ -0,0 +0,0 @@ public class DedicatedServerProperties extends Settings<DedicatedServerPropertie
-     @Nullable
-     private WorldGenSettings worldGenSettings;
- 
-+    public final String rconIp; // Paper - Add rcon ip
-+
-     // CraftBukkit start
-     public DedicatedServerProperties(Properties properties, OptionSet optionset) {
-         super(properties, optionset);
-@@ -0,0 +0,0 @@ public class DedicatedServerProperties extends Settings<DedicatedServerPropertie
-             return s.toLowerCase(Locale.ROOT);
-         }, WorldPresets.NORMAL.location().toString()));
-         this.serverResourcePackInfo = DedicatedServerProperties.getServerPackInfo(this.get("resource-pack", ""), this.get("resource-pack-sha1", ""), this.getLegacyString("resource-pack-hash"), this.get("require-resource-pack", false), this.get("resource-pack-prompt", ""));
-+        // Paper start - Configurable rcon ip
-+        final String rconIp = this.getStringRaw("rcon.ip");
-+        this.rconIp = rconIp == null ? this.serverIp : rconIp;
-+        // Paper end
-     }
- 
-     // CraftBukkit start
-diff --git a/src/main/java/net/minecraft/server/rcon/thread/RconThread.java b/src/main/java/net/minecraft/server/rcon/thread/RconThread.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/rcon/thread/RconThread.java
-+++ b/src/main/java/net/minecraft/server/rcon/thread/RconThread.java
-@@ -0,0 +0,0 @@ public class RconThread extends GenericThread {
-     @Nullable
-     public static RconThread create(ServerInterface server) {
-         DedicatedServerProperties dedicatedServerProperties = server.getProperties();
--        String string = server.getServerIp();
-+        String string = dedicatedServerProperties.rconIp; // Paper - Configurable rcon ip
-         if (string.isEmpty()) {
-             string = "0.0.0.0";
-         }

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

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

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

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

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

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

patches/unapplied/server/Configurable-projectile-relative-velocity.patch

@@ -1,39 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Lucavon <lucavonlp@gmail.com>
-Date: Tue, 23 Jul 2019 20:29:20 -0500
-Subject: [PATCH] Configurable projectile relative velocity
-
-This patch adds an option "disable relative projectile velocity", which, when
-enabled, will cause projectiles to ignore the shooter's current velocity,
-like they did in Minecraft 1.8 and prior.
-If a player is falling, for example, their shooting range will be drastically
-reduced, as a downwards velocity is applied to the projectile. This prevents
-players from saving themselves from falling off floating islands, for example,
-as a thrown ender pearl will not make it back to the island, while it would
-have in 1.8.
-
-While this could easily be done with plugins, too, there are multiple problems:
-P1) If multiple plugins cancel the velocity by subtracting the shooter's velocity
-from the projectile's velocity, the projectile's velocity would be different.
-As there's no way to detect whether the projectile's velocity has already been
-adjusted to ignore the player's velocity, plugins can't not do it if it's not
-necessary.
-P2) I've noticed some inconsistencies, e.g. weird velocity when shooting while
-using an elytra. Checking for those inconsistencies is possible, but not as
-efficient as just not applying the velocity in the first place.
-P3) Solutions for 1) and especially 2) might not be future-proof, while this
-server-internal fix makes this change future-proof.
-
-diff --git a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
-+++ b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
-@@ -0,0 +0,0 @@ public abstract class Projectile extends Entity {
-         this.shoot((double) f5, (double) f6, (double) f7, speed, divergence);
-         Vec3 vec3d = shooter.getDeltaMovement();
- 
--        this.setDeltaMovement(this.getDeltaMovement().add(vec3d.x, shooter.isOnGround() ? 0.0D : vec3d.y, vec3d.z));
-+        if (!shooter.level.paperConfig().misc.disableRelativeProjectileVelocity) this.setDeltaMovement(this.getDeltaMovement().add(vec3d.x, shooter.isOnGround() ? 0.0D : vec3d.y, vec3d.z)); // Paper - allow disabling relative velocity
-     }
- 
-     // CraftBukkit start - call projectile hit event

patches/unapplied/server/Configurable-spawn-chances-for-skeleton-horses.patch

@@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Zach Brown <1254957+zachbr@users.noreply.github.com>
-Date: Tue, 22 Mar 2016 12:04:28 -0500
-Subject: [PATCH] Configurable spawn chances for skeleton horses
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
-             blockposition = this.findLightningTargetAround(this.getBlockRandomPos(j, 0, k, 15));
-             if (this.isRainingAt(blockposition)) {
-                 DifficultyInstance difficultydamagescaler = this.getCurrentDifficultyAt(blockposition);
--                boolean flag1 = this.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && this.random.nextDouble() < (double) difficultydamagescaler.getEffectiveDifficulty() * 0.01D && !this.getBlockState(blockposition.below()).is(Blocks.LIGHTNING_ROD);
-+                boolean flag1 = this.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && this.random.nextDouble() < (double) difficultydamagescaler.getEffectiveDifficulty() * this.paperConfig().entities.spawning.skeletonHorseThunderSpawnChance.or(0.01D) && !this.getBlockState(blockposition.below()).is(Blocks.LIGHTNING_ROD); // Paper
- 
-                 if (flag1) {
-                     SkeletonHorse entityhorseskeleton = (SkeletonHorse) EntityType.SKELETON_HORSE.create(this);

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

@@ -1,48 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Byteflux <byte@byteflux.net>
-Date: Wed, 8 Aug 2018 16:33:21 -0600
-Subject: [PATCH] Configurable speed for water flowing over lava
-
-
-diff --git a/src/main/java/net/minecraft/world/level/block/LiquidBlock.java b/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/LiquidBlock.java
-@@ -0,0 +0,0 @@ public class LiquidBlock extends Block implements BucketPickup {
-     @Override
-     public void onPlace(BlockState state, Level world, BlockPos pos, BlockState oldState, boolean notify) {
-         if (this.shouldSpreadLiquid(world, pos, state)) {
--            world.scheduleTick(pos, state.getFluidState().getType(), this.fluid.getTickDelay(world));
-+            world.scheduleTick(pos, state.getFluidState().getType(), this.getFlowSpeed(world, pos)); // Paper
-         }
- 
-     }
- 
-+    // Paper start - Get flow speed. Throttle if its water and flowing adjacent to lava
-+    public int getFlowSpeed(Level world, BlockPos blockposition) {
-+        if (this.material == net.minecraft.world.level.material.Material.WATER) {
-+            if (
-+                world.getMaterialIfLoaded(blockposition.north(1)) == net.minecraft.world.level.material.Material.LAVA ||
-+                world.getMaterialIfLoaded(blockposition.south(1)) == net.minecraft.world.level.material.Material.LAVA ||
-+                world.getMaterialIfLoaded(blockposition.west(1)) == net.minecraft.world.level.material.Material.LAVA ||
-+                world.getMaterialIfLoaded(blockposition.east(1)) == net.minecraft.world.level.material.Material.LAVA
-+            ) {
-+                return world.paperConfig().environment.waterOverLavaFlowSpeed;
-+            }
-+        }
-+        return this.fluid.getTickDelay(world);
-+    }
-+    // Paper end
-+
-     @Override
-     public BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
-         if (state.getFluidState().isSource() || neighborState.getFluidState().isSource()) {
-@@ -0,0 +0,0 @@ public class LiquidBlock extends Block implements BucketPickup {
-     @Override
-     public void neighborChanged(BlockState state, Level world, BlockPos pos, Block sourceBlock, BlockPos sourcePos, boolean notify) {
-         if (this.shouldSpreadLiquid(world, pos, state)) {
--            world.scheduleTick(pos, state.getFluidState().getType(), this.fluid.getTickDelay(world));
-+            world.scheduleTick(pos, state.getFluidState().getType(), this.getFlowSpeed(world, pos)); // Paper
-         }
- 
-     }

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

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

patches/unapplied/server/Custom-replacement-for-eaten-items.patch

@@ -1,48 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jedediah Smith <jedediah@silencegreys.com>
-Date: Sun, 21 Jun 2015 15:07:20 -0400
-Subject: [PATCH] Custom replacement for eaten items
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity {
-                     this.triggerItemUseEffects(this.useItem, 16);
-                     // CraftBukkit start - fire PlayerItemConsumeEvent
-                     ItemStack itemstack;
-+                PlayerItemConsumeEvent event = null; // Paper
-                     if (this instanceof ServerPlayer) {
-                         org.bukkit.inventory.ItemStack craftItem = CraftItemStack.asBukkitCopy(this.useItem);
--                        PlayerItemConsumeEvent event = new PlayerItemConsumeEvent((Player) this.getBukkitEntity(), craftItem);
-+                    event = new PlayerItemConsumeEvent((Player) this.getBukkitEntity(), craftItem); // Paper
-                         level.getCraftServer().getPluginManager().callEvent(event);
- 
-                         if (event.isCancelled()) {
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity {
-                     } else {
-                         itemstack = this.useItem.finishUsingItem(this.level, this);
-                     }
-+
-+                // Paper start - save the default replacement item and change it if necessary
-+                final ItemStack defaultReplacement = itemstack;
-+                if (event != null && event.getReplacement() != null) {
-+                    itemstack = CraftItemStack.asNMSCopy(event.getReplacement());
-+                }
-+                // Paper end
-                     // CraftBukkit end
- 
-                     if (itemstack != this.useItem) {
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity {
-                     }
- 
-                     this.stopUsingItem();
-+                // Paper start - if the replacement is anything but the default, update the client inventory
-+                if (this instanceof ServerPlayer && !com.google.common.base.Objects.equal(defaultReplacement, itemstack)) {
-+                    ((ServerPlayer) this).getBukkitEntity().updateInventory();
-+                }
-+                // Paper end
-                 }
- 
-             }

patches/unapplied/server/Default-loading-permissions.yml-before-plugins.patch

@@ -1,38 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Fri, 18 Mar 2016 13:17:38 -0400
-Subject: [PATCH] Default loading permissions.yml before plugins
-
-Under previous behavior, plugins were not able to check if a player had a permission
-if it was defined in permissions.yml. there is no clean way for a plugin to fix that either.
-
-This will change the order so that by default, permissions.yml loads BEFORE plugins instead of after.
-
-This gives plugins expected permission checks.
-
-It also helps improve the expected logic, as servers should set the initial defaults, and then let plugins
-modify that. Under the previous logic, plugins were unable (cleanly) override permissions.yml.
-
-A config option has been added for those who depend on the previous behavior, but I don't expect that.
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-         if (type == PluginLoadOrder.STARTUP) {
-             this.helpMap.clear();
-             this.helpMap.initializeGeneralTopics();
-+            if (io.papermc.paper.configuration.GlobalConfiguration.get().misc.loadPermissionsYmlBeforePlugins) loadCustomPermissions(); // Paper
-         }
- 
-         Plugin[] plugins = this.pluginManager.getPlugins();
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
-             this.commandMap.registerServerAliases();
-             DefaultPermissions.registerCorePermissions();
-             CraftDefaultPermissions.registerCorePermissions();
--            this.loadCustomPermissions();
-+            if (!io.papermc.paper.configuration.GlobalConfiguration.get().misc.loadPermissionsYmlBeforePlugins) this.loadCustomPermissions(); // Paper
-             this.helpMap.initializeCommands();
-             this.syncCommands();
-         }

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

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

patches/unapplied/server/Do-not-let-armorstands-drown.patch

@@ -1,23 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Zach Brown <1254957+zachbr@users.noreply.github.com>
-Date: Sat, 18 Feb 2017 19:29:58 -0600
-Subject: [PATCH] Do not let armorstands drown
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-+++ b/src/main/java/net/minecraft/world/entity/decoration/ArmorStand.java
-@@ -0,0 +0,0 @@ public class ArmorStand extends LivingEntity {
-             super.move(type, movement);
-         }
-     }
-+
-+    // Paper start
-+    @Override
-+    public boolean canBreatheUnderwater() { // Skips a bit of damage handling code, probably a micro-optimization
-+        return true;
-+    }
-+    // Paper end
-     // Paper end
- }

patches/unapplied/server/Do-not-load-chunks-for-Pathfinding.patch

@@ -1,42 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Thu, 31 Mar 2016 19:17:58 -0400
-Subject: [PATCH] Do not load chunks for Pathfinding
-
-
-diff --git a/src/main/java/net/minecraft/world/level/pathfinder/WalkNodeEvaluator.java b/src/main/java/net/minecraft/world/level/pathfinder/WalkNodeEvaluator.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/pathfinder/WalkNodeEvaluator.java
-+++ b/src/main/java/net/minecraft/world/level/pathfinder/WalkNodeEvaluator.java
-@@ -0,0 +0,0 @@ public class WalkNodeEvaluator extends NodeEvaluator {
-                 for(int n = -1; n <= 1; ++n) {
-                     if (l != 0 || n != 0) {
-                         pos.set(i + l, j + m, k + n);
--                        BlockState blockState = world.getBlockState(pos);
-+                        // Paper start
-+                        BlockState blockState = world.getBlockStateIfLoaded(pos);
-+                        if (blockState == null) {
-+                            return BlockPathTypes.BLOCKED;
-+                        } else {
-+                        // Paper end
-                         if (blockState.is(Blocks.CACTUS)) {
-                             return BlockPathTypes.DANGER_CACTUS;
-                         }
-@@ -0,0 +0,0 @@ public class WalkNodeEvaluator extends NodeEvaluator {
-                         if (world.getFluidState(pos).is(FluidTags.WATER)) {
-                             return BlockPathTypes.WATER_BORDER;
-                         }
-+                        } // Paper
-                     }
-                 }
-             }
-@@ -0,0 +0,0 @@ public class WalkNodeEvaluator extends NodeEvaluator {
-     }
- 
-     protected static BlockPathTypes getBlockPathTypeRaw(BlockGetter world, BlockPos pos) {
--        BlockState blockState = world.getBlockState(pos);
-+        BlockState blockState = world.getBlockStateIfLoaded(pos); // Paper
-+        if (blockState == null) return BlockPathTypes.BLOCKED; // Paper
-         Block block = blockState.getBlock();
-         Material material = blockState.getMaterial();
-         if (blockState.isAir()) {

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

@@ -1,77 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Sun, 8 Aug 2021 16:26:46 -0700
-Subject: [PATCH] Do not submit profile lookups to worldgen threads
-
-They block. On network I/O.
-
-If enough tasks are submitted the server will eventually stall
-out due to a sync load, as the worldgen threads will be
-stalling on profile lookups.
-
-diff --git a/src/main/java/net/minecraft/Util.java b/src/main/java/net/minecraft/Util.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/Util.java
-+++ b/src/main/java/net/minecraft/Util.java
-@@ -0,0 +0,0 @@ public class Util {
-     private static final AtomicInteger WORKER_COUNT = new AtomicInteger(1);
-     private static final ExecutorService BOOTSTRAP_EXECUTOR = makeExecutor("Bootstrap");
-     private static final ExecutorService BACKGROUND_EXECUTOR = makeExecutor("Main");
-+    // Paper start - don't submit BLOCKING PROFILE LOOKUPS to the world gen thread
-+    public static final ExecutorService PROFILE_EXECUTOR = Executors.newFixedThreadPool(2, new java.util.concurrent.ThreadFactory() {
-+
-+        private final AtomicInteger count = new AtomicInteger();
-+
-+        @Override
-+        public Thread newThread(Runnable run) {
-+            Thread ret = new Thread(run);
-+            ret.setName("Profile Lookup Executor #" + this.count.getAndIncrement());
-+            ret.setUncaughtExceptionHandler((Thread thread, Throwable throwable) -> {
-+                LOGGER.error("Uncaught exception in thread " + thread.getName(), throwable);
-+            });
-+            return ret;
-+        }
-+    });
-+    // Paper end - don't submit BLOCKING PROFILE LOOKUPS to the world gen thread
-     private static final ExecutorService IO_POOL = makeIoExecutor();
-     public static LongSupplier timeSource = System::nanoTime;
-     public static final Ticker TICKER = new Ticker() {
-diff --git a/src/main/java/net/minecraft/server/players/GameProfileCache.java b/src/main/java/net/minecraft/server/players/GameProfileCache.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/players/GameProfileCache.java
-+++ b/src/main/java/net/minecraft/server/players/GameProfileCache.java
-@@ -0,0 +0,0 @@ public class GameProfileCache {
-             } else {
-                 this.requests.put(username, CompletableFuture.supplyAsync(() -> {
-                     return this.get(username);
--                }, Util.backgroundExecutor()).whenCompleteAsync((optional, throwable) -> {
-+                }, Util.PROFILE_EXECUTOR).whenCompleteAsync((optional, throwable) -> { // Paper - not a good idea to use BLOCKING OPERATIONS on the worldgen executor
-                     this.requests.remove(username);
-                 }, this.executor).whenCompleteAsync((optional, throwable) -> {
-                     consumer.accept(optional);
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/SkullBlockEntity.java
-@@ -0,0 +0,0 @@ public class SkullBlockEntity extends BlockEntity {
-     public static void updateGameprofile(@Nullable GameProfile owner, Consumer<GameProfile> callback) {
-         if (owner != null && !StringUtil.isNullOrEmpty(owner.getName()) && (!owner.isComplete() || !owner.getProperties().containsKey("textures")) && profileCache != null && sessionService != null) {
-             profileCache.getAsync(owner.getName(), (profile) -> {
--                Util.backgroundExecutor().execute(() -> {
-+                Util.PROFILE_EXECUTOR.execute(() -> { // Paper - not a good idea to use BLOCKING OPERATIONS on the worldgen executor
-                     Util.ifElse(profile, (profilex) -> {
-                         Property property = Iterables.getFirst(profilex.getProperties().get("textures"), (Property)null);
-                         if (property == null) {
-diff --git a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
-+++ b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
-@@ -0,0 +0,0 @@ public final class CraftPlayerProfile implements PlayerProfile {
- 
-     @Override
-     public CompletableFuture<PlayerProfile> update() {
--        return CompletableFuture.supplyAsync(this::getUpdatedProfile, Util.backgroundExecutor());
-+        return CompletableFuture.supplyAsync(this::getUpdatedProfile, Util.PROFILE_EXECUTOR); // Paper - not a good idea to use BLOCKING OPERATIONS on the worldgen executor
-     }
- 
-     private CraftPlayerProfile getUpdatedProfile() {

patches/unapplied/server/Don-t-allow-digging-into-unloaded-chunks.patch

@@ -1,77 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Shane Freeder <theboyetronic@gmail.com>
-Date: Sun, 11 Nov 2018 21:01:09 +0000
-Subject: [PATCH] Don't allow digging into unloaded chunks
-
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
-@@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
-         BlockState iblockdata;
- 
-         if (this.hasDelayedDestroy) {
--            iblockdata = this.level.getBlockState(this.delayedDestroyPos);
--            if (iblockdata.isAir()) {
-+            iblockdata = this.level.getBlockStateIfLoaded(this.delayedDestroyPos); // Paper
-+            if (iblockdata == null || iblockdata.isAir()) { // Paper
-                 this.hasDelayedDestroy = false;
-             } else {
-                 float f = this.incrementDestroyProgress(iblockdata, this.delayedDestroyPos, this.delayedTickStart);
-@@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
-                 }
-             }
-         } else if (this.isDestroyingBlock) {
--            iblockdata = this.level.getBlockState(this.destroyPos);
-+            // Paper start - don't want to do same logic as above, return instead
-+            iblockdata = this.level.getBlockStateIfLoaded(this.destroyPos);
-+            if (iblockdata == null) {
-+                this.isDestroyingBlock = false;
-+                return;
-+            }
-+            // Paper end
-             if (iblockdata.isAir()) {
-                 this.level.destroyBlockProgress(this.player.getId(), this.destroyPos, -1);
-                 this.lastSentState = -1;
-@@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
- 
-     public void handleBlockBreakAction(BlockPos pos, ServerboundPlayerActionPacket.Action action, Direction direction, int worldHeight, int sequence) {
-         if (this.player.getEyePosition().distanceToSqr(Vec3.atCenterOf(pos)) > ServerGamePacketListenerImpl.MAX_INTERACTION_DISTANCE) {
-+            if (true) return; // Paper - Don't notify if unreasonably far away
-             this.debugLogging(pos, false, sequence, "too far");
-         } else if (pos.getY() >= worldHeight) {
-             this.player.connection.send(new ClientboundBlockUpdatePacket(pos, this.level.getBlockState(pos)));
-@@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
-                 this.debugLogging(pos, true, sequence, "stopped destroying");
-             } else if (action == ServerboundPlayerActionPacket.Action.ABORT_DESTROY_BLOCK) {
-                 this.isDestroyingBlock = false;
--                if (!Objects.equals(this.destroyPos, pos)) {
-+                if (!Objects.equals(this.destroyPos, pos) && !BlockPos.ZERO.equals(this.destroyPos)) { // Paper
-                     ServerPlayerGameMode.LOGGER.debug("Mismatch in destroy block pos: {} {}", this.destroyPos, pos); // CraftBukkit - SPIGOT-5457 sent by client when interact event cancelled
--                    this.level.destroyBlockProgress(this.player.getId(), this.destroyPos, -1);
--                    this.debugLogging(pos, true, sequence, "aborted mismatched destroying");
-+                    BlockState type = this.level.getBlockStateIfLoaded(this.destroyPos); // Paper - don't load unloaded chunks for stale records here
-+                    if (type != null) this.level.destroyBlockProgress(this.player.getId(), this.destroyPos, -1);
-+                    if (type != null) this.debugLogging(pos, true, sequence, "aborted mismatched destroying");
-+                    this.destroyPos = BlockPos.ZERO; // Paper
-                 }
- 
-                 this.level.destroyBlockProgress(this.player.getId(), pos, -1);
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
-             case START_DESTROY_BLOCK:
-             case ABORT_DESTROY_BLOCK:
-             case STOP_DESTROY_BLOCK:
-+                // Paper start - Don't allow digging in unloaded chunks
-+                if (this.player.level.getChunkIfLoadedImmediately(blockposition.getX() >> 4, blockposition.getZ() >> 4) == null) {
-+                    this.player.connection.ackBlockChangesUpTo(packet.getSequence());
-+                    return;
-+                }
-+                // Paper end - Don't allow digging in unloaded chunks
-                 this.player.gameMode.handleBlockBreakAction(blockposition, packetplayinblockdig_enumplayerdigtype, packet.getDirection(), this.player.level.getMaxBuildHeight(), packet.getSequence());
-                 this.player.connection.ackBlockChangesUpTo(packet.getSequence());
-                 return;

patches/unapplied/server/Don-t-allow-entities-to-ride-themselves-572.patch

@@ -1,18 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Alfie Cleveland <alfeh@me.com>
-Date: Sun, 8 Jan 2017 04:31:36 +0000
-Subject: [PATCH] Don't allow entities to ride themselves - #572
-
-
-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 Nameable, EntityAccess, CommandSource {
-     }
- 
-     protected boolean addPassenger(Entity entity) { // CraftBukkit
-+        if (entity == this) throw new IllegalArgumentException("Entities cannot become a passenger of themselves"); // Paper - issue 572
-         if (entity.getVehicle() != this) {
-             throw new IllegalStateException("Use x.startRiding(y), not y.addPassenger(x)");
-         } else {

patches/unapplied/server/Don-t-call-getItemMeta-on-hasItemMeta.patch

@@ -1,64 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Hugo Manrique <hugmanrique@gmail.com>
-Date: Thu, 26 Jul 2018 14:10:23 +0200
-Subject: [PATCH] Don't call getItemMeta on hasItemMeta
-
-Spigot 1.13 checks if any field (which are manually copied from the ItemStack's "tag" NBT tag) on the ItemMeta class of an ItemStack is set.
-
-We could just check if the "tag" NBT tag is empty, albeit that would break some plugins. The only general tag added on 1.13 is "Damage", and we can just check if the "tag" NBT tag contains any other tag that's not "Damage" (https://minecraft.gamepedia.com/Player.dat_format#Item_structure) making the `hasItemStack` method behave as before.
-
-Returns true if getDamage() == 0 or has damage tag or other tag is set.
-Check the `ItemMetaTest#testTaggedButNotMeta` method to see how this method behaves.
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
-+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
-@@ -0,0 +0,0 @@ public final class CraftItemStack extends ItemStack {
- 
-     @Override
-     public boolean hasItemMeta() {
--        return CraftItemStack.hasItemMeta(this.handle) && !CraftItemFactory.instance().equals(this.getItemMeta(), null);
-+        return CraftItemStack.hasItemMeta(this.handle) && (this.handle.getDamageValue() != 0 || (this.handle.getTag() != null && this.handle.getTag().tags.size() >= (this.handle.getTag().contains(CraftMetaItem.DAMAGE.NBT) ? 2 : 1))); // Paper - keep 1.12 CraftBukkit behavior without calling getItemMeta
-     }
- 
-     static boolean hasItemMeta(net.minecraft.world.item.ItemStack item) {
-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 {
-         assertThat(itemMeta.hasConflictingEnchant(null), is(false));
-     }
- 
-+    // Paper start
-+    private void testItemMeta(ItemStack stack) {
-+        assertThat("Should not have ItemMeta", stack.hasItemMeta(), is(false));
-+
-+        stack.setDurability((short) 0);
-+        assertThat("ItemStack with zero durability should not have ItemMeta", stack.hasItemMeta(), is(false));
-+
-+        stack.setDurability((short) 2);
-+        assertThat("ItemStack with non-zero durability should have ItemMeta", stack.hasItemMeta(), is(true));
-+
-+        stack.setLore(java.util.Collections.singletonList("Lore"));
-+        assertThat("ItemStack with lore and durability should have ItemMeta", stack.hasItemMeta(), is(true));
-+
-+        stack.setDurability((short) 0);
-+        assertThat("ItemStack with lore should have ItemMeta", stack.hasItemMeta(), is(true));
-+
-+        stack.setLore(null);
-+    }
-+
-+    @Test
-+    public void testHasItemMeta() {
-+        ItemStack itemStack = new ItemStack(Material.SHEARS);
-+
-+        testItemMeta(itemStack);
-+        testItemMeta(CraftItemStack.asCraftCopy(itemStack));
-+    }
-+    // Paper end
-+
-     @Test
-     public void testConflictingStoredEnchantment() {
-         EnchantmentStorageMeta itemMeta = (EnchantmentStorageMeta) Bukkit.getItemFactory().getItemMeta(Material.ENCHANTED_BOOK);

patches/unapplied/server/Don-t-check-ConvertSigns-boolean-every-sign-save.patch

@@ -1,29 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sat, 2 Mar 2019 11:11:29 -0500
-Subject: [PATCH] Don't check ConvertSigns boolean every sign save
-
-property lookups arent super cheap. they synchronize, validate
-and check security managers.
-
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.phys.Vec2;
- import net.minecraft.world.phys.Vec3;
- 
- public class SignBlockEntity extends BlockEntity implements CommandSource { // CraftBukkit - implements
-+    private static final boolean CONVERT_LEGACY_SIGNS = Boolean.getBoolean("convertLegacySigns"); // Paper
- 
-     public static final int LINES = 4;
-     private static final String[] RAW_TEXT_FIELD_NAMES = new String[]{"Text1", "Text2", "Text3", "Text4"};
-@@ -0,0 +0,0 @@ public class SignBlockEntity extends BlockEntity implements CommandSource { // C
-         }
- 
-         // CraftBukkit start
--        if (Boolean.getBoolean("convertLegacySigns")) {
-+        if (CONVERT_LEGACY_SIGNS) { // Paper
-             nbt.putBoolean("Bukkit.isConverted", true);
-         }
-         // CraftBukkit end

patches/unapplied/server/Don-t-load-Chunks-from-Hoppers-and-other-things.patch

@@ -1,32 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Thu, 3 Nov 2016 20:28:12 -0400
-Subject: [PATCH] Don't load Chunks from Hoppers and other things
-
-Hoppers call this to I guess "get the primary side" of a double sided chest.
-
-If the double sided chest crosses chunk lines, it causes the chunk to load.
-This will end up causing sync chunk loads, which will unload with Chunk GC,
-only to be reloaded again the next tick.
-
-This of course is undesirable, so just return the loaded side as "primary"
-and treat it as a single chest if the other sides are unloaded
-
-diff --git a/src/main/java/net/minecraft/world/level/block/DoubleBlockCombiner.java b/src/main/java/net/minecraft/world/level/block/DoubleBlockCombiner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/DoubleBlockCombiner.java
-+++ b/src/main/java/net/minecraft/world/level/block/DoubleBlockCombiner.java
-@@ -0,0 +0,0 @@ public class DoubleBlockCombiner {
-                 return new DoubleBlockCombiner.NeighborCombineResult.Single<>(blockEntity);
-             } else {
-                 BlockPos blockPos = pos.relative(function.apply(state));
--                BlockState blockState = world.getBlockState(blockPos);
-+                // Paper start
-+                BlockState blockState = world.getBlockStateIfLoaded(blockPos);
-+                if (blockState == null) {
-+                    return new DoubleBlockCombiner.NeighborCombineResult.Single<>(blockEntity);
-+                }
-+                // Paper end
-                 if (blockState.is(state.getBlock())) {
-                     DoubleBlockCombiner.BlockType blockType2 = typeMapper.apply(blockState);
-                     if (blockType2 != DoubleBlockCombiner.BlockType.SINGLE && blockType != blockType2 && blockState.getValue(directionProperty) == state.getValue(directionProperty)) {

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

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

patches/unapplied/server/Don-t-save-empty-scoreboard-teams-to-scoreboard.dat.patch

@@ -1,18 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sat, 7 May 2016 23:33:08 -0400
-Subject: [PATCH] Don't save empty scoreboard teams to scoreboard.dat
-
-
-diff --git a/src/main/java/net/minecraft/world/scores/ScoreboardSaveData.java b/src/main/java/net/minecraft/world/scores/ScoreboardSaveData.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/scores/ScoreboardSaveData.java
-+++ b/src/main/java/net/minecraft/world/scores/ScoreboardSaveData.java
-@@ -0,0 +0,0 @@ public class ScoreboardSaveData extends SavedData {
-         ListTag listTag = new ListTag();
- 
-         for(PlayerTeam playerTeam : this.scoreboard.getPlayerTeams()) {
-+            if (!io.papermc.paper.configuration.GlobalConfiguration.get().scoreboards.saveEmptyScoreboardTeams && playerTeam.getPlayers().isEmpty()) continue; // Paper
-             CompoundTag compoundTag = new CompoundTag();
-             compoundTag.putString("Name", playerTeam.getName());
-             compoundTag.putString("DisplayName", Component.Serializer.toJson(playerTeam.getDisplayName()));

patches/unapplied/server/Don-t-sleep-after-profile-lookups-if-not-needed.patch

@@ -1,33 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Tue, 23 Oct 2018 20:25:05 -0400
-Subject: [PATCH] Don't sleep after profile lookups if not needed
-
-Mojang was sleeping even if we had no more requests to go after
-the current one finished, resulting in 100ms lost per profile lookup
-
-diff --git a/src/main/java/com/mojang/authlib/yggdrasil/YggdrasilGameProfileRepository.java b/src/main/java/com/mojang/authlib/yggdrasil/YggdrasilGameProfileRepository.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/com/mojang/authlib/yggdrasil/YggdrasilGameProfileRepository.java
-+++ b/src/main/java/com/mojang/authlib/yggdrasil/YggdrasilGameProfileRepository.java
-@@ -0,0 +0,0 @@ public class YggdrasilGameProfileRepository implements GameProfileRepository {
-         }
- 
-         final int page = 0;
-+        boolean hasRequested = false; // Paper
- 
-         for (final List<String> request : Iterables.partition(criteria, ENTRIES_PER_PAGE)) {
-             int failCount = 0;
-@@ -0,0 +0,0 @@ public class YggdrasilGameProfileRepository implements GameProfileRepository {
-                         LOGGER.debug("Couldn't find profile {}", name);
-                         callback.onProfileLookupFailed(new GameProfile(null, name), new ProfileNotFoundException("Server did not find the requested profile"));
-                     }
-+                    // Paper start
-+                    if (!hasRequested) {
-+                        hasRequested = true;
-+                        continue;
-+                    }
-+                    // Paper end
- 
-                     try {
-                         Thread.sleep(DELAY_BETWEEN_PAGES);