Add Replay Api (#86)

* feat: base replay api support

* fix an async bug

.github/workflows/build.yml

@@ -10,13 +10,13 @@ on:
   workflow_dispatch:
     inputs:
       force-release:
-        description: "Force release if you enter 1, default release if not released else skip release"
+        description: "Force disable release if you enter 2, force release if you enter 1, default release if not released else skip release"
         required: false
-        default: "0"
+        default: ""
       force-push:
-        description: "Push to repo if you enter 1, default push if not released else skip push repo"
+        description: "Force disable push to repo if you enter 2, push to repo if you enter 1, default push if not released else skip push repo"
         required: false
-        default: "0"
+        default: ""
       comments:
         description: "Add comments to release"
         required: false
@@ -39,7 +39,7 @@ jobs:
           java-version: 21
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v4
+        uses: gradle/actions/setup-gradle@v5
 
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
@@ -50,16 +50,16 @@ jobs:
       - name: Apply All Patches
         run: ./gradlew --refresh-dependencies applyAllPatches
 
-      - name: CreateMojmapPaperclipJar
+      - name: Build Paperclip Jar
         run: ./gradlew --refresh-dependencies createMojmapPaperclipJar
 
       - name: Upload Artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v5
         with:
           name: ${{ env.project_id_b }} CI Artifacts
           path: lophine-server/build/libs/*-paperclip-*-mojmap.jar
 
-      - name: SetENV
+      - name: Set Environment
         if: github.event_name != 'pull_request'
         run: sh scripts/SetENV.sh
 
@@ -84,8 +84,8 @@ jobs:
           fi
           echo "release_exists=${release_exists}" >> $GITHUB_ENV
 
-      - name: Publish to repo
-        if: (( github.event_name != 'pull_request' && env.flag_release == 'true' && env.release_exists != 'true' ) || ( env.release_exists == 'true' && inputs.force-push == '1' )) && false # do not push to any repo
+      - name: Publish To Repo
+        if: (( github.event_name != 'pull_request' && env.flag_release == 'true' && env.release_exists != 'true' && !(inputs.force-push == '2')) || inputs.force-push == '1') && false # do not push to any repo
         continue-on-error: true
         run: ./gradlew --refresh-dependencies generateDevelopmentBundle publish -PpublishDevBundle=true
         env:
@@ -93,7 +93,7 @@ jobs:
           PRIVATE_MAVEN_REPO_USERNAME: ${{ secrets.PRIVATE_MAVEN_REPO_USERNAME }}
 
       - name: Create Release - Pre Process
-        if: ( github.event_name != 'pull_request' && env.flag_release == 'true' && env.release_exists != 'true' ) || ( env.release_exists == 'true' && inputs.force-release == '1' )
+        if: ( github.event_name != 'pull_request' && env.flag_release == 'true' && env.release_exists != 'true' && !(inputs.force-release == '2')) || inputs.force-release == '1'
         run: |
           if [ ${{ inputs.comments }} == "" ]; then
           echo "No comments provided"

gradle.properties

@@ -4,7 +4,7 @@ mcVersion=1.21.8
 release=2
 # 0 for skip release, 1 for pre-release, 2 for release
 
-luminolRef=e92a696b62d759bb96cb27f9553611a6621fb535
+luminolRef=fc15c32debe0d87631bf5ecf69de4cfeba119a6c
 
 org.gradle.configuration-cache=true
 org.gradle.caching=true

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.0.0-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.0-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

lophine-api/paper-patches/features/0002-Leaves-Add-fakeplayer-api.patch

@@ -1,8 +1,11 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Bacteriawa <A3167717663@hotmail.com>
 Date: Sat, 30 Aug 2025 16:51:26 +0800
-Subject: [PATCH] Add fakeplayer api
+Subject: [PATCH] Leaves: Add fakeplayer api
 
+Co-authored by: violetc <58360096+s-yh-china@users.noreply.github.com>
+As a part of : Leaves (https://github.com/LeavesMC/Leaves)
+Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
 
 diff --git a/src/main/java/org/bukkit/Bukkit.java b/src/main/java/org/bukkit/Bukkit.java
 index 85b778980e762835ac278528087e91b2e3effb43..89f00f4b6ff64305fa44ebb71f22a113c1296d26 100644

lophine-api/paper-patches/features/0003-Leaves-Replay-Mod-API.patch

@@ -0,0 +1,37 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Sun, 16 Nov 2025 15:50:28 +0800
+Subject: [PATCH] Leaves: Replay Mod API
+
+Co-authored by: violetc <58360096+s-yh-china@users.noreply.github.com>
+As a part of : Leaves (https://github.com/LeavesMC/Leaves)
+Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
+
+diff --git a/src/main/java/org/bukkit/Bukkit.java b/src/main/java/org/bukkit/Bukkit.java
+index 89f00f4b6ff64305fa44ebb71f22a113c1296d26..e9d20fe8b88aa63fb62effd430b5e22c8dbe1307 100644
+--- a/src/main/java/org/bukkit/Bukkit.java
++++ b/src/main/java/org/bukkit/Bukkit.java
+@@ -3063,4 +3063,10 @@ public final class Bukkit {
+         return server.getBotManager();
+     }
+     // Leaves end - Bot API
++
++    // Leaves start - Photographer API
++    public static @NotNull org.leavesmc.leaves.entity.photographer.PhotographerManager getPhotographerManager() {
++        return server.getPhotographerManager();
++    }
++    // Leaves end - Photographer API
+ }
+diff --git a/src/main/java/org/bukkit/Server.java b/src/main/java/org/bukkit/Server.java
+index c7ae463fb166750bbd0638a2ccf81753b293a381..4caadc8f9b328d978ece84c1480e32f24868531f 100644
+--- a/src/main/java/org/bukkit/Server.java
++++ b/src/main/java/org/bukkit/Server.java
+@@ -2762,4 +2762,8 @@ public interface Server extends PluginMessageRecipient, net.kyori.adventure.audi
+      */
+     @NotNull org.leavesmc.leaves.entity.bot.BotManager getBotManager();
+     // Leaves end - Bot API
++
++    // Leaves start - Photographer API
++    @NotNull org.leavesmc.leaves.entity.photographer.PhotographerManager getPhotographerManager();
++    // Leaves end - Photographer API
+ }

lophine-api/src/main/java/org/leavesmc/leaves/entity/photographer/Photographer.java

@@ -0,0 +1,43 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.entity.photographer;
+
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+
+public interface Photographer extends Player {
+
+    @NotNull String getId();
+
+    void setRecordFile(@NotNull File file);
+
+    void stopRecording();
+
+    void stopRecording(boolean async);
+
+    void stopRecording(boolean async, boolean save);
+
+    void pauseRecording();
+
+    void resumeRecording();
+
+    void setFollowPlayer(@Nullable Player player);
+}

lophine-api/src/main/java/org/leavesmc/leaves/entity/photographer/PhotographerManager.java

@@ -0,0 +1,44 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.entity.photographer;
+
+import org.bukkit.Location;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.leavesmc.leaves.replay.BukkitRecorderOption;
+
+import java.util.Collection;
+import java.util.UUID;
+
+public interface PhotographerManager {
+    @Nullable Photographer getPhotographer(@NotNull UUID uuid);
+
+    @Nullable Photographer getPhotographer(@NotNull String id);
+
+    @Nullable Photographer createPhotographer(@NotNull String id, @NotNull Location location);
+
+    @Nullable Photographer createPhotographer(@NotNull String id, @NotNull Location location, @NotNull BukkitRecorderOption recorderOption);
+
+    void removePhotographer(@NotNull String id);
+
+    void removePhotographer(@NotNull UUID uuid);
+
+    void removeAllPhotographers();
+
+    Collection<Photographer> getPhotographers();
+}

lophine-api/src/main/java/org/leavesmc/leaves/replay/BukkitRecorderOption.java

@@ -0,0 +1,35 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.replay;
+
+public class BukkitRecorderOption {
+
+    // public int recordDistance = -1;
+    public String serverName = "Lophine"; // Lophine - rebrand to Lophine to avoid confusion
+    public BukkitRecordWeather forceWeather = BukkitRecordWeather.NULL;
+    public int forceDayTime = -1;
+    public boolean ignoreChat = false;
+    // public boolean ignoreItem = false;
+
+    public enum BukkitRecordWeather {
+        CLEAR,
+        RAIN,
+        THUNDER,
+        NULL
+    }
+}

lophine-server/build.gradle.kts.patch

@@ -51,7 +51,7 @@
      // Luminol start - Dependenices insert
      implementation("com.electronwill.night-config:toml:3.8.2") // Night config
      implementation("com.github.luben:zstd-jni:1.5.4-1")
