Patch updates

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

@@ -1,202 +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
-
-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.resources.ResourceLocation;
- import net.minecraft.util.profiling.jfr.JvmProfiler;
-+import net.minecraft.nbt.CompoundTag; // Paper
-+import net.minecraft.nbt.NbtIo; // Paper
- import net.minecraft.world.level.ChunkPos;
- import org.slf4j.Logger;
- 
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable {
-         this.usedSectors = new RegionBitmap();
-         this.info = storageKey;
-         this.path = path;
-+        initOversizedState(); // Paper
-         this.version = compressionFormat;
-         if (!Files.isDirectory(directory, new LinkOption[0])) {
-             throw new IllegalArgumentException("Expected directory, got " + String.valueOf(directory.toAbsolutePath()));
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable {
- 
-     }
- 
-+    // Paper start
-+    private final byte[] oversized = new byte[1024];
-+    private int oversizedCount;
-+
-+    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.path.getParent().resolve(this.path.getFileName().toString().replaceAll("\\.mca$", "") + ".oversized.nbt");
-+    }
-+
-+    private Path getOversizedFile(int x, int z) {
-+        return this.path.getParent().resolve(this.path.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 @@ public final 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 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) {
-+        net.minecraft.nbt.ListTag levelList = level.getList(key, net.minecraft.nbt.Tag.TAG_COMPOUND);
-+        net.minecraft.nbt.ListTag oversizedList = oversizedLevel.getList(oversizedKey, net.minecraft.nbt.Tag.TAG_COMPOUND);
-+
-+        if (!oversizedList.isEmpty()) {
-+            levelList.addAll(oversizedList);
-+            level.put(key, levelList);
-+        }
-+    }
-+    // 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 final class RegionFileStorage implements AutoCloseable {
-         // CraftBukkit end
-         DataInputStream datainputstream = regionfile.getChunkDataInputStream(pos);
- 
-+        // Paper start
-+        if (regionfile.isOversized(pos.x, pos.z)) {
-+            printOversizedLog("Loading Oversized Chunk!", regionfile.getPath(), pos.x, pos.z);
-+            return readOversizedChunk(regionfile, pos);
-+        }
-+        // Paper end
-         CompoundTag nbttagcompound;
-         label43:
-         {
-@@ -0,0 +0,0 @@ public final 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/server/Attempt-to-recalculate-regionfile-header-if-it-is-co.patch

@@ -1,742 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Sun, 2 Feb 2020 02:25:10 -0800
-Subject: [PATCH] Attempt to recalculate regionfile header if it is corrupt
-
-Instead of trying to relocate the chunk, which is seems to never
-be the correct choice, so we end up duplicating or swapping chunks,
-we instead drop the current regionfile header and recalculate -
-hoping that at least then we don't swap chunks, and maybe recover
-them all.
-
-diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionBitmap.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionBitmap.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionBitmap.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionBitmap.java
-@@ -0,0 +0,0 @@ import java.util.BitSet;
- public class RegionBitmap {
-     private final BitSet used = new BitSet();
- 
-+    // Paper start - Attempt to recalculate regionfile header if it is corrupt
-+    public final void copyFrom(RegionBitmap other) {
-+        BitSet thisBitset = this.used;
-+        BitSet otherBitset = other.used;
-+
-+        for (int i = 0; i < Math.max(thisBitset.size(), otherBitset.size()); ++i) {
-+            thisBitset.set(i, otherBitset.get(i));
-+        }
-+    }
-+
-+    public final boolean tryAllocate(int from, int length) {
-+        BitSet bitset = this.used;
-+        int firstSet = bitset.nextSetBit(from);
-+        if (firstSet > 0 && firstSet < (from + length)) {
-+            return false;
-+        }
-+        bitset.set(from, from + length);
-+        return true;
-+    }
-+    // Paper end - Attempt to recalculate regionfile header if it is corrupt
-+
-     public void force(int start, int size) {
-         this.used.set(start, start + size);
-     }
-diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
-     private final IntBuffer timestamps;
-     @VisibleForTesting
-     protected final RegionBitmap usedSectors;
-+    // Paper start - Attempt to recalculate regionfile header if it is corrupt
-+    private static long roundToSectors(long bytes) {
-+        long sectors = bytes >>> 12; // 4096 = 2^12
-+        long remainingBytes = bytes & 4095;
-+        long sign = -remainingBytes; // sign is 1 if nonzero
-+        return sectors + (sign >>> 63);
-+    }
-+
-+    private static final CompoundTag OVERSIZED_COMPOUND = new CompoundTag();
-+
-+    private CompoundTag attemptRead(long sector, int chunkDataLength, long fileLength) throws IOException {
-+        try {
-+            if (chunkDataLength < 0) {
-+                return null;
-+            }
-+
-+            long offset = sector * 4096L + 4L; // offset for chunk data
-+
-+            if ((offset + chunkDataLength) > fileLength) {
-+                return null;
-+            }
-+
-+            ByteBuffer chunkData = ByteBuffer.allocate(chunkDataLength);
-+            if (chunkDataLength != this.file.read(chunkData, offset)) {
-+                return null;
-+            }
-+
-+            ((java.nio.Buffer)chunkData).flip();
-+
-+            byte compressionType = chunkData.get();
-+            if (compressionType < 0) { // compressionType & 128 != 0
-+                // oversized chunk
-+                return OVERSIZED_COMPOUND;
-+            }
-+
-+            RegionFileVersion compression = RegionFileVersion.fromId(compressionType);
-+            if (compression == null) {
-+                return null;
-+            }
-+
-+            InputStream input = compression.wrap(new ByteArrayInputStream(chunkData.array(), chunkData.position(), chunkDataLength - chunkData.position()));
-+
-+            return NbtIo.read(new DataInputStream(input));
-+        } catch (Exception ex) {
-+            return null;
-+        }
-+    }
-+
-+    private int getLength(long sector) throws IOException {
-+        ByteBuffer length = ByteBuffer.allocate(4);
-+        if (4 != this.file.read(length, sector * 4096L)) {
-+            return -1;
-+        }
-+
-+        return length.getInt(0);
-+    }
-+
-+    private void backupRegionFile() {
-+        Path backup = this.path.getParent().resolve(this.path.getFileName() + "." + new java.util.Random().nextLong() + ".backup");
-+        this.backupRegionFile(backup);
-+    }
-+
-+    private void backupRegionFile(Path to) {
-+        try {
-+            this.file.force(true);
-+            LOGGER.warn("Backing up regionfile \"" + this.path.toAbsolutePath() + "\" to " + to.toAbsolutePath());
-+            java.nio.file.Files.copy(this.path, to, java.nio.file.StandardCopyOption.COPY_ATTRIBUTES);
-+            LOGGER.warn("Backed up the regionfile to " + to.toAbsolutePath());
-+        } catch (IOException ex) {
-+            LOGGER.error("Failed to backup to " + to.toAbsolutePath(), ex);
-+        }
-+    }
-+
-+    private static boolean inSameRegionfile(ChunkPos first, ChunkPos second) {
-+        return (first.x & ~31) == (second.x & ~31) && (first.z & ~31) == (second.z & ~31);
-+    }
-+
-+    // note: only call for CHUNK regionfiles
-+    boolean recalculateHeader() throws IOException {
-+        if (!this.canRecalcHeader) {
-+            return false;
-+        }
-+        ChunkPos ourLowerLeftPosition = RegionFileStorage.getRegionFileCoordinates(this.path);
-+        if (ourLowerLeftPosition == null) {
-+            LOGGER.error("Unable to get chunk location of regionfile " + this.path.toAbsolutePath() + ", cannot recover header");
-+            return false;
-+        }
-+        synchronized (this) {
-+            LOGGER.warn("Corrupt regionfile header detected! Attempting to re-calculate header offsets for regionfile " + this.path.toAbsolutePath(), new Throwable());
-+
-+            // try to backup file so maybe it could be sent to us for further investigation
-+
-+            this.backupRegionFile();
-+            CompoundTag[] compounds = new CompoundTag[32 * 32]; // only in the regionfile (i.e exclude mojang/aikar oversized data)
-+            int[] rawLengths = new int[32 * 32]; // length of chunk data including 4 byte length field, bytes
-+            int[] sectorOffsets = new int[32 * 32]; // in sectors
-+            boolean[] hasAikarOversized = new boolean[32 * 32];
-+
-+            long fileLength = this.file.size();
-+            long totalSectors = roundToSectors(fileLength);
-+
-+            // search the regionfile from start to finish for the most up-to-date chunk data
-+
-+            for (long i = 2, maxSector = Math.min((long)(Integer.MAX_VALUE >>> 8), totalSectors); i < maxSector; ++i) { // first two sectors are header, skip
-+                int chunkDataLength = this.getLength(i);
-+                CompoundTag compound = this.attemptRead(i, chunkDataLength, fileLength);
-+                if (compound == null || compound == OVERSIZED_COMPOUND) {
-+                    continue;
-+                }
-+
-+                ChunkPos chunkPos = SerializableChunkData.getChunkCoordinate(compound);
-+                if (!inSameRegionfile(ourLowerLeftPosition, chunkPos)) {
-+                    LOGGER.error("Ignoring absolute chunk " + chunkPos + " in regionfile as it is not contained in the bounds of the regionfile '" + this.path.toAbsolutePath() + "'. It should be in regionfile (" + (chunkPos.x >> 5) + "," + (chunkPos.z >> 5) + ")");
-+                    continue;
-+                }
-+                int location = (chunkPos.x & 31) | ((chunkPos.z & 31) << 5);
-+
-+                CompoundTag otherCompound = compounds[location];
-+
-+                if (otherCompound != null && SerializableChunkData.getLastWorldSaveTime(otherCompound) > SerializableChunkData.getLastWorldSaveTime(compound)) {
-+                    continue; // don't overwrite newer data.
-+                }
-+
-+                // aikar oversized?
-+                Path aikarOversizedFile = this.getOversizedFile(chunkPos.x, chunkPos.z);
-+                boolean isAikarOversized = false;
-+                if (Files.exists(aikarOversizedFile)) {
-+                    try {
-+                        CompoundTag aikarOversizedCompound = this.getOversizedData(chunkPos.x, chunkPos.z);
-+                        if (SerializableChunkData.getLastWorldSaveTime(compound) == SerializableChunkData.getLastWorldSaveTime(aikarOversizedCompound)) {
-+                            // best we got for an id. hope it's good enough
-+                            isAikarOversized = true;
-+                        }
-+                    } catch (Exception ex) {
-+                        LOGGER.error("Failed to read aikar oversized data for absolute chunk (" + chunkPos.x + "," + chunkPos.z + ") in regionfile " + this.path.toAbsolutePath() + ", oversized data for this chunk will be lost", ex);
-+                        // fall through, if we can't read aikar oversized we can't risk corrupting chunk data
-+                    }
-+                }
-+
-+                hasAikarOversized[location] = isAikarOversized;
-+                compounds[location] = compound;
-+                rawLengths[location] = chunkDataLength + 4;
-+                sectorOffsets[location] = (int)i;
-+
-+                int chunkSectorLength = (int)roundToSectors(rawLengths[location]);
-+                i += chunkSectorLength;
-+                --i; // gets incremented next iteration
-+            }
-+
-+            // forge style oversized data is already handled by the local search, and aikar data we just hope
-+            // we get it right as aikar data has no identifiers we could use to try and find its corresponding
-+            // local data compound
-+
-+            java.nio.file.Path containingFolder = this.externalFileDir;
-+            Path[] regionFiles = Files.list(containingFolder).toArray(Path[]::new);
-+            boolean[] oversized = new boolean[32 * 32];
-+            RegionFileVersion[] oversizedCompressionTypes = new RegionFileVersion[32 * 32];
-+
-+            if (regionFiles != null) {
-+                int lowerXBound = ourLowerLeftPosition.x; // inclusive
-+                int lowerZBound = ourLowerLeftPosition.z; // inclusive
-+                int upperXBound = lowerXBound + 32 - 1; // inclusive
-+                int upperZBound = lowerZBound + 32 - 1; // inclusive
-+
-+                // read mojang oversized data
-+                for (Path regionFile : regionFiles) {
-+                    ChunkPos oversizedCoords = getOversizedChunkPair(regionFile);
-+                    if (oversizedCoords == null) {
-+                        continue;
-+                    }
-+
-+                    if ((oversizedCoords.x < lowerXBound || oversizedCoords.x > upperXBound) || (oversizedCoords.z < lowerZBound || oversizedCoords.z > upperZBound)) {
-+                        continue; // not in our regionfile
-+                    }
-+
-+                    // ensure oversized data is valid & is newer than data in the regionfile
-+
-+                    int location = (oversizedCoords.x & 31) | ((oversizedCoords.z & 31) << 5);
-+
-+                    byte[] chunkData;
-+                    try {
-+                        chunkData = Files.readAllBytes(regionFile);
-+                    } catch (Exception ex) {
-+                        LOGGER.error("Failed to read oversized chunk data in file " + regionFile.toAbsolutePath() + ", data will be lost", ex);
-+                        continue;
-+                    }
-+
-+                    CompoundTag compound = null;
-+
-+                    // We do not know the compression type, as it's stored in the regionfile. So we need to try all of them
-+                    RegionFileVersion compression = null;
-+                    for (RegionFileVersion compressionType : RegionFileVersion.VERSIONS.values()) {
-+                        try {
-+                            DataInputStream in = new DataInputStream(compressionType.wrap(new ByteArrayInputStream(chunkData))); // typical java
-+                            compound = NbtIo.read((java.io.DataInput)in);
-+                            compression = compressionType;
-+                            break; // reaches here iff readNBT does not throw
-+                        } catch (Exception ex) {
-+                            continue;
-+                        }
-+                    }
-+
-+                    if (compound == null) {
-+                        LOGGER.error("Failed to read oversized chunk data in file " + regionFile.toAbsolutePath() + ", it's corrupt. Its data will be lost");
-+                        continue;
-+                    }
-+
-+                    if (!SerializableChunkData.getChunkCoordinate(compound).equals(oversizedCoords)) {
-+                        LOGGER.error("Can't use oversized chunk stored in " + regionFile.toAbsolutePath() + ", got absolute chunkpos: " + SerializableChunkData.getChunkCoordinate(compound) + ", expected " + oversizedCoords);
-+                        continue;
-+                    }
-+
-+                    if (compounds[location] == null || SerializableChunkData.getLastWorldSaveTime(compound) > SerializableChunkData.getLastWorldSaveTime(compounds[location])) {
-+                        oversized[location] = true;
-+                        oversizedCompressionTypes[location] = compression;
-+                    }
-+                }
-+            }
-+
-+            // now we need to calculate a new offset header
-+
-+            int[] calculatedOffsets = new int[32 * 32];
-+            RegionBitmap newSectorAllocations = new RegionBitmap();
-+            newSectorAllocations.force(0, 2); // make space for header
-+
-+            // allocate sectors for normal chunks
-+
-+            for (int chunkX = 0; chunkX < 32; ++chunkX) {
-+                for (int chunkZ = 0; chunkZ < 32; ++chunkZ) {
-+                    int location = chunkX | (chunkZ << 5);
-+
-+                    if (oversized[location]) {
-+                        continue;
-+                    }
-+
-+                    int rawLength = rawLengths[location]; // bytes
-+                    int sectorOffset = sectorOffsets[location]; // sectors
-+                    int sectorLength = (int)roundToSectors(rawLength);
-+
-+                    if (newSectorAllocations.tryAllocate(sectorOffset, sectorLength)) {
-+                        calculatedOffsets[location] = sectorOffset << 8 | (sectorLength > 255 ? 255 : sectorLength); // support forge style oversized
-+                    } else {
-+                        LOGGER.error("Failed to allocate space for local chunk (overlapping data??) at (" + chunkX + "," + chunkZ + ") in regionfile " + this.path.toAbsolutePath() + ", chunk will be regenerated");
-+                    }
-+                }
-+            }
-+
-+            // allocate sectors for oversized chunks
-+
-+            for (int chunkX = 0; chunkX < 32; ++chunkX) {
-+                for (int chunkZ = 0; chunkZ < 32; ++chunkZ) {
-+                    int location = chunkX | (chunkZ << 5);
-+
-+                    if (!oversized[location]) {
-+                        continue;
-+                    }
-+
-+                    int sectorOffset = newSectorAllocations.allocate(1);
-+                    int sectorLength = 1;
-+
-+                    try {
-+                        this.file.write(this.createExternalStub(oversizedCompressionTypes[location]), sectorOffset * 4096);
-+                        // only allocate in the new offsets if the write succeeds
-+                        calculatedOffsets[location] = sectorOffset << 8 | (sectorLength > 255 ? 255 : sectorLength); // support forge style oversized
-+                    } catch (IOException ex) {
-+                        newSectorAllocations.free(sectorOffset, sectorLength);
-+                        LOGGER.error("Failed to write new oversized chunk data holder, local chunk at (" + chunkX + "," + chunkZ + ") in regionfile " + this.path.toAbsolutePath() + " will be regenerated");
-+                    }
-+                }
-+            }
-+
-+            // rewrite aikar oversized data
-+
-+            this.oversizedCount = 0;
-+            for (int chunkX = 0; chunkX < 32; ++chunkX) {
-+                for (int chunkZ = 0; chunkZ < 32; ++chunkZ) {
-+                    int location = chunkX | (chunkZ << 5);
-+                    int isAikarOversized = hasAikarOversized[location] ? 1 : 0;
-+
-+                    this.oversizedCount += isAikarOversized;
-+                    this.oversized[location] = (byte)isAikarOversized;
-+                }
-+            }
-+
-+            if (this.oversizedCount > 0) {
-+                try {
-+                    this.writeOversizedMeta();
-+                } catch (Exception ex) {
-+                    LOGGER.error("Failed to write aikar oversized chunk meta, all aikar style oversized chunk data will be lost for regionfile " + this.path.toAbsolutePath(), ex);
-+                    Files.deleteIfExists(this.getOversizedMetaFile());
-+                }
-+            } else {
-+                Files.deleteIfExists(this.getOversizedMetaFile());
-+            }
-+
-+            this.usedSectors.copyFrom(newSectorAllocations);
-+
-+            // before we overwrite the old sectors, print a summary of the chunks that got changed.
-+
-+            LOGGER.info("Starting summary of changes for regionfile " + this.path.toAbsolutePath());
-+
-+            for (int chunkX = 0; chunkX < 32; ++chunkX) {
-+                for (int chunkZ = 0; chunkZ < 32; ++chunkZ) {
-+                    int location = chunkX | (chunkZ << 5);
-+
-+                    int oldOffset = this.offsets.get(location);
-+                    int newOffset = calculatedOffsets[location];
-+
-+                    if (oldOffset == newOffset) {
-+                        continue;
-+                    }
-+
-+                    this.offsets.put(location, newOffset); // overwrite incorrect offset
-+
-+                    if (oldOffset == 0) {
-+                        // found lost data
-+                        LOGGER.info("Found missing data for local chunk (" + chunkX + "," + chunkZ + ") in regionfile " + this.path.toAbsolutePath());
-+                    } else if (newOffset == 0) {
-+                        LOGGER.warn("Data for local chunk (" + chunkX + "," + chunkZ + ") could not be recovered in regionfile " + this.path.toAbsolutePath() + ", it will be regenerated");
-+                    } else {
-+                        LOGGER.info("Local chunk (" + chunkX + "," + chunkZ + ") changed to point to newer data or correct chunk in regionfile " + this.path.toAbsolutePath());
-+                    }
-+                }
-+            }
-+
-+            LOGGER.info("End of change summary for regionfile " + this.path.toAbsolutePath());
-+
-+            // simply destroy the timestamp header, it's not used
-+
-+            for (int i = 0; i < 32 * 32; ++i) {
-+                this.timestamps.put(i, calculatedOffsets[i] != 0 ? RegionFile.getTimestamp() : 0); // write a valid timestamp for valid chunks, I do not want to find out whatever dumb program actually checks this
-+            }
-+
-+            // write new header
-+            try {
-+                this.flush();
-+                this.file.force(true); // try to ensure it goes through...
-+                LOGGER.info("Successfully wrote new header to disk for regionfile " + this.path.toAbsolutePath());
-+            } catch (IOException ex) {
-+                LOGGER.error("Failed to write new header to disk for regionfile " + this.path.toAbsolutePath(), ex);
-+            }
-+        }
-+
-+        return true;
-+    }
-+
-+    final boolean canRecalcHeader; // final forces compile fail on new constructor
-+    // Paper end - Attempt to recalculate regionfile header if it is corrupt
- 
-     // Paper start - rewrite chunk system
-     @Override
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
-             throw new IllegalArgumentException("Expected directory, got " + String.valueOf(directory.toAbsolutePath()));
-         } else {
-             this.externalFileDir = directory;
-+            this.canRecalcHeader = RegionFileStorage.isChunkDataFolder(this.externalFileDir); // Paper - add can recalc flag
-             this.offsets = this.header.asIntBuffer();
-             ((java.nio.Buffer) this.offsets).limit(1024); // CraftBukkit - decompile error
-             ((java.nio.Buffer) this.header).position(4096); // CraftBukkit - decompile error
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
-                     RegionFile.LOGGER.warn("Region file {} has truncated header: {}", path, i);
-                 }
- 
--                long j = Files.size(path);
-+                final long j = Files.size(path); final long regionFileSize = j; // Paper - recalculate header on header corruption
- 
--                for (int k = 0; k < 1024; ++k) {
--                    int l = this.offsets.get(k);
-+                boolean needsHeaderRecalc = false; // Paper - recalculate header on header corruption
-+                boolean hasBackedUp = false; // Paper - recalculate header on header corruption
-+                for (int k = 0; k < 1024; ++k) { final int headerLocation = k; // Paper - we expect this to be the header location
-+                    final int l = this.offsets.get(k);
- 
-                     if (l != 0) {
--                        int i1 = RegionFile.getSectorNumber(l);
--                        int j1 = RegionFile.getNumSectors(l);
-+                        final int i1 = RegionFile.getSectorNumber(l); final int offset = i1; // Paper - we expect this to be offset in file in sectors
-+                        int j1 = RegionFile.getNumSectors(l); final int sectorLength; // Paper - diff on change, we expect this to be sector length of region - watch out for reassignments
-                         // Spigot start
-                         if (j1 == 255) {
-                             // We're maxed out, so we need to read the proper length from the section
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
-                             j1 = (realLen.getInt(0) + 4) / 4096 + 1;
-                         }
-                         // Spigot end
-+                        sectorLength = j1; // Paper - diff on change, we expect this to be sector length of region
- 
-                         if (i1 < 2) {
-                             RegionFile.LOGGER.warn("Region file {} has invalid sector at index: {}; sector {} overlaps with header", new Object[]{path, k, i1});
--                            this.offsets.put(k, 0);
-+                            //this.offsets.put(k, 0); // Paper - we catch this, but need it in the header for the summary change
-                         } else if (j1 == 0) {
-                             RegionFile.LOGGER.warn("Region file {} has an invalid sector at index: {}; size has to be > 0", path, k);
--                            this.offsets.put(k, 0);
-+                            //this.offsets.put(k, 0); // Paper - we catch this, but need it in the header for the summary change
-                         } else if ((long) i1 * 4096L > j) {
-                             RegionFile.LOGGER.warn("Region file {} has an invalid sector at index: {}; sector {} is out of bounds", new Object[]{path, k, i1});
--                            this.offsets.put(k, 0);
-+                            //this.offsets.put(k, 0); // Paper - we catch this, but need it in the header for the summary change
-                         } else {
--                            this.usedSectors.force(i1, j1);
-+                            //this.usedSectors.force(i1, j1); // Paper - move this down so we can check if it fails to allocate
-+                        }
-+                        // Paper start - recalculate header on header corruption
-+                        if (offset < 2 || sectorLength <= 0 || ((long)offset * 4096L) > regionFileSize) {
-+                            if (canRecalcHeader) {
-+                                LOGGER.error("Detected invalid header for regionfile " + this.path.toAbsolutePath() + "! Recalculating header...");
-+                                needsHeaderRecalc = true;
-+                                break;
-+                            } else {
-+                                // location = chunkX | (chunkZ << 5);
-+                                LOGGER.error("Detected invalid header for regionfile " + this.path.toAbsolutePath() +
-+                                        "! Cannot recalculate, removing local chunk (" + (headerLocation & 31) + "," + (headerLocation >>> 5) + ") from header");
-+                                if (!hasBackedUp) {
-+                                    hasBackedUp = true;
-+                                    this.backupRegionFile();
-+                                }
-+                                this.timestamps.put(headerLocation, 0); // be consistent, delete the timestamp too
-+                                this.offsets.put(headerLocation, 0); // delete the entry from header
-+                                continue;
-+                            }
-+                        }
-+                        boolean failedToAllocate = !this.usedSectors.tryAllocate(offset, sectorLength);
-+                        if (failedToAllocate) {
-+                            LOGGER.error("Overlapping allocation by local chunk (" + (headerLocation & 31) + "," + (headerLocation >>> 5) + ") in regionfile " + this.path.toAbsolutePath());
-                         }
-+                        if (failedToAllocate & !canRecalcHeader) {
-+                            // location = chunkX | (chunkZ << 5);
-+                            LOGGER.error("Detected invalid header for regionfile " + this.path.toAbsolutePath() +
-+                                    "! Cannot recalculate, removing local chunk (" + (headerLocation & 31) + "," + (headerLocation >>> 5) + ") from header");
-+                            if (!hasBackedUp) {
-+                                hasBackedUp = true;
-+                                this.backupRegionFile();
-+                            }
-+                            this.timestamps.put(headerLocation, 0); // be consistent, delete the timestamp too
-+                            this.offsets.put(headerLocation, 0); // delete the entry from header
-+                            continue;
-+                        }
-+                        needsHeaderRecalc |= failedToAllocate;
-+                        // Paper end - recalculate header on header corruption
-                     }
-                 }
-+                // Paper start - recalculate header on header corruption
-+                // we move the recalc here so comparison to old header is correct when logging to console
-+                if (needsHeaderRecalc) { // true if header gave us overlapping allocations or had other issues
-+                    LOGGER.error("Recalculating regionfile " + this.path.toAbsolutePath() + ", header gave erroneous offsets & locations");
-+                    this.recalculateHeader();
-+                }
-+                // Paper end
-             }
- 
-         }
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
-     }
- 
-     private Path getExternalChunkPath(ChunkPos chunkPos) {
--        String s = "c." + chunkPos.x + "." + chunkPos.z + ".mcc";
-+        String s = "c." + chunkPos.x + "." + chunkPos.z + ".mcc"; // Paper - diff on change
- 
-         return this.externalFileDir.resolve(s);
-     }
- 
-+    // Paper start
-+    private static ChunkPos getOversizedChunkPair(Path file) {
-+        String fileName = file.getFileName().toString();
-+
-+        if (!fileName.startsWith("c.") || !fileName.endsWith(".mcc")) {
-+            return null;
-+        }
-+
-+        String[] split = fileName.split("\\.");
-+
-+        if (split.length != 4) {
-+            return null;
-+        }
-+
-+        try {
-+            int x = Integer.parseInt(split[1]);
-+            int z = Integer.parseInt(split[2]);
-+
-+            return new ChunkPos(x, z);
-+        } catch (NumberFormatException ex) {
-+            return null;
-+        }
-+    }
-+    // Paper end
-+
-     @Nullable
-     public synchronized DataInputStream getChunkDataInputStream(ChunkPos pos) throws IOException {
-         int i = this.getOffset(pos);
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
-             ((java.nio.Buffer) bytebuffer).flip(); // CraftBukkit - decompile error
-             if (bytebuffer.remaining() < 5) {
-                 RegionFile.LOGGER.error("Chunk {} header is truncated: expected {} but read {}", new Object[]{pos, l, bytebuffer.remaining()});
-+                // Paper start - recalculate header on regionfile corruption
-+                if (this.canRecalcHeader && this.recalculateHeader()) {
-+                    return this.getChunkDataInputStream(pos);
-+                }
-+                // Paper end - recalculate header on regionfile corruption
-                 return null;
-             } else {
-                 int i1 = bytebuffer.getInt();
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
- 
-                 if (i1 == 0) {
-                     RegionFile.LOGGER.warn("Chunk {} is allocated, but stream is missing", pos);
-+                    // Paper start - recalculate header on regionfile corruption
-+                    if (this.canRecalcHeader && this.recalculateHeader()) {
-+                        return this.getChunkDataInputStream(pos);
-+                    }
-+                    // Paper end - recalculate header on regionfile corruption
-                     return null;
-                 } else {
-                     int j1 = i1 - 1;
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
-                     if (RegionFile.isExternalStreamChunk(b0)) {
-                         if (j1 != 0) {
-                             RegionFile.LOGGER.warn("Chunk has both internal and external streams");
-+                            // Paper start - recalculate header on regionfile corruption
-+                            if (this.canRecalcHeader && this.recalculateHeader()) {
-+                                return this.getChunkDataInputStream(pos);
-+                            }
-+                            // Paper end - recalculate header on regionfile corruption
-                         }
- 
--                        return this.createExternalChunkInputStream(pos, RegionFile.getExternalChunkVersion(b0));
-+                        // Paper start - recalculate header on regionfile corruption
-+                        final DataInputStream ret = this.createExternalChunkInputStream(pos, RegionFile.getExternalChunkVersion(b0));
-+                        if (ret == null && this.canRecalcHeader && this.recalculateHeader()) {
-+                            return this.getChunkDataInputStream(pos);
-+                        }
-+                        return ret;
-+                        // Paper end - recalculate header on regionfile corruption
-                     } else if (j1 > bytebuffer.remaining()) {
-                         RegionFile.LOGGER.error("Chunk {} stream is truncated: expected {} but read {}", new Object[]{pos, j1, bytebuffer.remaining()});
-+                        // Paper start - recalculate header on regionfile corruption
-+                        if (this.canRecalcHeader && this.recalculateHeader()) {
-+                            return this.getChunkDataInputStream(pos);
-+                        }
-+                        // Paper end - recalculate header on regionfile corruption
-                         return null;
-                     } else if (j1 < 0) {
-                         RegionFile.LOGGER.error("Declared size {} of chunk {} is negative", i1, pos);
-+                        // Paper start - recalculate header on regionfile corruption
-+                        if (this.canRecalcHeader && this.recalculateHeader()) {
-+                            return this.getChunkDataInputStream(pos);
-+                        }
-+                        // Paper end - recalculate header on regionfile corruption
-                         return null;
-                     } else {
-                         JvmProfiler.INSTANCE.onRegionFileRead(this.info, pos, this.version, j1);
--                        return this.createChunkInputStream(pos, b0, RegionFile.createStream(bytebuffer, j1));
-+                        // Paper start - recalculate header on regionfile corruption
-+                        final DataInputStream ret = this.createChunkInputStream(pos, b0, RegionFile.createStream(bytebuffer, j1));
-+                        if (ret == null && this.canRecalcHeader && this.recalculateHeader()) {
-+                            return this.getChunkDataInputStream(pos);
-+                        }
-+                        return ret;
-+                        // Paper end - recalculate header on regionfile corruption
-                     }
-                 }
-             }
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
-     }
- 
-     private ByteBuffer createExternalStub() {
-+        // Paper start - add version param
-+        return this.createExternalStub(this.version);
-+    }
-+    private ByteBuffer createExternalStub(RegionFileVersion version) {
-+        // Paper end - add version param
-         ByteBuffer bytebuffer = ByteBuffer.allocate(5);
- 
-         bytebuffer.putInt(1);
--        bytebuffer.put((byte) (this.version.getId() | 128));
-+        bytebuffer.put((byte) (version.getId() | 128)); // Paper - replace with version param
-         ((java.nio.Buffer) bytebuffer).flip(); // CraftBukkit - decompile error
-         return bytebuffer;
-     }
-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 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
-         }
-     }
-     // Paper end - rewrite chunk system
-+    // Paper start - recalculate region file headers
-+    private final boolean isChunkData;
-+
-+    public static boolean isChunkDataFolder(Path path) {
-+        return path.toFile().getName().equalsIgnoreCase("region");
-+    }
-+
-+    @Nullable
-+    public static ChunkPos getRegionFileCoordinates(Path file) {
-+        String fileName = file.getFileName().toString();
-+        if (!fileName.startsWith("r.") || !fileName.endsWith(".mca")) {
-+            return null;
-+        }
-+
-+        String[] split = fileName.split("\\.");
-+
-+        if (split.length != 4) {
-+            return null;
-+        }
-+
-+        try {
-+            int x = Integer.parseInt(split[1]);
-+            int z = Integer.parseInt(split[2]);
-+
-+            return new ChunkPos(x << 5, z << 5);
-+        } catch (NumberFormatException ex) {
-+            return null;
-+        }
-+    }
-+    // Paper end
- 
-     protected RegionFileStorage(RegionStorageInfo storageKey, Path directory, boolean dsync) { // Paper - protected
-         this.folder = directory;
-         this.sync = dsync;
-         this.info = storageKey;
-+        this.isChunkData = isChunkDataFolder(this.folder); // Paper - recalculate region file headers
-     }
- 
-     // Paper start - rewrite chunk system
-@@ -0,0 +0,0 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
-             try {
-                 if (datainputstream != null) {
-                     nbttagcompound = NbtIo.read((DataInput) datainputstream);
-+                    // Paper start - recover from corrupt regionfile header
-+                    if (this.isChunkData) {
-+                        ChunkPos chunkPos = SerializableChunkData.getChunkCoordinate(nbttagcompound);
-+                        if (!chunkPos.equals(pos)) {
-+                            net.minecraft.server.MinecraftServer.LOGGER.error("Attempting to read chunk data at " + pos + " but got chunk data for " + chunkPos + " instead! Attempting regionfile recalculation for regionfile " + regionfile.getPath().toAbsolutePath());
-+                            if (regionfile.recalculateHeader()) {
-+                                return this.read(pos);
-+                            }
-+                            net.minecraft.server.MinecraftServer.LOGGER.error("Can't recalculate regionfile header, regenerating chunk " + pos + " for " + regionfile.getPath().toAbsolutePath());
-+                            return null;
-+                        }
-+                    }
-+                    // Paper end - recover from corrupt regionfile header
-                     break label43;
-                 }
- 
-diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileVersion.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileVersion.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileVersion.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileVersion.java
-@@ -0,0 +0,0 @@ import org.slf4j.Logger;
- 
- public class RegionFileVersion {
-     private static final Logger LOGGER = LogUtils.getLogger();
--    private static final Int2ObjectMap<RegionFileVersion> VERSIONS = new Int2ObjectOpenHashMap<>();
-+    public static final Int2ObjectMap<RegionFileVersion> VERSIONS = new Int2ObjectOpenHashMap<>(); // Paper - private -> public
-     private static final Object2ObjectMap<String, RegionFileVersion> VERSIONS_BY_NAME = new Object2ObjectOpenHashMap<>();
-     public static final RegionFileVersion VERSION_GZIP = register(
-         new RegionFileVersion(
-diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/SerializableChunkData.java b/src/main/java/net/minecraft/world/level/chunk/storage/SerializableChunkData.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/chunk/storage/SerializableChunkData.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/storage/SerializableChunkData.java
-@@ -0,0 +0,0 @@ public record SerializableChunkData(Registry<Biome> biomeRegistry, ChunkPos chun
-         }
-     }
-     // Paper end - guard against serializing mismatching coordinates
-+    // Paper start - Attempt to recalculate regionfile header if it is corrupt
-+    // TODO: Check on update
-+    public static long getLastWorldSaveTime(final CompoundTag chunkData) {
-+        final int dataVersion = ChunkStorage.getVersion(chunkData);
-+        if (dataVersion < 2842) { // Level tag is removed after this version
-+            final CompoundTag levelData = chunkData.getCompound("Level");
-+            return levelData.getLong("LastUpdate");
-+        } else {
-+            return chunkData.getLong("LastUpdate");
-+        }
-+    }
-+    // Paper end - Attempt to recalculate regionfile header if it is corrupt
- 
-     // Paper start - Do not let the server load chunks from newer versions
-     private static final int CURRENT_DATA_VERSION = net.minecraft.SharedConstants.getCurrentVersion().getDataVersion().getVersion();
-@@ -0,0 +0,0 @@ public record SerializableChunkData(Registry<Biome> biomeRegistry, ChunkPos chun
-         nbttagcompound.putInt("xPos", this.chunkPos.x);
-         nbttagcompound.putInt("yPos", this.minSectionY);
-         nbttagcompound.putInt("zPos", this.chunkPos.z);
--        nbttagcompound.putLong("LastUpdate", this.lastUpdateTime);
-+        nbttagcompound.putLong("LastUpdate", this.lastUpdateTime); // Paper - Diff on change
-         nbttagcompound.putLong("InhabitedTime", this.inhabitedTime);
-         nbttagcompound.putString("Status", BuiltInRegistries.CHUNK_STATUS.getKey(this.chunkStatus).toString());
-         DataResult<Tag> dataresult; // CraftBukkit - decompile error

patches/server/Check-distance-in-entity-interactions.patch

@@ -1,68 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Mon, 2 Aug 2021 10:10:40 +0200
-Subject: [PATCH] Check distance in entity interactions
-
-
-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 {
-         .filter(fileSystemProvider -> fileSystemProvider.getScheme().equalsIgnoreCase("jar"))
-         .findFirst()
-         .orElseThrow(() -> new IllegalStateException("No jar file system provider found"));
-+    public static final double COLLISION_EPSILON = 1.0E-7; // Paper - Check distance in entity interactions
-     private static Consumer<String> thePauser = message -> {
-     };
- 
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-                 if (!source.is(DamageTypeTags.IS_PROJECTILE)) {
-                     Entity entity = source.getDirectEntity();
- 
--                    if (entity instanceof LivingEntity) {
-+                    if (entity instanceof LivingEntity && entity.distanceToSqr(this) <= (200.0D * 200.0D)) { // Paper - Check distance in entity interactions
-                         LivingEntity entityliving = (LivingEntity) entity;
- 
-                         this.blockUsingShield(entityliving);
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-                         d0 = source.getSourcePosition().x() - this.getX();
-                         d1 = source.getSourcePosition().z() - this.getZ();
-                     }
-+                    // Paper start - Check distance in entity interactions; see for loop in knockback method
-+                    if (Math.abs(d0) > 200) {
-+                        d0 = Math.random() - Math.random();
-+                    }
-+                    if (Math.abs(d1) > 200) {
-+                        d1 = Math.random() - Math.random();
-+                    }
-+                    // Paper end - Check distance in entity interactions
- 
-                     this.knockback(0.4000000059604645D, d0, d1, entity1, entity1 == null ? io.papermc.paper.event.entity.EntityKnockbackEvent.Cause.DAMAGE : io.papermc.paper.event.entity.EntityKnockbackEvent.Cause.ENTITY_ATTACK); // CraftBukkit // Paper - knockback events
-                     if (!flag) {
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-                 this.hurtCurrentlyUsedShield((float) -event.getDamage(DamageModifier.BLOCKING));
-                 Entity entity = damagesource.getDirectEntity();
- 
--                if (!damagesource.is(DamageTypeTags.IS_PROJECTILE) && entity instanceof LivingEntity) { // Paper - Fix shield disable inconsistency
-+                if (!damagesource.is(DamageTypeTags.IS_PROJECTILE) && entity instanceof LivingEntity && entity.distanceToSqr(this) <= (200.0D * 200.0D)) { // Paper - Fix shield disable inconsistency & Check distance in entity interactions
-                     this.blockUsingShield((LivingEntity) entity);
-                 }
-             }
-diff --git a/src/main/java/net/minecraft/world/entity/vehicle/AbstractBoat.java b/src/main/java/net/minecraft/world/entity/vehicle/AbstractBoat.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/vehicle/AbstractBoat.java
-+++ b/src/main/java/net/minecraft/world/entity/vehicle/AbstractBoat.java
-@@ -0,0 +0,0 @@ public abstract class AbstractBoat extends VehicleEntity implements Leashable {
-             double d2 = (double) (this.getWaterLevelAbove() - this.getBbHeight()) + 0.101D;
- 
-             if (this.level().noCollision(this, this.getBoundingBox().move(0.0D, d2 - this.getY(), 0.0D))) {
--                this.setPos(this.getX(), d2, this.getZ());
-+                this.move(MoverType.SELF, new Vec3(0.0D, d2 - this.getY(), 0.0D)); // Paper - Check distance in entity interactions // TODO Still needed??
-                 this.setDeltaMovement(this.getDeltaMovement().multiply(1.0D, 0.0D, 1.0D));
-                 this.lastYd = 0.0D;
-             }

patches/server/Detail-more-information-in-watchdog-dumps.patch

@@ -1,295 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Thu, 26 Mar 2020 21:59:32 -0700
-Subject: [PATCH] Detail more information in watchdog dumps
-
-- Dump position, world, velocity, and uuid for currently ticking entities
-- Dump player name, player uuid, position, and world for packet handling
-
-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<?>> {
-             if (!(this.packetListener instanceof net.minecraft.server.network.ServerLoginPacketListenerImpl loginPacketListener)
-                 || loginPacketListener.state != net.minecraft.server.network.ServerLoginPacketListenerImpl.State.VERIFYING
-                 || Connection.joinAttemptsThisTick++ < MAX_PER_TICK) {
-+            // Paper start - detailed watchdog information
-+            net.minecraft.network.protocol.PacketUtils.packetProcessing.push(this.packetListener);
-+            try {
-             tickablepacketlistener.tick();
-+            } finally {
-+                net.minecraft.network.protocol.PacketUtils.packetProcessing.pop();
-+            } // Paper end - detailed watchdog information
-             } // Paper end - Buffer joins to world
-         }
- 
-diff --git a/src/main/java/net/minecraft/network/protocol/PacketUtils.java b/src/main/java/net/minecraft/network/protocol/PacketUtils.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/protocol/PacketUtils.java
-+++ b/src/main/java/net/minecraft/network/protocol/PacketUtils.java
-@@ -0,0 +0,0 @@ public class PacketUtils {
- 
-     private static final Logger LOGGER = LogUtils.getLogger();
- 
-+    // Paper start - detailed watchdog information
-+    public static final java.util.concurrent.ConcurrentLinkedDeque<PacketListener> packetProcessing = new java.util.concurrent.ConcurrentLinkedDeque<>();
-+    static final java.util.concurrent.atomic.AtomicLong totalMainThreadPacketsProcessed = new java.util.concurrent.atomic.AtomicLong();
-+
-+    public static long getTotalProcessedPackets() {
-+        return totalMainThreadPacketsProcessed.get();
-+    }
-+
-+    public static java.util.List<PacketListener> getCurrentPacketProcessors() {
-+        java.util.List<PacketListener> ret = new java.util.ArrayList<>(4);
-+        for (PacketListener listener : packetProcessing) {
-+            ret.add(listener);
-+        }
-+
-+        return ret;
-+    }
-+    // Paper end - detailed watchdog information
-+
-     public PacketUtils() {}
- 
-     public static <T extends PacketListener> void ensureRunningOnSameThread(Packet<T> packet, T listener, ServerLevel world) throws RunningOnDifferentThreadException {
-@@ -0,0 +0,0 @@ public class PacketUtils {
-     public static <T extends PacketListener> void ensureRunningOnSameThread(Packet<T> packet, T listener, BlockableEventLoop<?> engine) throws RunningOnDifferentThreadException {
-         if (!engine.isSameThread()) {
-             engine.executeIfPossible(() -> {
-+                packetProcessing.push(listener); // Paper - detailed watchdog information
-+                try { // Paper - detailed watchdog information
-                 if (listener instanceof ServerCommonPacketListenerImpl serverCommonPacketListener && serverCommonPacketListener.processedDisconnect) return; // CraftBukkit - Don't handle sync packets for kicked players
-                 if (listener.shouldHandleMessage(packet)) {
-                     try {
-@@ -0,0 +0,0 @@ public class PacketUtils {
-                 } else {
-                     PacketUtils.LOGGER.debug("Ignoring packet due to disconnection: {}", packet);
-                 }
-+                // Paper start - detailed watchdog information
-+                } finally {
-+                    totalMainThreadPacketsProcessed.getAndIncrement();
-+                    packetProcessing.pop();
-+                }
-+                // Paper end - detailed watchdog information
- 
-             });
-             throw RunningOnDifferentThreadException.RUNNING_ON_DIFFERENT_THREAD;
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
- 
-     }
- 
-+    // Paper start - log detailed entity tick information
-+    // TODO replace with varhandle
-+    static final java.util.concurrent.atomic.AtomicReference<Entity> currentlyTickingEntity = new java.util.concurrent.atomic.AtomicReference<>();
-+
-+    public static List<Entity> getCurrentlyTickingEntities() {
-+        Entity ticking = currentlyTickingEntity.get();
-+        List<Entity> ret = java.util.Arrays.asList(ticking == null ? new Entity[0] : new Entity[] { ticking });
-+
-+        return ret;
-+    }
-+    // Paper end - log detailed entity tick information
-+
-     public void tickNonPassenger(Entity entity) {
-+        // Paper start - log detailed entity tick information
-+        ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread("Cannot tick an entity off-main");
-+        try {
-+            if (currentlyTickingEntity.get() == null) {
-+                currentlyTickingEntity.lazySet(entity);
-+            }
-+            // Paper end - log detailed entity tick information
-         // Spigot start
-         /*if (!org.spigotmc.ActivationRange.checkIfActive(entity)) { // Paper - comment out EAR 2
-             entity.tickCount++;
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
-             this.tickPassenger(entity, entity1, isActive); // Paper - EAR 2
-         }
- 
-+        // Paper start - log detailed entity tick information
-+        } finally {
-+            if (currentlyTickingEntity.get() == entity) {
-+                currentlyTickingEntity.lazySet(null);
-+            }
-+        }
-+        // Paper end - log detailed entity tick information
-     }
- 
-     private void tickPassenger(Entity vehicle, Entity passenger, boolean isActive) { // Paper - EAR 2
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-         return this.onGround;
-     }
- 
-+    // Paper start - detailed watchdog information
-+    public final Object posLock = new Object(); // Paper - log detailed entity tick information
-+
-+    private Vec3 moveVector;
-+    private double moveStartX;
-+    private double moveStartY;
-+    private double moveStartZ;
-+
-+    public final Vec3 getMoveVector() {
-+        return this.moveVector;
-+    }
-+
-+    public final double getMoveStartX() {
-+        return this.moveStartX;
-+    }
-+
-+    public final double getMoveStartY() {
-+        return this.moveStartY;
-+    }
-+
-+    public final double getMoveStartZ() {
-+        return this.moveStartZ;
-+    }
-+    // Paper end - detailed watchdog information
-+
-     public void move(MoverType type, Vec3 movement) {
-         final Vec3 originalMovement = movement; // Paper - Expose pre-collision velocity
-+        // Paper start - detailed watchdog information
-+        ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread("Cannot move an entity off-main");
-+        synchronized (this.posLock) {
-+            this.moveStartX = this.getX();
-+            this.moveStartY = this.getY();
-+            this.moveStartZ = this.getZ();
-+            this.moveVector = movement;
-+        }
-+        try {
-+        // Paper end - detailed watchdog information
-         if (this.noPhysics) {
-             this.setPos(this.getX() + movement.x, this.getY() + movement.y, this.getZ() + movement.z);
-         } else {
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-                 gameprofilerfiller.pop();
-             }
-         }
-+        // Paper start - detailed watchdog information
-+        } finally {
-+            synchronized (this.posLock) { // Paper
-+                this.moveVector = null;
-+            } // Paper
-+        }
-+        // Paper end - detailed watchdog information
-     }
- 
-     private void applyMovementEmissionAndPlaySound(Entity.MovementEmission moveEffect, Vec3 movement, BlockPos landingPos, BlockState landingState) {
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-     }
- 
-     public void setDeltaMovement(Vec3 velocity) {
-+        synchronized (this.posLock) { // Paper
-         this.deltaMovement = velocity;
-+        } // Paper
-     }
- 
-     public void addDeltaMovement(Vec3 velocity) {
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-         }
-         // Paper end - Fix MC-4
-         if (this.position.x != x || this.position.y != y || this.position.z != z) {
-+            synchronized (this.posLock) { // Paper
-             this.position = new Vec3(x, y, z);
-+            } // Paper
-             int i = Mth.floor(x);
-             int j = Mth.floor(y);
-             int k = Mth.floor(z);
-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 ca.spottedleaf.moonrise.common.util.TickThre
-     private volatile long lastTick;
-     private volatile boolean stopping;
- 
-+    // Paper start - log detailed tick information
-+    private void dumpEntity(net.minecraft.world.entity.Entity entity) {
-+        Logger log = Bukkit.getServer().getLogger();
-+        double posX, posY, posZ;
-+        net.minecraft.world.phys.Vec3 mot;
-+        double moveStartX, moveStartY, moveStartZ;
-+        net.minecraft.world.phys.Vec3 moveVec;
-+        synchronized (entity.posLock) {
-+            posX = entity.getX();
-+            posY = entity.getY();
-+            posZ = entity.getZ();
-+            mot = entity.getDeltaMovement();
-+            moveStartX = entity.getMoveStartX();
-+            moveStartY = entity.getMoveStartY();
-+            moveStartZ = entity.getMoveStartZ();
-+            moveVec = entity.getMoveVector();
-+        }
-+
-+        String entityType = net.minecraft.world.entity.EntityType.getKey(entity.getType()).toString();
-+        java.util.UUID entityUUID = entity.getUUID();
-+        net.minecraft.world.level.Level world = entity.level();
-+
-+        log.log(Level.SEVERE, "Ticking entity: " + entityType + ", entity class: " + entity.getClass().getName());
-+        log.log(Level.SEVERE, "Entity status: removed: " + entity.isRemoved() + ", valid: " + entity.valid + ", alive: " + entity.isAlive() + ", is passenger: " + entity.isPassenger());
-+        log.log(Level.SEVERE, "Entity UUID: " + entityUUID);
-+        log.log(Level.SEVERE, "Position: world: '" + (world == null ? "unknown world?" : world.getWorld().getName()) + "' at location (" + posX + ", " + posY + ", " + posZ + ")");
-+        log.log(Level.SEVERE, "Velocity: " + (mot == null ? "unknown velocity" : mot.toString()) + " (in blocks per tick)");
-+        log.log(Level.SEVERE, "Entity AABB: " + entity.getBoundingBox());
-+        if (moveVec != null) {
-+            log.log(Level.SEVERE, "Move call information: ");
-+            log.log(Level.SEVERE, "Start position: (" + moveStartX + ", " + moveStartY + ", " + moveStartZ + ")");
-+            log.log(Level.SEVERE, "Move vector: " + moveVec.toString());
-+        }
-+    }
-+
-+    private void dumpTickingInfo() {
-+        Logger log = Bukkit.getServer().getLogger();
-+
-+        // ticking entities
-+        for (net.minecraft.world.entity.Entity entity : net.minecraft.server.level.ServerLevel.getCurrentlyTickingEntities()) {
-+            this.dumpEntity(entity);
-+            net.minecraft.world.entity.Entity vehicle = entity.getVehicle();
-+            if (vehicle != null) {
-+                log.log(Level.SEVERE, "Detailing vehicle for above entity:");
-+                this.dumpEntity(vehicle);
-+            }
-+        }
-+
-+        // packet processors
-+        for (net.minecraft.network.PacketListener packetListener : net.minecraft.network.protocol.PacketUtils.getCurrentPacketProcessors()) {
-+            if (packetListener instanceof net.minecraft.server.network.ServerGamePacketListenerImpl) {
-+                net.minecraft.server.level.ServerPlayer player = ((net.minecraft.server.network.ServerGamePacketListenerImpl)packetListener).player;
-+                long totalPackets = net.minecraft.network.protocol.PacketUtils.getTotalProcessedPackets();
-+                if (player == null) {
-+                    log.log(Level.SEVERE, "Handling packet for player connection or ticking player connection (null player): " + packetListener);
-+                    log.log(Level.SEVERE, "Total packets processed on the main thread for all players: " + totalPackets);
-+                } else {
-+                    this.dumpEntity(player);
-+                    net.minecraft.world.entity.Entity vehicle = player.getVehicle();
-+                    if (vehicle != null) {
-+                        log.log(Level.SEVERE, "Detailing vehicle for above entity:");
-+                        this.dumpEntity(vehicle);
-+                    }
-+                    log.log(Level.SEVERE, "Total packets processed on the main thread for all players: " + totalPackets);
-+                }
-+            } else {
-+                log.log(Level.SEVERE, "Handling packet for connection: " + packetListener);
-+            }
-+        }
-+    }
-+    // Paper end - log detailed tick information
-+
-     private WatchdogThread(long timeoutTime, boolean restart)
-     {
-         super( "Paper Watchdog Thread" );
-@@ -0,0 +0,0 @@ public class WatchdogThread extends ca.spottedleaf.moonrise.common.util.TickThre
-                 log.log( Level.SEVERE, "------------------------------" );
-                 log.log( Level.SEVERE, "Server thread dump (Look for plugins here before reporting to Paper!):" ); // Paper
-                 ca.spottedleaf.moonrise.patches.chunk_system.scheduling.ChunkTaskScheduler.dumpAllChunkLoadInfo(MinecraftServer.getServer(), isLongTimeout); // Paper - rewrite chunk system
-+                this.dumpTickingInfo(); // Paper - log detailed tick information
-                 WatchdogThread.dumpThread( ManagementFactory.getThreadMXBean().getThreadInfo( MinecraftServer.getServer().serverThread.getId(), Integer.MAX_VALUE ), log );
-                 log.log( Level.SEVERE, "------------------------------" );
-                 //

patches/server/Entity-Activation-Range-2.0.patch

@@ -1,775 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Fri, 13 May 2016 01:38:06 -0400
-Subject: [PATCH] Entity Activation Range 2.0
-
-Optimizes performance of Activation Range
-
-Adds many new configurations and a new wake up inactive system
-
-Fixes and adds new Immunities to improve gameplay behavior
-
-Adds water Mobs to activation range config and nerfs fish
-Adds flying monsters to control ghast and phantoms
-Adds villagers as separate config
-
-== AT ==
-public net.minecraft.world.entity.Entity isInsidePortal
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
- 
-     public void tickNonPassenger(Entity entity) {
-         // Spigot start
--        if (!org.spigotmc.ActivationRange.checkIfActive(entity)) {
-+        /*if (!org.spigotmc.ActivationRange.checkIfActive(entity)) { // Paper - comment out EAR 2
-             entity.tickCount++;
-             entity.inactiveTick();
-             return;
--        }
-+        }*/ // Paper - comment out EAR 2
-         // Spigot end
-         entity.setOldPosAndRot();
-         ProfilerFiller gameprofilerfiller = Profiler.get();
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
-             return BuiltInRegistries.ENTITY_TYPE.getKey(entity.getType()).toString();
-         });
-         gameprofilerfiller.incrementCounter("tickNonPassenger");
-+        final boolean isActive = org.spigotmc.ActivationRange.checkIfActive(entity); // Paper - EAR 2
-+        if (isActive) { // Paper - EAR 2
-         entity.tick();
-         entity.postTick(); // CraftBukkit
-+        } else { entity.inactiveTick(); } // Paper - EAR 2
-         gameprofilerfiller.pop();
-         Iterator iterator = entity.getPassengers().iterator();
- 
-         while (iterator.hasNext()) {
-             Entity entity1 = (Entity) iterator.next();
- 
--            this.tickPassenger(entity, entity1);
-+            this.tickPassenger(entity, entity1, isActive); // Paper - EAR 2
-         }
- 
-     }
- 
--    private void tickPassenger(Entity vehicle, Entity passenger) {
-+    private void tickPassenger(Entity vehicle, Entity passenger, boolean isActive) { // Paper - EAR 2
-         if (!passenger.isRemoved() && passenger.getVehicle() == vehicle) {
-             if (passenger instanceof Player || this.entityTickList.contains(passenger)) {
-                 passenger.setOldPosAndRot();
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
-                     return BuiltInRegistries.ENTITY_TYPE.getKey(passenger.getType()).toString();
-                 });
-                 gameprofilerfiller.incrementCounter("tickPassenger");
-+                // Paper start - EAR 2
-+                if (isActive) {
-                 passenger.rideTick();
-                 passenger.postTick(); // CraftBukkit
-+                } else {
-+                passenger.setDeltaMovement(Vec3.ZERO);
-+                passenger.inactiveTick();
-+                // copied from inside of if (isPassenger()) of passengerTick, but that ifPassenger is unnecessary
-+                vehicle.positionRider(passenger);
-+                }
-+                // Paper end - EAR 2
-                 gameprofilerfiller.pop();
-                 Iterator iterator = passenger.getPassengers().iterator();
- 
-                 while (iterator.hasNext()) {
-                     Entity entity2 = (Entity) iterator.next();
- 
--                    this.tickPassenger(passenger, entity2);
-+                    this.tickPassenger(passenger, entity2, isActive); // Paper - EAR 2
-                 }
- 
-             }
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-     // Spigot end
-     protected int numCollisions = 0; // Paper - Cap entity collisions
-     public boolean fromNetherPortal; // Paper - Add option to nerf pigmen from nether portals
-+    public long activatedImmunityTick = Integer.MIN_VALUE; // Paper - EAR
-+    public boolean isTemporarilyActive; // Paper - EAR
-     public boolean spawnedViaMobSpawner; // Paper - Yes this name is similar to above, upstream took the better one
-     // Paper start - Entity origin API
-     @javax.annotation.Nullable
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-         } else {
-             this.wasOnFire = this.isOnFire();
-             if (type == MoverType.PISTON) {
-+                this.activatedTick = Math.max(this.activatedTick, MinecraftServer.currentTick + 20); // Paper - EAR 2
-+                this.activatedImmunityTick = Math.max(this.activatedImmunityTick, MinecraftServer.currentTick + 20);   // Paper - EAR 2
-                 movement = this.limitPistonMovement(movement);
-                 if (movement.equals(Vec3.ZERO)) {
-                     return;
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-                 this.stuckSpeedMultiplier = Vec3.ZERO;
-                 this.setDeltaMovement(Vec3.ZERO);
-             }
-+            // Paper start - ignore movement changes while inactive.
-+            if (isTemporarilyActive && !(this instanceof ItemEntity) && movement == getDeltaMovement() && type == MoverType.SELF) {
-+                setDeltaMovement(Vec3.ZERO);
-+                gameprofilerfiller.pop();
-+                return;
-+            }
-+            // Paper end
- 
-             movement = this.maybeBackOffFromEdge(movement, type);
-             Vec3 vec3d1 = this.collide(movement);
-diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/Mob.java
-+++ b/src/main/java/net/minecraft/world/entity/Mob.java
-@@ -0,0 +0,0 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
-         return this.lookControl;
-     }
- 
-+    // Paper start
-+    @Override
-+    public void inactiveTick() {
-+        super.inactiveTick();
-+        if (this.goalSelector.inactiveTick()) {
-+            this.goalSelector.tick();
-+        }
-+        if (this.targetSelector.inactiveTick()) {
-+            this.targetSelector.tick();
-+        }
-+    }
-+    // Paper end
-+
-     public MoveControl getMoveControl() {
-         Entity entity = this.getControlledVehicle();
- 
-diff --git a/src/main/java/net/minecraft/world/entity/PathfinderMob.java b/src/main/java/net/minecraft/world/entity/PathfinderMob.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/PathfinderMob.java
-+++ b/src/main/java/net/minecraft/world/entity/PathfinderMob.java
-@@ -0,0 +0,0 @@ public abstract class PathfinderMob extends Mob {
-         super(type, world);
-     }
- 
-+    public BlockPos movingTarget; public BlockPos getMovingTarget() { return movingTarget; } // Paper
-+
-     public float getWalkTargetValue(BlockPos pos) {
-         return this.getWalkTargetValue(pos, this.level());
-     }
-diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java b/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java
-@@ -0,0 +0,0 @@ public class GoalSelector {
-     private final Map<Goal.Flag, WrappedGoal> lockedFlags = new EnumMap<>(Goal.Flag.class);
-     private final Set<WrappedGoal> availableGoals = new ObjectLinkedOpenHashSet<>();
-     private final EnumSet<Goal.Flag> disabledFlags = EnumSet.noneOf(Goal.Flag.class);
-+    private int curRate; // Paper - EAR 2
- 
-     public void addGoal(int priority, Goal goal) {
-         this.availableGoals.add(new WrappedGoal(priority, goal));
-@@ -0,0 +0,0 @@ public class GoalSelector {
-         this.availableGoals.removeIf(goal -> predicate.test(goal.getGoal()));
-     }
- 
-+    // Paper start - EAR 2
-+    public boolean inactiveTick() {
-+        this.curRate++;
-+        return this.curRate % 3 == 0; // TODO newGoalRate was already unused in 1.20.4, check if this is correct
-+    }
-+    public boolean hasTasks() {
-+        for (WrappedGoal task : this.availableGoals) {
-+            if (task.isRunning()) {
-+                return true;
-+            }
-+        }
-+        return false;
-+    }
-+    // Paper end - EAR 2
-     public void removeGoal(Goal goal) {
-         for (WrappedGoal wrappedGoal : this.availableGoals) {
-             if (wrappedGoal.getGoal() == goal && wrappedGoal.isRunning()) {
-diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/MoveToBlockGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/MoveToBlockGoal.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ai/goal/MoveToBlockGoal.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/goal/MoveToBlockGoal.java
-@@ -0,0 +0,0 @@ public abstract class MoveToBlockGoal extends Goal {
-     public MoveToBlockGoal(PathfinderMob mob, double speed, int range) {
-         this(mob, speed, range, 1);
-     }
-+    // Paper start - activation range improvements
-+    @Override
-+    public void stop() {
-+        super.stop();
-+        this.blockPos = BlockPos.ZERO;
-+        this.mob.movingTarget = null;
-+    }
-+    // Paper end
- 
-     public MoveToBlockGoal(PathfinderMob mob, double speed, int range, int maxYDifference) {
-         this.mob = mob;
-@@ -0,0 +0,0 @@ public abstract class MoveToBlockGoal extends Goal {
-                         mutableBlockPos.setWithOffset(blockPos, m, k - 1, n);
-                         if (this.mob.isWithinRestriction(mutableBlockPos) && this.isValidTarget(this.mob.level(), mutableBlockPos)) {
-                             this.blockPos = mutableBlockPos;
-+                            this.mob.movingTarget = mutableBlockPos == BlockPos.ZERO ? null : mutableBlockPos.immutable(); // Paper
-                             return true;
-                         }
-                     }
-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 inactiveTick() {
-         // SPIGOT-3874, SPIGOT-3894, SPIGOT-3846, SPIGOT-5286 :(
--        if (this.level().spigotConfig.tickInactiveVillagers && this.isEffectiveAi()) {
--            this.customServerAiStep((ServerLevel) this.level());
-+        // Paper start
-+        if (this.getUnhappyCounter() > 0) {
-+            this.setUnhappyCounter(this.getUnhappyCounter() - 1);
-+        }
-+        if (this.isEffectiveAi()) {
-+            if (this.level().spigotConfig.tickInactiveVillagers) {
-+                this.customServerAiStep(this.level().getMinecraftWorld());
-+            } else {
-+                this.customServerAiStep(this.level().getMinecraftWorld(), true);
-+            }
-         }
-+        maybeDecayGossip();
-+        // Paper end
-         super.inactiveTick();
-     }
-     // Spigot End
- 
-     @Override
-     protected void customServerAiStep(ServerLevel world) {
-+        // Paper start - EAR 2
-+        this.customServerAiStep(world, false);
-+    }
-+    protected void customServerAiStep(ServerLevel world, final boolean inactive) {
-+        // Paper end - EAR 2
-         ProfilerFiller gameprofilerfiller = Profiler.get();
- 
-         gameprofilerfiller.push("villagerBrain");
--        this.getBrain().tick(world, this);
-+        if (!inactive) this.getBrain().tick(world, this);
-         gameprofilerfiller.pop();
-         if (this.assignProfessionWhenSpawned) {
-             this.assignProfessionWhenSpawned = false;
-@@ -0,0 +0,0 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
-             this.lastTradedPlayer = null;
-         }
- 
--        if (!this.isNoAi() && this.random.nextInt(100) == 0) {
-+        if (!inactive && !this.isNoAi() && this.random.nextInt(100) == 0) { // Paper - EAR 2
-             Raid raid = world.getRaidAt(this.blockPosition());
- 
-             if (raid != null && raid.isActive() && !raid.isOver()) {
-@@ -0,0 +0,0 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
-         if (this.getVillagerData().getProfession() == VillagerProfession.NONE && this.isTrading()) {
-             this.stopTrading();
-         }
-+        if (inactive) return; // Paper - EAR 2
- 
-         super.customServerAiStep(world);
-     }
-diff --git a/src/main/java/net/minecraft/world/entity/vehicle/MinecartHopper.java b/src/main/java/net/minecraft/world/entity/vehicle/MinecartHopper.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/vehicle/MinecartHopper.java
-+++ b/src/main/java/net/minecraft/world/entity/vehicle/MinecartHopper.java
-@@ -0,0 +0,0 @@ public class MinecartHopper extends AbstractMinecartContainer implements Hopper
-         if (bl != this.isEnabled()) {
-             this.setEnabled(bl);
-         }
-+        this.immunize();  // Paper
-     }
- 
-     public boolean isEnabled() {
-@@ -0,0 +0,0 @@ public class MinecartHopper extends AbstractMinecartContainer implements Hopper
- 
-     public boolean suckInItems() {
-         if (HopperBlockEntity.suckInItems(this.level(), this)) {
-+            this.immunize();  // Paper
-             return true;
-         } else {
-             for (ItemEntity itemEntity : this.level()
-                 .getEntitiesOfClass(ItemEntity.class, this.getBoundingBox().inflate(0.25, 0.0, 0.25), EntitySelector.ENTITY_STILL_ALIVE)) {
-                 if (HopperBlockEntity.addItem(this, itemEntity)) {
-+                    this.immunize();  // Paper
-                     return true;
-                 }
-             }
-@@ -0,0 +0,0 @@ public class MinecartHopper extends AbstractMinecartContainer implements Hopper
-     public AbstractContainerMenu createMenu(int syncId, Inventory playerInventory) {
-         return new HopperMenu(syncId, playerInventory, this);
-     }
-+
-+    // Paper start
-+    public void immunize() {
-+        this.activatedImmunityTick = Math.max(this.activatedImmunityTick, net.minecraft.server.MinecraftServer.currentTick + 20);
-+    }
-+    // Paper end
-+
- }
-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 Map<BlockPos, BlockEntity> capturedTileEntities = new java.util.LinkedHashMap<>(); // Paper - Retain block place order when capturing blockstates
-     public List<ItemEntity> captureDrops;
-     public final it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap<SpawnCategory> ticksPerSpawnCategory = new it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap<>();
-+    // Paper start
-+    public int wakeupInactiveRemainingAnimals;
-+    public int wakeupInactiveRemainingFlying;
-+    public int wakeupInactiveRemainingMonsters;
-+    public int wakeupInactiveRemainingVillagers;
-+    // Paper end
-     public boolean populating;
-     public final org.spigotmc.SpigotWorldConfig spigotConfig; // Spigot
-     // Paper start - add paper world config
-diff --git a/src/main/java/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java b/src/main/java/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java
-@@ -0,0 +0,0 @@ public class PistonMovingBlockEntity extends BlockEntity {
-                                 }
- 
-                                 entity.setDeltaMovement(e, g, h);
-+                                // Paper - EAR items stuck in in slime pushed by a piston
-+                                entity.activatedTick = Math.max(entity.activatedTick, net.minecraft.server.MinecraftServer.currentTick + 10);
-+                                entity.activatedImmunityTick = Math.max(entity.activatedImmunityTick, net.minecraft.server.MinecraftServer.currentTick + 10);
-+                                // Paper end
-                                 break;
-                             }
-                         }
-diff --git a/src/main/java/org/spigotmc/ActivationRange.java b/src/main/java/org/spigotmc/ActivationRange.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/spigotmc/ActivationRange.java
-+++ b/src/main/java/org/spigotmc/ActivationRange.java
-@@ -0,0 +0,0 @@
- package org.spigotmc;
- 
-+import net.minecraft.core.BlockPos;
- import net.minecraft.server.MinecraftServer;
-+import net.minecraft.server.level.ServerChunkCache;
- import net.minecraft.world.entity.Entity;
- import net.minecraft.world.entity.ExperienceOrb;
-+import net.minecraft.world.entity.FlyingMob;
- import net.minecraft.world.entity.LightningBolt;
- import net.minecraft.world.entity.LivingEntity;
-+import net.minecraft.world.entity.Mob;
- import net.minecraft.world.entity.PathfinderMob;
-+import net.minecraft.world.entity.ai.Brain;
- import net.minecraft.world.entity.ambient.AmbientCreature;
- import net.minecraft.world.entity.animal.Animal;
-+import net.minecraft.world.entity.animal.Bee;
- import net.minecraft.world.entity.animal.Sheep;
-+import net.minecraft.world.entity.animal.WaterAnimal;
-+import net.minecraft.world.entity.animal.horse.Llama;
- import net.minecraft.world.entity.boss.EnderDragonPart;
- import net.minecraft.world.entity.boss.enderdragon.EndCrystal;
- import net.minecraft.world.entity.boss.enderdragon.EnderDragon;
-@@ -0,0 +0,0 @@ import net.minecraft.world.entity.boss.wither.WitherBoss;
- import net.minecraft.world.entity.item.ItemEntity;
- import net.minecraft.world.entity.item.PrimedTnt;
- import net.minecraft.world.entity.monster.Creeper;
--import net.minecraft.world.entity.monster.Monster;
--import net.minecraft.world.entity.monster.Slime;
-+import net.minecraft.world.entity.monster.Enemy;
-+import net.minecraft.world.entity.monster.Pillager;
- import net.minecraft.world.entity.npc.Villager;
- import net.minecraft.world.entity.player.Player;
- import net.minecraft.world.entity.projectile.AbstractArrow;
- import net.minecraft.world.entity.projectile.AbstractHurtingProjectile;
-+import net.minecraft.world.entity.projectile.EyeOfEnder;
- import net.minecraft.world.entity.projectile.FireworkRocketEntity;
- import net.minecraft.world.entity.projectile.ThrowableProjectile;
- import net.minecraft.world.entity.projectile.ThrownTrident;
-@@ -0,0 +0,0 @@ public class ActivationRange
- 
-         AABB boundingBox = new AABB( 0, 0, 0, 0, 0, 0 );
-     }
-+    // Paper start
-+
-+    static net.minecraft.world.entity.schedule.Activity[] VILLAGER_PANIC_IMMUNITIES = {
-+        net.minecraft.world.entity.schedule.Activity.HIDE,
-+        net.minecraft.world.entity.schedule.Activity.PRE_RAID,
-+        net.minecraft.world.entity.schedule.Activity.RAID,
-+        net.minecraft.world.entity.schedule.Activity.PANIC
-+    };
-+
-+    private static int checkInactiveWakeup(Entity entity) {
-+        Level world = entity.level();
-+        SpigotWorldConfig config = world.spigotConfig;
-+        long inactiveFor = MinecraftServer.currentTick - entity.activatedTick;
-+        if (entity.activationType == ActivationType.VILLAGER) {
-+            if (inactiveFor > config.wakeUpInactiveVillagersEvery && world.wakeupInactiveRemainingVillagers > 0) {
-+                world.wakeupInactiveRemainingVillagers--;
-+                return config.wakeUpInactiveVillagersFor;
-+            }
-+        } else if (entity.activationType == ActivationType.ANIMAL) {
-+            if (inactiveFor > config.wakeUpInactiveAnimalsEvery && world.wakeupInactiveRemainingAnimals > 0) {
-+                world.wakeupInactiveRemainingAnimals--;
-+                return config.wakeUpInactiveAnimalsFor;
-+            }
-+        } else if (entity.activationType == ActivationType.FLYING_MONSTER) {
-+            if (inactiveFor > config.wakeUpInactiveFlyingEvery && world.wakeupInactiveRemainingFlying > 0) {
-+                world.wakeupInactiveRemainingFlying--;
-+                return config.wakeUpInactiveFlyingFor;
-+            }
-+        } else if (entity.activationType == ActivationType.MONSTER || entity.activationType == ActivationType.RAIDER) {
-+            if (inactiveFor > config.wakeUpInactiveMonstersEvery && world.wakeupInactiveRemainingMonsters > 0) {
-+                world.wakeupInactiveRemainingMonsters--;
-+                return config.wakeUpInactiveMonstersFor;
-+            }
-+        }
-+        return -1;
-+    }
-+    // Paper end
- 
-     static AABB maxBB = new AABB( 0, 0, 0, 0, 0, 0 );
- 
-@@ -0,0 +0,0 @@ public class ActivationRange
-      */
-     public static ActivationType initializeEntityActivationType(Entity entity)
-     {
-+        if (entity instanceof WaterAnimal) { return ActivationType.WATER; } // Paper
-+        else if (entity instanceof Villager) { return ActivationType.VILLAGER; } // Paper
-+        else if (entity instanceof FlyingMob && entity instanceof Enemy) { return ActivationType.FLYING_MONSTER; } // Paper - doing & Monster incase Flying no longer includes monster in future
-         if ( entity instanceof Raider )
-         {
-             return ActivationType.RAIDER;
--        } else if ( entity instanceof Monster || entity instanceof Slime )
-+        } else if ( entity instanceof Enemy ) // Paper - correct monster check
-         {
-             return ActivationType.MONSTER;
-         } else if ( entity instanceof PathfinderMob || entity instanceof AmbientCreature )
-@@ -0,0 +0,0 @@ public class ActivationRange
-      */
-     public static boolean initializeEntityActivationState(Entity entity, SpigotWorldConfig config)
-     {
--        if ( ( entity.activationType == ActivationType.MISC && config.miscActivationRange == 0 )
--                || ( entity.activationType == ActivationType.RAIDER && config.raiderActivationRange == 0 )
--                || ( entity.activationType == ActivationType.ANIMAL && config.animalActivationRange == 0 )
--                || ( entity.activationType == ActivationType.MONSTER && config.monsterActivationRange == 0 )
-+        if ( ( entity.activationType == ActivationType.MISC && config.miscActivationRange <= 0 )
-+                || ( entity.activationType == ActivationType.RAIDER && config.raiderActivationRange <= 0 )
-+                || ( entity.activationType == ActivationType.ANIMAL && config.animalActivationRange <= 0 )
-+                || ( entity.activationType == ActivationType.MONSTER && config.monsterActivationRange <= 0 )
-+                || ( entity.activationType == ActivationType.VILLAGER && config.villagerActivationRange <= 0 ) // Paper
-+                || ( entity.activationType == ActivationType.WATER && config.waterActivationRange <= 0 ) // Paper
-+                || ( entity.activationType == ActivationType.FLYING_MONSTER && config.flyingMonsterActivationRange <= 0 ) // Paper
-+                || entity instanceof EyeOfEnder // Paper
-                 || entity instanceof Player
-                 || entity instanceof ThrowableProjectile
-                 || entity instanceof EnderDragon
-@@ -0,0 +0,0 @@ public class ActivationRange
-         final int raiderActivationRange = world.spigotConfig.raiderActivationRange;
-         final int animalActivationRange = world.spigotConfig.animalActivationRange;
-         final int monsterActivationRange = world.spigotConfig.monsterActivationRange;
-+        // Paper start
-+        final int waterActivationRange = world.spigotConfig.waterActivationRange;
-+        final int flyingActivationRange = world.spigotConfig.flyingMonsterActivationRange;
-+        final int villagerActivationRange = world.spigotConfig.villagerActivationRange;
-+        world.wakeupInactiveRemainingAnimals = Math.min(world.wakeupInactiveRemainingAnimals + 1, world.spigotConfig.wakeUpInactiveAnimals);
-+        world.wakeupInactiveRemainingVillagers = Math.min(world.wakeupInactiveRemainingVillagers + 1, world.spigotConfig.wakeUpInactiveVillagers);
-+        world.wakeupInactiveRemainingMonsters = Math.min(world.wakeupInactiveRemainingMonsters + 1, world.spigotConfig.wakeUpInactiveMonsters);
-+        world.wakeupInactiveRemainingFlying = Math.min(world.wakeupInactiveRemainingFlying + 1, world.spigotConfig.wakeUpInactiveFlying);
-+        final ServerChunkCache chunkProvider = (ServerChunkCache) world.getChunkSource();
-+        // Paper end
- 
-         int maxRange = Math.max( monsterActivationRange, animalActivationRange );
-         maxRange = Math.max( maxRange, raiderActivationRange );
-         maxRange = Math.max( maxRange, miscActivationRange );
-+        // Paper start
-+        maxRange = Math.max( maxRange, flyingActivationRange );
-+        maxRange = Math.max( maxRange, waterActivationRange );
-+        maxRange = Math.max( maxRange, villagerActivationRange );
-+        // Paper end
-         maxRange = Math.min( ( world.spigotConfig.simulationDistance << 4 ) - 8, maxRange );
- 
-         for ( Player player : world.players() )
-@@ -0,0 +0,0 @@ public class ActivationRange
-                 continue;
-             }
- 
--            ActivationRange.maxBB = player.getBoundingBox().inflate( maxRange, 256, maxRange );
--            ActivationType.MISC.boundingBox = player.getBoundingBox().inflate( miscActivationRange, 256, miscActivationRange );
--            ActivationType.RAIDER.boundingBox = player.getBoundingBox().inflate( raiderActivationRange, 256, raiderActivationRange );
--            ActivationType.ANIMAL.boundingBox = player.getBoundingBox().inflate( animalActivationRange, 256, animalActivationRange );
--            ActivationType.MONSTER.boundingBox = player.getBoundingBox().inflate( monsterActivationRange, 256, monsterActivationRange );
-+            // Paper start
-+            int worldHeight = world.getHeight();
-+            ActivationRange.maxBB = player.getBoundingBox().inflate( maxRange, worldHeight, maxRange );
-+            ActivationType.MISC.boundingBox = player.getBoundingBox().inflate( miscActivationRange, worldHeight, miscActivationRange );
-+            ActivationType.RAIDER.boundingBox = player.getBoundingBox().inflate( raiderActivationRange, worldHeight, raiderActivationRange );
-+            ActivationType.ANIMAL.boundingBox = player.getBoundingBox().inflate( animalActivationRange, worldHeight, animalActivationRange );
-+            ActivationType.MONSTER.boundingBox = player.getBoundingBox().inflate( monsterActivationRange, worldHeight, monsterActivationRange );
-+            ActivationType.WATER.boundingBox = player.getBoundingBox().inflate( waterActivationRange, worldHeight, waterActivationRange );
-+            ActivationType.FLYING_MONSTER.boundingBox = player.getBoundingBox().inflate( flyingActivationRange, worldHeight, flyingActivationRange );
-+            ActivationType.VILLAGER.boundingBox = player.getBoundingBox().inflate( villagerActivationRange, worldHeight, villagerActivationRange );
-+            // Paper end
- 
--            world.getEntities().get(ActivationRange.maxBB, ActivationRange::activateEntity);
-+            // Paper start
-+            java.util.List<Entity> entities = world.getEntities((Entity)null, ActivationRange.maxBB, null);
-+            boolean tickMarkers = world.paperConfig().entities.markers.tick; // Paper - Configurable marker ticking
-+            for (Entity entity : entities) {
-+                // Paper start - Configurable marker ticking
-+                if (!tickMarkers && entity instanceof net.minecraft.world.entity.Marker) {
-+                    continue;
-+                }
-+                // Paper end - Configurable marker ticking
-+                ActivationRange.activateEntity(entity);
-+            }
-+            // Paper end
-         }
-     }
- 
-@@ -0,0 +0,0 @@ public class ActivationRange
-      * @param entity
-      * @return
-      */
--    public static boolean checkEntityImmunities(Entity entity)
-+    public static int checkEntityImmunities(Entity entity) // Paper - return # of ticks to get immunity
-     {
-+        // Paper start
-+        SpigotWorldConfig config = entity.level().spigotConfig;
-+        int inactiveWakeUpImmunity = checkInactiveWakeup(entity);
-+        if (inactiveWakeUpImmunity > -1) {
-+            return inactiveWakeUpImmunity;
-+        }
-+        if (entity.getRemainingFireTicks() > 0) {
-+            return 2;
-+        }
-+        if (entity.activatedImmunityTick >= MinecraftServer.currentTick) {
-+            return 1;
-+        }
-+        long inactiveFor = MinecraftServer.currentTick - entity.activatedTick;
-+        // Paper end
-         // quick checks.
--        if ( entity.wasTouchingWater || entity.getRemainingFireTicks() > 0 )
-+        if ( (entity.activationType != ActivationType.WATER && entity.wasTouchingWater && entity.isPushedByFluid()) ) // Paper
-         {
--            return true;
-+            return 100; // Paper
-+        }
-+        // Paper start
-+        if ( !entity.onGround() || entity.getDeltaMovement().horizontalDistanceSqr() > 9.999999747378752E-6D )
-+        {
-+            return 100;
-         }
-+        // Paper end
-         if ( !( entity instanceof AbstractArrow ) )
-         {
--            if ( !entity.onGround() || !entity.passengers.isEmpty() || entity.isPassenger() )
-+            if ( (!entity.onGround() && !(entity instanceof FlyingMob)) ) // Paper - remove passengers logic
-             {
--                return true;
-+                return 10; // Paper
-             }
-         } else if ( !( (AbstractArrow) entity ).isInGround() )
-         {
--            return true;
-+            return 1; // Paper
-         }
-         // special cases.
-         if ( entity instanceof LivingEntity )
-         {
-             LivingEntity living = (LivingEntity) entity;
--            if ( /*TODO: Missed mapping? living.attackTicks > 0 || */ living.hurtTime > 0 || living.activeEffects.size() > 0 )
-+            if ( living.onClimbable() || living.jumping || living.hurtTime > 0 || living.activeEffects.size() > 0 || living.isFreezing()) // Paper
-             {
--                return true;
-+                return 1; // Paper
-             }
--            if ( entity instanceof PathfinderMob && ( (PathfinderMob) entity ).getTarget() != null )
-+            if ( entity instanceof Mob && ((Mob) entity ).getTarget() != null) // Paper
-             {
--                return true;
-+                return 20; // Paper
-             }
--            if ( entity instanceof Villager && ( (Villager) entity ).canBreed() )
-+            // Paper start
-+            if (entity instanceof Bee) {
-+                Bee bee = (Bee)entity;
-+                BlockPos movingTarget = bee.getMovingTarget();
-+                if (bee.isAngry() ||
-+                    (bee.getHivePos() != null && bee.getHivePos().equals(movingTarget)) ||
-+                    (bee.getSavedFlowerPos() != null && bee.getSavedFlowerPos().equals(movingTarget))
-+                ) {
-+                    return 20;
-+                }
-+            }
-+            if ( entity instanceof Villager ) {
-+                Brain<Villager> behaviorController = ((Villager) entity).getBrain();
-+
-+                if (config.villagersActiveForPanic) {
-+                    for (net.minecraft.world.entity.schedule.Activity activity : VILLAGER_PANIC_IMMUNITIES) {
-+                        if (behaviorController.isActive(activity)) {
-+                            return 20*5;
-+                        }
-+                    }
-+                }
-+
-+                if (config.villagersWorkImmunityAfter > 0 && inactiveFor >= config.villagersWorkImmunityAfter) {
-+                    if (behaviorController.isActive(net.minecraft.world.entity.schedule.Activity.WORK)) {
-+                        return config.villagersWorkImmunityFor;
-+                    }
-+                }
-+            }
-+            if ( entity instanceof Llama && ( (Llama) entity ).inCaravan() )
-             {
--                return true;
-+                return 1;
-             }
-+            // Paper end
-             if ( entity instanceof Animal )
-             {
-                 Animal animal = (Animal) entity;
-                 if ( animal.isBaby() || animal.isInLove() )
-                 {
--                    return true;
-+                    return 5; // Paper
-                 }
-                 if ( entity instanceof Sheep && ( (Sheep) entity ).isSheared() )
-                 {
--                    return true;
-+                    return 1; // Paper
-                 }
-             }
-             if (entity instanceof Creeper && ((Creeper) entity).isIgnited()) { // isExplosive
--                return true;
-+                return 20; // Paper
-+            }
-+            // Paper start
-+            if (entity instanceof Mob && ((Mob) entity).targetSelector.hasTasks() ) {
-+                return 0;
-             }
-+            if (entity instanceof Pillager) {
-+                Pillager pillager = (Pillager) entity;
-+                // TODO:?
-+            }
-+            // Paper end
-         }
-         // SPIGOT-6644: Otherwise the target refresh tick will be missed
-         if (entity instanceof ExperienceOrb) {
--            return true;
-+            return 20; // Paper
-         }
--        return false;
-+        return -1; // Paper
-     }
- 
-     /**
-@@ -0,0 +0,0 @@ public class ActivationRange
-         if (entity instanceof FireworkRocketEntity || (entity instanceof ItemEntity && (entity.tickCount + entity.getId()) % 4 == 0)) { // Paper - Needed for item gravity, see ItemEntity tick
-             return true;
-         }
-+        // Paper start - special case always immunities
-+        // immunize brand new entities, dead entities, and portal scenarios
-+        if (entity.defaultActivationState || entity.tickCount < 20*10 || !entity.isAlive() || (entity.portalProcess != null && !entity.portalProcess.hasExpired()) || entity.portalCooldown > 0) {
-+            return true;
-+        }
-+        // immunize leashed entities
-+        if (entity instanceof Mob && ((Mob)entity).getLeashHolder() instanceof Player) {
-+            return true;
-+        }
-+        // Paper end
- 
--        boolean isActive = entity.activatedTick >= MinecraftServer.currentTick || entity.defaultActivationState;
-+        boolean isActive = entity.activatedTick >= MinecraftServer.currentTick;
-+        entity.isTemporarilyActive = false; // Paper
- 
-         // Should this entity tick?
-         if ( !isActive )
-@@ -0,0 +0,0 @@ public class ActivationRange
-             if ( ( MinecraftServer.currentTick - entity.activatedTick - 1 ) % 20 == 0 )
-             {
-                 // Check immunities every 20 ticks.
--                if ( ActivationRange.checkEntityImmunities( entity ) )
--                {
--                    // Triggered some sort of immunity, give 20 full ticks before we check again.
--                    entity.activatedTick = MinecraftServer.currentTick + 20;
-+                // Paper start
-+                int immunity = checkEntityImmunities(entity);
-+                if (immunity >= 0) {
-+                    entity.activatedTick = MinecraftServer.currentTick + immunity;
-+                } else {
-+                    entity.isTemporarilyActive = true;
-                 }
-+                // Paper end
-                 isActive = true;
-             }
-         }
-diff --git a/src/main/java/org/spigotmc/SpigotWorldConfig.java b/src/main/java/org/spigotmc/SpigotWorldConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/spigotmc/SpigotWorldConfig.java
-+++ b/src/main/java/org/spigotmc/SpigotWorldConfig.java
-@@ -0,0 +0,0 @@ public class SpigotWorldConfig
-     public int monsterActivationRange = 32;
-     public int raiderActivationRange = 64;
-     public int miscActivationRange = 16;
-+    // Paper start
-+    public int flyingMonsterActivationRange = 32;
-+    public int waterActivationRange = 16;
-+    public int villagerActivationRange = 32;
-+    public int wakeUpInactiveAnimals = 4;
-+    public int wakeUpInactiveAnimalsEvery = 60*20;
-+    public int wakeUpInactiveAnimalsFor = 5*20;
-+    public int wakeUpInactiveMonsters = 8;
-+    public int wakeUpInactiveMonstersEvery = 20*20;
-+    public int wakeUpInactiveMonstersFor = 5*20;
-+    public int wakeUpInactiveVillagers = 4;
-+    public int wakeUpInactiveVillagersEvery = 30*20;
-+    public int wakeUpInactiveVillagersFor = 5*20;
-+    public int wakeUpInactiveFlying = 8;
-+    public int wakeUpInactiveFlyingEvery = 10*20;
-+    public int wakeUpInactiveFlyingFor = 5*20;
-+    public int villagersWorkImmunityAfter = 5*20;
-+    public int villagersWorkImmunityFor = 20;
-+    public boolean villagersActiveForPanic = true;
-+    // Paper end
-     public boolean tickInactiveVillagers = true;
-     public boolean ignoreSpectatorActivation = false;
-     private void activationRange()
-     {
-+        boolean hasAnimalsConfig = config.getInt("entity-activation-range.animals", this.animalActivationRange) != this.animalActivationRange; // Paper
-         this.animalActivationRange = this.getInt( "entity-activation-range.animals", this.animalActivationRange );
-         this.monsterActivationRange = this.getInt( "entity-activation-range.monsters", this.monsterActivationRange );
-         this.raiderActivationRange = this.getInt( "entity-activation-range.raiders", this.raiderActivationRange );
-         this.miscActivationRange = this.getInt( "entity-activation-range.misc", this.miscActivationRange );
-+        // Paper start
-+        this.waterActivationRange = this.getInt( "entity-activation-range.water", this.waterActivationRange );
-+        this.villagerActivationRange = this.getInt( "entity-activation-range.villagers", hasAnimalsConfig ? this.animalActivationRange : this.villagerActivationRange );
-+        this.flyingMonsterActivationRange = this.getInt( "entity-activation-range.flying-monsters", this.flyingMonsterActivationRange );
-+
-+        this.wakeUpInactiveAnimals = this.getInt("entity-activation-range.wake-up-inactive.animals-max-per-tick", this.wakeUpInactiveAnimals);
-+        this.wakeUpInactiveAnimalsEvery = this.getInt("entity-activation-range.wake-up-inactive.animals-every", this.wakeUpInactiveAnimalsEvery);
-+        this.wakeUpInactiveAnimalsFor = this.getInt("entity-activation-range.wake-up-inactive.animals-for", this.wakeUpInactiveAnimalsFor);
-+
-+        this.wakeUpInactiveMonsters = this.getInt("entity-activation-range.wake-up-inactive.monsters-max-per-tick", this.wakeUpInactiveMonsters);
-+        this.wakeUpInactiveMonstersEvery = this.getInt("entity-activation-range.wake-up-inactive.monsters-every", this.wakeUpInactiveMonstersEvery);
-+        this.wakeUpInactiveMonstersFor = this.getInt("entity-activation-range.wake-up-inactive.monsters-for", this.wakeUpInactiveMonstersFor);
-+
-+        this.wakeUpInactiveVillagers = this.getInt("entity-activation-range.wake-up-inactive.villagers-max-per-tick", this.wakeUpInactiveVillagers);
-+        this.wakeUpInactiveVillagersEvery = this.getInt("entity-activation-range.wake-up-inactive.villagers-every", this.wakeUpInactiveVillagersEvery);
-+        this.wakeUpInactiveVillagersFor = this.getInt("entity-activation-range.wake-up-inactive.villagers-for", this.wakeUpInactiveVillagersFor);
-+
-+        this.wakeUpInactiveFlying = this.getInt("entity-activation-range.wake-up-inactive.flying-monsters-max-per-tick", this.wakeUpInactiveFlying);
-+        this.wakeUpInactiveFlyingEvery = this.getInt("entity-activation-range.wake-up-inactive.flying-monsters-every", this.wakeUpInactiveFlyingEvery);
-+        this.wakeUpInactiveFlyingFor = this.getInt("entity-activation-range.wake-up-inactive.flying-monsters-for", this.wakeUpInactiveFlyingFor);
-+
-+        this.villagersWorkImmunityAfter = this.getInt( "entity-activation-range.villagers-work-immunity-after", this.villagersWorkImmunityAfter );
-+        this.villagersWorkImmunityFor = this.getInt( "entity-activation-range.villagers-work-immunity-for", this.villagersWorkImmunityFor );
-+        this.villagersActiveForPanic = this.getBoolean( "entity-activation-range.villagers-active-for-panic", this.villagersActiveForPanic );
-+        // Paper end
-         this.tickInactiveVillagers = this.getBoolean( "entity-activation-range.tick-inactive-villagers", this.tickInactiveVillagers );
-         this.ignoreSpectatorActivation = this.getBoolean( "entity-activation-range.ignore-spectators", this.ignoreSpectatorActivation );
-         this.log( "Entity Activation Range: An " + this.animalActivationRange + " / Mo " + this.monsterActivationRange + " / Ra " + this.raiderActivationRange + " / Mi " + this.miscActivationRange + " / Tiv " + this.tickInactiveVillagers + " / Isa " + this.ignoreSpectatorActivation );

patches/server/Entity-load-save-limit-per-chunk.patch

@@ -1,81 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
-Date: Wed, 18 Nov 2020 20:52:25 -0800
-Subject: [PATCH] Entity load/save limit per chunk
-
-Adds a config option to limit the number of entities saved and loaded
-to a chunk. The default values of -1 disable the limit. Although
-defaults are only included for certain entites, this allows setting
-limits for any entity type.
-
-diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/ChunkEntitySlices.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/ChunkEntitySlices.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/ChunkEntitySlices.java
-+++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/ChunkEntitySlices.java
-@@ -0,0 +0,0 @@ public final class ChunkEntitySlices {
-         }
- 
-         final ListTag entitiesTag = new ListTag();
-+        final java.util.Map<net.minecraft.world.entity.EntityType<?>, Integer> savedEntityCounts = new java.util.HashMap<>(); // Paper - Entity load/save limit per chunk
-         for (final Entity entity : PlatformHooks.get().modifySavedEntities(world, chunkPos.x, chunkPos.z, entities)) {
-+            // Paper start - Entity load/save limit per chunk
-+            final EntityType<?> entityType = entity.getType();
-+            final int saveLimit = world.paperConfig().chunks.entityPerChunkSaveLimit.getOrDefault(entityType, -1);
-+            if (saveLimit > -1) {
-+                if (savedEntityCounts.getOrDefault(entityType, 0) >= saveLimit) {
-+                    continue;
-+                }
-+                savedEntityCounts.merge(entityType, 1, Integer::sum);
-+            }
-+            // Paper end - Entity load/save limit per chunk
-             CompoundTag compoundTag = new CompoundTag();
-             if (entity.save(compoundTag)) {
-                 entitiesTag.add(compoundTag);
-diff --git a/src/main/java/net/minecraft/world/entity/EntityType.java b/src/main/java/net/minecraft/world/entity/EntityType.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/EntityType.java
-+++ b/src/main/java/net/minecraft/world/entity/EntityType.java
-@@ -0,0 +0,0 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
-         final Spliterator<? extends Tag> spliterator = entityNbtList.spliterator();
- 
-         return StreamSupport.stream(new Spliterator<Entity>() {
-+            final java.util.Map<EntityType<?>, Integer> loadedEntityCounts = new java.util.HashMap<>(); // Paper - Entity load/save limit per chunk
-             public boolean tryAdvance(Consumer<? super Entity> consumer) {
-                 return spliterator.tryAdvance((nbtbase) -> {
-                     EntityType.loadEntityRecursive((CompoundTag) nbtbase, world, reason, (entity) -> {
-+                        // Paper start - Entity load/save limit per chunk
-+                        final EntityType<?> entityType = entity.getType();
-+                        final int saveLimit = world.paperConfig().chunks.entityPerChunkSaveLimit.getOrDefault(entityType, -1);
-+                        if (saveLimit > -1) {
-+                            if (this.loadedEntityCounts.getOrDefault(entityType, 0) >= saveLimit) {
-+                                return null;
-+                            }
-+                            this.loadedEntityCounts.merge(entityType, 1, Integer::sum);
-+                        }
-+                        // Paper end - Entity load/save limit per chunk
-                         consumer.accept(entity);
-                         return entity;
-                     });
-diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/EntityStorage.java b/src/main/java/net/minecraft/world/level/chunk/storage/EntityStorage.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/chunk/storage/EntityStorage.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/storage/EntityStorage.java
-@@ -0,0 +0,0 @@ public class EntityStorage implements EntityPersistentStorage<Entity> {
-             }
-         } else {
-             ListTag listTag = new ListTag();
-+            final java.util.Map<net.minecraft.world.entity.EntityType<?>, Integer> savedEntityCounts = new java.util.HashMap<>(); // Paper - Entity load/save limit per chunk
-             dataList.getEntities().forEach(entity -> {
-+                // Paper start - Entity load/save limit per chunk
-+                final EntityType<?> entityType = entity.getType();
-+                final int saveLimit = this.level.paperConfig().chunks.entityPerChunkSaveLimit.getOrDefault(entityType, -1);
-+                if (saveLimit > -1) {
-+                    if (savedEntityCounts.getOrDefault(entityType, 0) >= saveLimit) {
-+                        return;
-+                    }
-+                    savedEntityCounts.merge(entityType, 1, Integer::sum);
-+                }
-+                // Paper end - Entity load/save limit per chunk
-                 CompoundTag compoundTagx = new CompoundTag();
-                 if (entity.save(compoundTagx)) {
-                     listTag.add(compoundTagx);

patches/server/Fix-entity-tracker-desync-when-new-players-are-added.patch

@@ -1,105 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Tue, 20 Feb 2024 18:24:16 -0800
-Subject: [PATCH] Fix entity tracker desync when new players are added to the
- tracker
-
-The delta position packet instructs the client to update
-the entity position by a position difference. However, this position
-difference is relative to the last position in the entity tracker
-state, not the last position which has been sent to the player. As
-a result, if the last position the player has recorded is different
-than the one stored in the entity tracker (which occurs when a new
-player is added to an existing entity tracker state) then the sent
-position difference will cause a position desync for the client.
-
-We can resolve this problem by either tracking the last position
-sent per-player, or by simply resetting the last sent position
-in the entity tracker state every time a new player is added.
-Resetting the last sent position every time a new player is
-added to the tracker is just easier to do, so that is what
-this patch does.
-
-This patch also fixes entities appearing to disappear when
-teleporting to players by changing the initial position
-in the spawn packet to the entities current tracking position.
-When teleporting, the spawn packet will contain the old position
-which is most likely in an unloaded chunk - which means that the
-client will not tick the entity and thus not lerp the entity
-from its old position to its new position.
-
-diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundAddEntityPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundAddEntityPacket.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/protocol/game/ClientboundAddEntityPacket.java
-+++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundAddEntityPacket.java
-@@ -0,0 +0,0 @@ public class ClientboundAddEntityPacket implements Packet<ClientGamePacketListen
-         this(
-             entity.getId(),
-             entity.getUUID(),
--            entityTrackerEntry.getPositionBase().x(),
--            entityTrackerEntry.getPositionBase().y(),
--            entityTrackerEntry.getPositionBase().z(),
-+            // Paper start - fix entity tracker desync
-+            entity.trackingPosition().x(),
-+            entity.trackingPosition().y(),
-+            entity.trackingPosition().z(),
-+            // Paper end - fix entity tracker desync
-             entityTrackerEntry.getLastSentXRot(),
-             entityTrackerEntry.getLastSentYRot(),
-             entity.getType(),
-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
-                         this.serverEntity.addPairing(player);
-                         }
-                         // Paper end - entity tracking events
-+                        this.serverEntity.onPlayerAdd(); // Paper - fix desync when a player is added to the tracker
-                     }
-                 } else if (this.seenBy.remove(player.connection)) {
-                     this.serverEntity.removePairing(player);
-diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerEntity.java
-+++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
-@@ -0,0 +0,0 @@ public class ServerEntity {
-         this.trackedDataValues = entity.getEntityData().getNonDefaultValues();
-     }
- 
-+    // Paper start - fix desync when a player is added to the tracker
-+    private boolean forceStateResync;
-+    public void onPlayerAdd() {
-+        this.forceStateResync = true;
-+    }
-+    // Paper end - fix desync when a player is added to the tracker
-+
-     public void sendChanges() {
-         // Paper start - optimise collisions
-         if (((ca.spottedleaf.moonrise.patches.chunk_system.entity.ChunkSystemEntity)this.entity).moonrise$isHardColliding()) {
-@@ -0,0 +0,0 @@ public class ServerEntity {
-             }
-         }
- 
--        if (this.tickCount % this.updateInterval == 0 || this.entity.hasImpulse || this.entity.getEntityData().isDirty()) {
-+        if (this.forceStateResync || this.tickCount % this.updateInterval == 0 || this.entity.hasImpulse || this.entity.getEntityData().isDirty()) { // Paper - fix desync when a player is added to the tracker
-             byte b0 = Mth.packDegrees(this.entity.getYRot());
-             byte b1 = Mth.packDegrees(this.entity.getXRot());
-             boolean flag = Math.abs(b0 - this.lastSentYRot) >= 1 || Math.abs(b1 - this.lastSentXRot) >= 1;
-@@ -0,0 +0,0 @@ public class ServerEntity {
-                     long k = this.positionCodec.encodeZ(vec3d);
-                     boolean flag5 = i < -32768L || i > 32767L || j < -32768L || j > 32767L || k < -32768L || k > 32767L;
- 
--                    if (!flag5 && this.teleportDelay <= 400 && !this.wasRiding && this.wasOnGround == this.entity.onGround()) {
-+                    if (!this.forceStateResync && !flag5 && this.teleportDelay <= 400 && !this.wasRiding && this.wasOnGround == this.entity.onGround()) { // Paper - fix desync when a player is added to the tracker
-                         if ((!flag2 || !flag) && !(this.entity instanceof AbstractArrow)) {
-                             if (flag2) {
-                                 packet1 = new ClientboundMoveEntityPacket.Pos(this.entity.getId(), (short) ((int) i), (short) ((int) j), (short) ((int) k), this.entity.onGround());
-@@ -0,0 +0,0 @@ public class ServerEntity {
-             }
- 
-             this.entity.hasImpulse = false;
-+            this.forceStateResync = false; // Paper - fix desync when a player is added to the tracker
-         }
- 
-         ++this.tickCount;

patches/server/Fix-entity-type-tags-suggestions-in-selectors.patch

@@ -1,152 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Sun, 22 Aug 2021 15:21:57 -0700
-Subject: [PATCH] Fix entity type tags suggestions in selectors
-
-This would really be better as a client fix because just to fix it
-all EntityArguments have been told to ask the server for completions
-when if this was fixed on the client, that wouldn't be needed.
-
-Mojira Issue: https://bugs.mojang.com/browse/MC-235045
-
-diff --git a/src/main/java/net/minecraft/commands/CommandSourceStack.java b/src/main/java/net/minecraft/commands/CommandSourceStack.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/commands/CommandSourceStack.java
-+++ b/src/main/java/net/minecraft/commands/CommandSourceStack.java
-@@ -0,0 +0,0 @@ public class CommandSourceStack implements ExecutionCommandSource<CommandSourceS
-         return this.source.getBukkitSender(this);
-     }
-     // CraftBukkit end
-+    // Paper start - tell clients to ask server for suggestions for EntityArguments
-+    @Override
-+    public Collection<String> getSelectedEntities() {
-+        if (io.papermc.paper.configuration.GlobalConfiguration.get().commands.fixTargetSelectorTagCompletion && this.source instanceof ServerPlayer player) {
-+            final Entity cameraEntity = player.getCamera();
-+            final double pickDistance = player.entityInteractionRange();
-+            final Vec3 min = cameraEntity.getEyePosition(1.0F);
-+            final Vec3 viewVector = cameraEntity.getViewVector(1.0F);
-+            final Vec3 max = min.add(viewVector.x * pickDistance, viewVector.y * pickDistance, viewVector.z * pickDistance);
-+            final net.minecraft.world.phys.AABB aabb = cameraEntity.getBoundingBox().expandTowards(viewVector.scale(pickDistance)).inflate(1.0D, 1.0D, 1.0D);
-+            final net.minecraft.world.phys.EntityHitResult hitResult = net.minecraft.world.entity.projectile.ProjectileUtil.getEntityHitResult(cameraEntity, min, max, aabb, (e) -> !e.isSpectator() && e.isPickable(), pickDistance * pickDistance);
-+            return hitResult != null ? java.util.Collections.singletonList(hitResult.getEntity().getStringUUID()) : SharedSuggestionProvider.super.getSelectedEntities();
-+        }
-+        return SharedSuggestionProvider.super.getSelectedEntities();
-+    }
-+    // Paper end - tell clients to ask server for suggestions for EntityArguments
- }
-diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/commands/Commands.java
-+++ b/src/main/java/net/minecraft/commands/Commands.java
-@@ -0,0 +0,0 @@ public class Commands {
-         Iterator iterator = children.iterator();
-         // Paper end - Perf: Async command map building
- 
-+        boolean registeredAskServerSuggestionsForTree = false; // Paper - tell clients to ask server for suggestions for EntityArguments
-         while (iterator.hasNext()) {
-             CommandNode<CommandSourceStack> commandnode2 = (CommandNode) iterator.next();
-             // Paper start - Brigadier API
-@@ -0,0 +0,0 @@ public class Commands {
- 
-                     if (requiredargumentbuilder.getSuggestionsProvider() != null) {
-                         requiredargumentbuilder.suggests(SuggestionProviders.safelySwap(requiredargumentbuilder.getSuggestionsProvider()));
-+                        // Paper start - tell clients to ask server for suggestions for EntityArguments
-+                        registeredAskServerSuggestionsForTree = requiredargumentbuilder.getSuggestionsProvider() == net.minecraft.commands.synchronization.SuggestionProviders.ASK_SERVER;
-+                    } else if (io.papermc.paper.configuration.GlobalConfiguration.get().commands.fixTargetSelectorTagCompletion && !registeredAskServerSuggestionsForTree && requiredargumentbuilder.getType() instanceof net.minecraft.commands.arguments.EntityArgument) {
-+                        requiredargumentbuilder.suggests(requiredargumentbuilder.getType()::listSuggestions);
-+                        registeredAskServerSuggestionsForTree = true; // You can only
-+                        // Paper end - tell clients to ask server for suggestions for EntityArguments
-                     }
-                 }
- 
-diff --git a/src/main/java/net/minecraft/commands/arguments/EntityArgument.java b/src/main/java/net/minecraft/commands/arguments/EntityArgument.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/commands/arguments/EntityArgument.java
-+++ b/src/main/java/net/minecraft/commands/arguments/EntityArgument.java
-@@ -0,0 +0,0 @@ public class EntityArgument implements ArgumentType<EntitySelector> {
-             final boolean permission = object instanceof CommandSourceStack stack
-                     ? stack.bypassSelectorPermissions || stack.hasPermission(2, "minecraft.command.selector")
-                     : icompletionprovider.hasPermission(2);
--            EntitySelectorParser argumentparserselector = new EntitySelectorParser(stringreader, permission);
-+            EntitySelectorParser argumentparserselector = new EntitySelectorParser(stringreader, permission, true); // Paper - tell clients to ask server for suggestions for EntityArguments
-             // Paper end - Fix EntityArgument permissions
- 
-             try {
-@@ -0,0 +0,0 @@ public class EntityArgument implements ArgumentType<EntitySelector> {
-             }
- 
-             return argumentparserselector.fillSuggestions(suggestionsbuilder, (suggestionsbuilder1) -> {
--                Collection<String> collection = icompletionprovider.getOnlinePlayerNames();
-+                // Paper start - tell clients to ask server for suggestions for EntityArguments
-+                final Collection<String> collection;
-+                if (icompletionprovider instanceof CommandSourceStack commandSourceStack && commandSourceStack.getEntity() instanceof ServerPlayer sourcePlayer) {
-+                    collection = new java.util.ArrayList<>();
-+                    for (final ServerPlayer player : commandSourceStack.getServer().getPlayerList().getPlayers()) {
-+                        if (sourcePlayer.getBukkitEntity().canSee(player.getBukkitEntity())) {
-+                            collection.add(player.getGameProfile().getName());
-+                        }
-+                    }
-+                } else {
-+                    collection = icompletionprovider.getOnlinePlayerNames();
-+                }
-+                // Paper end - tell clients to ask server for suggestions for EntityArguments
-                 Iterable<String> iterable = this.playersOnly ? collection : Iterables.concat(collection, icompletionprovider.getSelectedEntities());
- 
-                 SharedSuggestionProvider.suggest((Iterable) iterable, suggestionsbuilder1);
-diff --git a/src/main/java/net/minecraft/commands/arguments/selector/EntitySelectorParser.java b/src/main/java/net/minecraft/commands/arguments/selector/EntitySelectorParser.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/commands/arguments/selector/EntitySelectorParser.java
-+++ b/src/main/java/net/minecraft/commands/arguments/selector/EntitySelectorParser.java
-@@ -0,0 +0,0 @@ public class EntitySelectorParser {
-     private boolean hasScores;
-     private boolean hasAdvancements;
-     private boolean usesSelectors;
-+    public boolean parsingEntityArgumentSuggestions; // Paper - tell clients to ask server for suggestions for EntityArguments
- 
-     public EntitySelectorParser(StringReader reader, boolean atAllowed) {
-+        // Paper start - tell clients to ask server for suggestions for EntityArguments
-+        this(reader, atAllowed, false);
-+    }
-+    public EntitySelectorParser(StringReader reader, boolean atAllowed, boolean parsingEntityArgumentSuggestions) {
-+        this.parsingEntityArgumentSuggestions = parsingEntityArgumentSuggestions;
-+        // Paper end - tell clients to ask server for suggestions for EntityArguments
-         this.distance = MinMaxBounds.Doubles.ANY;
-         this.level = MinMaxBounds.Ints.ANY;
-         this.rotX = WrappedMinMaxBounds.ANY;
-diff --git a/src/main/java/net/minecraft/commands/arguments/selector/options/EntitySelectorOptions.java b/src/main/java/net/minecraft/commands/arguments/selector/options/EntitySelectorOptions.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/commands/arguments/selector/options/EntitySelectorOptions.java
-+++ b/src/main/java/net/minecraft/commands/arguments/selector/options/EntitySelectorOptions.java
-@@ -0,0 +0,0 @@ public class EntitySelectorOptions {
-     public static final DynamicCommandExceptionType ERROR_ENTITY_TYPE_INVALID = new DynamicCommandExceptionType(
-         entity -> Component.translatableEscape("argument.entity.options.type.invalid", entity)
-     );
-+    // Paper start - tell clients to ask server for suggestions for EntityArguments
-+    public static final DynamicCommandExceptionType ERROR_ENTITY_TAG_INVALID = new DynamicCommandExceptionType((object) -> {
-+        return io.papermc.paper.adventure.PaperAdventure
-+            .asVanilla(net.kyori.adventure.text.Component
-+                .text("Invalid or unknown entity type tag '" + object + "'")
-+                .hoverEvent(net.kyori.adventure.text.event.HoverEvent
-+                    .showText(net.kyori.adventure.text.Component
-+                        .text("You can disable this error in 'paper.yml'")
-+                    )
-+                )
-+            );
-+    });
-+    // Paper end - tell clients to ask server for suggestions for EntityArguments
- 
-     private static void register(String id, EntitySelectorOptions.Modifier handler, Predicate<EntitySelectorParser> condition, Component description) {
-         OPTIONS.put(id, new EntitySelectorOptions.Option(handler, condition, description));
-@@ -0,0 +0,0 @@ public class EntitySelectorOptions {
- 
-                         if (reader.isTag()) {
-                             TagKey<EntityType<?>> tagKey = TagKey.create(Registries.ENTITY_TYPE, ResourceLocation.read(reader.getReader()));
-+                            // Paper start - tell clients to ask server for suggestions for EntityArguments; throw error if invalid entity tag (only on suggestions to keep cmd success behavior)
-+                            if (reader.parsingEntityArgumentSuggestions && io.papermc.paper.configuration.GlobalConfiguration.get().commands.fixTargetSelectorTagCompletion && net.minecraft.core.registries.BuiltInRegistries.ENTITY_TYPE.get(tagKey).isEmpty()) {
-+                                reader.getReader().setCursor(i);
-+                                throw ERROR_ENTITY_TAG_INVALID.createWithContext(reader.getReader(), tagKey);
-+                            }
-+                            // Paper end - tell clients to ask server for suggestions for EntityArguments
-                             reader.addPredicate(entity -> entity.getType().is(tagKey) != bl);
-                         } else {
-                             ResourceLocation resourceLocation = ResourceLocation.read(reader.getReader());

patches/server/Flat-bedrock-generator-settings.patch

@@ -1,292 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Byteflux <byte@byteflux.net>
-Date: Wed, 2 Mar 2016 02:17:54 -0600
-Subject: [PATCH] Flat bedrock generator settings
-
-== AT ==
-public net.minecraft.world.level.levelgen.SurfaceRules$Condition
-public net.minecraft.world.level.levelgen.SurfaceRules$Context
-public net.minecraft.world.level.levelgen.SurfaceRules$Context blockX
-public net.minecraft.world.level.levelgen.SurfaceRules$Context blockY
-public net.minecraft.world.level.levelgen.SurfaceRules$Context blockZ
-public net.minecraft.world.level.levelgen.SurfaceRules$Context context
-public net.minecraft.world.level.levelgen.SurfaceRules$Context randomState
-public net.minecraft.world.level.levelgen.SurfaceRules$LazyYCondition
-public net.minecraft.world.level.levelgen.SurfaceRules$LazyCondition
-public net.minecraft.world.level.levelgen.SurfaceRules$VerticalGradientConditionSource
-public net.minecraft.world.level.levelgen.SurfaceRules$SurfaceRule
-
-Co-authored-by: Noah van der Aa <ndvdaa@gmail.com>
-
-diff --git a/src/main/java/io/papermc/paper/world/worldgen/OptionallyFlatBedrockConditionSource.java b/src/main/java/io/papermc/paper/world/worldgen/OptionallyFlatBedrockConditionSource.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/io/papermc/paper/world/worldgen/OptionallyFlatBedrockConditionSource.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.world.worldgen;
-+
-+import com.mojang.serialization.Codec;
-+import com.mojang.serialization.MapCodec;
-+import com.mojang.serialization.codecs.RecordCodecBuilder;
-+import net.minecraft.core.Registry;
-+import net.minecraft.core.registries.BuiltInRegistries;
-+import net.minecraft.core.registries.Registries;
-+import net.minecraft.resources.ResourceKey;
-+import net.minecraft.resources.ResourceLocation;
-+import net.minecraft.util.KeyDispatchDataCodec;
-+import net.minecraft.util.Mth;
-+import net.minecraft.util.RandomSource;
-+import net.minecraft.world.level.levelgen.PositionalRandomFactory;
-+import net.minecraft.world.level.levelgen.SurfaceRules;
-+import net.minecraft.world.level.levelgen.VerticalAnchor;
-+import org.checkerframework.checker.nullness.qual.NonNull;
-+import org.checkerframework.framework.qual.DefaultQualifier;
-+
-+// Modelled off of SurfaceRules$VerticalGradientConditionSource
-+@DefaultQualifier(NonNull.class)
-+public record OptionallyFlatBedrockConditionSource(ResourceLocation randomName, VerticalAnchor trueAtAndBelow, VerticalAnchor falseAtAndAbove, boolean isRoof) implements SurfaceRules.ConditionSource {
-+
-+    private static final ResourceKey<MapCodec<? extends SurfaceRules.ConditionSource>> CODEC_RESOURCE_KEY = ResourceKey.create(
-+        Registries.MATERIAL_CONDITION,
-+        ResourceLocation.fromNamespaceAndPath(ResourceLocation.PAPER_NAMESPACE, "optionally_flat_bedrock_condition_source")
-+    );
-+    private static final KeyDispatchDataCodec<OptionallyFlatBedrockConditionSource> CODEC = KeyDispatchDataCodec.of(RecordCodecBuilder.mapCodec((instance) -> {
-+        return instance.group(
-+            ResourceLocation.CODEC.fieldOf("random_name").forGetter(OptionallyFlatBedrockConditionSource::randomName),
-+            VerticalAnchor.CODEC.fieldOf("true_at_and_below").forGetter(OptionallyFlatBedrockConditionSource::trueAtAndBelow),
-+            VerticalAnchor.CODEC.fieldOf("false_at_and_above").forGetter(OptionallyFlatBedrockConditionSource::falseAtAndAbove),
-+            Codec.BOOL.fieldOf("is_roof").forGetter(OptionallyFlatBedrockConditionSource::isRoof)
-+        ).apply(instance, OptionallyFlatBedrockConditionSource::new);
-+    }));
-+
-+    public static void bootstrap() {
-+        Registry.register(BuiltInRegistries.MATERIAL_CONDITION, CODEC_RESOURCE_KEY, CODEC.codec());
-+    }
-+
-+    @Override
-+    public KeyDispatchDataCodec<? extends SurfaceRules.ConditionSource> codec() {
-+        return CODEC;
-+    }
-+
-+    @Override
-+    public SurfaceRules.Condition apply(final SurfaceRules.Context context) {
-+        boolean hasFlatBedrock = context.context.getWorld().paperConfig().environment.generateFlatBedrock;
-+        int tempTrueAtAndBelowY = this.trueAtAndBelow().resolveY(context.context);
-+        int tempFalseAtAndAboveY = this.falseAtAndAbove().resolveY(context.context);
-+
-+        int flatYLevel = this.isRoof ? Math.max(tempFalseAtAndAboveY, tempTrueAtAndBelowY) - 1 : Math.min(tempFalseAtAndAboveY, tempTrueAtAndBelowY);
-+        final int trueAtAndBelowY = hasFlatBedrock ? flatYLevel : tempTrueAtAndBelowY;
-+        final int falseAtAndAboveY = hasFlatBedrock ? flatYLevel : tempFalseAtAndAboveY;
-+
-+        final PositionalRandomFactory positionalRandomFactory = context.randomState.getOrCreateRandomFactory(this.randomName());
-+
-+        class VerticalGradientCondition extends SurfaceRules.LazyYCondition {
-+            VerticalGradientCondition(SurfaceRules.Context context) {
-+                super(context);
-+            }
-+
-+            @Override
-+            protected boolean compute() {
-+                int blockY = this.context.blockY;
-+                if (blockY <= trueAtAndBelowY) {
-+                    return true;
-+                } else if (blockY >= falseAtAndAboveY) {
-+                    return false;
-+                } else {
-+                    double d = Mth.map(blockY, trueAtAndBelowY, falseAtAndAboveY, 1.0D, 0.0D);
-+                    RandomSource randomSource = positionalRandomFactory.at(this.context.blockX, blockY, this.context.blockZ);
-+                    return (double)randomSource.nextFloat() < d;
-+                }
-+            }
-+        }
-+
-+        return new VerticalGradientCondition(context);
-+    }
-+}
-diff --git a/src/main/java/net/minecraft/server/Bootstrap.java b/src/main/java/net/minecraft/server/Bootstrap.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/Bootstrap.java
-+++ b/src/main/java/net/minecraft/server/Bootstrap.java
-@@ -0,0 +0,0 @@ public class Bootstrap {
-                     CauldronInteraction.bootStrap();
-                     // Paper start
-                     BuiltInRegistries.bootStrap(() -> {
-+                        io.papermc.paper.world.worldgen.OptionallyFlatBedrockConditionSource.bootstrap(); // Paper - Flat bedrock generator settings
-                     });
-                     // Paper end
-                     CreativeModeTabs.validate();
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java b/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/NoiseBasedChunkGenerator.java
-@@ -0,0 +0,0 @@ public final class NoiseBasedChunkGenerator extends ChunkGenerator {
-     @Override
-     public void buildSurface(WorldGenRegion region, StructureManager structures, RandomState noiseConfig, ChunkAccess chunk) {
-         if (!SharedConstants.debugVoidTerrain(chunk.getPos())) {
--            WorldGenerationContext worldgenerationcontext = new WorldGenerationContext(this, region);
-+            WorldGenerationContext worldgenerationcontext = new WorldGenerationContext(this, region, region.getMinecraftWorld()); // Paper - Flat bedrock generator settings
- 
-             this.buildSurface(chunk, worldgenerationcontext, noiseConfig, structures, region.getBiomeManager(), region.registryAccess().lookupOrThrow(Registries.BIOME), Blender.of(region));
-         }
-@@ -0,0 +0,0 @@ public final class NoiseBasedChunkGenerator extends ChunkGenerator {
-             return this.createNoiseChunk(ichunkaccess1, structureAccessor, Blender.of(chunkRegion), noiseConfig);
-         });
-         Aquifer aquifer = noisechunk.aquifer();
--        CarvingContext carvingcontext = new CarvingContext(this, chunkRegion.registryAccess(), chunk.getHeightAccessorForGeneration(), noisechunk, noiseConfig, ((NoiseGeneratorSettings) this.settings.value()).surfaceRule());
-+        CarvingContext carvingcontext = new CarvingContext(this, chunkRegion.registryAccess(), chunk.getHeightAccessorForGeneration(), noisechunk, noiseConfig, ((NoiseGeneratorSettings) this.settings.value()).surfaceRule(), chunkRegion.getMinecraftWorld()); // Paper - Flat bedrock generator settings
-         CarvingMask carvingmask = ((ProtoChunk) chunk).getOrCreateCarvingMask();
- 
-         for (int j = -8; j <= 8; ++j) {
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/WorldGenerationContext.java b/src/main/java/net/minecraft/world/level/levelgen/WorldGenerationContext.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/levelgen/WorldGenerationContext.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/WorldGenerationContext.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.level.chunk.ChunkGenerator;
- public class WorldGenerationContext {
-     private final int minY;
-     private final int height;
-+    private final @javax.annotation.Nullable net.minecraft.world.level.Level level; // Paper - Flat bedrock generator settings
- 
--    public WorldGenerationContext(ChunkGenerator generator, LevelHeightAccessor world) {
-+    public WorldGenerationContext(ChunkGenerator generator, LevelHeightAccessor world) { this(generator, world, null); } // Paper - Flat bedrock generator settings
-+    public WorldGenerationContext(ChunkGenerator generator, LevelHeightAccessor world, @org.jetbrains.annotations.Nullable net.minecraft.world.level.Level level) { // Paper - Flat bedrock generator settings
-         this.minY = Math.max(world.getMinY(), generator.getMinY());
-         this.height = Math.min(world.getHeight(), generator.getGenDepth());
-+        this.level = level; // Paper - Flat bedrock generator settings
-     }
- 
-     public int getMinGenY() {
-@@ -0,0 +0,0 @@ public class WorldGenerationContext {
-     public int getGenDepth() {
-         return this.height;
-     }
-+
-+    // Paper start - Flat bedrock generator settings
-+    public net.minecraft.world.level.Level getWorld() {
-+        if (this.level == null) {
-+            throw new NullPointerException("WorldGenerationContext was initialized without a Level, but WorldGenerationContext#getWorld was called");
-+        }
-+        return this.level;
-+    }
-+    // Paper end - Flat bedrock generator settings
- }
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/carver/CarvingContext.java b/src/main/java/net/minecraft/world/level/levelgen/carver/CarvingContext.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/levelgen/carver/CarvingContext.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/carver/CarvingContext.java
-@@ -0,0 +0,0 @@ public class CarvingContext extends WorldGenerationContext {
-         LevelHeightAccessor heightLimitView,
-         NoiseChunk chunkNoiseSampler,
-         RandomState noiseConfig,
--        SurfaceRules.RuleSource materialRule
-+        SurfaceRules.RuleSource materialRule, @javax.annotation.Nullable net.minecraft.world.level.Level level  // Paper - Flat bedrock generator settings
-     ) {
--        super(noiseChunkGenerator, heightLimitView);
-+        super(noiseChunkGenerator, heightLimitView, level); // Paper - Flat bedrock generator settings
-         this.registryAccess = registryManager;
-         this.noiseChunk = chunkNoiseSampler;
-         this.randomState = noiseConfig;
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/placement/PlacementContext.java b/src/main/java/net/minecraft/world/level/levelgen/placement/PlacementContext.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/levelgen/placement/PlacementContext.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/placement/PlacementContext.java
-@@ -0,0 +0,0 @@ public class PlacementContext extends WorldGenerationContext {
-     private final Optional<PlacedFeature> topFeature;
- 
-     public PlacementContext(WorldGenLevel world, ChunkGenerator generator, Optional<PlacedFeature> placedFeature) {
--        super(generator, world);
-+        super(generator, world, world.getLevel()); // Paper - Flat bedrock generator settings
-         this.level = world;
-         this.generator = generator;
-         this.topFeature = placedFeature;
-diff --git a/src/main/resources/data/minecraft/worldgen/noise_settings/amplified.json b/src/main/resources/data/minecraft/worldgen/noise_settings/amplified.json
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/resources/data/minecraft/worldgen/noise_settings/amplified.json
-+++ b/src/main/resources/data/minecraft/worldgen/noise_settings/amplified.json
-@@ -0,0 +0,0 @@
-       {
-         "type": "minecraft:condition",
-         "if_true": {
--          "type": "minecraft:vertical_gradient",
-+          "type": "paper:optionally_flat_bedrock_condition_source",
-+          "is_roof": false,
-           "false_at_and_above": {
-             "above_bottom": 5
-           },
-diff --git a/src/main/resources/data/minecraft/worldgen/noise_settings/caves.json b/src/main/resources/data/minecraft/worldgen/noise_settings/caves.json
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/resources/data/minecraft/worldgen/noise_settings/caves.json
-+++ b/src/main/resources/data/minecraft/worldgen/noise_settings/caves.json
-@@ -0,0 +0,0 @@
-         "if_true": {
-           "type": "minecraft:not",
-           "invert": {
--            "type": "minecraft:vertical_gradient",
-+            "type": "paper:optionally_flat_bedrock_condition_source",
-+            "is_roof": true,
-             "false_at_and_above": {
-               "below_top": 0
-             },
-@@ -0,0 +0,0 @@
-       {
-         "type": "minecraft:condition",
-         "if_true": {
--          "type": "minecraft:vertical_gradient",
-+          "type": "paper:optionally_flat_bedrock_condition_source",
-+          "is_roof": false,
-           "false_at_and_above": {
-             "above_bottom": 5
-           },
-diff --git a/src/main/resources/data/minecraft/worldgen/noise_settings/large_biomes.json b/src/main/resources/data/minecraft/worldgen/noise_settings/large_biomes.json
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/resources/data/minecraft/worldgen/noise_settings/large_biomes.json
-+++ b/src/main/resources/data/minecraft/worldgen/noise_settings/large_biomes.json
-@@ -0,0 +0,0 @@
-       {
-         "type": "minecraft:condition",
-         "if_true": {
--          "type": "minecraft:vertical_gradient",
-+          "type": "paper:optionally_flat_bedrock_condition_source",
-+          "is_roof": false,
-           "false_at_and_above": {
-             "above_bottom": 5
-           },
-diff --git a/src/main/resources/data/minecraft/worldgen/noise_settings/nether.json b/src/main/resources/data/minecraft/worldgen/noise_settings/nether.json
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/resources/data/minecraft/worldgen/noise_settings/nether.json
-+++ b/src/main/resources/data/minecraft/worldgen/noise_settings/nether.json
-@@ -0,0 +0,0 @@
-       {
-         "type": "minecraft:condition",
-         "if_true": {
--          "type": "minecraft:vertical_gradient",
-+          "type": "paper:optionally_flat_bedrock_condition_source",
-+          "is_roof": false,
-           "false_at_and_above": {
-             "above_bottom": 5
-           },
-@@ -0,0 +0,0 @@
-         "if_true": {
-           "type": "minecraft:not",
-           "invert": {
--            "type": "minecraft:vertical_gradient",
-+            "type": "paper:optionally_flat_bedrock_condition_source",
-+            "is_roof": true,
-             "false_at_and_above": {
-               "below_top": 0
-             },
-diff --git a/src/main/resources/data/minecraft/worldgen/noise_settings/overworld.json b/src/main/resources/data/minecraft/worldgen/noise_settings/overworld.json
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/resources/data/minecraft/worldgen/noise_settings/overworld.json
-+++ b/src/main/resources/data/minecraft/worldgen/noise_settings/overworld.json
-@@ -0,0 +0,0 @@
-       {
-         "type": "minecraft:condition",
-         "if_true": {
--          "type": "minecraft:vertical_gradient",
-+          "type": "paper:optionally_flat_bedrock_condition_source",
-+          "is_roof": false,
-           "false_at_and_above": {
-             "above_bottom": 5
-           },

patches/server/Handle-Oversized-block-entities-in-chunks.patch

@@ -1,64 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Wed, 6 May 2020 05:00:57 -0400
-Subject: [PATCH] Handle Oversized block entities in chunks
-
-Splits out Extra Packets if too many TE's are encountered to prevent
-creating too large of a packet to sed.
-
-Co-authored-by: Spottedleaf <Spottedleaf@users.noreply.github.com>
-
-diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
-+++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
-@@ -0,0 +0,0 @@ public class ClientboundLevelChunkPacketData {
-     private final CompoundTag heightmaps;
-     private final byte[] buffer;
-     private final List<ClientboundLevelChunkPacketData.BlockEntityInfo> blockEntitiesData;
-+    // Paper start - Handle oversized block entities in chunks
-+    private final java.util.List<net.minecraft.network.protocol.Packet<?>> extraPackets = new java.util.ArrayList<>();
-+    private static final int TE_LIMIT = Integer.getInteger("Paper.excessiveTELimit", 750);
-+
-+    public List<net.minecraft.network.protocol.Packet<?>> getExtraPackets() {
-+        return this.extraPackets;
-+    }
-+    // Paper end - Handle oversized block entities in chunks
- 
-     // Paper start - Anti-Xray - Add chunk packet info
-     @Deprecated @io.papermc.paper.annotation.DoNotUse public ClientboundLevelChunkPacketData(LevelChunk chunk) { this(chunk, null); }
-@@ -0,0 +0,0 @@ public class ClientboundLevelChunkPacketData {
-         extractChunkData(new FriendlyByteBuf(this.getWriteBuffer()), chunk, chunkPacketInfo);
-         // Paper end
-         this.blockEntitiesData = Lists.newArrayList();
-+        int totalTileEntities = 0; // Paper - Handle oversized block entities in chunks
- 
-         for (Entry<BlockPos, BlockEntity> entry2 : chunk.getBlockEntities().entrySet()) {
-+            // Paper start - Handle oversized block entities in chunks
-+            if (++totalTileEntities > TE_LIMIT) {
-+                var packet = entry2.getValue().getUpdatePacket();
-+                if (packet != null) {
-+                    this.extraPackets.add(packet);
-+                    continue;
-+                }
-+            }
-+            // Paper end - Handle oversized block entities in chunks
-             this.blockEntitiesData.add(ClientboundLevelChunkPacketData.BlockEntityInfo.create(entry2.getValue()));
-         }
-     }
-diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java
-+++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundLevelChunkWithLightPacket.java
-@@ -0,0 +0,0 @@ public class ClientboundLevelChunkWithLightPacket implements Packet<ClientGamePa
-     public ClientboundLightUpdatePacketData getLightData() {
-         return this.lightData;
-     }
-+
-+    // Paper start - Handle oversized block entities in chunks
-+    @Override
-+    public java.util.List<Packet<?>> getExtraPackets() {
-+        return this.chunkData.getExtraPackets();
-+    }
-+    // Paper end - Handle oversized block entities in chunks
- }

patches/server/Implement-chunk-view-API.patch

@@ -1,51 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Flo0 <flo.roma@web.de>
-Date: Thu, 5 Dec 2024 12:15:07 +0100
-Subject: [PATCH] Implement chunk view API
-
-
-diff --git a/src/main/java/io/papermc/paper/FeatureHooks.java b/src/main/java/io/papermc/paper/FeatureHooks.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/io/papermc/paper/FeatureHooks.java
-+++ b/src/main/java/io/papermc/paper/FeatureHooks.java
-@@ -0,0 +0,0 @@ package io.papermc.paper;
- import io.papermc.paper.command.PaperSubcommand;
- import io.papermc.paper.command.subcommands.ChunkDebugCommand;
- import io.papermc.paper.command.subcommands.FixLightCommand;
-+import it.unimi.dsi.fastutil.longs.LongIterator;
- import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
--import it.unimi.dsi.fastutil.longs.LongSet;
- import it.unimi.dsi.fastutil.longs.LongSets;
- import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
- import it.unimi.dsi.fastutil.objects.ObjectSet;
-@@ -0,0 +0,0 @@ public final class FeatureHooks {
-     }
- 
-     public static Set<Long> getSentChunkKeys(final ServerPlayer player) {
--        final LongSet keys = new LongOpenHashSet();
--        player.getChunkTrackingView().forEach(pos -> keys.add(pos.longKey));
--        return LongSets.unmodifiable(keys);
-+        return LongSets.unmodifiable(player.moonrise$getChunkLoader().getSentChunksRaw().clone());
-     }
- 
-     public static Set<Chunk> getSentChunks(final ServerPlayer player) {
--        final ObjectSet<Chunk> chunks = new ObjectOpenHashSet<>();
-+        final LongOpenHashSet rawChunkKeys = player.moonrise$getChunkLoader().getSentChunksRaw();
-+        final ObjectSet<org.bukkit.Chunk> chunks = new ObjectOpenHashSet<>(rawChunkKeys.size());
-         final World world = player.serverLevel().getWorld();
--        player.getChunkTrackingView().forEach(pos -> {
--            final org.bukkit.Chunk chunk = world.getChunkAt(pos.longKey);
--            chunks.add(chunk);
--        });
-+        final LongIterator iter = player.moonrise$getChunkLoader().getSentChunksRaw().longIterator();
-+        while (iter.hasNext()) {
-+            chunks.add(world.getChunkAt(iter.nextLong(), false));
-+        }
-         return ObjectSets.unmodifiable(chunks);
-     }
- 
-     public static boolean isChunkSent(final ServerPlayer player, final long chunkKey) {
--        return player.getChunkTrackingView().contains(new ChunkPos(chunkKey));
-+        return player.moonrise$getChunkLoader().getSentChunksRaw().contains(chunkKey);
-     }
- }

patches/server/Improve-Maps-in-item-frames-performance-and-bug-fixe.patch

@@ -1,124 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Fri, 29 Apr 2016 20:02:00 -0400
-Subject: [PATCH] Improve Maps (in item frames) performance and bug fixes
-
-Maps used a modified version of rendering to support plugin controlled
-imaging on maps. The Craft Map Renderer is much slower than Vanilla,
-causing maps in item frames to cause a noticeable hit on server performance.
-
-This updates the map system to not use the Craft system if we detect that no
-custom renderers are in use, defaulting to the much simpler Vanilla system.
-
-Additionally, numerous issues to player position tracking on maps has been fixed.
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
-                             {
-                                 if ( iter.next().player == entity )
-                                 {
-+                                    map.decorations.remove(entity.getName().getString()); // Paper
-                                     iter.remove();
-                                 }
-                             }
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player {
-                 this.awardStat(Stats.DROP);
-             }
- 
-+            // Paper start - remove player from map on drop
-+            if (itemstack.getItem() == net.minecraft.world.item.Items.FILLED_MAP) {
-+                net.minecraft.world.level.saveddata.maps.MapItemSavedData worldmap = net.minecraft.world.item.MapItem.getSavedData(itemstack, this.level());
-+                if (worldmap != null) {
-+                    worldmap.tickCarriedBy(this, itemstack);
-+                    }
-+                }
-+            // Paper end
-             return entityitem;
-         }
-     }
-diff --git a/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java b/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java
-+++ b/src/main/java/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java
-@@ -0,0 +0,0 @@ public class MapItemSavedData extends SavedData {
-     public final Map<String, MapDecoration> decorations = Maps.newLinkedHashMap();
-     private final Map<String, MapFrame> frameMarkers = Maps.newHashMap();
-     private int trackedDecorationCount;
-+    private org.bukkit.craftbukkit.map.RenderData vanillaRender = new org.bukkit.craftbukkit.map.RenderData(); // Paper
- 
-     // CraftBukkit start
-     public final CraftMapView mapView;
-@@ -0,0 +0,0 @@ public class MapItemSavedData extends SavedData {
-         // CraftBukkit start
-         this.mapView = new CraftMapView(this);
-         this.server = (CraftServer) org.bukkit.Bukkit.getServer();
-+        this.vanillaRender.buffer = colors; // Paper
-         // CraftBukkit end
-     }
- 
-@@ -0,0 +0,0 @@ public class MapItemSavedData extends SavedData {
-         if (abyte.length == 16384) {
-             worldmap.colors = abyte;
-         }
-+        worldmap.vanillaRender.buffer = abyte; // Paper
- 
-         RegistryOps<Tag> registryops = registries.createSerializationContext(NbtOps.INSTANCE);
-         List<MapBanner> list = (List) MapBanner.LIST_CODEC.parse(registryops, nbt.get("banners")).resultOrPartial((s) -> {
-@@ -0,0 +0,0 @@ public class MapItemSavedData extends SavedData {
-             --this.trackedDecorationCount;
-         }
- 
--        this.setDecorationsDirty();
-+        if (mapicon != null) this.setDecorationsDirty(); // Paper - only mark dirty if a change occurs
-     }
- 
-     public static void addTargetDecoration(ItemStack stack, BlockPos pos, String id, Holder<MapDecorationType> decorationType) {
-@@ -0,0 +0,0 @@ public class MapItemSavedData extends SavedData {
- 
-     public class HoldingPlayer {
- 
-+        // Paper start
-+        private void addSeenPlayers(java.util.Collection<MapDecoration> icons) {
-+            org.bukkit.entity.Player player = (org.bukkit.entity.Player) this.player.getBukkitEntity();
-+            MapItemSavedData.this.decorations.forEach((name, mapIcon) -> {
-+                // If this cursor is for a player check visibility with vanish system
-+                org.bukkit.entity.Player other = org.bukkit.Bukkit.getPlayerExact(name); // Spigot
-+                if (other == null || player.canSee(other)) {
-+                    icons.add(mapIcon);
-+                }
-+            });
-+        }
-+        private boolean shouldUseVanillaMap() {
-+            return mapView.getRenderers().size() == 1 && mapView.getRenderers().get(0).getClass() == org.bukkit.craftbukkit.map.CraftMapRenderer.class;
-+        }
-+        // Paper end
-         public final Player player;
-         private boolean dirtyData = true;
-         private int minDirtyX;
-@@ -0,0 +0,0 @@ public class MapItemSavedData extends SavedData {
-         @Nullable
-         Packet<?> nextUpdatePacket(MapId mapId) {
-             MapItemSavedData.MapPatch worldmap_c;
--            org.bukkit.craftbukkit.map.RenderData render = MapItemSavedData.this.mapView.render((org.bukkit.craftbukkit.entity.CraftPlayer) this.player.getBukkitEntity()); // CraftBukkit
-+            if (!this.dirtyData && this.tick % 5 != 0) { this.tick++; return null; } // Paper - this won't end up sending, so don't render it!
-+            boolean vanillaMaps = shouldUseVanillaMap(); // Paper
-+            org.bukkit.craftbukkit.map.RenderData render = !vanillaMaps ? MapItemSavedData.this.mapView.render((org.bukkit.craftbukkit.entity.CraftPlayer) this.player.getBukkitEntity()) : MapItemSavedData.this.vanillaRender; // CraftBukkit // Paper
- 
-             if (this.dirtyData) {
-                 this.dirtyData = false;
-@@ -0,0 +0,0 @@ public class MapItemSavedData extends SavedData {
-                 // CraftBukkit start
-                 java.util.Collection<MapDecoration> icons = new java.util.ArrayList<MapDecoration>();
- 
-+                if (vanillaMaps) addSeenPlayers(icons); // Paper
-+
-                 for (org.bukkit.map.MapCursor cursor : render.cursors) {
-                     if (cursor.isVisible()) {
-                         icons.add(new MapDecoration(CraftMapCursor.CraftType.bukkitToMinecraftHolder(cursor.getType()), cursor.getX(), cursor.getY(), cursor.getDirection(), Optional.ofNullable(PaperAdventure.asVanilla(cursor.caption()))));

patches/server/Improve-cancelling-PreCreatureSpawnEvent-with-per-pl.patch

@@ -1,89 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: kickash32 <kickash32@gmail.com>
-Date: Mon, 5 Apr 2021 01:42:35 -0400
-Subject: [PATCH] Improve cancelling PreCreatureSpawnEvent with per player mob
- spawns
-
-
-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
-             ++(backingSet[i].mobCounts[index]);
-         }
-     }
-+    // Paper start - per player mob count backoff
-+    public void updateFailurePlayerMobTypeMap(int chunkX, int chunkZ, net.minecraft.world.entity.MobCategory mobCategory) {
-+        if (!this.level.paperConfig().entities.spawning.perPlayerMobSpawns) {
-+            return;
-+        }
-+        int idx = mobCategory.ordinal();
-+        final ca.spottedleaf.moonrise.common.list.ReferenceList<ServerPlayer> inRange =
-+            this.level.moonrise$getNearbyPlayers().getPlayersByChunk(chunkX, chunkZ, ca.spottedleaf.moonrise.common.misc.NearbyPlayers.NearbyMapType.TICK_VIEW_DISTANCE);
-+        if (inRange == null) {
-+            return;
-+        }
-+        final ServerPlayer[] backingSet = inRange.getRawDataUnchecked();
-+        for (int i = 0, len = inRange.size(); i < len; i++) {
-+            ++(backingSet[i].mobBackoffCounts[idx]);
-+        }
-+    }
-+    // Paper end - per player mob count backoff
-     public int getMobCountNear(final ServerPlayer player, final net.minecraft.world.entity.MobCategory mobCategory) {
--        return player.mobCounts[mobCategory.ordinal()];
-+        return player.mobCounts[mobCategory.ordinal()] + player.mobBackoffCounts[mobCategory.ordinal()]; // Paper - per player mob count backoff
-         // Paper end - Optional per player mob spawns
-     }
-     // Paper end
-diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-+++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource implements ca.spottedleaf.moon
-         if ((this.spawnFriendlies || this.spawnEnemies) && this.level.paperConfig().entities.spawning.perPlayerMobSpawns) { // don't count mobs when animals and monsters are disabled
-             // re-set mob counts
-             for (ServerPlayer player : this.level.players) {
--                Arrays.fill(player.mobCounts, 0);
-+                // Paper start - per player mob spawning backoff
-+                for (int ii = 0; ii < ServerPlayer.MOBCATEGORY_TOTAL_ENUMS; ii++) {
-+                    player.mobCounts[ii] = 0;
-+
-+                    int newBackoff = player.mobBackoffCounts[ii] - 1; // TODO make configurable bleed // TODO use nonlinear algorithm?
-+                    if (newBackoff < 0) {
-+                        newBackoff = 0;
-+                    }
-+                    player.mobBackoffCounts[ii] = newBackoff;
-+                }
-+                // Paper end - per player mob spawning backoff
-             }
-             spawnercreature_d = NaturalSpawner.createState(naturalSpawnChunkCount, this.level.getAllEntities(), this::getFullChunk, null, true);
-         } else {
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player imple
-     public static final int MOBCATEGORY_TOTAL_ENUMS = net.minecraft.world.entity.MobCategory.values().length;
-     public final int[] mobCounts = new int[MOBCATEGORY_TOTAL_ENUMS]; // Paper
-     // Paper end - Optional per player mob spawns
-+    public final int[] mobBackoffCounts = new int[MOBCATEGORY_TOTAL_ENUMS]; // Paper - per player mob count backoff
- 
-     // CraftBukkit start
-     public CraftPlayer.TransferCookieConnection transferCookieConnection;
-diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java
-+++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
-@@ -0,0 +0,0 @@ public final class NaturalSpawner {
- 
-                                     // Paper start - PreCreatureSpawnEvent
-                                     PreSpawnStatus doSpawning = isValidSpawnPostitionForType(world, group, structuremanager, chunkgenerator, biomesettingsmobs_c, blockposition_mutableblockposition, d2);
-+                                    // Paper start - per player mob count backoff
-+                                    if (doSpawning == PreSpawnStatus.ABORT || doSpawning == PreSpawnStatus.CANCELLED) {
-+                                        world.getChunkSource().chunkMap.updateFailurePlayerMobTypeMap(blockposition_mutableblockposition.getX() >> 4, blockposition_mutableblockposition.getZ() >> 4, group);
-+                                    }
-+                                    // Paper end - per player mob count backoff
-                                     if (doSpawning == PreSpawnStatus.ABORT) {
-                                         return;
-                                     }

patches/server/Improve-exact-choice-recipe-ingredients.patch

@@ -1,453 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Sun, 25 Jun 2023 23:10:14 -0700
-Subject: [PATCH] Improve exact choice recipe ingredients
-
-Fixes exact choices not working with recipe book clicks
-and shapeless recipes.
-
-== AT ==
-public net.minecraft.world.item.ItemStackLinkedSet TYPE_AND_TAG
-
-diff --git a/src/main/java/io/papermc/paper/inventory/recipe/ItemOrExact.java b/src/main/java/io/papermc/paper/inventory/recipe/ItemOrExact.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/io/papermc/paper/inventory/recipe/ItemOrExact.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.inventory.recipe;
-+
-+import net.minecraft.core.Holder;
-+import net.minecraft.world.item.ItemStack;
-+
-+public sealed interface ItemOrExact permits ItemOrExact.Item, ItemOrExact.Exact {
-+
-+    int getMaxStackSize();
-+
-+    boolean matches(ItemStack stack);
-+
-+    record Item(Holder<net.minecraft.world.item.Item> item) implements ItemOrExact {
-+
-+        public Item(final ItemStack stack) {
-+            this(stack.getItemHolder());
-+        }
-+
-+        @Override
-+        public int getMaxStackSize() {
-+            return this.item.value().getDefaultMaxStackSize();
-+        }
-+
-+        @Override
-+        public boolean matches(final ItemStack stack) {
-+            return stack.is(this.item);
-+        }
-+
-+        @Override
-+        public boolean equals(final Object obj) {
-+            if (!(obj instanceof final Item otherItem)) return false;
-+            return this.item.equals(otherItem.item());
-+        }
-+
-+        @Override
-+        public int hashCode() {
-+            return this.item.hashCode();
-+        }
-+    }
-+
-+    record Exact(ItemStack stack) implements ItemOrExact {
-+
-+        @Override
-+        public int getMaxStackSize() {
-+            return this.stack.getMaxStackSize();
-+        }
-+
-+        @Override
-+        public boolean matches(final ItemStack stack) {
-+            return ItemStack.isSameItemSameComponents(this.stack, stack);
-+        }
-+
-+        @Override
-+        public boolean equals(final Object obj) {
-+            if (!(obj instanceof final Exact otherExact)) return false;
-+            return ItemStack.isSameItemSameComponents(this.stack, otherExact.stack);
-+        }
-+
-+        @Override
-+        public int hashCode() {
-+            return ItemStack.hashItemAndComponents(this.stack);
-+        }
-+    }
-+}
-diff --git a/src/main/java/io/papermc/paper/inventory/recipe/StackedContentsExtrasMap.java b/src/main/java/io/papermc/paper/inventory/recipe/StackedContentsExtrasMap.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/io/papermc/paper/inventory/recipe/StackedContentsExtrasMap.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.inventory.recipe;
-+
-+import it.unimi.dsi.fastutil.objects.Object2IntMap;
-+import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
-+import it.unimi.dsi.fastutil.objects.ObjectOpenCustomHashSet;
-+import it.unimi.dsi.fastutil.objects.ObjectSet;
-+import net.minecraft.world.entity.player.StackedContents;
-+import net.minecraft.world.item.ItemStack;
-+import net.minecraft.world.item.ItemStackLinkedSet;
-+import net.minecraft.world.item.crafting.CraftingInput;
-+import net.minecraft.world.item.crafting.Ingredient;
-+import net.minecraft.world.item.crafting.Recipe;
-+
-+public final class StackedContentsExtrasMap {
-+
-+    private final StackedContents<ItemOrExact> contents;
-+    public Object2IntMap<ItemOrExact.Item> regularRemoved = new Object2IntOpenHashMap<>(); // needed for re-using the regular contents (for ShapelessRecipe)
-+    public final ObjectSet<ItemStack> exactIngredients = new ObjectOpenCustomHashSet<>(ItemStackLinkedSet.TYPE_AND_TAG);
-+
-+    public StackedContentsExtrasMap(final StackedContents<ItemOrExact> contents) {
-+        this.contents = contents;
-+    }
-+
-+    public void initialize(final Recipe<?> recipe) {
-+        this.exactIngredients.clear();
-+        for (final Ingredient ingredient : recipe.placementInfo().ingredients()) {
-+            if (ingredient.isExact()) {
-+                this.exactIngredients.addAll(ingredient.itemStacks());
-+            }
-+        }
-+    }
-+
-+    public void accountInput(final CraftingInput input) {
-+        // similar logic to the CraftingInput constructor
-+        for (final ItemStack item : input.items()) {
-+            if (!item.isEmpty()) {
-+                if (this.accountStack(item, 1)) {
-+                    // if stack was accounted for as an exact ingredient, don't include it in the regular contents
-+                    final ItemOrExact.Item asItem = new ItemOrExact.Item(item);
-+                    if (this.contents.amounts.containsKey(asItem)) {
-+                        final int amount = this.contents.amounts.removeInt(asItem);
-+                        this.regularRemoved.put(asItem, amount);
-+                    }
-+                }
-+            }
-+        }
-+    }
-+
-+    public void resetExtras() {
-+        // clear previous extra ids
-+        for (final ItemStack extra : this.exactIngredients) {
-+            this.contents.amounts.removeInt(new ItemOrExact.Exact(extra));
-+        }
-+        for (final Object2IntMap.Entry<ItemOrExact.Item> entry : this.regularRemoved.object2IntEntrySet()) {
-+            this.contents.amounts.addTo(entry.getKey(), entry.getIntValue());
-+        }
-+        this.exactIngredients.clear();
-+        this.regularRemoved.clear();
-+    }
-+
-+    public boolean accountStack(final ItemStack stack, final int count) {
-+        if (this.exactIngredients.contains(stack)) {
-+            this.contents.account(new ItemOrExact.Exact(stack), count);
-+            return true;
-+        }
-+        return false;
-+    }
-+}
-diff --git a/src/main/java/net/minecraft/recipebook/ServerPlaceRecipe.java b/src/main/java/net/minecraft/recipebook/ServerPlaceRecipe.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/recipebook/ServerPlaceRecipe.java
-+++ b/src/main/java/net/minecraft/recipebook/ServerPlaceRecipe.java
-@@ -0,0 +0,0 @@ public class ServerPlaceRecipe<R extends Recipe<?>> {
-             return RecipeBookMenu.PostPlaceAction.NOTHING;
-         } else {
-             StackedItemContents stackedItemContents = new StackedItemContents();
-+            stackedItemContents.initializeExtras(recipe.value(), null); // Paper - Improve exact choice recipe ingredients
-             inventory.fillStackedContents(stackedItemContents);
-             handler.fillCraftSlotsStackedContents(stackedItemContents);
-             return serverPlaceRecipe.tryPlaceRecipe(recipe, stackedItemContents);
-@@ -0,0 +0,0 @@ public class ServerPlaceRecipe<R extends Recipe<?>> {
-         }
- 
-         int j = this.calculateAmountToCraft(i, bl);
--        List<Holder<Item>> list = new ArrayList<>();
-+        List<io.papermc.paper.inventory.recipe.ItemOrExact> list = new ArrayList<>(); // Paper - Improve exact choice recipe ingredients
-         if (finder.canCraft(recipe.value(), j, list::add)) {
-             int k = clampToMaxStackSize(j, list);
-             if (k != j) {
-@@ -0,0 +0,0 @@ public class ServerPlaceRecipe<R extends Recipe<?>> {
-                 this.gridWidth, this.gridHeight, recipe.value(), recipe.value().placementInfo().slotsToIngredientIndex(), (slotx, index, x, y) -> {
-                     if (slotx != -1) {
-                         Slot slot2 = this.inputGridSlots.get(index);
--                        Holder<Item> holder = list.get(slotx);
-+                        io.papermc.paper.inventory.recipe.ItemOrExact holder = list.get(slotx); // Paper - Improve exact choice recipe ingredients
-                         int jx = k;
- 
-                         while (jx > 0) {
-@@ -0,0 +0,0 @@ public class ServerPlaceRecipe<R extends Recipe<?>> {
-         }
-     }
- 
--    private static int clampToMaxStackSize(int count, List<Holder<Item>> entries) {
--        for (Holder<Item> holder : entries) {
--            count = Math.min(count, holder.value().getDefaultMaxStackSize());
-+    // Paper start - Improve exact choice recipe ingredients
-+    private static int clampToMaxStackSize(int count, List<io.papermc.paper.inventory.recipe.ItemOrExact> entries) {
-+        for (io.papermc.paper.inventory.recipe.ItemOrExact holder : entries) {
-+            count = Math.min(count, holder.getMaxStackSize());
-+            // Paper end - Improve exact choice recipe ingredients
-         }
- 
-         return count;
-@@ -0,0 +0,0 @@ public class ServerPlaceRecipe<R extends Recipe<?>> {
-         }
-     }
- 
--    private int moveItemToGrid(Slot slot, Holder<Item> item, int count) {
-+    private int moveItemToGrid(Slot slot, io.papermc.paper.inventory.recipe.ItemOrExact item, int count) { // Paper - Improve exact choice recipe ingredients
-         ItemStack itemStack = slot.getItem();
-         int i = this.inventory.findSlotMatchingCraftingIngredient(item, itemStack);
-         if (i == -1) {
-diff --git a/src/main/java/net/minecraft/world/entity/player/Inventory.java b/src/main/java/net/minecraft/world/entity/player/Inventory.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/player/Inventory.java
-+++ b/src/main/java/net/minecraft/world/entity/player/Inventory.java
-@@ -0,0 +0,0 @@ public class Inventory implements Container, Nameable {
-         return !stack.isDamaged() && !stack.isEnchanted() && !stack.has(DataComponents.CUSTOM_NAME);
-     }
- 
--    public int findSlotMatchingCraftingIngredient(Holder<Item> item, ItemStack stack) {
-+    public int findSlotMatchingCraftingIngredient(io.papermc.paper.inventory.recipe.ItemOrExact item, ItemStack stack) { // Paper - Improve exact choice recipe ingredients
-         for (int i = 0; i < this.items.size(); ++i) {
-             ItemStack itemstack1 = (ItemStack) this.items.get(i);
- 
--            if (!itemstack1.isEmpty() && itemstack1.is(item) && Inventory.isUsableForCrafting(itemstack1) && (stack.isEmpty() || ItemStack.isSameItemSameComponents(stack, itemstack1))) {
-+            if (!itemstack1.isEmpty() && item.matches(itemstack1) && (!(item instanceof io.papermc.paper.inventory.recipe.ItemOrExact.Item) || Inventory.isUsableForCrafting(itemstack1)) && (stack.isEmpty() || ItemStack.isSameItemSameComponents(stack, itemstack1))) { // Paper - Improve exact choice recipe ingredients
-                 return i;
-             }
-         }
-diff --git a/src/main/java/net/minecraft/world/entity/player/StackedContents.java b/src/main/java/net/minecraft/world/entity/player/StackedContents.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/player/StackedContents.java
-+++ b/src/main/java/net/minecraft/world/entity/player/StackedContents.java
-@@ -0,0 +0,0 @@ import java.util.List;
- import javax.annotation.Nullable;
- 
- public class StackedContents<T> {
--    public final Reference2IntOpenHashMap<T> amounts = new Reference2IntOpenHashMap<>();
-+    public final it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap<T> amounts = new it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap<>(); // Paper - Improve exact choice recipe ingredients (don't use "reference" map)
- 
-     boolean hasAtLeast(T input, int minimum) {
-         return this.amounts.getInt(input) >= minimum;
-@@ -0,0 +0,0 @@ public class StackedContents<T> {
-     List<T> getUniqueAvailableIngredientItems(Iterable<? extends StackedContents.IngredientInfo<T>> ingredients) {
-         List<T> list = new ArrayList<>();
- 
--        for (Entry<T> entry : Reference2IntMaps.fastIterable(this.amounts)) {
-+        for (it.unimi.dsi.fastutil.objects.Object2IntMap.Entry<T> entry : it.unimi.dsi.fastutil.objects.Object2IntMaps.fastIterable(this.amounts)) { // Paper - Improve exact choice recipe ingredients (don't use "reference" map)
-             if (entry.getIntValue() > 0 && anyIngredientMatches(ingredients, entry.getKey())) {
-                 list.add(entry.getKey());
-             }
-@@ -0,0 +0,0 @@ public class StackedContents<T> {
-     @VisibleForTesting
-     public int getResultUpperBound(List<? extends StackedContents.IngredientInfo<T>> ingredients) {
-         int i = Integer.MAX_VALUE;
--        ObjectIterable<Entry<T>> objectIterable = Reference2IntMaps.fastIterable(this.amounts);
-+        ObjectIterable<it.unimi.dsi.fastutil.objects.Object2IntMap.Entry<T>> objectIterable = it.unimi.dsi.fastutil.objects.Object2IntMaps.fastIterable(this.amounts); // Paper - Improve exact choice recipe ingredients (don't use "reference" map)
- 
-         label31:
-         for (StackedContents.IngredientInfo<T> ingredientInfo : ingredients) {
-             int j = 0;
- 
--            for (Entry<T> entry : objectIterable) {
-+            for (it.unimi.dsi.fastutil.objects.Object2IntMap.Entry<T> entry : objectIterable) { // Paper - Improve exact choice recipe ingredients (don't use "reference" map)
-                 int k = entry.getIntValue();
-                 if (k > j) {
-                     if (ingredientInfo.acceptsItem(entry.getKey())) {
-diff --git a/src/main/java/net/minecraft/world/entity/player/StackedItemContents.java b/src/main/java/net/minecraft/world/entity/player/StackedItemContents.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/player/StackedItemContents.java
-+++ b/src/main/java/net/minecraft/world/entity/player/StackedItemContents.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.item.crafting.PlacementInfo;
- import net.minecraft.world.item.crafting.Recipe;
- 
- public class StackedItemContents {
--    private final StackedContents<Holder<Item>> raw = new StackedContents<>();
-+    // Paper start - Improve exact choice recipe ingredients
-+    private final StackedContents<io.papermc.paper.inventory.recipe.ItemOrExact> raw = new StackedContents<>();
-+    @Nullable
-+    private io.papermc.paper.inventory.recipe.StackedContentsExtrasMap extrasMap = null;
-+    // Paper start - Improve exact choice recipe ingredients
- 
-     public void accountSimpleStack(ItemStack item) {
-+        if (this.extrasMap != null && this.extrasMap.accountStack(item, Math.min(64, item.getCount()))) return; // Paper - Improve exact choice recipe ingredients; max of 64 due to accountStack method below
-         if (Inventory.isUsableForCrafting(item)) {
-             this.accountStack(item);
-         }
-@@ -0,0 +0,0 @@ public class StackedItemContents {
-     public void accountStack(ItemStack item, int maxCount) {
-         if (!item.isEmpty()) {
-             int i = Math.min(maxCount, item.getCount());
--            this.raw.account(item.getItemHolder(), i);
-+            if (this.extrasMap != null && !item.getComponentsPatch().isEmpty() && this.extrasMap.accountStack(item, i)) return; // Paper - Improve exact choice recipe ingredients; if an exact ingredient, don't include it
-+            this.raw.account(new io.papermc.paper.inventory.recipe.ItemOrExact.Item(item.getItemHolder()), i);
-         }
-     }
- 
--    public boolean canCraft(Recipe<?> recipe, @Nullable StackedContents.Output<Holder<Item>> itemCallback) {
-+    // Paper start - Improve exact choice recipe ingredients
-+    public void initializeExtras(final Recipe<?> recipe, @Nullable final net.minecraft.world.item.crafting.CraftingInput input) {
-+        if (this.extrasMap == null) {
-+            this.extrasMap = new io.papermc.paper.inventory.recipe.StackedContentsExtrasMap(this.raw);
-+        }
-+        this.extrasMap.initialize(recipe);
-+        if (input != null) this.extrasMap.accountInput(input);
-+    }
-+
-+    public void resetExtras() {
-+        if (this.extrasMap != null && !this.raw.amounts.isEmpty()) {
-+            this.extrasMap.resetExtras();
-+        }
-+    }
-+    // Paper end - Improve exact choice recipe ingredients
-+
-+    public boolean canCraft(Recipe<?> recipe, @Nullable StackedContents.Output<io.papermc.paper.inventory.recipe.ItemOrExact> itemCallback) { // Paper - Improve exact choice recipe ingredients
-         return this.canCraft(recipe, 1, itemCallback);
-     }
- 
--    public boolean canCraft(Recipe<?> recipe, int quantity, @Nullable StackedContents.Output<Holder<Item>> itemCallback) {
-+    public boolean canCraft(Recipe<?> recipe, int quantity, @Nullable StackedContents.Output<io.papermc.paper.inventory.recipe.ItemOrExact> itemCallback) { // Paper - Improve exact choice recipe ingredients
-         PlacementInfo placementInfo = recipe.placementInfo();
-         return !placementInfo.isImpossibleToPlace() && this.canCraft(placementInfo.ingredients(), quantity, itemCallback);
-     }
- 
-     public boolean canCraft(
--        List<? extends StackedContents.IngredientInfo<Holder<Item>>> rawIngredients, @Nullable StackedContents.Output<Holder<Item>> itemCallback
-+        List<? extends StackedContents.IngredientInfo<io.papermc.paper.inventory.recipe.ItemOrExact>> rawIngredients, @Nullable StackedContents.Output<io.papermc.paper.inventory.recipe.ItemOrExact> itemCallback // Paper - Improve exact choice recipe ingredients
-     ) {
-         return this.canCraft(rawIngredients, 1, itemCallback);
-     }
- 
-     private boolean canCraft(
--        List<? extends StackedContents.IngredientInfo<Holder<Item>>> rawIngredients, int quantity, @Nullable StackedContents.Output<Holder<Item>> itemCallback
-+        List<? extends StackedContents.IngredientInfo<io.papermc.paper.inventory.recipe.ItemOrExact>> rawIngredients, int quantity, @Nullable StackedContents.Output<io.papermc.paper.inventory.recipe.ItemOrExact> itemCallback // Paper - Improve exact choice recipe ingredients
-     ) {
-         return this.raw.tryPick(rawIngredients, quantity, itemCallback);
-     }
- 
--    public int getBiggestCraftableStack(Recipe<?> recipe, @Nullable StackedContents.Output<Holder<Item>> itemCallback) {
-+    public int getBiggestCraftableStack(Recipe<?> recipe, @Nullable StackedContents.Output<io.papermc.paper.inventory.recipe.ItemOrExact> itemCallback) { // Paper - Improve exact choice recipe ingredients
-         return this.getBiggestCraftableStack(recipe, Integer.MAX_VALUE, itemCallback);
-     }
- 
--    public int getBiggestCraftableStack(Recipe<?> recipe, int max, @Nullable StackedContents.Output<Holder<Item>> itemCallback) {
-+    public int getBiggestCraftableStack(Recipe<?> recipe, int max, @Nullable StackedContents.Output<io.papermc.paper.inventory.recipe.ItemOrExact> itemCallback) { // Paper - Improve exact choice recipe ingredients
-         return this.raw.tryPickAll(recipe.placementInfo().ingredients(), max, itemCallback);
-     }
- 
-diff --git a/src/main/java/net/minecraft/world/item/crafting/Ingredient.java b/src/main/java/net/minecraft/world/item/crafting/Ingredient.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/item/crafting/Ingredient.java
-+++ b/src/main/java/net/minecraft/world/item/crafting/Ingredient.java
-@@ -0,0 +0,0 @@ import java.util.List;
- import javax.annotation.Nullable;
- // CraftBukkit end
- 
--public final class Ingredient implements StackedContents.IngredientInfo<Holder<Item>>, Predicate<ItemStack> {
-+public final class Ingredient implements StackedContents.IngredientInfo<io.papermc.paper.inventory.recipe.ItemOrExact>, Predicate<ItemStack> { // Paper - Improve exact choice recipe ingredients
- 
-     public static final StreamCodec<RegistryFriendlyByteBuf, Ingredient> CONTENTS_STREAM_CODEC = ByteBufCodecs.holderSet(Registries.ITEM).map(Ingredient::new, (recipeitemstack) -> {
-         return recipeitemstack.values;
-@@ -0,0 +0,0 @@ public final class Ingredient implements StackedContents.IngredientInfo<Holder<I
-     private final HolderSet<Item> values;
-     // CraftBukkit start
-     @Nullable
--    private List<ItemStack> itemStacks;
-+    private java.util.Set<ItemStack> itemStacks; // Paper - Improve exact choice recipe ingredients
- 
-     public boolean isExact() {
-         return this.itemStacks != null;
-     }
- 
--    public List<ItemStack> itemStacks() {
-+    public java.util.Set<ItemStack> itemStacks() { // Paper - Improve exact choice recipe ingredients
-         return this.itemStacks;
-     }
- 
-     public static Ingredient ofStacks(List<ItemStack> stacks) {
-         Ingredient recipe = Ingredient.of(stacks.stream().map(ItemStack::getItem));
--        recipe.itemStacks = stacks;
-+        // Paper start - Improve exact choice recipe ingredients
-+        recipe.itemStacks = net.minecraft.world.item.ItemStackLinkedSet.createTypeAndComponentsSet();
-+        recipe.itemStacks.addAll(stacks);
-+        recipe.itemStacks = java.util.Collections.unmodifiableSet(recipe.itemStacks);
-+        // Paper end - Improve exact choice recipe ingredients
-         return recipe;
-     }
-     // CraftBukkit end
-@@ -0,0 +0,0 @@ public final class Ingredient implements StackedContents.IngredientInfo<Holder<I
-     public boolean test(ItemStack itemstack) {
-         // CraftBukkit start
-         if (this.isExact()) {
--            for (ItemStack itemstack1 : this.itemStacks()) {
--                if (itemstack1.getItem() == itemstack.getItem() && ItemStack.isSameItemSameComponents(itemstack, itemstack1)) {
--                    return true;
--                }
--            }
--
--            return false;
-+            return this.itemStacks.contains(itemstack); // Paper - Improve exact choice recipe ingredients (hashing FTW!)
-         }
-         // CraftBukkit end
-         return itemstack.is(this.values);
-     }
- 
--    public boolean acceptsItem(Holder<Item> holder) {
--        return this.values.contains(holder);
-+    // Paper start - Improve exact choice recipe ingredients
-+    @Override
-+    public boolean acceptsItem(final io.papermc.paper.inventory.recipe.ItemOrExact holder) {
-+        return switch (holder) {
-+            case io.papermc.paper.inventory.recipe.ItemOrExact.Item(final Holder<Item> item) ->
-+                !this.isExact() && this.values.contains(item);
-+            case io.papermc.paper.inventory.recipe.ItemOrExact.Exact(final ItemStack exact) ->
-+                this.isExact() && this.itemStacks.contains(exact);
-+        };
-+        // Paper end - Improve exact choice recipe ingredients
-     }
- 
-     public boolean equals(Object object) {
-@@ -0,0 +0,0 @@ public final class Ingredient implements StackedContents.IngredientInfo<Holder<I
-     }
- 
-     public SlotDisplay display() {
-+        // Paper start - show exact ingredients in recipe book
-+        if (this.isExact()) {
-+            return new SlotDisplay.Composite(this.itemStacks().stream().<SlotDisplay>map(SlotDisplay.ItemStackSlotDisplay::new).toList());
-+        }
-+        // Paper end - show exact ingredients in recipe book
-         return (SlotDisplay) this.values.unwrap().map(SlotDisplay.TagSlotDisplay::new, (list) -> {
-             return new SlotDisplay.Composite(list.stream().map(Ingredient::displayForSingleItem).toList());
-         });
-diff --git a/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java b/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java
-+++ b/src/main/java/net/minecraft/world/item/crafting/ShapelessRecipe.java
-@@ -0,0 +0,0 @@ public class ShapelessRecipe implements CraftingRecipe {
-     }
- 
-     public boolean matches(CraftingInput input, Level world) {
--        return input.ingredientCount() != this.ingredients.size() ? false : (input.size() == 1 && this.ingredients.size() == 1 ? ((Ingredient) this.ingredients.getFirst()).test(input.getItem(0)) : input.stackedContents().canCraft((Recipe) this, (StackedContents.Output) null));
-+        // Paper start - Improve exact choice recipe ingredients & unwrap ternary
-+        if (input.ingredientCount() != this.ingredients.size()) {
-+            return false;
-+        }
-+        if (input.size() == 1 && this.ingredients.size() == 1) {
-+            return this.ingredients.getFirst().test(input.getItem(0));
-+        }
-+        input.stackedContents().initializeExtras(this, input);
-+        boolean canCraft = input.stackedContents().canCraft(this, null);
-+        input.stackedContents().resetExtras();
-+        return canCraft;
-+        // Paper end - Improve exact choice recipe ingredients & unwrap ternary
-     }
- 
-     public ItemStack assemble(CraftingInput input, HolderLookup.Provider registries) {

patches/server/Improve-performance-of-mass-crafts.patch

@@ -1,92 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jake Potrebic <jake.m.potrebic@gmail.com>
-Date: Sun, 13 Aug 2023 15:41:52 -0700
-Subject: [PATCH] Improve performance of mass crafts
-
-When the server crafts all available items in CraftingMenu or InventoryMenu the game
-checks either 4 or 9 times for each individual craft for a matching recipe for that container.
-This check can be expensive if 64 total crafts are being performed with the recipe matching logic
-being run 64 * 9 + 64 times. A breakdown of those times is below. This patch caches the last matching
-recipe so that it is checked first and only if it doesn't match does the rest of the matching logic run.
-
-Shift-click crafts are processed one at a time, so shift clicking on an item in the result of a iron block craft
-where all the 9 inputs are full stacks of iron will run 64 iron block crafts. For each of those crafts, the
-'remaining' blocks are calculated. This is due to recipes that have leftover items like buckets. This is done
-for each craft, and done once to get the full 9 leftover items which are usually air. Then 1 item is removed
-from each of the 9 inputs and each time that happens, logic is triggered to update the result itemstack. So
-for each craft, that logic is run 9 times (hence the 64 * 9). The + 64 is from the 64 checks for remaining items.
-
-After this patch, the full iteration over all recipes checking for a match should run once for a full craft to find the
-initial recipe match. Then that recipe will be checked first for all future recipe match checks.
-
-diff --git a/src/main/java/net/minecraft/world/inventory/CraftingContainer.java b/src/main/java/net/minecraft/world/inventory/CraftingContainer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/inventory/CraftingContainer.java
-+++ b/src/main/java/net/minecraft/world/inventory/CraftingContainer.java
-@@ -0,0 +0,0 @@ public interface CraftingContainer extends Container, StackedContentsCompatible
-     List<ItemStack> getItems();
- 
-     // CraftBukkit start
--    default RecipeHolder<?> getCurrentRecipe() {
-+    default RecipeHolder<net.minecraft.world.item.crafting.CraftingRecipe> getCurrentRecipe() { // Paper - use correct generic
-         return null;
-     }
- 
--    default void setCurrentRecipe(RecipeHolder<?> recipe) {
-+    default void setCurrentRecipe(RecipeHolder<net.minecraft.world.item.crafting.CraftingRecipe> recipe) { // Paper - use correct generic
-     }
-     // CraftBukkit end
- 
-diff --git a/src/main/java/net/minecraft/world/inventory/CraftingMenu.java b/src/main/java/net/minecraft/world/inventory/CraftingMenu.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/inventory/CraftingMenu.java
-+++ b/src/main/java/net/minecraft/world/inventory/CraftingMenu.java
-@@ -0,0 +0,0 @@ public class CraftingMenu extends AbstractCraftingMenu {
-         CraftingInput craftinginput = craftingInventory.asCraftInput();
-         ServerPlayer entityplayer = (ServerPlayer) player;
-         ItemStack itemstack = ItemStack.EMPTY;
-+        if (recipe == null) recipe = craftingInventory.getCurrentRecipe(); // Paper - Perf: Improve mass crafting; check last recipe used first
-         Optional<RecipeHolder<CraftingRecipe>> optional = world.getServer().getRecipeManager().getRecipeFor(RecipeType.CRAFTING, craftinginput, world, recipe);
-         craftingInventory.setCurrentRecipe(optional.orElse(null)); // CraftBukkit
- 
-diff --git a/src/main/java/net/minecraft/world/inventory/ResultSlot.java b/src/main/java/net/minecraft/world/inventory/ResultSlot.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/inventory/ResultSlot.java
-+++ b/src/main/java/net/minecraft/world/inventory/ResultSlot.java
-@@ -0,0 +0,0 @@ public class ResultSlot extends Slot {
-     private NonNullList<ItemStack> getRemainingItems(CraftingInput input, Level world) {
-         return world instanceof ServerLevel serverLevel
-             ? serverLevel.recipeAccess()
--                .getRecipeFor(RecipeType.CRAFTING, input, serverLevel)
-+                .getRecipeFor(RecipeType.CRAFTING, input, serverLevel, this.craftSlots.getCurrentRecipe()) // Paper - Perf: Improve mass crafting; check last recipe used first
-                 .map(recipe -> recipe.value().getRemainingItems(input))
-                 .orElseGet(() -> copyAllInputItems(input))
-             : CraftingRecipe.defaultCraftingReminder(input);
-diff --git a/src/main/java/net/minecraft/world/inventory/TransientCraftingContainer.java b/src/main/java/net/minecraft/world/inventory/TransientCraftingContainer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/inventory/TransientCraftingContainer.java
-+++ b/src/main/java/net/minecraft/world/inventory/TransientCraftingContainer.java
-@@ -0,0 +0,0 @@ public class TransientCraftingContainer implements CraftingContainer {
- 
-     // CraftBukkit start - add fields
-     public List<HumanEntity> transaction = new java.util.ArrayList<HumanEntity>();
--    private RecipeHolder<?> currentRecipe;
-+    private RecipeHolder<net.minecraft.world.item.crafting.CraftingRecipe> currentRecipe; // Paper - use correct generic
-     public Container resultInventory;
-     private Player owner;
-     private int maxStack = MAX_STACK;
-@@ -0,0 +0,0 @@ public class TransientCraftingContainer implements CraftingContainer {
-     }
- 
-     @Override
--    public RecipeHolder<?> getCurrentRecipe() {
-+    public RecipeHolder<net.minecraft.world.item.crafting.CraftingRecipe> getCurrentRecipe() { // Paper - use correct generic
-         return this.currentRecipe;
-     }
- 
-     @Override
--    public void setCurrentRecipe(RecipeHolder<?> currentRecipe) {
-+    public void setCurrentRecipe(RecipeHolder<net.minecraft.world.item.crafting.CraftingRecipe> currentRecipe) { // Paper - use correct generic
-         this.currentRecipe = currentRecipe;
-     }
- 

patches/server/Improved-Watchdog-Support.patch

@@ -1,455 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sun, 12 Apr 2020 15:50:48 -0400
-Subject: [PATCH] Improved Watchdog Support
-
-Forced Watchdog Crash support and Improve Async Shutdown
-
-If the request to shut down the server is received while we are in
-a watchdog hang, immediately treat it as a crash and begin the shutdown
-process. Shutdown process is now improved to also shutdown cleanly when
-not using restart scripts either.
-
-If a server is deadlocked, a server owner can send SIGUP (or any other signal
-the JVM understands to shut down as it currently does) and the watchdog
-will no longer need to wait until the full timeout, allowing you to trigger
-a close process and try to shut the server down gracefully, saving player and
-world data.
-
-Previously there was no way to trigger this outside of waiting for a full watchdog
-timeout, which may be set to a really long time...
-
-Additionally, fix everything to do with shutting the server down asynchronously.
-
-Previously, nearly everything about the process was fragile and unsafe. Main might
-not have actually been frozen, and might still be manipulating state.
-
-Or, some reuest might ask main to do something in the shutdown but main is dead.
-
-Or worse, other things might start closing down items such as the Console or Thread Pool
-before we are fully shutdown.
-
-This change tries to resolve all of these issues by moving everything into the stop
-method and guaranteeing only one thread is stopping the server.
-
-We then issue Thread Death to the main thread of another thread initiates the stop process.
-We have to ensure Thread Death propagates correctly though to stop main completely.
-
-This is to ensure that if main isn't truely stuck, it's not manipulating state we are trying to save.
-
-This also moves all plugins who register "delayed init" tasks to occur just before "Done" so they
-are properly accounted for and wont trip watchdog on init.
-
-diff --git a/src/main/java/io/papermc/paper/util/LogManagerShutdownThread.java b/src/main/java/io/papermc/paper/util/LogManagerShutdownThread.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/io/papermc/paper/util/LogManagerShutdownThread.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.util;
-+
-+public class LogManagerShutdownThread extends Thread {
-+
-+    static LogManagerShutdownThread INSTANCE = new LogManagerShutdownThread();
-+    public static final void hook() {
-+        if (INSTANCE == null) {
-+            throw new IllegalStateException("Cannot re-hook after being unhooked");
-+        }
-+        Runtime.getRuntime().addShutdownHook(INSTANCE);
-+    }
-+
-+    public static final void unhook() {
-+        Runtime.getRuntime().removeShutdownHook(INSTANCE);
-+        INSTANCE = null;
-+    }
-+
-+    private LogManagerShutdownThread() {
-+        super("Log4j2 Shutdown Thread");
-+    }
-+
-+    @Override
-+    public void run() {
-+        org.apache.logging.log4j.LogManager.shutdown();
-+    }
-+}
-diff --git a/src/main/java/net/minecraft/CrashReport.java b/src/main/java/net/minecraft/CrashReport.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/CrashReport.java
-+++ b/src/main/java/net/minecraft/CrashReport.java
-@@ -0,0 +0,0 @@ public class CrashReport {
-     }
- 
-     public static CrashReport forThrowable(Throwable cause, String title) {
-+        if (cause instanceof ThreadDeath) com.destroystokyo.paper.util.SneakyThrow.sneaky(cause); // Paper
-         while (cause instanceof CompletionException && cause.getCause() != null) {
-             cause = cause.getCause();
-         }
-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 {
-     @SuppressForbidden(reason = "System.out needed before bootstrap") // CraftBukkit - decompile error
-     @DontObfuscate
-     public static void main(final OptionSet optionset) { // CraftBukkit - replaces main(String[] astring)
-+        io.papermc.paper.util.LogManagerShutdownThread.hook(); // Paper
-         SharedConstants.tryDetectVersion();
-         /* CraftBukkit start - Replace everything
-         OptionParser optionparser = new OptionParser();
-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
-     public java.util.Queue<Runnable> processQueue = new java.util.concurrent.ConcurrentLinkedQueue<Runnable>();
-     public int autosavePeriod;
-     // Paper - don't store the vanilla dispatcher
--    private boolean forceTicks;
-+    public boolean forceTicks; // Paper - Improved watchdog support
-     // CraftBukkit end
-     // Spigot start
-     public static final int TPS = 20;
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-     public boolean isIteratingOverLevels = false; // Paper - Throw exception on world create while being ticked
-     private final Set<String> pluginsBlockingSleep = new java.util.HashSet<>(); // Paper - API to allow/disallow tick sleeping
- 
-+    public volatile Thread shutdownThread; // Paper
-+    public volatile boolean abnormalExit = false; // Paper
-+
-     public static <S extends MinecraftServer> S spin(Function<Thread, S> serverFactory) {
-         ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.init(); // Paper - rewrite data converter system
-         AtomicReference<S> atomicreference = new AtomicReference();
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         }
-         */
-         // Paper end
-+        io.papermc.paper.util.LogManagerShutdownThread.unhook(); // Paper
-         Runtime.getRuntime().addShutdownHook(new org.bukkit.craftbukkit.util.ServerShutdownThread(this));
-         // CraftBukkit end
-         this.paperConfigurations = services.paperConfigurations(); // Paper - add paper configuration files
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-     // CraftBukkit start
-     private boolean hasStopped = false;
-     private boolean hasLoggedStop = false; // Paper - Debugging
-+    public volatile boolean hasFullyShutdown = false; // Paper
-     private final Object stopLock = new Object();
-     public final boolean hasStopped() {
-         synchronized (this.stopLock) {
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-             this.hasStopped = true;
-         }
-         if (!hasLoggedStop && isDebugging()) io.papermc.paper.util.TraceUtil.dumpTraceForThread("Server stopped"); // Paper - Debugging
-+        // Paper start - kill main thread, and kill it hard
-+        shutdownThread = Thread.currentThread();
-+        org.spigotmc.WatchdogThread.doStop(); // Paper
-+        // Paper end
-         // CraftBukkit end
-         if (this.metricsRecorder.isRecording()) {
-             this.cancelRecordingMetrics();
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-             ca.spottedleaf.moonrise.common.util.MoonriseCommon.haltExecutors();
-         }
-         // Paper end - rewrite chunk system
-+        // Paper start - Improved watchdog support - move final shutdown items here
-+        Util.shutdownExecutors();
-+        try {
-+            net.minecrell.terminalconsole.TerminalConsoleAppender.close(); // Paper - Use TerminalConsoleAppender
-+        } catch (final Exception ignored) {
-+        }
-+        io.papermc.paper.log.CustomLogManager.forceReset(); // Paper - Reset loggers after shutdown
-+        this.onServerExit();
-+        // Paper end - Improved watchdog support - move final shutdown items here
-     }
- 
-     public String getLocalIp() {
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
- 
-     protected void runServer() {
-         try {
-+            long serverStartTime = Util.getNanos(); // Paper
-             if (!this.initServer()) {
-                 throw new IllegalStateException("Failed to initialize server");
-             }
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
- 
-             this.server.spark.enableBeforePlugins(); // Paper - spark
-             // Spigot start
-+            // Paper start - Improved Watchdog Support
-+            LOGGER.info("Running delayed init tasks");
-+            this.server.getScheduler().mainThreadHeartbeat(); // run all 1 tick delay tasks during init,
-+            // this is going to be the first thing the tick process does anyways, so move done and run it after
-+            // everything is init before watchdog tick.
-+            // anything at 3+ won't be caught here but also will trip watchdog....
-+            // tasks are default scheduled at -1 + delay, and first tick will tick at 1
-+            final long actualDoneTimeMs = System.currentTimeMillis() - org.bukkit.craftbukkit.Main.BOOT_TIME.toEpochMilli(); // Paper - Add total time
-+            LOGGER.info("Done ({})! For help, type \"help\"", String.format(java.util.Locale.ROOT, "%.3fs", actualDoneTimeMs / 1000.00D)); // Paper - Add total time
-+            org.spigotmc.WatchdogThread.tick();
-+            // Paper end - Improved Watchdog Support
-             org.spigotmc.WatchdogThread.hasStarted = true; // Paper
-             Arrays.fill( this.recentTps, 20 );
-             // Paper start - further improve server tick loop
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-                 JvmProfiler.INSTANCE.onServerTick(this.smoothedTickTimeMillis);
-             }
-         } catch (Throwable throwable2) {
-+            // Paper start
-+            if (throwable2 instanceof ThreadDeath) {
-+                MinecraftServer.LOGGER.error("Main thread terminated by WatchDog due to hard crash", throwable2);
-+                return;
-+            }
-+            // Paper end
-             MinecraftServer.LOGGER.error("Encountered an unexpected exception", throwable2);
-             CrashReport crashreport = MinecraftServer.constructOrExtractCrashReport(throwable2);
- 
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-                     this.services.profileCache().clearExecutor();
-                 }
- 
--                org.spigotmc.WatchdogThread.doStop(); // Spigot
-+                //org.spigotmc.WatchdogThread.doStop(); // Spigot // Paper - move into stop
-                 // CraftBukkit start - Restore terminal to original settings
-                 try {
--                    net.minecrell.terminalconsole.TerminalConsoleAppender.close(); // Paper - Use TerminalConsoleAppender
-+                    //net.minecrell.terminalconsole.TerminalConsoleAppender.close(); // Paper - Move into stop
-                 } catch (Exception ignored) {
-                 }
-                 // CraftBukkit end
--                io.papermc.paper.log.CustomLogManager.forceReset(); // Paper - Reset loggers after shutdown
--                this.onServerExit();
-+                //io.papermc.paper.log.CustomLogManager.forceReset(); // Paper - Reset loggers after shutdown
-+                //this.onServerExit(); // Paper - moved into stop
-             }
- 
-         }
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
- 
-     @Override
-     public TickTask wrapRunnable(Runnable runnable) {
-+        // Paper start - anything that does try to post to main during watchdog crash, run on watchdog
-+        if (this.hasStopped && Thread.currentThread().equals(shutdownThread)) {
-+            runnable.run();
-+            runnable = () -> {};
-+        }
-+        // Paper end
-         return new TickTask(this.tickCount, runnable);
-     }
- 
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-             this.resources.managers.updateStaticRegistryTags();
-             this.resources.managers.getRecipeManager().finalizeRecipeLoading(this.worldData.enabledFeatures());
-             this.potionBrewing = this.potionBrewing.reload(this.worldData.enabledFeatures()); // Paper - Custom Potion Mixes
--            this.getPlayerList().saveAll();
-+            // Paper start
-+            if (Thread.currentThread() != this.serverThread) {
-+                return;
-+            }
-+            // this.getPlayerList().saveAll(); // Paper - we don't need to save everything, just advancements // TODO Move this to a different patch
-+            for (ServerPlayer player : this.getPlayerList().getPlayers()) {
-+                player.getAdvancements().save();
-+            }
-+            // Paper end
-             this.getPlayerList().reloadResources();
-             this.functionManager.replaceLibrary(this.resources.managers.getFunctionLibrary());
-             this.structureTemplateManager.onResourceManagerReload(this.resources.resourceManager);
-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
-             long j = Util.getNanos() - i;
-             String s = String.format(Locale.ROOT, "%.3fs", (double) j / 1.0E9D);
- 
--            DedicatedServer.LOGGER.info("Done ({})! For help, type \"help\"", s);
-+            DedicatedServer.LOGGER.info("Done preparing level \"{}\" ({})", this.getLevelIdName(), s); // Paper - clarify startup log messages & add total time
-             if (dedicatedserverproperties.announcePlayerAchievements != null) {
-                 ((GameRules.BooleanValue) this.getGameRules().getRule(GameRules.RULE_ANNOUNCE_ADVANCEMENTS)).set(dedicatedserverproperties.announcePlayerAchievements, this.overworld()); // CraftBukkit - per-world
-             }
-@@ -0,0 +0,0 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
-             // this.remoteStatusListener.stop(); // Paper - don't wait for remote connections
-         }
- 
--        System.exit(0); // CraftBukkit
-+        hasFullyShutdown = true; // Paper
-+        System.exit(this.abnormalExit ? 70 : 0); // CraftBukkit // Paper
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
-     @Override
-     public void stopServer() {
-         super.stopServer();
--        Util.shutdownExecutors();
-+        //Util.shutdownExecutors(); // Paper - moved into super
-         SkullBlockEntity.clear();
-     }
- 
-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 {
-         this.cserver.getPluginManager().callEvent(playerQuitEvent);
-         entityplayer.getBukkitEntity().disconnect(playerQuitEvent.getQuitMessage());
- 
--        entityplayer.doTick(); // SPIGOT-924
-+        if (server.isSameThread()) entityplayer.doTick(); // SPIGOT-924 // Paper - don't tick during emergency shutdowns (Watchdog)
-         // CraftBukkit end
- 
-         // Paper start - Configurable player collision; Remove from collideRule team if needed
-diff --git a/src/main/java/net/minecraft/util/thread/BlockableEventLoop.java b/src/main/java/net/minecraft/util/thread/BlockableEventLoop.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/util/thread/BlockableEventLoop.java
-+++ b/src/main/java/net/minecraft/util/thread/BlockableEventLoop.java
-@@ -0,0 +0,0 @@ public abstract class BlockableEventLoop<R extends Runnable> implements Profiler
-     public static boolean isNonRecoverable(Throwable exception) {
-         return exception instanceof ReportedException reportedException
-             ? isNonRecoverable(reportedException.getCause())
--            : exception instanceof OutOfMemoryError || exception instanceof StackOverflowError;
-+            : exception instanceof OutOfMemoryError || exception instanceof StackOverflowError || exception instanceof ThreadDeath; // Paper
-     }
- }
-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, ca.spottedl
-         try {
-             tickConsumer.accept(entity);
-         } catch (Throwable throwable) {
-+            if (throwable instanceof ThreadDeath) throw throwable; // Paper
-             // Paper start - Prevent block entity and entity crashes
-             final String msg = String.format("Entity threw exception at %s:%s,%s,%s", entity.level().getWorld().getName(), entity.getX(), entity.getY(), entity.getZ());
-             MinecraftServer.LOGGER.error(msg, throwable);
-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 implements ca.spottedleaf.moonrise.p
- 
-                         gameprofilerfiller.pop();
-                     } catch (Throwable throwable) {
-+                        if (throwable instanceof ThreadDeath) throw throwable; // Paper
-                         // Paper start - Prevent block entity and entity crashes
-                         final String msg = String.format("BlockEntity threw exception at %s:%s,%s,%s", LevelChunk.this.getLevel().getWorld().getName(), this.getPos().getX(), this.getPos().getY(), this.getPos().getZ());
-                         net.minecraft.server.MinecraftServer.LOGGER.error(msg, throwable);
-diff --git a/src/main/java/org/bukkit/craftbukkit/util/ServerShutdownThread.java b/src/main/java/org/bukkit/craftbukkit/util/ServerShutdownThread.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/util/ServerShutdownThread.java
-+++ b/src/main/java/org/bukkit/craftbukkit/util/ServerShutdownThread.java
-@@ -0,0 +0,0 @@ public class ServerShutdownThread extends Thread {
-     @Override
-     public void run() {
-         try {
-+            // Paper start - try to shutdown on main
-+            server.safeShutdown(false, false);
-+            for (int i = 1000; i > 0 && !server.hasStopped(); i -= 100) {
-+                Thread.sleep(100);
-+            }
-+            if (server.hasStopped()) {
-+                while (!server.hasFullyShutdown) Thread.sleep(1000);
-+                return;
-+            }
-+            // Looks stalled, close async
-             org.spigotmc.AsyncCatcher.enabled = false; // Spigot
-+            server.forceTicks = true;
-             this.server.close();
-+            while (!server.hasFullyShutdown) Thread.sleep(1000);
-+        } catch (InterruptedException e) {
-+            e.printStackTrace();
-+            // Paper end
-         } finally {
-+            org.apache.logging.log4j.LogManager.shutdown(); // Paper
-             try {
--                net.minecrell.terminalconsole.TerminalConsoleAppender.close(); // Paper - Use TerminalConsoleAppender
-+                //net.minecrell.terminalconsole.TerminalConsoleAppender.close(); // Paper - Move into stop
-             } catch (Exception e) {
-             }
-         }
-diff --git a/src/main/java/org/spigotmc/RestartCommand.java b/src/main/java/org/spigotmc/RestartCommand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/spigotmc/RestartCommand.java
-+++ b/src/main/java/org/spigotmc/RestartCommand.java
-@@ -0,0 +0,0 @@ public class RestartCommand extends Command
-     // Paper end
- 
-     // Paper start - copied from above and modified to return if the hook registered
--    private static boolean addShutdownHook(String restartScript)
-+    public static boolean addShutdownHook(String restartScript) // Paper
-     {
-         String[] split = restartScript.split( " " );
-         if ( split.length > 0 && new File( split[0] ).isFile() )
-diff --git a/src/main/java/org/spigotmc/WatchdogThread.java b/src/main/java/org/spigotmc/WatchdogThread.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/spigotmc/WatchdogThread.java
-+++ b/src/main/java/org/spigotmc/WatchdogThread.java
-@@ -0,0 +0,0 @@ import org.bukkit.Bukkit;
- public class WatchdogThread extends ca.spottedleaf.moonrise.common.util.TickThread // Paper - rewrite chunk system
- {
- 
-+    public static final boolean DISABLE_WATCHDOG = Boolean.getBoolean("disable.watchdog"); // Paper - Improved watchdog support
-     private static WatchdogThread instance;
-     private long timeoutTime;
-     private boolean restart;
-@@ -0,0 +0,0 @@ public class WatchdogThread extends ca.spottedleaf.moonrise.common.util.TickThre
-     {
-         if ( WatchdogThread.instance == null )
-         {
-+            if (timeoutTime <= 0) timeoutTime = 300; // Paper
-             WatchdogThread.instance = new WatchdogThread( timeoutTime * 1000L, restart );
-             WatchdogThread.instance.start();
-         } else
-@@ -0,0 +0,0 @@ public class WatchdogThread extends ca.spottedleaf.moonrise.common.util.TickThre
-             // 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
-+            MinecraftServer server = MinecraftServer.getServer();
-+            if ( this.lastTick != 0 && this.timeoutTime > 0 && WatchdogThread.hasStarted && (!server.isRunning() || (currentTime > this.lastTick + this.earlyWarningEvery && !DISABLE_WATCHDOG) )) // Paper - add property to disable
-             {
--                boolean isLongTimeout = currentTime > lastTick + timeoutTime;
-+                boolean isLongTimeout = currentTime > lastTick + timeoutTime || (!server.isRunning() && !server.hasStopped() && currentTime > lastTick + 1000);
-                 // 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...
-+                if ( !isLongTimeout && server.hasStopped()) continue; // Don't spam early watchdog warnings during shutdown, we'll come back to this...
-                 lastEarlyWarning = currentTime;
-                 if (isLongTimeout) {
-                 // Paper end
-@@ -0,0 +0,0 @@ public class WatchdogThread extends ca.spottedleaf.moonrise.common.util.TickThre
- 
-                 if ( isLongTimeout )
-                 {
--                if ( this.restart && !MinecraftServer.getServer().hasStopped() )
-+                if ( !server.hasStopped() )
-                 {
--                    RestartCommand.restart();
-+                    AsyncCatcher.enabled = false; // Disable async catcher incase it interferes with us
-+                    server.forceTicks = true;
-+                    if (restart) {
-+                        RestartCommand.addShutdownHook( SpigotConfig.restartScript );
-+                    }
-+                    // try one last chance to safe shutdown on main incase it 'comes back'
-+                    server.abnormalExit = true;
-+                    server.safeShutdown(false, restart);
-+                    try {
-+                        Thread.sleep(1000);
-+                    } catch (InterruptedException e) {
-+                        e.printStackTrace();
-+                    }
-+                    if (!server.hasStopped()) {
-+                        server.close();
-+                    }
-                 }
-                 break;
-                 } // Paper end
-diff --git a/src/main/resources/log4j2.xml b/src/main/resources/log4j2.xml
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/resources/log4j2.xml
-+++ b/src/main/resources/log4j2.xml
-@@ -0,0 +0,0 @@
- <?xml version="1.0" encoding="UTF-8"?>
--<Configuration status="WARN">
-+<Configuration status="WARN" shutdownHook="disable">
-     <Appenders>
-         <Queue name="ServerGuiConsole">
-             <PatternLayout pattern="[%d{HH:mm:ss} %level]: %msg{nolookups}%n" />

patches/server/Incremental-chunk-and-player-saving.patch

@@ -1,133 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Shane Freeder <theboyetronic@gmail.com>
-Date: Sun, 9 Jun 2019 03:53:22 +0100
-Subject: [PATCH] Incremental chunk and player 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
- 
-         try {
-             this.isSaving = true;
--            this.getPlayerList().saveAll();
-+            this.getPlayerList().saveAll(); // Paper - Incremental chunk and player saving; diff on change
-             flag3 = this.saveAllChunks(suppressLogs, flush, force);
-         } finally {
-             this.isSaving = false;
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         }
- 
-         --this.ticksUntilAutosave;
--        if (this.autosavePeriod > 0 && this.ticksUntilAutosave <= 0) { // CraftBukkit
--            this.autoSave();
-+        // Paper start - Incremental chunk and player saving
-+        final ProfilerFiller profiler = Profiler.get();
-+        int playerSaveInterval = io.papermc.paper.configuration.GlobalConfiguration.get().playerAutoSave.rate;
-+        if (playerSaveInterval < 0) {
-+            playerSaveInterval = autosavePeriod;
-+        }
-+        profiler.push("save");
-+        final boolean fullSave = autosavePeriod > 0 && this.tickCount % autosavePeriod == 0;
-+        try {
-+            this.isSaving = true;
-+            if (playerSaveInterval > 0) {
-+                this.playerList.saveAll(playerSaveInterval);
-+            }
-+            for (final ServerLevel level : this.getAllLevels()) {
-+                if (level.paperConfig().chunks.autoSaveInterval.value() > 0) {
-+                    level.saveIncrementally(fullSave);
-+                }
-+            }
-+        } finally {
-+            this.isSaving = false;
-         }
-+        profiler.pop();
-+        // Paper end - Incremental chunk and player saving
- 
-         ProfilerFiller gameprofilerfiller = Profiler.get();
- 
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
-         return !this.server.isUnderSpawnProtection(this, pos, player) && this.getWorldBorder().isWithinBounds(pos);
-     }
- 
-+    // Paper start - Incremental chunk and player saving
-+    public void saveIncrementally(boolean doFull) {
-+        ServerChunkCache chunkproviderserver = this.getChunkSource();
-+
-+        if (doFull) {
-+            org.bukkit.Bukkit.getPluginManager().callEvent(new org.bukkit.event.world.WorldSaveEvent(getWorld()));
-+        }
-+
-+        if (doFull) {
-+            this.saveLevelData(true);
-+        }
-+        // chunk autosave is already called by the ChunkSystem during unload processing (ChunkMap#processUnloads)
-+        // Copied from save()
-+        // CraftBukkit start - moved from MinecraftServer.saveChunks
-+        if (doFull) { // Paper
-+            ServerLevel worldserver1 = this;
-+            this.serverLevelData.setWorldBorder(worldserver1.getWorldBorder().createSettings());
-+            this.serverLevelData.setCustomBossEvents(this.server.getCustomBossEvents().save(this.registryAccess()));
-+            this.convertable.saveDataTag(this.server.registryAccess(), this.serverLevelData, this.server.getPlayerList().getSingleplayerData());
-+        }
-+        // CraftBukkit end
-+    }
-+    // Paper end - Incremental chunk and player saving
-+
-     public void save(@Nullable ProgressListener progressListener, boolean flush, boolean savingDisabled) {
-         // Paper start - add close param
-         this.save(progressListener, flush, savingDisabled, false);
-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 @@ import org.bukkit.inventory.MainHand;
- public class ServerPlayer extends net.minecraft.world.entity.player.Player implements ca.spottedleaf.moonrise.patches.chunk_system.player.ChunkSystemServerPlayer { // Paper - rewrite chunk system
- 
-     private static final Logger LOGGER = LogUtils.getLogger();
-+    public long lastSave = MinecraftServer.currentTick; // Paper - Incremental chunk and player saving
-     private static final int NEUTRAL_MOB_DEATH_NOTIFICATION_RADII_XZ = 32;
-     private static final int NEUTRAL_MOB_DEATH_NOTIFICATION_RADII_Y = 10;
-     private static final int FLY_STAT_RECORDING_SPEED = 25;
-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 {
- 
-     protected void save(ServerPlayer player) {
-         if (!player.getBukkitEntity().isPersistent()) return; // CraftBukkit
-+        player.lastSave = MinecraftServer.currentTick; // Paper - Incremental chunk and player saving
-         this.playerIo.save(player);
-         ServerStatsCounter serverstatisticmanager = (ServerStatsCounter) player.getStats(); // CraftBukkit
- 
-@@ -0,0 +0,0 @@ public abstract class PlayerList {
-     }
- 
-     public void saveAll() {
-+        // Paper start - Incremental chunk and player saving
-+        this.saveAll(-1);
-+    }
-+
-+    public void saveAll(int interval) {
-         io.papermc.paper.util.MCUtil.ensureMain("Save Players" , () -> { // Paper - Ensure main
-+        int numSaved = 0;
-+        long now = MinecraftServer.currentTick;
-         for (int i = 0; i < this.players.size(); ++i) {
--            this.save((ServerPlayer) this.players.get(i));
-+            final ServerPlayer player = this.players.get(i);
-+            if (interval == -1 || now - player.lastSave >= interval) {
-+                this.save(player);
-+                if (interval != -1 && ++numSaved >= io.papermc.paper.configuration.GlobalConfiguration.get().playerAutoSave.maxPerTick()) { break; }
-+            }
-+            // Paper end - Incremental chunk and player saving
-         }
- 
-         return null; }); // Paper - ensure main

patches/server/Lag-compensation-ticks.patch

@@ -1,129 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Sat, 23 Sep 2023 22:05:35 -0700
-Subject: [PATCH] Lag compensation ticks
-
-Areas affected by lag comepnsation:
- - Block breaking and destroying
- - Eating food items
-
-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
- 
-     public volatile Thread shutdownThread; // Paper
-     public volatile boolean abnormalExit = false; // Paper
-+    public static final long SERVER_INIT = System.nanoTime(); // Paper - Lag compensation
- 
-     public static <S extends MinecraftServer> S spin(Function<Thread, S> serverFactory) {
-         ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.init(); // Paper - rewrite data converter system
-@@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-             worldserver.hasPhysicsEvent = org.bukkit.event.block.BlockPhysicsEvent.getHandlerList().getRegisteredListeners().length > 0; // Paper - BlockPhysicsEvent
-             worldserver.hasEntityMoveEvent = io.papermc.paper.event.entity.EntityMoveEvent.getHandlerList().getRegisteredListeners().length > 0; // Paper - Add EntityMoveEvent
-             net.minecraft.world.level.block.entity.HopperBlockEntity.skipHopperEvents = worldserver.paperConfig().hopper.disableMoveEvent || org.bukkit.event.inventory.InventoryMoveItemEvent.getHandlerList().getRegisteredListeners().length == 0; // Paper - Perf: Optimize Hoppers
-+            worldserver.updateLagCompensationTick(); // Paper - lag compensation
- 
-             gameprofilerfiller.push(() -> {
-                 String s = String.valueOf(worldserver);
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
-         );
-     }
-     // Paper end - chunk tick iteration
-+    // Paper start - lag compensation
-+    private long lagCompensationTick = net.minecraft.server.MinecraftServer.SERVER_INIT;
-+
-+    public long getLagCompensationTick() {
-+        return this.lagCompensationTick;
-+    }
-+
-+    public void updateLagCompensationTick() {
-+        this.lagCompensationTick = (System.nanoTime() - net.minecraft.server.MinecraftServer.SERVER_INIT) / (java.util.concurrent.TimeUnit.MILLISECONDS.toNanos(50L));
-+    }
-+    // Paper end - lag compensation
- 
-     // Add env and gen to constructor, IWorldDataServer -> WorldDataServer
-     public ServerLevel(MinecraftServer minecraftserver, Executor executor, LevelStorageSource.LevelStorageAccess convertable_conversionsession, PrimaryLevelData iworlddataserver, ResourceKey<Level> resourcekey, LevelStem worlddimension, ChunkProgressListener worldloadlistener, boolean flag, long i, List<CustomSpawner> list, boolean flag1, @Nullable RandomSequences randomsequences, org.bukkit.World.Environment env, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider) {
-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 {
-     }
- 
-     public void tick() {
--        this.gameTicks = MinecraftServer.currentTick; // CraftBukkit;
-+        this.gameTicks = (int)this.level.getLagCompensationTick(); // CraftBukkit; // Paper - lag compensation
-         BlockState iblockdata;
- 
-         if (this.hasDelayedDestroy) {
-diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-         this.resendPossiblyDesyncedDataValues(java.util.List.of(DATA_LIVING_ENTITY_FLAGS), serverPlayer);
-     }
-     // Paper end - Properly cancel usable items
-+    // Paper start - lag compensate eating
-+    protected long eatStartTime;
-+    protected int totalEatTimeTicks;
-+    // Paper end - lag compensate eating
-     private void updatingUsingItem() {
-         if (this.isUsingItem()) {
-             if (ItemStack.isSameItem(this.getItemInHand(this.getUsedItemHand()), this.useItem)) {
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
- 
-     protected void updateUsingItem(ItemStack stack) {
-         stack.onUseTick(this.level(), this, this.getUseItemRemainingTicks());
--        if (--this.useItemRemaining == 0 && !this.level().isClientSide && !stack.useOnRelease()) {
-+        // Paper start - lag compensate eating
-+        // we add 1 to the expected time to avoid lag compensating when we should not
-+        final boolean shouldLagCompensate = this.useItem.has(DataComponents.FOOD) && this.eatStartTime != -1 && (System.nanoTime() - this.eatStartTime) > ((1L + this.totalEatTimeTicks) * 50L * (1000L * 1000L));
-+        if ((--this.useItemRemaining == 0 || shouldLagCompensate) && !this.level().isClientSide && !stack.useOnRelease()) {
-+            this.useItemRemaining = 0;
-+            // Paper end - lag compensate eating
-             this.completeUsingItem();
-         }
- 
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
- 
-         if (!itemstack.isEmpty() && !this.isUsingItem() || forceUpdate) { // Paper - Prevent consuming the wrong itemstack
-             this.useItem = itemstack;
--            this.useItemRemaining = itemstack.getUseDuration(this);
-+            // Paper start - lag compensate eating
-+            this.useItemRemaining = this.totalEatTimeTicks = itemstack.getUseDuration(this);
-+            this.eatStartTime = System.nanoTime();
-+            // Paper end - lag compensate eating
-             if (!this.level().isClientSide) {
-                 this.setLivingEntityFlag(1, true);
-                 this.setLivingEntityFlag(2, hand == InteractionHand.OFF_HAND);
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-                 }
-             } else if (!this.isUsingItem() && !this.useItem.isEmpty()) {
-                 this.useItem = ItemStack.EMPTY;
--                this.useItemRemaining = 0;
-+                // Paper start - lag compensate eating
-+                this.useItemRemaining = this.totalEatTimeTicks = 0;
-+                this.eatStartTime = -1L;
-+                // Paper end - lag compensate eating
-             }
-         }
- 
-@@ -0,0 +0,0 @@ public abstract class LivingEntity extends Entity implements Attackable {
-         }
- 
-         this.useItem = ItemStack.EMPTY;
--        this.useItemRemaining = 0;
-+        // Paper start - lag compensate eating
-+        this.useItemRemaining = this.totalEatTimeTicks = 0;
-+        this.eatStartTime = -1L;
-+        // Paper end - lag compensate eating
-     }
- 
-     public boolean isBlocking() {

patches/server/Only-write-chunk-data-to-disk-if-it-serializes-witho.patch

@@ -1,129 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Sun, 19 Dec 2021 09:13:41 -0800
-Subject: [PATCH] Only write chunk data to disk if it serializes without
- throwing
-
-This ensures at least a valid version of the chunk exists
-on disk, even if outdated
-
-diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
- 
-     }
-     // Paper end
-+    public static final int MAX_CHUNK_SIZE = 500 * 1024 * 1024; // Paper - don't write garbage data to disk if writing serialization fails
-     private class ChunkBuffer extends ByteArrayOutputStream implements ca.spottedleaf.moonrise.patches.chunk_system.storage.ChunkSystemChunkBuffer { // Paper - rewrite chunk system
- 
-         private final ChunkPos pos;
-@@ -0,0 +0,0 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
-             super.write(RegionFile.this.version.getId());
-             this.pos = chunkcoordintpair;
-         }
-+        // Paper start - don't write garbage data to disk if writing serialization fails
-+        @Override
-+        public void write(final int b) {
-+            if (this.count > MAX_CHUNK_SIZE) {
-+                throw new RegionFileStorage.RegionFileSizeException("Region file too large: " + this.count);
-+            }
-+            super.write(b);
-+        }
-+
-+        @Override
-+        public void write(final byte[] b, final int off, final int len) {
-+            if (this.count + len > MAX_CHUNK_SIZE) {
-+                throw new RegionFileStorage.RegionFileSizeException("Region file too large: " + (this.count + len));
-+            }
-+            super.write(b, off, len);
-+        }
-+        // Paper end - don't write garbage data to disk if writing serialization fails
- 
-         public void close() throws IOException {
-             ByteBuffer bytebuffer = ByteBuffer.wrap(this.buf, 0, this.count);
-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 net.minecraft.world.level.ChunkPos;
- 
- public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise.patches.chunk_system.io.ChunkSystemRegionFileStorage { // Paper - rewrite chunk system
- 
-+    private static final org.slf4j.Logger LOGGER = com.mojang.logging.LogUtils.getLogger(); // Paper
-+
-     public static final String ANVIL_EXTENSION = ".mca";
-     private static final int MAX_CACHE_SIZE = 256;
-     public final Long2ObjectLinkedOpenHashMap<RegionFile> regionCache = new Long2ObjectLinkedOpenHashMap();
-@@ -0,0 +0,0 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
-         // (and, the regionfile parameter is unused for writing until the write call)
-         final ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.WriteData writeData = ((ca.spottedleaf.moonrise.patches.chunk_system.storage.ChunkSystemRegionFile)regionFile).moonrise$startWrite(compound, pos);
- 
-+        try { // Paper - implement RegionFileSizeException
-         try {
-             NbtIo.write(compound, writeData.output());
-         } finally {
-             writeData.output().close();
-         }
-+        // Paper start - implement RegionFileSizeException
-+        } catch (final RegionFileSizeException ex) {
-+            // note: it's OK if close() is called, as close() here will not issue a write to the RegionFile
-+            // see startWrite
-+            final int maxSize = RegionFile.MAX_CHUNK_SIZE / (1024 * 1024);
-+            LOGGER.error("Chunk at (" + chunkX + "," + chunkZ + ") in regionfile '" + regionFile.getPath().toString() + "' exceeds max size of " + maxSize + "MiB, it has been deleted from disk.");
-+            return new ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.WriteData(
-+                compound, ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.WriteData.WriteResult.DELETE,
-+                null, null
-+            );
-+        }
-+        // Paper end - implement RegionFileSizeException
- 
-         return writeData;
-     }
-@@ -0,0 +0,0 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
-             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
-+                // Paper start - don't write garbage data to disk if writing serialization fails
-+                dataoutputstream.close(); // Only write if successful
-+            } catch (final RegionFileSizeException ex) {
-+                regionfile.clear(pos);
-+                final int maxSize = RegionFile.MAX_CHUNK_SIZE / (1024 * 1024);
-+                LOGGER.error("Chunk at (" + pos.x + "," + pos.z + ") in regionfile '" + regionfile.getPath().toString() + "' exceeds max size of " + maxSize + "MiB, it has been deleted from disk.");
-+                return;
-+                // Paper end - don't write garbage data to disk if writing serialization fails
-             } catch (Throwable throwable) {
-                 if (dataoutputstream != null) {
-                     try {
--                        dataoutputstream.close();
-+                        //dataoutputstream.close(); // Paper - don't write garbage data to disk if writing serialization fails
-                     } catch (Throwable throwable1) {
-                         throwable.addSuppressed(throwable1);
-                     }
-@@ -0,0 +0,0 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
- 
-                 throw throwable;
-             }
--
--            if (dataoutputstream != null) {
--                dataoutputstream.close();
--            }
-+            // Paper - don't write garbage data to disk if writing serialization fails; move into try block to only write if successfully serialized
-         }
- 
-     }
-@@ -0,0 +0,0 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
-     public RegionStorageInfo info() {
-         return this.info;
-     }
-+
-+    // Paper start - don't write garbage data to disk if writing serialization fails
-+    public static final class RegionFileSizeException extends RuntimeException {
-+
-+        public RegionFileSizeException(String message) {
-+            super(message);
-+        }
-+    }
-+    // Paper end - don't write garbage data to disk if writing serialization fails
- }

patches/server/Optimise-collision-checking-in-player-move-packet-ha.patch

@@ -1,168 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Thu, 2 Jul 2020 12:02:43 -0700
-Subject: [PATCH] Optimise collision checking in player move packet handling
-
-Move collision logic to just the hasNewCollision call instead of getCubes + hasNewCollision
-
-diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-                     return;
-                 }
- 
--                boolean flag = worldserver.noCollision(entity, entity.getBoundingBox().deflate(0.0625D));
-+                AABB oldBox = entity.getBoundingBox(); // Paper - copy from player movement packet
- 
-                 d6 = d3 - this.vehicleLastGoodX; // Paper - diff on change, used for checking large move vectors above
-                 d7 = d4 - this.vehicleLastGoodY; // Paper - diff on change, used for checking large move vectors above
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-                 }
- 
-                 entity.move(MoverType.PLAYER, new Vec3(d6, d7, d8));
-+                boolean didCollide = toX != entity.getX() || toY != entity.getY() || toZ != entity.getZ(); // Paper - needed here as the difference in Y can be reset - also note: this is only a guess at whether collisions took place, floating point errors can make this true when it shouldn't be...
-                 double d11 = d7;
- 
-                 d6 = d3 - entity.getX();
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-                 boolean flag2 = false;
- 
-                 if (d10 > org.spigotmc.SpigotConfig.movedWronglyThreshold) { // Spigot
--                    flag2 = true;
-+                    flag2 = true; // Paper - diff on change, this should be moved wrongly
-                     ServerGamePacketListenerImpl.LOGGER.warn("{} (vehicle of {}) moved wrongly! {}", new Object[]{entity.getName().getString(), this.player.getName().getString(), Math.sqrt(d10)});
-                 }
- 
-                 entity.absMoveTo(d3, d4, d5, f, f1);
-                 this.player.absMoveTo(d3, d4, d5, this.player.getYRot(), this.player.getXRot()); // CraftBukkit
--                boolean flag3 = worldserver.noCollision(entity, entity.getBoundingBox().deflate(0.0625D));
- 
--                if (flag && (flag2 || !flag3)) {
-+                // Paper start - optimise out extra getCubes
-+                boolean teleportBack = flag2; // violating this is always a fail
-+                if (!teleportBack) {
-+                    // note: only call after setLocation, or else getBoundingBox is wrong
-+                    AABB newBox = entity.getBoundingBox();
-+                    if (didCollide || !oldBox.equals(newBox)) {
-+                        teleportBack = this.hasNewCollision(worldserver, entity, oldBox, newBox);
-+                    } // else: no collision at all detected, why do we care?
-+                }
-+                if (teleportBack) { // Paper end - optimise out extra getCubes
-                     entity.absMoveTo(d0, d1, d2, f, f1);
-                     this.player.absMoveTo(d0, d1, d2, this.player.getYRot(), this.player.getXRot()); // CraftBukkit
-                     this.send(ClientboundMoveVehiclePacket.fromEntity(entity));
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-     }
- 
-     private boolean noBlocksAround(Entity entity) {
--        return entity.level().getBlockStates(entity.getBoundingBox().inflate(0.0625D).expandTowards(0.0D, -0.55D, 0.0D)).allMatch(BlockBehaviour.BlockStateBase::isAir);
-+        // Paper start - stop using streams, this is already a known fixed problem in Entity#move
-+        AABB box = entity.getBoundingBox().inflate(0.0625D).expandTowards(0.0D, -0.55D, 0.0D);
-+        int minX = Mth.floor(box.minX);
-+        int minY = Mth.floor(box.minY);
-+        int minZ = Mth.floor(box.minZ);
-+        int maxX = Mth.floor(box.maxX);
-+        int maxY = Mth.floor(box.maxY);
-+        int maxZ = Mth.floor(box.maxZ);
-+
-+        Level world = entity.level();
-+        BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos();
-+
-+        for (int y = minY; y <= maxY; ++y) {
-+            for (int z = minZ; z <= maxZ; ++z) {
-+                for (int x = minX; x <= maxX; ++x) {
-+                    pos.set(x, y, z);
-+                    BlockState type = world.getBlockStateIfLoaded(pos);
-+                    if (type != null && !type.isAir()) {
-+                        return false;
-+                    }
-+                }
-+            }
-+        }
-+
-+        return true;
-+        // Paper end - stop using streams, this is already a known fixed problem in Entity#move
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-                                 }
-                             }
- 
--                            AABB axisalignedbb = this.player.getBoundingBox();
-+                            AABB axisalignedbb = this.player.getBoundingBox(); // Paper - diff on change, should be old AABB
- 
-                             d6 = d0 - this.lastGoodX; // Paper - diff on change, used for checking large move vectors above
-                             d7 = d1 - this.lastGoodY; // Paper - diff on change, used for checking large move vectors above
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
- 
-                             this.player.move(MoverType.PLAYER, new Vec3(d6, d7, d8));
-                             this.player.onGround = packet.isOnGround(); // CraftBukkit - SPIGOT-5810, SPIGOT-5835, SPIGOT-6828: reset by this.player.move
-+                            boolean didCollide = toX != this.player.getX() || toY != this.player.getY() || toZ != this.player.getZ(); // Paper - needed here as the difference in Y can be reset - also note: this is only a guess at whether collisions took place, floating point errors can make this true when it shouldn't be...
-                             // Paper start - prevent position desync
-                             if (this.awaitingPositionFromClient != null) {
-                                 return; // ... thanks Mojang for letting move calls teleport across dimensions.
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-                             }
- 
-                             // Paper start - Add fail move event
--                            boolean teleportBack = !this.player.noPhysics && !this.player.isSleeping() && (movedWrongly && worldserver.noCollision(this.player, axisalignedbb) || this.isPlayerCollidingWithAnythingNew(worldserver, axisalignedbb, d0, d1, d2));
-+                            // Paper start - optimise out extra getCubes
-+                            boolean teleportBack = !this.player.noPhysics && !this.player.isSleeping() && movedWrongly;
-+                            this.player.absMoveTo(d0, d1, d2, f, f1); // prevent desync by tping to the set position, dropped for unknown reasons by mojang
-+                            if (!this.player.noPhysics && !this.player.isSleeping() && !teleportBack) {
-+                                AABB newBox = this.player.getBoundingBox();
-+                                if (didCollide || !axisalignedbb.equals(newBox)) {
-+                                    // note: only call after setLocation, or else getBoundingBox is wrong
-+                                    teleportBack = this.hasNewCollision(worldserver, this.player, axisalignedbb, newBox);
-+                                } // else: no collision at all detected, why do we care?
-+                            }
-+                            // Paper end - optimise out extra getCubes
-                             if (teleportBack) {
-                                 io.papermc.paper.event.player.PlayerFailMoveEvent event = fireFailMove(io.papermc.paper.event.player.PlayerFailMoveEvent.FailReason.CLIPPED_INTO_BLOCK,
-                                     toX, toY, toZ, toYaw, toPitch, false);
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
- 
-     private boolean updateAwaitingTeleport() {
-         if (this.awaitingPositionFromClient != null) {
--            if (this.tickCount - this.awaitingTeleportTime > 20) {
-+            if (false && this.tickCount - this.awaitingTeleportTime > 20) { // Paper - this will greatly screw with clients with > 1000ms RTT
-                 this.awaitingTeleportTime = this.tickCount;
-                 this.teleport(this.awaitingPositionFromClient.x, this.awaitingPositionFromClient.y, this.awaitingPositionFromClient.z, this.player.getYRot(), this.player.getXRot());
-             }
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-         }
-     }
- 
-+    // Paper start - optimise out extra getCubes
-+    private boolean hasNewCollision(final ServerLevel world, final Entity entity, final AABB oldBox, final AABB newBox) {
-+        final List<AABB> collisionsBB = new java.util.ArrayList<>();
-+        final List<VoxelShape> collisionsVoxel = new java.util.ArrayList<>();
-+        ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.getCollisions(
-+            world, entity, newBox, collisionsVoxel, collisionsBB,
-+            ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_FLAG_COLLIDE_WITH_UNLOADED_CHUNKS | ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_FLAG_CHECK_BORDER,
-+            null, null
-+        );
-+
-+        for (int i = 0, len = collisionsBB.size(); i < len; ++i) {
-+            final AABB box = collisionsBB.get(i);
-+            if (!ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.voxelShapeIntersect(box, oldBox)) {
-+                return true;
-+            }
-+        }
-+
-+        for (int i = 0, len = collisionsVoxel.size(); i < len; ++i) {
-+            final VoxelShape voxel = collisionsVoxel.get(i);
-+            if (!ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.voxelShapeIntersectNoEmpty(voxel, oldBox)) {
-+                return true;
-+            }
-+        }
-+
-+        return false;
-+    }
-+    // Paper end - optimise out extra getCubes
-     private boolean isPlayerCollidingWithAnythingNew(LevelReader world, AABB box, double newX, double newY, double newZ) {
-         AABB axisalignedbb1 = this.player.getBoundingBox().move(newX - this.player.getX(), newY - this.player.getY(), newZ - this.player.getZ());
-         Iterable<VoxelShape> iterable = world.getCollisions(this.player, axisalignedbb1.deflate(9.999999747378752E-6D));

patches/server/Optimise-getChunkAt-calls-for-loaded-chunks.patch

@@ -1,60 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Sat, 25 Jan 2020 17:04:35 -0800
-Subject: [PATCH] Optimise getChunkAt calls for loaded chunks
-
-bypass the need to get a player chunk, then get the either,
-then unwrap it...
-
-diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-+++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
-                 return this.getChunk(x, z, leastStatus, create);
-             }, this.mainThreadProcessor).join();
-         } else {
-+            // Paper start - Perf: Optimise getChunkAt calls for loaded chunks
-+            LevelChunk ifLoaded = this.getChunkAtIfLoadedMainThread(x, z);
-+            if (ifLoaded != null) {
-+                return ifLoaded;
-+            }
-+            // Paper end - Perf: Optimise getChunkAt calls for loaded chunks
-             ProfilerFiller gameprofilerfiller = Profiler.get();
- 
-             gameprofilerfiller.incrementCounter("getChunk");
-@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
-         if (Thread.currentThread() != this.mainThread) {
-             return null;
-         } else {
--            Profiler.get().incrementCounter("getChunkNow");
--            long k = ChunkPos.asLong(chunkX, chunkZ);
--
--            ChunkAccess ichunkaccess;
--
--            for (int l = 0; l < 4; ++l) {
--                if (k == this.lastChunkPos[l] && this.lastChunkStatus[l] == ChunkStatus.FULL) {
--                    ichunkaccess = this.lastChunk[l];
--                    return ichunkaccess instanceof LevelChunk ? (LevelChunk) ichunkaccess : null;
--                }
--            }
--
--            ChunkHolder playerchunk = this.getVisibleChunkIfPresent(k);
--
--            if (playerchunk == null) {
--                return null;
--            } else {
--                ichunkaccess = playerchunk.getChunkIfPresent(ChunkStatus.FULL);
--                if (ichunkaccess != null) {
--                    this.storeInCache(k, ichunkaccess, ChunkStatus.FULL);
--                    if (ichunkaccess instanceof LevelChunk) {
--                        return (LevelChunk) ichunkaccess;
--                    }
--                }
--
--                return null;
--            }
-+            return this.getChunkAtIfLoadedMainThread(chunkX, chunkZ); // Paper - Perf: Optimise getChunkAt calls for loaded chunks
-         }
-     }
- 

patches/server/Optimize-Bit-Operations-by-inlining.patch

@@ -1,213 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Thu, 4 Jun 2020 02:24:49 -0400
-Subject: [PATCH] Optimize Bit Operations by inlining
-
-Inline bit operations and reduce instruction count to make these hot
-operations faster
-
-diff --git a/src/main/java/net/minecraft/core/BlockPos.java b/src/main/java/net/minecraft/core/BlockPos.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/core/BlockPos.java
-+++ b/src/main/java/net/minecraft/core/BlockPos.java
-@@ -0,0 +0,0 @@ public class BlockPos extends Vec3i {
-     };
-     private static final Logger LOGGER = LogUtils.getLogger();
-     public static final BlockPos ZERO = new BlockPos(0, 0, 0);
--    public static final int PACKED_HORIZONTAL_LENGTH = 1 + Mth.log2(Mth.smallestEncompassingPowerOfTwo(30000000));
--    public static final int PACKED_Y_LENGTH = 64 - 2 * PACKED_HORIZONTAL_LENGTH;
--    private static final long PACKED_X_MASK = (1L << PACKED_HORIZONTAL_LENGTH) - 1L;
--    private static final long PACKED_Y_MASK = (1L << PACKED_Y_LENGTH) - 1L;
--    private static final long PACKED_Z_MASK = (1L << PACKED_HORIZONTAL_LENGTH) - 1L;
-+    // Paper start - Optimize Bit Operations by inlining
-+    public static final int PACKED_HORIZONTAL_LENGTH = 26;
-+    public static final int PACKED_Y_LENGTH = 12;
-+    private static final long PACKED_X_MASK = 67108863;
-+    private static final long PACKED_Y_MASK = 4095;
-+    private static final long PACKED_Z_MASK = 67108863;
-     private static final int Y_OFFSET = 0;
--    private static final int Z_OFFSET = PACKED_Y_LENGTH;
--    private static final int X_OFFSET = PACKED_Y_LENGTH + PACKED_HORIZONTAL_LENGTH;
--    public static final int MAX_HORIZONTAL_COORDINATE = (1 << PACKED_HORIZONTAL_LENGTH) / 2 - 1;
-+    private static final int Z_OFFSET = 12;
-+    private static final int X_OFFSET = 38;
-+    public static final int MAX_HORIZONTAL_COORDINATE = 33554431;
-+    // Paper end - Optimize Bit Operations by inlining
- 
-     public BlockPos(int x, int y, int z) {
-         super(x, y, z);
-@@ -0,0 +0,0 @@ public class BlockPos extends Vec3i {
-         this(pos.getX(), pos.getY(), pos.getZ());
-     }
- 
-+    public static long getAdjacent(int baseX, int baseY, int baseZ, Direction enumdirection) { return asLong(baseX + enumdirection.getStepX(), baseY + enumdirection.getStepY(), baseZ + enumdirection.getStepZ()); } // Paper
-     public static long offset(long value, Direction direction) {
-         return offset(value, direction.getStepX(), direction.getStepY(), direction.getStepZ());
-     }
- 
-     public static long offset(long value, int x, int y, int z) {
--        return asLong(getX(value) + x, getY(value) + y, getZ(value) + z);
-+        return asLong((int) (value >> 38) + x, (int) ((value << 52) >> 52) + y, (int) ((value << 26) >> 38) + z); // Paper - simplify/inline
-     }
- 
-     public static int getX(long packedPos) {
--        return (int)(packedPos << 64 - X_OFFSET - PACKED_HORIZONTAL_LENGTH >> 64 - PACKED_HORIZONTAL_LENGTH);
-+        return (int) (packedPos >> 38); // Paper - simplify/inline
-     }
- 
-     public static int getY(long packedPos) {
--        return (int)(packedPos << 64 - PACKED_Y_LENGTH >> 64 - PACKED_Y_LENGTH);
-+        return (int) ((packedPos << 52) >> 52); // Paper - simplify/inline
-     }
- 
-     public static int getZ(long packedPos) {
--        return (int)(packedPos << 64 - Z_OFFSET - PACKED_HORIZONTAL_LENGTH >> 64 - PACKED_HORIZONTAL_LENGTH);
-+        return (int) ((packedPos << 26) >> 38);  // Paper - simplify/inline
-     }
- 
-     public static BlockPos of(long packedPos) {
--        return new BlockPos(getX(packedPos), getY(packedPos), getZ(packedPos));
-+        return new BlockPos((int) (packedPos >> 38), (int) ((packedPos << 52) >> 52), (int) ((packedPos << 26) >> 38)); // Paper - simplify/inline
-     }
- 
-     public static BlockPos containing(double x, double y, double z) {
-@@ -0,0 +0,0 @@ public class BlockPos extends Vec3i {
-     }
- 
-     public static long asLong(int x, int y, int z) {
--        long l = 0L;
--        l |= ((long)x & PACKED_X_MASK) << X_OFFSET;
--        l |= ((long)y & PACKED_Y_MASK) << 0;
--        return l | ((long)z & PACKED_Z_MASK) << Z_OFFSET;
-+        return (((long) x & (long) 67108863) << 38) | (((long) y & (long) 4095)) | (((long) z & (long) 67108863) << 12); // Paper - inline constants and simplify
-     }
- 
-     public static long getFlatIndex(long y) {
-diff --git a/src/main/java/net/minecraft/core/SectionPos.java b/src/main/java/net/minecraft/core/SectionPos.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/core/SectionPos.java
-+++ b/src/main/java/net/minecraft/core/SectionPos.java
-@@ -0,0 +0,0 @@ public class SectionPos extends Vec3i {
-     }
- 
-     public static SectionPos of(BlockPos pos) {
--        return new SectionPos(blockToSectionCoord(pos.getX()), blockToSectionCoord(pos.getY()), blockToSectionCoord(pos.getZ()));
-+        return new SectionPos(pos.getX() >> 4, pos.getY() >> 4, pos.getZ() >> 4); // Paper
-     }
- 
-     public static SectionPos of(ChunkPos chunkPos, int y) {
-@@ -0,0 +0,0 @@ public class SectionPos extends Vec3i {
-     }
- 
-     public static SectionPos of(long packed) {
--        return new SectionPos(x(packed), y(packed), z(packed));
-+        return new SectionPos((int) (packed >> 42), (int) (packed << 44 >> 44), (int) (packed << 22 >> 42)); // Paper
-     }
- 
-     public static SectionPos bottomOf(ChunkAccess chunk) {
-@@ -0,0 +0,0 @@ public class SectionPos extends Vec3i {
-         return offset(packed, direction.getStepX(), direction.getStepY(), direction.getStepZ());
-     }
- 
-+    // Paper start
-+    public static long getAdjacentFromBlockPos(int x, int y, int z, Direction enumdirection) {
-+        return (((long) ((x >> 4) + enumdirection.getStepX()) & 4194303L) << 42) | (((long) ((y >> 4) + enumdirection.getStepY()) & 1048575L)) | (((long) ((z >> 4) + enumdirection.getStepZ()) & 4194303L) << 20);
-+    }
-+    public static long getAdjacentFromSectionPos(int x, int y, int z, Direction enumdirection) {
-+        return (((long) (x + enumdirection.getStepX()) & 4194303L) << 42) | (((long) ((y) + enumdirection.getStepY()) & 1048575L)) | (((long) (z + enumdirection.getStepZ()) & 4194303L) << 20);
-+    }
-+    // Paper end
-     public static long offset(long packed, int x, int y, int z) {
--        return asLong(x(packed) + x, y(packed) + y, z(packed) + z);
-+        return (((long) ((int) (packed >> 42) + x) & 4194303L) << 42) | (((long) ((int) (packed << 44 >> 44) + y) & 1048575L)) | (((long) ((int) (packed << 22 >> 42) + z) & 4194303L) << 20); // Simplify to reduce instruction count
-     }
- 
-     public static int posToSectionCoord(double coord) {
-@@ -0,0 +0,0 @@ public class SectionPos extends Vec3i {
-     }
- 
-     public static short sectionRelativePos(BlockPos pos) {
--        int i = sectionRelative(pos.getX());
--        int j = sectionRelative(pos.getY());
--        int k = sectionRelative(pos.getZ());
--        return (short)(i << 8 | k << 4 | j << 0);
-+        return (short) ((pos.getX() & 15) << 8 | (pos.getZ() & 15) << 4 | pos.getY() & 15); // Paper - simplify/inline
-     }
- 
-     public static int sectionRelativeX(short packedLocalPos) {
-@@ -0,0 +0,0 @@ public class SectionPos extends Vec3i {
-         return this.getZ();
-     }
- 
--    public int minBlockX() {
--        return sectionToBlockCoord(this.x());
-+    public final int minBlockX() { // Paper - make final
-+        return this.getX() << 4; // Paper - inline
-     }
- 
--    public int minBlockY() {
--        return sectionToBlockCoord(this.y());
-+    public final int minBlockY() { // Paper - make final
-+        return this.getY() << 4; // Paper - inline
-     }
- 
--    public int minBlockZ() {
--        return sectionToBlockCoord(this.z());
-+    public int minBlockZ() { // Paper - make final
-+        return this.getZ() << 4; // Paper - inline
-     }
- 
-     public int maxBlockX() {
-@@ -0,0 +0,0 @@ public class SectionPos extends Vec3i {
-     }
- 
-     public static long blockToSection(long blockPos) {
--        return asLong(blockToSectionCoord(BlockPos.getX(blockPos)), blockToSectionCoord(BlockPos.getY(blockPos)), blockToSectionCoord(BlockPos.getZ(blockPos)));
-+        // b(a(BlockPosition.b(i)), a(BlockPosition.c(i)), a(BlockPosition.d(i)));
-+        return (((long) (int) (blockPos >> 42) & 4194303L) << 42) | (((long) (int) ((blockPos << 52) >> 56) & 1048575L)) | (((long) (int) ((blockPos << 26) >> 42) & 4194303L) << 20); // Simplify to reduce instruction count
-     }
- 
-     public static long getZeroNode(int x, int z) {
-@@ -0,0 +0,0 @@ public class SectionPos extends Vec3i {
-         return asLong(blockToSectionCoord(pos.getX()), blockToSectionCoord(pos.getY()), blockToSectionCoord(pos.getZ()));
-     }
- 
-+    // Paper start
-+    public static long blockPosAsSectionLong(int i, int j, int k) {
-+        return (((long) (i >> 4) & 4194303L) << 42) | (((long) (j >> 4) & 1048575L)) | (((long) (k >> 4) & 4194303L) << 20);
-+    }
-+    // Paper end
-+
-     public static long asLong(int x, int y, int z) {
--        long l = 0L;
--        l |= ((long)x & 4194303L) << 42;
--        l |= ((long)y & 1048575L) << 0;
--        return l | ((long)z & 4194303L) << 20;
-+        return (((long) x & 4194303L) << 42) | (((long) y & 1048575L)) | (((long) z & 4194303L) << 20); // Paper - Simplify to reduce instruction count
-     }
- 
-     public long asLong() {
--        return asLong(this.x(), this.y(), this.z());
-+        return (((long) getX() & 4194303L) << 42) | (((long) getY() & 1048575L)) | (((long) getZ() & 4194303L) << 20); // Paper - Simplify to reduce instruction count
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class SectionPos extends Vec3i {
-     }
- 
-     public static Stream<SectionPos> cube(SectionPos center, int radius) {
--        int i = center.x();
--        int j = center.y();
--        int k = center.z();
--        return betweenClosedStream(i - radius, j - radius, k - radius, i + radius, j + radius, k + radius);
-+        return betweenClosedStream(center.getX() - radius, center.getY() - radius, center.getZ() - radius, center.getX() + radius, center.getY() + radius, center.getZ() + radius); // Paper - simplify/inline
-     }
- 
-     public static Stream<SectionPos> aroundChunk(ChunkPos center, int radius, int minY, int maxY) {
--        int i = center.x;
--        int j = center.z;
--        return betweenClosedStream(i - radius, minY, j - radius, i + radius, maxY, j + radius);
-+        return betweenClosedStream(center.x - radius, minY, center.z - radius, center.x + radius, maxY, center.z + radius); // Paper - simplify/inline
-     }
- 
-     public static Stream<SectionPos> betweenClosedStream(int minX, int minY, int minZ, int maxX, int maxY, int maxZ) {

patches/server/Optimize-Collision-to-not-load-chunks.patch

@@ -1,96 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Thu, 2 Apr 2020 02:37:57 -0400
-Subject: [PATCH] Optimize Collision to not load chunks
-
-The collision code takes an AABB and generates a cuboid of checks rather
-than a cylinder, so at high velocity this can generate a lot of chunk checks.
-
-Treat an unloaded chunk as a collision for entities, and also for players if
-the "prevent moving into unloaded chunks" setting is enabled.
-
-If that serting is not enabled, collisions will be ignored for players, since
-movement will load only the chunk the player enters anyways and avoids loading
-massive amounts of surrounding chunks due to large AABB lookups.
-
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-     // Paper end - Share random for entities to make them more random
-     public org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason spawnReason; // Paper - Entity#getEntitySpawnReason
- 
-+    public boolean collisionLoadChunks = false; // Paper
-     private CraftEntity bukkitEntity;
- 
-     public CraftEntity getBukkitEntity() {
-diff --git a/src/main/java/net/minecraft/world/level/BlockCollisions.java b/src/main/java/net/minecraft/world/level/BlockCollisions.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/BlockCollisions.java
-+++ b/src/main/java/net/minecraft/world/level/BlockCollisions.java
-@@ -0,0 +0,0 @@ public class BlockCollisions<T> extends AbstractIterator<T> {
-     @Override
-     protected T computeNext() {
-         while (this.cursor.advance()) {
--            int i = this.cursor.nextX();
--            int j = this.cursor.nextY();
--            int k = this.cursor.nextZ();
-+            int i = this.cursor.nextX(); final int x = i; // Paper - OBFHELPER
-+            int j = this.cursor.nextY(); final int y = j; // Paper - OBFHELPER
-+            int k = this.cursor.nextZ(); final int z = k; // Paper - OBFHELPER
-             int l = this.cursor.getNextType();
-             if (l != 3) {
--                BlockGetter blockGetter = this.getChunk(i, k);
--                if (blockGetter != null) {
--                    this.pos.set(i, j, k);
--                    BlockState blockState = blockGetter.getBlockState(this.pos);
--                    if ((!this.onlySuffocatingBlocks || blockState.isSuffocating(blockGetter, this.pos))
-+                // Paper start - ensure we don't load chunks
-+                // BlockGetter blockGetter = this.getChunk(i, k);
-+                if (true) {
-+                    final @Nullable Entity source = this.context instanceof net.minecraft.world.phys.shapes.EntityCollisionContext entityContext ? entityContext.getEntity() : null;
-+                    boolean far = source != null && io.papermc.paper.util.MCUtil.distanceSq(source.getX(), y, source.getZ(), x, y, z) > 14;
-+                    this.pos.set(x, y, z);
-+                    BlockState blockState;
-+                    if (this.collisionGetter instanceof net.minecraft.server.level.WorldGenRegion) {
-+                        BlockGetter blockGetter = this.getChunk(x, z);
-+                        if (blockGetter == null) {
-+                            continue;
-+                        }
-+                        blockState = blockGetter.getBlockState(this.pos);
-+                    } else if ((!far && source instanceof net.minecraft.server.level.ServerPlayer) || (source != null && source.collisionLoadChunks)) {
-+                        blockState = this.collisionGetter.getBlockState(this.pos);
-+                    } else {
-+                        blockState = this.collisionGetter.getBlockStateIfLoaded(this.pos);
-+                    }
-+                    if (blockState == null) {
-+                        if (!(source instanceof net.minecraft.server.level.ServerPlayer) || source.level().paperConfig().chunks.preventMovingIntoUnloadedChunks) {
-+                            return this.resultProvider.apply(new BlockPos.MutableBlockPos(x, y, z), Shapes.create(far ? source.getBoundingBox() : new AABB(new BlockPos(x, y, z))));
-+                        }
-+                        continue;
-+                    }
-+                    if (true // onlySuffocatingBlocks is only true on the client, so we don't care about it here
-+                    // Paper end - ensure we don't load chunks
-                         && (l != 1 || blockState.hasLargeCollisionShape())
-                         && (l != 2 || blockState.is(Blocks.MOVING_PISTON))) {
-                         VoxelShape voxelShape = this.context.getCollisionShape(blockState, this.collisionGetter, this.pos);
-diff --git a/src/main/java/net/minecraft/world/level/CollisionGetter.java b/src/main/java/net/minecraft/world/level/CollisionGetter.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/CollisionGetter.java
-+++ b/src/main/java/net/minecraft/world/level/CollisionGetter.java
-@@ -0,0 +0,0 @@ public interface CollisionGetter extends BlockGetter {
-     }
- 
-     default boolean noCollision(@Nullable Entity entity, AABB box, boolean checkFluid) {
--        for (VoxelShape voxelShape : checkFluid ? this.getBlockAndLiquidCollisions(entity, box) : this.getBlockCollisions(entity, box)) {
-+        try { if (entity != null) entity.collisionLoadChunks = true; // Paper
-+            for (VoxelShape voxelShape : checkFluid ? this.getBlockAndLiquidCollisions(entity, box) : this.getBlockCollisions(entity, box)) {
-             if (!voxelShape.isEmpty()) {
-                 return false;
-             }
-         }
-+        } finally { if (entity != null) entity.collisionLoadChunks = false; } // Paper
- 
-         if (!this.getEntityCollisions(entity, box).isEmpty()) {
-             return false;

patches/server/Optimize-GoalSelector-Goal.Flag-Set-operations.patch

@@ -1,171 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Mon, 6 Apr 2020 17:53:29 -0700
-Subject: [PATCH] Optimize GoalSelector Goal.Flag Set operations
-
-Optimise the stream.anyMatch statement to move to a bitset
-where we can replace the call with a single bitwise operation.
-
-diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/Goal.java b/src/main/java/net/minecraft/world/entity/ai/goal/Goal.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ai/goal/Goal.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/goal/Goal.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.entity.Entity;
- import net.minecraft.world.level.Level;
- 
- public abstract class Goal {
--    private final EnumSet<Goal.Flag> flags = EnumSet.noneOf(Goal.Flag.class);
-+    private final EnumSet<Goal.Flag> flags = EnumSet.noneOf(Goal.Flag.class); // Paper unused, but dummy to prevent plugins from crashing as hard. Theyll need to support paper in a special case if this is super important, but really doesn't seem like it would be.
-+    private final ca.spottedleaf.moonrise.common.set.OptimizedSmallEnumSet<net.minecraft.world.entity.ai.goal.Goal.Flag> goalTypes = new ca.spottedleaf.moonrise.common.set.OptimizedSmallEnumSet<>(Goal.Flag.class); // Paper - remove streams from pathfindergoalselector
-+
-+    // Paper start - remove streams from pathfindergoalselector; make sure types are not empty
-+    public Goal() {
-+        if (this.goalTypes.size() == 0) {
-+            this.goalTypes.addUnchecked(Flag.UNKNOWN_BEHAVIOR);
-+        }
-+    }
-+    // Paper end - remove streams from pathfindergoalselector
- 
-     public abstract boolean canUse();
- 
-@@ -0,0 +0,0 @@ public abstract class Goal {
-     }
- 
-     public void setFlags(EnumSet<Goal.Flag> controls) {
--        this.flags.clear();
--        this.flags.addAll(controls);
-+        // Paper start - remove streams from pathfindergoalselector
-+        this.goalTypes.clear();
-+        this.goalTypes.addAllUnchecked(controls);
-+        if (this.goalTypes.size() == 0) {
-+            this.goalTypes.addUnchecked(Flag.UNKNOWN_BEHAVIOR);
-+        }
-+        // Paper end - remove streams from pathfindergoalselector
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public abstract class Goal {
-         return this.getClass().getSimpleName();
-     }
- 
--    public EnumSet<Goal.Flag> getFlags() {
--        return this.flags;
-+    // Paper start - remove streams from pathfindergoalselector
-+    public ca.spottedleaf.moonrise.common.set.OptimizedSmallEnumSet<Goal.Flag> getFlags() {
-+        return this.goalTypes;
-+        // Paper end - remove streams from pathfindergoalselector
-     }
- 
-     // Paper start - Mob Goal API
-     public boolean hasFlag(final Goal.Flag flag) {
--        return this.flags.contains(flag);
-+        return this.goalTypes.hasElement(flag);
-     }
- 
-     public void addFlag(final Goal.Flag flag) {
--        this.flags.add(flag);
-+        this.goalTypes.addUnchecked(flag);
-     }
-     // Paper end - Mob Goal API
- 
-diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java b/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java
-@@ -0,0 +0,0 @@ public class GoalSelector {
-     };
-     private final Map<Goal.Flag, WrappedGoal> lockedFlags = new EnumMap<>(Goal.Flag.class);
-     private final Set<WrappedGoal> availableGoals = new ObjectLinkedOpenHashSet<>();
--    private final EnumSet<Goal.Flag> disabledFlags = EnumSet.noneOf(Goal.Flag.class);
-+    private static final Goal.Flag[] GOAL_FLAG_VALUES = Goal.Flag.values(); // Paper - remove streams from pathfindergoalselector
-+    private final ca.spottedleaf.moonrise.common.set.OptimizedSmallEnumSet<net.minecraft.world.entity.ai.goal.Goal.Flag> goalTypes = new ca.spottedleaf.moonrise.common.set.OptimizedSmallEnumSet<>(Goal.Flag.class); // Paper - remove streams from pathfindergoalselector
-     private int curRate; // Paper - EAR 2
- 
-     public void addGoal(int priority, Goal goal) {
-@@ -0,0 +0,0 @@ public class GoalSelector {
-         this.availableGoals.removeIf(wrappedGoalx -> wrappedGoalx.getGoal() == goal);
-     }
- 
--    private static boolean goalContainsAnyFlags(WrappedGoal goal, EnumSet<Goal.Flag> controls) {
--        for (Goal.Flag flag : goal.getFlags()) {
--            if (controls.contains(flag)) {
--                return true;
--            }
--        }
--
--        return false;
-+    // Paper start
-+    private static boolean goalContainsAnyFlags(WrappedGoal goal, ca.spottedleaf.moonrise.common.set.OptimizedSmallEnumSet<Goal.Flag> controls) {
-+        return goal.getFlags().hasCommonElements(controls);
-     }
- 
-     private static boolean goalCanBeReplacedForAllFlags(WrappedGoal goal, Map<Goal.Flag, WrappedGoal> goalsByControl) {
--        for (Goal.Flag flag : goal.getFlags()) {
-+        long flagIterator = goal.getFlags().getBackingSet();
-+        int wrappedGoalSize = goal.getFlags().size();
-+        for (int i = 0; i < wrappedGoalSize; ++i) {
-+            final Goal.Flag flag = GOAL_FLAG_VALUES[Long.numberOfTrailingZeros(flagIterator)];
-+            flagIterator ^= ca.spottedleaf.concurrentutil.util.IntegerUtil.getTrailingBit(flagIterator);
-+            // Paper end
-             if (!goalsByControl.getOrDefault(flag, NO_GOAL).canBeReplacedBy(goal)) {
-                 return false;
-             }
-@@ -0,0 +0,0 @@ public class GoalSelector {
-         profilerFiller.push("goalCleanup");
- 
-         for (WrappedGoal wrappedGoal : this.availableGoals) {
--            if (wrappedGoal.isRunning() && (goalContainsAnyFlags(wrappedGoal, this.disabledFlags) || !wrappedGoal.canContinueToUse())) {
-+            if (wrappedGoal.isRunning() && (goalContainsAnyFlags(wrappedGoal, this.goalTypes) || !wrappedGoal.canContinueToUse())) { // Paper - Perf: optimize goal types by removing streams
-                 wrappedGoal.stop();
-             }
-         }
-@@ -0,0 +0,0 @@ public class GoalSelector {
-         profilerFiller.push("goalUpdate");
- 
-         for (WrappedGoal wrappedGoal2 : this.availableGoals) {
--            if (!wrappedGoal2.isRunning()
--                && !goalContainsAnyFlags(wrappedGoal2, this.disabledFlags)
--                && goalCanBeReplacedForAllFlags(wrappedGoal2, this.lockedFlags)
--                && wrappedGoal2.canUse()) {
--                for (Goal.Flag flag : wrappedGoal2.getFlags()) {
-+            // Paper start
-+            if (!wrappedGoal2.isRunning() && !goalContainsAnyFlags(wrappedGoal2, this.goalTypes) && goalCanBeReplacedForAllFlags(wrappedGoal2, this.lockedFlags) && wrappedGoal2.canUse()) {
-+                long flagIterator = wrappedGoal2.getFlags().getBackingSet();
-+                int wrappedGoalSize = wrappedGoal2.getFlags().size();
-+                for (int i = 0; i < wrappedGoalSize; ++i) {
-+                    final Goal.Flag flag = GOAL_FLAG_VALUES[Long.numberOfTrailingZeros(flagIterator)];
-+                    flagIterator ^= ca.spottedleaf.concurrentutil.util.IntegerUtil.getTrailingBit(flagIterator);
-+                    // Paper end
-                     WrappedGoal wrappedGoal3 = this.lockedFlags.getOrDefault(flag, NO_GOAL);
-                     wrappedGoal3.stop();
-                     this.lockedFlags.put(flag, wrappedGoal2);
-@@ -0,0 +0,0 @@ public class GoalSelector {
-     }
- 
-     public void disableControlFlag(Goal.Flag control) {
--        this.disabledFlags.add(control);
-+        this.goalTypes.addUnchecked(control); // Paper - remove streams from pathfindergoalselector
-     }
- 
-     public void enableControlFlag(Goal.Flag control) {
--        this.disabledFlags.remove(control);
-+        this.goalTypes.removeUnchecked(control); // Paper - remove streams from pathfindergoalselector
-     }
- 
-     public void setControlFlag(Goal.Flag control, boolean enabled) {
-diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/WrappedGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/WrappedGoal.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ai/goal/WrappedGoal.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/goal/WrappedGoal.java
-@@ -0,0 +0,0 @@ public class WrappedGoal extends Goal {
-     }
- 
-     @Override
--    public EnumSet<Goal.Flag> getFlags() {
-+    // Paper start - remove streams from pathfindergoalselector
-+    public ca.spottedleaf.moonrise.common.set.OptimizedSmallEnumSet<Goal.Flag> getFlags() {
-         return this.goal.getFlags();
-+        // Paper end - remove streams from pathfindergoalselector
-     }
- 
-     public boolean isRunning() {

patches/server/Optimize-Hoppers.patch

@@ -1,664 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Wed, 27 Apr 2016 22:09:52 -0400
-Subject: [PATCH] Optimize Hoppers
-
-* Removes unnecessary extra calls to .update() that are very expensive
-* Lots of itemstack cloning removed. Only clone if the item is actually moved
-* Return true when a plugin cancels inventory move item event instead of false, as false causes pulls to cycle through all items.
-  However, pushes do not exhibit the same behavior, so this is not something plugins could of been relying on.
-* Add option (Default on) to cooldown hoppers when they fail to move an item due to full inventory
-* Skip subsequent InventoryMoveItemEvents if a plugin does not use the item after first event fire for an iteration by tracking changes to the event via an internal event implementation.
-* Don't check for Entities with Inventories if the block above us is also occluding (not just Inventoried)
-* Remove Streams from Item Suck In and restore restore 1.12 AABB checks which is simpler and no voxel allocations (was doing TWO Item Suck ins)
-
-diff --git a/src/main/java/io/papermc/paper/event/inventory/PaperInventoryMoveItemEvent.java b/src/main/java/io/papermc/paper/event/inventory/PaperInventoryMoveItemEvent.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/io/papermc/paper/event/inventory/PaperInventoryMoveItemEvent.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.event.inventory;
-+
-+import org.bukkit.event.inventory.InventoryMoveItemEvent;
-+import org.bukkit.inventory.Inventory;
-+import org.bukkit.inventory.ItemStack;
-+import org.checkerframework.checker.nullness.qual.NonNull;
-+import org.checkerframework.framework.qual.DefaultQualifier;
-+import org.jetbrains.annotations.NotNull;
-+
-+@DefaultQualifier(NonNull.class)
-+public class PaperInventoryMoveItemEvent extends InventoryMoveItemEvent {
-+
-+    public boolean calledSetItem;
-+    public boolean calledGetItem;
-+
-+    public PaperInventoryMoveItemEvent(final @NotNull Inventory sourceInventory, final @NotNull ItemStack itemStack, final @NotNull Inventory destinationInventory, final boolean didSourceInitiate) {
-+        super(sourceInventory, itemStack, destinationInventory, didSourceInitiate);
-+    }
-+
-+    @Override
-+    public ItemStack getItem() {
-+        this.calledGetItem = true;
-+        return super.getItem();
-+    }
-+
-+    @Override
-+    public void setItem(final ItemStack itemStack) {
-+        super.setItem(itemStack);
-+        this.calledSetItem = true;
-+    }
-+}
-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
-             ServerLevel worldserver = (ServerLevel) iterator.next();
-             worldserver.hasPhysicsEvent = org.bukkit.event.block.BlockPhysicsEvent.getHandlerList().getRegisteredListeners().length > 0; // Paper - BlockPhysicsEvent
-             worldserver.hasEntityMoveEvent = io.papermc.paper.event.entity.EntityMoveEvent.getHandlerList().getRegisteredListeners().length > 0; // Paper - Add EntityMoveEvent
-+            net.minecraft.world.level.block.entity.HopperBlockEntity.skipHopperEvents = worldserver.paperConfig().hopper.disableMoveEvent || org.bukkit.event.inventory.InventoryMoveItemEvent.getHandlerList().getRegisteredListeners().length == 0; // Paper - Perf: Optimize Hoppers
- 
-             gameprofilerfiller.push(() -> {
-                 String s = String.valueOf(worldserver);
-diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/item/ItemStack.java
-+++ b/src/main/java/net/minecraft/world/item/ItemStack.java
-@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
-     }
- 
-     public ItemStack copy() {
--        if (this.isEmpty()) {
-+        // Paper start - Perf: Optimize Hoppers
-+        return this.copy(false);
-+    }
-+
-+    public ItemStack copy(boolean originalItem) {
-+        if (!originalItem && this.isEmpty()) {
-+            // Paper end - Perf: Optimize Hoppers
-             return ItemStack.EMPTY;
-         } else {
--            ItemStack itemstack = new ItemStack(this.getItem(), this.count, this.components.copy());
-+            ItemStack itemstack = new ItemStack(originalItem ? this.item : this.getItem(), this.count, this.components.copy()); // Paper - Perf: Optimize Hoppers
- 
-             itemstack.setPopTime(this.getPopTime());
-             return itemstack;
-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 @@ import org.bukkit.inventory.InventoryHolder;
- // CraftBukkit end
- 
- public abstract class BlockEntity {
-+    static boolean ignoreTileUpdates; // Paper - Perf: Optimize Hoppers
- 
-     // CraftBukkit start - data containers
-     private static final CraftPersistentDataTypeRegistry DATA_TYPE_REGISTRY = new CraftPersistentDataTypeRegistry();
-@@ -0,0 +0,0 @@ public abstract class BlockEntity {
- 
-     public void setChanged() {
-         if (this.level != null) {
-+            if (ignoreTileUpdates) return; // Paper - Perf: Optimize Hoppers
-             BlockEntity.setChanged(this.level, this.worldPosition, this.blockState);
-         }
- 
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/HopperBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/HopperBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/HopperBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/HopperBlockEntity.java
-@@ -0,0 +0,0 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
- 
-     }
- 
-+    // Paper start - Perf: Optimize Hoppers
-+    private static final int HOPPER_EMPTY = 0;
-+    private static final int HOPPER_HAS_ITEMS = 1;
-+    private static final int HOPPER_IS_FULL = 2;
-+
-+    private static int getFullState(final HopperBlockEntity tileEntity) {
-+        tileEntity.unpackLootTable(null);
-+
-+        final List<ItemStack> hopperItems = tileEntity.getItems();
-+
-+        boolean empty = true;
-+        boolean full = true;
-+
-+        for (int i = 0, len = hopperItems.size(); i < len; ++i) {
-+            final ItemStack stack = hopperItems.get(i);
-+            if (stack.isEmpty()) {
-+                full = false;
-+                continue;
-+            }
-+
-+            if (!full) {
-+                // can't be full
-+                return HOPPER_HAS_ITEMS;
-+            }
-+
-+            empty = false;
-+
-+            if (stack.getCount() != stack.getMaxStackSize()) {
-+                // can't be full or empty
-+                return HOPPER_HAS_ITEMS;
-+            }
-+        }
-+
-+        return empty ? HOPPER_EMPTY : (full ? HOPPER_IS_FULL : HOPPER_HAS_ITEMS);
-+    }
-+    // Paper end - Perf: Optimize Hoppers
-+
-     private static boolean tryMoveItems(Level world, BlockPos pos, BlockState state, HopperBlockEntity blockEntity, BooleanSupplier booleansupplier) {
-         if (world.isClientSide) {
-             return false;
-@@ -0,0 +0,0 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
-             if (!blockEntity.isOnCooldown() && (Boolean) state.getValue(HopperBlock.ENABLED)) {
-                 boolean flag = false;
- 
--                if (!blockEntity.isEmpty()) {
-+                final int fullState = getFullState(blockEntity); // Paper - Perf: Optimize Hoppers
-+                if (fullState != HOPPER_EMPTY) { // Paper - Perf: Optimize Hoppers
-                     flag = HopperBlockEntity.ejectItems(world, pos, blockEntity);
-                 }
- 
--                if (!blockEntity.inventoryFull()) {
-+                if (fullState != HOPPER_IS_FULL || flag) { // Paper - Perf: Optimize Hoppers
-                     flag |= booleansupplier.getAsBoolean();
-                 }
- 
-@@ -0,0 +0,0 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
-         return false;
-     }
- 
-+    // Paper start - Perf: Optimize Hoppers
-+    private static boolean skipPullModeEventFire;
-+    private static boolean skipPushModeEventFire;
-+    public static boolean skipHopperEvents;
-+
-+    private static boolean hopperPush(final Level level, final Container destination, final Direction direction, final HopperBlockEntity hopper) {
-+        skipPushModeEventFire = skipHopperEvents;
-+        boolean foundItem = false;
-+        for (int i = 0; i < hopper.getContainerSize(); ++i) {
-+            final ItemStack item = hopper.getItem(i);
-+            if (!item.isEmpty()) {
-+                foundItem = true;
-+                ItemStack origItemStack = item;
-+                ItemStack movedItem = origItemStack;
-+
-+                final int originalItemCount = origItemStack.getCount();
-+                final int movedItemCount = Math.min(level.spigotConfig.hopperAmount, originalItemCount);
-+                origItemStack.setCount(movedItemCount);
-+
-+                // We only need to fire the event once to give protection plugins a chance to cancel this event
-+                // Because nothing uses getItem, every event call should end up the same result.
-+                if (!skipPushModeEventFire) {
-+                    movedItem = callPushMoveEvent(destination, movedItem, hopper);
-+                    if (movedItem == null) { // cancelled
-+                        origItemStack.setCount(originalItemCount);
-+                        return false;
-+                    }
-+                }
-+
-+                final ItemStack remainingItem = addItem(hopper, destination, movedItem, direction);
-+                final int remainingItemCount = remainingItem.getCount();
-+                if (remainingItemCount != movedItemCount) {
-+                    origItemStack = origItemStack.copy(true);
-+                    origItemStack.setCount(originalItemCount);
-+                    if (!origItemStack.isEmpty()) {
-+                        origItemStack.setCount(originalItemCount - movedItemCount + remainingItemCount);
-+                    }
-+                    hopper.setItem(i, origItemStack);
-+                    destination.setChanged();
-+                    return true;
-+                }
-+                origItemStack.setCount(originalItemCount);
-+            }
-+        }
-+        if (foundItem && level.paperConfig().hopper.cooldownWhenFull) { // Inventory was full - cooldown
-+            hopper.setCooldown(level.spigotConfig.hopperTransfer);
-+        }
-+        return false;
-+    }
-+
-+    private static boolean hopperPull(final Level level, final Hopper hopper, final Container container, ItemStack origItemStack, final int i) {
-+        ItemStack movedItem = origItemStack;
-+        final int originalItemCount = origItemStack.getCount();
-+        final int movedItemCount = Math.min(level.spigotConfig.hopperAmount, originalItemCount);
-+        container.setChanged(); // original logic always marks source inv as changed even if no move happens.
-+        movedItem.setCount(movedItemCount);
-+
-+        if (!skipPullModeEventFire) {
-+            movedItem = callPullMoveEvent(hopper, container, movedItem);
-+            if (movedItem == null) { // cancelled
-+                origItemStack.setCount(originalItemCount);
-+                // Drastically improve performance by returning true.
-+                // No plugin could of relied on the behavior of false as the other call
-+                // site for IMIE did not exhibit the same behavior
-+                return true;
-+            }
-+        }
-+
-+        final ItemStack remainingItem = addItem(container, hopper, movedItem, null);
-+        final int remainingItemCount = remainingItem.getCount();
-+        if (remainingItemCount != movedItemCount) {
-+            origItemStack = origItemStack.copy(true);
-+            origItemStack.setCount(originalItemCount);
-+            if (!origItemStack.isEmpty()) {
-+                origItemStack.setCount(originalItemCount - movedItemCount + remainingItemCount);
-+            }
-+
-+            ignoreTileUpdates = true;
-+            container.setItem(i, origItemStack);
-+            ignoreTileUpdates = false;
-+            container.setChanged();
-+            return true;
-+        }
-+        origItemStack.setCount(originalItemCount);
-+
-+        if (level.paperConfig().hopper.cooldownWhenFull) {
-+            cooldownHopper(hopper);
-+        }
-+
-+        return false;
-+    }
-+
-+    @Nullable
-+    private static ItemStack callPushMoveEvent(Container iinventory, ItemStack itemstack, HopperBlockEntity hopper) {
-+        final Inventory destinationInventory = getInventory(iinventory);
-+        final io.papermc.paper.event.inventory.PaperInventoryMoveItemEvent event = new io.papermc.paper.event.inventory.PaperInventoryMoveItemEvent(hopper.getOwner(false).getInventory(),
-+            CraftItemStack.asCraftMirror(itemstack), destinationInventory, true);
-+        final boolean result = event.callEvent();
-+        if (!event.calledGetItem && !event.calledSetItem) {
-+            skipPushModeEventFire = true;
-+        }
-+        if (!result) {
-+            cooldownHopper(hopper);
-+            return null;
-+        }
-+
-+        if (event.calledSetItem) {
-+            return CraftItemStack.asNMSCopy(event.getItem());
-+        } else {
-+            return itemstack;
-+        }
-+    }
-+
-+    @Nullable
-+    private static ItemStack callPullMoveEvent(final Hopper hopper, final Container container, final ItemStack itemstack) {
-+        final Inventory sourceInventory = getInventory(container);
-+        final Inventory destination = getInventory(hopper);
-+
-+        // Mirror is safe as no plugins ever use this item
-+        final io.papermc.paper.event.inventory.PaperInventoryMoveItemEvent event = new io.papermc.paper.event.inventory.PaperInventoryMoveItemEvent(sourceInventory, CraftItemStack.asCraftMirror(itemstack), destination, false);
-+        final boolean result = event.callEvent();
-+        if (!event.calledGetItem && !event.calledSetItem) {
-+            skipPullModeEventFire = true;
-+        }
-+        if (!result) {
-+            cooldownHopper(hopper);
-+            return null;
-+        }
-+
-+        if (event.calledSetItem) {
-+            return CraftItemStack.asNMSCopy(event.getItem());
-+        } else {
-+            return itemstack;
-+        }
-+    }
-+
-+    private static Inventory getInventory(final Container container) {
-+        final Inventory sourceInventory;
-+        if (container instanceof CompoundContainer compoundContainer) {
-+            // Have to special-case large chests as they work oddly
-+            sourceInventory = new org.bukkit.craftbukkit.inventory.CraftInventoryDoubleChest(compoundContainer);
-+        } else if (container instanceof BlockEntity blockEntity) {
-+            sourceInventory = blockEntity.getOwner(false).getInventory();
-+        } else if (container.getOwner() != null) {
-+            sourceInventory = container.getOwner().getInventory();
-+        } else {
-+            sourceInventory = new CraftInventory(container);
-+        }
-+        return sourceInventory;
-+    }
-+
-+    private static void cooldownHopper(final Hopper hopper) {
-+        if (hopper instanceof HopperBlockEntity blockEntity && blockEntity.getLevel() != null) {
-+            blockEntity.setCooldown(blockEntity.getLevel().spigotConfig.hopperTransfer);
-+        }
-+    }
-+
-+    private static boolean allMatch(Container iinventory, Direction enumdirection, java.util.function.BiPredicate<ItemStack, Integer> test) {
-+        if (iinventory instanceof WorldlyContainer) {
-+            for (int i : ((WorldlyContainer) iinventory).getSlotsForFace(enumdirection)) {
-+                if (!test.test(iinventory.getItem(i), i)) {
-+                    return false;
-+                }
-+            }
-+        } else {
-+            int size = iinventory.getContainerSize();
-+            for (int i = 0; i < size; i++) {
-+                if (!test.test(iinventory.getItem(i), i)) {
-+                    return false;
-+                }
-+            }
-+        }
-+        return true;
-+    }
-+
-+    private static boolean anyMatch(Container iinventory, Direction enumdirection, java.util.function.BiPredicate<ItemStack, Integer> test) {
-+        if (iinventory instanceof WorldlyContainer) {
-+            for (int i : ((WorldlyContainer) iinventory).getSlotsForFace(enumdirection)) {
-+                if (test.test(iinventory.getItem(i), i)) {
-+                    return true;
-+                }
-+            }
-+        } else {
-+            int size = iinventory.getContainerSize();
-+            for (int i = 0; i < size; i++) {
-+                if (test.test(iinventory.getItem(i), i)) {
-+                    return true;
-+                }
-+            }
-+        }
-+        return true;
-+    }
-+    private static final java.util.function.BiPredicate<ItemStack, Integer> STACK_SIZE_TEST = (itemstack, i) -> itemstack.getCount() >= itemstack.getMaxStackSize();
-+    private static final java.util.function.BiPredicate<ItemStack, Integer> IS_EMPTY_TEST = (itemstack, i) -> itemstack.isEmpty();
-+    // Paper end - Perf: Optimize Hoppers
-+
-     private static boolean ejectItems(Level world, BlockPos pos, HopperBlockEntity blockEntity) {
-         Container iinventory = HopperBlockEntity.getAttachedContainer(world, pos, blockEntity);
- 
-@@ -0,0 +0,0 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
-             if (HopperBlockEntity.isFullContainer(iinventory, enumdirection)) {
-                 return false;
-             } else {
--                for (int i = 0; i < blockEntity.getContainerSize(); ++i) {
--                    ItemStack itemstack = blockEntity.getItem(i);
--
--                    if (!itemstack.isEmpty()) {
--                        int j = itemstack.getCount();
--                        // CraftBukkit start - Call event when pushing items into other inventories
--                        ItemStack original = itemstack.copy();
--                        CraftItemStack oitemstack = CraftItemStack.asCraftMirror(blockEntity.removeItem(i, world.spigotConfig.hopperAmount)); // Spigot
--
--                        Inventory destinationInventory;
--                        // Have to special case large chests as they work oddly
--                        if (iinventory instanceof CompoundContainer) {
--                            destinationInventory = new org.bukkit.craftbukkit.inventory.CraftInventoryDoubleChest((CompoundContainer) iinventory);
--                        } else if (iinventory.getOwner() != null) {
--                            destinationInventory = iinventory.getOwner().getInventory();
--                        } else {
--                            destinationInventory = new CraftInventory(iinventory);
--                        }
--
--                        InventoryMoveItemEvent event = new InventoryMoveItemEvent(blockEntity.getOwner().getInventory(), oitemstack, destinationInventory, true);
--                        world.getCraftServer().getPluginManager().callEvent(event);
--                        if (event.isCancelled()) {
--                            blockEntity.setItem(i, original);
--                            blockEntity.setCooldown(world.spigotConfig.hopperTransfer); // Delay hopper checks // Spigot
--                            return false;
--                        }
--                        int origCount = event.getItem().getAmount(); // Spigot
--                        ItemStack itemstack1 = HopperBlockEntity.addItem(blockEntity, iinventory, CraftItemStack.asNMSCopy(event.getItem()), enumdirection);
--                        // CraftBukkit end
--
--                        if (itemstack1.isEmpty()) {
--                            iinventory.setChanged();
--                            return true;
--                        }
--
--                        itemstack.setCount(j);
--                        // Spigot start
--                        itemstack.shrink(origCount - itemstack1.getCount());
--                        if (j <= world.spigotConfig.hopperAmount) {
--                            // Spigot end
--                            blockEntity.setItem(i, itemstack);
--                        }
--                    }
--                }
--
--                return false;
-+                // Paper start - Perf: Optimize Hoppers
-+                return hopperPush(world, iinventory, enumdirection, blockEntity);
-+                //for (int i = 0; i < blockEntity.getContainerSize(); ++i) {
-+                //    ItemStack itemstack = blockEntity.getItem(i);
-+
-+                //    if (!itemstack.isEmpty()) {
-+                //        int j = itemstack.getCount();
-+                //        // CraftBukkit start - Call event when pushing items into other inventories
-+                //        ItemStack original = itemstack.copy();
-+                //        CraftItemStack oitemstack = CraftItemStack.asCraftMirror(blockEntity.removeItem(i, world.spigotConfig.hopperAmount)); // Spigot
-+
-+                //        Inventory destinationInventory;
-+                //        // Have to special case large chests as they work oddly
-+                //        if (iinventory instanceof CompoundContainer) {
-+                //            destinationInventory = new org.bukkit.craftbukkit.inventory.CraftInventoryDoubleChest((CompoundContainer) iinventory);
-+                //        } else if (iinventory.getOwner() != null) {
-+                //            destinationInventory = iinventory.getOwner().getInventory();
-+                //        } else {
-+                //            destinationInventory = new CraftInventory(iinventory);
-+                //        }
-+
-+                //        InventoryMoveItemEvent event = new InventoryMoveItemEvent(tileentityhopper.getOwner().getInventory(), oitemstack, destinationInventory, true);
-+                //        world.getCraftServer().getPluginManager().callEvent(event);
-+                //        if (event.isCancelled()) {
-+                //            blockEntity.setItem(i, original);
-+                //            blockEntity.setCooldown(world.spigotConfig.hopperTransfer); // Delay hopper checks // Spigot
-+                //            return false;
-+                //        }
-+                //        int origCount = event.getItem().getAmount(); // Spigot
-+                //        ItemStack itemstack1 = HopperBlockEntity.addItem(blockEntity, iinventory, CraftItemStack.asNMSCopy(event.getItem()), enumdirection);
-+                //        // CraftBukkit end
-+
-+                //        if (itemstack1.isEmpty()) {
-+                //            iinventory.setChanged();
-+                //            return true;
-+                //        }
-+
-+                //        itemstack.setCount(j);
-+                //        // Spigot start
-+                //        itemstack.shrink(origCount - itemstack1.getCount());
-+                //        if (j <= world.spigotConfig.hopperAmount) {
-+                //          // Spigot end
-+                //            blockEntity.setItem(i, itemstack);
-+                //        }
-+                //    }
-+                //}
-+
-+                // return false;
-+                // Paper end - Perf: Optimize Hoppers
-             }
-         }
-     }
-@@ -0,0 +0,0 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
-                 return false;
-             }
-         }
--
-         return true;
-     }
- 
-@@ -0,0 +0,0 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
- 
-         if (iinventory != null) {
-             Direction enumdirection = Direction.DOWN;
-+            skipPullModeEventFire = skipHopperEvents; // Paper - Perf: Optimize Hoppers
-             int[] aint = HopperBlockEntity.getSlots(iinventory, enumdirection);
-             int i = aint.length;
- 
-@@ -0,0 +0,0 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
-         ItemStack itemstack = iinventory.getItem(i);
- 
-         if (!itemstack.isEmpty() && HopperBlockEntity.canTakeItemFromContainer(ihopper, iinventory, itemstack, i, enumdirection)) {
--            int j = itemstack.getCount();
--            // CraftBukkit start - Call event on collection of items from inventories into the hopper
--            ItemStack original = itemstack.copy();
--            CraftItemStack oitemstack = CraftItemStack.asCraftMirror(iinventory.removeItem(i, world.spigotConfig.hopperAmount)); // Spigot
--
--            Inventory sourceInventory;
--            // Have to special case large chests as they work oddly
--            if (iinventory instanceof CompoundContainer) {
--                sourceInventory = new org.bukkit.craftbukkit.inventory.CraftInventoryDoubleChest((CompoundContainer) iinventory);
--            } else if (iinventory.getOwner() != null) {
--                sourceInventory = iinventory.getOwner().getInventory();
--            } else {
--                sourceInventory = new CraftInventory(iinventory);
--            }
--
--            InventoryMoveItemEvent event = new InventoryMoveItemEvent(sourceInventory, oitemstack, ihopper.getOwner().getInventory(), false);
--
--            Bukkit.getServer().getPluginManager().callEvent(event);
--            if (event.isCancelled()) {
--                iinventory.setItem(i, original);
--
--                if (ihopper instanceof HopperBlockEntity) {
--                    ((HopperBlockEntity) ihopper).setCooldown(world.spigotConfig.hopperTransfer); // Spigot
--                }
--
--                return false;
--            }
--            int origCount = event.getItem().getAmount(); // Spigot
--            ItemStack itemstack1 = HopperBlockEntity.addItem(iinventory, ihopper, CraftItemStack.asNMSCopy(event.getItem()), null);
--            // CraftBukkit end
--
--            if (itemstack1.isEmpty()) {
--                iinventory.setChanged();
--                return true;
--            }
--
--            itemstack.setCount(j);
--            // Spigot start
--            itemstack.shrink(origCount - itemstack1.getCount());
--            if (j <= world.spigotConfig.hopperAmount) {
--                // Spigot end
--                iinventory.setItem(i, itemstack);
--            }
-+            // Paper start - Perf: Optimize Hoppers
-+            return hopperPull(world, ihopper, iinventory, itemstack, i);
-+        //    int j = itemstack.getCount();
-+        //    // CraftBukkit start - Call event on collection of items from inventories into the hopper
-+        //    ItemStack original = itemstack.copy();
-+        //    CraftItemStack oitemstack = CraftItemStack.asCraftMirror(iinventory.removeItem(i, world.spigotConfig.hopperAmount)); // Spigot
-+
-+        //    Inventory sourceInventory;
-+        //    // Have to special case large chests as they work oddly
-+        //    if (iinventory instanceof CompoundContainer) {
-+        //        sourceInventory = new org.bukkit.craftbukkit.inventory.CraftInventoryDoubleChest((CompoundContainer) iinventory);
-+        //    } else if (iinventory.getOwner() != null) {
-+        //        sourceInventory = iinventory.getOwner().getInventory();
-+        //    } else {
-+        //        sourceInventory = new CraftInventory(iinventory);
-+        //    }
-+
-+        //    InventoryMoveItemEvent event = new InventoryMoveItemEvent(sourceInventory, oitemstack, ihopper.getOwner().getInventory(), false);
-+
-+        //    Bukkit.getServer().getPluginManager().callEvent(event);
-+        //    if (event.isCancelled()) {
-+        //        iinventory.setItem(i, original);
-+
-+        //        if (ihopper instanceof HopperBlockEntity) {
-+        //            ((HopperBlockEntity) ihopper).setCooldown(world.spigotConfig.hopperTransfer); // Spigot
-+        //        }
-+
-+        //        return false;
-+        //    }
-+        //    int origCount = event.getItem().getAmount(); // Spigot
-+        //    ItemStack itemstack1 = HopperBlockEntity.addItem(iinventory, ihopper, CraftItemStack.asNMSCopy(event.getItem()), null);
-+        //    // CraftBukkit end
-+
-+        //    if (itemstack1.isEmpty()) {
-+        //        iinventory.setChanged();
-+        //        return true;
-+        //    }
-+
-+        //    itemstack.setCount(j);
-+        //    // Spigot start
-+        //    itemstack.shrink(origCount - itemstack1.getCount());
-+        //    if (j <= world.spigotConfig.hopperAmount) {
-+        //        // Spigot end
-+        //        iinventory.setItem(i, itemstack);
-+        //    }
-+            // Paper end - Perf: Optimize Hoppers
-         }
- 
-         return false;
-@@ -0,0 +0,0 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
-     public static boolean addItem(Container inventory, ItemEntity itemEntity) {
-         boolean flag = false;
-         // CraftBukkit start
--        InventoryPickupItemEvent event = new InventoryPickupItemEvent(inventory.getOwner().getInventory(), (org.bukkit.entity.Item) itemEntity.getBukkitEntity());
-+        if (InventoryPickupItemEvent.getHandlerList().getRegisteredListeners().length > 0) { // Paper - optimize hoppers
-+        InventoryPickupItemEvent event = new InventoryPickupItemEvent(getInventory(inventory), (org.bukkit.entity.Item) itemEntity.getBukkitEntity()); // Paper - Perf: Optimize Hoppers; use getInventory() to avoid snapshot creation
-         itemEntity.level().getCraftServer().getPluginManager().callEvent(event);
-         if (event.isCancelled()) {
-             return false;
-         }
-         // CraftBukkit end
-+        } // Paper - Perf: Optimize Hoppers
-         ItemStack itemstack = itemEntity.getItem().copy();
-         ItemStack itemstack1 = HopperBlockEntity.addItem((Container) null, inventory, itemstack, (Direction) null);
- 
-@@ -0,0 +0,0 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
-                     stack = stack.split(to.getMaxStackSize());
-                 }
-                 // Spigot end
-+                ignoreTileUpdates = true; // Paper - Perf: Optimize Hoppers
-                 to.setItem(slot, stack);
-+                ignoreTileUpdates = false; // Paper - Perf: Optimize Hoppers
-                 stack = leftover; // Paper - Make hoppers respect inventory max stack size
-                 flag = true;
-             } else if (HopperBlockEntity.canMergeItems(itemstack1, stack)) {
-@@ -0,0 +0,0 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
- 
-     @Nullable
-     public static Container getContainerAt(Level world, BlockPos pos) {
--        return HopperBlockEntity.getContainerAt(world, pos, world.getBlockState(pos), (double) pos.getX() + 0.5D, (double) pos.getY() + 0.5D, (double) pos.getZ() + 0.5D);
-+        return HopperBlockEntity.getContainerAt(world, pos, world.getBlockState(pos), (double) pos.getX() + 0.5D, (double) pos.getY() + 0.5D, (double) pos.getZ() + 0.5D, true);
-     }
- 
-     @Nullable
-     private static Container getContainerAt(Level world, BlockPos pos, BlockState state, double x, double y, double z) {
-+        // Paper start - Perf: Optimize Hoppers
-+        return HopperBlockEntity.getContainerAt(world, pos, state, x, y, z, false);
-+    }
-+    @Nullable
-+    private static Container getContainerAt(Level world, BlockPos pos, BlockState state, double x, double y, double z, boolean optimizeEntities) {
-+        // Paper end - Perf: Optimize Hoppers
-         Container iinventory = HopperBlockEntity.getBlockContainer(world, pos, state);
- 
--        if (iinventory == null) {
-+        if (iinventory == null && (!optimizeEntities || !world.paperConfig().hopper.ignoreOccludingBlocks || !state.getBukkitMaterial().isOccluding())) { // Paper - Perf: Optimize Hoppers
-             iinventory = HopperBlockEntity.getEntityContainer(world, x, y, z);
-         }
- 
-@@ -0,0 +0,0 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
- 
-     @Nullable
-     private static Container getEntityContainer(Level world, double x, double y, double z) {
--        List<Entity> list = world.getEntities((Entity) null, new AABB(x - 0.5D, y - 0.5D, z - 0.5D, x + 0.5D, y + 0.5D, z + 0.5D), EntitySelector.CONTAINER_ENTITY_SELECTOR);
-+        List<Entity> list = world.getEntitiesOfClass((Class) Container.class, new AABB(x - 0.5D, y - 0.5D, z - 0.5D, x + 0.5D, y + 0.5D, z + 0.5D), EntitySelector.CONTAINER_ENTITY_SELECTOR); // Paper - Perf: Optimize hoppers
- 
-         return !list.isEmpty() ? (Container) list.get(world.random.nextInt(list.size())) : null;
-     }
- 
-     private static boolean canMergeItems(ItemStack first, ItemStack second) {
--        return first.getCount() <= first.getMaxStackSize() && ItemStack.isSameItemSameComponents(first, second);
-+        return first.getCount() < first.getMaxStackSize() && ItemStack.isSameItemSameComponents(first, second); // Paper - Perf: Optimize Hoppers; used to return true for full itemstacks?!
-     }
- 
-     @Override
-diff --git a/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
-@@ -0,0 +0,0 @@ public abstract class RandomizableContainerBlockEntity extends BaseContainerBloc
- 
-     @Override
-     public ItemStack getItem(int slot) {
--        this.unpackLootTable(null);
-+        if (slot == 0) this.unpackLootTable(null); // Paper - Perf: Optimize Hoppers
-         return super.getItem(slot);
-     }
- 

patches/server/Optimize-Network-Manager-and-add-advanced-packet-sup.patch

@@ -1,395 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Wed, 6 May 2020 04:53:35 -0400
-Subject: [PATCH] Optimize Network Manager and add advanced packet support
-
-Adds ability for 1 packet to bundle other packets to follow it
-Adds ability for a packet to delay sending more packets until a state is ready.
-
-Removes synchronization from sending packets
-Removes processing packet queue off of main thread
-  - for the few cases where it is allowed, order is not necessary nor
-    should it even be happening concurrently in first place (handshaking/login/status)
-
-Ensures packets sent asynchronously are dispatched on main thread
-
-This helps ensure safety for ProtocolLib as packet listeners
-are commonly accessing world state. This will allow you to schedule
-a packet to be sent async, but itll be dispatched sync for packet
-listeners to process.
-
-This should solve some deadlock risks
-
-Also adds Netty Channel Flush Consolidation to reduce the amount of flushing
-
-Also avoids spamming closed channel exception by rechecking closed state in dispatch
-and then catch exceptions and close if they fire.
-
-Part of this commit was authored by: Spottedleaf, sandtechnology
-
-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<?>> {
-     private static final ProtocolInfo<ServerHandshakePacketListener> INITIAL_PROTOCOL = HandshakeProtocols.SERVERBOUND;
-     private final PacketFlow receiving;
-     private volatile boolean sendLoginDisconnect = true;
--    private final Queue<Consumer<Connection>> pendingActions = Queues.newConcurrentLinkedQueue();
-+    private final Queue<WrappedConsumer> pendingActions = Queues.newConcurrentLinkedQueue(); // Paper
-     public Channel channel;
-     public SocketAddress address;
-     // Spigot Start
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
-     public java.net.InetSocketAddress virtualHost;
-     private static boolean enableExplicitFlush = Boolean.getBoolean("paper.explicit-flush"); // Paper - Disable explicit network manager flushing
-     // Paper end
-+    // Paper start - Optimize network
-+    public boolean isPending = true;
-+    public boolean queueImmunity;
-+    // Paper end - Optimize network
- 
-     // Paper start - add utility methods
-     public final net.minecraft.server.level.ServerPlayer getPlayer() {
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
-     }
- 
-     public void send(Packet<?> packet, @Nullable PacketSendListener callbacks, boolean flush) {
--        if (this.isConnected()) {
--            this.flushQueue();
-+        // Paper start - Optimize network: Handle oversized packets better
-+        final boolean connected = this.isConnected();
-+        if (!connected && !this.preparing) {
-+            return;
-+        }
-+
-+        packet.onPacketDispatch(this.getPlayer());
-+        if (connected && (InnerUtil.canSendImmediate(this, packet)
-+            || (io.papermc.paper.util.MCUtil.isMainThread() && packet.isReady() && this.pendingActions.isEmpty()
-+            && (packet.getExtraPackets() == null || packet.getExtraPackets().isEmpty())))) {
-             this.sendPacket(packet, callbacks, flush);
-         } else {
--            this.pendingActions.add((networkmanager) -> {
--                networkmanager.sendPacket(packet, callbacks, flush);
--            });
--        }
-+            // Write the packets to the queue, then flush - antixray hooks there already
-+            final java.util.List<Packet<?>> extraPackets = InnerUtil.buildExtraPackets(packet);
-+            final boolean hasExtraPackets = extraPackets != null && !extraPackets.isEmpty();
-+            if (!hasExtraPackets) {
-+                this.pendingActions.add(new PacketSendAction(packet, callbacks, flush));
-+            } else {
-+                final java.util.List<PacketSendAction> actions = new java.util.ArrayList<>(1 + extraPackets.size());
-+                actions.add(new PacketSendAction(packet, null, false)); // Delay the future listener until the end of the extra packets
-+
-+                for (int i = 0, len = extraPackets.size(); i < len;) {
-+                    final Packet<?> extraPacket = extraPackets.get(i);
-+                    final boolean end = ++i == len;
-+                    actions.add(new PacketSendAction(extraPacket, end ? callbacks : null, end)); // Append listener to the end
-+                }
-+
-+                this.pendingActions.addAll(actions);
-+            }
- 
-+            this.flushQueue();
-+            // Paper end - Optimize network
-+        }
-     }
- 
-     public void runOnceConnected(Consumer<Connection> task) {
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
-             this.flushQueue();
-             task.accept(this);
-         } else {
--            this.pendingActions.add(task);
-+            this.pendingActions.add(new WrappedConsumer(task)); // Paper - Optimize network
-         }
- 
-     }
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
-     }
- 
-     private void doSendPacket(Packet<?> packet, @Nullable PacketSendListener callbacks, boolean flush) {
-+        // Paper start - Optimize network
-+        final net.minecraft.server.level.ServerPlayer player = this.getPlayer();
-+        if (!this.isConnected()) {
-+            packet.onPacketDispatchFinish(player, null);
-+            return;
-+        }
-+        try {
-+        // Paper end - Optimize network
-         ChannelFuture channelfuture = flush ? this.channel.writeAndFlush(packet) : this.channel.write(packet);
- 
-         if (callbacks != null) {
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
-             });
-         }
- 
-+        // Paper start - Optimize network
-+        if (packet.hasFinishListener()) {
-+            channelfuture.addListener((ChannelFutureListener) channelFuture -> packet.onPacketDispatchFinish(player, channelFuture));
-+        }
-         channelfuture.addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE);
-+        } catch (final Exception e) {
-+            LOGGER.error("NetworkException: {}", player, e);
-+            this.disconnect(Component.translatable("disconnect.genericReason", "Internal Exception: " + e.getMessage()));
-+            packet.onPacketDispatchFinish(player, null);
-+        }
-+        // Paper end - Optimize network
-     }
- 
-     public void flushChannel() {
-         if (this.isConnected()) {
-             this.flush();
-         } else {
--            this.pendingActions.add(Connection::flush);
-+            this.pendingActions.add(new WrappedConsumer(Connection::flush)); // Paper - Optimize network
-         }
- 
-     }
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
- 
-     }
- 
--    private void flushQueue() {
--        if (this.channel != null && this.channel.isOpen()) {
--            Queue queue = this.pendingActions;
--
-+    // Paper start - Optimize network: Rewrite this to be safer if ran off main thread
-+    private boolean flushQueue() {
-+        if (!this.isConnected()) {
-+            return true;
-+        }
-+        if (io.papermc.paper.util.MCUtil.isMainThread()) {
-+            return this.processQueue();
-+        } else if (this.isPending) {
-+            // Should only happen during login/status stages
-             synchronized (this.pendingActions) {
--                Consumer consumer;
-+                return this.processQueue();
-+            }
-+        }
-+        return false;
-+    }
-+
-+    private boolean processQueue() {
-+        if (this.pendingActions.isEmpty()) {
-+            return true;
-+        }
- 
--                while ((consumer = (Consumer) this.pendingActions.poll()) != null) {
--                    consumer.accept(this);
-+        // If we are on main, we are safe here in that nothing else should be processing queue off main anymore
-+        // But if we are not on main due to login/status, the parent is synchronized on packetQueue
-+        final java.util.Iterator<WrappedConsumer> iterator = this.pendingActions.iterator();
-+        while (iterator.hasNext()) {
-+            final WrappedConsumer queued = iterator.next(); // poll -> peek
-+
-+            // Fix NPE (Spigot bug caused by handleDisconnection())
-+            if (queued == null) {
-+                return true;
-+            }
-+
-+            if (queued.isConsumed()) {
-+                continue;
-+            }
-+
-+            if (queued instanceof PacketSendAction packetSendAction) {
-+                final Packet<?> packet = packetSendAction.packet;
-+                if (!packet.isReady()) {
-+                    return false;
-                 }
-+            }
- 
-+            iterator.remove();
-+            if (queued.tryMarkConsumed()) {
-+                queued.accept(this);
-             }
-         }
-+        return true;
-     }
-+    // Paper end - Optimize network
- 
-     private static final int MAX_PER_TICK = io.papermc.paper.configuration.GlobalConfiguration.get().misc.maxJoinsPerTick; // Paper - Buffer joins to world
-     private static int joinAttemptsThisTick; // Paper - Buffer joins to world
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
-     public void disconnect(DisconnectionDetails disconnectionInfo) {
-         // Spigot Start
-         this.preparing = false;
-+        this.clearPacketQueue(); // Paper - Optimize network
-         // Spigot End
-         if (this.channel == null) {
-             this.delayedDisconnect = disconnectionInfo;
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
-     public void handleDisconnection() {
-         if (this.channel != null && !this.channel.isOpen()) {
-             if (this.disconnectionHandled) {
--                Connection.LOGGER.warn("handleDisconnection() called twice");
-+                // Connection.LOGGER.warn("handleDisconnection() called twice"); // Paper - Don't log useless message
-             } else {
-                 this.disconnectionHandled = true;
-                 PacketListener packetlistener = this.getPacketListener();
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
- 
-                     packetlistener1.onDisconnect(disconnectiondetails);
-                 }
--                this.pendingActions.clear(); // Free up packet queue.
-+                this.clearPacketQueue(); // Paper - Optimize network
-                 // Paper start - Add PlayerConnectionCloseEvent
-                 final PacketListener packetListener = this.getPacketListener();
-                 if (packetListener instanceof net.minecraft.server.network.ServerCommonPacketListenerImpl commonPacketListener) {
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
-     public void setBandwidthLogger(LocalSampleLogger log) {
-         this.bandwidthDebugMonitor = new BandwidthDebugMonitor(log);
-     }
-+
-+    // Paper start - Optimize network
-+    public void clearPacketQueue() {
-+        final net.minecraft.server.level.ServerPlayer player = getPlayer();
-+        for (final Consumer<Connection> queuedAction : this.pendingActions) {
-+            if (queuedAction instanceof PacketSendAction packetSendAction) {
-+                final Packet<?> packet = packetSendAction.packet;
-+                if (packet.hasFinishListener()) {
-+                    packet.onPacketDispatchFinish(player, null);
-+                }
-+            }
-+        }
-+        this.pendingActions.clear();
-+    }
-+
-+    private static class InnerUtil { // Attempt to hide these methods from ProtocolLib, so it doesn't accidently pick them up.
-+
-+        @Nullable
-+        private static java.util.List<Packet<?>> buildExtraPackets(final Packet<?> packet) {
-+            final java.util.List<Packet<?>> extra = packet.getExtraPackets();
-+            if (extra == null || extra.isEmpty()) {
-+                return null;
-+            }
-+
-+            final java.util.List<Packet<?>> ret = new java.util.ArrayList<>(1 + extra.size());
-+            buildExtraPackets0(extra, ret);
-+            return ret;
-+        }
-+
-+        private static void buildExtraPackets0(final java.util.List<Packet<?>> extraPackets, final java.util.List<Packet<?>> into) {
-+            for (final Packet<?> extra : extraPackets) {
-+                into.add(extra);
-+                final java.util.List<Packet<?>> extraExtra = extra.getExtraPackets();
-+                if (extraExtra != null && !extraExtra.isEmpty()) {
-+                    buildExtraPackets0(extraExtra, into);
-+                }
-+            }
-+        }
-+
-+        private static boolean canSendImmediate(final Connection networkManager, final net.minecraft.network.protocol.Packet<?> packet) {
-+            return networkManager.isPending || networkManager.packetListener.protocol() != ConnectionProtocol.PLAY ||
-+                packet instanceof net.minecraft.network.protocol.common.ClientboundKeepAlivePacket ||
-+                packet instanceof net.minecraft.network.protocol.game.ClientboundPlayerChatPacket ||
-+                packet instanceof net.minecraft.network.protocol.game.ClientboundSystemChatPacket ||
-+                packet instanceof net.minecraft.network.protocol.game.ClientboundCommandSuggestionsPacket ||
-+                packet instanceof net.minecraft.network.protocol.game.ClientboundSetTitleTextPacket ||
-+                packet instanceof net.minecraft.network.protocol.game.ClientboundSetSubtitleTextPacket ||
-+                packet instanceof net.minecraft.network.protocol.game.ClientboundSetActionBarTextPacket ||
-+                packet instanceof net.minecraft.network.protocol.game.ClientboundSetTitlesAnimationPacket ||
-+                packet instanceof net.minecraft.network.protocol.game.ClientboundClearTitlesPacket ||
-+                packet instanceof net.minecraft.network.protocol.game.ClientboundSoundPacket ||
-+                packet instanceof net.minecraft.network.protocol.game.ClientboundSoundEntityPacket ||
-+                packet instanceof net.minecraft.network.protocol.game.ClientboundStopSoundPacket ||
-+                packet instanceof net.minecraft.network.protocol.game.ClientboundLevelParticlesPacket ||
-+                packet instanceof net.minecraft.network.protocol.game.ClientboundBossEventPacket;
-+        }
-+    }
-+
-+    private static class WrappedConsumer implements Consumer<Connection> {
-+        private final Consumer<Connection> delegate;
-+        private final java.util.concurrent.atomic.AtomicBoolean consumed = new java.util.concurrent.atomic.AtomicBoolean(false);
-+
-+        private WrappedConsumer(final Consumer<Connection> delegate) {
-+            this.delegate = delegate;
-+        }
-+
-+        @Override
-+        public void accept(final Connection connection) {
-+            this.delegate.accept(connection);
-+        }
-+
-+        public boolean tryMarkConsumed() {
-+            return consumed.compareAndSet(false, true);
-+        }
-+
-+        public boolean isConsumed() {
-+            return consumed.get();
-+        }
-+    }
-+
-+    private static final class PacketSendAction extends WrappedConsumer {
-+        private final Packet<?> packet;
-+
-+        private PacketSendAction(final Packet<?> packet, @Nullable final PacketSendListener packetSendListener, final boolean flush) {
-+            super(connection -> connection.sendPacket(packet, packetSendListener, flush));
-+            this.packet = packet;
-+        }
-+    }
-+    // Paper end - Optimize network
- }
-diff --git a/src/main/java/net/minecraft/network/protocol/Packet.java b/src/main/java/net/minecraft/network/protocol/Packet.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/protocol/Packet.java
-+++ b/src/main/java/net/minecraft/network/protocol/Packet.java
-@@ -0,0 +0,0 @@ public interface Packet<T extends PacketListener> {
-     static <B extends ByteBuf, T extends Packet<?>> StreamCodec<B, T> codec(StreamMemberEncoder<B, T> encoder, StreamDecoder<B, T> decoder) {
-         return StreamCodec.ofMember(encoder, decoder);
-     }
-+
-+    // Paper start
-+    /**
-+     * @param player Null if not at PLAY stage yet
-+     */
-+    default void onPacketDispatch(@org.jetbrains.annotations.Nullable net.minecraft.server.level.ServerPlayer player) {
-+    }
-+
-+    /**
-+     * @param player Null if not at PLAY stage yet
-+     * @param future Can be null if packet was cancelled
-+     */
-+    default void onPacketDispatchFinish(@org.jetbrains.annotations.Nullable net.minecraft.server.level.ServerPlayer player, @org.jetbrains.annotations.Nullable io.netty.channel.ChannelFuture future) {}
-+
-+    default boolean hasFinishListener() {
-+        return false;
-+    }
-+
-+    default boolean isReady() {
-+        return true;
-+    }
-+
-+    @org.jetbrains.annotations.Nullable
-+    default java.util.List<Packet<?>> getExtraPackets() {
-+        return null;
-+    }
-+    // Paper end
- }
-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 {
-     final List<Connection> connections = Collections.synchronizedList(Lists.newArrayList());
-     // Paper start - prevent blocking on adding a new connection while the server is ticking
-     private final java.util.Queue<Connection> pending = new java.util.concurrent.ConcurrentLinkedQueue<>();
-+    private static final boolean disableFlushConsolidation = Boolean.getBoolean("Paper.disableFlushConsolidate"); // Paper - Optimize network
-     private final void addPending() {
-         Connection connection;
-         while ((connection = pending.poll()) != null) {
-             connections.add(connection);
-+            connection.isPending = false; // Paper - Optimize network
-         }
-     }
-     // Paper end - prevent blocking on adding a new connection while the server is ticking
-@@ -0,0 +0,0 @@ public class ServerConnectionListener {
-                         ;
-                     }
- 
-+                    if (!disableFlushConsolidation) channel.pipeline().addFirst(new io.netty.handler.flush.FlushConsolidationHandler()); // Paper - Optimize network
-                     ChannelPipeline channelpipeline = channel.pipeline().addLast("timeout", new ReadTimeoutHandler(30));
- 
-                     if (ServerConnectionListener.this.server.repliesToStatus()) {

patches/server/Optimize-Pathfinder-Remove-Streams-Optimized-collect.patch

@@ -1,134 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Tue, 4 Aug 2020 22:24:15 +0200
-Subject: [PATCH] Optimize Pathfinder - Remove Streams / Optimized collections
-
-I utilized the IDE to convert streams to non streams code, so shouldn't
-be any risk of behavior change. Only did minor optimization of the
-generated code set to remove unnecessary things.
-
-I expect us to just drop this patch on next major update and re-apply
-it with the IDE again and re-apply the collections optimization.
-
-Optimize collection by creating a list instead of a set of the key and value.
-
-This lets us get faster foreach iteration, as well as avoids map lookups on
-the values when needed.
-
-diff --git a/src/main/java/net/minecraft/world/level/pathfinder/PathFinder.java b/src/main/java/net/minecraft/world/level/pathfinder/PathFinder.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/pathfinder/PathFinder.java
-+++ b/src/main/java/net/minecraft/world/level/pathfinder/PathFinder.java
-@@ -0,0 +0,0 @@ public class PathFinder {
-         if (node == null) {
-             return null;
-         } else {
--            Map<Target, BlockPos> map = positions.stream()
--                .collect(Collectors.toMap(pos -> this.nodeEvaluator.getTarget((double)pos.getX(), (double)pos.getY(), (double)pos.getZ()), Function.identity()));
-+            // Paper start - Perf: remove streams and optimize collection
-+            List<Map.Entry<Target, BlockPos>> map = Lists.newArrayList();
-+            for (final BlockPos pos : positions) {
-+                map.add(new java.util.AbstractMap.SimpleEntry<>(this.nodeEvaluator.getTarget(pos.getX(), pos.getY(), pos.getZ()), pos));
-+            }
-+            // Paper end - Perf: remove streams and optimize collection
-             Path path = this.findPath(node, map, followRange, distance, rangeMultiplier);
-             this.nodeEvaluator.done();
-             return path;
-@@ -0,0 +0,0 @@ public class PathFinder {
-     }
- 
-     @Nullable
--    private Path findPath(Node startNode, Map<Target, BlockPos> positions, float followRange, int distance, float rangeMultiplier) {
-+    // Paper start - Perf: remove streams and optimize collection
-+    private Path findPath(Node startNode, List<Map.Entry<Target, BlockPos>> positions, float followRange, int distance, float rangeMultiplier) {
-         ProfilerFiller profilerFiller = Profiler.get();
-         profilerFiller.push("find_path");
-         profilerFiller.markForCharting(MetricCategory.PATH_FINDING);
--        Set<Target> set = positions.keySet();
-+        // Set<Target> set = positions.keySet();
-         startNode.g = 0.0F;
--        startNode.h = this.getBestH(startNode, set);
-+        startNode.h = this.getBestH(startNode, positions); // Paper - optimize collection
-         startNode.f = startNode.h;
-         this.openSet.clear();
-         this.openSet.insert(startNode);
--        Set<Node> set2 = ImmutableSet.of();
-+        // Set<Node> set2 = ImmutableSet.of(); // Paper - unused - diff on change
-         int i = 0;
--        Set<Target> set3 = Sets.newHashSetWithExpectedSize(set.size());
-+        List<Map.Entry<Target, BlockPos>> entryList = Lists.newArrayListWithExpectedSize(positions.size()); // Paper - optimize collection
-         int j = (int)((float)this.maxVisitedNodes * rangeMultiplier);
- 
-         while (!this.openSet.isEmpty()) {
-@@ -0,0 +0,0 @@ public class PathFinder {
-             Node node = this.openSet.pop();
-             node.closed = true;
- 
--            for (Target target : set) {
-+            // Paper start - optimize collection
-+            for (int i1 = 0; i1 < positions.size(); i1++) {
-+                final Map.Entry<Target, BlockPos> entry = positions.get(i1);
-+                Target target = entry.getKey();
-                 if (node.distanceManhattan(target) <= (float)distance) {
-                     target.setReached();
--                    set3.add(target);
-+                    entryList.add(entry);
-+                    // Paper end - Perf: remove streams and optimize collection
-                 }
-             }
- 
--            if (!set3.isEmpty()) {
-+            if (!entryList.isEmpty()) { // Paper - Perf: remove streams and optimize collection; rename
-                 break;
-             }
- 
-@@ -0,0 +0,0 @@ public class PathFinder {
-                     if (node2.walkedDistance < followRange && (!node2.inOpenSet() || g < node2.g)) {
-                         node2.cameFrom = node;
-                         node2.g = g;
--                        node2.h = this.getBestH(node2, set) * 1.5F;
-+                        node2.h = this.getBestH(node2, positions) * 1.5F; // Paper - Perf: remove streams and optimize collection
-                         if (node2.inOpenSet()) {
-                             this.openSet.changeCost(node2, node2.g + node2.h);
-                         } else {
-@@ -0,0 +0,0 @@ public class PathFinder {
-             }
-         }
- 
--        Optional<Path> optional = !set3.isEmpty()
--            ? set3.stream().map(node -> this.reconstructPath(node.getBestNode(), positions.get(node), true)).min(Comparator.comparingInt(Path::getNodeCount))
--            : set.stream()
--                .map(targetx -> this.reconstructPath(targetx.getBestNode(), positions.get(targetx), false))
--                .min(Comparator.comparingDouble(Path::getDistToTarget).thenComparingInt(Path::getNodeCount));
-+        // Paper start - Perf: remove streams and optimize collection
-+        Path best = null;
-+        boolean entryListIsEmpty = entryList.isEmpty();
-+        Comparator<Path> comparator = entryListIsEmpty ? Comparator.comparingInt(Path::getNodeCount)
-+            : Comparator.comparingDouble(Path::getDistToTarget).thenComparingInt(Path::getNodeCount);
-+        for (Map.Entry<Target, BlockPos> entry : entryListIsEmpty ? positions : entryList) {
-+            Path path = this.reconstructPath(entry.getKey().getBestNode(), entry.getValue(), !entryListIsEmpty);
-+            if (best == null || comparator.compare(path, best) < 0)
-+                best = path;
-+        }
-         profilerFiller.pop();
--        return optional.isEmpty() ? null : optional.get();
-+        return best;
-+        // Paper end - Perf: remove streams and optimize collection
-     }
- 
-     protected float distance(Node a, Node b) {
-         return a.distanceTo(b);
-     }
- 
--    private float getBestH(Node node, Set<Target> targets) {
-+    private float getBestH(Node node, List<Map.Entry<Target, BlockPos>> targets) { // Paper - Perf: remove streams and optimize collection; Set<Target> -> List<Map.Entry<Target, BlockPos>>
-         float f = Float.MAX_VALUE;
- 
--        for (Target target : targets) {
-+        // Paper start - Perf: remove streams and optimize collection
-+        for (int i = 0, targetsSize = targets.size(); i < targetsSize; i++) {
-+            final Target target = targets.get(i).getKey();
-+            // Paper end - Perf: remove streams and optimize collection
-             float g = node.distanceTo(target);
-             target.updateBest(g, node);
-             f = Math.min(g, f);

patches/server/Optimize-Voxel-Shape-Merging.patch

@@ -1,123 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Sun, 3 May 2020 22:35:09 -0400
-Subject: [PATCH] Optimize Voxel Shape Merging
-
-This method shows up as super hot in profiler, and also a high "self" time.
-
-Upon analyzing, it appears most usages of this method fall down to the final
-else statement of the nasty ternary.
-
-Upon even further analyzation, it appears then the majority of those have a
-consistent list 1.... One with Infinity head and Tails.
-
-First optimization is to detect these infinite states and immediately return that
-VoxelShapeMergerList so we can avoid testing the rest for most cases.
-
-Break the method into 2 to help the JVM promote inlining of this fast path.
-
-Then it was also noticed that VoxelShapeMergerList constructor is also a hotspot
-with a high self time...
-
-Well, knowing that in most cases our list 1 is actualy the same value, it allows
-us to know that with an infinite list1, the result on the merger is essentially
-list2 as the final values.
-
-This let us analyze the 2 potential states (Infinite with 2 sources or 4 sources)
-and compute a deterministic result for the MergerList values.
-
-Additionally, this lets us avoid even allocating new objects for this too, further
-reducing memory usage.
-
-diff --git a/src/main/java/net/minecraft/world/phys/shapes/IndirectMerger.java b/src/main/java/net/minecraft/world/phys/shapes/IndirectMerger.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/phys/shapes/IndirectMerger.java
-+++ b/src/main/java/net/minecraft/world/phys/shapes/IndirectMerger.java
-@@ -0,0 +0,0 @@ public class IndirectMerger implements IndexMerger {
-     private final int[] firstIndices;
-     private final int[] secondIndices;
-     private final int resultLength;
-+    // Paper start
-+    private static final int[] INFINITE_B_1 = new int[]{1, 1};
-+    private static final int[] INFINITE_B_0 = new int[]{0, 0};
-+    private static final int[] INFINITE_C = new int[]{0, 1};
-+    // Paper end
- 
-     public IndirectMerger(DoubleList first, DoubleList second, boolean includeFirstOnly, boolean includeSecondOnly) {
-         double d = Double.NaN;
-         int i = first.size();
-         int j = second.size();
-         int k = i + j;
-+        // Paper start - optimize common path of infinity doublelist
-+        int size = first.size();
-+        double tail = first.getDouble(size - 1);
-+        double head = first.getDouble(0);
-+        if (head == Double.NEGATIVE_INFINITY && tail == Double.POSITIVE_INFINITY && !includeFirstOnly && !includeSecondOnly && (size == 2 || size == 4)) {
-+            this.result = second.toDoubleArray();
-+            this.resultLength = second.size();
-+            if (size == 2) {
-+                this.firstIndices = INFINITE_B_0;
-+            } else {
-+                this.firstIndices = INFINITE_B_1;
-+            }
-+            this.secondIndices = INFINITE_C;
-+            return;
-+        }
-+        // Paper end
-         this.result = new double[k];
-         this.firstIndices = new int[k];
-         this.secondIndices = new int[k];
-diff --git a/src/main/java/net/minecraft/world/phys/shapes/Shapes.java b/src/main/java/net/minecraft/world/phys/shapes/Shapes.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/phys/shapes/Shapes.java
-+++ b/src/main/java/net/minecraft/world/phys/shapes/Shapes.java
-@@ -0,0 +0,0 @@ public final class Shapes {
-     }
- 
-     @VisibleForTesting
--    protected static IndexMerger createIndexMerger(int size, DoubleList first, DoubleList second, boolean includeFirst, boolean includeSecond) {
-+    private static IndexMerger createIndexMerger(int size, DoubleList first, DoubleList second, boolean includeFirst, boolean includeSecond) { // Paper - private
-+        // Paper start - fast track the most common scenario
-+        // doublelist is usually a DoubleArrayList with Infinite head/tails that falls to the final else clause
-+        // This is actually the most common path, so jump to it straight away
-+        if (first.getDouble(0) == Double.NEGATIVE_INFINITY && first.getDouble(first.size() - 1) == Double.POSITIVE_INFINITY) {
-+            return new IndirectMerger(first, second, includeFirst, includeSecond);
-+        }
-+        // Split out rest to hopefully inline the above
-+        return lessCommonMerge(size, first, second, includeFirst, includeSecond);
-+    }
-+
-+    private static IndexMerger lessCommonMerge(int size, DoubleList first, DoubleList second, boolean includeFirst, boolean includeSecond) {
-         int i = first.size() - 1;
-         int j = second.size() - 1;
-+        // Paper note - Rewrite below as optimized order if instead of nasty ternary
-         if (first instanceof CubePointRange && second instanceof CubePointRange) {
-             long l = lcm(i, j);
-             if ((long)size * l <= 256L) {
-@@ -0,0 +0,0 @@ public final class Shapes {
-             }
-         }
- 
--        if (first.getDouble(i) < second.getDouble(0) - 1.0E-7) {
-+        // Paper start - Identical happens more often than Disjoint
-+        if (i == j && Objects.equals(first, second)) {
-+            if (first instanceof IdenticalMerger) {
-+                return (IndexMerger) first;
-+            } else if (second instanceof IdenticalMerger) {
-+                return (IndexMerger) second;
-+            }
-+            return new IdenticalMerger(first);
-+        } else if (first.getDouble(i) < second.getDouble(0) - 1.0E-7) {
-             return new NonOverlappingMerger(first, second, false);
-         } else if (second.getDouble(j) < first.getDouble(0) - 1.0E-7) {
-             return new NonOverlappingMerger(second, first, true);
-         } else {
--            return (IndexMerger)(i == j && Objects.equals(first, second)
--                ? new IdenticalMerger(first)
--                : new IndirectMerger(first, second, includeFirst, includeSecond));
-+            return new IndirectMerger(first, second, includeFirst, includeSecond);
-         }
-+        // Paper end
-     }
- 
-     public interface DoubleLineConsumer {

patches/server/Optimize-isInWorldBounds-and-getBlockState-for-inlin.patch

@@ -1,99 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Aikar <aikar@aikar.co>
-Date: Thu, 3 Mar 2016 02:07:55 -0600
-Subject: [PATCH] Optimize isInWorldBounds and getBlockState for inlining
-
-Hot methods, so reduce # of instructions for the method.
-
-Move is valid location test to the BlockPosition class so that it can access local variables.
-
-Replace all calls to the new place to the unnecessary forward.
-
-Optimize getType and getBlockData to manually inline and optimize the calls
-
-diff --git a/src/main/java/net/minecraft/core/Vec3i.java b/src/main/java/net/minecraft/core/Vec3i.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/core/Vec3i.java
-+++ b/src/main/java/net/minecraft/core/Vec3i.java
-@@ -0,0 +0,0 @@ public class Vec3i implements Comparable<Vec3i> {
-         );
-     }
- 
-+    // Paper start
-+    public final boolean isInsideBuildHeightAndWorldBoundsHorizontal(net.minecraft.world.level.LevelHeightAccessor levelHeightAccessor) {
-+        return getX() >= -30000000 && getZ() >= -30000000 && getX() < 30000000 && getZ() < 30000000 && !levelHeightAccessor.isOutsideBuildHeight(getY());
-+    }
-+    // Paper end
-+
-     public Vec3i(int x, int y, int z) {
-         this.x = x;
-         this.y = y;
-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 {
-     // Paper end
- 
-     public boolean isInWorldBounds(BlockPos pos) {
--        return !this.isOutsideBuildHeight(pos) && Level.isInWorldBoundsHorizontal(pos);
-+        return pos.isInsideBuildHeightAndWorldBoundsHorizontal(this); // Paper - use better/optimized check
-     }
- 
-     public static boolean isInSpawnableBounds(BlockPos pos) {
-diff --git a/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java b/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/ChunkAccess.java
-@@ -0,0 +0,0 @@ public abstract class ChunkAccess implements BiomeManager.NoiseBiomeSource, Ligh
-         return GameEventListenerRegistry.NOOP;
-     }
- 
-+    public abstract BlockState getBlockState(final int x, final int y, final int z); // Paper
-     @Nullable
-     public abstract BlockState setBlockState(BlockPos pos, BlockState state, boolean moved);
- 
-diff --git a/src/main/java/net/minecraft/world/level/chunk/ImposterProtoChunk.java b/src/main/java/net/minecraft/world/level/chunk/ImposterProtoChunk.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/chunk/ImposterProtoChunk.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/ImposterProtoChunk.java
-@@ -0,0 +0,0 @@ public class ImposterProtoChunk extends ProtoChunk {
-     public BlockState getBlockState(BlockPos pos) {
-         return this.wrapped.getBlockState(pos);
-     }
-+    // Paper start
-+    @Override
-+    public final BlockState getBlockState(final int x, final int y, final int z) {
-+        return this.wrapped.getBlockStateFinal(x, y, z);
-+    }
-+    // Paper end
- 
-     @Override
-     public FluidState getFluidState(BlockPos pos) {
-diff --git a/src/main/java/net/minecraft/world/level/chunk/ProtoChunk.java b/src/main/java/net/minecraft/world/level/chunk/ProtoChunk.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/chunk/ProtoChunk.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/ProtoChunk.java
-@@ -0,0 +0,0 @@ public class ProtoChunk extends ChunkAccess {
- 
-     @Override
-     public BlockState getBlockState(BlockPos pos) {
--        int i = pos.getY();
--        if (this.isOutsideBuildHeight(i)) {
-+        // Paper start
-+        return getBlockState(pos.getX(), pos.getY(), pos.getZ());
-+    }
-+    public BlockState getBlockState(final int x, final int y, final int z) {
-+        if (this.isOutsideBuildHeight(y)) {
-             return Blocks.VOID_AIR.defaultBlockState();
-         } else {
--            LevelChunkSection levelChunkSection = this.getSection(this.getSectionIndex(i));
--            return levelChunkSection.hasOnlyAir() ? Blocks.AIR.defaultBlockState() : levelChunkSection.getBlockState(pos.getX() & 15, i & 15, pos.getZ() & 15);
-+            LevelChunkSection levelChunkSection = this.getSections()[this.getSectionIndex(y)];
-+            return levelChunkSection.hasOnlyAir() ? Blocks.AIR.defaultBlockState() : levelChunkSection.getBlockState(x & 15, y & 15, z & 15);
-         }
-     }
-+    // Paper end
- 
-     @Override
-     public FluidState getFluidState(BlockPos pos) {

patches/server/Optional-per-player-mob-spawns.patch

@@ -1,232 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: kickash32 <kickash32@gmail.com>
-Date: Mon, 19 Aug 2019 01:27:58 +0500
-Subject: [PATCH] Optional per player mob spawns
-
-
-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
-     }
- 
-     // Paper start
-+    // Paper start - Optional per player mob spawns
-+    public void updatePlayerMobTypeMap(final Entity entity) {
-+        if (!this.level.paperConfig().entities.spawning.perPlayerMobSpawns) {
-+            return;
-+        }
-+        final int index = entity.getType().getCategory().ordinal();
-+
-+        final ca.spottedleaf.moonrise.common.list.ReferenceList<ServerPlayer> inRange =
-+            this.level.moonrise$getNearbyPlayers().getPlayers(entity.chunkPosition(), ca.spottedleaf.moonrise.common.misc.NearbyPlayers.NearbyMapType.TICK_VIEW_DISTANCE);
-+        if (inRange == null) {
-+            return;
-+        }
-+        final ServerPlayer[] backingSet = inRange.getRawDataUnchecked();
-+        for (int i = 0, len = inRange.size(); i < len; i++) {
-+            ++(backingSet[i].mobCounts[index]);
-+        }
-+    }
-     public int getMobCountNear(final ServerPlayer player, final net.minecraft.world.entity.MobCategory mobCategory) {
--        return -1;
-+        return player.mobCounts[mobCategory.ordinal()];
-+        // Paper end - Optional per player mob spawns
-     }
-     // Paper end
- 
-diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-+++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource implements ca.spottedleaf.moon
-                     gameprofilerfiller.popPush("shuffleChunks");
-                     // Paper start - chunk tick iteration optimisation
-                     this.shuffleRandom.setSeed(this.level.random.nextLong());
--                    Util.shuffle(list, this.shuffleRandom);
-+                    if (!this.level.paperConfig().entities.spawning.perPlayerMobSpawns) Util.shuffle(list, this.shuffleRandom); // Paper - Optional per player mob spawns; do not need this when per-player is enabled
-                     // Paper end - chunk tick iteration optimisation
-                     this.tickChunks(gameprofilerfiller, j, list);
-                     gameprofilerfiller.pop();
-@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource implements ca.spottedleaf.moon
-     private void tickChunks(ProfilerFiller profiler, long timeDelta, List<LevelChunk> chunks) {
-         profiler.popPush("naturalSpawnCount");
-         int j = this.distanceManager.getNaturalSpawnChunkCount();
--        NaturalSpawner.SpawnState spawnercreature_d = NaturalSpawner.createState(j, this.level.getAllEntities(), this::getFullChunk, new LocalMobCapCalculator(this.chunkMap));
-+        // Paper start - Optional per player mob spawns
-+        final int naturalSpawnChunkCount = j;
-+        NaturalSpawner.SpawnState spawnercreature_d; // moved down
-+        if ((this.spawnFriendlies || this.spawnEnemies) && this.level.paperConfig().entities.spawning.perPlayerMobSpawns) { // don't count mobs when animals and monsters are disabled
-+            // re-set mob counts
-+            for (ServerPlayer player : this.level.players) {
-+                Arrays.fill(player.mobCounts, 0);
-+            }
-+            spawnercreature_d = NaturalSpawner.createState(naturalSpawnChunkCount, this.level.getAllEntities(), this::getFullChunk, null, true);
-+        } else {
-+            spawnercreature_d = NaturalSpawner.createState(naturalSpawnChunkCount, this.level.getAllEntities(), this::getFullChunk, !this.level.paperConfig().entities.spawning.perPlayerMobSpawns ? new LocalMobCapCalculator(this.chunkMap) : null, false);
-+        }
-+        // Paper end - Optional per player mob spawns
- 
-         this.lastSpawnState = spawnercreature_d;
-         profiler.popPush("spawnAndTick");
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -0,0 +0,0 @@ public class ServerPlayer extends net.minecraft.world.entity.player.Player imple
-     public boolean queueHealthUpdatePacket;
-     public net.minecraft.network.protocol.game.ClientboundSetHealthPacket queuedHealthUpdatePacket;
-     // Paper end - cancellable death event
-+    // Paper start - Optional per player mob spawns
-+    public static final int MOBCATEGORY_TOTAL_ENUMS = net.minecraft.world.entity.MobCategory.values().length;
-+    public final int[] mobCounts = new int[MOBCATEGORY_TOTAL_ENUMS]; // Paper
-+    // Paper end - Optional per player mob spawns
- 
-     // CraftBukkit start
-     public CraftPlayer.TransferCookieConnection transferCookieConnection;
-diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java
-+++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
-@@ -0,0 +0,0 @@ public final class NaturalSpawner {
-     private NaturalSpawner() {}
- 
-     public static NaturalSpawner.SpawnState createState(int spawningChunkCount, Iterable<Entity> entities, NaturalSpawner.ChunkGetter chunkSource, LocalMobCapCalculator densityCapper) {
-+        // Paper start - Optional per player mob spawns
-+        return createState(spawningChunkCount, entities, chunkSource, densityCapper, false);
-+    }
-+
-+    public static NaturalSpawner.SpawnState createState(int spawningChunkCount, Iterable<Entity> entities, NaturalSpawner.ChunkGetter chunkSource, LocalMobCapCalculator densityCapper, boolean countMobs) {
-+        // Paper end - Optional per player mob spawns
-         PotentialCalculator spawnercreatureprobabilities = new PotentialCalculator();
-         Object2IntOpenHashMap<MobCategory> object2intopenhashmap = new Object2IntOpenHashMap();
-         Iterator iterator = entities.iterator();
-@@ -0,0 +0,0 @@ public final class NaturalSpawner {
-                         spawnercreatureprobabilities.addCharge(entity.blockPosition(), biomesettingsmobs_b.charge());
-                     }
- 
--                    if (entity instanceof Mob) {
-+                    if (densityCapper != null && entity instanceof Mob) { // Paper - Optional per player mob spawns
-                         densityCapper.addMob(chunk.getPos(), enumcreaturetype);
-                     }
- 
-                     object2intopenhashmap.addTo(enumcreaturetype, 1);
-+                    // Paper start - Optional per player mob spawns
-+                    if (countMobs) {
-+                        chunk.level.getChunkSource().chunkMap.updatePlayerMobTypeMap(entity);
-+                    }
-+                    // Paper end - Optional per player mob spawns
-                 });
-             }
-         }
-@@ -0,0 +0,0 @@ public final class NaturalSpawner {
-                 continue;
-             }
- 
--            if ((flag || !enumcreaturetype.isFriendly()) && (flag1 || enumcreaturetype.isFriendly()) && (flag2 || !enumcreaturetype.isPersistent()) && spawnercreature_d.canSpawnForCategoryGlobal(enumcreaturetype, limit)) {
-+            if ((flag || !enumcreaturetype.isFriendly()) && (flag1 || enumcreaturetype.isFriendly()) && (flag2 || !enumcreaturetype.isPersistent()) && (worldserver.paperConfig().entities.spawning.perPlayerMobSpawns || spawnercreature_d.canSpawnForCategoryGlobal(enumcreaturetype, limit))) { // Paper - Optional per player mob spawns; remove global check, check later during the local one
-                 // CraftBukkit end
-                 list.add(enumcreaturetype);
-             }
-@@ -0,0 +0,0 @@ public final class NaturalSpawner {
-         while (iterator.hasNext()) {
-             MobCategory enumcreaturetype = (MobCategory) iterator.next();
- 
--            if (info.canSpawnForCategoryLocal(enumcreaturetype, chunk.getPos())) {
-+            // Paper start - Optional per player mob spawns
-+            final boolean canSpawn;
-+            int maxSpawns = Integer.MAX_VALUE;
-+            if (world.paperConfig().entities.spawning.perPlayerMobSpawns) {
-+                // Copied from getFilteredSpawningCategories
-+                int limit = enumcreaturetype.getMaxInstancesPerChunk();
-+                SpawnCategory spawnCategory = CraftSpawnCategory.toBukkit(enumcreaturetype);
-+                if (CraftSpawnCategory.isValidForLimits(spawnCategory)) {
-+                    limit = world.getWorld().getSpawnLimit(spawnCategory);
-+                }
-+
-+                // Apply per-player limit
-+                int minDiff = Integer.MAX_VALUE;
-+                final ca.spottedleaf.moonrise.common.list.ReferenceList<net.minecraft.server.level.ServerPlayer> inRange =
-+                    world.moonrise$getNearbyPlayers().getPlayers(chunk.getPos(), ca.spottedleaf.moonrise.common.misc.NearbyPlayers.NearbyMapType.TICK_VIEW_DISTANCE);
-+                if (inRange != null) {
-+                    final net.minecraft.server.level.ServerPlayer[] backingSet = inRange.getRawDataUnchecked();
-+                    for (int k = 0, len = inRange.size(); k < len; k++) {
-+                        minDiff = Math.min(limit - world.getChunkSource().chunkMap.getMobCountNear(backingSet[k], enumcreaturetype), minDiff);
-+                    }
-+                }
-+
-+                maxSpawns = (minDiff == Integer.MAX_VALUE) ? 0 : minDiff;
-+                canSpawn = maxSpawns > 0;
-+            } else {
-+                canSpawn = info.canSpawnForCategoryLocal(enumcreaturetype, chunk.getPos());
-+            }
-+            if (canSpawn) {
-+                // Paper end - Optional per player mob spawns
-                 Objects.requireNonNull(info);
-                 NaturalSpawner.SpawnPredicate spawnercreature_c = info::canSpawn;
- 
-                 Objects.requireNonNull(info);
--                NaturalSpawner.spawnCategoryForChunk(enumcreaturetype, world, chunk, spawnercreature_c, info::afterSpawn);
-+                // Paper start - Optional per player mob spawns
-+                NaturalSpawner.spawnCategoryForChunk(enumcreaturetype, world, chunk, spawnercreature_c, info::afterSpawn,
-+                    maxSpawns, world.paperConfig().entities.spawning.perPlayerMobSpawns ? world.getChunkSource().chunkMap::updatePlayerMobTypeMap : null);
-+                // Paper end - Optional per player mob spawns
-             }
-         }
- 
-@@ -0,0 +0,0 @@ public final class NaturalSpawner {
-     // Paper end - Add mobcaps commands
- 
-     public static void spawnCategoryForChunk(MobCategory group, ServerLevel world, LevelChunk chunk, NaturalSpawner.SpawnPredicate checker, NaturalSpawner.AfterSpawnCallback runner) {
-+        // Paper start - Optional per player mob spawns
-+        spawnCategoryForChunk(group, world, chunk, checker, runner, Integer.MAX_VALUE, null);
-+    }
-+    public static void spawnCategoryForChunk(MobCategory group, ServerLevel world, LevelChunk chunk, NaturalSpawner.SpawnPredicate checker, NaturalSpawner.AfterSpawnCallback runner, int maxSpawns, Consumer<Entity> trackEntity) {
-+        // Paper end - Optional per player mob spawns
-         BlockPos blockposition = NaturalSpawner.getRandomPosWithin(world, chunk);
- 
-         if (blockposition.getY() >= world.getMinY() + 1) {
--            NaturalSpawner.spawnCategoryForPosition(group, world, chunk, blockposition, checker, runner);
-+            NaturalSpawner.spawnCategoryForPosition(group, world, chunk, blockposition, checker, runner, maxSpawns, trackEntity); // Paper - Optional per player mob spawns
-         }
-     }
- 
-@@ -0,0 +0,0 @@ public final class NaturalSpawner {
-         });
-     }
- 
-+    // Paper start - Optional per player mob spawns
-     public static void spawnCategoryForPosition(MobCategory group, ServerLevel world, ChunkAccess chunk, BlockPos pos, NaturalSpawner.SpawnPredicate checker, NaturalSpawner.AfterSpawnCallback runner) {
-+        spawnCategoryForPosition(group, world,chunk, pos, checker, runner, Integer.MAX_VALUE, null);
-+    }
-+    public static void spawnCategoryForPosition(MobCategory group, ServerLevel world, ChunkAccess chunk, BlockPos pos, NaturalSpawner.SpawnPredicate checker, NaturalSpawner.AfterSpawnCallback runner, int maxSpawns, Consumer<Entity> trackEntity) {
-+    // Paper end - Optional per player mob spawns
-         StructureManager structuremanager = world.structureManager();
-         ChunkGenerator chunkgenerator = world.getChunkSource().getGenerator();
-         int i = pos.getY();
-@@ -0,0 +0,0 @@ public final class NaturalSpawner {
-                                                 ++j;
-                                                 ++k1;
-                                                 runner.run(entityinsentient, chunk);
-+                                                // Paper start - Optional per player mob spawns
-+                                                if (trackEntity != null) {
-+                                                    trackEntity.accept(entityinsentient);
-+                                                }
-+                                                // Paper end - Optional per player mob spawns
-                                             }
-                                             // CraftBukkit end
--                                            if (j >= entityinsentient.getMaxSpawnClusterSize()) {
-+                                            if (j >= entityinsentient.getMaxSpawnClusterSize() || j >= maxSpawns) { // Paper - Optional per player mob spawns
-                                                 return;
-                                             }
- 
-@@ -0,0 +0,0 @@ public final class NaturalSpawner {
-             MobCategory enumcreaturetype = entitytypes.getCategory();
- 
-             this.mobCategoryCounts.addTo(enumcreaturetype, 1);
--            this.localMobCapCalculator.addMob(new ChunkPos(blockposition), enumcreaturetype);
-+            if (this.localMobCapCalculator != null) this.localMobCapCalculator.addMob(new ChunkPos(blockposition), enumcreaturetype); // Paper - Optional per player mob spawns
-         }
- 
-         public int getSpawnableChunkCount() {

patches/server/Remove-streams-from-hot-code.patch

@@ -1,215 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Josh Roy <10731363+JRoy@users.noreply.github.com>
-Date: Wed, 1 Jul 2020 18:01:49 -0400
-Subject: [PATCH] Remove streams from hot code
-
-Co-authored-by: Bjarne Koll <git@lynxplay.dev>
-Co-authored-by: Spottedleaf <Spottedleaf@users.noreply.github.com>
-
-diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/GateBehavior.java b/src/main/java/net/minecraft/world/entity/ai/behavior/GateBehavior.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ai/behavior/GateBehavior.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/behavior/GateBehavior.java
-@@ -0,0 +0,0 @@ public class GateBehavior<E extends LivingEntity> implements BehaviorControl<E>
-         if (this.hasRequiredMemories(entity)) {
-             this.status = Behavior.Status.RUNNING;
-             this.orderPolicy.apply(this.behaviors);
--            this.runningPolicy.apply(this.behaviors.stream(), world, entity, time);
-+            this.runningPolicy.apply(this.behaviors, world, entity, time); // Paper - Perf: Remove streams from hot code
-             return true;
-         } else {
-             return false;
-@@ -0,0 +0,0 @@ public class GateBehavior<E extends LivingEntity> implements BehaviorControl<E>
- 
-     @Override
-     public final void tickOrStop(ServerLevel world, E entity, long time) {
--        this.behaviors.stream().filter(task -> task.getStatus() == Behavior.Status.RUNNING).forEach(task -> task.tickOrStop(world, entity, time));
-+        // Paper start - Perf: Remove streams from hot code
-+        for (final BehaviorControl<? super E> task : this.behaviors) {
-+            if (task.getStatus() == Behavior.Status.RUNNING) {
-+                task.tickOrStop(world, entity, time);
-+            }
-+        }
-+        // Paper end - Perf: Remove streams from hot code
-         if (this.behaviors.stream().noneMatch(task -> task.getStatus() == Behavior.Status.RUNNING)) {
-             this.doStop(world, entity, time);
-         }
-@@ -0,0 +0,0 @@ public class GateBehavior<E extends LivingEntity> implements BehaviorControl<E>
-     @Override
-     public final void doStop(ServerLevel world, E entity, long time) {
-         this.status = Behavior.Status.STOPPED;
--        this.behaviors.stream().filter(task -> task.getStatus() == Behavior.Status.RUNNING).forEach(task -> task.doStop(world, entity, time));
--        this.exitErasedMemories.forEach(entity.getBrain()::eraseMemory);
-+        // Paper start - Perf: Remove streams from hot code
-+        for (final BehaviorControl<? super E> task : this.behaviors) {
-+            if (task.getStatus() == Behavior.Status.RUNNING) {
-+                task.doStop(world, entity, time);
-+            }
-+        }
-+        for (final MemoryModuleType<?> exitErasedMemory : this.exitErasedMemories) {
-+            entity.getBrain().eraseMemory(exitErasedMemory);
-+        }
-+        // Paper end - Perf: Remove streams from hot code
-     }
- 
-     @Override
-@@ -0,0 +0,0 @@ public class GateBehavior<E extends LivingEntity> implements BehaviorControl<E>
- 
-     public static enum RunningPolicy {
-         RUN_ONE {
-+            // Paper start - Perf: Remove streams from hot code
-             @Override
--            public <E extends LivingEntity> void apply(Stream<BehaviorControl<? super E>> tasks, ServerLevel world, E entity, long time) {
--                tasks.filter(task -> task.getStatus() == Behavior.Status.STOPPED).filter(task -> task.tryStart(world, entity, time)).findFirst();
-+            public <E extends LivingEntity> void apply(ShufflingList<BehaviorControl<? super E>> tasks, ServerLevel world, E entity, long time) {
-+                for (final BehaviorControl<? super E> task : tasks) {
-+                    if (task.getStatus() == Behavior.Status.STOPPED && task.tryStart(world, entity, time)) {
-+                        break;
-+                    }
-+                }
-+                // Paper end - Perf: Remove streams from hot code
-             }
-         },
-         TRY_ALL {
-+            // Paper start - Perf: Remove streams from hot code
-             @Override
--            public <E extends LivingEntity> void apply(Stream<BehaviorControl<? super E>> tasks, ServerLevel world, E entity, long time) {
--                tasks.filter(task -> task.getStatus() == Behavior.Status.STOPPED).forEach(task -> task.tryStart(world, entity, time));
-+            public <E extends LivingEntity> void apply(ShufflingList<BehaviorControl<? super E>> tasks, ServerLevel world, E entity, long time) {
-+                for (final BehaviorControl<? super E> task : tasks) {
-+                    if (task.getStatus() == Behavior.Status.STOPPED) {
-+                        task.tryStart(world, entity, time);
-+                    }
-+                }
-+                // Paper end - Perf: Remove streams from hot code
-             }
-         };
- 
--        public abstract <E extends LivingEntity> void apply(Stream<BehaviorControl<? super E>> tasks, ServerLevel world, E entity, long time);
-+        public abstract <E extends LivingEntity> void apply(ShufflingList<BehaviorControl<? super E>> tasks, ServerLevel world, E entity, long time); // Paper - Perf: Remove streams from hot code
-     }
- }
-diff --git a/src/main/java/net/minecraft/world/entity/ai/gossip/GossipContainer.java b/src/main/java/net/minecraft/world/entity/ai/gossip/GossipContainer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ai/gossip/GossipContainer.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/gossip/GossipContainer.java
-@@ -0,0 +0,0 @@ public class GossipContainer {
-         return this.gossips.entrySet().stream().flatMap(entry -> entry.getValue().unpack(entry.getKey()));
-     }
- 
-+    // Paper start - Perf: Remove streams from hot code
-+    private List<GossipContainer.GossipEntry> decompress() {
-+        List<GossipContainer.GossipEntry> list = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>();
-+        for (Map.Entry<UUID, GossipContainer.EntityGossips> entry : this.gossips.entrySet()) {
-+            for (GossipContainer.GossipEntry cur : entry.getValue().decompress(entry.getKey())) {
-+                if (cur.weightedValue() != 0) {
-+                    list.add(cur);
-+                }
-+            }
-+        }
-+        return list;
-+    }
-+    // Paper end - Perf: Remove streams from hot code
-+
-     private Collection<GossipContainer.GossipEntry> selectGossipsForTransfer(RandomSource random, int count) {
--        List<GossipContainer.GossipEntry> list = this.unpack().toList();
-+        List<GossipContainer.GossipEntry> list = this.decompress(); // Paper - Perf: Remove streams from hot code
-         if (list.isEmpty()) {
-             return Collections.emptyList();
-         } else {
-@@ -0,0 +0,0 @@ public class GossipContainer {
- 
-     public <T> T store(DynamicOps<T> ops) {
-         return GossipContainer.GossipEntry.LIST_CODEC
--            .encodeStart(ops, this.unpack().toList())
-+            .encodeStart(ops, this.decompress()) // Paper - Perf: Remove streams from hot code
-             .resultOrPartial(error -> LOGGER.warn("Failed to serialize gossips: {}", error))
-             .orElseGet(ops::emptyList);
-     }
-@@ -0,0 +0,0 @@ public class GossipContainer {
-         final Object2IntMap<GossipType> entries = new Object2IntOpenHashMap<>();
- 
-         public int weightedValue(Predicate<GossipType> gossipTypeFilter) {
--            return this.entries
--                .object2IntEntrySet()
--                .stream()
--                .filter(entry -> gossipTypeFilter.test(entry.getKey()))
--                .mapToInt(entry -> entry.getIntValue() * entry.getKey().weight)
--                .sum();
-+            // Paper start - Perf: Remove streams from hot code
-+            int weight = 0;
-+            for (Object2IntMap.Entry<GossipType> entry : entries.object2IntEntrySet()) {
-+                if (gossipTypeFilter.test(entry.getKey())) {
-+                    weight += entry.getIntValue() * entry.getKey().weight;
-+                }
-+            }
-+            return weight;
-+        }
-+
-+        public List<GossipContainer.GossipEntry> decompress(UUID uuid) {
-+            List<GossipContainer.GossipEntry> list = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>();
-+            for (Object2IntMap.Entry<GossipType> entry : entries.object2IntEntrySet()) {
-+                list.add(new GossipContainer.GossipEntry(uuid, entry.getKey(), entry.getIntValue()));
-+            }
-+            return list;
-+            // Paper end - Perf: Remove streams from hot code
-         }
- 
-         public Stream<GossipContainer.GossipEntry> unpack(UUID target) {
-diff --git a/src/main/java/net/minecraft/world/entity/ai/sensing/NearestItemSensor.java b/src/main/java/net/minecraft/world/entity/ai/sensing/NearestItemSensor.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/entity/ai/sensing/NearestItemSensor.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/sensing/NearestItemSensor.java
-@@ -0,0 +0,0 @@ public class NearestItemSensor extends Sensor<Mob> {
-     @Override
-     protected void doTick(ServerLevel world, Mob entity) {
-         Brain<?> brain = entity.getBrain();
--        List<ItemEntity> list = world.getEntitiesOfClass(ItemEntity.class, entity.getBoundingBox().inflate(32.0, 16.0, 32.0), itemEntity -> true);
-+        List<ItemEntity> list = world.getEntitiesOfClass(ItemEntity.class, entity.getBoundingBox().inflate(32.0, 16.0, 32.0), itemEntity -> itemEntity.closerThan(entity, MAX_DISTANCE_TO_WANTED_ITEM) && entity.wantsToPickUp(world, itemEntity.getItem())); // Paper - Perf: Move predicate into getEntities
-         list.sort(Comparator.comparingDouble(entity::distanceToSqr));
--        Optional<ItemEntity> optional = list.stream()
--            .filter(itemEntity -> entity.wantsToPickUp(world, itemEntity.getItem()))
--            .filter(itemEntityx -> itemEntityx.closerThan(entity, 32.0))
--            .filter(entity::hasLineOfSight)
--            .findFirst();
--        brain.setMemory(MemoryModuleType.NEAREST_VISIBLE_WANTED_ITEM, optional);
-+        // Paper start - Perf: remove streams from hot code
-+        ItemEntity nearest = null;
-+        for (ItemEntity entityItem : list) {
-+            if (entity.hasLineOfSight(entityItem)) { // Paper - Perf: Move predicate into getEntities
-+                nearest = entityItem;
-+                break;
-+            }
-+        }
-+        brain.setMemory(MemoryModuleType.NEAREST_VISIBLE_WANTED_ITEM, Optional.ofNullable(nearest));
-+        // Paper end - Perf: remove streams from hot code
-     }
- }
-diff --git a/src/main/java/net/minecraft/world/level/levelgen/Beardifier.java b/src/main/java/net/minecraft/world/level/levelgen/Beardifier.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/world/level/levelgen/Beardifier.java
-+++ b/src/main/java/net/minecraft/world/level/levelgen/Beardifier.java
-@@ -0,0 +0,0 @@ public class Beardifier implements DensityFunctions.BeardifierOrMarker {
-         int j = pos.getMinBlockZ();
-         ObjectList<Beardifier.Rigid> objectList = new ObjectArrayList<>(10);
-         ObjectList<JigsawJunction> objectList2 = new ObjectArrayList<>(32);
--        world.startsForStructure(pos, structure -> structure.terrainAdaptation() != TerrainAdjustment.NONE)
--            .forEach(
--                start -> {
-+        // Paper start - Perf: Remove streams from hot code
-+        for (net.minecraft.world.level.levelgen.structure.StructureStart start : world.startsForStructure(pos, (structure) -> {
-+            return structure.terrainAdaptation() != TerrainAdjustment.NONE;
-+        })) { // Paper end - Perf: Remove streams from hot code
-                     TerrainAdjustment terrainAdjustment = start.getStructure().terrainAdaptation();
- 
-                     for (StructurePiece structurePiece : start.getPieces()) {
-@@ -0,0 +0,0 @@ public class Beardifier implements DensityFunctions.BeardifierOrMarker {
-                             }
-                         }
-                     }
--                }
--            );
-+        } // Paper - Perf: Remove streams from hot code
-         return new Beardifier(objectList.iterator(), objectList2.iterator());
-     }
- 

patches/server/Use-Velocity-compression-and-cipher-natives.patch

@@ -1,387 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Andrew Steinborn <git@steinborn.me>
-Date: Mon, 26 Jul 2021 02:15:17 -0400
-Subject: [PATCH] Use Velocity compression and cipher natives
-
-== AT ==
-private-f net.minecraft.network.CompressionDecoder inflater
-
-diff --git a/build.gradle.kts b/build.gradle.kts
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/build.gradle.kts
-+++ b/build.gradle.kts
-@@ -0,0 +0,0 @@ dependencies {
-     runtimeOnly("org.xerial:sqlite-jdbc:3.47.0.0")
-     runtimeOnly("com.mysql:mysql-connector-j:9.1.0")
-     runtimeOnly("com.lmax:disruptor:3.4.4") // Paper
-+    // Paper start - Use Velocity cipher
-+    implementation("com.velocitypowered:velocity-native:3.3.0-SNAPSHOT") {
-+        isTransitive = false
-+    }
-+    // Paper end - Use Velocity cipher
- 
-     runtimeOnly("org.apache.maven:maven-resolver-provider:3.9.6")
-     runtimeOnly("org.apache.maven.resolver:maven-resolver-connector-basic:1.9.18")
-diff --git a/src/main/java/net/minecraft/network/CipherDecoder.java b/src/main/java/net/minecraft/network/CipherDecoder.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/CipherDecoder.java
-+++ b/src/main/java/net/minecraft/network/CipherDecoder.java
-@@ -0,0 +0,0 @@ import java.util.List;
- import javax.crypto.Cipher;
- 
- public class CipherDecoder extends MessageToMessageDecoder<ByteBuf> {
--    private final CipherBase cipher;
-+    private final com.velocitypowered.natives.encryption.VelocityCipher cipher; // Paper - Use Velocity cipher
- 
--    public CipherDecoder(Cipher cipher) {
--        this.cipher = new CipherBase(cipher);
-+    public CipherDecoder(com.velocitypowered.natives.encryption.VelocityCipher cipher) {  // Paper - Use Velocity cipher
-+        this.cipher = cipher;  // Paper - Use Velocity cipher
-     }
- 
-     protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List<Object> list) throws Exception {
--        list.add(this.cipher.decipher(channelHandlerContext, byteBuf));
-+        // Paper start - Use Velocity cipher
-+        ByteBuf compatible = com.velocitypowered.natives.util.MoreByteBufUtils.ensureCompatible(channelHandlerContext.alloc(), cipher, byteBuf);
-+        try {
-+            cipher.process(compatible);
-+            list.add(compatible);
-+        } catch (Exception e) {
-+            compatible.release(); // compatible will never be used if we throw an exception
-+            throw e;
-+        }
-+        // Paper end - Use Velocity cipher
-     }
-+
-+    // Paper start - Use Velocity cipher
-+    @Override
-+    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
-+        cipher.close();
-+    }
-+    // Paper end - Use Velocity cipher
- }
-diff --git a/src/main/java/net/minecraft/network/CipherEncoder.java b/src/main/java/net/minecraft/network/CipherEncoder.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/CipherEncoder.java
-+++ b/src/main/java/net/minecraft/network/CipherEncoder.java
-@@ -0,0 +0,0 @@ import io.netty.buffer.ByteBuf;
- import io.netty.channel.ChannelHandlerContext;
- import io.netty.handler.codec.MessageToByteEncoder;
- import javax.crypto.Cipher;
-+import java.util.List;
- 
--public class CipherEncoder extends MessageToByteEncoder<ByteBuf> {
--    private final CipherBase cipher;
-+public class CipherEncoder extends io.netty.handler.codec.MessageToMessageEncoder<ByteBuf> { // Paper - Use Velocity cipher; change superclass
-+    private final com.velocitypowered.natives.encryption.VelocityCipher cipher; // Paper - Use Velocity cipher
- 
--    public CipherEncoder(Cipher cipher) {
--        this.cipher = new CipherBase(cipher);
-+    public CipherEncoder(com.velocitypowered.natives.encryption.VelocityCipher cipher) {  // Paper - Use Velocity cipher
-+        this.cipher = cipher;  // Paper - Use Velocity cipher
-     }
- 
--    protected void encode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, ByteBuf byteBuf2) throws Exception {
--        this.cipher.encipher(byteBuf, byteBuf2);
-+    protected void encode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List<Object> list) throws Exception {
-+        // Paper start - Use Velocity cipher
-+        ByteBuf compatible = com.velocitypowered.natives.util.MoreByteBufUtils.ensureCompatible(channelHandlerContext.alloc(), cipher, byteBuf);
-+        try {
-+            cipher.process(compatible);
-+            list.add(compatible);
-+        } catch (Exception e) {
-+            compatible.release(); // compatible will never be used if we throw an exception
-+            throw e;
-+        }
-+        // Paper end - Use Velocity cipher
-     }
-+
-+    // Paper start - Use Velocity cipher
-+    @Override
-+    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
-+        cipher.close();
-+    }
-+    // Paper end - Use Velocity cipher
- }
-diff --git a/src/main/java/net/minecraft/network/CompressionDecoder.java b/src/main/java/net/minecraft/network/CompressionDecoder.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/CompressionDecoder.java
-+++ b/src/main/java/net/minecraft/network/CompressionDecoder.java
-@@ -0,0 +0,0 @@ public class CompressionDecoder extends ByteToMessageDecoder {
-     public static final int MAXIMUM_COMPRESSED_LENGTH = 2097152;
-     public static final int MAXIMUM_UNCOMPRESSED_LENGTH = 8388608;
-     private Inflater inflater;
-+    private com.velocitypowered.natives.compression.VelocityCompressor compressor; // Paper - Use Velocity cipher
-     private int threshold;
-     private boolean validateDecompressed;
- 
-+    // Paper start - Use Velocity cipher
-+    @io.papermc.paper.annotation.DoNotUse
-     public CompressionDecoder(int compressionThreshold, boolean rejectsBadPackets) {
-+        this(null, compressionThreshold, rejectsBadPackets);
-+    }
-+    public CompressionDecoder(com.velocitypowered.natives.compression.VelocityCompressor compressor, int compressionThreshold, boolean rejectsBadPackets) {
-         this.threshold = compressionThreshold;
-         this.validateDecompressed = rejectsBadPackets;
--        this.inflater = new Inflater();
-+        this.inflater = compressor == null ? new Inflater() : null;
-+        this.compressor = compressor;
-+        // Paper end - Use Velocity cipher
-     }
- 
-     protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List<Object> list) throws Exception {
-@@ -0,0 +0,0 @@ public class CompressionDecoder extends ByteToMessageDecoder {
-                     }
-                 }
- 
-+                if (inflater != null) { // Paper - Use Velocity cipher; fallback to vanilla inflater
-                 this.setupInflaterInput(byteBuf);
-                 ByteBuf byteBuf2 = this.inflate(channelHandlerContext, i);
-                 this.inflater.reset();
-                 list.add(byteBuf2);
-+                return; // Paper - Use Velocity cipher
-+                } // Paper - use velocity compression
-+
-+                // Paper start - Use Velocity cipher
-+                int claimedUncompressedSize = i; // OBFHELPER
-+                ByteBuf compatibleIn = com.velocitypowered.natives.util.MoreByteBufUtils.ensureCompatible(channelHandlerContext.alloc(), this.compressor, byteBuf);
-+                ByteBuf uncompressed = com.velocitypowered.natives.util.MoreByteBufUtils.preferredBuffer(channelHandlerContext.alloc(), this.compressor, claimedUncompressedSize);
-+                try {
-+                    this.compressor.inflate(compatibleIn, uncompressed, claimedUncompressedSize);
-+                    list.add(uncompressed);
-+                    byteBuf.clear();
-+                } catch (Exception e) {
-+                    uncompressed.release();
-+                    throw e;
-+                } finally {
-+                    compatibleIn.release();
-+                }
-+                // Paper end - Use Velocity cipher
-             }
-         }
-     }
- 
-+    // Paper start - Use Velocity cipher
-+    @Override
-+    public void handlerRemoved0(ChannelHandlerContext ctx) throws Exception {
-+        if (this.compressor != null) {
-+            this.compressor.close();
-+        }
-+    }
-+    // Paper end - Use Velocity cipher
-+
-     private void setupInflaterInput(ByteBuf buf) {
-         ByteBuffer byteBuffer;
-         if (buf.nioBufferCount() > 0) {
-@@ -0,0 +0,0 @@ public class CompressionDecoder extends ByteToMessageDecoder {
-         }
-     }
- 
--    public void setThreshold(int compressionThreshold, boolean rejectsBadPackets) {
-+    // Paper start - Use Velocity cipher
-+    public void setThreshold(com.velocitypowered.natives.compression.VelocityCompressor compressor, int compressionThreshold, boolean rejectsBadPackets) {
-+        if (this.compressor == null && compressor != null) { // Only re-configure once. Re-reconfiguring would require closing the native compressor.
-+            this.compressor = compressor;
-+            this.inflater = null;
-+        }
-+    // Paper end - Use Velocity cipher
-         this.threshold = compressionThreshold;
-         this.validateDecompressed = rejectsBadPackets;
-     }
-diff --git a/src/main/java/net/minecraft/network/CompressionEncoder.java b/src/main/java/net/minecraft/network/CompressionEncoder.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/net/minecraft/network/CompressionEncoder.java
-+++ b/src/main/java/net/minecraft/network/CompressionEncoder.java
-@@ -0,0 +0,0 @@ import io.netty.handler.codec.MessageToByteEncoder;
- import java.util.zip.Deflater;
- 
- public class CompressionEncoder extends MessageToByteEncoder<ByteBuf> {
--    private final byte[] encodeBuf = new byte[8192];
-+    @javax.annotation.Nullable private final byte[] encodeBuf; // Paper - Use Velocity cipher
-+    @javax.annotation.Nullable // Paper - Use Velocity cipher
-     private final Deflater deflater;
-+    @javax.annotation.Nullable // Paper - Use Velocity cipher
-+    private final com.velocitypowered.natives.compression.VelocityCompressor compressor; // Paper - Use Velocity cipher
-     private int threshold;
- 
-+    // Paper start - Use Velocity cipher
-     public CompressionEncoder(int compressionThreshold) {
-+        this(null, compressionThreshold);
-+    }
-+    public CompressionEncoder(@javax.annotation.Nullable com.velocitypowered.natives.compression.VelocityCompressor compressor, int compressionThreshold) {
-         this.threshold = compressionThreshold;
--        this.deflater = new Deflater();
-+        if (compressor == null) {
-+            this.encodeBuf = new byte[8192];
-+            this.deflater = new Deflater();
-+        } else {
-+            this.encodeBuf = null;
-+            this.deflater = null;
-+        }
-+        this.compressor = compressor;
-+        // Paper end - Use Velocity cipher
-     }
- 
--    protected void encode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, ByteBuf byteBuf2) {
-+    protected void encode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, ByteBuf byteBuf2) throws Exception { // Paper - Use Velocity cipher
-         int i = byteBuf.readableBytes();
-         if (i > 8388608) {
-             throw new IllegalArgumentException("Packet too big (is " + i + ", should be less than 8388608)");
-@@ -0,0 +0,0 @@ public class CompressionEncoder extends MessageToByteEncoder<ByteBuf> {
-                 VarInt.write(byteBuf2, 0);
-                 byteBuf2.writeBytes(byteBuf);
-             } else {
-+                if (this.deflater != null) { // Paper - Use Velocity cipher
-                 byte[] bs = new byte[i];
-                 byteBuf.readBytes(bs);
-                 VarInt.write(byteBuf2, bs.length);
-@@ -0,0 +0,0 @@ public class CompressionEncoder extends MessageToByteEncoder<ByteBuf> {
-                 }
- 
-                 this.deflater.reset();
-+                // Paper start - Use Velocity cipher
-+                    return;
-+                }
-+
-+                VarInt.write(byteBuf2, i);
-+                final ByteBuf compatibleIn = com.velocitypowered.natives.util.MoreByteBufUtils.ensureCompatible(channelHandlerContext.alloc(), this.compressor, byteBuf);
-+                try {
-+                    this.compressor.deflate(compatibleIn, byteBuf2);
-+                } finally {
-+                    compatibleIn.release();
-+                }
-             }
-         }
-     }
- 
-+    @Override
-+    protected ByteBuf allocateBuffer(ChannelHandlerContext ctx, ByteBuf msg, boolean preferDirect) throws Exception{
-+        if (this.compressor != null) {
-+            // We allocate bytes to be compressed plus 1 byte. This covers two cases:
-+            //
-+            // - Compression
-+            //    According to https://github.com/ebiggers/libdeflate/blob/master/libdeflate.h#L103,
-+            //    if the data compresses well (and we do not have some pathological case) then the maximum
-+            //    size the compressed size will ever be is the input size minus one.
-+            // - Uncompressed
-+            //    This is fairly obvious - we will then have one more than the uncompressed size.
-+            final int initialBufferSize = msg.readableBytes() + 1;
-+            return com.velocitypowered.natives.util.MoreByteBufUtils.preferredBuffer(ctx.alloc(), this.compressor, initialBufferSize);
-+        }
-+
-+        return super.allocateBuffer(ctx, msg, preferDirect);
-+    }
-+
-+    @Override
-+    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
-+        if (this.compressor != null) {
-+            this.compressor.close();
-+            // Paper end - Use Velocity cipher
-+        }
-+    }
-+
-     public int getThreshold() {
-         return this.threshold;
-     }
-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<?>> {
-         return networkmanager;
-     }
- 
--    public void setEncryptionKey(Cipher decryptionCipher, Cipher encryptionCipher) {
--        this.encrypted = true;
--        this.channel.pipeline().addBefore("splitter", "decrypt", new CipherDecoder(decryptionCipher));
--        this.channel.pipeline().addBefore("prepender", "encrypt", new CipherEncoder(encryptionCipher));
-+    // Paper start - Use Velocity cipher
-+//    public void setEncryptionKey(Cipher decryptionCipher, Cipher encryptionCipher) {
-+//        this.encrypted = true;
-+//        this.channel.pipeline().addBefore("splitter", "decrypt", new CipherDecoder(decryptionCipher));
-+//        this.channel.pipeline().addBefore("prepender", "encrypt", new CipherEncoder(encryptionCipher));
-+//    }
-+
-+    public void setupEncryption(javax.crypto.SecretKey key) throws net.minecraft.util.CryptException {
-+        if (!this.encrypted) {
-+            try {
-+                com.velocitypowered.natives.encryption.VelocityCipher decryption = com.velocitypowered.natives.util.Natives.cipher.get().forDecryption(key);
-+                com.velocitypowered.natives.encryption.VelocityCipher encryption = com.velocitypowered.natives.util.Natives.cipher.get().forEncryption(key);
-+
-+                this.encrypted = true;
-+                this.channel.pipeline().addBefore("splitter", "decrypt", new CipherDecoder(decryption));
-+                this.channel.pipeline().addBefore("prepender", "encrypt", new CipherEncoder(encryption));
-+            } catch (java.security.GeneralSecurityException e) {
-+                throw new net.minecraft.util.CryptException(e);
-+            }
-+        }
-     }
-+    // Paper end - Use Velocity cipher
- 
-     public boolean isEncrypted() {
-         return this.encrypted;
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
- 
-     public void setupCompression(int compressionThreshold, boolean rejectsBadPackets) {
-         if (compressionThreshold >= 0) {
-+            com.velocitypowered.natives.compression.VelocityCompressor compressor = com.velocitypowered.natives.util.Natives.compress.get().create(io.papermc.paper.configuration.GlobalConfiguration.get().misc.compressionLevel.or(-1)); // Paper - Use Velocity cipher
-             ChannelHandler channelhandler = this.channel.pipeline().get("decompress");
- 
-             if (channelhandler instanceof CompressionDecoder) {
-                 CompressionDecoder packetdecompressor = (CompressionDecoder) channelhandler;
- 
--                packetdecompressor.setThreshold(compressionThreshold, rejectsBadPackets);
-+                packetdecompressor.setThreshold(compressor, compressionThreshold, rejectsBadPackets); // Paper - Use Velocity cipher
-             } else {
--                this.channel.pipeline().addAfter("splitter", "decompress", new CompressionDecoder(compressionThreshold, rejectsBadPackets));
-+                this.channel.pipeline().addAfter("splitter", "decompress", new CompressionDecoder(compressor, compressionThreshold, rejectsBadPackets)); // Paper - Use Velocity cipher
-             }
- 
-             channelhandler = this.channel.pipeline().get("compress");
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
- 
-                 packetcompressor.setThreshold(compressionThreshold);
-             } else {
--                this.channel.pipeline().addAfter("prepender", "compress", new CompressionEncoder(compressionThreshold));
-+                this.channel.pipeline().addAfter("prepender", "compress", new CompressionEncoder(compressor, compressionThreshold)); // Paper - Use Velocity cipher
-             }
-             this.channel.pipeline().fireUserEventTriggered(io.papermc.paper.network.ConnectionEvent.COMPRESSION_THRESHOLD_SET); // Paper - Add Channel initialization listeners
-         } else {
-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 {
-             }
-             // Paper end - Warn people with console access that HAProxy is in use.
- 
-+            // Paper start - Use Velocity cipher
-+            ServerConnectionListener.LOGGER.info("Paper: Using " + com.velocitypowered.natives.util.Natives.compress.getLoadedVariant() + " compression from Velocity.");
-+            ServerConnectionListener.LOGGER.info("Paper: Using " + com.velocitypowered.natives.util.Natives.cipher.getLoadedVariant() + " cipher from Velocity.");
-+            // Paper end - Use Velocity cipher
-+
-             this.channels.add(((ServerBootstrap) ((ServerBootstrap) (new ServerBootstrap()).channel(oclass)).childHandler(new ChannelInitializer<Channel>() {
-                 protected void initChannel(Channel channel) {
-                     try {
-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,
-             }
- 
-             SecretKey secretkey = packet.getSecretKey(privatekey);
--            Cipher cipher = Crypt.getCipher(2, secretkey);
--            Cipher cipher1 = Crypt.getCipher(1, secretkey);
-+            // Paper start - Use Velocity cipher
-+//            Cipher cipher = Crypt.getCipher(2, secretkey);
-+//            Cipher cipher1 = Crypt.getCipher(1, secretkey);
-+            // Paper end - Use Velocity cipher
- 
-             s = (new BigInteger(Crypt.digestData("", this.server.getKeyPair().getPublic(), secretkey))).toString(16);
-             this.state = ServerLoginPacketListenerImpl.State.AUTHENTICATING;
--            this.connection.setEncryptionKey(cipher, cipher1);
-+            this.connection.setupEncryption(secretkey); // Paper - Use Velocity cipher
-         } catch (CryptException cryptographyexception) {
-             throw new IllegalStateException("Protocol error", cryptographyexception);
-         }

patches/server/optimize-dirt-and-snow-spreading.patch

@@ -1,78 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: lukas81298 <lukas81298@gommehd.net>
-Date: Fri, 22 Jan 2021 21:50:18 +0100
-Subject: [PATCH] optimize dirt and snow spreading
-
-
-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 @@ public abstract class SpreadingSnowyDirtBlock extends SnowyDirtBlock {
-     }
- 
-     private static boolean canBeGrass(BlockState state, LevelReader world, BlockPos pos) {
-+    // Paper start - Perf: optimize dirt and snow spreading
-+        return canBeGrass(world.getChunk(pos), state, world, pos);
-+    }
-+    private static boolean canBeGrass(net.minecraft.world.level.chunk.ChunkAccess chunk, BlockState state, LevelReader world, BlockPos pos) {
-+    // Paper end - Perf: optimize dirt and snow spreading
-         BlockPos blockposition1 = pos.above();
--        BlockState iblockdata1 = world.getBlockState(blockposition1);
-+        BlockState iblockdata1 = chunk.getBlockState(blockposition1); // Paper - Perf: optimize dirt and snow spreading
- 
-         if (iblockdata1.is(Blocks.SNOW) && (Integer) iblockdata1.getValue(SnowLayerBlock.LAYERS) == 1) {
-             return true;
-@@ -0,0 +0,0 @@ public abstract class SpreadingSnowyDirtBlock extends SnowyDirtBlock {
-     protected abstract MapCodec<? extends SpreadingSnowyDirtBlock> codec();
- 
-     private static boolean canPropagate(BlockState state, LevelReader world, BlockPos pos) {
-+    // Paper start - Perf: optimize dirt and snow spreading
-+        return canPropagate(world.getChunk(pos), state, world, pos);
-+    }
-+
-+    private static boolean canPropagate(net.minecraft.world.level.chunk.ChunkAccess chunk, BlockState state, LevelReader world, BlockPos pos) {
-+    // Paper end - Perf: optimize dirt and snow spreading
-         BlockPos blockposition1 = pos.above();
- 
--        return SpreadingSnowyDirtBlock.canBeGrass(state, world, pos) && !world.getFluidState(blockposition1).is(FluidTags.WATER);
-+        return SpreadingSnowyDirtBlock.canBeGrass(chunk, state, world, pos) && !chunk.getFluidState(blockposition1).is(FluidTags.WATER); // Paper - Perf: optimize dirt and snow spreading
-     }
- 
-     @Override
-     protected void randomTick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
-         if (this instanceof GrassBlock && world.paperConfig().tickRates.grassSpread != 1 && (world.paperConfig().tickRates.grassSpread < 1 || (net.minecraft.server.MinecraftServer.currentTick + pos.hashCode()) % world.paperConfig().tickRates.grassSpread != 0)) { return; } // Paper - Configurable random tick rates for blocks
--        if (!SpreadingSnowyDirtBlock.canBeGrass(state, world, pos)) {
-+        // Paper start - Perf: optimize dirt and snow spreading
-+        final net.minecraft.world.level.chunk.ChunkAccess cachedBlockChunk = world.getChunkIfLoaded(pos);
-+        if (cachedBlockChunk == null) { // Is this needed?
-+            return;
-+        }
-+        if (!SpreadingSnowyDirtBlock.canBeGrass(cachedBlockChunk, state, world, pos)) {
-+            // Paper end - Perf: optimize dirt and snow spreading
-             // CraftBukkit start
-             if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, pos, Blocks.DIRT.defaultBlockState()).isCancelled()) {
-                 return;
-@@ -0,0 +0,0 @@ public abstract class SpreadingSnowyDirtBlock extends SnowyDirtBlock {
-                 for (int i = 0; i < 4; ++i) {
-                     BlockPos blockposition1 = pos.offset(random.nextInt(3) - 1, random.nextInt(5) - 3, random.nextInt(3) - 1);
- 
--                    if (world.getBlockState(blockposition1).is(Blocks.DIRT) && SpreadingSnowyDirtBlock.canPropagate(iblockdata1, world, blockposition1)) {
--                        org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(world, pos, blockposition1, (BlockState) iblockdata1.setValue(SpreadingSnowyDirtBlock.SNOWY, isSnowySetting(world.getBlockState(blockposition1.above())))); // CraftBukkit
-+                    // Paper start - Perf: optimize dirt and snow spreading
-+                    if (pos.getX() == blockposition1.getX() && pos.getY() == blockposition1.getY() && pos.getZ() == blockposition1.getZ()) {
-+                        continue;
-+                    }
-+
-+                    final net.minecraft.world.level.chunk.ChunkAccess access;
-+                    if (cachedBlockChunk.locX == blockposition1.getX() >> 4 && cachedBlockChunk.locZ == blockposition1.getZ() >> 4) {
-+                        access = cachedBlockChunk;
-+                    } else {
-+                        access = world.getChunkAt(blockposition1);
-+                    }
-+                    if (access.getBlockState(blockposition1).is(Blocks.DIRT) && SpreadingSnowyDirtBlock.canPropagate(access, iblockdata1, world, blockposition1)) {
-+                        org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(world, pos, blockposition1, (BlockState) iblockdata1.setValue(SpreadingSnowyDirtBlock.SNOWY, isSnowySetting(access.getBlockState(blockposition1.above())))); // CraftBukkit
-+                    // Paper end - Perf: optimize dirt and snow spreading
-                     }
-                 }
-             }