Merge pull request #7 from HaHaWTH/ver/1.20.4

Fix MC-172047 and MC-2025

.github/workflows/build_1_20_4.yml

@@ -17,7 +17,7 @@ permissions: write-all
 
 jobs:
   build:
-    runs-on: macos-latest
+    runs-on: ubuntu-latest
 
     steps:
     - uses: actions/checkout@v3
@@ -43,15 +43,15 @@ jobs:
       with:
         name: Artifacts
         path: build/libs/
-    - name: Publish API
+    - name: Publish All
       run: |
         echo "GITHUB_USERNAME=LuminolCI" >> $GITHUB_ENV
         export GITHUB_USERNAME=LuminolCI
         echo "GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }}" >> $GITHUB_ENV
         export GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }}
-        ./gradlew publish
+        ./gradlew publish -PpublishDevBundle=true
     - name: Rename jar file
-      run: mv build/libs/Luminol-paperclip-1.20.4-R0.1-SNAPSHOT-reobf.jar build/libs/luminol-1.20.4-paperclip.jar
+      run: mv build/libs/luminol-paperclip-1.20.4-R0.1-SNAPSHOT-reobf.jar build/libs/luminol-1.20.4-paperclip.jar
     - name: Release Artifacts
       uses: svenstaro/upload-release-action@v2
       with:

README.md

@@ -1,8 +1,7 @@
 <img src="./public/image/Luminol_5.png" alt="Logo" align="right" width="250">
 
 # Luminol
