even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even even more patches

2021-11-24 22:31:14 -08:00
parent 437205bba8
commit de5dbadea0
29 changed files with 139 additions and 9414 deletions
--- a/patches/unapplied/server/Add-Raw-Byte-Entity-Serialization.patch
+++ b/patches/unapplied/server/Add-Raw-Byte-Entity-Serialization.patch
@@ -1,80 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Mariell Hoversholm <proximyst@proximyst.com>
-Date: Sun, 24 Oct 2021 16:20:31 -0400
-Subject: [PATCH] Add Raw Byte Entity Serialization
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, i
-         }
-     }
- 
-+    // Paper start - Entity serialization api
-+    public boolean serializeEntity(CompoundTag compound) {
-+        List<Entity> pass = new java.util.ArrayList<>(this.getPassengers());
-+        this.passengers = ImmutableList.of();
-+        boolean result = save(compound);
-+        this.passengers = ImmutableList.copyOf(pass);
-+        return result;
-+    }
-+    // Paper end
-     public boolean save(CompoundTag nbt) {
-         return this.isPassenger() ? false : this.saveAsPassenger(nbt);
-     }
-diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
-@@ -0,0 +0,0 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
-         }
-         return set;
-     }
-+
-+    @Override
-+    public boolean spawnAt(Location location, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason reason) {
-+        Preconditions.checkNotNull(location, "location cannot be null");
-+        Preconditions.checkNotNull(reason, "reason cannot be null");
-+        entity.level = ((CraftWorld) location.getWorld()).getHandle();
-+        entity.setPos(location.getX(), location.getY(), location.getZ());
-+        entity.setRot(location.getYaw(), location.getPitch());
-+        return !entity.valid && entity.level.addEntity(entity, reason);
-+    }
-     // Paper end
- }
-diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
-+++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
-@@ -0,0 +0,0 @@ public final class CraftMagicNumbers implements UnsafeValues {
-         return CraftItemStack.asCraftMirror(net.minecraft.world.item.ItemStack.of((CompoundTag) converted.getValue()));
-     }
- 
-+    @Override
-+    public byte[] serializeEntity(org.bukkit.entity.Entity entity) {
-+        Preconditions.checkNotNull(entity, "null cannot be serialized");
-+        Preconditions.checkArgument(entity instanceof org.bukkit.craftbukkit.entity.CraftEntity, "only CraftEntities can be serialized");
-+
-+        CompoundTag compound = new CompoundTag();
-+        ((org.bukkit.craftbukkit.entity.CraftEntity) entity).getHandle().serializeEntity(compound);
-+        return serializeNbtToBytes(compound);
-+    }
-+
-+    @Override
-+    public org.bukkit.entity.Entity deserializeEntity(byte[] data, org.bukkit.World world, boolean preserveUUID) {
-+        Preconditions.checkNotNull(data, "null cannot be deserialized");
-+        Preconditions.checkArgument(data.length > 0, "cannot deserialize nothing");
-+
-+        CompoundTag compound = deserializeNbtFromBytes(data);
-+        int dataVersion = compound.getInt("DataVersion");
-+        compound = ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.ENTITY, compound, dataVersion, getDataVersion());
-+        if (!preserveUUID) compound.remove("UUID"); // Generate a new UUID so we don't have to worry about deserializing the same entity twice
-+        return net.minecraft.world.entity.EntityType.create(compound, ((org.bukkit.craftbukkit.CraftWorld) world).getHandle())
-+            .orElseThrow(() -> new IllegalArgumentException("An ID was not found for the data. Did you downgrade?")).getBukkitEntity();
-+    }
-+
-     private byte[] serializeNbtToBytes(CompoundTag compound) {
-         compound.putInt("DataVersion", getDataVersion());
-         java.io.ByteArrayOutputStream outputStream = new java.io.ByteArrayOutputStream();
--- a/patches/unapplied/server/Add-packet-limiter-config.patch
+++ b/patches/unapplied/server/Add-packet-limiter-config.patch
@@ -1,205 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <spottedleaf@spottedleaf.dev>
-Date: Fri, 30 Oct 2020 22:37:16 -0700
-Subject: [PATCH] Add packet limiter config
-
-Example config:
-packet-limiter:
-  kick-message: '&cSent too many packets'
-  limits:
-    all:
-      interval: 7.0
-      max-packet-rate: 500.0
-    PacketPlayInAutoRecipe:
-      interval: 4.0
-      max-packet-rate: 5.0
-      action: DROP
-
-all section refers to all incoming packets, the action for all is
-hard coded to KICK.
-
-For specific limits, the section name is the class's name,
-and an action can be defined: DROP or KICK
-
-If interval or rate are less-than 0, the limit is ignored
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-         playerMaxConcurrentChunkLoads = getDouble("settings.chunk-loading.player-max-concurrent-loads", 4.0);
-         globalMaxConcurrentChunkLoads = getDouble("settings.chunk-loading.global-max-concurrent-loads", 500.0);
-     }
-+
-+    public static final class PacketLimit {
-+        public final double packetLimitInterval;
-+        public final double maxPacketRate;
-+        public final ViolateAction violateAction;
-+
-+        public PacketLimit(final double packetLimitInterval, final double maxPacketRate, final ViolateAction violateAction) {
-+            this.packetLimitInterval = packetLimitInterval;
-+            this.maxPacketRate = maxPacketRate;
-+            this.violateAction = violateAction;
-+        }
-+
-+        public static enum ViolateAction {
-+            KICK, DROP;
-+        }
-+    }
-+
-+    public static String kickMessage;
-+    public static PacketLimit allPacketsLimit;
-+    public static java.util.Map<Class<? extends net.minecraft.network.protocol.Packet<?>>, PacketLimit> packetSpecificLimits = new java.util.HashMap<>();
-+
-+    private static void packetLimiter() {
-+        packetSpecificLimits.clear();
-+        kickMessage = org.bukkit.ChatColor.translateAlternateColorCodes('&', getString("settings.packet-limiter.kick-message", "&cSent too many packets"));
-+        allPacketsLimit = new PacketLimit(
-+            getDouble("settings.packet-limiter.limits.all.interval", 7.0),
-+            getDouble("settings.packet-limiter.limits.all.max-packet-rate", 500.0),
-+            PacketLimit.ViolateAction.KICK
-+        );
-+        if (allPacketsLimit.maxPacketRate <= 0.0 || allPacketsLimit.packetLimitInterval <= 0.0) {
-+            allPacketsLimit = null;
-+        }
-+        final ConfigurationSection section = config.getConfigurationSection("settings.packet-limiter.limits");
-+
-+        // add default packets
-+
-+        // auto recipe limiting
-+        getDouble("settings.packet-limiter.limits." +
-+            "PacketPlayInAutoRecipe" + ".interval", 4.0);
-+        getDouble("settings.packet-limiter.limits." +
-+            "PacketPlayInAutoRecipe" + ".max-packet-rate", 5.0);
-+        getString("settings.packet-limiter.limits." +
-+            "PacketPlayInAutoRecipe" + ".action", PacketLimit.ViolateAction.DROP.name());
-+
-+        final Map<String, String> mojangToSpigot = new HashMap<>();
-+        final Map<String, io.papermc.paper.util.ObfHelper.ClassMapping> maps = io.papermc.paper.util.ObfHelper.INSTANCE.mappingsByObfName();
-+        if (maps != null) {
-+            maps.forEach((spigotName, classMapping) ->
-+                mojangToSpigot.put(classMapping.mojangName(), classMapping.obfName()));
-+        }
-+
-+        for (final String packetClassName : section.getKeys(false)) {
-+            if (packetClassName.equals("all")) {
-+                continue;
-+            }
-+            Class<?> packetClazz = null;
-+
-+            for (final String subpackage : List.of("game", "handshake", "login", "status")) {
-+                final String fullName = "net.minecraft.network.protocol." + subpackage + "." + packetClassName;
-+                try {
-+                    packetClazz = Class.forName(fullName);
-+                    break;
-+                } catch (final ClassNotFoundException ex) {
-+                    try {
-+                        final String spigot = mojangToSpigot.get(fullName);
-+                        if (spigot != null) {
-+                            packetClazz = Class.forName(spigot);
-+                        }
-+                    } catch (final ClassNotFoundException ignore) {}
-+                }
-+            }
-+
-+            if (packetClazz == null || !net.minecraft.network.protocol.Packet.class.isAssignableFrom(packetClazz)) {
-+                MinecraftServer.LOGGER.warn("Packet '" + packetClassName + "' does not exist, cannot limit it! Please update paper.yml");
-+                continue;
-+            }
-+
-+            if (!(section.get(packetClassName.concat(".interval")) instanceof Number) || !(section.get(packetClassName.concat(".max-packet-rate")) instanceof Number)) {
-+                throw new RuntimeException("Packet limit setting " + packetClassName + " is missing interval or max-packet-rate!");
-+            }
-+
-+            final String actionString = section.getString(packetClassName.concat(".action"), "KICK");
-+            PacketLimit.ViolateAction action = PacketLimit.ViolateAction.KICK;
-+            for (PacketLimit.ViolateAction test : PacketLimit.ViolateAction.values()) {
-+                if (actionString.equalsIgnoreCase(test.name())) {
-+                    action = test;
-+                    break;
-+                }
-+            }
-+
-+            final double interval = section.getDouble(packetClassName.concat(".interval"));
-+            final double rate = section.getDouble(packetClassName.concat(".max-packet-rate"));
-+
-+            if (interval > 0.0 && rate > 0.0) {
-+                packetSpecificLimits.put((Class)packetClazz, new PacketLimit(interval, rate, action));
-+            }
-+        }
-+    }
- }
-diff --git a/src/main/java/net/minecraft/network/Connection.java b/src/main/java/net/minecraft/network/Connection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/network/Connection.java
-+++ b/src/main/java/net/minecraft/network/Connection.java
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
-         }
-     }
-     // Paper end - allow controlled flushing
-+    // Paper start - packet limiter
-+    protected final Object PACKET_LIMIT_LOCK = new Object();
-+    protected final io.papermc.paper.util.IntervalledCounter allPacketCounts = com.destroystokyo.paper.PaperConfig.allPacketsLimit != null ? new io.papermc.paper.util.IntervalledCounter(
-+            (long)(com.destroystokyo.paper.PaperConfig.allPacketsLimit.packetLimitInterval * 1.0e9)
-+    ) : null;
-+    protected final java.util.Map<Class<? extends net.minecraft.network.protocol.Packet<?>>, io.papermc.paper.util.IntervalledCounter> packetSpecificLimits = new java.util.HashMap<>();
-+
-+    private boolean stopReadingPackets;
-+    private void killForPacketSpam() {
-+        this.sendPacket(new ClientboundDisconnectPacket(org.bukkit.craftbukkit.util.CraftChatMessage.fromString(com.destroystokyo.paper.PaperConfig.kickMessage, true)[0]), (future) -> {
-+            this.disconnect(org.bukkit.craftbukkit.util.CraftChatMessage.fromString(com.destroystokyo.paper.PaperConfig.kickMessage, true)[0]);
-+        });
-+        this.setReadOnly();
-+        this.stopReadingPackets = true;
-+    }
-+    // Paper end - packet limiter
- 
-     public Connection(PacketFlow side) {
-         this.receiving = side;
-@@ -0,0 +0,0 @@ public class Connection extends SimpleChannelInboundHandler<Packet<?>> {
- 
-     protected void channelRead0(ChannelHandlerContext channelhandlercontext, Packet<?> packet) {
-         if (this.channel.isOpen()) {
-+            // Paper start - packet limiter
-+            if (this.stopReadingPackets) {
-+                return;
-+            }
-+            if (this.allPacketCounts != null ||
-+                    com.destroystokyo.paper.PaperConfig.packetSpecificLimits.containsKey(packet.getClass())) {
-+                long time = System.nanoTime();
-+                synchronized (PACKET_LIMIT_LOCK) {
-+                    if (this.allPacketCounts != null) {
-+                        this.allPacketCounts.updateAndAdd(1, time);
-+                        if (this.allPacketCounts.getRate() >= com.destroystokyo.paper.PaperConfig.allPacketsLimit.maxPacketRate) {
-+                            this.killForPacketSpam();
-+                            return;
-+                        }
-+                    }
-+
-+                    for (Class<?> check = packet.getClass(); check != Object.class; check = check.getSuperclass()) {
-+                        com.destroystokyo.paper.PaperConfig.PacketLimit packetSpecificLimit =
-+                            com.destroystokyo.paper.PaperConfig.packetSpecificLimits.get(check);
-+                        if (packetSpecificLimit == null) {
-+                            continue;
-+                        }
-+                        io.papermc.paper.util.IntervalledCounter counter = this.packetSpecificLimits.computeIfAbsent((Class)check, (clazz) -> {
-+                            return new io.papermc.paper.util.IntervalledCounter((long)(packetSpecificLimit.packetLimitInterval * 1.0e9));
-+                        });
-+                        counter.updateAndAdd(1, time);
-+                        if (counter.getRate() >= packetSpecificLimit.maxPacketRate) {
-+                            switch (packetSpecificLimit.violateAction) {
-+                                case DROP:
-+                                    return;
-+                                case KICK:
-+                                    this.killForPacketSpam();
-+                                    return;
-+                            }
-+                        }
-+                    }
-+                }
-+            }
-+            // Paper end - packet limiter
-             try {
-                 Connection.genericsFtw(packet, this.packetListener);
-             } catch (RunningOnDifferentThreadException cancelledpackethandleexception) {
--- a/patches/unapplied/server/Add-paper-mobcaps-and-paper-playermobcaps.patch
+++ b/patches/unapplied/server/Add-paper-mobcaps-and-paper-playermobcaps.patch
@@ -1,373 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
-Date: Mon, 16 Aug 2021 01:31:54 -0500
-Subject: [PATCH] Add '/paper mobcaps' and '/paper playermobcaps'
-
-Add commands to get the mobcaps for a world, as well as the mobcaps for
-each player when per-player mob spawning is enabled.
-
-Also has a hover text on each mob category listing what entity types are
-in said category
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperCommand.java b/src/main/java/com/destroystokyo/paper/PaperCommand.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/com/destroystokyo/paper/PaperCommand.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperCommand.java
-@@ -0,0 +0,0 @@ package com.destroystokyo.paper;
- import com.destroystokyo.paper.io.SyncLoadFinder;
- import com.google.common.base.Functions;
- import com.google.common.base.Joiner;
-+import com.google.common.collect.ImmutableMap;
- import com.google.common.collect.ImmutableSet;
- import com.google.common.collect.Iterables;
- import com.google.common.collect.Lists;
-@@ -0,0 +0,0 @@ import com.google.common.collect.Maps;
- import com.google.gson.JsonObject;
- import com.google.gson.internal.Streams;
- import com.google.gson.stream.JsonWriter;
-+import net.kyori.adventure.text.Component;
-+import net.kyori.adventure.text.ComponentLike;
-+import net.kyori.adventure.text.TextComponent;
-+import net.kyori.adventure.text.format.NamedTextColor;
-+import net.kyori.adventure.text.format.TextColor;
-+import net.minecraft.core.Registry;
- import net.minecraft.resources.ResourceLocation;
- import net.minecraft.server.MCUtil;
- import net.minecraft.server.MinecraftServer;
-@@ -0,0 +0,0 @@ import net.minecraft.server.level.ServerLevel;
- import net.minecraft.server.level.ServerPlayer;
- import net.minecraft.server.level.ThreadedLevelLightEngine;
- import net.minecraft.world.entity.EntityType;
-+import net.minecraft.world.entity.MobCategory;
- import net.minecraft.world.level.ChunkPos;
- import net.minecraft.network.protocol.game.ClientboundLightUpdatePacket;
- import net.minecraft.resources.ResourceLocation;
- import net.minecraft.server.MCUtil;
-+import net.minecraft.world.level.NaturalSpawner;
- import org.apache.commons.lang3.tuple.MutablePair;
- import org.apache.commons.lang3.tuple.Pair;
- import org.bukkit.Bukkit;
-@@ -0,0 +0,0 @@ import java.util.List;
- import java.util.Locale;
- import java.util.Map;
- import java.util.Set;
-+import java.util.function.ToIntFunction;
- import java.util.stream.Collectors;
- 
- public class PaperCommand extends Command {
-     private static final String BASE_PERM = "bukkit.command.paper.";
-    private static final ImmutableSet<String> SUBCOMMANDS = ImmutableSet.<String>builder().add("heap", "entity", "reload", "version", "debug", "chunkinfo", "fixlight", "syncloadinfo", "dumpitem").build();
-+    private static final ImmutableSet<String> SUBCOMMANDS = ImmutableSet.<String>builder().add("heap", "entity", "reload", "version", "debug", "chunkinfo", "fixlight", "syncloadinfo", "dumpitem", "mobcaps", "playermobcaps").build();
- 
-     public PaperCommand(String name) {
-         super(name);
-@@ -0,0 +0,0 @@ public class PaperCommand extends Command {
-                     return getListMatchingLast(sender, args, "help", "chunks");
-                 }
-                 break;
-+            case "mobcaps":
-+                return getListMatchingLast(sender, args, this.suggestMobcaps(sender, args));
-+            case "playermobcaps":
-+                return getListMatchingLast(sender, args, this.suggestPlayerMobcaps(sender, args));
-             case "chunkinfo":
-                 List<String> worldNames = new ArrayList<>();
-                 worldNames.add("*");
-@@ -0,0 +0,0 @@ public class PaperCommand extends Command {
-             case "syncloadinfo":
-                 this.doSyncLoadInfo(sender, args);
-                 break;
-+            case "mobcaps":
-+                this.printMobcaps(sender, args);
-+                break;
-+            case "playermobcaps":
-+                this.printPlayerMobcaps(sender, args);
-+                break;
-             case "ver":
-                 if (!testPermission(sender, "version")) break; // "ver" needs a special check because it's an alias. All other commands are checked up before the switch statement (because they are present in the SUBCOMMANDS set)
-             case "version":
-@@ -0,0 +0,0 @@ public class PaperCommand extends Command {
-         }
-     }
- 
-+    public static final Map<MobCategory, TextColor> MOB_CATEGORY_COLORS = ImmutableMap.<MobCategory, TextColor>builder()
-+        .put(MobCategory.MONSTER, NamedTextColor.RED)
-+        .put(MobCategory.CREATURE, NamedTextColor.GREEN)
-+        .put(MobCategory.AMBIENT, NamedTextColor.GRAY)
-+        .put(MobCategory.UNDERGROUND_WATER_CREATURE, TextColor.color(0x3541E6))
-+        .put(MobCategory.WATER_CREATURE, TextColor.color(0x006EFF))
-+        .put(MobCategory.WATER_AMBIENT, TextColor.color(0x00B3FF))
-+        .put(MobCategory.MISC, TextColor.color(0x636363))
-+        .build();
-+
-+    private List<String> suggestMobcaps(CommandSender sender, String[] args) {
-+        if (args.length == 2) {
-+            final List<String> worlds = new ArrayList<>(Bukkit.getWorlds().stream().map(World::getName).toList());
-+            worlds.add("*");
-+            return worlds;
-+        }
-+
-+        return Collections.emptyList();
-+    }
-+
-+    private List<String> suggestPlayerMobcaps(CommandSender sender, String[] args) {
-+        if (args.length == 2) {
-+            final List<String> list = new ArrayList<>();
-+            for (final Player player : Bukkit.getOnlinePlayers()) {
-+                if (!(sender instanceof Player senderPlayer) || senderPlayer.canSee(player)) {
-+                    list.add(player.getName());
-+                }
-+            }
-+            return list;
-+        }
-+
-+        return Collections.emptyList();
-+    }
-+
-+    private void printMobcaps(CommandSender sender, String[] args) {
-+        final List<World> worlds;
-+        if (args.length == 1) {
-+            if (sender instanceof Player player) {
-+                worlds = List.of(player.getWorld());
-+            } else {
-+                sender.sendMessage(Component.text("Must specify a world! ex: '/paper mobcaps world'", NamedTextColor.RED));
-+                return;
-+            }
-+        } else if (args.length == 2) {
-+            final String input = args[1];
-+            if (input.equals("*")) {
-+                worlds = Bukkit.getWorlds();
-+            } else {
-+                final World world = Bukkit.getWorld(input);
-+                if (world == null) {
-+                    sender.sendMessage(Component.text("'" + input + "' is not a valid world!", NamedTextColor.RED));
-+                    return;
-+                } else {
-+                    worlds = List.of(world);
-+                }
-+            }
-+        } else {
-+            sender.sendMessage(Component.text("Too many arguments!", NamedTextColor.RED));
-+            return;
-+        }
-+
-+        for (final World world : worlds) {
-+            final ServerLevel level = ((CraftWorld) world).getHandle();
-+            final NaturalSpawner.SpawnState state = level.getChunkSource().getLastSpawnState();
-+
-+            final int chunks;
-+            if (state == null) {
-+                chunks = 0;
-+            } else {
-+                chunks = state.getSpawnableChunkCount();
-+            }
-+            sender.sendMessage(TextComponent.ofChildren(
-+                Component.text("Mobcaps for world: "),
-+                Component.text(world.getName(), NamedTextColor.AQUA),
-+                Component.text(" (" + chunks + " spawnable chunks)")
-+            ));
-+
-+            sender.sendMessage(this.buildMobcapsComponent(
-+                category -> {
-+                    if (state == null) {
-+                        return 0;
-+                    } else {
-+                        return state.getMobCategoryCounts().getOrDefault(category, 0);
-+                    }
-+                },
-+                category -> NaturalSpawner.globalLimitForCategory(level, category, chunks)
-+            ));
-+        }
-+    }
-+
-+    private void printPlayerMobcaps(CommandSender sender, String[] args) {
-+        final Player player;
-+        if (args.length == 1) {
-+            if (sender instanceof Player pl) {
-+                player = pl;
-+            } else {
-+                sender.sendMessage(Component.text("Must specify a player! ex: '/paper playermobcount playerName'", NamedTextColor.RED));
-+                return;
-+            }
-+        } else if (args.length == 2) {
-+            final String input = args[1];
-+            player = Bukkit.getPlayerExact(input);
-+            if (player == null) {
-+                sender.sendMessage(Component.text("Could not find player named '" + input + "'", NamedTextColor.RED));
-+                return;
-+            }
-+        } else {
-+            sender.sendMessage(Component.text("Too many arguments!", NamedTextColor.RED));
-+            return;
-+        }
-+
-+        final ServerPlayer serverPlayer = ((CraftPlayer) player).getHandle();
-+        final ServerLevel level = serverPlayer.getLevel();
-+
-+        if (!level.paperConfig.perPlayerMobSpawns) {
-+            sender.sendMessage(Component.text("Use '/paper mobcaps' for worlds where per-player mob spawning is disabled.", NamedTextColor.RED));
-+            return;
-+        }
-+
-+        sender.sendMessage(TextComponent.ofChildren(Component.text("Mobcaps for player: "), Component.text(player.getName(), NamedTextColor.GREEN)));
-+        sender.sendMessage(this.buildMobcapsComponent(
-+            category -> level.chunkSource.chunkMap.getMobCountNear(serverPlayer, category),
-+            category -> NaturalSpawner.limitForCategory(level, category)
-+        ));
-+    }
-+
-+    private Component buildMobcapsComponent(final ToIntFunction<MobCategory> countGetter, final ToIntFunction<MobCategory> limitGetter) {
-+        return MOB_CATEGORY_COLORS.entrySet().stream()
-+            .map(entry -> {
-+                final MobCategory category = entry.getKey();
-+                final TextColor color = entry.getValue();
-+
-+                final Component categoryHover = TextComponent.ofChildren(
-+                    Component.text("Entity types in category ", TextColor.color(0xE0E0E0)),
-+                    Component.text(category.getName(), color),
-+                    Component.text(':', NamedTextColor.GRAY),
-+                    Component.newline(),
-+                    Component.newline(),
-+                    Registry.ENTITY_TYPE.entrySet().stream()
-+                        .filter(it -> it.getValue().getCategory() == category)
-+                        .map(it -> Component.translatable(it.getValue().getDescriptionId()))
-+                        .collect(Component.toComponent(Component.text(", ", NamedTextColor.GRAY)))
-+                );
-+
-+                final Component categoryComponent = Component.text()
-+                    .content("  " + category.getName())
-+                    .color(color)
-+                    .hoverEvent(categoryHover)
-+                    .build();
-+
-+                final TextComponent.Builder builder = Component.text()
-+                    .append(
-+                        categoryComponent,
-+                        Component.text(": ", NamedTextColor.GRAY)
-+                    );
-+                final int limit = limitGetter.applyAsInt(category);
-+                if (limit != -1) {
-+                    builder.append(
-+                        Component.text(countGetter.applyAsInt(category)),
-+                        Component.text("/", NamedTextColor.GRAY),
-+                        Component.text(limit)
-+                    );
-+                } else {
-+                    builder.append(Component.text()
-+                        .append(
-+                            Component.text('n'),
-+                            Component.text("/", NamedTextColor.GRAY),
-+                            Component.text('a')
-+                        )
-+                        .hoverEvent(Component.text("This category does not naturally spawn.")));
-+                }
-+                return builder;
-+            })
-+            .map(ComponentLike::asComponent)
-+            .collect(Component.toComponent(Component.newline()));
-+    }
-+
-     private void doChunkInfo(CommandSender sender, String[] args) {
-         List<org.bukkit.World> worlds;
-         if (args.length < 2 || args[1].equals("*")) {
-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 {
-             MobCategory enumcreaturetype = aenumcreaturetype[j];
-             // CraftBukkit start - Use per-world spawn limits
-             boolean spawnThisTick = true;
-            int limit = enumcreaturetype.getMaxInstancesPerChunk();
-+            final int limit = limitForCategory(world, enumcreaturetype); // Paper
-             switch (enumcreaturetype) {
-                case MONSTER:
-                    spawnThisTick = spawnMonsterThisTick;
-                    limit = world.getWorld().getMonsterSpawnLimit();
-                    break;
-                case CREATURE:
-                    spawnThisTick = spawnAnimalThisTick;
-                    limit = world.getWorld().getAnimalSpawnLimit();
-                    break;
-                case WATER_CREATURE:
-                    spawnThisTick = spawnWaterThisTick;
-                    limit = world.getWorld().getWaterAnimalSpawnLimit();
-                    break;
-                case UNDERGROUND_WATER_CREATURE:
-                    spawnThisTick = spawnWaterUndergroundCreatureThisTick;
-                    limit = world.getWorld().getWaterUndergroundCreatureSpawnLimit();
-                    break;
-                case AMBIENT:
-                    spawnThisTick = spawnAmbientThisTick;
-                    limit = world.getWorld().getAmbientSpawnLimit();
-                    break;
-                case WATER_AMBIENT:
-                    spawnThisTick = spawnWaterAmbientThisTick;
-                    limit = world.getWorld().getWaterAmbientSpawnLimit();
-                    break;
-+                // Paper start - not mindiff so we get conflict on change
-+                case MONSTER -> spawnThisTick = spawnMonsterThisTick;
-+                case CREATURE -> spawnThisTick = spawnAnimalThisTick;
-+                case WATER_CREATURE -> spawnThisTick = spawnWaterThisTick;
-+                case UNDERGROUND_WATER_CREATURE -> spawnThisTick = spawnWaterUndergroundCreatureThisTick;
-+                case AMBIENT -> spawnThisTick = spawnAmbientThisTick;
-+                case WATER_AMBIENT -> spawnThisTick = spawnWaterAmbientThisTick;
-+                // Paper end
-             }
- 
-             if (!spawnThisTick || limit == 0) {
-@@ -0,0 +0,0 @@ public final class NaturalSpawner {
-         world.getProfiler().pop();
-     }
- 
-+    // Paper start
-+    public static int limitForCategory(final ServerLevel world, final MobCategory enumcreaturetype) {
-+        return switch (enumcreaturetype) {
-+            case MONSTER -> world.getWorld().getMonsterSpawnLimit();
-+            case CREATURE -> world.getWorld().getAnimalSpawnLimit();
-+            case WATER_CREATURE -> world.getWorld().getWaterAnimalSpawnLimit();
-+            case UNDERGROUND_WATER_CREATURE -> world.getWorld().getWaterUndergroundCreatureSpawnLimit();
-+            case AMBIENT -> world.getWorld().getAmbientSpawnLimit();
-+            case WATER_AMBIENT -> world.getWorld().getWaterAmbientSpawnLimit();
-+            default -> enumcreaturetype.getMaxInstancesPerChunk();
-+        };
-+    }
-+
-+    public static int globalLimitForCategory(final ServerLevel level, final MobCategory category, final int spawnableChunkCount) {
-+        final int categoryLimit = limitForCategory(level, category);
-+        if (categoryLimit < 1) {
-+            return categoryLimit;
-+        }
-+        return categoryLimit * spawnableChunkCount / NaturalSpawner.MAGIC_NUMBER;
-+    }
-+    // Paper end
-+
-     // Paper start - add parameters and int ret type
-     public static void spawnCategoryForChunk(MobCategory group, ServerLevel world, LevelChunk chunk, NaturalSpawner.SpawnPredicate checker, NaturalSpawner.AfterSpawnCallback runner) {
-         spawnCategoryForChunk(group, world, chunk, checker, runner);
-diff --git a/src/test/java/io/papermc/paper/PaperCommandTest.java b/src/test/java/io/papermc/paper/PaperCommandTest.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/test/java/io/papermc/paper/PaperCommandTest.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper;
-+
-+import com.destroystokyo.paper.PaperCommand;
-+import java.util.HashSet;
-+import java.util.Set;
-+import net.minecraft.world.entity.MobCategory;
-+import org.junit.Assert;
-+import org.junit.Test;
-+
-+public class PaperCommandTest {
-+    @Test
-+    public void testMobCategoryColors() {
-+        final Set<String> missing = new HashSet<>();
-+        for (final MobCategory value : MobCategory.values()) {
-+            if (!PaperCommand.MOB_CATEGORY_COLORS.containsKey(value)) {
-+                missing.add(value.getName());
-+            }
-+        }
-+        Assert.assertTrue("PaperCommand.MOB_CATEGORY_COLORS map missing TextColors for [" + String.join(", ", missing + "]"), missing.isEmpty());
-+    }
-+}
--- a/patches/unapplied/server/Allow-removal-addition-of-entities-to-entity-ticklis.patch
+++ b/patches/unapplied/server/Allow-removal-addition-of-entities-to-entity-ticklis.patch
@@ -1,89 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Sat, 19 Jun 2021 22:47:17 -0700
-Subject: [PATCH] Allow removal/addition of entities to entity ticklist during
- tick
-
-It really doesn't make any sense that we would iterate over removed
-entities during tick. Sure - tick entity checks removed, but
-does it check if the entity is in an entity ticking chunk?
-No it doesn't. So, allowing removal while iteration
-ENSURES only entities MARKED TO TICK are ticked.
-
-diff --git a/src/main/java/net/minecraft/world/level/entity/EntityTickList.java b/src/main/java/net/minecraft/world/level/entity/EntityTickList.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/entity/EntityTickList.java
-+++ b/src/main/java/net/minecraft/world/level/entity/EntityTickList.java
-@@ -0,0 +0,0 @@ import javax.annotation.Nullable;
- import net.minecraft.world.entity.Entity;
- 
- public class EntityTickList {
-    private Int2ObjectMap<Entity> active = new Int2ObjectLinkedOpenHashMap<>();
-    private Int2ObjectMap<Entity> passive = new Int2ObjectLinkedOpenHashMap<>();
-    @Nullable
-    private Int2ObjectMap<Entity> iterated;
-+    private final io.papermc.paper.util.maplist.IteratorSafeOrderedReferenceSet<Entity> entities = new io.papermc.paper.util.maplist.IteratorSafeOrderedReferenceSet<>(true); // Paper - rewrite this, always keep this updated - why would we EVER tick an entity that's not ticking?
- 
-     private void ensureActiveIsNotIterated() {
-        if (this.iterated == this.active) {
-            this.passive.clear();
-
-            for(Entry<Entity> entry : Int2ObjectMaps.fastIterable(this.active)) {
-                this.passive.put(entry.getIntKey(), entry.getValue());
-            }
-
-            Int2ObjectMap<Entity> int2ObjectMap = this.active;
-            this.active = this.passive;
-            this.passive = int2ObjectMap;
-        }
-+        // Paper - replace with better logic, do not delay removals
- 
-     }
- 
-     public void add(Entity entity) {
-         io.papermc.paper.util.TickThread.ensureTickThread("Asynchronous entity ticklist addition"); // Paper
-         this.ensureActiveIsNotIterated();
-        this.active.put(entity.getId(), entity);
-+        this.entities.add(entity); // Paper - replace with better logic, do not delay removals/additions
-     }
- 
-     public void remove(Entity entity) {
-         io.papermc.paper.util.TickThread.ensureTickThread("Asynchronous entity ticklist removal"); // Paper
-         this.ensureActiveIsNotIterated();
-        this.active.remove(entity.getId());
-+        this.entities.remove(entity); // Paper - replace with better logic, do not delay removals/additions
-     }
- 
-     public boolean contains(Entity entity) {
-        return this.active.containsKey(entity.getId());
-+        return this.entities.contains(entity); // Paper - replace with better logic, do not delay removals/additions
-     }
- 
-     public void forEach(Consumer<Entity> action) {
-         io.papermc.paper.util.TickThread.ensureTickThread("Asynchronous entity ticklist iteration"); // Paper
-        if (this.iterated != null) {
-            throw new UnsupportedOperationException("Only one concurrent iteration supported");
-        } else {
-            this.iterated = this.active;
-
-            try {
-                for(Entity entity : this.active.values()) {
-                    action.accept(entity);
-                }
-            } finally {
-                this.iterated = null;
-+        // Paper start - replace with better logic, do not delay removals/additions
-+        // To ensure nothing weird happens with dimension travelling, do not iterate over new entries...
-+        // (by dfl iterator() is configured to not iterate over new entries)
-+        io.papermc.paper.util.maplist.IteratorSafeOrderedReferenceSet.Iterator<Entity> iterator = this.entities.iterator();
-+        try {
-+            while (iterator.hasNext()) {
-+                action.accept(iterator.next());
-             }
-
-+        } finally {
-+            iterator.finishedIterating();
-         }
-+        // Paper end - replace with better logic, do not delay removals/additions
-     }
- }
--- a/patches/unapplied/server/Consolidate-flush-calls-for-entity-tracker-packets.patch
+++ b/patches/unapplied/server/Consolidate-flush-calls-for-entity-tracker-packets.patch
@@ -1,52 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <spottedleaf@spottedleaf.dev>
-Date: Sat, 4 Apr 2020 17:00:20 -0700
-Subject: [PATCH] Consolidate flush calls for entity tracker packets
-
-Most server packets seem to be sent from here, so try to avoid
-expensive flush calls from them.
-
-This change was motivated due to local testing:
-
- My server spawn has 130 cows in it (for testing a prev. patch)
- Try to let 200 players join spawn
-
-Without this change, I could only get 20 players on before they
-all started timing out due to the load put on the Netty I/O threads.
-
-With this change I could get all 200 on at 0ms ping.
-
-(one of the primary issues is that my CPU is kinda trash, and having
-4 extra threads at 100% is just too much for it).
-
-So in general this patch should reduce Netty I/O thread load.
-
-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 {
-             this.level.getProfiler().pop();
-         }
- 
-+        // Paper start - controlled flush for entity tracker packets
-+        List<net.minecraft.network.Connection> disabledFlushes = new java.util.ArrayList<>(this.level.players.size());
-+        for (ServerPlayer player : this.level.players) {
-+            net.minecraft.server.network.ServerGamePacketListenerImpl connection = player.connection;
-+            if (connection != null) {
-+                connection.connection.disableAutomaticFlush();
-+                disabledFlushes.add(connection.connection);
-+            }
-+        }
-+        try { // Paper end - controlled flush for entity tracker packets
-         this.chunkMap.tick();
-+        // Paper start - controlled flush for entity tracker packets
-+        } finally {
-+            for (net.minecraft.network.Connection networkManager : disabledFlushes) {
-+                networkManager.enableAutomaticFlush();
-+            }
-+        }
-+        // Paper end - controlled flush for entity tracker packets
-     }
- 
-     private void getFullChunk(long pos, Consumer<LevelChunk> chunkConsumer) {
--- a/patches/unapplied/server/Custom-table-implementation-for-blockstate-state-loo.patch
+++ b/patches/unapplied/server/Custom-table-implementation-for-blockstate-state-loo.patch
@@ -1,343 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Thu, 11 Mar 2021 20:05:44 -0800
-Subject: [PATCH] Custom table implementation for blockstate state lookups
-
-Testing some redstone intensive machines showed to bring about a 10%
-improvement.
-
-diff --git a/src/main/java/io/papermc/paper/util/table/ZeroCollidingReferenceStateTable.java b/src/main/java/io/papermc/paper/util/table/ZeroCollidingReferenceStateTable.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/main/java/io/papermc/paper/util/table/ZeroCollidingReferenceStateTable.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.util.table;
-+
-+import com.google.common.collect.Table;
-+import net.minecraft.world.level.block.state.StateHolder;
-+import net.minecraft.world.level.block.state.properties.Property;
-+import java.util.Collection;
-+import java.util.HashSet;
-+import java.util.Map;
-+import java.util.Set;
-+
-+public final class ZeroCollidingReferenceStateTable {
-+
-+    // upper 32 bits: starting index
-+    // lower 32 bits: bitset for contained ids
-+    protected final long[] this_index_table;
-+    protected final Comparable<?>[] this_table;
-+    protected final StateHolder<?, ?> this_state;
-+
-+    protected long[] index_table;
-+    protected StateHolder<?, ?>[][] value_table;
-+
-+    public ZeroCollidingReferenceStateTable(final StateHolder<?, ?> state, final Map<Property<?>, Comparable<?>> this_map) {
-+        this.this_state = state;
-+        this.this_index_table = this.create_table(this_map.keySet());
-+
-+        int max_id = -1;
-+        for (final Property<?> property : this_map.keySet()) {
-+            final int id = lookup_vindex(property, this.this_index_table);
-+            if (id > max_id) {
-+                max_id = id;
-+            }
-+        }
-+
-+        this.this_table = new Comparable[max_id + 1];
-+        for (final Map.Entry<Property<?>, Comparable<?>> entry : this_map.entrySet()) {
-+            this.this_table[lookup_vindex(entry.getKey(), this.this_index_table)] = entry.getValue();
-+        }
-+    }
-+
-+    public void loadInTable(final Table<Property<?>, Comparable<?>, StateHolder<?, ?>> table,
-+                            final Map<Property<?>, Comparable<?>> this_map) {
-+        final Set<Property<?>> combined = new HashSet<>(table.rowKeySet());
-+        combined.addAll(this_map.keySet());
-+
-+        this.index_table = this.create_table(combined);
-+
-+        int max_id = -1;
-+        for (final Property<?> property : combined) {
-+            final int id = lookup_vindex(property, this.index_table);
-+            if (id > max_id) {
-+                max_id = id;
-+            }
-+        }
-+
-+        this.value_table = new StateHolder[max_id + 1][];
-+
-+        final Map<Property<?>, Map<Comparable<?>, StateHolder<?, ?>>> map = table.rowMap();
-+        for (final Property<?> property : map.keySet()) {
-+            final Map<Comparable<?>, StateHolder<?, ?>> propertyMap = map.get(property);
-+
-+            final int id = lookup_vindex(property, this.index_table);
-+            final StateHolder<?, ?>[] states = this.value_table[id] = new StateHolder[property.getPossibleValues().size()];
-+
-+            for (final Map.Entry<Comparable<?>, StateHolder<?, ?>> entry : propertyMap.entrySet()) {
-+                if (entry.getValue() == null) {
-+                    // TODO what
-+                    continue;
-+                }
-+
-+                states[((Property)property).getIdFor(entry.getKey())] = entry.getValue();
-+            }
-+        }
-+
-+
-+        for (final Map.Entry<Property<?>, Comparable<?>> entry : this_map.entrySet()) {
-+            final Property<?> property = entry.getKey();
-+            final int index = lookup_vindex(property, this.index_table);
-+
-+            if (this.value_table[index] == null) {
-+                this.value_table[index] = new StateHolder[property.getPossibleValues().size()];
-+            }
-+
-+            this.value_table[index][((Property)property).getIdFor(entry.getValue())] = this.this_state;
-+        }
-+    }
-+
-+
-+    protected long[] create_table(final Collection<Property<?>> collection) {
-+        int max_id = -1;
-+        for (final Property<?> property : collection) {
-+            final int id = property.getId();
-+            if (id > max_id) {
-+                max_id = id;
-+            }
-+        }
-+
-+        final long[] ret = new long[((max_id + 1) + 31) >>> 5]; // ceil((max_id + 1) / 32)
-+
-+        for (final Property<?> property : collection) {
-+            final int id = property.getId();
-+
-+            ret[id >>> 5] |= (1L << (id & 31));
-+        }
-+
-+        int total = 0;
-+        for (int i = 1, len = ret.length; i < len; ++i) {
-+            ret[i] |= (long)(total += Long.bitCount(ret[i - 1] & 0xFFFFFFFFL)) << 32;
-+        }
-+
-+        return ret;
-+    }
-+
-+    public Comparable<?> get(final Property<?> state) {
-+        final Comparable<?>[] table = this.this_table;
-+        final int index = lookup_vindex(state, this.this_index_table);
-+
-+        if (index < 0 || index >= table.length) {
-+            return null;
-+        }
-+        return table[index];
-+    }
-+
-+    public StateHolder<?, ?> get(final Property<?> property, final Comparable<?> with) {
-+        final int withId = ((Property)property).getIdFor(with);
-+        if (withId < 0) {
-+            return null;
-+        }
-+
-+        final int index = lookup_vindex(property, this.index_table);
-+        final StateHolder<?, ?>[][] table = this.value_table;
-+        if (index < 0 || index >= table.length) {
-+            return null;
-+        }
-+
-+        final StateHolder<?, ?>[] values = table[index];
-+
-+        if (withId >= values.length) {
-+            return null;
-+        }
-+
-+        return values[withId];
-+    }
-+
-+    protected static int lookup_vindex(final Property<?> property, final long[] index_table) {
-+        final int id = property.getId();
-+        final long bitset_mask = (1L << (id & 31));
-+        final long lower_mask = bitset_mask - 1;
-+        final int index = id >>> 5;
-+        if (index >= index_table.length) {
-+            return -1;
-+        }
-+        final long index_value = index_table[index];
-+        final long contains_check = ((index_value & bitset_mask) - 1) >> (Long.SIZE - 1); // -1L if doesn't contain
-+
-+        // index = total bits set in lower table values (upper 32 bits of index_value) plus total bits set in lower indices below id
-+        // contains_check is 0 if the bitset had id set, else it's -1: so index is unaffected if contains_check == 0,
-+        // otherwise it comes out as -1.
-+        return (int)(((index_value >>> 32) + Long.bitCount(index_value & lower_mask)) | contains_check);
-+    }
-+}
-diff --git a/src/main/java/net/minecraft/world/level/block/state/StateHolder.java b/src/main/java/net/minecraft/world/level/block/state/StateHolder.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/block/state/StateHolder.java
-+++ b/src/main/java/net/minecraft/world/level/block/state/StateHolder.java
-@@ -0,0 +0,0 @@ public abstract class StateHolder<O, S> {
-     private final ImmutableMap<Property<?>, Comparable<?>> values;
-     private Table<Property<?>, Comparable<?>, S> neighbours;
-     protected final MapCodec<S> propertiesCodec;
-+    protected final io.papermc.paper.util.table.ZeroCollidingReferenceStateTable optimisedTable; // Paper - optimise state lookup
- 
-     protected StateHolder(O owner, ImmutableMap<Property<?>, Comparable<?>> entries, MapCodec<S> codec) {
-         this.owner = owner;
-         this.values = entries;
-         this.propertiesCodec = codec;
-+        this.optimisedTable = new io.papermc.paper.util.table.ZeroCollidingReferenceStateTable(this, entries); // Paper - optimise state lookup
-     }
- 
-     public <T extends Comparable<T>> S cycle(Property<T> property) {
-@@ -0,0 +0,0 @@ public abstract class StateHolder<O, S> {
-     }
- 
-     public <T extends Comparable<T>> boolean hasProperty(Property<T> property) {
-        return this.values.containsKey(property);
-+        return this.optimisedTable.get(property) != null; // Paper - optimise state lookup
-     }
- 
-     public <T extends Comparable<T>> T getValue(Property<T> property) {
-        Comparable<?> comparable = this.values.get(property);
-+        Comparable<?> comparable = this.optimisedTable.get(property); // Paper - optimise state lookup
-         if (comparable == null) {
-             throw new IllegalArgumentException("Cannot get property " + property + " as it does not exist in " + this.owner);
-         } else {
-@@ -0,0 +0,0 @@ public abstract class StateHolder<O, S> {
-     }
- 
-     public <T extends Comparable<T>> Optional<T> getOptionalValue(Property<T> property) {
-        Comparable<?> comparable = this.values.get(property);
-+        Comparable<?> comparable = this.optimisedTable.get(property); // Paper - optimise state lookup
-         return comparable == null ? Optional.empty() : Optional.of(property.getValueClass().cast(comparable));
-     }
- 
-     public <T extends Comparable<T>, V extends T> S setValue(Property<T> property, V value) {
-        Comparable<?> comparable = this.values.get(property);
-        if (comparable == null) {
-            throw new IllegalArgumentException("Cannot set property " + property + " as it does not exist in " + this.owner);
-        } else if (comparable == value) {
-            return (S)this;
-        } else {
-            S object = this.neighbours.get(property, value);
-            if (object == null) {
-                throw new IllegalArgumentException("Cannot set property " + property + " to " + value + " on " + this.owner + ", it is not an allowed value");
-            } else {
-                return object;
-            }
-+        // Paper start - optimise state lookup
-+        final S ret = (S)this.optimisedTable.get(property, value);
-+        if (ret == null) {
-+            throw new IllegalArgumentException("Cannot set property " + property + " to " + value + " on " + this.owner + ", it is not an allowed value");
-         }
-+        return ret;
-+        // Paper end - optimise state lookup
-     }
- 
-     public void populateNeighbours(Map<Map<Property<?>, Comparable<?>>, S> states) {
-@@ -0,0 +0,0 @@ public abstract class StateHolder<O, S> {
-                 }
-             }
- 
-            this.neighbours = (Table<Property<?>, Comparable<?>, S>)(table.isEmpty() ? table : ArrayTable.create(table));
-+            this.neighbours = (Table<Property<?>, Comparable<?>, S>)(table.isEmpty() ? table : ArrayTable.create(table)); this.optimisedTable.loadInTable((Table)this.neighbours, this.values); // Paper - optimise state lookup
-         }
-     }
- 
-diff --git a/src/main/java/net/minecraft/world/level/block/state/properties/BooleanProperty.java b/src/main/java/net/minecraft/world/level/block/state/properties/BooleanProperty.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/block/state/properties/BooleanProperty.java
-+++ b/src/main/java/net/minecraft/world/level/block/state/properties/BooleanProperty.java
-@@ -0,0 +0,0 @@ import java.util.Optional;
- public class BooleanProperty extends Property<Boolean> {
-     private final ImmutableSet<Boolean> values = ImmutableSet.of(true, false);
- 
-+    // Paper start - optimise iblockdata state lookup
-+    @Override
-+    public final int getIdFor(final Boolean value) {
-+        return value.booleanValue() ? 1 : 0;
-+    }
-+    // Paper end - optimise iblockdata state lookup
-+
-     protected BooleanProperty(String name) {
-         super(name, Boolean.class);
-     }
-diff --git a/src/main/java/net/minecraft/world/level/block/state/properties/EnumProperty.java b/src/main/java/net/minecraft/world/level/block/state/properties/EnumProperty.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/block/state/properties/EnumProperty.java
-+++ b/src/main/java/net/minecraft/world/level/block/state/properties/EnumProperty.java
-@@ -0,0 +0,0 @@ public class EnumProperty<T extends Enum<T> & StringRepresentable> extends Prope
-     private final ImmutableSet<T> values;
-     private final Map<String, T> names = Maps.newHashMap();
- 
-+    // Paper start - optimise iblockdata state lookup
-+    private int[] idLookupTable;
-+
-+    @Override
-+    public final int getIdFor(final T value) {
-+        return this.idLookupTable[value.ordinal()];
-+    }
-+    // Paper end - optimise iblockdata state lookup
-+
-     protected EnumProperty(String name, Class<T> type, Collection<T> values) {
-         super(name, type);
-         this.values = ImmutableSet.copyOf(values);
-@@ -0,0 +0,0 @@ public class EnumProperty<T extends Enum<T> & StringRepresentable> extends Prope
-             this.names.put(string, enum_);
-         }
- 
-+        // Paper start - optimise iblockdata state lookup
-+        int id = 0;
-+        this.idLookupTable = new int[type.getEnumConstants().length];
-+        java.util.Arrays.fill(this.idLookupTable, -1);
-+        for (final T value : this.getPossibleValues()) {
-+            this.idLookupTable[value.ordinal()] = id++;
-+        }
-+        // Paper end - optimise iblockdata state lookup
-     }
- 
-     @Override
-diff --git a/src/main/java/net/minecraft/world/level/block/state/properties/IntegerProperty.java b/src/main/java/net/minecraft/world/level/block/state/properties/IntegerProperty.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/block/state/properties/IntegerProperty.java
-+++ b/src/main/java/net/minecraft/world/level/block/state/properties/IntegerProperty.java
-@@ -0,0 +0,0 @@ public class IntegerProperty extends Property<Integer> {
-     public final int min;
-     public final int max;
- 
-+    // Paper start - optimise iblockdata state lookup
-+    @Override
-+    public final int getIdFor(final Integer value) {
-+        final int val = value.intValue();
-+        final int ret = val - this.min;
-+
-+        return ret | ((this.max - ret) >> 31);
-+    }
-+    // Paper end - optimise iblockdata state lookup
-+
-     protected IntegerProperty(String name, int min, int max) {
-         super(name, Integer.class);
-         this.min = min;
-diff --git a/src/main/java/net/minecraft/world/level/block/state/properties/Property.java b/src/main/java/net/minecraft/world/level/block/state/properties/Property.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/block/state/properties/Property.java
-+++ b/src/main/java/net/minecraft/world/level/block/state/properties/Property.java
-@@ -0,0 +0,0 @@ public abstract class Property<T extends Comparable<T>> {
-     }, this::getName);
-     private final Codec<Property.Value<T>> valueCodec = this.codec.xmap(this::value, Property.Value::value);
- 
-+    // Paper start - optimise iblockdata state lookup
-+    private static final java.util.concurrent.atomic.AtomicInteger ID_GENERATOR = new java.util.concurrent.atomic.AtomicInteger();
-+    private final int id = ID_GENERATOR.getAndIncrement();
-+
-+    public final int getId() {
-+        return this.id;
-+    }
-+
-+    public abstract int getIdFor(final T value);
-+    // Paper end - optimise state lookup
-+
-     protected Property(String name, Class<T> type) {
-         this.clazz = type;
-         this.name = name;
--- a/patches/unapplied/server/Detail-more-information-in-watchdog-dumps.patch
+++ b/patches/unapplied/server/Detail-more-information-in-watchdog-dumps.patch
@@ -1,296 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <spottedleaf@spottedleaf.dev>
-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 ServerGamePacketListenerImpl) {
-+            // Paper start - detailed watchdog information
-+            net.minecraft.network.protocol.PacketUtils.packetProcessing.push(this.packetListener);
-+            try {
-+            // Paper end - detailed watchdog information
-             ((ServerGamePacketListenerImpl) this.packetListener).tick();
-+            } finally { // Paper start - detailed watchdog information
-+                net.minecraft.network.protocol.PacketUtils.packetProcessing.pop();
-+            } // Paper start - detailed watchdog information
-         }
- 
-         if (!this.isConnected() && !this.disconnectionHandled) {
-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 = LogManager.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 {
-         if (!engine.isSameThread()) {
-             Timing timing = MinecraftTimings.getPacketTiming(packet); // Paper - timings
-             engine.execute(() -> {
-+                packetProcessing.push(listener); // Paper - detailed watchdog information
-+                try { // Paper - detailed watchdog information
-                 if (MinecraftServer.getServer().hasStopped() || (listener instanceof ServerGamePacketListenerImpl && ((ServerGamePacketListenerImpl) listener).processedDisconnect)) return; // CraftBukkit, MC-142590
-                 if (listener.getConnection().isConnected()) {
-                     try (Timing ignored = timing.startTiming()) { // Paper - timings
-@@ -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 WorldGenLevel {
- 
-     }
- 
-+    // 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
-+        io.papermc.paper.util.TickThread.ensureTickThread("Cannot tick an entity off-main");
-+        try {
-+            if (currentlyTickingEntity.get() == null) {
-+                currentlyTickingEntity.lazySet(entity);
-+            }
-+            // Paper end - log detailed entity tick information
-         ++TimingHistory.entityTicks; // Paper - timings
-         // Spigot start
-         co.aikar.timings.Timing timer; // Paper
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
-             this.tickPassenger(entity, entity1);
-         }
-         // } finally { timer.stopTiming(); } // Paper - timings - move up
-
-+        // 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) {
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, n
-         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 movementType, Vec3 movement) {
-+        // Paper start - detailed watchdog information
-+        io.papermc.paper.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 Nameable, EntityAccess, CommandSource, n
-                 this.level.getProfiler().pop();
-             }
-         }
-+        // Paper start - detailed watchdog information
-+        } finally {
-+            synchronized (this.posLock) { // Paper
-+                this.moveVector = null;
-+            } // Paper
-+        }
-+        // Paper end - detailed watchdog information
-     }
- 
-     protected void tryCheckInsideBlocks() {
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, n
-     }
- 
-     public void setDeltaMovement(Vec3 velocity) {
-+        synchronized (this.posLock) { // Paper
-         this.deltaMovement = velocity;
-+        } // Paper
-     }
- 
-     public void setDeltaMovement(double x, double y, double z) {
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, n
-         }
-         // 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 Thread
-     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 = entity.getMinecraftKey().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 Thread
-                 log.log( Level.SEVERE, "------------------------------" );
-                 log.log( Level.SEVERE, "Server thread dump (Look for plugins here before reporting to Paper!):" ); // Paper
-                 com.destroystokyo.paper.io.chunk.ChunkTaskManager.dumpAllChunkLoadInfo(); // Paper
-+                this.dumpTickingInfo(); // Paper - log detailed tick information
-                 WatchdogThread.dumpThread( ManagementFactory.getThreadMXBean().getThreadInfo( server.serverThread.getId(), Integer.MAX_VALUE ), log );
-                 log.log( Level.SEVERE, "------------------------------" );
-                 //
--- a/patches/unapplied/server/Distance-manager-tick-timings.patch
+++ b/patches/unapplied/server/Distance-manager-tick-timings.patch
@@ -1,40 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <spottedleaf@spottedleaf.dev>
-Date: Sat, 18 Jul 2020 16:03:57 -0700
-Subject: [PATCH] Distance manager tick timings
-
-Recently this has been taking up more time, so add a timings to
-really figure out how much.
-
-diff --git a/src/main/java/co/aikar/timings/MinecraftTimings.java b/src/main/java/co/aikar/timings/MinecraftTimings.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/co/aikar/timings/MinecraftTimings.java
-+++ b/src/main/java/co/aikar/timings/MinecraftTimings.java
-@@ -0,0 +0,0 @@ public final class MinecraftTimings {
- 
-     public static final Timing antiXrayUpdateTimer = Timings.ofSafe("anti-xray - update");
-     public static final Timing antiXrayObfuscateTimer = Timings.ofSafe("anti-xray - obfuscate");
-+    public static final Timing distanceManagerTick = Timings.ofSafe("Distance Manager Tick"); // Paper - add timings for distance manager
- 
-     public static final Timing midTickChunkTasks = Timings.ofSafe("Mid Tick Chunk Tasks");
- 
-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 {
-     public boolean runDistanceManagerUpdates() {
-         if (distanceManager.delayDistanceManagerTick) return false; // Paper - Chunk priority
-         if (this.chunkMap.unloadingPlayerChunk) { net.minecraft.server.MinecraftServer.LOGGER.fatal("Cannot tick distance manager while unloading playerchunks", new Throwable()); throw new IllegalStateException("Cannot tick distance manager while unloading playerchunks"); } // Paper
-+        co.aikar.timings.MinecraftTimings.distanceManagerTick.startTiming(); try { // Paper - add timings for distance manager
-         boolean flag = this.distanceManager.runAllUpdates(this.chunkMap);
-         boolean flag1 = this.chunkMap.promoteChunkMap();
- 
-@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
-             this.clearCache();
-             return true;
-         }
-+        } finally { co.aikar.timings.MinecraftTimings.distanceManagerTick.stopTiming(); } // Paper - add timings for distance manager
-     }
- 
-     // Paper start - helper
--- a/patches/unapplied/server/Do-not-run-raytrace-logic-for-AIR.patch
+++ b/patches/unapplied/server/Do-not-run-raytrace-logic-for-AIR.patch
@@ -1,22 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Sun, 7 Mar 2021 13:15:04 -0800
-Subject: [PATCH] Do not run raytrace logic for AIR
-
-Saves approx. 5% for the raytrace call, as most (expensive)
-raytracing tends to go through air and returning early is an
-easy win. The remaining problems with this function
-are mostly with the block getting itself.
-
-diff --git a/src/main/java/net/minecraft/world/level/BlockGetter.java b/src/main/java/net/minecraft/world/level/BlockGetter.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/BlockGetter.java
-+++ b/src/main/java/net/minecraft/world/level/BlockGetter.java
-@@ -0,0 +0,0 @@ public interface BlockGetter extends LevelHeightAccessor {
-                 return BlockHitResult.miss(raytrace1.getTo(), Direction.getNearest(vec3d.x, vec3d.y, vec3d.z), new BlockPos(raytrace1.getTo()));
-             }
-             // Paper end
-+            if (iblockdata.isAir()) return null; // Paper - optimise air cases
-             FluidState fluid = iblockdata.getFluidState(); // Paper - don't need to go to world state again
-             Vec3 vec3d = raytrace1.getFrom();
-             Vec3 vec3d1 = raytrace1.getTo();
--- a/patches/unapplied/server/Don-t-lookup-fluid-state-when-raytracing.patch
+++ b/patches/unapplied/server/Don-t-lookup-fluid-state-when-raytracing.patch
@@ -1,20 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <spottedleaf@spottedleaf.dev>
-Date: Fri, 28 Aug 2020 12:33:47 -0700
-Subject: [PATCH] Don't lookup fluid state when raytracing
-
-Just use the iblockdata already retrieved, removes a getType call.
-
-diff --git a/src/main/java/net/minecraft/world/level/BlockGetter.java b/src/main/java/net/minecraft/world/level/BlockGetter.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/BlockGetter.java
-+++ b/src/main/java/net/minecraft/world/level/BlockGetter.java
-@@ -0,0 +0,0 @@ public interface BlockGetter extends LevelHeightAccessor {
-                 return BlockHitResult.miss(raytrace1.getTo(), Direction.getNearest(vec3d.x, vec3d.y, vec3d.z), new BlockPos(raytrace1.getTo()));
-             }
-             // Paper end
-            FluidState fluid = this.getFluidState(blockposition);
-+            FluidState fluid = iblockdata.getFluidState(); // Paper - don't need to go to world state again
-             Vec3 vec3d = raytrace1.getFrom();
-             Vec3 vec3d1 = raytrace1.getTo();
-             VoxelShape voxelshape = raytrace1.getBlockShape(iblockdata, this, blockposition);
--- a/patches/unapplied/server/Highly-optimise-single-and-multi-AABB-VoxelShapes-an.patch
+++ b/patches/unapplied/server/Highly-optimise-single-and-multi-AABB-VoxelShapes-an.patch
--- a/patches/unapplied/server/Lag-compensate-block-breaking.patch
+++ b/patches/unapplied/server/Lag-compensate-block-breaking.patch
@@ -1,155 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <spottedleaf@spottedleaf.dev>
-Date: Fri, 14 Feb 2020 22:16:34 -0800
-Subject: [PATCH] Lag compensate block breaking
-
-Use time instead of ticks if ticks fall behind
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-             }
-         }
-     }
-+
-+    public static boolean lagCompensateBlockBreaking;
-+
-+    private static void lagCompensateBlockBreaking() {
-+        lagCompensateBlockBreaking = getBoolean("settings.lag-compensate-block-breaking", true);
-+    }
- }
-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 {
-     @Nullable
-     private GameType previousGameModeForPlayer;
-     private boolean isDestroyingBlock;
-    private int destroyProgressStart;
-+    private int destroyProgressStart; private long lastDigTime; // Paper - lag compensate block breaking
-     private BlockPos destroyPos;
-     private int gameTicks;
-     private boolean hasDelayedDestroy;
-     private BlockPos delayedDestroyPos;
-    private int delayedTickStart;
-+    private int delayedTickStart; private long hasDestroyedTooFastStartTime; // Paper - lag compensate block breaking
-     private int lastSentState;
- 
-+    // Paper start - lag compensate block breaking
-+    private int getTimeDiggingLagCompensate() {
-+        int lagCompensated = (int)((System.nanoTime() - this.lastDigTime) / (50L * 1000L * 1000L));
-+        int tickDiff = this.gameTicks - this.destroyProgressStart;
-+        return (com.destroystokyo.paper.PaperConfig.lagCompensateBlockBreaking && lagCompensated > (tickDiff + 1)) ? lagCompensated : tickDiff; // add one to ensure we don't lag compensate unless we need to
-+    }
-+
-+    private int getTimeDiggingTooFastLagCompensate() {
-+        int lagCompensated = (int)((System.nanoTime() - this.hasDestroyedTooFastStartTime) / (50L * 1000L * 1000L));
-+        int tickDiff = this.gameTicks - this.delayedTickStart;
-+        return (com.destroystokyo.paper.PaperConfig.lagCompensateBlockBreaking && lagCompensated > (tickDiff + 1)) ? lagCompensated : tickDiff; // add one to ensure we don't lag compensate unless we need to
-+    }
-+    // Paper end
-+
-     public ServerPlayerGameMode(ServerPlayer player) {
-         this.gameModeForPlayer = GameType.DEFAULT_MODE;
-         this.destroyPos = BlockPos.ZERO;
-@@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
-             if (iblockdata == null || iblockdata.isAir()) { // Paper
-                 this.hasDelayedDestroy = false;
-             } else {
-                float f = this.incrementDestroyProgress(iblockdata, this.delayedDestroyPos, this.delayedTickStart);
-+                float f = this.updateBlockBreakAnimation(iblockdata, this.delayedDestroyPos, this.getTimeDiggingTooFastLagCompensate()); // Paper - lag compensate destroying blocks
- 
-                 if (f >= 1.0F) {
-                     this.hasDelayedDestroy = false;
-@@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
-                 this.lastSentState = -1;
-                 this.isDestroyingBlock = false;
-             } else {
-                this.incrementDestroyProgress(iblockdata, this.destroyPos, this.destroyProgressStart);
-+                this.updateBlockBreakAnimation(iblockdata, this.destroyPos, this.getTimeDiggingLagCompensate()); // Paper - lag compensate destroying
-             }
-         }
- 
-@@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
- 
-     private float incrementDestroyProgress(BlockState state, BlockPos pos, int i) {
-         int j = this.gameTicks - i;
-+        // Paper start - change i (startTime) to totalTime
-+        return this.updateBlockBreakAnimation(state, pos, j);
-+    }
-+    private float updateBlockBreakAnimation(BlockState state, BlockPos pos, int totalTime) {
-+        int j = totalTime;
-+        // Paper end
-         float f = state.getDestroyProgress(this.player, this.player.level, pos) * (float) (j + 1);
-         int k = (int) (f * 10.0F);
- 
-@@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
-                     return;
-                 }
- 
-                this.destroyProgressStart = this.gameTicks;
-+                this.destroyProgressStart = this.gameTicks; this.lastDigTime = System.nanoTime(); // Paper - lag compensate block breaking
-                 float f = 1.0F;
- 
-                 iblockdata = this.level.getBlockState(pos);
-@@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
-                     int j = (int) (f * 10.0F);
- 
-                     this.level.destroyBlockProgress(this.player.getId(), pos, j);
-                    this.player.connection.send(new ClientboundBlockBreakAckPacket(pos, this.level.getBlockState(pos), action, true, "actual start of destroying"));
-+                    if (!com.destroystokyo.paper.PaperConfig.lagCompensateBlockBreaking) this.player.connection.send(new ClientboundBlockBreakAckPacket(pos, this.level.getBlockState(pos), action, true, "actual start of destroying"));
-                     this.lastSentState = j;
-                 }
-             } else if (action == ServerboundPlayerActionPacket.Action.STOP_DESTROY_BLOCK) {
-                 if (pos.equals(this.destroyPos)) {
-                    int k = this.gameTicks - this.destroyProgressStart;
-+                    int k = this.getTimeDiggingLagCompensate(); // Paper - lag compensate block breaking
- 
-                     iblockdata = this.level.getBlockState(pos);
-                     if (!iblockdata.isAir()) {
-@@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
-                             this.isDestroyingBlock = false;
-                             this.hasDelayedDestroy = true;
-                             this.delayedDestroyPos = pos;
-                            this.delayedTickStart = this.destroyProgressStart;
-+                            this.delayedTickStart = this.destroyProgressStart; this.hasDestroyedTooFastStartTime = this.lastDigTime; // Paper - lag compensate block breaking
-                         }
-                     }
-                 }
- 
-+                // Paper start - this can cause clients on a lagging server to think they're not currently destroying a block
-+                if (com.destroystokyo.paper.PaperConfig.lagCompensateBlockBreaking) {
-+                    this.player.connection.send(new ClientboundBlockUpdatePacket(this.level, pos));
-+                } else {
-                 this.player.connection.send(new ClientboundBlockBreakAckPacket(pos, this.level.getBlockState(pos), action, true, "stopped destroying"));
-+                }
-+                // Paper end - this can cause clients on a lagging server to think they're not currently destroying a block
-             } else if (action == ServerboundPlayerActionPacket.Action.ABORT_DESTROY_BLOCK) {
-                 this.isDestroyingBlock = false;
-                 if (!Objects.equals(this.destroyPos, pos) && !BlockPos.ZERO.equals(this.destroyPos)) {
-@@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
-                 }
- 
-                 this.level.destroyBlockProgress(this.player.getId(), pos, -1);
-                this.player.connection.send(new ClientboundBlockBreakAckPacket(pos, this.level.getBlockState(pos), action, true, "aborted destroying"));
-+                if (!com.destroystokyo.paper.PaperConfig.lagCompensateBlockBreaking) this.player.connection.send(new ClientboundBlockBreakAckPacket(pos, this.level.getBlockState(pos), action, true, "aborted destroying")); // Paper - this can cause clients on a lagging server to think they stopped destroying a block they're currently destroying
-             }
- 
-         }
-@@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
- 
-     public void destroyAndAck(BlockPos pos, ServerboundPlayerActionPacket.Action action, String reason) {
-         if (this.destroyBlock(pos)) {
-+            // Paper start - this can cause clients on a lagging server to think they're not currently destroying a block
-+            if (com.destroystokyo.paper.PaperConfig.lagCompensateBlockBreaking) {
-+                this.player.connection.send(new ClientboundBlockUpdatePacket(this.level, pos));
-+            } else {
-             this.player.connection.send(new ClientboundBlockBreakAckPacket(pos, this.level.getBlockState(pos), action, true, reason));
-+            }
-+            // Paper end - this can cause clients on a lagging server to think they're not currently destroying a block
-         } else {
-             this.player.connection.send(new ClientboundBlockUpdatePacket(this.level, pos)); // CraftBukkit - SPIGOT-5196
-         }
--- a/patches/unapplied/server/Make-sure-inlined-getChunkAt-has-inlined-logic-for-l.patch
+++ b/patches/unapplied/server/Make-sure-inlined-getChunkAt-has-inlined-logic-for-l.patch
@@ -1,34 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <spottedleaf@spottedleaf.dev>
-Date: Sun, 20 Sep 2020 16:10:49 -0700
-Subject: [PATCH] Make sure inlined getChunkAt has inlined logic for loaded
- chunks
-
-Tux did some profiling some time ago and showed that the
-previous getChunkAt method which had inlined logic for loaded
-chunks did get inlined, but the standard CPS.getChunkAt
-method was not inlined.
-
-Paper recently reverted this optimisation, so it's been reintroduced
-here.
-
-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 {
- 
-     @Override
-     public final LevelChunk getChunk(int chunkX, int chunkZ) { // Paper - final to help inline
-+        // Paper start - make sure loaded chunks get the inlined variant of this function
-+        net.minecraft.server.level.ServerChunkCache cps = ((ServerLevel)this).getChunkSource();
-+        if (cps.mainThread == Thread.currentThread()) {
-+            LevelChunk ifLoaded = cps.getChunkAtIfLoadedMainThread(chunkX, chunkZ);
-+            if (ifLoaded != null) {
-+                return ifLoaded;
-+            }
-+        }
-+        // Paper end - make sure loaded chunks get the inlined variant of this function
-         return (LevelChunk) this.getChunk(chunkX, chunkZ, ChunkStatus.FULL, true); // Paper - avoid a method jump
-     }
- 
--- a/patches/unapplied/server/Manually-inline-methods-in-BlockPosition.patch
+++ b/patches/unapplied/server/Manually-inline-methods-in-BlockPosition.patch
@@ -1,63 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <spottedleaf@spottedleaf.dev>
-Date: Mon, 6 Jul 2020 22:48:48 -0700
-Subject: [PATCH] Manually inline methods in BlockPosition
-
-
-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 {
-         }
- 
-         public BlockPos.MutableBlockPos set(int x, int y, int z) {
-            this.setX(x);
-            this.setY(y);
-            this.setZ(z);
-+            this.x = x; // Paper - force inline
-+            this.y = y; // Paper - force inline
-+            this.z = z; // Paper - force inline
-             return this;
-         }
- 
-@@ -0,0 +0,0 @@ public class BlockPos extends Vec3i {
-         // Paper start - comment out useless overrides @Override - TODO figure out why this is suddenly important to keep
-         @Override
-         public BlockPos.MutableBlockPos setX(int i) {
-            super.setX(i);
-+            this.x = i; // Paper
-             return this;
-         }
- 
-         @Override
-         public BlockPos.MutableBlockPos setY(int i) {
-            super.setY(i);
-+            this.y = i; // Paper
-             return this;
-         }
- 
-         @Override
-         public BlockPos.MutableBlockPos setZ(int i) {
-            super.setZ(i);
-+            this.z = i; // Paper
-             return this;
-         }
-         // Paper end
-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> {
-         return IntStream.of(vec3i.getX(), vec3i.getY(), vec3i.getZ());
-     });
-     public static final Vec3i ZERO = new Vec3i(0, 0, 0);
-    private int x;
-    private int y;
-    private int z;
-+    protected int x; // Paper - protected
-+    protected int y; // Paper - protected
-+    protected int z; // Paper - protected
- 
-     // Paper start
-     public boolean isValidLocation(net.minecraft.world.level.LevelHeightAccessor levelHeightAccessor) {
--- a/patches/unapplied/server/Name-craft-scheduler-threads-according-to-the-plugin.patch
+++ b/patches/unapplied/server/Name-craft-scheduler-threads-according-to-the-plugin.patch
@@ -1,33 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <spottedleaf@spottedleaf.dev>
-Date: Sun, 19 Jul 2020 15:17:01 -0700
-Subject: [PATCH] Name craft scheduler threads according to the plugin using
- them
-
-Provides quick access to culprits running far more threads than
-they should be
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftAsyncTask.java b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftAsyncTask.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/scheduler/CraftAsyncTask.java
-+++ b/src/main/java/org/bukkit/craftbukkit/scheduler/CraftAsyncTask.java
-@@ -0,0 +0,0 @@ class CraftAsyncTask extends CraftTask {
-     @Override
-     public void run() {
-         final Thread thread = Thread.currentThread();
-        synchronized (this.workers) {
-+        // Paper start - name threads according to running plugin
-+        final String nameBefore = thread.getName();
-+        thread.setName(nameBefore + " - " + this.getOwner().getName());
-+        try { synchronized (this.workers) {  // Paper end - name threads according to running plugin
-             if (getPeriod() == CraftTask.CANCEL) {
-                 // Never continue running after cancelled.
-                 // Checking this with the lock is important!
-@@ -0,0 +0,0 @@ class CraftAsyncTask extends CraftTask {
-                 }
-             }
-         }
-+        } finally { thread.setName(nameBefore); } // Paper - name worker thread according
-     }
- 
-     LinkedList<BukkitWorker> getWorkers() {
--- a/patches/unapplied/server/Oprimise-map-impl-for-tracked-players.patch
+++ b/patches/unapplied/server/Oprimise-map-impl-for-tracked-players.patch
@@ -1,29 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Fri, 19 Feb 2021 22:51:52 -0800
-Subject: [PATCH] Oprimise map impl for tracked players
-
-Reference2BooleanOpenHashMap is going to have
-better lookups than HashMap.
-
-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 @@ import org.apache.logging.log4j.LogManager;
- import org.apache.logging.log4j.Logger;
- 
- import org.bukkit.entity.Player; // CraftBukkit
-+import it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet; // Paper
- 
- public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider {
- 
-@@ -0,0 +0,0 @@ Sections go from 0..16. Now whenever a section is not empty, it can potentially
-         final Entity entity;
-         private final int range;
-         SectionPos lastSectionPos;
-        public final Set<ServerPlayerConnection> seenBy = Sets.newIdentityHashSet();
-+        public final Set<ServerPlayerConnection> seenBy = new ReferenceOpenHashSet<>(); // Paper - optimise map impl
- 
-         public TrackedEntity(Entity entity, int i, int j, boolean flag) {
-             this.serverEntity = new ServerEntity(ChunkMap.this.level, entity, j, flag, this::broadcast, this.seenBy); // CraftBukkit
--- a/patches/unapplied/server/Optimise-BlockSoil-nearby-water-lookup.patch
+++ b/patches/unapplied/server/Optimise-BlockSoil-nearby-water-lookup.patch
@@ -1,52 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Thu, 10 Jun 2021 14:36:00 -0700
-Subject: [PATCH] Optimise BlockSoil nearby water lookup
-
-Apparently the abstract block iteration was taking about
-75% of the method call.
-
-diff --git a/src/main/java/net/minecraft/world/level/block/FarmBlock.java b/src/main/java/net/minecraft/world/level/block/FarmBlock.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/block/FarmBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/FarmBlock.java
-@@ -0,0 +0,0 @@ public class FarmBlock extends Block {
-     }
- 
-     private static boolean isNearWater(LevelReader world, BlockPos pos) {
-        Iterator iterator = BlockPos.betweenClosed(pos.offset(-4, 0, -4), pos.offset(4, 1, 4)).iterator();
-
-        BlockPos blockposition1;
-
-        do {
-            if (!iterator.hasNext()) {
-                return false;
-+        // Paper start - remove abstract block iteration
-+        int xOff = pos.getX();
-+        int yOff = pos.getY();
-+        int zOff = pos.getZ();
-+
-+        for (int dz = -4; dz <= 4; ++dz) {
-+            int z = dz + zOff;
-+            for (int dx = -4; dx <= 4; ++dx) {
-+                int x = xOff + dx;
-+                for (int dy = 0; dy <= 1; ++dy) {
-+                    int y = dy + yOff;
-+                    net.minecraft.world.level.chunk.LevelChunk chunk = (net.minecraft.world.level.chunk.LevelChunk)world.getChunk(x >> 4, z >> 4);
-+                    net.minecraft.world.level.material.FluidState fluid = chunk.getBlockData(x, y, z).getFluidState();
-+                    if (fluid.is(FluidTags.WATER)) {
-+                        return true;
-+                    }
-+                }
-             }
-+        }
- 
-            blockposition1 = (BlockPos) iterator.next();
-        } while (!world.getFluidState(blockposition1).is((Tag) FluidTags.WATER));
-
-        return true;
-+        return false;
-+        // Paper end - remove abstract block iteration
-     }
- 
-     @Override
--- a/patches/unapplied/server/Optimise-chunk-tick-iteration.patch
+++ b/patches/unapplied/server/Optimise-chunk-tick-iteration.patch
@@ -1,94 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <spottedleaf@spottedleaf.dev>
-Date: Thu, 7 May 2020 05:48:54 -0700
-Subject: [PATCH] Optimise chunk tick iteration
-
-Use a dedicated list of entity ticking chunks to reduce the cost
-
-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 {
- 
-             this.lastSpawnState = spawnercreature_d;
-             this.level.getProfiler().pop();
-            List<ChunkHolder> list = Lists.newArrayList(this.chunkMap.getChunks());
-
-            Collections.shuffle(list);
-+            // Paper - moved down, enabled if per-player = false
-             // Paper - moved natural spawn event up
-             this.level.timings.chunkTicks.startTiming(); // Paper
-            list.forEach((playerchunk) -> {
-                Optional<LevelChunk> optional = ((Either) playerchunk.getTickingChunkFuture().getNow(ChunkHolder.UNLOADED_LEVEL_CHUNK)).left();
-
-                if (optional.isPresent()) {
-                    LevelChunk chunk = (LevelChunk) optional.get();
-+            // Paper start
-+            java.util.Iterator<LevelChunk> iterator;
-+            if (this.level.paperConfig.perPlayerMobSpawns) {
-+                iterator = this.entityTickingChunks.iterator();
-+            } else {
-+                iterator = this.entityTickingChunks.unsafeIterator();
-+                List<LevelChunk> shuffled = new java.util.ArrayList<>(this.entityTickingChunks.size());
-+                while (iterator.hasNext()) {
-+                    shuffled.add(iterator.next());
-+                }
-+                Collections.shuffle(shuffled);
-+                iterator = shuffled.iterator();
-+            }
-+            try { while (iterator.hasNext()) {
-+                LevelChunk chunk = iterator.next();
-+                ChunkHolder playerchunk = chunk.playerChunk;
-+                if (playerchunk != null) {
-+                    this.level.getProfiler().push("broadcast");
-+                    this.level.timings.broadcastChunkUpdates.startTiming(); // Paper - timings
-+                    playerchunk.broadcastChanges(chunk);
-+                    this.level.timings.broadcastChunkUpdates.stopTiming(); // Paper - timings
-+                    this.level.getProfiler().pop();
-+                    // Paper end
-                     ChunkPos chunkcoordintpair = chunk.getPos();
- 
-                    if (this.level.isPositionEntityTicking(chunkcoordintpair) && !this.chunkMap.isOutsideOfRange(playerchunk, chunkcoordintpair, false)) { // Paper - optimise isOutsideOfRange
-+                    if ((true || this.level.isPositionEntityTicking(chunkcoordintpair)) && !this.chunkMap.isOutsideOfRange(playerchunk, chunkcoordintpair, false)) { // Paper - optimise isOutsideOfRange // Paper - we only iterate entity ticking chunks
-                         chunk.setInhabitedTime(chunk.getInhabitedTime() + j);
-                         if (flag1 && (this.spawnEnemies || this.spawnFriendlies) && this.level.getWorldBorder().isWithinBounds(chunk.getPos()) && !this.chunkMap.isOutsideOfRange(playerchunk, chunkcoordintpair, true)) { // Spigot // Paper - optimise isOutsideOfRange
-                             NaturalSpawner.spawnForChunk(this.level, chunk, spawnercreature_d, this.spawnFriendlies, this.spawnEnemies, flag2);
-@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
-                         // this.level.timings.doTickTiles.stopTiming(); // Spigot // Paper
-                     }
-                 }
-            });
-+            } // Paper start - optimise chunk tick iteration
-+            } finally {
-+                if (iterator instanceof io.papermc.paper.util.maplist.IteratorSafeOrderedReferenceSet.Iterator) {
-+                    ((io.papermc.paper.util.maplist.IteratorSafeOrderedReferenceSet.Iterator<LevelChunk>)iterator).finishedIterating();
-+                }
-+            }
-+            // Paper end - optimise chunk tick iteration
-             this.level.timings.chunkTicks.stopTiming(); // Paper
-             this.level.getProfiler().push("customSpawners");
-             if (flag1) {
-@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
-                 } // Paper - timings
-             }
- 
-            this.level.getProfiler().popPush("broadcast");
-            this.chunkMap.getChunks().forEach((playerchunk) -> { // Paper - no... just no...
-                Optional<LevelChunk> optional = ((Either) playerchunk.getTickingChunkFuture().getNow(ChunkHolder.UNLOADED_LEVEL_CHUNK)).left(); // CraftBukkit - decompile error
-
-                Objects.requireNonNull(playerchunk);
-
-                // Paper start - timings
-                optional.ifPresent(chunk -> {
-                    this.level.timings.broadcastChunkUpdates.startTiming(); // Paper - timings
-                    playerchunk.broadcastChanges(chunk);
-                    this.level.timings.broadcastChunkUpdates.stopTiming(); // Paper - timings
-                });
-                // Paper end
-            });
-            this.level.getProfiler().pop();
-+            // Paper - no, iterating just ONCE is expensive enough! Don't do it TWICE! Code moved up
-             this.level.getProfiler().pop();
-         }
- 
--- a/patches/unapplied/server/Optimise-collision-checking-in-player-move-packet-ha.patch
+++ b/patches/unapplied/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@spottedleaf.dev>
-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 implements ServerPlayerConnection, Ser
-                     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 - 1.0E-6D; // Paper - diff on change, used for checking large move vectors above
-                 d8 = d5 - this.vehicleLastGoodZ; // Paper - diff on change, used for checking large move vectors above
-                 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 implements ServerPlayerConnection, Ser
-                 boolean flag1 = false;
- 
-                 if (d10 > org.spigotmc.SpigotConfig.movedWronglyThreshold) { // Spigot
-                    flag1 = true;
-+                    flag1 = true; // Paper - diff on change, this should be moved wrongly
-                     ServerGamePacketListenerImpl.LOGGER.warn("{} (vehicle of {}) moved wrongly! {}", entity.getName().getString(), this.player.getName().getString(), Math.sqrt(d10));
-                 }
-                 Location curPos = this.getCraftPlayer().getLocation(); // Spigot
- 
-                 entity.absMoveTo(d3, d4, d5, f, f1);
-                 this.player.absMoveTo(d3, d4, d5, this.player.getYRot(), this.player.getXRot()); // CraftBukkit
-                boolean flag2 = worldserver.noCollision(entity, entity.getBoundingBox().deflate(0.0625D));
-
-                if (flag && (flag1 || !flag2)) {
-+                // Paper start - optimise out extra getCubes
-+                boolean teleportBack = flag1; // 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.connection.send(new ClientboundMoveVehiclePacket(entity));
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
-     }
- 
-     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.getTypeIfLoaded(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 implements ServerPlayerConnection, Ser
-                 }
- 
-                 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 implements ServerPlayerConnection, Ser
-                                 }
-                             }
- 
-                            AABB axisalignedbb = this.player.getBoundingBox();
-+                            AABB axisalignedbb = this.player.getBoundingBox(); // Paper - diff on change, should be old AABB
- 
-                             d7 = d0 - this.lastGoodX; // Paper - diff on change, used for checking large move vectors above
-                             d8 = d1 - this.lastGoodY; // Paper - diff on change, used for checking large move vectors above
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
-                             }
- 
-                             this.player.move(MoverType.PLAYER, new Vec3(d7, d8, d9));
-+                            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...
-                             this.player.setOnGround(packet.isOnGround()); // CraftBukkit - SPIGOT-5810, SPIGOT-5835: reset by this.player.move
-                             // Paper start - prevent position desync
-                             if (this.awaitingPositionFromClient != null) {
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
-                             boolean flag1 = false;
- 
-                             if (!this.player.isChangingDimension() && d11 > org.spigotmc.SpigotConfig.movedWronglyThreshold && !this.player.isSleeping() && !this.player.gameMode.isCreative() && this.player.gameMode.getGameModeForPlayer() != GameType.SPECTATOR) { // Spigot
-                                flag1 = true;
-+                                flag1 = true; // Paper - diff on change, this should be moved wrongly
-                                 ServerGamePacketListenerImpl.LOGGER.warn("{} moved wrongly!", this.player.getName().getString());
-                             }
- 
-                             this.player.absMoveTo(d0, d1, d2, f, f1);
-                            if (!this.player.noPhysics && !this.player.isSleeping() && (flag1 && worldserver.noCollision(this.player, axisalignedbb) || this.isPlayerCollidingWithAnythingNew((LevelReader) worldserver, axisalignedbb))) {
-+                            // Paper start - optimise out extra getCubes
-+                            // Original for reference:
-+                            // boolean teleportBack = flag1 && worldserver.getCubes(this.player, axisalignedbb) || (didCollide && this.a((IWorldReader) worldserver, axisalignedbb));
-+                            boolean teleportBack = flag1; // violating this is always a fail
-+                            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?
-+                            }
-+                            if (!this.player.noPhysics && !this.player.isSleeping() && teleportBack) { // Paper end - optimise out extra getCubes
-                                 this.teleport(d3, d4, d5, f, f1);
-                             } else {
-                                 // CraftBukkit start - fire PlayerMoveEvent
-@@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Ser
-         }
-     }
- 
-+    // Paper start - optimise out extra getCubes
-+    private boolean hasNewCollision(final ServerLevel world, final Entity entity, final AABB oldBox, final AABB newBox) {
-+        final List<AABB> collisions = io.papermc.paper.util.CachedLists.getTempCollisionList();
-+        try {
-+            io.papermc.paper.util.CollisionUtil.getCollisions(world, entity, newBox, collisions, false, true,
-+                true, false, null, null);
-+
-+            for (int i = 0, len = collisions.size(); i < len; ++i) {
-+                final AABB box = collisions.get(i);
-+                if (!io.papermc.paper.util.CollisionUtil.voxelShapeIntersect(box, oldBox)) {
-+                    return true;
-+                }
-+            }
-+
-+            return false;
-+        } finally {
-+            io.papermc.paper.util.CachedLists.returnTempCollisionList(collisions);
-+        }
-+    }
-+    // Paper end - optimise out extra getCubes
-+
-     private boolean isPlayerCollidingWithAnythingNew(LevelReader world, AABB box) {
-         Stream<VoxelShape> stream = world.getCollisions(this.player, this.player.getBoundingBox().deflate(9.999999747378752E-6D), (entity) -> {
-             return true;
--- a/patches/unapplied/server/Optimise-random-block-ticking.patch
+++ b/patches/unapplied/server/Optimise-random-block-ticking.patch
@@ -1,369 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Sun, 20 Jun 2021 16:19:26 -0700
-Subject: [PATCH] Optimise random block ticking
-
-Massive performance improvement for random block ticking.
-The performance increase comes from the fact that the vast
-majority of attempted block ticks (~95% in my testing) fail
-because the randomly selected block is not tickable.
-
-Now only tickable blocks are targeted, however this means that
-the maximum number of block ticks occurs per chunk. However,
-not all chunks are going to be targeted. The percent chance
-of a chunk being targeted is based on how many tickable blocks
-are in the chunk.
-This means that while block ticks are spread out less, the
-total number of blocks ticked per world tick remains the same.
-Therefore, the chance of a random tickable block being ticked
-remains the same.
-
-diff --git a/src/main/java/io/papermc/paper/util/math/ThreadUnsafeRandom.java b/src/main/java/io/papermc/paper/util/math/ThreadUnsafeRandom.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
--- /dev/null
-+++ b/src/main/java/io/papermc/paper/util/math/ThreadUnsafeRandom.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.util.math;
-+
-+import java.util.Random;
-+
-+public final class ThreadUnsafeRandom extends Random {
-+
-+    // See javadoc and internal comments for java.util.Random where these values come from, how they are used, and the author for them.
-+    private static final long multiplier = 0x5DEECE66DL;
-+    private static final long addend = 0xBL;
-+    private static final long mask = (1L << 48) - 1;
-+
-+    private static long initialScramble(long seed) {
-+        return (seed ^ multiplier) & mask;
-+    }
-+
-+    private long seed;
-+
-+    @Override
-+    public void setSeed(long seed) {
-+        // note: called by Random constructor
-+        this.seed = initialScramble(seed);
-+    }
-+
-+    @Override
-+    protected int next(int bits) {
-+        // avoid the expensive CAS logic used by superclass
-+        return (int) (((this.seed = this.seed * multiplier + addend) & mask) >>> (48 - bits));
-+    }
-+
-+    // Taken from
-+    // https://lemire.me/blog/2016/06/27/a-fast-alternative-to-the-modulo-reduction/
-+    // https://github.com/lemire/Code-used-on-Daniel-Lemire-s-blog/blob/master/2016/06/25/fastrange.c
-+    // Original license is public domain
-+    public static int fastRandomBounded(final long randomInteger, final long limit) {
-+        // randomInteger must be [0, pow(2, 32))
-+        // limit must be [0, pow(2, 32))
-+        return (int)((randomInteger * limit) >>> 32);
-+    }
-+
-+    @Override
-+    public int nextInt(int bound) {
-+        // yes this breaks random's spec
-+        // however there's nothing that uses this class that relies on it
-+        return fastRandomBounded(this.next(32) & 0xFFFFFFFFL, bound);
-+    }
-+}
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
-             entityplayer.stopSleepInBed(false, false);
-         });
-     }
-+    // Paper start - optimise random block ticking
-+    private final BlockPos.MutableBlockPos chunkTickMutablePosition = new BlockPos.MutableBlockPos();
-+    private final io.papermc.paper.util.math.ThreadUnsafeRandom randomTickRandom = new io.papermc.paper.util.math.ThreadUnsafeRandom();
-+    // Paper end
- 
-     public void tickChunk(LevelChunk chunk, int randomTickSpeed) {
-         ChunkPos chunkcoordintpair = chunk.getPos();
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
-         ProfilerFiller gameprofilerfiller = this.getProfiler();
- 
-         gameprofilerfiller.push("thunder");
-        BlockPos blockposition;
-+        final BlockPos.MutableBlockPos blockposition = this.chunkTickMutablePosition; // Paper - use mutable to reduce allocation rate, final to force compile fail on change
- 
-         if (!this.paperConfig.disableThunder && flag && this.isThundering() && this.spigotConfig.thunderChance > 0 && this.random.nextInt(this.spigotConfig.thunderChance) == 0) { // Spigot // Paper - disable thunder
-            blockposition = this.findLightningTargetAround(this.getBlockRandomPos(j, 0, k, 15));
-+            blockposition.set(this.findLightningTargetAround(this.getBlockRandomPos(j, 0, k, 15))); // Paper
-             if (this.isRainingAt(blockposition)) {
-                 DifficultyInstance difficultydamagescaler = this.getCurrentDifficultyAt(blockposition);
-                 boolean flag1 = this.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && this.random.nextDouble() < (double) difficultydamagescaler.getEffectiveDifficulty() * paperConfig.skeleHorseSpawnChance && !this.getBlockState(blockposition.below()).is(Blocks.LIGHTNING_ROD); // Paper
-@@ -0,0 +0,0 @@ public class ServerLevel extends Level implements WorldGenLevel {
-         }
- 
-         gameprofilerfiller.popPush("iceandsnow");
-        if (!this.paperConfig.disableIceAndSnow && this.random.nextInt(16) == 0) { // Paper - Disable ice and snow
-            blockposition = this.getHeightmapPos(Heightmap.Types.MOTION_BLOCKING, this.getBlockRandomPos(j, 0, k, 15));
-            BlockPos blockposition1 = blockposition.below();
-+         if (!this.paperConfig.disableIceAndSnow && this.randomTickRandom.nextInt(16) == 0) { // Paper - Disable ice and snow // Paper - optimise random ticking
-+            // Paper start - optimise chunk ticking
-+            this.getRandomBlockPosition(j, 0, k, 15, blockposition);
-+            int normalY = chunk.getHeight(Heightmap.Types.MOTION_BLOCKING, blockposition.getX() & 15, blockposition.getZ() & 15) + 1;
-+            int downY = normalY - 1;
-+            blockposition.setY(normalY);
-+            // Paper end
-             Biome biomebase = this.getBiome(blockposition);
- 
-            if (biomebase.shouldFreeze((LevelReader) this, blockposition1)) {
-                org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(this, blockposition1, Blocks.ICE.defaultBlockState(), null); // CraftBukkit
-+            // Paper start - optimise chunk ticking
-+            blockposition.setY(downY);
-+            if (biomebase.shouldFreeze(this, blockposition)) {
-+                org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(this, blockposition, Blocks.ICE.defaultBlockState(), null); // CraftBukkit
-+                // Paper end
-             }
- 
-             if (flag) {
-+                blockposition.setY(normalY); // Paper
-                 if (biomebase.shouldSnow(this, blockposition)) {
-                     org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockFormEvent(this, blockposition, Blocks.SNOW.defaultBlockState(), null); // CraftBukkit
-                 }
- 
-                BlockState iblockdata = this.getBlockState(blockposition1);
-+                blockposition.setY(downY); // Paper
-+                BlockState iblockdata = this.getBlockState(blockposition); // Paper
-+                blockposition.setY(normalY); // Paper
-                 Biome.Precipitation biomebase_precipitation = this.getBiome(blockposition).getPrecipitation();
- 
-                if (biomebase_precipitation == Biome.Precipitation.RAIN && biomebase.isColdEnoughToSnow(blockposition1)) {
-+                blockposition.setY(downY); // Paper
-+                if (biomebase_precipitation == Biome.Precipitation.RAIN && biomebase.isColdEnoughToSnow(blockposition)) { // Paper
-                     biomebase_precipitation = Biome.Precipitation.SNOW;
-                 }
- 
-                iblockdata.getBlock().handlePrecipitation(iblockdata, (Level) this, blockposition1, biomebase_precipitation);
-+                iblockdata.getBlock().handlePrecipitation(iblockdata, (Level) this, blockposition, biomebase_precipitation); // Paper
-             }
-         }
- 
-        gameprofilerfiller.popPush("tickBlocks");
-+        // Paper start - optimise random block ticking
-+        gameprofilerfiller.popPush("randomTick");
-         timings.chunkTicksBlocks.startTiming(); // Paper
-         if (randomTickSpeed > 0) {
-            LevelChunkSection[] achunksection = chunk.getSections();
-            int l = achunksection.length;
-
-            for (int i1 = 0; i1 < l; ++i1) {
-                LevelChunkSection chunksection = achunksection[i1];
-
-                if (chunksection != LevelChunk.EMPTY_SECTION && chunksection.isRandomlyTicking()) {
-                    int j1 = chunksection.bottomBlockY();
-
-                    for (int k1 = 0; k1 < randomTickSpeed; ++k1) {
-                        BlockPos blockposition2 = this.getBlockRandomPos(j, j1, k, 15);
-
-                        gameprofilerfiller.push("randomTick");
-                        BlockState iblockdata1 = chunksection.getBlockState(blockposition2.getX() - j, blockposition2.getY() - j1, blockposition2.getZ() - k);
-+            LevelChunkSection[] sections = chunk.getSections();
-+            int minSection = io.papermc.paper.util.WorldUtil.getMinSection(this);
-+            for (int sectionIndex = 0; sectionIndex < sections.length; ++sectionIndex) {
-+                LevelChunkSection section = sections[sectionIndex];
-+                if (section == null || section.tickingList.size() == 0) {
-+                    continue;
-+                }
- 
-                        if (iblockdata1.isRandomlyTicking()) {
-                            iblockdata1.randomTick(this, blockposition2, this.random);
-                        }
-+                int yPos = (sectionIndex + minSection) << 4;
-+                for (int a = 0; a < randomTickSpeed; ++a) {
-+                    int tickingBlocks = section.tickingList.size();
-+                    int index = this.randomTickRandom.nextInt(16 * 16 * 16);
-+                    if (index >= tickingBlocks) {
-+                        continue;
-+                    }
- 
-                        FluidState fluid = iblockdata1.getFluidState();
-+                    long raw = section.tickingList.getRaw(index);
-+                    int location = com.destroystokyo.paper.util.maplist.IBlockDataList.getLocationFromRaw(raw);
-+                    int randomX = location & 15;
-+                    int randomY = ((location >>> (4 + 4)) & 255) | yPos;
-+                    int randomZ = (location >>> 4) & 15;
- 
-                        if (fluid.isRandomlyTicking()) {
-                            fluid.randomTick(this, blockposition2, this.random);
-                        }
-+                    BlockPos blockposition2 = blockposition.set(j + randomX, randomY, k + randomZ);
-+                    BlockState iblockdata = com.destroystokyo.paper.util.maplist.IBlockDataList.getBlockDataFromRaw(raw);
- 
-                        gameprofilerfiller.pop();
-                    }
-+                    iblockdata.randomTick(this, blockposition2, this.randomTickRandom);
-+                    // We drop the fluid tick since LAVA is ALREADY TICKED by the above method (See LiquidBlock).
-+                    // TODO CHECK ON UPDATE
-                 }
-             }
-         }
-
-+        // Paper end - optimise random block ticking
-         timings.chunkTicksBlocks.stopTiming(); // Paper
-         gameprofilerfiller.pop();
-     }
-diff --git a/src/main/java/net/minecraft/util/BitStorage.java b/src/main/java/net/minecraft/util/BitStorage.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/util/BitStorage.java
-+++ b/src/main/java/net/minecraft/util/BitStorage.java
-@@ -0,0 +0,0 @@ public class BitStorage {
-         }
- 
-     }
-+
-+    // Paper start
-+    public final void forEach(DataBitConsumer consumer) {
-+        int i = 0;
-+        long[] along = this.data;
-+        int j = along.length;
-+
-+        for (int k = 0; k < j; ++k) {
-+            long l = along[k];
-+
-+            for (int i1 = 0; i1 < this.valuesPerLong; ++i1) {
-+                consumer.accept(i, (int) (l & this.mask));
-+                l >>= this.bits;
-+                ++i;
-+                if (i >= this.size) {
-+                    return;
-+                }
-+            }
-+        }
-+    }
-+
-+    @FunctionalInterface
-+    public static interface DataBitConsumer {
-+
-+        void accept(int location, int data);
-+
-+    }
-+    // Paper end
- }
-diff --git a/src/main/java/net/minecraft/world/entity/animal/Turtle.java b/src/main/java/net/minecraft/world/entity/animal/Turtle.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/entity/animal/Turtle.java
-+++ b/src/main/java/net/minecraft/world/entity/animal/Turtle.java
-@@ -0,0 +0,0 @@ public class Turtle extends Animal {
-     }
- 
-     public void setHomePos(BlockPos pos) {
-        this.entityData.set(Turtle.HOME_POS, pos);
-+        this.entityData.set(Turtle.HOME_POS, pos.immutable()); // Paper - called with mutablepos...
-     }
- 
-     public BlockPos getHomePos() {
-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 abstract TagContainer getTagManager();
- 
-     public BlockPos getBlockRandomPos(int x, int y, int z, int l) {
-+        // Paper start - allow use of mutable pos
-+        BlockPos.MutableBlockPos ret = new BlockPos.MutableBlockPos();
-+        this.getRandomBlockPosition(x, y, z, l, ret);
-+        return ret.immutable();
-+    }
-+    public final BlockPos.MutableBlockPos getRandomBlockPosition(int x, int y, int z, int l, BlockPos.MutableBlockPos out) {
-+        // Paper end
-         this.randValue = this.randValue * 3 + 1013904223;
-         int i1 = this.randValue >> 2;
- 
-        return new BlockPos(x + (i1 & 15), y + (i1 >> 16 & l), z + (i1 >> 8 & 15));
-+        out.set(x + (i1 & 15), y + (i1 >> 16 & l), z + (i1 >> 8 & 15)); // Paper - change to setValues call
-+        return out; // Paper
-     }
- 
-     public boolean noSave() {
-diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
-@@ -0,0 +0,0 @@ public class LevelChunkSection {
-     private short tickingBlockCount;
-     private short tickingFluidCount;
-     public final PalettedContainer<BlockState> states; // Paper - package-private // Paper - public
-+    public final com.destroystokyo.paper.util.maplist.IBlockDataList tickingList = new com.destroystokyo.paper.util.maplist.IBlockDataList(); // Paper
- 
-     // Paper start - Anti-Xray - Add parameters
-     @Deprecated public LevelChunkSection(int yOffset) { this(yOffset, null, null, true); } // Notice for updates: Please make sure this constructor isn't used anywhere
-@@ -0,0 +0,0 @@ public class LevelChunkSection {
-             --this.nonEmptyBlockCount;
-             if (blockState.isRandomlyTicking()) {
-                 --this.tickingBlockCount;
-+                // Paper start
-+                this.tickingList.remove(x, y, z);
-+                // Paper end
-             }
-         }
- 
-@@ -0,0 +0,0 @@ public class LevelChunkSection {
-             ++this.nonEmptyBlockCount;
-             if (state.isRandomlyTicking()) {
-                 ++this.tickingBlockCount;
-+                // Paper start
-+                this.tickingList.add(x, y, z, state);
-+                // Paper end
-             }
-         }
- 
-@@ -0,0 +0,0 @@ public class LevelChunkSection {
-     }
- 
-     public void recalcBlockCounts() {
-+        // Paper start
-+        this.tickingList.clear();
-+        // Paper end
-         this.nonEmptyBlockCount = 0;
-         this.tickingBlockCount = 0;
-         this.tickingFluidCount = 0;
-        this.states.count((state, count) -> {
-+        this.states.forEachLocation((state, location) -> { // Paper
-             FluidState fluidState = state.getFluidState();
-             if (!state.isAir()) {
-                this.nonEmptyBlockCount = (short)(this.nonEmptyBlockCount + count);
-+                this.nonEmptyBlockCount = (short)(this.nonEmptyBlockCount + 1); // Paper
-                 if (state.isRandomlyTicking()) {
-                    this.tickingBlockCount = (short)(this.tickingBlockCount + count);
-+                    // Paper start
-+                    this.tickingBlockCount = (short)(this.tickingBlockCount + 1);
-+                    this.tickingList.add(location, state);
-+                    // Paper end
-                 }
-             }
- 
-             if (!fluidState.isEmpty()) {
-                this.nonEmptyBlockCount = (short)(this.nonEmptyBlockCount + count);
-+                this.nonEmptyBlockCount = (short)(this.nonEmptyBlockCount + 1); // Paper
-                 if (fluidState.isRandomlyTicking()) {
-                    this.tickingFluidCount = (short)(this.tickingFluidCount + count);
-+                    this.tickingFluidCount = (short)(this.tickingFluidCount + 1); // Paper
-                 }
-             }
- 
-diff --git a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
-@@ -0,0 +0,0 @@ public class PalettedContainer<T> implements PaletteResize<T> {
-     public interface CountConsumer<T> {
-         void accept(T object, int count);
-     }
-+
-+    // Paper start
-+   public void forEachLocation(PalettedContainer.CountConsumer<T> datapaletteblock_a) {
-+       this.storage.forEach((int location, int data) -> {
-+           datapaletteblock_a.accept(this.palette.valueFor(data), location);
-+       });
-+   }
-+    // Paper end
- }
--- a/patches/unapplied/server/Prevent-unload-calls-removing-tickets-for-sync-loads.patch
+++ b/patches/unapplied/server/Prevent-unload-calls-removing-tickets-for-sync-loads.patch
@@ -1,67 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <spottedleaf@spottedleaf.dev>
-Date: Thu, 18 Jun 2020 18:23:20 -0700
-Subject: [PATCH] Prevent unload() calls removing tickets for sync loads
-
-
-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 completablefuture;
-     }
- 
-+    private long syncLoadCounter; // Paper - prevent plugin unloads from removing our ticket
-+
-     private CompletableFuture<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>> getChunkFutureMainThread(int chunkX, int chunkZ, ChunkStatus leastStatus, boolean create) {
-         // Paper start - add isUrgent - old sig left in place for dirty nms plugins
-         return getChunkFutureMainThread(chunkX, chunkZ, leastStatus, create, false);
-@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
-             ChunkHolder.FullChunkStatus currentChunkState = ChunkHolder.getFullChunkStatus(playerchunk.getTicketLevel());
-             currentlyUnloading = (oldChunkState.isOrAfter(ChunkHolder.FullChunkStatus.BORDER) && !currentChunkState.isOrAfter(ChunkHolder.FullChunkStatus.BORDER));
-         }
-+        final Long identifier; // Paper - prevent plugin unloads from removing our ticket
-         if (create && !currentlyUnloading) {
-             // CraftBukkit end
-             this.distanceManager.addTicket(TicketType.UNKNOWN, chunkcoordintpair, l, chunkcoordintpair);
-+            identifier = Long.valueOf(this.syncLoadCounter++); // Paper - prevent plugin unloads from removing our ticket
-+            this.distanceManager.addTicketAtLevel(TicketType.REQUIRED_LOAD, chunkcoordintpair, l, identifier); // Paper - prevent plugin unloads from removing our ticket
-             if (isUrgent) this.distanceManager.markUrgent(chunkcoordintpair); // Paper - Chunk priority
-             if (this.chunkAbsent(playerchunk, l)) {
-                 ProfilerFiller gameprofilerfiller = this.level.getProfiler();
-@@ -0,0 +0,0 @@ public class ServerChunkCache extends ChunkSource {
-                 playerchunk = this.getVisibleChunkIfPresent(k);
-                 gameprofilerfiller.pop();
-                 if (this.chunkAbsent(playerchunk, l)) {
-+                    this.distanceManager.removeTicketAtLevel(TicketType.REQUIRED_LOAD, chunkcoordintpair, l, identifier); // Paper
-                     throw (IllegalStateException) Util.pauseInIde((Throwable) (new IllegalStateException("No chunk holder after ticket has been added")));
-                 }
-             }
-        }
- 
-+        } else { identifier = null; } // Paper - prevent plugin unloads from removing our ticket
-         // Paper start - Chunk priority
-         CompletableFuture<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>> future = this.chunkAbsent(playerchunk, l) ? ChunkHolder.UNLOADED_CHUNK_FUTURE : playerchunk.getOrScheduleFuture(leastStatus, this.chunkMap);
-+        // Paper start - prevent plugin unloads from removing our ticket
-+        if (create && !currentlyUnloading) {
-+            future.thenAcceptAsync((either) -> {
-+                ServerChunkCache.this.distanceManager.removeTicketAtLevel(TicketType.REQUIRED_LOAD, chunkcoordintpair, l, identifier);
-+            }, ServerChunkCache.this.mainThreadProcessor);
-+        }
-+        // Paper end - prevent plugin unloads from removing our ticket
-         if (isUrgent) {
-             future.thenAccept(either -> this.distanceManager.clearUrgent(chunkcoordintpair));
-         }
-diff --git a/src/main/java/net/minecraft/server/level/TicketType.java b/src/main/java/net/minecraft/server/level/TicketType.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/TicketType.java
-+++ b/src/main/java/net/minecraft/server/level/TicketType.java
-@@ -0,0 +0,0 @@ public class TicketType<T> {
-     public static final TicketType<Unit> PLUGIN = TicketType.create("plugin", (a, b) -> 0); // CraftBukkit
-     public static final TicketType<org.bukkit.plugin.Plugin> PLUGIN_TICKET = TicketType.create("plugin_ticket", (plugin1, plugin2) -> plugin1.getClass().getName().compareTo(plugin2.getClass().getName())); // CraftBukkit
-     public static final TicketType<Long> DELAY_UNLOAD = create("delay_unload", Long::compareTo, 300); // Paper
-+    public static final TicketType<Long> REQUIRED_LOAD = create("required_load", Long::compareTo); // Paper - make sure getChunkAt does not fail
- 
-     public static <T> TicketType<T> create(String name, Comparator<T> argumentComparator) {
-         return new TicketType<>(name, argumentComparator, 0L);
--- a/patches/unapplied/server/Replace-player-chunk-loader-system.patch
+++ b/patches/unapplied/server/Replace-player-chunk-loader-system.patch
--- a/patches/unapplied/server/Replace-ticket-level-propagator.patch
+++ b/patches/unapplied/server/Replace-ticket-level-propagator.patch
@@ -1,248 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Sun, 21 Mar 2021 16:25:42 -0700
-Subject: [PATCH] Replace ticket level propagator
-
-Mojang's propagator is slow, and this isn't surprising
-given it's built on the same utilities the vanilla light engine
-is built on. The simple propagator I wrote is approximately 4x
-faster when simulating player movement. For a long time timing
-reports have shown this function take up significant tick, (
-approx 10% or more), and async sampling data shows the level
-propagation alone takes up a significant amount. So this
-should help with that. A big side effect is that mid-tick
-will be more effective, since more time will be allocated
-to actually processing chunk tasks vs the ticket level updates.
-
-diff --git a/src/main/java/net/minecraft/server/level/DistanceManager.java b/src/main/java/net/minecraft/server/level/DistanceManager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/DistanceManager.java
-+++ b/src/main/java/net/minecraft/server/level/DistanceManager.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.level.chunk.LevelChunk;
- import org.apache.logging.log4j.LogManager;
- import org.apache.logging.log4j.Logger;
- 
-+import it.unimi.dsi.fastutil.longs.Long2IntLinkedOpenHashMap; // Paper
- public abstract class DistanceManager {
- 
-     static final Logger LOGGER = LogManager.getLogger();
-@@ -0,0 +0,0 @@ public abstract class DistanceManager {
-     private static final int INITIAL_TICKET_LIST_CAPACITY = 4;
-     final Long2ObjectMap<ObjectSet<ServerPlayer>> playersPerChunk = new Long2ObjectOpenHashMap();
-     public final Long2ObjectOpenHashMap<SortedArraySet<Ticket<?>>> tickets = new Long2ObjectOpenHashMap();
-    private final DistanceManager.ChunkTicketTracker ticketTracker = new DistanceManager.ChunkTicketTracker();
-+    //private final DistanceManager.ChunkTicketTracker ticketTracker = new DistanceManager.ChunkTicketTracker(); // Paper - replace ticket level propagator
-     public static final int MOB_SPAWN_RANGE = 8; // private final ChunkMapDistance.b f = new ChunkMapDistance.b(8); // Paper - no longer used
-     //private final DistanceManager.PlayerTicketTracker playerTicketManager = new DistanceManager.PlayerTicketTracker(33); // Paper - no longer used
-     // Paper start use a queue, but still keep unique requirement
-@@ -0,0 +0,0 @@ public abstract class DistanceManager {
-         this.mainThreadExecutor = mainThreadExecutor;
-     }
- 
-+    // Paper start - replace ticket level propagator
-+    protected final Long2IntLinkedOpenHashMap ticketLevelUpdates = new Long2IntLinkedOpenHashMap() {
-+        @Override
-+        protected void rehash(int newN) {
-+            // no downsizing allowed
-+            if (newN < this.n) {
-+                return;
-+            }
-+            super.rehash(newN);
-+        }
-+    };
-+    protected final io.papermc.paper.util.misc.Delayed8WayDistancePropagator2D ticketLevelPropagator = new io.papermc.paper.util.misc.Delayed8WayDistancePropagator2D(
-+            (long coordinate, byte oldLevel, byte newLevel) -> {
-+                DistanceManager.this.ticketLevelUpdates.putAndMoveToLast(coordinate, convertBetweenTicketLevels(newLevel));
-+            }
-+    );
-+    // function for converting between ticket levels and propagator levels and vice versa
-+    // the problem is the ticket level propagator will propagate from a set source down to zero, whereas mojang expects
-+    // levels to propagate from a set value up to a maximum value. so we need to convert the levels we put into the propagator
-+    // and the levels we get out of the propagator
-+
-+    // this maps so that GOLDEN_TICKET + 1 will be 0 in the propagator, GOLDEN_TICKET will be 1, and so on
-+    // we need GOLDEN_TICKET+1 as 0 because anything >= GOLDEN_TICKET+1 should be unloaded
-+    public static int convertBetweenTicketLevels(final int level) {
-+        return ChunkMap.MAX_CHUNK_DISTANCE - level + 1;
-+    }
-+
-+    protected final int getPropagatedTicketLevel(final long coordinate) {
-+        return convertBetweenTicketLevels(this.ticketLevelPropagator.getLevel(coordinate));
-+    }
-+
-+    protected final void updateTicketLevel(final long coordinate, final int ticketLevel) {
-+        if (ticketLevel > ChunkMap.MAX_CHUNK_DISTANCE) {
-+            this.ticketLevelPropagator.removeSource(coordinate);
-+        } else {
-+            this.ticketLevelPropagator.setSource(coordinate, convertBetweenTicketLevels(ticketLevel));
-+        }
-+    }
-+    // Paper end - replace ticket level propagator
-+
-     protected void purgeStaleTickets() {
-         ++this.ticketTickCounter;
-         ObjectIterator objectiterator = this.tickets.long2ObjectEntrySet().fastIterator();
-@@ -0,0 +0,0 @@ public abstract class DistanceManager {
-             if ((entry.getValue()).removeIf((ticket) -> { // CraftBukkit - decompile error
-                 return ticket.timedOut(this.ticketTickCounter);
-             })) {
-                this.ticketTracker.update(entry.getLongKey(), DistanceManager.getTicketLevelAt((SortedArraySet) entry.getValue()), false);
-+                this.updateTicketLevel(entry.getLongKey(), getTicketLevelAt(entry.getValue())); // Paper - replace ticket level propagator
-             }
- 
-             if (((SortedArraySet) entry.getValue()).isEmpty()) {
-@@ -0,0 +0,0 @@ public abstract class DistanceManager {
-     @Nullable
-     protected abstract ChunkHolder updateChunkScheduling(long pos, int level, @Nullable ChunkHolder holder, int k);
- 
-+    protected long ticketLevelUpdateCount; // Paper - replace ticket level propagator
-     public boolean runAllUpdates(ChunkMap playerchunkmap) {
-         //this.f.a(); // Paper - no longer used
-         org.spigotmc.AsyncCatcher.catchOp("DistanceManagerTick"); // Paper
-         //this.playerTicketManager.runAllUpdates(); // Paper - no longer used
-        int i = Integer.MAX_VALUE - this.ticketTracker.runDistanceUpdates(Integer.MAX_VALUE);
-        boolean flag = i != 0;
-+        boolean flag = this.ticketLevelPropagator.propagateUpdates(); // Paper - replace ticket level propagator
- 
-         if (flag) {
-             ;
-         }
- 
-        // Paper start
-        if (!this.pendingChunkUpdates.isEmpty()) {
-            this.pollingPendingChunkUpdates = true; try { // Paper - Chunk priority
-            while(!this.pendingChunkUpdates.isEmpty()) {
-                ChunkHolder remove = this.pendingChunkUpdates.remove();
-                remove.isUpdateQueued = false;
-                remove.updateFutures(playerchunkmap, this.mainThreadExecutor);
-            }
-            } finally { this.pollingPendingChunkUpdates = false; } // Paper - Chunk priority
-            // Paper end
-            return true;
-        } else {
-            if (!this.ticketsToRelease.isEmpty()) {
-                LongIterator longiterator = this.ticketsToRelease.iterator();
-+        // Paper start - replace level propagator
-+        ticket_update_loop:
-+        while (!this.ticketLevelUpdates.isEmpty()) {
-+            flag = true;
- 
-                while (longiterator.hasNext()) {
-                    long j = longiterator.nextLong();
-+            boolean oldPolling = this.pollingPendingChunkUpdates;
-+            this.pollingPendingChunkUpdates = true;
-+            try {
-+                for (java.util.Iterator<Long2IntMap.Entry> iterator = this.ticketLevelUpdates.long2IntEntrySet().fastIterator(); iterator.hasNext();) {
-+                    Long2IntMap.Entry entry = iterator.next();
-+                    long key = entry.getLongKey();
-+                    int newLevel = entry.getIntValue();
-+                    ChunkHolder chunk = this.getChunk(key);
-+
-+                    if (chunk == null && newLevel > ChunkMap.MAX_CHUNK_DISTANCE) {
-+                        // not loaded and it shouldn't be loaded!
-+                        continue;
-+                    }
-+
-+                    int currentLevel = chunk == null ? ChunkMap.MAX_CHUNK_DISTANCE + 1 : chunk.getTicketLevel();
-+
-+                    if (currentLevel == newLevel) {
-+                        // nothing to do
-+                        continue;
-+                    }
- 
-                    if (this.getTickets(j).stream().anyMatch((ticket) -> {
-                        return ticket.getType() == TicketType.PLAYER;
-                    })) {
-                        ChunkHolder playerchunk = playerchunkmap.getUpdatingChunkIfPresent(j);
-+                    this.updateChunkScheduling(key, newLevel, chunk, currentLevel);
-+                }
- 
-                        if (playerchunk == null) {
-                            throw new IllegalStateException();
-+                long recursiveCheck = ++this.ticketLevelUpdateCount;
-+                while (!this.ticketLevelUpdates.isEmpty()) {
-+                    long key = this.ticketLevelUpdates.firstLongKey();
-+                    int newLevel = this.ticketLevelUpdates.removeFirstInt();
-+                    ChunkHolder chunk = this.getChunk(key);
-+
-+                    if (chunk == null) {
-+                        if (newLevel <= ChunkMap.MAX_CHUNK_DISTANCE) {
-+                            throw new IllegalStateException("Expected chunk holder to be created");
-                         }
-+                        // not loaded and it shouldn't be loaded!
-+                        continue;
-+                    }
- 
-                        CompletableFuture<Either<LevelChunk, ChunkHolder.ChunkLoadingFailure>> completablefuture = playerchunk.getEntityTickingChunkFuture();
-+                    int currentLevel = chunk.oldTicketLevel;
- 
-                        completablefuture.thenAccept((either) -> {
-                            this.mainThreadExecutor.execute(() -> {
-                                this.ticketThrottlerReleaser.tell(ChunkTaskPriorityQueueSorter.release(() -> {
-                                }, j, false));
-                            });
-                        });
-+                    if (currentLevel == newLevel) {
-+                        // nothing to do
-+                        continue;
-+                    }
-+
-+                    chunk.updateFutures(playerchunkmap, this.mainThreadExecutor);
-+                    if (recursiveCheck != this.ticketLevelUpdateCount) {
-+                        // back to the start, we must create player chunks and update the ticket level fields before
-+                        // processing the actual level updates
-+                        continue ticket_update_loop;
-                     }
-                 }
- 
-                this.ticketsToRelease.clear();
-            }
-+                for (;;) {
-+                    if (recursiveCheck != this.ticketLevelUpdateCount) {
-+                        continue ticket_update_loop;
-+                    }
-+                    ChunkHolder pendingUpdate = this.pendingChunkUpdates.poll();
-+                    if (pendingUpdate == null) {
-+                        break;
-+                    }
- 
-            return flag;
-+                    pendingUpdate.updateFutures(playerchunkmap, this.mainThreadExecutor);
-+                }
-+            } finally {
-+                this.pollingPendingChunkUpdates = oldPolling;
-+            }
-         }
-+
-+        return flag;
-+        // Paper end - replace level propagator
-     }
-     boolean pollingPendingChunkUpdates = false; // Paper - Chunk priority
- 
-@@ -0,0 +0,0 @@ public abstract class DistanceManager {
- 
-         ticket1.setCreatedTick(this.ticketTickCounter);
-         if (ticket.getTicketLevel() < j) {
-            this.ticketTracker.update(i, ticket.getTicketLevel(), true);
-+            this.updateTicketLevel(i, ticket.getTicketLevel()); // Paper - replace ticket level propagator
-         }
- 
-         return ticket == ticket1; // CraftBukkit
-@@ -0,0 +0,0 @@ public abstract class DistanceManager {
-         // Paper start - Chunk priority
-         int newLevel = getTicketLevelAt(arraysetsorted);
-         if (newLevel > oldLevel) {
-            this.ticketTracker.update(i, newLevel, false);
-+            this.updateTicketLevel(i, newLevel); // Paper // Paper - replace ticket level propagator
-         }
-         // Paper end
-         return removed; // CraftBukkit
-@@ -0,0 +0,0 @@ public abstract class DistanceManager {
-             SortedArraySet<Ticket<?>> tickets = entry.getValue();
-             if (tickets.remove(target)) {
-                 // copied from removeTicket
-                this.ticketTracker.update(entry.getLongKey(), DistanceManager.getTicketLevelAt(tickets), false);
-+                this.updateTicketLevel(entry.getLongKey(), getTicketLevelAt(tickets)); // Paper - replace ticket level propagator
- 
-                 // can't use entry after it's removed
-                 if (tickets.isEmpty()) {
--- a/patches/unapplied/server/Rewrite-the-light-engine.patch
+++ b/patches/unapplied/server/Rewrite-the-light-engine.patch
--- a/patches/unapplied/server/Send-full-pos-packets-for-hard-colliding-entities.patch
+++ b/patches/unapplied/server/Send-full-pos-packets-for-hard-colliding-entities.patch
@@ -1,38 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Tue, 16 Feb 2021 00:16:56 -0800
-Subject: [PATCH] Send full pos packets for hard colliding entities
-
-Prevent collision problems due to desync (i.e boats)
-
-Configurable under
-`send-full-pos-for-hard-colliding-entities`
-
-diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
-@@ -0,0 +0,0 @@ public class PaperConfig {
-     private static void lagCompensateBlockBreaking() {
-         lagCompensateBlockBreaking = getBoolean("settings.lag-compensate-block-breaking", true);
-     }
-+
-+    public static boolean sendFullPosForHardCollidingEntities;
-+
-+    private static void sendFullPosForHardCollidingEntities() {
-+        sendFullPosForHardCollidingEntities = getBoolean("settings.send-full-pos-for-hard-colliding-entities", true);
-+    }
- }
-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 {
-                     // Paper end - remove allocation of Vec3D here
-                     boolean flag4 = k < -32768L || k > 32767L || l < -32768L || l > 32767L || i1 < -32768L || i1 > 32767L;
- 
-                    if (!flag4 && this.teleportDelay <= 400 && !this.wasRiding && this.wasOnGround == this.entity.isOnGround()) {
-+                    if (!flag4 && this.teleportDelay <= 400 && !this.wasRiding && this.wasOnGround == this.entity.isOnGround() && !(com.destroystokyo.paper.PaperConfig.sendFullPosForHardCollidingEntities && this.entity.hardCollides())) { // Paper - send full pos for hard colliding entities to prevent collision problems due to desync
-                         if ((!flag2 || !flag3) && !(this.entity instanceof AbstractArrow)) {
-                             if (flag2) {
-                                 packet1 = new ClientboundMoveEntityPacket.Pos(this.entity.getId(), (short) ((int) k), (short) ((int) l), (short) ((int) i1), this.entity.isOnGround());
--- a/patches/unapplied/server/Time-scoreboard-search.patch
+++ b/patches/unapplied/server/Time-scoreboard-search.patch
@@ -1,43 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <spottedleaf@spottedleaf.dev>
-Date: Tue, 21 Apr 2020 01:53:22 -0700
-Subject: [PATCH] Time scoreboard search
-
-Plugins leaking scoreboards will make this very expensive,
-let server owners debug it easily
-
-diff --git a/src/main/java/co/aikar/timings/MinecraftTimings.java b/src/main/java/co/aikar/timings/MinecraftTimings.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/co/aikar/timings/MinecraftTimings.java
-+++ b/src/main/java/co/aikar/timings/MinecraftTimings.java
-@@ -0,0 +0,0 @@ public final class MinecraftTimings {
-     public static final Timing antiXrayUpdateTimer = Timings.ofSafe("anti-xray - update");
-     public static final Timing antiXrayObfuscateTimer = Timings.ofSafe("anti-xray - obfuscate");
-     public static final Timing distanceManagerTick = Timings.ofSafe("Distance Manager Tick"); // Paper - add timings for distance manager
-+    public static final Timing scoreboardScoreSearch = Timings.ofSafe("Scoreboard score search"); // Paper - add timings for scoreboard search
- 
-     public static final Timing midTickChunkTasks = Timings.ofSafe("Mid Tick Chunk Tasks");
- 
-diff --git a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboardManager.java b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboardManager.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboardManager.java
-+++ b/src/main/java/org/bukkit/craftbukkit/scoreboard/CraftScoreboardManager.java
-@@ -0,0 +0,0 @@ public final class CraftScoreboardManager implements ScoreboardManager {
- 
-     // CraftBukkit method
-     public void getScoreboardScores(ObjectiveCriteria criteria, String name, Consumer<Score> consumer) {
-+        // Paper start - add timings for scoreboard search
-+        // plugins leaking scoreboards will make this very expensive, let server owners debug it easily
-+        co.aikar.timings.MinecraftTimings.scoreboardScoreSearch.startTimingIfSync();
-+        try {
-+        // Paper end - add timings for scoreboard search
-         for (CraftScoreboard scoreboard : this.scoreboards) {
-             Scoreboard board = scoreboard.board;
-             board.forAllObjectives(criteria, name, (score) -> consumer.accept(score));
-         }
-+        } finally { // Paper start - add timings for scoreboard search
-+            co.aikar.timings.MinecraftTimings.scoreboardScoreSearch.stopTimingIfSync();
-+        }
-+        // Paper end - add timings for scoreboard search
-     }
- }
--- a/patches/unapplied/server/Use-correct-LevelStem-registry-when-loading-default-.patch
+++ b/patches/unapplied/server/Use-correct-LevelStem-registry-when-loading-default-.patch
@@ -1,27 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
-Date: Sat, 16 Oct 2021 17:38:35 -0700
-Subject: [PATCH] Use correct LevelStem registry when loading default
- end/nether
-
-
-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
-             long i = generatorsettings.seed();
-             long j = BiomeManager.obfuscateSeed(i);
-             List<CustomSpawner> list = ImmutableList.of(new PhantomSpawner(), new PatrolSpawner(), new CatSpawner(), new VillageSiege(), new WanderingTraderSpawner(iworlddataserver));
-            LevelStem worlddimension = (LevelStem) registrymaterials.get(dimensionKey);
-+            // Paper start - Use correct LevelStem registry
-+            final LevelStem worlddimension;
-+            if (dimensionKey == LevelStem.END || dimensionKey == LevelStem.NETHER) {
-+                worlddimension = generatorsettings.dimensions().get(dimensionKey);
-+            } else {
-+                worlddimension = registrymaterials.get(dimensionKey);
-+            }
-+            // Paper end
-             DimensionType dimensionmanager;
-             ChunkGenerator chunkgenerator;
- 
--- a/patches/unapplied/server/Use-hash-table-for-maintaing-changed-block-set.patch
+++ b/patches/unapplied/server/Use-hash-table-for-maintaing-changed-block-set.patch
@@ -1,30 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Spottedleaf <Spottedleaf@users.noreply.github.com>
-Date: Thu, 11 Mar 2021 21:17:02 -0800
-Subject: [PATCH] Use hash table for maintaing changed block set
-
-When a lot of block changes occur the iteration for checking can
-add up a bit and cause a small performance impact.
-
-diff --git a/src/main/java/net/minecraft/server/level/ChunkHolder.java b/src/main/java/net/minecraft/server/level/ChunkHolder.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
--- a/src/main/java/net/minecraft/server/level/ChunkHolder.java
-+++ b/src/main/java/net/minecraft/server/level/ChunkHolder.java
-@@ -0,0 +0,0 @@ import net.minecraft.world.level.lighting.LevelLightEngine;
- import net.minecraft.server.MinecraftServer;
- // CraftBukkit end
- 
-+import it.unimi.dsi.fastutil.shorts.ShortOpenHashSet; // Paper
-+
- public class ChunkHolder {
- 
-     public static final Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure> UNLOADED_CHUNK = Either.right(ChunkHolder.ChunkLoadingFailure.UNLOADED);
-@@ -0,0 +0,0 @@ public class ChunkHolder {
-             if (i < 0 || i >= this.changedBlocksPerSection.length) return; // CraftBukkit - SPIGOT-6086, SPIGOT-6296
-             if (this.changedBlocksPerSection[i] == null) {
-                 this.hasChangedSections = true;
-                this.changedBlocksPerSection[i] = new ShortArraySet();
-+                this.changedBlocksPerSection[i] = new ShortOpenHashSet(); // Paper - use a set to make setting constant-time
-             }
- 
-             this.changedBlocksPerSection[i].add(SectionPos.sectionRelativePos(pos));