Update gradle.properties

feat: add a config to revert MC-159283
Update upstream(Luminol)
2025-08-26 14:08:25 +08:00 · 2025-08-26 03:04:39 +08:00 · 2025-08-25 22:31:49 +08:00 · 2025-08-25 21:32:02 +08:00 · 2025-08-24 22:07:20 +08:00 · 2025-08-24 03:55:44 +08:00
48 changed files with 976 additions and 286 deletions
@@ -16,10 +16,10 @@ jobs:
    environment: default
    steps:
      - name: Checkout Git Repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5

      - name: Set up JDK
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
        with:
          distribution: zulu
          java-version: 21
@@ -2,7 +2,7 @@

 # Lophine

-<h4>Lophine 是一个基于Luminol的分支，具有许多有用的优化和可配置的原版特性，目标是在Folia上实现更多生电的实现</h4>
+<h4>Lophine 是一个基于Luminol的分支，具有许多有用的优化和可配置的原版特性，目标是在Folia上实现更多生电的内容（请注意，完整生电请使用Fabric）</h4>

 ![Created At](https://img.shields.io/github/created-at/LuminolMC/Lophine?style=flat-square)
 [![License](https://img.shields.io/github/license/LuminolMC/Lophine?style=flat-square)](LICENSE.md)
@@ -42,7 +42,7 @@
 ```kotlin
 repositories {
    maven {
-        url = "https://repo.menthamc.com/repository/maven-public/"
+        url = "https://repo.menthamc.org/repository/maven-public/"
    }
 }

@@ -57,7 +57,7 @@ dependencies {
 <repositories>
    <repository>
        <id>menthamc</id>
-        <url>https://repo.menthamc.com/repository/maven-public/</url>
+        <url>https://repo.menthamc.org/repository/maven-public/</url>
    </repository>
 </repositories>

@@ -3,7 +3,7 @@
 # Lophine

 <h4>Lophine is a Luminol fork with many useful optimizations and configurable vanilla features, aims to provide
-more function for survival-usable circuit on folia</h4>
+more function for survival-usable circuit on folia (Please note that Fabric should be used for complete survival-usable)</h4>

 ![Created At](https://img.shields.io/github/created-at/LuminolMC/Lophine?style=flat-square)
 [![License](https://img.shields.io/github/license/LuminolMC/Lophine?style=flat-square)](LICENSE.md)
@@ -43,7 +43,7 @@ For gradle:
 ```kotlin
 repositories {
    maven {
-        url = "https://repo.menthamc.com/repository/maven-public/"
+        url = "https://repo.menthamc.org/repository/maven-public/"
    }
 }

@@ -58,7 +58,7 @@ For maven
 <repositories>
    <repository>
        <id>menthamc</id>
-        <url>https://repo.menthamc.com/repository/maven-public/</url>
+        <url>https://repo.menthamc.org/repository/maven-public/</url>
    </repository>
 </repositories>

@@ -41,7 +41,7 @@ paperweight {
 }

 val paperMavenPublicUrl = "https://repo.papermc.io/repository/maven-public/"
-val menthaMavenPublicUrl = "https://repo.menthamc.com/repository/maven-public/";
+val menthaMavenPublicUrl = "https://repo.menthamc.org/repository/maven-public/";

 subprojects {
    apply(plugin = "java-library")
@@ -88,7 +88,7 @@ subprojects {

    extensions.configure<PublishingExtension> {
        repositories {
-            maven("https://repo.menthamc.com/repository/maven-snapshots/") {
+            maven("https://repo.menthamc.org/repository/maven-snapshots/") {
                name = "MenthaMC"
                credentials(PasswordCredentials::class) {
                    username = System.getenv("PRIVATE_MAVEN_REPO_USERNAME")
@@ -4,7 +4,7 @@ mcVersion=1.21.8
 release=2
 # 0 for skip release, 1 for pre-release, 2 for release

-luminolRef=baa7a4f47b93c32527ea671d16193af8def87486
+luminolRef=50f7c765e4dbd4abc6eac48fe3d5eaba372bfe98

 org.gradle.configuration-cache=true
 org.gradle.caching=true
@@ -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 a67fc80eb3182415557b4bdf7f146aefb43103da..52fec4c88fee3c027c954365538516aaa8335c7f 100644
+index 136b9e9c3bcb43698c653060665dc82444e09768..cc2b7b8f897570e5d079f80375c93cf2550df6af 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 {
@@ -17,11 +17,11 @@ index a67fc80eb3182415557b4bdf7f146aefb43103da..52fec4c88fee3c027c954365538516aa
     }
 
 diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/ServerModNameConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/ServerModNameConfig.java
-index ded1f0667327a70a923ebda55c41b1c9094d3e37..57ddc0832b919b115b85c81ac30f136e32f1e77e 100644
+index 997bc00dffbf5c15fde610c95527e8013ae57660..d94e11eb9f10c9622052c7b327ccfdf24de6ae73 100644
 --- a/src/main/java/me/earthme/luminol/config/modules/misc/ServerModNameConfig.java
 +++ b/src/main/java/me/earthme/luminol/config/modules/misc/ServerModNameConfig.java
-@@ -6,7 +6,7 @@ import me.earthme.luminol.config.flags.ConfigInfo;
- 
+@@ -8,7 +8,7 @@ import me.earthme.luminol.config.flags.ConfigInfo;
+ @ConfigClassInfo(configAttribution = EnumConfigCategory.MISC, mainName = "server_mod_name")
 public class ServerModNameConfig implements IConfigModule {
     @ConfigInfo(baseName = "name")
 -    public static String serverModName = "Luminol";
@@ -5,26 +5,26 @@ Subject: [PATCH] Transformed Configs


 diff --git a/src/main/java/me/earthme/luminol/config/modules/experiment/CommandBlockExecutionConfig.java b/src/main/java/me/earthme/luminol/config/modules/experiment/CommandBlockExecutionConfig.java
-index 531214d7ab28ece4bf84e82b39d1c9f983f0fb0c..b68fa0427bb975e91e76f73ab4cc089a424937a3 100644
+index 83d803d7d7f3cecdbcb593da70234aa9dd81a1ff..00ad1597bdb20118d756d9371c0d50890d0a5e8c 100644
 --- a/src/main/java/me/earthme/luminol/config/modules/experiment/CommandBlockExecutionConfig.java
 +++ b/src/main/java/me/earthme/luminol/config/modules/experiment/CommandBlockExecutionConfig.java
-@@ -5,6 +5,7 @@ import me.earthme.luminol.config.IConfigModule;
- import me.earthme.luminol.config.flags.ConfigInfo;
+@@ -7,6 +7,7 @@ import me.earthme.luminol.config.flags.ConfigInfo;
 
+ @ConfigClassInfo(configAttribution = EnumConfigCategory.EXPERIMENT, mainName = "force_enable_command_block_command_execution")
 public class CommandBlockExecutionConfig implements IConfigModule {
 +    @me.earthme.luminol.config.flags.TransformedConfig(name = "command_block_enabled", category = {"experiment", "command"}, originInstance = "lophine")
     @ConfigInfo(baseName = "enabled")
     public static boolean enabled = false;
- 
+ }
 diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/PaperPacketLimiterConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/PaperPacketLimiterConfig.java
-index c269446dda05cfc848407f80f53820c8fcd0c7b4..e69ffae53aa24496a29a4c4890cdcb366d2bec12 100644
+index 385612dd2e3bd2b4651ccfda41986ff7047067e4..4450ba56a491c15aea6ea9e1fed0e379660fbec5 100644
 --- a/src/main/java/me/earthme/luminol/config/modules/misc/PaperPacketLimiterConfig.java
 +++ b/src/main/java/me/earthme/luminol/config/modules/misc/PaperPacketLimiterConfig.java
-@@ -5,6 +5,7 @@ import me.earthme.luminol.config.IConfigModule;
- import me.earthme.luminol.config.flags.ConfigInfo;
+@@ -7,6 +7,7 @@ import me.earthme.luminol.config.flags.ConfigInfo;
 
+ @ConfigClassInfo(configAttribution = EnumConfigCategory.MISC, mainName = "force_disable_packet_limiter_of_paper")
 public class PaperPacketLimiterConfig implements IConfigModule {
 +    @me.earthme.luminol.config.flags.TransformedConfig(name = "unlimit-packet", category = {"misc", "network"}, originInstance = "lophine")
     @ConfigInfo(baseName = "force_disable")
     public static boolean forceDisable = false;
- 
+ }
@@ -8,114 +8,181 @@ 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 5995c499298454a060433746c64be5fcc8d202e2..3452399de0fa464ce04a7cf1a05b440346bef662 100644
+index 102de78be0eb82d6898b4104fad1bf5e8366f993..11891a66fe3232287238ea87289444586fbc9717 100644
 --- a/src/main/java/org/leavesmc/leaves/util/ItemOverstackUtils.java
 +++ b/src/main/java/org/leavesmc/leaves/util/ItemOverstackUtils.java
-@@ -17,29 +17,30 @@
+@@ -17,12 +17,173 @@
 
 package org.leavesmc.leaves.util;
 
 +import fun.bm.lophine.config.modules.misc.ContainerExpansionConfig;
- //import io.papermc.paper.datacomponent.DataComponentTypes;
- //import io.papermc.paper.datacomponent.item.ItemEnchantments;
- 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.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 net.minecraft.world.item.component.CustomData;
 +import net.minecraft.world.item.component.ItemContainerContents;
 +import net.minecraft.world.level.block.ShulkerBoxBlock;
- //import org.bukkit.enchantments.Enchantment;
-//import org.jetbrains.annotations.NotNull;
 +import org.jetbrains.annotations.NotNull;
- //import org.leavesmc.leaves.LeavesConfig;
- 
- import java.util.List;
-//import java.util.Objects;
+
+import java.util.List;
 +import java.util.Objects;
- import java.util.Optional;
+import java.util.Optional;
 
+ // Only the used part is retained
 public class ItemOverstackUtils {
- 
-     private static final List<ItemUtil> overstackUtils = List.of(
-/*        new ShulkerBox(),
-        new CurseEnchantedBook()*/
+    private static final List<ItemUtil> overstackUtils = List.of(
 +            new ShulkerBox()
-+            // new CurseEnchantedBook() // only use shulker box part
-     );
- 
-     public static int getItemStackMaxCount(ItemStack stack) {
-@@ -109,6 +110,7 @@ public class ItemOverstackUtils {
- 
+    );
+
+    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());
-+        // only use shulker box part
- /*        if (LeavesConfig.modify.oldMC.allowGrindstoneOverstacking && CurseEnchantedBook.isCursedEnchantedBook(itemStack)) {
-             return result;
-         }*/
-@@ -134,9 +136,9 @@ public class ItemOverstackUtils {
-         }
+         return Math.clamp(result, 0f, 1f);
     }
- 
-/*    private static class ShulkerBox implements ItemUtil {
+
+    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) {
-            if (LeavesConfig.modify.shulkerBox.sameNbtStackable) {
+        public static boolean shulkerBoxCheck(@NotNull ItemStack stack1, @NotNull ItemStack stack2) {
 +            if (ContainerExpansionConfig.nbtShulkerStackable) {
-                 return Objects.equals(stack1.getComponents(), stack2.getComponents());
-             }
-             return shulkerBoxNoItem(stack1) && shulkerBoxNoItem(stack2) && Objects.equals(stack1.getComponents(), stack2.getComponents());
-@@ -148,24 +150,24 @@ public class ItemOverstackUtils {
- 
-         @Override
-         public boolean isEnabled() {
-            return LeavesConfig.modify.shulkerBox.shulkerBoxStackSize > 1;
+                return Objects.equals(stack1.getComponents(), stack2.getComponents());
+            }
+            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 ContainerExpansionConfig.shulkerCount > 1;
-         }
- 
-         @Override
-         public boolean tryStackItems(ItemEntity self, ItemEntity other) {
-             ItemStack selfStack = self.getItem();
-             if (!isEnabled() ||
-                !(selfStack.getItem() instanceof BlockItem blockItem) ||
-                !(blockItem.getBlock() instanceof ShulkerBoxBlock)
+        }
+
+        @Override
+        public boolean tryStackItems(ItemEntity self, ItemEntity other) {
+            ItemStack selfStack = self.getItem();
+            if (!isEnabled() ||
 +                    !(selfStack.getItem() instanceof BlockItem blockItem) ||
 +                    !(blockItem.getBlock() instanceof ShulkerBoxBlock)
-             ) {
-                 return false;
-             }
- 
-             ItemStack otherStack = other.getItem();
-             if (selfStack.getItem() == otherStack.getItem()
-                && shulkerBoxCheck(selfStack, otherStack)
-                && selfStack.getCount() != org.leavesmc.leaves.LeavesConfig.modify.shulkerBox.shulkerBoxStackSize) {
-                int amount = Math.min(otherStack.getCount(), org.leavesmc.leaves.LeavesConfig.modify.shulkerBox.shulkerBoxStackSize - selfStack.getCount());
+            ) {
+                return false;
+            }
+
+            ItemStack otherStack = other.getItem();
+            if (selfStack.getItem() == otherStack.getItem()
 +                    && shulkerBoxCheck(selfStack, otherStack)
 +                    && selfStack.getCount() != ContainerExpansionConfig.shulkerCount) {
 +                int amount = Math.min(otherStack.getCount(), ContainerExpansionConfig.shulkerCount - selfStack.getCount());
- 
-                 selfStack.grow(amount);
-                 self.setItem(selfStack);
-@@ -187,14 +189,15 @@ 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))) {
-                return LeavesConfig.modify.shulkerBox.shulkerBoxStackSize;
+
+                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 &&
 +                    bi.getBlock() instanceof ShulkerBoxBlock && (ContainerExpansionConfig.nbtShulkerStackable || shulkerBoxNoItem(stack))) {
 +                return ContainerExpansionConfig.shulkerCount;
-             }
-             return -1;
-         }
-     }
- 
-    public static class CurseEnchantedBook implements ItemUtil {
-+// only use shulker box part
-+/*    public static class CurseEnchantedBook implements ItemUtil {
-         public static boolean isCursedEnchantedBook(ItemStack stack) {
-             ItemEnchantments enchantments = stack.getBukkitStack().getData(DataComponentTypes.STORED_ENCHANTMENTS);
-             if (enchantments == null || enchantments.enchantments().size() != 1) {
+            }
+            return -1;
+        }
+    }
+ }
+\ No newline at end of file
@@ -1,27 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Helvetica Volubi <suisuroru@blue-millennium.fun>
-Date: Wed, 21 May 2025 13:04:00 +0800
-Subject: [PATCH] Add config to disable end crystal check
-
-
-diff --git a/net/minecraft/world/level/dimension/end/EndDragonFight.java b/net/minecraft/world/level/dimension/end/EndDragonFight.java
-index 4fa8371c212dcc02b8cf5fd267b736e1cf3f50c1..3f1520bdd5ef708824712ea62974fedb35067f23 100644
--- a/net/minecraft/world/level/dimension/end/EndDragonFight.java
-+++ b/net/minecraft/world/level/dimension/end/EndDragonFight.java
-@@ -547,6 +547,8 @@ public class EndDragonFight {
- 
-                 blockPos = this.portalLocation;
-             }
-+            // Luminol start - Disable end crystal check
-+            if (!fun.bm.lophine.config.modules.fixes.DisableEndCrystalCheckConfig.disableCheck) {
-             // Paper start - Perf: Do crystal-portal proximity check before entity lookup
-             if (placedEndCrystalPos != null) {
-                 // The end crystal must be 0 or 1 higher than the portal origin
-@@ -562,6 +564,7 @@ public class EndDragonFight {
-                 }
-             }
-             // Paper end - Perf: Do crystal-portal proximity check before entity lookup
-+            } // Luminol end - Disable end crystal check
- 
- 
-             List<EndCrystal> list = Lists.newArrayList();
@@ -18,7 +18,7 @@ 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 75f327fff68097c1c9f65767552f686421e1e397..ed7421895311d89ad9726804893eff423868d375 100644
+index 125412d16d1a66dadfe4bbf64629c4052e0c7647..ccb05b6e328a29eea4761721b496ab36ba362361 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;
@@ -30,7 +30,7 @@ index 75f327fff68097c1c9f65767552f686421e1e397..ed7421895311d89ad9726804893eff42
     // 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
-@@ -6467,4 +6467,46 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -6472,4 +6472,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
@@ -88,7 +88,7 @@ index a0f1db50adf5163a671d3d9e9df7adb7de4250c6..af13707933af14171447d5ab6faacb64
     public int getSpawnProtectionRadius() {
         return 16;
 diff --git a/net/minecraft/server/network/ServerCommonPacketListenerImpl.java b/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
-index 714813cba67da4a737682fe9276cb0d96fea336d..9677a3d62de11dafc8b9debe7a18ee6d14c7a64d 100644
+index 8150b16c196edcb226be9268ea6e0012e44517fa..c54bf0429c0ca3a35a730658c7b1b3ddc776bf9e 100644
 --- a/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
 +++ b/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
@@ -57,6 +57,7 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
@@ -446,7 +446,7 @@ index 10b2cc20bbf3b70e4e09dbbe14b90506e6366158..1535bb8cec8692e8d26eaff090288f1b
     }
 
 diff --git a/net/minecraft/world/level/block/entity/HopperBlockEntity.java b/net/minecraft/world/level/block/entity/HopperBlockEntity.java
-index 2f8128a11e316a6ee6b283f9a411096e582c03b7..5b93eeba6c03738011551ce18332cebe9e278a8e 100644
+index b78d23ab22a74db2e16707424ed14f5760edf5b4..486181bf59f0863a7b60749a0b75b5ac79e2e470 100644
 --- a/net/minecraft/world/level/block/entity/HopperBlockEntity.java
 +++ b/net/minecraft/world/level/block/entity/HopperBlockEntity.java
@@ -145,7 +145,7 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
@@ -70,10 +70,10 @@ index 0fffa384f928ab84451331380968fb4650eafe26..d84a10396395939149da88bcb01be59e
         return new ChestMenu(MenuType.GENERIC_9x6, containerId, playerInventory, container, 6);
     }
 diff --git a/net/minecraft/world/inventory/PlayerEnderChestContainer.java b/net/minecraft/world/inventory/PlayerEnderChestContainer.java
-index beb74bc8398de8b48f41af7daef14d624826310e..5dd6e89931d397b8afdb84024ed46b0d06dcf347 100644
+index 51148b7b95c93a9e25da70ac9275c63f1458d84c..b6bceae1ec26685af485bfe9d846f7584d5012cd 100644
 --- a/net/minecraft/world/inventory/PlayerEnderChestContainer.java
 +++ b/net/minecraft/world/inventory/PlayerEnderChestContainer.java
-@@ -25,11 +25,18 @@ public class PlayerEnderChestContainer extends SimpleContainer {
+@@ -26,11 +26,18 @@ public class PlayerEnderChestContainer extends SimpleContainer {
     }
 
     public PlayerEnderChestContainer(Player owner) {
@@ -31,7 +31,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 c6c6432c2efeb7b95c2894b188cd966321ae3186..1cd9af71ee66df5f277748c0a5a59a30bd57accc 100644
+index ec07d916ff52f5a866218c2fa4d632b83675faf2..eabaae86e4951046db5d1bae9abb92f1bece100f 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
@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Tue, 26 Aug 2025 02:55:23 +0800
+Subject: [PATCH] Add config to allow to generate end void rings
+
+
+diff --git a/net/minecraft/world/level/levelgen/DensityFunctions.java b/net/minecraft/world/level/levelgen/DensityFunctions.java
+index 04527a5c65ad630f794fed9071d485aedd02257a..ed4408e6a98b12b91382d23fdfeeb69c6926d038 100644
+--- a/net/minecraft/world/level/levelgen/DensityFunctions.java
+++ b/net/minecraft/world/level/levelgen/DensityFunctions.java
+@@ -528,7 +528,7 @@ public final class DensityFunctions {
+             int i1 = z / 2;
+             int i2 = x % 2;
+             int i3 = z % 2;
+-            float f = 100.0F - Mth.sqrt((long)x * (long)x + (long)z * (long)z) * 8.0F; // Paper - cast ints to long to avoid integer overflow
+            float f = fun.bm.lophine.config.modules.gameplay.EndVoidRingsConfig.enabled ? 100.0F - Mth.sqrt(x * x + z * z) * 8.0F : 100.0F - Mth.sqrt((long)x * (long)x + (long)z * (long)z) * 8.0F; // Paper - cast ints to long to avoid integer overflow // Lophine - optimize end void rings generation
+             f = Mth.clamp(f, -100.0F, 80.0F);
+ 
+             NoiseCache cache = noiseCache.get().computeIfAbsent(noise, noiseKey -> new NoiseCache()); // Paper - Perf: Optimize end generation
@@ -0,0 +1,34 @@
+package com.logisticscraft.occlusionculling;
+
+import com.logisticscraft.occlusionculling.util.Vec3d;
+
+public interface DataProvider {
+
+    /**
+     * Prepares the requested chunk. Returns true if the chunk is ready, false when
+     * not loaded. Should not reload the chunk when the x and y are the same as the
+     * last request!
+     *
+     * @param chunkX
+     * @param chunkZ
+     * @return
+     */
+    boolean prepareChunk(int chunkX, int chunkZ);
+
+    /**
+     * Location is inside the chunk.
+     *
+     * @param x
+     * @param y
+     * @param z
+     * @return
+     */
+    boolean isOpaqueFullCube(int x, int y, int z);
+
+    default void cleanup() {
+    }
+
+    default void checkingPosition(Vec3d[] targetPoints, int size, Vec3d viewerPosition) {
+    }
+
+}
@@ -0,0 +1,515 @@
+package com.logisticscraft.occlusionculling;
+
+import com.logisticscraft.occlusionculling.cache.ArrayOcclusionCache;
+import com.logisticscraft.occlusionculling.cache.OcclusionCache;
+import com.logisticscraft.occlusionculling.util.MathUtilities;
+import com.logisticscraft.occlusionculling.util.Vec3d;
+
+import java.util.Arrays;
+import java.util.BitSet;
+
+public class OcclusionCullingInstance {
+
+    private static final int ON_MIN_X = 0x01;
+    private static final int ON_MAX_X = 0x02;
+    private static final int ON_MIN_Y = 0x04;
+    private static final int ON_MAX_Y = 0x08;
+    private static final int ON_MIN_Z = 0x10;
+    private static final int ON_MAX_Z = 0x20;
+
+    private final int reach;
+    private final double aabbExpansion;
+    private final DataProvider provider;
+    private final OcclusionCache cache;
+
+    // Reused allocated data structures
+    private final BitSet skipList = new BitSet(); // Grows bigger in case some mod introduces giant hitboxes
+    private final Vec3d[] targetPoints = new Vec3d[15];
+    private final Vec3d targetPos = new Vec3d(0, 0, 0);
+    private final int[] cameraPos = new int[3];
+    private final boolean[] dotselectors = new boolean[14];
+    private boolean allowRayChecks = false;
+    private final int[] lastHitBlock = new int[3];
+    private boolean allowWallClipping = false;
+
+
+    public OcclusionCullingInstance(int maxDistance, DataProvider provider) {
+        this(maxDistance, provider, new ArrayOcclusionCache(maxDistance), 0.5);
+    }
+
+    public OcclusionCullingInstance(int maxDistance, DataProvider provider, OcclusionCache cache, double aabbExpansion) {
+        this.reach = maxDistance;
+        this.provider = provider;
+        this.cache = cache;
+        this.aabbExpansion = aabbExpansion;
+        for (int i = 0; i < targetPoints.length; i++) {
+            targetPoints[i] = new Vec3d(0, 0, 0);
+        }
+    }
+
+    public boolean isAABBVisible(Vec3d aabbMin, Vec3d aabbMax, Vec3d viewerPosition) {
+        try {
+            int maxX = MathUtilities.floor(aabbMax.x
+                    + aabbExpansion);
+            int maxY = MathUtilities.floor(aabbMax.y
+                    + aabbExpansion);
+            int maxZ = MathUtilities.floor(aabbMax.z
+                    + aabbExpansion);
+            int minX = MathUtilities.floor(aabbMin.x
+                    - aabbExpansion);
+            int minY = MathUtilities.floor(aabbMin.y
+                    - aabbExpansion);
+            int minZ = MathUtilities.floor(aabbMin.z
+                    - aabbExpansion);
+
+            cameraPos[0] = MathUtilities.floor(viewerPosition.x);
+            cameraPos[1] = MathUtilities.floor(viewerPosition.y);
+            cameraPos[2] = MathUtilities.floor(viewerPosition.z);
+
+            Relative relX = Relative.from(minX, maxX, cameraPos[0]);
+            Relative relY = Relative.from(minY, maxY, cameraPos[1]);
+            Relative relZ = Relative.from(minZ, maxZ, cameraPos[2]);
+
+            if (relX == Relative.INSIDE && relY == Relative.INSIDE && relZ == Relative.INSIDE) {
+                return true; // We are inside of the AABB, don't cull
+            }
+
+            skipList.clear();
+
+            // Just check the cache first
+            int id = 0;
+            for (int x = minX; x <= maxX; x++) {
+                for (int y = minY; y <= maxY; y++) {
+                    for (int z = minZ; z <= maxZ; z++) {
+                        int cachedValue = getCacheValue(x, y, z);
+
+                        if (cachedValue == 1) {
+                            // non-occluding
+                            return true;
+                        }
+
+                        if (cachedValue != 0) {
+                            // was checked and it wasn't visible
+                            skipList.set(id);
+                        }
+                        id++;
+                    }
+                }
+            }
+
+            // only after the first hit wall the cache becomes valid.
+            allowRayChecks = false;
+
+            // since the cache wasn't helpfull 
+            id = 0;
+            for (int x = minX; x <= maxX; x++) {
+                byte visibleOnFaceX = 0;
+                byte faceEdgeDataX = 0;
+                faceEdgeDataX |= (x == minX) ? ON_MIN_X : 0;
+                faceEdgeDataX |= (x == maxX) ? ON_MAX_X : 0;
+                visibleOnFaceX |= (x == minX && relX == Relative.POSITIVE) ? ON_MIN_X : 0;
+                visibleOnFaceX |= (x == maxX && relX == Relative.NEGATIVE) ? ON_MAX_X : 0;
+                for (int y = minY; y <= maxY; y++) {
+                    byte faceEdgeDataY = faceEdgeDataX;
+                    byte visibleOnFaceY = visibleOnFaceX;
+                    faceEdgeDataY |= (y == minY) ? ON_MIN_Y : 0;
+                    faceEdgeDataY |= (y == maxY) ? ON_MAX_Y : 0;
+                    visibleOnFaceY |= (y == minY && relY == Relative.POSITIVE) ? ON_MIN_Y : 0;
+                    visibleOnFaceY |= (y == maxY && relY == Relative.NEGATIVE) ? ON_MAX_Y : 0;
+                    for (int z = minZ; z <= maxZ; z++) {
+                        byte faceEdgeData = faceEdgeDataY;
+                        byte visibleOnFace = visibleOnFaceY;
+                        faceEdgeData |= (z == minZ) ? ON_MIN_Z : 0;
+                        faceEdgeData |= (z == maxZ) ? ON_MAX_Z : 0;
+                        visibleOnFace |= (z == minZ && relZ == Relative.POSITIVE) ? ON_MIN_Z : 0;
+                        visibleOnFace |= (z == maxZ && relZ == Relative.NEGATIVE) ? ON_MAX_Z : 0;
+                        if (skipList.get(id)) { // was checked and it wasn't visible
+                            id++;
+                            continue;
+                        }
+
+                        if (visibleOnFace != 0) {
+                            targetPos.set(x, y, z);
+                            if (isVoxelVisible(viewerPosition, targetPos, faceEdgeData, visibleOnFace)) {
+                                return true;
+                            }
+                        }
+                        id++;
+                    }
+                }
+            }
+
+            return false;
+        } catch (Throwable t) {
+            // Failsafe
+            t.printStackTrace();
+        }
+        return true;
+    }
+
+    /**
+     * @param viewerPosition
+     * @param position
+     * @param faceData       contains rather this Block is on the outside for a given face
+     * @param visibleOnFace  contains rather a face should be concidered
+     * @return
+     */
+    private boolean isVoxelVisible(Vec3d viewerPosition, Vec3d position, byte faceData, byte visibleOnFace) {
+        int targetSize = 0;
+        Arrays.fill(dotselectors, false);
+        if ((visibleOnFace & ON_MIN_X) == ON_MIN_X) {
+            dotselectors[0] = true;
+            if ((faceData & ~ON_MIN_X) != 0) {
+                dotselectors[1] = true;
+                dotselectors[4] = true;
+                dotselectors[5] = true;
+            }
+            dotselectors[8] = true;
+        }
+        if ((visibleOnFace & ON_MIN_Y) == ON_MIN_Y) {
+            dotselectors[0] = true;
+            if ((faceData & ~ON_MIN_Y) != 0) {
+                dotselectors[3] = true;
+                dotselectors[4] = true;
+                dotselectors[7] = true;
+            }
+            dotselectors[9] = true;
+        }
+        if ((visibleOnFace & ON_MIN_Z) == ON_MIN_Z) {
+            dotselectors[0] = true;
+            if ((faceData & ~ON_MIN_Z) != 0) {
+                dotselectors[1] = true;
+                dotselectors[4] = true;
+                dotselectors[5] = true;
+            }
+            dotselectors[10] = true;
+        }
+        if ((visibleOnFace & ON_MAX_X) == ON_MAX_X) {
+            dotselectors[4] = true;
+            if ((faceData & ~ON_MAX_X) != 0) {
+                dotselectors[5] = true;
+                dotselectors[6] = true;
+                dotselectors[7] = true;
+            }
+            dotselectors[11] = true;
+        }
+        if ((visibleOnFace & ON_MAX_Y) == ON_MAX_Y) {
+            dotselectors[1] = true;
+            if ((faceData & ~ON_MAX_Y) != 0) {
+                dotselectors[2] = true;
+                dotselectors[5] = true;
+                dotselectors[6] = true;
+            }
+            dotselectors[12] = true;
+        }
+        if ((visibleOnFace & ON_MAX_Z) == ON_MAX_Z) {
+            dotselectors[2] = true;
+            if ((faceData & ~ON_MAX_Z) != 0) {
+                dotselectors[3] = true;
+                dotselectors[6] = true;
+                dotselectors[7] = true;
+            }
+            dotselectors[13] = true;
+        }
+
+        if (dotselectors[0]) targetPoints[targetSize++].setAdd(position, 0.05, 0.05, 0.05);
+        if (dotselectors[1]) targetPoints[targetSize++].setAdd(position, 0.05, 0.95, 0.05);
+        if (dotselectors[2]) targetPoints[targetSize++].setAdd(position, 0.05, 0.95, 0.95);
+        if (dotselectors[3]) targetPoints[targetSize++].setAdd(position, 0.05, 0.05, 0.95);
+        if (dotselectors[4]) targetPoints[targetSize++].setAdd(position, 0.95, 0.05, 0.05);
+        if (dotselectors[5]) targetPoints[targetSize++].setAdd(position, 0.95, 0.95, 0.05);
+        if (dotselectors[6]) targetPoints[targetSize++].setAdd(position, 0.95, 0.95, 0.95);
+        if (dotselectors[7]) targetPoints[targetSize++].setAdd(position, 0.95, 0.05, 0.95);
+        // middle points
+        if (dotselectors[8]) targetPoints[targetSize++].setAdd(position, 0.05, 0.5, 0.5);
+        if (dotselectors[9]) targetPoints[targetSize++].setAdd(position, 0.5, 0.05, 0.5);
+        if (dotselectors[10]) targetPoints[targetSize++].setAdd(position, 0.5, 0.5, 0.05);
+        if (dotselectors[11]) targetPoints[targetSize++].setAdd(position, 0.95, 0.5, 0.5);
+        if (dotselectors[12]) targetPoints[targetSize++].setAdd(position, 0.5, 0.95, 0.5);
+        if (dotselectors[13]) targetPoints[targetSize++].setAdd(position, 0.5, 0.5, 0.95);
+
+        return isVisible(viewerPosition, targetPoints, targetSize);
+    }
+
+    private boolean rayIntersection(int[] b, Vec3d rayOrigin, Vec3d rayDir) {
+        Vec3d rInv = new Vec3d(1, 1, 1).div(rayDir);
+
+        double t1 = (b[0] - rayOrigin.x) * rInv.x;
+        double t2 = (b[0] + 1 - rayOrigin.x) * rInv.x;
+        double t3 = (b[1] - rayOrigin.y) * rInv.y;
+        double t4 = (b[1] + 1 - rayOrigin.y) * rInv.y;
+        double t5 = (b[2] - rayOrigin.z) * rInv.z;
+        double t6 = (b[2] + 1 - rayOrigin.z) * rInv.z;
+
+        double tmin = Math.max(Math.max(Math.min(t1, t2), Math.min(t3, t4)), Math.min(t5, t6));
+        double tmax = Math.min(Math.min(Math.max(t1, t2), Math.max(t3, t4)), Math.max(t5, t6));
+
+        // if tmax > 0, ray (line) is intersecting AABB, but the whole AABB is behind us
+        if (tmax > 0) {
+            return false;
+        }
+
+        // if tmin > tmax, ray doesn't intersect AABB
+        if (tmin > tmax) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * returns the grid cells that intersect with this Vec3d<br>
+     * <a href=
+     * "http://playtechs.blogspot.de/2007/03/raytracing-on-grid.html">http://playtechs.blogspot.de/2007/03/raytracing-on-grid.html</a>
+     * <p>
+     * Caching assumes that all Vec3d's are inside the same block
+     */
+    private boolean isVisible(Vec3d start, Vec3d[] targets, int size) {
+        // start cell coordinate
+        int x = cameraPos[0];
+        int y = cameraPos[1];
+        int z = cameraPos[2];
+
+        for (int v = 0; v < size; v++) {
+            // ray-casting target
+            Vec3d target = targets[v];
+
+            double relativeX = start.x - target.getX();
+            double relativeY = start.y - target.getY();
+            double relativeZ = start.z - target.getZ();
+
+            if (allowRayChecks && rayIntersection(lastHitBlock, start, new Vec3d(relativeX, relativeY, relativeZ).normalize())) {
+                continue;
+            }
+
+            // horizontal and vertical cell amount spanned
+            double dimensionX = Math.abs(relativeX);
+            double dimensionY = Math.abs(relativeY);
+            double dimensionZ = Math.abs(relativeZ);
+
+            // distance between horizontal intersection points with cell border as a
+            // fraction of the total Vec3d length
+            double dimFracX = 1f / dimensionX;
+            // distance between vertical intersection points with cell border as a fraction
+            // of the total Vec3d length
+            double dimFracY = 1f / dimensionY;
+            double dimFracZ = 1f / dimensionZ;
+
+            // total amount of intersected cells
+            int intersectCount = 1;
+
+            // 1, 0 or -1
+            // determines the direction of the next cell (horizontally / vertically)
+            int x_inc, y_inc, z_inc;
+
+            // the distance to the next horizontal / vertical intersection point with a cell
+            // border as a fraction of the total Vec3d length
+            double t_next_y, t_next_x, t_next_z;
+
+            if (dimensionX == 0f) {
+                x_inc = 0;
+                t_next_x = dimFracX; // don't increment horizontally because the Vec3d is perfectly vertical
+            } else if (target.x > start.x) {
+                x_inc = 1; // target point is horizontally greater than starting point so increment every
+                // step by 1
+                intersectCount += MathUtilities.floor(target.x) - x; // increment total amount of intersecting cells
+                t_next_x = (float) ((x + 1 - start.x) * dimFracX); // calculate the next horizontal
+                // intersection
+                // point based on the position inside
+                // the first cell
+            } else {
+                x_inc = -1; // target point is horizontally smaller than starting point so reduce every step
+                // by 1
+                intersectCount += x - MathUtilities.floor(target.x); // increment total amount of intersecting cells
+                t_next_x = (float) ((start.x - x)
+                        * dimFracX); // calculate the next horizontal
+                // intersection point
+                // based on the position inside
+                // the first cell
+            }
+
+            if (dimensionY == 0f) {
+                y_inc = 0;
+                t_next_y = dimFracY; // don't increment vertically because the Vec3d is perfectly horizontal
+            } else if (target.y > start.y) {
+                y_inc = 1; // target point is vertically greater than starting point so increment every
+                // step by 1
+                intersectCount += MathUtilities.floor(target.y) - y; // increment total amount of intersecting cells
+                t_next_y = (float) ((y + 1 - start.y)
+                        * dimFracY); // calculate the next vertical
+                // intersection
+                // point based on the position inside
+                // the first cell
+            } else {
+                y_inc = -1; // target point is vertically smaller than starting point so reduce every step
+                // by 1
+                intersectCount += y - MathUtilities.floor(target.y); // increment total amount of intersecting cells
+                t_next_y = (float) ((start.y - y)
+                        * dimFracY); // calculate the next vertical intersection
+                // point
+                // based on the position inside
+                // the first cell
+            }
+
+            if (dimensionZ == 0f) {
+                z_inc = 0;
+                t_next_z = dimFracZ; // don't increment vertically because the Vec3d is perfectly horizontal
+            } else if (target.z > start.z) {
+                z_inc = 1; // target point is vertically greater than starting point so increment every
+                // step by 1
+                intersectCount += MathUtilities.floor(target.z) - z; // increment total amount of intersecting cells
+                t_next_z = (float) ((z + 1 - start.z)
+                        * dimFracZ); // calculate the next vertical
+                // intersection
+                // point based on the position inside
+                // the first cell
+            } else {
+                z_inc = -1; // target point is vertically smaller than starting point so reduce every step
+                // by 1
+                intersectCount += z - MathUtilities.floor(target.z); // increment total amount of intersecting cells
+                t_next_z = (float) ((start.z - z)
+                        * dimFracZ); // calculate the next vertical intersection
+                // point
+                // based on the position inside
+                // the first cell
+            }
+
+            boolean finished = stepRay(start, x, y, z,
+                    dimFracX, dimFracY, dimFracZ, intersectCount, x_inc, y_inc,
+                    z_inc, t_next_y, t_next_x, t_next_z);
+            provider.cleanup();
+            if (finished) {
+                cacheResult(targets[0], true);
+                return true;
+            } else {
+                allowRayChecks = true;
+            }
+        }
+        cacheResult(targets[0], false);
+        return false;
+    }
+
+    private boolean stepRay(Vec3d start, int currentX, int currentY,
+                            int currentZ, double distInX, double distInY,
+                            double distInZ, int n, int x_inc, int y_inc,
+                            int z_inc, double t_next_y, double t_next_x,
+                            double t_next_z) {
+        allowWallClipping = true; // initially allow rays to go through walls till they are on the outside
+        // iterate through all intersecting cells (n times)
+        for (; n > 1; n--) { // n-1 times because we don't want to check the last block
+            // towards - where from
+
+
+            // get cached value, 0 means uncached (default)
+            int cVal = getCacheValue(currentX, currentY, currentZ);
+
+            if (cVal == 2 && !allowWallClipping) {
+                // block cached as occluding, stop ray
+                lastHitBlock[0] = currentX;
+                lastHitBlock[1] = currentY;
+                lastHitBlock[2] = currentZ;
+                return false;
+            }
+
+            if (cVal == 0) {
+                // save current cell
+                int chunkX = currentX >> 4;
+                int chunkZ = currentZ >> 4;
+
+                if (!provider.prepareChunk(chunkX, chunkZ)) { // Chunk not ready
+                    return false;
+                }
+
+                if (provider.isOpaqueFullCube(currentX, currentY, currentZ)) {
+                    if (!allowWallClipping) {
+                        cache.setLastHidden();
+                        lastHitBlock[0] = currentX;
+                        lastHitBlock[1] = currentY;
+                        lastHitBlock[2] = currentZ;
+                        return false;
+                    }
+                } else {
+                    // outside of wall, now clipping is not allowed
+                    allowWallClipping = false;
+                    cache.setLastVisible();
+                }
+            }
+
+            if (cVal == 1) {
+                // outside of wall, now clipping is not allowed
+                allowWallClipping = false;
+            }
+
+
+            if (t_next_y < t_next_x && t_next_y < t_next_z) { // next cell is upwards/downwards because the distance to
+                // the next vertical
+                // intersection point is smaller than to the next horizontal intersection point
+                currentY += y_inc; // move up/down
+                t_next_y += distInY; // update next vertical intersection point
+            } else if (t_next_x < t_next_y && t_next_x < t_next_z) { // next cell is right/left
+                currentX += x_inc; // move right/left
+                t_next_x += distInX; // update next horizontal intersection point
+            } else {
+                currentZ += z_inc; // move right/left
+                t_next_z += distInZ; // update next horizontal intersection point
+            }
+
+        }
+        return true;
+    }
+
+    // -1 = invalid location, 0 = not checked yet, 1 = visible, 2 = occluding
+    private int getCacheValue(int x, int y, int z) {
+        x -= cameraPos[0];
+        y -= cameraPos[1];
+        z -= cameraPos[2];
+        if (Math.abs(x) > reach - 2 || Math.abs(y) > reach - 2
+                || Math.abs(z) > reach - 2) {
+            return -1;
+        }
+
+        // check if target is already known
+        return cache.getState(x + reach, y + reach, z + reach);
+    }
+
+
+    private void cacheResult(int x, int y, int z, boolean result) {
+        int cx = x - cameraPos[0] + reach;
+        int cy = y - cameraPos[1] + reach;
+        int cz = z - cameraPos[2] + reach;
+        if (result) {
+            cache.setVisible(cx, cy, cz);
+        } else {
+            cache.setHidden(cx, cy, cz);
+        }
+    }
+
+    private void cacheResult(Vec3d vector, boolean result) {
+        int cx = MathUtilities.floor(vector.x) - cameraPos[0] + reach;
+        int cy = MathUtilities.floor(vector.y) - cameraPos[1] + reach;
+        int cz = MathUtilities.floor(vector.z) - cameraPos[2] + reach;
+        if (result) {
+            cache.setVisible(cx, cy, cz);
+        } else {
+            cache.setHidden(cx, cy, cz);
+        }
+    }
+
+    public void resetCache() {
+        this.cache.resetCache();
+    }
+
+    private enum Relative {
+        INSIDE, POSITIVE, NEGATIVE;
+
+        public static Relative from(int min, int max, int pos) {
+            if (max > pos && min > pos) {
+                return POSITIVE;
+            } else if (min < pos && max < pos) {
+                return NEGATIVE;
+            }
+            return INSIDE;
+        }
+    }
+
+}
@@ -0,0 +1,57 @@
+package com.logisticscraft.occlusionculling.cache;
+
+import java.util.Arrays;
+
+public class ArrayOcclusionCache implements OcclusionCache {
+
+    private final int reachX2;
+    private final byte[] cache;
+    private int positionKey;
+    private int entry;
+    private int offset;
+
+    public ArrayOcclusionCache(int reach) {
+        this.reachX2 = reach * 2;
+        this.cache = new byte[(reachX2 * reachX2 * reachX2) / 4];
+    }
+
+    @Override
+    public void resetCache() {
+        Arrays.fill(cache, (byte) 0);
+    }
+
+    @Override
+    public void setVisible(int x, int y, int z) {
+        positionKey = x + y * reachX2 + z * reachX2 * reachX2;
+        entry = positionKey / 4;
+        offset = (positionKey % 4) * 2;
+        cache[entry] |= 1 << offset;
+    }
+
+    @Override
+    public void setHidden(int x, int y, int z) {
+        positionKey = x + y * reachX2 + z * reachX2 * reachX2;
+        entry = positionKey / 4;
+        offset = (positionKey % 4) * 2;
+        cache[entry] |= 1 << offset + 1;
+    }
+
+    @Override
+    public int getState(int x, int y, int z) {
+        positionKey = x + y * reachX2 + z * reachX2 * reachX2;
+        entry = positionKey / 4;
+        offset = (positionKey % 4) * 2;
+        return cache[entry] >> offset & 3;
+    }
+
+    @Override
+    public void setLastVisible() {
+        cache[entry] |= 1 << offset;
+    }
+
+    @Override
+    public void setLastHidden() {
+        cache[entry] |= 1 << offset + 1;
+    }
+
+}
@@ -0,0 +1,17 @@
+package com.logisticscraft.occlusionculling.cache;
+
+public interface OcclusionCache {
+
+    void resetCache();
+
+    void setVisible(int x, int y, int z);
+
+    void setHidden(int x, int y, int z);
+
+    int getState(int x, int y, int z);
+
+    void setLastHidden();
+
+    void setLastVisible();
+
+}
@@ -0,0 +1,25 @@
+package com.logisticscraft.occlusionculling.util;
+
+/**
+ * Contains MathHelper methods
+ */
+public final class MathUtilities {
+
+    private MathUtilities() {
+    }
+
+    public static int floor(double d) {
+        int i = (int) d;
+        return d < (double) i ? i - 1 : i;
+    }
+
+    public static int fastFloor(double d) {
+        return (int) (d + 1024.0) - 1024;
+    }
+
+    public static int ceil(double d) {
+        int i = (int) d;
+        return d > (double) i ? i + 1 : i;
+    }
+
+}
@@ -0,0 +1,87 @@
+package com.logisticscraft.occlusionculling.util;
+
+public class Vec3d {
+
+    public double x;
+    public double y;
+    public double z;
+
+    public Vec3d(double x, double y, double z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    public double getX() {
+        return x;
+    }
+
+    public double getY() {
+        return y;
+    }
+
+    public double getZ() {
+        return z;
+    }
+
+    public void set(double x, double y, double z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    public void setAdd(Vec3d vec, double x, double y, double z) {
+        this.x = vec.x + x;
+        this.y = vec.y + y;
+        this.z = vec.z + z;
+    }
+
+    public Vec3d div(Vec3d rayDir) {
+        this.x /= rayDir.x;
+        this.z /= rayDir.z;
+        this.y /= rayDir.y;
+        return this;
+    }
+
+    public Vec3d normalize() {
+        double mag = Math.sqrt(x * x + y * y + z * z);
+        this.x /= mag;
+        this.y /= mag;
+        this.z /= mag;
+        return this;
+    }
+
+    public boolean equals(Object other) {
+        if (this == other) {
+            return true;
+        }
+        if (!(other instanceof Vec3d)) {
+            return false;
+        }
+        Vec3d vec3d = (Vec3d) other;
+        if (Double.compare(vec3d.x, x) != 0) {
+            return false;
+        }
+        if (Double.compare(vec3d.y, y) != 0) {
+            return false;
+        }
+        return Double.compare(vec3d.z, z) == 0;
+    }
+
+    @Override
+    public int hashCode() {
+        long l = Double.doubleToLongBits(x);
+        int i = (int) (l ^ l >>> 32);
+        l = Double.doubleToLongBits(y);
+        i = 31 * i + (int) (l ^ l >>> 32);
+        l = Double.doubleToLongBits(z);
+        i = 31 * i + (int) (l ^ l >>> 32);
+        return i;
+    }
+
+    @Override
+    public String toString() {
+        return "(" + x + ", " + y + ", " + z + ")";
+    }
+
+}
@@ -2,8 +2,10 @@ package fun.bm.lophine.config.modules.experiment;

 import me.earthme.luminol.config.EnumConfigCategory;
 import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
 import me.earthme.luminol.config.flags.ConfigInfo;

+@ConfigClassInfo(configAttribution = EnumConfigCategory.EXPERIMENT, mainName = "command")
 public class CommandConfig implements IConfigModule {
    @ConfigInfo(baseName = "tick_command_enabled", comments =
            """
@@ -15,14 +17,4 @@ public class CommandConfig implements IConfigModule {
                    Allow to use datapack command
                        --- datapack hot-update unsupported, please restart server""")
    public static boolean datapack = false;
-
-    @Override
-    public EnumConfigCategory getCategory() {
-        return EnumConfigCategory.EXPERIMENT;
-    }
-
-    @Override
-    public String getBaseName() {
-        return "command";
-    }
 }
@@ -2,21 +2,13 @@ package fun.bm.lophine.config.modules.experiment;

 import me.earthme.luminol.config.EnumConfigCategory;
 import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
 import me.earthme.luminol.config.flags.ConfigInfo;

+@ConfigClassInfo(configAttribution = EnumConfigCategory.EXPERIMENT, mainName = "entity_damage_source_trace")
 public class EntityDamageSourceTraceConfig implements IConfigModule {
    @ConfigInfo(baseName = "enabled", comments =
            """
                    Allow trace damage source cross different Region Scheduler.""")
    public static boolean enabled = false;
-
-    @Override
-    public EnumConfigCategory getCategory() {
-        return EnumConfigCategory.EXPERIMENT;
-    }
-
-    @Override
-    public String getBaseName() {
-        return "entity_damage_source_trace";
-    }
 }
@@ -2,8 +2,10 @@ package fun.bm.lophine.config.modules.experiment;

 import me.earthme.luminol.config.EnumConfigCategory;
 import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
 import me.earthme.luminol.config.flags.ConfigInfo;

+@ConfigClassInfo(configAttribution = EnumConfigCategory.EXPERIMENT, mainName = "ray_tracking_entity_tracker")
 public class RayTrackingEntityTrackerConfig implements IConfigModule {
    @ConfigInfo(baseName = "enabled")
    public static boolean enabled = false;
@@ -15,14 +17,4 @@ public class RayTrackingEntityTrackerConfig implements IConfigModule {
    public static int tracingDistance = 48;
    @ConfigInfo(baseName = "hitbox_limit")
    public static int hitboxLimit = 50;
-
-    @Override
-    public EnumConfigCategory getCategory() {
-        return EnumConfigCategory.EXPERIMENT;
-    }
-
-    @Override
-    public String getBaseName() {
-        return "ray_tracking_entity_tracker";
-    }
 }
@@ -2,23 +2,15 @@ package fun.bm.lophine.config.modules.experiment;

 import me.earthme.luminol.config.EnumConfigCategory;
 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;

+@ConfigClassInfo(configAttribution = EnumConfigCategory.EXPERIMENT, mainName = "waypoint_bar")
 public class WaypointConfig implements IConfigModule {
    @TransformedConfig(name = "enable-waypoint", category = {"experiment", "waypoint bar"})
    @ConfigInfo(baseName = "enabled", comments =
            """
                    Enable waypoint bar unsafe""")
    public static boolean forceEnableWaypointUnsafe = false;
-
-    @Override
-    public EnumConfigCategory getCategory() {
-        return EnumConfigCategory.EXPERIMENT;
-    }
-
-    @Override
-    public String getBaseName() {
-        return "waypoint_bar";
-    }
 }
@@ -1,25 +0,0 @@
-package fun.bm.lophine.config.modules.fixes;
-
-import me.earthme.luminol.config.EnumConfigCategory;
-import me.earthme.luminol.config.IConfigModule;
-import me.earthme.luminol.config.flags.ConfigInfo;
-import me.earthme.luminol.config.flags.TransformedConfig;
-
-public class DisableEndCrystalCheckConfig implements IConfigModule {
-    @TransformedConfig(name = "disable_end_crystal_check", category = {"misc", "end_crystal"})
-    @ConfigInfo(baseName = "disable_end_crystal_check", comments =
-            """
-                    Disable paper's End Crystal position check.
-                    It reverts to vanilla respawn dragon logic.""")
-    public static boolean disableCheck = false;
-
-    @Override
-    public EnumConfigCategory getCategory() {
-        return EnumConfigCategory.FIXES;
-    }
-
-    @Override
-    public String getBaseName() {
-        return "end_crystal";
-    }
-}
@@ -0,0 +1,13 @@
+package fun.bm.lophine.config.modules.gameplay;
+
+import me.earthme.luminol.config.EnumConfigCategory;
+import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
+import me.earthme.luminol.config.flags.ConfigInfo;
+
+@ConfigClassInfo(configAttribution = EnumConfigCategory.GAMEPLAY, mainName = "end-void-ring")
+public class EndVoidRingsConfig implements IConfigModule {
+    @ConfigInfo(baseName = "enabled", comments = """
+            If enabled, it will generate end void rings, like MC-159283.""")
+    public static boolean enabled = false;
+}
@@ -2,8 +2,10 @@ package fun.bm.lophine.config.modules.misc;

 import me.earthme.luminol.config.EnumConfigCategory;
 import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
 import me.earthme.luminol.config.flags.ConfigInfo;

+@ConfigClassInfo(configAttribution = EnumConfigCategory.MISC, mainName = "container_expansion")
 public class ContainerExpansionConfig implements IConfigModule {
    @ConfigInfo(baseName = "barrel_rows", comments =
            """
@@ -22,14 +24,4 @@ public class ContainerExpansionConfig implements IConfigModule {

    @ConfigInfo(baseName = "same_nbt_shulker_stackable")
    public static boolean nbtShulkerStackable = false;
-
-    @Override
-    public EnumConfigCategory getCategory() {
-        return EnumConfigCategory.MISC;
-    }
-
-    @Override
-    public String getBaseName() {
-        return "container_expansion";
-    }
 }
@@ -2,8 +2,10 @@ package fun.bm.lophine.config.modules.misc;

 import me.earthme.luminol.config.EnumConfigCategory;
 import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
 import me.earthme.luminol.config.flags.ConfigInfo;

+@ConfigClassInfo(configAttribution = EnumConfigCategory.MISC, mainName = "disable-check")
 public class DisableCheckConfig implements IConfigModule {
    @ConfigInfo(baseName = "disable-op-move-check", comments = """
            Disable the check for the operator's move check""")
@@ -12,14 +14,4 @@ public class DisableCheckConfig implements IConfigModule {
    @ConfigInfo(baseName = "disable-op-fly-check", comments = """
            Disable the check for the operator's fly check""")
    public static boolean disableOpFlyCheck = false;
-
-    @Override
-    public EnumConfigCategory getCategory() {
-        return EnumConfigCategory.MISC;
-    }
-
-    @Override
-    public String getBaseName() {
-        return "disable-check";
-    }
 }
@@ -2,9 +2,11 @@ package fun.bm.lophine.config.modules.misc;

 import me.earthme.luminol.config.EnumConfigCategory;
 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;

+@ConfigClassInfo(configAttribution = EnumConfigCategory.MISC, mainName = "old-feature")
 public class OldFeatureConfig implements IConfigModule {
    @ConfigInfo(baseName = "spawn_invulnerable_time")
    public static boolean spawnInvulnerableTime = false;
@@ -18,14 +20,4 @@ public class OldFeatureConfig implements IConfigModule {
    @TransformedConfig(name = "give_bad_omen_when_kill_raid_captain", category = {"misc", "revert_raid_changes"}, transformComments = false)
    @ConfigInfo(baseName = "old_raid_behavior")
    public static boolean oldRaidBehavior = false;
-
-    @Override
-    public EnumConfigCategory getCategory() {
-        return EnumConfigCategory.MISC;
-    }
-
-    @Override
-    public String getBaseName() {
-        return "old-feature";
-    }
 }
@@ -2,23 +2,15 @@ package fun.bm.lophine.config.modules.misc;

 import me.earthme.luminol.config.EnumConfigCategory;
 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;

+@ConfigClassInfo(configAttribution = EnumConfigCategory.MISC, mainName = "redstone")
 public class RedStoneConfig implements IConfigModule {
    @TransformedConfig(name = "allow_skip_cooldown", category = {"misc", "redstone"})
    @ConfigInfo(baseName = "shears_rotate", comments =
            """
                    Allows you to use the Shears to right-click to rotate the block.""")
    public static boolean shears = false;
-
-    @Override
-    public EnumConfigCategory getCategory() {
-        return EnumConfigCategory.MISC;
-    }
-
-    @Override
-    public String getBaseName() {
-        return "redstone";
-    }
 }
@@ -2,10 +2,12 @@ package fun.bm.lophine.config.modules.misc;

 import me.earthme.luminol.config.EnumConfigCategory;
 import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
 import me.earthme.luminol.config.flags.ConfigInfo;

 import java.util.List;

+@ConfigClassInfo(configAttribution = EnumConfigCategory.MISC, mainName = "survux-protocol")
 public class SurvuxProtocolConfig implements IConfigModule {
    @ConfigInfo(baseName = "entity-protocol")
    public static boolean entityProtocol = false;
@@ -33,14 +35,4 @@ public class SurvuxProtocolConfig implements IConfigModule {

    @ConfigInfo(baseName = "litematics-max-nbt-size")
    public static int litematicsMaxNbtSize = 2097152;
-
-    @Override
-    public EnumConfigCategory getCategory() {
-        return EnumConfigCategory.MISC;
-    }
-
-    @Override
-    public String getBaseName() {
-        return "servux-protocol";
-    }
 }
@@ -2,22 +2,16 @@ package fun.bm.lophine.config.modules.misc;

 import me.earthme.luminol.config.EnumConfigCategory;
 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;

+@ConfigClassInfo(configAttribution = EnumConfigCategory.MISC, mainName = "villager")
 public class VillagerConfig implements IConfigModule {
+    @TransformedConfig(name = "villager-infinite-trade", category = {"misc", "villager-config"})
    @ConfigInfo(baseName = "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.""")
    public static boolean villagerInfiniteTrade = false;
-
-    @Override
-    public EnumConfigCategory getCategory() {
-        return EnumConfigCategory.MISC;
-    }
-
-    @Override
-    public String getBaseName() {
-        return "villager-config";
-    }
 }
@@ -2,21 +2,13 @@ package fun.bm.lophine.config.modules.optimizations;

 import me.earthme.luminol.config.EnumConfigCategory;
 import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
 import me.earthme.luminol.config.flags.ConfigInfo;

+@ConfigClassInfo(configAttribution = EnumConfigCategory.OPTIMIZATIONS, mainName = "language")
 public class LanguageConfig implements IConfigModule {
    @ConfigInfo(baseName = "lang", comments = """
            Please use the key from https://minecraft.wiki/w/Language
            Sample of format: en_us zh_cn zh_hk zh_tw""")
    public static String lang = "en_us";
-
-    @Override
-    public EnumConfigCategory getCategory() {
-        return EnumConfigCategory.OPTIMIZATIONS;
-    }
-
-    @Override
-    public String getBaseName() {
-        return "language";
-    }
 }
@@ -2,10 +2,14 @@ package fun.bm.lophine.config.modules.removed;

 import me.earthme.luminol.config.EnumConfigCategory;
 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;

+@ConfigClassInfo(configAttribution = EnumConfigCategory.REMOVED, mainName = "removed_config")
 public class RemovedConfig implements IConfigModule {
+    @TransformedConfig(name = "disable_end_crystal_check", category = {"fixes", "end_crystal"}, transform = false)
+    @TransformedConfig(name = "disable_end_crystal_check", category = {"misc", "end_crystal"}, transform = false)
    @TransformedConfig(name = "allow_skip_cooldown", category = {"misc", "revert_raid_changes"}, transform = false)
    @TransformedConfig(name = "bad_omen_infinite", category = {"misc", "revert_raid_changes"}, transform = false)
    @TransformedConfig(name = "skip_height_check", category = {"misc", "revert_raid_changes"}, transform = false)
@@ -19,14 +23,4 @@ public class RemovedConfig implements IConfigModule {
            """
                    RemovedConfig redirect to here, no any function.""")
    public static boolean enabled = true;
-
-    @Override
-    public EnumConfigCategory getCategory() {
-        return EnumConfigCategory.REMOVED;
-    }
-
-    @Override
-    public String getBaseName() {
-        return "removed_config";
-    }
 }
@@ -3,7 +3,7 @@ pluginManagement {
        gradlePluginPortal()
        mavenLocal()
        maven("https://repo.papermc.io/repository/maven-public/")
-        maven("https://repo.menthamc.com/repository/maven-public/")
+        maven("https://repo.menthamc.org/repository/maven-public/")
    }
 }
Author	SHA1	Message	Date
Helvetica Volubi	fc50c2ac44	Update gradle.properties	2025-08-26 14:08:25 +08:00
Helvetica Volubi	f81cee2454	feat: add a config to revert MC-159283	2025-08-26 03:04:39 +08:00
Helvetica Volubi	049716a64c	Update upstream(Luminol)	2025-08-25 22:31:49 +08:00
dependabot[bot]	c7c37c5a95	build(deps): bump actions/setup-java from 4 to 5 (#52 ) Bumps [actions/setup-java](https://github.com/actions/setup-java) from 4 to 5. - [Release notes](https://github.com/actions/setup-java/releases) - [Commits](https://github.com/actions/setup-java/compare/v4...v5) --- updated-dependencies: - dependency-name: actions/setup-java dependency-version: '5' dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-08-25 21:32:02 +08:00
Helvetica Volubi	4dea005c0d	Update gradle.properties	2025-08-24 22:07:20 +08:00
Helvetica Volubi	074c5c9553	Update upstream(Luminol-lithium-sleeping-block-entity)	2025-08-24 03:55:44 +08:00
Helvetica Volubi	f79cc86332	Update upstream(Luminol-lithium-sleeping-block-entity)	2025-08-22 20:55:59 +08:00
Helvetica Volubi	e880fdecfa	Update upstream(Luminol-lithium-sleeping-block-entity)	2025-08-22 02:18:26 +08:00
xiaoxijun	dda45b510a	update maven repo	2025-08-20 03:51:09 +08:00
Bacteriawa	6fec3a73ac	update maven repo	2025-08-20 02:59:17 +08:00
Helvetica Volubi	d22d5fdf5a	Update upstream(Luminol-lithium-sleeping-block-entity)	2025-08-19 07:11:56 +08:00
Helvetica Volubi	fcb90d468e	Update upstream(Luminol-lithium-sleeping-block-entity)	2025-08-18 23:18:53 +08:00
dependabot[bot]	1094716d9d	[ci skip]build(deps): bump actions/checkout from 4 to 5 (#49 ) Bumps [actions/checkout](https://github.com/actions/checkout) from 4 to 5. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/v4...v5) --- updated-dependencies: - dependency-name: actions/checkout dependency-version: '5' dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-08-18 19:22:24 +08:00
Helvetica Volubi	3d57a67913	Update upstream	2025-08-17 22:25:14 +08:00