-
-<h4>Luminol is a folia fork with many useful optimizations, configurable vanilla features, and more API supports, and it was designed for survival and anarchy servers</h4>
+<h4>Luminol is a Folia fork with many useful optimizations, configurable vanilla features, and more API supports, and it was designed for survival and anarchy servers</h4>
 
 [![MIT License](https://img.shields.io/github/license/LuminolMC/Luminol?style=flat-square)](LICENSE)
 [![Issues](https://img.shields.io/github/issues/LuminolMC/Luminol?style=flat-square)](https://github.com/LuminolMC/Luminol/issues)
@@ -13,28 +12,33 @@
 **English** | [中文](./README_CN.md)
 
 ## Features
- - Configurable vanilla features
- - Tpsbar support
- - Linear region file format(from kaiiju)
- - Useful optimizations to improve the performance of single threaded region
- - More API support for plugin development (W.I.P)
+- Configurable vanilla features
+- Tpsbar support
+- Linear region file format(from kaiiju)
+- Useful optimizations to improve the performance of single threaded region
+- More API support for plugin development (W.I.P)
 
 ## Download
 Any versions are available in the [release](https://github.com/LuminolMC/Luminol/releases), also you can build it by yourself through [the following steps](https://github.com/LuminolMC/Luminol#build).
 
 ## Build
 To build a paperclip jar, you need to run the following command. You can find the jar in build/libs(Note: JDK17 is needed)
+
  ```shell
  ./gradlew applyPatches && ./gradlew createReobfPaperclipJar
 ```
+
 ## Using API
 For gradle:
+
 ```kotlin
 dependencies {
     compileOnly("me.earthme.luminol:luminol-api:1.20.4-R0.1-SNAPSHOT")
 }
  ```
+
 For maven
+
 ```xml
 <dependency>
   <groupId>me.earthme.luminol</groupId>
@@ -46,11 +50,10 @@ For maven
 ## Contact
 > If you are interested in this project or have any issue, feel free to ask us.
 
-QQ Group: 368632360
-QQ Channel:[Click](https://pd.qq.com/s/eq9krf9j)
+QQ Group: `368632360` | QQ Channel: [Click To Join](https://pd.qq.com/s/eq9krf9j) | Telegram: [Click To Join](https://t.me/LuminolMC)
 
 ## Notice
-**This project is not related to Leaves.Do not report any bugs about protocol support to leaves because the protocol supports are already refactored**
+**This project is not related to Leaves.Do not report any bugs about protocol support to leaves because the protocol supports are already refactored.**
 
 ## About Issue
 When you meet any problems, just ask us, we will do our best to solve it, but remember to state your problem clear and provide enough logs etc.</br>
@@ -61,9 +64,11 @@ See [Contributing](./docs/CONTRIBUTING.md)
 ## BStats
 ![bStats](https://bstats.org/signatures/server-implementation/Luminol.svg "bStats")
 
-## Please star us
-<picture>
-    <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=LuminolMC/Lumino&type=Date&theme=dark" />
-    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=LuminolMC/Luminol&type=Date" />
-    <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=LuminolMC/Luminol&type=Date" />
+## Please ⭐star us!
+<a href="https://star-history.com/#LuminolMC/Luminol&LuminolMC/LightingLuminol&Date">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=LuminolMC/Luminol%2CLuminolMC/LightingLuminol&type=Date&theme=dark" />
+    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=LuminolMC/Luminol%2CLuminolMC/LightingLuminol&type=Date" />
+    <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=LuminolMC/Luminol%2CLuminolMC/LightingLuminol&type=Date" />
   </picture>
+</a>

README_CN.md

@@ -1,8 +1,7 @@
 <img src="./public/image/Luminol_5.png" alt="Logo" align="right" width="250">
 
 # Luminol
-
-<h4>Luminol 是一个基于folia的分支，具有许多有用的优化、可配置的原版特性和更多的API支持，它专为生存和无政府服务器设计</h4>
+<h4>Luminol 是一个基于Folia的分支，具有许多有用的优化、可配置的原版特性和更多的API支持，它专为生存和无政府服务器设计</h4>
 
 [![MIT License](https://img.shields.io/github/license/LuminolMC/Luminol?style=flat-square)](LICENSE)
 [![Issues](https://img.shields.io/github/issues/LuminolMC/Luminol?style=flat-square)](https://github.com/LuminolMC/Luminol/issues)
@@ -20,39 +19,55 @@
 - 更多的插件开发API支持（进行中）
 
 ## 下载
-任何版本都可以在 [release](https://github.com/LuminolMC/Luminol/releases), 中找到，您也可以通过[以下步骤](./README_CN.md#构建)自己构建。
+任何版本都可以在 [Release](https://github.com/LuminolMC/Luminol/releases) 中找到，你也可以通过[以下步骤](./README_CN.md#构建)自己构建。
 
 ## 构建
-要构建一个paperclip jar，你需要运行以下命令。你可以在build/libs中找到jar（注意：需要JDK17）
+要构建一个paperclip jar，你需要运行以下命令。你可以在build/libs中找到jar（注意：需要`JDK17`）
+
  ```shell
  ./gradlew applyPatches && ./gradlew createReobfPaperclipJar
 ```
+
 ## 使用API
 使用 Gradle:
+
 ```kotlin
 dependencies {
-    compileOnly("me.earthme.luminol:luminol-api:1.20.2-R0.1-SNAPSHOT")
+    compileOnly("me.earthme.luminol:luminol-api:1.20.4-R0.1-SNAPSHOT")
 }
  ```
+
 使用 Maven
+
 ```xml
 <dependency>
   <groupId>me.earthme.luminol</groupId>
   <artifactId>luminol-api</artifactId>
-  <version>1.20.2-R0.1-SNAPSHOT</version>
+  <version>1.20.4-R0.1-SNAPSHOT</version>
 </dependency>
 ```
 
 ## 联系方式
 > 如果您对这个项目感兴趣或有任何问题，请随时向我们提问。
 
-QQ群：368632360
+QQ群：`368632360` | QQ频道：[点击加入](https://pd.qq.com/s/eq9krf9j) | Telegram:[点击加入](https://t.me/LuminolMC)
 
 ## 关于 Issue
 当您遇到任何问题时，请向我们提问，我们将尽力解决，但请记得清楚地描述您的问题并提供足够的日志等信息。
 
 ## 贡献代码
-可查看 [Contributing](./docs/CONTRIBUTING_cn.md)
+可[查看 Contributing](./docs/CONTRIBUTING_cn.md)
 
 ## BStats
-![bStats](https://bstats.org/signatures/server-implementation/Luminol.svg "bStats")
+![bStats](https://bstats.org/signatures/server-implementation/Luminol.svg "bStats")
+
+## 请给我们一个 ⭐Star！
+> 你的每一个免费的 ⭐Star 就是我们每一个前进的动力。
+
+<a href="https://star-history.com/#LuminolMC/Luminol&LuminolMC/LightingLuminol&Date">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=LuminolMC/Luminol%2CLuminolMC/LightingLuminol&type=Date&theme=dark" />
+    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=LuminolMC/Luminol%2CLuminolMC/LightingLuminol&type=Date" />
+    <img alt="Star历史表" src="https://api.star-history.com/svg?repos=LuminolMC/Luminol%2CLuminolMC/LightingLuminol&type=Date" />
+  </picture>
+</a>

build.gradle.kts

@@ -2,7 +2,7 @@ plugins {
     java
     `maven-publish`
     id("com.github.johnrengelman.shadow") version "8.1.1" apply false
-    id("io.papermc.paperweight.patcher") version "1.5.9"
+    id("io.papermc.paperweight.patcher") version "1.5.11"
 }
 
 val paperMavenPublicUrl = "https://repo.papermc.io/repository/maven-public/"
@@ -63,7 +63,7 @@ tasks.generateDevelopmentBundle {
     libraryRepositories.set(
         listOf(
             "https://repo.maven.apache.org/maven2/",
-            paperMavenPublicUrl,
+            "https://maven.pkg.github.com/LuminolMC/Luminol",
         )
     )
 }
@@ -98,3 +98,43 @@ paperweight {
         }
     }
 }
+
+tasks.generateDevelopmentBundle {
+    apiCoordinates.set("me.earthme.luminol:luminol-api")
+    mojangApiCoordinates.set("io.papermc.paper:paper-mojangapi")
+    libraryRepositories.addAll(
+        "https://repo.maven.apache.org/maven2/",
+        paperMavenPublicUrl,
+    )
+}
+
+allprojects {
+    publishing {
+        repositories {
+            maven {
+                name = "githubPackage"
+                url = uri("https://maven.pkg.github.com/LuminolMC/Luminol")
+
+                credentials.username = System.getenv("GITHUB_USERNAME")
+                credentials.password = System.getenv("GITHUB_TOKEN")
+            }
+
+            publications {
+                register<MavenPublication>("gpr") {
+                    from(components["java"])
+                }
+            }
+        }
+    }
+ }
+
+publishing {
+    if (project.hasProperty("publishDevBundle")) {
+        publications.create<MavenPublication>("devBundle") {
+            artifact(tasks.generateDevelopmentBundle) {
+                artifactId = "dev-bundle"
+            }
+        }
+    }
+}
+

gradle.properties

@@ -1,7 +1,7 @@
 group = me.earthme.luminol
 version = 1.20.4-R0.1-SNAPSHOT
 
-foliaCommit = 8939611bb53d6d1d98fd76e91c320d55a28700ad
+foliaCommit = e97b1eee63b802568447d344bac5a66bf90c6c71
 
 org.gradle.caching = true
 org.gradle.parallel = true

patches/server/0001-Fix-build.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Fix build
 
 
 diff --git a/build.gradle.kts b/build.gradle.kts
-index 959e62d800de05b2dd77a252f442c3daf8438490..b9c5ef4d15aa97a380419912e3ee09d094ae752e 100644
+index 08d434023226af0d2c469055a3b2188fe8a4ed38..48e9f6ff317bfc7077563e9c651d2a90da6bb37a 100644
 --- a/build.gradle.kts
 +++ b/build.gradle.kts
 @@ -14,7 +14,7 @@ val alsoShade: Configuration by configurations.creating
@@ -17,7 +17,7 @@ index 959e62d800de05b2dd77a252f442c3daf8438490..b9c5ef4d15aa97a380419912e3ee09d0
      implementation("io.papermc.paper:paper-mojangapi:${project.version}") {
          exclude("io.papermc.paper", "paper-api")
      }
-@@ -73,7 +73,7 @@ tasks.jar {
+@@ -74,7 +74,7 @@ tasks.jar {
          attributes(
              "Main-Class" to "org.bukkit.craftbukkit.Main",
              "Implementation-Title" to "CraftBukkit",

patches/server/0002-Rebrand-to-Luminol.patch

@@ -51,10 +51,10 @@ index e2f704c115fd6e00960bb56bb0779f1100c89c17..72b9343979de5aa8bb399cbe7cb8a795
  
          return history != null ? TextComponent.ofChildren(updateMessage, Component.newline(), history) : updateMessage;
 diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index b73699a08a368e6305759438c00066b0d5e7b39a..22aff010859dded150b6e3dd0644fe3c38dbaea9 100644
+index 3ec07e77748ee9bb21f9d09230f935bca2217e4d..94ac1715a3c8f8d84911d758dd26a45394f87872 100644
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
 +++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -1954,7 +1954,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1953,7 +1953,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
  
      @DontObfuscate
      public String getServerModName() {

patches/server/0003-Empty-config-file-base.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Empty config file base
 
 
 diff --git a/build.gradle.kts b/build.gradle.kts
-index b9c5ef4d15aa97a380419912e3ee09d094ae752e..e837f1f9b444318cbee8719b9dd0eb669478742e 100644
+index 48e9f6ff317bfc7077563e9c651d2a90da6bb37a..d4baa7a193eba22be23921029ca4808a73de063d 100644
 --- a/build.gradle.kts
 +++ b/build.gradle.kts
 @@ -19,6 +19,7 @@ dependencies {
@@ -16,6 +16,82 @@ index b9c5ef4d15aa97a380419912e3ee09d094ae752e..e837f1f9b444318cbee8719b9dd0eb66
      // Paper start
      implementation("org.jline:jline-terminal-jansi:3.21.0")
      implementation("net.minecrell:terminalconsoleappender:1.3.0")
+diff --git a/src/main/java/me/earthme/luminol/commands/LuminolConfigCommand.java b/src/main/java/me/earthme/luminol/commands/LuminolConfigCommand.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..5c8745dffa80cf47e856d04d283937bda86881f8
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/commands/LuminolConfigCommand.java
+@@ -0,0 +1,70 @@
++package me.earthme.luminol.commands;
++
++import me.earthme.luminol.config.LuminolConfig;
++import net.kyori.adventure.text.Component;
++import net.kyori.adventure.text.format.TextColor;
++import org.bukkit.Location;
++import org.bukkit.command.Command;
++import org.bukkit.command.CommandSender;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++import java.util.ArrayList;
++import java.util.List;
++
++public class LuminolConfigCommand extends Command {
++    public LuminolConfigCommand(){
++        super("luminolconfig");
++        this.setPermission("luminol.commands.luminolconfig");
++        this.setDescription("Manage config file");
++        this.setUsage("/luminolconfig");
++    }
++
++    @Override
++    public @NotNull List<String> tabComplete(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args, @Nullable Location location) throws IllegalArgumentException {
++        final List<String> result = new ArrayList<>();
++
++        if (args.length == 1){
++            result.add("reload");
++        }
++
++        return result;
++    }
++
++    @Override
++    public boolean execute(@NotNull CommandSender sender, @NotNull String commandLabel, @NotNull String[] args) {
++        if (!this.testPermission(sender)){
++            sender.sendMessage(Component
++                    .text("No permission to execute this command!")
++                    .color(TextColor.color(255,0,0))
++            );
++        }
++
++        if (args.length < 1){
++            sender.sendMessage(
++                    Component
++                            .text("Wrong use!\n")
++                            .color(TextColor.color(255,0,0))
++            );
++            return true;
++        }
++
++        switch (args[0]){
++            case "reload" -> {
++                LuminolConfig.reloadAsync().thenAccept(nullValue -> sender.sendMessage(
++                        Component
++                                .text("Reloaded config file!")
++                                .color(TextColor.color(0,255,0))
++                ));
++            }
++
++            default -> sender.sendMessage(
++                    Component
++                            .text("Unknown action!\n")
++                            .color(TextColor.color(255,0,0))
++            );
++        }
++
++        return true;
++    }
++}
 diff --git a/src/main/java/me/earthme/luminol/config/ConfigInfo.java b/src/main/java/me/earthme/luminol/config/ConfigInfo.java
 new file mode 100644
 index 0000000000000000000000000000000000000000..01b64c2cf6b437114337626c242e1da3fbdb8ead
@@ -71,6 +147,20 @@ index 0000000000000000000000000000000000000000..ac2a92fe0ddbebb71ea4dd8c96f461d0
 +        return this.baseKeyName;
 +    }
 +}
+diff --git a/src/main/java/me/earthme/luminol/config/HotReloadUnsupported.java b/src/main/java/me/earthme/luminol/config/HotReloadUnsupported.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..559c11cb523c7cade34a0abfad15c988f5ad87fe
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/HotReloadUnsupported.java
+@@ -0,0 +1,8 @@
++package me.earthme.luminol.config;
++
++import java.lang.annotation.Retention;
++import java.lang.annotation.RetentionPolicy;
++
++@Retention(RetentionPolicy.RUNTIME)
++public @interface HotReloadUnsupported {
++}
 diff --git a/src/main/java/me/earthme/luminol/config/IConfigModule.java b/src/main/java/me/earthme/luminol/config/IConfigModule.java
 new file mode 100644
 index 0000000000000000000000000000000000000000..9f6896711907ac30fe0c00130207b970007e4bb4
@@ -101,13 +191,18 @@ index 0000000000000000000000000000000000000000..9f6896711907ac30fe0c00130207b970
 +}
 diff --git a/src/main/java/me/earthme/luminol/config/LuminolConfig.java b/src/main/java/me/earthme/luminol/config/LuminolConfig.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..7dc4b97c396aab1128ad4761b3f3ac6ee9d07205
+index 0000000000000000000000000000000000000000..2b4e64796bf01b0a5fcb306850cd60837ed4d36b
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/config/LuminolConfig.java
-@@ -0,0 +1,183 @@
+@@ -0,0 +1,218 @@
 +package me.earthme.luminol.config;
 +
 +import com.electronwill.nightconfig.core.file.CommentedFileConfig;
++import io.papermc.paper.threadedregions.RegionizedServer;
++import me.earthme.luminol.commands.LuminolConfigCommand;
++import org.bukkit.Bukkit;
++import org.bukkit.craftbukkit.scheduler.MinecraftInternalPlugin;
++import org.jetbrains.annotations.Contract;
 +import org.jetbrains.annotations.NotNull;
 +
 +import java.io.File;
@@ -120,6 +215,7 @@ index 0000000000000000000000000000000000000000..7dc4b97c396aab1128ad4761b3f3ac6e
 +import java.net.URLDecoder;
 +import java.nio.charset.StandardCharsets;
 +import java.util.*;
++import java.util.concurrent.CompletableFuture;
 +import java.util.jar.JarEntry;
 +import java.util.jar.JarFile;
 +
@@ -132,7 +228,34 @@ index 0000000000000000000000000000000000000000..7dc4b97c396aab1128ad4761b3f3ac6e
 +    private static final File baseConfigFile = new File(baseConfigFolder,"luminol_global_config.toml");
 +    private static final Set<IConfigModule> allInstanced = new HashSet<>();
 +    private static CommentedFileConfig configFileInstance;
-+    
++    public static boolean alreadyInited = false;
++    private static MinecraftInternalPlugin NULL_PLUGIN = new MinecraftInternalPlugin();
++
++    public static void setupLatch(){
++        Bukkit.getCommandMap().register("luminolconfig","luminol",new LuminolConfigCommand());
++        alreadyInited = true;
++    }
++
++    public static void reload(){
++        RegionizedServer.ensureGlobalTickThread("Reload luminol config off global region thread!");
++
++        dropAllInstanced();
++        try {
++            loadConfig();
++        }catch (Exception e){
++            logger.error(e);
++        }
++    }
++
++    @Contract(" -> new")
++    public static @NotNull CompletableFuture<Void> reloadAsync(){
++        return CompletableFuture.runAsync(LuminolConfig::reload,task -> Bukkit.getGlobalRegionScheduler().run(NULL_PLUGIN,scheduled -> task.run()));
++    }
++
++    public static void dropAllInstanced(){
++        allInstanced.clear();
++    }
++
 +    public static void loadConfig() throws IOException {
 +        baseConfigFolder.mkdirs();
 +
@@ -148,7 +271,7 @@ index 0000000000000000000000000000000000000000..7dc4b97c396aab1128ad4761b3f3ac6e
 +            instanceAllModule();
 +            loadAllModules();
 +        }catch (Exception e){
-+            e.printStackTrace();
++            logger.error("Failed to load config modules!",e);
 +        }
 +
 +        configFileInstance.save();
@@ -176,7 +299,7 @@ index 0000000000000000000000000000000000000000..7dc4b97c396aab1128ad4761b3f3ac6e
 +        for (Field field : fields) {
 +            int modifiers = field.getModifiers();
 +            if (Modifier.isStatic(modifiers) && !Modifier.isFinal(modifiers)) {
-+                boolean skipLoad = field.getAnnotation(DoNotLoad.class) != null;
++                boolean skipLoad = field.getAnnotation(DoNotLoad.class) != null || (alreadyInited && field.getAnnotation(HotReloadUnsupported.class) != null);
 +                ConfigInfo configInfo = field.getAnnotation(ConfigInfo.class);
 +
 +                if (skipLoad || configInfo == null){
@@ -205,18 +328,17 @@ index 0000000000000000000000000000000000000000..7dc4b97c396aab1128ad4761b3f3ac6e
 +
 +                final Object actuallyValue = configFileInstance.get(fullConfigKeyName);
 +                field.set(null,actuallyValue);
-+
-+
 +            }
 +        }
 +
 +        singleConfigModule.onLoaded(configFileInstance);
 +    }
 +
-+    public static Set<Class<?>> getClasses(String pack) {
-+        Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
++    public static @NotNull Set<Class<?>> getClasses(String pack) {
++        Set<Class<?>> classes = new LinkedHashSet<>();
 +        String packageDirName = pack.replace('.', '/');
 +        Enumeration<URL> dirs;
++
 +        try {
 +            dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
 +            while (dirs.hasMoreElements()) {
@@ -232,21 +354,24 @@ index 0000000000000000000000000000000000000000..7dc4b97c396aab1128ad4761b3f3ac6e
 +                        Enumeration<JarEntry> entries = jar.entries();
 +                        findClassesInPackageByJar(pack, entries, packageDirName, classes);
 +                    } catch (IOException e) {
-+                        e.printStackTrace();
++                        throw new RuntimeException(e);
 +                    }
 +                }
 +            }
 +        } catch (IOException e) {
-+            e.printStackTrace();
++            throw new RuntimeException(e);
 +        }
++
 +        return classes;
 +    }
 +
 +    private static void findClassesInPackageByFile(String packageName, String packagePath, Set<Class<?>> classes) {
 +        File dir = new File(packagePath);
++
 +        if (!dir.exists() || !dir.isDirectory()) {
 +            return;
 +        }
++
 +        File[] dirfiles = dir.listFiles((file) -> file.isDirectory() || file.getName().endsWith(".class"));
 +        if (dirfiles != null) {
 +            for (File file : dirfiles) {
@@ -257,7 +382,7 @@ index 0000000000000000000000000000000000000000..7dc4b97c396aab1128ad4761b3f3ac6e
 +                    try {
 +                        classes.add(Class.forName(packageName + '.' + className));
 +                    } catch (ClassNotFoundException e) {
-+                        e.printStackTrace();
++                        throw new RuntimeException(e);
 +                    }
 +                }
 +            }
@@ -281,7 +406,7 @@ index 0000000000000000000000000000000000000000..7dc4b97c396aab1128ad4761b3f3ac6e
 +                    try {
 +                        classes.add(Class.forName(packageName + '.' + className));
 +                    } catch (ClassNotFoundException e) {
-+                        e.printStackTrace();
++                        throw new RuntimeException(e);
 +                    }
 +                }
 +            }
@@ -289,7 +414,7 @@ index 0000000000000000000000000000000000000000..7dc4b97c396aab1128ad4761b3f3ac6e
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-index 0f8c868fce0a054a0ba356350baf4c3824c2c958..d99e0acf0000c566fdb1bffb149ec13a55d7c8dd 100644
+index 6b3242117d62175de462d04e4d178b49ae2521e9..4744ace98d1741db80ac2aea198f332d95c0ba33 100644
 --- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
 @@ -19,6 +19,8 @@ import java.util.Locale;
@@ -301,11 +426,12 @@ index 0f8c868fce0a054a0ba356350baf4c3824c2c958..d99e0acf0000c566fdb1bffb149ec13a
  import net.minecraft.DefaultUncaughtExceptionHandler;
  import net.minecraft.DefaultUncaughtExceptionHandlerWithName;
  import net.minecraft.SharedConstants;
-@@ -209,6 +211,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+@@ -209,6 +211,8 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
          this.paperConfigurations.initializeGlobalConfiguration(this.registryAccess());
          this.paperConfigurations.initializeWorldDefaultsConfiguration(this.registryAccess());
          // Paper end - initialize global and world-defaults configuration
 +        LuminolConfig.loadConfig(); //Luminol - load config file
++        LuminolConfig.setupLatch(); //Luminol - load config file
          // Paper start - fix converting txt to json file; convert old users earlier after PlayerList creation but before file load/save
          if (this.convertOldUsers()) {
              this.getProfileCache().save(false); // Paper

patches/server/0004-Add-config-for-server-mod-name.patch

@@ -47,10 +47,10 @@ index 0000000000000000000000000000000000000000..94e7c8910e3623163528a844fd7a08b3
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index 22aff010859dded150b6e3dd0644fe3c38dbaea9..4468e6fdbbe527111f4410188f2f2df7f592f81e 100644
+index 94ac1715a3c8f8d84911d758dd26a45394f87872..dd4fbe5a51e05560343d2ee919d4bc50963e3d70 100644
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
 +++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -1954,7 +1954,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1953,7 +1953,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
  
      @DontObfuscate
      public String getServerModName() {

patches/server/0007-Add-config-for-void-trading.patch

@@ -31,10 +31,10 @@ index 0000000000000000000000000000000000000000..22f3c6c70e4287f1bdd0b18f87f57efe
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index a16fc5ba55dbde0cf7f968884da40d70a754a0d8..9e82dc98ef2d4da39839699f455e0ef20ab4ef65 100644
+index ec25610cbffe30fecaeaadf9098e187bc15b5405..682ca5ec0aee427463d1a9f97292c6ea65ca2da0 100644
 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java
 +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -3046,7 +3046,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+@@ -3045,7 +3045,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
              // 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

patches/server/0011-Add-a-simple-tpsbar.patch

@@ -6,14 +6,19 @@ Subject: [PATCH] Add a simple tpsbar
 
 diff --git a/src/main/java/me/earthme/luminol/commands/TpsBarCommand.java b/src/main/java/me/earthme/luminol/commands/TpsBarCommand.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..ac8f0e3bf130ba6dfd7202e2f480352218154cdc
+index 0000000000000000000000000000000000000000..01677f210fae53a108bfe194189cb4c233e9fa47
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/commands/TpsBarCommand.java
-@@ -0,0 +1,40 @@
+@@ -0,0 +1,50 @@
 +package me.earthme.luminol.commands;
 +
++import me.earthme.luminol.config.modules.misc.TpsBarConfig;
 +import me.earthme.luminol.functions.GlobalServerTpsBar;
++import net.kyori.adventure.text.Component;
++import net.kyori.adventure.text.format.TextColor;
++import net.kyori.adventure.util.RGBLike;
 +import org.bukkit.ChatColor;
++import org.bukkit.Color;
 +import org.bukkit.command.Command;
 +import org.bukkit.command.CommandSender;
 +import org.bukkit.entity.Player;
@@ -33,18 +38,23 @@ index 0000000000000000000000000000000000000000..ac8f0e3bf130ba6dfd7202e2f4803522
 +            return true;
 +        }
 +
++        if (!TpsBarConfig.tpsbarEnabled){
++            sender.sendMessage(Component.text("Tpsbar was already disabled!").color(TextColor.color(255,0,0)));
++            return true;
++        }
++
 +        if (!(sender instanceof Player player)){
-+            sender.sendMessage(ChatColor.RED+"Only player can use this command!");
++            sender.sendMessage(Component.text("Only player can use this command!").color(TextColor.color(255,0,0)));
 +            return true;
 +        }
 +
 +        if (GlobalServerTpsBar.isPlayerVisible(player)) {
-+            player.sendMessage(ChatColor.BLUE + "Disabled tps bar");
++            player.sendMessage(Component.text("Disabled tps bar").color(TextColor.color(0,255,0)));
 +            GlobalServerTpsBar.setVisibilityForPlayer(player,false);
 +            return true;
 +        }
 +
-+        player.sendMessage(ChatColor.GREEN + "Enabled tps bar");
++        player.sendMessage(Component.text("Enabled tps bar").color(TextColor.color(0,255,0)));
 +        GlobalServerTpsBar.setVisibilityForPlayer(player,true);
 +
 +        return true;
@@ -52,17 +62,15 @@ index 0000000000000000000000000000000000000000..ac8f0e3bf130ba6dfd7202e2f4803522
 +}
 diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/TpsBarConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/TpsBarConfig.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..b370787c3f525b9b978ad14b3e7056d7c92fcae5
+index 0000000000000000000000000000000000000000..aafb2f5052c7c8e5971a47308253badb3027093c
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/config/modules/misc/TpsBarConfig.java
-@@ -0,0 +1,40 @@
+@@ -0,0 +1,49 @@
 +package me.earthme.luminol.config.modules.misc;
 +
 +import com.electronwill.nightconfig.core.file.CommentedFileConfig;
 +import me.earthme.luminol.commands.TpsBarCommand;
-+import me.earthme.luminol.config.ConfigInfo;
-+import me.earthme.luminol.config.EnumConfigCategory;
-+import me.earthme.luminol.config.IConfigModule;
++import me.earthme.luminol.config.*;
 +import me.earthme.luminol.functions.GlobalServerTpsBar;
 +import org.bukkit.Bukkit;
 +
@@ -77,6 +85,11 @@ index 0000000000000000000000000000000000000000..b370787c3f525b9b978ad14b3e7056d7
 +    public static List<String> tpsColors = List.of("GREEN","YELLOW","RED","PURPLE");
 +    @ConfigInfo(baseName = "ping_color_list")
 +    public static List<String> pingColors = List.of("GREEN","YELLOW","RED","PURPLE");
++    @ConfigInfo(baseName = "update_interval_ticks")
++    public static int updateInterval = 15;
++
++    @DoNotLoad
++    private static boolean inited = false;
 +
 +    @Override
 +    public EnumConfigCategory getCategory() {
@@ -92,16 +105,22 @@ index 0000000000000000000000000000000000000000..b370787c3f525b9b978ad14b3e7056d7
 +    public void onLoaded(CommentedFileConfig configInstance){
 +        if (tpsbarEnabled){
 +            GlobalServerTpsBar.init();
++        }else{
++            GlobalServerTpsBar.cancelBarUpdateTask();
++        }
++
++        if (!inited){
 +            Bukkit.getCommandMap().register("tpsbar","luminol",new TpsBarCommand("tpsbar"));
++            inited = true;
 +        }
 +    }
 +}
 diff --git a/src/main/java/me/earthme/luminol/functions/GlobalServerTpsBar.java b/src/main/java/me/earthme/luminol/functions/GlobalServerTpsBar.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..7511bc3f6828ab712f644cf4292a5f831e8c8653
+index 0000000000000000000000000000000000000000..3f1478dde900d671c4bfa43df80f629519cd602e
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/functions/GlobalServerTpsBar.java
-@@ -0,0 +1,206 @@
+@@ -0,0 +1,225 @@
 +package me.earthme.luminol.functions;
 +
 +import io.papermc.paper.threadedregions.ThreadedRegionizer;
@@ -133,18 +152,37 @@ index 0000000000000000000000000000000000000000..7511bc3f6828ab712f644cf4292a5f83
 +    private static final Logger logger = LogManager.getLogger();
 +
 +    public static void init(){
-+        Bukkit.getAsyncScheduler().runAtFixedRate(NULL_PLUGIN,c -> {
++        cancelBarUpdateTask();
++
++        Bukkit.getGlobalRegionScheduler().runAtFixedRate(NULL_PLUGIN,c -> {
 +            tpsbarTask = c;
 +            try {
 +                update();
 +            }catch (Exception e){
 +                logger.error(e);
 +            }
-+        },1,1, TimeUnit.SECONDS);
++        },1,TpsBarConfig.updateInterval);
++    }
++
++    public static void removeAllBars(){
++        for (Map.Entry<UUID,BossBar> barEntry : uuid2Bossbars.entrySet()){
++            final UUID playerUUID = barEntry.getKey();
++            final BossBar tpsBar = barEntry.getValue();
++
++            final Player targetPlayer = Bukkit.getPlayer(playerUUID);{
++                if (targetPlayer != null){
++                    targetPlayer.hideBossBar(tpsBar);
++                }
++            }
++        }
++
++        uuid2Bossbars.clear();
 +    }
 +
 +    public static void cancelBarUpdateTask(){
-+        if (tpsbarTask == null){
++        removeAllBars();
++
++        if (tpsbarTask == null || tpsbarTask.isCancelled()){
 +            return;
 +        }
 +
@@ -309,10 +347,10 @@ index 0000000000000000000000000000000000000000..7511bc3f6828ab712f644cf4292a5f83
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-index d6b480565340f5edbf81d7b57c3199292b020615..ea3b3f8b2318b8a1e8975e89c90cab05c6ab2835 100644
+index 4744ace98d1741db80ac2aea198f332d95c0ba33..550fb11c64e3adb35bb7f78c53f0b5ae5ce9ff58 100644
 --- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-@@ -831,6 +831,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+@@ -832,6 +832,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
  
      @Override
      public void stopServer() {

patches/server/0013-Add-config-for-offline-mode-warning.patch

@@ -31,10 +31,10 @@ index 0000000000000000000000000000000000000000..502b93c7bda9e8577a1901a8777b7cf9
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-index ea3b3f8b2318b8a1e8975e89c90cab05c6ab2835..dd0d8ba5087532770358416be72bb0215b265180 100644
+index 550fb11c64e3adb35bb7f78c53f0b5ae5ce9ff58..71151811c36c75ace1e41837123b320ae48a4b53 100644
 --- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-@@ -283,7 +283,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+@@ -284,7 +284,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
          String proxyFlavor = (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled) ? "Velocity" : "BungeeCord";
          String proxyLink = (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled) ? "https://docs.papermc.io/velocity/security" : "http://www.spigotmc.org/wiki/firewall-guide/";
          // Paper end - Add Velocity IP Forwarding Support

patches/server/0014-Add-config-for-out-of-order-chat-checks.patch

@@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Tue, 20 Feb 2024 13:10:07 +0000
+Subject: [PATCH] Add config for out-of-order chat checks
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/InorderChatConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/InorderChatConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..83176a8a7e993b51a0663b0f76161884abbf4951
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/InorderChatConfig.java
+@@ -0,0 +1,20 @@
++package me.earthme.luminol.config.modules.misc;
++
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++
++public class InorderChatConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = true;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "mojang_out_of_order_chat_check";
++    }
++}
+diff --git a/src/main/java/net/minecraft/network/chat/SignedMessageChain.java b/src/main/java/net/minecraft/network/chat/SignedMessageChain.java
+index ba12919c3f9aec34a9e64993b143ae92be5eb172..ba983d557ae16b3fbb7d0ea6ff67666a809d2e99 100644
+--- a/src/main/java/net/minecraft/network/chat/SignedMessageChain.java
++++ b/src/main/java/net/minecraft/network/chat/SignedMessageChain.java
+@@ -38,7 +38,7 @@ public class SignedMessageChain {
+                 throw new SignedMessageChain.DecodeException(Component.translatable("chat.disabled.chain_broken"), false); // Paper - diff on change (if disconnects, need a new kick event cause)
+             } else if (playerPublicKey.data().hasExpired()) {
+                 throw new SignedMessageChain.DecodeException(Component.translatable("chat.disabled.expiredProfileKey"), false, org.bukkit.event.player.PlayerKickEvent.Cause.EXPIRED_PROFILE_PUBLIC_KEY); // Paper - kick event causes
+-            } else if (body.timeStamp().isBefore(this.lastTimeStamp)) {
++            } else if (me.earthme.luminol.config.modules.misc.InorderChatConfig.enabled && body.timeStamp().isBefore(this.lastTimeStamp)) { // Luminol - Add config for out-of-order chat checks
+                 throw new SignedMessageChain.DecodeException(Component.translatable("multiplayer.disconnect.out_of_order_chat"), true, org.bukkit.event.player.PlayerKickEvent.Cause.OUT_OF_ORDER_CHAT); // Paper - kick event causes
+             } else {
+                 this.lastTimeStamp = body.timeStamp();

patches/server/0015-Add-a-simple-watchdog-for-tick-regions.patch

@@ -0,0 +1,257 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Sun, 10 Mar 2024 05:04:33 +0000
+Subject: [PATCH] Add a simple watchdog for tick regions
+
+
+diff --git a/src/main/java/io/papermc/paper/threadedregions/RegionizedServer.java b/src/main/java/io/papermc/paper/threadedregions/RegionizedServer.java
+index fc3d332aa1c1d469cedfe2aaa7102dcd78e25642..1ae61bc6603dd3ac290e3ead20416f9c5b63ff02 100644
+--- a/src/main/java/io/papermc/paper/threadedregions/RegionizedServer.java
++++ b/src/main/java/io/papermc/paper/threadedregions/RegionizedServer.java
+@@ -279,6 +279,7 @@ public final class RegionizedServer {
+      */
+ 
+     private void globalTick(final int tickCount) {
++        me.earthme.luminol.utils.LuminolWatchDog.globalRegionHeartBeat(); //Luminol
+         /*
+         if (false) {
+             io.papermc.paper.threadedregions.ThreadedTicketLevelPropagator.main(null);
+diff --git a/src/main/java/io/papermc/paper/threadedregions/ThreadedRegionizer.java b/src/main/java/io/papermc/paper/threadedregions/ThreadedRegionizer.java
+index 531aa50f2c84e13358e8918bb0c15ea3cd036cb5..fd0053369eb68f0fd596d8acfba4a5247ef8105a 100644
+--- a/src/main/java/io/papermc/paper/threadedregions/ThreadedRegionizer.java
++++ b/src/main/java/io/papermc/paper/threadedregions/ThreadedRegionizer.java
+@@ -167,6 +167,8 @@ public final class ThreadedRegionizer<R extends ThreadedRegionizer.ThreadedRegio
+         if (removed != region) {
+             throw new IllegalStateException("Expected to remove " + region + ", but removed " + removed);
+         }
++
++        me.earthme.luminol.utils.LuminolWatchDog.onRegionDeath(region); //Luminol - Simple watchdog
+     }
+ 
+     public int getSectionCoordinate(final int chunkCoordinate) {
+diff --git a/src/main/java/io/papermc/paper/threadedregions/TickRegions.java b/src/main/java/io/papermc/paper/threadedregions/TickRegions.java
+index 2ad25dd345ab42125d456f2b9cf67d8c4515c8b7..78c50292fb25e8703e9c91db892f05456f07d72f 100644
+--- a/src/main/java/io/papermc/paper/threadedregions/TickRegions.java
++++ b/src/main/java/io/papermc/paper/threadedregions/TickRegions.java
+@@ -402,6 +402,7 @@ public final class TickRegions implements ThreadedRegionizer.RegionCallbacks<Tic
+ 
+         @Override
+         protected void tickRegion(final int tickCount, final long startTime, final long scheduledEnd) {
++            me.earthme.luminol.utils.LuminolWatchDog.tickRegionHeartBeat(); //Luminol - Simple watchdog
+             final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia - profiler
+             profiler.startTick(); try { // Folia - profiler
+             MinecraftServer.getServer().tickServer(startTime, scheduledEnd, TimeUnit.MILLISECONDS.toMillis(10L), this.region);
+diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/WatchdogConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/WatchdogConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..71d80b401470db777a86274d32f178bb2aa023d5
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/WatchdogConfig.java
+@@ -0,0 +1,27 @@
++package me.earthme.luminol.config.modules.misc;
++
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.HotReloadUnsupported;
++import me.earthme.luminol.config.IConfigModule;
++
++public class WatchdogConfig implements IConfigModule {
++
++    @HotReloadUnsupported
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = false;
++    @ConfigInfo(baseName = "warn_period_ticks")
++    public static long warnPeriodTicks = 5 * 20;
++    @ConfigInfo(baseName = "timeout_ticks")
++    public static long timeOutTicks = 30 * 20;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "watchdog";
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/utils/LuminolWatchDog.java b/src/main/java/me/earthme/luminol/utils/LuminolWatchDog.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..6b4368cdf9762ad981345fef0f26cd008a4236ee
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/utils/LuminolWatchDog.java
+@@ -0,0 +1,161 @@
++package me.earthme.luminol.utils;
++
++import com.google.common.collect.Maps;
++import io.papermc.paper.threadedregions.ThreadedRegionizer;
++import io.papermc.paper.threadedregions.TickRegionScheduler;
++import io.papermc.paper.util.StacktraceDeobfuscator;
++import me.earthme.luminol.config.modules.misc.WatchdogConfig;
++import net.minecraft.server.MinecraftServer;
++import org.apache.commons.lang3.tuple.Pair;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++import org.slf4j.Logger;
++
++import java.lang.management.ManagementFactory;
++import java.lang.management.ThreadInfo;
++import java.util.ArrayList;
++import java.util.List;
++import java.util.Map;
++import java.util.concurrent.CompletableFuture;
++import java.util.concurrent.Executor;
++import java.util.concurrent.TimeUnit;
++
++public class LuminolWatchDog {
++    private static final Object keepaliveDataLock = new Object();
++    private static Pair<Thread,Long> globalRegionLastKeepalive = null;
++    private static final Map<Thread,Pair<ThreadedRegionizer.ThreadedRegion<?,?>,Long>> otherTickRegionKeepalive = Maps.newHashMap();
++    private static final Executor checkTimer = CompletableFuture.delayedExecutor(50, TimeUnit.MILLISECONDS);
++    private static final Logger logger = MinecraftServer.LOGGER;
++    private static int tickCount = 0;
++    private static boolean runScheduleNext = true;
++
++    public static void boot(){
++        runCheck();
++    }
++
++    private static void scheduleCheck(){
++        checkTimer.execute(LuminolWatchDog::runCheck);
++    }
++
++    private static void runCheck(){
++        try {
++            if (MinecraftServer.getServer().isStopped() || !runScheduleNext){
++                return;
++            }
++
++            tickCount++;
++
++            final List<Pair<Thread,Long>> threadsToWarn = new ArrayList<>();
++            final long currentTimeNano = System.nanoTime();
++            boolean shouldStopServer = false;
++
++            synchronized (keepaliveDataLock){
++                if (globalRegionLastKeepalive != null){
++                    final Thread lastGlobalRegionThread = globalRegionLastKeepalive.getLeft();
++                    final long lastTicked = globalRegionLastKeepalive.getRight();
++
++                    final long timeEscaped = currentTimeNano - lastTicked;
++
++                    if (timeEscaped >= WatchdogConfig.warnPeriodTicks * 50 * 1000 * 1000){
++                        threadsToWarn.add(Pair.of(lastGlobalRegionThread,timeEscaped));
++                    }
++                }
++
++                for(Pair<Thread,Long> warnInfo : threadsToWarn){
++                    final Thread targetThread = warnInfo.getLeft();
++                    final long timeEscaped = warnInfo.getRight();
++
++                    final ThreadedRegionizer.ThreadedRegion<?,?> targetRegion;
++
++                    synchronized (keepaliveDataLock){
++                        targetRegion = otherTickRegionKeepalive.get(targetThread).getLeft();
++                    }
++
++                    if (tickCount % WatchdogConfig.warnPeriodTicks == 0){
++                        dumpSingleRegion(targetThread,targetRegion,timeEscaped);
++                    }
++
++                    if (timeEscaped > WatchdogConfig.timeOutTicks * 50 * 1000 * 1000){
++                        shouldStopServer = true;
++                        runScheduleNext = false;
++                    }
++                }
++
++                if (shouldStopServer){
++                    MinecraftServer.getServer().stopServer();
++                }
++            }
++        }finally {
++            if (runScheduleNext){
++                scheduleCheck();
++            }
++        }
++    }
++
++    private static void dumpSingleRegion(@NotNull Thread thread, @Nullable ThreadedRegionizer.ThreadedRegion<?,?> region,long timeEscaped){
++        final StringBuilder messageBuilder = new StringBuilder();
++        messageBuilder.append("====================================").append("\n");
++        messageBuilder.append("There is a single region that has no responding in " + TimeUnit.NANOSECONDS.toSeconds(timeEscaped) + " seconds!").append("\n");
++        messageBuilder.append("If you believe this is a bug,please send it to github issue after checking your plugins!").append("\n");
++        messageBuilder.append("Tick Region: ").append(region == null ? "Global Region" : "ChunkX(Center): " + region.getCenterChunk().x + " ChunkZ(Center): " + region.getCenterChunk().z).append("\n");
++        messageBuilder.append("Thread Name: ").append(thread.getName()).append("\n");
++        messageBuilder.append("Thread Id: ").append(thread.getId()).append("\n");
++
++        final ThreadInfo targetThreadInfo = ManagementFactory.getThreadMXBean().getThreadInfo(thread.getId());
++
++        messageBuilder.append("Is Suspend: ").append(targetThreadInfo.isSuspended()).append("\n");
++        messageBuilder.append("Thread State: ").append(targetThreadInfo.getThreadState()).append("\n");
++        messageBuilder.append("Thread Priority: ").append(targetThreadInfo.getPriority()).append("\n");
++        messageBuilder.append("Thread Stack Trace:").append("\n");
++
++        for (StackTraceElement stackTraceElement : StacktraceDeobfuscator.INSTANCE.deobfuscateStacktrace(thread.getStackTrace())){
++            messageBuilder.append("\t\t").append(stackTraceElement).append("\n");
++        }
++
++        messageBuilder.append("\n");
++        messageBuilder.append("====================================");
++
++        logger.error(messageBuilder.toString());
++    }
++
++    public static void globalRegionHeartBeat(){
++        if (!WatchdogConfig.enabled){
++            return;
++        }
++
++        synchronized (keepaliveDataLock){
++            globalRegionLastKeepalive = Pair.of(Thread.currentThread(),System.nanoTime());
++        }
++    }
++
++    public static void tickRegionHeartBeat(){
++        if (!WatchdogConfig.enabled){
++            return;
++        }
++
++        final ThreadedRegionizer.ThreadedRegion<?,?> currentRegion = TickRegionScheduler.getCurrentRegion();
++
++        if (currentRegion == null) {
++            return;
++        }
++
++        synchronized (keepaliveDataLock){
++            if (!otherTickRegionKeepalive.containsKey(Thread.currentThread())){
++                otherTickRegionKeepalive.put(Thread.currentThread(),Pair.of(currentRegion,System.nanoTime()));
++                return;
++            }
++
++            otherTickRegionKeepalive.replace(Thread.currentThread(),Pair.of(currentRegion,System.nanoTime()));
++        }
++    }
++
++    public static void onRegionDeath(ThreadedRegionizer.ThreadedRegion<?,?> currentRegion){
++        if (!WatchdogConfig.enabled){
++            return;
++        }
++
++        synchronized (keepaliveDataLock){
++            otherTickRegionKeepalive.remove(Thread.currentThread());
++        }
++    }
++}
+\ No newline at end of file
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index dd4fbe5a51e05560343d2ee919d4bc50963e3d70..4d3ba2b02d19cc43a19bc633b9c5df66b85533f7 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1222,6 +1222,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             this.statusIcon = (ServerStatus.Favicon) this.loadStatusIcon().orElse(null); // CraftBukkit - decompile error
+             this.status = this.buildServerStatus();
+ 
++            me.earthme.luminol.utils.LuminolWatchDog.boot(); //Luminol - Simple watchdog
++
+             // Folia start - region threading
+             if (true) {
+                 io.papermc.paper.threadedregions.RegionizedServer.getInstance().init(); // Folia - region threading - only after loading worlds

patches/server/0016-Io_uring-channel-type-support.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Io_uring channel type support
 
 
 diff --git a/build.gradle.kts b/build.gradle.kts
-index e837f1f9b444318cbee8719b9dd0eb669478742e..3a787b0afa3a34f23f1c18fb5250a5ff4bcd2f96 100644
+index d4baa7a193eba22be23921029ca4808a73de063d..32c93c1349b8dbf6017f4e926e697c1c40627d36 100644
 --- a/build.gradle.kts
 +++ b/build.gradle.kts
 @@ -35,6 +35,7 @@ dependencies {
@@ -18,17 +18,19 @@ index e837f1f9b444318cbee8719b9dd0eb669478742e..3a787b0afa3a34f23f1c18fb5250a5ff
      implementation("org.apache.logging.log4j:log4j-iostreams:2.19.0") // Paper - remove exclusion
 diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/IOUringSupportConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/IOUringSupportConfig.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..313c3908ea406119da4f49db2e4fac6572727c80
+index 0000000000000000000000000000000000000000..f3090b6e11d82d02528c7afd358ef4db61707092
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/config/modules/misc/IOUringSupportConfig.java
-@@ -0,0 +1,20 @@
+@@ -0,0 +1,22 @@
 +package me.earthme.luminol.config.modules.misc;
 +
 +import me.earthme.luminol.config.ConfigInfo;
 +import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.HotReloadUnsupported;
 +import me.earthme.luminol.config.IConfigModule;
 +
 +public class IOUringSupportConfig implements IConfigModule {
++    @HotReloadUnsupported
 +    @ConfigInfo(baseName = "enabled")
 +    public static boolean enabled = false;
 +

patches/server/0017-Try-fixing-folia-spector-teleportation.patch

@@ -31,7 +31,7 @@ index 0000000000000000000000000000000000000000..8487799cdfb776eaca33b57f7c99ae3a
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 92a2e116f47d1434cc406709c3bcf85fedd2bb86..59f3ea98d0346d5b92053e13fa20048e3a946203 100644
+index 318cb1e98a3d73b7893f07c9f0db3adab801b67e..9cbf17436b4cf52aae374767aafe79ea4f60c3ce 100644
 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
 +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
 @@ -17,6 +17,8 @@ import java.util.OptionalInt;

patches/server/0018-Teleport-async-if-entity-was-moving-to-another-regio.patch

@@ -6,7 +6,7 @@ Subject: [PATCH] Teleport async if entity was moving to another region at once
 
 diff --git a/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaEntityMovingFixConfig.java b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaEntityMovingFixConfig.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..9ccd6a3a07abfce54dccf9b6e01d0050d03279b2
+index 0000000000000000000000000000000000000000..73d99a105a18231901e691922b0c283adae0cc79
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaEntityMovingFixConfig.java
 @@ -0,0 +1,22 @@
@@ -19,7 +19,7 @@ index 0000000000000000000000000000000000000000..9ccd6a3a07abfce54dccf9b6e01d0050
 +public class FoliaEntityMovingFixConfig implements IConfigModule {
 +    @ConfigInfo(baseName = "enabled")
 +    public static boolean enabled = false;
-+    @ConfigInfo(baseName = "warnOnDetected")
++    @ConfigInfo(baseName = "warn_on_detected")
 +    public static boolean warnOnDetected = true;
 +
 +    @Override

patches/server/0019-Prevent-teleportAsync-calling-during-moving-event-be.patch

@@ -48,7 +48,7 @@ index 9cbf17436b4cf52aae374767aafe79ea4f60c3ce..f2068e7608ed765e35759eb981db6c95
          super(world, world.getSharedSpawnPos(), world.getSharedSpawnAngle(), profile);
          this.chatVisibility = ChatVisiblity.FULL;
 diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
-index bcd5d0a274960ccd02a18f754c7ccfdaea698ecc..3ab8e0b0744eaa94cab1f81bc561e420cb151adf 100644
+index 9555ae82d68cf217bc17e3bd9af2462702a2506b..51053d90f1bbad0b6453c13e06010cd7193ae7b7 100644
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 @@ -675,7 +675,9 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
@@ -61,7 +61,7 @@ index bcd5d0a274960ccd02a18f754c7ccfdaea698ecc..3ab8e0b0744eaa94cab1f81bc561e420
  
                      // If the event is cancelled we move the player back to their old location.
                      if (event.isCancelled()) {
-@@ -1625,7 +1627,9 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+@@ -1621,7 +1623,9 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
  
                                      Location oldTo = to.clone();
                                      PlayerMoveEvent event = new PlayerMoveEvent(player, from, to);

patches/server/0021-Kaiiju-linear-region-format-and-settings.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Kaiiju linear region format and settings
 
 
 diff --git a/build.gradle.kts b/build.gradle.kts
-index 3a787b0afa3a34f23f1c18fb5250a5ff4bcd2f96..18326989bfccea2c6d292b0020aab711438031c8 100644
+index 32c93c1349b8dbf6017f4e926e697c1c40627d36..d104fb1b29bc103736fcd19a8f12ca095b6b4960 100644
 --- a/build.gradle.kts
 +++ b/build.gradle.kts
 @@ -20,6 +20,10 @@ dependencies {
@@ -573,10 +573,10 @@ index 9017907c0ec67a37a506f09b7e4499cef7885279..8b9ffcaab5d71660291d1c0454d2abd9
  
 diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/RegionFormatConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/RegionFormatConfig.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..5219ef799585db502a19e79145b971365a736277
+index 0000000000000000000000000000000000000000..7c034f65bac5aab4c46a8506efa5befe7891bc99
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/config/modules/misc/RegionFormatConfig.java
-@@ -0,0 +1,50 @@
+@@ -0,0 +1,58 @@
 +package me.earthme.luminol.config.modules.misc;
 +
 +import com.electronwill.nightconfig.core.file.CommentedFileConfig;
@@ -587,12 +587,16 @@ index 0000000000000000000000000000000000000000..5219ef799585db502a19e79145b97136
 +    @DoNotLoad
 +    public static RegionFileFormat regionFormatName = RegionFileFormat.ANVIL;
 +
++    @HotReloadUnsupported
 +    @ConfigInfo(baseName = "formatName")
 +    private static String formatName = "ANVIL";
++    @HotReloadUnsupported
 +    @ConfigInfo(baseName = "linear_compression_level")
 +    public static int regionFormatLinearCompressionLevel = 1;
++    @HotReloadUnsupported
 +    @ConfigInfo(baseName = "linear_flusher_thread_count")
 +    public static int linearFlushThreads = 1;
++    @HotReloadUnsupported
 +    @ConfigInfo(baseName = "linear_flush_frequency")
 +    public static int linearFlushFrequency = 10;
 +
@@ -608,6 +612,10 @@ index 0000000000000000000000000000000000000000..5219ef799585db502a19e79145b97136
 +
 +    @Override
 +    public void onLoaded(CommentedFileConfig configInstance){
++        if (LuminolConfig.alreadyInited){
++            return;
++        }
++
 +        regionFormatName = RegionFileFormat.fromString(formatName);
 +        if (regionFormatName.equals(RegionFileFormat.INVALID)) {
 +            LuminolConfig.logger.error("Unknown region format in luminol global config: {}", formatName);
@@ -628,7 +636,7 @@ index 0000000000000000000000000000000000000000..5219ef799585db502a19e79145b97136
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index 4468e6fdbbe527111f4410188f2f2df7f592f81e..13ad20b3d43cc22ad1046220b24272dd274de997 100644
+index 4d3ba2b02d19cc43a19bc633b9c5df66b85533f7..b3173889ba86b39bac9d0171a863bf4effbb41b1 100644
 --- a/src/main/java/net/minecraft/server/MinecraftServer.java
 +++ b/src/main/java/net/minecraft/server/MinecraftServer.java
 @@ -923,7 +923,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
@@ -650,7 +658,7 @@ index 4468e6fdbbe527111f4410188f2f2df7f592f81e..13ad20b3d43cc22ad1046220b24272dd
  
          return flag3;
 diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
-index 21ec49acb3c1241d9286959c42a7f8363f637e4f..c212030a24174115a975604b91d03cf8ad4043de 100644
+index 79e507c1463dbb9039b1fed8bdf41c0ee5f4fec3..8f642259ab8aa94eb5739ecbe72211c248c1114d 100644
 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java
 +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
 @@ -211,7 +211,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
@@ -697,10 +705,10 @@ index 21ec49acb3c1241d9286959c42a7f8363f637e4f..c212030a24174115a975604b91d03cf8
          regionFile.setStatus(chunkPos.x, chunkPos.z, ChunkSerializer.getStatus(compound));
      }
 diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 9e82dc98ef2d4da39839699f455e0ef20ab4ef65..c0f8f72d1677d4ef6a15f487262953c5df3b03c0 100644
+index 682ca5ec0aee427463d1a9f97292c6ea65ca2da0..c06ddc99a0971be46746c767ad8ce590a8e2ee30 100644
 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java
 +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -447,8 +447,8 @@ public class ServerLevel extends Level implements WorldGenLevel {
+@@ -446,8 +446,8 @@ public class ServerLevel extends Level implements WorldGenLevel {
  
      private static final class EntityRegionFileStorage extends net.minecraft.world.level.chunk.storage.RegionFileStorage {
  
@@ -711,7 +719,7 @@ index 9e82dc98ef2d4da39839699f455e0ef20ab4ef65..c0f8f72d1677d4ef6a15f487262953c5
          }
  
          protected void write(ChunkPos pos, net.minecraft.nbt.CompoundTag nbt) throws IOException {
-@@ -809,7 +809,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+@@ -808,7 +808,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
          // CraftBukkit end
          boolean flag2 = minecraftserver.forceSynchronousWrites();
          DataFixer datafixer = minecraftserver.getFixerUpper();

patches/server/0024-Kaiiju-Async-path-processing.patch

@@ -515,7 +515,7 @@ index 0000000000000000000000000000000000000000..a5472bb9d453bbeee92738c8d1a57ef4
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
-index a1a0ac986e2052d3669428a29987630bc226d80f..192584ac3b280cef2e76bc510c03ff6e0fd26ce2 100644
+index a3992e21e7d4112b9903e8d16a5e898d448eaea8..dc94c66404e9f2015119e249a560571355c92c96 100644
 --- a/src/main/java/net/minecraft/world/entity/Mob.java
 +++ b/src/main/java/net/minecraft/world/entity/Mob.java
 @@ -296,6 +296,7 @@ public abstract class Mob extends LivingEntity implements Targeting {

patches/server/0025-Petal-Reduce-sensor-work.patch

@@ -33,7 +33,7 @@ index 0000000000000000000000000000000000000000..dd45cf1fde5ee4cf8347064f106c64b8
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
-index 192584ac3b280cef2e76bc510c03ff6e0fd26ce2..8e2da025ff13abd7f021099b66dc04d1ead64390 100644
+index dc94c66404e9f2015119e249a560571355c92c96..9636f69fab9f34f3b3f4590f151248cd5b2da089 100644
 --- a/src/main/java/net/minecraft/world/entity/Mob.java
 +++ b/src/main/java/net/minecraft/world/entity/Mob.java
 @@ -926,10 +926,11 @@ public abstract class Mob extends LivingEntity implements Targeting {

patches/server/0027-Pufferfish-Cache-climbing-check-for-activation.patch

@@ -18,7 +18,7 @@ index 24c05e40c9eeeb4a181d2f9994b0e786393046b9..a899f33c8c6033ad99d8187f29d6e9eb
      private Vec3 deltaMovement;
      private float yRot;
 diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index b640d877f924094bcabbf9618bbd9aa0a70bf94a..d38918b973f76e4b3eec5e16ea4f2473e92ae858 100644
+index 2fa76a711a629e38a95b93e473272b8217783f99..3bde76d51ffe48490360d9ff5d27e2aa91c920ca 100644
 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
 +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
 @@ -142,7 +142,6 @@ import org.bukkit.event.entity.EntityTeleportEvent;

patches/server/0029-Pufferfish-Optimize-suffocation.patch

@@ -31,7 +31,7 @@ index 0000000000000000000000000000000000000000..3e48cd297b4869e5c89b6abc43c726d3
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index d38918b973f76e4b3eec5e16ea4f2473e92ae858..3731013a4369dac2130045bdc2bbde170075a3df 100644
+index 3bde76d51ffe48490360d9ff5d27e2aa91c920ca..56cee73ec911a171f1e4c1c733436caa504d0b57 100644
 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
 +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
 @@ -419,7 +419,7 @@ public abstract class LivingEntity extends Entity implements Attackable {

patches/server/0032-Pufferfish-Improve-container-checking-with-a-bitset.patch

@@ -459,7 +459,7 @@ index 26ff1a3d07c92f7035020d08d35116f7feede600..009263f6aab41608d7e17bebbed6f962
  
      public static void entityInside(Level world, BlockPos pos, BlockState state, Entity entity, HopperBlockEntity blockEntity) {
 diff --git a/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
-index a94300a457b25f0e33a8eeabba6dd5720ca9ab1e..b41635dd0569ff7df909df492d3e850aef7214be 100644
+index f52ccd4f3e062af3c7cc6eaea5b074a3bbd21690..a5cd70b6ada2b44f64db0985483ee5eadc67003f 100644
 --- a/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
 +++ b/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
 @@ -94,12 +94,7 @@ public abstract class RandomizableContainerBlockEntity extends BaseContainerBloc

patches/server/0036-Pufferfish-Entity-TTL.patch

@@ -49,7 +49,7 @@ index 0000000000000000000000000000000000000000..15697d69659b6e1e776acf5094684b5f
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index e6b90e53b2b539543084ddbfda4ab819656a3179..03a6633edd34a34f7c5cfb1a58f4d132e6bd1c12 100644
+index 0b201fd79233ed0a5c2d298b283a15497dffd8e5..f120f977e3535847a1e3a009a25eb0137fce6ab0 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
 @@ -798,6 +798,12 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S

patches/server/0038-Pufferfish-Dynamic-Activation-of-Brain.patch

@@ -71,10 +71,10 @@ index 0000000000000000000000000000000000000000..af5893ba1f738ec9827d7b714682c314
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index c0f8f72d1677d4ef6a15f487262953c5df3b03c0..33154e89457e3d7331c6d17785544d08f7e6bed8 100644
+index c06ddc99a0971be46746c767ad8ce590a8e2ee30..f3f095e6acbe50154503524b160255394f4d9ec6 100644
 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java
 +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -988,6 +988,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+@@ -987,6 +987,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
              this.timings.entityTick.startTiming(); // Spigot
              profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.ENTITY_TICK); try { // Folia - profiler
              regionizedWorldData.forEachTickingEntity((entity) -> { // Folia - regionised ticking
@@ -83,7 +83,7 @@ index c0f8f72d1677d4ef6a15f487262953c5df3b03c0..33154e89457e3d7331c6d17785544d08
                      if (false && this.shouldDiscardEntity(entity)) { // CraftBukkit - We prevent spawning in general, so this butchering is not needed
                          entity.discard();
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 03a6633edd34a34f7c5cfb1a58f4d132e6bd1c12..f61ac02037ce13bb80b0db0814145fd9ff39bc37 100644
+index f120f977e3535847a1e3a009a25eb0137fce6ab0..d62734c0365af706c136274faf3e135f6ea099ee 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
 @@ -482,6 +482,11 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
@@ -111,7 +111,7 @@ index 8deae3e95a26f4b42b2c2134e22f9649bd7a5391..c09357c1ef84a29d972119cb496b0ae9
      private String descriptionId;
      @Nullable
 diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
-index 8e2da025ff13abd7f021099b66dc04d1ead64390..2f592612ddc39723b76ddc6de3b20681ece5829d 100644
+index 9636f69fab9f34f3b3f4590f151248cd5b2da089..50a144b0122c970856ef3faa3f899ee72e2a6300 100644
 --- a/src/main/java/net/minecraft/world/entity/Mob.java
 +++ b/src/main/java/net/minecraft/world/entity/Mob.java
 @@ -233,10 +233,10 @@ public abstract class Mob extends LivingEntity implements Targeting {

patches/server/0039-Pufferfish-Throttle-goal-selector-during-inactive-ti.patch

@@ -0,0 +1,51 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Tue, 20 Feb 2024 13:03:42 +0000
+Subject: [PATCH] Pufferfish Throttle goal selector during inactive ticking
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/optimizations/EntityGoalSelectorInactiveTickConfig.java b/src/main/java/me/earthme/luminol/config/modules/optimizations/EntityGoalSelectorInactiveTickConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..acc032f727e605e79b688efb4873ff474fe7e132
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/optimizations/EntityGoalSelectorInactiveTickConfig.java
+@@ -0,0 +1,20 @@
++package me.earthme.luminol.config.modules.optimizations;
++
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++
++public class EntityGoalSelectorInactiveTickConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.OPTIMIZATIONS;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "skip_goal_selector_tick_in_inactive_tick";
++    }
++}
+diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
+index 50a144b0122c970856ef3faa3f899ee72e2a6300..7378c9cb5eeddc7cefc409638179dfb8602ed0d0 100644
+--- a/src/main/java/net/minecraft/world/entity/Mob.java
++++ b/src/main/java/net/minecraft/world/entity/Mob.java
+@@ -229,11 +229,13 @@ public abstract class Mob extends LivingEntity implements Targeting {
+         return this.lookControl;
+     }
+ 
++    int _pufferfish_inactiveTickDisableCounter = 0; // Pufferfish - throttle inactive goal selector ticking
+     // Paper start
+     @Override
+     public void inactiveTick() {
+         super.inactiveTick();
+-        if (this.goalSelector.inactiveTick(this.activatedPriority, true)) { // Pufferfish - pass activated priroity
++        boolean isThrottled = me.earthme.luminol.config.modules.optimizations.EntityGoalSelectorInactiveTickConfig.enabled && _pufferfish_inactiveTickDisableCounter++ % 20 != 0; // Pufferfish - throttle inactive goal selector ticking
++        if (this.goalSelector.inactiveTick(this.activatedPriority, true) && !isThrottled) { // Pufferfish - pass activated priroity // Pufferfish - throttle inactive goal selector ticking
+             this.goalSelector.tick();
+         }
+         if (this.targetSelector.inactiveTick(this.activatedPriority, true)) { // Pufferfish - pass activated priority

patches/server/0040-Pufferfish-Reduce-entity-allocations.patch

@@ -0,0 +1,36 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Tue, 20 Feb 2024 13:11:11 +0000
+Subject: [PATCH] Pufferfish Reduce entity allocations
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java b/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java
+index 897d7632ecfea40890433474870dd7a5e534d8ab..683c9693754d1a87b7e8fccc757a0d0963351f60 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java
++++ b/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java
+@@ -23,9 +23,11 @@ public class AttributeMap {
+     private final Map<Attribute, AttributeInstance> attributes = Maps.newHashMap();
+     private final Set<AttributeInstance> dirtyAttributes = Sets.newHashSet();
+     private final AttributeSupplier supplier;
++    private final java.util.function.Function<Attribute, AttributeInstance> createInstance; // Pufferfish
+ 
+     public AttributeMap(AttributeSupplier defaultAttributes) {
+         this.supplier = defaultAttributes;
++        this.createInstance = attribute -> this.supplier.createInstance(this::onAttributeModified, attribute); // Pufferfish
+     }
+ 
+     private void onAttributeModified(AttributeInstance instance) {
+@@ -45,11 +47,10 @@ public class AttributeMap {
+         }).collect(Collectors.toList());
+     }
+ 
++
+     @Nullable
+     public AttributeInstance getInstance(Attribute attribute) {
+-        return this.attributes.computeIfAbsent(attribute, (attributex) -> {
+-            return this.supplier.createInstance(this::onAttributeModified, attributex);
+-        });
++        return this.attributes.computeIfAbsent(attribute, this.createInstance); // Pufferfish - cache lambda, as for some reason java allocates it anyways
+     }
+ 
+     @Nullable

patches/server/0042-Gale-Don-t-load-chunks-to-activate-climbing-entities.patch

@@ -52,7 +52,7 @@ index d62734c0365af706c136274faf3e135f6ea099ee..bc655e3db34630a419be883b0dcc1ba4
          return this.chunkPosition;
      }
 diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 3731013a4369dac2130045bdc2bbde170075a3df..39f054b9352376336b543c1ca4e9be9a6dee79b3 100644
+index 56cee73ec911a171f1e4c1c733436caa504d0b57..ea1a603fffc4effd6114eb47361dd35fb03981f0 100644
 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
 +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
 @@ -2046,19 +2046,43 @@ public abstract class LivingEntity extends Entity implements Attackable {

patches/server/0043-Gale-Optimize-sun-burn-tick.patch

@@ -37,10 +37,10 @@ index bc655e3db34630a419be883b0dcc1ba4d5bbeb90..bf530eb5e039f37b9bea37d2a61ee31f
          this.absMoveTo(x, y, z);
          this.setYRot(yaw % 360.0F);
 diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
-index 50a144b0122c970856ef3faa3f899ee72e2a6300..128cba0cf37fc9b06111f80d63a2cf857e23edb1 100644
+index 7378c9cb5eeddc7cefc409638179dfb8602ed0d0..d83a6adc34c64652f1070651f5c96579a5c45e67 100644
 --- a/src/main/java/net/minecraft/world/entity/Mob.java
 +++ b/src/main/java/net/minecraft/world/entity/Mob.java
-@@ -1747,13 +1747,29 @@ public abstract class Mob extends LivingEntity implements Targeting {
+@@ -1749,13 +1749,29 @@ public abstract class Mob extends LivingEntity implements Targeting {
  
      }
  

patches/server/0044-Gale-Check-frozen-ticks-before-landing-block.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Gale Check frozen ticks before landing block
 
 
 diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 39f054b9352376336b543c1ca4e9be9a6dee79b3..7ae3d5a9e44092501271b36e593fe6d7270c472b 100644
+index ea1a603fffc4effd6114eb47361dd35fb03981f0..bd3f1a6447ae59400a18456ea2c2f2fdb24a3f91 100644
 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
 +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
 @@ -588,11 +588,10 @@ public abstract class LivingEntity extends Entity implements Attackable {

patches/server/0045-Gale-Don-t-trigger-lootable-refresh-for-non-player-i.patch

@@ -6,7 +6,7 @@ Subject: [PATCH] Gale Don't trigger lootable refresh for non-player
 
 
 diff --git a/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
-index b41635dd0569ff7df909df492d3e850aef7214be..7ff40b74827a52eb5daaff72e1563b044d41c6c1 100644
+index a5cd70b6ada2b44f64db0985483ee5eadc67003f..e49be65c2d379027c2821c0db7f151bc3cd20a4b 100644
 --- a/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
 +++ b/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
 @@ -68,6 +68,7 @@ public abstract class RandomizableContainerBlockEntity extends BaseContainerBloc

patches/server/0050-Gale-Faster-chunk-serialization.patch

@@ -0,0 +1,434 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Tue, 20 Feb 2024 13:21:53 +0000
+Subject: [PATCH] Gale Faster chunk serialization
+
+
+diff --git a/src/main/java/me/jellysquid/mods/lithium/common/world/chunk/LithiumHashPalette.java b/src/main/java/me/jellysquid/mods/lithium/common/world/chunk/LithiumHashPalette.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..349618b7f544bf9a30e0796d4d9a26407a2b8329
+--- /dev/null
++++ b/src/main/java/me/jellysquid/mods/lithium/common/world/chunk/LithiumHashPalette.java
+@@ -0,0 +1,192 @@
++// Gale - Lithium - faster chunk serialization
++
++package me.jellysquid.mods.lithium.common.world.chunk;
++
++import com.google.common.collect.ImmutableList;
++import it.unimi.dsi.fastutil.HashCommon;
++import it.unimi.dsi.fastutil.objects.Reference2IntMap;
++import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
++import java.util.Arrays;
++import java.util.List;
++import java.util.function.Predicate;
++import net.minecraft.core.IdMap;
++import net.minecraft.network.FriendlyByteBuf;
++import net.minecraft.network.VarInt;
++import net.minecraft.world.level.chunk.Palette;
++import net.minecraft.world.level.chunk.PaletteResize;
++
++import static it.unimi.dsi.fastutil.Hash.FAST_LOAD_FACTOR;
++
++/**
++ * Generally provides better performance over the vanilla {@link net.minecraft.world.level.chunk.HashMapPalette} when calling
++ * {@link LithiumHashPalette#idFor(Object)} through using a faster backing map and reducing pointer chasing.
++ */
++public class LithiumHashPalette<T> implements Palette<T> {
++    private static final int ABSENT_VALUE = -1;
++
++    private final IdMap<T> idList;
++    private final PaletteResize<T> resizeHandler;
++    private final int indexBits;
++
++    private final Reference2IntMap<T> table;
++    private T[] entries;
++    private int size = 0;
++
++    public LithiumHashPalette(IdMap<T> idList, PaletteResize<T> resizeHandler, int indexBits, T[] entries, Reference2IntMap<T> table, int size) {
++        this.idList = idList;
++        this.resizeHandler = resizeHandler;
++        this.indexBits = indexBits;
++        this.entries = entries;
++        this.table = table;
++        this.size = size;
++    }
++
++    public LithiumHashPalette(IdMap<T> idList, int bits, PaletteResize<T> resizeHandler, List<T> list) {
++        this(idList, bits, resizeHandler);
++
++        for (T t : list) {
++            this.addEntry(t);
++        }
++    }
++
++    @SuppressWarnings("unchecked")
++    public LithiumHashPalette(IdMap<T> idList, int bits, PaletteResize<T> resizeHandler) {
++        this.idList = idList;
++        this.indexBits = bits;
++        this.resizeHandler = resizeHandler;
++
++        int capacity = 1 << bits;
++
++        this.entries = (T[]) new Object[capacity];
++        this.table = new Reference2IntOpenHashMap<>(capacity, FAST_LOAD_FACTOR);
++        this.table.defaultReturnValue(ABSENT_VALUE);
++    }
++
++    @Override
++    public int idFor(T obj) {
++        int id = this.table.getInt(obj);
++
++        if (id == ABSENT_VALUE) {
++            id = this.computeEntry(obj);
++        }
++
++        return id;
++    }
++
++    @Override
++    public boolean maybeHas(Predicate<T> predicate) {
++        for (int i = 0; i < this.size; ++i) {
++            if (predicate.test(this.entries[i])) {
++                return true;
++            }
++        }
++
++        return false;
++    }
++
++    private int computeEntry(T obj) {
++        int id = this.addEntry(obj);
++
++        if (id >= 1 << this.indexBits) {
++            if (this.resizeHandler == null) {
++                throw new IllegalStateException("Cannot grow");
++            } else {
++                id = this.resizeHandler.onResize(this.indexBits + 1, obj);
++            }
++        }
++
++        return id;
++    }
++
++    private int addEntry(T obj) {
++        int nextId = this.size;
++
++        if (nextId >= this.entries.length) {
++            this.resize(this.size);
++        }
++
++        this.table.put(obj, nextId);
++        this.entries[nextId] = obj;
++
++        this.size++;
++
++        return nextId;
++    }
++
++    private void resize(int neededCapacity) {
++        this.entries = Arrays.copyOf(this.entries, HashCommon.nextPowerOfTwo(neededCapacity + 1));
++    }
++
++    @Override
++    public T valueFor(int id) {
++        T[] entries = this.entries;
++
++        if (id >= 0 && id < entries.length) {
++            return entries[id];
++        }
++
++        return null;
++    }
++
++    @Override
++    public void read(FriendlyByteBuf buf) {
++        this.clear();
++
++        int entryCount = buf.readVarInt();
++
++        for (int i = 0; i < entryCount; ++i) {
++            this.addEntry(this.idList.byId(buf.readVarInt()));
++        }
++    }
++
++    @Override
++    public void write(FriendlyByteBuf buf) {
++        int size = this.size;
++        buf.writeVarInt(size);
++
++        for (int i = 0; i < size; ++i) {
++            buf.writeVarInt(this.idList.getId(this.valueFor(i)));
++        }
++    }
++
++    @Override
++    public int getSerializedSize() {
++        int size = VarInt.getByteSize(this.size);
++
++        for (int i = 0; i < this.size; ++i) {
++            size += VarInt.getByteSize(this.idList.getId(this.valueFor(i)));
++        }
++
++        return size;
++    }
++
++    @Override
++    public int getSize() {
++        return this.size;
++    }
++
++    @Override
++    public Palette<T> copy() {
++        return new LithiumHashPalette<>(this.idList, this.resizeHandler, this.indexBits, this.entries.clone(), new Reference2IntOpenHashMap<>(this.table), this.size);
++    }
++
++    private void clear() {
++        Arrays.fill(this.entries, null);
++        this.table.clear();
++        this.size = 0;
++    }
++
++    public List<T> getElements() {
++        ImmutableList.Builder<T> builder = new ImmutableList.Builder<>();
++        for (T entry : this.entries) {
++            if (entry != null) {
++                builder.add(entry);
++            }
++        }
++        return builder.build();
++    }
++
++    public static <A> Palette<A> create(int bits, IdMap<A> idList, PaletteResize<A> listener, List<A> list) {
++        return new LithiumHashPalette<>(idList, bits, listener, list);
++    }
++}
+diff --git a/src/main/java/net/minecraft/util/BitStorage.java b/src/main/java/net/minecraft/util/BitStorage.java
+index 8bafd5fd7499ba4a04bf706cfd1e156073716e21..f62aab492f231e688b448389b1910e6fc2f5d8e6 100644
+--- a/src/main/java/net/minecraft/util/BitStorage.java
++++ b/src/main/java/net/minecraft/util/BitStorage.java
+@@ -31,4 +31,6 @@ public interface BitStorage {
+ 
+     }
+     // Paper end
++
++    <T> void compact(net.minecraft.world.level.chunk.Palette<T> srcPalette, net.minecraft.world.level.chunk.Palette<T> dstPalette, short[] out); // Gale - Lithium - faster chunk serialization
+ }
+diff --git a/src/main/java/net/minecraft/util/SimpleBitStorage.java b/src/main/java/net/minecraft/util/SimpleBitStorage.java
+index 453c1d7e01970fd817d27f59c3b00ffc70e8ca0c..844539798213360831541f49d97f8401d80d030e 100644
+--- a/src/main/java/net/minecraft/util/SimpleBitStorage.java
++++ b/src/main/java/net/minecraft/util/SimpleBitStorage.java
+@@ -201,4 +201,45 @@ public class SimpleBitStorage implements BitStorage {
+             super(message);
+         }
+     }
++
++    // Gale start - Lithium - faster chunk serialization
++    @Override
++    public <T> void compact(net.minecraft.world.level.chunk.Palette<T> srcPalette, net.minecraft.world.level.chunk.Palette<T> dstPalette, short[] out) {
++        if (this.size >= Short.MAX_VALUE) {
++            throw new IllegalStateException("Array too large");
++        }
++
++        if (this.size != out.length) {
++            throw new IllegalStateException("Array size mismatch");
++        }
++
++        short[] mappings = new short[(int) (this.mask + 1)];
++
++        int idx = 0;
++
++        for (long word : this.data) {
++            long bits = word;
++
++            for (int elementIdx = 0; elementIdx < this.valuesPerLong; ++elementIdx) {
++                int value = (int) (bits & this.mask);
++                int remappedId = mappings[value];
++
++                if (remappedId == 0) {
++                    remappedId = dstPalette.idFor(srcPalette.valueFor(value)) + 1;
++                    mappings[value] = (short) remappedId;
++                }
++
++                out[idx] = (short) (remappedId - 1);
++                bits >>= this.bits;
++
++                ++idx;
++
++                if (idx >= this.size) {
++                    return;
++                }
++            }
++        }
++    }
++    // Gale end - Lithium - faster chunk serialization
++
+ }
+diff --git a/src/main/java/net/minecraft/util/ZeroBitStorage.java b/src/main/java/net/minecraft/util/ZeroBitStorage.java
+index f8de91393564b3691c17339ac9196cc0fc1cf748..ecfe47110697378d7f7369640cd06b77f6fa0a87 100644
+--- a/src/main/java/net/minecraft/util/ZeroBitStorage.java
++++ b/src/main/java/net/minecraft/util/ZeroBitStorage.java
+@@ -72,4 +72,6 @@ public class ZeroBitStorage implements BitStorage {
+     public BitStorage copy() {
+         return this;
+     }
++
++    @Override public <T> void compact(net.minecraft.world.level.chunk.Palette<T> srcPalette, net.minecraft.world.level.chunk.Palette<T> dstPalette, short[] out) {}  // Gale - Lithium - faster chunk serialization
+ }
+diff --git a/src/main/java/net/minecraft/world/level/chunk/PaletteResize.java b/src/main/java/net/minecraft/world/level/chunk/PaletteResize.java
+index acae3eb30e0689048937f479dc3070f0688abdad..4b79f0474a9013dd4fdb68c6363ca1942ba8b007 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/PaletteResize.java
++++ b/src/main/java/net/minecraft/world/level/chunk/PaletteResize.java
+@@ -1,5 +1,5 @@
+ package net.minecraft.world.level.chunk;
+ 
+-interface PaletteResize<T> {
++public interface PaletteResize<T> {  // Gale - Lithium - faster chunk serialization - package -> public
+     int onResize(int newBits, T object);
+ }
+diff --git a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
+index 983799520ce052d98c9231f4f7925492d4f7d5c9..6e7b3ea1819780aef6db3ff0b43998de8f1066bf 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
++++ b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
+@@ -25,6 +25,22 @@ import net.minecraft.util.ThreadingDetector;
+ import net.minecraft.util.ZeroBitStorage;
+ 
+ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainerRO<T> {
++
++    // Gale start - Lithium - faster chunk serialization
++    private static final ThreadLocal<short[]> CACHED_ARRAY_4096 = ThreadLocal.withInitial(() -> new short[4096]);
++    private static final ThreadLocal<short[]> CACHED_ARRAY_64 = ThreadLocal.withInitial(() -> new short[64]);
++    private Optional<LongStream> asOptional(long[] data) {
++        return Optional.of(Arrays.stream(data));
++    }
++    private short[] getOrCreate(int size) {
++        return switch (size) {
++            case 64 -> CACHED_ARRAY_64.get();
++            case 4096 -> CACHED_ARRAY_4096.get();
++            default -> new short[size];
++        };
++    }
++    // Gale end - Lithium - faster chunk serialization
++
+     private static final int MIN_PALETTE_BITS = 0;
+     private final PaletteResize<T> dummyPaletteResize = (newSize, added) -> {
+         return 0;
+@@ -302,30 +318,54 @@ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainer
+     public synchronized PalettedContainerRO.PackedData<T> pack(IdMap<T> idList, PalettedContainer.Strategy paletteProvider) { // Paper - synchronize
+         this.acquire();
+ 
+-        PalettedContainerRO.PackedData var12;
++        // Gale start - Lithium - faster chunk serialization
++        Optional<LongStream> data = Optional.empty();
++        List<T> elements = null;
+         try {
+-            HashMapPalette<T> hashMapPalette = new HashMapPalette<>(idList, this.data.storage.getBits(), this.dummyPaletteResize);
+-            int i = paletteProvider.size();
+-            int[] is = new int[i];
+-            this.data.storage.unpack(is);
+-            swapPalette(is, (id) -> {
+-                return hashMapPalette.idFor(this.data.palette.valueFor(id));
+-            });
+-            int j = paletteProvider.calculateBitsForSerialization(idList, hashMapPalette.getSize());
+-            Optional<LongStream> optional;
+-            if (j != 0) {
+-                SimpleBitStorage simpleBitStorage = new SimpleBitStorage(j, i, is);
+-                optional = Optional.of(Arrays.stream(simpleBitStorage.getRaw()));
+-            } else {
+-                optional = Optional.empty();
++            // The palette that will be serialized
++            me.jellysquid.mods.lithium.common.world.chunk.LithiumHashPalette<T> hashPalette = null;
++
++            final Palette<T> palette = this.data.palette();
++            final BitStorage storage = this.data.storage();
++            if (storage instanceof ZeroBitStorage || palette.getSize() == 1) {
++                // If the palette only contains one entry, don't attempt to repack it.
++                elements = List.of(palette.valueFor(0));
++            } else if (palette instanceof me.jellysquid.mods.lithium.common.world.chunk.LithiumHashPalette<T> lithiumHashPalette) {
++                hashPalette = lithiumHashPalette;
+             }
+ 
+-            var12 = new PalettedContainerRO.PackedData<>(hashMapPalette.getEntries(), optional);
++            if (elements == null) {
++                me.jellysquid.mods.lithium.common.world.chunk.LithiumHashPalette<T> compactedPalette = new me.jellysquid.mods.lithium.common.world.chunk.LithiumHashPalette<>(idList, storage.getBits(), this.dummyPaletteResize);
++                short[] array = this.getOrCreate(paletteProvider.size());
++
++                storage.compact(this.data.palette(), compactedPalette, array);
++
++                // If the palette didn't change during compaction, do a simple copy of the data array
++                if (hashPalette != null && hashPalette.getSize() == compactedPalette.getSize() && storage.getBits() == paletteProvider.calculateBitsForSerialization(idList, hashPalette.getSize())) { // paletteSize can de-sync from palette - see https://github.com/CaffeineMC/lithium-fabric/issues/279
++                    data = this.asOptional(storage.getRaw().clone());
++                    elements = hashPalette.getElements();
++                } else {
++                    int bits = paletteProvider.calculateBitsForSerialization(idList, compactedPalette.getSize());
++                    if (bits != 0) {
++                        // Re-pack the integer array as the palette has changed size
++                        SimpleBitStorage copy = new SimpleBitStorage(bits, array.length);
++                        for (int i = 0; i < array.length; ++i) {
++                            copy.set(i, array[i]);
++                        }
++
++                        // We don't need to clone the data array as we are the sole owner of it
++                        data = this.asOptional(copy.getRaw());
++                    }
++
++                    elements = compactedPalette.getElements();
++                }
++            }
+         } finally {
+             this.release();
+         }
+ 
+-        return var12;
++        return new PalettedContainerRO.PackedData<>(elements, data);
++        // Gale end - Lithium - faster chunk serialization
+     }
+ 
+     private static <T> void swapPalette(int[] is, IntUnaryOperator applier) {
+@@ -365,17 +405,37 @@ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainer
+ 
+     @Override
+     public void count(PalettedContainer.CountConsumer<T> counter) {
+-        if (this.data.palette.getSize() == 1) {
+-            counter.accept(this.data.palette.valueFor(0), this.data.storage.getSize());
+-        } else {
+-            Int2IntOpenHashMap int2IntOpenHashMap = new Int2IntOpenHashMap();
+-            this.data.storage.getAll((key) -> {
+-                int2IntOpenHashMap.addTo(key, 1);
+-            });
+-            int2IntOpenHashMap.int2IntEntrySet().forEach((entry) -> {
+-                counter.accept(this.data.palette.valueFor(entry.getIntKey()), entry.getIntValue());
+-            });
++        // Gale start - Lithium - faster chunk serialization
++        int len = this.data.palette().getSize();
++
++        // Do not allocate huge arrays if we're using a large palette
++        if (len > 4096) {
++            // VanillaCopy
++            if (this.data.palette.getSize() == 1) {
++                counter.accept(this.data.palette.valueFor(0), this.data.storage.getSize());
++            } else {
++                Int2IntOpenHashMap int2IntOpenHashMap = new Int2IntOpenHashMap();
++                this.data.storage.getAll((key) -> {
++                    int2IntOpenHashMap.addTo(key, 1);
++                });
++                int2IntOpenHashMap.int2IntEntrySet().forEach((entry) -> {
++                    counter.accept(this.data.palette.valueFor(entry.getIntKey()), entry.getIntValue());
++                });
++            }
++        }
++
++        short[] counts = new short[len];
++
++        this.data.storage().getAll(i -> counts[i]++);
++
++        for (int i = 0; i < counts.length; i++) {
++            T obj = this.data.palette().valueFor(i);
++
++            if (obj != null) {
++                counter.accept(obj, counts[i]);
++            }
+         }
++        // Gale end - Lithium - faster chunk serialization
+     }
+ 
+     static record Configuration<T>(Palette.Factory factory, int bits) {

patches/server/0052-Sparkly-Paper-Optimize-canSee-checks.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Sparkly Paper Optimize canSee checks
 
 
 diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
-index c212030a24174115a975604b91d03cf8ad4043de..2fc86eb396ed600154840dd6cd43b9294a34595c 100644
+index 8f642259ab8aa94eb5739ecbe72211c248c1114d..1ef9d716c6c1523c0ee1cb6fd484e2a8ca367adc 100644
 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java
 +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
 @@ -1408,7 +1408,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider

patches/server/0054-Leaves-Protocol-Core.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Leaves Protocol Core
 
 
 diff --git a/src/main/java/io/papermc/paper/threadedregions/RegionizedServer.java b/src/main/java/io/papermc/paper/threadedregions/RegionizedServer.java
-index fc3d332aa1c1d469cedfe2aaa7102dcd78e25642..bebaa4e7abcbd01dc57fddf2a473b846e887cc7f 100644
+index 1ae61bc6603dd3ac290e3ead20416f9c5b63ff02..168ed2c21aed6a10f3aca259880b1b8bdbf98b78 100644
 --- a/src/main/java/io/papermc/paper/threadedregions/RegionizedServer.java
 +++ b/src/main/java/io/papermc/paper/threadedregions/RegionizedServer.java
-@@ -313,6 +313,8 @@ public final class RegionizedServer {
+@@ -314,6 +314,8 @@ public final class RegionizedServer {
  
          // player list
          MinecraftServer.getServer().getPlayerList().tick();
@@ -120,10 +120,10 @@ index 0000000000000000000000000000000000000000..64a1d25973b032e8cab64bbffa6824a1
 +}
 diff --git a/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocolManager.java b/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocolManager.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..055f044ce6cef4377f6f577efdbfad0ec9a2d57b
+index 0000000000000000000000000000000000000000..8b7813c442733f5d4d3b2a072902099cbe596b37
 --- /dev/null
 +++ b/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocolManager.java
-@@ -0,0 +1,340 @@
+@@ -0,0 +1,344 @@
 +package top.leavesmc.leaves.protocol.core;
 +
 +import net.minecraft.network.FriendlyByteBuf;
@@ -167,7 +167,11 @@ index 0000000000000000000000000000000000000000..055f044ce6cef4377f6f577efdbfad0e
 +    private static final Map<LeavesProtocol, Map<ProtocolHandler.MinecraftRegister, Method>> MINECRAFT_REGISTER = new HashMap<>();
 +
 +    public static void init() {
-+        for (Class<?> clazz : getClasses("top.leavesmc.leaves.protocol")) {
++        //Luminol start - For the protocol supports of luminol
++        final Set<Class<?>> allClazz = getClasses("org.leavesmc.leaves.protocol");
++        allClazz.addAll(getClasses("me.earthme.luminol.protocols"));
++        //Luminol end
++        for (Class<?> clazz : allClazz) {
 +            final LeavesProtocol protocol = clazz.getAnnotation(LeavesProtocol.class);
 +            if (protocol != null) {
 +                Set<Method> methods;

patches/server/0055-Leaves-Bladeren-Protocol.patch

@@ -6,21 +6,25 @@ Subject: [PATCH] Leaves Bladeren Protocol
 
 diff --git a/src/main/java/me/earthme/luminol/config/modules/gameplay/LeavesBladerenProtocolConfig.java b/src/main/java/me/earthme/luminol/config/modules/gameplay/LeavesBladerenProtocolConfig.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..b882549a3c3bc8c192014fd6e1ac7b4f0feddafc
+index 0000000000000000000000000000000000000000..4950d33288d6bc3c4ce90ae12bbf4797e3989500
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/config/modules/gameplay/LeavesBladerenProtocolConfig.java
-@@ -0,0 +1,24 @@
+@@ -0,0 +1,28 @@
 +package me.earthme.luminol.config.modules.gameplay;
 +
 +import me.earthme.luminol.config.ConfigInfo;
 +import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.HotReloadUnsupported;
 +import me.earthme.luminol.config.IConfigModule;
 +
 +public class LeavesBladerenProtocolConfig implements IConfigModule {
++    @HotReloadUnsupported
 +    @ConfigInfo(baseName = "enable_base_protocol")
 +    public static boolean enableBaseProtocol = false;
++    @HotReloadUnsupported
 +    @ConfigInfo(baseName = "enable_mspt_sync_protocol")
 +    public static boolean msptSyncProtocol = false;
++    @HotReloadUnsupported
 +    @ConfigInfo(baseName = "mspt_sync_interval")
 +    public static int msptSyncTickInterval = 20;
 +

patches/server/0056-Leaves-Fix-Bladeren-Protocol.patch

@@ -21,10 +21,10 @@ index 64a1d25973b032e8cab64bbffa6824a131676773..57a563b3f2d01719d490578907411d25
  
  }
 diff --git a/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocolManager.java b/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocolManager.java
-index 055f044ce6cef4377f6f577efdbfad0ec9a2d57b..18fc0e2c890020bf587f5b1d2e097126d3e19999 100644
+index 8b7813c442733f5d4d3b2a072902099cbe596b37..1f5b37daa5cbb709eeacf3dc7a4f9b4a0dc05274 100644
 --- a/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocolManager.java
 +++ b/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocolManager.java
-@@ -56,7 +56,7 @@ public class LeavesProtocolManager {
+@@ -60,7 +60,7 @@ public class LeavesProtocolManager {
                      return;
                  }
  
@@ -33,7 +33,7 @@ index 055f044ce6cef4377f6f577efdbfad0ec9a2d57b..18fc0e2c890020bf587f5b1d2e097126
                  for (final Method method : methods) {
                      if (method.isBridge() || method.isSynthetic() || !Modifier.isStatic(method.getModifiers())) {
                          continue;
-@@ -131,13 +131,13 @@ public class LeavesProtocolManager {
+@@ -135,13 +135,13 @@ public class LeavesProtocolManager {
  
      public static CustomPacketPayload getPayload(ResourceLocation id, FriendlyByteBuf buf) {
          for (LeavesProtocol protocol : KNOWN_TYPES.keySet()) {
@@ -49,7 +49,7 @@ index 055f044ce6cef4377f6f577efdbfad0ec9a2d57b..18fc0e2c890020bf587f5b1d2e097126
                      try {
                          return map.get(receiver).newInstance(id, buf);
                      } catch (InvocationTargetException | InstantiationException | IllegalAccessException e) {
-@@ -151,15 +151,14 @@ public class LeavesProtocolManager {
+@@ -155,15 +155,14 @@ public class LeavesProtocolManager {
  
      public static void handlePayload(ServerPlayer player, CustomPacketPayload payload) {
          for (LeavesProtocol protocol : KNOW_RECEIVERS.keySet()) {
@@ -67,7 +67,7 @@ index 055f044ce6cef4377f6f577efdbfad0ec9a2d57b..18fc0e2c890020bf587f5b1d2e097126
                          try {
                              map.get(receiver).invoke(null, player, payload);
                          } catch (InvocationTargetException | IllegalAccessException e) {
-@@ -222,7 +221,7 @@ public class LeavesProtocolManager {
+@@ -226,7 +225,7 @@ public class LeavesProtocolManager {
      public static void handleMinecraftRegister(String channelId, ServerPlayer player) {
          for (LeavesProtocol protocol : MINECRAFT_REGISTER.keySet()) {
              String[] channel = channelId.split(":");

patches/server/0057-Leaves-carpet-protocol-support.patch

@@ -4,19 +4,21 @@ Date: Thu, 8 Feb 2024 11:57:18 +0000
 Subject: [PATCH] Leaves carpet protocol support
 
 
-diff --git a/src/main/java/me/earthme/luminol/config/modules/gameplay/LeavesProtocolSupportConfig.java b/src/main/java/me/earthme/luminol/config/modules/gameplay/LeavesProtocolSupportConfig.java
+diff --git a/src/main/java/me/earthme/luminol/config/modules/gameplay/LeavesCarpetProtocolSupportConfig.java b/src/main/java/me/earthme/luminol/config/modules/gameplay/LeavesCarpetProtocolSupportConfig.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..80d57d6262510cf7c6446e46cdd16d05461e9484
+index 0000000000000000000000000000000000000000..0ef77515b213b74bdcf7dac70a02bfaa1c8804f5
 --- /dev/null
-+++ b/src/main/java/me/earthme/luminol/config/modules/gameplay/LeavesProtocolSupportConfig.java
-@@ -0,0 +1,20 @@
++++ b/src/main/java/me/earthme/luminol/config/modules/gameplay/LeavesCarpetProtocolSupportConfig.java
+@@ -0,0 +1,22 @@
 +package me.earthme.luminol.config.modules.gameplay;
 +
 +import me.earthme.luminol.config.ConfigInfo;
 +import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.HotReloadUnsupported;
 +import me.earthme.luminol.config.IConfigModule;
 +
-+public class LeavesProtocolSupportConfig implements IConfigModule {
++public class LeavesCarpetProtocolSupportConfig implements IConfigModule {
++    @HotReloadUnsupported
 +    @ConfigInfo(baseName = "enabled")
 +    public static boolean enabled = false;
 +
@@ -32,12 +34,13 @@ index 0000000000000000000000000000000000000000..80d57d6262510cf7c6446e46cdd16d05
 +}
 diff --git a/src/main/java/top/leavesmc/leaves/protocol/CarpetServerProtocol.java b/src/main/java/top/leavesmc/leaves/protocol/CarpetServerProtocol.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..2af49a86bf2a8bb65073c8ce088e875224916fd8
+index 0000000000000000000000000000000000000000..0542d66a3dfae2aa3ccb6ca3dced6b34024017ad
 --- /dev/null
 +++ b/src/main/java/top/leavesmc/leaves/protocol/CarpetServerProtocol.java
-@@ -0,0 +1,112 @@
+@@ -0,0 +1,113 @@
 +package top.leavesmc.leaves.protocol;
 +
++import me.earthme.luminol.config.modules.gameplay.LeavesCarpetProtocolSupportConfig;
 +import net.minecraft.nbt.CompoundTag;
 +import net.minecraft.network.FriendlyByteBuf;
 +import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
@@ -72,7 +75,7 @@ index 0000000000000000000000000000000000000000..2af49a86bf2a8bb65073c8ce088e8752
 +
 +    @ProtocolHandler.PlayerJoin
 +    public static void onPlayerJoin(ServerPlayer player) {
-+        if (me.earthme.luminol.config.modules.gameplay.LeavesProtocolSupportConfig.enabled) {
++        if (LeavesCarpetProtocolSupportConfig.enabled) {
 +            CompoundTag data = new CompoundTag();
 +            data.putString(HI, VERSION);
 +            ProtocolUtils.sendPayloadPacket(player, new CarpetPayload(data));
@@ -81,7 +84,7 @@ index 0000000000000000000000000000000000000000..2af49a86bf2a8bb65073c8ce088e8752
 +
 +    @ProtocolHandler.PayloadReceiver(payload = CarpetPayload.class, payloadId = "hello")
 +    private static void handleHello(@NotNull ServerPlayer player, @NotNull CarpetServerProtocol.CarpetPayload payload) {
-+        if (me.earthme.luminol.config.modules.gameplay.LeavesProtocolSupportConfig.enabled) {
++        if (LeavesCarpetProtocolSupportConfig.enabled) {
 +            if (payload.nbt.contains(HELLO)) {
 +                MinecraftServer.LOGGER.info("Player " + player.getScoreboardName() + " joined with carpet " + payload.nbt.getString(HELLO));
 +                CompoundTag data = new CompoundTag();

patches/server/0059-Fix-MC-172047.patch

@@ -0,0 +1,55 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: HaHaWTH <fsjk947@gmail.com>
+Date: Fri, 15 Mar 2024 03:16:22 +0800
+Subject: [PATCH] Fix-MC-172047
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Wolf.java b/src/main/java/net/minecraft/world/entity/animal/Wolf.java
+index 2d20b2c1f58beb1ad8c9012d8124e476899e6be6..4e06908ed9759abb61a5ef5abf774874d231a83e 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Wolf.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Wolf.java
+@@ -52,6 +52,7 @@ import net.minecraft.world.entity.ai.goal.target.OwnerHurtTargetGoal;
+ import net.minecraft.world.entity.ai.goal.target.ResetUniversalAngerTargetGoal;
+ import net.minecraft.world.entity.animal.horse.AbstractHorse;
+ import net.minecraft.world.entity.animal.horse.Llama;
++import net.minecraft.world.entity.decoration.ArmorStand;
+ import net.minecraft.world.entity.monster.AbstractSkeleton;
+ import net.minecraft.world.entity.monster.Creeper;
+ import net.minecraft.world.entity.monster.Ghast;
+@@ -529,13 +530,34 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+ 
+     @Override
+     public boolean wantsToAttack(LivingEntity target, LivingEntity owner) {
+-        if (!(target instanceof Creeper) && !(target instanceof Ghast)) {
++        if (!(target instanceof Creeper) && !(target instanceof Ghast) && !(target instanceof ArmorStand)) { // Luminol - Fix MC-172047
+             if (target instanceof Wolf) {
+                 Wolf entitywolf = (Wolf) target;
+ 
+                 return !entitywolf.isTame() || entitywolf.getOwner() != owner;
+             } else {
+-                return target instanceof Player && owner instanceof Player && !((Player) owner).canHarmPlayer((Player) target) ? false : (target instanceof AbstractHorse && ((AbstractHorse) target).isTamed() ? false : !(target instanceof TamableAnimal) || !((TamableAnimal) target).isTame());
++                // Luminol start
++                if (target instanceof Player) {
++                    Player targetPlayer = (Player) target;
++                    if (owner instanceof Player) {
++                        Player ownerPlayer = (Player) owner;
++                        if (!ownerPlayer.canHarmPlayer(targetPlayer)) {
++                            return false;
++                        }
++                    }
++                }
++                if (target instanceof AbstractHorse) {
++                    AbstractHorse targetHorse = (AbstractHorse) target;
++                    if (targetHorse.isTamed()) {
++                        return false;
++                    }
++                }
++                if (target instanceof TamableAnimal) {
++                    TamableAnimal tamableAnimalTarget = (TamableAnimal) target;
++                    return !tamableAnimalTarget.isTame();
++                }
++                return true;
++                // Luminol end
+             }
+         } else {
+             return false;

patches/server/0060-Fix-MC-2025.patch

@@ -0,0 +1,41 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: HaHaWTH <fsjk947@gmail.com>
+Date: Fri, 15 Mar 2024 03:32:46 +0800
+Subject: [PATCH] Fix-MC-2025
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index d175f13ada111bcee977957c6fd9580e032183e9..6de8506b39f73aac7c3a3956251bb54f9f7a7533 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -2532,6 +2532,16 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+                 nbttagcompound.putBoolean("Paper.FreezeLock", true);
+             }
+             // Paper end
++
++            // Luminol start - Fix MC-2025
++            AABB boundingBox = getBoundingBox();
++            ListTag boundingBoxList = new ListTag();
++            for (double coord : new double[]{boundingBox.minX, boundingBox.minY, boundingBox.minZ, boundingBox.maxX, boundingBox.maxY, boundingBox.maxZ}) {
++                boundingBoxList.add(DoubleTag.valueOf(coord));
++            }
++            nbttagcompound.put("Luminol.BoundingBox", boundingBoxList);
++            // Luminol end
++
+             return nbttagcompound;
+         } catch (Throwable throwable) {
+             CrashReport crashreport = CrashReport.forThrowable(throwable, "Saving entity NBT");
+@@ -2609,6 +2619,13 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+                         this.reapplyPosition();
+                     }
+ 
++                    // Luminol start - Fix MC-2025
++                    if (nbt.contains("Luminol.BoundingBox", net.minecraft.nbt.Tag.TAG_LIST)) {
++                        ListTag boundingBoxList = nbt.getList("Luminol.BoundingBox", net.minecraft.nbt.Tag.TAG_DOUBLE);
++                        setBoundingBox(new AABB(boundingBoxList.getDouble(0), boundingBoxList.getDouble(1), boundingBoxList.getDouble(2), boundingBoxList.getDouble(3), boundingBoxList.getDouble(4), boundingBoxList.getDouble(5)));
++                    }
++                    // Luminol end
++
+                 } else {
+                     throw new IllegalStateException("Entity has invalid rotation");
+                 }

settings.gradle.kts

@@ -7,7 +7,7 @@ pluginManagement {
     }
 }
 
-rootProject.name = "Luminol"
+rootProject.name = "luminol"
 for (name in listOf("Luminol-API", "Luminol-Server")) {
     val projName = name.toLowerCase(Locale.ENGLISH)
     include(projName)