Readd Leaves protocols

leaf-server/minecraft-patches/features/0113-Leaves-Protocol-Core.patch

@@ -0,0 +1,154 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: violetc <58360096+s-yh-china@users.noreply.github.com>
+Date: Tue, 26 Sep 2023 19:00:41 +0800
+Subject: [PATCH] Leaves: Protocol Core
+
+TODO: Check whether Leaves's Return-nether-portal-fix.patch improves performance
+and change store way to sql maybe?
+
+Original license: GPLv3
+Original project: https://github.com/LeavesMC/Leaves
+
+Commit: 358d3d232c88d0d089e2bcd2de9f814384572b8b
+
+diff --git a/net/minecraft/network/protocol/common/custom/CustomPacketPayload.java b/net/minecraft/network/protocol/common/custom/CustomPacketPayload.java
+index fb263fa1f30a7dfcb7ec2656abfb38e5fe88eac9..56fd1ed7ccaf96e7eedea60fbdbf7f934939d563 100644
+--- a/net/minecraft/network/protocol/common/custom/CustomPacketPayload.java
++++ b/net/minecraft/network/protocol/common/custom/CustomPacketPayload.java
+@@ -40,13 +40,22 @@ public interface CustomPacketPayload {
+ 
+             @Override
+             public void encode(B buffer, CustomPacketPayload value) {
++                // Leaves start - protocol core
++                if (value instanceof org.leavesmc.leaves.protocol.core.LeavesCustomPayload payload) {
++                    org.leavesmc.leaves.protocol.core.LeavesProtocolManager.encode(buffer, payload);
++                    return;
++                }
++                // Leaves end - protocol core
+                 this.writeCap(buffer, value.type(), value);
+             }
+ 
+             @Override
+             public CustomPacketPayload decode(B buffer) {
+                 ResourceLocation resourceLocation = buffer.readResourceLocation();
+-                return (CustomPacketPayload)this.findCodec(resourceLocation).decode(buffer);
++                // Leaves start - protocol core
++                var payload = org.leavesmc.leaves.protocol.core.LeavesProtocolManager.decode(resourceLocation, buffer);
++                return java.util.Objects.requireNonNullElseGet(payload, () -> this.findCodec(resourceLocation).decode(buffer));
++                // Leaves end - protocol core
+             }
+         };
+     }
+diff --git a/net/minecraft/network/protocol/common/custom/DiscardedPayload.java b/net/minecraft/network/protocol/common/custom/DiscardedPayload.java
+index 62b9d9486c15a1ec6527f786df4e9fc483390bcb..5384bbc6bb3dbe5481f9d8cb10282551a0f78ec1 100644
+--- a/net/minecraft/network/protocol/common/custom/DiscardedPayload.java
++++ b/net/minecraft/network/protocol/common/custom/DiscardedPayload.java
+@@ -4,12 +4,12 @@ import net.minecraft.network.FriendlyByteBuf;
+ import net.minecraft.network.codec.StreamCodec;
+ import net.minecraft.resources.ResourceLocation;
+ 
+-public record DiscardedPayload(ResourceLocation id, byte[] data) implements CustomPacketPayload { // Paper - store data
++public record DiscardedPayload(ResourceLocation id, byte @org.jetbrains.annotations.Nullable [] data) implements CustomPacketPayload { // Paper - store data // Leaves - nullable
+     public static <T extends FriendlyByteBuf> StreamCodec<T, DiscardedPayload> codec(ResourceLocation id, int maxSize) {
+         return CustomPacketPayload.codec((value, output) -> {
+             // Paper start
+             // Always write data
+-            output.writeBytes(value.data);
++            if (value.data != null) output.writeBytes(value.data); // Leaves - nullable
+         }, buffer -> {
+             int i = buffer.readableBytes();
+             if (i >= 0 && i <= maxSize) {
+diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
+index 3190ed2171b0de32aeb8761aa3e510c968c45448..58c52eabba725be9fa5fde06be5cf69d0281ce5b 100644
+--- a/net/minecraft/server/MinecraftServer.java
++++ b/net/minecraft/server/MinecraftServer.java
+@@ -1735,6 +1735,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             GameTestTicker.SINGLETON.tick();
+         }
+ 
++        org.leavesmc.leaves.protocol.core.LeavesProtocolManager.handleTick(tickCount); // Leaves - protocol
++
+         for (int i = 0; i < this.tickables.size(); i++) {
+             this.tickables.get(i).run();
+         }
+diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
+index 5775a39220bb5f48e2ce01c51402ac8b194a8d9d..f3fb661e2cbf8119264d113a06bcb7bb5150be91 100644
+--- a/net/minecraft/server/level/ServerPlayer.java
++++ b/net/minecraft/server/level/ServerPlayer.java
+@@ -429,6 +429,8 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+     private ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.PlayerChunkLoaderData chunkLoader;
+     private final ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.ViewDistanceHolder viewDistanceHolder = new ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.ViewDistanceHolder();
+ 
++    public net.minecraft.network.Connection internalConnection; // Leaves - protocol core
++
+     @Override
+     public final boolean moonrise$isRealPlayer() {
+         return this.isRealPlayer;
+diff --git a/net/minecraft/server/network/ServerCommonPacketListenerImpl.java b/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+index d2e8adccf33c6b842fac615006b782b09cfa7a1a..4d48ffeecba7fc4b53dad5f0a4d9c1bb8eac50c1 100644
+--- a/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
++++ b/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+@@ -151,6 +151,18 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+ 
+     @Override
+     public void handleCustomPayload(ServerboundCustomPayloadPacket packet) {
++        // Leaves start - protocol
++        if (packet.payload() instanceof org.leavesmc.leaves.protocol.core.LeavesCustomPayload leavesPayload) {
++            org.leavesmc.leaves.protocol.core.LeavesProtocolManager.handlePayload(player, leavesPayload);
++            return;
++        }
++        if (packet.payload() instanceof net.minecraft.network.protocol.common.custom.DiscardedPayload(net.minecraft.resources.ResourceLocation id, byte[] data)) {
++            if (org.leavesmc.leaves.protocol.core.LeavesProtocolManager.handleBytebuf(player, id, io.netty.buffer.Unpooled.wrappedBuffer(data))) {
++                return;
++            }
++        }
++        // Leaves end - protocol
++
+         // Paper start
+         if (packet.payload() instanceof net.minecraft.network.protocol.common.custom.BrandPayload(String brand)) {
+             this.player.clientBrandName = brand;
+@@ -210,6 +222,7 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+         final String channel = new String(data, from, length, java.nio.charset.StandardCharsets.US_ASCII);
+         if (register) {
+             this.getCraftPlayer().addChannel(channel);
++            org.leavesmc.leaves.protocol.core.LeavesProtocolManager.handleMinecraftRegister(channel, player); // Leaves - protocol
+         } else {
+             this.getCraftPlayer().removeChannel(channel);
+         }
+diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
+index d7d68dbdd39ff6e61531d2edeafdd923f0573c89..5cdfd7b0170ad1dff67802cd7b4d59753b7067b8 100644
+--- a/net/minecraft/server/players/PlayerList.java
++++ b/net/minecraft/server/players/PlayerList.java
+@@ -345,6 +345,8 @@ public abstract class PlayerList {
+ 
+         player.didPlayerJoinEvent = true; // Gale - EMC - do not process chat/commands before player has joined
+ 
++        org.leavesmc.leaves.protocol.core.LeavesProtocolManager.handlePlayerJoin(player); // Leaves - protocol
++
+         final net.kyori.adventure.text.Component jm = playerJoinEvent.joinMessage();
+ 
+         if (jm != null && !jm.equals(net.kyori.adventure.text.Component.empty())) { // Paper - Adventure
+@@ -522,6 +524,7 @@ public abstract class PlayerList {
+         return this.remove(player, net.kyori.adventure.text.Component.translatable("multiplayer.player.left", net.kyori.adventure.text.format.NamedTextColor.YELLOW, io.papermc.paper.configuration.GlobalConfiguration.get().messages.useDisplayNameInQuitMessage ? player.getBukkitEntity().displayName() : io.papermc.paper.adventure.PaperAdventure.asAdventure(player.getDisplayName())));
+     }
+     public @Nullable net.kyori.adventure.text.Component remove(ServerPlayer player, net.kyori.adventure.text.Component leaveMessage) {
++        org.leavesmc.leaves.protocol.core.LeavesProtocolManager.handlePlayerLeave(player); // Leaves - protocol
+         // Paper end - Fix kick event leave message not being sent
+         org.purpurmc.purpur.task.BossBarTask.removeFromAll(player.getBukkitEntity()); // Purpur - Implement TPSBar
+         ServerLevel serverLevel = player.serverLevel();
+@@ -648,6 +651,7 @@ public abstract class PlayerList {
+         SocketAddress socketAddress = loginlistener.connection.getRemoteAddress();
+ 
+         ServerPlayer entity = new ServerPlayer(this.server, this.server.getLevel(Level.OVERWORLD), gameProfile, ClientInformation.createDefault());
++        entity.internalConnection = loginlistener.connection; // Leaves - protocol core
+         entity.transferCookieConnection = loginlistener;
+         org.bukkit.entity.Player player = entity.getBukkitEntity();
+         org.bukkit.event.player.PlayerLoginEvent event = new org.bukkit.event.player.PlayerLoginEvent(player, loginlistener.connection.hostname, ((java.net.InetSocketAddress) socketAddress).getAddress(), ((java.net.InetSocketAddress) loginlistener.connection.channel.remoteAddress()).getAddress());
+@@ -1527,6 +1531,7 @@ public abstract class PlayerList {
+             serverPlayer.connection.send(clientboundUpdateRecipesPacket);
+             serverPlayer.getRecipeBook().sendInitialRecipeBook(serverPlayer);
+         }
++        org.leavesmc.leaves.protocol.core.LeavesProtocolManager.handleDataPackReload(); // Leaves - protocol core
+     }
+ 
+     public boolean isAllowCommandsForAllPlayers() {

leaf-server/minecraft-patches/features/0114-Leaves-Jade-Protocol.patch

@@ -0,0 +1,114 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: violetc <58360096+s-yh-china@users.noreply.github.com>
+Date: Sat, 3 Dec 2022 08:57:15 +0800
+Subject: [PATCH] Leaves: Jade Protocol
+
+Original license: GPLv3
+Original project: https://github.com/LeavesMC/Leaves
+
+This patch is Powered by Jade (https://github.com/Snownee/Jade)
+
+diff --git a/net/minecraft/world/entity/animal/armadillo/Armadillo.java b/net/minecraft/world/entity/animal/armadillo/Armadillo.java
+index aea96e036846c66d411fdea55fbbf0efb60d467d..fb8a56d0ee80b0d397f2acd3af1f52fc26676b62 100644
+--- a/net/minecraft/world/entity/animal/armadillo/Armadillo.java
++++ b/net/minecraft/world/entity/animal/armadillo/Armadillo.java
+@@ -60,7 +60,7 @@ public class Armadillo extends Animal {
+     public final AnimationState rollOutAnimationState = new AnimationState();
+     public final AnimationState rollUpAnimationState = new AnimationState();
+     public final AnimationState peekAnimationState = new AnimationState();
+-    private int scuteTime;
++    public int scuteTime; // Leaves - private -> public
+     private boolean peekReceivedClient = false;
+ 
+     public Armadillo(EntityType<? extends Animal> entityType, Level level) {
+diff --git a/net/minecraft/world/entity/animal/frog/Tadpole.java b/net/minecraft/world/entity/animal/frog/Tadpole.java
+index 7a3bfa91ffc5c7c6b04eef7b1b1d3c04c5a6d856..07fd03f1a8e72a5b39e5f9fd13f401dbfdb45280 100644
+--- a/net/minecraft/world/entity/animal/frog/Tadpole.java
++++ b/net/minecraft/world/entity/animal/frog/Tadpole.java
+@@ -284,7 +284,7 @@ public class Tadpole extends AbstractFish {
+         }
+     }
+ 
+-    private int getTicksLeftUntilAdult() {
++    public int getTicksLeftUntilAdult() { // Leaves - private -> public
+         return Math.max(0, ticksToBeFrog - this.age);
+     }
+ 
+diff --git a/net/minecraft/world/level/storage/loot/LootPool.java b/net/minecraft/world/level/storage/loot/LootPool.java
+index 29ad43245a310756c4227acd7532e905f7f8b8ee..ad422817593449b8e914628b51d760e732e2d50c 100644
+--- a/net/minecraft/world/level/storage/loot/LootPool.java
++++ b/net/minecraft/world/level/storage/loot/LootPool.java
+@@ -36,7 +36,7 @@ public class LootPool {
+             )
+             .apply(instance, LootPool::new)
+     );
+-    private final List<LootPoolEntryContainer> entries;
++    public final List<LootPoolEntryContainer> entries; // Leaves - private -> public
+     private final List<LootItemCondition> conditions;
+     private final Predicate<LootContext> compositeCondition;
+     private final List<LootItemFunction> functions;
+diff --git a/net/minecraft/world/level/storage/loot/LootTable.java b/net/minecraft/world/level/storage/loot/LootTable.java
+index 7a8eb1e8b07647e1124594f78652d34731e4fda6..6cfe7ef8c81f506bce9c971b597cc4e902bcabbe 100644
+--- a/net/minecraft/world/level/storage/loot/LootTable.java
++++ b/net/minecraft/world/level/storage/loot/LootTable.java
+@@ -49,7 +49,7 @@ public class LootTable {
+     public static final LootTable EMPTY = new LootTable(LootContextParamSets.EMPTY, Optional.empty(), List.of(), List.of());
+     private final ContextKeySet paramSet;
+     private final Optional<ResourceLocation> randomSequence;
+-    private final List<LootPool> pools;
++    public final List<LootPool> pools; // Leaves - private -> public
+     private final List<LootItemFunction> functions;
+     private final BiFunction<ItemStack, LootContext, ItemStack> compositeFunction;
+     public org.bukkit.craftbukkit.CraftLootTable craftLootTable; // CraftBukkit
+diff --git a/net/minecraft/world/level/storage/loot/entries/CompositeEntryBase.java b/net/minecraft/world/level/storage/loot/entries/CompositeEntryBase.java
+index 8e91ddc6c0e492d165ad8322b4a3d5c3bad5409c..6e420bfb3c223b094157bdfec7dad20d8eab4968 100644
+--- a/net/minecraft/world/level/storage/loot/entries/CompositeEntryBase.java
++++ b/net/minecraft/world/level/storage/loot/entries/CompositeEntryBase.java
+@@ -9,7 +9,7 @@ import net.minecraft.world.level.storage.loot.ValidationContext;
+ import net.minecraft.world.level.storage.loot.predicates.LootItemCondition;
+ 
+ public abstract class CompositeEntryBase extends LootPoolEntryContainer {
+-    protected final List<LootPoolEntryContainer> children;
++    public final List<LootPoolEntryContainer> children; // Leaves - private -> public
+     private final ComposableEntryContainer composedChildren;
+ 
+     protected CompositeEntryBase(List<LootPoolEntryContainer> children, List<LootItemCondition> conditions) {
+diff --git a/net/minecraft/world/level/storage/loot/entries/LootPoolEntryContainer.java b/net/minecraft/world/level/storage/loot/entries/LootPoolEntryContainer.java
+index e0e933245e038b7229eeddbda272b081161ab603..c5e3834fa970ac909cefea43420378394153d781 100644
+--- a/net/minecraft/world/level/storage/loot/entries/LootPoolEntryContainer.java
++++ b/net/minecraft/world/level/storage/loot/entries/LootPoolEntryContainer.java
+@@ -13,7 +13,7 @@ import net.minecraft.world.level.storage.loot.predicates.ConditionUserBuilder;
+ import net.minecraft.world.level.storage.loot.predicates.LootItemCondition;
+ 
+ public abstract class LootPoolEntryContainer implements ComposableEntryContainer {
+-    protected final List<LootItemCondition> conditions;
++    public final List<LootItemCondition> conditions; // Leaves - private -> public
+     private final Predicate<LootContext> compositeCondition;
+ 
+     protected LootPoolEntryContainer(List<LootItemCondition> conditions) {
+diff --git a/net/minecraft/world/level/storage/loot/entries/NestedLootTable.java b/net/minecraft/world/level/storage/loot/entries/NestedLootTable.java
+index f7b647e81ca99040bae8161a2bc0dcacf5bd537f..069df530b1db72bd4a2b1b80b2570dca545dfd20 100644
+--- a/net/minecraft/world/level/storage/loot/entries/NestedLootTable.java
++++ b/net/minecraft/world/level/storage/loot/entries/NestedLootTable.java
+@@ -22,7 +22,7 @@ public class NestedLootTable extends LootPoolSingletonContainer {
+             .and(singletonFields(instance))
+             .apply(instance, NestedLootTable::new)
+     );
+-    private final Either<ResourceKey<LootTable>, LootTable> contents;
++    public final Either<ResourceKey<LootTable>, LootTable> contents; // Leaves - private -> public
+ 
+     private NestedLootTable(
+         Either<ResourceKey<LootTable>, LootTable> contents, int weight, int quality, List<LootItemCondition> conditions, List<LootItemFunction> functions
+diff --git a/net/minecraft/world/level/storage/loot/predicates/CompositeLootItemCondition.java b/net/minecraft/world/level/storage/loot/predicates/CompositeLootItemCondition.java
+index 7134c54984a12949cd6a2e8dc35c2e1c0431e524..52f36fbb9bfcad81004e531efab85e9b87d3284d 100644
+--- a/net/minecraft/world/level/storage/loot/predicates/CompositeLootItemCondition.java
++++ b/net/minecraft/world/level/storage/loot/predicates/CompositeLootItemCondition.java
+@@ -11,7 +11,7 @@ import net.minecraft.world.level.storage.loot.LootContext;
+ import net.minecraft.world.level.storage.loot.ValidationContext;
+ 
+ public abstract class CompositeLootItemCondition implements LootItemCondition {
+-    protected final List<LootItemCondition> terms;
++    public final List<LootItemCondition> terms; // Leaves - private -> public
+     private final Predicate<LootContext> composedPredicate;
+ 
+     protected CompositeLootItemCondition(List<LootItemCondition> terms, Predicate<LootContext> composedPredicate) {

leaf-server/minecraft-patches/features/0115-Leaves-Xaero-Map-Protocol.patch

@@ -0,0 +1,22 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: violetc <58360096+s-yh-china@users.noreply.github.com>
+Date: Fri, 27 Jan 2023 09:42:57 +0800
+Subject: [PATCH] Leaves: Xaero Map Protocol
+
+Original license: GPLv3
+Original project: https://github.com/LeavesMC/Leaves
+
+This patch is Powered by Xaero Map
+
+diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
+index 5cdfd7b0170ad1dff67802cd7b4d59753b7067b8..b7c1d4c66d3ea23288e9e6ba9cb20122730f8869 100644
+--- a/net/minecraft/server/players/PlayerList.java
++++ b/net/minecraft/server/players/PlayerList.java
+@@ -1238,6 +1238,7 @@ public abstract class PlayerList {
+         player.connection.send(new ClientboundInitializeBorderPacket(worldBorder));
+         player.connection.send(new ClientboundSetTimePacket(level.getGameTime(), level.getDayTime(), level.getGameRules().getBoolean(GameRules.RULE_DAYLIGHT)));
+         player.connection.send(new ClientboundSetDefaultSpawnPositionPacket(level.getSharedSpawnPos(), level.getSharedSpawnAngle()));
++        org.leavesmc.leaves.protocol.XaeroMapProtocol.onSendWorldInfo(player); // Leaves - xaero map protocol
+         if (level.isRaining()) {
+             // CraftBukkit start - handle player weather
+             // player.connection.send(new ClientboundGameEventPacket(ClientboundGameEventPacket.START_RAINING, 0.0F));

leaf-server/minecraft-patches/features/0116-Leaves-Syncmatica-Protocol.patch

@@ -0,0 +1,26 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: violetc <58360096+s-yh-china@users.noreply.github.com>
+Date: Thu, 18 May 2023 16:16:56 +0800
+Subject: [PATCH] Leaves: Syncmatica Protocol
+
+Original license: GPLv3
+Original project: https://github.com/LeavesMC/Leaves
+
+This patch is Powered by Syncmatica (https://github.com/End-Tech/syncmatica)
+
+diff --git a/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 44e96e867d8a4403a7c88f772d2aa60cbe9f516b..0bf9ead58e256dccd3c1e89bd08ebae9d630b49e 100644
+--- a/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -319,8 +319,11 @@ public class ServerGamePacketListenerImpl
+         this.signedMessageDecoder = SignedMessageChain.Decoder.unsigned(player.getUUID(), server::enforceSecureProfile);
+         this.chatMessageChain = new FutureChain(server.chatExecutor); // CraftBukkit - async chat
+         this.tickEndEvent = new io.papermc.paper.event.packet.ClientTickEndEvent(player.getBukkitEntity()); // Paper - add client tick end event
++        this.exchangeTarget = new org.leavesmc.leaves.protocol.syncmatica.exchange.ExchangeTarget(this); // Leaves - Syncmatica Protocol
+     }
+ 
++    public final org.leavesmc.leaves.protocol.syncmatica.exchange.ExchangeTarget exchangeTarget; // Leaves - Syncmatica Protocol
++
+     // Purpur start - AFK API
+     private final com.google.common.cache.LoadingCache<org.bukkit.craftbukkit.entity.CraftPlayer, Boolean> kickPermissionCache = com.google.common.cache.CacheBuilder.newBuilder()
+         .maximumSize(1000)

leaf-server/minecraft-patches/features/0117-Leaves-Replay-Mod-API.patch

@@ -0,0 +1,375 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: violetc <58360096+s-yh-china@users.noreply.github.com>
+Date: Thu, 3 Aug 2023 20:36:38 +0800
+Subject: [PATCH] Leaves: Replay Mod API
+
+Co-authored-by: alazeprt <nono135246@126.com>
+
+Original license: GPLv3
+Original project: https://github.com/LeavesMC/Leaves
+
+This patch is Powered by ReplayMod(https://github.com/ReplayMod)
+
+diff --git a/net/minecraft/commands/CommandSourceStack.java b/net/minecraft/commands/CommandSourceStack.java
+index 4d06587cd55af988eecdda5186577ab72ca3d533..6d1096d6cdf0ae23ab4cacabe4dbe531fea455a7 100644
+--- a/net/minecraft/commands/CommandSourceStack.java
++++ b/net/minecraft/commands/CommandSourceStack.java
+@@ -625,7 +625,7 @@ public class CommandSourceStack implements ExecutionCommandSource<CommandSourceS
+ 
+     @Override
+     public Collection<String> getOnlinePlayerNames() {
+-        return this.entity instanceof ServerPlayer sourcePlayer && !sourcePlayer.getBukkitEntity().hasPermission("paper.bypass-visibility.tab-completion") ? this.getServer().getPlayerList().getPlayers().stream().filter(serverPlayer -> sourcePlayer.getBukkitEntity().canSee(serverPlayer.getBukkitEntity())).map(serverPlayer -> serverPlayer.getGameProfile().getName()).toList() : Lists.newArrayList(this.server.getPlayerNames()); // Paper - Make CommandSourceStack respect hidden players
++        return this.entity instanceof ServerPlayer sourcePlayer && !(sourcePlayer instanceof org.leavesmc.leaves.replay.ServerPhotographer) && !sourcePlayer.getBukkitEntity().hasPermission("paper.bypass-visibility.tab-completion") ? this.getServer().getPlayerList().getPlayers().stream().filter(serverPlayer -> sourcePlayer.getBukkitEntity().canSee(serverPlayer.getBukkitEntity())).map(serverPlayer -> serverPlayer.getGameProfile().getName()).toList() : Lists.newArrayList(this.server.getPlayerNames()); // Paper - Make CommandSourceStack respect hidden players // Leaves - only real player
+     }
+ 
+     @Override
+diff --git a/net/minecraft/commands/arguments/selector/EntitySelector.java b/net/minecraft/commands/arguments/selector/EntitySelector.java
+index b305ba9bab617bf4e52d0e6ddf160bacc5751a94..853933618e67d7597c23b3099ea7a7a105c0483e 100644
+--- a/net/minecraft/commands/arguments/selector/EntitySelector.java
++++ b/net/minecraft/commands/arguments/selector/EntitySelector.java
+@@ -128,11 +128,12 @@ public class EntitySelector {
+             return this.findPlayers(source);
+         } else if (this.playerName != null) {
+             ServerPlayer playerByName = source.getServer().getPlayerList().getPlayerByName(this.playerName);
++            playerByName = playerByName instanceof org.leavesmc.leaves.replay.ServerPhotographer ? null : playerByName; // Leaves - skip photographer
+             return playerByName == null ? List.of() : List.of(playerByName);
+         } else if (this.entityUUID != null) {
+             for (ServerLevel serverLevel : source.getServer().getAllLevels()) {
+                 Entity entity = serverLevel.getEntity(this.entityUUID);
+-                if (entity != null) {
++                if (entity != null && !(entity instanceof org.leavesmc.leaves.replay.ServerPhotographer)) {
+                     if (entity.getType().isEnabled(source.enabledFeatures())) {
+                         return List.of(entity);
+                     }
+@@ -146,7 +147,7 @@ public class EntitySelector {
+             AABB absoluteAabb = this.getAbsoluteAabb(vec3);
+             if (this.currentEntity) {
+                 Predicate<Entity> predicate = this.getPredicate(vec3, absoluteAabb, null);
+-                return source.getEntity() != null && predicate.test(source.getEntity()) ? List.of(source.getEntity()) : List.of();
++                return source.getEntity() != null && !(source.getEntity() instanceof org.leavesmc.leaves.replay.ServerPhotographer) && predicate.test(source.getEntity()) ? List.of(source.getEntity()) : List.of(); // Leaves - skip photographer
+             } else {
+                 Predicate<Entity> predicate = this.getPredicate(vec3, absoluteAabb, source.enabledFeatures());
+                 List<Entity> list = new ObjectArrayList<>();
+@@ -157,6 +158,7 @@ public class EntitySelector {
+                         this.addEntities(list, serverLevel1, absoluteAabb, predicate);
+                     }
+                 }
++                list.removeIf(entity -> entity instanceof org.leavesmc.leaves.replay.ServerPhotographer); // Leaves - skip photographer
+ 
+                 return this.sortAndLimit(vec3, list);
+             }
+@@ -192,9 +194,11 @@ public class EntitySelector {
+         this.checkPermissions(source);
+         if (this.playerName != null) {
+             ServerPlayer playerByName = source.getServer().getPlayerList().getPlayerByName(this.playerName);
++            playerByName = playerByName instanceof org.leavesmc.leaves.replay.ServerPhotographer ? null : playerByName; // Leaves - skip photographer
+             return playerByName == null || !canSee(source, playerByName) ? List.of() : List.of(playerByName); // Purpur - Hide hidden players from entity selector
+         } else if (this.entityUUID != null) {
+             ServerPlayer playerByName = source.getServer().getPlayerList().getPlayer(this.entityUUID);
++            playerByName = playerByName instanceof org.leavesmc.leaves.replay.ServerPhotographer ? null : playerByName; // Leaves - skip photographer
+             return playerByName == null || !canSee(source, playerByName) ? List.of() : List.of(playerByName); // Purpur - Hide hidden players from entity selector
+         } else {
+             Vec3 vec3 = this.position.apply(source.getPosition());
+@@ -206,13 +210,13 @@ public class EntitySelector {
+                 int resultLimit = this.getResultLimit();
+                 List<ServerPlayer> players;
+                 if (this.isWorldLimited()) {
+-                    players = source.getLevel().getPlayers(predicate, resultLimit);
++                    players = source.getLevel().getPlayers((player -> !(player instanceof org.leavesmc.leaves.replay.ServerPhotographer) && predicate.test(player)), resultLimit); // Leaves - skip photographer
+                     players.removeIf(entityplayer3 -> !canSee(source, entityplayer3)); // Purpur - Hide hidden players from entity selector
+                 } else {
+                     players = new ObjectArrayList<>();
+ 
+                     for (ServerPlayer serverPlayer1 : source.getServer().getPlayerList().getPlayers()) {
+-                        if (predicate.test(serverPlayer1) && canSee(source, serverPlayer1)) { // Purpur - Hide hidden players from entity selector
++                        if (predicate.test(serverPlayer1) && canSee(source, serverPlayer1) && !(serverPlayer1 instanceof org.leavesmc.leaves.replay.ServerPhotographer)) { // Purpur - Hide hidden players from entity selector // Leaves - skip photographer
+                             players.add(serverPlayer1);
+                             if (players.size() >= resultLimit) {
+                                 return players;
+diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
+index 58c52eabba725be9fa5fde06be5cf69d0281ce5b..83cbf865d83edcb4caea59a1a2b4932a915414be 100644
+--- a/net/minecraft/server/MinecraftServer.java
++++ b/net/minecraft/server/MinecraftServer.java
+@@ -1638,7 +1638,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     }
+ 
+     private ServerStatus.Players buildPlayerStatus() {
+-        List<ServerPlayer> players = this.playerList.getPlayers();
++        List<ServerPlayer> players = this.playerList.realPlayers; // Leaves - only real player
+         int maxPlayers = this.getMaxPlayers();
+         if (this.hidesOnlinePlayers()) {
+             return new ServerStatus.Players(maxPlayers, players.size(), List.of());
+diff --git a/net/minecraft/server/PlayerAdvancements.java b/net/minecraft/server/PlayerAdvancements.java
+index edf115439c630a4471460db02109bbce7868de81..c7e92f0122823d9e1aa471c5c0e995d1e1d90184 100644
+--- a/net/minecraft/server/PlayerAdvancements.java
++++ b/net/minecraft/server/PlayerAdvancements.java
+@@ -168,6 +168,11 @@ public class PlayerAdvancements {
+     }
+ 
+     public boolean award(AdvancementHolder advancement, String criterionKey) {
++        // Leaves start - photographer can't get advancement
++        if (player instanceof org.leavesmc.leaves.replay.ServerPhotographer) {
++            return false;
++        }
++        // Leaves end - photographer can't get advancement
+         boolean flag = false;
+         AdvancementProgress orStartProgress = this.getOrStartProgress(advancement);
+         boolean isDone = orStartProgress.isDone();
+diff --git a/net/minecraft/server/commands/OpCommand.java b/net/minecraft/server/commands/OpCommand.java
+index 814bb2981ab32b216b7953e9b14fe09e96cc7c89..45f884bf598b38ec45baf423b84f52931cb019da 100644
+--- a/net/minecraft/server/commands/OpCommand.java
++++ b/net/minecraft/server/commands/OpCommand.java
+@@ -25,7 +25,7 @@ public class OpCommand {
+                             (context, builder) -> {
+                                 PlayerList playerList = context.getSource().getServer().getPlayerList();
+                                 return SharedSuggestionProvider.suggest(
+-                                    playerList.getPlayers()
++                                    playerList.realPlayers // Leaves - only real player
+                                         .stream()
+                                         .filter(player -> !playerList.isOp(player.getGameProfile()))
+                                         .map(player -> player.getGameProfile().getName()),
+diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
+index e6730996dfd4c2422b6c13f10309fc58af4ac595..9b193bf81cf7f9f45dfa207a826043e083c2f8ba 100644
+--- a/net/minecraft/server/level/ServerLevel.java
++++ b/net/minecraft/server/level/ServerLevel.java
+@@ -212,6 +212,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+     public boolean hasEntityMoveEvent; // Paper - Add EntityMoveEvent
+     private final alternate.current.wire.WireHandler wireHandler = new alternate.current.wire.WireHandler(this); // Paper - optimize redstone (Alternate Current)
+     public boolean hasRidableMoveEvent = false; // Purpur - Ridables
++    final List<ServerPlayer> realPlayers; // Leaves - skip
+ 
+     @Override
+     public @Nullable LevelChunk getChunkIfLoaded(int x, int z) {
+@@ -690,6 +691,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+         // Paper end - rewrite chunk system
+         this.getCraftServer().addWorld(this.getWorld()); // CraftBukkit
+         this.preciseTime = this.serverLevelData.getDayTime(); // Purpur - Configurable daylight cycle
++        this.realPlayers = Lists.newArrayList(); // Leaves - skip
+     }
+ 
+     // Paper start
+@@ -2690,6 +2692,11 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             // ServerLevel.this.getChunkSource().addEntity(entity); // Paper - ignore and warn about illegal addEntity calls instead of crashing server; moved down below valid=true
+             if (entity instanceof ServerPlayer serverPlayer) {
+                 ServerLevel.this.players.add(serverPlayer);
++                // Leaves start - skip
++                if (!(serverPlayer instanceof org.leavesmc.leaves.replay.ServerPhotographer)) {
++                    ServerLevel.this.realPlayers.add(serverPlayer);
++                }
++                // Leaves end - skip
+                 ServerLevel.this.updateSleepingPlayerList();
+             }
+ 
+@@ -2760,6 +2767,11 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             ServerLevel.this.getChunkSource().removeEntity(entity);
+             if (entity instanceof ServerPlayer serverPlayer) {
+                 ServerLevel.this.players.remove(serverPlayer);
++                // Leaves start - skip
++                if (!(serverPlayer instanceof org.leavesmc.leaves.replay.ServerPhotographer)) {
++                    ServerLevel.this.realPlayers.remove(serverPlayer);
++                }
++                // Leaves end - skip
+                 ServerLevel.this.updateSleepingPlayerList();
+             }
+ 
+diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
+index b7c1d4c66d3ea23288e9e6ba9cb20122730f8869..f6bfd246571f9f7b25e4bdff66253a99a2e5a77f 100644
+--- a/net/minecraft/server/players/PlayerList.java
++++ b/net/minecraft/server/players/PlayerList.java
+@@ -132,6 +132,7 @@ public abstract class PlayerList {
+     private boolean allowCommandsForAllPlayers;
+     private static final boolean ALLOW_LOGOUTIVATOR = false;
+     private int sendAllPlayerInfoIn;
++    public final List<ServerPlayer> realPlayers = new java.util.concurrent.CopyOnWriteArrayList(); // Leaves - replay api
+ 
+     // CraftBukkit start
+     private org.bukkit.craftbukkit.CraftServer cserver;
+@@ -150,6 +151,106 @@ public abstract class PlayerList {
+ 
+     abstract public void loadAndSaveFiles(); // Paper - fix converting txt to json file; moved from DedicatedPlayerList constructor
+ 
++    // Leaves start - replay mod api
++    public void placeNewPhotographer(Connection connection, org.leavesmc.leaves.replay.ServerPhotographer player, ServerLevel worldserver) {
++        player.isRealPlayer = true; // Paper
++        player.loginTime = System.currentTimeMillis(); // Paper
++
++        ServerLevel worldserver1 = worldserver;
++
++        player.setServerLevel(worldserver1);
++        player.spawnIn(worldserver1);
++        player.gameMode.setLevel((ServerLevel) player.level());
++
++        LevelData worlddata = worldserver1.getLevelData();
++
++        player.loadGameTypes(null);
++        ServerGamePacketListenerImpl playerconnection = new ServerGamePacketListenerImpl(this.server, connection, player, CommonListenerCookie.createInitial(player.gameProfile, false));
++        GameRules gamerules = worldserver1.getGameRules();
++        boolean flag = gamerules.getBoolean(GameRules.RULE_DO_IMMEDIATE_RESPAWN);
++        boolean flag1 = gamerules.getBoolean(GameRules.RULE_REDUCEDDEBUGINFO);
++        boolean flag2 = gamerules.getBoolean(GameRules.RULE_LIMITED_CRAFTING);
++
++        playerconnection.send(new ClientboundLoginPacket(player.getId(), worlddata.isHardcore(), this.server.levelKeys(), this.getMaxPlayers(), worldserver1.getWorld().getSendViewDistance(), worldserver1.getWorld().getSimulationDistance(), flag1, !flag, flag2, player.createCommonSpawnInfo(worldserver1), this.server.enforceSecureProfile())); // Paper - replace old player chunk management
++        player.getBukkitEntity().sendSupportedChannels(); // CraftBukkit
++        playerconnection.send(new ClientboundChangeDifficultyPacket(worlddata.getDifficulty(), worlddata.isDifficultyLocked()));
++        playerconnection.send(new ClientboundPlayerAbilitiesPacket(player.getAbilities()));
++        playerconnection.send(new ClientboundSetHeldSlotPacket(player.getInventory().getSelectedSlot()));
++        RecipeManager craftingmanager = this.server.getRecipeManager();
++        playerconnection.send(new ClientboundUpdateRecipesPacket(craftingmanager.getSynchronizedItemProperties(), craftingmanager.getSynchronizedStonecutterRecipes()));
++
++        this.sendPlayerPermissionLevel(player);
++        player.getStats().markAllDirty();
++        player.getRecipeBook().sendInitialRecipeBook(player);
++        this.updateEntireScoreboard(worldserver1.getScoreboard(), player);
++        this.server.invalidateStatus();
++
++        playerconnection.teleport(player.getX(), player.getY(), player.getZ(), player.getYRot(), player.getXRot());
++        ServerStatus serverping = this.server.getStatus();
++
++        if (serverping != null) {
++            player.sendServerStatus(serverping);
++        }
++
++        this.players.add(player);
++        this.playersByName.put(player.getScoreboardName().toLowerCase(java.util.Locale.ROOT), player); // Spigot
++        this.playersByUUID.put(player.getUUID(), player);
++
++        player.supressTrackerForLogin = true;
++        worldserver1.addNewPlayer(player);
++        this.server.getCustomBossEvents().onPlayerConnect(player);
++        org.bukkit.craftbukkit.entity.CraftPlayer bukkitPlayer = player.getBukkitEntity();
++
++        player.containerMenu.transferTo(player.containerMenu, bukkitPlayer);
++        if (!player.connection.isAcceptingMessages()) {
++            return;
++        }
++
++        // org.leavesmc.leaves.protocol.core.LeavesProtocolManager.handlePlayerJoin(player); // Leaves - protocol
++
++        final List<ServerPlayer> onlinePlayers = Lists.newArrayListWithExpectedSize(this.players.size() - 1);
++        for (int i = 0; i < this.players.size(); ++i) {
++            ServerPlayer entityplayer1 = this.players.get(i);
++
++            if (entityplayer1 == player || !bukkitPlayer.canSee(entityplayer1.getBukkitEntity())) {
++                continue;
++            }
++
++            onlinePlayers.add(entityplayer1);
++        }
++        if (!onlinePlayers.isEmpty()) {
++            player.connection.send(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(onlinePlayers, player));
++        }
++
++        player.sentListPacket = true;
++        player.supressTrackerForLogin = false;
++        ((ServerLevel)player.level()).getChunkSource().chunkMap.addEntity(player);
++
++        this.sendLevelInfo(player, worldserver1);
++
++        if (player.level() == worldserver1 && !worldserver1.players().contains(player)) {
++            worldserver1.addNewPlayer(player);
++            this.server.getCustomBossEvents().onPlayerConnect(player);
++        }
++
++        worldserver1 = player.serverLevel();
++        java.util.Iterator<net.minecraft.world.effect.MobEffectInstance> iterator = player.getActiveEffects().iterator();
++        while (iterator.hasNext()) {
++            MobEffectInstance mobeffect = iterator.next();
++            playerconnection.send(new ClientboundUpdateMobEffectPacket(player.getId(), mobeffect, false));
++        }
++
++        if (player.isDeadOrDying()) {
++            net.minecraft.core.Holder<net.minecraft.world.level.biome.Biome> plains = worldserver1.registryAccess().lookupOrThrow(net.minecraft.core.registries.Registries.BIOME)
++                    .getOrThrow(net.minecraft.world.level.biome.Biomes.PLAINS);
++            player.connection.send(new net.minecraft.network.protocol.game.ClientboundLevelChunkWithLightPacket(
++                    new net.minecraft.world.level.chunk.EmptyLevelChunk(worldserver1, player.chunkPosition(), plains),
++                    worldserver1.getLightEngine(), null, null, false)
++            );
++        }
++    }
++    // Leaves end - replay mod api
++
+     public void placeNewPlayer(Connection connection, ServerPlayer player, CommonListenerCookie cookie) {
+         player.isRealPlayer = true; // Paper
+         player.loginTime = System.currentTimeMillis(); // Paper - Replace OfflinePlayer#getLastPlayed
+@@ -317,6 +418,7 @@ public abstract class PlayerList {
+ 
+         // player.connection.send(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(this.players)); // CraftBukkit - replaced with loop below
+         this.players.add(player);
++        this.realPlayers.add(player); // Leaves - replay api
+         this.playersByName.put(player.getScoreboardName().toLowerCase(java.util.Locale.ROOT), player); // Spigot
+         this.playersByUUID.put(player.getUUID(), player);
+         this.addToSendAllPlayerInfoBuckets(player); // Gale - Purpur - spread out sending all player info
+@@ -378,6 +480,12 @@ public abstract class PlayerList {
+                 continue;
+             }
+ 
++            // Leaves start - skip photographer
++            if (entityplayer1 instanceof org.leavesmc.leaves.replay.ServerPhotographer) {
++                continue;
++            }
++            // Leaves end - skip photographer
++
+             onlinePlayers.add(entityplayer1); // Paper - Use single player info update packet on join
+         }
+         // Paper start - Use single player info update packet on join
+@@ -519,6 +627,43 @@ public abstract class PlayerList {
+         }
+     }
+ 
++    // Leaves start - replay mod api
++    public void removePhotographer(org.leavesmc.leaves.replay.ServerPhotographer entityplayer) {
++        ServerLevel worldserver = entityplayer.serverLevel();
++
++        entityplayer.awardStat(Stats.LEAVE_GAME);
++
++        if (entityplayer.containerMenu != entityplayer.inventoryMenu) {
++            entityplayer.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.DISCONNECT);
++        }
++
++        if (server.isSameThread()) entityplayer.doTick();
++
++        if (this.collideRuleTeamName != null) {
++            final net.minecraft.world.scores.Scoreboard scoreBoard = this.server.getLevel(Level.OVERWORLD).getScoreboard();
++            final PlayerTeam team = scoreBoard.getPlayersTeam(this.collideRuleTeamName);
++            if (entityplayer.getTeam() == team && team != null) {
++                scoreBoard.removePlayerFromTeam(entityplayer.getScoreboardName(), team);
++            }
++        }
++
++        worldserver.removePlayerImmediately(entityplayer, Entity.RemovalReason.UNLOADED_WITH_PLAYER);
++        entityplayer.retireScheduler();
++        entityplayer.getAdvancements().stopListening();
++        this.players.remove(entityplayer);
++        this.playersByName.remove(entityplayer.getScoreboardName().toLowerCase(java.util.Locale.ROOT));
++        this.server.getCustomBossEvents().onPlayerDisconnect(entityplayer);
++        UUID uuid = entityplayer.getUUID();
++        ServerPlayer entityplayer1 = this.playersByUUID.get(uuid);
++
++        if (entityplayer1 == entityplayer) {
++            this.playersByUUID.remove(uuid);
++        }
++
++        this.cserver.getScoreboardManager().removePlayer(entityplayer.getBukkitEntity());
++    }
++    // Leaves stop - replay mod api
++
+     public @Nullable net.kyori.adventure.text.Component remove(ServerPlayer player) { // CraftBukkit - return string // Paper - return Component
+         // Paper start - Fix kick event leave message not being sent
+         return this.remove(player, net.kyori.adventure.text.Component.translatable("multiplayer.player.left", net.kyori.adventure.text.format.NamedTextColor.YELLOW, io.papermc.paper.configuration.GlobalConfiguration.get().messages.useDisplayNameInQuitMessage ? player.getBukkitEntity().displayName() : io.papermc.paper.adventure.PaperAdventure.asAdventure(player.getDisplayName())));
+@@ -595,6 +740,7 @@ public abstract class PlayerList {
+         player.retireScheduler(); // Paper - Folia schedulers
+         player.getAdvancements().stopListening();
+         this.players.remove(player);
++        this.realPlayers.remove(player); // Leaves - replay api
+         this.playersByName.remove(player.getScoreboardName().toLowerCase(java.util.Locale.ROOT)); // Spigot
+         this.removeFromSendAllPlayerInfoBuckets(player); // Gale - Purpur - spread out sending all player info
+         this.server.getCustomBossEvents().onPlayerDisconnect(player);
+@@ -687,7 +833,7 @@ public abstract class PlayerList {
+             // return this.players.size() >= this.maxPlayers && !this.canBypassPlayerLimit(gameProfile)
+             //     ? Component.translatable("multiplayer.disconnect.server_full")
+             //     : null;
+-            if (this.players.size() >= this.maxPlayers && !(player.hasPermission("purpur.joinfullserver") || this.canBypassPlayerLimit(gameProfile))) { // Purpur - Allow player join full server by permission
++            if (this.realPlayers.size() >= this.maxPlayers && !(player.hasPermission("purpur.joinfullserver") || this.canBypassPlayerLimit(gameProfile))) { // Purpur - Allow player join full server by permission // Leaves - only real player
+                 event.disallow(org.bukkit.event.player.PlayerLoginEvent.Result.KICK_FULL, net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(org.spigotmc.SpigotConfig.serverFullMessage)); // Spigot // Paper - Adventure
+             }
+         }

leaf-server/minecraft-patches/features/0120-Reduce-canSee-work.patch

@@ -7,7 +7,7 @@ Co-authored by: Martijn Muijsers <martijnmuijsers@live.nl>
 Co-authored by: MachineBreaker <machinebreaker>
 
 diff --git a/net/minecraft/world/level/Level.java b/net/minecraft/world/level/Level.java
-index 3b814983b91165ecee1a15d24cc0352247316a9f..453d4babc78f5676cb9534a5d80967a6f8c5a263 100644
+index a94f6eb93a4271d8b50cbb55dce04affd1ac4a13..9ac2ecb78f6214616376b0e3badef21dc3f72114 100644
 --- a/net/minecraft/world/level/Level.java
 +++ b/net/minecraft/world/level/Level.java
 @@ -987,17 +987,19 @@ public abstract class Level implements LevelAccessor, UUIDLookup<Entity>, AutoCl

leaf-server/minecraft-patches/features/0121-Fix-sprint-glitch.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Fix sprint glitch
 
 
 diff --git a/net/minecraft/world/entity/LivingEntity.java b/net/minecraft/world/entity/LivingEntity.java
-index 40ab67a6930242553ed7acc9d6cc474a36e23888..ab7bdbce80046df43e4889c20c4d3d9fb1d2e2c4 100644
+index ed15b5f29658d799a36dcbd196a8fcb107be4bda..09aa0b344aff0c48eec9a296d47c0704bd0fdc5c 100644
 --- a/net/minecraft/world/entity/LivingEntity.java
 +++ b/net/minecraft/world/entity/LivingEntity.java
 @@ -1387,7 +1387,8 @@ public abstract class LivingEntity extends Entity implements Attackable {

leaf-server/minecraft-patches/features/0125-Plazma-Add-some-missing-Pufferfish-configurations.patch

@@ -10,7 +10,7 @@ Add Pufferfish DAB support for Camel, Sniffer
 https://github.com/pufferfish-gg/Pufferfish/issues/83
 
 diff --git a/net/minecraft/world/entity/animal/armadillo/Armadillo.java b/net/minecraft/world/entity/animal/armadillo/Armadillo.java
-index aea96e036846c66d411fdea55fbbf0efb60d467d..3b1a40226e903119503108ea72bd0880c164e0e0 100644
+index fb8a56d0ee80b0d397f2acd3af1f52fc26676b62..5d93eb5e56e45d485c0718db9e3d8754e97b691c 100644
 --- a/net/minecraft/world/entity/animal/armadillo/Armadillo.java
 +++ b/net/minecraft/world/entity/animal/armadillo/Armadillo.java
 @@ -162,8 +162,10 @@ public class Armadillo extends Animal {

leaf-server/minecraft-patches/features/0126-Plazma-Add-missing-purpur-configuration-options.patch

@@ -92,7 +92,7 @@ index 50f9a11f8cb53fd1fa34017598ff3fe828b3ca25..9f9abbd3272cba17f79dc4da6cf2cd4d
      protected Brain.Provider<Frog> brainProvider() {
          return Brain.provider(MEMORY_TYPES, SENSOR_TYPES);
 diff --git a/net/minecraft/world/entity/animal/frog/Tadpole.java b/net/minecraft/world/entity/animal/frog/Tadpole.java
-index 7a3bfa91ffc5c7c6b04eef7b1b1d3c04c5a6d856..649d0fd34fc807ee0c87577490c77b71d5d76ecf 100644
+index 07fd03f1a8e72a5b39e5f9fd13f401dbfdb45280..daa315bfbedb0ec21a684d9141fb41ad40ce45b1 100644
 --- a/net/minecraft/world/entity/animal/frog/Tadpole.java
 +++ b/net/minecraft/world/entity/animal/frog/Tadpole.java
 @@ -106,6 +106,23 @@ public class Tadpole extends AbstractFish {

leaf-server/minecraft-patches/features/0129-SparklyPaper-Skip-EntityScheduler-s-executeTick-chec.patch

@@ -13,7 +13,7 @@ To avoid the hefty ArrayDeque's size() call, we check if we *really* need to exe
 Most entities won't have any scheduled tasks, so this is a nice performance bonus. These optimizations, however, wouldn't work in a Folia environment, but because in SparklyPaper executeTick is always executed on the main thread, it ain't an issue for us (yay).
 
 diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index 3190ed2171b0de32aeb8761aa3e510c968c45448..b8b1bcac05917fa985210bcd5c6e226ed188b0ff 100644
+index 83cbf865d83edcb4caea59a1a2b4932a915414be..3a86960729e23c7a5028dd64538d08428afd2b01 100644
 --- a/net/minecraft/server/MinecraftServer.java
 +++ b/net/minecraft/server/MinecraftServer.java
 @@ -289,6 +289,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa

leaf-server/minecraft-patches/features/0134-Remove-useless-creating-stats-json-bases-on-player-n.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Remove useless creating stats json bases on player name logic
 
 
 diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
-index d7d68dbdd39ff6e61531d2edeafdd923f0573c89..536fea9622cdec212aa61adbb627704c59a8999f 100644
+index f6bfd246571f9f7b25e4bdff66253a99a2e5a77f..5966b45ec8c385539535139885e5ff522c998141 100644
 --- a/net/minecraft/server/players/PlayerList.java
 +++ b/net/minecraft/server/players/PlayerList.java
-@@ -1426,6 +1426,8 @@ public abstract class PlayerList {
+@@ -1577,6 +1577,8 @@ public abstract class PlayerList {
          if (serverStatsCounter == null) {
              File file = this.server.getWorldPath(LevelResource.PLAYER_STATS_DIR).toFile();
              File file1 = new File(file, uuid + ".json");
@@ -17,7 +17,7 @@ index d7d68dbdd39ff6e61531d2edeafdd923f0573c89..536fea9622cdec212aa61adbb627704c
              if (!file1.exists()) {
                  File file2 = new File(file, displayName + ".json"); // CraftBukkit
                  Path path = file2.toPath();
-@@ -1433,6 +1435,8 @@ public abstract class PlayerList {
+@@ -1584,6 +1586,8 @@ public abstract class PlayerList {
                      file2.renameTo(file1);
                  }
              }

leaf-server/minecraft-patches/features/0135-Improve-Purpur-AFK-system.patch

@@ -19,10 +19,10 @@ index eb600398e4802bb47231bbc0c55fb24ce24a6efb..54cc28bb1693be2077cb30d1dc85f9ae
              org.purpurmc.purpur.command.DemoCommand.register(this.dispatcher); // Purpur - Add demo command
              org.purpurmc.purpur.command.PingCommand.register(this.dispatcher); // Purpur - Add ping command
 diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
-index a05cd22bfe3a2c25a5e37c973766a162ce8e7244..602a087122a6baa3cb33e1bf5e6c4d98e500fa05 100644
+index f3fb661e2cbf8119264d113a06bcb7bb5150be91..034a946cd545d775188a4375a87c90d253ebdb08 100644
 --- a/net/minecraft/server/level/ServerPlayer.java
 +++ b/net/minecraft/server/level/ServerPlayer.java
-@@ -2385,6 +2385,10 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+@@ -2387,6 +2387,10 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
  
      // Purpur start - AFK API
      private boolean isAfk = false;
@@ -33,7 +33,7 @@ index a05cd22bfe3a2c25a5e37c973766a162ce8e7244..602a087122a6baa3cb33e1bf5e6c4d98
  
      @Override
      public void setAfk(boolean afk) {
-@@ -2422,6 +2426,18 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+@@ -2424,6 +2428,18 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
              String prefix = (split.length > 0 ? split[0] : "").replace(org.purpurmc.purpur.PurpurConfig.afkTabListPrefix, "");
              String suffix = (split.length > 1 ? split[1] : "").replace(org.purpurmc.purpur.PurpurConfig.afkTabListSuffix, "");
              if (afk) {
@@ -53,10 +53,10 @@ index a05cd22bfe3a2c25a5e37c973766a162ce8e7244..602a087122a6baa3cb33e1bf5e6c4d98
              } else {
                  getBukkitEntity().setPlayerListName(prefix + scoreboardName + suffix, true);
 diff --git a/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 470660998d3df511f00936bcaa210142ab8ba7b2..220dd097aa1d912feb6699dccd1b68523c14cdf6 100644
+index 0bf9ead58e256dccd3c1e89bd08ebae9d630b49e..3c14d32ec9caf3dba9d99afe86a3ca053de70958 100644
 --- a/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 +++ b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -2324,6 +2324,7 @@ public class ServerGamePacketListenerImpl
+@@ -2327,6 +2327,7 @@ public class ServerGamePacketListenerImpl
  
      @Override
      public void handleChatCommand(ServerboundChatCommandPacket packet) {
@@ -64,7 +64,7 @@ index 470660998d3df511f00936bcaa210142ab8ba7b2..220dd097aa1d912feb6699dccd1b6852
          this.tryHandleChat(packet.command(), () -> {
              // CraftBukkit start - SPIGOT-7346: Prevent disconnected players from executing commands
              if (this.player.hasDisconnected()) {
-@@ -2332,7 +2333,7 @@ public class ServerGamePacketListenerImpl
+@@ -2335,7 +2336,7 @@ public class ServerGamePacketListenerImpl
              // CraftBukkit end
              this.performUnsignedChatCommand(packet.command());
              this.detectRateSpam("/" + packet.command()); // Spigot
@@ -73,7 +73,7 @@ index 470660998d3df511f00936bcaa210142ab8ba7b2..220dd097aa1d912feb6699dccd1b6852
      }
  
      private void performUnsignedChatCommand(String command) {
-@@ -2365,6 +2366,7 @@ public class ServerGamePacketListenerImpl
+@@ -2368,6 +2369,7 @@ public class ServerGamePacketListenerImpl
      public void handleSignedChatCommand(ServerboundChatCommandSignedPacket packet) {
          Optional<LastSeenMessages> optional = this.unpackAndApplyLastSeen(packet.lastSeenMessages());
          if (!optional.isEmpty()) {
@@ -81,7 +81,7 @@ index 470660998d3df511f00936bcaa210142ab8ba7b2..220dd097aa1d912feb6699dccd1b6852
              this.tryHandleChat(packet.command(), () -> {
                  // CraftBukkit start - SPIGOT-7346: Prevent disconnected players from executing commands
                  if (this.player.hasDisconnected()) {
-@@ -2373,7 +2375,7 @@ public class ServerGamePacketListenerImpl
+@@ -2376,7 +2378,7 @@ public class ServerGamePacketListenerImpl
                  // CraftBukkit end
                  this.performSignedChatCommand(packet, optional.get());
                  this.detectRateSpam("/" + packet.command()); // Spigot
@@ -90,7 +90,7 @@ index 470660998d3df511f00936bcaa210142ab8ba7b2..220dd097aa1d912feb6699dccd1b6852
          }
      }
  
-@@ -2480,12 +2482,17 @@ public class ServerGamePacketListenerImpl
+@@ -2483,12 +2485,17 @@ public class ServerGamePacketListenerImpl
          return dispatcher.parse(command, this.player.createCommandSourceStack());
      }
  
@@ -110,7 +110,7 @@ index 470660998d3df511f00936bcaa210142ab8ba7b2..220dd097aa1d912feb6699dccd1b6852
              this.player.resetLastActionTime();
              // CraftBukkit start
              if (sync) {
-@@ -2497,6 +2504,40 @@ public class ServerGamePacketListenerImpl
+@@ -2500,6 +2507,40 @@ public class ServerGamePacketListenerImpl
          }
      }
  
@@ -152,11 +152,11 @@ index 470660998d3df511f00936bcaa210142ab8ba7b2..220dd097aa1d912feb6699dccd1b6852
          synchronized (this.lastSeenMessages) {
              Optional var10000;
 diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
-index 536fea9622cdec212aa61adbb627704c59a8999f..37ba75bd50f785da11a0127fb40d86ee8b988c17 100644
+index 5966b45ec8c385539535139885e5ff522c998141..e9529dfb98bf025fbdd59bbd2c61ea8169907fb6 100644
 --- a/net/minecraft/server/players/PlayerList.java
 +++ b/net/minecraft/server/players/PlayerList.java
-@@ -524,6 +524,7 @@ public abstract class PlayerList {
-     public @Nullable net.kyori.adventure.text.Component remove(ServerPlayer player, net.kyori.adventure.text.Component leaveMessage) {
+@@ -672,6 +672,7 @@ public abstract class PlayerList {
+         org.leavesmc.leaves.protocol.core.LeavesProtocolManager.handlePlayerLeave(player); // Leaves - protocol
          // Paper end - Fix kick event leave message not being sent
          org.purpurmc.purpur.task.BossBarTask.removeFromAll(player.getBukkitEntity()); // Purpur - Implement TPSBar
 +        net.minecraft.server.network.ServerGamePacketListenerImpl.afkCooldown.remove(player.getBukkitEntity().getUniqueId()); // Leaf - Improve Purpur AFK system

leaf-server/minecraft-patches/features/0136-Virtual-thread-for-chat-executor.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Virtual thread for chat executor
 
 
 diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index b8b1bcac05917fa985210bcd5c6e226ed188b0ff..49cd06c0b71c6aa643b692c21ecbc01266291770 100644
+index 3a86960729e23c7a5028dd64538d08428afd2b01..3ca7405318a4076000250203be4b91dbde95191b 100644
 --- a/net/minecraft/server/MinecraftServer.java
 +++ b/net/minecraft/server/MinecraftServer.java
-@@ -2660,7 +2660,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -2662,7 +2662,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
      }
  
      public final java.util.concurrent.ExecutorService chatExecutor = java.util.concurrent.Executors.newCachedThreadPool(

leaf-server/minecraft-patches/features/0138-Mirai-Configurable-chat-message-signatures.patch

@@ -103,10 +103,10 @@ index cdfb9004dd4f4ea1bbb77895b7fc020d628c485d..54910c2e1d6e6bb556e536fda060bd09
          // Paper start - Add setting for proxy online mode status
          return properties.enforceSecureProfile
 diff --git a/net/minecraft/server/network/ServerCommonPacketListenerImpl.java b/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
-index d2e8adccf33c6b842fac615006b782b09cfa7a1a..434be9d08d8e816e2dea1e9d23fa26d21b9f35f6 100644
+index 4d48ffeecba7fc4b53dad5f0a4d9c1bb8eac50c1..18f0d486c478087f404d8bb6cd840079e2c8d239 100644
 --- a/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
 +++ b/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
-@@ -315,10 +315,30 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+@@ -328,10 +328,30 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
      }
  
      public void send(Packet<?> packet) {
@@ -138,10 +138,10 @@ index d2e8adccf33c6b842fac615006b782b09cfa7a1a..434be9d08d8e816e2dea1e9d23fa26d2
          if (packet == null || this.processedDisconnect) { // Spigot
              return;
 diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
-index 37ba75bd50f785da11a0127fb40d86ee8b988c17..a3fdc328399c5d4806c6f361ba83515cf2094336 100644
+index e9529dfb98bf025fbdd59bbd2c61ea8169907fb6..3bc0469173330b50b488fb8eaf5f0c1b98e33fc4 100644
 --- a/net/minecraft/server/players/PlayerList.java
 +++ b/net/minecraft/server/players/PlayerList.java
-@@ -1386,7 +1386,7 @@ public abstract class PlayerList {
+@@ -1537,7 +1537,7 @@ public abstract class PlayerList {
      public void broadcastChatMessage(PlayerChatMessage message, Predicate<ServerPlayer> shouldFilterMessageTo, @Nullable ServerPlayer sender, ChatType.Bound boundChatType, @Nullable Function<net.kyori.adventure.audience.Audience, Component> unsignedFunction) {
          // Paper end
          boolean flag = this.verifyChatTrusted(message);
@@ -150,7 +150,7 @@ index 37ba75bd50f785da11a0127fb40d86ee8b988c17..a3fdc328399c5d4806c6f361ba83515c
          OutgoingChatMessage outgoingChatMessage = OutgoingChatMessage.create(message);
          boolean flag1 = false;
  
-@@ -1411,6 +1411,7 @@ public abstract class PlayerList {
+@@ -1562,6 +1562,7 @@ public abstract class PlayerList {
      }
  
      public boolean verifyChatTrusted(PlayerChatMessage message) {

leaf-server/minecraft-patches/features/0140-Matter-Secure-Seed.patch

@@ -48,10 +48,10 @@ index 229e115447b06db3e3b440ee8ea0505979656846..a9acfc3ba6c3447b4632d32fe24e9a09
      }
  
 diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
-index 0f09a2b0cbc17f1d64638f677f2518617f906576..7d8efad091cbf9f1177e7c0751c8e534bd665e0a 100644
+index 9b193bf81cf7f9f45dfa207a826043e083c2f8ba..11e8738b7cf388e0742bfe5e6136365f6ac066f9 100644
 --- a/net/minecraft/server/level/ServerLevel.java
 +++ b/net/minecraft/server/level/ServerLevel.java
-@@ -624,6 +624,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -625,6 +625,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
              chunkGenerator = new org.bukkit.craftbukkit.generator.CustomChunkGenerator(this, chunkGenerator, gen);
          }
          // CraftBukkit end
@@ -60,7 +60,7 @@ index 0f09a2b0cbc17f1d64638f677f2518617f906576..7d8efad091cbf9f1177e7c0751c8e534
          DataFixer fixerUpper = server.getFixerUpper();
          // Paper - rewrite chunk system
 diff --git a/net/minecraft/world/entity/monster/Slime.java b/net/minecraft/world/entity/monster/Slime.java
-index 7b6db084a483b4a9c2f292c5ed6e4c7550344c50..471d61cfd26ab1724432afc99dfe335a09a5ba48 100644
+index 9a157a2bdbbeab89dbfcd23be8bdc62c8de4548c..c257a19ff6b15ee6a83e9c946e2b20309ada9b51 100644
 --- a/net/minecraft/world/entity/monster/Slime.java
 +++ b/net/minecraft/world/entity/monster/Slime.java
 @@ -412,7 +412,11 @@ public class Slime extends Mob implements Enemy {

leaf-server/minecraft-patches/features/0142-Faster-random-generator.patch

@@ -27,10 +27,10 @@ index a9acfc3ba6c3447b4632d32fe24e9a09d55ba1e2..0f9d18dd29e210ad656da211a3cb1cb2
          final ServerLevel world = this.level;
          final int randomTickSpeed = world.getGameRules().getInt(GameRules.RULE_RANDOMTICKING);
 diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
-index 7d8efad091cbf9f1177e7c0751c8e534bd665e0a..d23ed8dbda5132337c8c96c67cf924e438ea9f4b 100644
+index 11e8738b7cf388e0742bfe5e6136365f6ac066f9..16cafa0acb7b2972ce08ab56921e73eb44eff6fa 100644
 --- a/net/minecraft/server/level/ServerLevel.java
 +++ b/net/minecraft/server/level/ServerLevel.java
-@@ -889,7 +889,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -891,7 +891,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
      private void optimiseRandomTick(final LevelChunk chunk, final int tickSpeed) {
          final LevelChunkSection[] sections = chunk.getSections();
          final int minSection = ca.spottedleaf.moonrise.common.util.WorldUtil.getMinSection((ServerLevel)(Object)this);
@@ -39,7 +39,7 @@ index 7d8efad091cbf9f1177e7c0751c8e534bd665e0a..d23ed8dbda5132337c8c96c67cf924e4
          final boolean doubleTickFluids = !ca.spottedleaf.moonrise.common.PlatformHooks.get().configFixMC224294();
  
          final ChunkPos cpos = chunk.getPos();
-@@ -938,7 +938,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -940,7 +940,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
      private int currentIceAndSnowTick = 0; protected void resetIceAndSnowTick() { this.currentIceAndSnowTick = this.simpleRandom.nextInt(16); } // Gale - Airplane - optimize random calls in chunk ticking
  
      public void tickChunk(LevelChunk chunk, int randomTickSpeed) {
@@ -97,7 +97,7 @@ index 8516d47b0ba79d91638837199e7ae0fb6cb44a79..4f4b55dd099dd2c2fea118b18b535881
      RandomSource fork();
  
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index 109ec179bd7e960cb09a98e1ec6179a60b2cba57..1f439c158f58fac08d17a262c01a1202ff3eb8e0 100644
+index 4e3b73bee5dae2b5921db86cc53b4cd9ebbd06f8..fa44ddaeac193a686211a9ede5993674626b8e25 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
 @@ -149,7 +149,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
@@ -110,7 +110,7 @@ index 109ec179bd7e960cb09a98e1ec6179a60b2cba57..1f439c158f58fac08d17a262c01a1202
      private static final class RandomRandomSource extends ca.spottedleaf.moonrise.common.util.ThreadUnsafeRandom {
          public RandomRandomSource() {
 diff --git a/net/minecraft/world/level/Level.java b/net/minecraft/world/level/Level.java
-index 453d4babc78f5676cb9534a5d80967a6f8c5a263..5fe79a471b5a5f1474a1fcb305b323d2e3a0de87 100644
+index 9ac2ecb78f6214616376b0e3badef21dc3f72114..f145453f70a219c1be33b241309ae2ab22a8004b 100644
 --- a/net/minecraft/world/level/Level.java
 +++ b/net/minecraft/world/level/Level.java
 @@ -117,7 +117,7 @@ public abstract class Level implements LevelAccessor, UUIDLookup<Entity>, AutoCl
@@ -189,7 +189,7 @@ index 426692d9627f46d708f551bd22ce3c52b2a23b37..8a19fd2b816b07a7374cb9dc96896a12
              if (!org.dreeam.leaf.config.modules.misc.SecureSeed.enabled) {
              // Paper start - Add missing structure set seed configs
 diff --git a/net/minecraft/world/level/levelgen/DensityFunctions.java b/net/minecraft/world/level/levelgen/DensityFunctions.java
-index 04527a5c65ad630f794fed9071d485aedd02257a..15fc39f9c77fdd03a0ca4a39d173c851b9454f08 100644
+index 77731406cb3dc417aa2fe1cb4352f3d2d7d498aa..1420dac658c4b27d25882a6d7dd3efb2c5b7e720 100644
 --- a/net/minecraft/world/level/levelgen/DensityFunctions.java
 +++ b/net/minecraft/world/level/levelgen/DensityFunctions.java
 @@ -518,7 +518,7 @@ public final class DensityFunctions {

leaf-server/minecraft-patches/features/0145-Configurable-connection-message.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Configurable connection message
 
 
 diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
-index a3fdc328399c5d4806c6f361ba83515cf2094336..9f2dcbbd82c5f077f058b64a61cc31d76b34b471 100644
+index 3bc0469173330b50b488fb8eaf5f0c1b98e33fc4..fae3c65d7411cd2c279dde27f8b8eafd45b657cf 100644
 --- a/net/minecraft/server/players/PlayerList.java
 +++ b/net/minecraft/server/players/PlayerList.java
-@@ -336,7 +336,7 @@ public abstract class PlayerList {
+@@ -438,7 +438,7 @@ public abstract class PlayerList {
          // Ensure that player inventory is populated with its viewer
          player.containerMenu.transferTo(player.containerMenu, bukkitPlayer);
  
@@ -17,7 +17,7 @@ index a3fdc328399c5d4806c6f361ba83515cf2094336..9f2dcbbd82c5f077f058b64a61cc31d7
          this.cserver.getPluginManager().callEvent(playerJoinEvent);
  
          if (!player.connection.isAcceptingMessages()) {
-@@ -347,7 +347,7 @@ public abstract class PlayerList {
+@@ -451,7 +451,7 @@ public abstract class PlayerList {
  
          final net.kyori.adventure.text.Component jm = playerJoinEvent.joinMessage();
  
@@ -26,7 +26,7 @@ index a3fdc328399c5d4806c6f361ba83515cf2094336..9f2dcbbd82c5f077f058b64a61cc31d7
              joinMessage = io.papermc.paper.adventure.PaperAdventure.asVanilla(jm); // Paper - Adventure
              this.server.getPlayerList().broadcastSystemMessage(joinMessage, false); // Paper - Adventure
          }
-@@ -533,7 +533,7 @@ public abstract class PlayerList {
+@@ -681,7 +681,7 @@ public abstract class PlayerList {
              player.closeContainer(org.bukkit.event.inventory.InventoryCloseEvent.Reason.DISCONNECT); // Paper - Inventory close reason
          }
  
@@ -35,7 +35,7 @@ index a3fdc328399c5d4806c6f361ba83515cf2094336..9f2dcbbd82c5f077f058b64a61cc31d7
          this.cserver.getPluginManager().callEvent(playerQuitEvent);
          player.getBukkitEntity().disconnect(playerQuitEvent.getQuitMessage());
  
-@@ -1538,4 +1538,40 @@ public abstract class PlayerList {
+@@ -1690,4 +1690,40 @@ public abstract class PlayerList {
      public boolean isAllowCommandsForAllPlayers() {
          return this.allowCommandsForAllPlayers;
      }

leaf-server/minecraft-patches/features/0148-Remove-stream-in-entity-visible-effects-filter.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Remove stream in entity visible effects filter
 
 
 diff --git a/net/minecraft/world/entity/LivingEntity.java b/net/minecraft/world/entity/LivingEntity.java
-index ab7bdbce80046df43e4889c20c4d3d9fb1d2e2c4..916a964263a9b71d20007c29302341dd50c94b85 100644
+index 09aa0b344aff0c48eec9a296d47c0704bd0fdc5c..fdbe3d4d71ba30c8330760555e97ff436643a7a9 100644
 --- a/net/minecraft/world/entity/LivingEntity.java
 +++ b/net/minecraft/world/entity/LivingEntity.java
 @@ -988,12 +988,15 @@ public abstract class LivingEntity extends Entity implements Attackable {

leaf-server/minecraft-patches/features/0157-Remove-stream-in-updateFluidOnEyes.patch

@@ -46,7 +46,7 @@ index 6c7edbbf3935c40ccb78bee680ea75431718b9bd..a1b4dc70d555cce5e06c0298736d8b89
          public String toString() {
              return "Reference{" + this.key + "=" + this.value + "}";
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index 1f439c158f58fac08d17a262c01a1202ff3eb8e0..753515c65a2b49db15ef6616cc7caf276fdbbeb1 100644
+index fa44ddaeac193a686211a9ede5993674626b8e25..c3d4cdfece32a05acd03b892cd5b343f0d230e64 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
 @@ -1976,7 +1976,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess

leaf-server/minecraft-patches/features/0159-Remove-stream-in-entity-mountedOrDismounted-changes-.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Remove stream in entity mountedOrDismounted changes update
 
 
 diff --git a/net/minecraft/server/level/ServerEntity.java b/net/minecraft/server/level/ServerEntity.java
-index 27e8c6a61cfa30b4e5bcc8ac30b0023940d9f310..dca939778d637ee293dc14f55edde7b1a97a2617 100644
+index b3fe9ea70148cdbefbdb617abaf81fe48ee26685..d6b261f8d3fbeee771208528b3e0bd5fcd94878b 100644
 --- a/net/minecraft/server/level/ServerEntity.java
 +++ b/net/minecraft/server/level/ServerEntity.java
 @@ -118,7 +118,19 @@ public class ServerEntity {

leaf-server/minecraft-patches/features/0160-Replace-Entity-active-effects-map-with-optimized-col.patch

@@ -6,7 +6,7 @@ Subject: [PATCH] Replace Entity active effects map with optimized collection
 Dreeam TODO: check this
 
 diff --git a/net/minecraft/world/entity/LivingEntity.java b/net/minecraft/world/entity/LivingEntity.java
-index 916a964263a9b71d20007c29302341dd50c94b85..fe201ffb28df1171bc22f7ed40cd729b9f3f1017 100644
+index fdbe3d4d71ba30c8330760555e97ff436643a7a9..ba6d9a5df71e9aae9defedf5bbe12f49599123cb 100644
 --- a/net/minecraft/world/entity/LivingEntity.java
 +++ b/net/minecraft/world/entity/LivingEntity.java
 @@ -196,6 +196,10 @@ public abstract class LivingEntity extends Entity implements Attackable {

leaf-server/minecraft-patches/features/0161-Replace-criterion-map-with-optimized-collection.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Replace criterion map with optimized collection
 
 
 diff --git a/net/minecraft/server/PlayerAdvancements.java b/net/minecraft/server/PlayerAdvancements.java
-index edf115439c630a4471460db02109bbce7868de81..6dc728625de0f323322c34104e1c55b17aa0b712 100644
+index c7e92f0122823d9e1aa471c5c0e995d1e1d90184..10ac7393d20a0857be2bfdd856dda448699b3eff 100644
 --- a/net/minecraft/server/PlayerAdvancements.java
 +++ b/net/minecraft/server/PlayerAdvancements.java
 @@ -60,7 +60,7 @@ public class PlayerAdvancements {

leaf-server/minecraft-patches/features/0164-Use-caffeine-cache-for-kickPermission-instead-of-usi.patch

@@ -6,11 +6,11 @@ Subject: [PATCH] Use caffeine cache for kickPermission instead of using
 
 
 diff --git a/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index 4287bb927a25206016298be2cc659d5920b3c414..5e693808b54efd77a40ccf0bafdf5a2aa7245da3 100644
+index 3c14d32ec9caf3dba9d99afe86a3ca053de70958..155e2047659111f68e27d3517e5178afa233dfe4 100644
 --- a/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 +++ b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -322,17 +322,12 @@ public class ServerGamePacketListenerImpl
-     }
+@@ -325,17 +325,12 @@ public class ServerGamePacketListenerImpl
+     public final org.leavesmc.leaves.protocol.syncmatica.exchange.ExchangeTarget exchangeTarget; // Leaves - Syncmatica Protocol
  
      // Purpur start - AFK API
 -    private final com.google.common.cache.LoadingCache<org.bukkit.craftbukkit.entity.CraftPlayer, Boolean> kickPermissionCache = com.google.common.cache.CacheBuilder.newBuilder()
@@ -31,7 +31,7 @@ index 4287bb927a25206016298be2cc659d5920b3c414..5e693808b54efd77a40ccf0bafdf5a2a
      // Purpur end - AFK API
  
      @Override
-@@ -395,7 +390,7 @@ public class ServerGamePacketListenerImpl
+@@ -398,7 +393,7 @@ public class ServerGamePacketListenerImpl
              && Util.getMillis() - this.player.getLastActionTime() > this.server.getPlayerIdleTimeout() * 1000L * 60L && !this.player.wonGame) { // Paper - Prevent AFK kick while watching end credits
              // Purpur start - AFK API
              this.player.setAfk(true);

leaf-server/minecraft-patches/features/0165-Do-not-place-player-if-the-server-is-full.patch

@@ -6,15 +6,15 @@ Subject: [PATCH] Do not place player if the server is full
 Fix https://github.com/PaperMC/Paper/issues/10668
 
 diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
-index a289c3247ef6e1b7ae76fdc86c286e7b426731b4..7f12288fc361f780171026beb52c07b20ae17324 100644
+index fae3c65d7411cd2c279dde27f8b8eafd45b657cf..34c5c2e3d6b0706cb91ec0171969cf81e94741a4 100644
 --- a/net/minecraft/server/players/PlayerList.java
 +++ b/net/minecraft/server/players/PlayerList.java
-@@ -241,6 +241,13 @@ public abstract class PlayerList {
+@@ -342,6 +342,13 @@ public abstract class PlayerList {
              return;
          }
          // Gale end - MultiPaper - do not place player in world if kicked before being spawned in
 +        // Leaf start - Do not place player if the server is full - copied from canPlayerLogin
-+        if (org.dreeam.leaf.config.modules.fixes.DontPlacePlayerIfFull.enabled && this.players.size() >= this.maxPlayers && !(player.getBukkitEntity().hasPermission("purpur.joinfullserver") || this.canBypassPlayerLimit(gameProfile))) { // Purpur - Allow player join full server by permission
++        if (org.dreeam.leaf.config.modules.fixes.DontPlacePlayerIfFull.enabled && this.realPlayers.size() >= this.maxPlayers && !(player.getBukkitEntity().hasPermission("purpur.joinfullserver") || this.canBypassPlayerLimit(gameProfile))) { // Purpur - Allow player join full server by permission
 +            connection.disconnect(io.papermc.paper.adventure.PaperAdventure.asVanilla(net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(org.spigotmc.SpigotConfig.serverFullMessage)));
 +            //playerconnection.disconnect(io.papermc.paper.adventure.PaperAdventure.asVanilla(net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(org.spigotmc.SpigotConfig.serverFullMessage)), org.bukkit.event.player.PlayerKickEvent.Cause.TIMEOUT);
 +            return;
@@ -23,12 +23,12 @@ index a289c3247ef6e1b7ae76fdc86c286e7b426731b4..7f12288fc361f780171026beb52c07b2
  
          org.bukkit.Location loc = ev.getSpawnLocation();
          serverLevel = ((org.bukkit.craftbukkit.CraftWorld) loc.getWorld()).getHandle();
-@@ -684,7 +691,7 @@ public abstract class PlayerList {
+@@ -834,7 +841,7 @@ public abstract class PlayerList {
              // return this.players.size() >= this.maxPlayers && !this.canBypassPlayerLimit(gameProfile)
              //     ? Component.translatable("multiplayer.disconnect.server_full")
              //     : null;
--            if (this.players.size() >= this.maxPlayers && !(player.hasPermission("purpur.joinfullserver") || this.canBypassPlayerLimit(gameProfile))) { // Purpur - Allow player join full server by permission
-+            if (this.players.size() >= this.maxPlayers && !(player.hasPermission("purpur.joinfullserver") || this.canBypassPlayerLimit(gameProfile))) { // Purpur - Allow player join full server by permission // Leaf - Do not place player if the server is full - diff on change
+-            if (this.realPlayers.size() >= this.maxPlayers && !(player.hasPermission("purpur.joinfullserver") || this.canBypassPlayerLimit(gameProfile))) { // Purpur - Allow player join full server by permission // Leaves - only real player
++            if (this.realPlayers.size() >= this.maxPlayers && !(player.hasPermission("purpur.joinfullserver") || this.canBypassPlayerLimit(gameProfile))) { // Purpur - Allow player join full server by permission // Leaves - only real player // Leaf - Do not place player if the server is full - diff on change
                  event.disallow(org.bukkit.event.player.PlayerLoginEvent.Result.KICK_FULL, net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(org.spigotmc.SpigotConfig.serverFullMessage)); // Spigot // Paper - Adventure
              }
          }

leaf-server/minecraft-patches/features/0168-Fix-MC-119417.patch

@@ -6,10 +6,10 @@ Subject: [PATCH] Fix MC-119417
 Related MC issue: https://bugs.mojang.com/browse/MC/issues/MC-119417
 
 diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
-index 602a087122a6baa3cb33e1bf5e6c4d98e500fa05..f898961de04ad0b224d0405e2cd43d61665cc1b1 100644
+index 034a946cd545d775188a4375a87c90d253ebdb08..18125ed336c3425f123232b405a8af9ee3a2ba7d 100644
 --- a/net/minecraft/server/level/ServerPlayer.java
 +++ b/net/minecraft/server/level/ServerPlayer.java
-@@ -2189,6 +2189,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+@@ -2191,6 +2191,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
              this.connection.send(new ClientboundGameEventPacket(ClientboundGameEventPacket.CHANGE_GAME_MODE, gameMode.getId()));
              if (gameMode == GameType.SPECTATOR) {
                  this.removeEntitiesOnShoulder();

leaf-server/minecraft-patches/features/0170-Configurable-player-knockback-zombie.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Configurable player knockback zombie
 
 
 diff --git a/net/minecraft/world/entity/LivingEntity.java b/net/minecraft/world/entity/LivingEntity.java
-index fe201ffb28df1171bc22f7ed40cd729b9f3f1017..f36af61d7620f57f396d879d669161b8b1a30875 100644
+index ba6d9a5df71e9aae9defedf5bbe12f49599123cb..4c3eadc2d8480b2a2c2c08e58620544d403d3adc 100644
 --- a/net/minecraft/world/entity/LivingEntity.java
 +++ b/net/minecraft/world/entity/LivingEntity.java
 @@ -2079,6 +2079,8 @@ public abstract class LivingEntity extends Entity implements Attackable {

leaf-server/minecraft-patches/features/0171-Paper-PR-Skip-AI-during-inactive-ticks-for-non-aware.patch

@@ -8,7 +8,7 @@ Original project: https://github.com/PaperMC/Paper
 Paper pull request: https://github.com/PaperMC/Paper/pull/10990
 
 diff --git a/net/minecraft/world/entity/Mob.java b/net/minecraft/world/entity/Mob.java
-index e9ebf23b0b1af85e3738a70acc0eaa3e8980261f..d473c09e98eb5d3ef7b3e096197c7bf9a6219c56 100644
+index cf136bc3d0d285ebde23c6e31c002933564fdcb2..c15b6e32bd00650366dc4ecba2abeb6bfb98d638 100644
 --- a/net/minecraft/world/entity/Mob.java
 +++ b/net/minecraft/world/entity/Mob.java
 @@ -207,6 +207,11 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab

leaf-server/minecraft-patches/features/0174-Dont-send-useless-entity-packets.patch

@@ -9,7 +9,7 @@ Original license: MIT
 Original project: https://github.com/PurpurMC/Purpur
 
 diff --git a/net/minecraft/server/level/ServerEntity.java b/net/minecraft/server/level/ServerEntity.java
-index dca939778d637ee293dc14f55edde7b1a97a2617..44d87997e1ce9b846ebed541634a4478334c920c 100644
+index d6b261f8d3fbeee771208528b3e0bd5fcd94878b..1a9601aee097b6c10cf2ae1c52fddf45da85f60f 100644
 --- a/net/minecraft/server/level/ServerEntity.java
 +++ b/net/minecraft/server/level/ServerEntity.java
 @@ -221,6 +221,8 @@ public class ServerEntity {

leaf-server/minecraft-patches/features/0175-Multithreaded-Tracker.patch

@@ -353,10 +353,10 @@ index 1a9601aee097b6c10cf2ae1c52fddf45da85f60f..16b2ca8c96e9561aa57e0903d1e98e64
      }
  
 diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
-index 42f56bd6a9f449df23f7e7f00b3efa114a003449..0471b04833fbca5dfc0cc6575692cdefb83edbed 100644
+index 16cafa0acb7b2972ce08ab56921e73eb44eff6fa..bbccf0c8aef3792bb7b7cb0070e48bca4c274a2c 100644
 --- a/net/minecraft/server/level/ServerLevel.java
 +++ b/net/minecraft/server/level/ServerLevel.java
-@@ -2503,7 +2503,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -2505,7 +2505,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
  
      @Override
      public LevelEntityGetter<Entity> getEntities() {
@@ -365,7 +365,7 @@ index 42f56bd6a9f449df23f7e7f00b3efa114a003449..0471b04833fbca5dfc0cc6575692cdef
          return this.moonrise$getEntityLookup(); // Paper - rewrite chunk system
      }
  
-@@ -2739,7 +2739,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -2746,7 +2746,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
                          }
  
                          map.carriedByPlayers.remove(player);
@@ -375,10 +375,10 @@ index 42f56bd6a9f449df23f7e7f00b3efa114a003449..0471b04833fbca5dfc0cc6575692cdef
                          }
                      }
 diff --git a/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index be803fd0a79850254bd4a7f64534142cd5b4ec98..6992a53abdcff6299bedf33ba0b1bc6386a1ea74 100644
+index 155e2047659111f68e27d3517e5178afa233dfe4..c91348eea1350728d8f6de7b8c3613cb44b5cdec 100644
 --- a/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 +++ b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-@@ -1878,7 +1878,7 @@ public class ServerGamePacketListenerImpl
+@@ -1881,7 +1881,7 @@ public class ServerGamePacketListenerImpl
      }
  
      public void internalTeleport(PositionMoveRotation posMoveRotation, Set<Relative> relatives) {

leaf-server/minecraft-patches/features/0176-Nitori-Async-playerdata-saving.patch

@@ -7,7 +7,7 @@ Original license: GPL v3
 Original project: https://github.com/Gensokyo-Reimagined/Nitori
 
 diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index 17d3a8a2cc3c86ed6aae9c20ed9f281dc9715cf5..354823def23167feb1e7b35cd9db5ef1584e7e8c 100644
+index 3ca7405318a4076000250203be4b91dbde95191b..2aed6f594c73bea5e8919e65cf04bc7eb6775c3e 100644
 --- a/net/minecraft/server/MinecraftServer.java
 +++ b/net/minecraft/server/MinecraftServer.java
 @@ -1067,6 +1067,12 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa

leaf-server/minecraft-patches/features/0185-TT20-Lag-compensation.patch

@@ -7,7 +7,7 @@ Original license: AGPL-3.0
 Original project: https://github.com/snackbag/TT20
 
 diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index d2e7ca050c236b17206738e5e5f8d4936afedd45..508f3c7c1e806576f1faea7975ac9bbe73b1024b 100644
+index 2aed6f594c73bea5e8919e65cf04bc7eb6775c3e..bbd2b327c658b56a1fcf30c8b77cab987d688fcc 100644
 --- a/net/minecraft/server/MinecraftServer.java
 +++ b/net/minecraft/server/MinecraftServer.java
 @@ -1544,6 +1544,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa

leaf-server/minecraft-patches/features/0187-Lithium-Skip-unnecessary-calculations-if-player-is-n.patch

@@ -12,7 +12,7 @@ As part of: Lithium (https://github.com/CaffeineMC/lithium-fabric)
 Licensed under: LGPL-3.0 (https://www.gnu.org/licenses/lgpl-3.0.html)
 
 diff --git a/net/minecraft/world/entity/LivingEntity.java b/net/minecraft/world/entity/LivingEntity.java
-index f36af61d7620f57f396d879d669161b8b1a30875..eb40f810d4eb8d6a8cc130719b637a473f19cc82 100644
+index 68241d1d488bc2848e3c0d167270c1788e573c37..b3e9ad0669bb4b91d5d991f106b225e914a4e68f 100644
 --- a/net/minecraft/world/entity/LivingEntity.java
 +++ b/net/minecraft/world/entity/LivingEntity.java
 @@ -2796,6 +2796,7 @@ public abstract class LivingEntity extends Entity implements Attackable {

leaf-server/minecraft-patches/features/0190-Smooth-teleport-config.patch

@@ -9,10 +9,10 @@ happen but the visual "refresh" of a world change is hidden. Depending on the de
 this can act as a "smooth teleport" to a world if the new world is very similar looking to the old one.
 
 diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
-index f898961de04ad0b224d0405e2cd43d61665cc1b1..afbac4f2da3aa58da82b9a06d656851f12756f32 100644
+index 18125ed336c3425f123232b405a8af9ee3a2ba7d..e97a93c97e1822f969dce2d30dd915db5d3d14cf 100644
 --- a/net/minecraft/server/level/ServerPlayer.java
 +++ b/net/minecraft/server/level/ServerPlayer.java
-@@ -1417,6 +1417,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+@@ -1419,6 +1419,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
                  LevelData worlddata = level.getLevelData();
  
                  this.connection.send(new ClientboundRespawnPacket(this.createCommonSpawnInfo(level), (byte) 3));
@@ -20,7 +20,7 @@ index f898961de04ad0b224d0405e2cd43d61665cc1b1..afbac4f2da3aa58da82b9a06d656851f
                  this.connection.send(new ClientboundChangeDifficultyPacket(worlddata.getDifficulty(), worlddata.isDifficultyLocked()));
                  PlayerList playerList = this.server.getPlayerList();
  
-@@ -1426,7 +1427,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+@@ -1428,7 +1429,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
                  // CraftBukkit end
                  this.portalPos = org.bukkit.craftbukkit.util.CraftLocation.toBlockPosition(exit); // Purpur - Fix stuck in portals
                  this.setServerLevel(level);
@@ -30,10 +30,10 @@ index f898961de04ad0b224d0405e2cd43d61665cc1b1..afbac4f2da3aa58da82b9a06d656851f
                  level.addDuringTeleport(this);
                  this.triggerDimensionChangeTriggers(serverLevel);
 diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
-index 8e2161a2ff45b8f29fa4744b0cdd429d0f9a6c41..07dafa0e12fd51e4b9e968e22b20f000d04f6dbc 100644
+index 34c5c2e3d6b0706cb91ec0171969cf81e94741a4..8b1652805a2ac9ebae9c99dd77e81c7a484a7abb 100644
 --- a/net/minecraft/server/players/PlayerList.java
 +++ b/net/minecraft/server/players/PlayerList.java
-@@ -806,11 +806,11 @@ public abstract class PlayerList {
+@@ -956,11 +956,11 @@ public abstract class PlayerList {
          byte b = (byte)(keepInventory ? 1 : 0);
          ServerLevel serverLevel = serverPlayer.serverLevel();
          LevelData levelData = serverLevel.getLevelData();

leaf-server/minecraft-patches/features/0193-Lithium-equipment-tracking.patch

@@ -241,7 +241,7 @@ index 90814ad07a2686c5a274860395f5aca29cc3bf13..369f0176a636def905fb2a2df1a0e2ca
 +    }
  }
 diff --git a/net/minecraft/world/entity/LivingEntity.java b/net/minecraft/world/entity/LivingEntity.java
-index 7e9ace691bb2662afd2c0fc504007a6d22a8aec0..dabd49c7b9e689be4b476c16b28cbb8edcd3306b 100644
+index b3e9ad0669bb4b91d5d991f106b225e914a4e68f..a927e8a7d9149f5b7abaae50ba8d4fdc6ec87b55 100644
 --- a/net/minecraft/world/entity/LivingEntity.java
 +++ b/net/minecraft/world/entity/LivingEntity.java
 @@ -417,7 +417,7 @@ public abstract class LivingEntity extends Entity implements Attackable {

leaf-server/minecraft-patches/features/0195-Cache-chunk-key.patch

@@ -97,10 +97,10 @@ index fd3d0f6cb53bc8b6186f0d86575f21007b2c20ed..cddeeab73e7b981701a42c5aad6b4777
          // Paper end - rewrite chunk system
      }
 diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
-index 0471b04833fbca5dfc0cc6575692cdefb83edbed..1f3020f5a051d5f4e5c8fa088f844962c3105573 100644
+index bbccf0c8aef3792bb7b7cb0070e48bca4c274a2c..ccd6f16e244745ee0702504dbea710485037a3e3 100644
 --- a/net/minecraft/server/level/ServerLevel.java
 +++ b/net/minecraft/server/level/ServerLevel.java
-@@ -503,7 +503,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -504,7 +504,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
      @Override
      public final void moonrise$markChunkForPlayerTicking(final LevelChunk chunk) {
          final ChunkPos pos = chunk.getPos();
@@ -109,7 +109,7 @@ index 0471b04833fbca5dfc0cc6575692cdefb83edbed..1f3020f5a051d5f4e5c8fa088f844962
              return;
          }
  
-@@ -2569,7 +2569,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -2571,7 +2571,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
  
      public boolean areEntitiesActuallyLoadedAndTicking(ChunkPos chunkPos) {
          // Paper start - rewrite chunk system
@@ -118,7 +118,7 @@ index 0471b04833fbca5dfc0cc6575692cdefb83edbed..1f3020f5a051d5f4e5c8fa088f844962
          return chunkHolder != null && chunkHolder.isEntityTickingReady();
          // Paper end - rewrite chunk system
      }
-@@ -2584,7 +2584,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -2586,7 +2586,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
  
      public boolean canSpawnEntitiesInChunk(ChunkPos chunkPos) {
          // Paper start - rewrite chunk system

leaf-server/minecraft-patches/features/0199-PaperPR-Fix-MC-117075-Block-Entities-Unload-Lag-Spik.patch

@@ -12,7 +12,7 @@ We replaced the `blockEntityTickers` list with a custom list based on fastutil's
 This is WAY FASTER than using `removeAll` with a list of entries to be removed, because we don't need to calculate the identity of each block entity to be removed, and we can jump directly to where the search should begin, giving a performance boost for small removals (because we don't need to loop thru the entire list to find what element should be removed) and a performance boost for big removals (no need to calculate the identity of each block entity).
 
 diff --git a/net/minecraft/world/level/Level.java b/net/minecraft/world/level/Level.java
-index 5fe79a471b5a5f1474a1fcb305b323d2e3a0de87..817cc2e4f311a626681d94b748a01ae2e3048445 100644
+index f145453f70a219c1be33b241309ae2ab22a8004b..22da84734462d09a55bc599db4374e1e4f4d6bd2 100644
 --- a/net/minecraft/world/level/Level.java
 +++ b/net/minecraft/world/level/Level.java
 @@ -104,7 +104,7 @@ public abstract class Level implements LevelAccessor, UUIDLookup<Entity>, AutoCl

leaf-server/minecraft-patches/features/0202-SparklyPaper-Reset-dirty-flag-when-loading-maps-from.patch

@@ -9,7 +9,7 @@ By default, the server will start rewriting all map datas to the disk after load
 This also slows down world saving a lot if you have a lot of maps
 
 diff --git a/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java b/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java
-index df471cd42f4084facb895b229c261b685054c3ae..3e84cb0fe6efa95ccede9ead29cafbf1afb717d9 100644
+index d62ff9ebd4b55e1a9a0b51e84be868d844e5a954..8abf2160ae5df851e218f78ce1bfb8350df2bc28 100644
 --- a/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java
 +++ b/net/minecraft/world/level/saveddata/maps/MapItemSavedData.java
 @@ -160,6 +160,7 @@ public class MapItemSavedData extends SavedData {

leaf-server/minecraft-patches/features/0203-Optimize-checking-nearby-players-for-spawning.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Optimize checking nearby players for spawning
 
 
 diff --git a/net/minecraft/server/level/ChunkMap.java b/net/minecraft/server/level/ChunkMap.java
-index 560a857f3b61679bbf2ee93ac6da393052a1f320..a50fb16dc2e6230d346eea8ee76820ec56906446 100644
+index ae0a7c9b95f4f2561769e0d661fadbe29a2d6f8b..14b2abc51fa5d2caa56adfaf50784296c5668ae6 100644
 --- a/net/minecraft/server/level/ChunkMap.java
 +++ b/net/minecraft/server/level/ChunkMap.java
 @@ -773,7 +773,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider

leaf-server/minecraft-patches/features/0204-Cache-supporting-block-check.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Cache supporting block check
 
 
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index a2e9306d9a5eef738f8225e98fb1cc1f4bbca504..cb17aaad72940ac94317a50cbe85b22c00e02a10 100644
+index 1cbc319a9b5ce3b15f79fcfec8cf9c46d0d3d1d0..309a31215cb63452215fd880590cffd569aee208 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
 @@ -1078,12 +1078,36 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess

leaf-server/minecraft-patches/features/0209-Only-player-pushable.patch

@@ -6,7 +6,7 @@ Subject: [PATCH] Only player pushable
 Useful for extreme cases like massive entities collide together in a small area
 
 diff --git a/net/minecraft/world/entity/LivingEntity.java b/net/minecraft/world/entity/LivingEntity.java
-index dabd49c7b9e689be4b476c16b28cbb8edcd3306b..8461be7c6723925d26f7f162564a18f4aa162089 100644
+index a927e8a7d9149f5b7abaae50ba8d4fdc6ec87b55..0f717ee9e977ece4f30e66d9d1caf6bb7beecda7 100644
 --- a/net/minecraft/world/entity/LivingEntity.java
 +++ b/net/minecraft/world/entity/LivingEntity.java
 @@ -3635,7 +3635,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
@@ -78,7 +78,7 @@ index dabd49c7b9e689be4b476c16b28cbb8edcd3306b..8461be7c6723925d26f7f162564a18f4
          AABB aabb = boundingBoxBeforeSpin.minmax(boundingBoxAfterSpin);
          List<Entity> entities = this.level().getEntities(this, aabb);
 diff --git a/net/minecraft/world/entity/decoration/ArmorStand.java b/net/minecraft/world/entity/decoration/ArmorStand.java
-index a5a6e4cd74a5444ce06828404036de1728a1a5ce..f6b1c17dbd9999a4d774cf3943c967db46c46f53 100644
+index cb2a8f9cff99a7a906bc7be09d301728742bc11e..f3ef1c11f1f5fe02c0b38f327b527221a5a45b0f 100644
 --- a/net/minecraft/world/entity/decoration/ArmorStand.java
 +++ b/net/minecraft/world/entity/decoration/ArmorStand.java
 @@ -247,7 +247,7 @@ public class ArmorStand extends LivingEntity {

leaf-server/minecraft-patches/features/0212-Cache-eligible-players-for-despawn-checks.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Cache eligible players for despawn checks
 
 
 diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
-index 1f3020f5a051d5f4e5c8fa088f844962c3105573..c6eb136e8db0aa232681ac9bd28c4b70fbbacb40 100644
+index ccd6f16e244745ee0702504dbea710485037a3e3..2ecb73fc7b6754ade93bf16b48c623e6b3a955a9 100644
 --- a/net/minecraft/server/level/ServerLevel.java
 +++ b/net/minecraft/server/level/ServerLevel.java
-@@ -723,6 +723,8 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -725,6 +725,8 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
          return this.structureManager;
      }
  
@@ -17,7 +17,7 @@ index 1f3020f5a051d5f4e5c8fa088f844962c3105573..c6eb136e8db0aa232681ac9bd28c4b70
      public void tick(BooleanSupplier hasTimeLeft) {
          this.handlingTick = true;
          TickRateManager tickRateManager = this.tickRateManager();
-@@ -790,6 +792,19 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -792,6 +794,19 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
              }
  
              io.papermc.paper.entity.activation.ActivationRange.activateEntities(this); // Paper - EAR
@@ -38,10 +38,10 @@ index 1f3020f5a051d5f4e5c8fa088f844962c3105573..c6eb136e8db0aa232681ac9bd28c4b70
                  .forEach(
                      entity -> {
 diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
-index afbac4f2da3aa58da82b9a06d656851f12756f32..f765cc0044282ad592a146773ab93f82fefcebc4 100644
+index e97a93c97e1822f969dce2d30dd915db5d3d14cf..ccd442b24693bc9269cc8ab3e44887d0ad3eadbd 100644
 --- a/net/minecraft/server/level/ServerPlayer.java
 +++ b/net/minecraft/server/level/ServerPlayer.java
-@@ -1517,6 +1517,13 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+@@ -1519,6 +1519,13 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
          this.containerMenu.broadcastChanges();
      }