-@@ -276,14 +_,14 @@
+@@ -275,14 +_,14 @@
          val gitBranch = git.exec(providers, "rev-parse", "--abbrev-ref", "HEAD").get().trim()
          attributes(
              "Main-Class" to "org.bukkit.craftbukkit.Main",
@@ -70,7 +70,7 @@
              "Build-Number" to (build ?: ""),
              "Build-Time" to buildTime.toString(),
              "Git-Branch" to gitBranch,
-@@ -447,7 +_,7 @@
+@@ -446,7 +_,7 @@
  }
  
  fill {

lophine-server/luminol-patches/features/0001-Rebrand-to-Lophine.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Rebrand to Lophine
 
 
 diff --git a/src/main/java/me/earthme/luminol/config/ConfigManager.java b/src/main/java/me/earthme/luminol/config/ConfigManager.java
-index d8066afd5f3f2ea9a5dff87d853562e22268785c..f8b2364fa162a41304a99a4993354e33528ab801 100644
+index a5208f5426ea2e5d8f50c51fe17718ea1d63eef5..c80c578f1a3786bd7413c9a7af8ae125fe7975bb 100644
 --- a/src/main/java/me/earthme/luminol/config/ConfigManager.java
 +++ b/src/main/java/me/earthme/luminol/config/ConfigManager.java
 @@ -21,6 +21,7 @@ public class ConfigManager {

lophine-server/luminol-patches/features/0002-Transformed-Configs.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Transformed Configs
 
 
 diff --git a/src/main/java/me/earthme/luminol/config/modules/experiment/CommandConfig.java b/src/main/java/me/earthme/luminol/config/modules/experiment/CommandConfig.java
-index 66ae993896ba38a7fa5302d4ff88a52e4a0bb72c..c6d53d720437f43a713469049de3d90d1082cd2e 100644
+index 4051384e82dba0416838c3c9889a6e368367b601..a5535b479cdcca870d0c8be6ed6fbcb32f266ac2 100644
 --- a/src/main/java/me/earthme/luminol/config/modules/experiment/CommandConfig.java
 +++ b/src/main/java/me/earthme/luminol/config/modules/experiment/CommandConfig.java
 @@ -11,6 +11,7 @@ public class CommandConfig implements IConfigModule {
@@ -14,8 +14,8 @@ index 66ae993896ba38a7fa5302d4ff88a52e4a0bb72c..c6d53d720437f43a713469049de3d90d
      public static boolean data = false;
 +    @TransformedConfig(name = "command_block_enabled", directory = {"experiment", "command"}, originInstance = "lophine")
      @TransformedConfig(name = "enabled", directory = {"experiment", "force_enable_command_block_command_execution"})
-     @ConfigInfo(name = "enable_command_block")
-     public static boolean commandBlock = false;
+     @ConfigInfo(name = "enable_command_block", comments = """
+             Force to enable command blocks.
 diff --git a/src/main/java/me/earthme/luminol/config/modules/optimizations/PaperPacketLimiterConfig.java b/src/main/java/me/earthme/luminol/config/modules/optimizations/PaperPacketLimiterConfig.java
 index 35e6014f04093050a9a62b895b43e5c5d8c6a28e..11abfb884f972fd73ca4c13a6e309de1bcd23fd5 100644
 --- a/src/main/java/me/earthme/luminol/config/modules/optimizations/PaperPacketLimiterConfig.java

lophine-server/luminol-patches/features/0003-Leaves-Item-overstack-util.patch

@@ -8,180 +8,69 @@ As a part of : Leaves (https://github.com/LeavesMC/Leaves/blob/d93e9766d3797d130
 Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
 
 diff --git a/src/main/java/org/leavesmc/leaves/util/ItemOverstackUtils.java b/src/main/java/org/leavesmc/leaves/util/ItemOverstackUtils.java
-index 3a6314ed7f62c6473ce9ddc9deeee2a32b9d2893..23a0f8100eb3162331161635e8051981c4e34aed 100644
+index 112dc08eb62c4c50fb4859f51a366cedf027ca00..b5f661fd20b382725ad117c56ce2c94ded32b1b7 100644
 --- a/src/main/java/org/leavesmc/leaves/util/ItemOverstackUtils.java
 +++ b/src/main/java/org/leavesmc/leaves/util/ItemOverstackUtils.java
-@@ -17,12 +17,173 @@
+@@ -17,6 +17,7 @@
  
  package org.leavesmc.leaves.util;
  
 +import fun.bm.lophine.config.modules.function.ContainerExpansionConfig;
-+import net.minecraft.core.component.DataComponents;
-+import net.minecraft.nbt.CompoundTag;
-+import net.minecraft.world.entity.item.ItemEntity;
-+import net.minecraft.world.item.BlockItem;
- import net.minecraft.world.item.ItemStack;
-+import net.minecraft.world.item.component.CustomData;
-+import net.minecraft.world.item.component.ItemContainerContents;
-+import net.minecraft.world.level.block.ShulkerBoxBlock;
-+import org.jetbrains.annotations.NotNull;
-+
-+import java.util.List;
-+import java.util.Objects;
-+import java.util.Optional;
+ import io.papermc.paper.datacomponent.DataComponentTypes;
+ import io.papermc.paper.datacomponent.item.ItemEnchantments;
+ import net.minecraft.core.component.DataComponents;
+@@ -135,9 +136,9 @@ public class ItemOverstackUtils {
  
- // Only the used part is retained
- public class ItemOverstackUtils {
-+    private static final List<ItemUtil> overstackUtils = List.of(
-+            new ShulkerBox()
-+    );
-+
-+    public static int getItemStackMaxCount(ItemStack stack) {
-+        int size;
-+        for (ItemUtil util : overstackUtils) {
-+            if ((size = util.getMaxServerStackCount(stack)) != -1) {
-+                return size;
-+            }
-+        }
-+        return stack.getMaxStackSize();
-+    }
-+
-+    public static int getNetworkMaxCount(ItemStack stack) {
-+        int size;
-+        for (ItemUtil util : overstackUtils) {
-+            if ((size = util.getMaxClientStackCount(stack)) != -1) {
-+                return size;
-+            }
-+        }
-+        return stack.getMaxStackSize();
-+    }
-+
-+    public static boolean tryStackItems(ItemEntity self, ItemEntity other) {
-+        for (ItemUtil util : overstackUtils) {
-+            if (util.tryStackItems(self, other)) {
-+                return true;
-+            }
-+        }
-+        return false;
-+    }
-+
-+    public static boolean hasOverstackingItem() {
-+        return overstackUtils.stream().anyMatch(ItemUtil::isEnabled);
-+    }
-+
-+    public static int getItemStackMaxCountReal(ItemStack stack) {
-+        CompoundTag nbt = Optional.ofNullable(stack.get(DataComponents.CUSTOM_DATA)).orElse(CustomData.EMPTY).copyTag();
-+        return nbt.getInt("Leaves.RealStackSize").orElse(stack.getMaxStackSize());
-+    }
-+
-+    public static ItemStack encodeMaxStackSize(ItemStack itemStack) {
-+        int realMaxStackSize = getItemStackMaxCountReal(itemStack);
-+        int modifiedMaxStackSize = getNetworkMaxCount(itemStack);
-+        if (itemStack.getMaxStackSize() != modifiedMaxStackSize) {
-+            itemStack.set(DataComponents.MAX_STACK_SIZE, modifiedMaxStackSize);
-+            CompoundTag nbt = itemStack.getOrDefault(DataComponents.CUSTOM_DATA, CustomData.EMPTY).copyTag();
-+            nbt.putInt("Leaves.RealStackSize", realMaxStackSize);
-+            itemStack.set(DataComponents.CUSTOM_DATA, CustomData.of(nbt));
-+        }
-+        return itemStack;
-+    }
-+
-+    public static ItemStack decodeMaxStackSize(ItemStack itemStack) {
-+        int realMaxStackSize = getItemStackMaxCountReal(itemStack);
-+        if (itemStack.getMaxStackSize() != realMaxStackSize) {
-+            itemStack.set(DataComponents.MAX_STACK_SIZE, realMaxStackSize);
-+            CompoundTag nbt = itemStack.getOrDefault(DataComponents.CUSTOM_DATA, CustomData.EMPTY).copyTag();
-+            nbt.remove("Leaves.RealStackSize");
-+            if (nbt.isEmpty()) {
-+                itemStack.remove(DataComponents.CUSTOM_DATA);
-+            } else {
-+                itemStack.set(DataComponents.CUSTOM_DATA, CustomData.of(nbt));
-+            }
-+        }
-+        return itemStack;
-+    }
-+
-     public static float getItemStackSignalStrength(int maxStackSize, ItemStack itemStack) {
-         float result = (float) itemStack.getCount() / Math.min(maxStackSize, itemStack.getMaxStackSize());
-         return Math.clamp(result, 0f, 1f);
-     }
-+
-+    public static boolean isStackable(ItemStack itemStack) {
-+        return getItemStackMaxCount(itemStack) > 1 && (!itemStack.isDamageableItem() || !itemStack.isDamaged());
-+    }
-+
-+
-+    private interface ItemUtil {
-+        boolean isEnabled();
-+
-+        boolean tryStackItems(ItemEntity self, ItemEntity other);
-+
-+        // number -> modified count, -1 -> I don't care
-+        int getMaxServerStackCount(ItemStack stack);
-+
-+        // number -> modified count, -1 -> I don't care
-+        default int getMaxClientStackCount(ItemStack stack) {
-+            return getMaxServerStackCount(stack);
-+        }
-+    }
-+
-+    private static class ShulkerBox implements ItemUtil {
-+        public static boolean shulkerBoxCheck(@NotNull ItemStack stack1, @NotNull ItemStack stack2) {
+     private static class ShulkerBox implements ItemUtil {
+         public static boolean shulkerBoxCheck(@NotNull ItemStack stack1, @NotNull ItemStack stack2) {
+-            /*if (LeavesConfig.modify.shulkerBox.sameNbtStackable) {
 +            if (ContainerExpansionConfig.nbtShulkerStackable) {
-+                return Objects.equals(stack1.getComponents(), stack2.getComponents());
+                 return Objects.equals(stack1.getComponents(), stack2.getComponents());
+-            }*/  // Luminol
 +            }
-+            return shulkerBoxNoItem(stack1) && shulkerBoxNoItem(stack2) && Objects.equals(stack1.getComponents(), stack2.getComponents());
-+        }
-+
-+        public static boolean shulkerBoxNoItem(@NotNull ItemStack stack) {
-+            return stack.getComponents().getOrDefault(DataComponents.CONTAINER, ItemContainerContents.EMPTY).stream().findAny().isEmpty();
-+        }
-+
-+        @Override
-+        public boolean isEnabled() {
+             return shulkerBoxNoItem(stack1) && shulkerBoxNoItem(stack2) && Objects.equals(stack1.getComponents(), stack2.getComponents());
+         }
+ 
+@@ -147,16 +148,15 @@ public class ItemOverstackUtils {
+ 
+         @Override
+         public boolean isEnabled() {
+-            // return LeavesConfig.modify.shulkerBox.stackableShulkerBoxes > 1;  // Luminol
+-            return false;  // Luminol
 +            return ContainerExpansionConfig.shulkerCount > 1;
-+        }
-+
-+        @Override
-+        public boolean tryStackItems(ItemEntity self, ItemEntity other) {
-+            ItemStack selfStack = self.getItem();
-+            if (!isEnabled() ||
+         }
+ 
+         @Override
+         public boolean tryStackItems(ItemEntity self, ItemEntity other) {
+             ItemStack selfStack = self.getItem();
+             if (!isEnabled() ||
+-                    !(selfStack.getItem() instanceof net.minecraft.world.item.BlockItem blockItem) ||
+-                    !(blockItem.getBlock() instanceof net.minecraft.world.level.block.ShulkerBoxBlock)
 +                    !(selfStack.getItem() instanceof BlockItem blockItem) ||
 +                    !(blockItem.getBlock() instanceof ShulkerBoxBlock)
-+            ) {
-+                return false;
-+            }
-+
-+            ItemStack otherStack = other.getItem();
-+            if (selfStack.getItem() == otherStack.getItem()
-+                    && shulkerBoxCheck(selfStack, otherStack)
+             ) {
+                 return false;
+             }
+@@ -164,8 +164,8 @@ public class ItemOverstackUtils {
+             ItemStack otherStack = other.getItem();
+             if (selfStack.getItem() == otherStack.getItem()
+                     && shulkerBoxCheck(selfStack, otherStack)
+-                    && selfStack.getCount() != /*org.leavesmc.leaves.LeavesConfig.modify.shulkerBox.stackableShulkerBoxes*/ 1) {  // Luminol
+-                int amount = Math.min(otherStack.getCount(), /*org.leavesmc.leaves.LeavesConfig.modify.shulkerBox.stackableShulkerBoxes*/1 - selfStack.getCount()); // Luminol
 +                    && selfStack.getCount() != ContainerExpansionConfig.shulkerCount) {
 +                int amount = Math.min(otherStack.getCount(), ContainerExpansionConfig.shulkerCount - selfStack.getCount());
-+
-+                selfStack.grow(amount);
-+                self.setItem(selfStack);
-+
-+                self.pickupDelay = Math.max(other.pickupDelay, self.pickupDelay);
-+                self.age = Math.min(other.getAge(), self.age);
-+
-+                otherStack.shrink(amount);
-+                if (otherStack.isEmpty()) {
-+                    other.discard();
-+                } else {
-+                    other.setItem(otherStack);
-+                }
-+                return true;
-+            }
-+            return false;
-+        }
-+
-+        @Override
-+        public int getMaxServerStackCount(ItemStack stack) {
-+            if (isEnabled() && stack.getItem() instanceof BlockItem bi &&
+ 
+                 selfStack.grow(amount);
+                 self.setItem(selfStack);
+@@ -187,9 +187,8 @@ public class ItemOverstackUtils {
+         @Override
+         public int getMaxServerStackCount(ItemStack stack) {
+             if (isEnabled() && stack.getItem() instanceof BlockItem bi &&
+-                    bi.getBlock() instanceof ShulkerBoxBlock && (/*LeavesConfig.modify.shulkerBox.sameNbtStackable ||*/ shulkerBoxNoItem(stack))) {  // Luminol
+-                // return LeavesConfig.modify.shulkerBox.stackableShulkerBoxes;  // Luminol
+-                return 1; // Luminol
 +                    bi.getBlock() instanceof ShulkerBoxBlock && (ContainerExpansionConfig.nbtShulkerStackable || shulkerBoxNoItem(stack))) {
 +                return ContainerExpansionConfig.shulkerCount;
-+            }
-+            return -1;
-+        }
-+    }
- }
+             }
+             return -1;
+         }

lophine-server/minecraft-patches/features/0001-Add-config-to-allow-infinite-trade.patch

@@ -1,60 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Helvetica Volubi <suisuroru@blue-millennium.fun>
-Date: Mon, 7 Jul 2025 16:30:54 +0800
-Subject: [PATCH] Add config to allow infinite trade
-
-
-diff --git a/net/minecraft/world/entity/npc/Villager.java b/net/minecraft/world/entity/npc/Villager.java
-index 79242037e868a140513f032e74e8594c0c6ff41c..050e89c3e95c7c3ef7ad98f8ef03ab206241a7e2 100644
---- a/net/minecraft/world/entity/npc/Villager.java
-+++ b/net/minecraft/world/entity/npc/Villager.java
-@@ -490,8 +490,15 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
-     }
- 
-     private void resendOffersToTradingPlayer() {
--        MerchantOffers offers = this.getOffers();
-+        // Lophine start - infinite trade
-+        MerchantOffers offers = this.getOffers().copy();
-         Player tradingPlayer = this.getTradingPlayer();
-+        if (fun.bm.lophine.config.modules.function.VillagerConfig.villagerInfiniteTrade) {
-+            for (MerchantOffer merchantOffer : offers) {
-+                merchantOffer.maxUses = 524288;
-+            }
-+        }
-+        // Lophine end - infinite trade
-         if (tradingPlayer != null && !offers.isEmpty()) {
-             tradingPlayer.sendMerchantOffers(
-                 tradingPlayer.containerMenu.containerId,
-diff --git a/net/minecraft/world/item/trading/Merchant.java b/net/minecraft/world/item/trading/Merchant.java
-index 6e2fa442ddcd4ef3c4fe789b9ebac9dd409c9de7..0c7318a0ed214204f5493576c8a7b02fbe51c00b 100644
---- a/net/minecraft/world/item/trading/Merchant.java
-+++ b/net/minecraft/world/item/trading/Merchant.java
-@@ -42,7 +42,14 @@ public interface Merchant {
-             new SimpleMenuProvider((containerId, inventory, player1) -> new MerchantMenu(containerId, inventory, this), displayName)
-         );
-         if (optionalInt.isPresent()) {
--            MerchantOffers offers = this.getOffers();
-+            // Lophine start - infinite trade
-+            MerchantOffers offers = this.getOffers().copy();
-+            if (fun.bm.lophine.config.modules.function.VillagerConfig.villagerInfiniteTrade) {
-+                for (MerchantOffer merchantOffer : offers) {
-+                    merchantOffer.maxUses = 5242884;
-+                }
-+            }
-+            // Lophine end - infinite trade
-             if (!offers.isEmpty()) {
-                 player.sendMerchantOffers(optionalInt.getAsInt(), offers, level, this.getVillagerXp(), this.showProgressBar(), this.canRestock());
-             }
-diff --git a/net/minecraft/world/item/trading/MerchantOffer.java b/net/minecraft/world/item/trading/MerchantOffer.java
-index 64c99df8ff305fa28c75dc03fc5ef8c61634ad84..770f37d7158c7b4cec62783025f623a68c1f2457 100644
---- a/net/minecraft/world/item/trading/MerchantOffer.java
-+++ b/net/minecraft/world/item/trading/MerchantOffer.java
-@@ -196,7 +196,7 @@ public class MerchantOffer {
-     }
- 
-     public boolean isOutOfStock() {
--        return this.uses >= this.maxUses;
-+        return (this.uses >= this.maxUses && !fun.bm.lophine.config.modules.function.VillagerConfig.villagerInfiniteTrade); // Lophine - infinite trade
-     }
- 
-     public void setToOutOfStock() {

lophine-server/minecraft-patches/features/0003-Add-config-to-enable-raytracing-tracker.patch

@@ -18,10 +18,10 @@ index 6868b915bf3deb85783a638d4441a15fea6da2dc..70740381c6501c1a518c52b24381edd1
                      double rangeY = level.paperConfig().entities.trackingRangeY.get(this.entity, -1);
                      if (rangeY != -1) {
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index 90c36bb87a761119edb376f3bd425d48d29bf36f..a720d8db40ca56c997a4eeae14ebbc6fe764892c 100644
+index ea177b8ad7ebb25e3e2967c8ff3d36dc3dda6a1d..861684a36e3277c31842f30c82ffd9d85e2fe3f8 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
-@@ -147,7 +147,7 @@ import net.minecraft.world.waypoints.WaypointTransmitter;
+@@ -146,7 +146,7 @@ import net.minecraft.world.waypoints.WaypointTransmitter;
  import org.jetbrains.annotations.Contract;
  import org.slf4j.Logger;
  
@@ -30,7 +30,7 @@ index 90c36bb87a761119edb376f3bd425d48d29bf36f..a720d8db40ca56c997a4eeae14ebbc6f
      // CraftBukkit start
      private static final int CURRENT_LEVEL = 2;
      public boolean preserveMotion = true; // Paper - Fix Entity Teleportation and cancel velocity if teleported; keep initial motion on first snapTo
-@@ -6474,4 +6474,46 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -6462,4 +6462,46 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
      // Paper end - Expose entity id counter
  
      public boolean shouldTickHot() { return this.tickCount > 20 * 10 && this.isAlive(); } // KioCG

lophine-server/minecraft-patches/features/0004-Add-config-to-enable-function-command.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Add config to enable function command
 
 
 diff --git a/net/minecraft/commands/Commands.java b/net/minecraft/commands/Commands.java
-index af895859057ca303177ec3c8a07cf7534e62cca6..e0e9fcf3224f55f2ef31c8afca3154a5992f761b 100644
+index 11697e65a7f7871920ca7bad37de07f78a3da1f8..25ccbfa12d57d540195ecc16aa54a144f8ecc0e8 100644
 --- a/net/minecraft/commands/Commands.java
 +++ b/net/minecraft/commands/Commands.java
-@@ -206,7 +206,9 @@ public class Commands {
+@@ -204,7 +204,9 @@ public class Commands {
          FillCommand.register(this.dispatcher, context);
          FillBiomeCommand.register(this.dispatcher, context);
          ForceLoadCommand.register(this.dispatcher);

lophine-server/minecraft-patches/features/0005-Add-config-to-enable-datapack-command.patch

@@ -1,59 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Helvetica Volubi <suisuroru@blue-millennium.fun>
-Date: Wed, 2 Jul 2025 23:36:25 +0800
-Subject: [PATCH] Add config to enable datapack command
-
-
-diff --git a/net/minecraft/commands/Commands.java b/net/minecraft/commands/Commands.java
-index e05f75b6bbd48d6fb7379926d68d5f8ed6014be9..af895859057ca303177ec3c8a07cf7534e62cca6 100644
---- a/net/minecraft/commands/Commands.java
-+++ b/net/minecraft/commands/Commands.java
-@@ -192,7 +192,9 @@ public class Commands {
-         if(me.earthme.luminol.config.modules.experiment.CommandConfig.data) {
-             DataCommands.register(this.dispatcher); // Folia - region threading - TODO
-         }
--        //DataPackCommand.register(this.dispatcher, context); // Folia - region threading - TODO
-+        if (fun.bm.lophine.config.modules.experiment.CommandConfig.datapack) {
-+            DataPackCommand.register(this.dispatcher, context); // Folia - region threading - TODO
-+        }
-         //DebugCommand.register(this.dispatcher); // Folia - region threading - TODO
-         DefaultGameModeCommands.register(this.dispatcher);
-         //DialogCommand.register(this.dispatcher, context); // Folia - region threading - TODO
-diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index 75027e73859c955a54034640f905cb5d91a6a2f4..b4b3ff86f7c4afb94fc4da5133746391a078a7fb 100644
---- a/net/minecraft/server/MinecraftServer.java
-+++ b/net/minecraft/server/MinecraftServer.java
-@@ -2353,6 +2353,16 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         return this.reloadResources(selectedIds, io.papermc.paper.event.server.ServerResourcesReloadedEvent.Cause.PLUGIN);
-     }
- 
-+    // Lophine start - region thread skip reload // TODO - add reload support
-+    public void saveDatapacks(Collection<String> selectedIds) {
-+        this.packRepository.setSelected(selectedIds, false); // Paper - add pendingReload flag to determine required pack loading - false as this is *after* a reload (see above)
-+        WorldDataConfiguration worldDataConfiguration = new WorldDataConfiguration(
-+                getSelectedPacks(this.packRepository, true), this.worldData.enabledFeatures()
-+        );
-+        this.worldData.setDataConfiguration(worldDataConfiguration);
-+    }
-+    // Lophine end - region thread skip reload // TODO - add reload support
-+
-     public CompletableFuture<Void> reloadResources(Collection<String> selectedIds, io.papermc.paper.event.server.ServerResourcesReloadedEvent.Cause cause) {
-         // Paper end - Add ServerResourcesReloadedEvent
-         CompletableFuture<Void> completableFuture = CompletableFuture.<ImmutableList>supplyAsync(
-diff --git a/net/minecraft/server/commands/ReloadCommand.java b/net/minecraft/server/commands/ReloadCommand.java
-index b540a3c3a02f7242578a63477e34b9063e86f1d2..9f0adf157872e1c68cd7752a24eacdc636e8d17a 100644
---- a/net/minecraft/server/commands/ReloadCommand.java
-+++ b/net/minecraft/server/commands/ReloadCommand.java
-@@ -16,6 +16,12 @@ public class ReloadCommand {
-     private static final Logger LOGGER = LogUtils.getLogger();
- 
-     public static void reloadPacks(Collection<String> selectedIds, CommandSourceStack source) {
-+        // Lophine start - region thread skip reload // TODO - add reload support
-+        if (true) {
-+            source.getServer().saveDatapacks(selectedIds);
-+            return;
-+        }
-+        // Lophine end - region thread skip reload // TODO - add reload support
-         source.getServer().reloadResources(selectedIds, io.papermc.paper.event.server.ServerResourcesReloadedEvent.Cause.COMMAND).exceptionally(throwable -> { // Paper - Add ServerResourcesReloadedEvent
-             LOGGER.warn("Failed to execute reload", throwable);
-             source.sendFailure(Component.translatable("commands.reload.failure"));

lophine-server/minecraft-patches/features/0005-Add-config-to-enable-scoreboard-command.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Add config to enable scoreboard command
 
 
 diff --git a/net/minecraft/commands/Commands.java b/net/minecraft/commands/Commands.java
-index e0e9fcf3224f55f2ef31c8afca3154a5992f761b..6633af3cff77bcd4bcc591c032d647b7a850dced 100644
+index 25ccbfa12d57d540195ecc16aa54a144f8ecc0e8..22d211bee83e3ef34d6ac81dd89c0e73924bee90 100644
 --- a/net/minecraft/commands/Commands.java
 +++ b/net/minecraft/commands/Commands.java
-@@ -231,7 +231,11 @@ public class Commands {
+@@ -229,7 +229,11 @@ public class Commands {
          //RotateCommand.register(this.dispatcher); // Folia - region threading - TODO later
          SayCommand.register(this.dispatcher);
          //ScheduleCommand.register(this.dispatcher); // Folia - region threading

lophine-server/minecraft-patches/features/0006-Add-config-to-enable-tick-command.patch

@@ -97,10 +97,10 @@ index c485d5b3ba95f2a969bdf0dab9654ac284976f8d..b957585cf7cf7f845e20f59c7b355722
                  this.scheduler.regionFailed(this, false, thr);
                  // regionFailed will schedule a shutdown, so we should avoid letting this region tick further
 diff --git a/net/minecraft/commands/Commands.java b/net/minecraft/commands/Commands.java
-index 6633af3cff77bcd4bcc591c032d647b7a850dced..dc5a558c72a5a7ab8a650262c6a1a2dc5142b8fc 100644
+index 22d211bee83e3ef34d6ac81dd89c0e73924bee90..1fb359073342a657e9e493403263b56be5b3393f 100644
 --- a/net/minecraft/commands/Commands.java
 +++ b/net/minecraft/commands/Commands.java
-@@ -251,7 +251,11 @@ public class Commands {
+@@ -249,7 +249,11 @@ public class Commands {
          TeleportCommand.register(this.dispatcher);
          TellRawCommand.register(this.dispatcher, context);
          //TestCommand.register(this.dispatcher, context); // Folia - region threading
@@ -114,7 +114,7 @@ index 6633af3cff77bcd4bcc591c032d647b7a850dced..dc5a558c72a5a7ab8a650262c6a1a2dc
          TitleCommand.register(this.dispatcher, context);
          //TriggerCommand.register(this.dispatcher); // Folia - region threading - TODO later
 diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index b4b3ff86f7c4afb94fc4da5133746391a078a7fb..b156b5c635f931a3d4abc0584591f90476d011a6 100644
+index 75027e73859c955a54034640f905cb5d91a6a2f4..2f4970242c754cfba8ff5656a63af07d9d0a723c 100644
 --- a/net/minecraft/server/MinecraftServer.java
 +++ b/net/minecraft/server/MinecraftServer.java
 @@ -267,7 +267,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa

lophine-server/minecraft-patches/features/0007-Add-config-to-enable-waypoint-command-bar.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Add config to enable waypoint command & bar
 
 
 diff --git a/net/minecraft/commands/Commands.java b/net/minecraft/commands/Commands.java
-index dc5a558c72a5a7ab8a650262c6a1a2dc5142b8fc..9eee09ecc18abcc5972f65938ba8607dfeede026 100644
+index 1fb359073342a657e9e493403263b56be5b3393f..451a685782da46f5683ea6707289bbaf3193771f 100644
 --- a/net/minecraft/commands/Commands.java
 +++ b/net/minecraft/commands/Commands.java
-@@ -259,7 +259,11 @@ public class Commands {
+@@ -257,7 +257,11 @@ public class Commands {
          TimeCommand.register(this.dispatcher);
          TitleCommand.register(this.dispatcher, context);
          //TriggerCommand.register(this.dispatcher); // Folia - region threading - TODO later

lophine-server/minecraft-patches/features/0008-Fix-datapack-command-save-function.patch

@@ -0,0 +1,94 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Wed, 2 Jul 2025 23:36:25 +0800
+Subject: [PATCH] Fix datapack command save function
+
+
+diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
+index 2f4970242c754cfba8ff5656a63af07d9d0a723c..b156b5c635f931a3d4abc0584591f90476d011a6 100644
+--- a/net/minecraft/server/MinecraftServer.java
++++ b/net/minecraft/server/MinecraftServer.java
+@@ -2353,6 +2353,16 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         return this.reloadResources(selectedIds, io.papermc.paper.event.server.ServerResourcesReloadedEvent.Cause.PLUGIN);
+     }
+ 
++    // Lophine start - region thread skip reload // TODO - add reload support
++    public void saveDatapacks(Collection<String> selectedIds) {
++        this.packRepository.setSelected(selectedIds, false); // Paper - add pendingReload flag to determine required pack loading - false as this is *after* a reload (see above)
++        WorldDataConfiguration worldDataConfiguration = new WorldDataConfiguration(
++                getSelectedPacks(this.packRepository, true), this.worldData.enabledFeatures()
++        );
++        this.worldData.setDataConfiguration(worldDataConfiguration);
++    }
++    // Lophine end - region thread skip reload // TODO - add reload support
++
+     public CompletableFuture<Void> reloadResources(Collection<String> selectedIds, io.papermc.paper.event.server.ServerResourcesReloadedEvent.Cause cause) {
+         // Paper end - Add ServerResourcesReloadedEvent
+         CompletableFuture<Void> completableFuture = CompletableFuture.<ImmutableList>supplyAsync(
+diff --git a/net/minecraft/server/commands/DataPackCommand.java b/net/minecraft/server/commands/DataPackCommand.java
+index a5032b34752061d61fd9ddb4db828d35e403f5e7..3eaa9c85d06f6ecc8ed639d8befa861439390eb7 100644
+--- a/net/minecraft/server/commands/DataPackCommand.java
++++ b/net/minecraft/server/commands/DataPackCommand.java
+@@ -98,7 +98,7 @@ public class DataPackCommand {
+         dispatcher.register(
+             Commands.literal("datapack")
+                 .requires(Commands.hasPermission(2))
+-                /*.then( // Luminol - Add back read-only datapack command
++                .then(
+                     Commands.literal("enable")
+                         .then(
+                             Commands.argument("name", StringArgumentType.string())
+@@ -160,11 +160,11 @@ public class DataPackCommand {
+                                 .suggests(SELECTED_PACKS)
+                                 .executes(commandContext -> disablePack(commandContext.getSource(), getPack(commandContext, "name", false)))
+                         )
+-                )*/ // Luminol - Add back read-only datapack command
++                )
+                 .then(
+                     Commands.literal("list")
+                         .executes(commandContext -> listPacks(commandContext.getSource()))
+-                        // .then(Commands.literal("available").executes(commandContext -> listAvailablePacks(commandContext.getSource()))) // Luminol - Add back read-only datapack command
++                        .then(Commands.literal("available").executes(commandContext -> listAvailablePacks(commandContext.getSource())))
+                         .then(Commands.literal("enabled").executes(commandContext -> listEnabledPacks(commandContext.getSource())))
+                 )
+                 .then(
+@@ -252,7 +252,7 @@ public class DataPackCommand {
+     }
+ 
+     private static int listPacks(CommandSourceStack source) {
+-        return listEnabledPacks(source) ;// + listAvailablePacks(source); // Luminol - Add back read-only datapack command
++        return listEnabledPacks(source) + listAvailablePacks(source);
+     }
+ 
+     private static int listAvailablePacks(CommandSourceStack source) {
+@@ -280,7 +280,7 @@ public class DataPackCommand {
+ 
+     private static int listEnabledPacks(CommandSourceStack source) {
+         PackRepository packRepository = source.getServer().getPackRepository();
+-        // packRepository.reload(); // Luminol - Add back read-only datapack command
++        packRepository.reload();
+         Collection<? extends Pack> selectedPacks = packRepository.getSelectedPacks();
+         if (selectedPacks.isEmpty()) {
+             source.sendSuccess(() -> Component.translatable("commands.datapack.list.enabled.none"), false);
+diff --git a/net/minecraft/server/commands/ReloadCommand.java b/net/minecraft/server/commands/ReloadCommand.java
+index b540a3c3a02f7242578a63477e34b9063e86f1d2..bc999de32931558d0d8dc26264653dd63c1cad19 100644
+--- a/net/minecraft/server/commands/ReloadCommand.java
++++ b/net/minecraft/server/commands/ReloadCommand.java
+@@ -16,11 +16,17 @@ public class ReloadCommand {
+     private static final Logger LOGGER = LogUtils.getLogger();
+ 
+     public static void reloadPacks(Collection<String> selectedIds, CommandSourceStack source) {
++        // Lophine start - region thread skip reload // TODO - add reload support
++        source.getServer().saveDatapacks(selectedIds);
++        source.getSender().sendMessage("You need to restart server to load datapacks update.");
++        if (false) {
+         source.getServer().reloadResources(selectedIds, io.papermc.paper.event.server.ServerResourcesReloadedEvent.Cause.COMMAND).exceptionally(throwable -> { // Paper - Add ServerResourcesReloadedEvent
+             LOGGER.warn("Failed to execute reload", throwable);
+             source.sendFailure(Component.translatable("commands.reload.failure"));
+             return null;
+         });
++        }
++        // Lophine end - region thread skip reload // TODO - add reload support
+     }
+ 
+     private static Collection<String> discoverNewPacks(PackRepository packRepository, WorldData worldData, Collection<String> selectedIds) {

lophine-server/minecraft-patches/features/0010-Leaves-Configurable-trading-with-the-void.patch

@@ -0,0 +1,47 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Wed, 29 Oct 2025 00:09:09 +0800
+Subject: [PATCH] Leaves: Configurable trading with the void
+
+Co-authored by: violetc <58360096+s-yh-china@users.noreply.github.com>
+As a part of : Leaves (https://github.com/LeavesMC/Leaves)
+Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
+
+diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
+index 985ddea9d74a37f58f32a27375f6f7e6af0f2192..9796c449f924b8fd9c0dd6bb02cf196641e495ed 100644
+--- a/net/minecraft/server/level/ServerLevel.java
++++ b/net/minecraft/server/level/ServerLevel.java
+@@ -2901,7 +2901,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             // Spigot start
+             if (entity.getBukkitEntity() instanceof org.bukkit.inventory.InventoryHolder && (!(entity instanceof ServerPlayer) || entity.getRemovalReason() != Entity.RemovalReason.KILLED)) { // SPIGOT-6876: closeInventory clears death message
+                 // Paper start - Fix merchant inventory not closing on entity removal
+-                if (entity.getBukkitEntity() instanceof org.bukkit.inventory.Merchant merchant && merchant.getTrader() != null) {
++                if (!fun.bm.lophine.config.modules.function.OldFeatureConfig.villagerVoidTrade && entity.getBukkitEntity() instanceof org.bukkit.inventory.Merchant merchant && merchant.getTrader() != null) { // Leaves - Configurable trading with the void
+                     merchant.getTrader().closeInventory(org.bukkit.event.inventory.InventoryCloseEvent.Reason.UNLOADED);
+                 }
+                 // Paper end - Fix merchant inventory not closing on entity removal
+diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
+index 593dbcda4b497291eb1ecdc64b947a8d279f8be6..6c1f4f943a5be5f2e43a82cca52ca76a98226915 100644
+--- a/net/minecraft/server/players/PlayerList.java
++++ b/net/minecraft/server/players/PlayerList.java
+@@ -649,7 +649,7 @@ public abstract class PlayerList {
+                 player.stopRiding();
+                 rootVehicle.getPassengersAndSelf().forEach(entity -> {
+                     // Paper start - Fix villager boat exploit
+-                    if (entity instanceof net.minecraft.world.entity.npc.AbstractVillager villager) {
++                    if (!fun.bm.lophine.config.modules.function.OldFeatureConfig.villagerVoidTrade && entity instanceof net.minecraft.world.entity.npc.AbstractVillager villager) { // Leaves - Configurable trading with the void
+                         final net.minecraft.world.entity.player.Player human = villager.getTradingPlayer();
+                         if (human != null) {
+                             villager.setTradingPlayer(null);
+diff --git a/net/minecraft/world/inventory/MerchantMenu.java b/net/minecraft/world/inventory/MerchantMenu.java
+index d59f67ffe34201c63e3d9706a4434f33b6732edb..c635c7211bff9d190b7035b284dda162334fd5c2 100644
+--- a/net/minecraft/world/inventory/MerchantMenu.java
++++ b/net/minecraft/world/inventory/MerchantMenu.java
+@@ -74,6 +74,7 @@ public class MerchantMenu extends AbstractContainerMenu {
+ 
+     @Override
+     public boolean stillValid(Player player) {
++        if (fun.bm.lophine.config.modules.function.OldFeatureConfig.villagerVoidTrade) return this.trader.getTradingPlayer() == player; // Leaves - Configurable trading with the void
+         if (!checkReachable) return true; // Paper - checkReachable
+         return this.trader.stillValid(player);
+     }

lophine-server/minecraft-patches/features/0010-Rewrite-tickCount-support.patch

@@ -1,59 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Helvetica Volubi <suisuroru@blue-millennium.fun>
-Date: Sun, 28 Sep 2025 13:21:30 +0800
-Subject: [PATCH] Rewrite tickCount support
-
-
-diff --git a/io/papermc/paper/threadedregions/TickRegionScheduler.java b/io/papermc/paper/threadedregions/TickRegionScheduler.java
-index b957585cf7cf7f845e20f59c7b355722880f3b4e..9b279d003eb9f780ed2723c98b28d9f4d6e3a281 100644
---- a/io/papermc/paper/threadedregions/TickRegionScheduler.java
-+++ b/io/papermc/paper/threadedregions/TickRegionScheduler.java
-@@ -412,6 +412,8 @@ public final class TickRegionScheduler {
-             }
-             // Luminol end - Add tick command support
- 
-+            MinecraftServer.getServer().handleTickCount(tickCount); // Lophine - reuse tick count
-+
-             if (!this.tryMarkTicking()) {
-                 if (!this.cancelled.get()) {
-                     throw new IllegalStateException("Scheduled region should be acquirable");
-diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index b156b5c635f931a3d4abc0584591f90476d011a6..ef0b401affa58077e8dd32b52063202a1c7e0bb6 100644
---- a/net/minecraft/server/MinecraftServer.java
-+++ b/net/minecraft/server/MinecraftServer.java
-@@ -305,6 +305,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
- 
-     // Folia start - regionised ticking
-     public final io.papermc.paper.threadedregions.RegionizedServer regionizedServer = new io.papermc.paper.threadedregions.RegionizedServer();
-+    private int tickCount; // Lophine - reuse tick count
-+    private int lastTickCount;
- 
-     @Override
-     public <V> CompletableFuture<V> submit(java.util.function.Supplier<V> task) {
-@@ -2227,9 +2229,25 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         return false;
-     }
- 
-+    // Lophine start - reuse tick count
-     public int getTickCount() {
--        throw new UnsupportedOperationException(); // Folia - region threading
-+        return tickCount;
-+    }
-+
-+    public boolean checkTickCount(int period) {
-+        if (tickCount % period == 0) {
-+            return true;
-+        }
-+
-+        int nextPeriodTick = ((lastTickCount / period) + 1) * period;
-+        return nextPeriodTick < tickCount;
-+    }
-+
-+    public void handleTickCount(int tickCount) {
-+        this.lastTickCount = this.tickCount;
-+        this.tickCount += tickCount;
-     }
-+    // Lophine end - reuse tick count
- 
-     public int getSpawnProtectionRadius() {
-         return 16;

lophine-server/minecraft-patches/features/0011-Leaves-Item-overstack-util.patch

@@ -446,10 +446,10 @@ index 10b2cc20bbf3b70e4e09dbbe14b90506e6366158..1535bb8cec8692e8d26eaff090288f1b
      }
  
 diff --git a/net/minecraft/world/level/block/entity/HopperBlockEntity.java b/net/minecraft/world/level/block/entity/HopperBlockEntity.java
-index aca3303a043144894ae20ddc43abc55790db44ad..55cbf9b4cc568fb9b418433f597ed6b64e4409b0 100644
+index 3fd172f82216fa35c36e5f563819a6f01ffd4ea4..419bc939e19a306b33d4d387007c6acbae73fba3 100644
 --- a/net/minecraft/world/level/block/entity/HopperBlockEntity.java
 +++ b/net/minecraft/world/level/block/entity/HopperBlockEntity.java
-@@ -148,7 +148,7 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+@@ -144,7 +144,7 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
      public void setItem(int index, ItemStack stack) {
          this.unpackLootTable(null);
          this.getItems().set(index, stack);
@@ -458,7 +458,7 @@ index aca3303a043144894ae20ddc43abc55790db44ad..55cbf9b4cc568fb9b418433f597ed6b6
      }
  
      @Override
-@@ -770,9 +770,9 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+@@ -740,9 +740,9 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
              if (item.isEmpty()) {
                  // Spigot start - SPIGOT-6693, SimpleContainer#setItem
                  ItemStack leftover = ItemStack.EMPTY; // Paper - Make hoppers respect inventory max stack size
@@ -469,4 +469,4 @@ index aca3303a043144894ae20ddc43abc55790db44ad..55cbf9b4cc568fb9b418433f597ed6b6
 +                    stack = stack.split(Math.min(destination.getMaxStackSize(), stack.getMaxStackSize())); // Leaves - item over-stack util
                  }
                  // Spigot end
-                 //IGNORE_TILE_UPDATES.set(Boolean.TRUE); // Paper - Perf: Optimize Hoppers // Folia - region threading // Luminol - Use vanilla hopper logic
+                 //IGNORE_TILE_UPDATES.set(Boolean.TRUE); // Paper - Perf: Optimize Hoppers // Folia - region threading // Luminol - vanilla hopper

lophine-server/minecraft-patches/features/0015-Leaves-Servux-Protocol.patch

@@ -23,7 +23,7 @@ index d0d90a25a10bbecfffceee1992af88c60d14fd87..187e48e78e69c80b25710f193813335e
 +    // Leaves end - servux
  }
 diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
-index eb3aef1f5198592eda5dafe84b91271e861b4135..576dde41a4b48aac9079cca902f4371a31470af3 100644
+index 9796c449f924b8fd9c0dd6bb02cf196641e495ed..4f1976c47a087bf4f36687124ef29ca7b664f682 100644
 --- a/net/minecraft/server/level/ServerLevel.java
 +++ b/net/minecraft/server/level/ServerLevel.java
 @@ -2368,6 +2368,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe

lophine-server/minecraft-patches/features/0016-LeavesHooks.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Sun, 16 Nov 2025 17:47:48 +0800
+Subject: [PATCH] LeavesHooks
+
+
+diff --git a/ca/spottedleaf/moonrise/paper/PaperHooks.java b/ca/spottedleaf/moonrise/paper/PaperHooks.java
+index d9fd093f59987f471627ff20cfd2eb1a3c0dea64..78c6d425589b8147c33583ac46d6f21ec5dbefaa 100644
+--- a/ca/spottedleaf/moonrise/paper/PaperHooks.java
++++ b/ca/spottedleaf/moonrise/paper/PaperHooks.java
+@@ -29,7 +29,7 @@ import net.minecraft.world.phys.AABB;
+ import java.util.List;
+ import java.util.function.Predicate;
+ 
+-public final class PaperHooks extends BaseChunkSystemHooks implements PlatformHooks {
++public class PaperHooks extends BaseChunkSystemHooks implements PlatformHooks {
+ 
+     private static final org.slf4j.Logger LOGGER = com.mojang.logging.LogUtils.getLogger();
+ 

lophine-server/minecraft-patches/features/0017-Purpur-Barrels-and-enderchests-6-rows.patch

@@ -8,7 +8,7 @@ As part of: Purpur (https://github.com/PurpurMC/Purpur/blob/09f547de09fc5d886f18
 Licensed under: MIT (https://github.com/PurpurMC/Purpur/blob/09f547de09fc5d886f18f6d99ff389289766ec9d/LICENSE)
 
 diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
-index 593dbcda4b497291eb1ecdc64b947a8d279f8be6..cb863a36fc67e993956ec3be655e6e4b9764c051 100644
+index 6c1f4f943a5be5f2e43a82cca52ca76a98226915..8e2775e873c92beed6a0e4e8ce1304ab8ca6e8d1 100644
 --- a/net/minecraft/server/players/PlayerList.java
 +++ b/net/minecraft/server/players/PlayerList.java
 @@ -1087,6 +1087,10 @@ public abstract class PlayerList {

lophine-server/minecraft-patches/features/0020-I18n-support.patch

@@ -5,10 +5,18 @@ Subject: [PATCH] I18n support
 
 
 diff --git a/net/minecraft/locale/Language.java b/net/minecraft/locale/Language.java
-index 7b9e2a1a208b46a69c16e6afd8b502259893574f..db46a31ea8a36562e548eb07f0c4cf9b9e8c3360 100644
+index 7b9e2a1a208b46a69c16e6afd8b502259893574f..c300ae4363298fecef8fa9bf739f01c0a11e145f 100644
 --- a/net/minecraft/locale/Language.java
 +++ b/net/minecraft/locale/Language.java
-@@ -65,7 +65,7 @@ public abstract class Language {
+@@ -36,6 +36,7 @@ public abstract class Language {
+         Map<String, String> map = new HashMap<>();
+         BiConsumer<String, String> biConsumer = map::put;
+         parseTranslations(biConsumer, "/assets/minecraft/lang/en_us.json");
++        fun.bm.lophine.utils.ServerI18nUtil.loadLophineI18nDefault(biConsumer);
+         deprecatedTranslationsInfo.applyToMap(map);
+         final Map<String, String> map1 = Map.copyOf(map);
+         return new Language() {
+@@ -65,7 +66,7 @@ public abstract class Language {
          };
      }
  
@@ -31,7 +39,7 @@ index cf72cb8b418239b56c755486b03a321672e16bc3..b69c06607ca900beeebf4892a978442d
              String awtException = io.papermc.paper.util.ServerEnvironment.awtDependencyCheck();
              if (awtException != null) {
 diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
-index c93feb64b6088a4878fcdb6e7c733a5f37e9385b..79c911003c7b1c3d94e7e9d3974eeadcc16bde3a 100644
+index 392d75548f7eb271a6320ac30eb301a61071d465..0e278f7b9ed85ce8c3cedd9154f817b30ff1e48a 100644
 --- a/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/net/minecraft/server/dedicated/DedicatedServer.java
 @@ -172,6 +172,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface

lophine-server/minecraft-patches/features/0023-Leaves-Fakeplayer.patch

@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Bacteriawa <A3167717663@hotmail.com>
 Date: Sat, 30 Aug 2025 17:16:32 +0800
-Subject: [PATCH] Leaves: Leaves Fakeplayer
+Subject: [PATCH] Leaves: Fakeplayer
 
 Co-authored by: violetc <58360096+s-yh-china@users.noreply.github.com>
 As a part of : Leaves (https://github.com/LeavesMC/Leaves)
@@ -33,10 +33,10 @@ index 66ec0424a46dcd49cf44467357d80b1a2d84d3b2..04ae8de63af0a8abe578f14c8ef85fd4
      private DisconnectionDetails disconnectionDetails;
      private boolean encrypted;
 diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index ef0b401affa58077e8dd32b52063202a1c7e0bb6..c461ab6c6ab21008be893f84913f0e6f9cf6d336 100644
+index b156b5c635f931a3d4abc0584591f90476d011a6..81726e5782d25ff35a2bea8820a62786e46148b1 100644
 --- a/net/minecraft/server/MinecraftServer.java
 +++ b/net/minecraft/server/MinecraftServer.java
-@@ -349,6 +349,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -347,6 +347,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
      }
      // Folia end - regionised ticking
  
@@ -45,7 +45,7 @@ index ef0b401affa58077e8dd32b52063202a1c7e0bb6..c461ab6c6ab21008be893f84913f0e6f
      public static <S extends MinecraftServer> S spin(Function<Thread, S> threadFunction) {
          ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.init(); // Paper - rewrite data converter system
          AtomicReference<S> atomicReference = new AtomicReference<>();
-@@ -1040,6 +1042,11 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1038,6 +1040,11 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
      // Folia end - region threading
  
      public void stopServer() {
@@ -57,7 +57,7 @@ index ef0b401affa58077e8dd32b52063202a1c7e0bb6..c461ab6c6ab21008be893f84913f0e6f
          // Folia start - region threading
          // halt scheduler
          // don't wait, we may be on a scheduler thread
-@@ -1590,7 +1597,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1588,7 +1595,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
          int i = this.pauseWhileEmptySeconds() * 20;
          this.removeDisabledPluginsBlockingSleep(); // Paper - API to allow/disallow tick sleeping
          if (false && i > 0) { // Folia - region threading - this is complicated to implement, and even if done correctly is messy
@@ -66,7 +66,7 @@ index ef0b401affa58077e8dd32b52063202a1c7e0bb6..c461ab6c6ab21008be893f84913f0e6f
                  this.emptyTicks++;
              } else {
                  this.emptyTicks = 0;
-@@ -1914,6 +1921,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1912,6 +1919,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
  
      public void tickConnection() {
          this.getConnection().tick();
@@ -74,7 +74,7 @@ index ef0b401affa58077e8dd32b52063202a1c7e0bb6..c461ab6c6ab21008be893f84913f0e6f
      }
  
      private void synchronizeTime(ServerLevel level) {
-@@ -3001,6 +3009,16 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -2983,6 +2991,16 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
          return 0;
      }
  
@@ -219,7 +219,7 @@ index f2286b96b8f40b4588f817913c42ae7b4a92340f..e6c7bbb023000b9de90c1256274ff5ab
                  playerList.op(gameProfile);
                  i++;
 diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
-index 79c911003c7b1c3d94e7e9d3974eeadcc16bde3a..328428f0ef8a2305f661c167e6fe1f604b0d6890 100644
+index 0e278f7b9ed85ce8c3cedd9154f817b30ff1e48a..09d4b1d68c3f046ef304016a1afe7a3038dfae3e 100644
 --- a/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/net/minecraft/server/dedicated/DedicatedServer.java
 @@ -162,6 +162,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
@@ -239,18 +239,9 @@ index 79c911003c7b1c3d94e7e9d3974eeadcc16bde3a..328428f0ef8a2305f661c167e6fe1f60
          // Paper start - fix converting txt to json file; convert old users earlier after PlayerList creation but before file load/save
          if (this.convertOldUsers()) {
 diff --git a/net/minecraft/server/level/ChunkMap.java b/net/minecraft/server/level/ChunkMap.java
-index 70740381c6501c1a518c52b24381edd16792507f..5e31b499a894113b4be1982a1071348fcbaf9ded 100644
+index 70740381c6501c1a518c52b24381edd16792507f..8ad6d5a2522cfbe316fec2c3b918e2e1b9af3d1b 100644
 --- a/net/minecraft/server/level/ChunkMap.java
 +++ b/net/minecraft/server/level/ChunkMap.java
-@@ -134,7 +134,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
-     public final AtomicInteger tickingGenerated = new AtomicInteger();  // Paper - public
-     private final String storageName;
-     //private final PlayerMap playerMap = new PlayerMap(); // Folia - region threading
--    //public final Int2ObjectMap<ChunkMap.TrackedEntity> entityMap = new Int2ObjectOpenHashMap<>(); // Folia - region threading
-+    public final Int2ObjectMap<ChunkMap.TrackedEntity> entityMap = new Int2ObjectOpenHashMap<>(); // Folia - region threading
-     private final Long2ByteMap chunkTypeCache = new Long2ByteOpenHashMap();
-     // Paper - rewrite chunk system
-     public int serverViewDistance;
 @@ -1309,6 +1309,13 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
                      }
                  } else if (this.seenBy.remove(player.connection)) {
@@ -266,7 +257,7 @@ index 70740381c6501c1a518c52b24381edd16792507f..5e31b499a894113b4be1982a1071348f
              }
          }
 diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
-index 576dde41a4b48aac9079cca902f4371a31470af3..952b92c55d7192791a19ecebe80894f6cf992049 100644
+index 89d72f242d0fc224701bdcdf245d948415e7c820..5efe7d94a364cec1bd18c4d8d62c19075d52f3e8 100644
 --- a/net/minecraft/server/level/ServerLevel.java
 +++ b/net/minecraft/server/level/ServerLevel.java
 @@ -207,6 +207,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
@@ -298,7 +289,7 @@ index 576dde41a4b48aac9079cca902f4371a31470af3..952b92c55d7192791a19ecebe80894f6
      @Override
      public void updatePOIOnBlockStateChange(BlockPos pos, BlockState oldState, BlockState newState) {
          Optional<Holder<PoiType>> optional = PoiTypes.forState(oldState);
-@@ -2826,6 +2834,11 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -2827,6 +2835,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);
@@ -310,7 +301,7 @@ index 576dde41a4b48aac9079cca902f4371a31470af3..952b92c55d7192791a19ecebe80894f6
                  if (serverPlayer.isReceivingWaypoints()) {
                      ServerLevel.this.getWaypointManager().addPlayer(serverPlayer);
                  }
-@@ -2913,6 +2926,11 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -2914,6 +2927,11 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
              ServerLevel.this.getChunkSource().removeEntity(entity);
              if (entity instanceof ServerPlayer serverPlayer) {
                  ServerLevel.this.players.remove(serverPlayer);
@@ -434,7 +425,7 @@ index 144a2644c15f276f02bb3be859dc5d05a677ac55..c6a89e8936cffa49b3de153ed3c40e3c
          boolean stateLocked = true; try { this.stateLock.lock(); // Paper - Fix GameProfileCache concurrency
          GameProfileCache.GameProfileInfo gameProfileInfo = this.profilesByName.get(string);
 diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
-index cb863a36fc67e993956ec3be655e6e4b9764c051..908ec29a6e285122d1a8a43dc547b74af2697442 100644
+index 8e2775e873c92beed6a0e4e8ce1304ab8ca6e8d1..580f114fd99b017403c61e994d0c947d00e5115d 100644
 --- a/net/minecraft/server/players/PlayerList.java
 +++ b/net/minecraft/server/players/PlayerList.java
 @@ -425,6 +425,19 @@ public abstract class PlayerList {
@@ -445,7 +436,7 @@ index cb863a36fc67e993956ec3be655e6e4b9764c051..908ec29a6e285122d1a8a43dc547b74a
 +            if (fun.bm.lophine.config.modules.function.FakeplayerConfig.enable) {
 +                org.leavesmc.leaves.bot.ServerBot bot = this.server.getBotList().getBotByName(player.getScoreboardName());
 +                if (bot != null) {
-+                    this.server.getBotList().removeBot(bot, org.leavesmc.leaves.event.bot.BotRemoveEvent.RemoveReason.INTERNAL, player.getBukkitEntity(), false);
++                    this.server.getBotList().removeBot(bot, org.leavesmc.leaves.event.bot.BotRemoveEvent.RemoveReason.INTERNAL, player.getBukkitEntity(), false, true);
 +                }
 +                this.server.getBotList().bots.forEach(bot1 -> {
 +                    bot1.sendPlayerInfo(player);
@@ -548,10 +539,10 @@ index 52fd730998535ea071bfc99b7cc2c254b9b656d7..0abf6f0265fcb916f2c2c76fb1313bd1
  
          for (WaypointTransmitter waypointTransmitter : this.waypoints) {
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index a720d8db40ca56c997a4eeae14ebbc6fe764892c..118a21e7ba82832560fb0d8fb8d6b21beeb14000 100644
+index 861684a36e3277c31842f30c82ffd9d85e2fe3f8..da1b004c1f66437534f3180b6d3f3a054b7c6945 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
-@@ -1225,7 +1225,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -1224,7 +1224,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
  
              BlockPos onPosLegacy = this.getOnPosLegacy();
              BlockState blockState = this.level().getBlockState(onPosLegacy);
@@ -560,7 +551,7 @@ index a720d8db40ca56c997a4eeae14ebbc6fe764892c..118a21e7ba82832560fb0d8fb8d6b21b
                  this.checkFallDamage(vec3.y, this.onGround(), blockState, onPosLegacy);
              }
  
-@@ -1539,7 +1539,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -1538,7 +1538,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
      }
  
      // Paper start - optimise collisions

lophine-server/minecraft-patches/features/0024-Modify-merge-ItemEntity-logic.patch

@@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Fri, 3 Oct 2025 19:43:36 +0800
+Subject: [PATCH] Modify merge ItemEntity logic
+
+Add followTickSequenceMerge to modify merge items, due to Paper's modification of the merge radius, when the merge radius is large and stacks containing many items get stuck in an unexpected position, individual items may never reach their destination. This configuration option is added to fix this behavior.
+
+diff --git a/net/minecraft/world/entity/item/ItemEntity.java b/net/minecraft/world/entity/item/ItemEntity.java
+index e5e8c752129a6ebb0dd1315c9b8ec459be11ef07..dfd202a74ec7f2cdb9cdc208a6428090a110f811 100644
+--- a/net/minecraft/world/entity/item/ItemEntity.java
++++ b/net/minecraft/world/entity/item/ItemEntity.java
+@@ -295,7 +295,7 @@ public class ItemEntity extends Entity implements TraceableEntity, ChangePublish
+         ItemStack item = this.getItem();
+         ItemStack item1 = itemEntity.getItem();
+         if (Objects.equals(this.target, itemEntity.target) && areMergable(item, item1)) {
+-            if (item1.getCount() < item.getCount()) {
++            if (fun.bm.lophine.config.modules.misc.ItemEntityConfig.followTickSequenceMerge || item1.getCount() < item.getCount()) { // Lophine - add follow Tick Sequence Merge, see Paper#13073
+                 merge(this, item, itemEntity, item1);
+             } else {
+                 merge(itemEntity, item1, this, item);

lophine-server/minecraft-patches/features/0025-Leaves-Syncmatica-Protocol.patch

@@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: violetc <58360096+s-yh-china@users.noreply.github.com>
+Date: Mon, 3 Feb 2025 16:51:01 +0800
+Subject: [PATCH] Leaves: Syncmatica Protocol
+
+This patch is Powered by Syncmatica(https://github.com/End-Tech/syncmatica)
+Co-authored by: violetc <58360096+s-yh-china@users.noreply.github.com>
+As a part of : Leaves (https://github.com/LeavesMC/Leaves)
+Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
+
+diff --git a/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index e17f9629369f8653b484b4cc71de4874b5faa4d6..9be4bc9e78c22c12ba594b16dac6901023f0fd47 100644
+--- a/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -330,9 +330,12 @@ 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
+         this.playerGameConnection =  new io.papermc.paper.connection.PaperPlayerGameConnection(this); // Paper
+     }
+ 
++    public final org.leavesmc.leaves.protocol.syncmatica.exchange.ExchangeTarget exchangeTarget; // Leaves - Syncmatica Protocol
++
+     // Paper start - configuration phase API
+     @Override
+     public io.papermc.paper.connection.PlayerCommonConnection getApiConnection() {

lophine-server/minecraft-patches/features/0026-Leaves-BBOR-Protocol.patch

@@ -0,0 +1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: violetc <58360096+s-yh-china@users.noreply.github.com>
+Date: Mon, 3 Feb 2025 13:03:42 +0800
+Subject: [PATCH] Leaves: BBOR Protocol
+
+Co-authored by: violetc <58360096+s-yh-china@users.noreply.github.com>
+As a part of : Leaves (https://github.com/LeavesMC/Leaves)
+Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
+
+diff --git a/net/minecraft/world/level/chunk/LevelChunk.java b/net/minecraft/world/level/chunk/LevelChunk.java
+index f8bc2679d9eeaa5d179ab70a4cc5c97522bcc674..a536dc4e09b22b69bcdf59871a9cccfcf8129395 100644
+--- a/net/minecraft/world/level/chunk/LevelChunk.java
++++ b/net/minecraft/world/level/chunk/LevelChunk.java
+@@ -754,6 +754,11 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p
+ 
+     public void setLoaded(boolean loaded) {
+         this.loaded = loaded;
++        // Leaves start - bbor
++        if (loaded) {
++            org.leavesmc.leaves.protocol.BBORProtocol.onChunkLoaded(this);
++        }
++        // Leaves end - bbor
+     }
+ 
+     public Level getLevel() {

lophine-server/minecraft-patches/features/0027-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: Mon, 3 Feb 2025 13:33:19 +0800
+Subject: [PATCH] Leaves: Jade Protocol
+
+This patch is Powered by Jade(https://github.com/Snownee/Jade)
+Co-authored by: violetc <58360096+s-yh-china@users.noreply.github.com>
+As a part of : Leaves (https://github.com/LeavesMC/Leaves)
+Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
+
+diff --git a/net/minecraft/world/entity/animal/armadillo/Armadillo.java b/net/minecraft/world/entity/animal/armadillo/Armadillo.java
+index c1798db2972c8f2a343cf6e16fd9354ff212d906..a8d617b16ab2b2c0cdb289a0aa05fa171940cd7e 100644
+--- a/net/minecraft/world/entity/animal/armadillo/Armadillo.java
++++ b/net/minecraft/world/entity/animal/armadillo/Armadillo.java
+@@ -63,7 +63,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 17f58246849ed407821a987b200cc765eb7943f9..ac27df3ba0ce9bbdf2f32ea87171fbb9407008d6 100644
+--- a/net/minecraft/world/entity/animal/frog/Tadpole.java
++++ b/net/minecraft/world/entity/animal/frog/Tadpole.java
+@@ -254,7 +254,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 6901e629d941e22e64d83eed4e8cfee3165a96a1..fdc26c8d8c82c20534c57af2a0281b99998cc9f6 100644
+--- a/net/minecraft/world/level/storage/loot/LootPool.java
++++ b/net/minecraft/world/level/storage/loot/LootPool.java
+@@ -37,7 +37,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 8612cdf7161f8ddff60a6478cc901318b8f958ba..07a962d647baa99b0e1bf3898a07cc914e91397e 100644
+--- a/net/minecraft/world/level/storage/loot/LootTable.java
++++ b/net/minecraft/world/level/storage/loot/LootTable.java
+@@ -50,7 +50,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 eeaa49e9f70a18b5d39493aeff73f31b05ac2faa..8cd0403d7873c4c37caef75935b06b056c3d951d 100644
+--- a/net/minecraft/world/level/storage/loot/entries/CompositeEntryBase.java
++++ b/net/minecraft/world/level/storage/loot/entries/CompositeEntryBase.java
+@@ -16,7 +16,7 @@ public abstract class CompositeEntryBase extends LootPoolEntryContainer {
+             return "Empty children list";
+         }
+     };
+-    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 65e27bce9e59ef97bc8b914d646fba924d0f0877..a49bdcdf37b351436e0ba6d7865f10827c4e6ab4 100644
+--- a/net/minecraft/world/level/storage/loot/entries/LootPoolEntryContainer.java
++++ b/net/minecraft/world/level/storage/loot/entries/LootPoolEntryContainer.java
+@@ -14,7 +14,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 141026601cd9a4561426b85fd1f8e7dc0544fbd7..a5d7ebb93c147bf0f806ac3c9b2dc4b878573944 100644
+--- a/net/minecraft/world/level/storage/loot/entries/NestedLootTable.java
++++ b/net/minecraft/world/level/storage/loot/entries/NestedLootTable.java
+@@ -29,7 +29,7 @@ public class NestedLootTable extends LootPoolSingletonContainer {
+             return "->{inline}";
+         }
+     };
+-    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 bae72197acc929c7ed3e964f156115d728eb2176..8f3094f42f3366a1313d70c0b27fbe5632b2082a 100644
+--- a/net/minecraft/world/level/storage/loot/predicates/CompositeLootItemCondition.java
++++ b/net/minecraft/world/level/storage/loot/predicates/CompositeLootItemCondition.java
+@@ -12,7 +12,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) {

lophine-server/minecraft-patches/features/0028-Leaves-Xaero-Map-Protocol.patch

@@ -0,0 +1,21 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: violetc <58360096+s-yh-china@users.noreply.github.com>
+Date: Fri, 7 Feb 2025 14:23:43 +0800
+Subject: [PATCH] Leaves: Xaero Map Protocol
+
+Co-authored by: violetc <58360096+s-yh-china@users.noreply.github.com>
+As a part of : Leaves (https://github.com/LeavesMC/Leaves)
+Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
+
+diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
+index 580f114fd99b017403c61e994d0c947d00e5115d..11c1eb6995ec3aa896815efa59477096c39089d1 100644
+--- a/net/minecraft/server/players/PlayerList.java
++++ b/net/minecraft/server/players/PlayerList.java
+@@ -1247,6 +1247,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));

lophine-server/minecraft-patches/features/0029-Leaves-Support-REI-protocol.patch

@@ -0,0 +1,43 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: violetc <58360096+s-yh-china@users.noreply.github.com>
+Date: Thu, 27 Mar 2025 13:04:35 +0800
+Subject: [PATCH] Leaves: Support REI protocol
+
+Co-authored by: violetc <58360096+s-yh-china@users.noreply.github.com>
+As a part of : Leaves (https://github.com/LeavesMC/Leaves)
+Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
+
+diff --git a/net/minecraft/world/item/crafting/SmithingTransformRecipe.java b/net/minecraft/world/item/crafting/SmithingTransformRecipe.java
+index 9bc0a9c3577d63a0ad5489bfd4c07d5006245c5f..bb2e891539b7eb49dc7925630695149aa531f672 100644
+--- a/net/minecraft/world/item/crafting/SmithingTransformRecipe.java
++++ b/net/minecraft/world/item/crafting/SmithingTransformRecipe.java
+@@ -83,6 +83,12 @@ public class SmithingTransformRecipe implements SmithingRecipe {
+         );
+     }
+ 
++    // Leaves start - REI
++    public SlotDisplay getResult() {
++        return this.result.display();
++    }
++    // Leaves end - REI
++
+     // CraftBukkit start
+     @Override
+     public org.bukkit.inventory.Recipe toBukkitRecipe(org.bukkit.NamespacedKey id) {
+diff --git a/net/minecraft/world/item/crafting/SmithingTrimRecipe.java b/net/minecraft/world/item/crafting/SmithingTrimRecipe.java
+index c324896afc2ee28ebb4d426ce4a469ee847ce24d..d5b26ff7be916e07e1162536cb2ddf5674c82f46 100644
+--- a/net/minecraft/world/item/crafting/SmithingTrimRecipe.java
++++ b/net/minecraft/world/item/crafting/SmithingTrimRecipe.java
+@@ -85,6 +85,12 @@ public class SmithingTrimRecipe implements SmithingRecipe {
+         return Optional.of(this.addition);
+     }
+ 
++    // Leaves start
++    public Holder<TrimPattern> pattern() {
++        return pattern;
++    }
++    // Leaves end
++
+     @Override
+     public RecipeSerializer<SmithingTrimRecipe> getSerializer() {
+         return RecipeSerializer.SMITHING_TRIM;

lophine-server/minecraft-patches/features/0030-Leaves-Wool-Hopper-Counter.patch

@@ -0,0 +1,95 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Mon, 27 Oct 2025 15:38:29 +0800
+Subject: [PATCH] Leaves: Wool Hopper Counter
+
+Co-authored by: violetc <58360096+s-yh-china@users.noreply.github.com>
+As a part of : Leaves (https://github.com/LeavesMC/Leaves)
+Licensed under: MIT
+
+This patch is Powered by fabric-carpet(https://github.com/gnembon/fabric-carpet)
+
+diff --git a/net/minecraft/world/level/block/entity/HopperBlockEntity.java b/net/minecraft/world/level/block/entity/HopperBlockEntity.java
+index 419bc939e19a306b33d4d387007c6acbae73fba3..96445438c5b4202e3fc93bece778ad0d7312d41c 100644
+--- a/net/minecraft/world/level/block/entity/HopperBlockEntity.java
++++ b/net/minecraft/world/level/block/entity/HopperBlockEntity.java
+@@ -228,8 +228,30 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+                     flag |= validator.getAsBoolean(); // Paper - note: this is not a validator, it's what adds/sucks in items
+                 }
+ 
++                // Leaves start - Wool hopper counter
++                if (fun.bm.lophine.config.modules.function.WoolHopperCounterConfig.unlimitedSpeed && org.leavesmc.leaves.util.HopperCounter.isEnabled()) {
++                    net.minecraft.world.item.DyeColor woolColor = org.leavesmc.leaves.util.WoolUtils.getWoolColorAtPosition(level, blockEntity.getBlockPos().relative(state.getValue(HopperBlock.FACING)));
++                    if (woolColor != null) {
++                        for (int i = 0; i < Short.MAX_VALUE; i++) {
++                            flag |= suckInItems(level, blockEntity);
++                            if (!flag) {
++                                break;
++                            } else {
++                                woolHopperCounter(level, pos, state, HopperBlockEntity.getContainerAt(level, pos));
++                            }
++                        }
++                    }
++                }
++                // Leaves end - Wool hopper counter
++
+                 if (flag) {
+                     blockEntity.setCooldown(level.spigotConfig.hopperTransfer); // Spigot
++                    // Leaves start - Wool hopper counter
++                    if (fun.bm.lophine.config.modules.function.WoolHopperCounterConfig.unlimitedSpeed && org.leavesmc.leaves.util.HopperCounter.isEnabled() && woolHopperCounter(level, pos, state, HopperBlockEntity.getContainerAt(level, pos))) {
++                        blockEntity.setCooldown(0);
++                        return true;
++                    }
++                    // Leaves end - Wool hopper counter
+                     setChanged(level, pos, state);
+                     // Leaves start - Lithium Sleeping Block Entity
+                     if (me.earthme.luminol.config.modules.optimizations.LeavesSleepingBlockEntityConfig.enabled
+@@ -461,6 +483,13 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+     // Paper end - Perf: Optimize Hoppers
+ 
+     private static boolean ejectItems(Level level, BlockPos pos, HopperBlockEntity blockEntity) {
++        // Leaves start - hopper counter
++        if (org.leavesmc.leaves.util.HopperCounter.isEnabled()) {
++            if (woolHopperCounter(level, pos, level.getBlockState(pos), HopperBlockEntity.getContainerAt(level, pos))) {
++                return true;
++            }
++        }
++        // Leaves end - hopper counter
+         Container attachedContainer = me.earthme.luminol.config.modules.optimizations.LeavesSleepingBlockEntityConfig.enabled ? blockEntity.getInsertInventory(level) : getAttachedContainer(level, pos, blockEntity); // Leaves - Lithium Sleeping Block Entity
+         if (attachedContainer == null) {
+             return false;
+@@ -536,6 +565,26 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+         }
+     }
+ 
++    // Leaves start - hopper counter
++    private static boolean woolHopperCounter(Level level, BlockPos blockPos, BlockState state, @Nullable Container container) {
++        if (container == null) {
++            return false;
++        }
++        net.minecraft.world.item.DyeColor woolColor = org.leavesmc.leaves.util.WoolUtils.getWoolColorAtPosition(level, blockPos.relative(state.getValue(HopperBlock.FACING)));
++        if (woolColor != null) {
++            for (int i = 0; i < container.getContainerSize(); ++i) {
++                if (!container.getItem(i).isEmpty()) {
++                    ItemStack itemstack = container.getItem(i);
++                    org.leavesmc.leaves.util.HopperCounter.getCounter(woolColor).add(level, itemstack);
++                    container.setItem(i, ItemStack.EMPTY);
++                }
++            }
++            return true;
++        }
++        return false;
++    }
++    // Leaves end - hopper counter
++
+     private static int[] getSlots(Container container, Direction direction) {
+         if (container instanceof WorldlyContainer worldlyContainer) {
+             return worldlyContainer.getSlotsForFace(direction);
+@@ -680,6 +729,7 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+     }
+ 
+     public static boolean addItem(Container container, ItemEntity item) {
++        if (fun.bm.lophine.config.modules.function.WoolHopperCounterConfig.unlimitedSpeed && org.leavesmc.leaves.util.HopperCounter.isEnabled() && item.isRemoved()) return false; // Leaves - Wool hopper counter
+         boolean flag = false;
+         // CraftBukkit start
+         if (org.bukkit.event.inventory.InventoryPickupItemEvent.getHandlerList().getRegisteredListeners().length > 0) { // Paper - optimize hoppers

lophine-server/minecraft-patches/features/0031-Leaves-Alternative-block-placement-Protocol.patch

@@ -0,0 +1,99 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: violetc <58360096+s-yh-china@users.noreply.github.com>
+Date: Mon, 3 Feb 2025 13:51:26 +0800
+Subject: [PATCH] Leaves: Alternative block placement Protocol
+
+Co-authored by: violetc <58360096+s-yh-china@users.noreply.github.com>
+As a part of : Leaves (https://github.com/LeavesMC/Leaves)
+Licensed under: MIT
+
+This patch is Powered by
+carpet-extra(https://github.com/gnembon/carpet-extra)
+MasaGadget(https://github.com/plusls/MasaGadget)
+litematica(https://github.com/maruohon/litematica)
+
+diff --git a/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 9be4bc9e78c22c12ba594b16dac6901023f0fd47..3d9c26bc8cc14e98310f557f351871b082e5023e 100644
+--- a/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -2087,7 +2087,7 @@ public class ServerGamePacketListenerImpl
+                 if (ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(this.player.level(), blockPos.getX() >> 4, blockPos.getZ() >> 4, 8) && this.player.canInteractWithBlock(blockPos, 1.0)) { // Folia - do not allow players to interact with blocks outside the current region
+                     Vec3 vec3 = location.subtract(Vec3.atCenterOf(blockPos));
+                     double d = 1.0000001;
+-                    if (Math.abs(vec3.x()) < 1.0000001 && Math.abs(vec3.y()) < 1.0000001 && Math.abs(vec3.z()) < 1.0000001) {
++                    if (fun.bm.lophine.config.modules.function.protocol.AlternativeBlockPlacementProtocolConfig.needIgnoreDistance() ||Math.abs(vec3.x()) < 1.0000001 && Math.abs(vec3.y()) < 1.0000001 && Math.abs(vec3.z()) < 1.0000001) { // Leaves - disableDistanceCheckForUseItem
+                         Direction direction = hitResult.getDirection();
+                         this.player.resetLastActionTime();
+                         int maxY = this.player.level().getMaxY();
+diff --git a/net/minecraft/world/item/BlockItem.java b/net/minecraft/world/item/BlockItem.java
+index 6db566adf2d0df1d26221eda04aa01738df6d3d2..8f112f382190d606a87f38da8bcdf8dd5f31d1c5 100644
+--- a/net/minecraft/world/item/BlockItem.java
++++ b/net/minecraft/world/item/BlockItem.java
+@@ -149,7 +149,7 @@ public class BlockItem extends Item {
+ 
+     @Nullable
+     protected BlockState getPlacementState(BlockPlaceContext context) {
+-        BlockState stateForPlacement = this.getBlock().getStateForPlacement(context);
++        BlockState stateForPlacement = this.getBlock().getRealStateForPlacement(context); // Leaves - alternativeBlockPlacement
+         return stateForPlacement != null && this.canPlace(context, stateForPlacement) ? stateForPlacement : null;
+     }
+ 
+diff --git a/net/minecraft/world/item/StandingAndWallBlockItem.java b/net/minecraft/world/item/StandingAndWallBlockItem.java
+index 12c6c8aeec89a0a55633c62fe98f5a3aa75fd476..1f0e7c391d02b18e2c89700025713ec3d759f2ea 100644
+--- a/net/minecraft/world/item/StandingAndWallBlockItem.java
++++ b/net/minecraft/world/item/StandingAndWallBlockItem.java
+@@ -27,14 +27,14 @@ public class StandingAndWallBlockItem extends BlockItem {
+     @Nullable
+     @Override
+     protected BlockState getPlacementState(BlockPlaceContext context) {
+-        BlockState stateForPlacement = this.wallBlock.getStateForPlacement(context);
++        BlockState stateForPlacement = this.wallBlock.getRealStateForPlacement(context); // Leaves - alternativeBlockPlacement
+         BlockState blockState = null;
+         LevelReader level = context.getLevel();
+         BlockPos clickedPos = context.getClickedPos();
+ 
+         for (Direction direction : context.getNearestLookingDirections()) {
+             if (direction != this.attachmentDirection.getOpposite()) {
+-                BlockState blockState1 = direction == this.attachmentDirection ? this.getBlock().getStateForPlacement(context) : stateForPlacement;
++                BlockState blockState1 = direction == this.attachmentDirection ? this.getBlock().getRealStateForPlacement(context) : stateForPlacement; // Leaves - alternativeBlockPlacement
+                 if (blockState1 != null && this.canPlace(level, blockState1, clickedPos)) {
+                     blockState = blockState1;
+                     break;
+diff --git a/net/minecraft/world/level/block/Block.java b/net/minecraft/world/level/block/Block.java
+index 644b9fab1d6729bf3964ebee0d6e9c46f89b8c46..634bdb554dfe757c3c9f13a79c3f644d8be4e3ea 100644
+--- a/net/minecraft/world/level/block/Block.java
++++ b/net/minecraft/world/level/block/Block.java
+@@ -439,6 +439,33 @@ public class Block extends BlockBehaviour implements ItemLike {
+     public void stepOn(Level level, BlockPos pos, BlockState state, Entity entity) {
+     }
+ 
++    // Leaves start - alternativeBlockPlacement
++    @Nullable
++    public BlockState getRealStateForPlacement(BlockPlaceContext ctx) {
++        BlockState vanillaState = this.getStateForPlacement(ctx);
++        switch (fun.bm.lophine.config.modules.function.protocol.AlternativeBlockPlacementProtocolConfig.alternativeBlockPlacement) {
++            case fun.bm.lophine.enums.EnumAlternativePlaceType.CARPET -> {
++                BlockState tryState = org.leavesmc.leaves.protocol.CarpetAlternativeBlockPlacement.alternativeBlockPlacement(this, ctx);
++                if (tryState != null) {
++                    return tryState;
++                }
++            }
++            case fun.bm.lophine.enums.EnumAlternativePlaceType.CARPET_FIX -> {
++                BlockState tryState = org.leavesmc.leaves.protocol.CarpetAlternativeBlockPlacement.alternativeBlockPlacementFix(this, ctx);
++                if (tryState != null) {
++                    return tryState;
++                }
++            }
++            case fun.bm.lophine.enums.EnumAlternativePlaceType.LITEMATICA -> {
++                if (vanillaState != null) {
++                    return org.leavesmc.leaves.protocol.LitematicaEasyPlaceProtocol.applyPlacementProtocol(vanillaState, ctx);
++                }
++            }
++        }
++        return vanillaState;
++    }
++    // Leaves end - alternativeBlockPlacement
++
+     @Nullable
+     public BlockState getStateForPlacement(BlockPlaceContext context) {
+         return this.defaultBlockState();

lophine-server/minecraft-patches/features/0031-Leaves-Replay-Mod-API.patch

@@ -0,0 +1,562 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Sun, 16 Nov 2025 15:48:12 +0800
+Subject: [PATCH] Leaves: Replay Mod API
+
+Co-authored by: violetc <58360096+s-yh-china@users.noreply.github.com>
+As a part of : Leaves (https://github.com/LeavesMC/Leaves) & ReplayMod (https://github.com/ReplayMod)
+Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
+
+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 8c005a7b9480da7c124c5bd5bfccd5ca83abbcb1..a814a67f321662f05e2c5f81666f75e128bf4ea7 100644
+--- a/net/minecraft/commands/CommandSourceStack.java
++++ b/net/minecraft/commands/CommandSourceStack.java
+@@ -580,7 +580,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 514f8fbdeb776087608665c35de95294aadf5cf0..b75772897cabc3e7c59301d451685378fa55b6c3 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 ? List.of() : List.of(playerByName);
+         } 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 ? List.of() : List.of(playerByName);
+         } else {
+             Vec3 vec3 = this.position.apply(source.getPosition());
+@@ -206,11 +210,11 @@ 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
+                 } else {
+                     players = new ObjectArrayList<>();
+ 
+-                    for (ServerPlayer serverPlayer1 : source.getServer().getPlayerList().getPlayers()) {
++                    for (ServerPlayer serverPlayer1 : source.getServer().getPlayerList().realPlayers) { // Leaves - only real players
+                         if (predicate.test(serverPlayer1)) {
+                             players.add(serverPlayer1);
+                             if (players.size() >= resultLimit) {
+diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
+index 81726e5782d25ff35a2bea8820a62786e46148b1..3c94631f468f4ee1b46de9981c17171e5901d745 100644
+--- a/net/minecraft/server/MinecraftServer.java
++++ b/net/minecraft/server/MinecraftServer.java
+@@ -1800,7 +1800,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     }
+ 
+     private ServerStatus.Players buildPlayerStatus() {
+-        List<ServerPlayer> players = new java.util.ArrayList<>(this.playerList.getPlayers()); // Folia - region threading
++        List<ServerPlayer> players = new java.util.ArrayList<>(this.playerList.realPlayers); // Folia - region threading
+         int maxPlayers = this.getMaxPlayers();
+         if (this.hidesOnlinePlayers()) {
+             return new ServerStatus.Players(maxPlayers, players.size(), List.of());
+@@ -2001,7 +2001,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
+     @Override
+     public int getPlayerCount() {
+-        return this.playerList.getPlayerCount();
++        return this.playerList.realPlayers.size(); // Leaves - only real player
+     }
+ 
+     @Override
+@@ -2415,7 +2415,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+                     if (Thread.currentThread() != this.serverThread) return; // Paper
+                     // Paper start - we don't need to save everything, just advancements
+                     // this.getPlayerList().saveAll();
+-                    for (final ServerPlayer player : this.getPlayerList().getPlayers()) {
++                    for (final ServerPlayer player : this.getPlayerList().realPlayers) { // Leaves - only real players
+                         player.getAdvancements().save();
+                     }
+                     // Paper end - we don't need to save everything, just advancements
+@@ -2554,7 +2554,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             if (!playerList.isUsingWhitelist()) return; // Paper - whitelist not enabled
+             UserWhiteList whiteList = playerList.getWhiteList();
+ 
+-            for (ServerPlayer serverPlayer : Lists.newArrayList(playerList.getPlayers())) {
++            for (ServerPlayer serverPlayer : Lists.newArrayList(playerList.realPlayers)) { // Leaves - only real player
+                 if (!whiteList.isWhiteListed(serverPlayer.getGameProfile()) && !this.getPlayerList().isOp(serverPlayer.getGameProfile())) { // Paper - Fix kicking ops when whitelist is reloaded (MC-171420)
+                     serverPlayer.connection.disconnect(net.kyori.adventure.text.Component.text(org.spigotmc.SpigotConfig.whitelistMessage), org.bukkit.event.player.PlayerKickEvent.Cause.WHITELIST); // Paper - use configurable message & kick event cause
+                 }
+diff --git a/net/minecraft/server/PlayerAdvancements.java b/net/minecraft/server/PlayerAdvancements.java
+index 5c0e338dc1b0eb5724d10a73d6fc7975f9d2e5e5..0e7e4246837353a5936a6388f23b6b4b2ec1d5f3 100644
+--- a/net/minecraft/server/PlayerAdvancements.java
++++ b/net/minecraft/server/PlayerAdvancements.java
+@@ -168,7 +168,7 @@ public class PlayerAdvancements {
+ 
+     public boolean award(AdvancementHolder advancement, String criterionKey) {
+         // Leaves start - bot can't get advancement
+-        if (player instanceof org.leavesmc.leaves.bot.ServerBot) {
++        if (player instanceof org.leavesmc.leaves.bot.ServerBot || player instanceof org.leavesmc.leaves.replay.ServerPhotographer) { // Leaves - and photographer
+             return false;
+         }
+         // Leaves end - bot can't get advancement
+diff --git a/net/minecraft/server/ServerScoreboard.java b/net/minecraft/server/ServerScoreboard.java
+index fc1c377ad05edcefacd407671801ae605f3fc31a..5635f0940b4b70f27c8dfdc1aa666fcb7e26d55d 100644
+--- a/net/minecraft/server/ServerScoreboard.java
++++ b/net/minecraft/server/ServerScoreboard.java
+@@ -242,7 +242,7 @@ public class ServerScoreboard extends Scoreboard {
+     public void startTrackingObjective(Objective objective) {
+         List<Packet<?>> startTrackingPackets = this.getStartTrackingPackets(objective);
+ 
+-        for (ServerPlayer serverPlayer : this.server.getPlayerList().getPlayers()) {
++        for (ServerPlayer serverPlayer : this.server.getPlayerList().realPlayers) { // Leaves - only real players
+             if (serverPlayer.getBukkitEntity().getScoreboard().getHandle() != this) continue; // CraftBukkit - Only players on this board
+             for (Packet<?> packet : startTrackingPackets) {
+                 serverPlayer.connection.send(packet);
+@@ -268,7 +268,7 @@ public class ServerScoreboard extends Scoreboard {
+     public void stopTrackingObjective(Objective objective) {
+         List<Packet<?>> stopTrackingPackets = this.getStopTrackingPackets(objective);
+ 
+-        for (ServerPlayer serverPlayer : this.server.getPlayerList().getPlayers()) {
++        for (ServerPlayer serverPlayer : this.server.getPlayerList().realPlayers) { // Leaves - only real players
+             if (serverPlayer.getBukkitEntity().getScoreboard().getHandle() != this) continue; // CraftBukkit - Only players on this board
+             for (Packet<?> packet : stopTrackingPackets) {
+                 serverPlayer.connection.send(packet);
+diff --git a/net/minecraft/server/commands/DefaultGameModeCommands.java b/net/minecraft/server/commands/DefaultGameModeCommands.java
+index c2ab47bb97c4fbbbc48a8ff0538ab8fd38532a88..2b7d11195f96e68a004e0e060e19d4004bb8a154 100644
+--- a/net/minecraft/server/commands/DefaultGameModeCommands.java
++++ b/net/minecraft/server/commands/DefaultGameModeCommands.java
+@@ -27,7 +27,7 @@ public class DefaultGameModeCommands {
+         server.setDefaultGameType(gamemode);
+         GameType forcedGameType = server.getForcedGameType();
+         if (forcedGameType != null) {
+-            for (ServerPlayer serverPlayer : server.getPlayerList().getPlayers()) {
++            for (ServerPlayer serverPlayer : server.getPlayerList().realPlayers) { // Leaves - only real players
+                 serverPlayer.getBukkitEntity().taskScheduler.schedule((ServerPlayer player) -> { // Folia - region threading
+                 // Paper start - Expand PlayerGameModeChangeEvent
+                 org.bukkit.event.player.PlayerGameModeChangeEvent event = player.setGameMode(gamemode, org.bukkit.event.player.PlayerGameModeChangeEvent.Cause.DEFAULT_GAMEMODE, net.kyori.adventure.text.Component.empty()); // Folia - region threading
+diff --git a/net/minecraft/server/commands/ListPlayersCommand.java b/net/minecraft/server/commands/ListPlayersCommand.java
+index c6ae34f91b3629990294fc5e69237a1e600ef038..2109b0a2d4099e64c34cd1c45b83f72654d3b615 100644
+--- a/net/minecraft/server/commands/ListPlayersCommand.java
++++ b/net/minecraft/server/commands/ListPlayersCommand.java
+@@ -33,7 +33,7 @@ public class ListPlayersCommand {
+     private static int format(CommandSourceStack source, Function<ServerPlayer, Component> nameExtractor) {
+         PlayerList playerList = source.getServer().getPlayerList();
+         // CraftBukkit start
+-        List<ServerPlayer> playersTemp = playerList.getPlayers();
++        List<ServerPlayer> playersTemp = playerList.realPlayers;
+         if (source.getBukkitSender() instanceof org.bukkit.entity.Player) {
+             org.bukkit.entity.Player sender = (org.bukkit.entity.Player) source.getBukkitSender();
+             playersTemp = playersTemp.stream().filter((ep) -> sender.canSee(ep.getBukkitEntity())).collect(java.util.stream.Collectors.toList());
+diff --git a/net/minecraft/server/commands/OpCommand.java b/net/minecraft/server/commands/OpCommand.java
+index e6c7bbb023000b9de90c1256274ff5aba4a6478a..98f8804d58616592332e2a968282be6ad8903ea8 100644
+--- a/net/minecraft/server/commands/OpCommand.java
++++ b/net/minecraft/server/commands/OpCommand.java
+@@ -25,7 +25,7 @@ public class OpCommand {
+                             (commandContext, suggestionsBuilder) -> {
+                                 PlayerList playerList = commandContext.getSource().getServer().getPlayerList();
+                                 return SharedSuggestionProvider.suggest(
+-                                    playerList.getPlayers()
++                                    playerList.realPlayers // Leaves - only real player
+                                         .stream()
+                                         .filter(serverPlayer -> !playerList.isOp(serverPlayer.getGameProfile()))
+                                         .map(serverPlayer -> serverPlayer.getGameProfile().getName()),
+diff --git a/net/minecraft/server/commands/ParticleCommand.java b/net/minecraft/server/commands/ParticleCommand.java
+index 33d96239f4b72a5587dc70f9602847a870d6d6a5..a83ce2cd112fca02cf3545f8c38e5cafae2c7c0e 100644
+--- a/net/minecraft/server/commands/ParticleCommand.java
++++ b/net/minecraft/server/commands/ParticleCommand.java
+@@ -36,7 +36,7 @@ public class ParticleCommand {
+                                 0.0F,
+                                 0,
+                                 false,
+-                                commandContext.getSource().getServer().getPlayerList().getPlayers()
++                                commandContext.getSource().getServer().getPlayerList().realPlayers // Leaves - only real player
+                             )
+                         )
+                         .then(
+@@ -50,7 +50,7 @@ public class ParticleCommand {
+                                         0.0F,
+                                         0,
+                                         false,
+-                                        context1.getSource().getServer().getPlayerList().getPlayers()
++                                        context1.getSource().getServer().getPlayerList().realPlayers // Leaves - only real player
+                                     )
+                                 )
+                                 .then(
+@@ -68,7 +68,7 @@ public class ParticleCommand {
+                                                                 FloatArgumentType.getFloat(context1, "speed"),
+                                                                 IntegerArgumentType.getInteger(context1, "count"),
+                                                                 false,
+-                                                                context1.getSource().getServer().getPlayerList().getPlayers()
++                                                                context1.getSource().getServer().getPlayerList().realPlayers // Leaves - only real player
+                                                             )
+                                                         )
+                                                         .then(
+@@ -82,7 +82,7 @@ public class ParticleCommand {
+                                                                         FloatArgumentType.getFloat(context1, "speed"),
+                                                                         IntegerArgumentType.getInteger(context1, "count"),
+                                                                         true,
+-                                                                        context1.getSource().getServer().getPlayerList().getPlayers()
++                                                                        context1.getSource().getServer().getPlayerList().realPlayers // Leaves - only real player
+                                                                     )
+                                                                 )
+                                                                 .then(
+@@ -112,7 +112,7 @@ public class ParticleCommand {
+                                                                         FloatArgumentType.getFloat(context1, "speed"),
+                                                                         IntegerArgumentType.getInteger(context1, "count"),
+                                                                         false,
+-                                                                        context1.getSource().getServer().getPlayerList().getPlayers()
++                                                                        context1.getSource().getServer().getPlayerList().realPlayers // Leaves - only real player
+                                                                     )
+                                                                 )
+                                                                 .then(
+diff --git a/net/minecraft/server/commands/TeamMsgCommand.java b/net/minecraft/server/commands/TeamMsgCommand.java
+index 134d7b1a9d5a5a47ebf4aabff110dde914cd6fe1..894dd1d048904b8a775416ea6cb3112215c567bc 100644
+--- a/net/minecraft/server/commands/TeamMsgCommand.java
++++ b/net/minecraft/server/commands/TeamMsgCommand.java
+@@ -40,7 +40,7 @@ public class TeamMsgCommand {
+                                 } else {
+                                     List<ServerPlayer> list = commandSourceStack.getServer()
+                                         .getPlayerList()
+-                                        .getPlayers()
++                                        .realPlayers // Leaves - only real players
+                                         .stream()
+                                         .filter(player -> player == entityOrException || player.getTeam() == team)
+                                         .toList();
+diff --git a/net/minecraft/server/commands/WhitelistCommand.java b/net/minecraft/server/commands/WhitelistCommand.java
+index 763a51d9a0859296eb4ea52b6879d6c7703db673..25b4fcf79dbf3e227451b3321d8fd38bab55ffe9 100644
+--- a/net/minecraft/server/commands/WhitelistCommand.java
++++ b/net/minecraft/server/commands/WhitelistCommand.java
+@@ -43,7 +43,7 @@ public class WhitelistCommand {
+                                     (commandContext, suggestionsBuilder) -> {
+                                         PlayerList playerList = commandContext.getSource().getServer().getPlayerList();
+                                         return SharedSuggestionProvider.suggest(
+-                                            playerList.getPlayers()
++                                            playerList.realPlayers // Leaves - only real player
+                                                 .stream()
+                                                 .filter(serverPlayer -> !playerList.getWhiteList().isWhiteListed(serverPlayer.getGameProfile()))
+                                                 .map(serverPlayer -> serverPlayer.getGameProfile().getName()),
+diff --git a/net/minecraft/server/gui/PlayerListComponent.java b/net/minecraft/server/gui/PlayerListComponent.java
+index f5ba0c9a4c3f9eaa38eeb689de915c25c7165433..24bbc32bc17802edbd9cc14310fe8141c0ad85b0 100644
+--- a/net/minecraft/server/gui/PlayerListComponent.java
++++ b/net/minecraft/server/gui/PlayerListComponent.java
+@@ -17,8 +17,8 @@ public class PlayerListComponent extends JList<String> {
+         if (this.tickCount++ % 20 == 0) {
+             Vector<String> list = new Vector<>();
+ 
+-            for (int i = 0; i < this.server.getPlayerList().getPlayers().size(); i++) {
+-                list.add(this.server.getPlayerList().getPlayers().get(i).getGameProfile().getName());
++            for (int i = 0; i < this.server.getPlayerList().realPlayers.size(); i++) { // Leaves - only real players
++                list.add(this.server.getPlayerList().realPlayers.get(i).getGameProfile().getName()); // Leaves - only real players
+             }
+ 
+             this.setListData(list);
+diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
+index 5efe7d94a364cec1bd18c4d8d62c19075d52f3e8..a4ee2bcdb31f889c7edbbc422636782c0d5d0af6 100644
+--- a/net/minecraft/server/level/ServerLevel.java
++++ b/net/minecraft/server/level/ServerLevel.java
+@@ -2836,7 +2836,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             if (entity instanceof ServerPlayer serverPlayer) {
+                 ServerLevel.this.players.add(serverPlayer);
+                 // Leaves start - skip
+-                if (!(serverPlayer instanceof org.leavesmc.leaves.bot.ServerBot)) {
++                if (!(serverPlayer instanceof org.leavesmc.leaves.bot.ServerBot) && !(serverPlayer instanceof org.leavesmc.leaves.replay.ServerPhotographer)) { // and photographer
+                     ServerLevel.this.realPlayers.add(serverPlayer);
+                 }
+                 // Leaves end - skip
+@@ -2928,7 +2928,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             if (entity instanceof ServerPlayer serverPlayer) {
+                 ServerLevel.this.players.remove(serverPlayer);
+                 // Leaves start - skip
+-                if (!(serverPlayer instanceof org.leavesmc.leaves.bot.ServerBot)) {
++                if (!(serverPlayer instanceof org.leavesmc.leaves.bot.ServerBot) && !(serverPlayer instanceof org.leavesmc.leaves.replay.ServerPhotographer)) { // and photographer
+                     ServerLevel.this.realPlayers.remove(serverPlayer);
+                 }
+                 // Leaves end - skip
+diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
+index 4b2dba8b30b72fb3acc00957b3e19d6fc178c99e..afd607df83fda3de6f53f55ad305c8f69fe6ddb6 100644
+--- a/net/minecraft/server/level/ServerPlayer.java
++++ b/net/minecraft/server/level/ServerPlayer.java
+@@ -194,7 +194,7 @@ import net.minecraft.world.scores.criteria.ObjectiveCriteria;
+ import org.slf4j.Logger;
+ 
+ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patches.chunk_system.player.ChunkSystemServerPlayer { // Paper - rewrite chunk system
+-    private static final Logger LOGGER = LogUtils.getLogger();
++    protected static final Logger LOGGER = LogUtils.getLogger();
+     public static final long LAST_SAVE_ABSENT = Long.MIN_VALUE; public long lastSave = LAST_SAVE_ABSENT; // Paper // Folia - threaded regions - changed to nanoTime
+     private static final int NEUTRAL_MOB_DEATH_NOTIFICATION_RADII_XZ = 32;
+     private static final int NEUTRAL_MOB_DEATH_NOTIFICATION_RADII_Y = 10;
+diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
+index 11c1eb6995ec3aa896815efa59477096c39089d1..54e7ddf0b3949e02d2705ff7626010c947965938 100644
+--- a/net/minecraft/server/players/PlayerList.java
++++ b/net/minecraft/server/players/PlayerList.java
+@@ -130,6 +130,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;
+@@ -213,6 +214,122 @@ 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
++
++        // Leaves start - bot support
++        if (fun.bm.lophine.config.modules.function.FakeplayerConfig.enable) {
++            org.leavesmc.leaves.bot.ServerBot bot = this.server.getBotList().getBotByName(player.getScoreboardName());
++            if (bot != null) {
++                this.server.getBotList().removeBot(bot, org.leavesmc.leaves.event.bot.BotRemoveEvent.RemoveReason.INTERNAL, player.getBukkitEntity(), false);
++            }
++            this.server.getBotList().bots.forEach(bot1 -> {
++                bot1.sendPlayerInfo(player);
++                bot1.sendFakeDataIfNeed(player, true);
++            }); // Leaves - render bot
++        }
++        // Leaves end - bot support
++
++        final List<ServerPlayer> onlinePlayers = Lists.newArrayListWithExpectedSize(this.players.size() - 1);
++        final List<ServerPlayer> playerList = List.copyOf(this.players); // Lophine - copy to avoid ConcurrentModificationException
++        for (ServerPlayer serverPlayer : playerList) {
++            if (serverPlayer == player || !bukkitPlayer.canSee(serverPlayer.getBukkitEntity())) {
++                continue;
++            }
++
++            // Leaves start - skip photographer
++            if (serverPlayer instanceof org.leavesmc.leaves.replay.ServerPhotographer) {
++                continue;
++            }
++            // Leaves end - skip photographer
++
++            onlinePlayers.add(serverPlayer);
++        }
++        if (!onlinePlayers.isEmpty()) {
++            player.connection.send(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(onlinePlayers, player));
++        }
++
++        player.sentListPacket = true;
++        player.supressTrackerForLogin = false;
++        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.level();
++        for (MobEffectInstance mobeffect : player.getActiveEffects()) {
++            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 loadSpawnForNewPlayer(Connection connection, ServerPlayer player, CommonListenerCookie cookie, org.apache.commons.lang3.mutable.MutableObject<net.minecraft.util.ProblemReporter.ScopedCollector> scopedCollectorStore, org.apache.commons.lang3.mutable.MutableObject<ValueInput> data, org.apache.commons.lang3.mutable.MutableObject<String> lastKnownName, ca.spottedleaf.concurrentutil.completable.CallbackCompletable<org.bukkit.Location> toComplete) { // Folia - region threading - rewrite login process
+         player.isRealPlayer = true; // Paper
+         player.loginTime = System.currentTimeMillis(); // Paper - Replace OfflinePlayer#getLastPlayed
+@@ -398,6 +515,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.broadcastAll(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(List.of(player))); // CraftBukkit - replaced with loop below
+@@ -601,6 +719,7 @@ public abstract class PlayerList {
+     }
+ 
+     protected void save(ServerPlayer player) {
++        if (player instanceof org.leavesmc.leaves.replay.ServerPhotographer) return; // Leaves - skip photographer
+         if (!player.getBukkitEntity().isPersistent()) return; // CraftBukkit
+         player.lastSave = System.nanoTime(); // Folia - region threading - changed to nanoTime tracking
+         this.playerIo.save(player);
+@@ -615,6 +734,43 @@ public abstract class PlayerList {
+         }
+     }
+ 
++    // Leaves start - replay mod api
++    public void removePhotographer(org.leavesmc.leaves.replay.ServerPhotographer entityplayer) {
++        ServerLevel worldserver = entityplayer.level();
++
++        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())));
+@@ -688,6 +844,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.server.getCustomBossEvents().onPlayerDisconnect(player);
+         UUID uuid = player.getUUID();
+@@ -1044,15 +1201,15 @@ public abstract class PlayerList {
+     }
+ 
+     public String[] getPlayerNamesArray() {
+-        List<ServerPlayer> players = new java.util.ArrayList<>(this.players); // Folia - region threading
+-        String[] strings = new String[this.players.size() + this.server.getBotList().bots.size()]; // Leaves - fakeplayer support
++        List<ServerPlayer> players = new java.util.ArrayList<>(this.realPlayers); // Folia - region threading
++        String[] strings = new String[players.size() + this.server.getBotList().bots.size()]; // Leaves - fakeplayer support, and skip photographer
+ 
+-        for (int i = 0; i < players.size(); i++) { // Folia - region threading
+-            strings[i] = players.get(i).getGameProfile().getName(); // Folia - region threading
++        for (int i = 0; i < players.size(); i++) { // Folia - region threading // Leaves - only real players
++            strings[i] = players.get(i).getGameProfile().getName(); // Folia - region threading // Leaves - only real players
+         }
+         // Leaves start - fakeplayer support
+-        for (int i = this.players.size(); i < strings.length; ++i) {
+-            strings[i] = this.server.getBotList().bots.get(i - this.players.size()).getGameProfile().getName();
++        for (int i = players.size(); i < strings.length; ++i) { // Leaves - only real players
++            strings[i] = this.server.getBotList().bots.get(i - players.size()).getGameProfile().getName(); // Leaves - only real players
+         }
+         // Leaves end - fakeplayer support
+ 
+diff --git a/net/minecraft/world/entity/LivingEntity.java b/net/minecraft/world/entity/LivingEntity.java
+index 12466e0294123a5922ee7694984d4d277a390ddd..205e2648569b7c18f488aa4d3d9ec944bb1babf4 100644
+--- a/net/minecraft/world/entity/LivingEntity.java
++++ b/net/minecraft/world/entity/LivingEntity.java
+@@ -257,7 +257,7 @@ public abstract class LivingEntity extends Entity implements Attackable, Waypoin
+     protected ItemStack useItem = ItemStack.EMPTY;
+     public int useItemRemaining;
+     protected int fallFlyTicks;
+-    private BlockPos lastPos;
++    protected BlockPos lastPos;
+     private Optional<BlockPos> lastClimbablePos = Optional.empty();
+     @Nullable
+     private DamageSource lastDamageSource;

lophine-server/paper-patches/features/0004-Leaves-Leaves-Fakeplayer.patch

@@ -161,7 +161,7 @@ index 852e1ffef6a022caad7c8eff34091e50112a2290..8eb5d014d9ed688ffebaffb4ce0bb408
          if (entity instanceof EnderDragonPart complexPart) {
              if (complexPart.parentMob instanceof EnderDragon) {
 diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
-index e040f9a7c9451fbe547dda56952410047a99ddc0..05753de195bd7f4ac2952183662a8cc9ec8f4ba0 100644
+index 317837a2a9b3b511b5cac4df4db248d4652816dc..a8253d1a3129c8258e9ead7c430e1bcf82f735d7 100644
 --- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
 +++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
 @@ -897,7 +897,11 @@ public class CraftEventFactory {

lophine-server/paper-patches/features/0005-Leaves-Replay-Mod-API.patch

@@ -0,0 +1,106 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Sun, 16 Nov 2025 15:55:47 +0800
+Subject: [PATCH] Leaves: Replay Mod API
+
+Co-authored by: violetc <58360096+s-yh-china@users.noreply.github.com>
+As a part of : Leaves (https://github.com/LeavesMC/Leaves)
+Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
+
+diff --git a/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java b/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java
+index e1f456b31ffda9370b63e51f343847d6f9f62263..8a0f85241cc1530aacccc8b6ea24b9dec86fad66 100644
+--- a/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java
++++ b/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java
+@@ -57,7 +57,7 @@ class PaperEventManager {
+         }
+ 
+         // Leaves start - skip bot
+-        if (event instanceof org.bukkit.event.player.PlayerEvent playerEvent && playerEvent.getPlayer() instanceof org.leavesmc.leaves.entity.bot.Bot) {
++        if (event instanceof org.bukkit.event.player.PlayerEvent playerEvent && (playerEvent.getPlayer() instanceof org.leavesmc.leaves.entity.bot.Bot || playerEvent.getPlayer() instanceof org.leavesmc.leaves.entity.photographer.Photographer)) { // Leaves - and photographer
+             return;
+         }
+         // Leaves end - skip bot
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 0a96721797b9bbc643f68677bbb1d10c3c89e815..7e2d870dc8b77c58270542f8916b9c9b88588809 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -317,6 +317,7 @@ public final class CraftServer implements Server {
+     public io.papermc.paper.SparksFly spark; // Paper - spark // Luminol - Force disable builtin spark
+     private final ServerConfiguration serverConfig = new PaperServerConfiguration();
+     private final org.leavesmc.leaves.entity.bot.CraftBotManager botManager; // Leaves
++    private final org.leavesmc.leaves.entity.photographer.CraftPhotographerManager photographerManager = new org.leavesmc.leaves.entity.photographer.CraftPhotographerManager(); // Leaves
+ 
+     // Paper start - Folia region threading API
+     private final io.papermc.paper.threadedregions.scheduler.FoliaRegionScheduler regionizedScheduler = new io.papermc.paper.threadedregions.scheduler.FoliaRegionScheduler(); // Folia - region threading
+@@ -411,7 +412,7 @@ public final class CraftServer implements Server {
+     public CraftServer(DedicatedServer console, PlayerList playerList) {
+         this.console = console;
+         this.playerList = (DedicatedPlayerList) playerList;
+-        this.playerView = Collections.unmodifiableList(Lists.transform(playerList.players, new Function<ServerPlayer, CraftPlayer>() {
++        this.playerView = Collections.unmodifiableList(Lists.transform(playerList.realPlayers, new Function<ServerPlayer, CraftPlayer>() { // Leaves - replay api
+             @Override
+             public CraftPlayer apply(ServerPlayer player) {
+                 return player.getBukkitEntity();
+@@ -3333,4 +3334,11 @@ public final class CraftServer implements Server {
+         }
+     }
+     // Folia end - region TPS API
++
++    // Leaves start - replay mod api
++    @Override
++    public org.leavesmc.leaves.entity.photographer.CraftPhotographerManager getPhotographerManager() {
++        return photographerManager;
++    }
++    // Leaves end - replay mod api
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index 8eb5d014d9ed688ffebaffb4ce0bb40896961a04..634bd74449c6991ad72330d10f42ddbb7f59c164 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -127,6 +127,7 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+         }
+ 
+         if (entity instanceof org.leavesmc.leaves.bot.ServerBot bot) { return new org.leavesmc.leaves.entity.bot.CraftBot(server, bot); }
++        if (entity instanceof org.leavesmc.leaves.replay.ServerPhotographer photographer) { return new org.leavesmc.leaves.entity.photographer.CraftPhotographer(server, photographer); }
+ 
+         // Special case complex part, since there is no extra entity type for them
+         if (entity instanceof EnderDragonPart complexPart) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 7883b7973570b5f275a03c6aac4d3b4392e7fa6e..18d066c605f8027d9b1170b64ef1428fb969631b 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -2214,7 +2214,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player, PluginMessa
+ 
+     @Override
+     public boolean canSee(Player player) {
+-        return this.canSee((org.bukkit.entity.Entity) player);
++        return !(player instanceof org.leavesmc.leaves.entity.photographer.Photographer) && this.canSee((org.bukkit.entity.Entity) player); // Leaves - skip photographer
+     }
+ 
+     @Override
+diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
+index 679529d94c16960527e5d76adb61c7e536f55d3e..503e11640bd2b6f7c854747723d26fe9cd67f490 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
++++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
+@@ -338,7 +338,7 @@ public final class CraftMagicNumbers implements UnsafeValues {
+                     Bukkit.getLogger().log(Level.SEVERE, "Error saving advancement " + key, ex);
+                 }
+ 
+-                MinecraftServer.getServer().getPlayerList().getPlayers().forEach(player -> {
++                net.minecraft.server.MinecraftServer.getServer().getPlayerList().realPlayers.forEach(player -> { // Leaves - only real players
+                     player.getAdvancements().reload(MinecraftServer.getServer().getAdvancements());
+                     player.getAdvancements().flushDirty(player, false);
+                 });
+diff --git a/src/main/java/org/bukkit/craftbukkit/util/LazyPlayerSet.java b/src/main/java/org/bukkit/craftbukkit/util/LazyPlayerSet.java
+index 25aae550dcdcef2df268d0dd99bdcc9bbd49fcf8..83af50de50a03e164d572f3c3466b6d0b42ed138 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/LazyPlayerSet.java
++++ b/src/main/java/org/bukkit/craftbukkit/util/LazyPlayerSet.java
+@@ -23,7 +23,7 @@ public class LazyPlayerSet extends LazyHashSet<Player> {
+     }
+ 
+     public static Set<Player> makePlayerSet(final MinecraftServer server) {
+-        List<ServerPlayer> players = server.getPlayerList().players;
++        List<ServerPlayer> players = server.getPlayerList().realPlayers; // Leaves - only real players
+         Set<Player> reference = new HashSet<>(players.size());
+         for (ServerPlayer player : players) {
+             reference.add(player.getBukkitEntity());

lophine-server/paper-patches/features/0005-LeavesHooks.patch

@@ -0,0 +1,13 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Sun, 16 Nov 2025 17:47:42 +0800
+Subject: [PATCH] LeavesHooks
+
+
+diff --git a/src/main/resources/META-INF/services/ca.spottedleaf.moonrise.common.PlatformHooks b/src/main/resources/META-INF/services/ca.spottedleaf.moonrise.common.PlatformHooks
+index e57c3ca79677b1dfe7cf3db36f0406de7ea5bd0a..86edd824ec42e550dd1419fd57d93a21fe2d648d 100644
+--- a/src/main/resources/META-INF/services/ca.spottedleaf.moonrise.common.PlatformHooks
++++ b/src/main/resources/META-INF/services/ca.spottedleaf.moonrise.common.PlatformHooks
+@@ -1 +1 @@
+-ca.spottedleaf.moonrise.paper.PaperHooks
++org.leavesmc.leaves.region.LeavesHooks

lophine-server/src/main/java/fun/bm/lophine/command/counter/CounterCommand.java

@@ -0,0 +1,41 @@
+package fun.bm.lophine.command.counter;
+
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import fun.bm.lophine.command.counter.sub.DisplayCommand;
+import fun.bm.lophine.command.counter.sub.ResetCommand;
+import fun.bm.lophine.command.counter.sub.ToggleCommand;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.JoinConfiguration;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.command.CommandContext;
+import org.leavesmc.leaves.command.RootNode;
+import org.leavesmc.leaves.util.HopperCounter;
+
+public class CounterCommand extends RootNode {
+    private final String PERM_BASE;
+
+    public CounterCommand() {
+        super("counter", "lophine.commands.counter");
+        this.PERM_BASE = "lophine.commands.counter";
+        children(
+                new ToggleCommand(this),
+                new ResetCommand(this),
+                new DisplayCommand(this)
+        );
+    }
+
+    @Override
+    protected boolean execute(@NotNull CommandContext context) throws CommandSyntaxException {
+        context.getSender().sendMessage(Component.join(JoinConfiguration.noSeparators(),
+                Component.text("Hopper Counter: ", NamedTextColor.GRAY),
+                Component.text(HopperCounter.isEnabled(), HopperCounter.isEnabled() ? NamedTextColor.AQUA : NamedTextColor.GRAY)
+        ));
+        return true;
+    }
+
+    public boolean hasPermission(@NotNull CommandSender sender, String... subcommand) {
+        return hasPermission(PERM_BASE, sender, subcommand);
+    }
+}

lophine-server/src/main/java/fun/bm/lophine/command/counter/CounterSubCommand.java

@@ -0,0 +1,24 @@
+package fun.bm.lophine.command.counter;
+
+import net.minecraft.commands.CommandSourceStack;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.command.LiteralNode;
+
+public class CounterSubCommand extends LiteralNode {
+    protected final CounterCommand parent;
+
+    protected CounterSubCommand(String name, CounterCommand parent) {
+        super(name);
+        this.parent = parent;
+    }
+
+    @Override
+    public boolean requires(@NotNull CommandSourceStack source) {
+        return hasPermission(source.getSender());
+    }
+
+    protected boolean hasPermission(CommandSender sender) {
+        return parent.hasPermission(sender, this.name);
+    }
+}

lophine-server/src/main/java/fun/bm/lophine/command/counter/sub/DisplayCommand.java

@@ -0,0 +1,91 @@
+package fun.bm.lophine.command.counter.sub;
+
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
+import fun.bm.lophine.command.counter.CounterCommand;
+import fun.bm.lophine.command.counter.CounterSubCommand;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.item.DyeColor;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.command.ArgumentNode;
+import org.leavesmc.leaves.command.CommandContext;
+import org.leavesmc.leaves.util.HopperCounter;
+
+import java.util.concurrent.CompletableFuture;
+
+public class DisplayCommand extends CounterSubCommand {
+    public DisplayCommand(CounterCommand parent) {
+        super("display", parent);
+        children(
+                DyeColorArg::new
+        );
+    }
+
+    public static void displayCounter(CommandContext context, @NotNull HopperCounter counter, boolean realTime) {
+        for (Component component : counter.format(MinecraftServer.getServer(), context.getSource().getLevel(), realTime)) {
+            context.getSender().sendMessage(component);
+        }
+    }
+
+    private static class DyeColorArg extends ArgumentNode<String> {
+        protected DyeColorArg() {
+            super("color", StringArgumentType.string());
+            children(
+                    TimeArg::new
+            );
+        }
+
+        @Override
+        protected boolean execute(@NotNull CommandContext context) {
+            String color0 = context.getArgument(DyeColorArg.class);
+            DyeColor color = DyeColor.byName(color0, null);
+            if (color == null) return true;
+            HopperCounter counter = HopperCounter.getCounter(color);
+            displayCounter(context, counter, false);
+            return true;
+        }
+
+        @Override
+        protected CompletableFuture<Suggestions> getSuggestions(@NotNull CommandContext context, @NotNull SuggestionsBuilder builder) {
+            String path = context.getArgumentOrDefault(DyeColorArg.class, "");
+            for (DyeColor value : DyeColor.values()) {
+                String color = value.getName();
+                if (color.startsWith(path)) {
+                    builder.suggest(color);
+                }
+            }
+            return builder.buildFuture();
+        }
+
+        private static class TimeArg extends ArgumentNode<String> {
+            protected TimeArg() {
+                super("time", StringArgumentType.string());
+            }
+
+            @Override
+            protected boolean execute(@NotNull CommandContext context) {
+                String color0 = context.getArgument(DyeColorArg.class);
+                DyeColor color = DyeColor.byName(color0, null);
+                if (color == null) return true;
+                HopperCounter counter = HopperCounter.getCounter(color);
+                String timeType = context.getArgument(TimeArg.class);
+                switch (timeType) {
+                    case "realtime" -> displayCounter(context, counter, true);
+                    case "gametick" -> displayCounter(context, counter, false);
+                    default ->
+                            context.getSender().sendMessage(Component.text("Invalid time type: " + timeType, NamedTextColor.RED));
+                }
+                return true;
+            }
+
+            protected CompletableFuture<Suggestions> getSuggestions(@NotNull CommandContext context, @NotNull SuggestionsBuilder builder) {
+                builder.suggest("realtime");
+                builder.suggest("gametick");
+                return builder.buildFuture();
+            }
+        }
+    }
+}

lophine-server/src/main/java/fun/bm/lophine/command/counter/sub/ResetCommand.java

@@ -0,0 +1,75 @@
+package fun.bm.lophine.command.counter.sub;
+
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
+import fun.bm.lophine.command.counter.CounterCommand;
+import fun.bm.lophine.command.counter.CounterSubCommand;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.JoinConfiguration;
+import net.kyori.adventure.text.format.TextColor;
+import net.minecraft.world.item.DyeColor;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.command.ArgumentNode;
+import org.leavesmc.leaves.command.CommandContext;
+import org.leavesmc.leaves.util.HopperCounter;
+
+import java.util.concurrent.CompletableFuture;
+
+public class ResetCommand extends CounterSubCommand {
+    public ResetCommand(CounterCommand parent) {
+        super("reset", parent);
+        children(
+                DyeColorArg::new
+        );
+    }
+
+    @Override
+    protected boolean execute(@NotNull CommandContext context) throws CommandSyntaxException {
+        HopperCounter.resetAll(context.getSource().getLevel(), false);
+        context.getSender().sendMessage(Component.text("Restarted all counters."));
+        return true;
+    }
+
+    private static class DyeColorArg extends ArgumentNode<String> {
+        protected DyeColorArg() {
+            super("color", StringArgumentType.string());
+        }
+
+        @Override
+        protected boolean execute(@NotNull CommandContext context) {
+            String color0 = context.getArgument(DyeColorArg.class);
+            if (color0.equals("all")) {
+                HopperCounter.resetAll(context.getSource().getLevel(), false);
+                context.getSender().sendMessage(Component.text("Restarted all counters."));
+                return true;
+            }
+            DyeColor color = DyeColor.byName(color0, null);
+            if (color == null) return true;
+            HopperCounter counter = HopperCounter.getCounter(color);
+            counter.reset(context.getSource().getLevel());
+            context.getSender().sendMessage(Component.join(JoinConfiguration.noSeparators(),
+                    Component.text("Restarted "),
+                    Component.text(color.getName(), TextColor.color(color.getTextColor())),
+                    Component.text(" counter.")
+            ));
+            return true;
+        }
+
+        @Override
+        protected CompletableFuture<Suggestions> getSuggestions(@NotNull CommandContext context, @NotNull SuggestionsBuilder builder) {
+            String path = context.getArgumentOrDefault(DyeColorArg.class, "");
+            if ("all".startsWith(path)) {
+                builder.suggest("all");
+            }
+            for (DyeColor value : DyeColor.values()) {
+                String color = value.getName();
+                if (color.startsWith(path)) {
+                    builder.suggest(color);
+                }
+            }
+            return builder.buildFuture();
+        }
+    }
+}

lophine-server/src/main/java/fun/bm/lophine/command/counter/sub/ToggleCommand.java

@@ -0,0 +1,55 @@
+package fun.bm.lophine.command.counter.sub;
+
+import com.mojang.brigadier.arguments.BoolArgumentType;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import fun.bm.lophine.command.counter.CounterCommand;
+import fun.bm.lophine.command.counter.CounterSubCommand;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.command.ArgumentNode;
+import org.leavesmc.leaves.command.CommandContext;
+import org.leavesmc.leaves.util.HopperCounter;
+
+public class ToggleCommand extends CounterSubCommand {
+    public ToggleCommand(CounterCommand parent) {
+        super("toggle", parent);
+        children(
+                BooleanArg::new
+        );
+    }
+
+    @Override
+    protected boolean execute(@NotNull CommandContext context) throws CommandSyntaxException {
+        if (!HopperCounter.isEnabled()) {
+            HopperCounter.setEnabled(true);
+            context.getSender().sendMessage(Component.text("Hopper Counter now is enabled.", NamedTextColor.AQUA));
+        } else {
+            HopperCounter.setEnabled(false);
+            context.getSender().sendMessage(Component.text("Hopper Counter now is disabled.", NamedTextColor.RED));
+        }
+        return true;
+    }
+
+    private static class BooleanArg extends ArgumentNode<Boolean> {
+        protected BooleanArg() {
+            super("enabled", BoolArgumentType.bool());
+        }
+
+        @Override
+        protected boolean execute(@NotNull CommandContext context) {
+            boolean enabled = context.getArgument(BooleanArg.class);
+            if (enabled == HopperCounter.isEnabled()) {
+                context.getSender().sendMessage(Component.text("Hopper Counter is already " + (enabled ? "enabled" : "disabled") + ".", NamedTextColor.GRAY));
+            } else {
+                HopperCounter.setEnabled(enabled);
+                if (enabled) {
+                    context.getSender().sendMessage(Component.text("Hopper Counter now is enabled.", NamedTextColor.AQUA));
+                } else {
+                    context.getSender().sendMessage(Component.text("Hopper Counter now is disabled.", NamedTextColor.RED));
+                }
+            }
+            return true;
+        }
+    }
+}

lophine-server/src/main/java/fun/bm/lophine/config/modules/experiment/CommandConfig.java

@@ -13,12 +13,6 @@ public class CommandConfig implements IConfigModule {
                     Allow to use tick command""")
     public static boolean tick = false;
 
-    @ConfigInfo(name = "datapack_command_enabled", comments =
-            """
-                    Allow to use datapack command
-                        --- datapack hot-update unsupported, please restart server""")
-    public static boolean datapack = false;
-
     @ConfigInfo(name = "function_command_enabled", comments =
             """
                     Allow to use function command""")
@@ -30,7 +24,7 @@ public class CommandConfig implements IConfigModule {
             """
                     Allow to use waypoint command""")
     public static boolean waypoint = false;
-    
+
     @ConfigInfo(name = "scoreboard_command_enabled", comments =
             """
                     Allow to use scoreboard command""")

lophine-server/src/main/java/fun/bm/lophine/config/modules/function/ContainerExpansionConfig.java

@@ -23,14 +23,16 @@ public class ContainerExpansionConfig implements IConfigModule {
                     range: 1~6""")
     public static int enderchestRows = 3;
 
+    @TransformedConfig(name = "shulker_stackable_count", directory = {"function", "container_expansion"})
     @TransformedConfig(name = "shulker_stackable_count", directory = {"misc", "container_expansion"})
     @CommandSuggestions(suggest = {"1", "2", "32", "64"})
-    @ConfigInfo(name = "shulker_stackable_count", comments =
+    @ConfigInfo(name = "shulker_stackable_count", directory = {"shulker_box"}, comments =
             """
                     range: 1~64""")
     public static int shulkerCount = 1;
 
+    @TransformedConfig(name = "same_nbt_shulker_stackable", directory = {"function", "container_expansion"})
     @TransformedConfig(name = "same_nbt_shulker_stackable", directory = {"misc", "container_expansion"})
-    @ConfigInfo(name = "same_nbt_shulker_stackable")
+    @ConfigInfo(name = "same_nbt_shulker_stackable", directory = {"shulker_box"})
     public static boolean nbtShulkerStackable = false;
 }

lophine-server/src/main/java/fun/bm/lophine/config/modules/function/FakeplayerConfig.java

@@ -5,10 +5,12 @@ import me.earthme.luminol.config.IConfigModule;
 import me.earthme.luminol.config.flags.ConfigClassInfo;
 import me.earthme.luminol.config.flags.ConfigInfo;
 import me.earthme.luminol.enums.EnumConfigCategory;
+import org.jetbrains.annotations.Nullable;
 import org.leavesmc.leaves.bot.ServerBot;
 import org.leavesmc.leaves.command.bot.BotCommand;
 
 import java.util.List;
+import java.util.Set;
 
 @ConfigClassInfo(category = EnumConfigCategory.FUNCTION, name = "fakeplayer")
 public class FakeplayerConfig implements IConfigModule {
@@ -91,7 +93,7 @@ public class FakeplayerConfig implements IConfigModule {
     }
 
     @Override
-    public void onLoaded(CommentedFileConfig configInstance) {
+    public void onLoaded(CommentedFileConfig configInstance, @Nullable Set<Exception> exs) {
         if (enable) {
             command = new BotCommand();
             command.register();

lophine-server/src/main/java/fun/bm/lophine/config/modules/function/OldFeatureConfig.java

@@ -24,4 +24,12 @@ public class OldFeatureConfig implements IConfigModule {
     @TransformedConfig(name = "give_bad_omen_when_kill_raid_captain", directory = {"misc", "revert_raid_changes"}, transformComments = false)
     @ConfigInfo(name = "old_raid_behavior")
     public static boolean oldRaidBehavior = false;
+
+    @TransformedConfig(name = "villager-infinite-trade", directory = {"function", "villager"}, transformComments = false)
+    @TransformedConfig(name = "villager-infinite-trade", directory = {"misc", "villager"}, transformComments = false)
+    @TransformedConfig(name = "villager-infinite-trade", directory = {"misc", "villager-config"}, transformComments = false)
+    @ConfigInfo(name = "villager-void-trade", comments =
+            """
+                    Allow villager void trade.""")
+    public static boolean villagerVoidTrade = false;
 }

lophine-server/src/main/java/fun/bm/lophine/config/modules/function/VillagerConfig.java

@@ -1,19 +0,0 @@
-package fun.bm.lophine.config.modules.function;
-
-import me.earthme.luminol.config.IConfigModule;
-import me.earthme.luminol.config.flags.ConfigClassInfo;
-import me.earthme.luminol.config.flags.ConfigInfo;
-import me.earthme.luminol.config.flags.TransformedConfig;
-import me.earthme.luminol.enums.EnumConfigCategory;
-
-@ConfigClassInfo(category = EnumConfigCategory.MISC, name = "villager")
-public class VillagerConfig implements IConfigModule {
-    @TransformedConfig(name = "villager-infinite-trade", directory = {"misc", "villager"})
-    @TransformedConfig(name = "villager-infinite-trade", directory = {"misc", "villager-config"})
-    @ConfigInfo(name = "villager-infinite-trade", comments =
-            """
-                    Allow villager infinite trade (limit of 524288 times)
-                        ---- we won't edit saved data, only edit in send data to client.
-                        (after we fixed void trade, this config will drop to void trade)""")
-    public static boolean villagerInfiniteTrade = false;
-}

lophine-server/src/main/java/fun/bm/lophine/config/modules/function/WoolHopperCounterConfig.java

@@ -0,0 +1,31 @@
+package fun.bm.lophine.config.modules.function;
+
+import com.electronwill.nightconfig.core.file.CommentedFileConfig;
+import fun.bm.lophine.command.counter.CounterCommand;
+import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
+import me.earthme.luminol.config.flags.ConfigInfo;
+import me.earthme.luminol.enums.EnumConfigCategory;
+import org.bukkit.Bukkit;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Set;
+
+@ConfigClassInfo(category = EnumConfigCategory.FUNCTION, name = "wool-hopper-counter")
+public class WoolHopperCounterConfig implements IConfigModule {
+    @ConfigInfo(name = "enabled")
+    public static boolean enabled = false;
+
+    @ConfigInfo(name = "unlimited-speed")
+    public static boolean unlimitedSpeed = false;
+
+    @Override
+    public void onLoaded(CommentedFileConfig configInstance, @Nullable Set<Exception> exs) {
+        if (enabled) new CounterCommand().register();
+    }
+
+    @Override
+    public void onUnloaded(CommentedFileConfig configInstance) {
+        Bukkit.getCommandMap().getKnownCommands().remove("luminol:tpsbar");
+    }
+}

lophine-server/src/main/java/fun/bm/lophine/config/modules/function/protocol/AlternativeBlockPlacementProtocolConfig.java

@@ -0,0 +1,23 @@
+package fun.bm.lophine.config.modules.function.protocol;
+
+import fun.bm.lophine.enums.EnumAlternativePlaceType;
+import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
+import me.earthme.luminol.config.flags.ConfigInfo;
+import me.earthme.luminol.enums.EnumConfigCategory;
+
+@ConfigClassInfo(category = EnumConfigCategory.FUNCTION, name = "alternative_block_placement", directory = {"protocol"})
+public class AlternativeBlockPlacementProtocolConfig implements IConfigModule {
+    @ConfigInfo(name = "enabled", comments = """
+            Specify the precise placement protocol type
+            NONE Disable precise placement protocol
+            CARPET Precise placement protocol version 2
+            CARPET_FIX Enhanced precise placement protocol version 2 (requires MasaGadget installed on client)
+            LITEMATICA Precise placement protocol version 3""")
+    public static EnumAlternativePlaceType alternativeBlockPlacement = EnumAlternativePlaceType.NONE;
+
+    public static boolean needIgnoreDistance() {
+        return alternativeBlockPlacement != EnumAlternativePlaceType.NONE;
+    }
+}
+

lophine-server/src/main/java/fun/bm/lophine/config/modules/function/protocol/AppleSkinProtocolConfig.java

@@ -0,0 +1,16 @@
+package fun.bm.lophine.config.modules.function.protocol;
+
+import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
+import me.earthme.luminol.config.flags.ConfigInfo;
+import me.earthme.luminol.enums.EnumConfigCategory;
+
+@ConfigClassInfo(category = EnumConfigCategory.FUNCTION, name = "appleskin", directory = {"protocol"})
+public class AppleSkinProtocolConfig implements IConfigModule {
+    @ConfigInfo(name = "enabled", comments = """
+            Enable AppleSkin protocol support""")
+    public static boolean enabled = false;
+    @ConfigInfo(name = "sync-tick-interval", comments = """
+            Set AppleSkin Synchronization Frequency (Unit: Game Ticks)""")
+    public static int syncTickInterval = 20;
+}

lophine-server/src/main/java/fun/bm/lophine/config/modules/function/protocol/BBORProtocolConfig.java

@@ -0,0 +1,13 @@
+package fun.bm.lophine.config.modules.function.protocol;
+
+import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
+import me.earthme.luminol.config.flags.ConfigInfo;
+import me.earthme.luminol.enums.EnumConfigCategory;
+
+@ConfigClassInfo(category = EnumConfigCategory.FUNCTION, name = "bbor", directory = {"protocol"})
+public class BBORProtocolConfig implements IConfigModule {
+    @ConfigInfo(name = "enabled", comments = """
+            Enable BBOR protocol support""")
+    public static boolean enabled = false;
+}

lophine-server/src/main/java/fun/bm/lophine/config/modules/function/protocol/JadeProtocolConfig.java

@@ -0,0 +1,13 @@
+package fun.bm.lophine.config.modules.function.protocol;
+
+import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
+import me.earthme.luminol.config.flags.ConfigInfo;
+import me.earthme.luminol.enums.EnumConfigCategory;
+
+@ConfigClassInfo(category = EnumConfigCategory.FUNCTION, name = "jade", directory = {"protocol"})
+public class JadeProtocolConfig implements IConfigModule {
+    @ConfigInfo(name = "enabled", comments = """
+            Enable Jade protocol support""")
+    public static boolean enabled = false;
+}

lophine-server/src/main/java/fun/bm/lophine/config/modules/function/protocol/REIServerProtocolConfig.java

@@ -0,0 +1,13 @@
+package fun.bm.lophine.config.modules.function.protocol;
+
+import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
+import me.earthme.luminol.config.flags.ConfigInfo;
+import me.earthme.luminol.enums.EnumConfigCategory;
+
+@ConfigClassInfo(category = EnumConfigCategory.FUNCTION, name = "rei", directory = {"protocol"})
+public class REIServerProtocolConfig implements IConfigModule {
+    @ConfigInfo(name = "enabled", comments = """
+            Enable Roughly Enough Items protocol support""")
+    public static boolean enabled = false;
+}

lophine-server/src/main/java/fun/bm/lophine/config/modules/function/protocol/ServuxProtocolConfig.java

@@ -1,4 +1,4 @@
-package fun.bm.lophine.config.modules.function;
+package fun.bm.lophine.config.modules.function.protocol;
 
 import me.earthme.luminol.config.IConfigModule;
 import me.earthme.luminol.config.flags.CommandSuggestions;
@@ -9,54 +9,64 @@ import me.earthme.luminol.enums.EnumConfigCategory;
 
 import java.util.List;
 
-@ConfigClassInfo(category = EnumConfigCategory.FUNCTION, name = "servux-protocol")
+@ConfigClassInfo(category = EnumConfigCategory.FUNCTION, name = "servux", directory = {"protocol"})
 public class ServuxProtocolConfig implements IConfigModule {
+    @TransformedConfig(name = "entity-protocol", directory = {"function", "servux-protocol", "data"})
     @TransformedConfig(name = "entity-protocol", directory = {"function", "survux-protocol"})
     @TransformedConfig(name = "entity-protocol", directory = {"misc", "survux-protocol"})
     @ConfigInfo(name = "entity-protocol", directory = {"data"})
     public static boolean entityProtocol = false;
 
+    @TransformedConfig(name = "hud-logger-protocol", directory = {"function", "servux-protocol"})
     @TransformedConfig(name = "hud-logger-protocol", directory = {"function", "survux-protocol"})
     @TransformedConfig(name = "hud-logger-protocol", directory = {"misc", "survux-protocol"})
     @ConfigInfo(name = "hud-logger-protocol")
     public static boolean hudLoggerProtocol = false;
 
+    @TransformedConfig(name = "hud-metadata-protocol", directory = {"function", "servux-protocol"})
     @TransformedConfig(name = "hud-metadata-protocol", directory = {"function", "survux-protocol"})
     @TransformedConfig(name = "hud-metadata-protocol", directory = {"misc", "survux-protocol"})
     @ConfigInfo(name = "hud-metadata-protocol")
     public static boolean hudMetadataProtocol = false;
 
+    @TransformedConfig(name = "hud-metadata-share-seed", directory = {"function", "servux-protocol"})
     @TransformedConfig(name = "hud-metadata-share-seed", directory = {"function", "survux-protocol"})
     @TransformedConfig(name = "hud-metadata-share-seed", directory = {"misc", "survux-protocol"})
     @ConfigInfo(name = "hud-metadata-share-seed")
     public static boolean hudMetadataShareSeed = false;
 
+    @TransformedConfig(name = "structure-protocol", directory = {"function", "servux-protocol"})
     @TransformedConfig(name = "structure-protocol", directory = {"function", "survux-protocol"})
     @TransformedConfig(name = "structure-protocol", directory = {"misc", "survux-protocol"})
     @ConfigInfo(name = "structure-protocol")
     public static boolean structureProtocol = false;
 
+    @TransformedConfig(name = "hud-enabled-loggers", directory = {"function", "servux-protocol"})
     @TransformedConfig(name = "hud-enabled-loggers", directory = {"function", "survux-protocol"})
     @TransformedConfig(name = "hud-enabled-loggers", directory = {"misc", "survux-protocol"})
     @ConfigInfo(name = "hud-enabled-loggers")
     public static List<String> hudEnabledLoggers = List.of("tps", "mob_caps");
 
+    @TransformedConfig(name = "hud-update-interval", directory = {"function", "servux-protocol"})
     @TransformedConfig(name = "hud-update-interval", directory = {"function", "survux-protocol"})
     @TransformedConfig(name = "hud-update-interval", directory = {"misc", "survux-protocol"})
     @ConfigInfo(name = "hud-update-interval")
     public static int hudUpdateInterval = 1;
 
+    @TransformedConfig(name = "litematics-enabled", directory = {"function", "servux-protocol", "litematics"})
     @TransformedConfig(name = "litematics-enabled", directory = {"function", "survux-protocol"})
     @TransformedConfig(name = "litematics-enabled", directory = {"misc", "survux-protocol"})
     @ConfigInfo(name = "litematics-enabled", directory = {"litematics"})
     public static boolean litematicsEnabled = false;
 
+    @TransformedConfig(name = "litematics-max-nbt-size", directory = {"function", "servux-protocol", "litematics"})
     @TransformedConfig(name = "litematics-max-nbt-size", directory = {"function", "survux-protocol"})
     @TransformedConfig(name = "litematics-max-nbt-size", directory = {"misc", "survux-protocol"})
     @CommandSuggestions(suggest = {"-1", "2097152"})
     @ConfigInfo(name = "litematics-max-nbt-size", directory = {"litematics"})
     public static int litematicsMaxNbtSize = 2097152;
 
+    @TransformedConfig(name = "litematics-print-max-delay-ticks", directory = {"function", "servux-protocol", "litematics"})
     @TransformedConfig(name = "litematics-print-max-delay-ticks", directory = {"function", "survux-protocol"})
     @CommandSuggestions(suggest = {"-1", "1200"})
     @ConfigInfo(name = "litematics-print-max-delay-ticks", directory = {"litematics"}, comments = "The max delay ticks for printing litematics, -1 to disable")

lophine-server/src/main/java/fun/bm/lophine/config/modules/function/protocol/SyncmaticaProtocolConfig.java

@@ -0,0 +1,28 @@
+package fun.bm.lophine.config.modules.function.protocol;
+
+import com.electronwill.nightconfig.core.file.CommentedFileConfig;
+import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
+import me.earthme.luminol.config.flags.ConfigInfo;
+import me.earthme.luminol.enums.EnumConfigCategory;
+import org.jetbrains.annotations.Nullable;
+import org.leavesmc.leaves.protocol.syncmatica.SyncmaticaProtocol;
+
+import java.util.Set;
+
+@ConfigClassInfo(category = EnumConfigCategory.FUNCTION, name = "syncmatica", directory = {"protocol"})
+public class SyncmaticaProtocolConfig implements IConfigModule {
+    @ConfigInfo(name = "enabled", comments = """
+            Enable Syncmatica protocol support""")
+    public static boolean enabled = false;
+    @ConfigInfo(name = "useQuota", comments = """
+            Is there a limit on the size of projection files?""")
+    public static boolean useQuota = false;
+    @ConfigInfo(name = "quota-Limit", comments = """
+            Maximum Projection File Size (in bytes)""")
+    public static int quotaLimit = 40000000;
+
+    public void onLoaded(CommentedFileConfig configInstance, @Nullable Set<Exception> e) {
+        SyncmaticaProtocol.init(enabled);
+    }
+}

lophine-server/src/main/java/fun/bm/lophine/config/modules/function/protocol/XaeroMapProtocolConfig.java

@@ -0,0 +1,17 @@
+package fun.bm.lophine.config.modules.function.protocol;
+
+import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
+import me.earthme.luminol.config.flags.ConfigInfo;
+import me.earthme.luminol.enums.EnumConfigCategory;
+
+import java.util.Random;
+
+@ConfigClassInfo(category = EnumConfigCategory.FUNCTION, name = "xaero-map", directory = {"protocol"})
+public class XaeroMapProtocolConfig implements IConfigModule {
+    @ConfigInfo(name = "enabled", comments = """
+            Enable Xaero World Map Protocol Support""")
+    public static boolean enabled = false;
+    @ConfigInfo(name = "xaeroMapServerID")
+    public static int xaeroMapServerID = new Random().nextInt();
+}

lophine-server/src/main/java/fun/bm/lophine/config/modules/misc/ItemEntityConfig.java

@@ -0,0 +1,16 @@
+package fun.bm.lophine.config.modules.misc;
+
+import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
+import me.earthme.luminol.config.flags.ConfigInfo;
+import me.earthme.luminol.enums.EnumConfigCategory;
+
+@ConfigClassInfo(category = EnumConfigCategory.MISC, name = "item-entity")
+public class ItemEntityConfig implements IConfigModule {
+    @ConfigInfo(name = "follow-tick-sequence-merge", comments = """
+            Due to Paper's modification of the merge radius,
+            when the merge radius is large and stacks containing many items get stuck in an unexpected position,
+            individual items may never reach their destination.
+            This configuration option is added to fix this behavior.""")
+    public static boolean followTickSequenceMerge = false;
+}

lophine-server/src/main/java/fun/bm/lophine/config/modules/removed/RemovedConfig.java

@@ -8,6 +8,7 @@ import me.earthme.luminol.enums.EnumConfigCategory;
 
 @ConfigClassInfo(category = EnumConfigCategory.REMOVED, name = "removed_config")
 public class RemovedConfig implements IConfigModule {
+    @TransformedConfig(name = "datapack_command_enabled", directory = {"experiment", "command"}, transform = false)
     @TransformedConfig(name = "disable_end_crystal_check", directory = {"fixes", "end_crystal"}, transform = false)
     @TransformedConfig(name = "disable_end_crystal_check", directory = {"misc", "end_crystal"}, transform = false)
     @TransformedConfig(name = "allow_skip_cooldown", directory = {"misc", "revert_raid_changes"}, transform = false)

lophine-server/src/main/java/fun/bm/lophine/enums/EnumAlternativePlaceType.java

@@ -0,0 +1,8 @@
+package fun.bm.lophine.enums;
+
+public enum EnumAlternativePlaceType {
+    NONE,
+    CARPET,
+    CARPET_FIX,
+    LITEMATICA
+}

lophine-server/src/main/java/fun/bm/lophine/utils/ServerI18nUtil.java

@@ -6,9 +6,9 @@ import com.google.gson.JsonParser;
 import com.google.gson.JsonSyntaxException;
 import com.mojang.logging.LogUtils;
 import fun.bm.lophine.config.modules.function.LanguageConfig;
+import io.papermc.paper.ServerBuildInfo;
 import me.earthme.luminol.config.ConfigManager;
 import me.earthme.luminol.config.ConfigsInstance;
-import net.minecraft.DetectedVersion;
 import net.minecraft.locale.DeprecatedTranslationsInfo;
 import net.minecraft.locale.Language;
 import net.minecraft.network.chat.FormattedText;
@@ -41,7 +41,7 @@ import java.util.function.BiConsumer;
  */
 public class ServerI18nUtil {
     private static final Logger logger = LogUtils.getClassLogger();
-    private static final String VERSION = DetectedVersion.BUILT_IN.name();
+    private static final String VERSION = ServerBuildInfo.buildInfo().minecraftVersionId();
     private static final String BASE_PATH = "cache/lophine/" + VERSION + "/";
     private static final String defaultLophineLangPath = "/assets/lophine/lang/en_us.json";
     private static final String manifestUrl = "https://launchermeta.mojang.com/mc/game/version_manifest.json";

lophine-server/src/main/java/org/leavesmc/leaves/bot/BotList.java

@@ -24,6 +24,7 @@ import com.mojang.authlib.properties.Property;
 import com.mojang.logging.LogUtils;
 import fun.bm.lophine.config.modules.function.FakeplayerConfig;
 import io.papermc.paper.adventure.PaperAdventure;
+import io.papermc.paper.threadedregions.RegionizedServer;
 import net.kyori.adventure.text.format.NamedTextColor;
 import net.kyori.adventure.text.format.Style;
 import net.minecraft.nbt.CompoundTag;
@@ -173,31 +174,14 @@ public class BotList {
 
         bot.supressTrackerForLogin = true;
 
-        io.papermc.paper.threadedregions.RegionizedServer.getInstance().taskQueue.queueTickTaskQueue(
-                world, net.minecraft.util.Mth.floor(location.getX()) >> 4, net.minecraft.util.Mth.floor(location.getZ()) >> 4,
-                () -> {
-                    world.addNewPlayer(bot);
-
-                    BotJoinEvent event1 = new BotJoinEvent(bot.getBukkitEntity(), PaperAdventure.asAdventure(Component.translatable("multiplayer.player.joined", bot.getDisplayName())).style(Style.style(NamedTextColor.YELLOW)));
-                    this.server.server.getPluginManager().callEvent(event1);
-
-                    net.kyori.adventure.text.Component joinMessage = event1.joinMessage();
-                    if (joinMessage != null && !joinMessage.equals(net.kyori.adventure.text.Component.empty())) {
-                        this.server.getPlayerList().broadcastSystemMessage(PaperAdventure.asVanilla(joinMessage), false);
-                    }
-
-                    bot.renderInfo();
-                    bot.supressTrackerForLogin = false;
-
-                    bot.level().getChunkSource().chunkMap.addEntity(bot);
-                    bot.renderData();
-                    bot.initInventoryMenu();
-                    botsNameByWorldUuid
-                            .computeIfAbsent(bot.level().uuid.toString(), (k) -> new HashSet<>())
-                            .add(bot.getBukkitEntity().getRealName());
-                    BotList.LOGGER.info("{}[{}] logged in with entity id {} at ([{}]{}, {}, {})", bot.getName().getString(), "Local", bot.getId(), bot.level().serverLevelData.getLevelName(), bot.getX(), bot.getY(), bot.getZ());
-                },
-                ca.spottedleaf.concurrentutil.util.Priority.HIGHER);
+        if (TickThread.isTickThreadFor(world, net.minecraft.util.Mth.floor(location.getX()) >> 4, net.minecraft.util.Mth.floor(location.getZ()) >> 4)) {
+            summonBot(bot, world);
+        } else {
+            RegionizedServer.getInstance().taskQueue.queueTickTaskQueue(
+                    world, net.minecraft.util.Mth.floor(location.getX()) >> 4, net.minecraft.util.Mth.floor(location.getZ()) >> 4,
+                    () -> summonBot(bot, world),
+                    ca.spottedleaf.concurrentutil.util.Priority.HIGHER);
+        }
         optional.ifPresent(nbt -> {
             bot.loadAndSpawnEnderPearls(nbt);
             bot.loadAndSpawnParentVehicle(nbt);
@@ -205,6 +189,42 @@ public class BotList {
         return bot;
     }
 
+    private ServerBot summonBot(ServerBot bot, ServerLevel world) {
+        world.addNewPlayer(bot);
+
+        BotJoinEvent event1 = new BotJoinEvent(bot.getBukkitEntity(), PaperAdventure.asAdventure(Component.translatable("multiplayer.player.joined", bot.getDisplayName())).style(Style.style(NamedTextColor.YELLOW)));
+        this.server.server.getPluginManager().callEvent(event1);
+
+        net.kyori.adventure.text.Component joinMessage = event1.joinMessage();
+        if (joinMessage != null && !joinMessage.equals(net.kyori.adventure.text.Component.empty())) {
+            this.server.getPlayerList().broadcastSystemMessage(PaperAdventure.asVanilla(joinMessage), false);
+        }
+
+        bot.renderInfo();
+        bot.supressTrackerForLogin = false;
+
+        bot.level().getChunkSource().chunkMap.addEntity(bot);
+        bot.renderData();
+        bot.initInventoryMenu();
+        botsNameByWorldUuid
+                .computeIfAbsent(bot.level().uuid.toString(), (k) -> new HashSet<>())
+                .add(bot.getBukkitEntity().getRealName());
+        BotList.LOGGER.info("{}[{}] logged in with entity id {} at ([{}]{}, {}, {})", bot.getName().getString(), "Local", bot.getId(), bot.level().serverLevelData.getLevelName(), bot.getX(), bot.getY(), bot.getZ());
+        return bot;
+    }
+
+    /*
+     * return true if async
+     */
+    public boolean removeBot(@NotNull ServerBot bot, @NotNull BotRemoveEvent.RemoveReason reason, @Nullable CommandSender remover, boolean saved, boolean async) {
+        if (async && !TickThread.isTickThreadFor(bot.level(), bot.getX(), bot.getZ())) {
+            bot.getBukkitEntity().taskScheduler.schedule((Entity unused) -> this.removeBot(bot, reason, remover, saved), null, 1L);
+            return true;
+        }
+        this.removeBot(bot, reason, remover, saved);
+        return false;
+    }
+
     public boolean removeBot(@NotNull ServerBot bot, @NotNull BotRemoveEvent.RemoveReason reason, @Nullable CommandSender remover, boolean saved) {
         return this.removeBot(bot, reason, remover, saved, this.dataStorage);
     }
@@ -296,24 +316,36 @@ public class BotList {
         AtomicInteger received = new AtomicInteger();
         for (ServerBot bot : this.bots) {
             bot.resume = FakeplayerConfig.canResident;
-            if (TickThread.isTickThreadFor(bot)) {
+            if (TickThread.isTickThreadFor(bot.level(), bot.getX(), bot.getZ())) {
                 this.removeBot(bot, BotRemoveEvent.RemoveReason.INTERNAL, null, FakeplayerConfig.canResident);
             } else {
                 finished = false;
                 check.getAndIncrement();
-                bot.getBukkitEntity().taskScheduler.schedule((Entity unused) -> {
-                    BotList.this.removeBot(bot, BotRemoveEvent.RemoveReason.INTERNAL, null, FakeplayerConfig.canResident);
-                    received.getAndIncrement();
-                    if (received.get() >= check.get()) {
-                        this.forceShutdown = true;
-                        MinecraftServer.getServer().stopServer();
-                    }
-                }, null, 1L);
+                this.removeBot(bot, check, received, new AtomicInteger());
             }
         }
         return finished;
     }
 
+    private void removeBot(ServerBot bot, AtomicInteger check, AtomicInteger received, AtomicInteger counter) {
+        bot.getBukkitEntity().taskScheduler.schedule((Entity unused) -> {
+            if (counter.get() >= 20) {
+                BotList.LOGGER.info("Try to remove bot {} located in [{}]{},{},{} too many times!", bot.getName().getString(), bot.level().serverLevelData.getLevelName(), bot.getX(), bot.getY(), bot.getZ());
+            }
+            counter.getAndIncrement();
+            try {
+                this.removeBot(bot, BotRemoveEvent.RemoveReason.INTERNAL, null, FakeplayerConfig.canResident);
+                received.getAndIncrement();
+            } catch (Exception e) {
+                this.removeBot(bot, check, received, counter);
+            }
+            if (received.get() >= check.get()) {
+                this.forceShutdown = true;
+                MinecraftServer.getServer().stopServer();
+            }
+        }, null, 1L);
+    }
+
     public void loadBotInfo() {
         if (!FakeplayerConfig.enable || !FakeplayerConfig.canResident) {
             return;

lophine-server/src/main/java/org/leavesmc/leaves/bot/ServerBot.java

@@ -154,7 +154,7 @@ public class ServerBot extends ServerPlayer {
             this.notSleepTicks++;
         }
 
-        if (FakeplayerConfig.regenAmount > 0.0 && getServer().checkTickCount(20)) {
+        if (FakeplayerConfig.regenAmount > 0.0 && this.tickCount % 20 == 0) {
             float regenAmount = (float) (FakeplayerConfig.regenAmount * 20);
             this.setHealth(Math.min(this.getHealth() + regenAmount, this.getMaxHealth()));
         }
@@ -464,10 +464,10 @@ public class ServerBot extends ServerPlayer {
     }
 
     public void sendFakeData(ServerPlayerConnection playerConnection, boolean login) {
-        ChunkMap.TrackedEntity entityTracker = this.level().getChunkSource().chunkMap.entityMap.get(this.getId());
+        ChunkMap.TrackedEntity entityTracker = this.moonrise$getTrackedEntity();
 
         if (entityTracker == null) {
-            LOGGER.warn("Fakeplayer cant get entity tracker for " + this.getId());
+            LOGGER.warn("Fakeplayer cant get entity tracker for {}", this.getId());
             return;
         }
 

lophine-server/src/main/java/org/leavesmc/leaves/command/bot/subcommands/RemoveCommand.java

@@ -56,9 +56,7 @@ public class RemoveCommand extends BotSubcommand {
 
     private static boolean removeBot(@NotNull ServerBot bot, @Nullable CommandSender sender, boolean taskQueue) {
         if (taskQueue) {
-            bot.getBukkitEntity().taskScheduler.schedule((LivingEntity nmsEntity) -> {
-                removeBotOrigin(bot, sender);
-            }, null, 1L);
+            bot.getBukkitEntity().taskScheduler.schedule((LivingEntity nmsEntity) -> removeBotOrigin(bot, sender), null, 1L);
         } else {
             return removeBotOrigin(bot, sender);
         }

lophine-server/src/main/java/org/leavesmc/leaves/command/bot/subcommands/SaveCommand.java

@@ -21,6 +21,7 @@ import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import fun.bm.lophine.config.modules.function.FakeplayerConfig;
 import net.kyori.adventure.text.format.NamedTextColor;
 import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.world.entity.LivingEntity;
 import org.bukkit.command.CommandSender;
 import org.jetbrains.annotations.NotNull;
 import org.leavesmc.leaves.bot.BotList;
@@ -55,8 +56,24 @@ public class SaveCommand extends BotSubcommand {
 
         @Override
         protected boolean execute(@NotNull CommandContext context) throws CommandSyntaxException {
-            ServerBot bot = context.getCustomArgument(BotArgument.class);
-            CommandSender sender = context.getSender();
+            save(context.getCustomArgument(BotArgument.class), context.getSender());
+            return true;
+        }
+
+        private boolean save(ServerBot bot, CommandSender sender) {
+            return save(bot, sender, true);
+        }
+
+        private boolean save(ServerBot bot, CommandSender sender, boolean taskQueue) {
+            if (taskQueue) {
+                bot.getBukkitEntity().taskScheduler.schedule((LivingEntity nmsEntity) -> saveOrigin(bot, sender), null, 1L);
+            } else {
+                saveOrigin(bot, sender);
+            }
+            return true;
+        }
+
+        private boolean saveOrigin(ServerBot bot, CommandSender sender) {
             BotList botList = BotList.INSTANCE;
 
             boolean success = botList.removeBot(bot, BotRemoveEvent.RemoveReason.COMMAND, sender, true);

lophine-server/src/main/java/org/leavesmc/leaves/entity/photographer/CraftPhotographer.java

@@ -0,0 +1,90 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.entity.photographer;
+
+import net.minecraft.server.level.ServerPlayer;
+import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.craftbukkit.entity.CraftPlayer;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.leavesmc.leaves.replay.ServerPhotographer;
+
+import java.io.File;
+
+public class CraftPhotographer extends CraftPlayer implements Photographer {
+
+    public CraftPhotographer(CraftServer server, ServerPhotographer entity) {
+        super(server, entity);
+    }
+
+    @Override
+    public void stopRecording() {
+        this.stopRecording(true);
+    }
+
+    @Override
+    public void stopRecording(boolean async) {
+        this.stopRecording(async, true);
+    }
+
+    @Override
+    public void stopRecording(boolean async, boolean save) {
+        this.getHandle().remove(async, save);
+    }
+
+    @Override
+    public void pauseRecording() {
+        this.getHandle().pauseRecording();
+    }
+
+    @Override
+    public void resumeRecording() {
+        this.getHandle().resumeRecording();
+    }
+
+    @Override
+    public void setRecordFile(@NotNull File file) {
+        this.getHandle().setSaveFile(file);
+    }
+
+    @Override
+    public void setFollowPlayer(@Nullable Player player) {
+        ServerPlayer serverPlayer = player != null ? ((CraftPlayer) player).getHandle() : null;
+        this.getHandle().setFollowPlayer(serverPlayer);
+    }
+
+    @Override
+    public @NotNull String getId() {
+        return this.getHandle().createState.id;
+    }
+
+    @Override
+    public ServerPhotographer getHandle() {
+        return (ServerPhotographer) entity;
+    }
+
+    public void setHandle(final ServerPhotographer entity) {
+        super.setHandle(entity);
+    }
+
+    @Override
+    public String toString() {
+        return "CraftPhotographer{" + "name=" + getName() + '}';
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/entity/photographer/CraftPhotographerManager.java

@@ -0,0 +1,99 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.entity.photographer;
+
+import com.google.common.collect.Lists;
+import org.bukkit.Location;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.leavesmc.leaves.replay.BukkitRecorderOption;
+import org.leavesmc.leaves.replay.RecorderOption;
+import org.leavesmc.leaves.replay.ServerPhotographer;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.UUID;
+
+public class CraftPhotographerManager implements PhotographerManager {
+
+    private final Collection<Photographer> photographerViews = Collections.unmodifiableList(Lists.transform(ServerPhotographer.getPhotographers(), ServerPhotographer::getBukkitPlayer));
+
+    @Override
+    public @Nullable Photographer getPhotographer(@NotNull UUID uuid) {
+        ServerPhotographer photographer = ServerPhotographer.getPhotographer(uuid);
+        if (photographer != null) {
+            return photographer.getBukkitPlayer();
+        }
+        return null;
+    }
+
+    @Override
+    public @Nullable Photographer getPhotographer(@NotNull String id) {
+        ServerPhotographer photographer = ServerPhotographer.getPhotographer(id);
+        if (photographer != null) {
+            return photographer.getBukkitPlayer();
+        }
+        return null;
+    }
+
+    @Override
+    public @Nullable Photographer createPhotographer(@NotNull String id, @NotNull Location location) {
+        ServerPhotographer photographer = new ServerPhotographer.PhotographerCreateState(location, id, RecorderOption.createDefaultOption()).createSync();
+        if (photographer != null) {
+            return photographer.getBukkitPlayer();
+        }
+        return null;
+    }
+
+    @Override
+    public @Nullable Photographer createPhotographer(@NotNull String id, @NotNull Location location, @NotNull BukkitRecorderOption recorderOption) {
+        ServerPhotographer photographer = new ServerPhotographer.PhotographerCreateState(location, id, RecorderOption.createFromBukkit(recorderOption)).createSync();
+        if (photographer != null) {
+            return photographer.getBukkitPlayer();
+        }
+        return null;
+    }
+
+    @Override
+    public void removePhotographer(@NotNull String id) {
+        ServerPhotographer photographer = ServerPhotographer.getPhotographer(id);
+        if (photographer != null) {
+            photographer.remove(true);
+        }
+    }
+
+    @Override
+    public void removePhotographer(@NotNull UUID uuid) {
+        ServerPhotographer photographer = ServerPhotographer.getPhotographer(uuid);
+        if (photographer != null) {
+            photographer.remove(true);
+        }
+    }
+
+    @Override
+    public void removeAllPhotographers() {
+        for (ServerPhotographer photographer : ServerPhotographer.getPhotographers()) {
+            photographer.remove(true);
+        }
+    }
+
+    @Override
+    public Collection<Photographer> getPhotographers() {
+        return photographerViews;
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/AppleSkinProtocol.java

@@ -0,0 +1,145 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol;
+
+import fun.bm.lophine.config.modules.function.protocol.AppleSkinProtocolConfig;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.food.FoodData;
+import net.minecraft.world.level.GameRules;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.protocol.core.Context;
+import org.leavesmc.leaves.protocol.core.LeavesProtocol;
+import org.leavesmc.leaves.protocol.core.ProtocolHandler;
+import org.leavesmc.leaves.protocol.core.ProtocolUtils;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+@LeavesProtocol.Register(namespace = "appleskin")
+public class AppleSkinProtocol implements LeavesProtocol {
+
+    public static final String PROTOCOL_ID = "appleskin";
+
+    private static final ResourceLocation SATURATION_KEY = id("saturation");
+    private static final ResourceLocation EXHAUSTION_KEY = id("exhaustion");
+    private static final ResourceLocation NATURAL_REGENERATION_KEY = id("natural_regeneration");
+
+    private static final float MINIMUM_EXHAUSTION_CHANGE_THRESHOLD = 0.01F;
+
+    private static final Map<ServerPlayer, Float> previousSaturationLevels = new ConcurrentHashMap<>();
+    private static final Map<ServerPlayer, Float> previousExhaustionLevels = new ConcurrentHashMap<>();
+    private static final Map<ServerPlayer, Boolean> previousNaturalRegeneration = new ConcurrentHashMap<>();
+
+    private static final Map<UUID, Set<String>> subscribedChannels = new ConcurrentHashMap<>();
+
+    @Contract("_ -> new")
+    public static ResourceLocation id(String path) {
+        return ResourceLocation.tryBuild(PROTOCOL_ID, path);
+    }
+
+    @ProtocolHandler.PlayerJoin
+    public static void onPlayerLoggedIn(@NotNull ServerPlayer player) {
+        resetPlayerData(player);
+    }
+
+    @ProtocolHandler.PlayerLeave
+    public static void onPlayerLoggedOut(@NotNull ServerPlayer player) {
+        subscribedChannels.remove(player.getUUID());
+        resetPlayerData(player);
+    }
+
+    @ProtocolHandler.MinecraftRegister(onlyNamespace = true)
+    public static void onPlayerSubscribed(@NotNull Context context, ResourceLocation id) {
+        subscribedChannels.computeIfAbsent(context.profile().getId(), k -> new HashSet<>()).add(id.getPath());
+    }
+
+    @ProtocolHandler.Ticker
+    public static void tick() {
+        for (Map.Entry<UUID, Set<String>> entry : subscribedChannels.entrySet()) {
+            ServerPlayer player = MinecraftServer.getServer().getPlayerList().getPlayer(entry.getKey());
+            if (player == null) {
+                continue;
+            }
+
+            FoodData data = player.getFoodData();
+            for (String channel : entry.getValue()) {
+                switch (channel) {
+                    case "saturation" -> {
+                        float saturation = data.getSaturationLevel();
+                        Float previousSaturation = previousSaturationLevels.get(player);
+                        if (previousSaturation == null || saturation != previousSaturation) {
+                            ProtocolUtils.sendBytebufPacket(player, SATURATION_KEY, buf -> buf.writeFloat(saturation));
+                            previousSaturationLevels.put(player, saturation);
+                        }
+                    }
+
+                    case "exhaustion" -> {
+                        float exhaustion = data.exhaustionLevel;
+                        Float previousExhaustion = previousExhaustionLevels.get(player);
+                        if (previousExhaustion == null || Math.abs(exhaustion - previousExhaustion) >= MINIMUM_EXHAUSTION_CHANGE_THRESHOLD) {
+                            ProtocolUtils.sendBytebufPacket(player, EXHAUSTION_KEY, buf -> buf.writeFloat(exhaustion));
+                            previousExhaustionLevels.put(player, exhaustion);
+                        }
+                    }
+
+                    case "natural_regeneration" -> {
+                        boolean regeneration = player.level().getGameRules().getBoolean(GameRules.RULE_NATURAL_REGENERATION);
+                        Boolean previousRegeneration = previousNaturalRegeneration.get(player);
+                        if (previousRegeneration == null || regeneration != previousRegeneration) {
+                            ProtocolUtils.sendBytebufPacket(player, NATURAL_REGENERATION_KEY, buf -> buf.writeBoolean(regeneration));
+                            previousNaturalRegeneration.put(player, regeneration);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @ProtocolHandler.ReloadServer
+    public static void onServerReload() {
+        disableAllPlayer();
+    }
+
+    public static void disableAllPlayer() {
+        for (ServerPlayer player : MinecraftServer.getServer().getPlayerList().getPlayers()) {
+            onPlayerLoggedOut(player);
+        }
+    }
+
+    private static void resetPlayerData(@NotNull ServerPlayer player) {
+        previousExhaustionLevels.remove(player);
+        previousSaturationLevels.remove(player);
+        previousNaturalRegeneration.remove(player);
+    }
+
+    @Override
+    public int tickerInterval(String tickerID) {
+        return AppleSkinProtocolConfig.syncTickInterval;
+    }
+
+    @Override
+    public boolean isActive() {
+        return AppleSkinProtocolConfig.enabled;
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/BBORProtocol.java

@@ -0,0 +1,246 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol;
+
+import fun.bm.lophine.config.modules.function.protocol.BBORProtocolConfig;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Registry;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.level.levelgen.structure.BoundingBox;
+import net.minecraft.world.level.levelgen.structure.Structure;
+import net.minecraft.world.level.levelgen.structure.StructurePiece;
+import net.minecraft.world.level.levelgen.structure.StructureStart;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.protocol.core.LeavesProtocol;
+import org.leavesmc.leaves.protocol.core.ProtocolHandler;
+import org.leavesmc.leaves.protocol.core.ProtocolUtils;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+@LeavesProtocol.Register(namespace = "bbor")
+public class BBORProtocol implements LeavesProtocol {
+
+    public static final String PROTOCOL_ID = "bbor";
+
+    // send
+    private static final ResourceLocation INITIALIZE_CLIENT = id("initialize");
+    private static final ResourceLocation ADD_BOUNDING_BOX = id("add_bounding_box_v2");
+    private static final ResourceLocation STRUCTURE_LIST_SYNC = id("structure_list_sync_v1");
+    // call
+    private static final Map<Integer, ServerPlayer> players = new ConcurrentHashMap<>();
+    private static final Map<Integer, Set<BBoundingBox>> playerBoundingBoxesCache = new ConcurrentHashMap<>();
+    private static final Map<ResourceLocation, Map<BBoundingBox, Set<BBoundingBox>>> dimensionCache = new ConcurrentHashMap<>();
+
+    private static boolean initialized = false;
+
+    @Contract("_ -> new")
+    public static ResourceLocation id(String path) {
+        return ResourceLocation.tryBuild(PROTOCOL_ID, path);
+    }
+
+    @ProtocolHandler.Ticker
+    public static void tick() {
+        for (var playerEntry : players.entrySet()) {
+            sendBoundingToPlayer(playerEntry.getKey(), playerEntry.getValue());
+        }
+    }
+
+    @ProtocolHandler.ReloadServer
+    public static void onServerReload() {
+        if (BBORProtocolConfig.enabled) {
+            initAllPlayer();
+        } else {
+            loggedOutAllPlayer();
+        }
+    }
+
+    @ProtocolHandler.PlayerJoin
+    public static void onPlayerLoggedIn(@NotNull ServerPlayer player) {
+        ServerLevel overworld = MinecraftServer.getServer().overworld();
+        ProtocolUtils.sendBytebufPacket(player, INITIALIZE_CLIENT, buf -> {
+            buf.writeLong(overworld.getSeed());
+            buf.writeInt(overworld.levelData.getSpawnPos().getX());
+            buf.writeInt(overworld.levelData.getSpawnPos().getZ());
+        });
+        sendStructureList(player);
+    }
+
+    @ProtocolHandler.PlayerLeave
+    public static void onPlayerLoggedOut(@NotNull ServerPlayer player) {
+        players.remove(player.getId());
+        playerBoundingBoxesCache.remove(player.getId());
+    }
+
+    @ProtocolHandler.BytebufReceiver(key = "subscribe")
+    public static void onPlayerSubscribed(@NotNull ServerPlayer player, FriendlyByteBuf buf) {
+        players.put(player.getId(), player);
+        sendBoundingToPlayer(player.getId(), player);
+    }
+
+    @ProtocolHandler.ReloadDataPack
+    public static void onDataPackReload() {
+        players.values().forEach(BBORProtocol::sendStructureList);
+    }
+
+    public static void onChunkLoaded(@NotNull LevelChunk chunk) {
+        Map<String, StructureStart> structures = new HashMap<>();
+        final Registry<Structure> structureFeatureRegistry = chunk.getLevel().registryAccess().lookupOrThrow(Registries.STRUCTURE);
+        for (var es : chunk.getAllStarts().entrySet()) {
+            final var optional = structureFeatureRegistry.getResourceKey(es.getKey());
+            optional.ifPresent(key -> structures.put(key.location().toString(), es.getValue()));
+        }
+        if (!structures.isEmpty()) {
+            onStructuresLoaded(chunk.getLevel().dimension().location(), structures);
+        }
+    }
+
+    public static void onStructuresLoaded(@NotNull ResourceLocation dimensionID, @NotNull Map<String, StructureStart> structures) {
+        Map<BBoundingBox, Set<BBoundingBox>> cache = getOrCreateCache(dimensionID);
+        for (var entry : structures.entrySet()) {
+            StructureStart structureStart = entry.getValue();
+            if (structureStart == null || !structureStart.isValid()) {
+                continue;
+            }
+
+            String type = "structure:" + entry.getKey();
+            BoundingBox bb = structureStart.getBoundingBox();
+            BBoundingBox boundingBox = buildStructure(bb, type);
+            if (cache.containsKey(boundingBox)) {
+                continue;
+            }
+
+            Set<BBoundingBox> structureBoundingBoxes = new HashSet<>();
+            if (!structureStart.getPieces().isEmpty()) {
+                for (StructurePiece structureComponent : structureStart.getPieces()) {
+                    structureBoundingBoxes.add(buildStructure(structureComponent.getBoundingBox(), type));
+                }
+                cache.put(boundingBox, structureBoundingBoxes);
+            }
+        }
+    }
+
+    private static @NotNull BBoundingBox buildStructure(@NotNull BoundingBox bb, String type) {
+        BlockPos min = new BlockPos(bb.minX(), bb.minY(), bb.minZ());
+        BlockPos max = new BlockPos(bb.maxX(), bb.maxY(), bb.maxZ());
+        return new BBoundingBox(type, min, max);
+    }
+
+    private static void sendStructureList(@NotNull ServerPlayer player) {
+        final Registry<Structure> structureRegistry = MinecraftServer.getServer().registryAccess().lookupOrThrow(Registries.STRUCTURE);
+        final Set<String> structureIds = structureRegistry.entrySet().stream()
+                .map(e -> e.getKey().location().toString()).collect(Collectors.toSet());
+        ProtocolUtils.sendBytebufPacket(player, STRUCTURE_LIST_SYNC, buf -> {
+            buf.writeVarInt(structureIds.size());
+            structureIds.forEach(buf::writeUtf);
+        });
+    }
+
+    private static void sendBoundingToPlayer(int id, ServerPlayer player) {
+        for (var entry : dimensionCache.entrySet()) {
+            if (entry.getValue() == null) {
+                return;
+            }
+
+            Set<BBoundingBox> playerBoundingBoxes = playerBoundingBoxesCache.computeIfAbsent(id, k -> new HashSet<>());
+            Map<BBoundingBox, Set<BBoundingBox>> boundingBoxMap = entry.getValue();
+            for (BBoundingBox key : boundingBoxMap.keySet()) {
+                if (playerBoundingBoxes.contains(key)) {
+                    continue;
+                }
+
+                Set<BBoundingBox> boundingBoxes = boundingBoxMap.get(key);
+                ProtocolUtils.sendBytebufPacket(player, ADD_BOUNDING_BOX, buf -> {
+                    buf.writeResourceLocation(entry.getKey());
+                    key.serialize(buf);
+                    if (boundingBoxes != null && boundingBoxes.size() > 1) {
+                        for (BBoundingBox box : boundingBoxes) {
+                            box.serialize(buf);
+                        }
+                    }
+                });
+                playerBoundingBoxes.add(key);
+            }
+        }
+    }
+
+    public static void initAllPlayer() {
+        for (ServerPlayer player : MinecraftServer.getServer().getPlayerList().getPlayers()) {
+            onPlayerLoggedIn(player);
+        }
+        initialized = true;
+    }
+
+    public static void loggedOutAllPlayer() {
+        players.clear();
+        playerBoundingBoxesCache.clear();
+        for (var cache : dimensionCache.values()) {
+            cache.clear();
+        }
+        dimensionCache.clear();
+    }
+
+    private static Map<BBoundingBox, Set<BBoundingBox>> getOrCreateCache(ResourceLocation dimensionId) {
+        return dimensionCache.computeIfAbsent(dimensionId, dt -> new ConcurrentHashMap<>());
+    }
+
+    @Override
+    public boolean isActive() {
+        boolean active = BBORProtocolConfig.enabled;
+        if (!active && initialized) {
+            initialized = false;
+            loggedOutAllPlayer();
+        }
+        return active;
+    }
+
+    private record BBoundingBox(String type, BlockPos min, BlockPos max) {
+
+        private static int combineHashCodes(int @NotNull ... hashCodes) {
+            final int prime = 31;
+            int result = 0;
+            for (int hashCode : hashCodes) {
+                result = prime * result + hashCode;
+            }
+            return result;
+        }
+
+        public void serialize(@NotNull FriendlyByteBuf buf) {
+            buf.writeChar('S');
+            buf.writeInt(type.hashCode());
+            buf.writeVarInt(min.getX()).writeVarInt(min.getY()).writeVarInt(min.getZ());
+            buf.writeVarInt(max.getX()).writeVarInt(max.getY()).writeVarInt(max.getZ());
+        }
+
+        @Override
+        public int hashCode() {
+            return combineHashCodes(min.hashCode(), max.hashCode());
+        }
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/CarpetAlternativeBlockPlacement.java

@@ -0,0 +1,170 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.util.Mth;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.context.BlockPlaceContext;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.*;
+import net.minecraft.world.level.block.piston.PistonBaseBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.*;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.NotNull;
+
+import javax.annotation.Nullable;
+import java.util.Objects;
+
+public class CarpetAlternativeBlockPlacement {
+
+    @Nullable
+    public static BlockState alternativeBlockPlacement(@NotNull Block block, @NotNull BlockPlaceContext context) {
+        Vec3 hitPos = context.getClickLocation();
+        BlockPos blockPos = context.getClickedPos();
+        double relativeHitX = hitPos.x - blockPos.getX();
+        BlockState state = block.getStateForPlacement(context);
+        Player player = context.getPlayer();
+
+        if (relativeHitX < 2 || state == null || player == null) {
+            return null;
+        }
+
+        EnumProperty<Direction> directionProp = getFirstDirectionProperty(state);
+        int protocolValue = ((int) relativeHitX - 2) / 2;
+
+        if (directionProp != null) {
+            Direction origFacing = state.getValue(directionProp);
+            Direction facing = origFacing;
+            int facingIndex = protocolValue & 0xF;
+
+            if (facingIndex == 6) {
+                facing = facing.getOpposite();
+            } else if (facingIndex <= 5) {
+                facing = Direction.from3DDataValue(facingIndex);
+            }
+
+            if (!directionProp.getPossibleValues().contains(facing)) {
+                facing = player.getDirection().getOpposite();
+            }
+
+            if (facing != origFacing && directionProp.getPossibleValues().contains(facing)) {
+                if (state.getBlock() instanceof BedBlock) {
+                    BlockPos headPos = blockPos.relative(facing);
+
+                    if (!context.getLevel().getBlockState(headPos).canBeReplaced(context)) {
+                        return null;
+                    }
+                }
+
+                state = state.setValue(directionProp, facing);
+            }
+        } else if (state.hasProperty(BlockStateProperties.AXIS)) {
+            Direction.Axis axis = Direction.Axis.VALUES[protocolValue % 3];
+            state = state.setValue(BlockStateProperties.AXIS, axis);
+        }
+
+        protocolValue &= 0xFFFFFFF0;
+
+        if (protocolValue >= 16) {
+            if (block instanceof RepeaterBlock) {
+                Integer delay = (protocolValue / 16);
+
+                if (RepeaterBlock.DELAY.getPossibleValues().contains(delay)) {
+                    state = state.setValue(RepeaterBlock.DELAY, delay);
+                }
+            } else if (protocolValue == 16) {
+                if (block instanceof ComparatorBlock) {
+                    state = state.setValue(ComparatorBlock.MODE, ComparatorMode.SUBTRACT);
+                } else if (state.hasProperty(BlockStateProperties.HALF) && state.getValue(BlockStateProperties.HALF) == Half.BOTTOM) {
+                    state = state.setValue(BlockStateProperties.HALF, Half.TOP);
+                } else if (state.hasProperty(BlockStateProperties.SLAB_TYPE) && state.getValue(BlockStateProperties.SLAB_TYPE) == SlabType.BOTTOM) {
+                    state = state.setValue(BlockStateProperties.SLAB_TYPE, SlabType.TOP);
+                }
+            }
+        }
+
+        return state;
+    }
+
+    @Nullable
+    public static BlockState alternativeBlockPlacementFix(Block block, @NotNull BlockPlaceContext context) {
+        Direction facing;
+        Vec3 vec3d = context.getClickLocation();
+        BlockPos pos = context.getClickedPos();
+        double hitX = vec3d.x - pos.getX();
+        if (hitX < 2) {
+            return null;
+        }
+        int code = (int) (hitX - 2) / 2;
+        Player placer = Objects.requireNonNull(context.getPlayer());
+        Level world = context.getLevel();
+
+        if (block instanceof GlazedTerracottaBlock) {
+            facing = Direction.from3DDataValue(code);
+            if (facing == Direction.UP || facing == Direction.DOWN) {
+                facing = placer.getDirection().getOpposite();
+            }
+            return block.defaultBlockState().setValue(GlazedTerracottaBlock.FACING, facing);
+        } else if (block instanceof ObserverBlock) {
+            return block.defaultBlockState().setValue(ObserverBlock.FACING, Direction.from3DDataValue(code)).setValue(ObserverBlock.POWERED, true);
+        } else if (block instanceof RepeaterBlock) {
+            facing = Direction.from3DDataValue(code % 16);
+            if (facing == Direction.UP || facing == Direction.DOWN) {
+                facing = placer.getDirection().getOpposite();
+            }
+            return block.defaultBlockState().setValue(RepeaterBlock.FACING, facing).setValue(RepeaterBlock.DELAY, Mth.clamp(code / 16, 1, 4)).setValue(RepeaterBlock.LOCKED, Boolean.FALSE);
+        } else if (block instanceof TrapDoorBlock) {
+            facing = Direction.from3DDataValue(code % 16);
+            if (facing == Direction.UP || facing == Direction.DOWN) {
+                facing = placer.getDirection().getOpposite();
+            }
+            return block.defaultBlockState().setValue(TrapDoorBlock.FACING, facing).setValue(TrapDoorBlock.OPEN, Boolean.FALSE).setValue(TrapDoorBlock.HALF, (code >= 16) ? Half.TOP : Half.BOTTOM).setValue(TrapDoorBlock.OPEN, world.hasNeighborSignal(pos));
+        } else if (block instanceof ComparatorBlock) {
+            facing = Direction.from3DDataValue(code % 16);
+            if ((facing == Direction.UP) || (facing == Direction.DOWN)) {
+                facing = placer.getDirection().getOpposite();
+            }
+            ComparatorMode m = (hitX >= 16) ? ComparatorMode.SUBTRACT : ComparatorMode.COMPARE;
+            return block.defaultBlockState().setValue(ComparatorBlock.FACING, facing).setValue(ComparatorBlock.POWERED, Boolean.FALSE).setValue(ComparatorBlock.MODE, m);
+        } else if (block instanceof DispenserBlock) {
+            return block.defaultBlockState().setValue(DispenserBlock.FACING, Direction.from3DDataValue(code)).setValue(DispenserBlock.TRIGGERED, Boolean.FALSE);
+        } else if (block instanceof PistonBaseBlock) {
+            return block.defaultBlockState().setValue(DirectionalBlock.FACING, Direction.from3DDataValue(code)).setValue(PistonBaseBlock.EXTENDED, Boolean.FALSE);
+        } else if (block instanceof StairBlock) {
+            return Objects.requireNonNull(block.getStateForPlacement(context)).setValue(StairBlock.FACING, Direction.from3DDataValue(code % 16)).setValue(StairBlock.HALF, (hitX >= 16) ? Half.TOP : Half.BOTTOM);
+        }
+        return null;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Nullable
+    public static EnumProperty<Direction> getFirstDirectionProperty(@NotNull BlockState state) {
+        for (Property<?> prop : state.getProperties()) {
+            if (prop instanceof EnumProperty<?> enumProperty) {
+                if (enumProperty.getValueClass().equals(Direction.class)) {
+                    return (EnumProperty<Direction>) enumProperty;
+                }
+            }
+        }
+
+        return null;
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/LitematicaEasyPlaceProtocol.java

@@ -0,0 +1,243 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol;
+
+import com.google.common.collect.ImmutableSet;
+import com.mojang.logging.LogUtils;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.util.Mth;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.item.context.BlockPlaceContext;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.BedBlock;
+import net.minecraft.world.level.block.RepeaterBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+import net.minecraft.world.level.block.state.properties.Property;
+import net.minecraft.world.level.block.state.properties.SlabType;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.NotNull;
+import org.slf4j.Logger;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+public class LitematicaEasyPlaceProtocol {
+
+    private static final Logger LOGGER = LogUtils.getClassLogger();
+
+    public static final ImmutableSet<Property<?>> WHITELISTED_PROPERTIES = ImmutableSet.of(
+            BlockStateProperties.INVERTED,
+            BlockStateProperties.OPEN,
+            BlockStateProperties.BELL_ATTACHMENT,
+            BlockStateProperties.AXIS,
+            BlockStateProperties.HALF,
+            BlockStateProperties.ATTACH_FACE,
+            BlockStateProperties.CHEST_TYPE,
+            BlockStateProperties.MODE_COMPARATOR,
+            BlockStateProperties.DOOR_HINGE,
+            BlockStateProperties.FACING,
+            BlockStateProperties.FACING_HOPPER,
+            BlockStateProperties.HORIZONTAL_FACING,
+            BlockStateProperties.ORIENTATION,
+            BlockStateProperties.RAIL_SHAPE,
+            BlockStateProperties.RAIL_SHAPE_STRAIGHT,
+            BlockStateProperties.SLAB_TYPE,
+            BlockStateProperties.STAIRS_SHAPE,
+            BlockStateProperties.BITES,
+            BlockStateProperties.DELAY,
+            BlockStateProperties.NOTE,
+            BlockStateProperties.ROTATION_16
+    );
+
+    public static BlockState applyPlacementProtocol(BlockState state, BlockPlaceContext context) {
+        return applyPlacementProtocolV3(state, UseContext.from(context, context.getHand()));
+    }
+
+    @SuppressWarnings("unchecked")
+    @Nullable
+    private static <T extends Comparable<T>> BlockState applyPlacementProtocolV3(BlockState state, @NotNull UseContext context) {
+        int protocolValue = (int) (context.getHitVec().x - (double) context.getPos().getX()) - 2;
+        BlockState oldState = state;
+        if (protocolValue < 0) {
+            return oldState;
+        }
+
+        EnumProperty<Direction> property = CarpetAlternativeBlockPlacement.getFirstDirectionProperty(state);
+        if (property != null && property != BlockStateProperties.VERTICAL_DIRECTION) {
+            state = applyDirectionProperty(state, context, property, protocolValue);
+
+            if (state == null) {
+                return null;
+            }
+
+            if (state.canSurvive(context.getWorld(), context.getPos())) {
+                oldState = state;
+            } else {
+                state = oldState;
+            }
+
+            protocolValue >>>= 3;
+        }
+
+        protocolValue >>>= 1;
+
+        List<Property<?>> propList = new ArrayList<>(state.getBlock().getStateDefinition().getProperties());
+        propList.sort(Comparator.comparing(Property::getName));
+
+        try {
+            for (Property<?> p : propList) {
+                if (property != null && property.equals(p)) {
+                    continue;
+                }
+                if (!WHITELISTED_PROPERTIES.contains(p)) {
+                    continue;
+                }
+
+                Property<T> prop = (Property<T>) p;
+                List<T> list = new ArrayList<>(prop.getPossibleValues());
+                list.sort(Comparable::compareTo);
+
+                int requiredBits = Mth.log2(Mth.smallestEncompassingPowerOfTwo(list.size()));
+                int bitMask = ~(0xFFFFFFFF << requiredBits);
+                int valueIndex = protocolValue & bitMask;
+
+                if (valueIndex < list.size()) {
+                    T value = list.get(valueIndex);
+
+                    if (!state.getValue(prop).equals(value) && value != SlabType.DOUBLE) {
+                        state = state.setValue(prop, value);
+
+                        if (state.canSurvive(context.getWorld(), context.getPos())) {
+                            oldState = state;
+                        } else {
+                            state = oldState;
+                        }
+                    }
+
+                    protocolValue >>>= requiredBits;
+                }
+            }
+        } catch (Exception e) {
+            LOGGER.warn("Exception trying to apply placement protocol value", e);
+        }
+
+        if (state.getBlock() instanceof RepeaterBlock repeaterBlock) {
+            state = state.setValue(RepeaterBlock.LOCKED, repeaterBlock.isLocked(context.getWorld(), context.getPos(), state));
+        }
+
+        if (state.canSurvive(context.getWorld(), context.getPos())) {
+            return state;
+        } else {
+            return null;
+        }
+    }
+
+    private static BlockState applyDirectionProperty(BlockState state, UseContext context, EnumProperty<Direction> property, int protocolValue) {
+        Direction facingOrig = state.getValue(property);
+        Direction facing = facingOrig;
+        int decodedFacingIndex = (protocolValue & 0xF) >> 1;
+
+        if (decodedFacingIndex == 6) {
+            facing = facing.getOpposite();
+        } else if (decodedFacingIndex <= 5) {
+            facing = Direction.from3DDataValue(decodedFacingIndex);
+
+            if (!property.getPossibleValues().contains(facing)) {
+                facing = context.getEntity().getDirection().getOpposite();
+            }
+        }
+
+        if (facing != facingOrig && property.getPossibleValues().contains(facing)) {
+            if (state.getBlock() instanceof BedBlock) {
+                BlockPos headPos = context.pos.relative(facing);
+                BlockPlaceContext ctx = context.getItemPlacementContext();
+
+                if (ctx == null || !context.getWorld().getBlockState(headPos).canBeReplaced(ctx)) {
+                    return null;
+                }
+            }
+
+            state = state.setValue(property, facing);
+        }
+
+        return state;
+    }
+
+    public static class UseContext {
+
+        private final Level world;
+        private final BlockPos pos;
+        private final Direction side;
+        private final Vec3 hitVec;
+        private final LivingEntity entity;
+        private final InteractionHand hand;
+        @Nullable
+        private final BlockPlaceContext itemPlacementContext;
+
+        private UseContext(Level world, BlockPos pos, Direction side, Vec3 hitVec, LivingEntity entity, InteractionHand hand, @Nullable BlockPlaceContext itemPlacementContext) {
+            this.world = world;
+            this.pos = pos;
+            this.side = side;
+            this.hitVec = hitVec;
+            this.entity = entity;
+            this.hand = hand;
+            this.itemPlacementContext = itemPlacementContext;
+        }
+
+        @NotNull
+        public static UseContext from(@NotNull BlockPlaceContext ctx, InteractionHand hand) {
+            Vec3 pos = ctx.getClickLocation();
+            return new UseContext(ctx.getLevel(), ctx.getClickedPos(), ctx.getClickedFace(), new Vec3(pos.x, pos.y, pos.z), ctx.getPlayer(), hand, ctx);
+        }
+
+        public Level getWorld() {
+            return this.world;
+        }
+
+        public BlockPos getPos() {
+            return this.pos;
+        }
+
+        public Direction getSide() {
+            return this.side;
+        }
+
+        public Vec3 getHitVec() {
+            return this.hitVec;
+        }
+
+        public LivingEntity getEntity() {
+            return this.entity;
+        }
+
+        public InteractionHand getHand() {
+            return this.hand;
+        }
+
+        @Nullable
+        public BlockPlaceContext getItemPlacementContext() {
+            return this.itemPlacementContext;
+        }
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/XaeroMapProtocol.java

@@ -0,0 +1,64 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol;
+
+import fun.bm.lophine.config.modules.function.protocol.XaeroMapProtocolConfig;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerPlayer;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.protocol.core.LeavesProtocol;
+import org.leavesmc.leaves.protocol.core.ProtocolUtils;
+
+@LeavesProtocol.Register(namespace = "xaerominimap_or_xaeroworldmap_i_dont_care")
+public class XaeroMapProtocol implements LeavesProtocol {
+
+    public static final String PROTOCOL_ID_MINI = "xaerominimap";
+    public static final String PROTOCOL_ID_WORLD = "xaeroworldmap";
+
+    private static final ResourceLocation MINIMAP_KEY = idMini("main");
+    private static final ResourceLocation WORLDMAP_KEY = idWorld("main");
+
+    @Contract("_ -> new")
+    public static ResourceLocation idMini(String path) {
+        return ResourceLocation.tryBuild(PROTOCOL_ID_MINI, path);
+    }
+
+    @Contract("_ -> new")
+    public static ResourceLocation idWorld(String path) {
+        return ResourceLocation.tryBuild(PROTOCOL_ID_WORLD, path);
+    }
+
+    public static void onSendWorldInfo(@NotNull ServerPlayer player) {
+        if (XaeroMapProtocolConfig.enabled) {
+            ProtocolUtils.sendBytebufPacket(player, MINIMAP_KEY, buf -> {
+                buf.writeByte(0);
+                buf.writeInt(XaeroMapProtocolConfig.xaeroMapServerID);
+            });
+            ProtocolUtils.sendBytebufPacket(player, WORLDMAP_KEY, buf -> {
+                buf.writeByte(0);
+                buf.writeInt(XaeroMapProtocolConfig.xaeroMapServerID);
+            });
+        }
+    }
+
+    @Override
+    public boolean isActive() {
+        return XaeroMapProtocolConfig.enabled;
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/core/LeavesProtocolManager.java

@@ -24,7 +24,6 @@ import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.RegistryFriendlyByteBuf;
 import net.minecraft.network.codec.StreamCodec;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.level.ServerPlayer;
 import org.leavesmc.leaves.protocol.core.invoker.*;
 import org.slf4j.Logger;
@@ -66,6 +65,8 @@ public class LeavesProtocolManager {
     private static final List<EmptyInvokerHolder<ProtocolHandler.ReloadServer>> RELOAD_SERVER = new ArrayList<>();
     private static final List<EmptyInvokerHolder<ProtocolHandler.ReloadDataPack>> RELOAD_DATAPACK = new ArrayList<>();
 
+    private static long lastAcceptTime = 0;
+
     @SuppressWarnings("unchecked")
     public static void init() {
         for (Class<?> clazz : getClasses("org.leavesmc.leaves.protocol")) {
@@ -253,8 +254,11 @@ public class LeavesProtocolManager {
     }
 
     public static void handleTick() {
+        long currentTime = System.currentTimeMillis() / 50;
+        if (currentTime == lastAcceptTime) return;
+        lastAcceptTime = currentTime;
         for (var tickerInfo : TICKERS) {
-            if (MinecraftServer.getServer().checkTickCount(tickerInfo.owner().tickerInterval(tickerInfo.handler().tickerId()))) {
+            if (currentTime % tickerInfo.owner().tickerInterval(tickerInfo.handler().tickerId()) == 0) {
                 tickerInfo.invoke();
             }
         }

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/JadeProtocol.java

@@ -0,0 +1,275 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade;
+
+import ca.spottedleaf.moonrise.common.util.TickThread;
+import com.mojang.logging.LogUtils;
+import fun.bm.lophine.config.modules.function.protocol.JadeProtocolConfig;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.util.Mth;
+import net.minecraft.world.entity.AgeableMob;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.Mob;
+import net.minecraft.world.entity.animal.Animal;
+import net.minecraft.world.entity.animal.Chicken;
+import net.minecraft.world.entity.animal.allay.Allay;
+import net.minecraft.world.entity.animal.armadillo.Armadillo;
+import net.minecraft.world.entity.animal.frog.Tadpole;
+import net.minecraft.world.entity.animal.sniffer.Sniffer;
+import net.minecraft.world.entity.monster.ZombieVillager;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.CampfireBlock;
+import net.minecraft.world.level.block.entity.*;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.protocol.core.LeavesProtocol;
+import org.leavesmc.leaves.protocol.core.ProtocolHandler;
+import org.leavesmc.leaves.protocol.core.ProtocolUtils;
+import org.leavesmc.leaves.protocol.jade.accessor.BlockAccessor;
+import org.leavesmc.leaves.protocol.jade.accessor.EntityAccessor;
+import org.leavesmc.leaves.protocol.jade.payload.*;
+import org.leavesmc.leaves.protocol.jade.provider.*;
+import org.leavesmc.leaves.protocol.jade.provider.block.*;
+import org.leavesmc.leaves.protocol.jade.provider.entity.*;
+import org.leavesmc.leaves.protocol.jade.util.*;
+import org.leavesmc.leaves.protocol.servux.litematics.utils.NbtUtils;
+import org.slf4j.Logger;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+@LeavesProtocol.Register(namespace = "jade")
+public class JadeProtocol implements LeavesProtocol {
+    private static final Logger LOGGER = LogUtils.getLogger();
+
+    public static final String PROTOCOL_ID = "jade";
+    public static final String PROTOCOL_VERSION = "8";
+    public static final HierarchyLookup<IServerDataProvider<EntityAccessor>> entityDataProviders = new HierarchyLookup<>(Entity.class);
+    public static final PairHierarchyLookup<IServerDataProvider<BlockAccessor>> blockDataProviders = new PairHierarchyLookup<>(new HierarchyLookup<>(Block.class), new HierarchyLookup<>(BlockEntity.class));
+    public static final WrappedHierarchyLookup<IServerExtensionProvider<ItemStack>> itemStorageProviders = WrappedHierarchyLookup.forAccessor();
+    private static final Set<ServerPlayer> enabledPlayers = new HashSet<>();
+
+    public static PriorityStore<ResourceLocation, IJadeProvider> priorities;
+    private static List<Block> shearableBlocks = null;
+
+    @Contract("_ -> new")
+    public static ResourceLocation id(String path) {
+        return ResourceLocation.tryBuild(PROTOCOL_ID, path);
+    }
+
+    @Contract("_ -> new")
+    public static @NotNull ResourceLocation mc_id(String path) {
+        return ResourceLocation.withDefaultNamespace(path);
+    }
+
+    @ProtocolHandler.Init
+    public static void init() {
+        priorities = new PriorityStore<>(IJadeProvider::getDefaultPriority, IJadeProvider::getUid);
+
+        // core plugin
+        blockDataProviders.register(BlockEntity.class, BlockNameProvider.INSTANCE);
+
+        // universal plugin
+        entityDataProviders.register(Entity.class, ItemStorageProvider.getEntity());
+        blockDataProviders.register(Block.class, ItemStorageProvider.getBlock());
+
+        itemStorageProviders.register(Object.class, ItemStorageExtensionProvider.INSTANCE);
+        itemStorageProviders.register(Block.class, ItemStorageExtensionProvider.INSTANCE);
+
+        // vanilla plugin
+        entityDataProviders.register(Entity.class, AnimalOwnerProvider.INSTANCE);
+        entityDataProviders.register(LivingEntity.class, StatusEffectsProvider.INSTANCE);
+        entityDataProviders.register(AgeableMob.class, MobGrowthProvider.INSTANCE);
+        entityDataProviders.register(Tadpole.class, MobGrowthProvider.INSTANCE);
+        entityDataProviders.register(Animal.class, MobBreedingProvider.INSTANCE);
+        entityDataProviders.register(Allay.class, MobBreedingProvider.INSTANCE);
+        entityDataProviders.register(Mob.class, PetArmorProvider.INSTANCE);
+
+        entityDataProviders.register(Chicken.class, NextEntityDropProvider.INSTANCE);
+        entityDataProviders.register(Armadillo.class, NextEntityDropProvider.INSTANCE);
+        entityDataProviders.register(Sniffer.class, NextEntityDropProvider.INSTANCE);
+
+        entityDataProviders.register(ZombieVillager.class, ZombieVillagerProvider.INSTANCE);
+
+        blockDataProviders.register(BrewingStandBlockEntity.class, BrewingStandProvider.INSTANCE);
+        blockDataProviders.register(BeehiveBlockEntity.class, BeehiveProvider.INSTANCE);
+        blockDataProviders.register(CommandBlockEntity.class, CommandBlockProvider.INSTANCE);
+        blockDataProviders.register(JukeboxBlockEntity.class, JukeboxProvider.INSTANCE);
+        blockDataProviders.register(LecternBlockEntity.class, LecternProvider.INSTANCE);
+
+        blockDataProviders.register(ComparatorBlockEntity.class, RedstoneProvider.INSTANCE);
+        blockDataProviders.register(HopperBlockEntity.class, HopperLockProvider.INSTANCE);
+        blockDataProviders.register(CalibratedSculkSensorBlockEntity.class, RedstoneProvider.INSTANCE);
+
+        blockDataProviders.register(AbstractFurnaceBlockEntity.class, FurnaceProvider.INSTANCE);
+        blockDataProviders.register(ChiseledBookShelfBlockEntity.class, ChiseledBookshelfProvider.INSTANCE);
+        blockDataProviders.register(TrialSpawnerBlockEntity.class, MobSpawnerCooldownProvider.INSTANCE);
+
+        itemStorageProviders.register(CampfireBlock.class, CampfireProvider.INSTANCE);
+
+        blockDataProviders.idMapped();
+        entityDataProviders.idMapped();
+
+        blockDataProviders.loadComplete(priorities);
+        entityDataProviders.loadComplete(priorities);
+        itemStorageProviders.loadComplete(priorities);
+
+        rebuildShearableBlocks();
+    }
+
+    @ProtocolHandler.PayloadReceiver(payload = ClientHandshakePayload.class)
+    public static void clientHandshake(ServerPlayer player, ClientHandshakePayload payload) {
+        if (!payload.protocolVersion().equals(PROTOCOL_VERSION)) {
+            player.sendSystemMessage(Component.literal("You are using a different version of Jade than the server. Please update Jade or report to the server operator").withColor(0xff0000));
+            return;
+        }
+        ProtocolUtils.sendPayloadPacket(player, new ServerHandshakePayload(Collections.emptyMap(), shearableBlocks, blockDataProviders.mappedIds(), entityDataProviders.mappedIds()));
+        synchronized (enabledPlayers) {
+            enabledPlayers.add(player);
+        }
+    }
+
+    @ProtocolHandler.PlayerLeave
+    public static void onPlayerLeave(ServerPlayer player) {
+        synchronized (enabledPlayers) {
+            enabledPlayers.remove(player);
+        }
+    }
+
+    @ProtocolHandler.PayloadReceiver(payload = RequestEntityPayload.class)
+    public static void requestEntityData(ServerPlayer player, RequestEntityPayload payload) {
+        player.getBukkitEntity().taskScheduler.schedule((LivingEntity nmsEntity) -> {
+            EntityAccessor accessor = payload.data().unpack(player);
+            if (accessor == null) {
+                return;
+            }
+
+            Entity entity = accessor.getEntity();
+            double maxDistance = Mth.square(player.entityInteractionRange() + 21);
+            if (entity == null || player.distanceToSqr(entity) > maxDistance) {
+                return;
+            }
+
+            List<IServerDataProvider<EntityAccessor>> providers = entityDataProviders.get(entity);
+            if (providers.isEmpty()) {
+                return;
+            }
+
+            CompoundTag tag = new CompoundTag();
+            for (IServerDataProvider<EntityAccessor> provider : providers) {
+                if (!payload.dataProviders().contains(provider)) {
+                    continue;
+                }
+                try {
+                    provider.appendServerData(tag, accessor);
+                } catch (Exception e) {
+                    LOGGER.warn("Error while saving data for entity " + entity);
+                }
+            }
+            tag.putInt("EntityId", entity.getId());
+
+            ProtocolUtils.sendPayloadPacket(player, new ReceiveDataPayload(tag));
+        }, null, 1L);
+    }
+
+    @ProtocolHandler.PayloadReceiver(payload = RequestBlockPayload.class)
+    public static void requestBlockData(ServerPlayer player, RequestBlockPayload payload) {
+        ServerLevel level = player.level();
+        player.getBukkitEntity().taskScheduler.schedule((LivingEntity nmsEntity) -> {
+            BlockAccessor accessor = payload.data().unpack(player);
+            if (accessor == null) {
+                return;
+            }
+
+            BlockPos pos = accessor.getPosition();
+            Block block = accessor.getBlock();
+            BlockEntity blockEntity = TickThread.isTickThreadFor(level, pos) ? accessor.getBlockEntity() : null;
+            double maxDistance = Mth.square(player.blockInteractionRange() + 21);
+            if (pos.distSqr(player.blockPosition()) > maxDistance || !accessor.getLevel().isLoaded(pos)) {
+                return;
+            }
+
+            List<IServerDataProvider<BlockAccessor>> providers;
+            if (blockEntity != null) {
+                providers = blockDataProviders.getMerged(block, blockEntity);
+            } else {
+                providers = blockDataProviders.first.get(block);
+            }
+
+            if (providers.isEmpty()) {
+                return;
+            }
+
+            CompoundTag tag = new CompoundTag();
+            for (IServerDataProvider<BlockAccessor> provider : providers) {
+                if (!payload.dataProviders().contains(provider)) {
+                    continue;
+                }
+                try {
+                    provider.appendServerData(tag, accessor);
+                } catch (Exception e) {
+                    LOGGER.warn("Error while saving data for block " + accessor.getBlockState());
+                }
+            }
+            NbtUtils.writeBlockPosToTag(pos, tag);
+            tag.putString("BlockId", BuiltInRegistries.BLOCK.getKey(block).toString());
+
+            ProtocolUtils.sendPayloadPacket(player, new ReceiveDataPayload(tag));
+        }, null, 1L);
+    }
+
+    @ProtocolHandler.ReloadServer
+    public static void onServerReload() {
+        rebuildShearableBlocks();
+        synchronized (enabledPlayers) {
+            for (ServerPlayer player : enabledPlayers) {
+                ProtocolUtils.sendPayloadPacket(player, new ServerHandshakePayload(Collections.emptyMap(), shearableBlocks, blockDataProviders.mappedIds(), entityDataProviders.mappedIds()));
+            }
+        }
+    }
+
+    private static void rebuildShearableBlocks() {
+        try {
+            shearableBlocks = Collections.unmodifiableList(LootTableMineableCollector.execute(
+                    MinecraftServer.getServer().reloadableRegistries().lookup().lookupOrThrow(Registries.LOOT_TABLE),
+                    Items.SHEARS.getDefaultInstance()
+            ));
+        } catch (Throwable ignore) {
+            shearableBlocks = List.of();
+            LOGGER.warn("Failed to collect shearable blocks");
+        }
+    }
+
+    @Override
+    public boolean isActive() {
+        return JadeProtocolConfig.enabled;
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/accessor/Accessor.java

@@ -0,0 +1,39 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.accessor;
+
+import net.minecraft.nbt.Tag;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamEncoder;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.phys.HitResult;
+import org.jetbrains.annotations.Nullable;
+
+public interface Accessor<T extends HitResult> {
+    ServerLevel getLevel();
+
+    Player getPlayer();
+
+    <D> Tag encodeAsNbt(StreamEncoder<RegistryFriendlyByteBuf, D> codec, D value);
+
+    T getHitResult();
+
+    @Nullable
+    Object getTarget();
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/accessor/AccessorImpl.java

@@ -0,0 +1,77 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.accessor;
+
+import io.netty.buffer.Unpooled;
+import net.minecraft.nbt.ByteArrayTag;
+import net.minecraft.nbt.Tag;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamEncoder;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.phys.HitResult;
+import org.apache.commons.lang3.ArrayUtils;
+
+import java.util.function.Supplier;
+
+public abstract class AccessorImpl<T extends HitResult> implements Accessor<T> {
+
+    private final ServerLevel level;
+    private final Player player;
+    private final Supplier<T> hit;
+    protected boolean verify;
+    private RegistryFriendlyByteBuf buffer;
+
+    public AccessorImpl(ServerLevel level, Player player, Supplier<T> hit) {
+        this.level = level;
+        this.player = player;
+        this.hit = hit;
+    }
+
+    @Override
+    public ServerLevel getLevel() {
+        return level;
+    }
+
+    @Override
+    public Player getPlayer() {
+        return player;
+    }
+
+    private RegistryFriendlyByteBuf buffer() {
+        if (buffer == null) {
+            buffer = new RegistryFriendlyByteBuf(Unpooled.buffer(), level.registryAccess());
+        }
+        buffer.clear();
+        return buffer;
+    }
+
+    @Override
+    public <D> Tag encodeAsNbt(StreamEncoder<RegistryFriendlyByteBuf, D> streamCodec, D value) {
+        RegistryFriendlyByteBuf buffer = buffer();
+        streamCodec.encode(buffer, value);
+        ByteArrayTag tag = new ByteArrayTag(ArrayUtils.subarray(buffer.array(), 0, buffer.readableBytes()));
+        buffer.clear();
+        return tag;
+    }
+
+    @Override
+    public T getHitResult() {
+        return hit.get();
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/accessor/BlockAccessor.java

@@ -0,0 +1,61 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.accessor;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.BlockHitResult;
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.function.Supplier;
+
+public interface BlockAccessor extends Accessor<BlockHitResult> {
+
+    Block getBlock();
+
+    BlockState getBlockState();
+
+    BlockEntity getBlockEntity();
+
+    BlockPos getPosition();
+
+    @ApiStatus.NonExtendable
+    interface Builder {
+        Builder level(ServerLevel level);
+
+        Builder player(Player player);
+
+        Builder hit(BlockHitResult hit);
+
+        Builder blockState(BlockState state);
+
+        default Builder blockEntity(BlockEntity blockEntity) {
+            return blockEntity(() -> blockEntity);
+        }
+
+        Builder blockEntity(Supplier<BlockEntity> blockEntity);
+
+        Builder from(BlockAccessor accessor);
+
+        BlockAccessor build();
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/accessor/BlockAccessorImpl.java

@@ -0,0 +1,160 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.accessor;
+
+import com.google.common.base.Suppliers;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.BlockHitResult;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.function.Supplier;
+
+/**
+ * Class to get information of block target and context.
+ */
+public class BlockAccessorImpl extends AccessorImpl<BlockHitResult> implements BlockAccessor {
+
+    private final BlockState blockState;
+    @Nullable
+    private final Supplier<BlockEntity> blockEntity;
+
+    private BlockAccessorImpl(Builder builder) {
+        super(builder.level, builder.player, Suppliers.ofInstance(builder.hit));
+        blockState = builder.blockState;
+        blockEntity = builder.blockEntity;
+    }
+
+    @Override
+    public Block getBlock() {
+        return getBlockState().getBlock();
+    }
+
+    @Override
+    public BlockState getBlockState() {
+        return blockState;
+    }
+
+    @Override
+    public BlockEntity getBlockEntity() {
+        return blockEntity == null ? null : blockEntity.get();
+    }
+
+    @Override
+    public BlockPos getPosition() {
+        return getHitResult().getBlockPos();
+    }
+
+    @Nullable
+    @Override
+    public Object getTarget() {
+        return getBlockEntity();
+    }
+
+    public static class Builder implements BlockAccessor.Builder {
+        private ServerLevel level;
+        private Player player;
+        private BlockHitResult hit;
+        private BlockState blockState = Blocks.AIR.defaultBlockState();
+        private Supplier<BlockEntity> blockEntity;
+
+        @Override
+        public Builder level(ServerLevel level) {
+            this.level = level;
+            return this;
+        }
+
+        @Override
+        public Builder player(Player player) {
+            this.player = player;
+            return this;
+        }
+
+        @Override
+        public Builder hit(BlockHitResult hit) {
+            this.hit = hit;
+            return this;
+        }
+
+        @Override
+        public Builder blockState(BlockState blockState) {
+            this.blockState = blockState;
+            return this;
+        }
+
+        @Override
+        public Builder blockEntity(Supplier<BlockEntity> blockEntity) {
+            this.blockEntity = blockEntity;
+            return this;
+        }
+
+        @Override
+        public Builder from(BlockAccessor accessor) {
+            level = accessor.getLevel();
+            player = accessor.getPlayer();
+            hit = accessor.getHitResult();
+            blockEntity = accessor::getBlockEntity;
+            blockState = accessor.getBlockState();
+            return this;
+        }
+
+        @Override
+        public BlockAccessor build() {
+            return new BlockAccessorImpl(this);
+        }
+    }
+
+    public record SyncData(boolean showDetails, BlockHitResult hit, BlockState blockState, ItemStack fakeBlock) {
+        public static final StreamCodec<RegistryFriendlyByteBuf, SyncData> STREAM_CODEC = StreamCodec.composite(
+                ByteBufCodecs.BOOL,
+                SyncData::showDetails,
+                StreamCodec.of(FriendlyByteBuf::writeBlockHitResult, FriendlyByteBuf::readBlockHitResult),
+                SyncData::hit,
+                ByteBufCodecs.idMapper(Block.BLOCK_STATE_REGISTRY),
+                SyncData::blockState,
+                ItemStack.OPTIONAL_STREAM_CODEC,
+                SyncData::fakeBlock,
+                SyncData::new
+        );
+
+        public BlockAccessor unpack(ServerPlayer player) {
+            Supplier<BlockEntity> blockEntity = null;
+            if (blockState.hasBlockEntity()) {
+                blockEntity = Suppliers.memoize(() -> player.level().getBlockEntity(hit.getBlockPos()));
+            }
+            return new Builder()
+                    .level(player.level())
+                    .player(player)
+                    .hit(hit)
+                    .blockState(blockState)
+                    .blockEntity(blockEntity)
+                    .build();
+        }
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/accessor/EntityAccessor.java

@@ -0,0 +1,59 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.accessor;
+
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.phys.EntityHitResult;
+import org.jetbrains.annotations.ApiStatus;
+
+import java.util.function.Supplier;
+
+public interface EntityAccessor extends Accessor<EntityHitResult> {
+
+    Entity getEntity();
+
+    /**
+     * For part entity like ender dragon's, getEntity() will return the parent entity.
+     */
+    Entity getRawEntity();
+
+    @ApiStatus.NonExtendable
+    interface Builder {
+        Builder level(ServerLevel level);
+
+        Builder player(Player player);
+
+        default Builder hit(EntityHitResult hit) {
+            return hit(() -> hit);
+        }
+
+        Builder hit(Supplier<EntityHitResult> hit);
+
+        default Builder entity(Entity entity) {
+            return entity(() -> entity);
+        }
+
+        Builder entity(Supplier<Entity> entity);
+
+        Builder from(EntityAccessor accessor);
+
+        EntityAccessor build();
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/accessor/EntityAccessorImpl.java

@@ -0,0 +1,129 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.accessor;
+
+import com.google.common.base.Suppliers;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.phys.EntityHitResult;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.protocol.jade.util.CommonUtil;
+
+import java.util.function.Supplier;
+
+public class EntityAccessorImpl extends AccessorImpl<EntityHitResult> implements EntityAccessor {
+
+    private final Supplier<Entity> entity;
+
+    public EntityAccessorImpl(Builder builder) {
+        super(builder.level, builder.player, builder.hit);
+        entity = builder.entity;
+    }
+
+    @Override
+    public Entity getEntity() {
+        return CommonUtil.wrapPartEntityParent(getRawEntity());
+    }
+
+    @Override
+    public Entity getRawEntity() {
+        return entity.get();
+    }
+
+    @NotNull
+    @Override
+    public Object getTarget() {
+        return getEntity();
+    }
+
+    public static class Builder implements EntityAccessor.Builder {
+        private ServerLevel level;
+        private Player player;
+        private Supplier<EntityHitResult> hit;
+        private Supplier<Entity> entity;
+
+        @Override
+        public Builder level(ServerLevel level) {
+            this.level = level;
+            return this;
+        }
+
+        @Override
+        public Builder player(Player player) {
+            this.player = player;
+            return this;
+        }
+
+
+        @Override
+        public Builder hit(Supplier<EntityHitResult> hit) {
+            this.hit = hit;
+            return this;
+        }
+
+        @Override
+        public Builder entity(Supplier<Entity> entity) {
+            this.entity = entity;
+            return this;
+        }
+
+        @Override
+        public Builder from(EntityAccessor accessor) {
+            level = accessor.getLevel();
+            player = accessor.getPlayer();
+            hit = accessor::getHitResult;
+            entity = accessor::getEntity;
+            return this;
+        }
+
+        @Override
+        public EntityAccessor build() {
+            return new EntityAccessorImpl(this);
+        }
+    }
+
+    public record SyncData(boolean showDetails, int id, int partIndex, Vec3 hitVec) {
+        public static final StreamCodec<RegistryFriendlyByteBuf, SyncData> STREAM_CODEC = StreamCodec.composite(
+                ByteBufCodecs.BOOL,
+                SyncData::showDetails,
+                ByteBufCodecs.VAR_INT,
+                SyncData::id,
+                ByteBufCodecs.VAR_INT,
+                SyncData::partIndex,
+                ByteBufCodecs.VECTOR3F.map(Vec3::new, Vec3::toVector3f),
+                SyncData::hitVec,
+                SyncData::new
+        );
+
+        public EntityAccessor unpack(ServerPlayer player) {
+            Supplier<Entity> entity = Suppliers.memoize(() -> CommonUtil.getPartEntity(player.level().getEntity(id), partIndex));
+            return new EntityAccessorImpl.Builder()
+                    .level(player.level())
+                    .player(player)
+                    .entity(entity)
+                    .hit(Suppliers.memoize(() -> new EntityHitResult(entity.get(), hitVec)))
+                    .build();
+        }
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/payload/ClientHandshakePayload.java

@@ -0,0 +1,36 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.payload;
+
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.resources.ResourceLocation;
+import org.leavesmc.leaves.protocol.core.LeavesCustomPayload;
+import org.leavesmc.leaves.protocol.jade.JadeProtocol;
+
+public record ClientHandshakePayload(String protocolVersion) implements LeavesCustomPayload {
+
+    @ID
+    private static final ResourceLocation PACKET_CLIENT_HANDSHAKE = JadeProtocol.id("client_handshake");
+
+    @Codec
+    private static final StreamCodec<RegistryFriendlyByteBuf, ClientHandshakePayload> CODEC = StreamCodec.composite(
+            ByteBufCodecs.STRING_UTF8, ClientHandshakePayload::protocolVersion, ClientHandshakePayload::new
+    );
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/payload/ReceiveDataPayload.java

@@ -0,0 +1,37 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.payload;
+
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.resources.ResourceLocation;
+import org.leavesmc.leaves.protocol.core.LeavesCustomPayload;
+import org.leavesmc.leaves.protocol.jade.JadeProtocol;
+
+public record ReceiveDataPayload(CompoundTag tag) implements LeavesCustomPayload {
+
+    @ID
+    private static final ResourceLocation PACKET_RECEIVE_DATA = JadeProtocol.id("receive_data");
+
+    @Codec
+    private static final StreamCodec<FriendlyByteBuf, ReceiveDataPayload> CODEC = StreamCodec.composite(
+            ByteBufCodecs.COMPOUND_TAG, ReceiveDataPayload::tag, ReceiveDataPayload::new
+    );
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/payload/RequestBlockPayload.java

@@ -0,0 +1,53 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.payload;
+
+import io.netty.buffer.ByteBuf;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.resources.ResourceLocation;
+import org.jetbrains.annotations.Nullable;
+import org.leavesmc.leaves.protocol.core.LeavesCustomPayload;
+import org.leavesmc.leaves.protocol.jade.JadeProtocol;
+import org.leavesmc.leaves.protocol.jade.accessor.BlockAccessor;
+import org.leavesmc.leaves.protocol.jade.accessor.BlockAccessorImpl;
+import org.leavesmc.leaves.protocol.jade.provider.IServerDataProvider;
+
+import java.util.List;
+import java.util.Objects;
+
+import static org.leavesmc.leaves.protocol.jade.JadeProtocol.blockDataProviders;
+
+public record RequestBlockPayload(BlockAccessorImpl.SyncData data,
+                                  List<@Nullable IServerDataProvider<BlockAccessor>> dataProviders) implements LeavesCustomPayload {
+
+    @ID
+    private static final ResourceLocation PACKET_REQUEST_BLOCK = JadeProtocol.id("request_block");
+
+    @Codec
+    private static final StreamCodec<RegistryFriendlyByteBuf, RequestBlockPayload> CODEC = StreamCodec.composite(
+            BlockAccessorImpl.SyncData.STREAM_CODEC,
+            RequestBlockPayload::data,
+            ByteBufCodecs.<ByteBuf, IServerDataProvider<BlockAccessor>>list()
+                    .apply(ByteBufCodecs.idMapper(
+                            $ -> Objects.requireNonNull(blockDataProviders.idMapper()).byId($),
+                            $ -> Objects.requireNonNull(blockDataProviders.idMapper()).getIdOrThrow($))),
+            RequestBlockPayload::dataProviders,
+            RequestBlockPayload::new);
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/payload/RequestEntityPayload.java

@@ -0,0 +1,54 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.payload;
+
+import io.netty.buffer.ByteBuf;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.resources.ResourceLocation;
+import org.jetbrains.annotations.Nullable;
+import org.leavesmc.leaves.protocol.core.LeavesCustomPayload;
+import org.leavesmc.leaves.protocol.jade.JadeProtocol;
+import org.leavesmc.leaves.protocol.jade.accessor.EntityAccessor;
+import org.leavesmc.leaves.protocol.jade.accessor.EntityAccessorImpl;
+import org.leavesmc.leaves.protocol.jade.provider.IServerDataProvider;
+
+import java.util.List;
+import java.util.Objects;
+
+import static org.leavesmc.leaves.protocol.jade.JadeProtocol.entityDataProviders;
+
+public record RequestEntityPayload(EntityAccessorImpl.SyncData data,
+                                   List<@Nullable IServerDataProvider<EntityAccessor>> dataProviders) implements LeavesCustomPayload {
+
+    @ID
+    private static final ResourceLocation PACKET_REQUEST_ENTITY = JadeProtocol.id("request_entity");
+
+    @Codec
+    private static final StreamCodec<RegistryFriendlyByteBuf, RequestEntityPayload> CODEC = StreamCodec.composite(
+            EntityAccessorImpl.SyncData.STREAM_CODEC,
+            RequestEntityPayload::data,
+            ByteBufCodecs.<ByteBuf, IServerDataProvider<EntityAccessor>>list()
+                    .apply(ByteBufCodecs.idMapper(
+                            $ -> Objects.requireNonNull(entityDataProviders.idMapper()).byId($),
+                            $ -> Objects.requireNonNull(entityDataProviders.idMapper()).getIdOrThrow($)
+                    )),
+            RequestEntityPayload::dataProviders,
+            RequestEntityPayload::new);
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/payload/ServerHandshakePayload.java

@@ -0,0 +1,59 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.payload;
+
+
+import com.google.common.collect.Maps;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.block.Block;
+import org.leavesmc.leaves.protocol.core.LeavesCustomPayload;
+import org.leavesmc.leaves.protocol.jade.JadeProtocol;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.leavesmc.leaves.protocol.jade.util.JadeCodec.PRIMITIVE_STREAM_CODEC;
+
+public record ServerHandshakePayload(
+        Map<ResourceLocation, Object> serverConfig,
+        List<Block> shearableBlocks,
+        List<ResourceLocation> blockProviderIds,
+        List<ResourceLocation> entityProviderIds
+) implements LeavesCustomPayload {
+
+    @ID
+    private static final ResourceLocation PACKET_SERVER_HANDSHAKE = JadeProtocol.id("server_handshake");
+
+    @Codec
+    private static final StreamCodec<RegistryFriendlyByteBuf, ServerHandshakePayload> CODEC = StreamCodec.composite(
+            ByteBufCodecs.map(Maps::newHashMapWithExpectedSize, ResourceLocation.STREAM_CODEC, PRIMITIVE_STREAM_CODEC),
+            ServerHandshakePayload::serverConfig,
+            ByteBufCodecs.registry(Registries.BLOCK).apply(ByteBufCodecs.list()),
+            ServerHandshakePayload::shearableBlocks,
+            ByteBufCodecs.<ByteBuf, ResourceLocation>list().apply(ResourceLocation.STREAM_CODEC),
+            ServerHandshakePayload::blockProviderIds,
+            ByteBufCodecs.<ByteBuf, ResourceLocation>list().apply(ResourceLocation.STREAM_CODEC),
+            ServerHandshakePayload::entityProviderIds,
+            ServerHandshakePayload::new
+    );
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/provider/IJadeProvider.java

@@ -0,0 +1,29 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.provider;
+
+import net.minecraft.resources.ResourceLocation;
+
+public interface IJadeProvider {
+
+    ResourceLocation getUid();
+
+    default int getDefaultPriority() {
+        return 0;
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/provider/IServerDataProvider.java

@@ -0,0 +1,25 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.provider;
+
+import net.minecraft.nbt.CompoundTag;
+import org.leavesmc.leaves.protocol.jade.accessor.Accessor;
+
+public interface IServerDataProvider<T extends Accessor<?>> extends IJadeProvider {
+    void appendServerData(CompoundTag data, T accessor);
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/provider/IServerExtensionProvider.java

@@ -0,0 +1,27 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.provider;
+
+import org.leavesmc.leaves.protocol.jade.accessor.Accessor;
+import org.leavesmc.leaves.protocol.jade.util.ViewGroup;
+
+import java.util.List;
+
+public interface IServerExtensionProvider<T> extends IJadeProvider {
+    List<ViewGroup<T>> getGroups(Accessor<?> request);
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/provider/ItemStorageExtensionProvider.java

@@ -0,0 +1,165 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.provider;
+
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
+import com.mojang.logging.LogUtils;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.Container;
+import net.minecraft.world.LockCode;
+import net.minecraft.world.RandomizableContainer;
+import net.minecraft.world.WorldlyContainerHolder;
+import net.minecraft.world.entity.animal.horse.AbstractHorse;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.entity.vehicle.ContainerEntity;
+import net.minecraft.world.inventory.PlayerEnderChestContainer;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.ChestBlock;
+import net.minecraft.world.level.block.entity.BaseContainerBlockEntity;
+import net.minecraft.world.level.block.entity.ChestBlockEntity;
+import net.minecraft.world.level.block.entity.EnderChestBlockEntity;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.leavesmc.leaves.protocol.jade.JadeProtocol;
+import org.leavesmc.leaves.protocol.jade.accessor.Accessor;
+import org.leavesmc.leaves.protocol.jade.accessor.BlockAccessor;
+import org.leavesmc.leaves.protocol.jade.util.ItemCollector;
+import org.leavesmc.leaves.protocol.jade.util.ItemIterator;
+import org.leavesmc.leaves.protocol.jade.util.ViewGroup;
+import org.slf4j.Logger;
+
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+
+public enum ItemStorageExtensionProvider implements IServerExtensionProvider<ItemStack> {
+    INSTANCE;
+
+    public static final Cache<Object, ItemCollector<?>> targetCache = CacheBuilder.newBuilder().weakKeys().expireAfterAccess(60, TimeUnit.SECONDS).build();
+
+    private static final ResourceLocation UNIVERSAL_ITEM_STORAGE = JadeProtocol.mc_id("item_storage.default");
+
+    private static final Logger LOGGER = LogUtils.getLogger();
+
+    public static ItemCollector<?> createItemCollector(Accessor<?> request) {
+        if (request.getTarget() instanceof AbstractHorse) {
+            return new ItemCollector<>(new ItemIterator.ContainerItemIterator(o -> {
+                if (o instanceof AbstractHorse horse) {
+                    return horse.inventory;
+                }
+                return null;
+            }, 2));
+        }
+
+        // TODO BlockEntity like fabric's ItemStorage
+
+        final Container container = findContainer(request);
+        if (container != null) {
+            if (container instanceof ChestBlockEntity) {
+                return new ItemCollector<>(new ItemIterator.ContainerItemIterator(o -> {
+                    if (o instanceof ChestBlockEntity blockEntity) {
+                        if (blockEntity.getBlockState().getBlock() instanceof ChestBlock chestBlock) {
+                            Container compound = null;
+                            if (blockEntity.getLevel() != null) {
+                                compound = ChestBlock.getContainer(
+                                        chestBlock, blockEntity.getBlockState(),
+                                        blockEntity.getLevel(), blockEntity.getBlockPos(),
+                                        true // Bypass lock check
+                                );
+                            }
+                            if (compound != null) {
+                                return compound;
+                            }
+                        }
+                        return blockEntity;
+                    }
+                    return null;
+                }, 0));
+            }
+            return new ItemCollector<>(new ItemIterator.ContainerItemIterator(0));
+        }
+
+        return ItemCollector.EMPTY;
+    }
+
+    public static @Nullable Container findContainer(@NotNull Accessor<?> accessor) {
+        Object target = accessor.getTarget();
+        if (target == null && accessor instanceof BlockAccessor blockAccessor &&
+                blockAccessor.getBlock() instanceof WorldlyContainerHolder holder) {
+            return holder.getContainer(blockAccessor.getBlockState(), accessor.getLevel(), blockAccessor.getPosition());
+        } else if (target instanceof Container container) {
+            return container;
+        }
+        return null;
+    }
+
+    @Override
+    public List<ViewGroup<ItemStack>> getGroups(Accessor<?> request) {
+        Object target = request.getTarget();
+
+        switch (target) {
+            case null -> {
+                return createItemCollector(request).update(request);
+            }
+            case RandomizableContainer te when te.getLootTable() != null -> {
+                return List.of();
+            }
+            case ContainerEntity containerEntity when containerEntity.getContainerLootTable() != null -> {
+                return List.of();
+            }
+            case EnderChestBlockEntity enderChest when request.getPlayer().getEnderChestInventory().isEmpty() -> {
+                return List.of();
+            }
+            default -> {
+            }
+        }
+
+        Player player = request.getPlayer();
+        if (!player.isCreative() && !player.isSpectator() && target instanceof BaseContainerBlockEntity te) {
+            if (te.lockKey != LockCode.NO_LOCK) {
+                return List.of();
+            }
+        }
+
+        if (target instanceof EnderChestBlockEntity) {
+            PlayerEnderChestContainer inventory = player.getEnderChestInventory();
+            return new ItemCollector<>(new ItemIterator.ContainerItemIterator(x -> inventory, 0)).update(request);
+        }
+
+        ItemCollector<?> itemCollector;
+        try {
+            itemCollector = targetCache.get(target, () -> createItemCollector(request));
+        } catch (ExecutionException e) {
+            LOGGER.warn("Failed to get item collector for " + target);
+            return null;
+        }
+
+        return itemCollector.update(request);
+    }
+
+    @Override
+    public ResourceLocation getUid() {
+        return UNIVERSAL_ITEM_STORAGE;
+    }
+
+    @Override
+    public int getDefaultPriority() {
+        return 9999;
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/provider/ItemStorageProvider.java

@@ -0,0 +1,104 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.provider;
+
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.LockCode;
+import net.minecraft.world.RandomizableContainer;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.entity.AbstractFurnaceBlockEntity;
+import net.minecraft.world.level.block.entity.BaseContainerBlockEntity;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.protocol.jade.JadeProtocol;
+import org.leavesmc.leaves.protocol.jade.accessor.Accessor;
+import org.leavesmc.leaves.protocol.jade.accessor.BlockAccessor;
+import org.leavesmc.leaves.protocol.jade.accessor.EntityAccessor;
+import org.leavesmc.leaves.protocol.jade.util.CommonUtil;
+import org.leavesmc.leaves.protocol.jade.util.ItemCollector;
+import org.leavesmc.leaves.protocol.jade.util.ViewGroup;
+
+import java.util.List;
+import java.util.Map;
+
+public abstract class ItemStorageProvider<T extends Accessor<?>> implements IServerDataProvider<T> {
+
+    private static final StreamCodec<RegistryFriendlyByteBuf, Map.Entry<ResourceLocation, List<ViewGroup<ItemStack>>>> STREAM_CODEC = ViewGroup.listCodec(ItemStack.OPTIONAL_STREAM_CODEC);
+
+    private static final ResourceLocation UNIVERSAL_ITEM_STORAGE = JadeProtocol.mc_id("item_storage");
+
+    public static ForBlock getBlock() {
+        return ForBlock.INSTANCE;
+    }
+
+    public static ForEntity getEntity() {
+        return ForEntity.INSTANCE;
+    }
+
+    public static void putData(CompoundTag tag, @NotNull Accessor<?> accessor) {
+        Object target = accessor.getTarget();
+        Player player = accessor.getPlayer();
+        Map.Entry<ResourceLocation, List<ViewGroup<ItemStack>>> entry = CommonUtil.getServerExtensionData(accessor, JadeProtocol.itemStorageProviders);
+        if (entry != null) {
+            List<ViewGroup<ItemStack>> groups = entry.getValue();
+            for (ViewGroup<ItemStack> group : groups) {
+                if (group.views.size() > ItemCollector.MAX_SIZE) {
+                    group.views = group.views.subList(0, ItemCollector.MAX_SIZE);
+                }
+            }
+            tag.put(UNIVERSAL_ITEM_STORAGE.toString(), accessor.encodeAsNbt(STREAM_CODEC, entry));
+            return;
+        }
+        if (target instanceof RandomizableContainer containerEntity && containerEntity.getLootTable() != null) {
+            tag.putBoolean("Loot", true);
+        } else if (!player.isCreative() && !player.isSpectator() && target instanceof BaseContainerBlockEntity te) {
+            if (te.lockKey != LockCode.NO_LOCK) {
+                tag.putBoolean("Locked", true);
+            }
+        }
+    }
+
+    @Override
+    public ResourceLocation getUid() {
+        return UNIVERSAL_ITEM_STORAGE;
+    }
+
+    @Override
+    public void appendServerData(CompoundTag tag, @NotNull T accessor) {
+        if (accessor.getTarget() instanceof AbstractFurnaceBlockEntity) {
+            return;
+        }
+        putData(tag, accessor);
+    }
+
+    @Override
+    public int getDefaultPriority() {
+        return 1000;
+    }
+
+    public static class ForBlock extends ItemStorageProvider<BlockAccessor> {
+        private static final ForBlock INSTANCE = new ForBlock();
+    }
+
+    public static class ForEntity extends ItemStorageProvider<EntityAccessor> {
+        private static final ForEntity INSTANCE = new ForEntity();
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/provider/StreamServerDataProvider.java

@@ -0,0 +1,40 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.provider;
+
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
+import org.jetbrains.annotations.Nullable;
+import org.leavesmc.leaves.protocol.jade.accessor.Accessor;
+
+public interface StreamServerDataProvider<T extends Accessor<?>, D> extends IServerDataProvider<T> {
+
+    @Override
+    default void appendServerData(CompoundTag data, T accessor) {
+        D value = streamData(accessor);
+        if (value != null) {
+            data.put(getUid().toString(), accessor.encodeAsNbt(streamCodec(), value));
+        }
+    }
+
+    @Nullable
+    D streamData(T accessor);
+
+    StreamCodec<RegistryFriendlyByteBuf, D> streamCodec();
+}

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/provider/block/BeehiveProvider.java

@@ -0,0 +1,51 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.protocol.jade.provider.block;
+
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.block.entity.BeehiveBlockEntity;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.protocol.jade.JadeProtocol;
+import org.leavesmc.leaves.protocol.jade.accessor.BlockAccessor;
+import org.leavesmc.leaves.protocol.jade.provider.StreamServerDataProvider;
+
+public enum BeehiveProvider implements StreamServerDataProvider<BlockAccessor, Byte> {
+    INSTANCE;
+
+    private static final ResourceLocation MC_BEEHIVE = JadeProtocol.mc_id("beehive");
+
+    @Override
+    public @NotNull StreamCodec<RegistryFriendlyByteBuf, Byte> streamCodec() {
+        return ByteBufCodecs.BYTE.cast();
+    }
+
+    @Override
+    public Byte streamData(@NotNull BlockAccessor accessor) {
+        BeehiveBlockEntity beehive = (BeehiveBlockEntity) accessor.getBlockEntity();
+        int bees = beehive.getOccupantCount();
+        return (byte) (beehive.isFull() ? bees : -bees);
+    }
+
+    @Override
+    public ResourceLocation getUid() {
+        return MC_BEEHIVE;
+    }
+}