Dropped duplicated patches

Fixes:
     https://github.com/PaperMC/Folia/issues/311
     https://github.com/PaperMC/Folia/issues/324

Related to :
     https://bugs.mojang.com/browse/MC-92875

.gitattributes

@@ -0,0 +1,11 @@
+#
+# https://help.github.com/articles/dealing-with-line-endings/
+#
+# Linux start script should use lf
+/gradlew        text eol=lf
+
+# These are Windows script files and should use crlf
+*.bat           text eol=crlf
+
+# Binary files should be left untouched
+*.jar           binary

.github/FUNDING.yml

@@ -0,0 +1,14 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+polar: # Replace with a single Polar username
+buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
+custom: https://afdian.com/a/Luminol

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -0,0 +1,68 @@
+name: Bug反馈 Bug report
+description: 
+  报告Bug，插件不兼容情况，以及其他相关问题。
+  Report issues with plugin incompatbility or other behavior related issues.
+labels:
+  - bug
+body:
+  - type: markdown
+    attributes:
+      value: |
+        请详细描述您所遇到的Bug。确保您**真的**遇到了**服务端**Bug，而非原版特性或客户端Bug。
+        Please describe the bug you encountered in detail. Make sure you're **actually** hitting a **server-side** bug, not a vanilla feature or client-side bug.<br>
+        如果您确定的话，就按照下面的模板填充信息，并提交反馈。
+        If you are sure, follow the template below to fill in the information and submit your feedback.<br>
+        如果此bug被尝试修复，您可以帮助我们测试并回复。若bug的确被修复，您可以关闭issue来让开发者确认。
+        If this bug is tried to fix, you can help us test and reply. If the bug is fixed, you can close the issue to let the developer confirm.
+  - type: input
+    id: leavesMC-version
+    attributes:
+      label: 服务端版本 LuminolMC Version
+      description:
+        LuminolMC服务端发行版本 LuminolMC server release version (contains the git commit's hash)<br>
+        通过执行`/version`命令将获取到的内容复制到这里。 Run `/version` on your server and paste the full, unmodified output here.
+      placeholder: >
+        e.g. git-Luminol-"0635a89" (MC: 1.20.4)
+    validations:
+      required: true
+  - type: textarea
+    id: expected-behavior
+    attributes:
+      label: 预期的行为 Expected behavior
+      description: 你期望看到的情况是什么样。What you expected to see.
+      placeholder: e.g. 使用 /tpsbar [NAME] 命令可以切换TPSBAR的开关
+    validations:
+      required: true
+  - type: textarea
+    id: actual-behavior
+    attributes:
+      label: 观测到的实际行为 Observed/Actual behavior
+      description: 你实际看到的。 What you actually saw.
+      placeholder: e.g. 使用 /tpsbar [NAME] 命令切换不了TPSBAR
+    validations:
+      required: true
+  - type: textarea
+    id: reproduce
+    attributes:
+      label: 复现步骤 Steps/models to reproduce
+      description:
+        这里应该有一个图片、视频或其他信息来展现你的问题。<br>
+        This may include a build schematic, a video, or detailed instructions to help reconstruct the issue.
+      placeholder: e.g. 登录其他账号，使用 /tpsbar [NAME] 命令切换不了TPSBAR
+    validations:
+      required: true
+  - type: textarea
+    id: plugin-list
+    attributes:
+      label: 插件与数据包列表。 Plugin and Datapack List.
+      description:
+        服务器上的所有插件和数据包列表。
+        All plugins and datapacks running on your server.<br>
+        执行命令`/plugins`查看插件列表。执行命令`/datapack list`查看数据包列表。
+        To list plugins, run `/plugins`. For datapacks, run `/datapack list`.
+    validations:
+      required: true
+  - type: textarea
+    id: other
+    attributes:
+      label: 更多详细信息。 The more information.

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -0,0 +1,31 @@
+name: 新的需求 Feature Request
+description: 
+  为Luminol提供新的想法。
+  Suggest an idea for Luminol.
+labels:
+  - enhancement
+body:
+  - type: markdown
+    attributes:
+      value: |
+        感谢您为 Luminol 提交新的需求！请尽可能详细地描述，以便我们可以更轻松地考虑和审查请求。
+        Thank you for filling out a feature request for Luminol! Please be as detailed as possible so that we may consider and review the request easier.<br>
+        请搜索所有问题以避免重复的功能请求。如果您期望的功能已存在，请回复如果您有什么要补充的。
+        We ask that you search all the issues to avoid a duplicate feature request. If one exists, please reply if you have anything to add.<br>
+        在请求新功能之前，请确保您使用的是最新版本并且您请求的功能不在 Luminol 中。
+        Before requesting a new feature, please make sure you are using the latest version and that the feature you are requesting is not already in Paper.<br>
+        我们的开发人员可能没有过多时间来测试新功能的可用性，如新功能进入Test状态，您可以帮助我们进行测试并回复。
+        Our developers may not have much time to test the usability of new functions. If the new functions enter the Test state, you can help us test and reply.
+
+  - type: textarea
+    id: feature
+    attributes:
+      label: 描述你希望添加的功能。 Describe the feature you'd like.
+      placeholder: e.g. 添加新的PATH
+    validations:
+      required: true
+  - type: textarea
+    id: othre
+    attributes:
+      label: 其他 Other
+      description: 添加其他的信息。 Add any other context or screenshots about the feature request below.

.github/workflows/build.yml

@@ -1,63 +0,0 @@
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-gradle
-
-name: LuminolCI - Ver/1.20.2
-
-on:
-  push:
-    branches: [ "ver/1.20.2" ]
-  pull_request:
-    branches: [ "ver/1.20.2" ]
-
-permissions: write-all
-
-jobs:
-  build:
-    runs-on: macos-latest
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Set up git
-      run: git config --global user.email "noreply@github.com" && git config --global user.name "ci"
-    - name: Set up JDK 17
-      uses: actions/setup-java@v3
-      with:
-        java-version: '17'
-        distribution: 'temurin'
-    - name: Make gradlew executable
-      run: chmod 777 ./gradlew
-    - name: Setup project
-      uses: gradle/gradle-build-action@bd5760595778326ba7f1441bcf7e88b49de61a25 # v2.6.0
-      with:
-        arguments: applyPatches
-    - name: Build project to paperclip jar
-      uses: gradle/gradle-build-action@bd5760595778326ba7f1441bcf7e88b49de61a25 # v2.6.0
-      with:
-        arguments: createReobfPaperclipJar
-    - name: Capture build artifacts
-      uses: actions/upload-artifact@v3
-      with:
-        name: Artifacts
-        path: build/libs/
-    - name: Publish API
-      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
-    - name: Rename jar file
-      run: mv build/libs/Luminol-paperclip-1.20.2-R0.1-SNAPSHOT-reobf.jar build/libs/lunminol-1.20.2-paperclip.jar
-    - name: Release Artifacts
-      uses: svenstaro/upload-release-action@v2
-      with:
-       release_name: "Luminol MC1.20.2 - ${{ github.event.repository.updated_at}}"
-       tag: "1.20.2-${{ github.run_id }}"
-       repo_token: "${{ secrets.GITHUB_TOKEN }}"
-       file: "build/libs/lunminol-1.20.2-paperclip.jar"
-       file_glob: true
-       prerelease: false    

.github/workflows/build_1.21.4.yml

@@ -0,0 +1,63 @@
+name: Luminol CI - dev/1.21.4-hardfork
+
+on:
+    push:
+      branches: [ "dev/1.21.4-hardfork" ]
+    pull_request:
+      branches: [ "dev/1.21.4-hardfork" ]
+
+permissions: write-all
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    environment: default
+    steps:
+      - name: Checkout Git Repository
+        uses: actions/checkout@v4
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+      - name: Set up JDK
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'zulu'
+          java-version: '22'
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+      - name: Configure Git User Details
+        run: git config --global user.email "ci@luminolmc.com" && git config --global user.name "LuminolMC CI"
+      - name: Apply Patches
+        run: ./gradlew applyAllPatches
+      - name: CreateJar
+        run: ./gradlew createMojmapPaperclipJar
+      - name: Publish to repo
+        continue-on-error: true
+        run: |
+          export MAVEN_REPO_USER=${{ secrets.MAVEN_REPO_USER }}
+          export MAVEN_REPO_PASSWORD=${{ secrets.MAVEN_REPO_PASSWORD }}
+          ./gradlew publish -PpublishDevBundle=true
+      - name: Upload Artifact
+        uses: "actions/upload-artifact@v4"
+        with:
+          name: "${{ env.project_id_b }} CI Artifacts"
+          path: "luminol-server/build/libs/*.jar"
+      - name: SetENV
+        run: sh scripts/SetENV.sh
+      - name: Create Release
+        if: "!contains(github.event.commits[0].message, '[release skip]')"
+        uses: ncipollo/release-action@v1.14.0
+        with:
+          tag: ${{ env.tag }}
+          name: ${{ env.project_id_b }} ${{ env.mcversion }} - ${{ env.commit_id }}
+          body: |
+            📦Version: `${{ env.mcversion }}` | Commit ${{ env.commit_id }} [![download](https://img.shields.io/github/downloads/LuminolMC/${{ env.project_id }}/${{ env.tag }}/total?color=red&style=flat-square)](https://github.com/LuminolMC/${{ env.project_id }}/download/${{ env.tag }}/${{ env.jar }})
+            This release is automatically compiled by GitHub Actions
+            ### Commit Message
+            ${{ env.commit_msg }}
+          artifacts: |
+            ${{ env.jar_dir }}
+            ${{ env.jar_dir_bundler }}
+          generateReleaseNotes: true
+          prerelease: ${{ env.pre }}
+          makeLatest: ${{ env.make_latest }}
+          token: "${{ secrets.GITHUB_TOKEN }}"

.gitignore

@@ -1,58 +1,18 @@
-# JVM crash related
-core.*
-hs_err_pid*
+# Ignore Gradle project-specific cache directory
+.gradle
+
+# Ignore Gradle build output directory
+build
+
+/run
+
+/luminol-server/build.gradle.kts
+/luminol-api/build.gradle.kts
+/folia-server/build.gradle.kts
+/folia-server/src/minecraft
+/paper-server
+/folia-api/build.gradle.kts
+/paper-api
+/paper-api-generator
 
-# Intellij
 .idea/
-*.iml
-*.ipr
-*.iws
-out/
-
-# Eclipse
-.classpath
-.project
-.settings/
-
-# netbeans
-nbproject/
-nbactions.xml
-
-# Gradle
-!gradle-wrapper.jar
-.gradle/
-build/
-*/build/
-
-# we use maven!
-build.xml
-
-# Maven
-log/
-target/
-dependency-reduced-pom.xml
-
-# various other potential build files
-build/
-bin/
-dist/
-manifest.mf
-
-# Mac
-.DS_Store/
-.DS_Store
-
-# vim
-.*.sw[a-p]
-
-# Linux temp files
-*~
-
-# other stuff
-run/
-
-build-data/
-Hearse-API
-Hearse-Server
-*.jar
-/patches/todo/

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Era4FunMC
+Copyright (c) 2025 LuminolMC
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

README.md

@@ -1,39 +1,93 @@
+<img src="./public/image/Luminol_5.png" alt="Logo" align="right" width="250">
+
 # Luminol
+<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)
 ![Commit Activity](https://img.shields.io/github/commit-activity/w/LuminolMC/Luminol?style=flat-square)
 ![CodeFactor Grade](https://img.shields.io/codefactor/grade/github/LuminolMC/Luminol?style=flat-square)
 ![GitHub all releases](https://img.shields.io/github/downloads/LuminolMC/Luminol/total?style=flat-square)
 
-<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>
+[English](./README_EN.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)
+## 特性
+- 可配置的原版特性
+- Tpsbar 支持
+- 对单线程区域性能的优化
+- 更多的插件开发API支持（进行中）
 
-## 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.
+## 下载
+任何版本都可以在 [Release](https://github.com/LuminolMC/Luminol/releases) 中找到，你也可以通过[以下步骤](./README.md#构建)自己构建。
+
+## 构建
+要构建一个paperclip jar，你需要运行以下命令。你可以在build/libs中找到jar（注意：需要`JDK21`）
 
-## 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
+ ./gradlew applyPatches && ./gradlew createMojmapPaperclipJar
 ```
-## Using API
-For gradle:
+
+## 使用API
+使用 Gradle:
+
 ```kotlin
+repositories {
+    maven {
+        url = "https://maven.moliatopia.icu/repository/maven-snapshots/"
+    }
+}
+
 dependencies {
-    compileOnly("me.earthme.luminol:luminol-api:1.20.2-R0.1-SNAPSHOT")
+    compileOnly("me.earthme.luminol:luminol-api:$VERSION")
 }
  ```
-For maven
+
+使用 Maven
+
 ```xml
-<dependency>
-  <groupId>me.earthme.luminol</groupId>
-  <artifactId>luminol-api</artifactId>
-  <version>1.20.2-R0.1-SNAPSHOT</version>
-</dependency>
+<repositories>
+    <repository>
+        <id>moliatopia</id>
+        <url>https://maven.moliatopia.icu/repository/maven-snapshots/</url>
+    </repository>
+</repositories>
+
+<dependencies>
+    <dependency>
+        <groupId>me.earthme.luminol</groupId>
+        <artifactId>luminol-api</artifactId>
+        <version>$VERSION</version>
+    </dependency>
+</dependencies>
 ```
+
+## 联系方式
+> 如果您对这个项目感兴趣或有任何问题，请随时向我们提问。
+
+**QQ群: [368632360](http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=MfosKhcDd8Fdxn1MREuZ8Krbf9T6jiBC&authKey=3cm6qdHohON3gHnuD63FK4k07fIbrWnY4hdyq8OmELsfjMVP1kbFTJY9mRyM2Rkj&noverify=0&group_code=368632360)** | QQ频道: [点击加入](https://pd.qq.com/s/eq9krf9j) | Telegram: [点击加入](https://t.me/LuminolMC) | Discord: [点击加入](https://discord.gg/Qd7m3V6eDx)
+
+
+## 关于 Issue
+当您遇到任何问题时，请向我们提问，我们将尽力解决，但请记得清楚地描述您的问题并提供足够的日志等信息。
+
+## 贡献代码
+可[查看 Contributing](./docs/CONTRIBUTING.md)
+
+## BStats
+![bStats](https://bstats.org/signatures/server-implementation/Luminol.svg "bStats")
+
+## 特别感谢
+<b>感谢[LegacyLands](https://github.com/LegacyLands)对本项目的赞助,如果你想开发一些跨folia/非folia平台的插件,[legacy-lands-library](https://github.com/LegacyLands/legacy-lands-library/)将会是个不错的lib</b>
+
+![legacy-lands-logo](public/image/legacy-lands-logo.png)
+
+## 请给我们一个 ⭐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>

README_EN.md

@@ -0,0 +1,91 @@
+<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>
+
+[![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)
+![Commit Activity](https://img.shields.io/github/commit-activity/w/LuminolMC/Luminol?style=flat-square)
+![CodeFactor Grade](https://img.shields.io/codefactor/grade/github/LuminolMC/Luminol?style=flat-square)
+![GitHub all releases](https://img.shields.io/github/downloads/LuminolMC/Luminol/total?style=flat-square)
+
+**English** | [中文](./README.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)
+
+## 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](./README_EN.md#build).
+
+## Build
+To build a paperclip jar, you need to run the following command. You can find the jar in build/libs(Note: JDK21 is needed)
+
+ ```shell
+ ./gradlew applyPatches && ./gradlew createMojmapPaperclipJar
+```
+
+## Using API
+For gradle:
+
+```kotlin
+repositories {
+    maven {
+        url = "https://maven.moliatopia.icu/repository/maven-snapshots/"
+    }
+}
+
+dependencies {
+    compileOnly("me.earthme.luminol:luminol-api:$VERSION")
+}
+ ```
+
+For maven
+
+```xml
+<repositories>
+    <repository>
+        <id>moliatopia</id>
+        <url>https://maven.moliatopia.icu/repository/maven-snapshots/</url>
+    </repository>
+</repositories>
+
+<dependencies>
+<dependency>
+    <groupId>me.earthme.luminol</groupId>
+    <artifactId>luminol-api</artifactId>
+    <version>$VERSION</version>
+</dependency>
+</dependencies>
+```
+
+## Contact
+> If you are interested in this project or have any issue, feel free to ask us.
+
+**QQ Group: [368632360](http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=MfosKhcDd8Fdxn1MREuZ8Krbf9T6jiBC&authKey=3cm6qdHohON3gHnuD63FK4k07fIbrWnY4hdyq8OmELsfjMVP1kbFTJY9mRyM2Rkj&noverify=0&group_code=368632360)** | QQ Channel: [Click To Join](https://pd.qq.com/s/eq9krf9j) | Telegram: [Click To Join](https://t.me/LuminolMC) | Discord: [Click To Join](https://discord.gg/Qd7m3V6eDx)
+
+## 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>
+
+## Pull Requests
+See [Contributing](./docs/CONTRIBUTING_EN.md)
+
+## BStats
+![bStats](https://bstats.org/signatures/server-implementation/Luminol.svg "bStats")
+
+## Special Thanks
+Thanks [LegacyLands](https://github.com/LegacyLands) for sponsoring this project.If you want to develop some crossing folia/non-folia platform plugins, [legacy-lands-library](https://github.com/LegacyLands/legacy-lands-library/) will be a nice choice for you
+
+![legacy-lands-logo](public/image/legacy-lands-logo.png)
+
+## 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>

build.gradle.kts

@@ -1,95 +1,92 @@
-import io.papermc.paperweight.util.constants.*
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+import org.gradle.api.tasks.testing.logging.TestLogEvent
 
 plugins {
-    java
-    `maven-publish`
-    id("com.github.johnrengelman.shadow") version "8.1.1" apply false
-    id("io.papermc.paperweight.patcher") version "1.5.9"
+    java // TODO java launcher tasks
+    id("io.papermc.paperweight.patcher") version "2.0.0-beta.14"
+}
+
+paperweight {
+    upstreams.register("folia") {
+        repo = github("PaperMC", "Folia")
+        ref = providers.gradleProperty("foliaRef")
+
+        patchFile {
+            path = "folia-server/build.gradle.kts"
+            outputFile = file("luminol-server/build.gradle.kts")
+            patchFile = file("luminol-server/build.gradle.kts.patch")
+        }
+        patchFile {
+            path = "folia-api/build.gradle.kts"
+            outputFile = file("luminol-api/build.gradle.kts")
+            patchFile = file("luminol-api/build.gradle.kts.patch")
+        }
+        patchRepo("paperApi") {
+            upstreamPath = "paper-api"
+            patchesDir = file("luminol-api/paper-patches")
+            outputDir = file("paper-api")
+        }
+        patchDir("foliaApi") {
+            upstreamPath = "folia-api"
+            excludes = listOf("build.gradle.kts", "build.gradle.kts.patch", "paper-patches")
+            patchesDir = file("luminol-api/folia-patches")
+            outputDir = file("folia-api")
+        }
+    }
 }
 
 val paperMavenPublicUrl = "https://repo.papermc.io/repository/maven-public/"
 
-repositories {
-    mavenCentral()
-    maven(paperMavenPublicUrl) {
-        content { onlyForConfigurations(configurations.paperclip.name) }
-    }
-}
-
-dependencies {
-    remapper("net.fabricmc:tiny-remapper:0.8.6:fat")
-    decompiler("org.quiltmc:quiltflower:1.9.0")
-    paperclip("io.papermc:paperclip:3.0.3-SNAPSHOT")
-}
-
 subprojects {
-    apply(plugin = "java")
+    apply(plugin = "java-library")
     apply(plugin = "maven-publish")
 
-    java {
+    extensions.configure<JavaPluginExtension> {
         toolchain {
-            languageVersion.set(JavaLanguageVersion.of(17))
+            languageVersion = JavaLanguageVersion.of(21)
         }
     }
 
-    tasks.withType<JavaCompile> {
-        options.encoding = Charsets.UTF_8.name()
-        options.release.set(17)
-    }
-
-    tasks.withType<Javadoc> {
-        options.encoding = Charsets.UTF_8.name()
-    }
-
-    tasks.withType<ProcessResources> {
-        filteringCharset = Charsets.UTF_8.name()
-    }
-
     repositories {
         mavenCentral()
         maven(paperMavenPublicUrl)
-        maven("https://oss.sonatype.org/content/groups/public/")
-        maven("https://ci.emc.gs/nexus/content/groups/aikar/")
-        maven("https://repo.aikar.co/content/groups/aikar")
-        maven("https://repo.md-5.net/content/repositories/releases/")
-        maven("https://hub.spigotmc.org/nexus/content/groups/public/")
-        maven("https://jitpack.io")
-        maven("https://repo.codemc.io/repository/maven-public/")
     }
 
-}
+    dependencies {
+        "testRuntimeOnly"("org.junit.platform:junit-platform-launcher")
+    }
 
-tasks.generateDevelopmentBundle {
-    apiCoordinates.set("me.earthme.luminol:luminol-api")
-    mojangApiCoordinates.set("io.papermc.paper:paper-mojangapi")
-    libraryRepositories.set(
-        listOf(
-            "https://repo.maven.apache.org/maven2/",
-            paperMavenPublicUrl,
-        )
-    )
-}
+    tasks.withType<AbstractArchiveTask>().configureEach {
+        isPreserveFileTimestamps = false
+        isReproducibleFileOrder = true
+    }
+    tasks.withType<JavaCompile> {
+        options.encoding = Charsets.UTF_8.name()
+        options.release = 21
+        options.isFork = true
+    }
+    tasks.withType<Javadoc> {
+        options.encoding = Charsets.UTF_8.name()
+    }
+    tasks.withType<ProcessResources> {
+        filteringCharset = Charsets.UTF_8.name()
+    }
+    tasks.withType<Test> {
+        testLogging {
+            showStackTraces = true
+            exceptionFormat = TestExceptionFormat.FULL
+            events(TestLogEvent.STANDARD_OUT)
+        }
+    }
 
-paperweight {
-    serverProject.set(project(":luminol-server"))
-
-    remapRepo.set("https://maven.fabricmc.net/")
-    decompileRepo.set("https://maven.quiltmc.org/")
-
-    useStandardUpstream("folia") {
-        url.set(github("PaperMC", "Folia"))
-        ref.set(providers.gradleProperty("foliaCommit"))
-
-        withStandardPatcher {
-            apiSourceDirPath.set("Folia-API")
-            serverSourceDirPath.set("Folia-Server")
-
-
-            apiPatchDir.set(layout.projectDirectory.dir("patches/api"))
-            apiOutputDir.set(layout.projectDirectory.dir("Luminol-API"))
-
-            serverPatchDir.set(layout.projectDirectory.dir("patches/server"))
-            serverOutputDir.set(layout.projectDirectory.dir("Luminol-Server"))
+    extensions.configure<PublishingExtension> {
+        repositories {
+            /*
+            maven("https://repo.papermc.io/repository/maven-snapshots/") {
+                name = "paperSnapshots"
+                credentials(PasswordCredentials::class)
+            }
+             */
         }
     }
 }

docs/CONTRIBUTING.md

@@ -0,0 +1,67 @@
+为Luminol贡献代码
+===========
+
+[English](./CONTRIBUTING_EN.md) | **中文**
+
+我们很开心您想为我们的项目做出贡献！一般来说，我们对PR的审核是十分宽松的；
+但是如果您可以遵守下列的规则，我们可以更快地完成审核。
+
+## 使用个人账户进行 Fork
+
+我们会定期尝试合并已有的 PR，如果有一些小问题，会尝试帮您解决这些问题。
+
+但是如果您使用了组织账号进行 PR，我们就不能对您的 PR 进行修改了。因此我们只能关闭你的PR然后进行手动合并。
+
+所以，请不要使用组织账号进行 Fork！
+
+您可以看看 [这个 Issue](https://github.com/isaacs/github/issues/1681) 来了解一下我们为什么无法修改组织账号的 PR。
+
+## 开发环境
+
+在开始开发之前，您首先需要拥有以下软件作为开发环境：
+
+- `git`
+- `JDK 17 或更高版本`
+
+## 了解补丁（Patches）
+
+Luminol 使用和 Folia 一样的补丁系统，并为了针对不同部分的修改分成了两个目录：
+
+- `luminol-api` - 对 `Folia-API` / `Paper-API` / `Spigot-API` / `Bukkit` 进行的修改。
+
+补丁系统是基于 git 的，你可以在这里了解 git 的基本内容: <https://git-scm.com/docs/gittutorial>
+
+如果你已经 Fork 了主储存库，那么下面你应该这么做：
+
+1. 将你的仓库 clone 到本地；
+2. 在你的 IDE 或 终端 内执行 Gradle 的 `applyPatches` 任务，如果是在终端内，你可以执行 `./gradlew applyPatches`；
+3. 进入 `luminol-api` 文件夹进行修改。
+
+顺便一提，`luminol-api` 并不是正常的 git 仓库：
+
+- 在应用补丁前，基点将会指向未被更改的源码
+- 在基点后的每一个提交都是一个补丁
+- 只有在 Folia 最后一个提交后的提交才会被视为 luminol 补丁
+
+## 增加补丁
+
+按照以下步骤增加一个补丁是非常简单的：
+
+1. 对 `luminol-api` 进行修改；
+2. 使用 git 添加你的修改，比如 `git add .`；
+3. 使用 `git commit -m <提交信息>` 进行提交；
+4. 运行 Gradle 任务 `rebuildPatches` 将你的提交转化为一个补丁；
+5. 将你生成的补丁文件进行推送。
+
+这样做以后，你就可以将你的补丁文件进行 PR 提交。
+
+## 修改补丁
+
+你可以使用以下方法来修改一个补丁的内容：
+
+1. 在 HEAD 上直接进行修改；
+2. 使用 `git commit -a --fixup <hash>` 来进行一个更正提交；
+   - 如果你想要更改提交信息，你也可以用 `--squash` 来代替 `--fixup`。
+3. 使用 `git rebase -i --autosquash base` 来进行自动变基，你只需要输入 `:q` 来关闭确认页面即可；
+4. 运行 Gradle 任务 `rebuildPatches` 来修改已被修改的补丁；
+5. 将修改后的补丁 PR 发回储存库。

docs/CONTRIBUTING_EN.md

@@ -0,0 +1,70 @@
+Contributing to Luminol
+===========
+
+**English** | [中文](./CONTRIBUTING.md)
+
+We're glad that you want to contribute to our project!  
+In general, our review of pull requests is very lenient.  
+And if you can follow the rules below, we can complete the review faster.
+
+## Please fork using your personal account
+
+We regularly merge existing PRs.  
+If there're some small problems, we'll help you solve them by editing your PR.
+
+But, if your PR is from a organization, we can NOT edit your PR, so we must merge your PR manually.
+
+So, don't use orgnization accounts for fork!
+
+See also [This issue](https://github.com/isaacs/github/issues/1681), and then you'll know why we can't edit PRs from organizations.
+
+## Development Environment
+
+Before coding, you need these softwares / tools as Dev Environment.
+
+- `git`
+- `JDK 17 or higher`
+
+## Understanding "Patches"
+
+Luminol uses as the same patching system as Paper,  
+and has been divided into two directories for the purpose of modifying different parts of it:
+
+- `luminol-api` - Modifications to `Folia-API` / `Paper-API` / `Spigot-API` / `Bukkit`.
+
+The patching system is based on git, and you can learn about it at here: <https://git-scm.com/docs/gittutorial>
+
+If you have forked the main repository, then you should follow the steps below:
+
+1. Clone your repository to local
+2. Run Gradle's `applyPatches` task in your IDE or terminal (You can run `./gradlew applyPatches` directly in terminal.)
+3. Enter `luminol-api` directory to carry out modifications.
+
+BTW, `luminol-api` and are not normal git repositories.
+
+- Before applying patches, the base will point to unmodified source code.
+- Every commit after the base is a patch.
+- Only commits after the last commit of Paper will be considered Luminol' patches.
+
+## Adding new patches
+
+It's very easy to to add patches by following the steps below:
+
+1. Modify the code of `luminol-api`
+2. Add these changes to the local git repository (For example, `git add .`)
+3. Commit these changes using `git commit -m <Commit Message>`
+4. Run Gradle's task `rebuildPatches` to convert your commits to a new patch
+5. Push your patches to your repository
+
+After pushing, you can open a PR to submit your patches.
+
+## Modifying patches
+
+You can modify a existing patch by following the steps below:
+
+1. Modify code at HEAD
+2. Run `git commit -a --fixup <hash>` in your terminal to make a fix-up commit
+    - If you want to edit the commit message, replace `--fixup` with `--squash`.
+3. Run `git rebase -i --autosquash base` to rebase automatically, then just type `:q` to close the confirm page
+4. Run Gradle's task `rebuildPatches` to modify existing patches
+5. Push and PR again

gradle.properties

@@ -1,9 +1,10 @@
 group = me.earthme.luminol
-version = 1.20.2-R0.1-SNAPSHOT
+version=1.21.4-R0.1-SNAPSHOT
+mcVersion=1.21.4
 
-foliaCommit = 1e5e2154c9f88d788cecf0b9fcc77ece7d1f8663
+foliaRef=b05f1ef01d0887aac3616f4311ef93fe27f04c92
 
-org.gradle.caching = true
-org.gradle.parallel = true
-org.gradle.vfs.watch = false
-org.gradle.jvmargs = -Xmx3G
+org.gradle.configuration-cache=true
+org.gradle.caching=true
+org.gradle.parallel=true
+org.gradle.vfs.watch=false

gradle/wrapper/gradle-wrapper.properties

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

gradlew

@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
 #
@@ -55,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -83,10 +85,8 @@ done
 # This is normally unused
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -133,10 +133,13 @@ location of your Java installation."
     fi
 else
     JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
@@ -144,7 +147,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     case $MAX_FD in #(
       max*)
         # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045 
+        # shellcheck disable=SC2039,SC3045
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
@@ -152,7 +155,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
       '' | soft) :;; #(
       *)
         # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045 
+        # shellcheck disable=SC2039,SC3045
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
@@ -197,11 +200,15 @@ if "$cygwin" || "$msys" ; then
     done
 fi
 
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \

gradlew.bat

@@ -13,6 +13,8 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
 @if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
@@ -43,11 +45,11 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute
 
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -57,11 +59,11 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 

luminol-api/build.gradle.kts.patch

@@ -0,0 +1,43 @@
+--- a/folia-api/build.gradle.kts
++++ b/folia-api/build.gradle.kts
+@@ -54,6 +_,7 @@
+     api("org.apache.logging.log4j:log4j-api:$log4jVersion")
+     api("org.slf4j:slf4j-api:$slf4jVersion")
+     api("com.mojang:brigadier:1.3.10")
++    api("io.sentry:sentry:8.0.0-rc.2") // Pufferfish
+ 
+     // Deprecate bungeecord-chat in favor of adventure
+     api("net.md-5:bungeecord-chat:$bungeeCordChatVersion-deprecated+build.19") {
+@@ -104,17 +_,21 @@
+         java {
+             srcDir(generatedApiPath)
+             srcDir(file("../paper-api/src/main/java"))
++            srcDir(file("../folia-api/src/main/java"))
+         }
+         resources {
+             srcDir(file("../paper-api/src/main/resources"))
++            srcDir(file("../folia-api/src/main/resources"))
+         }
+     }
+     test {
+         java {
+             srcDir(file("../paper-api/src/test/java"))
++            srcDir(file("../folia-api/src/test/java"))
+         }
+         resources {
+             srcDir(file("../paper-api/src/test/resources"))
++            srcDir(file("../folia-api/src/test/resources"))
+         }
+     }
+ }
+@@ -258,3 +_,10 @@
+ tasks.check {
+     dependsOn(scanJarForOldGeneratedCode)
+ }
++
++// Pufferfish Start
++tasks.withType<JavaCompile> {
++    val compilerArgs = options.compilerArgs
++    compilerArgs.add("--add-modules=jdk.incubator.vector")
++}
++// Pufferfish End

luminol-api/paper-patches/features/0001-Rebrand-to-Luminol.patch

@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:18:38 +0800
+Subject: [PATCH] Rebrand to Luminol
+
+
+diff --git a/src/main/java/io/papermc/paper/ServerBuildInfo.java b/src/main/java/io/papermc/paper/ServerBuildInfo.java
+index 652ff54e7c50412503725d628bfe72ed03059790..ee163b9fa8f441aa4b3e2309f33e8f932dfc02d7 100644
+--- a/src/main/java/io/papermc/paper/ServerBuildInfo.java
++++ b/src/main/java/io/papermc/paper/ServerBuildInfo.java
+@@ -19,6 +19,13 @@ public interface ServerBuildInfo {
+      */
+     Key BRAND_PAPER_ID = Key.key("papermc", "paper");
+ 
++    // Luminol start
++    /**
++     * The brand id for Luminol.
++     */
++    Key BRAND_LUMINOL_ID = Key.key("luminolmc", "luminol");
++    // Luminol end
++
+     /**
+      * Gets the {@code ServerBuildInfo}.
+      *

luminol-api/paper-patches/features/0002-KioCG-Chunk-API.patch

@@ -0,0 +1,28 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Wed, 29 Jan 2025 09:50:53 +0800
+Subject: [PATCH] KioCG Chunk API
+
+
+diff --git a/src/main/java/org/bukkit/Chunk.java b/src/main/java/org/bukkit/Chunk.java
+index d434277342b2db19f98e032d3a316b27d728b840..e188353ad193f6203533790ae52fafc0554df63f 100644
+--- a/src/main/java/org/bukkit/Chunk.java
++++ b/src/main/java/org/bukkit/Chunk.java
+@@ -388,4 +388,6 @@ public interface Chunk extends PersistentDataHolder {
+          */
+         UNLOADED;
+     }
++
++    long getChunkHotAvg(); // KioCG
+ }
+diff --git a/src/main/java/org/bukkit/entity/Player.java b/src/main/java/org/bukkit/entity/Player.java
+index dd043851687283f48af899d069d732425c794afd..ac5b7d030cbe3aae908fb2a0130cdf04d4924c18 100644
+--- a/src/main/java/org/bukkit/entity/Player.java
++++ b/src/main/java/org/bukkit/entity/Player.java
+@@ -3928,4 +3928,6 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
+      * @return the result of this method, holding leftovers and spawned items.
+      */
+     @NotNull PlayerGiveResult give(@NotNull Collection<@NotNull ItemStack> items, boolean dropIfFull);
++
++    long getNearbyChunkHot(); // KioCG
+ }

luminol-api/paper-patches/features/0003-Disable-timings-warn-msg-and-commands.patch

@@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 12:22:53 +0800
+Subject: [PATCH] Disable timings warn msg and commands
+
+
+diff --git a/src/main/java/co/aikar/timings/Timings.java b/src/main/java/co/aikar/timings/Timings.java
+index 89017af09ce32e7a66014fc3aeb50155921252a5..b862779b48176dd7e67a2f1a3e7f24bc8c84e993 100644
+--- a/src/main/java/co/aikar/timings/Timings.java
++++ b/src/main/java/co/aikar/timings/Timings.java
+@@ -147,7 +147,7 @@ public final class Timings {
+     public static void setTimingsEnabled(boolean enabled) {
+         enabled = false; // Folia - region threading - disable timings
+         if (enabled && !warnedAboutDeprecationOnEnable) {
+-            Bukkit.getLogger().severe(PlainTextComponentSerializer.plainText().serialize(deprecationMessage()));
++            // Bukkit.getLogger().severe(PlainTextComponentSerializer.plainText().serialize(deprecationMessage()));  // Luminol - Disable timings warn msg and commands
+             warnedAboutDeprecationOnEnable = true;
+         }
+     }
+diff --git a/src/main/java/org/bukkit/command/SimpleCommandMap.java b/src/main/java/org/bukkit/command/SimpleCommandMap.java
+index 5df19bd701c67506689fc7f49d91f99ebfbc83f0..baf0cbd2f995ebe2e4382244eff6e15ec125d790 100644
+--- a/src/main/java/org/bukkit/command/SimpleCommandMap.java
++++ b/src/main/java/org/bukkit/command/SimpleCommandMap.java
+@@ -39,7 +39,7 @@ public class SimpleCommandMap implements CommandMap {
+         register("bukkit", new VersionCommand("version"));
+         register("bukkit", new ReloadCommand("reload"));
+         //register("bukkit", new PluginsCommand("plugins")); // Paper
+-        register("bukkit", new co.aikar.timings.TimingsCommand("timings")); // Paper
++        //register("bukkit", new co.aikar.timings.TimingsCommand("timings")); // Paper // Luminol - Disable timings warn msg and commands
+     }
+ 
+     public void setFallbackCommands() {
+diff --git a/src/main/java/org/bukkit/plugin/SimplePluginManager.java b/src/main/java/org/bukkit/plugin/SimplePluginManager.java
+index 468f5646da7bc413a6e91e82379e6554cc8b459d..ab36e3aaff57e2f27b5aed06b4bdfe277f86a35e 100644
+--- a/src/main/java/org/bukkit/plugin/SimplePluginManager.java
++++ b/src/main/java/org/bukkit/plugin/SimplePluginManager.java
+@@ -966,7 +966,7 @@ public final class SimplePluginManager implements PluginManager {
+      */
+     @Deprecated(forRemoval = true)
+     public void useTimings(boolean use) {
+-        co.aikar.timings.Timings.setTimingsEnabled(use); // Paper
++        // co.aikar.timings.Timings.setTimingsEnabled(use); // Paper // Luminol - Disable timings warn msg and commands
+     }
+ 
+     // Paper start

luminol-api/paper-patches/features/0004-Force-disable-reload-command.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Thu, 23 Jan 2025 12:04:04 +0800
+Subject: [PATCH] Force disable reload command
+
+
+diff --git a/src/main/java/org/bukkit/command/SimpleCommandMap.java b/src/main/java/org/bukkit/command/SimpleCommandMap.java
+index baf0cbd2f995ebe2e4382244eff6e15ec125d790..0d354eb5e7df427faff2d6c816c297c3d39a6e63 100644
+--- a/src/main/java/org/bukkit/command/SimpleCommandMap.java
++++ b/src/main/java/org/bukkit/command/SimpleCommandMap.java
+@@ -37,7 +37,7 @@ public class SimpleCommandMap implements CommandMap {
+ 
+     private void setDefaultCommands() {
+         register("bukkit", new VersionCommand("version"));
+-        register("bukkit", new ReloadCommand("reload"));
++        //register("bukkit", new ReloadCommand("reload")); // Luminol - Force disable reload command
+         //register("bukkit", new PluginsCommand("plugins")); // Paper
+         //register("bukkit", new co.aikar.timings.TimingsCommand("timings")); // Paper // Luminol - Disable timings warn msg and commands
+     }

luminol-api/paper-patches/features/0005-Pufferfish-Sentry.patch

@@ -0,0 +1,231 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 13:27:38 +0800
+Subject: [PATCH] Pufferfish Sentry
+
+
+diff --git a/src/main/java/gg/pufferfish/pufferfish/sentry/SentryContext.java b/src/main/java/gg/pufferfish/pufferfish/sentry/SentryContext.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..c7772aac00f6db664f7a5673bc2585fa025e6aad
+--- /dev/null
++++ b/src/main/java/gg/pufferfish/pufferfish/sentry/SentryContext.java
+@@ -0,0 +1,165 @@
++package gg.pufferfish.pufferfish.sentry;
++
++import com.google.gson.Gson;
++
++import java.lang.reflect.Field;
++import java.lang.reflect.Modifier;
++import java.util.Map;
++import java.util.TreeMap;
++
++import org.apache.logging.log4j.ThreadContext;
++import org.bukkit.command.Command;
++import org.bukkit.command.CommandSender;
++import org.bukkit.entity.Player;
++import org.bukkit.event.Event;
++import org.bukkit.event.player.PlayerEvent;
++import org.bukkit.plugin.Plugin;
++import org.bukkit.plugin.RegisteredListener;
++import org.jetbrains.annotations.Nullable;
++
++public class SentryContext {
++
++    private static final Gson GSON = new Gson();
++
++    public static void setPluginContext(@Nullable Plugin plugin) {
++        if (plugin != null) {
++            ThreadContext.put("pufferfishsentry_pluginname", plugin.getName());
++            ThreadContext.put("pufferfishsentry_pluginversion", plugin.getPluginMeta().getVersion());
++        }
++    }
++
++    public static void removePluginContext() {
++        ThreadContext.remove("pufferfishsentry_pluginname");
++        ThreadContext.remove("pufferfishsentry_pluginversion");
++    }
++
++    public static void setSenderContext(@Nullable CommandSender sender) {
++        if (sender != null) {
++            ThreadContext.put("pufferfishsentry_playername", sender.getName());
++            if (sender instanceof Player player) {
++                ThreadContext.put("pufferfishsentry_playerid", player.getUniqueId().toString());
++            }
++        }
++    }
++
++    public static void removeSenderContext() {
++        ThreadContext.remove("pufferfishsentry_playername");
++        ThreadContext.remove("pufferfishsentry_playerid");
++    }
++
++    public static void setEventContext(Event event, RegisteredListener registration) {
++        setPluginContext(registration.getPlugin());
++
++        try {
++            // Find the player that was involved with this event
++            Player player = null;
++            if (event instanceof PlayerEvent) {
++                player = ((PlayerEvent) event).getPlayer();
++            } else {
++                Class<? extends Event> eventClass = event.getClass();
++
++                Field playerField = null;
++
++                for (Field field : eventClass.getDeclaredFields()) {
++                    if (field.getType().equals(Player.class)) {
++                        playerField = field;
++                        break;
++                    }
++                }
++
++                if (playerField != null) {
++                    playerField.setAccessible(true);
++                    player = (Player) playerField.get(event);
++                }
++            }
++
++            if (player != null) {
++                setSenderContext(player);
++            }
++        } catch (Exception ignored) {
++        } // We can't really safely log exceptions.
++
++        ThreadContext.put("pufferfishsentry_eventdata", GSON.toJson(serializeFields(event)));
++    }
++
++    public static void removeEventContext() {
++        removePluginContext();
++        removeSenderContext();
++        ThreadContext.remove("pufferfishsentry_eventdata");
++    }
++
++    private static Map<String, String> serializeFields(Object object) {
++        Map<String, String> fields = new TreeMap<>();
++        fields.put("_class", object.getClass().getName());
++        for (Field declaredField : object.getClass().getDeclaredFields()) {
++            try {
++                if (Modifier.isStatic(declaredField.getModifiers())) {
++                    continue;
++                }
++
++                String fieldName = declaredField.getName();
++                if (fieldName.equals("handlers")) {
++                    continue;
++                }
++                declaredField.setAccessible(true);
++                Object value = declaredField.get(object);
++                if (value != null) {
++                    fields.put(fieldName, value.toString());
++                } else {
++                    fields.put(fieldName, "<null>");
++                }
++            } catch (Exception ignored) {
++            } // We can't really safely log exceptions.
++        }
++        return fields;
++    }
++
++    public static class State {
++
++        private Plugin plugin;
++        private Command command;
++        private String commandLine;
++        private Event event;
++        private RegisteredListener registeredListener;
++
++        public Plugin getPlugin() {
++            return plugin;
++        }
++
++        public void setPlugin(Plugin plugin) {
++            this.plugin = plugin;
++        }
++
++        public Command getCommand() {
++            return command;
++        }
++
++        public void setCommand(Command command) {
++            this.command = command;
++        }
++
++        public String getCommandLine() {
++            return commandLine;
++        }
++
++        public void setCommandLine(String commandLine) {
++            this.commandLine = commandLine;
++        }
++
++        public Event getEvent() {
++            return event;
++        }
++
++        public void setEvent(Event event) {
++            this.event = event;
++        }
++
++        public RegisteredListener getRegisteredListener() {
++            return registeredListener;
++        }
++
++        public void setRegisteredListener(RegisteredListener registeredListener) {
++            this.registeredListener = registeredListener;
++        }
++    }
++}
+diff --git a/src/main/java/org/bukkit/plugin/SimplePluginManager.java b/src/main/java/org/bukkit/plugin/SimplePluginManager.java
+index ab36e3aaff57e2f27b5aed06b4bdfe277f86a35e..96da9f1082ab134d197b3a6069f2fcdf38585efe 100644
+--- a/src/main/java/org/bukkit/plugin/SimplePluginManager.java
++++ b/src/main/java/org/bukkit/plugin/SimplePluginManager.java
+@@ -597,7 +597,9 @@ public final class SimplePluginManager implements PluginManager {
+ 
+     // Paper start
+     private void handlePluginException(String msg, Throwable ex, Plugin plugin) {
++        gg.pufferfish.pufferfish.sentry.SentryContext.setPluginContext(plugin); // Pufferfish
+         server.getLogger().log(Level.SEVERE, msg, ex);
++        gg.pufferfish.pufferfish.sentry.SentryContext.removePluginContext(); // Pufferfish
+         callEvent(new com.destroystokyo.paper.event.server.ServerExceptionEvent(new com.destroystokyo.paper.exception.ServerPluginEnableDisableException(msg, ex, plugin)));
+     }
+     // Paper end
+@@ -667,9 +669,11 @@ public final class SimplePluginManager implements PluginManager {
+                             ));
+                 }
+             } catch (Throwable ex) {
++                gg.pufferfish.pufferfish.sentry.SentryContext.setEventContext(event, registration); // Pufferfish
+                 // Paper start - error reporting
+                 String msg = "Could not pass event " + event.getEventName() + " to " + registration.getPlugin().getDescription().getFullName();
+                 server.getLogger().log(Level.SEVERE, msg, ex);
++                gg.pufferfish.pufferfish.sentry.SentryContext.removeEventContext(); // Pufferfish
+                 if (!(event instanceof com.destroystokyo.paper.event.server.ServerExceptionEvent)) { // We don't want to cause an endless event loop
+                     callEvent(new com.destroystokyo.paper.event.server.ServerExceptionEvent(new com.destroystokyo.paper.exception.ServerEventException(msg, ex, registration.getPlugin(), registration.getListener(), event)));
+                 }
+diff --git a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
+index b412aaf08901d169ac9fc89b36f9d6ccb95c53d3..45a9ca8969f635d20cc44c062fda85bbccd8f8ff 100644
+--- a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
++++ b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
+@@ -336,7 +336,13 @@ public final class JavaPluginLoader implements PluginLoader {
+             try {
+                 jPlugin.setEnabled(true);
+             } catch (Throwable ex) {
++                gg.pufferfish.pufferfish.sentry.SentryContext.setPluginContext(plugin); // Pufferfish
+                 server.getLogger().log(Level.SEVERE, "Error occurred while enabling " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex);
++                gg.pufferfish.pufferfish.sentry.SentryContext.removePluginContext(); // Pufferfish
++                // Paper start - Disable plugins that fail to load
++                this.server.getPluginManager().disablePlugin(jPlugin);
++                return;
++                // Paper end
+             }
+ 
+             // Perhaps abort here, rather than continue going, but as it stands,
+@@ -361,7 +367,9 @@ public final class JavaPluginLoader implements PluginLoader {
+             try {
+                 jPlugin.setEnabled(false);
+             } catch (Throwable ex) {
++                gg.pufferfish.pufferfish.sentry.SentryContext.setPluginContext(plugin); // Pufferfish
+                 server.getLogger().log(Level.SEVERE, "Error occurred while disabling " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex);
++                gg.pufferfish.pufferfish.sentry.SentryContext.removePluginContext(); // Pufferfish
+             }
+ 
+             if (cloader instanceof PluginClassLoader) {

luminol-api/paper-patches/features/0006-Pufferfish-SIMD-Utilities.patch

@@ -0,0 +1,92 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 14:00:28 +0800
+Subject: [PATCH] Pufferfish SIMD Utilities
+
+
+diff --git a/src/main/java/gg/pufferfish/pufferfish/simd/SIMDChecker.java b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDChecker.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..f00c008c03e2533f568085838cf13cb9b5b32cd9
+--- /dev/null
++++ b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDChecker.java
+@@ -0,0 +1,39 @@
++package gg.pufferfish.pufferfish.simd;
++
++import jdk.incubator.vector.FloatVector;
++import jdk.incubator.vector.IntVector;
++import jdk.incubator.vector.VectorSpecies;
++import org.slf4j.Logger;
++
++/**
++ * Basically, java is annoying and we have to push this out to its own class.
++ */
++@Deprecated
++public class SIMDChecker {
++	
++	@Deprecated
++	public static boolean canEnable(Logger logger) {
++		try {
++			if (SIMDDetection.getJavaVersion() < 17 || SIMDDetection.getJavaVersion() > 21) {
++				return false;
++			} else {
++				SIMDDetection.testRun = true;
++				
++				VectorSpecies<Integer> ISPEC = IntVector.SPECIES_PREFERRED;
++				VectorSpecies<Float> FSPEC = FloatVector.SPECIES_PREFERRED;
++
++                logger.info("Max SIMD vector size on this system is {} bits (int)", ISPEC.vectorBitSize());
++				logger.info("Max SIMD vector size on this system is " + FSPEC.vectorBitSize() + " bits (float)");
++				
++				if (ISPEC.elementSize() < 2 || FSPEC.elementSize() < 2) {
++					logger.warn("SIMD is not properly supported on this system!");
++					return false;
++				}
++
++				return true;
++			}
++		} catch (NoClassDefFoundError | Exception ignored) {} // Basically, we don't do anything. This lets us detect if it's not functional and disable it.
++		return false;
++	}
++	
++}
+diff --git a/src/main/java/gg/pufferfish/pufferfish/simd/SIMDDetection.java b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDDetection.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..cd953435a6179eaae7c9cc250a791cae26c5567b
+--- /dev/null
++++ b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDDetection.java
+@@ -0,0 +1,35 @@
++package gg.pufferfish.pufferfish.simd;
++
++import org.slf4j.Logger;
++
++@Deprecated
++public class SIMDDetection {
++	
++	public static boolean isEnabled = false;
++	public static boolean versionLimited = false;
++	public static boolean testRun = false;
++	
++	@Deprecated
++	public static boolean canEnable(Logger logger) {
++		try {
++			return SIMDChecker.canEnable(logger);
++		} catch (NoClassDefFoundError | Exception ignored) {
++			return false;
++		}
++	}
++	
++	@Deprecated
++	public static int getJavaVersion() {
++		// https://stackoverflow.com/a/2591122
++		String version = System.getProperty("java.version");
++		if(version.startsWith("1.")) {
++			version = version.substring(2, 3);
++		} else {
++			int dot = version.indexOf(".");
++			if(dot != -1) { version = version.substring(0, dot); }
++		}
++		version = version.split("-")[0]; // Azul is stupid
++		return Integer.parseInt(version);
++	}
++	
++}

luminol-api/paper-patches/features/0008-Tick-regions-api.patch

@@ -0,0 +1,200 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Mon, 27 Jan 2025 13:01:59 +0800
+Subject: [PATCH] Tick regions api
+
+
+diff --git a/src/main/java/me/earthme/luminol/api/RegionStats.java b/src/main/java/me/earthme/luminol/api/RegionStats.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..96147cace1550d14c682258dab0397587dcf76a4
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/RegionStats.java
+@@ -0,0 +1,25 @@
++package me.earthme.luminol.api;
++
++/**
++ * A simple package of folia's tick region state.It linked to the RegionStats of the nms part so that</br>
++ * You could call these methods to get the status of this tick region</br>
++ */
++public interface RegionStats {
++    /**
++     * Get the entity count in this tick region
++     * @return the entity count
++     */
++    int getEntityCount();
++
++    /**
++     * Get the player count in this tick region
++     * @return the player count
++     */
++    int getPlayerCount();
++
++    /**
++     * Get the chunk count in this tick region
++     * @return the chunk count
++     */
++    int getChunkCount();
++}
+diff --git a/src/main/java/me/earthme/luminol/api/ThreadedRegion.java b/src/main/java/me/earthme/luminol/api/ThreadedRegion.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..38972ac3d05ccbbb134f751a8d018b9c53ad10b5
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/ThreadedRegion.java
+@@ -0,0 +1,50 @@
++package me.earthme.luminol.api;
++
++import org.bukkit.Location;
++import org.bukkit.World;
++
++import javax.annotation.Nullable;
++
++/**
++ * A mirror of folia's ThreadedRegion</br>
++ * Including some handy methods to get the information of the tick region</br>
++ * Note: You should call these methods inside this tick region's thread context
++ */
++public interface ThreadedRegion {
++    /**
++     * Get the center chunk pos of this tick region</br>
++     * Note:</br>
++     *      1.Global region will return a null value(But we don't finish the global region yet()</br>
++     *      2.You should call these methods inside this tick region's thread context
++     * @return The center chunk pos
++     */
++    @Nullable
++    Location getCenterChunkPos();
++
++    /**
++     * Get the dead section percent of this tick region
++     * Note: </br>
++     *      1.Dead percent is mean the percent of the unloaded chunk count of this tick region, which is also used for determine
++     * that the tick region should or not check for splitting</br>
++     *      2.You should call these methods inside this tick region's thread context
++     * @return The dead section percent
++     */
++    double getDeadSectionPercent();
++
++    /**
++     * Get the tick region data of this tick region</br>
++     * Note:</br>
++     *       1.You should call this method inside this tick region's thread context</br>
++     *       2.You should call these methods inside this tick region's thread context
++     * @return The tick region data
++     */
++    TickRegionData getTickRegionData();
++
++    /**
++     * Get the world of this tick region</br>
++     * Note: Global region will return a null value too
++     * @return The world of this tick region
++     */
++    @Nullable
++    World getWorld();
++}
+diff --git a/src/main/java/me/earthme/luminol/api/ThreadedRegionizer.java b/src/main/java/me/earthme/luminol/api/ThreadedRegionizer.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..ff31a68a019fd9e5e687e6818f8729f4950bc060
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/ThreadedRegionizer.java
+@@ -0,0 +1,56 @@
++package me.earthme.luminol.api;
++
++import org.bukkit.Location;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++import java.util.Collection;
++
++/**
++ * A mirror of folia's ThreadedRegionizer
++ */
++public interface ThreadedRegionizer {
++    /**
++     * Get all the tick regions
++     * @return Temporary copied collection of all tick regions
++     */
++    Collection<ThreadedRegion> getAllRegions();
++
++    /**
++     * Get the tick region at the given chunk coordinates
++     * @param chunkX Chunk X
++     * @param chunkZ Chunk Z
++     * @return The tick region at the given chunk coordinates
++     */
++    @Nullable
++    ThreadedRegion getAtSynchronized(int chunkX, int chunkZ);
++
++    /**
++     * Get the tick region at the given chunk coordinates
++     * @param chunkX Chunk X
++     * @param chunkZ Chunk Z
++     * @return The tick region at the given chunk coordinates
++     */
++    @Nullable
++    ThreadedRegion getAtUnSynchronized(int chunkX, int chunkZ);
++
++    /**
++     * Get the tick region at the given location
++     * @param pos The location
++     * @return The tick region at the given location
++     */
++    @Nullable
++    default ThreadedRegion getAtSynchronized(@NotNull Location pos) {
++        return this.getAtSynchronized(pos.getBlockX() >> 4, pos.getBlockZ() >> 4);
++    }
++
++    /**
++     * Get the tick region at the given location
++     * @param pos The location
++     * @return The tick region at the given location
++     */
++    @Nullable
++    default ThreadedRegion getAtUnSynchronized(@NotNull Location pos) {
++        return this.getAtUnSynchronized(pos.getBlockX() >> 4, pos.getBlockZ() >> 4);
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/TickRegionData.java b/src/main/java/me/earthme/luminol/api/TickRegionData.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..ecde4462b08d701b8bff9f26902f17754cf791dd
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/TickRegionData.java
+@@ -0,0 +1,26 @@
++package me.earthme.luminol.api;
++
++import org.bukkit.World;
++
++/**
++ * A mirror of folia's tick region data
++ */
++public interface TickRegionData {
++    /**
++     * Get the world it's currently holding
++     * @return the world
++     */
++    World getWorld();
++
++    /**
++     * Get the current tick count
++     * @return the current tick count
++     */
++    long getCurrentTickCount();
++
++    /**
++     * Get the region stats
++     * @return the region stats
++     */
++    RegionStats getRegionStats();
++}
+diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
+index 8784842d14bbbe7dbde181e86782a0955be66924..f998f6f0d3017767aa4dde45a7e8aea5dd36fe99 100644
+--- a/src/main/java/org/bukkit/World.java
++++ b/src/main/java/org/bukkit/World.java
+@@ -4407,4 +4407,8 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
+             }
+         }
+     }
++
++    // Luminol start - Tick regions api
++    me.earthme.luminol.api.ThreadedRegionizer getThreadedRegionizer();
++    // Luminol end - Tick regions api
+ }

luminol-server/build.gradle.kts.patch

@@ -0,0 +1,113 @@
+--- a/folia-server/build.gradle.kts
++++ b/folia-server/build.gradle.kts
+@@ -20,8 +_,9 @@
+     minecraftVersion = providers.gradleProperty("mcVersion")
+     // macheOldPath = file("F:\\Projects\\PaperTooling\\mache\\versions\\1.21.4\\src\\main\\java")
+     // gitFilePatches = true
+-    
++
+     val fork = forks.register("folia") {
++        rootDirectory = upstreamsDirectory().map { it.dir("folia") }
+         upstream.patchDir("paperServer") {
+             upstreamPath = "paper-server"
+             excludes = setOf("src/minecraft", "patches", "build.gradle.kts")
+@@ -30,7 +_,23 @@
+         }
+     }
+ 
+-    activeFork = fork
++    val luminol = forks.register("luminol") {
++        forks = fork
++        upstream.patchRepo("paperServer") {
++            upstreamRepo = fork.patchedRepo("paperServer")
++            patchesDir = rootDirectory.dir("luminol-server/paper-patches")
++            outputDir = rootDirectory.dir("paper-server")
++        }
++
++        upstream.patchDir("foliaServer") {
++            upstreamPath = "folia-server"
++            excludes = setOf("src/minecraft", "paper-patches", "minecraft-patches", "build.gradle.kts", "build.gradle.kts.patch")
++            patchesDir = rootDirectory.dir("luminol-server/folia-patches")
++            outputDir = rootDirectory.dir("folia-server")
++        }
++    }
++
++    activeFork = luminol
+ 
+     spigot {
+         buildDataRef = "3edaf46ec1eed4115ce1b18d2846cded42577e42"
+@@ -116,10 +_,14 @@
+     main {
+         java { srcDir("../paper-server/src/main/java") }
+         resources { srcDir("../paper-server/src/main/resources") }
++        java { srcDir("../folia-server/src/main/java") }
++        resources { srcDir("../folia-server/src/main/resources") }
+     }
+     test {
+         java { srcDir("../paper-server/src/test/java") }
+         resources { srcDir("../paper-server/src/test/resources") }
++        java { srcDir("../folia-server/src/test/java") }
++        resources { srcDir("../folia-server/src/test/resources") }
+     }
+ }
+ 
+@@ -143,7 +_,14 @@
+ }
+ 
+ dependencies {
+-    implementation(project(":folia-api"))
++    implementation(project(":luminol-api")) // Luminol
++    implementation("com.electronwill.night-config:toml:3.6.6") // Luminol - Night config
++    // Abomination start
++    implementation("com.github.luben:zstd-jni:1.5.4-1")
++    implementation("org.lz4:lz4-java:1.8.0")
++    implementation("net.openhft:zero-allocation-hashing:0.16")
++    // Abomination end
++    implementation("io.github.classgraph:classgraph:4.8.158") // Kaiiju - Entity throttling & Removal
+     implementation("ca.spottedleaf:concurrentutil:0.0.3")
+     implementation("org.jline:jline-terminal-ffm:3.27.1") // use ffm on java 22+
+     implementation("org.jline:jline-terminal-jni:3.27.1") // fall back to jni on java 21
+@@ -200,6 +_,13 @@
+     implementation("me.lucko:spark-paper:1.10.119-SNAPSHOT")
+ }
+ 
++// Pufferfish Start
++tasks.withType<JavaCompile> {
++    val compilerArgs = options.compilerArgs
++    compilerArgs.add("--add-modules=jdk.incubator.vector")
++}
++// Pufferfish End
++
+ tasks.jar {
+     manifest {
+         val git = Git(rootProject.layout.projectDirectory.path)
+@@ -212,14 +_,14 @@
+         val gitBranch = git.exec(providers, "rev-parse", "--abbrev-ref", "HEAD").get().trim()
+         attributes(
+             "Main-Class" to "org.bukkit.craftbukkit.Main",
+-            "Implementation-Title" to "Folia",
++            "Implementation-Title" to "Luminol",
+             "Implementation-Version" to implementationVersion,
+             "Implementation-Vendor" to date,
+-            "Specification-Title" to "Folia",
++            "Specification-Title" to "Luminol",
+             "Specification-Version" to project.version,
+-            "Specification-Vendor" to "Paper Team",
+-            "Brand-Id" to "papermc:folia",
+-            "Brand-Name" to "Folia",
++            "Specification-Vendor" to "Luminol Team",
++            "Brand-Id" to "luminolmc:luminol",
++            "Brand-Name" to "Luminol",
+             "Build-Number" to (build ?: ""),
+             "Build-Time" to buildTime.toString(),
+             "Git-Branch" to gitBranch,
+@@ -350,3 +_,9 @@
+     classpath(tasks.createReobfPaperclipJar.flatMap { it.outputZip })
+     mainClass.set(null as String?)
+ }
++// Pufferfish Start
++tasks.withType<JavaCompile> {
++    val compilerArgs = options.compilerArgs
++    compilerArgs.add("--add-modules=jdk.incubator.vector")
++}
++// Pufferfish End

luminol-server/minecraft-patches/features/0001-Add-luminol-config-framework.patch

@@ -0,0 +1,31 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:15:52 +0800
+Subject: [PATCH] Add luminol config framework
+
+
+diff --git a/net/minecraft/server/Main.java b/net/minecraft/server/Main.java
+index 9aa664537cc37e44db46d5a2a64ae3116938c681..8d6a6534a134e99e5ee2652d7b0c858d538e69bd 100644
+--- a/net/minecraft/server/Main.java
++++ b/net/minecraft/server/Main.java
+@@ -108,6 +108,7 @@ public class Main {
+                 JvmProfiler.INSTANCE.start(Environment.SERVER);
+             }
+ 
++            me.earthme.luminol.config.LuminolConfig.preLoadConfig(); // Luminol - Luminol config
+             io.papermc.paper.plugin.PluginInitializerManager.load(optionSet); // Paper
+             Bootstrap.bootStrap();
+             Bootstrap.validate();
+diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
+index 341e400f789e0eda29827e2c45c483a470d2e982..8f348d140ab98e23ee0debe4bacac51fee49c35e 100644
+--- a/net/minecraft/server/dedicated/DedicatedServer.java
++++ b/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -212,6 +212,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
++        me.earthme.luminol.config.LuminolConfig.finalizeLoadConfig(); //Luminol - load config file
++        me.earthme.luminol.config.LuminolConfig.setupLatch(); //Luminol - load config file
+         this.server.spark.enableEarlyIfRequested(); // Paper - spark
+         // Paper start - fix converting txt to json file; convert old users earlier after PlayerList creation but before file load/save
+         if (this.convertOldUsers()) {

luminol-server/minecraft-patches/features/0002-Add-config-for-server-mod-name.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:17:52 +0800
+Subject: [PATCH] Add config for server mod name
+
+
+diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
+index faf72dd6dff74296c73cb058aaabd1f9f475a072..46375fa81b36b89b79c22f0a7ac6d610ab1183d4 100644
+--- a/net/minecraft/server/MinecraftServer.java
++++ b/net/minecraft/server/MinecraftServer.java
+@@ -1967,7 +1967,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
+     @DontObfuscate
+     public String getServerModName() {
+-        return io.papermc.paper.ServerBuildInfo.buildInfo().brandName(); // Paper
++        return me.earthme.luminol.config.modules.misc.ServerModNameConfig.fakeVanilla ? "vanilla" : me.earthme.luminol.config.modules.misc.ServerModNameConfig.serverModName; // Paper // Luminol - Add config for this
+     }
+ 
+     public SystemReport fillSystemReport(SystemReport systemReport) {

luminol-server/minecraft-patches/features/0003-Add-config-for-unsafe-teleportation.patch

@@ -0,0 +1,44 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:23:13 +0800
+Subject: [PATCH] Add config for unsafe teleportation
+
+
+diff --git a/net/minecraft/world/entity/item/FallingBlockEntity.java b/net/minecraft/world/entity/item/FallingBlockEntity.java
+index 1fa5e6a12b943e889bde566038a632a6adcf319e..c1f6a3b3a8fa990b8e9b052341ab31bde7c04e7a 100644
+--- a/net/minecraft/world/entity/item/FallingBlockEntity.java
++++ b/net/minecraft/world/entity/item/FallingBlockEntity.java
+@@ -65,7 +65,7 @@ public class FallingBlockEntity extends Entity {
+     public float fallDamagePerDistance;
+     @Nullable
+     public CompoundTag blockData;
+-    public boolean forceTickAfterTeleportToDuplicate;
++    public boolean forceTickAfterTeleportToDuplicate = me.earthme.luminol.config.modules.fixes.UnsafeTeleportationConfig.enabled; // Luminol - Unsafe teleportation
+     protected static final EntityDataAccessor<BlockPos> DATA_START_POS = SynchedEntityData.defineId(FallingBlockEntity.class, EntityDataSerializers.BLOCK_POS);
+     public boolean autoExpire = true; // Paper - Expand FallingBlock API
+ 
+@@ -401,7 +401,7 @@ public class FallingBlockEntity extends Entity {
+         ResourceKey<Level> resourceKey1 = this.level().dimension();
+         boolean flag = (resourceKey1 == Level.END || resourceKey == Level.END) && resourceKey1 != resourceKey;
+         Entity entity = super.teleport(teleportTransition);
+-        this.forceTickAfterTeleportToDuplicate = entity != null && flag && io.papermc.paper.configuration.GlobalConfiguration.get().unsupportedSettings.allowUnsafeEndPortalTeleportation; // Paper
++        this.forceTickAfterTeleportToDuplicate = entity != null && flag && (io.papermc.paper.configuration.GlobalConfiguration.get().unsupportedSettings.allowUnsafeEndPortalTeleportation || me.earthme.luminol.config.modules.fixes.UnsafeTeleportationConfig.enabled); // Paper // Luminol - Unsafe teleportation
+         return entity;
+     }
+ }
+diff --git a/net/minecraft/world/level/block/EndPortalBlock.java b/net/minecraft/world/level/block/EndPortalBlock.java
+index 177735cf744e564081e4c140a0f8210c3a07e037..7274f2d7df9228f34305a21abde6d114a495c1cb 100644
+--- a/net/minecraft/world/level/block/EndPortalBlock.java
++++ b/net/minecraft/world/level/block/EndPortalBlock.java
+@@ -67,6 +67,11 @@ public class EndPortalBlock extends BaseEntityBlock implements Portal {
+                 if (level.paperConfig().misc.disableEndCredits) {serverPlayer.seenCredits = true; return;} // Paper - Option to disable end credits
+                 serverPlayer.showEndCredits();
+             } else {
++                // Luminol start - unsafe teleportation
++                if (me.earthme.luminol.config.modules.fixes.UnsafeTeleportationConfig.enabled && !(entity instanceof net.minecraft.world.entity.player.Player)) {
++                    entity.endPortalLogicAsync(pos);
++                }
++                // Luminol end
+                 entity.setAsInsidePortal(this, pos);
+             }
+         }

luminol-server/minecraft-patches/features/0004-Add-config-for-vanilla-random.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:24:50 +0800
+Subject: [PATCH] Add config for vanilla random
+
+
+diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
+index 597520a680bc1a54055b99f93724682a4d940458..4cfc228a60a147409b8afc4cb138ce6437a9b667 100644
+--- a/net/minecraft/world/entity/Entity.java
++++ b/net/minecraft/world/entity/Entity.java
+@@ -255,7 +255,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     public double zOld;
+     public boolean noPhysics;
+     private boolean wasOnFire;
+-    public final RandomSource random = SHARED_RANDOM; // Paper - Share random for entities to make them more random
++    public final RandomSource random = me.earthme.luminol.config.modules.fixes.VanillaRandomSourceConfig.useLegacyRandomSourceForPlayers ? RandomSource.create() : SHARED_RANDOM; // Paper - Share random for entities to make them more random // Luminol - Add config for vanilla random SHARED_RANDOM
+     public int tickCount;
+     private int remainingFireTicks = -this.getFireImmuneTicks();
+     public boolean wasTouchingWater;

luminol-server/minecraft-patches/features/0005-Add-a-simple-tpsbar.patch

@@ -0,0 +1,31 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:27:31 +0800
+Subject: [PATCH] Add a simple tpsbar
+
+
+diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
+index 8f348d140ab98e23ee0debe4bacac51fee49c35e..852d598fc11a9640a20b093839707c3a5a96e057 100644
+--- a/net/minecraft/server/dedicated/DedicatedServer.java
++++ b/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -764,6 +764,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+ 
+     @Override
+     public void stopServer() {
++        me.earthme.luminol.functions.GlobalServerTpsBar.cancelBarUpdateTask(); //Luminol - Tpsbar
+         super.stopServer();
+         //Util.shutdownExecutors(); // Paper - Improved watchdog support; moved into super
+         SkullBlockEntity.clear();
+diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
+index ca3770e9f77e583dfa6cef8ca884eaf6a43f5ffa..465f20e5f24a8b37fb31393bcedd3807896666c7 100644
+--- a/net/minecraft/server/level/ServerPlayer.java
++++ b/net/minecraft/server/level/ServerPlayer.java
+@@ -393,7 +393,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+     public com.destroystokyo.paper.event.entity.PlayerNaturallySpawnCreaturesEvent playerNaturallySpawnedEvent; // Paper - PlayerNaturallySpawnCreaturesEvent
+     public @Nullable String clientBrandName = null; // Paper - Brand support
+     public org.bukkit.event.player.PlayerQuitEvent.QuitReason quitReason = null; // Paper - Add API for quit reason; there are a lot of changes to do if we change all methods leading to the event
+-
++    public volatile boolean isTpsBarVisible = false; //Luminol - Tps bar
+     // Paper start - rewrite chunk system
+     private ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.PlayerChunkLoaderData chunkLoader;
+     private final ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.ViewDistanceHolder viewDistanceHolder = new ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.ViewDistanceHolder();

luminol-server/minecraft-patches/features/0006-Add-a-simple-membar.patch

@@ -0,0 +1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:28:03 +0800
+Subject: [PATCH] Add a simple membar
+
+
+diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
+index 852d598fc11a9640a20b093839707c3a5a96e057..cc80198a5d5f4e9188ef35944d077200f03ac43b 100644
+--- a/net/minecraft/server/dedicated/DedicatedServer.java
++++ b/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -765,6 +765,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+     @Override
+     public void stopServer() {
+         me.earthme.luminol.functions.GlobalServerTpsBar.cancelBarUpdateTask(); //Luminol - Tpsbar
++        me.earthme.luminol.functions.GlobalServerMemoryBar.cancelBarUpdateTask(); //Luminol - Memory bar
+         super.stopServer();
+         //Util.shutdownExecutors(); // Paper - Improved watchdog support; moved into super
+         SkullBlockEntity.clear();
+diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
+index 465f20e5f24a8b37fb31393bcedd3807896666c7..b4a4eec6029f1aee5f3b0da6938a9b23db36d5f9 100644
+--- a/net/minecraft/server/level/ServerPlayer.java
++++ b/net/minecraft/server/level/ServerPlayer.java
+@@ -394,6 +394,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+     public @Nullable String clientBrandName = null; // Paper - Brand support
+     public org.bukkit.event.player.PlayerQuitEvent.QuitReason quitReason = null; // Paper - Add API for quit reason; there are a lot of changes to do if we change all methods leading to the event
+     public volatile boolean isTpsBarVisible = false; //Luminol - Tps bar
++    public volatile boolean isMemBarVisible = false; //Luminol - Memory bar
+     // Paper start - rewrite chunk system
+     private ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.PlayerChunkLoaderData chunkLoader;
+     private final ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.ViewDistanceHolder viewDistanceHolder = new ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.ViewDistanceHolder();

luminol-server/minecraft-patches/features/0007-Add-config-for-username-check.patch

@@ -0,0 +1,33 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:29:26 +0800
+Subject: [PATCH] Add config for username check
+
+
+diff --git a/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+index 159f2f169d26b436a70006f7bc9bdc481315dd32..2b366fea4d8d376b150786fdc00fd5e2413388f6 100644
+--- a/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
++++ b/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+@@ -176,7 +176,8 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
+     public void handleHello(ServerboundHelloPacket packet) {
+         Validate.validState(this.state == ServerLoginPacketListenerImpl.State.HELLO, "Unexpected hello packet");
+         // Paper start - Validate usernames
+-        if (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode()
++        if (me.earthme.luminol.config.modules.misc.UsernameCheckConfig.enabled // Luminol - Add config for username check
++            && io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode()
+             && io.papermc.paper.configuration.GlobalConfiguration.get().unsupportedSettings.performUsernameValidation
+             && !this.iKnowThisMayNotBeTheBestIdeaButPleaseDisableUsernameValidation) {
+             Validate.validState(StringUtil.isReasonablePlayerName(packet.name()), "Invalid characters in username");
+diff --git a/net/minecraft/server/players/GameProfileCache.java b/net/minecraft/server/players/GameProfileCache.java
+index 6fb3712f33a84a3612752dcfd9e97d67066f610e..26d37cf8fec2e8b0d3c3c1bbe4693d4c6ca4d4f9 100644
+--- a/net/minecraft/server/players/GameProfileCache.java
++++ b/net/minecraft/server/players/GameProfileCache.java
+@@ -77,7 +77,7 @@ public class GameProfileCache {
+     }
+ 
+     private static Optional<GameProfile> lookupGameProfile(GameProfileRepository profileRepo, String name) {
+-        if (!StringUtil.isValidPlayerName(name)) {
++        if (!StringUtil.isValidPlayerName(name) && false) { // Luminol - Add config for username check - Directly return, skip unnecessary following logic
+             return createUnknownProfile(name);
+         } else {
+             final AtomicReference<GameProfile> atomicReference = new AtomicReference<>();

luminol-server/minecraft-patches/features/0008-Add-config-for-offline-mode-warning.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:29:45 +0800
+Subject: [PATCH] Add config for offline mode warning
+
+
+diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
+index cc80198a5d5f4e9188ef35944d077200f03ac43b..82f80e152a8b7426d711df7df6eae9043cf35e69 100644
+--- a/net/minecraft/server/dedicated/DedicatedServer.java
++++ b/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -285,7 +285,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
+-        if (!this.usesAuthentication()) {
++        if (!this.usesAuthentication() && me.earthme.luminol.config.modules.misc.OfflineModeWarningConfig.enabled) { //Luminol - Add config for offline mod warning
+             LOGGER.warn("**** SERVER IS RUNNING IN OFFLINE/INSECURE MODE!");
+             LOGGER.warn("The server will make no attempt to authenticate usernames. Beware.");
+             // Spigot start

luminol-server/minecraft-patches/features/0009-Add-config-for-out-of-order-chat-checks.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:30:02 +0800
+Subject: [PATCH] Add config for out-of-order chat checks
+
+
+diff --git a/net/minecraft/network/chat/SignedMessageChain.java b/net/minecraft/network/chat/SignedMessageChain.java
+index f6eed34b2fd72ab74cc9dc4b99ca184d512c0a66..73ef2de5efa8fb48975f70998195df76f6161d16 100644
+--- a/net/minecraft/network/chat/SignedMessageChain.java
++++ b/net/minecraft/network/chat/SignedMessageChain.java
+@@ -45,7 +45,7 @@ public class SignedMessageChain {
+                     SignedMessageLink signedMessageLink = SignedMessageChain.this.nextLink;
+                     if (signedMessageLink == null) {
+                         throw new SignedMessageChain.DecodeException(SignedMessageChain.DecodeException.CHAIN_BROKEN);
+-                    } else if (body.timeStamp().isBefore(SignedMessageChain.this.lastTimeStamp)) {
++                    } else if (me.earthme.luminol.config.modules.misc.InorderChatConfig.enabled && body.timeStamp().isBefore(SignedMessageChain.this.lastTimeStamp)) { // Luminol - Add config for out-of-order chat checks
+                         this.setChainBroken();
+                         throw new SignedMessageChain.DecodeException(SignedMessageChain.DecodeException.OUT_OF_ORDER_CHAT, org.bukkit.event.player.PlayerKickEvent.Cause.OUT_OF_ORDER_CHAT); // Paper - kick event causes
+                     } else {

luminol-server/minecraft-patches/features/0010-Add-config-to-verify-signature-only-in-online-mode.patch

@@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:31:09 +0800
+Subject: [PATCH] Add config to verify signature only in online-mode
+
+
+diff --git a/net/minecraft/world/entity/player/ProfilePublicKey.java b/net/minecraft/world/entity/player/ProfilePublicKey.java
+index 41a9cc693183e96c83837692e93b177a521d6789..f4a2d1a2d467808b9cb75fc32765ddc27be5fdba 100644
+--- a/net/minecraft/world/entity/player/ProfilePublicKey.java
++++ b/net/minecraft/world/entity/player/ProfilePublicKey.java
+@@ -23,7 +23,7 @@ public record ProfilePublicKey(ProfilePublicKey.Data data) {
+     public static final Codec<ProfilePublicKey> TRUSTED_CODEC = ProfilePublicKey.Data.CODEC.xmap(ProfilePublicKey::new, ProfilePublicKey::data);
+ 
+     public static ProfilePublicKey createValidated(SignatureValidator signatureValidator, UUID profileId, ProfilePublicKey.Data data) throws ProfilePublicKey.ValidationException {
+-        if (!data.validateSignature(signatureValidator, profileId)) {
++        if (!data.validateSignature(signatureValidator, profileId) && (org.bukkit.Bukkit.getServer().getOnlineMode() && me.earthme.luminol.config.modules.misc.PublickeyVerifyConfig.enabled)) { // Luminol - Verify signature only in online-mode
+             throw new ProfilePublicKey.ValidationException(INVALID_SIGNATURE, org.bukkit.event.player.PlayerKickEvent.Cause.INVALID_PUBLIC_KEY_SIGNATURE); // Paper - kick event causes
+         } else {
+             return new ProfilePublicKey(data);
+diff --git a/net/minecraft/world/level/block/TripWireHookBlock.java b/net/minecraft/world/level/block/TripWireHookBlock.java
+index 6a7e5a642e2eaf7d5dffadb81738f7385a38c0af..f16500a50904aade3d984b908b11b8edd9c05ba1 100644
+--- a/net/minecraft/world/level/block/TripWireHookBlock.java
++++ b/net/minecraft/world/level/block/TripWireHookBlock.java
+@@ -215,7 +215,7 @@ public class TripWireHookBlock extends Block {
+                     BlockState blockState2 = blockStates[i2];
+                     if (blockState2 != null) {
+                         BlockState blockState3 = level.getBlockState(blockPos1);
+-                        if (blockState3.is(Blocks.TRIPWIRE) || blockState3.is(Blocks.TRIPWIRE_HOOK)) {
++                        if (me.earthme.luminol.config.modules.misc.TripwireConfig.enabled || blockState3.is(Blocks.TRIPWIRE) || blockState3.is(Blocks.TRIPWIRE_HOOK)) { // Luminol - Add config for tripwire dupe
+                             level.setBlock(blockPos1, blockState2.trySetValue(ATTACHED, Boolean.valueOf(flag2)), 3);
+                         }
+                     }

luminol-server/minecraft-patches/features/0011-Add-config-to-disable-entity-tick-catchers.patch

@@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:35:13 +0800
+Subject: [PATCH] Add config to disable entity tick catchers
+
+
+diff --git a/net/minecraft/world/level/Level.java b/net/minecraft/world/level/Level.java
+index 5ea7fdf1e337da4c207dd6a53ca942480dd31922..926f5c91eb59277704618fe1910f3dbb38cff002 100644
+--- a/net/minecraft/world/level/Level.java
++++ b/net/minecraft/world/level/Level.java
+@@ -1547,6 +1547,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
+         try {
+             consumerEntity.accept(entity);
+         } catch (Throwable var6) {
++            if (me.earthme.luminol.config.modules.experiment.DisableEntityCatchConfig.enabled) throw var6; // Luminol
+             // Paper start - Prevent block entity and entity crashes
+             final String msg = String.format("Entity threw exception at %s:%s,%s,%s", entity.level().getWorld().getName(), entity.getX(), entity.getY(), entity.getZ());
+             MinecraftServer.LOGGER.error(msg, var6);

luminol-server/minecraft-patches/features/0012-Add-experiment-config-for-command-block-command-exec.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:36:31 +0800
+Subject: [PATCH] Add experiment config for command block command execution
+
+
+diff --git a/net/minecraft/world/level/BaseCommandBlock.java b/net/minecraft/world/level/BaseCommandBlock.java
+index b02b79ccedb8b87bc22270377dfc36e21ebe1724..3786e8288c3a66a5e986ae2a150d03ce2dd5ed16 100644
+--- a/net/minecraft/world/level/BaseCommandBlock.java
++++ b/net/minecraft/world/level/BaseCommandBlock.java
+@@ -114,7 +114,7 @@ public abstract class BaseCommandBlock implements CommandSource {
+     }
+ 
+     public boolean performCommand(Level level) {
+-        if (true) return false; // Folia - region threading
++        if (!me.earthme.luminol.config.modules.experiment.CommandBlockConfig.enabled) return false; // Folia - region threading // Luminol
+         if (level.isClientSide || level.getGameTime() == this.lastExecution) {
+             return false;
+         } else if ("Searge".equalsIgnoreCase(this.command)) {

luminol-server/minecraft-patches/features/0013-Add-fix-for-off-region-adult-following-ai-behavior.patch

@@ -0,0 +1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:39:35 +0800
+Subject: [PATCH] Add fix for off region adult following ai behavior
+
+
+diff --git a/net/minecraft/world/entity/ai/behavior/BabyFollowAdult.java b/net/minecraft/world/entity/ai/behavior/BabyFollowAdult.java
+index a9be3acbf4ea52d2988347abfa6f4f8c02b1da26..751f3dde8e6bc2c0365e8672f5079af0379a69de 100644
+--- a/net/minecraft/world/entity/ai/behavior/BabyFollowAdult.java
++++ b/net/minecraft/world/entity/ai/behavior/BabyFollowAdult.java
+@@ -25,6 +25,14 @@ public class BabyFollowAdult {
+                         return false;
+                     } else {
+                         LivingEntity ageableMob = instance.get(nearestVisibleAdult); // CraftBukkit - type
++
++                        // Luminol start - Fix off world entity following which caused async issue
++                        if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(ageableMob)) {
++                            nearestVisibleAdult.erase();
++                            return true;
++                        }
++                        // Luminol end
++
+                         if (mob.closerThan(ageableMob, followRange.getMaxValue() + 1) && !mob.closerThan(ageableMob, followRange.getMinValue())) {
+                             // CraftBukkit start
+                             org.bukkit.event.entity.EntityTargetLivingEntityEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityTargetLivingEvent(mob, ageableMob, org.bukkit.event.entity.EntityTargetEvent.TargetReason.FOLLOW_LEADER);

luminol-server/minecraft-patches/features/0014-Add-configurable-region-format-framework-linear-v2-r.patch

@@ -0,0 +1,381 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:49:22 +0800
+Subject: [PATCH] Add configurable region format framework & linear v2 region
+ format support
+
+
+diff --git a/ca/spottedleaf/moonrise/patches/chunk_system/io/ChunkSystemRegionFileStorage.java b/ca/spottedleaf/moonrise/patches/chunk_system/io/ChunkSystemRegionFileStorage.java
+index a814512fcfb85312474ae2c2c21443843bf57831..2e084a5b28cbe4737f48c25e10af589213525362 100644
+--- a/ca/spottedleaf/moonrise/patches/chunk_system/io/ChunkSystemRegionFileStorage.java
++++ b/ca/spottedleaf/moonrise/patches/chunk_system/io/ChunkSystemRegionFileStorage.java
+@@ -8,9 +8,9 @@ public interface ChunkSystemRegionFileStorage {
+ 
+     public boolean moonrise$doesRegionFileNotExistNoIO(final int chunkX, final int chunkZ);
+ 
+-    public RegionFile moonrise$getRegionFileIfLoaded(final int chunkX, final int chunkZ);
++    public abomination.IRegionFile moonrise$getRegionFileIfLoaded(final int chunkX, final int chunkZ); // Luminol - Configurable region file format
+ 
+-    public RegionFile moonrise$getRegionFileIfExists(final int chunkX, final int chunkZ) throws IOException;
++    public abomination.IRegionFile moonrise$getRegionFileIfExists(final int chunkX, final int chunkZ) throws IOException; // Luminol - Configurable region file format
+ 
+     public MoonriseRegionFileIO.RegionDataController.WriteData moonrise$startWrite(
+             final int chunkX, final int chunkZ, final CompoundTag compound
+diff --git a/ca/spottedleaf/moonrise/patches/chunk_system/io/MoonriseRegionFileIO.java b/ca/spottedleaf/moonrise/patches/chunk_system/io/MoonriseRegionFileIO.java
+index 98fbc5c8044bd945d64569f13412a6e7e49a4e7f..9709d60d3b2a5478cd6c711669e32f28ac105667 100644
+--- a/ca/spottedleaf/moonrise/patches/chunk_system/io/MoonriseRegionFileIO.java
++++ b/ca/spottedleaf/moonrise/patches/chunk_system/io/MoonriseRegionFileIO.java
+@@ -1260,7 +1260,7 @@ public final class MoonriseRegionFileIO {
+                 this.regionDataController.finishWrite(this.chunkX, this.chunkZ, writeData);
+                 // Paper start - flush regionfiles on save
+                 if (this.world.paperConfig().chunks.flushRegionsOnSave) {
+-                    final RegionFile regionFile = this.regionDataController.getCache().moonrise$getRegionFileIfLoaded(this.chunkX, this.chunkZ);
++                    final abomination.IRegionFile regionFile = this.regionDataController.getCache().moonrise$getRegionFileIfLoaded(this.chunkX, this.chunkZ); // Luminol - Add configurable region file
+                     if (regionFile != null) {
+                         regionFile.flush();
+                     } // else: evicted from cache, which should have called flush
+@@ -1470,7 +1470,7 @@ public final class MoonriseRegionFileIO {
+ 
+         public static interface IORunnable {
+ 
+-            public void run(final RegionFile regionFile) throws IOException;
++            public void run(final abomination.IRegionFile regionFile) throws IOException; // Luminol - Configurable region file format
+ 
+         }
+     }
+diff --git a/ca/spottedleaf/moonrise/patches/chunk_system/storage/ChunkSystemChunkBuffer.java b/ca/spottedleaf/moonrise/patches/chunk_system/storage/ChunkSystemChunkBuffer.java
+index 51c126735ace8fdde89ad97b5cab62f244212db0..c7d4d944eb198ac53a3eeae717a25c7d5815c8c1 100644
+--- a/ca/spottedleaf/moonrise/patches/chunk_system/storage/ChunkSystemChunkBuffer.java
++++ b/ca/spottedleaf/moonrise/patches/chunk_system/storage/ChunkSystemChunkBuffer.java
+@@ -8,5 +8,5 @@ public interface ChunkSystemChunkBuffer {
+ 
+     public void moonrise$setWriteOnClose(final boolean value);
+ 
+-    public void moonrise$write(final RegionFile regionFile) throws IOException;
++    public void moonrise$write(final abomination.IRegionFile regionFile) throws IOException; // Luminol - Configurable region file format
+ }
+diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
+index 46375fa81b36b89b79c22f0a7ac6d610ab1183d4..c00378ba258647787bb9138e319b0f6a0b00e1ed 100644
+--- a/net/minecraft/server/MinecraftServer.java
++++ b/net/minecraft/server/MinecraftServer.java
+@@ -986,10 +986,10 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         // CraftBukkit end
+         if (flush) {
+             for (ServerLevel serverLevel2 : this.getAllLevels()) {
+-                LOGGER.info("ThreadedAnvilChunkStorage ({}): All chunks are saved", serverLevel2.getChunkSource().chunkMap.getStorageName());
++                LOGGER.info("ThreadedChunkStorage ({}): All chunks are saved", serverLevel2.getChunkSource().chunkMap.getStorageName()); // Luminol - configurable region format
+             }
+ 
+-            LOGGER.info("ThreadedAnvilChunkStorage: All dimensions are saved");
++            LOGGER.info("ThreadedChunkStorage: All dimensions are saved"); // Luminol - configurable region format
+         }
+ 
+         return flag;
+diff --git a/net/minecraft/util/worldupdate/WorldUpgrader.java b/net/minecraft/util/worldupdate/WorldUpgrader.java
+index e0bcda2ddea0d6633445a7440fbf0d18e50a7653..57ed3f61b265fc5c231ef0f2b7c4d33b4f3f6cba 100644
+--- a/net/minecraft/util/worldupdate/WorldUpgrader.java
++++ b/net/minecraft/util/worldupdate/WorldUpgrader.java
+@@ -72,7 +72,7 @@ public class WorldUpgrader implements AutoCloseable {
+     volatile int skipped;
+     final Reference2FloatMap<ResourceKey<Level>> progressMap = Reference2FloatMaps.synchronize(new Reference2FloatOpenHashMap<>());
+     volatile Component status = Component.translatable("optimizeWorld.stage.counting");
+-    static final Pattern REGEX = Pattern.compile("^r\\.(-?[0-9]+)\\.(-?[0-9]+)\\.mca$");
++    static final Pattern REGEX = Pattern.compile("^r\\.(-?[0-9]+)\\.(-?[0-9]+)\\\\"+ net.minecraft.world.level.chunk.storage.RegionFileStorage.getExtensionName() +"$"); // Luminol - Configurable region file format
+     final DimensionDataStorage overworldDataStorage;
+ 
+     public WorldUpgrader(
+@@ -261,7 +261,7 @@ public class WorldUpgrader implements AutoCloseable {
+         }
+ 
+         private static List<WorldUpgrader.FileToUpgrade> getAllChunkPositions(RegionStorageInfo regionStorageInfo, Path path) {
+-            File[] files = path.toFile().listFiles((directory, filename) -> filename.endsWith(".mca"));
++            File[] files = path.toFile().listFiles((directory, filename) -> filename.endsWith(net.minecraft.world.level.chunk.storage.RegionFileStorage.getExtensionName())); // Luminol - Configurable region file format
+             if (files == null) {
+                 return List.of();
+             } else {
+@@ -274,7 +274,7 @@ public class WorldUpgrader implements AutoCloseable {
+                         int i1 = Integer.parseInt(matcher.group(2)) << 5;
+                         List<ChunkPos> list1 = Lists.newArrayList();
+ 
+-                        try (RegionFile regionFile = new RegionFile(regionStorageInfo, file.toPath(), path, true)) {
++                        try (abomination.IRegionFile regionFile = net.minecraft.world.level.chunk.storage.RegionFileStorage.createNew(regionStorageInfo, file.toPath(), path, true)) {  // Luminol - Configurable region file format
+                             for (int i2 = 0; i2 < 32; i2++) {
+                                 for (int i3 = 0; i3 < 32; i3++) {
+                                     ChunkPos chunkPos = new ChunkPos(i2 + i, i3 + i1);
+@@ -322,7 +322,7 @@ public class WorldUpgrader implements AutoCloseable {
+ 
+         protected abstract boolean tryProcessOnePosition(T chunkStorage, ChunkPos chunkPos, ResourceKey<Level> dimension);
+ 
+-        private void onFileFinished(RegionFile regionFile) {
++        private void onFileFinished(abomination.IRegionFile regionFile) { // Luminol - Configurable region file format
+             if (WorldUpgrader.this.recreateRegionFiles) {
+                 if (this.previousWriteFuture != null) {
+                     this.previousWriteFuture.join();
+@@ -424,7 +424,7 @@ public class WorldUpgrader implements AutoCloseable {
+         }
+     }
+ 
+-    record FileToUpgrade(RegionFile file, List<ChunkPos> chunksToUpgrade) {
++    record FileToUpgrade(abomination.IRegionFile file, List<ChunkPos> chunksToUpgrade) { // Luminol - Configurable region file format
+     }
+ 
+     class PoiUpgrader extends WorldUpgrader.SimpleRegionStorageUpgrader {
+diff --git a/net/minecraft/world/level/chunk/storage/RegionFile.java b/net/minecraft/world/level/chunk/storage/RegionFile.java
+index 0c41177462cca5c4bbab6490e323b9535fd6300f..39b3c3ca7248fe60833f04aee89c8851b21d5008 100644
+--- a/net/minecraft/world/level/chunk/storage/RegionFile.java
++++ b/net/minecraft/world/level/chunk/storage/RegionFile.java
+@@ -22,7 +22,7 @@ import net.minecraft.util.profiling.jfr.JvmProfiler;
+ import net.minecraft.world.level.ChunkPos;
+ import org.slf4j.Logger;
+ 
+-public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patches.chunk_system.storage.ChunkSystemRegionFile { // Paper - rewrite chunk system
++public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patches.chunk_system.storage.ChunkSystemRegionFile , abomination.IRegionFile{ // Paper - rewrite chunk system // Luminol - Configurable region file format
+     private static final Logger LOGGER = LogUtils.getLogger();
+     public static final int MAX_CHUNK_SIZE = 500 * 1024 * 1024; // Paper - don't write garbage data to disk if writing serialization fails
+     private static final int SECTOR_BYTES = 4096;
+@@ -124,7 +124,7 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
+     }
+ 
+     // note: only call for CHUNK regionfiles
+-    boolean recalculateHeader() throws IOException {
++    public boolean recalculateHeader() throws IOException { // Luminol - Configurable region file format // Luminol - Configurable region file format
+         if (!this.canRecalcHeader) {
+             return false;
+         }
+@@ -786,7 +786,7 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
+         }
+     }
+ 
+-    protected synchronized void write(ChunkPos chunkPos, ByteBuffer chunkData) throws IOException {
++    public synchronized void write(ChunkPos chunkPos, ByteBuffer chunkData) throws IOException { // Luminol - Configurable region file format
+         int offsetIndex = getOffsetIndex(chunkPos);
+         int i = this.offsets.get(offsetIndex);
+         int sectorNumber = getSectorNumber(i);
+@@ -904,7 +904,7 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
+         }
+ 
+         @Override
+-        public final void moonrise$write(final RegionFile regionFile) throws IOException {
++        public final void moonrise$write(final abomination.IRegionFile regionFile) throws IOException { // Luminol - Configurable region file format
+             regionFile.write(this.pos, ByteBuffer.wrap(this.buf, 0, this.count));
+         }
+         // Paper end - rewrite chunk system
+@@ -970,11 +970,11 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
+         return (x & 31) + (z & 31) * 32;
+     }
+ 
+-    synchronized boolean isOversized(int x, int z) {
++    public synchronized boolean isOversized(int x, int z) { // Luminol - Configurable region file format
+         return this.oversized[getChunkIndex(x, z)] == 1;
+     }
+ 
+-    synchronized void setOversized(int x, int z, boolean oversized) throws IOException {
++    public synchronized void setOversized(int x, int z, boolean oversized) throws IOException { // Luminol - Configurable region file format
+         final int offset = getChunkIndex(x, z);
+         boolean previous = this.oversized[offset] == 1;
+         this.oversized[offset] = (byte) (oversized ? 1 : 0);
+@@ -1013,7 +1013,7 @@ public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patche
+         return this.path.getParent().resolve(this.path.getFileName().toString().replaceAll("\\.mca$", "") + "_oversized_" + x + "_" + z + ".nbt");
+     }
+ 
+-    synchronized net.minecraft.nbt.CompoundTag getOversizedData(int x, int z) throws IOException {
++    public synchronized net.minecraft.nbt.CompoundTag getOversizedData(int x, int z) throws IOException { // Luminol - Configurable region file format
+         Path file = getOversizedFile(x, z);
+         try (DataInputStream out = new DataInputStream(new java.io.BufferedInputStream(new java.util.zip.InflaterInputStream(Files.newInputStream(file))))) {
+             return net.minecraft.nbt.NbtIo.read((java.io.DataInput) out);
+diff --git a/net/minecraft/world/level/chunk/storage/RegionFileStorage.java b/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
+index dad7f94b611cf0fc68b1a3878c458233f6bb6d61..437fff55b565e469f6a4e41288b6f805e125be60 100644
+--- a/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
++++ b/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
+@@ -18,7 +18,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+     private static final org.slf4j.Logger LOGGER = com.mojang.logging.LogUtils.getLogger(); // Paper
+     public static final String ANVIL_EXTENSION = ".mca";
+     private static final int MAX_CACHE_SIZE = 256;
+-    public final Long2ObjectLinkedOpenHashMap<RegionFile> regionCache = new Long2ObjectLinkedOpenHashMap<>();
++    public final Long2ObjectLinkedOpenHashMap<abomination.IRegionFile> regionCache = new Long2ObjectLinkedOpenHashMap<>();  // Luminol - Configurable region file format
+     private final RegionStorageInfo info;
+     private final Path folder;
+     private final boolean sync;
+@@ -33,7 +33,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+     @Nullable
+     public static ChunkPos getRegionFileCoordinates(Path file) {
+         String fileName = file.getFileName().toString();
+-        if (!fileName.startsWith("r.") || !fileName.endsWith(".mca")) {
++        if (!fileName.startsWith("r.") || !fileName.endsWith(getExtensionName())) { // Luminol - Configurable region file format
+             return null;
+         }
+ 
+@@ -58,8 +58,27 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+     private static final int MAX_NON_EXISTING_CACHE = 1024 * 4;
+     private final it.unimi.dsi.fastutil.longs.LongLinkedOpenHashSet nonExistingRegionFiles = new it.unimi.dsi.fastutil.longs.LongLinkedOpenHashSet();
+     private static String getRegionFileName(final int chunkX, final int chunkZ) {
+-        return "r." + (chunkX >> REGION_SHIFT) + "." + (chunkZ >> REGION_SHIFT) + ".mca";
++        return "r." + (chunkX >> REGION_SHIFT) + "." + (chunkZ >> REGION_SHIFT) + getExtensionName(); // Luminol - Configurable region file format
+     }
++    // Luminol start - Configurable region file format
++    public static abomination.IRegionFile createNew(RegionStorageInfo info, Path filePath, Path folder, boolean sync) throws IOException{
++        final me.earthme.luminol.utils.EnumRegionFormat regionFormat = me.earthme.luminol.config.modules.misc.RegionFormatConfig.regionFormat;
++        final String fullFileName = filePath.getFileName().toString();
++        final String[] fullNameSplit = fullFileName.split("\\.");
++        final String extensionName = fullNameSplit[fullNameSplit.length - 1];
++
++        if (!regionFormat.getArgument().equalsIgnoreCase(extensionName)) {
++            net.minecraft.server.MinecraftServer.setFatalException(new RuntimeException("Invalid region file format: " + extensionName + " expected " + regionFormat.getArgument()));
++            throw new IOException("Invalid region file format: " + extensionName + " expected " + regionFormat.getArgument());
++        }
++
++        return regionFormat.getCreator().create(new me.earthme.luminol.utils.RegionCreatorInfo(info, filePath, folder, sync));
++    }
++
++    public static String getExtensionName() {
++        return "." + me.earthme.luminol.config.modules.misc.RegionFormatConfig.regionFormat.getArgument();
++    }
++    // Luminol end
+ 
+     private boolean doesRegionFilePossiblyExist(final long position) {
+         synchronized (this.nonExistingRegionFiles) {
+@@ -93,15 +112,15 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+     }
+ 
+     @Override
+-    public synchronized final RegionFile moonrise$getRegionFileIfLoaded(final int chunkX, final int chunkZ) {
++    public synchronized final abomination.IRegionFile moonrise$getRegionFileIfLoaded(final int chunkX, final int chunkZ) { // Luminol - Configurable region file format
+         return this.regionCache.getAndMoveToFirst(ChunkPos.asLong(chunkX >> REGION_SHIFT, chunkZ >> REGION_SHIFT));
+     }
+ 
+     @Override
+-    public synchronized final RegionFile moonrise$getRegionFileIfExists(final int chunkX, final int chunkZ) throws IOException {
++    public synchronized final abomination.IRegionFile moonrise$getRegionFileIfExists(final int chunkX, final int chunkZ) throws IOException {  // Luminol - Configurable region file format
+         final long key = ChunkPos.asLong(chunkX >> REGION_SHIFT, chunkZ >> REGION_SHIFT);
+ 
+-        RegionFile ret = this.regionCache.getAndMoveToFirst(key);
++        abomination.IRegionFile ret = this.regionCache.getAndMoveToFirst(key);  // Luminol - Configurable region file format
+         if (ret != null) {
+             return ret;
+         }
+@@ -125,7 +144,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+ 
+         FileUtil.createDirectoriesSafe(this.folder);
+ 
+-        ret = new RegionFile(this.info, regionPath, this.folder, this.sync);
++        ret = this.createNew(this.info, regionPath, this.folder, this.sync);  // Luminol - Configurable region file format
+ 
+         this.regionCache.putAndMoveToFirst(key, ret);
+ 
+@@ -144,7 +163,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+         }
+ 
+         final ChunkPos pos = new ChunkPos(chunkX, chunkZ);
+-        final RegionFile regionFile = this.getRegionFile(pos);
++        final abomination.IRegionFile regionFile = this.getRegionFile(pos);  // Luminol - Configurable region file format
+ 
+         // note: not required to keep regionfile loaded after this call, as the write param takes a regionfile as input
+         // (and, the regionfile parameter is unused for writing until the write call)
+@@ -178,7 +197,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+     ) throws IOException {
+         final ChunkPos pos = new ChunkPos(chunkX, chunkZ);
+         if (writeData.result() == ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.WriteData.WriteResult.DELETE) {
+-            final RegionFile regionFile = this.moonrise$getRegionFileIfExists(chunkX, chunkZ);
++            final abomination.IRegionFile regionFile = this.moonrise$getRegionFileIfExists(chunkX, chunkZ);  // Luminol - Configurable region file format
+             if (regionFile != null) {
+                 regionFile.clear(pos);
+             } // else: didn't exist
+@@ -193,7 +212,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+     public final ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.ReadData moonrise$readData(
+         final int chunkX, final int chunkZ
+     ) throws IOException {
+-        final RegionFile regionFile = this.moonrise$getRegionFileIfExists(chunkX, chunkZ);
++        final abomination.IRegionFile regionFile = this.moonrise$getRegionFileIfExists(chunkX, chunkZ);  // Luminol - Configurable region file format
+ 
+         final DataInputStream input = regionFile == null ? null : regionFile.getChunkDataInputStream(new ChunkPos(chunkX, chunkZ));
+ 
+@@ -237,7 +256,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+     }
+     // Paper end - rewrite chunk system
+     // Paper start - rewrite chunk system
+-    public RegionFile getRegionFile(ChunkPos chunkcoordintpair) throws IOException {
++    public abomination.IRegionFile getRegionFile(ChunkPos chunkcoordintpair) throws IOException {  // Luminol - Configurable region file format
+         return this.getRegionFile(chunkcoordintpair, false);
+     }
+     // Paper end - rewrite chunk system
+@@ -249,7 +268,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+         this.isChunkData = isChunkDataFolder(this.folder); // Paper - recalculate region file headers
+     }
+ 
+-    @org.jetbrains.annotations.Contract("_, false -> !null") @Nullable private RegionFile getRegionFile(ChunkPos chunkPos, boolean existingOnly) throws IOException { // CraftBukkit
++    @org.jetbrains.annotations.Contract("_, false -> !null") @Nullable private abomination.IRegionFile getRegionFile(ChunkPos chunkPos, boolean existingOnly) throws IOException { // CraftBukkit
+         // Paper start - rewrite chunk system
+         if (existingOnly) {
+             return this.moonrise$getRegionFileIfExists(chunkPos.x, chunkPos.z);
+@@ -257,7 +276,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+         synchronized (this) {
+             final long key = ChunkPos.asLong(chunkPos.x >> REGION_SHIFT, chunkPos.z >> REGION_SHIFT);
+ 
+-            RegionFile ret = this.regionCache.getAndMoveToFirst(key);
++            abomination.IRegionFile ret = this.regionCache.getAndMoveToFirst(key);  // Luminol - Configurable region file format
+             if (ret != null) {
+                 return ret;
+             }
+@@ -272,7 +291,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+ 
+             FileUtil.createDirectoriesSafe(this.folder);
+ 
+-            ret = new RegionFile(this.info, regionPath, this.folder, this.sync);
++            ret = this.createNew(this.info, regionPath, this.folder, this.sync); // Luminol - Configurable region file format
+ 
+             this.regionCache.putAndMoveToFirst(key, ret);
+ 
+@@ -286,7 +305,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+         org.apache.logging.log4j.LogManager.getLogger().fatal(msg + " (" + file.toString().replaceAll(".+[\\\\/]", "") + " - " + x + "," + z + ") Go clean it up to remove this message. /minecraft:tp " + (x<<4)+" 128 "+(z<<4) + " - DO NOT REPORT THIS TO PAPER - You may ask for help on Discord, but do not file an issue. These error messages can not be removed.");
+     }
+ 
+-    private static CompoundTag readOversizedChunk(RegionFile regionfile, ChunkPos chunkCoordinate) throws IOException {
++    private static CompoundTag readOversizedChunk(abomination.IRegionFile regionfile, ChunkPos chunkCoordinate) throws IOException {  // Luminol - Configurable region file format
+         synchronized (regionfile) {
+             try (DataInputStream datainputstream = regionfile.getChunkDataInputStream(chunkCoordinate)) {
+                 CompoundTag oversizedData = regionfile.getOversizedData(chunkCoordinate.x, chunkCoordinate.z);
+@@ -321,7 +340,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+     @Nullable
+     public CompoundTag read(ChunkPos chunkPos) throws IOException {
+         // CraftBukkit start - SPIGOT-5680: There's no good reason to preemptively create files on read, save that for writing
+-        RegionFile regionFile = this.getRegionFile(chunkPos, true);
++        abomination.IRegionFile regionFile = this.getRegionFile(chunkPos, true); // Luminol - Configurable region file format
+         if (regionFile == null) {
+             return null;
+         }
+@@ -360,7 +379,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+ 
+     public void scanChunk(ChunkPos chunkPos, StreamTagVisitor visitor) throws IOException {
+         // CraftBukkit start - SPIGOT-5680: There's no good reason to preemptively create files on read, save that for writing
+-        RegionFile regionFile = this.getRegionFile(chunkPos, true);
++        abomination.IRegionFile regionFile = this.getRegionFile(chunkPos, true); // Luminol - Configurable region file format
+         if (regionFile == null) {
+             return;
+         }
+@@ -374,7 +393,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+     }
+ 
+     public void write(ChunkPos chunkPos, @Nullable CompoundTag chunkData) throws IOException { // Paper - rewrite chunk system - public
+-        RegionFile regionFile = this.getRegionFile(chunkPos, chunkData == null); // CraftBukkit // Paper - rewrite chunk system
++        abomination.IRegionFile regionFile = this.getRegionFile(chunkPos, chunkData == null); // CraftBukkit // Paper - rewrite chunk system // Luminol - Configurable region file format
+         // Paper start - rewrite chunk system
+         if (regionFile == null) {
+             // if the RegionFile doesn't exist, no point in deleting from it
+@@ -404,7 +423,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+         // Paper start - rewrite chunk system
+         synchronized (this) {
+             final ExceptionCollector<IOException> exceptionCollector = new ExceptionCollector<>();
+-            for (final RegionFile regionFile : this.regionCache.values()) {
++            for (final abomination.IRegionFile regionFile : this.regionCache.values()) { // Luminol - Configurable region file format
+                 try {
+                     regionFile.close();
+                 } catch (final IOException ex) {
+@@ -420,7 +439,7 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+         // Paper start - rewrite chunk system
+         synchronized (this) {
+             final ExceptionCollector<IOException> exceptionCollector = new ExceptionCollector<>();
+-            for (final RegionFile regionFile : this.regionCache.values()) {
++            for (final abomination.IRegionFile regionFile : this.regionCache.values()) { // Luminol - Configurable region file format
+                 try {
+                     regionFile.flush();
+                 } catch (final IOException ex) {

luminol-server/minecraft-patches/features/0015-Add-config-for-watchdog-timeout.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:51:21 +0800
+Subject: [PATCH] Add config for watchdog timeout
+
+
+diff --git a/io/papermc/paper/threadedregions/FoliaWatchdogThread.java b/io/papermc/paper/threadedregions/FoliaWatchdogThread.java
+index 258d82ab2c78482e1561343e8e1f81fc33f1895e..967107c0f4a18a29877883ccddb4d7962f4b5788 100644
+--- a/io/papermc/paper/threadedregions/FoliaWatchdogThread.java
++++ b/io/papermc/paper/threadedregions/FoliaWatchdogThread.java
+@@ -65,7 +65,7 @@ public final class FoliaWatchdogThread extends Thread {
+ 
+             for (final RunningTick tick : ticks) {
+                 final long elapsed = now - tick.lastPrint;
+-                if (elapsed <= TimeUnit.SECONDS.toNanos(5L)) {
++                if (elapsed <= TimeUnit.MILLISECONDS.toNanos(me.earthme.luminol.config.modules.misc.FoliaWatchogConfig.tickRegionTimeOutMs)) { // Luminol - Add config for watchdog timeout
+                     continue;
+                 }
+                 tick.lastPrint = now;

luminol-server/minecraft-patches/features/0016-Teleport-async-if-entity-was-moving-to-another-regio.patch

@@ -0,0 +1,54 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:53:41 +0800
+Subject: [PATCH] Teleport async if entity was moving to another region at once
+
+
+diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
+index 0c17d7f2cd4d6092ed805fe52baae53812ba582a..22b0b721959d41647a2f92133b3d6faed6cacef6 100644
+--- a/net/minecraft/world/entity/Entity.java
++++ b/net/minecraft/world/entity/Entity.java
+@@ -1103,6 +1103,10 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     }
+     // Paper end - detailed watchdog information
+ 
++    //Luminol start - Fix large pos moving
++    private volatile boolean preventMoving = false;
++    //Luminol end
++
+     public void move(MoverType type, Vec3 movement) {
+         final Vec3 originalMovement = movement; // Paper - Expose pre-collision velocity
+         // Paper start - detailed watchdog information
+@@ -1113,6 +1117,32 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+             this.moveStartZ = this.getZ();
+             this.moveVector = movement;
+         }
++        //Luminol start - Fix high position moving
++        if (me.earthme.luminol.config.modules.fixes.FoliaEntityMovingFixConfig.enabled && ca.spottedleaf.moonrise.common.util.TickThread.isTickThread()){ //Except the threads because it may be called by the chunk system worker thread
++            var finalPosition = movement.add(this.position);
++            if (this.preventMoving || Double.isNaN(finalPosition.x) || Double.isNaN(finalPosition.y) || Double.isNaN(finalPosition.z)){
++                return;
++            }
++
++            if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(((ServerLevel) this.level),finalPosition)){
++                this.preventMoving = true;
++                this.teleportAsync(
++                        (ServerLevel) this.level(),
++                        finalPosition,
++                        this.getYRot(), this.getXRot(),
++                        null, org.bukkit.event.player.PlayerTeleportEvent.TeleportCause.UNKNOWN,
++                        Entity.TELEPORT_FLAG_LOAD_CHUNK | Entity.TELEPORT_FLAG_TELEPORT_PASSENGERS,
++                        result -> {
++                            this.preventMoving = false;
++                        }
++                );
++                if (me.earthme.luminol.config.modules.fixes.FoliaEntityMovingFixConfig.warnOnDetected){
++                    MinecraftServer.LOGGER.warn("Entity {} with entityId {} has tried moving to another region!",this.type.getCategory().getName(),this.getId());
++                }
++                return;
++            }
++        }
++        //Luminol end
+         try {
+         // Paper end - detailed watchdog information
+         if (this.noPhysics) {

luminol-server/minecraft-patches/features/0017-Try-fixing-folia-off-region-POI-accessing-issue.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:56:59 +0800
+Subject: [PATCH] Try fixing folia off region POI accessing issue
+
+
+diff --git a/net/minecraft/world/entity/ai/village/poi/PoiManager.java b/net/minecraft/world/entity/ai/village/poi/PoiManager.java
+index c10810bf00d75f459c3c6a9415c1e09f0519d50e..3adafa43367cd6648ecbccb92ba5bd509740d5a4 100644
+--- a/net/minecraft/world/entity/ai/village/poi/PoiManager.java
++++ b/net/minecraft/world/entity/ai/village/poi/PoiManager.java
+@@ -212,7 +212,7 @@ public class PoiManager extends SectionStorage<PoiSection, PoiSection.Packed> im
+ 
+     public Stream<PoiRecord> getInSquare(Predicate<Holder<PoiType>> typePredicate, BlockPos pos, int distance, PoiManager.Occupancy status) {
+         int i = Math.floorDiv(distance, 16) + 1;
+-        return ChunkPos.rangeClosed(new ChunkPos(pos), i).flatMap(chunkPos -> this.getInChunk(typePredicate, chunkPos, status)).filter(poiRecord -> {
++        return ChunkPos.rangeClosed(new ChunkPos(pos), i).filter(cpos -> me.earthme.luminol.config.modules.fixes.FoliaPOIAccessOffRegionFixConfig.enabled ? ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(this.world,cpos) : true).flatMap(chunkPos -> this.getInChunk(typePredicate, chunkPos, status)).filter(poiRecord -> { // Luminol - Fix off region POI access
+             BlockPos pos1 = poiRecord.getPos();
+             return Math.abs(pos1.getX() - pos.getX()) <= distance && Math.abs(pos1.getZ() - pos.getZ()) <= distance;
+         });

luminol-server/minecraft-patches/features/0018-Force-disable-builtin-spark-plugin.patch

@@ -0,0 +1,98 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 11:00:49 +0800
+Subject: [PATCH] Force disable builtin spark plugin
+
+
+diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
+index c00378ba258647787bb9138e319b0f6a0b00e1ed..ff71466ec0848d16121e351e30c31bb419af8b99 100644
+--- a/net/minecraft/server/MinecraftServer.java
++++ b/net/minecraft/server/MinecraftServer.java
+@@ -783,8 +783,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         // Paper end - Configurable player collision
+ 
+         this.server.enablePlugins(org.bukkit.plugin.PluginLoadOrder.POSTWORLD);
+-        this.server.spark.registerCommandBeforePlugins(this.server); // Paper - spark
+-        this.server.spark.enableAfterPlugins(this.server); // Paper - spark
++        if (false) this.server.spark.registerCommandBeforePlugins(this.server); // Paper - spark // Luminol - Force disable builtin spark
++        if (false) this.server.spark.enableAfterPlugins(this.server); // Paper - spark // Luminol - Force disable builtin spark
+         if (io.papermc.paper.plugin.PluginInitializerManager.instance().pluginRemapper != null) io.papermc.paper.plugin.PluginInitializerManager.instance().pluginRemapper.pluginsEnabled(); // Paper - Remap plugins
+         io.papermc.paper.command.brigadier.PaperCommands.INSTANCE.setValid(); // Paper - reset invalid state for event fire below
+         io.papermc.paper.plugin.lifecycle.event.LifecycleEventRunner.INSTANCE.callReloadableRegistrarEvent(io.papermc.paper.plugin.lifecycle.event.types.LifecycleEvents.COMMANDS, io.papermc.paper.command.brigadier.PaperCommands.INSTANCE, org.bukkit.plugin.Plugin.class, io.papermc.paper.plugin.lifecycle.event.registrar.ReloadableRegistrarEvent.Cause.INITIAL); // Paper - call commands event for regular plugins
+@@ -1072,7 +1072,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         Commands.COMMAND_SENDING_POOL.shutdownNow(); // Paper - Perf: Async command map building; Shutdown and don't bother finishing
+         // CraftBukkit start
+         if (this.server != null) {
+-            this.server.spark.disable(); // Paper - spark
++            if (false) this.server.spark.disable(); // Paper - spark // Luminol - Force disable builtin spark
+             this.server.disablePlugins();
+             this.server.waitForAsyncTasksShutdown(); // Paper - Wait for Async Tasks during shutdown
+         }
+@@ -1250,7 +1250,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             this.statusIcon = this.loadStatusIcon().orElse(null);
+             this.status = this.buildServerStatus();
+ 
+-            this.server.spark.enableBeforePlugins(); // Paper - spark
++            if (false) this.server.spark.enableBeforePlugins(); // Paper - spark // Luminol - Force disable builtin spark
+             // Folia start - region threading
+             if (true) {
+                 io.papermc.paper.threadedregions.RegionizedServer.getInstance().init(); // Folia - region threading - only after loading worlds
+@@ -1593,7 +1593,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             }
+ 
+             if (this.emptyTicks >= i) {
+-                this.server.spark.tickStart(); // Paper - spark
++                if (false) this.server.spark.tickStart(); // Paper - spark // Luminol - Force disable builtin spark
+                 if (this.emptyTicks == i) {
+                     LOGGER.info("Server empty for {} seconds, pausing", this.pauseWhileEmptySeconds());
+                     this.autoSave();
+@@ -1612,7 +1612,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+                 // Paper end - avoid issues with certain tasks not processing during sleep
+                 //this.server.spark.executeMainThreadTasks(); // Paper - spark // Folia - region threading
+                 this.tickConnection();
+-                this.server.spark.tickEnd(((double)(System.nanoTime() - lastTick) / 1000000D)); // Paper - spark
++                if (false) this.server.spark.tickEnd(((double)(System.nanoTime() - lastTick) / 1000000D)); // Paper - spark  // Luminol - Force disable builtin spark
++                // Paper end - Server Tick Events
+                 return;
+             }
+         }
+@@ -1635,7 +1636,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         };
+         // Folia end - region threading
+ 
+-        this.server.spark.tickStart(); // Paper - spark
++        if (false) this.server.spark.tickStart(); // Paper - spark // Luminol - Force disable builtin spark
+         new com.destroystokyo.paper.event.server.ServerTickStartEvent((int)region.getCurrentTick()).callEvent(); // Paper - Server Tick Events // Folia - region threading
+         // Folia start - region threading
+         if (region != null) {
+@@ -1706,7 +1707,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         long remaining = scheduledEnd - endTime; // Folia - region ticking
+         new com.destroystokyo.paper.event.server.ServerTickEndEvent((int)io.papermc.paper.threadedregions.RegionizedServer.getCurrentTick(), ((double)(endTime - startTime) / 1000000D), remaining).callEvent(); // Folia - region ticking
+         // Paper end - Server Tick Events
+-        this.server.spark.tickEnd(((double)(endTime - startTime) / 1000000D)); // Paper - spark // Folia - region threading
++        if (false) this.server.spark.tickEnd(((double)(endTime - startTime) / 1000000D)); // Paper - spark // Folia - region threading // Luminol - Force disable builtin spark
+         // Folia - region threading
+     }
+ 
+diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
+index 82f80e152a8b7426d711df7df6eae9043cf35e69..298d9eb8e303fb4eaae58dcc5c9f29e23150496f 100644
+--- a/net/minecraft/server/dedicated/DedicatedServer.java
++++ b/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -214,7 +214,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+         // Paper end - initialize global and world-defaults configuration
+         me.earthme.luminol.config.LuminolConfig.finalizeLoadConfig(); //Luminol - load config file
+         me.earthme.luminol.config.LuminolConfig.setupLatch(); //Luminol - load config file
+-        this.server.spark.enableEarlyIfRequested(); // Paper - spark
++        if (false) this.server.spark.enableEarlyIfRequested(); // Paper - spark // Luminol - Force disable builtin spark
+         // 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
+@@ -224,7 +224,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+         org.spigotmc.WatchdogThread.doStart(org.spigotmc.SpigotConfig.timeoutTime, org.spigotmc.SpigotConfig.restartOnCrash); // Paper - start watchdog thread
+         thread.start(); // Paper - Enhance console tab completions for brigadier commands; start console thread after MinecraftServer.console & PaperConfig are initialized
+         io.papermc.paper.command.PaperCommands.registerCommands(this); // Paper - setup /paper command
+-        this.server.spark.registerCommandBeforePlugins(this.server); // Paper - spark
++        if (false) this.server.spark.registerCommandBeforePlugins(this.server); // Paper - spark // Luminol - Force disable builtin spark
+         com.destroystokyo.paper.Metrics.PaperMetrics.startMetrics(); // Paper - start metrics
+         com.destroystokyo.paper.VersionHistoryManager.INSTANCE.getClass(); // Paper - load version history now
+ 

luminol-server/minecraft-patches/features/0019-Merge-Paper-11945-for-temporary-hooper-behavior-fix.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 11:03:09 +0800
+Subject: [PATCH] Merge Paper #11945 for temporary hooper behavior fix
+
+A hopper optimization fix on Paper's pr : https://github.com/PaperMC/Paper/pull/11945
+
+diff --git a/net/minecraft/world/level/block/entity/HopperBlockEntity.java b/net/minecraft/world/level/block/entity/HopperBlockEntity.java
+index ae988c4910421fb720177178ef6136e595ae6946..72a81e29be6570fb119b159210453a86f003f893 100644
+--- a/net/minecraft/world/level/block/entity/HopperBlockEntity.java
++++ b/net/minecraft/world/level/block/entity/HopperBlockEntity.java
+@@ -698,6 +698,7 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+             } else if (canMergeItems(item, stack)) {
+                 int i = Math.min(stack.getMaxStackSize(), destination.getMaxStackSize()) - item.getCount(); // Paper - Make hoppers respect inventory max stack size
+                 int min = Math.min(stack.getCount(), i);
++                stack = stack.copy(true); // Luminol
+                 stack.shrink(min);
+                 item.grow(min);
+                 flag = min > 0;

luminol-server/minecraft-patches/features/0020-Kaiiju-Don-t-pathfind-outside-region.patch

@@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 11:03:59 +0800
+Subject: [PATCH] Kaiiju Don't pathfind outside region
+
+
+diff --git a/net/minecraft/world/entity/ai/behavior/MoveToTargetSink.java b/net/minecraft/world/entity/ai/behavior/MoveToTargetSink.java
+index 621ba76784f2b92790eca62be4d0688834335ab6..52b3f1795843f40fdb3298cfd1a570a211a08739 100644
+--- a/net/minecraft/world/entity/ai/behavior/MoveToTargetSink.java
++++ b/net/minecraft/world/entity/ai/behavior/MoveToTargetSink.java
+@@ -119,7 +119,9 @@ public class MoveToTargetSink extends Behavior<Mob> {
+ 
+     private boolean tryComputePath(Mob mob, WalkTarget target, long time) {
+         BlockPos blockPos = target.getTarget().currentBlockPosition();
++        if (ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(mob.level(), blockPos)) // Kaiiju - Don't pathfind outside region
+         this.path = mob.getNavigation().createPath(blockPos, 0);
++        else this.path = null; // Kaiiju - Don't pathfind outside region
+         this.speedModifier = target.getSpeedModifier();
+         Brain<?> brain = mob.getBrain();
+         if (this.reachedTarget(mob, target)) {

luminol-server/minecraft-patches/features/0021-Kaiiju-Vanilla-end-portal-teleportation.patch

@@ -0,0 +1,66 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 11:04:12 +0800
+Subject: [PATCH] Kaiiju Vanilla end portal teleportation
+
+
+diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
+index 22b0b721959d41647a2f92133b3d6faed6cacef6..8312c3bb4e0a183834279227f57da723ea46a3a9 100644
+--- a/net/minecraft/world/entity/Entity.java
++++ b/net/minecraft/world/entity/Entity.java
+@@ -110,6 +110,7 @@ import net.minecraft.world.level.block.Rotation;
+ import net.minecraft.world.level.block.SoundType;
+ import net.minecraft.world.level.block.state.BlockState;
+ import net.minecraft.world.level.border.WorldBorder;
++import net.minecraft.world.level.dimension.LevelStem;
+ import net.minecraft.world.level.entity.EntityAccess;
+ import net.minecraft.world.level.entity.EntityInLevelCallback;
+ import net.minecraft.world.level.gameevent.DynamicGameEventListener;
+@@ -4276,13 +4277,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+                         targetPos, 16, // load 16 blocks to be safe from block physics
+                         ca.spottedleaf.concurrentutil.util.Priority.HIGH,
+                         (chunks) -> {
+-                            net.minecraft.world.level.levelgen.feature.EndPlatformFeature.createEndPlatform(destination, targetPos.below(), true, null);
++                            //net.minecraft.world.level.levelgen.feature.EndPlatformFeature.createEndPlatform(destination, targetPos.below(), true, null);  // Kaiiju - Vanilla end teleportation - moved down
+ 
++                            // Kaiiju start - Vanilla end teleportation
++                            Vec3 finalPos;
++                            if (this instanceof Player) finalPos = Vec3.atBottomCenterOf(targetPos.below());
++                            else finalPos = Vec3.atBottomCenterOf(targetPos);
++                            // Kaiiju end
+                             // the portal obsidian is placed at targetPos.y - 2, so if we want to place the entity
+                             // on the obsidian, we need to spawn at targetPos.y - 1
+                             portalInfoCompletable.complete(
+                                 new net.minecraft.world.level.portal.TeleportTransition(
+-                                    destination, Vec3.atBottomCenterOf(targetPos.below()), Vec3.ZERO, 90.0f, 0.0f,
++                                    destination, finalPos, this.getDeltaMovement(), 90.0f, 0.0f, // Kaiiju - Vanilla end teleportation
+                                     TeleportTransition.PLAY_PORTAL_SOUND.then(TeleportTransition.PLACE_PORTAL_TICKET),
+                                     org.bukkit.event.player.PlayerTeleportEvent.TeleportCause.END_PORTAL
+                                 )
+@@ -4478,6 +4484,10 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         if (!this.canPortalAsync(destination, takePassengers)) {
+             return false;
+         }
++        // Kaiiju start - sync end platform spawning & entity teleportation
++        final java.util.function.Consumer<Entity> tpComplete = type == PortalType.END && destination.getTypeKey() == LevelStem.END ?
++              e -> net.minecraft.world.level.levelgen.feature.EndPlatformFeature.createEndPlatform(destination, ServerLevel.END_SPAWN_POINT.below(), true, null) : teleportComplete;
++        // Kaiiju end
+ 
+         Vec3 initialPosition = this.position();
+         ChunkPos initialPositionChunk = new ChunkPos(
+@@ -4542,9 +4552,14 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+                         info.postTeleportTransition().onTransition(teleported);
+                     }
+ 
+-                    if (teleportComplete != null) {
++                    // Kaiiju start - vanilla end teleportation
++                    /*if (teleportComplete != null) {
+                         teleportComplete.accept(teleported);
++                    }*/
++                    if (tpComplete != null){
++                        tpComplete.accept(teleported);
+                     }
++                    // Kaiiju end
+                 }
+             );
+         });

luminol-server/minecraft-patches/features/0022-Kaiiju-Entity-tick-and-removal-limiter.patch

@@ -0,0 +1,52 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 11:07:08 +0800
+Subject: [PATCH] Kaiiju Entity tick and removal limiter
+
+
+diff --git a/io/papermc/paper/threadedregions/RegionizedWorldData.java b/io/papermc/paper/threadedregions/RegionizedWorldData.java
+index c6e487a4c14e6b82533881d01f32349b9ae28728..2c747cb8a724cd25c9d724908f92b320741600de 100644
+--- a/io/papermc/paper/threadedregions/RegionizedWorldData.java
++++ b/io/papermc/paper/threadedregions/RegionizedWorldData.java
+@@ -354,6 +354,7 @@ public final class RegionizedWorldData {
+     private final IteratorSafeOrderedReferenceSet<Mob> navigatingMobs = new IteratorSafeOrderedReferenceSet<>();
+     public final ReferenceList<Entity> trackerEntities = new ReferenceList<>(EMPTY_ENTITY_ARRAY); // Moonrise - entity tracker
+     public final ReferenceList<Entity> trackerUnloadedEntities = new ReferenceList<>(EMPTY_ENTITY_ARRAY); // Moonrise - entity tracker
++    public final dev.kaiijumc.kaiiju.KaiijuEntityThrottler entityThrottler = new dev.kaiijumc.kaiiju.KaiijuEntityThrottler(); // Kaiiju
+ 
+     // block ticking
+     private final ObjectLinkedOpenHashSet<BlockEventData> blockEvents = new ObjectLinkedOpenHashSet<>();
+diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
+index d34ad333b6ea3855a24a58fcd80ccf19b2bbf41c..ad121d609bcc1d9b53a1a20d4e25cf9dfa480fb8 100644
+--- a/net/minecraft/server/level/ServerLevel.java
++++ b/net/minecraft/server/level/ServerLevel.java
+@@ -808,6 +808,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             }
+ 
+             profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.ACTIVATE_ENTITIES); try { // Folia - profiler
++            if (dev.kaiijumc.kaiiju.KaiijuEntityLimits.enabled) regionizedWorldData.entityThrottler.tickLimiterStart(); // Kaiiju
+             io.papermc.paper.entity.activation.ActivationRange.activateEntities(this); // Paper - EAR
+             } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.ACTIVATE_ENTITIES); } // Folia - profiler
+             profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.ENTITY_TICK); try { // Folia - profiler
+@@ -829,6 +830,13 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+ 
+                                         entity.stopRiding();
+                                     }
++                                    // Kaiiju start
++                                    if (dev.kaiijumc.kaiiju.KaiijuEntityLimits.enabled) {
++                                        dev.kaiijumc.kaiiju.KaiijuEntityThrottler.EntityThrottlerReturn throttle = regionizedWorldData.entityThrottler.tickLimiterShouldSkip(entity);
++                                        if (throttle.remove && !entity.hasCustomName()) entity.remove(Entity.RemovalReason.DISCARDED);
++                                        if (throttle.skip) return;
++                                    }
++                                    // Kaiiju end
+ 
+                                     profilerFiller.push("tick");
+                                     this.guardEntityTick(this::tickNonPassenger, entity);
+@@ -838,6 +846,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+                         }
+                     }
+                 );
++                if (dev.kaiijumc.kaiiju.KaiijuEntityLimits.enabled) regionizedWorldData.entityThrottler.tickLimiterFinish(regionizedWorldData); // Kaiiju
+             } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.ENTITY_TICK); } // Folia - profiler
+             profilerFiller.pop();
+             profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.TILE_ENTITY); try { // Folia - profiler

luminol-server/minecraft-patches/features/0023-KioCG-Chunk-API-and-display-of-chunkhot-in-tpsbar.patch

@@ -0,0 +1,313 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 11:29:49 +0800
+Subject: [PATCH] KioCG Chunk API and display of chunkhot in tpsbar
+
+
+diff --git a/ca/spottedleaf/moonrise/paper/util/BaseChunkSystemHooks.java b/ca/spottedleaf/moonrise/paper/util/BaseChunkSystemHooks.java
+index 8d67b4629c69d3039b199aaad45533d1acde114e..f7bfeca4b11b9860241d5eb80b6df420868c7bea 100644
+--- a/ca/spottedleaf/moonrise/paper/util/BaseChunkSystemHooks.java
++++ b/ca/spottedleaf/moonrise/paper/util/BaseChunkSystemHooks.java
+@@ -136,6 +136,7 @@ public abstract class BaseChunkSystemHooks implements ca.spottedleaf.moonrise.co
+ 
+     @Override
+     public void onChunkNotTicking(final LevelChunk chunk, final ChunkHolder holder) {
++        chunk.getChunkHot().clear(); // KioCG
+         chunk.getLevel().getCurrentWorldData().removeTickingChunk(chunk.moonrise$getChunkAndHolder()); // Folia - region threading
+         ((ca.spottedleaf.moonrise.patches.chunk_tick_iteration.ChunkTickServerLevel)(ServerLevel)chunk.getLevel()).moonrise$removeChunkForPlayerTicking(chunk); // Moonrise - chunk tick iteration
+     }
+diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
+index ff71466ec0848d16121e351e30c31bb419af8b99..330af9f4de1c72387326816065350e71fe546efe 100644
+--- a/net/minecraft/server/MinecraftServer.java
++++ b/net/minecraft/server/MinecraftServer.java
+@@ -1666,7 +1666,44 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         // Folia end - region threading
+         //this.tickCount++; // Folia - region threading
+         //this.tickRateManager.tick(); // Folia - region threading
++        // KioCG start - ChunkHot
++        final ca.spottedleaf.moonrise.common.list.IteratorSafeOrderedReferenceSet<net.minecraft.world.level.chunk.LevelChunk> chunks = new ca.spottedleaf.moonrise.common.list.IteratorSafeOrderedReferenceSet<>();
++        if (region != null){
++            for (net.minecraft.server.level.ServerChunkCache.ChunkAndHolder chunkAndHolder : region.world.getCurrentWorldData().getTickingChunks()){
++                final net.minecraft.world.level.chunk.LevelChunk chunk = chunkAndHolder.chunk();
++
++                if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(region.world, chunk.locX, chunk.locZ)){
++                    continue;
++                }
++
++                chunks.add(chunk);
++            }
++        }
++        if (region != null && io.papermc.paper.threadedregions.RegionizedServer.getCurrentTick() % 20 == 0){
++            final java.util.Iterator<net.minecraft.world.level.chunk.LevelChunk> chunkIterator = chunks.unsafeIterator();
++            while (chunkIterator.hasNext()){
++                final net.minecraft.world.level.chunk.LevelChunk targetChunk = chunkIterator.next();
++
++                targetChunk.getChunkHot().nextTick();
++                targetChunk.getChunkHot().start();
++            }
++        }
++        //KioCG end
+         this.tickChildren(hasTimeLeft, region); // Folia - region threading
++        // KioCG start - ChunkHot
++        if (region != null && io.papermc.paper.threadedregions.RegionizedServer.getCurrentTick() % 20 == 0){
++            final java.util.Iterator<net.minecraft.world.level.chunk.LevelChunk> chunkIterator = chunks.unsafeIterator();
++            while (chunkIterator.hasNext()){
++                final net.minecraft.world.level.chunk.LevelChunk targetChunk = chunkIterator.next();
++
++                if (!targetChunk.getChunkHot().isStarted()){
++                    continue;
++                }
++
++                targetChunk.getChunkHot().stop();
++            }
++        }
++        //KioCG end
+         if (false && nanos - this.lastServerStatus >= STATUS_EXPIRE_TIME_NANOS) { // Folia - region threading
+             this.lastServerStatus = nanos;
+             this.status = this.buildServerStatus();
+diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
+index ad121d609bcc1d9b53a1a20d4e25cf9dfa480fb8..887a12b0b33a24f77e3dc118688f9e5b14d6f62f 100644
+--- a/net/minecraft/server/level/ServerLevel.java
++++ b/net/minecraft/server/level/ServerLevel.java
+@@ -1347,6 +1347,8 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+         final int timerId = isActive ? entity.getType().tickTimerId : entity.getType().inactiveTickTimerId;
+         final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler();
+         profiler.startTimer(timerId);
++        LevelChunk levelChunk = entity.shouldTickHot() ? this.getChunkIfLoaded(entity.moonrise$getSectionX(),entity.moonrise$getSectionZ()) : null; // KioCG
++        if (levelChunk != null) levelChunk.getChunkHot().startTicking(); try { // KioCG
+         try {
+         // Folia end - profiler
+         if (isActive) { // Paper - EAR 2
+@@ -1364,6 +1366,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+         } else {entity.inactiveTick();} // Paper - EAR 2
+         profilerFiller.pop();
+         } finally { profiler.stopTimer(timerId); } // Folia - profiler
++            } finally { if (levelChunk != null) levelChunk.getChunkHot().stopTickingAndCount(); } // KioCG
+ 
+         for (Entity entity1 : entity.getPassengers()) {
+             this.tickPassenger(entity, entity1, isActive); // Paper - EAR 2
+@@ -1383,6 +1386,8 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             final int timerId = isActive ? passengerEntity.getType().tickTimerId : passengerEntity.getType().inactiveTickTimerId;
+             final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler();
+             profiler.startTimer(timerId);
++            LevelChunk levelChunk = !(passengerEntity instanceof Player) ? this.getChunkIfLoaded(passengerEntity.blockPosition()) : null; // KioCG
++            if (levelChunk != null) levelChunk.getChunkHot().startTicking(); try { // KioCG
+             try {
+             // Folia end - profiler
+             passengerEntity.setOldPosAndRot();
+@@ -1416,6 +1421,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+                 this.tickPassenger(passengerEntity, entity, isActive); // Paper - EAR 2
+             }
+             } finally { profiler.stopTimer(timerId); } // Folia - profiler
++            } finally { if (levelChunk != null) levelChunk.getChunkHot().stopTickingAndCount(); } // KioCG
+         }
+     }
+ 
+diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
+index a07e02132bdda2693686440b9932992641cb6957..cbe7f275e7a466bd7f8ea184b22ced908b5a3d20 100644
+--- a/net/minecraft/server/level/ServerPlayer.java
++++ b/net/minecraft/server/level/ServerPlayer.java
+@@ -1007,7 +1007,34 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+         this.trackEnteredOrExitedLavaOnVehicle();
+         this.updatePlayerAttributes();
+         this.advancements.flushDirty(this);
++
++        // KioCG start - ChunkHot
++        if (this.tickCount % 20 == 0){
++            this.nearbyChunkHot = this.refreshNearbyChunkHot();
++        }
++        // KioCG end
++    }
++
++    // KioCG start - ChunkHot
++    private volatile long nearbyChunkHot = 0;
++
++    public long getNearbyChunkHot() { return this.nearbyChunkHot; }
++
++    private long refreshNearbyChunkHot() {
++        long total = 0L;
++        int searchRadius = ((ServerLevel) this.level()).moonrise$getViewDistanceHolder().getViewDistances().tickViewDistance();
++        for (int i = this.moonrise$getSectionX() - searchRadius; i <= this.moonrise$getSectionX() + searchRadius; ++i) {
++            for (int j = this.moonrise$getSectionZ() - searchRadius; j <= this.moonrise$getSectionZ() + searchRadius; ++j) {
++                net.minecraft.world.level.chunk.LevelChunk targetChunk = this.level().getChunkIfLoaded(i, j);
++                if (targetChunk != null) {
++                    total += targetChunk.getChunkHot().getAverage();
++                }
++            }
++        }
++        return total;
+     }
++    // KioCG end
++
+ 
+     private void updatePlayerAttributes() {
+         AttributeInstance attribute = this.getAttribute(Attributes.BLOCK_INTERACTION_RANGE);
+diff --git a/net/minecraft/world/entity/AreaEffectCloud.java b/net/minecraft/world/entity/AreaEffectCloud.java
+index 23b342cc31c7e72ade0e1ccad86a9ccf34380f13..249cb7326c8e4012dcffdb6bbb7bfc1f1eeb7b33 100644
+--- a/net/minecraft/world/entity/AreaEffectCloud.java
++++ b/net/minecraft/world/entity/AreaEffectCloud.java
+@@ -415,4 +415,11 @@ public class AreaEffectCloud extends Entity implements TraceableEntity {
+     public final boolean hurtServer(ServerLevel level, DamageSource damageSource, float amount) {
+         return false;
+     }
++
++    // KioCG start
++    @Override
++    public boolean shouldTickHot() {
++        return false;
++    }
++    // KioCG end
+ }
+diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
+index 8312c3bb4e0a183834279227f57da723ea46a3a9..924c9dce30b9176fb8f9ecc230e527fa609100f7 100644
+--- a/net/minecraft/world/entity/Entity.java
++++ b/net/minecraft/world/entity/Entity.java
+@@ -5963,4 +5963,6 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         return ((ServerLevel) this.level).isPositionEntityTicking(this.blockPosition());
+     }
+     // Paper end - Expose entity id counter
++
++    public boolean shouldTickHot() { return this.tickCount > 20 * 10 && this.isAlive(); } // KioCG
+ }
+diff --git a/net/minecraft/world/entity/LightningBolt.java b/net/minecraft/world/entity/LightningBolt.java
+index f003a65b34027dff14455860815c7d719c5289fa..6f9f8e52d2311343a0c0c3900a466c6a84f7de73 100644
+--- a/net/minecraft/world/entity/LightningBolt.java
++++ b/net/minecraft/world/entity/LightningBolt.java
+@@ -287,4 +287,11 @@ public class LightningBolt extends Entity {
+     public final boolean hurtServer(ServerLevel level, DamageSource damageSource, float amount) {
+         return false;
+     }
++
++    // KioCG start
++    @Override
++    public boolean shouldTickHot() {
++        return false;
++    }
++    // KioCG end
+ }
+diff --git a/net/minecraft/world/entity/Mob.java b/net/minecraft/world/entity/Mob.java
+index 6394b0899095b047ca9266135fc44aa0c32467cf..af7dbb0f2df0ec42c2c16bc58ba16b6c65d3ebcb 100644
+--- a/net/minecraft/world/entity/Mob.java
++++ b/net/minecraft/world/entity/Mob.java
+@@ -1720,4 +1720,11 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
+     public float[] getArmorDropChances() {
+         return this.armorDropChances;
+     }
++
++    // KioCG start
++    @Override
++    public boolean shouldTickHot() {
++        return super.shouldTickHot() && (!this.removeWhenFarAway(0.0) || this.isPersistenceRequired() || this.requiresCustomPersistence());
++    }
++    // KioCG end
+ }
+diff --git a/net/minecraft/world/entity/animal/horse/TraderLlama.java b/net/minecraft/world/entity/animal/horse/TraderLlama.java
+index c5b11a63bb2ab660efcc386ad9b4697e2a5efc97..f139822cb3e90b9d5fac6971e2ef1a8569d9849b 100644
+--- a/net/minecraft/world/entity/animal/horse/TraderLlama.java
++++ b/net/minecraft/world/entity/animal/horse/TraderLlama.java
+@@ -157,4 +157,11 @@ public class TraderLlama extends Llama {
+             super.start();
+         }
+     }
++
++    // KioCG start
++    @Override
++    public boolean shouldTickHot() {
++        return super.shouldTickHot() && !this.canDespawn();
++    }
++    // KioCG end
+ }
+diff --git a/net/minecraft/world/entity/npc/WanderingTrader.java b/net/minecraft/world/entity/npc/WanderingTrader.java
+index 6655d06e2011e20e7346dfe57527795269094d8a..48aa6fcb5c16fdbb4ae902cbb72c6b8e02820c88 100644
+--- a/net/minecraft/world/entity/npc/WanderingTrader.java
++++ b/net/minecraft/world/entity/npc/WanderingTrader.java
+@@ -320,4 +320,11 @@ public class WanderingTrader extends net.minecraft.world.entity.npc.AbstractVill
+             return !pos.closerToCenterThan(this.trader.position(), distance);
+         }
+     }
++
++    // KioCG start
++    @Override
++    public boolean shouldTickHot() {
++        return false;
++    }
++    // KioCG end
+ }
+diff --git a/net/minecraft/world/entity/player/Player.java b/net/minecraft/world/entity/player/Player.java
+index 7635b16cf82577a4822a5057aa5319d4c23e2168..0e020dfebe06dce4c19beb10c961ea9e8a35a415 100644
+--- a/net/minecraft/world/entity/player/Player.java
++++ b/net/minecraft/world/entity/player/Player.java
+@@ -1544,6 +1544,13 @@ public abstract class Player extends LivingEntity {
+         return true;
+     }
+ 
++    // KioCG start
++    @Override
++    public boolean shouldTickHot() {
++        return false;
++    }
++    // KioCG end
++
+     public Either<Player.BedSleepingProblem, Unit> startSleepInBed(BlockPos bedPos) {
+         // CraftBukkit start
+         return this.startSleepInBed(bedPos, false);
+diff --git a/net/minecraft/world/entity/projectile/Projectile.java b/net/minecraft/world/entity/projectile/Projectile.java
+index abfe6765faec49d4b8897608582d738c7b09522d..6e1de9252ac1236e0c5196e2511c72c0d7eb3502 100644
+--- a/net/minecraft/world/entity/projectile/Projectile.java
++++ b/net/minecraft/world/entity/projectile/Projectile.java
+@@ -516,4 +516,11 @@ public abstract class Projectile extends Entity implements TraceableEntity {
+     public interface ProjectileFactory<T extends Projectile> {
+         T create(ServerLevel level, LivingEntity owner, ItemStack spawnedFrom);
+     }
++
++    // KioCG start
++    @Override
++    public boolean shouldTickHot() {
++        return false;
++    }
++    // KioCG end
+ }
+diff --git a/net/minecraft/world/level/chunk/LevelChunk.java b/net/minecraft/world/level/chunk/LevelChunk.java
+index 78211c68bf52c0cd402fee7bcdde223130d49b5c..83b0e91165024697f6b7d41d43142b2b33641968 100644
+--- a/net/minecraft/world/level/chunk/LevelChunk.java
++++ b/net/minecraft/world/level/chunk/LevelChunk.java
+@@ -103,6 +103,7 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p
+     // Paper start - rewrite chunk system
+     private boolean postProcessingDone;
+     private net.minecraft.server.level.ServerChunkCache.ChunkAndHolder chunkAndHolder;
++    private final com.kiocg.ChunkHot chunkHot = new com.kiocg.ChunkHot(); public com.kiocg.ChunkHot getChunkHot() { return this.chunkHot; } // KioCG
+ 
+     @Override
+     public final boolean moonrise$isPostProcessingDone() {
+@@ -926,6 +927,7 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p
+                     try {
+                         ProfilerFiller profilerFiller = Profiler.get();
+                         profilerFiller.push(this::getType);
++                        LevelChunk.this.chunkHot.startTicking(); // KioCG
+                         profiler.startTimer(timerId); try { // Folia - profiler
+                         BlockState blockState = LevelChunk.this.getBlockState(blockPos);
+                         if (this.blockEntity.getType().isValid(blockState)) {
+@@ -940,7 +942,7 @@ public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.p
+                             }
+                             // Paper end - Remove the Block Entity if it's invalid
+                         }
+-                        } finally { profiler.stopTimer(timerId); } // Folia - profiler
++                        } finally { profiler.stopTimer(timerId);   LevelChunk.this.chunkHot.stopTickingAndCount(); } // Folia - profiler // KioCG
+ 
+                         profilerFiller.pop();
+                     } catch (Throwable var5) {
+diff --git a/net/minecraft/world/level/redstone/NeighborUpdater.java b/net/minecraft/world/level/redstone/NeighborUpdater.java
+index 26c15c60d358273a3b369c286771c81d6f0979dd..715580a893ba9dd34ee562b81350b81f9da3f905 100644
+--- a/net/minecraft/world/level/redstone/NeighborUpdater.java
++++ b/net/minecraft/world/level/redstone/NeighborUpdater.java
+@@ -60,7 +60,10 @@ public interface NeighborUpdater {
+                 }
+             }
+             // CraftBukkit end
++            net.minecraft.world.level.chunk.LevelChunk levelChunk = level.getChunkIfLoaded(pos); // KioCG
++            if (levelChunk != null) levelChunk.getChunkHot().startTicking(); try { // KioCG
+             state.handleNeighborChanged(level, pos, neighborBlock, orientation, movedByPiston);
++            } finally { if (levelChunk != null) levelChunk.getChunkHot().stopTickingAndCount(); } // KioCG
+             // Spigot start
+         } catch (StackOverflowError ex) {
+             level.lastPhysicsProblem = new BlockPos(pos);

luminol-server/minecraft-patches/features/0024-Purpur-use-alternative-keep-alive.patch

@@ -0,0 +1,67 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 11:43:15 +0800
+Subject: [PATCH] Purpur use alternative keep alive
+
+
+diff --git a/net/minecraft/server/network/ServerCommonPacketListenerImpl.java b/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+index 6eca15223b92aedac74233db886e2c1248750e2c..7507f32b5f0f7fbbf35eeaaf03bf9d99694c1683 100644
+--- a/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
++++ b/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+@@ -41,6 +41,7 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+     private long keepAliveChallenge;
+     private long closedListenerTime;
+     private boolean closed = false;
++    private it.unimi.dsi.fastutil.longs.LongList keepAlives = new it.unimi.dsi.fastutil.longs.LongArrayList(); // Purpur
+     private int latency;
+     private volatile boolean suspendFlushingOnServerThread = false;
+     // CraftBukkit start
+@@ -130,6 +131,16 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+ 
+     @Override
+     public void handleKeepAlive(ServerboundKeepAlivePacket packet) {
++        // Purpur start
++        if (me.earthme.luminol.config.modules.optimizations.PurpurAlternativeKeepaliveConfig.useAlternateKeepAlive) {
++            if (this.keepAlivePending && !keepAlives.isEmpty() && keepAlives.contains(packet.getId())) {
++                int ping = (int) (Util.getMillis() - packet.getId());
++                this.latency = (this.latency * 3 + ping) / 4;
++                this.keepAlivePending = false;
++                keepAlives.clear(); // we got a valid response, lets roll with it and forget the rest
++            }
++        } else
++        // Purpur end
+         if (this.keepAlivePending && packet.getId() == this.keepAliveChallenge) {
+             int i = (int)(Util.getMillis() - this.keepAliveTime);
+             this.latency = (this.latency * 3 + i) / 4;
+@@ -250,7 +261,22 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+         // Paper start - give clients a longer time to respond to pings as per pre 1.12.2 timings
+         // This should effectively place the keepalive handling back to "as it was" before 1.12.2
+         final long elapsedTime = millis - this.keepAliveTime;
+-        if (!this.isSingleplayerOwner() && elapsedTime >= 15000L) { // use vanilla's 15000L between keep alive packets
++        // Purpur start
++        if (me.earthme.luminol.config.modules.optimizations.PurpurAlternativeKeepaliveConfig.useAlternateKeepAlive) {
++            if (elapsedTime >= 1000L) { // 1 second
++                if (this.keepAlivePending && !this.processedDisconnect && keepAlives.size() * 1000L >= KEEPALIVE_LIMIT) {
++                    LOGGER.warn("{} was kicked due to keepalive timeout!", this.player.getScoreboardName());
++                    this.disconnect(ServerCommonPacketListenerImpl.TIMEOUT_DISCONNECTION_MESSAGE, org.bukkit.event.player.PlayerKickEvent.Cause.TIMEOUT);
++                } else if (this.checkIfClosed(millis)) {
++                    this.keepAlivePending = true;
++                    this.keepAliveTime = millis; // hijack this field for 1 second intervals
++                    this.keepAlives.add(millis); // currentTime is ID
++                    this.send(new ClientboundKeepAlivePacket(millis));
++                }
++            }
++        } else {
++
++            if (!this.isSingleplayerOwner() && elapsedTime >= 15000L) { // use vanilla's 15000L between keep alive packets
+             if (this.keepAlivePending) {
+                 if (!this.processedDisconnect && elapsedTime >= KEEPALIVE_LIMIT) { // check keepalive limit, don't fire if already disconnected
+                     this.disconnect(TIMEOUT_DISCONNECTION_MESSAGE, org.bukkit.event.player.PlayerKickEvent.Cause.TIMEOUT); // Paper - kick event cause
+@@ -263,6 +289,7 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+                 this.send(new ClientboundKeepAlivePacket(this.keepAliveChallenge));
+             }
+         }
++        } // Purpur end
+ 
+         Profiler.get().pop();
+     }

luminol-server/minecraft-patches/features/0025-Petal-Reduce-sensor-work.patch

@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 12:21:59 +0800
+Subject: [PATCH] Petal Reduce sensor work
+
+
+diff --git a/net/minecraft/world/entity/Mob.java b/net/minecraft/world/entity/Mob.java
+index af7dbb0f2df0ec42c2c16bc58ba16b6c65d3ebcb..53e78475e721a05e9757235d0849eae3878007cd 100644
+--- a/net/minecraft/world/entity/Mob.java
++++ b/net/minecraft/world/entity/Mob.java
+@@ -866,11 +866,11 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
+             return;
+         }
+         // Paper end - Allow nerfed mobs to jump and float
++        int i = this.tickCount + this.getId(); //Luminol - Petal - Move up
+         ProfilerFiller profilerFiller = Profiler.get();
+         profilerFiller.push("sensing");
+-        this.sensing.tick();
++        if (i % me.earthme.luminol.config.modules.optimizations.PetalReduceSensorWorkConfig.delayTicks == 0 || !me.earthme.luminol.config.modules.optimizations.PetalReduceSensorWorkConfig.enabled) this.sensing.tick(); // Luminol - Petal - Reduce sensor work
+         profilerFiller.pop();
+-        int i = this.tickCount + this.getId();
+         if (i % 2 != 0 && this.tickCount > 1) {
+             profilerFiller.push("targetSelector");
+             this.targetSelector.tickRunningGoals(false);

luminol-server/minecraft-patches/features/0026-Pufferfish-Cache-climbing-check-for-activation.patch

@@ -0,0 +1,44 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 12:25:44 +0800
+Subject: [PATCH] Pufferfish Cache climbing check for activation
+
+
+diff --git a/io/papermc/paper/entity/activation/ActivationRange.java b/io/papermc/paper/entity/activation/ActivationRange.java
+index ba8b5a0ebe652bfaf5c1498c19d12a91a192bf8e..76e0b50b2dc9c718a67f89de720a891b398cec2a 100644
+--- a/io/papermc/paper/entity/activation/ActivationRange.java
++++ b/io/papermc/paper/entity/activation/ActivationRange.java
+@@ -225,7 +225,7 @@ public final class ActivationRange {
+         }
+         // special cases.
+         if (entity instanceof final LivingEntity living) {
+-            if (living.onClimbable() || living.jumping || living.hurtTime > 0 || !living.activeEffects.isEmpty() || living.isFreezing()) {
++            if ( living.onClimableCached() || living.onClimbable() || living.jumping || living.hurtTime > 0 || !living.activeEffects.isEmpty() || living.isFreezing()) { // Pufferfish - use cached
+                 return 1;
+             }
+             if (entity instanceof final Mob mob && mob.getTarget() != null) {
+diff --git a/net/minecraft/world/entity/LivingEntity.java b/net/minecraft/world/entity/LivingEntity.java
+index d50aef6307fb854c8d4f66bb622cdafc43dce0ae..b6c820ebdc42edc1f3ce5c18eee5bff2e3822437 100644
+--- a/net/minecraft/world/entity/LivingEntity.java
++++ b/net/minecraft/world/entity/LivingEntity.java
+@@ -2044,6 +2044,20 @@ public abstract class LivingEntity extends Entity implements Attackable {
+         return this.lastClimbablePos;
+     }
+ 
++
++    // Pufferfish start
++    private boolean cachedOnClimable = false;
++    private BlockPos lastClimbingPosition = null;
++
++    public boolean onClimableCached() {
++        if (!this.blockPosition().equals(this.lastClimbingPosition)) {
++            this.cachedOnClimable = this.onClimbable();
++            this.lastClimbingPosition = this.blockPosition();
++        }
++        return this.cachedOnClimable;
++    }
++    // Pufferfish end
++
+     public boolean onClimbable() {
+         if (this.isSpectator()) {
+             return false;

luminol-server/minecraft-patches/features/0027-Pufferfish-Reduce-chunk-loading-lookups.patch

@@ -0,0 +1,31 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 12:27:17 +0800
+Subject: [PATCH] Pufferfish Reduce chunk loading & lookups
+
+
+diff --git a/net/minecraft/world/entity/monster/EnderMan.java b/net/minecraft/world/entity/monster/EnderMan.java
+index 4b5ffd278e0e9d47100e5452949e8d757bbfece4..772ccc4dc66253a84a6d24d00e271d9b4916f052 100644
+--- a/net/minecraft/world/entity/monster/EnderMan.java
++++ b/net/minecraft/world/entity/monster/EnderMan.java
+@@ -309,11 +309,18 @@ public class EnderMan extends Monster implements NeutralMob {
+     private boolean teleport(double x, double y, double z) {
+         BlockPos.MutableBlockPos mutableBlockPos = new BlockPos.MutableBlockPos(x, y, z);
+ 
+-        while (mutableBlockPos.getY() > this.level().getMinY() && !this.level().getBlockState(mutableBlockPos).blocksMotion()) {
++        // Pufferfish start - single chunk lookup
++        net.minecraft.world.level.chunk.LevelChunk chunk = this.level().getChunkIfLoaded(mutableBlockPos);
++        if (chunk == null) {
++            return false;
++        }
++        // Pufferfish end
++        while (mutableBlockPos.getY() > this.level().getMinY() && !chunk.getBlockState(mutableBlockPos).blocksMotion()) { // Pufferfish
++
+             mutableBlockPos.move(Direction.DOWN);
+         }
+ 
+-        BlockState blockState = this.level().getBlockState(mutableBlockPos);
++        BlockState blockState = chunk.getBlockState(mutableBlockPos); // Pufferfish
+         boolean flag = blockState.blocksMotion();
+         boolean isWater = blockState.getFluidState().is(FluidTags.WATER);
+         if (flag && !isWater) {

luminol-server/minecraft-patches/features/0028-Gale-Use-platform-math-functions.patch

@@ -0,0 +1,159 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 14:15:24 +0800
+Subject: [PATCH] Gale Use platform math functions
+
+License: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
+Gale - https://galemc.org
+
+This patch is based on the following patch:
+"Use Math.floor instead of fastfloor"
+By: Xymb <xymb@endcrystal.me>
+As part of: Kaiiju (https://github.com/KaiijuMC/Kaiiju)
+Licensed under: GPL-3.0 (https://www.gnu.org/licenses/gpl-3.0.html)
+
+* Comparison of floor methods used in Paper *
+
+Measure shown is floored number of milliseconds
+(nanoseconds integer-divided by 1_000_000
+taken to get the floor of 1000 randomly chosen doubles
+(all in the range of [-Integer.MAX_VALUE + 10, Integer.MAX_VALUE - 10])
+100_000 times (making it 100_000_000 floor operations total)
+and adding it to a total.
+
+We are testing the following methods:
+* net.minecraft.util.Mth.floor
+* java.lang.Math.floor
+* java.lang.StrictMath.floor
+* org.apache.commons.math3.util.FastMath.floor
+* org.apache.commons.math3.util.FastMath.floor, but with a hot start (see comment in code)
+* io.papermc.paper.util.MCUtil.fastFloor
+
+The tests performed clearly show that Math.floor is the fastest.
+This is most likely due to java.lang.Math's usage of the @IntrinsicCandidate
+annotation, which allows the JVM to use a more optimized implementation at runtime.
+However, in the case that there is no intrinsic replacement for Math.floor,
+it defers to StrictMath.floor, which relies on a number of native methods, and is
+still much faster than the existing Minecraft utility functions.
+Therefore, using Math.floor instead of these functions is better regardless.
+In Apache Commons Math 4, FastMath.floor has also been removed in favor of Math.floor.
+
+The versions used:
+* Windows 10 Home 21H2 19044.3086
+* OpenJDK Runtime Environment Temurin-19.0.2+7 (build 19.0.2+7)
+* Paper a3c760e6af1e8c7244ef75c6da6e6df278a79e14 on Minecraft 1.20.1
+* Apache Commons Math 3.6.1
+
+Results:
+Total is of type int                          Total is of type double
+----------------------------------------------------------------------------------
+Mth.floor                             2113    (double) Mth.floor              2658
+(int) Math.floor                      130     Math.floor                      194
+(int) StrictMath.floor                835     StrictMath.floor                381
+(int) FastMath.floor                  412     FastMath.floor                  376
+(int) FastMath.floor with hot start   359     FastMath.floor with hot start   321
+MCUtil.fastFloor                      2284    (double) MCUtil.fastFloor       2469
+
+Code is below:
+```java
+package somepackage;
+
+import io.papermc.paper.util.MCUtil;
+import net.minecraft.util.Mth;
+
+import java.util.Random;
+
+public class Main {
+
+    public static void main(String[] args) {
+
+				// IF FastMath.floor with a hot start:
+				// FastMath.floor(37485.5);
+
+        var random = new Random(4889338);
+        int size = 1000;
+        var values = new double[size];
+        double bound = Integer.MAX_VALUE - 10;
+        for (int i = 0; i < size; i++) {
+            values[i] = random.nextDouble(bound * 2) - bound;
+        }
+        int repeats = 100_000;
+
+        // int total = 0;
+				// OR
+				// double total = 0;
+
+        long start = System.nanoTime();
+        for (int repeat = 0; repeat < repeats; repeat++) {
+            for (int index = 0; index < size; index++) {
+                total += insert_function_being_tested_here(values[index]);
+            }
+        }
+        long diff = System.nanoTime() - start;
+        System.out.println(total);
+        System.out.println(diff / 1_000_000L);
+
+    }
+
+}
+```
+
+diff --git a/net/minecraft/util/Mth.java b/net/minecraft/util/Mth.java
+index d5d8134da9423cec199cf44762460104677194d6..e0eed27cb33348fcb46858c40014b5fe5dbaf426 100644
+--- a/net/minecraft/util/Mth.java
++++ b/net/minecraft/util/Mth.java
+@@ -58,18 +58,15 @@ public class Mth {
+     }
+ 
+     public static int floor(float value) {
+-        int i = (int)value;
+-        return value < i ? i - 1 : i;
++        return (int) Math.floor(value); // Gale - use platform math functions
+     }
+ 
+     public static int floor(double value) {
+-        int i = (int)value;
+-        return value < i ? i - 1 : i;
++        return (int) Math.floor(value); // Gale - use platform math functions
+     }
+ 
+     public static long lfloor(double value) {
+-        long l = (long)value;
+-        return value < l ? l - 1L : l;
++        return (long) Math.floor(value); // Gale - use platform math functions
+     }
+ 
+     public static float abs(float value) {
+@@ -81,13 +78,11 @@ public class Mth {
+     }
+ 
+     public static int ceil(float value) {
+-        int i = (int)value;
+-        return value > i ? i + 1 : i;
++        return (int) Math.ceil(value); // Gale - use platform math functions
+     }
+ 
+     public static int ceil(double value) {
+-        int i = (int)value;
+-        return value > i ? i + 1 : i;
++        return (int) Math.ceil(value); // Gale - use platform math functions
+     }
+ 
+     public static int clamp(int value, int min, int max) {
+@@ -123,15 +118,7 @@ public class Mth {
+     }
+ 
+     public static double absMax(double x, double y) {
+-        if (x < 0.0) {
+-            x = -x;
+-        }
+-
+-        if (y < 0.0) {
+-            y = -y;
+-        }
+-
+-        return Math.max(x, y);
++        return Math.max(Math.abs(x), Math.abs(y)); // Gale - use platform math functions
+     }
+ 
+     public static int floorDiv(int dividend, int divisor) {

luminol-server/minecraft-patches/features/0029-Gale-Variable-entity-wake-up-duration.patch

@@ -1,34 +1,14 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 17:08:22 +0800
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 15:31:52 +0800
 Subject: [PATCH] Gale Variable entity wake-up duration
 
 
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index 4f6af1fa55047e7be9e57c1dd1c60e9d96d12187..793dc5b35e9a0665d486a74ce5b776b43b941ee2 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -56,6 +56,7 @@ public class LuminolConfig {
-     public static int startDistanceSquared;
-     public static int maximumActivationPrio;
-     public static int activationDistanceMod;
-+    public static double entityWakeUpDurationRatioStandardDeviation = 0.2;
- 
- 
-     public static void init() throws IOException {
-@@ -167,6 +168,7 @@ public class LuminolConfig {
-         maxProjectileLoadsPerTick = get("optimizations.projectile.max-loads-per-tick", maxProjectileLoadsPerTick, "Controls how many chunks are allowed \nto be sync loaded by projectiles in a tick.");
-         maxProjectileLoadsPerProjectile = get("optimizations.projectile.max-loads-per-projectile", maxProjectileLoadsPerProjectile, "Controls how many chunks a projectile \n can load in its lifetime before it gets \nautomatically removed.");
-         initDAB();
-+        entityWakeUpDurationRatioStandardDeviation = get("optimizations.entity_wakeup_duration_ratio_standard_deviation",entityWakeUpDurationRatioStandardDeviation);
-     }
- 
-     public static <T> T get(String key,T def){
-diff --git a/src/main/java/org/spigotmc/ActivationRange.java b/src/main/java/org/spigotmc/ActivationRange.java
-index e77e1c60a611c49489c65d66e54236a86c3093e3..51adf24b9274b6bc78ef94e77a0b2d73b1f2bbbb 100644
---- a/src/main/java/org/spigotmc/ActivationRange.java
-+++ b/src/main/java/org/spigotmc/ActivationRange.java
-@@ -76,28 +76,40 @@ public class ActivationRange
+diff --git a/io/papermc/paper/entity/activation/ActivationRange.java b/io/papermc/paper/entity/activation/ActivationRange.java
+index 76e0b50b2dc9c718a67f89de720a891b398cec2a..e3d2371e36b48bb820931394e5b4182152f57630 100644
+--- a/io/papermc/paper/entity/activation/ActivationRange.java
++++ b/io/papermc/paper/entity/activation/ActivationRange.java
+@@ -54,27 +54,39 @@ public final class ActivationRange {
          if (entity.activationType == ActivationType.VILLAGER) {
              if (inactiveFor > config.wakeUpInactiveVillagersEvery && worldData.wakeupInactiveRemainingVillagers > 0) { // Folia - threaded regions
                  worldData.wakeupInactiveRemainingVillagers--; // Folia - threaded regions
@@ -56,13 +36,12 @@ index e77e1c60a611c49489c65d66e54236a86c3093e3..51adf24b9274b6bc78ef94e77a0b2d73
          }
          return -1;
      }
-     // Paper end
  
 +    // Gale start - variable entity wake-up duration
-+    private static final java.util.Random wakeUpDurationRandom = new java.util.Random();
++    private static final java.util.concurrent.ThreadLocalRandom wakeUpDurationRandom = java.util.concurrent.ThreadLocalRandom.current();
 +
 +    private static int getWakeUpDurationWithVariance(Entity entity, int wakeUpDuration) {
-+        double deviation = LuminolConfig.entityWakeUpDurationRatioStandardDeviation;
++        double deviation = me.earthme.luminol.config.modules.optimizations.GaleVariableEntityWakeupConfig.entityWakeUpDurationRatioStandardDeviation;
 +        if (deviation <= 0) {
 +            return wakeUpDuration;
 +        }
@@ -70,6 +49,6 @@ index e77e1c60a611c49489c65d66e54236a86c3093e3..51adf24b9274b6bc78ef94e77a0b2d73
 +    }
 +    // Gale end - variable entity wake-up duration
 +
-     static AABB maxBB = new AABB( 0, 0, 0, 0, 0, 0 );
+     //static AABB maxBB = new AABB(0, 0, 0, 0, 0, 0); // Folia - threaded regions - replaced by local variable
  
      /**

luminol-server/minecraft-patches/features/0030-Gale-Skip-entity-move-if-movement-is-zero.patch

@@ -0,0 +1,37 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 15:35:15 +0800
+Subject: [PATCH] Gale Skip entity move if movement is zero
+
+
+diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
+index 924c9dce30b9176fb8f9ecc230e527fa609100f7..f94deecb61be14ac72f8ec9842cac40993ed3185 100644
+--- a/net/minecraft/world/entity/Entity.java
++++ b/net/minecraft/world/entity/Entity.java
+@@ -1108,7 +1108,14 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     private volatile boolean preventMoving = false;
+     //Luminol end
+ 
++    private boolean boundingBoxChanged = false; // Gale - VMP - skip entity move if movement is zero
++
+     public void move(MoverType type, Vec3 movement) {
++        // Gale start - VMP - skip entity move if movement is zero
++        if (!this.boundingBoxChanged && movement.equals(Vec3.ZERO)) {
++            return;
++        }
++        // Gale end - VMP - skip entity move if movement is zero
+         final Vec3 originalMovement = movement; // Paper - Expose pre-collision velocity
+         // Paper start - detailed watchdog information
+         ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread("Cannot move an entity off-main");
+@@ -5042,6 +5049,11 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     }
+ 
+     public final void setBoundingBox(AABB bb) {
++        // Gale start - VMP - skip entity move if movement is zero
++        if (!this.bb.equals(bb)) {
++            this.boundingBoxChanged = true;
++        }
++        // Gale end - VMP - skip entity move if movement is zero
+         // CraftBukkit start - block invalid bounding boxes
+         double minX = bb.minX,
+                 minY = bb.minY,

luminol-server/minecraft-patches/features/0031-Gale-Replace-AI-attributes-with-optimized-collection.patch

@@ -0,0 +1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Wed, 22 Jan 2025 17:18:00 +0800
+Subject: [PATCH] Gale Replace AI attributes with optimized collections
+
+
+diff --git a/net/minecraft/world/entity/ai/attributes/AttributeMap.java b/net/minecraft/world/entity/ai/attributes/AttributeMap.java
+index 4c808c7ef336de74048f40bd1cc8b14131a9325d..8dfd32a8ec590c688dc8d64f18b6b59378c17880 100644
+--- a/net/minecraft/world/entity/ai/attributes/AttributeMap.java
++++ b/net/minecraft/world/entity/ai/attributes/AttributeMap.java
+@@ -19,9 +19,11 @@ import org.slf4j.Logger;
+ 
+ public class AttributeMap {
+     private static final Logger LOGGER = LogUtils.getLogger();
+-    private final Map<Holder<Attribute>, AttributeInstance> attributes = new Object2ObjectOpenHashMap<>();
+-    private final Set<AttributeInstance> attributesToSync = new ObjectOpenHashSet<>();
+-    private final Set<AttributeInstance> attributesToUpdate = new ObjectOpenHashSet<>();
++    // Gale start - Lithium - replace AI attributes with optimized collections
++    private final Map<Holder<Attribute>, AttributeInstance> attributes = new it.unimi.dsi.fastutil.objects.Reference2ReferenceOpenHashMap<>(0);
++    private final Set<AttributeInstance> attributesToSync = new it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet<>(0);
++    private final Set<AttributeInstance> attributesToUpdate = new it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet<>(0);
++    // Gale end - Lithium - replace AI attributes with optimized collections
+     private final AttributeSupplier supplier;
+ 
+     public AttributeMap(AttributeSupplier supplier) {

luminol-server/minecraft-patches/features/0032-Gale-Optimize-noise-generation.patch

@@ -0,0 +1,230 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Wed, 22 Jan 2025 17:23:16 +0800
+Subject: [PATCH] Gale Optimize noise generation
+
+
+diff --git a/net/minecraft/world/level/levelgen/synth/ImprovedNoise.java b/net/minecraft/world/level/levelgen/synth/ImprovedNoise.java
+index fb11a2eea540d55e50eab59f9857ca5d99f556f8..dcc1a3f8b611c9f103b848db90b077b984b60ada 100644
+--- a/net/minecraft/world/level/levelgen/synth/ImprovedNoise.java
++++ b/net/minecraft/world/level/levelgen/synth/ImprovedNoise.java
+@@ -11,6 +11,27 @@ public final class ImprovedNoise {
+     public final double yo;
+     public final double zo;
+ 
++    // Gale start - C2ME - optimize noise generation
++    private static final double[] FLAT_SIMPLEX_GRAD = new double[]{
++        1, 1, 0, 0,
++        -1, 1, 0, 0,
++        1, -1, 0, 0,
++        -1, -1, 0, 0,
++        1, 0, 1, 0,
++        -1, 0, 1, 0,
++        1, 0, -1, 0,
++        -1, 0, -1, 0,
++        0, 1, 1, 0,
++        0, -1, 1, 0,
++        0, 1, -1, 0,
++        0, -1, -1, 0,
++        1, 1, 0, 0,
++        0, -1, 1, 0,
++        -1, 1, 0, 0,
++        0, -1, -1, 0,
++    };
++    // Gale end - C2ME - optimize noise generation
++
+     public ImprovedNoise(RandomSource random) {
+         this.xo = random.nextDouble() * 256.0;
+         this.yo = random.nextDouble() * 256.0;
+@@ -38,9 +59,11 @@ public final class ImprovedNoise {
+         double d = x + this.xo;
+         double d1 = y + this.yo;
+         double d2 = z + this.zo;
+-        int floor = Mth.floor(d);
+-        int floor1 = Mth.floor(d1);
+-        int floor2 = Mth.floor(d2);
++        // Gale start - C2ME - optimize noise generation - optimize: remove frequent type conversions
++        double floor = Math.floor(d);
++        double floor1 = Math.floor(d1);
++        double floor2 = Math.floor(d2);
++        // Gale end - C2ME - optimize noise generation - optimize: remove frequent type conversions
+         double d3 = d - floor;
+         double d4 = d1 - floor1;
+         double d5 = d2 - floor2;
+@@ -53,25 +76,27 @@ public final class ImprovedNoise {
+                 d6 = d4;
+             }
+ 
+-            d7 = Mth.floor(d6 / yScale + 1.0E-7F) * yScale;
++            d7 = Math.floor(d6 / yScale + 1.0E-7F) * yScale; // Gale - C2ME - optimize noise generation - optimize: remove frequent type conversions
+         } else {
+             d7 = 0.0;
+         }
+ 
+-        return this.sampleAndLerp(floor, floor1, floor2, d3, d4 - d7, d5, d4);
++        return this.sampleAndLerp((int) floor, (int) floor1, (int) floor2, d3, d4 - d7, d5, d4); // Gale - C2ME - optimize noise generation - optimize: remove frequent type conversions
+     }
+ 
+     public double noiseWithDerivative(double x, double y, double z, double[] values) {
+         double d = x + this.xo;
+         double d1 = y + this.yo;
+         double d2 = z + this.zo;
+-        int floor = Mth.floor(d);
+-        int floor1 = Mth.floor(d1);
+-        int floor2 = Mth.floor(d2);
++        // Gale start - C2ME - optimize noise generation - optimize: remove frequent type conversions
++        double floor = Math.floor(d);
++        double floor1 = Math.floor(d1);
++        double floor2 = Math.floor(d2);
++        // Gale end - C2ME - optimize noise generation - optimize: remove frequent type conversions
+         double d3 = d - floor;
+         double d4 = d1 - floor1;
+         double d5 = d2 - floor2;
+-        return this.sampleWithDerivative(floor, floor1, floor2, d3, d4, d5, values);
++        return this.sampleWithDerivative((int) floor, (int) floor1, (int) floor2, d3, d4, d5, values); // Gale - C2ME - optimize noise generation - optimize: remove frequent type conversions
+     }
+ 
+     private static double gradDot(int gradIndex, double xFactor, double yFactor, double zFactor) {
+@@ -83,24 +108,69 @@ public final class ImprovedNoise {
+     }
+ 
+     private double sampleAndLerp(int gridX, int gridY, int gridZ, double deltaX, double weirdDeltaY, double deltaZ, double deltaY) {
+-        int i = this.p(gridX);
+-        int i1 = this.p(gridX + 1);
+-        int i2 = this.p(i + gridY);
+-        int i3 = this.p(i + gridY + 1);
+-        int i4 = this.p(i1 + gridY);
+-        int i5 = this.p(i1 + gridY + 1);
+-        double d = gradDot(this.p(i2 + gridZ), deltaX, weirdDeltaY, deltaZ);
+-        double d1 = gradDot(this.p(i4 + gridZ), deltaX - 1.0, weirdDeltaY, deltaZ);
+-        double d2 = gradDot(this.p(i3 + gridZ), deltaX, weirdDeltaY - 1.0, deltaZ);
+-        double d3 = gradDot(this.p(i5 + gridZ), deltaX - 1.0, weirdDeltaY - 1.0, deltaZ);
+-        double d4 = gradDot(this.p(i2 + gridZ + 1), deltaX, weirdDeltaY, deltaZ - 1.0);
+-        double d5 = gradDot(this.p(i4 + gridZ + 1), deltaX - 1.0, weirdDeltaY, deltaZ - 1.0);
+-        double d6 = gradDot(this.p(i3 + gridZ + 1), deltaX, weirdDeltaY - 1.0, deltaZ - 1.0);
+-        double d7 = gradDot(this.p(i5 + gridZ + 1), deltaX - 1.0, weirdDeltaY - 1.0, deltaZ - 1.0);
+-        double d8 = Mth.smoothstep(deltaX);
+-        double d9 = Mth.smoothstep(deltaY);
+-        double d10 = Mth.smoothstep(deltaZ);
+-        return Mth.lerp3(d8, d9, d10, d, d1, d2, d3, d4, d5, d6, d7);
++        // Gale start - C2ME - optimize noise generation - inline math & small optimization: remove frequent type conversions and redundant ops
++        final int var0 = gridX & 0xFF;
++        final int var1 = (gridX + 1) & 0xFF;
++        final int var2 = this.p[var0] & 0xFF;
++        final int var3 = this.p[var1] & 0xFF;
++        final int var4 = (var2 + gridY) & 0xFF;
++        final int var5 = (var3 + gridY) & 0xFF;
++        final int var6 = (var2 + gridY + 1) & 0xFF;
++        final int var7 = (var3 + gridY + 1) & 0xFF;
++        final int var8 = this.p[var4] & 0xFF;
++        final int var9 = this.p[var5] & 0xFF;
++        final int var10 = this.p[var6] & 0xFF;
++        final int var11 = this.p[var7] & 0xFF;
++
++        final int var12 = (var8 + gridZ) & 0xFF;
++        final int var13 = (var9 + gridZ) & 0xFF;
++        final int var14 = (var10 + gridZ) & 0xFF;
++        final int var15 = (var11 + gridZ) & 0xFF;
++        final int var16 = (var8 + gridZ + 1) & 0xFF;
++        final int var17 = (var9 + gridZ + 1) & 0xFF;
++        final int var18 = (var10 + gridZ + 1) & 0xFF;
++        final int var19 = (var11 + gridZ + 1) & 0xFF;
++        final int var20 = (this.p[var12] & 15) << 2;
++        final int var21 = (this.p[var13] & 15) << 2;
++        final int var22 = (this.p[var14] & 15) << 2;
++        final int var23 = (this.p[var15] & 15) << 2;
++        final int var24 = (this.p[var16] & 15) << 2;
++        final int var25 = (this.p[var17] & 15) << 2;
++        final int var26 = (this.p[var18] & 15) << 2;
++        final int var27 = (this.p[var19] & 15) << 2;
++        final double var60 = deltaX - 1.0;
++        final double var61 = weirdDeltaY - 1.0;
++        final double var62 = deltaZ - 1.0;
++        final double var87 = FLAT_SIMPLEX_GRAD[(var20) | 0] * deltaX + FLAT_SIMPLEX_GRAD[(var20) | 1] * weirdDeltaY + FLAT_SIMPLEX_GRAD[(var20) | 2] * deltaZ;
++        final double var88 = FLAT_SIMPLEX_GRAD[(var21) | 0] * var60 + FLAT_SIMPLEX_GRAD[(var21) | 1] * weirdDeltaY + FLAT_SIMPLEX_GRAD[(var21) | 2] * deltaZ;
++        final double var89 = FLAT_SIMPLEX_GRAD[(var22) | 0] * deltaX + FLAT_SIMPLEX_GRAD[(var22) | 1] * var61 + FLAT_SIMPLEX_GRAD[(var22) | 2] * deltaZ;
++        final double var90 = FLAT_SIMPLEX_GRAD[(var23) | 0] * var60 + FLAT_SIMPLEX_GRAD[(var23) | 1] * var61 + FLAT_SIMPLEX_GRAD[(var23) | 2] * deltaZ;
++        final double var91 = FLAT_SIMPLEX_GRAD[(var24) | 0] * deltaX + FLAT_SIMPLEX_GRAD[(var24) | 1] * weirdDeltaY + FLAT_SIMPLEX_GRAD[(var24) | 2] * var62;
++        final double var92 = FLAT_SIMPLEX_GRAD[(var25) | 0] * var60 + FLAT_SIMPLEX_GRAD[(var25) | 1] * weirdDeltaY + FLAT_SIMPLEX_GRAD[(var25) | 2] * var62;
++        final double var93 = FLAT_SIMPLEX_GRAD[(var26) | 0] * deltaX + FLAT_SIMPLEX_GRAD[(var26) | 1] * var61 + FLAT_SIMPLEX_GRAD[(var26) | 2] * var62;
++        final double var94 = FLAT_SIMPLEX_GRAD[(var27) | 0] * var60 + FLAT_SIMPLEX_GRAD[(var27) | 1] * var61 + FLAT_SIMPLEX_GRAD[(var27) | 2] * var62;
++
++        final double var95 = deltaX * 6.0 - 15.0;
++        final double var96 = deltaY * 6.0 - 15.0;
++        final double var97 = deltaZ * 6.0 - 15.0;
++        final double var98 = deltaX * var95 + 10.0;
++        final double var99 = deltaY * var96 + 10.0;
++        final double var100 = deltaZ * var97 + 10.0;
++        final double var101 = deltaX * deltaX * deltaX * var98;
++        final double var102 = deltaY * deltaY * deltaY * var99;
++        final double var103 = deltaZ * deltaZ * deltaZ * var100;
++
++        final double var113 = var87 + var101 * (var88 - var87);
++        final double var114 = var93 + var101 * (var94 - var93);
++        final double var115 = var91 + var101 * (var92 - var91);
++        final double var116 = var89 + var101 * (var90 - var89);
++        final double var117 = var114 - var115;
++        final double var118 = var102 * (var116 - var113);
++        final double var119 = var102 * var117;
++        final double var120 = var113 + var118;
++        final double var121 = var115 + var119;
++        return var120 + (var103 * (var121 - var120));
++        // Gale end - C2ME - optimize noise generation - inline math & small optimization: remove frequent type conversions and redundant ops
+     }
+ 
+     private double sampleWithDerivative(int gridX, int gridY, int gridZ, double deltaX, double deltaY, double deltaZ, double[] noiseValues) {
+diff --git a/net/minecraft/world/level/levelgen/synth/PerlinNoise.java b/net/minecraft/world/level/levelgen/synth/PerlinNoise.java
+index da3c26fbad32d75d71f7e59c8c3341316a754756..2c28bb2fed04542a2ee126fe0c1c1f0253a3e2eb 100644
+--- a/net/minecraft/world/level/levelgen/synth/PerlinNoise.java
++++ b/net/minecraft/world/level/levelgen/synth/PerlinNoise.java
+@@ -26,6 +26,10 @@ public class PerlinNoise {
+     private final double lowestFreqValueFactor;
+     private final double lowestFreqInputFactor;
+     private final double maxValue;
++    // Gale start - C2ME - optimize noise generation
++    private final int octaveSamplersCount;
++    private final double [] amplitudesArray;
++    // Gale end - C2ME - optimize noise generation
+ 
+     @Deprecated
+     public static PerlinNoise createLegacyForBlendedNoise(RandomSource random, IntStream octaves) {
+@@ -127,6 +131,10 @@ public class PerlinNoise {
+         this.lowestFreqInputFactor = Math.pow(2.0, -i);
+         this.lowestFreqValueFactor = Math.pow(2.0, size - 1) / (Math.pow(2.0, size) - 1.0);
+         this.maxValue = this.edgeValue(2.0);
++        // Gale start - C2ME - optimize noise generation
++        this.octaveSamplersCount = this.noiseLevels.length;
++        this.amplitudesArray = this.amplitudes.toDoubleArray();
++        // Gale end - C2ME - optimize noise generation
+     }
+ 
+     protected double maxValue() {
+@@ -138,7 +146,27 @@ public class PerlinNoise {
+     }
+ 
+     public double getValue(double x, double y, double z) {
+-        return this.getValue(x, y, z, 0.0, 0.0, false);
++        // Gale start - C2ME - optimize noise generation - optimize for common cases
++        double d = 0.0;
++        double e = this.lowestFreqInputFactor;
++        double f = this.lowestFreqValueFactor;
++
++        for (int i = 0; i < this.octaveSamplersCount; ++i) {
++            ImprovedNoise perlinNoiseSampler = this.noiseLevels[i];
++            if (perlinNoiseSampler != null) {
++                @SuppressWarnings("deprecation")
++                double g = perlinNoiseSampler.noise(
++                    wrap(x * e), wrap(y * e), wrap(z * e), 0.0, 0.0
++                );
++                d += this.amplitudesArray[i] * g * f;
++            }
++
++            e *= 2.0;
++            f /= 2.0;
++        }
++
++        return d;
++        // Gale end - C2ME - optimize noise generation - optimize for common cases
+     }
+ 
+     @Deprecated

luminol-server/minecraft-patches/features/0033-SparklyPaper-Optimize-canSee-checks.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 15:35:43 +0800
+Subject: [PATCH] SparklyPaper Optimize canSee checks
+
+
+diff --git a/net/minecraft/server/level/ChunkMap.java b/net/minecraft/server/level/ChunkMap.java
+index 5c507be097051de9a43a31bbc6190c3db7688667..7eff847790394aecd058e7a61905da86163b4c6e 100644
+--- a/net/minecraft/server/level/ChunkMap.java
++++ b/net/minecraft/server/level/ChunkMap.java
+@@ -1224,7 +1224,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+                 }
+                 // Folia end - region threading
+                 // CraftBukkit start - respect vanish API
+-                if (flag && (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(player) || !player.getBukkitEntity().canSee(this.entity.getBukkitEntity()))) { // Paper - only consider hits // Folia - region threading
++                if (flag && (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(player) || !player.getBukkitEntity().canSeeChunkMapUpdatePlayer(this.entity.getBukkitEntity()))) { // Paper - only consider hits // Folia - region threading // SparklyPaper - optimize canSee checks
+                     flag = false;
+                 }
+                 // CraftBukkit end

luminol-server/minecraft-patches/features/0034-SparklyPaper-Skip-distanceToSqr-call-in-ServerEntity.patch

@@ -0,0 +1,28 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 15:37:25 +0800
+Subject: [PATCH] SparklyPaper Skip "distanceToSqr" call in
+ "ServerEntity#sendChanges" if the delta movement hasn't changed
+
+
+diff --git a/net/minecraft/server/level/ServerEntity.java b/net/minecraft/server/level/ServerEntity.java
+index 0fb253aa55a24b56b17f524b3261c5b75c7d7e59..1de43a4969a2a4535239b15a7bc30d99eb6934c6 100644
+--- a/net/minecraft/server/level/ServerEntity.java
++++ b/net/minecraft/server/level/ServerEntity.java
+@@ -195,6 +195,8 @@ public class ServerEntity {
+ 
+                 if (this.entity.hasImpulse || this.trackDelta || this.entity instanceof LivingEntity && ((LivingEntity)this.entity).isFallFlying()) {
+                     Vec3 deltaMovement = this.entity.getDeltaMovement();
++
++                    if (deltaMovement != this.lastSentMovement) { // SparklyPaper start - skip distanceToSqr call in ServerEntity#sendChanges if the delta movement hasn't changed
+                     double d = deltaMovement.distanceToSqr(this.lastSentMovement);
+                     if (d > 1.0E-7 || d > 0.0 && deltaMovement.lengthSqr() == 0.0) {
+                         this.lastSentMovement = deltaMovement;
+@@ -212,6 +214,7 @@ public class ServerEntity {
+                             this.broadcast.accept(new ClientboundSetEntityMotionPacket(this.entity.getId(), this.lastSentMovement));
+                         }
+                     }
++                    } // SparklyPaper end
+                 }
+ 
+                 if (packet != null) {

luminol-server/minecraft-patches/features/0035-Leaf-Secure-seed-and-matter-seed-command.patch

@@ -0,0 +1,419 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Tue, 28 Jan 2025 18:56:53 +0800
+Subject: [PATCH] Leaf Secure seed and matter seed command
+
+
+diff --git a/net/minecraft/server/commands/SeedCommand.java b/net/minecraft/server/commands/SeedCommand.java
+index a65affc41a4fc299bc2281f0f53f2e075633899d..f071e469468b768bd9c063d78c222b1b3e3b13bd 100644
+--- a/net/minecraft/server/commands/SeedCommand.java
++++ b/net/minecraft/server/commands/SeedCommand.java
+@@ -12,6 +12,17 @@ public class SeedCommand {
+             long seed = context.getSource().getLevel().getSeed();
+             Component component = ComponentUtils.copyOnClickText(String.valueOf(seed));
+             context.getSource().sendSuccess(() -> Component.translatable("commands.seed.success", component), false);
++
++            // Leaf start - Matter - SecureSeed Command
++            if (me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled) {
++                su.plo.matter.Globals.setupGlobals(context.getSource().getLevel());
++                String seedStr = su.plo.matter.Globals.seedToString(su.plo.matter.Globals.worldSeed);
++                Component featureSeedComponent = ComponentUtils.copyOnClickText(seedStr);
++
++                context.getSource().sendSuccess(() -> Component.translatable(("Feature seed: %s"), featureSeedComponent), false);
++            }
++            // Leaf end - Matter - SecureSeed Command
++
+             return (int)seed;
+         }));
+     }
+diff --git a/net/minecraft/server/dedicated/DedicatedServerProperties.java b/net/minecraft/server/dedicated/DedicatedServerProperties.java
+index f6518e29f805018c72222f5aaa7b662071665b65..8d082996a0f361cfd12af6a2138efd7057732fc8 100644
+--- a/net/minecraft/server/dedicated/DedicatedServerProperties.java
++++ b/net/minecraft/server/dedicated/DedicatedServerProperties.java
+@@ -113,7 +113,17 @@ public class DedicatedServerProperties extends Settings<DedicatedServerPropertie
+         String string = this.get("level-seed", "");
+         boolean flag = this.get("generate-structures", true);
+         long l = WorldOptions.parseSeed(string).orElse(WorldOptions.randomSeed());
+-        this.worldOptions = new WorldOptions(l, flag, false);
++        // Leaf start - Matter - Secure Seed
++        if (me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled) {
++            String featureSeedStr = this.get("feature-level-seed", "");
++            long[] featureSeed = su.plo.matter.Globals.parseSeed(featureSeedStr)
++                .orElse(su.plo.matter.Globals.createRandomWorldSeed());
++
++            this.worldOptions = new WorldOptions(l, featureSeed, flag, false);
++        } else {
++            this.worldOptions = new WorldOptions(l, flag, false);
++        }
++        // Leaf end - Matter - Secure Seed
+         this.worldDimensionData = new DedicatedServerProperties.WorldDimensionData(
+             this.get("generator-settings", property -> GsonHelper.parse(!property.isEmpty() ? property : "{}"), new JsonObject()),
+             this.get("level-type", property -> property.toLowerCase(Locale.ROOT), WorldPresets.NORMAL.location().toString())
+diff --git a/net/minecraft/server/level/ServerChunkCache.java b/net/minecraft/server/level/ServerChunkCache.java
+index ac06b8a4813716a8d136be5731cbd96113976a7e..82d95005fc67336458b50c47d44ec4047fffcd1e 100644
+--- a/net/minecraft/server/level/ServerChunkCache.java
++++ b/net/minecraft/server/level/ServerChunkCache.java
+@@ -680,6 +680,7 @@ public class ServerChunkCache extends ChunkSource implements ca.spottedleaf.moon
+     }
+ 
+     public ChunkGenerator getGenerator() {
++        su.plo.matter.Globals.setupGlobals(level); // Leaf - Matter - Secure Seed
+         return this.chunkMap.generator();
+     }
+ 
+diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
+index 887a12b0b33a24f77e3dc118688f9e5b14d6f62f..12f6c929c0168ea5b3242ff7139f1eac8b4e3a4b 100644
+--- a/net/minecraft/server/level/ServerLevel.java
++++ b/net/minecraft/server/level/ServerLevel.java
+@@ -620,6 +620,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             chunkGenerator = new org.bukkit.craftbukkit.generator.CustomChunkGenerator(this, chunkGenerator, gen);
+         }
+         // CraftBukkit end
++        su.plo.matter.Globals.setupGlobals(this); // Leaf - Matter - Secure Seed
+         boolean flag = server.forceSynchronousWrites();
+         DataFixer fixerUpper = server.getFixerUpper();
+         // Paper - rewrite chunk system
+diff --git a/net/minecraft/world/entity/monster/Slime.java b/net/minecraft/world/entity/monster/Slime.java
+index 8db4cba1be6d7a5538295ba8da1fdaf7a77a16d0..25ef938623e2e4f65f6554731b756995638e4231 100644
+--- a/net/minecraft/world/entity/monster/Slime.java
++++ b/net/minecraft/world/entity/monster/Slime.java
+@@ -340,7 +340,12 @@ public class Slime extends Mob implements Enemy {
+             }
+ 
+             ChunkPos chunkPos = new ChunkPos(pos);
+-            boolean flag = level.getMinecraftWorld().paperConfig().entities.spawning.allChunksAreSlimeChunks || WorldgenRandom.seedSlimeChunk(chunkPos.x, chunkPos.z, ((WorldGenLevel) level).getSeed(), level.getMinecraftWorld().spigotConfig.slimeSeed).nextInt(10) == 0; // Spigot // Paper
++            // Leaf start - Matter - Secure Seed
++            boolean isSlimeChunk = me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled
++                ? level.getChunk(chunkPos.x, chunkPos.z).isSlimeChunk()
++                : WorldgenRandom.seedSlimeChunk(chunkPos.x, chunkPos.z, ((WorldGenLevel) level).getSeed(), level.getMinecraftWorld().spigotConfig.slimeSeed).nextInt(10) == 0; // Spigot // Paper
++            boolean flag = level.getMinecraftWorld().paperConfig().entities.spawning.allChunksAreSlimeChunks || isSlimeChunk;
++            // Leaf end - Matter - Secure Seed
+                 // Paper start - Replace rules for Height in Slime Chunks
+                 final double maxHeightSlimeChunk = level.getMinecraftWorld().paperConfig().entities.spawning.slimeSpawnHeight.slimeChunk.maximum;
+                 if (random.nextInt(10) == 0 && flag && pos.getY() < maxHeightSlimeChunk) {
+diff --git a/net/minecraft/world/level/chunk/ChunkAccess.java b/net/minecraft/world/level/chunk/ChunkAccess.java
+index 6d565b52552534ce9cacfc35ad1bf4adcb69eac3..3a6db5bc0c8be7d68e15317a621c1965fdc3a9bd 100644
+--- a/net/minecraft/world/level/chunk/ChunkAccess.java
++++ b/net/minecraft/world/level/chunk/ChunkAccess.java
+@@ -87,6 +87,10 @@ public abstract class ChunkAccess implements BiomeManager.NoiseBiomeSource, Ligh
+     public org.bukkit.craftbukkit.persistence.DirtyCraftPersistentDataContainer persistentDataContainer = new org.bukkit.craftbukkit.persistence.DirtyCraftPersistentDataContainer(ChunkAccess.DATA_TYPE_REGISTRY);
+     // CraftBukkit end
+     public final Registry<Biome> biomeRegistry; // CraftBukkit
++    // Leaf start - Matter - Secure Seed
++    private boolean slimeChunk;
++    private boolean hasComputedSlimeChunk;
++    // Leaf end - Matter - Secure Seed
+ 
+     // Paper start - rewrite chunk system
+     private volatile ca.spottedleaf.moonrise.patches.starlight.light.SWMRNibbleArray[] blockNibbles;
+@@ -191,6 +195,17 @@ public abstract class ChunkAccess implements BiomeManager.NoiseBiomeSource, Ligh
+         return GameEventListenerRegistry.NOOP;
+     }
+ 
++    // Leaf start - Matter - Secure Seed
++    public boolean isSlimeChunk() {
++        if (!hasComputedSlimeChunk) {
++            hasComputedSlimeChunk = true;
++            slimeChunk = su.plo.matter.WorldgenCryptoRandom.seedSlimeChunk(chunkPos.x, chunkPos.z).nextInt(10) == 0;
++        }
++
++        return slimeChunk;
++    }
++    // Leaf end - Matter - Secure Seed
++
+     public abstract BlockState getBlockState(final int x, final int y, final int z); // Paper
+     @Nullable
+     public abstract BlockState setBlockState(BlockPos pos, BlockState state, boolean isMoving);
+diff --git a/net/minecraft/world/level/chunk/ChunkGenerator.java b/net/minecraft/world/level/chunk/ChunkGenerator.java
+index b85c547f281c58bf45c9062d0b886cb4ff7b386b..55df64f9069496010841bfc373887d27fc5c2162 100644
+--- a/net/minecraft/world/level/chunk/ChunkGenerator.java
++++ b/net/minecraft/world/level/chunk/ChunkGenerator.java
+@@ -343,7 +343,11 @@ public abstract class ChunkGenerator {
+             Registry<Structure> registry = level.registryAccess().lookupOrThrow(Registries.STRUCTURE);
+             Map<Integer, List<Structure>> map = registry.stream().collect(Collectors.groupingBy(structure1 -> structure1.step().ordinal()));
+             List<FeatureSorter.StepFeatureData> list = this.featuresPerStep.get();
+-            WorldgenRandom worldgenRandom = new WorldgenRandom(new XoroshiroRandomSource(RandomSupport.generateUniqueSeed()));
++            // Leaf start - Matter - Secure Seed
++            WorldgenRandom worldgenRandom = me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled
++                ? new su.plo.matter.WorldgenCryptoRandom(blockPos.getX(), blockPos.getZ(), su.plo.matter.Globals.Salt.UNDEFINED, 0)
++                : new WorldgenRandom(new XoroshiroRandomSource(RandomSupport.generateUniqueSeed()));
++            // Leaf end - Matter - Secure Seed
+             long l = worldgenRandom.setDecorationSeed(level.getSeed(), blockPos.getX(), blockPos.getZ());
+             Set<Holder<Biome>> set = new ObjectArraySet<>();
+             ChunkPos.rangeClosed(sectionPos.chunk(), 1).forEach(chunkPos -> {
+@@ -556,8 +560,15 @@ public abstract class ChunkGenerator {
+                         } else {
+                             ArrayList<StructureSet.StructureSelectionEntry> list1 = new ArrayList<>(list.size());
+                             list1.addAll(list);
+-                            WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L));
+-                            worldgenRandom.setLargeFeatureSeed(structureState.getLevelSeed(), pos.x, pos.z);
++                            // Leaf start - Matter - Secure Seed
++                            WorldgenRandom worldgenRandom;
++                            if (me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled) {
++                                worldgenRandom = new su.plo.matter.WorldgenCryptoRandom(pos.x, pos.z, su.plo.matter.Globals.Salt.GENERATE_FEATURE, 0);
++                            } else {
++                                worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L));
++                                worldgenRandom.setLargeFeatureSeed(structureState.getLevelSeed(), pos.x, pos.z);
++                            }
++                            // Leaf end - Matter - Secure Seed
+                             int i = 0;
+ 
+                             for (StructureSet.StructureSelectionEntry structureSelectionEntry1 : list1) {
+diff --git a/net/minecraft/world/level/chunk/ChunkGeneratorStructureState.java b/net/minecraft/world/level/chunk/ChunkGeneratorStructureState.java
+index 619b98e42e254c0c260c171a26a2472ddf59b885..7abafc6f9f89159277ff84aa79a2edc4abcd7da3 100644
+--- a/net/minecraft/world/level/chunk/ChunkGeneratorStructureState.java
++++ b/net/minecraft/world/level/chunk/ChunkGeneratorStructureState.java
+@@ -205,7 +205,12 @@ public class ChunkGeneratorStructureState {
+             List<CompletableFuture<ChunkPos>> list = new ArrayList<>(count);
+             int spread = placement.spread();
+             HolderSet<Biome> holderSet = placement.preferredBiomes();
+-            RandomSource randomSource = RandomSource.create();
++            // Leaf start - Matter - Secure Seed
++            RandomSource randomSource = me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled
++                ? new su.plo.matter.WorldgenCryptoRandom(0, 0, su.plo.matter.Globals.Salt.STRONGHOLDS, 0)
++                : RandomSource.create();
++            // Leaf end - Matter - Secure Seed
++            if (!me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled) {
+             // Paper start - Add missing structure set seed configs
+             if (this.conf.strongholdSeed != null && structureSet.is(net.minecraft.world.level.levelgen.structure.BuiltinStructureSets.STRONGHOLDS)) {
+                 randomSource.setSeed(this.conf.strongholdSeed);
+@@ -213,6 +218,7 @@ public class ChunkGeneratorStructureState {
+             // Paper end - Add missing structure set seed configs
+             randomSource.setSeed(this.concentricRingsSeed);
+             } // Paper - Add missing structure set seed configs
++            } // Leaf - Matter - Secure Seed
+             double d = randomSource.nextDouble() * Math.PI * 2.0;
+             int i = 0;
+             int i1 = 0;
+diff --git a/net/minecraft/world/level/chunk/status/ChunkStep.java b/net/minecraft/world/level/chunk/status/ChunkStep.java
+index b8348976e80578d9eff64eea68c04c603fed49ad..bc5c6ea1f1e4f1608a70116f03fb2a58ca3252c3 100644
+--- a/net/minecraft/world/level/chunk/status/ChunkStep.java
++++ b/net/minecraft/world/level/chunk/status/ChunkStep.java
+@@ -60,6 +60,7 @@ public final class ChunkStep implements ca.spottedleaf.moonrise.patches.chunk_sy
+     }
+ 
+     public CompletableFuture<ChunkAccess> apply(WorldGenContext worldGenContext, StaticCache2D<GenerationChunkHolder> cache, ChunkAccess chunk) {
++        su.plo.matter.Globals.setupGlobals(worldGenContext.level()); // Leaf - Matter - Secure Seed
+         if (chunk.getPersistedStatus().isBefore(this.targetStatus)) {
+             ProfiledDuration profiledDuration = JvmProfiler.INSTANCE
+                 .onChunkGenerate(chunk.getPos(), worldGenContext.level().dimension(), this.targetStatus.getName());
+diff --git a/net/minecraft/world/level/levelgen/WorldOptions.java b/net/minecraft/world/level/levelgen/WorldOptions.java
+index c92508741439a8d0d833ea02d0104416adb83c92..a4063fe0c8e113f0fbd751b84aefaaad68e08ca0 100644
+--- a/net/minecraft/world/level/levelgen/WorldOptions.java
++++ b/net/minecraft/world/level/levelgen/WorldOptions.java
+@@ -9,8 +9,20 @@ import net.minecraft.util.RandomSource;
+ import org.apache.commons.lang3.StringUtils;
+ 
+ public class WorldOptions {
++    // Leaf start - Matter - Secure Seed
++    private static final com.google.gson.Gson gson = new com.google.gson.Gson();
++    private static final boolean isSecureSeedEnabled = me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled;
+     public static final MapCodec<WorldOptions> CODEC = RecordCodecBuilder.mapCodec(
+-        instance -> instance.group(
++        instance -> isSecureSeedEnabled
++            ? instance.group(
++                Codec.LONG.fieldOf("seed").stable().forGetter(WorldOptions::seed),
++                Codec.STRING.fieldOf("feature_seed").orElse(gson.toJson(su.plo.matter.Globals.createRandomWorldSeed())).stable().forGetter(WorldOptions::featureSeedSerialize),
++                Codec.BOOL.fieldOf("generate_features").orElse(true).stable().forGetter(WorldOptions::generateStructures),
++                Codec.BOOL.fieldOf("bonus_chest").orElse(false).stable().forGetter(WorldOptions::generateBonusChest),
++                Codec.STRING.lenientOptionalFieldOf("legacy_custom_options").stable().forGetter(worldOptions -> worldOptions.legacyCustomOptions)
++            )
++            .apply(instance, instance.stable(WorldOptions::new))
++            : instance.group(
+                 Codec.LONG.fieldOf("seed").stable().forGetter(WorldOptions::seed),
+                 Codec.BOOL.fieldOf("generate_features").orElse(true).stable().forGetter(WorldOptions::generateStructures),
+                 Codec.BOOL.fieldOf("bonus_chest").orElse(false).stable().forGetter(WorldOptions::generateBonusChest),
+@@ -18,8 +30,14 @@ public class WorldOptions {
+             )
+             .apply(instance, instance.stable(WorldOptions::new))
+     );
+-    public static final WorldOptions DEMO_OPTIONS = new WorldOptions("North Carolina".hashCode(), true, true);
++    // Leaf end - Matter - Secure Seed
++    // Leaf start - Matter - Secure Seed
++    public static final WorldOptions DEMO_OPTIONS = isSecureSeedEnabled
++            ? new WorldOptions((long) "North Carolina".hashCode(), su.plo.matter.Globals.createRandomWorldSeed(), true, true)
++            : new WorldOptions("North Carolina".hashCode(), true, true);
++    // Leaf end - Matter - Secure Seed
+     private final long seed;
++    private long[] featureSeed = su.plo.matter.Globals.createRandomWorldSeed(); // Leaf - Matter - Secure Seed
+     private final boolean generateStructures;
+     private final boolean generateBonusChest;
+     private final Optional<String> legacyCustomOptions;
+@@ -28,14 +46,35 @@ public class WorldOptions {
+         this(seed, generateStructures, generateBonusChest, Optional.empty());
+     }
+ 
++    // Leaf start - Matter - Secure Seed
++    public WorldOptions(long seed, long[] featureSeed, boolean generateStructures, boolean bonusChest) {
++        this(seed, featureSeed, generateStructures, bonusChest, Optional.empty());
++    }
++
++    private WorldOptions(long seed, String featureSeedJson, boolean generateStructures, boolean bonusChest, Optional<String> legacyCustomOptions) {
++        this(seed, gson.fromJson(featureSeedJson, long[].class), generateStructures, bonusChest, legacyCustomOptions);
++    }
++    // Leaf end - Matter - Secure Seed
++
+     public static WorldOptions defaultWithRandomSeed() {
+-        return new WorldOptions(randomSeed(), true, false);
++        // Leaf start - Matter - Secure Seed
++        return isSecureSeedEnabled
++                ? new WorldOptions(randomSeed(), su.plo.matter.Globals.createRandomWorldSeed(), true, false)
++                : new WorldOptions(randomSeed(), true, false);
++        // Leaf end - Matter - Secure Seed
+     }
+ 
+     public static WorldOptions testWorldWithRandomSeed() {
+         return new WorldOptions(randomSeed(), false, false);
+     }
+ 
++    // Leaf start - Matter - Secure Seed
++    private WorldOptions(long seed, long[] featureSeed, boolean generateStructures, boolean bonusChest, Optional<String> legacyCustomOptions) {
++        this(seed, generateStructures, bonusChest, legacyCustomOptions);
++        this.featureSeed = featureSeed;
++    }
++    // Leaf end - Matter - Secure Seed
++
+     private WorldOptions(long seed, boolean generateStructures, boolean generateBonusChest, Optional<String> legacyCustomOptions) {
+         this.seed = seed;
+         this.generateStructures = generateStructures;
+@@ -47,6 +86,16 @@ public class WorldOptions {
+         return this.seed;
+     }
+ 
++    // Leaf start - Matter - Secure Seed
++    public long[] featureSeed() {
++        return this.featureSeed;
++    }
++
++    private String featureSeedSerialize() {
++        return gson.toJson(this.featureSeed);
++    }
++    // Leaf end - Matter - Secure Seed
++
+     public boolean generateStructures() {
+         return this.generateStructures;
+     }
+@@ -59,17 +108,25 @@ public class WorldOptions {
+         return this.legacyCustomOptions.isPresent();
+     }
+ 
++    // Leaf start - Matter -  Secure Seed
+     public WorldOptions withBonusChest(boolean generateBonusChest) {
+-        return new WorldOptions(this.seed, this.generateStructures, generateBonusChest, this.legacyCustomOptions);
++        return isSecureSeedEnabled
++                ? new WorldOptions(this.seed, this.featureSeed, this.generateStructures, generateBonusChest, this.legacyCustomOptions)
++                : new WorldOptions(this.seed, this.generateStructures, generateBonusChest, this.legacyCustomOptions);
+     }
+ 
+     public WorldOptions withStructures(boolean generateStructures) {
+-        return new WorldOptions(this.seed, generateStructures, this.generateBonusChest, this.legacyCustomOptions);
++        return isSecureSeedEnabled
++                ? new WorldOptions(this.seed, this.featureSeed, generateStructures, this.generateBonusChest, this.legacyCustomOptions)
++                : new WorldOptions(this.seed, generateStructures, this.generateBonusChest, this.legacyCustomOptions);
+     }
+ 
+     public WorldOptions withSeed(OptionalLong seed) {
+-        return new WorldOptions(seed.orElse(randomSeed()), this.generateStructures, this.generateBonusChest, this.legacyCustomOptions);
++        return isSecureSeedEnabled
++                ? new WorldOptions(seed.orElse(randomSeed()), su.plo.matter.Globals.createRandomWorldSeed(), this.generateStructures, this.generateBonusChest, this.legacyCustomOptions)
++                : new WorldOptions(seed.orElse(randomSeed()), this.generateStructures, this.generateBonusChest, this.legacyCustomOptions);
+     }
++    // Leaf end - Matter - Secure Seed
+ 
+     public static OptionalLong parseSeed(String seed) {
+         seed = seed.trim();
+diff --git a/net/minecraft/world/level/levelgen/feature/GeodeFeature.java b/net/minecraft/world/level/levelgen/feature/GeodeFeature.java
+index 38475f6975533909924c8d54f438cf43cdfe31a3..db58fa5d2ee42711ae5ab8b7384fccdfe756e2dc 100644
+--- a/net/minecraft/world/level/levelgen/feature/GeodeFeature.java
++++ b/net/minecraft/world/level/levelgen/feature/GeodeFeature.java
+@@ -41,7 +41,11 @@ public class GeodeFeature extends Feature<GeodeConfiguration> {
+         int i1 = geodeConfiguration.maxGenOffset;
+         List<Pair<BlockPos, Integer>> list = Lists.newLinkedList();
+         int i2 = geodeConfiguration.distributionPoints.sample(randomSource);
+-        WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(worldGenLevel.getSeed()));
++        // Leaf start - Matter - Secure Seed
++        WorldgenRandom worldgenRandom = me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled
++                ? new su.plo.matter.WorldgenCryptoRandom(0, 0, su.plo.matter.Globals.Salt.GEODE_FEATURE, 0)
++                : new WorldgenRandom(new LegacyRandomSource(worldGenLevel.getSeed()));
++        // Leaf end - Matter - Secure Seed
+         NormalNoise normalNoise = NormalNoise.create(worldgenRandom, -4, 1.0);
+         List<BlockPos> list1 = Lists.newLinkedList();
+         double d = (double)i2 / geodeConfiguration.outerWallDistance.getMaxValue();
+diff --git a/net/minecraft/world/level/levelgen/structure/Structure.java b/net/minecraft/world/level/levelgen/structure/Structure.java
+index 8328e864c72b7a358d6bb1f33459b8c4df2ecb1a..05a0e97edd828ce998226fd651929b04bbb461f7 100644
+--- a/net/minecraft/world/level/levelgen/structure/Structure.java
++++ b/net/minecraft/world/level/levelgen/structure/Structure.java
+@@ -249,6 +249,11 @@ public abstract class Structure {
+         }
+ 
+         private static WorldgenRandom makeRandom(long seed, ChunkPos chunkPos) {
++            // Leaf start - Matter - Secure Seed
++            if (me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled) {
++                return new su.plo.matter.WorldgenCryptoRandom(chunkPos.x, chunkPos.z, su.plo.matter.Globals.Salt.GENERATE_FEATURE, seed);
++            }
++            // Leaf end - Matter - Secure Seed
+             WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L));
+             worldgenRandom.setLargeFeatureSeed(seed, chunkPos.x, chunkPos.z);
+             return worldgenRandom;
+diff --git a/net/minecraft/world/level/levelgen/structure/placement/RandomSpreadStructurePlacement.java b/net/minecraft/world/level/levelgen/structure/placement/RandomSpreadStructurePlacement.java
+index ee0d9dddb36b6879fa113299e24f1aa3b2b151cc..8a93a4eb0a4935af169ff4d4108a8c6e715187bd 100644
+--- a/net/minecraft/world/level/levelgen/structure/placement/RandomSpreadStructurePlacement.java
++++ b/net/minecraft/world/level/levelgen/structure/placement/RandomSpreadStructurePlacement.java
+@@ -67,8 +67,15 @@ public class RandomSpreadStructurePlacement extends StructurePlacement {
+     public ChunkPos getPotentialStructureChunk(long seed, int regionX, int regionZ) {
+         int i = Math.floorDiv(regionX, this.spacing);
+         int i1 = Math.floorDiv(regionZ, this.spacing);
+-        WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L));
+-        worldgenRandom.setLargeFeatureWithSalt(seed, i, i1, this.salt());
++        // Leaf start - Matter - Secure Seed
++        WorldgenRandom worldgenRandom;
++        if (me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled) {
++            worldgenRandom = new su.plo.matter.WorldgenCryptoRandom(i, i1, su.plo.matter.Globals.Salt.POTENTIONAL_FEATURE, this.salt);
++        } else {
++            worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L));
++            worldgenRandom.setLargeFeatureWithSalt(seed, i, i1, this.salt());
++        }
++        // Leaf end - Matter - Secure Seed
+         int i2 = this.spacing - this.separation;
+         int i3 = this.spreadType.evaluate(worldgenRandom, i2);
+         int i4 = this.spreadType.evaluate(worldgenRandom, i2);
+diff --git a/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java b/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java
+index 670335a7bbfbc9da64c389977498c22dfcd03251..d684a7c8e6455a9154b16e2c8bca5217cd1f597a 100644
+--- a/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java
++++ b/net/minecraft/world/level/levelgen/structure/placement/StructurePlacement.java
+@@ -118,8 +118,16 @@ public abstract class StructurePlacement {
+     public abstract StructurePlacementType<?> type();
+ 
+     private static boolean probabilityReducer(long levelSeed, int regionX, int regionZ, int salt, float probability, @org.jetbrains.annotations.Nullable Integer saltOverride) { // Paper - Add missing structure set seed configs; ignore here
+-        WorldgenRandom worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L));
+-        worldgenRandom.setLargeFeatureWithSalt(levelSeed, regionX, regionZ, salt);
++        // Leaf start - Matter - Secure Seed
++        WorldgenRandom worldgenRandom;
++        if (me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled) {
++            worldgenRandom = new su.plo.matter.WorldgenCryptoRandom(regionX, regionZ, su.plo.matter.Globals.Salt.UNDEFINED, salt);
++        } else {
++            worldgenRandom = new WorldgenRandom(new LegacyRandomSource(0L));
++            worldgenRandom.setLargeFeatureWithSalt(levelSeed, salt, regionX, regionZ);
++        }
++        // Leaf end - Matter - Secure Seed
++
+         return worldgenRandom.nextFloat() < probability;
+     }
+ 
+diff --git a/net/minecraft/world/level/levelgen/structure/pools/JigsawPlacement.java b/net/minecraft/world/level/levelgen/structure/pools/JigsawPlacement.java
+index eb85edaa3b7fab4f11545b0fa8bfea882dedb67d..a5b8abc06adbfcbffccfc005a625b952d8729470 100644
+--- a/net/minecraft/world/level/levelgen/structure/pools/JigsawPlacement.java
++++ b/net/minecraft/world/level/levelgen/structure/pools/JigsawPlacement.java
+@@ -64,7 +64,11 @@ public class JigsawPlacement {
+         ChunkGenerator chunkGenerator = context.chunkGenerator();
+         StructureTemplateManager structureTemplateManager = context.structureTemplateManager();
+         LevelHeightAccessor levelHeightAccessor = context.heightAccessor();
+-        WorldgenRandom worldgenRandom = context.random();
++        // Leaf start - Matter - Secure Seed
++        WorldgenRandom worldgenRandom = me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled
++            ? new su.plo.matter.WorldgenCryptoRandom(context.chunkPos().x, context.chunkPos().z, su.plo.matter.Globals.Salt.JIGSAW_PLACEMENT, 0)
++            : context.random();
++        // Leaf end - Matter - Secure Seed
+         Registry<StructureTemplatePool> registry = registryAccess.lookupOrThrow(Registries.TEMPLATE_POOL);
+         Rotation random = Rotation.getRandom(worldgenRandom);
+         StructureTemplatePool structureTemplatePool = startPool.unwrapKey()

luminol-server/minecraft-patches/features/0036-Tick-regions-api.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Mon, 27 Jan 2025 13:01:55 +0800
+Subject: [PATCH] Tick regions api
+
+
+diff --git a/io/papermc/paper/threadedregions/ThreadedRegionizer.java b/io/papermc/paper/threadedregions/ThreadedRegionizer.java
+index 604385af903845d966382ad0a4168798e4ed4a0e..7ac803ba9706b65a0125b6e00983fe6a7947991a 100644
+--- a/io/papermc/paper/threadedregions/ThreadedRegionizer.java
++++ b/io/papermc/paper/threadedregions/ThreadedRegionizer.java
+@@ -819,7 +819,7 @@ public final class ThreadedRegionizer<R extends ThreadedRegionizer.ThreadedRegio
+             return this.deadSections.size() == this.sectionByKey.size();
+         }
+ 
+-        private final double getDeadSectionPercent() {
++        public final double getDeadSectionPercent() { // Luminol - Threaded regions api
+             return (double)this.deadSections.size() / (double)this.sectionByKey.size();
+         }
+ 

luminol-server/paper-patches/features/0002-Add-luminol-config-framework.patch

@@ -0,0 +1,571 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:15:53 +0800
+Subject: [PATCH] Add luminol config framework
+
+
+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
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/ConfigInfo.java
+@@ -0,0 +1,11 @@
++package me.earthme.luminol.config;
++
++import java.lang.annotation.Retention;
++import java.lang.annotation.RetentionPolicy;
++
++@Retention(RetentionPolicy.RUNTIME)
++public @interface ConfigInfo {
++    String baseName();
++
++    String comments() default "";
++}
+diff --git a/src/main/java/me/earthme/luminol/config/DoNotLoad.java b/src/main/java/me/earthme/luminol/config/DoNotLoad.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..fffc5eb4be4b78a886f3c340bd60f3a2b0108a7d
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/DoNotLoad.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 DoNotLoad {
++}
+diff --git a/src/main/java/me/earthme/luminol/config/EnumConfigCategory.java b/src/main/java/me/earthme/luminol/config/EnumConfigCategory.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..7b75405c468d24ed8aea5aa54ae5ac339118bf60
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/EnumConfigCategory.java
+@@ -0,0 +1,19 @@
++package me.earthme.luminol.config;
++
++public enum EnumConfigCategory {
++    OPTIMIZATIONS("optimizations"),
++    FIXES("fixes"),
++    MISC("misc"),
++    GAMEPLAY("gameplay"),
++    EXPERIMENT("experiment");
++
++    private final String baseKeyName;
++
++    EnumConfigCategory(String baseKeyName) {
++        this.baseKeyName = baseKeyName;
++    }
++
++    public String getBaseKeyName() {
++        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
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/IConfigModule.java
+@@ -0,0 +1,22 @@
++package me.earthme.luminol.config;
++
++import com.electronwill.nightconfig.core.file.CommentedFileConfig;
++import org.jetbrains.annotations.NotNull;
++
++public interface IConfigModule {
++
++    EnumConfigCategory getCategory();
++
++    String getBaseName();
++
++    default void onLoaded(CommentedFileConfig configInstance) {}
++
++    default <T> T get(String keyName, T defaultValue, @NotNull CommentedFileConfig config){
++        if (!config.contains(keyName)){
++            config.set(keyName,defaultValue);
++            return defaultValue;
++        }
++
++        return config.get(keyName);
++    }
++}
+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..526b68e184a2f6f9e38cd02995b473a943404141
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/LuminolConfig.java
+@@ -0,0 +1,226 @@
++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.jetbrains.annotations.Contract;
++import org.jetbrains.annotations.NotNull;
++import java.io.File;
++import java.io.IOException;
++import java.lang.reflect.Field;
++import java.lang.reflect.InvocationTargetException;
++import java.lang.reflect.Modifier;
++import java.net.JarURLConnection;
++import java.net.URL;
++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;
++import org.apache.logging.log4j.LogManager;
++import org.apache.logging.log4j.Logger;
++
++public class LuminolConfig {
++    public static final Logger logger = LogManager.getLogger();
++    private static final File baseConfigFolder = new File("luminol_config");
++    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;
++
++    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 {
++            preLoadConfig();
++            finalizeLoadConfig();
++        }catch (Exception e){
++            logger.error(e);
++        }
++    }
++
++    @Contract(" -> new")
++    public static @NotNull CompletableFuture<Void> reloadAsync(){
++        return CompletableFuture.runAsync(LuminolConfig::reload,task -> RegionizedServer.getInstance().addTask(() -> {
++            try{
++                task.run();
++            }catch (Exception e){
++                logger.error(e);
++            }
++        }));
++    }
++
++    public static void dropAllInstanced(){
++        allInstanced.clear();
++    }
++
++    public static void finalizeLoadConfig() {
++        for (IConfigModule module : allInstanced) {
++            module.onLoaded(configFileInstance);
++        }
++    }
++
++    public static void preLoadConfig() throws IOException {
++        baseConfigFolder.mkdirs();
++
++        if (!baseConfigFile.exists()){
++            baseConfigFile.createNewFile();
++        }
++
++        configFileInstance = CommentedFileConfig.ofConcurrent(baseConfigFile);
++
++        configFileInstance.load();
++
++        try {
++            instanceAllModule();
++            loadAllModules();
++        }catch (Exception e){
++            logger.error("Failed to load config modules!",e);
++            throw new RuntimeException(e);
++        }
++
++        configFileInstance.save();
++    }
++
++    private static void loadAllModules() throws IllegalAccessException {
++        for (IConfigModule instanced : allInstanced){
++            loadForSingle(instanced);
++        }
++    }
++
++    private static void instanceAllModule() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
++        for (Class<?> clazz  : getClasses("me.earthme.luminol.config.modules")){
++            if (IConfigModule.class.isAssignableFrom(clazz)){
++                allInstanced.add((IConfigModule) clazz.getConstructor().newInstance());
++            }
++        }
++    }
++
++    private static void loadForSingle(@NotNull IConfigModule singleConfigModule) throws IllegalAccessException {
++        final EnumConfigCategory category = singleConfigModule.getCategory();
++
++        Field[] fields = singleConfigModule.getClass().getDeclaredFields();
++
++        for (Field field : fields) {
++            int modifiers = field.getModifiers();
++            if (Modifier.isStatic(modifiers) && !Modifier.isFinal(modifiers)) {
++                boolean skipLoad = field.getAnnotation(DoNotLoad.class) != null || (alreadyInited && field.getAnnotation(HotReloadUnsupported.class) != null);
++                ConfigInfo configInfo = field.getAnnotation(ConfigInfo.class);
++
++                if (skipLoad || configInfo == null){
++                    continue;
++                }
++
++                final String fullConfigKeyName = category.getBaseKeyName() + "." + singleConfigModule.getBaseName() + "." + configInfo.baseName();
++
++                field.setAccessible(true);
++                final Object currentValue = field.get(null);
++
++                if (!configFileInstance.contains(fullConfigKeyName)){
++                    if (currentValue == null){
++                        throw new UnsupportedOperationException("Config " + singleConfigModule.getBaseName() + "tried to add an null default value!");
++                    }
++
++                    final String comments = configInfo.comments();
++
++                    if (!comments.isBlank()){
++                        configFileInstance.setComment(fullConfigKeyName,comments);
++                    }
++
++                    configFileInstance.add(fullConfigKeyName,currentValue);
++                    continue;
++                }
++
++                final Object actuallyValue = configFileInstance.get(fullConfigKeyName);
++                field.set(null,actuallyValue);
++            }
++        }
++    }
++
++    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()) {
++                URL url = dirs.nextElement();
++                String protocol = url.getProtocol();
++                if ("file".equals(protocol)) {
++                    String filePath = URLDecoder.decode(url.getFile(), StandardCharsets.UTF_8);
++                    findClassesInPackageByFile(pack, filePath, classes);
++                } else if ("jar".equals(protocol)) {
++                    JarFile jar;
++                    try {
++                        jar = ((JarURLConnection) url.openConnection()).getJarFile();
++                        Enumeration<JarEntry> entries = jar.entries();
++                        findClassesInPackageByJar(pack, entries, packageDirName, classes);
++                    } catch (IOException e) {
++                        throw new RuntimeException(e);
++                    }
++                }
++            }
++        } catch (IOException e) {
++            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) {
++                if (file.isDirectory()) {
++                    findClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), classes);
++                } else {
++                    String className = file.getName().substring(0, file.getName().length() - 6);
++                    try {
++                        classes.add(Class.forName(packageName + '.' + className));
++                    } catch (ClassNotFoundException e) {
++                        throw new RuntimeException(e);
++                    }
++                }
++            }
++        }
++    }
++
++    private static void findClassesInPackageByJar(String packageName, Enumeration<JarEntry> entries, String packageDirName, Set<Class<?>> classes) {
++        while (entries.hasMoreElements()) {
++            JarEntry entry = entries.nextElement();
++            String name = entry.getName();
++            if (name.charAt(0) == '/') {
++                name = name.substring(1);
++            }
++            if (name.startsWith(packageDirName)) {
++                int idx = name.lastIndexOf('/');
++                if (idx != -1) {
++                    packageName = name.substring(0, idx).replace('/', '.');
++                }
++                if (name.endsWith(".class") && !entry.isDirectory()) {
++                    String className = name.substring(packageName.length() + 1, name.length() - 6);
++                    try {
++                        classes.add(Class.forName(packageName + '.' + className));
++                    } catch (ClassNotFoundException e) {
++                        throw new RuntimeException(e);
++                    }
++                }
++            }
++        }
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/utils/NullPlugin.java b/src/main/java/me/earthme/luminol/utils/NullPlugin.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..de94c8e39f0ae0da80d5a79af63413e287f5d190
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/utils/NullPlugin.java
+@@ -0,0 +1,152 @@
++package me.earthme.luminol.utils;
++
++import io.papermc.paper.plugin.configuration.PluginMeta;
++import io.papermc.paper.plugin.lifecycle.event.LifecycleEventManager;
++import org.bukkit.Server;
++import org.bukkit.command.Command;
++import org.bukkit.command.CommandSender;
++import org.bukkit.configuration.file.FileConfiguration;
++import org.bukkit.generator.BiomeProvider;
++import org.bukkit.generator.ChunkGenerator;
++import org.bukkit.plugin.*;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++import java.io.File;
++import java.io.InputStream;
++import java.util.List;
++import java.util.logging.Logger;
++
++public class NullPlugin  extends PluginBase {
++    private boolean enabled = true;
++
++    private final String pluginName;
++    private PluginDescriptionFile pdf;
++
++    public NullPlugin() {
++        this.pluginName = "Minecraft";
++        pdf = new PluginDescriptionFile(pluginName, "1.0", "nms");
++    }
++
++    public void setEnabled(boolean enabled) {
++        this.enabled = enabled;
++    }
++
++    @Override
++    public File getDataFolder() {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public PluginDescriptionFile getDescription() {
++        return pdf;
++    }
++    // Paper start
++    @Override
++    public io.papermc.paper.plugin.configuration.PluginMeta getPluginMeta() {
++        return pdf;
++    }
++    // Paper end
++
++    @Override
++    public FileConfiguration getConfig() {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public InputStream getResource(String filename) {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public void saveConfig() {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public void saveDefaultConfig() {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public void saveResource(String resourcePath, boolean replace) {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public void reloadConfig() {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public PluginLogger getLogger() {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public PluginLoader getPluginLoader() {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public Server getServer() {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public boolean isEnabled() {
++        return enabled;
++    }
++
++    @Override
++    public void onDisable() {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public void onLoad() {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public void onEnable() {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public boolean isNaggable() {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public void setNaggable(boolean canNag) {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public ChunkGenerator getDefaultWorldGenerator(String worldName, String id) {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public @Nullable BiomeProvider getDefaultBiomeProvider(@NotNull String worldName, @Nullable String id) {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    @Override
++    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++
++    // Paper start - lifecycle events
++    @Override
++    public @NotNull io.papermc.paper.plugin.lifecycle.event.LifecycleEventManager<org.bukkit.plugin.Plugin> getLifecycleManager() {
++        throw new UnsupportedOperationException("Not supported.");
++    }
++    // Paper end - lifecycle events
++}
+\ No newline at end of file

luminol-server/paper-patches/features/0003-Add-config-for-server-mod-name.patch

@@ -0,0 +1,48 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:17:53 +0800
+Subject: [PATCH] Add config for server mod name
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/network/PaperServerListPingEventImpl.java b/src/main/java/com/destroystokyo/paper/network/PaperServerListPingEventImpl.java
+index 6ed2114f577ce12d2d493985e798609c7d83f15e..7a5dcf3b7108794b9a224004730eb396a96cce8f 100644
+--- a/src/main/java/com/destroystokyo/paper/network/PaperServerListPingEventImpl.java
++++ b/src/main/java/com/destroystokyo/paper/network/PaperServerListPingEventImpl.java
+@@ -14,7 +14,7 @@ class PaperServerListPingEventImpl extends PaperServerListPingEvent {
+ 
+     PaperServerListPingEventImpl(MinecraftServer server, StatusClient client, int protocolVersion, @Nullable CachedServerIcon icon) {
+         super(client, server.motd(), server.getPlayerCount(), server.getMaxPlayers(),
+-                server.getServerModName() + ' ' + server.getServerVersion(), protocolVersion, icon);
++                me.earthme.luminol.config.modules.misc.ServerModNameConfig.fakeVanilla ? server.getServerVersion() : server.getServerModName() + ' ' + server.getServerVersion(), protocolVersion, icon);//Luminol - Fake vanilla mode
+         this.server = server;
+     }
+ 
+diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/ServerModNameConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/ServerModNameConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..94e7c8910e3623163528a844fd7a08b3ffe5826b
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/ServerModNameConfig.java
+@@ -0,0 +1,23 @@
++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 ServerModNameConfig implements IConfigModule {
++    @ConfigInfo(baseName = "name")
++    public static String serverModName = "Luminol";
++
++    @ConfigInfo(baseName = "vanilla_spoof")
++    public static boolean fakeVanilla = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "server_mod_name";
++    }
++}

luminol-server/paper-patches/features/0004-Add-config-for-unsafe-teleportation.patch

@@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:23:14 +0800
+Subject: [PATCH] Add config for unsafe teleportation
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/fixes/UnsafeTeleportationConfig.java b/src/main/java/me/earthme/luminol/config/modules/fixes/UnsafeTeleportationConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..865ffe0051d84ac9018ab54a54894c2fe8fd573e
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/fixes/UnsafeTeleportationConfig.java
+@@ -0,0 +1,22 @@
++package me.earthme.luminol.config.modules.fixes;
++
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++
++public class UnsafeTeleportationConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled", comments = "Allow non player entities enter end portals if enabled.\n" +
++            "If you want to use sand duping,please turn on this.\n" +
++            "Warning: This would cause some unsafe issues, you could learn more on : https://github.com/PaperMC/Folia/issues/297")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.FIXES;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "allow_unsafe_teleportation";
++    }
++}

luminol-server/paper-patches/features/0005-Add-config-for-vanilla-random.patch

@@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:24:51 +0800
+Subject: [PATCH] Add config for vanilla random
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/fixes/VanillaRandomSourceConfig.java b/src/main/java/me/earthme/luminol/config/modules/fixes/VanillaRandomSourceConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0e6bfc03be660415c333024b56ac6565e3b61ab1
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/fixes/VanillaRandomSourceConfig.java
+@@ -0,0 +1,20 @@
++package me.earthme.luminol.config.modules.fixes;
++
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++
++public class VanillaRandomSourceConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enable_for_player_entity",comments = "Related with RNG cracks")
++    public static boolean useLegacyRandomSourceForPlayers = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.FIXES;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "use_vanilla_random_source";
++    }
++}

luminol-server/paper-patches/features/0006-Add-a-simple-tpsbar.patch

@@ -0,0 +1,361 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:27:31 +0800
+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..01677f210fae53a108bfe194189cb4c233e9fa47
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/commands/TpsBarCommand.java
+@@ -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;
++import org.jetbrains.annotations.NotNull;
++
++public class TpsBarCommand extends Command {
++    public TpsBarCommand(@NotNull String name) {
++        super(name);
++        this.setPermission("luminol.commands.tpsbar");
++        this.setDescription("Show the tps and mspt through a bossbar");
++        this.setUsage("/tpsbar");
++    }
++
++    @Override
++    public boolean execute(@NotNull CommandSender sender, @NotNull String commandLabel, @NotNull String[] args) {
++        if (!testPermission(sender)){
++            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(Component.text("Only player can use this command!").color(TextColor.color(255,0,0)));
++            return true;
++        }
++
++        if (GlobalServerTpsBar.isPlayerVisible(player)) {
++            player.sendMessage(Component.text("Disabled tps bar").color(TextColor.color(0,255,0)));
++            GlobalServerTpsBar.setVisibilityForPlayer(player,false);
++            return true;
++        }
++
++        player.sendMessage(Component.text("Enabled tps bar").color(TextColor.color(0,255,0)));
++        GlobalServerTpsBar.setVisibilityForPlayer(player,true);
++
++        return true;
++    }
++}
+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..aafb2f5052c7c8e5971a47308253badb3027093c
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/TpsBarConfig.java
+@@ -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.*;
++import me.earthme.luminol.functions.GlobalServerTpsBar;
++import org.bukkit.Bukkit;
++
++import java.util.List;
++
++public class TpsBarConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean tpsbarEnabled = false;
++    @ConfigInfo(baseName = "format")
++    public static String tpsBarFormat = "<gray>TPS<yellow>:</yellow> <tps> MSPT<yellow>:</yellow> <mspt> Ping<yellow>:</yellow> <ping>ms";
++    @ConfigInfo(baseName = "tps_color_list")
++    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() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "tpsbar";
++    }
++
++    @Override
++    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..de2f03d6e771c09e8da2da454b7ec4a16c0a17ab
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/functions/GlobalServerTpsBar.java
+@@ -0,0 +1,214 @@
++package me.earthme.luminol.functions;
++
++import com.google.common.collect.Maps;
++import com.mojang.logging.LogUtils;
++import io.papermc.paper.threadedregions.ThreadedRegionizer;
++import io.papermc.paper.threadedregions.TickData;
++import io.papermc.paper.threadedregions.TickRegionScheduler;
++import io.papermc.paper.threadedregions.TickRegions;
++import io.papermc.paper.threadedregions.scheduler.ScheduledTask;
++import me.earthme.luminol.config.modules.misc.TpsBarConfig;
++import me.earthme.luminol.utils.NullPlugin;
++import net.kyori.adventure.bossbar.BossBar;
++import net.kyori.adventure.text.Component;
++import net.kyori.adventure.text.minimessage.MiniMessage;
++import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
++import org.bukkit.Bukkit;
++import org.bukkit.craftbukkit.entity.CraftPlayer;
++import org.bukkit.entity.Player;
++import org.jetbrains.annotations.NotNull;
++import org.slf4j.Logger;
++
++import java.util.*;
++
++public class GlobalServerTpsBar {
++    protected static final NullPlugin NULL_PLUGIN = new NullPlugin();
++    protected static final Map<UUID, BossBar> uuid2Bossbars = Maps.newConcurrentMap();
++    protected static final Map<UUID, ScheduledTask> scheduledTasks = new HashMap<>();
++
++    protected static volatile ScheduledTask scannerTask = null;
++    private static final Logger logger = LogUtils.getLogger();
++
++    public static void init(){
++        cancelBarUpdateTask();
++
++        scannerTask = Bukkit.getGlobalRegionScheduler().runAtFixedRate(NULL_PLUGIN, unused -> {
++            try {
++                update();
++                cleanUp();
++            }catch (Exception e){
++                logger.error(e.getLocalizedMessage());
++            }
++        }, 1, TpsBarConfig.updateInterval);
++    }
++
++    public static void cancelBarUpdateTask(){
++        if (scannerTask == null || scannerTask.isCancelled()){
++            return;
++        }
++
++        scannerTask.cancel();
++
++        for (ScheduledTask task : scheduledTasks.values()) {
++            if (!task.isCancelled()) {
++                task.cancel();
++            }
++        }
++    }
++
++    public static boolean isPlayerVisible(Player player){
++        return ((CraftPlayer) player).getHandle().isTpsBarVisible;
++    }
++
++    public static void setVisibilityForPlayer(Player target,boolean canSee){
++        ((CraftPlayer) target).getHandle().isTpsBarVisible = canSee;
++    }
++
++    private static void update(){
++        for (Player player : Bukkit.getOnlinePlayers()) {
++            scheduledTasks.computeIfAbsent(player.getUniqueId(), unused -> createBossBarForPlayer(player));
++        }
++    }
++
++    private static void cleanUp() {
++        final List<UUID> toCleanUp = new ArrayList<>();
++
++        for (Map.Entry<UUID, ScheduledTask> toCheck : scheduledTasks.entrySet()) {
++            if (toCheck.getValue().isCancelled()) {
++                toCleanUp.add(toCheck.getKey());
++            }
++        }
++
++        for (UUID uuid : toCleanUp) {
++            scheduledTasks.remove(uuid);
++        }
++    }
++
++    public static ScheduledTask createBossBarForPlayer(@NotNull Player apiPlayer) {
++        final UUID playerUUID = apiPlayer.getUniqueId();
++
++        return apiPlayer.getScheduler().runAtFixedRate(NULL_PLUGIN, (n) -> {
++            if (!isPlayerVisible(apiPlayer)) {
++                final BossBar removed = uuid2Bossbars.remove(playerUUID);
++
++                if (removed != null) {
++                    apiPlayer.hideBossBar(removed);
++                }
++                return;
++            }
++
++            final ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> region = TickRegionScheduler.getCurrentRegion();
++            final TickData.TickReportData reportData = region.getData().getRegionSchedulingHandle().getTickReport5s(System.nanoTime());
++
++
++            BossBar targetBossbar = uuid2Bossbars.computeIfAbsent(
++                    playerUUID,
++                    unused -> BossBar.bossBar(Component.text(""),0.0F, BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(3)), BossBar.Overlay.NOTCHED_20)
++            );
++
++            apiPlayer.showBossBar(targetBossbar);
++
++            if (reportData != null){
++                final TickData.SegmentData tpsData = reportData.tpsData().segmentAll();
++                final double mspt = reportData.timePerTickData().segmentAll().average() / 1.0E6;
++
++                updateTpsBar(tpsData.average(), mspt, targetBossbar, apiPlayer);
++            }
++        }, () -> {
++            final BossBar removed = uuid2Bossbars.remove(playerUUID); // Auto clean up it
++
++            if (removed != null) {
++                apiPlayer.hideBossBar(removed);
++            }
++        }, 1, TpsBarConfig.updateInterval);
++    }
++
++    private static void updateTpsBar(double tps, double mspt, @NotNull BossBar bar, @NotNull Player player){
++        bar.name(MiniMessage.miniMessage().deserialize(
++                TpsBarConfig.tpsBarFormat,
++                Placeholder.component("tps",getTpsComponent(tps)),
++                Placeholder.component("mspt",getMsptComponent(mspt)),
++                Placeholder.component("ping",getPingComponent(player.getPing()))
++        ));
++        bar.color(barColorFromTps(tps));
++        bar.progress((float) Math.min((float)1,Math.max(mspt / 50,0)));
++    }
++
++    private static @NotNull Component getPingComponent(int ping){
++        final BossBar.Color colorBukkit = barColorFromPing(ping);
++        final String colorString = colorBukkit.name();
++
++        final String content = "<%s><text></%s>";
++        final String replaced = String.format(content,colorString,colorString);
++
++        return MiniMessage.miniMessage().deserialize(replaced,Placeholder.parsed("text", String.valueOf(ping)));
++    }
++
++    private static BossBar.Color barColorFromPing(int ping){
++        if (ping == -1){
++            return BossBar.Color.valueOf(TpsBarConfig.pingColors.get(3));
++        }
++
++        if (ping <= 80){
++            return BossBar.Color.valueOf(TpsBarConfig.pingColors.get(0));
++        }
++
++        if (ping <= 160){
++            return BossBar.Color.valueOf(TpsBarConfig.pingColors.get(1));
++        }
++
++        return BossBar.Color.valueOf(TpsBarConfig.pingColors.get(2));
++    }
++
++    private static @NotNull Component getMsptComponent(double mspt){
++        final BossBar.Color colorBukkit = barColorFromMspt(mspt);
++        final String colorString = colorBukkit.name();
++
++        final String content = "<%s><text></%s>";
++        final String replaced = String.format(content,colorString,colorString);
++
++        return MiniMessage.miniMessage().deserialize(replaced,Placeholder.parsed("text", String.format("%.2f", mspt)));
++    }
++
++    private static BossBar.Color barColorFromMspt(double mspt){
++        if (mspt == -1){
++            return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(3));
++        }
++
++        if (mspt <= 25){
++            return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(0));
++        }
++
++        if (mspt <= 50){
++            return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(1));
++        }
++
++        return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(2));
++    }
++
++    private static @NotNull Component getTpsComponent(double tps){
++        final BossBar.Color colorBukkit = barColorFromTps(tps);
++        final String colorString = colorBukkit.name();
++
++        final String content = "<%s><text></%s>";
++        final String replaced = String.format(content,colorString,colorString);
++
++        return MiniMessage.miniMessage().deserialize(replaced,Placeholder.parsed("text", String.format("%.2f", tps)));
++    }
++
++    private static BossBar.Color barColorFromTps(double tps){
++        if (tps == -1){
++            return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(3));
++        }
++
++        if (tps >= 18){
++            return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(0));
++        }
++
++        if (tps >= 15){
++            return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(1));
++        }
++
++        return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(2));
++    }
++}
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 136ae23d7f470a1f3589f99ba8bf2e804da5d0ef..401b40818452dbeb465803570269476ced87e623 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -2403,6 +2403,9 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+                 handle.expToDrop = data.getInt("expToDrop");
+                 handle.keepLevel = data.getBoolean("keepLevel");
+             }
++            //Luminol start - Tpsbar
++            getHandle().isTpsBarVisible = data.getBoolean("tpsbarVisible");
++            //Luminol end
+         }
+     }
+ 
+@@ -2424,6 +2427,9 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         data.putLong("lastPlayed", System.currentTimeMillis());
+         data.putString("lastKnownName", handle.getScoreboardName());
+ 
++        //Luminol start - Tpsbar
++        data.putBoolean("tpsbarVisible",handle.isTpsBarVisible);
++        //Luminol end
+         // Paper start - persist for use in offline save data
+         if (!nbttagcompound.contains("Paper")) {
+             nbttagcompound.put("Paper", new CompoundTag());

luminol-server/paper-patches/features/0007-Add-a-simple-membar.patch

@@ -0,0 +1,316 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:28:04 +0800
+Subject: [PATCH] Add a simple membar
+
+
+diff --git a/src/main/java/me/earthme/luminol/commands/MembarCommand.java b/src/main/java/me/earthme/luminol/commands/MembarCommand.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..a5cbad6b947b1c3e1499bc6d311e17a5eb570c2f
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/commands/MembarCommand.java
+@@ -0,0 +1,47 @@
++package me.earthme.luminol.commands;
++
++import me.earthme.luminol.config.modules.misc.MembarConfig;
++import me.earthme.luminol.functions.GlobalServerMemoryBar;
++import net.kyori.adventure.text.Component;
++import net.kyori.adventure.text.format.TextColor;
++import org.bukkit.command.Command;
++import org.bukkit.command.CommandSender;
++import org.bukkit.entity.Player;
++import org.jetbrains.annotations.NotNull;
++
++public class MembarCommand extends Command {
++    public MembarCommand(@NotNull String name) {
++        super(name);
++        this.setPermission("luminol.commands.membar");
++        this.setDescription("Show the memory usage through a bossbar");
++        this.setUsage("/membar");
++    }
++
++    @Override
++    public boolean execute(@NotNull CommandSender sender, @NotNull String commandLabel, @NotNull String[] args) {
++        if (!testPermission(sender)){
++            return true;
++        }
++
++        if (!MembarConfig.memoryBarEnabled){
++            sender.sendMessage(Component.text("Membar was already disabled!").color(TextColor.color(255,0,0)));
++            return true;
++        }
++
++        if (!(sender instanceof Player player)){
++            sender.sendMessage(Component.text("Only player can use this command!").color(TextColor.color(255,0,0)));
++            return true;
++        }
++
++        if (GlobalServerMemoryBar.isPlayerVisible(player)) {
++            player.sendMessage(Component.text("Disabled mem bar").color(TextColor.color(0,255,0)));
++            GlobalServerMemoryBar.setVisibilityForPlayer(player,false);
++            return true;
++        }
++
++        player.sendMessage(Component.text("Enabled mem bar").color(TextColor.color(0,255,0)));
++        GlobalServerMemoryBar.setVisibilityForPlayer(player,true);
++
++        return true;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/MembarConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/MembarConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..b632c4a636974535bf001f010de1dcb6b25868c0
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/MembarConfig.java
+@@ -0,0 +1,50 @@
++package me.earthme.luminol.config.modules.misc;
++
++import com.electronwill.nightconfig.core.file.CommentedFileConfig;
++import me.earthme.luminol.commands.MembarCommand;
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.DoNotLoad;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++import me.earthme.luminol.functions.GlobalServerMemoryBar;
++import org.bukkit.Bukkit;
++
++import java.util.List;
++
++public class MembarConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean memoryBarEnabled = false;
++    @ConfigInfo(baseName = "format")
++    public static String memBarFormat = "<gray>Memory usage <yellow>:</yellow> <used>MB<yellow>/</yellow><available>MB";
++    @ConfigInfo(baseName = "memory_color_list")
++    public static List<String> memColors = 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() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "membar";
++    }
++
++    @Override
++    public void onLoaded(CommentedFileConfig configInstance){
++        if (memoryBarEnabled){
++            GlobalServerMemoryBar.init();
++        }else{
++            GlobalServerMemoryBar.cancelBarUpdateTask();
++        }
++
++        if (!inited){
++            Bukkit.getCommandMap().register("membar","luminol",new MembarCommand("membar"));
++            inited = true;
++        }
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/functions/GlobalServerMemoryBar.java b/src/main/java/me/earthme/luminol/functions/GlobalServerMemoryBar.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..3535cf03e7855b4d8b312ccf3a7b0564ea753019
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/functions/GlobalServerMemoryBar.java
+@@ -0,0 +1,171 @@
++package me.earthme.luminol.functions;
++
++import com.google.common.collect.Maps;
++import com.mojang.logging.LogUtils;
++import io.papermc.paper.threadedregions.scheduler.ScheduledTask;
++import me.earthme.luminol.config.modules.misc.MembarConfig;
++import me.earthme.luminol.utils.NullPlugin;
++import net.kyori.adventure.bossbar.BossBar;
++import net.kyori.adventure.text.Component;
++import net.kyori.adventure.text.minimessage.MiniMessage;
++import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
++import org.bukkit.Bukkit;
++import org.bukkit.craftbukkit.entity.CraftPlayer;
++import org.bukkit.entity.Player;
++import org.jetbrains.annotations.NotNull;
++import org.slf4j.Logger;
++
++import java.lang.management.ManagementFactory;
++import java.lang.management.MemoryUsage;
++import java.util.*;
++
++public class GlobalServerMemoryBar {
++    protected static final NullPlugin NULL_PLUGIN = new NullPlugin();
++    protected static final Map<UUID, BossBar> uuid2Bossbars = Maps.newConcurrentMap();
++    protected static final Map<UUID, ScheduledTask> scheduledTasks = new HashMap<>();
++    protected static volatile ScheduledTask scannerTask = null;
++    private static final Logger logger = LogUtils.getLogger();
++
++    public static void init(){
++        cancelBarUpdateTask();
++
++        scannerTask = Bukkit.getGlobalRegionScheduler().runAtFixedRate(NULL_PLUGIN, unused -> {
++            try {
++                update();
++            }catch (Exception e){
++                logger.error(e.getLocalizedMessage());
++            }
++        }, 1, MembarConfig.updateInterval);
++    }
++
++
++    public static void cancelBarUpdateTask(){
++        if (scannerTask == null || scannerTask.isCancelled()){
++            return;
++        }
++
++        scannerTask.cancel();
++
++        for (ScheduledTask task : scheduledTasks.values()) {
++            if (!task.isCancelled()) {
++                task.cancel();
++            }
++        }
++    }
++
++    public static boolean isPlayerVisible(Player player){
++        return ((CraftPlayer) player).getHandle().isMemBarVisible;
++    }
++
++    public static void setVisibilityForPlayer(Player target,boolean canSee){
++        ((CraftPlayer) target).getHandle().isMemBarVisible = canSee;
++    }
++
++    private static void update(){
++        doUpdate();
++        cleanUp();
++    }
++
++    private static void cleanUp(){
++        final List<UUID> toCleanUp = new ArrayList<>();
++
++        for (Map.Entry<UUID, ScheduledTask> toCheck : scheduledTasks.entrySet()) {
++            if (toCheck.getValue().isCancelled()) {
++                toCleanUp.add(toCheck.getKey());
++            }
++        }
++
++        for (UUID uuid : toCleanUp) {
++            scheduledTasks.remove(uuid);
++        }
++    }
++
++    private static void doUpdate(){
++        for (Player player : Bukkit.getOnlinePlayers()) {
++            scheduledTasks.computeIfAbsent(player.getUniqueId(), unused -> createBossBarForPlayer(player));
++        }
++    }
++
++    private static ScheduledTask createBossBarForPlayer(Player apiPlayer) {
++        return apiPlayer.getScheduler().runAtFixedRate(NULL_PLUGIN, (unused) -> {
++            final UUID playerUUID = apiPlayer.getUniqueId();
++
++            if (!isPlayerVisible(apiPlayer)) {
++                final BossBar removed = uuid2Bossbars.remove(playerUUID);
++
++                if (removed != null) {
++                    apiPlayer.hideBossBar(removed);
++                }
++
++                return;
++            }
++
++            MemoryUsage heap = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
++
++            long used = heap.getUsed();
++            long xmx = heap.getMax();
++
++            BossBar targetBossbar = uuid2Bossbars.computeIfAbsent(
++                    playerUUID,
++                    (unused1) -> BossBar.bossBar(Component.text(""),0.0F, BossBar.Color.valueOf(MembarConfig.memColors.get(3)), BossBar.Overlay.NOTCHED_20)
++            );
++
++            apiPlayer.showBossBar(targetBossbar);
++
++            updateMembar(targetBossbar, used, xmx);
++        }, () -> {
++            final BossBar removed = uuid2Bossbars.remove(apiPlayer.getUniqueId());
++
++            if (removed != null) {
++                apiPlayer.hideBossBar(removed);
++            }
++        }, 1, MembarConfig.updateInterval);
++    }
++
++    private static void updateMembar(@NotNull BossBar bar, long used, long xmx){
++        double percent = Math.max(Math.min((float) used / xmx, 1.0F), 0.0F);
++        bar.name(MiniMessage.miniMessage().deserialize(
++                MembarConfig.memBarFormat,
++                Placeholder.component("used", getMemoryComponent(used,xmx)),
++                Placeholder.component("available",getMaxMemComponent(xmx))
++        ));
++        bar.color(barColorFromMemory(percent));
++        bar.progress((float) percent);
++    }
++
++    private static @NotNull Component getMaxMemComponent(double max){
++        final BossBar.Color colorBukkit = BossBar.Color.GREEN;
++        final String colorString = colorBukkit.name();
++
++        final String content = "<%s><text></%s>";
++        final String replaced = String.format(content,colorString,colorString);
++
++        return MiniMessage.miniMessage().deserialize(replaced,Placeholder.parsed("text", String.format("%.2f", max / (1024 * 1024))));
++    }
++
++    private static @NotNull Component getMemoryComponent(long used,long max){
++        final BossBar.Color colorBukkit = barColorFromMemory(Math.max(Math.min((float) used / max, 1.0F), 0.0F));
++        final String colorString = colorBukkit.name();
++
++        final String content = "<%s><text></%s>";
++        final String replaced = String.format(content,colorString,colorString);
++
++        return MiniMessage.miniMessage().deserialize(replaced,Placeholder.parsed("text", String.format("%.2f", (double)used / (1024 * 1024))));
++    }
++
++    private static BossBar.Color barColorFromMemory(double memPercent){
++        if (memPercent == -1){
++            return BossBar.Color.valueOf(MembarConfig.memColors.get(3));
++        }
++
++        if (memPercent <= 50){
++            return BossBar.Color.valueOf(MembarConfig.memColors.getFirst());
++        }
++
++        if (memPercent <= 70){
++            return BossBar.Color.valueOf(MembarConfig.memColors.get(1));
++        }
++
++        return BossBar.Color.valueOf(MembarConfig.memColors.get(2));
++    }
++}
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 401b40818452dbeb465803570269476ced87e623..7a112a3a0a9411a166666c657dac6b7888105545 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -2406,6 +2406,9 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+             //Luminol start - Tpsbar
+             getHandle().isTpsBarVisible = data.getBoolean("tpsbarVisible");
+             //Luminol end
++            //Luminol start - Membar
++            getHandle().isMemBarVisible = data.getBoolean("membarVisible");
++            //Luminol end
+         }
+     }
+ 
+@@ -2430,6 +2433,9 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         //Luminol start - Tpsbar
+         data.putBoolean("tpsbarVisible",handle.isTpsBarVisible);
+         //Luminol end
++        //Luminol start - Membar
++        data.putBoolean("membarVisible", handle.isMemBarVisible);
++        //Luminol end
+         // Paper start - persist for use in offline save data
+         if (!nbttagcompound.contains("Paper")) {
+             nbttagcompound.put("Paper", new CompoundTag());

luminol-server/paper-patches/features/0008-Add-config-for-offline-mode-warning.patch

@@ -0,0 +1,58 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:29:45 +0800
+Subject: [PATCH] Add config for offline mode warning
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/OfflineModeWarningConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/OfflineModeWarningConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..502b93c7bda9e8577a1901a8777b7cf9b9bdc36b
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/OfflineModeWarningConfig.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 OfflineModeWarningConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = true;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "warn_on_offline_mode";
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/UsernameCheckConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/UsernameCheckConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..c7e4724cc4ab8d911bcaf0106c098b266c843bb1
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/UsernameCheckConfig.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 UsernameCheckConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = true;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "username_checks";
++    }
++}

luminol-server/paper-patches/features/0009-Add-config-for-out-of-order-chat-checks.patch

@@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:30:03 +0800
+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";
++    }
++}

luminol-server/paper-patches/features/0010-Add-config-to-verify-signature-only-in-online-mode.patch

@@ -0,0 +1,59 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:31:09 +0800
+Subject: [PATCH] Add config to verify signature only in online-mode
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/PublickeyVerifyConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/PublickeyVerifyConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..e45ce3abf49684c911678abcefd69586246cc0e3
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/PublickeyVerifyConfig.java
+@@ -0,0 +1,21 @@
++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 PublickeyVerifyConfig implements IConfigModule {
++
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "verify_publickey_only_in_online_mode";
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/TripwireConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/TripwireConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..8def8aad908f5e6b828d7d9179bfe1962c39f9f7
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/TripwireConfig.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 TripwireConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "tripwire_dupe";
++    }
++}

luminol-server/paper-patches/features/0011-Add-config-to-disable-entity-tick-catchers.patch

@@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:35:13 +0800
+Subject: [PATCH] Add config to disable entity tick catchers
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/experiment/DisableEntityCatchConfig.java b/src/main/java/me/earthme/luminol/config/modules/experiment/DisableEntityCatchConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0fd71151a85dd87c2294033e2e7512ac365caa62
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/experiment/DisableEntityCatchConfig.java
+@@ -0,0 +1,20 @@
++package me.earthme.luminol.config.modules.experiment;
++
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++
++public class DisableEntityCatchConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.EXPERIMENT;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "disable_entity_exception_catchers";
++    }
++}

luminol-server/paper-patches/features/0012-Add-config-to-disable-async-catchers.patch

@@ -0,0 +1,120 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Wed, 29 Jan 2025 09:08:22 +0800
+Subject: [PATCH] Add config to disable async catchers
+
+
+diff --git a/src/main/java/ca/spottedleaf/moonrise/common/util/TickThread.java b/src/main/java/ca/spottedleaf/moonrise/common/util/TickThread.java
+index c95769a4e64fabd7acdff6c5f6f349107e1cf5c0..4efa1c057ae6cfdea7889c372bd62dc14637daa0 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/common/util/TickThread.java
++++ b/src/main/java/ca/spottedleaf/moonrise/common/util/TickThread.java
+@@ -48,14 +48,14 @@ public class TickThread extends Thread {
+      */
+     @Deprecated
+     public static void ensureTickThread(final String reason) {
+-        if (!isTickThread()) {
++        if (!isTickThread() && !me.earthme.luminol.config.modules.experiment.DisableAsyncCatcherConfig.enabled) { // Luminol
+             LOGGER.error("Thread failed main thread check: " + reason + ", context=" + getThreadContext(), new Throwable());
+             throw new IllegalStateException(reason);
+         }
+     }
+ 
+     public static void ensureTickThread(final Level world, final BlockPos pos, final String reason) {
+-        if (!isTickThreadFor(world, pos)) {
++        if (!isTickThreadFor(world, pos) && !me.earthme.luminol.config.modules.experiment.DisableAsyncCatcherConfig.enabled) { // Luminol
+             final String ex = "Thread failed main thread check: " +
+                                reason + ", context=" + getThreadContext() + ", world=" + WorldUtil.getWorldName(world) + ", block_pos=" + pos;
+             LOGGER.error(ex, new Throwable());
+@@ -64,7 +64,7 @@ public class TickThread extends Thread {
+     }
+ 
+     public static void ensureTickThread(final Level world, final BlockPos pos, final int blockRadius, final String reason) {
+-        if (!isTickThreadFor(world, pos, blockRadius)) {
++        if (!isTickThreadFor(world, pos, blockRadius) && !me.earthme.luminol.config.modules.experiment.DisableAsyncCatcherConfig.enabled) { // Luminol
+             final String ex = "Thread failed main thread check: " +
+                 reason + ", context=" + getThreadContext() + ", world=" + WorldUtil.getWorldName(world) + ", block_pos=" + pos + ", block_radius=" + blockRadius;
+             LOGGER.error(ex, new Throwable());
+@@ -73,7 +73,7 @@ public class TickThread extends Thread {
+     }
+ 
+     public static void ensureTickThread(final Level world, final ChunkPos pos, final String reason) {
+-        if (!isTickThreadFor(world, pos)) {
++        if (!isTickThreadFor(world, pos) && !me.earthme.luminol.config.modules.experiment.DisableAsyncCatcherConfig.enabled) { // Luminol
+             final String ex = "Thread failed main thread check: " +
+                 reason + ", context=" + getThreadContext() + ", world=" + WorldUtil.getWorldName(world) + ", chunk_pos=" + pos;
+             LOGGER.error(ex, new Throwable());
+@@ -82,7 +82,7 @@ public class TickThread extends Thread {
+     }
+ 
+     public static void ensureTickThread(final Level world, final int chunkX, final int chunkZ, final String reason) {
+-        if (!isTickThreadFor(world, chunkX, chunkZ)) {
++        if (!isTickThreadFor(world, chunkX, chunkZ) && !me.earthme.luminol.config.modules.experiment.DisableAsyncCatcherConfig.enabled) { // Luminol
+             final String ex = "Thread failed main thread check: " +
+                 reason + ", context=" + getThreadContext() + ", world=" + WorldUtil.getWorldName(world) + ", chunk_pos=" + new ChunkPos(chunkX, chunkZ);
+             LOGGER.error(ex, new Throwable());
+@@ -91,7 +91,7 @@ public class TickThread extends Thread {
+     }
+ 
+     public static void ensureTickThread(final Entity entity, final String reason) {
+-        if (!isTickThreadFor(entity)) {
++        if (!isTickThreadFor(entity) && !me.earthme.luminol.config.modules.experiment.DisableAsyncCatcherConfig.enabled) { // Luminol
+             final String ex = "Thread failed main thread check: " +
+                 reason + ", context=" + getThreadContext() + ", entity=" + EntityUtil.dumpEntity(entity);
+             LOGGER.error(ex, new Throwable());
+@@ -100,7 +100,7 @@ public class TickThread extends Thread {
+     }
+ 
+     public static void ensureTickThread(final Level world, final AABB aabb, final String reason) {
+-        if (!isTickThreadFor(world, aabb)) {
++        if (!isTickThreadFor(world, aabb) && !me.earthme.luminol.config.modules.experiment.DisableAsyncCatcherConfig.enabled) { // Luminol
+             final String ex = "Thread failed main thread check: " +
+                 reason + ", context=" + getThreadContext() + ", world=" + WorldUtil.getWorldName(world) + ", aabb=" + aabb;
+             LOGGER.error(ex, new Throwable());
+@@ -109,7 +109,7 @@ public class TickThread extends Thread {
+     }
+ 
+     public static void ensureTickThread(final Level world, final double blockX, final double blockZ, final String reason) {
+-        if (!isTickThreadFor(world, blockX, blockZ)) {
++        if (!isTickThreadFor(world, blockX, blockZ) && !me.earthme.luminol.config.modules.experiment.DisableAsyncCatcherConfig.enabled) { // Luminol
+             final String ex = "Thread failed main thread check: " +
+                 reason + ", context=" + getThreadContext() + ", world=" + WorldUtil.getWorldName(world) + ", block_pos=" + new Vec3(blockX, 0.0, blockZ);
+             LOGGER.error(ex, new Throwable());
+diff --git a/src/main/java/me/earthme/luminol/config/modules/experiment/DisableAsyncCatcherConfig.java b/src/main/java/me/earthme/luminol/config/modules/experiment/DisableAsyncCatcherConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..61f653eeca366672ded88c491cf5c59e546e7301
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/experiment/DisableAsyncCatcherConfig.java
+@@ -0,0 +1,20 @@
++package me.earthme.luminol.config.modules.experiment;
++
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++
++public class DisableAsyncCatcherConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.EXPERIMENT;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "disable_async_catchers";
++    }
++}
+diff --git a/src/main/java/org/spigotmc/AsyncCatcher.java b/src/main/java/org/spigotmc/AsyncCatcher.java
+index 50f01faa88c8c658252fade3748f20e48e9c8432..36fa1f83c3286e10cc7c208a2a2f1a718d525ad8 100644
+--- a/src/main/java/org/spigotmc/AsyncCatcher.java
++++ b/src/main/java/org/spigotmc/AsyncCatcher.java
+@@ -7,7 +7,7 @@ public class AsyncCatcher {
+     public static boolean enabled = true;
+ 
+     public static void catchOp(String reason) {
+-        if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThread()) { // Paper - chunk system
++        if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThread() && !me.earthme.luminol.config.modules.experiment.DisableAsyncCatcherConfig.enabled) { // Paper - chunk system  // Luminol
+             MinecraftServer.LOGGER.error("Thread {} failed main thread check: {}", Thread.currentThread().getName(), reason, new Throwable()); // Paper
+             throw new IllegalStateException("Asynchronous " + reason + "!");
+         }

luminol-server/paper-patches/features/0013-Add-experiment-config-for-command-block-command-exec.patch

@@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:36:32 +0800
+Subject: [PATCH] Add experiment config for command block command execution
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/experiment/CommandBlockConfig.java b/src/main/java/me/earthme/luminol/config/modules/experiment/CommandBlockConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..3eafc59cc015569d3da8b1d8c4bfd046af17e0be
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/experiment/CommandBlockConfig.java
+@@ -0,0 +1,20 @@
++package me.earthme.luminol.config.modules.experiment;
++
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++
++public class CommandBlockConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enable")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.EXPERIMENT;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "force_enable_command_block_execution";
++    }
++}

luminol-server/paper-patches/features/0014-Add-configurable-region-format-framework-linear-v2-r.patch

@@ -0,0 +1,819 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:49:22 +0800
+Subject: [PATCH] Add configurable region format framework & linear v2 region
+ format support
+
+
+diff --git a/src/main/java/abomination/IRegionFile.java b/src/main/java/abomination/IRegionFile.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..fda43a34c89d75e3036f14da3c6efcf157189b22
+--- /dev/null
++++ b/src/main/java/abomination/IRegionFile.java
+@@ -0,0 +1,39 @@
++package abomination;
++
++import ca.spottedleaf.moonrise.patches.chunk_system.storage.ChunkSystemRegionFile;
++import net.minecraft.nbt.CompoundTag;
++import net.minecraft.world.level.ChunkPos;
++
++import java.io.DataInputStream;
++import java.io.DataOutputStream;
++import java.io.IOException;
++import java.nio.ByteBuffer;
++import java.nio.file.Path;
++
++public interface IRegionFile extends ChunkSystemRegionFile, AutoCloseable {
++    Path getPath();
++
++    DataInputStream getChunkDataInputStream(ChunkPos pos) throws IOException;
++
++    boolean doesChunkExist(ChunkPos pos) throws Exception;
++
++    DataOutputStream getChunkDataOutputStream(ChunkPos pos) throws IOException;
++
++    void flush() throws IOException;
++
++    void clear(ChunkPos pos) throws IOException;
++
++    boolean hasChunk(ChunkPos pos);
++
++    void close() throws IOException;
++
++    void write(ChunkPos pos, ByteBuffer buf) throws IOException;
++
++    CompoundTag getOversizedData(int x, int z) throws IOException;
++
++    boolean isOversized(int x, int z);
++
++    boolean recalculateHeader() throws IOException;
++
++    void setOversized(int x, int z, boolean oversized) throws IOException;
++}
+diff --git a/src/main/java/abomination/LinearRegionFile.java b/src/main/java/abomination/LinearRegionFile.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..bb0fcf5f47b5ae3d86e1d0572f951236afdcd017
+--- /dev/null
++++ b/src/main/java/abomination/LinearRegionFile.java
+@@ -0,0 +1,622 @@
++package abomination;
++
++import ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO;
++import com.github.luben.zstd.ZstdInputStream;
++import com.github.luben.zstd.ZstdOutputStream;
++import com.mojang.logging.LogUtils;
++import net.jpountz.lz4.LZ4Compressor;
++import net.jpountz.lz4.LZ4Factory;
++import net.jpountz.lz4.LZ4FastDecompressor;
++import net.openhft.hashing.LongHashFunction;
++import net.minecraft.nbt.CompoundTag;
++import net.minecraft.world.level.chunk.storage.RegionStorageInfo;
++import net.minecraft.world.level.chunk.storage.RegionFileVersion;
++import net.minecraft.world.level.ChunkPos;
++import org.slf4j.Logger;
++
++import javax.annotation.Nullable;
++import java.io.*;
++import java.nio.ByteBuffer;
++import java.nio.file.Files;
++import java.nio.file.Path;
++import java.nio.file.StandardCopyOption;
++import java.util.ArrayList;
++import java.util.Arrays;
++import java.util.List;
++import java.util.concurrent.TimeUnit;
++import java.util.concurrent.locks.LockSupport;
++import java.util.concurrent.locks.ReentrantLock;
++
++// LinearRegionFile_implementation_version_0_5byXymb
++// Just gonna use this string to inform other forks about updates ;-)
++public class LinearRegionFile implements IRegionFile{
++    private static final long SUPERBLOCK = 0xc3ff13183cca9d9aL;
++    private static final byte VERSION = 3;
++    private static final int HEADER_SIZE = 27;
++    private static final int FOOTER_SIZE = 8;
++    private static final Logger LOGGER = LogUtils.getLogger();
++
++    private byte[][] bucketBuffers;
++    private final byte[][] buffer = new byte[1024][];
++    private final int[] bufferUncompressedSize = new int[1024];
++
++    private final long[] chunkTimestamps = new long[1024];
++    private final Object markedToSaveLock = new Object();
++
++    private final LZ4Compressor compressor;
++    private final LZ4FastDecompressor decompressor;
++
++    private boolean markedToSave = false;
++    private boolean close = false;
++
++    public final ReentrantLock fileLock = new ReentrantLock(true);
++    public Path regionFile;
++
++    private final int compressionLevel;
++    private int gridSize = 8;
++    private int bucketSize = 4;
++    private final Thread bindThread;
++
++    public Path getRegionFile() {
++        return this.regionFile;
++    }
++
++    public ReentrantLock getFileLock() {
++        return this.fileLock;
++    }
++
++    private int chunkToBucketIdx(int chunkX, int chunkZ) {
++        int bx = chunkX / bucketSize, bz = chunkZ / bucketSize;
++        return bx * gridSize + bz;
++    }
++
++    private void openBucket(int chunkX, int chunkZ) {
++        chunkX = Math.floorMod(chunkX, 32);
++        chunkZ = Math.floorMod(chunkZ, 32);
++        int idx = chunkToBucketIdx(chunkX, chunkZ);
++
++        if (bucketBuffers == null) return;
++        if (bucketBuffers[idx] != null) {
++            try {
++                ByteArrayInputStream bucketByteStream = new ByteArrayInputStream(bucketBuffers[idx]);
++                ZstdInputStream zstdStream = new ZstdInputStream(bucketByteStream);
++                ByteBuffer bucketBuffer = ByteBuffer.wrap(zstdStream.readAllBytes());
++
++                int bx = chunkX / bucketSize, bz = chunkZ / bucketSize;
++
++                for (int cx = 0; cx < 32 / gridSize; cx++) {
++                    for (int cz = 0; cz < 32 / gridSize; cz++) {
++                        int chunkIndex = (bx * (32 / gridSize) + cx) + (bz * (32 / gridSize) + cz) * 32;
++
++                        int chunkSize = bucketBuffer.getInt();
++                        long timestamp = bucketBuffer.getLong();
++                        this.chunkTimestamps[chunkIndex] = timestamp;
++
++                        if (chunkSize > 0) {
++                            byte[] chunkData = new byte[chunkSize - 8];
++                            bucketBuffer.get(chunkData);
++
++                            int maxCompressedLength = this.compressor.maxCompressedLength(chunkData.length);
++                            byte[] compressed = new byte[maxCompressedLength];
++                            int compressedLength = this.compressor.compress(chunkData, 0, chunkData.length, compressed, 0, maxCompressedLength);
++                            byte[] finalCompressed = new byte[compressedLength];
++                            System.arraycopy(compressed, 0, finalCompressed, 0, compressedLength);
++
++                            // TODO: Optimization - return the requested chunk immediately to save on one LZ4 decompression
++                            this.buffer[chunkIndex] = finalCompressed;
++                            this.bufferUncompressedSize[chunkIndex] = chunkData.length;
++                        }
++                    }
++                }
++            } catch (IOException ex) {
++                throw new RuntimeException("Region file corrupted: " + regionFile + " bucket: " + idx);
++                // TODO: Make sure the server crashes instead of corrupting the world
++            }
++            bucketBuffers[idx] = null;
++        }
++    }
++
++    public boolean regionFileOpen = false;
++
++    private synchronized void openRegionFile() {
++        if (regionFileOpen) return;
++        regionFileOpen = true;
++
++        File regionFile = new File(this.regionFile.toString());
++
++        if(!regionFile.canRead()) {
++            this.bindThread.start();
++            return;
++        }
++
++        try {
++            byte[] fileContent = Files.readAllBytes(this.regionFile);
++            ByteBuffer buffer = ByteBuffer.wrap(fileContent);
++
++            long superBlock = buffer.getLong();
++            if (superBlock != SUPERBLOCK)
++                throw new RuntimeException("Invalid superblock: " + superBlock + " file " + this.regionFile);
++
++            byte version = buffer.get();
++            if (version == 1 || version == 2) {
++                parseLinearV1(buffer);
++            } else if (version == 3) {
++                parseLinearV2(buffer);
++            } else {
++                throw new RuntimeException("Invalid version: " + version + " file " + this.regionFile);
++            }
++
++            this.bindThread.start();
++        } catch (IOException e) {
++            throw new RuntimeException("Failed to open region file " + this.regionFile, e);
++        }
++    }
++
++    private void parseLinearV1(ByteBuffer buffer) throws IOException {
++        final int HEADER_SIZE = 32;
++        final int FOOTER_SIZE = 8;
++
++        // Skip newestTimestamp (Long) + Compression level (Byte) + Chunk count (Short): Unused.
++        buffer.position(buffer.position() + 11);
++
++        int dataCount = buffer.getInt();
++        long fileLength = this.regionFile.toFile().length();
++        if (fileLength != HEADER_SIZE + dataCount + FOOTER_SIZE) {
++            throw new IOException("Invalid file length: " + this.regionFile + " " + fileLength + " " + (HEADER_SIZE + dataCount + FOOTER_SIZE));
++        }
++
++        buffer.position(buffer.position() + 8); // Skip data hash (Long): Unused.
++
++        byte[] rawCompressed = new byte[dataCount];
++        buffer.get(rawCompressed);
++
++        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(rawCompressed);
++        ZstdInputStream zstdInputStream = new ZstdInputStream(byteArrayInputStream);
++        ByteBuffer decompressedBuffer = ByteBuffer.wrap(zstdInputStream.readAllBytes());
++
++        int[] starts = new int[1024];
++        for (int i = 0; i < 1024; i++) {
++            starts[i] = decompressedBuffer.getInt();
++            decompressedBuffer.getInt(); // Skip timestamps (Int): Unused.
++        }
++
++        for (int i = 0; i < 1024; i++) {
++            if (starts[i] > 0) {
++                int size = starts[i];
++                byte[] chunkData = new byte[size];
++                decompressedBuffer.get(chunkData);
++
++                int maxCompressedLength = this.compressor.maxCompressedLength(size);
++                byte[] compressed = new byte[maxCompressedLength];
++                int compressedLength = this.compressor.compress(chunkData, 0, size, compressed, 0, maxCompressedLength);
++                byte[] finalCompressed = new byte[compressedLength];
++                System.arraycopy(compressed, 0, finalCompressed, 0, compressedLength);
++
++                this.buffer[i] = finalCompressed;
++                this.bufferUncompressedSize[i] = size;
++                this.chunkTimestamps[i] = getTimestamp(); // Use current timestamp as we don't have the original
++            }
++        }
++    }
++
++    private void parseLinearV2(ByteBuffer buffer) throws IOException {
++        buffer.getLong(); // Skip newestTimestamp (Long)
++        gridSize = buffer.get();
++        if (gridSize != 1 && gridSize != 2 && gridSize != 4 && gridSize != 8 && gridSize != 16 && gridSize != 32)
++            throw new RuntimeException("Invalid grid size: " + gridSize + " file " + this.regionFile);
++        bucketSize = 32 / gridSize;
++
++        buffer.getInt(); // Skip region_x (Int)
++        buffer.getInt(); // Skip region_z (Int)
++
++        boolean[] chunkExistenceBitmap = deserializeExistenceBitmap(buffer);
++
++        while (true) {
++            byte featureNameLength = buffer.get();
++            if (featureNameLength == 0) break;
++            byte[] featureNameBytes = new byte[featureNameLength];
++            buffer.get(featureNameBytes);
++            String featureName = new String(featureNameBytes);
++            int featureValue = buffer.getInt();
++            // System.out.println("NBT Feature: " + featureName + " = " + featureValue);
++        }
++
++        int[] bucketSizes = new int[gridSize * gridSize];
++        byte[] bucketCompressionLevels = new byte[gridSize * gridSize];
++        long[] bucketHashes = new long[gridSize * gridSize];
++        for (int i = 0; i < gridSize * gridSize; i++) {
++            bucketSizes[i] = buffer.getInt();
++            bucketCompressionLevels[i] = buffer.get();
++            bucketHashes[i] = buffer.getLong();
++        }
++
++        bucketBuffers = new byte[gridSize * gridSize][];
++        for (int i = 0; i < gridSize * gridSize; i++) {
++            if (bucketSizes[i] > 0) {
++                bucketBuffers[i] = new byte[bucketSizes[i]];
++                buffer.get(bucketBuffers[i]);
++                long rawHash = LongHashFunction.xx().hashBytes(bucketBuffers[i]);
++                if (rawHash != bucketHashes[i]) throw new IOException("Region file hash incorrect " + this.regionFile);
++            }
++        }
++
++        long footerSuperBlock = buffer.getLong();
++        if (footerSuperBlock != SUPERBLOCK)
++            throw new IOException("Footer superblock invalid " + this.regionFile);
++    }
++
++    public LinearRegionFile(RegionStorageInfo storageKey, Path directory, Path path, boolean dsync, int compressionLevel) throws IOException {
++        this(storageKey, directory, path, RegionFileVersion.getCompressionFormat(), dsync, compressionLevel);
++    }
++
++    public LinearRegionFile(RegionStorageInfo storageKey, Path path, Path directory, RegionFileVersion compressionFormat, boolean dsync, int compressionLevel) throws IOException {
++        Runnable flushCheck = () -> {
++            while (!close) {
++                synchronized (saveLock) {
++                    if (markedToSave && activeSaveThreads < SAVE_THREAD_MAX_COUNT) {
++                        activeSaveThreads++;
++                        Runnable flushOperation = () -> {
++                            try {
++                                flush();
++                            } catch (IOException ex) {
++                                LOGGER.error("Region file {} flush failed", this.regionFile.toAbsolutePath(), ex);
++                            } finally {
++                                synchronized (saveLock) {
++                                    activeSaveThreads--;
++                                }
++                            }
++                        };
++
++                        Thread saveThread = USE_VIRTUAL_THREAD ?
++                                Thread.ofVirtual().name("Linear IO - " + LinearRegionFile.this.hashCode()).unstarted(flushOperation) :
++                                Thread.ofPlatform().name("Linear IO - " + LinearRegionFile.this.hashCode()).unstarted(flushOperation);
++                        saveThread.setPriority(Thread.NORM_PRIORITY - 3);
++                        saveThread.start();
++                    }
++                }
++                LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(SAVE_DELAY_MS));
++            }
++        };
++        this.bindThread = USE_VIRTUAL_THREAD ? Thread.ofVirtual().unstarted(flushCheck) : Thread.ofPlatform().unstarted(flushCheck);
++        this.bindThread.setName("Linear IO Schedule - " + this.hashCode());
++        this.regionFile = path;
++        this.compressionLevel = compressionLevel;
++
++        this.compressor = LZ4Factory.fastestInstance().fastCompressor();
++        this.decompressor = LZ4Factory.fastestInstance().fastDecompressor();
++    }
++
++    private synchronized void markToSave() {
++        synchronized(markedToSaveLock) {
++            markedToSave = true;
++        }
++    }
++
++    private synchronized boolean isMarkedToSave() {
++        synchronized(markedToSaveLock) {
++            if(markedToSave) {
++                markedToSave = false;
++                return true;
++            }
++            return false;
++        }
++    }
++
++    public static int SAVE_THREAD_MAX_COUNT = 6;
++    public static int SAVE_DELAY_MS = 100;
++    public static boolean USE_VIRTUAL_THREAD = true;
++    private static final Object saveLock = new Object();
++    private static int activeSaveThreads = 0;
++
++    /*public void run() {
++        while (!close) {
++            synchronized (saveLock) {
++                if (markedToSave && activeSaveThreads < SAVE_THREAD_MAX_COUNT) {
++                    activeSaveThreads++;
++                    Thread saveThread = new Thread(() -> {
++                        try {
++                            flush();
++                        } catch (IOException ex) {
++                            LOGGER.error("Region file " + this.regionFile.toAbsolutePath() + " flush failed", ex);
++                        } finally {
++                            synchronized (saveLock) {
++                                activeSaveThreads--;
++                            }
++                        }
++                    }, "RegionFileFlush");
++                    saveThread.setPriority(Thread.NORM_PRIORITY - 3);
++                    saveThread.start();
++                }
++            }
++            LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(SAVE_DELAY_MS));
++        }
++    }*/
++
++    public synchronized boolean doesChunkExist(ChunkPos pos) throws Exception {
++        openRegionFile();
++        throw new Exception("doesChunkExist is a stub");
++    }
++
++    public synchronized void flush() throws IOException {
++        if(!isMarkedToSave()) return;
++
++        openRegionFile();
++
++        long timestamp = getTimestamp();
++
++long writeStart = System.nanoTime();
++        File tempFile = new File(regionFile.toString() + ".tmp");
++        FileOutputStream fileStream = new FileOutputStream(tempFile);
++        DataOutputStream dataStream = new DataOutputStream(fileStream);
++
++        dataStream.writeLong(SUPERBLOCK);
++        dataStream.writeByte(VERSION);
++        dataStream.writeLong(timestamp);
++        dataStream.writeByte(gridSize);
++
++        String fileName = regionFile.getFileName().toString();
++        String[] parts = fileName.split("\\.");
++        int regionX = 0;
++        int regionZ = 0;
++        try {
++            if (parts.length >= 4) {
++                regionX = Integer.parseInt(parts[1]);
++                regionZ = Integer.parseInt(parts[2]);
++            } else {
++                LOGGER.warn("Unexpected file name format: " + fileName);
++            }
++        } catch (NumberFormatException e) {
++            LOGGER.error("Failed to parse region coordinates from file name: " + fileName, e);
++        }
++
++        dataStream.writeInt(regionX);
++        dataStream.writeInt(regionZ);
++
++        boolean[] chunkExistenceBitmap = new boolean[1024];
++        for (int i = 0; i < 1024; i++) {
++            chunkExistenceBitmap[i] = (this.bufferUncompressedSize[i] > 0);
++        }
++        writeSerializedExistenceBitmap(dataStream, chunkExistenceBitmap);
++
++        writeNBTFeatures(dataStream);
++
++        int bucketMisses = 0;
++        byte[][] buckets = new byte[gridSize * gridSize][];
++        for (int bx = 0; bx < gridSize; bx++) {
++            for (int bz = 0; bz < gridSize; bz++) {
++                if (bucketBuffers != null && bucketBuffers[bx * gridSize + bz] != null) {
++                    buckets[bx * gridSize + bz] = bucketBuffers[bx * gridSize + bz];
++                    continue;
++                }
++                bucketMisses++;
++
++                ByteArrayOutputStream bucketStream = new ByteArrayOutputStream();
++                ZstdOutputStream zstdStream = new ZstdOutputStream(bucketStream, this.compressionLevel);
++                DataOutputStream bucketDataStream = new DataOutputStream(zstdStream);
++
++                boolean hasData = false;
++                for (int cx = 0; cx < 32 / gridSize; cx++) {
++                    for (int cz = 0; cz < 32 / gridSize; cz++) {
++                        int chunkIndex = (bx * 32 / gridSize + cx) + (bz * 32 / gridSize + cz) * 32;
++                        if (this.bufferUncompressedSize[chunkIndex] > 0) {
++                            hasData = true;
++                            byte[] chunkData = new byte[this.bufferUncompressedSize[chunkIndex]];
++                            this.decompressor.decompress(this.buffer[chunkIndex], 0, chunkData, 0, this.bufferUncompressedSize[chunkIndex]);
++                            bucketDataStream.writeInt(chunkData.length + 8);
++                            bucketDataStream.writeLong(this.chunkTimestamps[chunkIndex]);
++                            bucketDataStream.write(chunkData);
++                        } else {
++                            bucketDataStream.writeInt(0);
++                            bucketDataStream.writeLong(this.chunkTimestamps[chunkIndex]);
++                        }
++                    }
++                }
++                bucketDataStream.close();
++
++                if (hasData) {
++                    buckets[bx * gridSize + bz] = bucketStream.toByteArray();
++                }
++            }
++        }
++
++        for (int i = 0; i < gridSize * gridSize; i++) {
++            dataStream.writeInt(buckets[i] != null ? buckets[i].length : 0);
++            dataStream.writeByte(this.compressionLevel);
++            long rawHash = 0;
++            if (buckets[i] != null) {
++                rawHash = LongHashFunction.xx().hashBytes(buckets[i]);
++            }
++            dataStream.writeLong(rawHash);
++        }
++
++        for (int i = 0; i < gridSize * gridSize; i++) {
++            if (buckets[i] != null) {
++                dataStream.write(buckets[i]);
++            }
++        }
++
++        dataStream.writeLong(SUPERBLOCK);
++
++        dataStream.flush();
++        fileStream.getFD().sync();
++        fileStream.getChannel().force(true); // Ensure atomicity on Btrfs
++        dataStream.close();
++
++        fileStream.close();
++        Files.move(tempFile.toPath(), this.regionFile, StandardCopyOption.REPLACE_EXISTING);
++//System.out.println("writeStart REGION FILE FLUSH " + (System.nanoTime() - writeStart) + " misses: " + bucketMisses);
++    }
++
++    private void writeNBTFeatures(DataOutputStream dataStream) throws IOException {
++        // writeNBTFeature(dataStream, "example", 1);
++        dataStream.writeByte(0); // End of NBT features
++    }
++
++    private void writeNBTFeature(DataOutputStream dataStream, String featureName, int featureValue) throws IOException {
++        byte[] featureNameBytes = featureName.getBytes();
++        dataStream.writeByte(featureNameBytes.length);
++        dataStream.write(featureNameBytes);
++        dataStream.writeInt(featureValue);
++    }
++
++    public static final int MAX_CHUNK_SIZE = 500 * 1024 * 1024; // Abomination - prevent chunk dupe
++
++    public synchronized void write(ChunkPos pos, ByteBuffer buffer) {
++        openRegionFile();
++        openBucket(pos.x, pos.z);
++        try {
++            byte[] b = toByteArray(new ByteArrayInputStream(buffer.array()));
++            int uncompressedSize = b.length;
++
++            if (uncompressedSize > MAX_CHUNK_SIZE) {
++                LOGGER.error("Chunk dupe attempt " + this.regionFile);
++                clear(pos);
++            } else {
++                int maxCompressedLength = this.compressor.maxCompressedLength(b.length);
++                byte[] compressed = new byte[maxCompressedLength];
++                int compressedLength = this.compressor.compress(b, 0, b.length, compressed, 0, maxCompressedLength);
++                b = new byte[compressedLength];
++                System.arraycopy(compressed, 0, b, 0, compressedLength);
++
++                int index = getChunkIndex(pos.x, pos.z);
++                this.buffer[index] = b;
++                this.chunkTimestamps[index] = getTimestamp();
++                this.bufferUncompressedSize[getChunkIndex(pos.x, pos.z)] = uncompressedSize;
++            }
++        } catch (IOException e) {
++            LOGGER.error("Chunk write IOException " + e + " " + this.regionFile);
++        }
++        markToSave();
++    }
++
++    public DataOutputStream getChunkDataOutputStream(ChunkPos pos) {
++        openRegionFile();
++        openBucket(pos.x, pos.z);
++        return new DataOutputStream(new BufferedOutputStream(new LinearRegionFile.ChunkBuffer(pos)));
++    }
++
++    @Override
++    public MoonriseRegionFileIO.RegionDataController.WriteData moonrise$startWrite(CompoundTag data, ChunkPos pos) throws IOException {
++        final DataOutputStream out = this.getChunkDataOutputStream(pos);
++
++        return new ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.WriteData(
++                data, ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.WriteData.WriteResult.WRITE,
++                out, regionFile -> out.close()
++        );
++    }
++
++    private class ChunkBuffer extends ByteArrayOutputStream {
++
++        private final ChunkPos pos;
++
++        public ChunkBuffer(ChunkPos chunkcoordintpair) {
++            super();
++            this.pos = chunkcoordintpair;
++        }
++
++        public void close() throws IOException {
++            ByteBuffer bytebuffer = ByteBuffer.wrap(this.buf, 0, this.count);
++            LinearRegionFile.this.write(this.pos, bytebuffer);
++        }
++    }
++
++    private byte[] toByteArray(InputStream in) throws IOException {
++        ByteArrayOutputStream out = new ByteArrayOutputStream();
++        byte[] tempBuffer = new byte[4096];
++
++        int length;
++        while ((length = in.read(tempBuffer)) >= 0) {
++            out.write(tempBuffer, 0, length);
++        }
++
++        return out.toByteArray();
++    }
++
++    @Nullable
++    public synchronized DataInputStream getChunkDataInputStream(ChunkPos pos) {
++        openRegionFile();
++        openBucket(pos.x, pos.z);
++
++        if(this.bufferUncompressedSize[getChunkIndex(pos.x, pos.z)] != 0) {
++            byte[] content = new byte[bufferUncompressedSize[getChunkIndex(pos.x, pos.z)]];
++            this.decompressor.decompress(this.buffer[getChunkIndex(pos.x, pos.z)], 0, content, 0, bufferUncompressedSize[getChunkIndex(pos.x, pos.z)]);
++            return new DataInputStream(new ByteArrayInputStream(content));
++        }
++        return null;
++    }
++
++    public synchronized void clear(ChunkPos pos) {
++        openRegionFile();
++        openBucket(pos.x, pos.z);
++        int i = getChunkIndex(pos.x, pos.z);
++        this.buffer[i] = null;
++        this.bufferUncompressedSize[i] = 0;
++        this.chunkTimestamps[i] = 0;
++        markToSave();
++    }
++
++    public synchronized boolean hasChunk(ChunkPos pos) {
++        openRegionFile();
++        openBucket(pos.x, pos.z);
++        return this.bufferUncompressedSize[getChunkIndex(pos.x, pos.z)] > 0;
++    }
++
++    public synchronized void close() throws IOException {
++        openRegionFile();
++        close = true;
++        try {
++            flush();
++        } catch(IOException e) {
++            throw new IOException("Region flush IOException " + e + " " + this.regionFile);
++        }
++    }
++
++    private static int getChunkIndex(int x, int z) {
++        return (x & 31) + ((z & 31) << 5);
++    }
++
++    private static int getTimestamp() {
++        return (int) (System.currentTimeMillis() / 1000L);
++    }
++
++    public boolean recalculateHeader() {
++        return false;
++    }
++
++    public void setOversized(int x, int z, boolean something) {}
++
++    public CompoundTag getOversizedData(int x, int z) throws IOException {
++        throw new IOException("getOversizedData is a stub " + this.regionFile);
++    }
++
++    public boolean isOversized(int x, int z) {
++        return false;
++    }
++
++    public Path getPath() {
++        return this.regionFile;
++    }
++
++    private boolean[] deserializeExistenceBitmap(ByteBuffer buffer) {
++        boolean[] result = new boolean[1024];
++        for (int i = 0; i < 128; i++) {
++            byte b = buffer.get();
++            for (int j = 0; j < 8; j++) {
++                result[i * 8 + j] = ((b >> (7 - j)) & 1) == 1;
++            }
++        }
++        return result;
++    }
++
++    private void writeSerializedExistenceBitmap(DataOutputStream out, boolean[] bitmap) throws IOException {
++        for (int i = 0; i < 128; i++) {
++            byte b = 0;
++            for (int j = 0; j < 8; j++) {
++                if (bitmap[i * 8 + j]) {
++                    b |= (1 << (7 - j));
++                }
++            }
++            out.writeByte(b);
++        }
++    }
++}
+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..eb689b6b79143ffaf1eadcba84feca0c632d1407
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/RegionFormatConfig.java
+@@ -0,0 +1,59 @@
++package me.earthme.luminol.config.modules.misc;
++
++import abomination.LinearRegionFile;
++import com.electronwill.nightconfig.core.file.CommentedFileConfig;
++import me.earthme.luminol.config.*;
++import me.earthme.luminol.utils.EnumRegionFormat;
++import net.minecraft.server.MinecraftServer;
++
++public class RegionFormatConfig implements IConfigModule {
++    @HotReloadUnsupported
++    @ConfigInfo(baseName = "format")
++    public static String format = "MCA";
++    @HotReloadUnsupported
++    @ConfigInfo(baseName = "linear_compression_level")
++    public static int linearCompressionLevel = 1;
++    @HotReloadUnsupported
++    @ConfigInfo(baseName = "linear_io_thread_count")
++    public static int linearIoThreadCount = 6;
++    @HotReloadUnsupported
++    @ConfigInfo(baseName = "linear_io_flush_delay_ms")
++    public static int linearIoFlushDelayMs = 100;
++    @HotReloadUnsupported
++    @ConfigInfo(baseName = "linear_use_virtual_thread")
++    public static boolean linearUseVirtualThread = true;
++
++    @DoNotLoad
++    public static EnumRegionFormat regionFormat;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "region_format";
++    }
++
++    @Override
++    public void onLoaded(CommentedFileConfig configInstance) {
++        regionFormat = EnumRegionFormat.fromString(format.toUpperCase());
++
++        if (regionFormat == null) {
++            throw new RuntimeException("Invalid region format: " + format);
++        }
++
++        if (regionFormat == EnumRegionFormat.LINEAR_V2) {
++            if (RegionFormatConfig.linearCompressionLevel > 23 || RegionFormatConfig.linearCompressionLevel < 1) {
++                MinecraftServer.LOGGER.error("Linear region compression level should be between 1 and 22 in config: {}", RegionFormatConfig.linearCompressionLevel);
++                MinecraftServer.LOGGER.error("Falling back to compression level 1.");
++                RegionFormatConfig.linearCompressionLevel = 1;
++            }
++
++            LinearRegionFile.SAVE_DELAY_MS = linearIoFlushDelayMs;
++            LinearRegionFile.SAVE_THREAD_MAX_COUNT = linearIoThreadCount;
++            LinearRegionFile.USE_VIRTUAL_THREAD = linearUseVirtualThread;
++        }
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/utils/EnumRegionFormat.java b/src/main/java/me/earthme/luminol/utils/EnumRegionFormat.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..73b4f9b5f608322839cf1e37fbf1d3a147247c60
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/utils/EnumRegionFormat.java
+@@ -0,0 +1,40 @@
++package me.earthme.luminol.utils;
++
++import abomination.LinearRegionFile;
++import me.earthme.luminol.config.modules.misc.RegionFormatConfig;
++import net.minecraft.world.level.chunk.storage.RegionFile;
++import org.jetbrains.annotations.Nullable;
++
++public enum EnumRegionFormat {
++    MCA("mca", "mca" , (info) -> new RegionFile(info.info(), info.filePath(), info.folder(), info.sync())),
++    LINEAR_V2("linear_v2", "linear" ,(info) -> new LinearRegionFile(info.info(), info.filePath(), info.folder(), info.sync(), RegionFormatConfig.linearCompressionLevel));
++
++    private final String name;
++    private final String argument;
++    private final IRegionCreateFunction creator;
++
++    EnumRegionFormat(String name, String argument, IRegionCreateFunction creator) {
++        this.name = name;
++        this.argument = argument;
++        this.creator = creator;
++    }
++
++    @Nullable
++    public static EnumRegionFormat fromString(String string) {
++        for (EnumRegionFormat format : values()) {
++            if (format.name.equalsIgnoreCase(string)) {
++                return format;
++            }
++        }
++
++        return null;
++    }
++
++    public IRegionCreateFunction getCreator() {
++        return this.creator;
++    }
++
++    public String getArgument() {
++        return this.argument;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/utils/IRegionCreateFunction.java b/src/main/java/me/earthme/luminol/utils/IRegionCreateFunction.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..fb87ef13803122aa5a2e7f0c578de359140d4f31
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/utils/IRegionCreateFunction.java
+@@ -0,0 +1,9 @@
++package me.earthme.luminol.utils;
++
++import abomination.IRegionFile;
++
++import java.io.IOException;
++
++public interface IRegionCreateFunction {
++    IRegionFile create(RegionCreatorInfo info) throws IOException;
++}
+diff --git a/src/main/java/me/earthme/luminol/utils/RegionCreatorInfo.java b/src/main/java/me/earthme/luminol/utils/RegionCreatorInfo.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..5af068489646ed70330d8c6242ec88f536c4c289
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/utils/RegionCreatorInfo.java
+@@ -0,0 +1,7 @@
++package me.earthme.luminol.utils;
++
++import net.minecraft.world.level.chunk.storage.RegionStorageInfo;
++
++import java.nio.file.Path;
++
++public record RegionCreatorInfo (RegionStorageInfo info, Path filePath, Path folder, boolean sync) {}

luminol-server/paper-patches/features/0015-Add-config-for-watchdog-timeout.patch

@@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:51:22 +0800
+Subject: [PATCH] Add config for watchdog timeout
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/FoliaWatchogConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/FoliaWatchogConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..de58b5bf9dedf35bc56a9211d0769b988704a7fe
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/FoliaWatchogConfig.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 FoliaWatchogConfig implements IConfigModule {
++    @ConfigInfo(baseName = "tick_region_time_out_ms")
++    public static int tickRegionTimeOutMs = 5000;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "folia_watchdog";
++    }
++}

luminol-server/paper-patches/features/0016-Teleport-async-if-entity-was-moving-to-another-regio.patch

@@ -0,0 +1,40 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:53:42 +0800
+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..0e51d465db3554ac80d00c6b85cc1f013f3949ba
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaEntityMovingFixConfig.java
+@@ -0,0 +1,28 @@
++package me.earthme.luminol.config.modules.fixes;
++
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++
++public class FoliaEntityMovingFixConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled", comments =
++            """
++                    A simple fix of a issue on folia\s
++                    (Some times the entity would\s
++                    have a large moment that cross the\s
++                    different tick regions and it would\s
++                    make the server crashed)  but sometimes it might doesn't work""")
++    public static boolean enabled = false;
++    @ConfigInfo(baseName = "warn_on_detected")
++    public static boolean warnOnDetected = true;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.FIXES;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "folia.fix_high_velocity_issue";
++    }
++}

luminol-server/paper-patches/features/0017-Try-fixing-folia-off-region-POI-accessing-issue.patch

@@ -0,0 +1,37 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 10:57:00 +0800
+Subject: [PATCH] Try fixing folia off region POI accessing issue
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaPOIAccessOffRegionFixConfig.java b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaPOIAccessOffRegionFixConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..7812a71f05dd32646037afd22cdabf72bb23b0d1
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaPOIAccessOffRegionFixConfig.java
+@@ -0,0 +1,25 @@
++package me.earthme.luminol.config.modules.fixes;
++
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++
++public class FoliaPOIAccessOffRegionFixConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled", comments =
++            """
++                    The POIManager of folia has something which has not been patched\s
++                     for regionized ticking and these would trigger the async catcher\s
++                    and make the server crash.If you would like to prevent it and didn't\s
++                    mind the side effect(currently unknown), you can enable this""")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.FIXES;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "folia.fix_poi_access_off_region";
++    }
++}

luminol-server/paper-patches/features/0018-Force-disable-builtin-spark-plugin.patch

@@ -0,0 +1,59 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 11:00:50 +0800
+Subject: [PATCH] Force disable builtin spark plugin
+
+
+diff --git a/src/main/java/io/papermc/paper/plugin/provider/source/FileProviderSource.java b/src/main/java/io/papermc/paper/plugin/provider/source/FileProviderSource.java
+index a0b84535a9d3833d4df692b85b272f145559dd80..c2ba46408b5ad727d7a17f21d47b2898bb1ef8b4 100644
+--- a/src/main/java/io/papermc/paper/plugin/provider/source/FileProviderSource.java
++++ b/src/main/java/io/papermc/paper/plugin/provider/source/FileProviderSource.java
+@@ -87,7 +87,7 @@ public class FileProviderSource implements ProviderSource<Path, Path> {
+         }
+ 
+         final PluginMeta config = type.getConfig(file);
+-        if ((config.getName().equals("spark") && config.getMainClass().equals("me.lucko.spark.bukkit.BukkitSparkPlugin")) && !SparksFly.isPluginPreferred()) {
++        if ((config.getName().equals("spark") && config.getMainClass().equals("me.lucko.spark.bukkit.BukkitSparkPlugin")) && !SparksFly.isPluginPreferred() && false) { // Luminol - Force disable builtin spark
+             LOGGER.info("The spark plugin will not be loaded as this server bundles the spark profiler.");
+             return;
+         }
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index bcd17eba9798747010ed96903992939a284199df..f9f20e9fd4530d0130046b56c55e798d4ede29d1 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -313,7 +313,7 @@ public final class CraftServer implements Server {
+     public static Exception excessiveVelEx; // Paper - Velocity warnings
+     private final io.papermc.paper.logging.SysoutCatcher sysoutCatcher = new io.papermc.paper.logging.SysoutCatcher(); // Paper
+     private final io.papermc.paper.potion.PaperPotionBrewer potionBrewer; // Paper - Custom Potion Mixes
+-    public final io.papermc.paper.SparksFly spark; // Paper - spark
++    public io.papermc.paper.SparksFly spark; // Paper - spark // Luminol - Force disable builtin spark
+ 
+     // Paper start - Folia region threading API
+     private final io.papermc.paper.threadedregions.scheduler.FoliaRegionScheduler regionizedScheduler = new io.papermc.paper.threadedregions.scheduler.FoliaRegionScheduler(); // Folia - region threading
+@@ -491,7 +491,7 @@ public final class CraftServer implements Server {
+         }
+         this.potionBrewer = new io.papermc.paper.potion.PaperPotionBrewer(console); // Paper - custom potion mixes
+         datapackManager = new io.papermc.paper.datapack.PaperDatapackManager(console.getPackRepository()); // Paper
+-        this.spark = new io.papermc.paper.SparksFly(this); // Paper - spark
++        if (false) this.spark = new io.papermc.paper.SparksFly(this); // Paper - spark // Luminol - Force disable builtin spark
+     }
+ 
+     public boolean getCommandBlockOverride(String command) {
+@@ -1155,7 +1155,7 @@ public final class CraftServer implements Server {
+         this.reloadData();
+         org.spigotmc.SpigotConfig.registerCommands(); // Spigot
+         io.papermc.paper.command.PaperCommands.registerCommands(this.console); // Paper
+-        this.spark.registerCommandBeforePlugins(this); // Paper - spark
++        if (false) this.spark.registerCommandBeforePlugins(this); // Paper - spark // Luminol - Force disable builtin spark
+         this.overrideAllCommandBlockCommands = this.commandsConfiguration.getStringList("command-block-overrides").contains("*");
+         this.ignoreVanillaPermissions = this.commandsConfiguration.getBoolean("ignore-vanilla-permissions");
+ 
+@@ -1184,7 +1184,7 @@ public final class CraftServer implements Server {
+         this.loadPlugins();
+         this.enablePlugins(PluginLoadOrder.STARTUP);
+         this.enablePlugins(PluginLoadOrder.POSTWORLD);
+-        this.spark.registerCommandAfterPlugins(this); // Paper - spark
++        if (false) this.spark.registerCommandAfterPlugins(this); // Paper - spark // Luminol - Force disable builtin spark
+         if (io.papermc.paper.plugin.PluginInitializerManager.instance().pluginRemapper != null) io.papermc.paper.plugin.PluginInitializerManager.instance().pluginRemapper.pluginsEnabled(); // Paper - Remap plugins
+         // Paper start - brigadier command API
+         io.papermc.paper.command.brigadier.PaperCommands.INSTANCE.setValid(); // to clear invalid state for event fire below

luminol-server/paper-patches/features/0019-KioCG-Chunk-API-and-display-of-chunkhot-in-tpsbar.patch

@@ -0,0 +1,201 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Wed, 29 Jan 2025 09:12:07 +0800
+Subject: [PATCH] KioCG Chunk API and display of chunkhot in tpsbar
+
+
+diff --git a/src/main/java/com/kiocg/ChunkHot.java b/src/main/java/com/kiocg/ChunkHot.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..53b4397997bc9b9b9d88e48304b37a2590161906
+--- /dev/null
++++ b/src/main/java/com/kiocg/ChunkHot.java
+@@ -0,0 +1,90 @@
++package com.kiocg;
++
++import java.util.Arrays;
++
++public class ChunkHot {
++    // 热度统计总区间数量
++    private static final int TIMES_LENGTH = 10;
++    // 当前统计区间下标
++    private int index = -1;
++
++    // 热度统计区间
++    private final long[] times = new long[TIMES_LENGTH];
++    // 存放临时的区间数值
++    // 用于修正正在统计的当前区间热度没有计入总值的问题
++    private long temp;
++    // 所有区间的热度总值
++    private long total;
++
++    // 用于每个具体统计的计算
++    private long nanos;
++    // 当前统计是否进行中
++    private volatile boolean started = false;
++
++    /**
++     * 更新区间下标
++     */
++    public void nextTick() {
++        this.index = ++this.index % TIMES_LENGTH;
++    }
++
++    /**
++     * 开始统计一个新区间
++     */
++    public void start() {
++        started = true;
++        temp = times[this.index];
++        times[this.index] = 0L;
++    }
++
++    public boolean isStarted(){
++        return this.started;
++    }
++
++    /**
++     * 结束当前区间的统计
++     * 将统计值更新入热度总值
++     */
++    public void stop() {
++        started = false;
++        total -= temp;
++        total += times[this.index];
++    }
++
++    /**
++     * 开始一个具体统计
++     */
++    public void startTicking() {
++        if (!started) return;
++        nanos = System.nanoTime();
++    }
++
++    /**
++     * 结束一个具体统计
++     * 将统计值计入当前热度区间
++     */
++    public void stopTickingAndCount() {
++        if (!started) return;
++        // 定义一个具体统计的最大值为 1,000,000
++        // 有时候某个具体统计的计算值会在某1刻飙升，可能是由于保存数据到磁盘？
++        times[this.index] += Math.min(System.nanoTime() - nanos, 1000000L);
++    }
++
++    /**
++     * 清空统计 (当区块卸载时)
++     */
++    public void clear() {
++        started = false;
++        Arrays.fill(times, 0L);
++        temp = 0L;
++        total = 0L;
++        nanos = 0L;
++    }
++
++    /**
++     * @return 获取区块热度平均值
++     */
++    public long getAverage() {
++        return total / ((long) TIMES_LENGTH * 20L);
++    }
++}
+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
+index aafb2f5052c7c8e5971a47308253badb3027093c..9fe7ac7ba83bbcc9a2a851a5cace47641323f4d2 100644
+--- a/src/main/java/me/earthme/luminol/config/modules/misc/TpsBarConfig.java
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/TpsBarConfig.java
+@@ -12,11 +12,13 @@ public class TpsBarConfig implements IConfigModule {
+     @ConfigInfo(baseName = "enabled")
+     public static boolean tpsbarEnabled = false;
+     @ConfigInfo(baseName = "format")
+-    public static String tpsBarFormat = "<gray>TPS<yellow>:</yellow> <tps> MSPT<yellow>:</yellow> <mspt> Ping<yellow>:</yellow> <ping>ms";
++    public static String tpsBarFormat = "<gray>TPS<yellow>:</yellow> <tps> MSPT<yellow>:</yellow> <mspt> Ping<yellow>:</yellow> <ping>ms ChunkHot<yellow>:</yellow> <chunkhot>";
+     @ConfigInfo(baseName = "tps_color_list")
+     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 = "chunkhot_color_list")
++    public static List<String> chunkHotColors = List.of("GREEN","YELLOW","RED","PURPLE");
+     @ConfigInfo(baseName = "update_interval_ticks")
+     public static int updateInterval = 15;
+ 
+diff --git a/src/main/java/me/earthme/luminol/functions/GlobalServerTpsBar.java b/src/main/java/me/earthme/luminol/functions/GlobalServerTpsBar.java
+index de2f03d6e771c09e8da2da454b7ec4a16c0a17ab..0b7347e8fdf995900221ee4aa4e97a4d260c6f9f 100644
+--- a/src/main/java/me/earthme/luminol/functions/GlobalServerTpsBar.java
++++ b/src/main/java/me/earthme/luminol/functions/GlobalServerTpsBar.java
+@@ -128,7 +128,8 @@ public class GlobalServerTpsBar {
+                 TpsBarConfig.tpsBarFormat,
+                 Placeholder.component("tps",getTpsComponent(tps)),
+                 Placeholder.component("mspt",getMsptComponent(mspt)),
+-                Placeholder.component("ping",getPingComponent(player.getPing()))
++                Placeholder.component("ping",getPingComponent(player.getPing())),
++                Placeholder.component("chunkhot",getChunkHotComponent(player.getNearbyChunkHot()))
+         ));
+         bar.color(barColorFromTps(tps));
+         bar.progress((float) Math.min((float)1,Math.max(mspt / 50,0)));
+@@ -170,6 +171,32 @@ public class GlobalServerTpsBar {
+         return MiniMessage.miniMessage().deserialize(replaced,Placeholder.parsed("text", String.format("%.2f", mspt)));
+     }
+ 
++    private static @NotNull Component getChunkHotComponent(long chunkHot){
++        final BossBar.Color colorBukkit = barColorFromChunkHot(chunkHot);
++        final String colorString = colorBukkit.name();
++
++        final String content = "<%s><text></%s>";
++        final String replaced = String.format(content,colorString,colorString);
++
++        return MiniMessage.miniMessage().deserialize(replaced,Placeholder.parsed("text", String.valueOf(chunkHot)));
++    }
++
++    private static BossBar.Color barColorFromChunkHot(long chunkHot){
++        if (chunkHot == -1){
++            return BossBar.Color.valueOf(TpsBarConfig.chunkHotColors.get(3));
++        }
++
++        if (chunkHot <= 300000L){
++            return BossBar.Color.valueOf(TpsBarConfig.chunkHotColors.get(0));
++        }
++
++        if (chunkHot <= 500000L){
++            return BossBar.Color.valueOf(TpsBarConfig.chunkHotColors.get(1));
++        }
++
++        return BossBar.Color.valueOf(TpsBarConfig.chunkHotColors.get(2));
++    }
++
+     private static BossBar.Color barColorFromMspt(double mspt){
+         if (mspt == -1){
+             return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(3));
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
+index de8b9048c8395c05b8688bc9d984b8ad680f15b3..f42692cd4f0154705c3d5b030d281cfc333803ed 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
+@@ -437,4 +437,12 @@ public class CraftChunk implements Chunk {
+     static {
+         Arrays.fill(FULL_LIGHT, (byte) 0xFF);
+     }
++
++    // KioCG start - ChunkHot
++    @Override
++    public long getChunkHotAvg() {
++        final net.minecraft.world.level.chunk.LevelChunk target = this.worldServer.getChunkIfLoaded(this.x,this.z);
++        return target == null ? -1 : target.getChunkHot().getAverage();
++    }
++    // KioCG end
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 7a112a3a0a9411a166666c657dac6b7888105545..8e9190da44839ba62880cf3218b5d5aaf300e34f 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -3605,4 +3605,11 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         handle.containerMenu.broadcastChanges();
+         return new PaperPlayerGiveResult(leftovers.build(), drops.build());
+     }
++
++    // KioCG start - ChunkHot
++    @Override
++    public long getNearbyChunkHot() {
++        return this.getHandle().getNearbyChunkHot();
++    }
++    // KioCG end
+ }

luminol-server/paper-patches/features/0020-Kaiiju-Entity-tick-and-removal-limiter.patch

@@ -0,0 +1,272 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 11:07:09 +0800
+Subject: [PATCH] Kaiiju Entity tick and removal limiter
+
+
+diff --git a/src/main/java/dev/kaiijumc/kaiiju/KaiijuEntityLimits.java b/src/main/java/dev/kaiijumc/kaiiju/KaiijuEntityLimits.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..40e80fc685a42bbaeea3e6e64754121178cc7d22
+--- /dev/null
++++ b/src/main/java/dev/kaiijumc/kaiiju/KaiijuEntityLimits.java
+@@ -0,0 +1,141 @@
++package dev.kaiijumc.kaiiju;
++
++import java.io.File;
++import java.io.IOException;
++import java.util.Map;
++import java.util.HashMap;
++import java.util.logging.Level;
++
++import com.google.common.base.Throwables;
++import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
++import io.github.classgraph.ClassGraph;
++import io.github.classgraph.ClassInfo;
++import io.github.classgraph.ScanResult;
++import org.slf4j.Logger;
++
++import com.mojang.logging.LogUtils;
++import net.minecraft.world.entity.Entity;
++import org.bukkit.Bukkit;
++import org.bukkit.configuration.InvalidConfigurationException;
++import org.bukkit.configuration.file.YamlConfiguration;
++
++@SuppressWarnings("unused")
++public class KaiijuEntityLimits {
++    private static final Logger LOGGER = LogUtils.getLogger();
++    private static final File CONFIG_FOLDER = new File("luminol_config");
++
++    protected static final String HEADER =
++        "Per region entity limits for Kaiiju.\n"
++        + "If there are more of particular entity type in a region than limit, entity ticking will be throttled.\n"
++        + "Example: for Wither limit 100 & 300 Withers in a region -> 100 Withers tick every tick & every Wither ticks every 3 ticks.\n"
++        + "Available entities: GlowSquid, Ambient, Bat, Animal, Bee, Cat, Chicken, Cod, Cow, Dolphin, Fish, FishSchool, Fox, Golem, IronGolem, "
++        + "MushroomCow, Ocelot, Panda, Parrot, Perchable, Pig, PolarBear, PufferFish, Rabbit, Salmon, Sheep, Snowman, Squid, TropicalFish, Turtle, "
++        + "WaterAnimal, Wolf, Allay, Axolotl, Camel, Frog, Tadpole, Goat, Horse, HorseAbstract, HorseChestedAbstract, HorseDonkey, HorseMule, "
++        + "HorseSkeleton, HorseZombie, Llama, LlamaTrader, Sniffer, EnderCrystal, EnderDragon, Wither, ArmorStand, Hanging, ItemFrame, Leash, "
++        + "Painting, GlowItemFrame, FallingBlock, Item, TNTPrimed, Blaze, CaveSpider, Creeper, Drowned, Enderman, Endermite, Evoker, Ghast, "
++        + "GiantZombie, Guardian, GuardianElder, IllagerAbstract, IllagerIllusioner, IllagerWizard, MagmaCube, Monster, MonsterPatrolling, Phantom, "
++        + "PigZombie, Pillager, Ravager, Shulker, Silverfish, Skeleton, SkeletonAbstract, SkeletonStray, SkeletonWither, Slime, Spider, Strider, Vex, "
++        + "Vindicator, Witch, Zoglin, Zombie, ZombieHusk, ZombieVillager, Hoglin, Piglin, PiglinAbstract, PiglinBrute, Warden, Villager, "
++        + "VillagerTrader, Arrow, DragonFireball, Egg, EnderPearl, EnderSignal, EvokerFangs, Fireball, FireballFireball, Fireworks, FishingHook, "
++        + "LargeFireball, LlamaSpit, Potion, Projectile, ProjectileThrowable, ShulkerBullet, SmallFireball, Snowball, SpectralArrow, ThrownExpBottle, "
++        + "ThrownTrident, TippedArrow, WitherSkull, Raider, ChestBoat, Boat, MinecartAbstract, MinecartChest, MinecartCommandBlock, MinecartContainer, "
++        + "MinecartFurnace, MinecartHopper, MinecartMobSpawner, MinecartRideable, MinecartTNT\n";
++    protected static final File ENTITY_LIMITS_FILE = new File(CONFIG_FOLDER, "kaiiju_entity_limits.yml");
++    public static YamlConfiguration entityLimitsConfig;
++    public static boolean enabled = false;
++
++    protected static Map<Class<? extends Entity>, EntityLimit> entityLimits;
++
++    static final String ENTITY_PREFIX = "Entity";
++
++    public static void init() {
++        init(true);
++    }
++
++    private static void init(boolean setup) {
++        entityLimitsConfig = new YamlConfiguration();
++
++        if (ENTITY_LIMITS_FILE.exists()) {
++            try {
++                entityLimitsConfig.load(ENTITY_LIMITS_FILE);
++            } catch (InvalidConfigurationException ex) {
++                Bukkit.getLogger().log(Level.SEVERE, "Could not load kaiiju_entity_limits.yml, please correct your syntax errors", ex);
++                throw Throwables.propagate(ex);
++            } catch (IOException ignore) {}
++        } else {
++            if (setup) {
++                entityLimitsConfig.options().header(HEADER);
++                entityLimitsConfig.options().copyDefaults(true);
++                entityLimitsConfig.set("enabled", enabled);
++                entityLimitsConfig.set("Axolotl.limit", 1000);
++                entityLimitsConfig.set("Axolotl.removal", 2000);
++                try {
++                    entityLimitsConfig.save(ENTITY_LIMITS_FILE);
++                } catch (IOException ex) {
++                    Bukkit.getLogger().log(Level.SEVERE, "Could not save " + ENTITY_LIMITS_FILE, ex);
++                }
++            }
++        }
++
++        enabled = entityLimitsConfig.getBoolean("enabled");
++
++        entityLimits = new Object2ObjectOpenHashMap<>();
++        try (ScanResult scanResult = new ClassGraph().enableAllInfo().acceptPackages("net.minecraft.world.entity").scan()) {
++            Map<String, ClassInfo> entityClasses = new HashMap<>();
++            for (ClassInfo classInfo : scanResult.getAllClasses()) {
++                Class<?> entityClass = Class.forName(classInfo.getName());
++                if (Entity.class.isAssignableFrom(entityClass)) {
++                    String entityName = extractEntityName(entityClass.getSimpleName());
++                    entityClasses.put(entityName, classInfo);
++                }
++            }
++
++            for (String key : entityLimitsConfig.getKeys(false)) {
++                if (key.equals("enabled")) {
++                    continue;
++                }
++
++                if (!entityClasses.containsKey(key)) {
++                    LOGGER.error("Unknown entity '" + key + "' in kaiiju-entity-limits.yml, skipping");
++                    continue;
++                }
++                int limit = entityLimitsConfig.getInt(key + ".limit");
++                int removal = entityLimitsConfig.getInt(key + ".removal");
++
++                if (limit < 1) {
++                    LOGGER.error(key + " has a limit less than the minimum of 1, ignoring");
++                    continue;
++                }
++                if (removal <= limit && removal != -1) {
++                    LOGGER.error(key + " has a removal limit that is less than or equal to its limit, setting removal to limit * 10");
++                    removal = limit * 10;
++                }
++
++                entityLimits.put((Class<? extends Entity>) Class.forName(entityClasses.get(key).getName()), new EntityLimit(limit, removal));
++            }
++        } catch (ClassNotFoundException e) {
++            e.printStackTrace();
++        }
++    }
++
++    public static EntityLimit getEntityLimit(Entity entity) {
++        return entityLimits.get(entity.getClass());
++    }
++
++    private static String extractEntityName(String input) {
++        int prefixLength = ENTITY_PREFIX.length();
++
++        if (input.length() <= prefixLength || !input.startsWith(ENTITY_PREFIX)) {
++            return input;
++        } else {
++            return input.substring(prefixLength);
++        }
++    }
++
++    public record EntityLimit(int limit, int removal) {
++        @Override
++        public String toString() {
++            return "EntityLimit{limit=" + limit + ", removal=" + removal + "}";
++        }
++    }
++}
+diff --git a/src/main/java/dev/kaiijumc/kaiiju/KaiijuEntityThrottler.java b/src/main/java/dev/kaiijumc/kaiiju/KaiijuEntityThrottler.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..eb690efacf083e4ff3e321578b12c534e6a40196
+--- /dev/null
++++ b/src/main/java/dev/kaiijumc/kaiiju/KaiijuEntityThrottler.java
+@@ -0,0 +1,84 @@
++package dev.kaiijumc.kaiiju;
++
++import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
++import net.minecraft.world.entity.Entity;
++import io.papermc.paper.threadedregions.RegionizedWorldData;
++
++public class KaiijuEntityThrottler {
++    private static class TickInfo {
++        int currentTick;
++        int continueFrom;
++        int toTick;
++        int toRemove;
++    }
++
++    public static class EntityThrottlerReturn {
++        public boolean skip;
++        public boolean remove;
++    }
++
++    private final Object2ObjectOpenHashMap<KaiijuEntityLimits.EntityLimit, TickInfo> entityLimitTickInfoMap = new Object2ObjectOpenHashMap<>();
++
++    public void tickLimiterStart() {
++        for (TickInfo tickInfo : entityLimitTickInfoMap.values()) {
++            tickInfo.currentTick = 0;
++        }
++    }
++
++    public EntityThrottlerReturn tickLimiterShouldSkip(Entity entity) {
++        EntityThrottlerReturn retVal = new EntityThrottlerReturn();
++        if (entity.isRemoved()) return retVal;
++        KaiijuEntityLimits.EntityLimit entityLimit = KaiijuEntityLimits.getEntityLimit(entity);
++
++        if (entityLimit != null) {
++            TickInfo tickInfo = entityLimitTickInfoMap.computeIfAbsent(entityLimit, el -> {
++                TickInfo newTickInfo = new TickInfo();
++                newTickInfo.toTick = entityLimit.limit();
++                return newTickInfo;
++            });
++
++            tickInfo.currentTick++;
++            if (tickInfo.currentTick <= tickInfo.toRemove && entityLimit.removal() > 0) {
++                retVal.skip = false;
++                retVal.remove = true;
++                return retVal;
++            }
++
++            if (tickInfo.currentTick < tickInfo.continueFrom) {
++                retVal.skip = true;
++                return retVal;
++            }
++            if (tickInfo.currentTick - tickInfo.continueFrom < tickInfo.toTick) {
++                retVal.skip = false;
++                return retVal;
++            }
++            retVal.skip = true;
++            return retVal;
++        } else {
++            retVal.skip = false;
++            return retVal;
++        }
++    }
++
++    public void tickLimiterFinish(RegionizedWorldData regionizedWorldData) {
++        for (var entry : entityLimitTickInfoMap.entrySet()) {
++            KaiijuEntityLimits.EntityLimit entityLimit = entry.getKey();
++            TickInfo tickInfo = entry.getValue();
++
++            int additionals = 0;
++            int nextContinueFrom = tickInfo.continueFrom + tickInfo.toTick;
++            if (nextContinueFrom >= tickInfo.currentTick) {
++                additionals = entityLimit.limit() - (tickInfo.currentTick - tickInfo.continueFrom);
++                nextContinueFrom = 0;
++            }
++            tickInfo.continueFrom = nextContinueFrom;
++            tickInfo.toTick = entityLimit.limit() + additionals;
++
++            if (tickInfo.toRemove == 0 && tickInfo.currentTick > entityLimit.removal()) {
++                tickInfo.toRemove = tickInfo.currentTick - entityLimit.removal();
++            } else if (tickInfo.toRemove != 0) {
++                tickInfo.toRemove = 0;
++            }
++        }
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/KaiijuEntityLimiterConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/KaiijuEntityLimiterConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..038d9ab60cfac7e40e7c0c0644fa0a0d035eac01
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/KaiijuEntityLimiterConfig.java
+@@ -0,0 +1,23 @@
++package me.earthme.luminol.config.modules.misc;
++
++import com.electronwill.nightconfig.core.file.CommentedFileConfig;
++import dev.kaiijumc.kaiiju.KaiijuEntityLimits;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++
++public class KaiijuEntityLimiterConfig implements IConfigModule {
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "kaiiju_entity_limiter";
++    }
++
++    @Override
++    public void onLoaded(CommentedFileConfig configInstance) {
++        KaiijuEntityLimits.init();
++    }
++}

luminol-server/paper-patches/features/0021-Purpur-use-alternative-keep-alive.patch

@@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 11:43:17 +0800
+Subject: [PATCH] Purpur use alternative keep alive
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/optimizations/PurpurAlternativeKeepaliveConfig.java b/src/main/java/me/earthme/luminol/config/modules/optimizations/PurpurAlternativeKeepaliveConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..43bbc2c30bdd3872a0179e0070403c3e257c320e
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/optimizations/PurpurAlternativeKeepaliveConfig.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 PurpurAlternativeKeepaliveConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean useAlternateKeepAlive = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.OPTIMIZATIONS;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "alternative_keepalive_handling";
++    }
++}

luminol-server/paper-patches/features/0022-Petal-Reduce-sensor-work.patch

@@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 12:22:00 +0800
+Subject: [PATCH] Petal Reduce sensor work
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/optimizations/PetalReduceSensorWorkConfig.java b/src/main/java/me/earthme/luminol/config/modules/optimizations/PetalReduceSensorWorkConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..dd45cf1fde5ee4cf8347064f106c64b861b77ead
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/optimizations/PetalReduceSensorWorkConfig.java
+@@ -0,0 +1,22 @@
++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 PetalReduceSensorWorkConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = true;
++    @ConfigInfo(baseName = "delay_ticks")
++    public static int delayTicks = 10;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.OPTIMIZATIONS;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "reduce_sensor_work";
++    }
++}

luminol-server/paper-patches/features/0023-Pufferfish-Reduce-projectile-chunk-loading.patch

@@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 12:29:28 +0800
+Subject: [PATCH] Pufferfish Reduce projectile chunk loading
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/optimizations/ProjectileChunkReduceConfig.java b/src/main/java/me/earthme/luminol/config/modules/optimizations/ProjectileChunkReduceConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..12683ec5a5102e45b6171fea0b833ba57e5e188c
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/optimizations/ProjectileChunkReduceConfig.java
+@@ -0,0 +1,22 @@
++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 ProjectileChunkReduceConfig implements IConfigModule {
++    @ConfigInfo(baseName = "max-loads-per-tick")
++    public static int maxProjectileLoadsPerTick;
++    @ConfigInfo(baseName = "max-loads-per-projectile")
++    public static int maxProjectileLoadsPerProjectile;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.OPTIMIZATIONS;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "projectile";
++    }
++}

luminol-server/paper-patches/features/0024-Pufferfish-Optimize-suffocation.patch

@@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 12:30:50 +0800
+Subject: [PATCH] Pufferfish Optimize suffocation
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/optimizations/SuffocationOptimizationConfig.java b/src/main/java/me/earthme/luminol/config/modules/optimizations/SuffocationOptimizationConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..3e48cd297b4869e5c89b6abc43c726d3a7511e7f
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/optimizations/SuffocationOptimizationConfig.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 SuffocationOptimizationConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.OPTIMIZATIONS;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "suffocation_optimization";
++    }
++}

luminol-server/paper-patches/features/0025-Pufferfish-Throttle-goal-selector-during-inactive-ti.patch

@@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 12:34:05 +0800
+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";
++    }
++}

luminol-server/paper-patches/features/0026-Pufferfish-SIMD-Utilities.patch

@@ -0,0 +1,65 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 15:22:25 +0800
+Subject: [PATCH] Pufferfish SIMD Utilities
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/optimizations/SIMDConfig.java b/src/main/java/me/earthme/luminol/config/modules/optimizations/SIMDConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..76cea165bcef0794a66ef7c29721f7716869420f
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/optimizations/SIMDConfig.java
+@@ -0,0 +1,53 @@
++package me.earthme.luminol.config.modules.optimizations;
++
++import com.electronwill.nightconfig.core.file.CommentedFileConfig;
++import com.mojang.logging.LogUtils;
++import gg.pufferfish.pufferfish.simd.SIMDDetection;
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.DoNotLoad;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++import org.slf4j.Logger;
++
++public class SIMDConfig implements IConfigModule {
++    @DoNotLoad
++    private static final Logger LOGGER = LogUtils.getLogger();
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = true;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.OPTIMIZATIONS;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "use_simd";
++    }
++
++    @Override
++    public void onLoaded(CommentedFileConfig configInstance) {
++        if (!enabled){
++            return;
++        }
++
++        // Attempt to detect vectorization
++        try {
++            SIMDDetection.isEnabled = SIMDDetection.canEnable(LOGGER);
++            SIMDDetection.versionLimited = SIMDDetection.getJavaVersion() < 17;
++        } catch (NoClassDefFoundError | Exception ignored) {
++            ignored.printStackTrace();
++        }
++
++        if (SIMDDetection.isEnabled) {
++            LOGGER.info("SIMD operations detected as functional. Will replace some operations with faster versions.");
++        } else if (SIMDDetection.versionLimited) {
++            LOGGER.warn("Will not enable SIMD! These optimizations are only safely supported on Java 17+.");
++        } else {
++            LOGGER.warn("SIMD operations are available for your server, but are not configured!");
++            LOGGER.warn("To enable additional optimizations, add \"--add-modules=jdk.incubator.vector\" to your startup flags, BEFORE the \"-jar\".");
++            LOGGER.warn("If you have already added this flag, then SIMD operations are not supported on your JVM or CPU.");
++            LOGGER.warn("Debug: Java: {}, test run: {}", System.getProperty("java.version"), SIMDDetection.testRun);
++        }
++    }
++}

luminol-server/paper-patches/features/0027-Pufferfish-Sentry.patch

@@ -0,0 +1,249 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 15:26:09 +0800
+Subject: [PATCH] Pufferfish Sentry
+
+
+diff --git a/src/main/java/gg/pufferfish/pufferfish/sentry/PufferfishSentryAppender.java b/src/main/java/gg/pufferfish/pufferfish/sentry/PufferfishSentryAppender.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..2b830cb288ceba390ed39cd33fc1ee855357a97e
+--- /dev/null
++++ b/src/main/java/gg/pufferfish/pufferfish/sentry/PufferfishSentryAppender.java
+@@ -0,0 +1,133 @@
++package gg.pufferfish.pufferfish.sentry;
++
++import com.google.common.reflect.TypeToken;
++import com.google.gson.Gson;
++import io.sentry.Breadcrumb;
++import io.sentry.Sentry;
++import io.sentry.SentryEvent;
++import io.sentry.SentryLevel;
++import io.sentry.protocol.Message;
++import io.sentry.protocol.User;
++
++import java.util.Map;
++
++import me.earthme.luminol.config.modules.misc.SentryConfig;
++import org.apache.logging.log4j.Level;
++import org.apache.logging.log4j.LogManager;
++import org.apache.logging.log4j.Marker;
++import org.apache.logging.log4j.core.LogEvent;
++import org.apache.logging.log4j.core.Logger;
++import org.apache.logging.log4j.core.appender.AbstractAppender;
++import org.apache.logging.log4j.core.filter.AbstractFilter;
++
++public class PufferfishSentryAppender extends AbstractAppender {
++
++    private static final org.apache.logging.log4j.Logger logger = LogManager.getLogger(PufferfishSentryAppender.class.getSimpleName());
++    private static final Gson GSON = new Gson();
++    private final Level logLevel;
++
++    public PufferfishSentryAppender(Level logLevel) {
++        super("PufferfishSentryAdapter", new SentryFilter(), null);
++        this.logLevel = logLevel;
++    }
++
++    @Override
++    public void append(LogEvent logEvent) {
++        if (logEvent.getLevel().isMoreSpecificThan(logLevel) && (logEvent.getThrown() != null || !SentryConfig.onlyLogThrown)) {
++            try {
++                logException(logEvent);
++            } catch (Exception e) {
++                logger.warn("Failed to log event with sentry", e);
++            }
++        } else {
++            try {
++                logBreadcrumb(logEvent);
++            } catch (Exception e) {
++                logger.warn("Failed to log event with sentry", e);
++            }
++        }
++    }
++
++    private void logException(LogEvent e) {
++        SentryEvent event = new SentryEvent(e.getThrown());
++
++        Message sentryMessage = new Message();
++        sentryMessage.setMessage(e.getMessage().getFormattedMessage());
++
++        event.setThrowable(e.getThrown());
++        event.setLevel(getLevel(e.getLevel()));
++        event.setLogger(e.getLoggerName());
++        event.setTransaction(e.getLoggerName());
++        event.setExtra("thread_name", e.getThreadName());
++
++        boolean hasContext = e.getContextData() != null;
++
++        if (hasContext && e.getContextData().containsKey("pufferfishsentry_playerid")) {
++            User user = new User();
++            user.setId(e.getContextData().getValue("pufferfishsentry_playerid"));
++            user.setUsername(e.getContextData().getValue("pufferfishsentry_playername"));
++            event.setUser(user);
++        }
++
++        if (hasContext && e.getContextData().containsKey("pufferfishsentry_pluginname")) {
++            event.setExtra("plugin.name", e.getContextData().getValue("pufferfishsentry_pluginname"));
++            event.setExtra("plugin.version", e.getContextData().getValue("pufferfishsentry_pluginversion"));
++            event.setTransaction(e.getContextData().getValue("pufferfishsentry_pluginname"));
++        }
++
++        if (hasContext && e.getContextData().containsKey("pufferfishsentry_eventdata")) {
++            Map<String, String> eventFields = GSON.fromJson((String) e.getContextData().getValue("pufferfishsentry_eventdata"), new TypeToken<Map<String, String>>() {
++            }.getType());
++            if (eventFields != null) {
++                event.setExtra("event", eventFields);
++            }
++        }
++
++        Sentry.captureEvent(event);
++    }
++
++    private void logBreadcrumb(LogEvent e) {
++        Breadcrumb breadcrumb = new Breadcrumb();
++
++        breadcrumb.setLevel(getLevel(e.getLevel()));
++        breadcrumb.setCategory(e.getLoggerName());
++        breadcrumb.setType(e.getLoggerName());
++        breadcrumb.setMessage(e.getMessage().getFormattedMessage());
++
++        Sentry.addBreadcrumb(breadcrumb);
++    }
++
++    private SentryLevel getLevel(Level level) {
++        return switch (level.getStandardLevel()) {
++            case TRACE, DEBUG -> SentryLevel.DEBUG;
++            case WARN -> SentryLevel.WARNING;
++            case ERROR -> SentryLevel.ERROR;
++            case FATAL -> SentryLevel.FATAL;
++            default -> SentryLevel.INFO;
++        };
++    }
++
++    private static class SentryFilter extends AbstractFilter {
++
++        @Override
++        public Result filter(Logger logger, Level level, Marker marker, String msg,
++                             Object... params) {
++            return this.filter(logger.getName());
++        }
++
++        @Override
++        public Result filter(Logger logger, Level level, Marker marker, Object msg, Throwable t) {
++            return this.filter(logger.getName());
++        }
++
++        @Override
++        public Result filter(LogEvent event) {
++            return this.filter(event == null ? null : event.getLoggerName());
++        }
++
++        private Result filter(String loggerName) {
++            return loggerName != null && loggerName.startsWith("gg.castaway.pufferfish.sentry") ? Result.DENY
++                    : Result.NEUTRAL;
++        }
++    }
++}
+diff --git a/src/main/java/gg/pufferfish/pufferfish/sentry/SentryManager.java b/src/main/java/gg/pufferfish/pufferfish/sentry/SentryManager.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..c01e5b5de685eca7edbe8a87732efd45d4dd2557
+--- /dev/null
++++ b/src/main/java/gg/pufferfish/pufferfish/sentry/SentryManager.java
+@@ -0,0 +1,44 @@
++package gg.pufferfish.pufferfish.sentry;
++
++import io.sentry.Sentry;
++import org.apache.logging.log4j.Level;
++import org.apache.logging.log4j.LogManager;
++import org.apache.logging.log4j.Logger;
++
++public class SentryManager {
++
++    private static final Logger logger = LogManager.getLogger(SentryManager.class);
++
++    private SentryManager() {
++
++    }
++
++    private static boolean initialized = false;
++
++    public static synchronized void init(Level logLevel) {
++        if (initialized) {
++            return;
++        }
++        if (logLevel == null) {
++            logger.error("Invalid log level, defaulting to WARN.");
++            logLevel = Level.WARN;
++        }
++        try {
++            initialized = true;
++
++            Sentry.init(options -> {
++                options.setDsn(me.earthme.luminol.config.modules.misc.SentryConfig.sentryDsn);
++                options.setMaxBreadcrumbs(100);
++            });
++
++            PufferfishSentryAppender appender = new PufferfishSentryAppender(logLevel);
++            appender.start();
++            ((org.apache.logging.log4j.core.Logger) LogManager.getRootLogger()).addAppender(appender);
++            logger.info("Sentry logging started!");
++        } catch (Exception e) {
++            logger.warn("Failed to initialize sentry!", e);
++            initialized = false;
++        }
++    }
++
++}
+diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/SentryConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/SentryConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..55d6bb635b182d15471bfcd481a2b7c6ce26c00b
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/SentryConfig.java
+@@ -0,0 +1,47 @@
++package me.earthme.luminol.config.modules.misc;
++
++import com.electronwill.nightconfig.core.file.CommentedFileConfig;
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++import org.apache.logging.log4j.Level;
++
++public class SentryConfig implements IConfigModule {
++
++    @ConfigInfo(baseName = "dsn", comments =
++            " Sentry DSN for improved error logging, leave blank to disable,\n" +
++                    " Obtain from https://sentry.io/")
++    public static String sentryDsn = "";
++
++    @ConfigInfo(baseName = "log_level", comments = " Logs with a level higher than or equal to this level will be recorded.")
++    public static String logLevel = "WARN";
++
++    @ConfigInfo(baseName = "only_log_thrown", comments = " Only log with a Throwable will be recorded after enabling this.")
++    public static boolean onlyLogThrown = true;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "sentry";
++    }
++
++    @Override
++    public void onLoaded(CommentedFileConfig configInstance) {
++        String sentryEnvironment = System.getenv("SENTRY_DSN");
++
++        sentryDsn = sentryEnvironment != null && !sentryEnvironment.isBlank()
++                ? sentryEnvironment
++                : configInstance.getOrElse("sentry.dsn", sentryDsn);
++
++        logLevel = configInstance.getOrElse("sentry.log-level", logLevel);
++        onlyLogThrown = configInstance.getOrElse("sentry.only-log-thrown", onlyLogThrown);
++
++        if (sentryDsn != null && !sentryDsn.isBlank()) {
++            gg.pufferfish.pufferfish.sentry.SentryManager.init(Level.getLevel(logLevel));
++        }
++    }
++}
+\ No newline at end of file

luminol-server/paper-patches/features/0028-Gale-Variable-entity-wake-up-duration.patch

@@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 15:31:53 +0800
+Subject: [PATCH] Gale Variable entity wake-up duration
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/optimizations/GaleVariableEntityWakeupConfig.java b/src/main/java/me/earthme/luminol/config/modules/optimizations/GaleVariableEntityWakeupConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..fa30e8dc39a2d4bd1399e41230b307b19eeb716a
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/optimizations/GaleVariableEntityWakeupConfig.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 GaleVariableEntityWakeupConfig implements IConfigModule {
++    @ConfigInfo(baseName = "entity_wakeup_duration_ratio_standard_deviation")
++    public static double entityWakeUpDurationRatioStandardDeviation = 0.2;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.OPTIMIZATIONS;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "variable_entity_waking_up";
++    }
++}

luminol-server/paper-patches/features/0029-SparklyPaper-Optimize-canSee-checks.patch

@@ -0,0 +1,37 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 15:35:44 +0800
+Subject: [PATCH] SparklyPaper Optimize canSee checks
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 8e9190da44839ba62880cf3218b5d5aaf300e34f..e411f0e94b983fce88c67e9dadc0f6ded90e973c 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -213,7 +213,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     private boolean hasPlayedBefore = false;
+     private final ConversationTracker conversationTracker = new ConversationTracker();
+     private final Set<String> channels = new HashSet<String>();
+-    private final Map<UUID, Set<WeakReference<Plugin>>> invertedVisibilityEntities = new HashMap<>();
++    private final Map<UUID, Set<WeakReference<Plugin>>> invertedVisibilityEntities = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(); // SparklyPaper - optimize canSee checks
+     private final Set<UUID> unlistedEntities = new HashSet<>(); // Paper - Add Listing API for Player
+     private static final WeakHashMap<Plugin, WeakReference<Plugin>> pluginWeakReferences = new WeakHashMap<>();
+     private int hash = 0;
+@@ -2267,9 +2267,16 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+ 
+     @Override
+     public boolean canSee(org.bukkit.entity.Entity entity) {
+-        return this.equals(entity) || entity.isVisibleByDefault() ^ this.invertedVisibilityEntities.containsKey(entity.getUniqueId()); // SPIGOT-7312: Can always see self
++        return this.equals(entity) || entity.isVisibleByDefault() ^ (!invertedVisibilityEntities.isEmpty() && this.invertedVisibilityEntities.containsKey(entity.getUniqueId())); // SPIGOT-7312: Can always see self // SparklyPaper - optimize canSee checks
+     }
+ 
++    // SparklyPaper - optimize canSee checks
++    // The check in ChunkMap#updatePlayer already rejects if it is the same entity, so we don't need to check it twice, especially because CraftPlayer's equals check is a bit expensive
++    public boolean canSeeChunkMapUpdatePlayer(org.bukkit.entity.Entity entity) {
++        return entity.isVisibleByDefault() ^ (!invertedVisibilityEntities.isEmpty() && this.invertedVisibilityEntities.containsKey(entity.getUniqueId())); // SPIGOT-7312: Can always see self // SparklyPaper - optimize canSee checks
++    }
++    // SparklyPaper end
++
+     public boolean canSeePlayer(UUID uuid) {
+         org.bukkit.entity.Entity entity = this.getServer().getPlayer(uuid);
+ 

luminol-server/paper-patches/features/0030-Leaf-Skip-event-if-no-listeners.patch

@@ -0,0 +1,31 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sun, 12 Jan 2025 15:37:56 +0800
+Subject: [PATCH] Leaf Skip event if no listeners
+
+
+diff --git a/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java b/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java
+index 7ce9ebba8ce304d1f3f21d4f15ee5f3560d7700b..9180f23529a31b6b0a5b38bb7cda3e32d487f691 100644
+--- a/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java
++++ b/src/main/java/io/papermc/paper/plugin/manager/PaperEventManager.java
+@@ -36,15 +36,17 @@ class PaperEventManager {
+ 
+     // SimplePluginManager
+     public void callEvent(@NotNull Event event) {
++        // Leaf start - Skip event if no listeners
++        RegisteredListener[] listeners = event.getHandlers().getRegisteredListeners();
++        if (listeners.length == 0) return;
++        // Leaf end - Skip event if no listeners
++
+         if (event.isAsynchronous() && this.server.isPrimaryThread()) {
+             throw new IllegalStateException(event.getEventName() + " may only be triggered asynchronously.");
+         } else if (!event.isAsynchronous() && !this.server.isPrimaryThread() && !this.server.isStopping()) {
+             throw new IllegalStateException(event.getEventName() + " may only be triggered synchronously.");
+         }
+ 
+-        HandlerList handlers = event.getHandlers();
+-        RegisteredListener[] listeners = handlers.getRegisteredListeners();
+-
+         for (RegisteredListener registration : listeners) {
+             if (!registration.getPlugin().isEnabled()) {
+                 continue;

luminol-server/paper-patches/features/0031-Leaf-Secure-seed-and-matter-seed-command.patch

@@ -0,0 +1,413 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Tue, 28 Jan 2025 18:56:59 +0800
+Subject: [PATCH] Leaf Secure seed and matter seed command
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/SecureSeedConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/SecureSeedConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..923e6dee55b765e46737ee145c32b767558c0132
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/SecureSeedConfig.java
+@@ -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.IConfigModule;
++
++public class SecureSeedConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled", comments = """
++                Once you enable secure seed, all ores and structures are generated with 1024-bit seed
++                instead of using 64-bit seed in vanilla, made seed cracker become impossible.""")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "secure_seed";
++    }
++}
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
+index f42692cd4f0154705c3d5b030d281cfc333803ed..39cc976f65f826a00e2e637c139f9134c5e74715 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
+@@ -206,7 +206,12 @@ public class CraftChunk implements Chunk {
+     @Override
+     public boolean isSlimeChunk() {
+         // 987234911L is deterimined in EntitySlime when seeing if a slime can spawn in a chunk
+-        return this.worldServer.paperConfig().entities.spawning.allChunksAreSlimeChunks || WorldgenRandom.seedSlimeChunk(this.getX(), this.getZ(), this.getWorld().getSeed(), worldServer.spigotConfig.slimeSeed).nextInt(10) == 0; // Paper
++        // Leaf start - Matter - Secure Seed
++        boolean isSlimeChunk = me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled
++            ? worldServer.getChunk(this.getX(), this.getZ()).isSlimeChunk()
++            : WorldgenRandom.seedSlimeChunk(this.getX(), this.getZ(), this.getWorld().getSeed(), worldServer.spigotConfig.slimeSeed).nextInt(10) == 0; // Paper
++        return this.worldServer.paperConfig().entities.spawning.allChunksAreSlimeChunks || isSlimeChunk;
++        // Leaf end - Matter - Secure Seed
+     }
+ 
+     @Override
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index f9f20e9fd4530d0130046b56c55e798d4ede29d1..d34502a826b1582dd13c6983ed1060373837353f 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -1422,7 +1422,11 @@ public final class CraftServer implements Server {
+             registryAccess = levelDataAndDimensions.dimensions().dimensionsRegistryAccess();
+         } else {
+             LevelSettings levelSettings;
+-            WorldOptions worldOptions = new WorldOptions(creator.seed(), creator.generateStructures(), false);
++            // Leaf start - Matter - Secure Seed
++            WorldOptions worldOptions = me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled
++                ? new WorldOptions(creator.seed(), su.plo.matter.Globals.createRandomWorldSeed(), creator.generateStructures(), false)
++                : new WorldOptions(creator.seed(), creator.generateStructures(), false);
++            // Leaf end - Matter - Secure Seed
+             WorldDimensions worldDimensions;
+ 
+             DedicatedServerProperties.WorldDimensionData properties = new DedicatedServerProperties.WorldDimensionData(GsonHelper.parse((creator.generatorSettings().isEmpty()) ? "{}" : creator.generatorSettings()), creator.type().name().toLowerCase(Locale.ROOT));
+diff --git a/src/main/java/su/plo/matter/Globals.java b/src/main/java/su/plo/matter/Globals.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..3cb89c197ca82c7f86c821fd96f6342428fff5d3
+--- /dev/null
++++ b/src/main/java/su/plo/matter/Globals.java
+@@ -0,0 +1,94 @@
++package su.plo.matter;
++
++import com.google.common.collect.Iterables;
++import net.minecraft.server.level.ServerLevel;
++
++import java.math.BigInteger;
++import java.security.SecureRandom;
++import java.util.Optional;
++
++public class Globals {
++    public static final int WORLD_SEED_LONGS = 16;
++    public static final int WORLD_SEED_BITS = WORLD_SEED_LONGS * 64;
++
++    public static final long[] worldSeed = new long[WORLD_SEED_LONGS];
++    public static final ThreadLocal<Integer> dimension = ThreadLocal.withInitial(() -> 0);
++
++    public enum Salt {
++        UNDEFINED,
++        BASTION_FEATURE,
++        WOODLAND_MANSION_FEATURE,
++        MINESHAFT_FEATURE,
++        BURIED_TREASURE_FEATURE,
++        NETHER_FORTRESS_FEATURE,
++        PILLAGER_OUTPOST_FEATURE,
++        GEODE_FEATURE,
++        NETHER_FOSSIL_FEATURE,
++        OCEAN_MONUMENT_FEATURE,
++        RUINED_PORTAL_FEATURE,
++        POTENTIONAL_FEATURE,
++        GENERATE_FEATURE,
++        JIGSAW_PLACEMENT,
++        STRONGHOLDS,
++        POPULATION,
++        DECORATION,
++        SLIME_CHUNK
++    }
++
++    public static void setupGlobals(ServerLevel world) {
++        if (!me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled) return;
++
++        long[] seed = world.getServer().getWorldData().worldGenOptions().featureSeed();
++        System.arraycopy(seed, 0, worldSeed, 0, WORLD_SEED_LONGS);
++        int worldIndex = Iterables.indexOf(world.getServer().levelKeys(), it -> it == world.dimension());
++        if (worldIndex == -1)
++            worldIndex = world.getServer().levelKeys().size(); // if we are in world construction it may not have been added to the map yet
++        dimension.set(worldIndex);
++    }
++
++    public static long[] createRandomWorldSeed() {
++        long[] seed = new long[WORLD_SEED_LONGS];
++        SecureRandom rand = new SecureRandom();
++        for (int i = 0; i < WORLD_SEED_LONGS; i++) {
++            seed[i] = rand.nextLong();
++        }
++        return seed;
++    }
++
++    // 1024-bit string -> 16 * 64 long[]
++    public static Optional<long[]> parseSeed(String seedStr) {
++        if (seedStr.isEmpty()) return Optional.empty();
++
++        if (seedStr.length() != WORLD_SEED_BITS) {
++            throw new IllegalArgumentException("Secure seed length must be " + WORLD_SEED_BITS + "-bit but found " + seedStr.length() + "-bit.");
++        }
++
++        long[] seed = new long[WORLD_SEED_LONGS];
++
++        for (int i = 0; i < WORLD_SEED_LONGS; i++) {
++            int start = i * 64;
++            int end = start + 64;
++            String seedSection = seedStr.substring(start, end);
++
++            BigInteger seedInDecimal = new BigInteger(seedSection, 2);
++            seed[i] = seedInDecimal.longValue();
++        }
++
++        return Optional.of(seed);
++    }
++
++    // 16 * 64 long[] -> 1024-bit string
++    public static String seedToString(long[] seed) {
++        StringBuilder sb = new StringBuilder();
++
++        for (long longV : seed) {
++            // Convert to 64-bit binary string per long
++            // Use format to keep 64-bit length, and use 0 to complete space
++            String binaryStr = String.format("%64s", Long.toBinaryString(longV)).replace(' ', '0');
++
++            sb.append(binaryStr);
++        }
++
++        return sb.toString();
++    }
++}
+diff --git a/src/main/java/su/plo/matter/Hashing.java b/src/main/java/su/plo/matter/Hashing.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..ec7a57c6af5d5f4fd27a643d253c2ecce90c01ac
+--- /dev/null
++++ b/src/main/java/su/plo/matter/Hashing.java
+@@ -0,0 +1,73 @@
++package su.plo.matter;
++
++public class Hashing {
++    // https://en.wikipedia.org/wiki/BLAKE_(hash_function)
++    // https://github.com/bcgit/bc-java/blob/master/core/src/main/java/org/bouncycastle/crypto/digests/Blake2bDigest.java
++
++    private final static long[] blake2b_IV = {
++            0x6a09e667f3bcc908L, 0xbb67ae8584caa73bL, 0x3c6ef372fe94f82bL,
++            0xa54ff53a5f1d36f1L, 0x510e527fade682d1L, 0x9b05688c2b3e6c1fL,
++            0x1f83d9abfb41bd6bL, 0x5be0cd19137e2179L
++    };
++
++    private final static byte[][] blake2b_sigma = {
++            {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
++            {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3},
++            {11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4},
++            {7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8},
++            {9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13},
++            {2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9},
++            {12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11},
++            {13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10},
++            {6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5},
++            {10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0},
++            {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
++            {14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3}
++    };
++
++    public static long[] hashWorldSeed(long[] worldSeed) {
++        long[] result = blake2b_IV.clone();
++        result[0] ^= 0x01010040;
++        hash(worldSeed, result, new long[16], 0, false);
++        return result;
++    }
++
++    public static void hash(long[] message, long[] chainValue, long[] internalState, long messageOffset, boolean isFinal) {
++        assert message.length == 16;
++        assert chainValue.length == 8;
++        assert internalState.length == 16;
++
++        System.arraycopy(chainValue, 0, internalState, 0, chainValue.length);
++        System.arraycopy(blake2b_IV, 0, internalState, chainValue.length, 4);
++        internalState[12] = messageOffset ^ blake2b_IV[4];
++        internalState[13] = blake2b_IV[5];
++        if (isFinal) internalState[14] = ~blake2b_IV[6];
++        internalState[15] = blake2b_IV[7];
++
++        for (int round = 0; round < 12; round++) {
++            G(message[blake2b_sigma[round][0]], message[blake2b_sigma[round][1]], 0, 4, 8, 12, internalState);
++            G(message[blake2b_sigma[round][2]], message[blake2b_sigma[round][3]], 1, 5, 9, 13, internalState);
++            G(message[blake2b_sigma[round][4]], message[blake2b_sigma[round][5]], 2, 6, 10, 14, internalState);
++            G(message[blake2b_sigma[round][6]], message[blake2b_sigma[round][7]], 3, 7, 11, 15, internalState);
++            G(message[blake2b_sigma[round][8]], message[blake2b_sigma[round][9]], 0, 5, 10, 15, internalState);
++            G(message[blake2b_sigma[round][10]], message[blake2b_sigma[round][11]], 1, 6, 11, 12, internalState);
++            G(message[blake2b_sigma[round][12]], message[blake2b_sigma[round][13]], 2, 7, 8, 13, internalState);
++            G(message[blake2b_sigma[round][14]], message[blake2b_sigma[round][15]], 3, 4, 9, 14, internalState);
++        }
++
++        for (int i = 0; i < 8; i++) {
++            chainValue[i] ^= internalState[i] ^ internalState[i + 8];
++        }
++    }
++
++    private static void G(long m1, long m2, int posA, int posB, int posC, int posD, long[] internalState) {
++        internalState[posA] = internalState[posA] + internalState[posB] + m1;
++        internalState[posD] = Long.rotateRight(internalState[posD] ^ internalState[posA], 32);
++        internalState[posC] = internalState[posC] + internalState[posD];
++        internalState[posB] = Long.rotateRight(internalState[posB] ^ internalState[posC], 24); // replaces 25 of BLAKE
++        internalState[posA] = internalState[posA] + internalState[posB] + m2;
++        internalState[posD] = Long.rotateRight(internalState[posD] ^ internalState[posA], 16);
++        internalState[posC] = internalState[posC] + internalState[posD];
++        internalState[posB] = Long.rotateRight(internalState[posB] ^ internalState[posC], 63); // replaces 11 of BLAKE
++    }
++}
+diff --git a/src/main/java/su/plo/matter/WorldgenCryptoRandom.java b/src/main/java/su/plo/matter/WorldgenCryptoRandom.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..fab359afe44c573b8b315115810ddefd85b4d22b
+--- /dev/null
++++ b/src/main/java/su/plo/matter/WorldgenCryptoRandom.java
+@@ -0,0 +1,159 @@
++package su.plo.matter;
++
++import net.minecraft.util.Mth;
++import net.minecraft.util.RandomSource;
++import net.minecraft.world.level.levelgen.LegacyRandomSource;
++import net.minecraft.world.level.levelgen.WorldgenRandom;
++import org.jetbrains.annotations.NotNull;
++
++import java.util.Arrays;
++
++public class WorldgenCryptoRandom extends WorldgenRandom {
++    // hash the world seed to guard against badly chosen world seeds
++    private static final long[] HASHED_ZERO_SEED = Hashing.hashWorldSeed(new long[Globals.WORLD_SEED_LONGS]);
++    private static final ThreadLocal<long[]> LAST_SEEN_WORLD_SEED = ThreadLocal.withInitial(() -> new long[Globals.WORLD_SEED_LONGS]);
++    private static final ThreadLocal<long[]> HASHED_WORLD_SEED = ThreadLocal.withInitial(() -> HASHED_ZERO_SEED);
++
++    private final long[] worldSeed = new long[Globals.WORLD_SEED_LONGS];
++    private final long[] randomBits = new long[8];
++    private int randomBitIndex;
++    private static final int MAX_RANDOM_BIT_INDEX = 64 * 8;
++    private static final int LOG2_MAX_RANDOM_BIT_INDEX = 9;
++    private long counter;
++    private final long[] message = new long[16];
++    private final long[] cachedInternalState = new long[16];
++
++    public WorldgenCryptoRandom(int x, int z, Globals.Salt typeSalt, long salt) {
++        super(new LegacyRandomSource(0L));
++        if (typeSalt != null) {
++            this.setSecureSeed(x, z, typeSalt, salt);
++        }
++    }
++
++    public void setSecureSeed(int x, int z, Globals.Salt typeSalt, long salt) {
++        System.arraycopy(Globals.worldSeed, 0, this.worldSeed, 0, Globals.WORLD_SEED_LONGS);
++        message[0] = ((long) x << 32) | ((long) z & 0xffffffffL);
++        message[1] = ((long) Globals.dimension.get() << 32) | ((long) salt & 0xffffffffL);
++        message[2] = typeSalt.ordinal();
++        message[3] = counter = 0;
++        randomBitIndex = MAX_RANDOM_BIT_INDEX;
++    }
++
++    private long[] getHashedWorldSeed() {
++        if (!Arrays.equals(worldSeed, LAST_SEEN_WORLD_SEED.get())) {
++            HASHED_WORLD_SEED.set(Hashing.hashWorldSeed(worldSeed));
++            System.arraycopy(worldSeed, 0, LAST_SEEN_WORLD_SEED.get(), 0, Globals.WORLD_SEED_LONGS);
++        }
++        return HASHED_WORLD_SEED.get();
++    }
++
++    private void moreRandomBits() {
++        message[3] = counter++;
++        System.arraycopy(getHashedWorldSeed(), 0, randomBits, 0, 8);
++        Hashing.hash(message, randomBits, cachedInternalState, 64, true);
++    }
++
++    private long getBits(int count) {
++        if (randomBitIndex >= MAX_RANDOM_BIT_INDEX) {
++            moreRandomBits();
++            randomBitIndex -= MAX_RANDOM_BIT_INDEX;
++        }
++
++        int alignment = randomBitIndex & 63;
++        if ((randomBitIndex >>> 6) == ((randomBitIndex + count) >>> 6)) {
++            long result = (randomBits[randomBitIndex >>> 6] >>> alignment) & ((1L << count) - 1);
++            randomBitIndex += count;
++            return result;
++        } else {
++            long result = (randomBits[randomBitIndex >>> 6] >>> alignment) & ((1L << (64 - alignment)) - 1);
++            randomBitIndex += count;
++            if (randomBitIndex >= MAX_RANDOM_BIT_INDEX) {
++                moreRandomBits();
++                randomBitIndex -= MAX_RANDOM_BIT_INDEX;
++            }
++            alignment = randomBitIndex & 63;
++            result <<= alignment;
++            result |= (randomBits[randomBitIndex >>> 6] >>> (64 - alignment)) & ((1L << alignment) - 1);
++
++            return result;
++        }
++    }
++
++    @Override
++    public @NotNull RandomSource fork() {
++        WorldgenCryptoRandom fork = new WorldgenCryptoRandom(0, 0, null, 0);
++
++        System.arraycopy(Globals.worldSeed, 0, fork.worldSeed, 0, Globals.WORLD_SEED_LONGS);
++        fork.message[0] = this.message[0];
++        fork.message[1] = this.message[1];
++        fork.message[2] = this.message[2];
++        fork.message[3] = this.message[3];
++        fork.randomBitIndex = this.randomBitIndex;
++        fork.counter = this.counter;
++        fork.nextLong();
++
++        return fork;
++    }
++
++    @Override
++    public int next(int bits) {
++        return (int) getBits(bits);
++    }
++
++    @Override
++    public void consumeCount(int count) {
++        randomBitIndex += count;
++        if (randomBitIndex >= MAX_RANDOM_BIT_INDEX * 2) {
++            randomBitIndex -= MAX_RANDOM_BIT_INDEX;
++            counter += randomBitIndex >>> LOG2_MAX_RANDOM_BIT_INDEX;
++            randomBitIndex &= MAX_RANDOM_BIT_INDEX - 1;
++            randomBitIndex += MAX_RANDOM_BIT_INDEX;
++        }
++    }
++
++    @Override
++    public int nextInt(int bound) {
++        int bits = Mth.ceillog2(bound);
++        int result;
++        do {
++            result = (int) getBits(bits);
++        } while (result >= bound);
++
++        return result;
++    }
++
++    @Override
++    public long nextLong() {
++        return getBits(64);
++    }
++
++    @Override
++    public double nextDouble() {
++        return getBits(53) * 0x1.0p-53;
++    }
++
++    @Override
++    public long setDecorationSeed(long worldSeed, int blockX, int blockZ) {
++        setSecureSeed(blockX, blockZ, Globals.Salt.POPULATION, 0);
++        return ((long) blockX << 32) | ((long) blockZ & 0xffffffffL);
++    }
++
++    @Override
++    public void setFeatureSeed(long populationSeed, int index, int step) {
++        setSecureSeed((int) (populationSeed >> 32), (int) populationSeed, Globals.Salt.DECORATION, index + 10000L * step);
++    }
++
++    @Override
++    public void setLargeFeatureSeed(long worldSeed, int chunkX, int chunkZ) {
++        super.setLargeFeatureSeed(worldSeed, chunkX, chunkZ);
++    }
++
++    @Override
++    public void setLargeFeatureWithSalt(long worldSeed, int regionX, int regionZ, int salt) {
++        super.setLargeFeatureWithSalt(worldSeed, regionX, regionZ, salt);
++    }
++
++    public static RandomSource seedSlimeChunk(int chunkX, int chunkZ) {
++        return new WorldgenCryptoRandom(chunkX, chunkZ, Globals.Salt.SLIME_CHUNK, 0);
++    }
++}

luminol-server/paper-patches/features/0033-Tick-regions-api.patch

@@ -0,0 +1,203 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Mon, 27 Jan 2025 13:01:56 +0800
+Subject: [PATCH] Tick regions api
+
+
+diff --git a/src/main/java/me/earthme/luminol/api/impl/RegionStatsImpl.java b/src/main/java/me/earthme/luminol/api/impl/RegionStatsImpl.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..30d4e7b6a433974c5047148f35973eb31c82d424
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/impl/RegionStatsImpl.java
+@@ -0,0 +1,27 @@
++package me.earthme.luminol.api.impl;
++
++import io.papermc.paper.threadedregions.TickRegions;
++import me.earthme.luminol.api.RegionStats;
++
++public class RegionStatsImpl implements RegionStats {
++    private final TickRegions.RegionStats internal;
++
++    public RegionStatsImpl(TickRegions.RegionStats internal) {
++        this.internal = internal;
++    }
++
++    @Override
++    public int getEntityCount() {
++        return this.internal.getEntityCount();
++    }
++
++    @Override
++    public int getPlayerCount() {
++        return this.internal.getPlayerCount();
++    }
++
++    @Override
++    public int getChunkCount() {
++        return this.internal.getChunkCount();
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/impl/ThreadedRegionImpl.java b/src/main/java/me/earthme/luminol/api/impl/ThreadedRegionImpl.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..a1380abacf7bc0fe106982d9b4cd7bbc44e4e375
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/impl/ThreadedRegionImpl.java
+@@ -0,0 +1,47 @@
++package me.earthme.luminol.api.impl;
++
++import io.papermc.paper.threadedregions.ThreadedRegionizer;
++import io.papermc.paper.threadedregions.TickRegions;
++import me.earthme.luminol.api.ThreadedRegion;
++import me.earthme.luminol.api.TickRegionData;
++import net.minecraft.world.level.ChunkPos;
++import org.bukkit.Location;
++import org.bukkit.World;
++
++import javax.annotation.Nullable;
++
++public class ThreadedRegionImpl implements ThreadedRegion {
++    private final ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> internal;
++
++    public ThreadedRegionImpl(ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> internal) {
++        this.internal = internal;
++    }
++
++    @Nullable
++    @Override
++    public Location getCenterChunkPos() {
++        final ChunkPos centerChunkPos = this.internal.getCenterChunk();
++
++        if (centerChunkPos == null) {
++            return null;
++        }
++
++        return new Location(this.internal.regioniser.world.getWorld(), centerChunkPos.getMiddleBlockX(), 0, centerChunkPos.getMiddleBlockZ());
++    }
++
++    @Override
++    public double getDeadSectionPercent() {
++        return this.internal.getDeadSectionPercent();
++    }
++
++    @Override
++    public TickRegionData getTickRegionData() {
++        return new TickRegionDataImpl(this.internal.getData());
++    }
++
++    @Nullable
++    @Override
++    public World getWorld() {
++        return this.internal.regioniser.world.getWorld();
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/impl/ThreadedRegionizerImpl.java b/src/main/java/me/earthme/luminol/api/impl/ThreadedRegionizerImpl.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..203ba60216febd8c19315afd89140d5400213f67
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/impl/ThreadedRegionizerImpl.java
+@@ -0,0 +1,53 @@
++package me.earthme.luminol.api.impl;
++
++import io.papermc.paper.threadedregions.TickRegions;
++import me.earthme.luminol.api.ThreadedRegion;
++import me.earthme.luminol.api.ThreadedRegionizer;
++import net.minecraft.server.level.ServerLevel;
++
++import java.util.ArrayList;
++import java.util.Collection;
++import java.util.List;
++
++public class ThreadedRegionizerImpl implements ThreadedRegionizer {
++    private final ServerLevel internal;
++
++    public ThreadedRegionizerImpl(ServerLevel internal) {
++        this.internal = internal;
++    }
++
++    @Override
++    public Collection<ThreadedRegion> getAllRegions() {
++        final List<ThreadedRegion> ret = new ArrayList<>();
++
++        this.internal.regioniser.computeForAllRegions(region -> {
++            final ThreadedRegion wrapped = new ThreadedRegionImpl(region);
++
++            ret.add(wrapped);
++        });
++
++        return ret;
++    }
++
++    @Override
++    public ThreadedRegion getAtSynchronized(int chunkX, int chunkZ) {
++        final io.papermc.paper.threadedregions.ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> got = this.internal.regioniser.getRegionAtSynchronised(chunkX, chunkZ);
++
++        if (got == null) {
++            return null;
++        }
++
++        return new ThreadedRegionImpl(got);
++    }
++
++    @Override
++    public ThreadedRegion getAtUnSynchronized(int chunkX, int chunkZ) {
++        final io.papermc.paper.threadedregions.ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> got = this.internal.regioniser.getRegionAtUnsynchronised(chunkX, chunkZ);
++
++        if (got == null) {
++            return null;
++        }
++
++        return new ThreadedRegionImpl(got);
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/impl/TickRegionDataImpl.java b/src/main/java/me/earthme/luminol/api/impl/TickRegionDataImpl.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..cf51350ccabeda97e9eff41ccd30c58e836fe041
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/impl/TickRegionDataImpl.java
+@@ -0,0 +1,30 @@
++package me.earthme.luminol.api.impl;
++
++import io.papermc.paper.threadedregions.TickRegions;
++import me.earthme.luminol.api.RegionStats;
++import me.earthme.luminol.api.TickRegionData;
++import org.bukkit.World;
++
++public class TickRegionDataImpl implements TickRegionData {
++    private final TickRegions.TickRegionData internal;
++
++    public TickRegionDataImpl(TickRegions.TickRegionData internal) {
++        this.internal = internal;
++    }
++
++    @Override
++    public World getWorld() {
++        return this.internal.world.getWorld();
++    }
++
++    @Override
++    public long getCurrentTickCount() {
++        return this.internal.getCurrentTick();
++    }
++
++    @Override
++    public RegionStats getRegionStats() {
++        return new RegionStatsImpl(this.internal.getRegionStats());
++    }
++
++}
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index b48107c5f8b451b284d880ee3d2be56d91b3e34f..9343b18614b29862a689c64db5567732e96d4944 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -2543,4 +2543,11 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+         return this.adventure$pointers;
+     }
+     // Paper end
++
++    // Luminol start - Tick regions api
++    @Override
++    public me.earthme.luminol.api.ThreadedRegionizer getThreadedRegionizer() {
++        return new me.earthme.luminol.api.impl.ThreadedRegionizerImpl(this.world);
++    }
++    // Luminol end
+ }

patches/api/0001-Added-maven-publish.patch

@@ -1,35 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 18:04:47 +0800
-Subject: [PATCH] Added maven publish
-
-
-diff --git a/build.gradle.kts b/build.gradle.kts
-index 639651972fddce4dff63a0f0a7e566a15b9e2dd6..890820cb36e4cadeadb4c2d7cd961a73b065a217 100644
---- a/build.gradle.kts
-+++ b/build.gradle.kts
-@@ -168,3 +168,23 @@ tasks.check {
-     dependsOn(scanJar)
- }
- // Paper end
-+
-+// Luminol start
-+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"])
-+            }
-+        }
-+    }
-+}
-+// Luminol end
-\ No newline at end of file

patches/server/0001-Fix-build.patch

@@ -1,28 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 08:20:14 +0800
-Subject: [PATCH] Fix build
-
-
-diff --git a/build.gradle.kts b/build.gradle.kts
-index 0cd12a854e544e867abfd94c18a9f138ba57e587..d295ee01481b088a376691de7c0927e95d7a68a8 100644
---- a/build.gradle.kts
-+++ b/build.gradle.kts
-@@ -14,7 +14,7 @@ val alsoShade: Configuration by configurations.creating
- 
- dependencies {
-     // Folia start
--    implementation(project(":folia-api"))
-+    implementation(project(":luminol-api")) //Luminol
-     implementation("io.papermc.paper:paper-mojangapi:${project.version}") {
-         exclude("io.papermc.paper", "paper-api")
-     }
-@@ -74,7 +74,7 @@ tasks.jar {
-         attributes(
-             "Main-Class" to "org.bukkit.craftbukkit.Main",
-             "Implementation-Title" to "CraftBukkit",
--            "Implementation-Version" to "git-Folia-$implementationVersion", // Folia
-+            "Implementation-Version" to "git-Luminol-$implementationVersion", // Folia //Luminol
-             "Implementation-Vendor" to date, // Paper
-             "Specification-Title" to "Bukkit",
-             "Specification-Version" to project.version,

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

@@ -1,91 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 08:20:54 +0800
-Subject: [PATCH] Rebrand to Luminol
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/Metrics.java b/src/main/java/com/destroystokyo/paper/Metrics.java
-index cb60d58d4a7556dd896f31d0cd249f860bb3ef84..b52a805150e95d7d27403d3c18088b335a355011 100644
---- a/src/main/java/com/destroystokyo/paper/Metrics.java
-+++ b/src/main/java/com/destroystokyo/paper/Metrics.java
-@@ -593,7 +593,7 @@ public class Metrics {
-             boolean logFailedRequests = config.getBoolean("logFailedRequests", false);
-             // Only start Metrics, if it's enabled in the config
-             if (config.getBoolean("enabled", true)) {
--                Metrics metrics = new Metrics("Folia", serverUUID, logFailedRequests, Bukkit.getLogger()); // Folia - we have our own bstats page
-+                Metrics metrics = new Metrics("Luminol", serverUUID, logFailedRequests, Bukkit.getLogger()); // Folia - we have our own bstats page //Luminol
- 
-                 metrics.addCustomChart(new Metrics.SimplePie("minecraft_version", () -> {
-                     String minecraftVersion = Bukkit.getVersion();
-@@ -611,7 +611,7 @@ public class Metrics {
-                 } else {
-                     paperVersion = "unknown";
-                 }
--                metrics.addCustomChart(new Metrics.SimplePie("folia_version", () -> paperVersion)); // Folia - we have our own bstats page
-+                metrics.addCustomChart(new Metrics.SimplePie("luminol_version", () -> paperVersion)); // Folia - we have our own bstats page //Luminol
- 
-                 metrics.addCustomChart(new Metrics.DrilldownPie("java_version", () -> {
-                     Map<String, Map<String, Integer>> map = new HashMap<>();
-diff --git a/src/main/java/com/destroystokyo/paper/PaperVersionFetcher.java b/src/main/java/com/destroystokyo/paper/PaperVersionFetcher.java
-index e2f704c115fd6e00960bb56bb0779f1100c89c17..72b9343979de5aa8bb399cbe7cb8a795df9830ab 100644
---- a/src/main/java/com/destroystokyo/paper/PaperVersionFetcher.java
-+++ b/src/main/java/com/destroystokyo/paper/PaperVersionFetcher.java
-@@ -20,7 +20,7 @@ import java.util.stream.StreamSupport;
- public class PaperVersionFetcher implements VersionFetcher {
-     private static final java.util.regex.Pattern VER_PATTERN = java.util.regex.Pattern.compile("^([0-9\\.]*)\\-.*R"); // R is an anchor, will always give '-R' at end
-     private static final String GITHUB_BRANCH_NAME = "master";
--    private static final String DOWNLOAD_PAGE = "https://papermc.io/downloads/paper";
-+    private static final String DOWNLOAD_PAGE = "https://github.com/Era4FunMC/Luminol"; //Luminol
-     private static @Nullable String mcVer;
- 
-     @Override
-@@ -31,8 +31,8 @@ public class PaperVersionFetcher implements VersionFetcher {
-     @Nonnull
-     @Override
-     public Component getVersionMessage(@Nonnull String serverVersion) {
--        String[] parts = serverVersion.substring("git-Folia-".length()).split("[-\\s]"); // Folia
--        final Component updateMessage = getUpdateStatusMessage("PaperMC/Folia", GITHUB_BRANCH_NAME, parts[0]); // Folia
-+        String[] parts = serverVersion.substring("git-Luminol-".length()).split("[-\\s]"); // Folia //Luminol
-+        final Component updateMessage = getUpdateStatusMessage("Era4FunMC/Luminol", GITHUB_BRANCH_NAME, parts[0]); // Folia //Luminol
-         final Component history = getHistory();
- 
-         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 4b189b54c8f326939a7b9ffdfb35edfb7d8cee63..781612b6fc3d020e832164ebce231961dd68e24e 100644
---- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -1833,7 +1833,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
- 
-     @DontObfuscate
-     public String getServerModName() {
--        return "Folia"; // Folia - Folia > // Paper - Paper > // Spigot - Spigot > // CraftBukkit - cb > vanilla!
-+        return "Luminol"; //Luminol - Luminol > // Folia - Folia > // Paper - Paper > // Spigot - Spigot > // CraftBukkit - cb > vanilla!
-     }
- 
-     public SystemReport fillSystemReport(SystemReport details) {
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index bc778637c7d4371cafa9bcda67f8965f57cc66d6..5fe36cbb14f0f0e9692cfa40381cebdb4e142bbe 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -269,7 +269,7 @@ import javax.annotation.Nullable; // Paper
- import javax.annotation.Nonnull; // Paper
- 
- public final class CraftServer implements Server {
--    private final String serverName = "Folia"; // Folia // Paper
-+    private final String serverName = "Luminol"; // Folia // Paper //Luminol
-     private final String serverVersion;
-     private final String bukkitVersion = Versioning.getBukkitVersion();
-     private final Logger logger = Logger.getLogger("Minecraft");
-diff --git a/src/main/java/org/bukkit/craftbukkit/util/Versioning.java b/src/main/java/org/bukkit/craftbukkit/util/Versioning.java
-index e9b6ca3aa25e140467ae866d572483050ea3fa0e..9699d7dcca5cf67f50ad05c0e875de424a4e00c5 100644
---- a/src/main/java/org/bukkit/craftbukkit/util/Versioning.java
-+++ b/src/main/java/org/bukkit/craftbukkit/util/Versioning.java
-@@ -11,7 +11,7 @@ public final class Versioning {
-     public static String getBukkitVersion() {
-         String result = "Unknown-Version";
- 
--        InputStream stream = Bukkit.class.getClassLoader().getResourceAsStream("META-INF/maven/dev.folia/folia-api/pom.properties"); // Folia
-+        InputStream stream = Bukkit.class.getClassLoader().getResourceAsStream("META-INF/maven/me.earthme.luminol/luminol-api/pom.properties"); // Folia //Luminol
-         Properties properties = new Properties();
- 
-         if (stream != null) {

patches/server/0003-Added-empty-luminol-config.patch

@@ -1,179 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 10:40:56 +0800
-Subject: [PATCH] Added empty luminol config
-
-
-diff --git a/build.gradle.kts b/build.gradle.kts
-index d295ee01481b088a376691de7c0927e95d7a68a8..54d761d7e4733c12fbb4957acd509d278ae11316 100644
---- a/build.gradle.kts
-+++ b/build.gradle.kts
-@@ -19,6 +19,7 @@ dependencies {
-         exclude("io.papermc.paper", "paper-api")
-     }
-     // Folia end
-+    implementation("com.electronwill.night-config:toml:3.6.0") //Luminol - Night config
-     // 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/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..1f9ff0fc33fa36c90fc4cbbd21b7b790de581632
---- /dev/null
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -0,0 +1,99 @@
-+package me.earthme.luminol;
-+
-+import com.electronwill.nightconfig.core.file.CommentedFileConfig;
-+import net.minecraft.server.level.ServerLevel;
-+
-+import java.io.File;
-+import java.io.IOException;
-+
-+public class LuminolConfig {
-+    private static final File PARENT_FOLDER = new File("luminol_config");
-+    private static final File MAIN_CONFIG_FILE = new File(PARENT_FOLDER,"luminol_global.toml");
-+    private static CommentedFileConfig MAIN_CONFIG;
-+
-+    public static String serverModName = "Luminol";
-+    public static boolean fakeVanillaModeEnabled = false;
-+
-+    public static void init() throws IOException {
-+        PARENT_FOLDER.mkdir();
-+
-+        if (!MAIN_CONFIG_FILE.exists()){
-+            MAIN_CONFIG_FILE.createNewFile();
-+        }
-+
-+        MAIN_CONFIG = CommentedFileConfig.ofConcurrent(MAIN_CONFIG_FILE);
-+
-+        MAIN_CONFIG.load();
-+        initValues();
-+        MAIN_CONFIG.save();
-+    }
-+
-+    public static void initValues(){
-+        serverModName = get("misc.server_mod_name",serverModName,"The servermod name will be sent to players,and you can see it in F3 or motd responses");
-+        fakeVanillaModeEnabled = get("misc.enable_fake_vanilla_mode",fakeVanillaModeEnabled,"Enable this to make the ping response of your server like a vanilla server");
-+    }
-+
-+    public static <T> T get(String key,T def){
-+        if (MAIN_CONFIG.contains(key)){
-+            return MAIN_CONFIG.get(key);
-+        }
-+
-+        MAIN_CONFIG.set(key,def);
-+        return def;
-+    }
-+
-+    public static <T> T get(String key,T def,String comment){
-+        MAIN_CONFIG.setComment(key,comment);
-+
-+        if (MAIN_CONFIG.contains(key)){
-+            return MAIN_CONFIG.get(key);
-+        }
-+
-+        MAIN_CONFIG.set(key,def);
-+        return def;
-+    }
-+
-+    public static class LumionalWorldConfig{
-+        private final File configFile;
-+        private CommentedFileConfig commentedFileConfig;
-+
-+        public LumionalWorldConfig(ServerLevel level) {
-+            this.configFile = new File(PARENT_FOLDER,"luminol_world_"+level.getWorld().getName()+".toml");
-+        }
-+
-+        public void init() throws IOException {
-+            if (!this.configFile.exists()){
-+                this.configFile.createNewFile();
-+            }
-+
-+            this.commentedFileConfig = CommentedFileConfig.ofConcurrent(this.configFile);
-+            this.commentedFileConfig.load();
-+            this.initValues();
-+            this.commentedFileConfig.save();
-+        }
-+
-+        public void initValues(){
-+
-+        }
-+
-+        public <T> T get(String key,T def,String comment){
-+            this.commentedFileConfig.setComment(key,comment);
-+
-+            if (this.commentedFileConfig.contains(key)){
-+                return this.commentedFileConfig.get(key);
-+            }
-+
-+            this.commentedFileConfig.set(key,def);
-+            return def;
-+        }
-+
-+        public <T> T get(String key,T def){
-+            if (this.commentedFileConfig.contains(key)){
-+                return this.commentedFileConfig.get(key);
-+            }
-+
-+            this.commentedFileConfig.set(key,def);
-+            return def;
-+        }
-+    }
-+}
-diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-index 05d8cabd2294456e3c8df60265f8b035990dd896..f0bf57a7acd77eeffbeeb6743ba58166823022fd 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;
- import java.util.Optional;
- import java.util.function.BooleanSupplier;
- import javax.annotation.Nullable;
-+
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.DefaultUncaughtExceptionHandler;
- import net.minecraft.DefaultUncaughtExceptionHandlerWithName;
- import net.minecraft.SharedConstants;
-@@ -206,6 +208,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
-         // Spigot end
-         // Paper start
-         io.papermc.paper.util.ObfHelper.INSTANCE.getClass(); // Paper - load mappings for stacktrace deobf and etc.
-+        LuminolConfig.init(); //Luminol
-         paperConfigurations.initializeGlobalConfiguration();
-         paperConfigurations.initializeWorldDefaultsConfiguration();
-         // Paper start - moved up to right after PlayerList creation but before file load/save
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 724aa1d8147ea2fb5e46d291adacfb7e1f5b5f62..e274c501e2455845f6f9a4614802336205362b69 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -38,6 +38,8 @@ import java.util.stream.Collectors;
- import java.util.stream.Stream;
- import javax.annotation.Nonnull;
- import javax.annotation.Nullable;
-+
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.CrashReport;
- import net.minecraft.Util;
- import net.minecraft.core.BlockPos;
-@@ -766,6 +768,8 @@ public class ServerLevel extends Level implements WorldGenLevel {
-     }
-     // Folia end - region threading
- 
-+    public final LuminolConfig.LumionalWorldConfig lumionalWorldConfig; //Luminol
-+
-     // Add env and gen to constructor, IWorldDataServer -> WorldDataServer
-     public ServerLevel(MinecraftServer minecraftserver, Executor executor, LevelStorageSource.LevelStorageAccess convertable_conversionsession, PrimaryLevelData iworlddataserver, ResourceKey<Level> resourcekey, LevelStem worlddimension, ChunkProgressListener worldloadlistener, boolean flag, long i, List<CustomSpawner> list, boolean flag1, @Nullable RandomSequences randomsequences, org.bukkit.World.Environment env, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider) {
-         // IRegistryCustom.Dimension iregistrycustom_dimension = minecraftserver.registryAccess(); // CraftBukkit - decompile error
-@@ -850,6 +854,12 @@ public class ServerLevel extends Level implements WorldGenLevel {
-         this.chunkTaskScheduler = new io.papermc.paper.chunk.system.scheduling.ChunkTaskScheduler(this, io.papermc.paper.chunk.system.scheduling.ChunkTaskScheduler.workerThreads); // Paper - rewrite chunk system
-         this.entityLookup = new io.papermc.paper.chunk.system.entity.EntityLookup(this, new EntityCallbacks()); // Paper - rewrite chunk system
-         this.updateTickData(); // Folia - region threading - make sure it is initialised before ticked
-+        this.lumionalWorldConfig = new LuminolConfig.LumionalWorldConfig(this);
-+        try {
-+            this.lumionalWorldConfig.init();
-+        } catch (IOException e) {
-+            throw new RuntimeException("Failed to create luminol config for level "+ this.getWorld().getName()+"!",e);
-+        }
-     }
- 
-     // Folia start - region threading

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

@@ -1,49 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 11:17:37 +0800
-Subject: [PATCH] Add config for server brand name
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/network/PaperServerListPingEventImpl.java b/src/main/java/com/destroystokyo/paper/network/PaperServerListPingEventImpl.java
-index 5d7110a33957a597592cacb864c947eb053e8563..25cda48a6ab9a703d64c391007f5c32c368fdbe2 100644
---- a/src/main/java/com/destroystokyo/paper/network/PaperServerListPingEventImpl.java
-+++ b/src/main/java/com/destroystokyo/paper/network/PaperServerListPingEventImpl.java
-@@ -1,6 +1,7 @@
- package com.destroystokyo.paper.network;
- 
- import com.destroystokyo.paper.event.server.PaperServerListPingEvent;
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.server.MinecraftServer;
- import net.minecraft.server.level.ServerPlayer;
- import org.bukkit.entity.Player;
-@@ -14,7 +15,7 @@ class PaperServerListPingEventImpl extends PaperServerListPingEvent {
- 
-     PaperServerListPingEventImpl(MinecraftServer server, StatusClient client, int protocolVersion, @Nullable CachedServerIcon icon) {
-         super(client, server.server.motd(), server.getPlayerCount(), server.getMaxPlayers(),
--                server.getServerModName() + ' ' + server.getServerVersion(), protocolVersion, icon);
-+                LuminolConfig.fakeVanillaModeEnabled ? server.getServerVersion() : server.getServerModName() + ' ' + server.getServerVersion(), protocolVersion, icon);//Luminol - Fake vanilla mode
-         this.server = server;
-     }
- 
-diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index 781612b6fc3d020e832164ebce231961dd68e24e..03165a7791aeac54e44391bbb0f432b613369bfa 100644
---- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -53,6 +53,8 @@ import java.util.stream.Collectors;
- import java.util.stream.Stream;
- import javax.annotation.Nullable;
- import javax.imageio.ImageIO;
-+
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.CrashReport;
- import net.minecraft.ReportedException;
- import net.minecraft.SharedConstants;
-@@ -1833,7 +1835,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
- 
-     @DontObfuscate
-     public String getServerModName() {
--        return "Luminol"; //Luminol - Luminol > // Folia - Folia > // Paper - Paper > // Spigot - Spigot > // CraftBukkit - cb > vanilla!
-+        return LuminolConfig.fakeVanillaModeEnabled ? "vanilla" : LuminolConfig.serverModName; //Luminol //Luminol - Luminol > // Folia - Folia > // Paper - Paper > // Spigot - Spigot > // CraftBukkit - cb > vanilla!
-     }
- 
-     public SystemReport fillSystemReport(SystemReport details) {