Update CI

This reverts commit e1afa32f90.

.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.net/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_1_20_4.yml_dis

@@ -5,19 +5,19 @@
 # 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
+name: LuminolCI - Ver/1.20.4
 
 on:
   push:
-    branches: [ "ver/1.20.2" ]
+    branches: [ "ver/1.20.4" ]
   pull_request:
-    branches: [ "ver/1.20.2" ]
+    branches: [ "ver/1.20.4" ]
 
 permissions: write-all
 
 jobs:
   build:
-    runs-on: macos-latest
+    runs-on: ubuntu-latest
 
     steps:
     - uses: actions/checkout@v3
@@ -37,27 +37,27 @@ jobs:
     - name: Build project to paperclip jar
       uses: gradle/gradle-build-action@bd5760595778326ba7f1441bcf7e88b49de61a25 # v2.6.0
       with:
-        arguments: createReobfPaperclipJar
+        arguments: createReobfBundlerJar createReobfPaperclipJar
     - name: Capture build artifacts
       uses: actions/upload-artifact@v3
       with:
         name: Artifacts
         path: build/libs/
-    - name: Publish API
+    - name: Publish All
       run: |
         echo "GITHUB_USERNAME=LuminolCI" >> $GITHUB_ENV
         export GITHUB_USERNAME=LuminolCI
         echo "GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }}" >> $GITHUB_ENV
         export GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }}
-        ./gradlew publish
+        ./gradlew publish -PpublishDevBundle=true
     - name: Rename jar file
-      run: mv build/libs/Luminol-paperclip-1.20.2-R0.1-SNAPSHOT-reobf.jar build/libs/lunminol-1.20.2-paperclip.jar
+      run: mv build/libs/luminol-paperclip-1.20.4-R0.1-SNAPSHOT-reobf.jar build/libs/luminol-1.20.4-paperclip.jar
     - name: Release Artifacts
       uses: svenstaro/upload-release-action@v2
       with:
-       release_name: "Luminol MC1.20.2 - ${{ github.event.repository.updated_at}}"
-       tag: "1.20.2-${{ github.run_id }}"
+       release_name: "Luminol MC1.20.4 - ${{ github.event.repository.updated_at}}"
+       tag: "1.20.4-${{ github.run_id }}"
        repo_token: "${{ secrets.GITHUB_TOKEN }}"
-       file: "build/libs/lunminol-1.20.2-paperclip.jar"
+       file: "build/libs/luminol-1.20.4-paperclip.jar"
        file_glob: true
-       prerelease: false    
+       prerelease: true

.github/workflows/build_1_20_4_v2.yml

@@ -0,0 +1,64 @@
+name: Luminol CI v2 - Ver/1.20.4
+
+on:
+    push:
+      branches: [ "ver/1.20.4" ]
+    pull_request:
+      branches: [ "ver/1.20.4" ]
+    # workflow_dispatch:
+permissions: write-all
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    environment: default
+
+    steps:
+      - name: Checkout Git Repository
+        uses: actions/checkout@v3
+      - name: Set up JDK
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+      - name: Setup Git Config
+        run: |
+          git config --global user.email "ci@luminolmc.com"
+          git config --global user.name "Luminol CI"
+      - name: Apply Patches
+        run: ./gradlew applyPatches
+      - name: Build
+        run: ./gradlew createReobfBundlerJar createReobfPaperclipJar
+      - uses: "actions/upload-artifact@v3"
+        with:
+          name: "Luminol CI Artifacts"
+          path: "build/libs/*.jar"
+      - name: Rename jar file
+        run: |
+          mv build/libs/luminol-bundler-1.20.4-R0.1-SNAPSHOT-reobf.jar build/libs/luminol-1.20.4-bundler.jar
+          mv build/libs/luminol-paperclip-1.20.4-R0.1-SNAPSHOT-reobf.jar build/libs/luminol-1.20.4-paperclip.jar
+      - name: setenv
+        run: |
+          sh scripts/SetENV.sh
+          echo "${{ env.tag }}"
+      - name: Create Release
+        if: "!contains(github.event.commits[0].message, '[release-skip]')"
+        uses: ncipollo/release-action@v1.12.0
+        with:
+          tag: ${{ env.tag }}
+          name: Luminol ${{ env.mcversion }} - ${{ env.commitid }}
+          body: |
+           📦Version: `${{ env.mcversion }}` | Commit ${{ env.commitid }} [![download](https://img.shields.io/github/downloads/LuminolMC/Luminol/${{ env.tag }}/total?color=0)](https://github.com/LeavesMC/LuminolMC/Luminol/download/${{ env.tag }}/luminol-1.20.4-paperclip.jar)
+            This release is automatically compiled by GitHub Actions
+          artifacts: |
+            build/libs/luminol-1.20.4-bundler.jar
+            build/libs/luminol-1.20.4-paperclip.jar
+          generateReleaseNotes: true
+          prerelease: ${{ env.pre }}
+          makeLatest: ${{ env.make_latest }}
+          token: "${{ secrets.GITHUB_TOKEN }}"
+      - name: Push to Api
+        if: "!contains(github.event.commits[0].message, '[release-skip]')"
+        env:
+          secret_v2: ${{ secrets.API_KEY }}
+          tag: ${{ env.tag }}
+        run: sh scripts/PushToAPI.sh

.gitignore

@@ -33,7 +33,6 @@ target/
 dependency-reduced-pom.xml
 
 # various other potential build files
-build/
 bin/
 dist/
 manifest.mf
@@ -51,8 +50,10 @@ manifest.mf
 # other stuff
 run/
 
+# Luminol
 build-data/
-Hearse-API
-Hearse-Server
+Luminol-API
+Luminol-Server
+paper-api-generator
 *.jar
-/patches/todo/
+/patches2/todo/

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Era4FunMC
+Copyright (c) 2024 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,77 @@
+<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) | **中文**
 
-## 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 支持
+- 线性区域文件格式 (from kaiiju)
+- 对单线程区域性能的优化
+- 更多的插件开发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（注意：需要`JDK17`）
 
-## Build
-To build a paperclip jar, you need to run the following command. You can find the jar in build/libs(Note: JDK17 is needed)
  ```shell
  ./gradlew applyPatches && ./gradlew createReobfPaperclipJar
 ```
-## Using API
-For gradle:
+
+## 使用API
+使用 Gradle:
+
 ```kotlin
 dependencies {
-    compileOnly("me.earthme.luminol:luminol-api:1.20.2-R0.1-SNAPSHOT")
+    compileOnly("me.earthme.luminol:luminol-api:1.20.4-R0.1-SNAPSHOT")
 }
  ```
-For maven
+
+使用 Maven
+
 ```xml
 <dependency>
   <groupId>me.earthme.luminol</groupId>
   <artifactId>luminol-api</artifactId>
-  <version>1.20.2-R0.1-SNAPSHOT</version>
+  <version>1.20.4-R0.1-SNAPSHOT</version>
 </dependency>
 ```
+
+## 联系方式
+> 如果您对这个项目感兴趣或有任何问题，请随时向我们提问。
+
+QQ群: [368632360](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/5hgtU72w33)
+
+> [!WARNING]
+> **此项目与Leaves无关。不要向Leaves报告任何有关协议支持的错误，因为协议支持已经重构**
+
+## 关于 Issue
+当您遇到任何问题时，请向我们提问，我们将尽力解决，但请记得清楚地描述您的问题并提供足够的日志等信息。
+
+## 贡献代码
+可[查看 Contributing](./docs/CONTRIBUTING.md)
+
+## BStats
+![bStats](https://bstats.org/signatures/server-implementation/Luminol.svg "bStats")
+
+## 请给我们一个 ⭐Star！
+> 你的每一个免费的 ⭐Star 就是我们每一个前进的动力。
+
+<a href="https://star-history.com/#LuminolMC/Luminol&LuminolMC/LightingLuminol&Date">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=LuminolMC/Luminol%2CLuminolMC/LightingLuminol&type=Date&theme=dark" />
+    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=LuminolMC/Luminol%2CLuminolMC/LightingLuminol&type=Date" />
+    <img alt="Star历史表" src="https://api.star-history.com/svg?repos=LuminolMC/Luminol%2CLuminolMC/LightingLuminol&type=Date" />
+  </picture>
+</a>
+

README_EN.md

@@ -0,0 +1,74 @@
+<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)
+
+## 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: JDK17 is needed)
+
+ ```shell
+ ./gradlew applyPatches && ./gradlew createReobfPaperclipJar
+```
+
+## Using API
+For gradle:
+
+```kotlin
+dependencies {
+    compileOnly("me.earthme.luminol:luminol-api:1.20.4-R0.1-SNAPSHOT")
+}
+ ```
+
+For maven
+
+```xml
+<dependency>
+  <groupId>me.earthme.luminol</groupId>
+  <artifactId>luminol-api</artifactId>
+  <version>1.20.4-R0.1-SNAPSHOT</version>
+</dependency>
+```
+
+## 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/5hgtU72w33)
+
+> [!WARNING]
+> **This project is not related to Leaves.Do not report any bugs about protocol support to leaves because the protocol supports are already refactored.**
+
+## About Issue
+When you meet any problems, just ask us, we will do our best to solve it, but remember to state your problem clear and provide enough logs etc.</br>
+
+## Pull Requests
+See [Contributing](./docs/CONTRIBUTING_EN.md)
+
+## BStats
+![bStats](https://bstats.org/signatures/server-implementation/Luminol.svg "bStats")
+
+## 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,10 +1,8 @@
-import io.papermc.paperweight.util.constants.*
-
 plugins {
     java
     `maven-publish`
     id("com.github.johnrengelman.shadow") version "8.1.1" apply false
-    id("io.papermc.paperweight.patcher") version "1.5.9"
+    id("io.papermc.paperweight.patcher") version "1.5.11"
 }
 
 val paperMavenPublicUrl = "https://repo.papermc.io/repository/maven-public/"
@@ -65,7 +63,7 @@ tasks.generateDevelopmentBundle {
     libraryRepositories.set(
         listOf(
             "https://repo.maven.apache.org/maven2/",
-            paperMavenPublicUrl,
+            "https://maven.pkg.github.com/LuminolMC/Luminol",
         )
     )
 }
@@ -91,5 +89,52 @@ paperweight {
             serverPatchDir.set(layout.projectDirectory.dir("patches/server"))
             serverOutputDir.set(layout.projectDirectory.dir("Luminol-Server"))
         }
+
+        patchTasks.register("generatedApi") {
+            isBareDirectory = true
+            upstreamDirPath = "paper-api-generator/generated"
+            patchDir = layout.projectDirectory.dir("patches/generatedApi")
+            outputDir = layout.projectDirectory.dir("paper-api-generator/generated")
+        }
     }
 }
+
+tasks.generateDevelopmentBundle {
+    apiCoordinates.set("me.earthme.luminol:luminol-api")
+    mojangApiCoordinates.set("io.papermc.paper:paper-mojangapi")
+    libraryRepositories.addAll(
+        "https://repo.maven.apache.org/maven2/",
+        paperMavenPublicUrl,
+    )
+}
+
+allprojects {
+    publishing {
+        repositories {
+            maven {
+                name = "githubPackage"
+                url = uri("https://maven.pkg.github.com/LuminolMC/Luminol")
+
+                credentials.username = System.getenv("GITHUB_USERNAME")
+                credentials.password = System.getenv("GITHUB_TOKEN")
+            }
+
+            publications {
+                register<MavenPublication>("gpr") {
+                    from(components["java"])
+                }
+            }
+        }
+    }
+ }
+
+publishing {
+    if (project.hasProperty("publishDevBundle")) {
+        publications.create<MavenPublication>("devBundle") {
+            artifact(tasks.generateDevelopmentBundle) {
+                artifactId = "dev-bundle"
+            }
+        }
+    }
+}
+

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,13 @@
 group = me.earthme.luminol
-version = 1.20.2-R0.1-SNAPSHOT
+version = 1.20.4-R0.1-SNAPSHOT
 
-foliaCommit = 1e5e2154c9f88d788cecf0b9fcc77ece7d1f8663
+foliaCommit = ef2c6971891b7571261591cd22d27ff555c5d3f2
 
 org.gradle.caching = true
 org.gradle.parallel = true
 org.gradle.vfs.watch = false
 org.gradle.jvmargs = -Xmx3G
+
+mcVersion=1.20.4
+GroupMCV=1.20
+preVersion=false

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/api/0001-Threaded-region-start-tick-and-finished-tick-event.patch

@@ -0,0 +1,101 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Fri, 9 Feb 2024 03:32:05 +0000
+Subject: [PATCH] Threaded region start tick and finished tick event
+
+
+diff --git a/src/main/java/me/earthme/luminol/api/events/TickRegionFinishedTickEvent.java b/src/main/java/me/earthme/luminol/api/events/TickRegionFinishedTickEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..29b98728d3ca4a439c6b3333cd123c0e0b8a2846
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/events/TickRegionFinishedTickEvent.java
+@@ -0,0 +1,42 @@
++package me.earthme.luminol.api.events;
++
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Called when a region finished its tick task.
++ */
++public class TickRegionFinishedTickEvent extends Event {
++    private static final HandlerList handlers = new HandlerList();
++
++    private final long currTime;
++    private final long regionId;
++
++    public TickRegionFinishedTickEvent(long currTime, long regionId) {
++        this.currTime = currTime;
++        this.regionId = regionId;
++    }
++
++    /**
++     * Get the time of tick end
++     * @return The time of tick end in nanoseconds
++     */
++    public long getFinishedTime() {
++        return this.currTime;
++    }
++
++    /**
++     * Get the id of current region
++     * Notice: The id of global region is -1 in this event
++     * @return The id of current region
++     */
++    public long getRegionId() {
++        return this.regionId;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return handlers;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/events/TickRegionStartTickEvent.java b/src/main/java/me/earthme/luminol/api/events/TickRegionStartTickEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..1f3cba43ebd873965c24b96ca116abfb149ab4e6
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/events/TickRegionStartTickEvent.java
+@@ -0,0 +1,41 @@
++package me.earthme.luminol.api.events;
++
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * Called when a tick was started.
++ */
++public class TickRegionStartTickEvent extends Event {
++    private static final HandlerList handlers = new HandlerList();
++    private final long currTime;
++    private final long regionId;
++
++    public TickRegionStartTickEvent(long currTime, long regionId) {
++        this.currTime = currTime;
++        this.regionId = regionId;
++    }
++
++    /**
++     * Get the id of current region
++     * Notice: The id of global region is -1 in this event
++     * @return The id of current region
++     */
++    public long getRegionId() {
++        return this.regionId;
++    }
++
++    /**
++     * Get the time of tick start
++     * @return The time of tick start in nanoseconds
++     */
++    public long getStartTime(){
++        return this.currTime;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return handlers;
++    }
++}

patches/api/0002-Leaves-Replay-Mod-API.patch

@@ -0,0 +1,129 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Sun, 17 Mar 2024 00:00:45 +0000
+Subject: [PATCH] Leaves Replay Mod API
+
+
+diff --git a/src/main/java/org/bukkit/Bukkit.java b/src/main/java/org/bukkit/Bukkit.java
+index 4d6de4f2c67b1f122768806443766bd20c5ae617..b5155ffe86c490252fd0fcd1a00581e09808eeee 100644
+--- a/src/main/java/org/bukkit/Bukkit.java
++++ b/src/main/java/org/bukkit/Bukkit.java
+@@ -2886,4 +2886,10 @@ public final class Bukkit {
+     public static Server.Spigot spigot() {
+         return server.spigot();
+     }
++
++    // Leaves start - Photographer API
++    public static @NotNull top.leavesmc.leaves.entity.PhotographerManager getPhotographerManager() {
++        return server.getPhotographerManager();
++    }
++    // Leaves end - Photographer API
+ }
+diff --git a/src/main/java/org/bukkit/Server.java b/src/main/java/org/bukkit/Server.java
+index d46f932b595495816ea038cf161bc7f2d85f177e..7d8a9bab880656e34d8c4dceb4dea3b0c1ced4c8 100644
+--- a/src/main/java/org/bukkit/Server.java
++++ b/src/main/java/org/bukkit/Server.java
+@@ -2518,4 +2518,8 @@ public interface Server extends PluginMessageRecipient, net.kyori.adventure.audi
+      */
+     public boolean isGlobalTickThread();
+     // Folia end - region threading API
++
++    // Leaves start - Photographer API
++    @NotNull top.leavesmc.leaves.entity.PhotographerManager getPhotographerManager();
++    // Leaves end - Photographer API
+ }
+diff --git a/src/main/java/top/leavesmc/leaves/entity/Photographer.java b/src/main/java/top/leavesmc/leaves/entity/Photographer.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..bfa6fe2a0ca095170aa5e073251402cf83a53ba0
+--- /dev/null
++++ b/src/main/java/top/leavesmc/leaves/entity/Photographer.java
+@@ -0,0 +1,27 @@
++package top.leavesmc.leaves.entity;
++
++import org.bukkit.entity.Player;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++
++import java.io.File;
++
++public interface Photographer extends Player {
++
++    @NotNull
++    public String getId();
++
++    public void setRecordFile(@NotNull File file);
++
++    public void stopRecording();
++
++    public void stopRecording(boolean async);
++
++    public void stopRecording(boolean async, boolean save);
++
++    public void pauseRecording();
++
++    public void resumeRecording();
++
++    public void setFollowPlayer(@Nullable Player player);
++}
+diff --git a/src/main/java/top/leavesmc/leaves/entity/PhotographerManager.java b/src/main/java/top/leavesmc/leaves/entity/PhotographerManager.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..2889a4835edea4254a3d35fc7861983644a1dc4b
+--- /dev/null
++++ b/src/main/java/top/leavesmc/leaves/entity/PhotographerManager.java
+@@ -0,0 +1,32 @@
++package top.leavesmc.leaves.entity;
++
++import org.bukkit.Location;
++import org.bukkit.util.Consumer;
++import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable;
++import top.leavesmc.leaves.replay.BukkitRecorderOption;
++
++import java.util.Collection;
++import java.util.UUID;
++
++public interface PhotographerManager {
++    @Nullable
++    public Photographer getPhotographer(@NotNull UUID uuid);
++
++    @Nullable
++    public Photographer getPhotographer(@NotNull String id);
++
++    @Nullable
++    public Photographer createPhotographer(@NotNull String id, @NotNull Location location);
++
++    @Nullable
++    public Photographer createPhotographer(@NotNull String id, @NotNull Location location, @NotNull BukkitRecorderOption recorderOption);
++
++    public void removePhotographer(@NotNull String id);
++
++    public void removePhotographer(@NotNull UUID uuid);
++
++    public void removeAllPhotographers();
++
++    public Collection<Photographer> getPhotographers();
++}
+diff --git a/src/main/java/top/leavesmc/leaves/replay/BukkitRecorderOption.java b/src/main/java/top/leavesmc/leaves/replay/BukkitRecorderOption.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..3df4a6055b91c28e273d6fb2697b608778f40a9c
+--- /dev/null
++++ b/src/main/java/top/leavesmc/leaves/replay/BukkitRecorderOption.java
+@@ -0,0 +1,18 @@
++package top.leavesmc.leaves.replay;
++
++public class BukkitRecorderOption {
++
++    // public int recordDistance = -1;
++    public String serverName = "Leaves";
++    public BukkitRecordWeather forceWeather = BukkitRecordWeather.NULL;
++    public int forceDayTime = -1;
++    public boolean ignoreChat = false;
++    // public boolean ignoreItem = false;
++
++    public enum BukkitRecordWeather {
++        CLEAR,
++        RAIN,
++        THUNDER,
++        NULL
++    }
++}

patches/server/0001-Fix-build.patch

@@ -1,11 +1,11 @@
 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
+From: MrHua269 <novau233@163.com>
+Date: Mon, 1 Jan 2024 07:59:27 +0000
 Subject: [PATCH] Fix build
 
 
 diff --git a/build.gradle.kts b/build.gradle.kts
-index 0cd12a854e544e867abfd94c18a9f138ba57e587..d295ee01481b088a376691de7c0927e95d7a68a8 100644
+index 905262067dabc7cbe5b08639fcefd3a996a937e0..c0608731dd7a352628a1e31997d0658dfa9f2ea8 100644
 --- a/build.gradle.kts
 +++ b/build.gradle.kts
 @@ -14,7 +14,7 @@ val alsoShade: Configuration by configurations.creating
@@ -13,11 +13,11 @@ index 0cd12a854e544e867abfd94c18a9f138ba57e587..d295ee01481b088a376691de7c0927e9
  dependencies {
      // Folia start
 -    implementation(project(":folia-api"))
-+    implementation(project(":luminol-api")) //Luminol
++    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 {
+@@ -75,7 +75,7 @@ tasks.jar {
          attributes(
              "Main-Class" to "org.bukkit.craftbukkit.Main",
              "Implementation-Title" to "CraftBukkit",

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/0003-Empty-config-file-base.patch

@@ -0,0 +1,437 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 00:45:19 +0000
+Subject: [PATCH] Empty config file base
+
+
+diff --git a/build.gradle.kts b/build.gradle.kts
+index 48e9f6ff317bfc7077563e9c651d2a90da6bb37a..d4baa7a193eba22be23921029ca4808a73de063d 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.6") //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/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..ac2a92fe0ddbebb71ea4dd8c96f461d06ec29a4c
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/EnumConfigCategory.java
+@@ -0,0 +1,18 @@
++package me.earthme.luminol.config;
++
++public enum EnumConfigCategory {
++    OPTIMIZATIONS("optimizations"),
++    FIXES("fixes"),
++    MISC("misc"),
++    GAMEPLAY("gameplay");
++
++    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..2b4e64796bf01b0a5fcb306850cd60837ed4d36b
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/LuminolConfig.java
+@@ -0,0 +1,218 @@
++package me.earthme.luminol.config;
++
++import com.electronwill.nightconfig.core.file.CommentedFileConfig;
++import io.papermc.paper.threadedregions.RegionizedServer;
++import me.earthme.luminol.commands.LuminolConfigCommand;
++import org.bukkit.Bukkit;
++import org.bukkit.craftbukkit.scheduler.MinecraftInternalPlugin;
++import org.jetbrains.annotations.Contract;
++import org.jetbrains.annotations.NotNull;
++
++import java.io.File;
++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;
++    private static MinecraftInternalPlugin NULL_PLUGIN = new MinecraftInternalPlugin();
++
++    public static void setupLatch(){
++        Bukkit.getCommandMap().register("luminolconfig","luminol",new LuminolConfigCommand());
++        alreadyInited = true;
++    }
++
++    public static void reload(){
++        RegionizedServer.ensureGlobalTickThread("Reload luminol config off global region thread!");
++
++        dropAllInstanced();
++        try {
++            loadConfig();
++        }catch (Exception e){
++            logger.error(e);
++        }
++    }
++
++    @Contract(" -> new")
++    public static @NotNull CompletableFuture<Void> reloadAsync(){
++        return CompletableFuture.runAsync(LuminolConfig::reload,task -> Bukkit.getGlobalRegionScheduler().run(NULL_PLUGIN,scheduled -> task.run()));
++    }
++
++    public static void dropAllInstanced(){
++        allInstanced.clear();
++    }
++
++    public static void loadConfig() throws IOException {
++        baseConfigFolder.mkdirs();
++
++        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);
++        }
++
++        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);
++            }
++        }
++
++        singleConfigModule.onLoaded(configFileInstance);
++    }
++
++    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/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+index 6b3242117d62175de462d04e4d178b49ae2521e9..4744ace98d1741db80ac2aea198f332d95c0ba33 100644
+--- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
++++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -19,6 +19,8 @@ import java.util.Locale;
+ import java.util.Optional;
+ import java.util.function.BooleanSupplier;
+ import javax.annotation.Nullable;
++
++import me.earthme.luminol.config.LuminolConfig;
+ import net.minecraft.DefaultUncaughtExceptionHandler;
+ import net.minecraft.DefaultUncaughtExceptionHandlerWithName;
+ import net.minecraft.SharedConstants;
+@@ -209,6 +211,8 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+         this.paperConfigurations.initializeGlobalConfiguration(this.registryAccess());
+         this.paperConfigurations.initializeWorldDefaultsConfiguration(this.registryAccess());
+         // Paper end - initialize global and world-defaults configuration
++        LuminolConfig.loadConfig(); //Luminol - load config file
++        LuminolConfig.setupLatch(); //Luminol - load config file
+         // Paper start - fix converting txt to json file; convert old users earlier after PlayerList creation but before file load/save
+         if (this.convertOldUsers()) {
+             this.getProfileCache().save(false); // Paper

patches/server/0004-Add-config-for-server-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) {

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

@@ -0,0 +1,61 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 00:49:38 +0000
+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";
++    }
++}
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 8c9a80197247a384dd80747bf23fdd809d08b341..0d756dd5181a2444175184227bef648d07c17236 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1963,7 +1963,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+ 
+     @DontObfuscate
+     public String getServerModName() {
+-        return "Luminol"; // Paper // Folia - Folia //Luminol - Luminol
++        return me.earthme.luminol.config.modules.misc.ServerModNameConfig.fakeVanilla ? "vanilla" : me.earthme.luminol.config.modules.misc.ServerModNameConfig.serverModName; // Paper // Folia - Folia //Luminol - Luminol //Luminol - Add config for this
+     }
+ 
+     public SystemReport fillSystemReport(SystemReport details) {

patches/server/0005-Add-config-for-unsafe-teleportation.patch

@@ -1,77 +1,57 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 11:18:04 +0800
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 00:53:03 +0000
 Subject: [PATCH] Add config for unsafe teleportation
 
 
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index 1f9ff0fc33fa36c90fc4cbbd21b7b790de581632..36ca0b94d29d81e5f1f2aff4a38ead0b363dd1c7 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -14,6 +14,8 @@ public class LuminolConfig {
-     public static String serverModName = "Luminol";
-     public static boolean fakeVanillaModeEnabled = false;
- 
-+    public static boolean safeTeleportation = true;
+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..1b0de6f0ccab72c409a63dc1904829008e30328e
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/fixes/UnsafeTeleportationConfig.java
+@@ -0,0 +1,20 @@
++package me.earthme.luminol.config.modules.fixes;
 +
-     public static void init() throws IOException {
-         PARENT_FOLDER.mkdir();
- 
-@@ -31,6 +33,8 @@ public class LuminolConfig {
-     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");
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
 +
-+        safeTeleportation = get("fixes.enable_safe_teleportation",safeTeleportation,"If this enabled,the end portals will not teleport removed entities.");
-     }
- 
-     public static <T> T get(String key,T def){
++public class UnsafeTeleportationConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled", comments = "If you want to use sand duping,please turn on this")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.FIXES;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "allow_unsafe_teleportation";
++    }
++}
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 385d5bc08928dd990b690b926e174af86f178c64..e357ed9607889536ecd0e6ea8b59c97d3dab631f 100644
+index 1d77bc6bdb87de1ad6c8740376391dedcaa73089..5e3a5e6b05254481ad413069b249ef554b591f8c 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -24,6 +24,8 @@ import java.util.function.BiConsumer;
- import java.util.function.Predicate;
- import java.util.stream.Stream;
- import javax.annotation.Nullable;
-+
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.BlockUtil;
- import net.minecraft.CrashReport;
- import net.minecraft.CrashReportCategory;
-@@ -4001,6 +4003,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+@@ -4065,6 +4065,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
  
      protected boolean tryEndPortal() {
          io.papermc.paper.util.TickThread.ensureTickThread(this, "Cannot portal entity async");
-+        if (!LuminolConfig.safeTeleportation && !(this instanceof Player)) return false; //Luminol - Unsafe teleportation
++        if (me.earthme.luminol.config.modules.fixes.UnsafeTeleportationConfig.enabled && !(this instanceof Player)) return false; //Luminol - Unsafe teleportation
          BlockPos pos = this.portalBlock;
          ServerLevel world = this.portalWorld;
          this.portalBlock = null;
 diff --git a/src/main/java/net/minecraft/world/level/block/EndPortalBlock.java b/src/main/java/net/minecraft/world/level/block/EndPortalBlock.java
-index 41d7cff39fc37955877668337689b4b26cd8c7cf..ca5799c618bec3d0abc4566d82a29bcc767c6f1f 100644
+index afc9445941b984cc1122839e4a8a17cf27aa966e..0eb328e2b32179ebeefc90063441a1510e0058b8 100644
 --- a/src/main/java/net/minecraft/world/level/block/EndPortalBlock.java
 +++ b/src/main/java/net/minecraft/world/level/block/EndPortalBlock.java
-@@ -1,5 +1,6 @@
- package net.minecraft.world.level.block;
- 
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.core.BlockPos;
- import net.minecraft.core.particles.ParticleTypes;
- import net.minecraft.resources.ResourceKey;
-@@ -7,6 +8,7 @@ import net.minecraft.server.level.ServerLevel;
- import net.minecraft.server.level.ServerPlayer;
- import net.minecraft.util.RandomSource;
- import net.minecraft.world.entity.Entity;
-+import net.minecraft.world.entity.player.Player;
- import net.minecraft.world.item.ItemStack;
- import net.minecraft.world.level.BlockGetter;
- import net.minecraft.world.level.Level;
-@@ -53,6 +55,13 @@ public class EndPortalBlock extends BaseEntityBlock {
+@@ -61,6 +61,13 @@ public class EndPortalBlock extends BaseEntityBlock {
                  // return; // CraftBukkit - always fire event in case plugins wish to change it
              }
  
 +            //Luminol start - Unsafe teleportation
-+            if (!LuminolConfig.safeTeleportation && !(entity instanceof Player)){
++            if (me.earthme.luminol.config.modules.fixes.UnsafeTeleportationConfig.enabled && !(entity instanceof net.minecraft.world.entity.player.Player)){
 +                entity.endPortalLogicAsync();
 +                return;
 +            }

patches/server/0006-Add-config-for-sand-duping.patch

@@ -1,57 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sat, 25 Nov 2023 18:17:52 +0800
-Subject: [PATCH] Add config for sand duping
-
-
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index 36ca0b94d29d81e5f1f2aff4a38ead0b363dd1c7..9db3bdd7a7d0b2a110e927ee4781eee489d0da9b 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -15,6 +15,7 @@ public class LuminolConfig {
-     public static boolean fakeVanillaModeEnabled = false;
- 
-     public static boolean safeTeleportation = true;
-+    public static boolean enableSandDuping = false;
- 
-     public static void init() throws IOException {
-         PARENT_FOLDER.mkdir();
-@@ -35,6 +36,7 @@ public class LuminolConfig {
-         fakeVanillaModeEnabled = get("misc.enable_fake_vanilla_mode",fakeVanillaModeEnabled,"Enable this to make the ping response of your server like a vanilla server");
- 
-         safeTeleportation = get("fixes.enable_safe_teleportation",safeTeleportation,"If this enabled,the end portals will not teleport removed entities.");
-+        enableSandDuping = get("fixes.enable_sand_duping",enableSandDuping,"If this enabled,The value of safe teleportation will always be false and sand duping will be enabled");
-     }
- 
-     public static <T> T get(String key,T def){
-diff --git a/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java b/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java
-index 8e348099d6b3eb4510405d76453d70e7cadeebf6..cf72aa13fce00bf21c036c14a605ea7c6090d5f0 100644
---- a/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java
-+++ b/src/main/java/net/minecraft/world/entity/item/FallingBlockEntity.java
-@@ -4,6 +4,8 @@ import com.mojang.logging.LogUtils;
- import java.util.Iterator;
- import java.util.function.Predicate;
- import javax.annotation.Nullable;
-+
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.CrashReportCategory;
- import net.minecraft.core.BlockPos;
- import net.minecraft.core.Direction;
-@@ -133,7 +135,7 @@ public class FallingBlockEntity extends Entity {
-     @Override
-     public void tick() {
-         // Paper start - fix sand duping
--        if (this.isRemoved()) {
-+        if (!LuminolConfig.enableSandDuping && this.isRemoved()) { //Luminol - Add config for sand duping
-             return;
-         }
-         // Paper end - fix sand duping
-@@ -150,7 +152,7 @@ public class FallingBlockEntity extends Entity {
-             this.move(MoverType.SELF, this.getDeltaMovement());
- 
-             // Paper start - fix sand duping
--            if (this.isRemoved()) {
-+            if (!LuminolConfig.enableSandDuping && this.isRemoved()) { //Luminol - Add config for sand duping
-                 return;
-             }
-             // Paper end - fix sand duping

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

@@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 00:59:18 +0000
+Subject: [PATCH] Add config for void trading
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/fixes/VoidTradingFixConfig.java b/src/main/java/me/earthme/luminol/config/modules/fixes/VoidTradingFixConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..22f3c6c70e4287f1bdd0b18f87f57efeb20140a2
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/fixes/VoidTradingFixConfig.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 VoidTradingFixConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.FIXES;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "allow_void_trading";
++    }
++}
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 81749b8da7182abd1bf35629f33388e813dbeac0..10df17ad79092f3e226df08e58620694b3581758 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -3045,7 +3045,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+             // Spigot Start
+             if (entity.getBukkitEntity() instanceof org.bukkit.inventory.InventoryHolder && (!(entity instanceof ServerPlayer) || entity.getRemovalReason() != Entity.RemovalReason.KILLED)) { // SPIGOT-6876: closeInventory clears death message
+                 // Paper start - Fix merchant inventory not closing on entity removal
+-                if (entity.getBukkitEntity() instanceof org.bukkit.inventory.Merchant merchant && merchant.getTrader() != null) {
++                if (!me.earthme.luminol.config.modules.fixes.VoidTradingFixConfig.enabled && (entity.getBukkitEntity() instanceof org.bukkit.inventory.Merchant merchant && merchant.getTrader() != null)) { //Luminol - Add config for void trading
+                     merchant.getTrader().closeInventory(org.bukkit.event.inventory.InventoryCloseEvent.Reason.UNLOADED);
+                 }
+                 // Paper end - Fix merchant inventory not closing on entity removal

patches/server/0007-Add-config-for-vanilla-random.patch

@@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 02:33:00 +0000
+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..ee247014c9a2ec1bbb7f25ef41da110a270154d6
+--- /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")
++    public static boolean useLegacyRandomSourceForPlayers = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.FIXES;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "use_vanilla_random_source";
++    }
++}
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 5e3a5e6b05254481ad413069b249ef554b591f8c..9bbfac91f97331b1b558264c867b7e00185291f2 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -567,7 +567,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+         this.bb = Entity.INITIAL_AABB;
+         this.stuckSpeedMultiplier = Vec3.ZERO;
+         this.nextStep = 1.0F;
+-        this.random = SHARED_RANDOM; // Paper - Share random for entities to make them more random
++        this.random = me.earthme.luminol.config.modules.fixes.VanillaRandomSourceConfig.useLegacyRandomSourceForPlayers ? RandomSource.create() : SHARED_RANDOM;//Luminol - Add config for vanilla random SHARED_RANDOM // Paper - Share random for entities to make them more random
+         this.remainingFireTicks = -this.getFireImmuneTicks();
+         this.fluidHeight = new Object2DoubleArrayMap(2);
+         this.fluidOnEyes = new HashSet();

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

@@ -1,39 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sat, 25 Nov 2023 18:22:09 +0800
-Subject: [PATCH] Add config for void trading
-
-
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index 9db3bdd7a7d0b2a110e927ee4781eee489d0da9b..dffa9db569fcef2feec75072fe86c9a6ded80aa4 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -16,6 +16,7 @@ public class LuminolConfig {
- 
-     public static boolean safeTeleportation = true;
-     public static boolean enableSandDuping = false;
-+    public static boolean enableVoidTrading = false;
- 
-     public static void init() throws IOException {
-         PARENT_FOLDER.mkdir();
-@@ -37,6 +38,7 @@ public class LuminolConfig {
- 
-         safeTeleportation = get("fixes.enable_safe_teleportation",safeTeleportation,"If this enabled,the end portals will not teleport removed entities.");
-         enableSandDuping = get("fixes.enable_sand_duping",enableSandDuping,"If this enabled,The value of safe teleportation will always be false and sand duping will be enabled");
-+        enableVoidTrading = get("fixes.enable_void_trading",enableVoidTrading);
-     }
- 
-     public static <T> T get(String key,T def){
-diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index e274c501e2455845f6f9a4614802336205362b69..722a5ec7f8e4995ac7025ca0785145d46bd66fcd 100644
---- a/src/main/java/net/minecraft/server/level/ServerLevel.java
-+++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -3026,7 +3026,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
-             // Spigot Start
-             if (entity.getBukkitEntity() instanceof org.bukkit.inventory.InventoryHolder && (!(entity instanceof ServerPlayer) || entity.getRemovalReason() != Entity.RemovalReason.KILLED)) { // SPIGOT-6876: closeInventory clears death message
-                 // Paper start
--                if (entity.getBukkitEntity() instanceof org.bukkit.inventory.Merchant merchant && merchant.getTrader() != null) {
-+                if (!LuminolConfig.enableVoidTrading && (entity.getBukkitEntity() instanceof org.bukkit.inventory.Merchant merchant && merchant.getTrader() != null)) { //Luminol - Add config for void trading
-                     merchant.getTrader().closeInventory(org.bukkit.event.inventory.InventoryCloseEvent.Reason.UNLOADED);
-                 }
-                 // Paper end

patches/server/0008-Add-config-for-chat-sign.patch

@@ -0,0 +1,76 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 02:00:50 +0000
+Subject: [PATCH] Add config for chat sign
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/ChatSignConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/ChatSignConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..1e03e51e51f56c38abaad100274e25c9f854f727
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/ChatSignConfig.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 ChatSignConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = true;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "mojang_chat_sign";
++    }
++}
+diff --git a/src/main/java/net/minecraft/commands/arguments/ArgumentSignatures.java b/src/main/java/net/minecraft/commands/arguments/ArgumentSignatures.java
+index 72a8aa676836fcb3b4578689d16af65e18f55bbe..9408747cb254a99d5cb3fc26fde16ddb80168894 100644
+--- a/src/main/java/net/minecraft/commands/arguments/ArgumentSignatures.java
++++ b/src/main/java/net/minecraft/commands/arguments/ArgumentSignatures.java
+@@ -14,9 +14,17 @@ public record ArgumentSignatures(List<ArgumentSignatures.Entry> entries) {
+     private static final int MAX_ARGUMENT_NAME_LENGTH = 16;
+ 
+     public ArgumentSignatures(FriendlyByteBuf buf) {
+-        this(buf.readCollection(FriendlyByteBuf.limitValue(ArrayList::new, 8), ArgumentSignatures.Entry::new));
++        this(readSign(buf)); //Luminol - Fix java compile
+     }
+ 
++    //Luminol start - Add config for chat sign
++    private static List<ArgumentSignatures.Entry> readSign(FriendlyByteBuf buf) {
++        var entries = buf.readCollection(FriendlyByteBuf.limitValue(ArrayList::new, 8), Entry::new);
++        return me.earthme.luminol.config.modules.misc.ChatSignConfig.enabled ? List.of() : entries;
++    }
++    //Luminol end
++
++
+     @Nullable
+     public MessageSignature get(String argumentName) {
+         for(ArgumentSignatures.Entry entry : this.entries) {
+diff --git a/src/main/java/net/minecraft/network/FriendlyByteBuf.java b/src/main/java/net/minecraft/network/FriendlyByteBuf.java
+index b863249ff7e13cf4939c8961601f0564c62fd661..6ab73b0568c3f9df8090be992736a14d49e0286c 100644
+--- a/src/main/java/net/minecraft/network/FriendlyByteBuf.java
++++ b/src/main/java/net/minecraft/network/FriendlyByteBuf.java
+@@ -143,6 +143,16 @@ public class FriendlyByteBuf extends ByteBuf {
+         // Paper end - Adventure; add max length parameter
+         DataResult<JsonElement> dataresult = codec.encodeStart(JsonOps.INSTANCE, value);
+ 
++        //Luminol start - Add config for chat sign
++        if (codec == net.minecraft.network.protocol.status.ServerStatus.CODEC) {
++            JsonElement element = Util.getOrThrow(dataresult, string -> new EncoderException("Failed to encode: " + string + " " + value));
++            element.getAsJsonObject().addProperty("preventsChatReports", !me.earthme.luminol.config.modules.misc.ChatSignConfig.enabled);
++
++            this.writeUtf(GSON.toJson(element));
++            return;
++        }
++        //Luminol end
++
+         this.writeUtf(FriendlyByteBuf.GSON.toJson((JsonElement) Util.getOrThrow(dataresult, (s) -> {
+             return new EncoderException("Failed to encode: " + s + " " + value);
+         })), maxLength); // Paper - Adventure; add max length parameter

patches/server/0008-Add-config-for-incorrect-tripwire-updating-fixing.patch

@@ -1,48 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sat, 25 Nov 2023 18:25:37 +0800
-Subject: [PATCH] Add config for incorrect tripwire updating fixing
-
-
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index dffa9db569fcef2feec75072fe86c9a6ded80aa4..a49da370c91211d4e2274f72d62c911a1912296a 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -17,6 +17,7 @@ public class LuminolConfig {
-     public static boolean safeTeleportation = true;
-     public static boolean enableSandDuping = false;
-     public static boolean enableVoidTrading = false;
-+    public static boolean allowIncorrectTripwireUpdating = false;
- 
-     public static void init() throws IOException {
-         PARENT_FOLDER.mkdir();
-@@ -39,6 +40,7 @@ public class LuminolConfig {
-         safeTeleportation = get("fixes.enable_safe_teleportation",safeTeleportation,"If this enabled,the end portals will not teleport removed entities.");
-         enableSandDuping = get("fixes.enable_sand_duping",enableSandDuping,"If this enabled,The value of safe teleportation will always be false and sand duping will be enabled");
-         enableVoidTrading = get("fixes.enable_void_trading",enableVoidTrading);
-+        allowIncorrectTripwireUpdating = get("fixes.allow_incorrect_trip_wire_updaing",allowIncorrectTripwireUpdating);
-     }
- 
-     public static <T> T get(String key,T def){
-diff --git a/src/main/java/net/minecraft/world/level/block/TripWireHookBlock.java b/src/main/java/net/minecraft/world/level/block/TripWireHookBlock.java
-index 004dce26ff073f1de52a84cd425c4f60fdab5e50..ef150d50ff076c80ee62c3c413745fa312c9d289 100644
---- a/src/main/java/net/minecraft/world/level/block/TripWireHookBlock.java
-+++ b/src/main/java/net/minecraft/world/level/block/TripWireHookBlock.java
-@@ -2,6 +2,8 @@ package net.minecraft.world.level.block;
- 
- import com.google.common.base.MoreObjects;
- import javax.annotation.Nullable;
-+
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.core.BlockPos;
- import net.minecraft.core.Direction;
- import net.minecraft.server.level.ServerLevel;
-@@ -147,7 +149,7 @@ public class TripWireHookBlock extends Block {
-                 boolean flag7 = (Boolean) iblockdata2.getValue(TripWireBlock.POWERED);
- 
-                 flag5 |= flag6 && flag7;
--                if (k != i || !tripWireBeingRemoved || !flag6) // Paper - don't update the tripwire again if being removed and not disarmed
-+                if (k != i || !tripWireBeingRemoved || !flag6 || LuminolConfig.allowIncorrectTripwireUpdating) // Paper - don't update the tripwire again if being removed and not disarmed //Luminol - Add config for incorrect tripwire updating fixing
-                 aiblockdata[k] = iblockdata2;
-                 if (k == i) {
-                     world.scheduleTick(pos, (Block) this, 10);

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

@@ -1,76 +1,24 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 15:19:16 +0800
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 04:39:56 +0000
 Subject: [PATCH] Add a simple tpsbar
 
 
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index 90a6cfd011aaefe66fda79f887380ab2d62a07b1..0657fce8aabb956a400b3cead53c28ef52e67fe9 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -2,11 +2,15 @@ package me.earthme.luminol;
- 
- import dev.kaiijumc.kaiiju.region.RegionFileFormat;
- import com.electronwill.nightconfig.core.file.CommentedFileConfig;
-+import me.earthme.luminol.commands.TpsBarCommand;
-+import me.earthme.luminol.functions.GlobalServerTpsBar;
- import net.minecraft.server.level.ServerLevel;
- import org.apache.logging.log4j.LogManager;
- import org.apache.logging.log4j.Logger;
-+import org.bukkit.Bukkit;
- 
- import java.util.Arrays;
-+import java.util.List;
- import java.util.logging.Level;
- import java.io.File;
- import java.io.IOException;
-@@ -20,6 +24,10 @@ public class LuminolConfig {
-     public static String serverModName = "Luminol";
-     public static boolean fakeVanillaModeEnabled = false;
-     public static boolean disableChatSign = false;
-+    public static boolean tpsbarEnabled = false;
-+    public static String tpsBarFormat = "<gray>TPS<yellow>:</yellow> <tps> MSPT<yellow>:</yellow> <mspt> Ping<yellow>:</yellow> <ping>ms";
-+    public static String[] tpsColors = new String[]{"GREEN","YELLOW","RED","PURPLE"};
-+    public static String[] pingColors = new String[]{"GREEN","YELLOW","RED","PURPLE"};
- 
-     public static boolean safeTeleportation = true;
-     public static boolean enableSandDuping = false;
-@@ -46,10 +54,25 @@ public class LuminolConfig {
-         MAIN_CONFIG.save();
-     }
- 
-+    public static void initTpsbar(){
-+        if (tpsbarEnabled){
-+            GlobalServerTpsBar.init();
-+            Bukkit.getCommandMap().register("tpsbar","luminol",new TpsBarCommand("tpsbar"));
-+        }
-+    }
-+
-     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");
-         disableChatSign = get("misc.disable_chat_sign",disableChatSign,"Set this to true to disable mojang's chat sign");
-+        tpsbarEnabled = get("misc.enable_tpsbar",tpsbarEnabled,"When this enabled,You or your players can see the tps,mspt and ping through a simple bossbar");
-+        tpsBarFormat = get("misc.tpsbar_title_format",tpsBarFormat,"The format of tpsbar.");
-+        tpsColors = get("misc.tpsbar_range_colors", List.of(tpsColors),"The bar and text color of each tps ranges.The last is the color of initial bar's color").toArray(String[]::new);
-+        pingColors = get("misc.tpsbar_ping_range_colors",List.of(pingColors),"As same as the tpsColors").toArray(String[]::new);
-+
-+        if (tpsbarEnabled){
-+            initTpsbar();
-+        }
- 
-         safeTeleportation = get("fixes.enable_safe_teleportation",safeTeleportation,"If this enabled,the end portals will not teleport removed entities.");
-         enableSandDuping = get("fixes.enable_sand_duping",enableSandDuping,"If this enabled,The value of safe teleportation will always be false and sand duping will be enabled");
 diff --git a/src/main/java/me/earthme/luminol/commands/TpsBarCommand.java b/src/main/java/me/earthme/luminol/commands/TpsBarCommand.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..ac8f0e3bf130ba6dfd7202e2f480352218154cdc
+index 0000000000000000000000000000000000000000..01677f210fae53a108bfe194189cb4c233e9fa47
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/commands/TpsBarCommand.java
-@@ -0,0 +1,40 @@
+@@ -0,0 +1,50 @@
 +package me.earthme.luminol.commands;
 +
++import me.earthme.luminol.config.modules.misc.TpsBarConfig;
 +import me.earthme.luminol.functions.GlobalServerTpsBar;
++import net.kyori.adventure.text.Component;
++import net.kyori.adventure.text.format.TextColor;
++import net.kyori.adventure.util.RGBLike;
 +import org.bukkit.ChatColor;
++import org.bukkit.Color;
 +import org.bukkit.command.Command;
 +import org.bukkit.command.CommandSender;
 +import org.bukkit.entity.Player;
@@ -90,43 +38,104 @@ index 0000000000000000000000000000000000000000..ac8f0e3bf130ba6dfd7202e2f4803522
 +            return true;
 +        }
 +
++        if (!TpsBarConfig.tpsbarEnabled){
++            sender.sendMessage(Component.text("Tpsbar was already disabled!").color(TextColor.color(255,0,0)));
++            return true;
++        }
++
 +        if (!(sender instanceof Player player)){
-+            sender.sendMessage(ChatColor.RED+"Only player can use this command!");
++            sender.sendMessage(Component.text("Only player can use this command!").color(TextColor.color(255,0,0)));
 +            return true;
 +        }
 +
 +        if (GlobalServerTpsBar.isPlayerVisible(player)) {
-+            player.sendMessage(ChatColor.BLUE + "Disabled tps bar");
++            player.sendMessage(Component.text("Disabled tps bar").color(TextColor.color(0,255,0)));
 +            GlobalServerTpsBar.setVisibilityForPlayer(player,false);
 +            return true;
 +        }
 +
-+        player.sendMessage(ChatColor.GREEN + "Enabled tps bar");
++        player.sendMessage(Component.text("Enabled tps bar").color(TextColor.color(0,255,0)));
 +        GlobalServerTpsBar.setVisibilityForPlayer(player,true);
 +
 +        return true;
 +    }
 +}
+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..3023bc0e7420870e80dda75f7b044069b61a2b7e
+index 0000000000000000000000000000000000000000..3f1478dde900d671c4bfa43df80f629519cd602e
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/functions/GlobalServerTpsBar.java
-@@ -0,0 +1,204 @@
+@@ -0,0 +1,225 @@
 +package me.earthme.luminol.functions;
 +
-+import com.google.common.collect.Lists;
 +import io.papermc.paper.threadedregions.ThreadedRegionizer;
 +import io.papermc.paper.threadedregions.TickData;
 +import io.papermc.paper.threadedregions.TickRegions;
 +import io.papermc.paper.threadedregions.scheduler.ScheduledTask;
-+import me.earthme.luminol.LuminolConfig;
++import me.earthme.luminol.config.modules.misc.TpsBarConfig;
 +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 net.minecraft.server.level.ServerLevel;
 +import net.minecraft.server.level.ServerPlayer;
++import org.apache.logging.log4j.LogManager;
++import org.apache.logging.log4j.Logger;
 +import org.bukkit.Bukkit;
 +import org.bukkit.craftbukkit.entity.CraftPlayer;
 +import org.bukkit.craftbukkit.scheduler.MinecraftInternalPlugin;
@@ -140,20 +149,40 @@ index 0000000000000000000000000000000000000000..3023bc0e7420870e80dda75f7b044069
 +    protected static final MinecraftInternalPlugin NULL_PLUGIN = new MinecraftInternalPlugin();
 +    protected static final Map<UUID,BossBar> uuid2Bossbars = new HashMap<>();
 +    protected static volatile ScheduledTask tpsbarTask = null;
++    private static final Logger logger = LogManager.getLogger();
 +
 +    public static void init(){
-+        Bukkit.getAsyncScheduler().runAtFixedRate(NULL_PLUGIN,c -> {
++        cancelBarUpdateTask();
++
++        Bukkit.getGlobalRegionScheduler().runAtFixedRate(NULL_PLUGIN,c -> {
 +            tpsbarTask = c;
 +            try {
 +                update();
 +            }catch (Exception e){
-+                e.printStackTrace();
++                logger.error(e);
 +            }
-+        },1,1, TimeUnit.SECONDS);
++        },1,TpsBarConfig.updateInterval);
++    }
++
++    public static void removeAllBars(){
++        for (Map.Entry<UUID,BossBar> barEntry : uuid2Bossbars.entrySet()){
++            final UUID playerUUID = barEntry.getKey();
++            final BossBar tpsBar = barEntry.getValue();
++
++            final Player targetPlayer = Bukkit.getPlayer(playerUUID);{
++                if (targetPlayer != null){
++                    targetPlayer.hideBossBar(tpsBar);
++                }
++            }
++        }
++
++        uuid2Bossbars.clear();
 +    }
 +
 +    public static void cancelBarUpdateTask(){
-+        if (tpsbarTask == null){
++        removeAllBars();
++
++        if (tpsbarTask == null || tpsbarTask.isCancelled()){
 +            return;
 +        }
 +
@@ -215,7 +244,7 @@ index 0000000000000000000000000000000000000000..3023bc0e7420870e80dda75f7b044069
 +            BossBar targetBossbar = uuid2Bossbars.get(nmsPlayer.getUUID());
 +
 +            if (targetBossbar == null && isPlayerVisible(apiPlayer)){
-+                targetBossbar = BossBar.bossBar(Component.text(""),0.0F, BossBar.Color.valueOf(LuminolConfig.tpsColors[3]), BossBar.Overlay.NOTCHED_20);
++                targetBossbar = BossBar.bossBar(Component.text(""),0.0F, BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(3)), BossBar.Overlay.NOTCHED_20);
 +                uuid2Bossbars.put(nmsPlayer.getUUID(),targetBossbar);
 +                apiPlayer.showBossBar(targetBossbar);
 +            }
@@ -230,13 +259,13 @@ index 0000000000000000000000000000000000000000..3023bc0e7420870e80dda75f7b044069
 +
 +    private static void updateTpsBar(double tps, double mspt, @NotNull BossBar bar, @NotNull Player player){
 +        bar.name(MiniMessage.miniMessage().deserialize(
-+                LuminolConfig.tpsBarFormat,
++                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(mspt / 50,1.0));
++        bar.progress((float) Math.min((float)1,Math.max(mspt / 50,0)));
 +    }
 +
 +    private static @NotNull Component getPingComponent(int ping){
@@ -251,18 +280,18 @@ index 0000000000000000000000000000000000000000..3023bc0e7420870e80dda75f7b044069
 +
 +    private static BossBar.Color barColorFromPing(int ping){
 +        if (ping == -1){
-+            return BossBar.Color.valueOf(LuminolConfig.tpsColors[3]);
++            return BossBar.Color.valueOf(TpsBarConfig.pingColors.get(3));
 +        }
 +
 +        if (ping <= 80){
-+            return BossBar.Color.valueOf(LuminolConfig.tpsColors[0]);
++            return BossBar.Color.valueOf(TpsBarConfig.pingColors.get(0));
 +        }
 +
 +        if (ping <= 160){
-+            return BossBar.Color.valueOf(LuminolConfig.tpsColors[1]);
++            return BossBar.Color.valueOf(TpsBarConfig.pingColors.get(1));
 +        }
 +
-+        return BossBar.Color.valueOf(LuminolConfig.tpsColors[2]);
++        return BossBar.Color.valueOf(TpsBarConfig.pingColors.get(2));
 +    }
 +
 +    private static @NotNull Component getMsptComponent(double mspt){
@@ -277,18 +306,18 @@ index 0000000000000000000000000000000000000000..3023bc0e7420870e80dda75f7b044069
 +
 +    private static BossBar.Color barColorFromMspt(double mspt){
 +        if (mspt == -1){
-+            return BossBar.Color.valueOf(LuminolConfig.tpsColors[3]);
++            return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(3));
 +        }
 +
 +        if (mspt <= 25){
-+            return BossBar.Color.valueOf(LuminolConfig.tpsColors[0]);
++            return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(0));
 +        }
 +
 +        if (mspt <= 50){
-+            return BossBar.Color.valueOf(LuminolConfig.tpsColors[1]);
++            return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(1));
 +        }
 +
-+        return BossBar.Color.valueOf(LuminolConfig.tpsColors[2]);
++        return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(2));
 +    }
 +
 +    private static @NotNull Component getTpsComponent(double tps){
@@ -303,90 +332,65 @@ index 0000000000000000000000000000000000000000..3023bc0e7420870e80dda75f7b044069
 +
 +    private static BossBar.Color barColorFromTps(double tps){
 +        if (tps == -1){
-+            return BossBar.Color.valueOf(LuminolConfig.tpsColors[3]);
++            return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(3));
 +        }
 +
 +        if (tps >= 18){
-+            return BossBar.Color.valueOf(LuminolConfig.tpsColors[0]);
++            return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(0));
 +        }
 +
 +        if (tps >= 15){
-+            return BossBar.Color.valueOf(LuminolConfig.tpsColors[1]);
++            return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(1));
 +        }
 +
-+        return BossBar.Color.valueOf(LuminolConfig.tpsColors[2]);
++        return BossBar.Color.valueOf(TpsBarConfig.tpsColors.get(2));
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-index f0bf57a7acd77eeffbeeb6743ba58166823022fd..4a1e068c27853a38db0641806626e7ac740bd8de 100644
+index 4744ace98d1741db80ac2aea198f332d95c0ba33..550fb11c64e3adb35bb7f78c53f0b5ae5ce9ff58 100644
 --- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-@@ -1,20 +1,16 @@
- package net.minecraft.server.dedicated;
- 
--import com.google.common.collect.Lists;
-+import me.earthme.luminol.functions.GlobalServerTpsBar;
- import com.mojang.authlib.GameProfile;
- import com.mojang.datafixers.DataFixer;
- import com.mojang.logging.LogUtils;
--import java.io.BufferedReader;
-+
- import java.io.BufferedWriter;
- import java.io.IOException;
--import java.io.InputStreamReader;
- import java.net.InetAddress;
- import java.net.Proxy;
--import java.nio.charset.StandardCharsets;
- import java.nio.file.Files;
- import java.nio.file.Path;
--import java.util.Collections;
--import java.util.List;
- import java.util.Locale;
- import java.util.Optional;
- import java.util.function.BooleanSupplier;
-@@ -829,6 +825,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+@@ -832,6 +832,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
  
      @Override
      public void stopServer() {
-+        GlobalServerTpsBar.cancelBarUpdateTask(); //Luminol - Tpsbar
++        me.earthme.luminol.functions.GlobalServerTpsBar.cancelBarUpdateTask(); //Luminol - Tpsbar
          super.stopServer();
          //Util.shutdownExecutors(); // Paper - moved into super
          SkullBlockEntity.clear();
 diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 97bfb92e52c3c5ef1cd22afe2b97c204eb45025a..d7a280427442bac8cc8ccb542d24d4e0901df70a 100644
+index cbc89b8898f9243776af88c2b04ad3c2e4e23fb6..318cb1e98a3d73b7893f07c9f0db3adab801b67e 100644
 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
 +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -278,6 +278,7 @@ public class ServerPlayer extends Player {
+@@ -285,6 +285,7 @@ public class ServerPlayer extends Player {
      // Paper start - replace player chunk loader
      private final java.util.concurrent.atomic.AtomicReference<io.papermc.paper.chunk.system.RegionizedPlayerChunkLoader.ViewDistances> viewDistances = new java.util.concurrent.atomic.AtomicReference<>(new io.papermc.paper.chunk.system.RegionizedPlayerChunkLoader.ViewDistances(-1, -1, -1));
      public io.papermc.paper.chunk.system.RegionizedPlayerChunkLoader.PlayerChunkLoaderData chunkLoader;
-+    public volatile boolean isTpsBarVisible = false;
++    public volatile boolean isTpsBarVisible = false; //Luminol - Tps bar
  
      public io.papermc.paper.chunk.system.RegionizedPlayerChunkLoader.ViewDistances getViewDistances() {
          return this.viewDistances.get();
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index 6c8f6e26687b557fcdcd65c657d8b35d3fde805e..06c92a2d3ecb3b747c2303819f72c1c41967af8c 100644
+index d2902fc7f3b7af59f181bd1e12435d946db7ad23..26f70965b45fa3c344781b569a651a4668d0621d 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -2216,6 +2216,10 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+@@ -2287,6 +2287,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
          }
      }
  
-@@ -2237,6 +2241,10 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+@@ -2308,6 +2311,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());

patches/server/0009-Add-config-for-chat-sign.patch

@@ -1,118 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sat, 25 Nov 2023 18:31:24 +0800
-Subject: [PATCH] Add config for chat sign
-
-
-diff --git a/src/main/java/io/papermc/paper/adventure/ChatProcessor.java b/src/main/java/io/papermc/paper/adventure/ChatProcessor.java
-index 772e3a864e0e70288a1c010d8bbb809d34d16a41..68bd66aad880c81d1f8eaf88525597c878350961 100644
---- a/src/main/java/io/papermc/paper/adventure/ChatProcessor.java
-+++ b/src/main/java/io/papermc/paper/adventure/ChatProcessor.java
-@@ -15,6 +15,8 @@ import java.util.Objects;
- import java.util.Set;
- import java.util.concurrent.ExecutionException;
- import java.util.function.Function;
-+
-+import me.earthme.luminol.LuminolConfig;
- import net.kyori.adventure.audience.Audience;
- import net.kyori.adventure.audience.ForwardingAudience;
- import net.kyori.adventure.key.Key;
-@@ -355,7 +357,7 @@ public final class ChatProcessor {
- 
-         private void sendToServer(final ChatType.Bound chatType, final @Nullable Function<Audience, net.minecraft.network.chat.Component> msgFunction) {
-             final PlayerChatMessage toConsoleMessage = msgFunction == null ? ChatProcessor.this.message : ChatProcessor.this.message.withUnsignedContent(msgFunction.apply(ChatProcessor.this.server.console));
--            ChatProcessor.this.server.logChatMessage(toConsoleMessage.decoratedContent(), chatType, ChatProcessor.this.server.getPlayerList().verifyChatTrusted(toConsoleMessage) ? null : "Not Secure");
-+            ChatProcessor.this.server.logChatMessage(toConsoleMessage.decoratedContent(), chatType, ChatProcessor.this.server.getPlayerList().verifyChatTrusted(toConsoleMessage) || LuminolConfig.disableChatSign ? null : "Not Secure"); //Luminol - Add config for chat sign
-         }
-     }
- 
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index a49da370c91211d4e2274f72d62c911a1912296a..8d1ce8eae252fcf05b6a62d2dc467d6d503d3df4 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -13,6 +13,7 @@ public class LuminolConfig {
- 
-     public static String serverModName = "Luminol";
-     public static boolean fakeVanillaModeEnabled = false;
-+    public static boolean disableChatSign = false;
- 
-     public static boolean safeTeleportation = true;
-     public static boolean enableSandDuping = false;
-@@ -36,6 +37,7 @@ public class LuminolConfig {
-     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");
-+        disableChatSign = get("misc.disable_chat_sign",disableChatSign,"Set this to true to disable mojang's chat sign");
- 
-         safeTeleportation = get("fixes.enable_safe_teleportation",safeTeleportation,"If this enabled,the end portals will not teleport removed entities.");
-         enableSandDuping = get("fixes.enable_sand_duping",enableSandDuping,"If this enabled,The value of safe teleportation will always be false and sand duping will be enabled");
-diff --git a/src/main/java/net/minecraft/commands/arguments/ArgumentSignatures.java b/src/main/java/net/minecraft/commands/arguments/ArgumentSignatures.java
-index 72a8aa676836fcb3b4578689d16af65e18f55bbe..04653d58f2493d796e61bc97f0481cb628539c37 100644
---- a/src/main/java/net/minecraft/commands/arguments/ArgumentSignatures.java
-+++ b/src/main/java/net/minecraft/commands/arguments/ArgumentSignatures.java
-@@ -4,6 +4,8 @@ import java.util.ArrayList;
- import java.util.List;
- import java.util.Objects;
- import javax.annotation.Nullable;
-+
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.network.FriendlyByteBuf;
- import net.minecraft.network.chat.MessageSignature;
- import net.minecraft.network.chat.SignableCommand;
-@@ -14,8 +16,16 @@ public record ArgumentSignatures(List<ArgumentSignatures.Entry> entries) {
-     private static final int MAX_ARGUMENT_NAME_LENGTH = 16;
- 
-     public ArgumentSignatures(FriendlyByteBuf buf) {
--        this(buf.readCollection(FriendlyByteBuf.limitValue(ArrayList::new, 8), ArgumentSignatures.Entry::new));
-+        this(readSign(buf));
-+    }
-+
-+    //Luminol start - Add config for chat sign
-+    private static List<ArgumentSignatures.Entry> readSign(FriendlyByteBuf buf) {
-+        var entries = buf.readCollection(FriendlyByteBuf.limitValue(ArrayList::new, 8), Entry::new);
-+        return LuminolConfig.disableChatSign ? List.of() : entries;
-     }
-+    //Luminol end
-+
- 
-     @Nullable
-     public MessageSignature get(String argumentName) {
-diff --git a/src/main/java/net/minecraft/network/FriendlyByteBuf.java b/src/main/java/net/minecraft/network/FriendlyByteBuf.java
-index 2e395962b555bef0ce1a98e1d768e7738f011535..11a9bc78c34b9f6bfff1ebf979be55b9bbbbed55 100644
---- a/src/main/java/net/minecraft/network/FriendlyByteBuf.java
-+++ b/src/main/java/net/minecraft/network/FriendlyByteBuf.java
-@@ -48,6 +48,8 @@ import java.util.function.Function;
- import java.util.function.IntFunction;
- import java.util.function.ToIntFunction;
- import javax.annotation.Nullable;
-+
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.Util;
- import net.minecraft.core.BlockPos;
- import net.minecraft.core.Direction;
-@@ -65,6 +67,7 @@ import net.minecraft.nbt.NbtIo;
- import net.minecraft.nbt.Tag;
- import net.minecraft.network.chat.Component;
- import net.minecraft.network.chat.MutableComponent;
-+import net.minecraft.network.protocol.status.ServerStatus;
- import net.minecraft.resources.ResourceKey;
- import net.minecraft.resources.ResourceLocation;
- import net.minecraft.util.Crypt;
-@@ -137,6 +140,17 @@ public class FriendlyByteBuf extends ByteBuf {
-     public <T> void writeJsonWithCodec(Codec<T> codec, T value) {
-         DataResult<JsonElement> dataresult = codec.encodeStart(JsonOps.INSTANCE, value);
- 
-+
-+        //Luminol start - Add config for chat sign
-+        if (codec == ServerStatus.CODEC) {
-+            JsonElement element = Util.getOrThrow(dataresult, string -> new EncoderException("Failed to encode: " + string + " " + value));
-+            element.getAsJsonObject().addProperty("preventsChatReports", LuminolConfig.disableChatSign);
-+
-+            this.writeUtf(GSON.toJson(element));
-+            return;
-+        }
-+        //Luminol end
-+
-         this.writeUtf(FriendlyByteBuf.GSON.toJson((JsonElement) Util.getOrThrow(dataresult, (s) -> {
-             return new EncoderException("Failed to encode: " + s + " " + value);
-         })));

patches/server/0010-Add-config-for-username-check.patch

@@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 04:50:10 +0000
+Subject: [PATCH] Add config for username check
+
+
+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";
++    }
++}
+diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+index aa4b461bbb2c8c4753f7c9057bab1740de2c0284..1ff6c82925417932df856bf1e5866519327f018e 100644
+--- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
+@@ -143,7 +143,7 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
+     @Override
+     public void handleHello(ServerboundHelloPacket packet) {
+         Validate.validState(this.state == ServerLoginPacketListenerImpl.State.HELLO, "Unexpected hello packet", new Object[0]);
+-        if (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode() && io.papermc.paper.configuration.GlobalConfiguration.get().unsupportedSettings.performUsernameValidation && !this.iKnowThisMayNotBeTheBestIdeaButPleaseDisableUsernameValidation) Validate.validState(Player.isValidUsername(packet.name()), "Invalid characters in username", new Object[0]); // Paper - config username validation
++        if (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode() && io.papermc.paper.configuration.GlobalConfiguration.get().unsupportedSettings.performUsernameValidation && !this.iKnowThisMayNotBeTheBestIdeaButPleaseDisableUsernameValidation && me.earthme.luminol.config.modules.misc.UsernameCheckConfig.enabled) Validate.validState(Player.isValidUsername(packet.name()), "Invalid characters in username", new Object[0]); // Paper - config username validation  //Luminol - Add config for username check
+         this.requestedUsername = packet.name();
+         GameProfile gameprofile = this.server.getSingleplayerProfile();
+ 

patches/server/0010-Add-config-for-vanilla-random.patch

@@ -1,39 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sat, 25 Nov 2023 19:03:34 +0800
-Subject: [PATCH] Add config for vanilla random
-
-
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index 8d1ce8eae252fcf05b6a62d2dc467d6d503d3df4..89d8ffc947d265e0e81943ad851e868b622de168 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -19,6 +19,7 @@ public class LuminolConfig {
-     public static boolean enableSandDuping = false;
-     public static boolean enableVoidTrading = false;
-     public static boolean allowIncorrectTripwireUpdating = false;
-+    public static boolean useVanillaRandomSource = false;
- 
-     public static void init() throws IOException {
-         PARENT_FOLDER.mkdir();
-@@ -43,6 +44,7 @@ public class LuminolConfig {
-         enableSandDuping = get("fixes.enable_sand_duping",enableSandDuping,"If this enabled,The value of safe teleportation will always be false and sand duping will be enabled");
-         enableVoidTrading = get("fixes.enable_void_trading",enableVoidTrading);
-         allowIncorrectTripwireUpdating = get("fixes.allow_incorrect_trip_wire_updaing",allowIncorrectTripwireUpdating);
-+        useVanillaRandomSource = get("fixes.use_vanilla_random_source",useVanillaRandomSource,"RNG feature related");
-     }
- 
-     public static <T> T get(String key,T def){
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index e357ed9607889536ecd0e6ea8b59c97d3dab631f..cb32a3851a315f1f1b4fb6d26fdffbcb471bfc06 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -569,7 +569,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
-         this.bb = Entity.INITIAL_AABB;
-         this.stuckSpeedMultiplier = Vec3.ZERO;
-         this.nextStep = 1.0F;
--        this.random = SHARED_RANDOM; // Paper
-+        this.random = LuminolConfig.useVanillaRandomSource ? RandomSource.create() : SHARED_RANDOM;//Luminol - Add config for vanilla random SHARED_RANDOM; // Paper
-         this.remainingFireTicks = -this.getFireImmuneTicks();
-         this.fluidHeight = new Object2DoubleArrayMap(2);
-         this.fluidOnEyes = new HashSet();

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

@@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 06:40:44 +0000
+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/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+index 550fb11c64e3adb35bb7f78c53f0b5ae5ce9ff58..71151811c36c75ace1e41837123b320ae48a4b53 100644
+--- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
++++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -284,7 +284,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+         String proxyFlavor = (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled) ? "Velocity" : "BungeeCord";
+         String proxyLink = (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.velocity.enabled) ? "https://docs.papermc.io/velocity/security" : "http://www.spigotmc.org/wiki/firewall-guide/";
+         // Paper end - Add Velocity IP Forwarding Support
+-        if (!this.usesAuthentication()) {
++        if (!this.usesAuthentication() && !me.earthme.luminol.config.modules.misc.OfflineModeWarningConfig.enabled) { //Luminol - Add config for offline mod warning
+             DedicatedServer.LOGGER.warn("**** SERVER IS RUNNING IN OFFLINE/INSECURE MODE!");
+             DedicatedServer.LOGGER.warn("The server will make no attempt to authenticate usernames. Beware.");
+             // Spigot start

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

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

patches/server/0012-Add-logger-field-to-LuminolConfig.patch

@@ -1,25 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sat, 25 Nov 2023 19:26:01 +0800
-Subject: [PATCH] Add logger field to LuminolConfig
-
-
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index 89d8ffc947d265e0e81943ad851e868b622de168..74573c50c903cfbe5f9617be5b75c21647f05a91 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -2,11 +2,14 @@ package me.earthme.luminol;
- 
- import com.electronwill.nightconfig.core.file.CommentedFileConfig;
- import net.minecraft.server.level.ServerLevel;
-+import org.apache.logging.log4j.LogManager;
-+import org.apache.logging.log4j.Logger;
- 
- import java.io.File;
- import java.io.IOException;
- 
- public class LuminolConfig {
-+    private static final Logger logger = LogManager.getLogger();
-     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;

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

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

patches/server/0013-Kaiiju-region-format-settings.patch

@@ -1,98 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sat, 25 Nov 2023 21:28:45 +0800
-Subject: [PATCH] Kaiiju region format settings
-
-
-diff --git a/src/main/java/dev/kaiijumc/kaiiju/region/RegionFileFormat.java b/src/main/java/dev/kaiijumc/kaiiju/region/RegionFileFormat.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..7164d9cd03186f0657783f83de3d6435cda2b17e
---- /dev/null
-+++ b/src/main/java/dev/kaiijumc/kaiiju/region/RegionFileFormat.java
-@@ -0,0 +1,16 @@
-+package dev.kaiijumc.kaiiju.region;
-+
-+public enum RegionFileFormat {
-+    ANVIL,
-+    LINEAR,
-+    INVALID;
-+
-+    public static RegionFileFormat fromString(String format) {
-+        for (RegionFileFormat rff : values()) {
-+            if (rff.name().equalsIgnoreCase(format)) {
-+                return rff;
-+            }
-+        }
-+        return RegionFileFormat.INVALID;
-+    }
-+}
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index 74573c50c903cfbe5f9617be5b75c21647f05a91..3d526d7cfb313e419de89be1b275651982be42c7 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -1,10 +1,13 @@
- package me.earthme.luminol;
- 
-+import dev.kaiijumc.kaiiju.region.RegionFileFormat;
- import com.electronwill.nightconfig.core.file.CommentedFileConfig;
- import net.minecraft.server.level.ServerLevel;
- import org.apache.logging.log4j.LogManager;
- import org.apache.logging.log4j.Logger;
- 
-+import java.util.Arrays;
-+import java.util.logging.Level;
- import java.io.File;
- import java.io.IOException;
- 
-@@ -24,6 +27,9 @@ public class LuminolConfig {
-     public static boolean allowIncorrectTripwireUpdating = false;
-     public static boolean useVanillaRandomSource = false;
- 
-+    public static RegionFileFormat regionFormatName = RegionFileFormat.ANVIL;
-+    public static int regionFormatLinearCompressionLevel = 1;
-+
-     public static void init() throws IOException {
-         PARENT_FOLDER.mkdir();
- 
-@@ -48,6 +54,19 @@ public class LuminolConfig {
-         enableVoidTrading = get("fixes.enable_void_trading",enableVoidTrading);
-         allowIncorrectTripwireUpdating = get("fixes.allow_incorrect_trip_wire_updaing",allowIncorrectTripwireUpdating);
-         useVanillaRandomSource = get("fixes.use_vanilla_random_source",useVanillaRandomSource,"RNG feature related");
-+
-+        regionFormatName = RegionFileFormat.fromString(get("save.region-format.format", regionFormatName.name()));
-+        if (regionFormatName.equals(RegionFileFormat.INVALID)) {
-+            logger.error("Unknown region format in luminol global config: " + regionFormatName);
-+            logger.error("Falling back to ANVIL region file format.");
-+            regionFormatName = RegionFileFormat.ANVIL;
-+        }
-+        regionFormatLinearCompressionLevel = get("save.region-format.linear.compression-level", regionFormatLinearCompressionLevel);
-+        if (regionFormatLinearCompressionLevel > 23 || regionFormatLinearCompressionLevel < 1) {
-+            logger.error("Linear region compression level should be between 1 and 22 in luminol global config: " + regionFormatLinearCompressionLevel);
-+            logger.error("Falling back to compression level 1.");
-+            regionFormatLinearCompressionLevel = 1;
-+        }
-     }
- 
-     public static <T> T get(String key,T def){
-diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
-index 03165a7791aeac54e44391bbb0f432b613369bfa..675bbf1f69011f7f95fabc050c9877d6e70070b2 100644
---- a/src/main/java/net/minecraft/server/MinecraftServer.java
-+++ b/src/main/java/net/minecraft/server/MinecraftServer.java
-@@ -882,7 +882,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-             // Paper start - rewrite chunk system
-             worldserver.save((ProgressListener) null, flush, worldserver.noSave && !force, close);
-             if (flush) {
--                MinecraftServer.LOGGER.info("ThreadedAnvilChunkStorage ({}): All chunks are saved", worldserver.getChunkSource().chunkMap.getStorageName());
-+                MinecraftServer.LOGGER.info("ThreadedChunkStorage ({}): All chunks are saved", worldserver.getChunkSource().chunkMap.getStorageName()); // Kaiiju
-             }
-             // Paper end - rewrite chunk system
-         }
-@@ -906,7 +906,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-                 //MinecraftServer.LOGGER.info("ThreadedAnvilChunkStorage ({}): All chunks are saved", worldserver2.getChunkSource().chunkMap.getStorageName()); // Paper - move up
-             }
- 
--            MinecraftServer.LOGGER.info("ThreadedAnvilChunkStorage: All dimensions are saved");
-+            MinecraftServer.LOGGER.info("ThreadedChunkStorage: All dimensions are saved"); // Kaiiju
-         }
- 
-         return flag3;

patches/server/0014-Add-config-for-incorrect-tripwire-updating-fixing.patch

@@ -0,0 +1,51 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Mon, 25 Mar 2024 13:16:04 +0000
+Subject: [PATCH] Add config for incorrect tripwire updating fixing
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/fixes/IncorrectTripwireFixConfig.java b/src/main/java/me/earthme/luminol/config/modules/fixes/IncorrectTripwireFixConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..79ce93a1e97f176c7b0e5b00d7f0880f0d157d03
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/fixes/IncorrectTripwireFixConfig.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 IncorrectTripwireFixConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.FIXES;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "allow_update_incorrect_trip_wire";
++    }
++}
+diff --git a/src/main/java/net/minecraft/world/level/block/TripWireHookBlock.java b/src/main/java/net/minecraft/world/level/block/TripWireHookBlock.java
+index 8bf94fcf5c46ffe6d90f8431338b768ef1a2dd61..25e069bd660720232737031fe1630765cce9a1b1 100644
+--- a/src/main/java/net/minecraft/world/level/block/TripWireHookBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/TripWireHookBlock.java
+@@ -201,8 +201,13 @@ public class TripWireHookBlock extends Block {
+                     BlockState iblockdata4 = aiblockdata[l];
+ 
+                     if (iblockdata4 != null) {
+-                        if (world.getBlockState(blockposition2).is(Blocks.TRIPWIRE)) { // Paper - Fix tripwire disarming not working as intended
++                        if (me.earthme.luminol.config.modules.fixes.IncorrectTripwireFixConfig.enabled || world.getBlockState(blockposition2).is(Blocks.TRIPWIRE)) { // Paper - Fix tripwire disarming not working as intended //Luminol - Add config for this
+                         world.setBlock(blockposition2, (BlockState) iblockdata4.trySetValue(TripWireHookBlock.ATTACHED, flag4), 3);
++                        //Luminol start - Add config for incorrect tripwire updating
++                        if (me.earthme.luminol.config.modules.fixes.IncorrectTripwireFixConfig.enabled){
++                            world.getBlockState(blockposition2).isAir();
++                        }
++                        //Luminol end
+                         }
+                     }
+                 }

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

@@ -0,0 +1,77 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 07:41:47 +0000
+Subject: [PATCH] Io_uring channel type support
+
+
+diff --git a/build.gradle.kts b/build.gradle.kts
+index 66c34f883a93dd86fcac8029cce63ffe7340c89b..66cb23bce8bf0a96867144874643f771f7440034 100644
+--- a/build.gradle.kts
++++ b/build.gradle.kts
+@@ -35,6 +35,7 @@ dependencies {
+     log4jPlugins.annotationProcessorConfigurationName("org.apache.logging.log4j:log4j-core:2.19.0") // Paper - Needed to generate meta for our Log4j plugins
+     runtimeOnly(log4jPlugins.output)
+     alsoShade(log4jPlugins.output)
++    implementation("io.netty.incubator:netty-incubator-transport-native-io_uring:0.0.21.Final:linux-x86_64") //Luminol - io_uring Libraries
+     implementation("io.netty:netty-codec-haproxy:4.1.97.Final") // Paper - Add support for proxy protocol
+     // Paper end
+     implementation("org.apache.logging.log4j:log4j-iostreams:2.19.0") // Paper - remove exclusion
+diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/IOUringSupportConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/IOUringSupportConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..f3090b6e11d82d02528c7afd358ef4db61707092
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/IOUringSupportConfig.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.HotReloadUnsupported;
++import me.earthme.luminol.config.IConfigModule;
++
++public class IOUringSupportConfig implements IConfigModule {
++    @HotReloadUnsupported
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "io_uring_support";
++    }
++}
+diff --git a/src/main/java/net/minecraft/server/network/ServerConnectionListener.java b/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
+index 6e95017f4c36208abdf344e3b7d55efe2d5b4e10..bf87a55d78155ea5c303ec28d6a0154e80d7fce3 100644
+--- a/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
++++ b/src/main/java/net/minecraft/server/network/ServerConnectionListener.java
+@@ -73,6 +73,10 @@ public class ServerConnectionListener {
+     }
+     // Paper end - prevent blocking on adding a new connection while the server is ticking
+ 
++    //Luminol start - io_uring support
++    public static final Supplier<io.netty.incubator.channel.uring.IOUringEventLoopGroup> SERVER_IO_URING_WORKER_GROUP = Suppliers.memoize(() -> new io.netty.incubator.channel.uring.IOUringEventLoopGroup(0, (new ThreadFactoryBuilder()).setNameFormat("Netty IO_URING Server IO #%d").setDaemon(true).setUncaughtExceptionHandler(new net.minecraft.DefaultUncaughtExceptionHandlerWithName(LOGGER)).build()));
++    //Luminol end
++
+     public ServerConnectionListener(MinecraftServer server) {
+         this.server = server;
+         this.running = true;
+@@ -90,7 +94,14 @@ public class ServerConnectionListener {
+             Class oclass;
+             EventLoopGroup eventloopgroup;
+ 
+-            if (Epoll.isAvailable() && this.server.isEpollEnabled()) {
++            //Luminol start - io_uring support
++            if (io.netty.incubator.channel.uring.IOUring.isAvailable() && me.earthme.luminol.config.modules.misc.IOUringSupportConfig.enabled){
++                eventloopgroup = SERVER_IO_URING_WORKER_GROUP.get();
++                oclass = io.netty.incubator.channel.uring.IOUringServerSocketChannel.class;
++                ServerConnectionListener.LOGGER.info("Using io_uring channel type");
++            }
++            else if (Epoll.isAvailable() && this.server.isEpollEnabled()) {
++            //Luminol end
+                 // Paper start - Unix domain socket support
+                 if (address instanceof io.netty.channel.unix.DomainSocketAddress) {
+                     oclass = io.netty.channel.epoll.EpollServerDomainSocketChannel.class;

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

@@ -1,55 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 15:36:59 +0800
-Subject: [PATCH] Petal Reduce sensor work
-
-
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index 0657fce8aabb956a400b3cead53c28ef52e67fe9..c3a481cb7bea0619b1af0e3203e9d88514e84c62 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -40,6 +40,8 @@ public class LuminolConfig {
-     public static int linearFlushFrequency = 10;
-     public static int linearFlushThreads = 1;
- 
-+    public static boolean reduceSensorWork = true;
-+
-     public static void init() throws IOException {
-         PARENT_FOLDER.mkdir();
- 
-@@ -98,6 +100,8 @@ public class LuminolConfig {
-             linearFlushThreads = Math.max(Runtime.getRuntime().availableProcessors() + linearFlushThreads, 1);
-         else
-             linearFlushThreads = Math.max(linearFlushThreads, 1);
-+
-+        reduceSensorWork = get("optimizations.reduce_sensor_work",reduceSensorWork,"This optimization is from petal.You can find out more about it on petal's repository");
-     }
- 
-     public static <T> T get(String key,T def){
-diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
-index 4e9d510646abbc2d2b6f2d935f7416b6872eb234..d3f8aa29b05a3813c0ec6e2ea5a253868abd6b07 100644
---- a/src/main/java/net/minecraft/world/entity/Mob.java
-+++ b/src/main/java/net/minecraft/world/entity/Mob.java
-@@ -9,6 +9,8 @@ import java.util.Optional;
- import java.util.UUID;
- import java.util.function.Predicate;
- import javax.annotation.Nullable;
-+
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.core.BlockPos;
- import net.minecraft.core.NonNullList;
- import net.minecraft.core.Vec3i;
-@@ -924,10 +926,11 @@ public abstract class Mob extends LivingEntity implements Targeting {
-             return;
-         }
-         // Paper end
-+        int i = this.tickCount + this.getId(); // Folia - region threading //Luminol - Petal - Move up
-+
-         this.level().getProfiler().push("sensing");
--        this.sensing.tick();
-+        if (i % 10 == 0 || !LuminolConfig.reduceSensorWork)this.sensing.tick(); //Luminol - Petal - Reduce sensor work
-         this.level().getProfiler().pop();
--        int i = this.tickCount + this.getId(); // Folia - region threading
- 
-         if (i % 2 != 0 && this.tickCount > 1) {
-             this.level().getProfiler().push("targetSelector");

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

@@ -0,0 +1,57 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 06:30:03 +0000
+Subject: [PATCH] Try fixing folia spector teleportation
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaSpectorTeleportationFixConfig.java b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaSpectorTeleportationFixConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..8487799cdfb776eaca33b57f7c99ae3aeadb890d
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaSpectorTeleportationFixConfig.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 FoliaSpectorTeleportationFixConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean fixSpectorTeleportFolia = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.FIXES;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "folia.fix_spector_teleportation";
++    }
++}
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 318cb1e98a3d73b7893f07c9f0db3adab801b67e..9cbf17436b4cf52aae374767aafe79ea4f60c3ce 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -17,6 +17,8 @@ import java.util.OptionalInt;
+ import java.util.Set;
+ import java.util.stream.Collectors;
+ import javax.annotation.Nullable;
++
++import me.earthme.luminol.config.modules.fixes.FoliaSpectorTeleportationFixConfig;
+ import net.minecraft.BlockUtil;
+ import net.minecraft.ChatFormatting;
+ import net.minecraft.CrashReport;
+@@ -842,6 +844,11 @@ public class ServerPlayer extends Player {
+         }
+ 
+         Entity entity = this.getCamera();
++        //Luminol start - Fix folia spector teleportation
++        if (!io.papermc.paper.util.TickThread.isTickThreadFor(entity) && FoliaSpectorTeleportationFixConfig.fixSpectorTeleportFolia){
++            this.setCamera(this);
++        }
++        //Luminol end
+ 
+         if (entity != this) {
+             if (entity.isAlive()) {

patches/server/0017-Add-config-for-username-check.patch

@@ -1,52 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 15:56:26 +0800
-Subject: [PATCH] Add config for username check
-
-
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index c3a481cb7bea0619b1af0e3203e9d88514e84c62..0929a5a167691bde7dedaa1e2812b34ad69913d6 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -28,6 +28,7 @@ public class LuminolConfig {
-     public static String tpsBarFormat = "<gray>TPS<yellow>:</yellow> <tps> MSPT<yellow>:</yellow> <mspt> Ping<yellow>:</yellow> <ping>ms";
-     public static String[] tpsColors = new String[]{"GREEN","YELLOW","RED","PURPLE"};
-     public static String[] pingColors = new String[]{"GREEN","YELLOW","RED","PURPLE"};
-+    public static boolean disableUsernameCheck = false;
- 
-     public static boolean safeTeleportation = true;
-     public static boolean enableSandDuping = false;
-@@ -71,6 +72,7 @@ public class LuminolConfig {
-         tpsBarFormat = get("misc.tpsbar_title_format",tpsBarFormat,"The format of tpsbar.");
-         tpsColors = get("misc.tpsbar_range_colors", List.of(tpsColors),"The bar and text color of each tps ranges.The last is the color of initial bar's color").toArray(String[]::new);
-         pingColors = get("misc.tpsbar_ping_range_colors",List.of(pingColors),"As same as the tpsColors").toArray(String[]::new);
-+        disableUsernameCheck = get("misc.disable_username_check",disableUsernameCheck,"Disable username check that can accept usernames with other characters(such as Chinese).Not recommended to use");
- 
-         if (tpsbarEnabled){
-             initTpsbar();
-diff --git a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-index f7c2d6d82ee1b5975cd114934b7beaec3d5d490d..f26c44bb8c4e3d8556c8c5ac7389e02381239594 100644
---- a/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-+++ b/src/main/java/net/minecraft/server/network/ServerLoginPacketListenerImpl.java
-@@ -16,6 +16,8 @@ import java.util.concurrent.atomic.AtomicInteger;
- import javax.annotation.Nullable;
- import javax.crypto.Cipher;
- import javax.crypto.SecretKey;
-+
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.DefaultUncaughtExceptionHandler;
- import net.minecraft.core.UUIDUtil;
- import net.minecraft.network.Connection;
-@@ -162,10 +164,10 @@ public class ServerLoginPacketListenerImpl implements ServerLoginPacketListener,
-     @Override
-     public void handleHello(ServerboundHelloPacket packet) {
-         Validate.validState(this.state == ServerLoginPacketListenerImpl.State.HELLO, "Unexpected hello packet", new Object[0]);
--        Validate.validState(ServerLoginPacketListenerImpl.isValidUsername(packet.name()), "Invalid characters in username", new Object[0]);
-+        if (!LuminolConfig.disableUsernameCheck) Validate.validState(ServerLoginPacketListenerImpl.isValidUsername(packet.name()), "Invalid characters in username", new Object[0]); //Luminol - Add config for usename check
-         // Paper start - validate usernames
-         if (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.isProxyOnlineMode() && io.papermc.paper.configuration.GlobalConfiguration.get().unsupportedSettings.performUsernameValidation) {
--            if (!this.iKnowThisMayNotBeTheBestIdeaButPleaseDisableUsernameValidation && !validateUsername(packet.name())) {
-+            if (!this.iKnowThisMayNotBeTheBestIdeaButPleaseDisableUsernameValidation && !validateUsername(packet.name()) && !LuminolConfig.disableUsernameCheck) { //Luminol - Add config for username check
-                 ServerLoginPacketListenerImpl.this.disconnect("Failed to verify username!");
-                 return;
-             }

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

@@ -0,0 +1,96 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 06:34:15 +0000
+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..73d99a105a18231901e691922b0c283adae0cc79
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaEntityMovingFixConfig.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 FoliaEntityMovingFixConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    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";
++    }
++}
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 9bbfac91f97331b1b558264c867b7e00185291f2..dfb1b8c3af93bfcddb976c003c6ac2d52afc41c6 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -7,6 +7,7 @@ import com.google.common.collect.Lists;
+ import com.google.common.collect.Sets;
+ import com.google.common.collect.UnmodifiableIterator;
+ import com.mojang.logging.LogUtils;
++import io.papermc.paper.util.TickThread;
+ import it.unimi.dsi.fastutil.objects.Object2DoubleArrayMap;
+ import it.unimi.dsi.fastutil.objects.Object2DoubleMap;
+ import java.util.Arrays;
+@@ -24,6 +25,8 @@ import java.util.function.BiConsumer;
+ import java.util.function.Predicate;
+ import java.util.stream.Stream;
+ import javax.annotation.Nullable;
++
++import me.earthme.luminol.config.modules.fixes.FoliaEntityMovingFixConfig;
+ import net.minecraft.BlockUtil;
+ import net.minecraft.CrashReport;
+ import net.minecraft.CrashReportCategory;
+@@ -1086,10 +1089,40 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+     }
+     // Paper end - detailed watchdog information
+ 
++    //Luminol start - Fix large pos moving
++    private volatile boolean preventMoving = false;
++    //Luminol end
++
+     public void move(MoverType movementType, Vec3 movement) {
+         final Vec3 originalMovement = movement; // Paper - Expose pre-collision velocity
+         // Paper start - detailed watchdog information
+         io.papermc.paper.util.TickThread.ensureTickThread("Cannot move an entity off-main");
++        //Luminol start - Fix high position moving
++        if (me.earthme.luminol.config.modules.fixes.FoliaEntityMovingFixConfig.enabled && TickThread.isTickThread()){ //Except the threads because it may be called by the chunk system worker thread
++            if (this.preventMoving){
++                return;
++            }
++
++            var finalPosition = movement.add(this.position);
++            if (!TickThread.isTickThreadFor(((ServerLevel) this.level),finalPosition)){
++                this.preventMoving = true;
++                this.teleportAsync(
++                        (ServerLevel) this.level(),
++                        finalPosition,
++                        this.getYRot(), this.getXRot(),
++                        null, PlayerTeleportEvent.TeleportCause.UNKNOWN,
++                        Entity.TELEPORT_FLAG_LOAD_CHUNK | Entity.TELEPORT_FLAG_TELEPORT_PASSENGERS,
++                        result -> {
++                            this.preventMoving = false;
++                        }
++                );
++                if (FoliaEntityMovingFixConfig.warnOnDetected){
++                    MinecraftServer.LOGGER.warn("Entity {} with entityId {} has tried moving to another region!",this.type.getCategory().getName(),this.getId());
++                }
++                return;
++            }
++        }
++        //Luminol end
+         synchronized (this.posLock) {
+             this.moveStartX = this.getX();
+             this.moveStartY = this.getY();

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

@@ -0,0 +1,207 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 06:58:52 +0000
+Subject: [PATCH] Prevent teleportAsync calling during moving event being
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaTeleportAsyncFixConfig.java b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaTeleportAsyncFixConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..b8aceab54bb60000e7c56810140271022f5147a2
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaTeleportAsyncFixConfig.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 FoliaTeleportAsyncFixConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = false;
++    @ConfigInfo(baseName = "throw_on_detected")
++    public static boolean throwOnDetected = true;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.FIXES;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "folia.prevent_teleportasync_call_during_moving";
++    }
++}
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 9cbf17436b4cf52aae374767aafe79ea4f60c3ce..f2068e7608ed765e35759eb981db6c95b07a06d8 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -332,6 +332,10 @@ public class ServerPlayer extends Player {
+     public double lastEntitySpawnRadiusSquared = -1.0;
+     // Paper end - optimise chunk tick iteration
+ 
++    //Luminol start - Prevent teleportAsync calling during moving event being handled
++    public boolean handlingMoveEvent = false;
++    //Luminol end
++
+     public ServerPlayer(MinecraftServer server, ServerLevel world, GameProfile profile, ClientInformation clientOptions) {
+         super(world, world.getSharedSpawnPos(), world.getSharedSpawnAngle(), profile);
+         this.chatVisibility = ChatVisiblity.FULL;
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 3b2508dc6cd4f70b09dce3b7e745e6efabaaa74e..b3ff8ed6d0f0414c15b9d2e6a51a0e34c361f92a 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -675,7 +675,9 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+ 
+                     Location oldTo = to.clone();
+                     PlayerMoveEvent event = new PlayerMoveEvent(player, from, to);
++                    this.player.handlingMoveEvent = true; //Luminol - Prevent teleportAsync calling during moving event being handled
+                     this.cserver.getPluginManager().callEvent(event);
++                    this.player.handlingMoveEvent = false; //Luminol - Prevent teleportAsync calling during moving event being handled
+ 
+                     // If the event is cancelled we move the player back to their old location.
+                     if (event.isCancelled()) {
+@@ -1621,7 +1623,9 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+ 
+                                     Location oldTo = to.clone();
+                                     PlayerMoveEvent event = new PlayerMoveEvent(player, from, to);
++                                    this.player.handlingMoveEvent = true; //Luminol - Prevent teleportAsync calling during moving event being handled
+                                     this.cserver.getPluginManager().callEvent(event);
++                                    this.player.handlingMoveEvent = false; //Luminol - Prevent teleportAsync calling during moving event being handled
+ 
+                                     // If the event is cancelled we move the player back to their old location.
+                                     if (event.isCancelled()) {
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index dfb1b8c3af93bfcddb976c003c6ac2d52afc41c6..09cdd28dcb2357ba3d7be316b7ca94dc93ac5dd0 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -27,6 +27,7 @@ import java.util.stream.Stream;
+ import javax.annotation.Nullable;
+ 
+ import me.earthme.luminol.config.modules.fixes.FoliaEntityMovingFixConfig;
++import me.earthme.luminol.config.modules.fixes.FoliaTeleportAsyncFixConfig;
+ import net.minecraft.BlockUtil;
+ import net.minecraft.CrashReport;
+ import net.minecraft.CrashReportCategory;
+@@ -59,7 +60,6 @@ import net.minecraft.network.syncher.EntityDataSerializers;
+ import net.minecraft.network.syncher.SynchedEntityData;
+ import net.minecraft.resources.ResourceKey;
+ import net.minecraft.resources.ResourceLocation;
+-import io.papermc.paper.util.MCUtil;
+ import net.minecraft.server.MinecraftServer;
+ import net.minecraft.server.level.ServerLevel;
+ import net.minecraft.server.level.ServerPlayer;
+@@ -132,7 +132,6 @@ import org.joml.Vector3f;
+ import org.slf4j.Logger;
+ import org.bukkit.Bukkit;
+ import org.bukkit.Location;
+-import org.bukkit.Server;
+ import org.bukkit.block.BlockFace;
+ import org.bukkit.command.CommandSender;
+ import org.bukkit.craftbukkit.event.CraftPortalEvent;
+@@ -3989,6 +3988,18 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+                                        java.util.function.Consumer<Entity> teleportComplete) {
+         io.papermc.paper.util.TickThread.ensureTickThread(this, "Cannot teleport entity async");
+ 
++        //Luminol start - Prevent teleportAsync calling during moving event being handled
++        if (this instanceof ServerPlayer player && FoliaTeleportAsyncFixConfig.enabled){
++            if (player.handlingMoveEvent){
++                if (FoliaTeleportAsyncFixConfig.throwOnDetected){
++                    throw new IllegalStateException("Player " + player.getScoreboardName() + " is trying to teleport to " + pos + " during move event handling!");
++                }
++                MinecraftServer.LOGGER.warn("Player {} is trying to teleport to {} during move event handling!",player.getScoreboardName(),pos);
++                return false;
++            }
++        }
++        //Luminol end
++
+         if (!ServerLevel.isInSpawnableBounds(new BlockPos(io.papermc.paper.util.CoordinateUtils.getBlockX(pos), io.papermc.paper.util.CoordinateUtils.getBlockY(pos), io.papermc.paper.util.CoordinateUtils.getBlockZ(pos)))) {
+             return false;
+         }
+diff --git a/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java b/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java
+index d514ec1e4cbdc579c3a61533998437903afdc8b6..c547376967360402d22657d25e1100366dd50c59 100644
+--- a/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java
++++ b/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecart.java
+@@ -5,6 +5,8 @@ import com.google.common.collect.ImmutableMap;
+ import com.google.common.collect.Maps;
+ import com.google.common.collect.UnmodifiableIterator;
+ import com.mojang.datafixers.util.Pair;
++
++import java.util.ArrayList;
+ import java.util.Iterator;
+ import java.util.List;
+ import java.util.Map;
+@@ -21,6 +23,7 @@ import net.minecraft.network.syncher.EntityDataAccessor;
+ import net.minecraft.network.syncher.EntityDataSerializers;
+ import net.minecraft.network.syncher.SynchedEntityData;
+ import net.minecraft.server.level.ServerLevel;
++import net.minecraft.server.level.ServerPlayer;
+ import net.minecraft.tags.BlockTags;
+ import net.minecraft.util.Mth;
+ import net.minecraft.world.entity.Entity;
+@@ -378,7 +381,21 @@ public abstract class AbstractMinecart extends VehicleEntity {
+             this.level().getCraftServer().getPluginManager().callEvent(new org.bukkit.event.vehicle.VehicleUpdateEvent(vehicle));
+ 
+             if (!from.equals(to)) {
++                //Luminol start - Prevent teleportAsync calling during moving event being handled
++                for (Entity passenger : this.getPassengers()) {
++                    if (passenger instanceof ServerPlayer player){
++                        player.handlingMoveEvent = true;
++                    }
++                }
++                //Luminol end
+                 this.level().getCraftServer().getPluginManager().callEvent(new org.bukkit.event.vehicle.VehicleMoveEvent(vehicle, from, to));
++                //Luminol start - Prevent teleportAsync calling during moving event being handled
++                for (Entity passenger : this.getPassengers()) {
++                    if (passenger instanceof ServerPlayer player){
++                        player.handlingMoveEvent = false;
++                    }
++                }
++                //Luminol end
+             }
+             // CraftBukkit end
+             if (this.getMinecartType() == AbstractMinecart.Type.RIDEABLE && this.getDeltaMovement().horizontalDistanceSqr() > 0.01D) {
+diff --git a/src/main/java/net/minecraft/world/entity/vehicle/Boat.java b/src/main/java/net/minecraft/world/entity/vehicle/Boat.java
+index db6aa75d642f4a7258f197933671907faf79c8f2..b7c792f75dda1c62ee3730b8204c347848710a9c 100644
+--- a/src/main/java/net/minecraft/world/entity/vehicle/Boat.java
++++ b/src/main/java/net/minecraft/world/entity/vehicle/Boat.java
+@@ -2,6 +2,8 @@ package net.minecraft.world.entity.vehicle;
+ 
+ import com.google.common.collect.Lists;
+ import com.google.common.collect.UnmodifiableIterator;
++
++import java.util.ArrayList;
+ import java.util.Iterator;
+ import java.util.List;
+ import java.util.function.IntFunction;
+@@ -16,6 +18,7 @@ import net.minecraft.network.protocol.game.ServerboundPaddleBoatPacket;
+ import net.minecraft.network.syncher.EntityDataAccessor;
+ import net.minecraft.network.syncher.EntityDataSerializers;
+ import net.minecraft.network.syncher.SynchedEntityData;
++import net.minecraft.server.level.ServerPlayer;
+ import net.minecraft.sounds.SoundEvent;
+ import net.minecraft.sounds.SoundEvents;
+ import net.minecraft.tags.EntityTypeTags;
+@@ -377,8 +380,22 @@ public class Boat extends VehicleEntity implements VariantHolder<Boat.Type> {
+         server.getPluginManager().callEvent(new org.bukkit.event.vehicle.VehicleUpdateEvent(vehicle));
+ 
+         if (this.lastLocation != null && !this.lastLocation.equals(to)) {
++            //Luminol start - Prevent teleportAsync calling during moving event being handled
++            for (Entity passenger : this.getPassengers()) {
++                if (passenger instanceof ServerPlayer player){
++                    player.handlingMoveEvent = true;
++                }
++            }
++            //Luminol end
+             VehicleMoveEvent event = new VehicleMoveEvent(vehicle, this.lastLocation, to);
+             server.getPluginManager().callEvent(event);
++            //Luminol start - Prevent teleportAsync calling during moving event being handled
++            for (Entity passenger : this.getPassengers()) {
++                if (passenger instanceof ServerPlayer player){
++                    player.handlingMoveEvent = false;
++                }
++            }
++            //Luminol end
+         }
+         this.lastLocation = vehicle.getLocation();
+         // CraftBukkit end

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

@@ -1,39 +1,24 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 11:30:57 +0800
-Subject: [PATCH] Kaiiju Add linear region format
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 03:11:28 +0000
+Subject: [PATCH] Kaiiju linear region format and settings
 
 
 diff --git a/build.gradle.kts b/build.gradle.kts
-index 54d761d7e4733c12fbb4957acd509d278ae11316..8a926993088d33983f75071b3320dd67c3e857c3 100644
+index 66cb23bce8bf0a96867144874643f771f7440034..57fcd58883effe57051b72a4e9f4af91aacd421a 100644
 --- a/build.gradle.kts
 +++ b/build.gradle.kts
-@@ -19,6 +19,10 @@ dependencies {
-         exclude("io.papermc.paper", "paper-api")
+@@ -20,6 +20,10 @@ dependencies {
      }
      // Folia end
+     implementation("com.electronwill.night-config:toml:3.6.6") //Luminol - Night config
 +    // Kaiiju start - Linear format
 +    implementation("com.github.luben:zstd-jni:1.5.4-1")
 +    implementation("org.lz4:lz4-java:1.8.0")
 +    // Kaiiju end
-     implementation("com.electronwill.night-config:toml:3.6.0") //Luminol - Night config
      // Paper start
      implementation("org.jline:jline-terminal-jansi:3.21.0")
-diff --git a/src/main/java/com/destroystokyo/paper/io/PaperFileIOThread.java b/src/main/java/com/destroystokyo/paper/io/PaperFileIOThread.java
-index f2c27e0ac65be4b75c1d86ef6fd45fdb538d96ac..00724993d0448454d14a47652b039b88052b8a4f 100644
---- a/src/main/java/com/destroystokyo/paper/io/PaperFileIOThread.java
-+++ b/src/main/java/com/destroystokyo/paper/io/PaperFileIOThread.java
-@@ -314,8 +314,8 @@ public final class PaperFileIOThread extends QueueExecutorThread {
-         public abstract void writeData(final int x, final int z, final CompoundTag compound) throws IOException;
-         public abstract CompoundTag readData(final int x, final int z) throws IOException;
- 
--        public abstract <T> T computeForRegionFile(final int chunkX, final int chunkZ, final Function<RegionFile, T> function);
--        public abstract <T> T computeForRegionFileIfLoaded(final int chunkX, final int chunkZ, final Function<RegionFile, T> function);
-+        public abstract <T> T computeForRegionFile(final int chunkX, final int chunkZ, final Function<dev.kaiijumc.kaiiju.region.AbstractRegionFile, T> function); // Kaiiju
-+        public abstract <T> T computeForRegionFileIfLoaded(final int chunkX, final int chunkZ, final Function<dev.kaiijumc.kaiiju.region.AbstractRegionFile, T> function); // Kaiiju
- 
-         public static final class InProgressWrite {
-             public long writeCounter;
+     implementation("net.minecrell:terminalconsoleappender:1.3.0")
 diff --git a/src/main/java/dev/kaiijumc/kaiiju/region/AbstractRegionFile.java b/src/main/java/dev/kaiijumc/kaiiju/region/AbstractRegionFile.java
 new file mode 100644
 index 0000000000000000000000000000000000000000..249303116d3cfadd078ebf0ae6e44bf99eed6a47
@@ -108,10 +93,10 @@ index 0000000000000000000000000000000000000000..dcfbabf54b19a4c29d5c95830242c5c2
 +}
 diff --git a/src/main/java/dev/kaiijumc/kaiiju/region/LinearRegionFile.java b/src/main/java/dev/kaiijumc/kaiiju/region/LinearRegionFile.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..e40989889f3821bb7484fc0bae5d94b033013904
+index 0000000000000000000000000000000000000000..dc5a5f42c9ca7a50295c18424722568a3ad33fa5
 --- /dev/null
 +++ b/src/main/java/dev/kaiijumc/kaiiju/region/LinearRegionFile.java
-@@ -0,0 +1,316 @@
+@@ -0,0 +1,324 @@
 +package dev.kaiijumc.kaiiju.region;
 +
 +import com.github.luben.zstd.ZstdInputStream;
@@ -240,7 +225,7 @@ index 0000000000000000000000000000000000000000..e40989889f3821bb7484fc0bae5d94b0
 +    }
 +
 +    public void flush() throws IOException {
-+        if (isMarkedToSave()) flushWrapper(); // sync
++        if (getAndResetSaveMarker()) flushWrapper(); // sync
 +    }
 +
 +    private void markToSave() {
@@ -248,10 +233,18 @@ index 0000000000000000000000000000000000000000..e40989889f3821bb7484fc0bae5d94b0
 +        markedToSave.set(true);
 +    }
 +
-+    public boolean isMarkedToSave() {
++    public boolean getAndResetSaveMarker() {
 +        return markedToSave.getAndSet(false);
 +    }
 +
++    public boolean isMarkedToSave(){
++        return this.markedToSave.get();
++    }
++
++    public void resetSaveMarker(){
++        this.markedToSave.set(false);
++    }
++
 +    public void flushWrapper() {
 +        try {
 +            save();
@@ -430,60 +423,94 @@ index 0000000000000000000000000000000000000000..e40989889f3821bb7484fc0bae5d94b0
 +}
 diff --git a/src/main/java/dev/kaiijumc/kaiiju/region/LinearRegionFileFlusher.java b/src/main/java/dev/kaiijumc/kaiiju/region/LinearRegionFileFlusher.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..e800c6103396530efe5acd0b4081a3cd05b62b68
+index 0000000000000000000000000000000000000000..65435eb666b2e1cabffc145e016faa5e3b373464
 --- /dev/null
 +++ b/src/main/java/dev/kaiijumc/kaiiju/region/LinearRegionFileFlusher.java
-@@ -0,0 +1,45 @@
+@@ -0,0 +1,57 @@
 +package dev.kaiijumc.kaiiju.region;
 +
 +import com.google.common.util.concurrent.ThreadFactoryBuilder;
-+import java.util.Queue;
++
++import java.util.Set;
 +import java.util.concurrent.*;
-+import me.earthme.luminol.LuminolConfig;
 +import org.bukkit.Bukkit;
 +
 +public class LinearRegionFileFlusher {
-+    private final Queue<LinearRegionFile> savingQueue = new LinkedBlockingQueue<>();
-+    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(
-+        new ThreadFactoryBuilder()
-+            .setNameFormat("linear-flush-scheduler")
-+            .build()
-+    );
++    private final Set<LinearRegionFile> pendingSaving = ConcurrentHashMap.newKeySet();
++
 +    private final ExecutorService executor = Executors.newFixedThreadPool(
-+        LuminolConfig.linearFlushThreads,
++        me.earthme.luminol.config.modules.misc.RegionFormatConfig.linearFlushThreads,
 +        new ThreadFactoryBuilder()
 +            .setNameFormat("linear-flusher-%d")
 +            .build()
 +    );
 +
++    private final Executor delayedFlusher = CompletableFuture.delayedExecutor(
++            me.earthme.luminol.config.modules.misc.RegionFormatConfig.linearFlushFrequency,
++            TimeUnit.SECONDS,
++            executor
++    );
++
 +    public LinearRegionFileFlusher() {
-+        Bukkit.getLogger().info("Using " + LuminolConfig.linearFlushThreads + " threads for linear region flushing.");
-+        scheduler.scheduleAtFixedRate(this::pollAndFlush, 0L, LuminolConfig.linearFlushFrequency, TimeUnit.SECONDS);
++        Bukkit.getLogger().info("Using " + me.earthme.luminol.config.modules.misc.RegionFormatConfig.linearFlushThreads + " threads for linear region flushing.");
 +    }
 +
 +    public void scheduleSave(LinearRegionFile regionFile) {
-+        if (savingQueue.contains(regionFile)) return;
-+        savingQueue.add(regionFile);
-+    }
-+
-+    private void pollAndFlush() {
-+        while (!savingQueue.isEmpty()) {
-+            LinearRegionFile regionFile = savingQueue.poll();
-+            if (!regionFile.closed && regionFile.isMarkedToSave())
-+                executor.execute(regionFile::flushWrapper);
++        if (this.pendingSaving.contains(regionFile) || !regionFile.isMarkedToSave()){
++            return;
 +        }
++
++        this.pendingSaving.add(regionFile);
++        this.delayedFlusher.execute(()->{
++            try {
++                if (!regionFile.closed && regionFile.isMarkedToSave()){
++                    regionFile.flushWrapper();
++                }
++            }finally {
++                regionFile.resetSaveMarker();
++                this.pendingSaving.remove(regionFile);
++            }
++        });
 +    }
 +
 +    public void shutdown() {
-+        executor.shutdown();
-+        scheduler.shutdown();
++        this.executor.shutdown();
++        for (;;) {
++            try {
++                if (this.executor.awaitTermination(5_00,TimeUnit.MILLISECONDS)) break;
++            } catch (InterruptedException e) {
++                e.printStackTrace();
++            }
++        }
++    }
++}
+diff --git a/src/main/java/dev/kaiijumc/kaiiju/region/RegionFileFormat.java b/src/main/java/dev/kaiijumc/kaiiju/region/RegionFileFormat.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..7164d9cd03186f0657783f83de3d6435cda2b17e
+--- /dev/null
++++ b/src/main/java/dev/kaiijumc/kaiiju/region/RegionFileFormat.java
+@@ -0,0 +1,16 @@
++package dev.kaiijumc.kaiiju.region;
++
++public enum RegionFileFormat {
++    ANVIL,
++    LINEAR,
++    INVALID;
++
++    public static RegionFileFormat fromString(String format) {
++        for (RegionFileFormat rff : values()) {
++            if (rff.name().equalsIgnoreCase(format)) {
++                return rff;
++            }
++        }
++        return RegionFileFormat.INVALID;
 +    }
 +}
 diff --git a/src/main/java/io/papermc/paper/chunk/system/io/RegionFileIOThread.java b/src/main/java/io/papermc/paper/chunk/system/io/RegionFileIOThread.java
-index 8a11e10b01fa012b2f98b1c193c53251e848f909..61001e76b38f8647b33e73b5cc15b4b6785cf49a 100644
+index 2934f0cf0ef09c84739312b00186c2ef0019a165..b46acbc078f3d3bfb0f3ede3f1cc172f4b48c5df 100644
 --- a/src/main/java/io/papermc/paper/chunk/system/io/RegionFileIOThread.java
 +++ b/src/main/java/io/papermc/paper/chunk/system/io/RegionFileIOThread.java
-@@ -811,7 +811,7 @@ public final class RegionFileIOThread extends PrioritisedQueueExecutorThread {
+@@ -816,7 +816,7 @@ public final class RegionFileIOThread extends PrioritisedQueueExecutorThread {
                                                 final ChunkDataController taskController) {
          final ChunkPos chunkPos = new ChunkPos(chunkX, chunkZ);
          if (intendingToBlock) {
@@ -492,7 +519,7 @@ index 8a11e10b01fa012b2f98b1c193c53251e848f909..61001e76b38f8647b33e73b5cc15b4b6
                  if (file == null) { // null if no regionfile exists
                      return Boolean.FALSE;
                  }
-@@ -824,7 +824,7 @@ public final class RegionFileIOThread extends PrioritisedQueueExecutorThread {
+@@ -829,7 +829,7 @@ public final class RegionFileIOThread extends PrioritisedQueueExecutorThread {
                  return Boolean.FALSE;
              } // else: it either exists or is not known, fall back to checking the loaded region file
  
@@ -501,7 +528,7 @@ index 8a11e10b01fa012b2f98b1c193c53251e848f909..61001e76b38f8647b33e73b5cc15b4b6
                  if (file == null) { // null if not loaded
                      // not sure at this point, let the I/O thread figure it out
                      return Boolean.TRUE;
-@@ -1126,9 +1126,9 @@ public final class RegionFileIOThread extends PrioritisedQueueExecutorThread {
+@@ -1131,9 +1131,9 @@ public final class RegionFileIOThread extends PrioritisedQueueExecutorThread {
              return this.getCache().doesRegionFileNotExistNoIO(new ChunkPos(chunkX, chunkZ));
          }
  
@@ -513,7 +540,7 @@ index 8a11e10b01fa012b2f98b1c193c53251e848f909..61001e76b38f8647b33e73b5cc15b4b6
              synchronized (cache) {
                  try {
                      regionFile = cache.getRegionFile(new ChunkPos(chunkX, chunkZ), existingOnly, true);
-@@ -1141,19 +1141,19 @@ public final class RegionFileIOThread extends PrioritisedQueueExecutorThread {
+@@ -1146,19 +1146,19 @@ public final class RegionFileIOThread extends PrioritisedQueueExecutorThread {
                  return function.apply(regionFile);
              } finally {
                  if (regionFile != null) {
@@ -537,7 +564,7 @@ index 8a11e10b01fa012b2f98b1c193c53251e848f909..61001e76b38f8647b33e73b5cc15b4b6
                  }
              }
  
-@@ -1161,7 +1161,7 @@ public final class RegionFileIOThread extends PrioritisedQueueExecutorThread {
+@@ -1166,7 +1166,7 @@ public final class RegionFileIOThread extends PrioritisedQueueExecutorThread {
                  return function.apply(regionFile);
              } finally {
                  if (regionFile != null) {
@@ -547,7 +574,7 @@ index 8a11e10b01fa012b2f98b1c193c53251e848f909..61001e76b38f8647b33e73b5cc15b4b6
              }
          }
 diff --git a/src/main/java/io/papermc/paper/world/ThreadedWorldUpgrader.java b/src/main/java/io/papermc/paper/world/ThreadedWorldUpgrader.java
-index 513833c2ea23df5b079d157bc5cb89d5c9754c0b..bd377033987bf7ded03016d1d8f05fd039bffbb5 100644
+index 9017907c0ec67a37a506f09b7e4499cef7885279..8b9ffcaab5d71660291d1c0454d2abd969d8c6ae 100644
 --- a/src/main/java/io/papermc/paper/world/ThreadedWorldUpgrader.java
 +++ b/src/main/java/io/papermc/paper/world/ThreadedWorldUpgrader.java
 @@ -84,8 +84,13 @@ public class ThreadedWorldUpgrader {
@@ -555,8 +582,8 @@ index 513833c2ea23df5b079d157bc5cb89d5c9754c0b..bd377033987bf7ded03016d1d8f05fd0
          LOGGER.info("Starting conversion now for world " + this.worldName);
  
 +        // Kaiiju start
-+        dev.kaiijumc.kaiiju.region.RegionFileFormat formatName = me.earthme.luminol.LuminolConfig.regionFormatName;
-+        int linearCompression = me.earthme.luminol.LuminolConfig.regionFormatLinearCompressionLevel;
++        dev.kaiijumc.kaiiju.region.RegionFileFormat formatName = me.earthme.luminol.config.modules.misc.RegionFormatConfig.regionFormatName;
++        int linearCompression = me.earthme.luminol.config.modules.misc.RegionFormatConfig.regionFormatLinearCompressionLevel;
 +        LOGGER.info("Using format " + formatName + " (" + linearCompression + ")");
 +        // Kaiiju end
          final WorldInfo info = new WorldInfo(() -> worldPersistentData,
@@ -565,57 +592,117 @@ index 513833c2ea23df5b079d157bc5cb89d5c9754c0b..bd377033987bf7ded03016d1d8f05fd0
  
          long expectedChunks = (long)regionFiles.length * (32L * 32L);
  
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index 3d526d7cfb313e419de89be1b275651982be42c7..90a6cfd011aaefe66fda79f887380ab2d62a07b1 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -29,6 +29,8 @@ public class LuminolConfig {
- 
-     public static RegionFileFormat regionFormatName = RegionFileFormat.ANVIL;
-     public static int regionFormatLinearCompressionLevel = 1;
-+    public static int linearFlushFrequency = 10;
+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..5d594b606178bd26180caad49de17c0e67e89747
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/RegionFormatConfig.java
+@@ -0,0 +1,58 @@
++package me.earthme.luminol.config.modules.misc;
++
++import com.electronwill.nightconfig.core.file.CommentedFileConfig;
++import dev.kaiijumc.kaiiju.region.RegionFileFormat;
++import me.earthme.luminol.config.*;
++
++public class RegionFormatConfig implements IConfigModule {
++    @DoNotLoad
++    public static RegionFileFormat regionFormatName = RegionFileFormat.ANVIL;
++
++    @HotReloadUnsupported
++    @ConfigInfo(baseName = "formatName")
++    private static String formatName = "ANVIL";
++    @HotReloadUnsupported
++    @ConfigInfo(baseName = "linear_compression_level",comments = "WARNING: DO NOT USE TOO HIGH COMPRESSION LEVEL(Recommended is 1 which is default value if you are using linear) BECAUSE THAT WOULD MAKE YOUR DATA IN DANGER!")
++    public static int regionFormatLinearCompressionLevel = 1;
++    @HotReloadUnsupported
++    @ConfigInfo(baseName = "linear_flusher_thread_count")
 +    public static int linearFlushThreads = 1;
- 
-     public static void init() throws IOException {
-         PARENT_FOLDER.mkdir();
-@@ -67,6 +69,12 @@ public class LuminolConfig {
-             logger.error("Falling back to compression level 1.");
-             regionFormatLinearCompressionLevel = 1;
-         }
-+        linearFlushFrequency = get("save.region-format.linear.flush-frequency", linearFlushFrequency);
-+        linearFlushThreads = get("save.region-format.linear.flush-max-threads", linearFlushThreads);
++    @HotReloadUnsupported
++    @ConfigInfo(baseName = "linear_flush_frequency")
++    public static int linearFlushFrequency = 10;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "region_format";
++    }
++
++    @Override
++    public void onLoaded(CommentedFileConfig configInstance){
++        if (LuminolConfig.alreadyInited){
++            return;
++        }
++
++        regionFormatName = RegionFileFormat.fromString(formatName);
++        if (regionFormatName.equals(RegionFileFormat.INVALID)) {
++            LuminolConfig.logger.error("Unknown region format in luminol global config: {}", formatName);
++            LuminolConfig.logger.error("Falling back to ANVIL region file format.");
++            regionFormatName = RegionFileFormat.ANVIL;
++        }
++
++        if (regionFormatLinearCompressionLevel > 23 || regionFormatLinearCompressionLevel < 1) {
++            LuminolConfig.logger.error("Linear region compression level should be between 1 and 22 in luminol global config: {}", regionFormatLinearCompressionLevel);
++            LuminolConfig.logger.error("Falling back to compression level 1.");
++            regionFormatLinearCompressionLevel = 1;
++        }
++
 +        if (linearFlushThreads < 0)
 +            linearFlushThreads = Math.max(Runtime.getRuntime().availableProcessors() + linearFlushThreads, 1);
 +        else
 +            linearFlushThreads = Math.max(linearFlushThreads, 1);
-     }
++    }
++}
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 59b1da130e519cbe06ed5eedf9e4dc881e45ba36..c924951c3dd7652ee446b40689ff9004546e972a 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -923,7 +923,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+             // Paper start - rewrite chunk system
+             worldserver.save((ProgressListener) null, flush, worldserver.noSave && !force, close);
+             if (flush) {
+-                MinecraftServer.LOGGER.info("ThreadedAnvilChunkStorage ({}): All chunks are saved", worldserver.getChunkSource().chunkMap.getStorageName());
++                MinecraftServer.LOGGER.info("ThreadedChunkStorage ({}): All chunks are saved", worldserver.getChunkSource().chunkMap.getStorageName()); // Kaiiju
+             }
+             // Paper end - rewrite chunk system
+         }
+@@ -947,7 +947,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+                 //MinecraftServer.LOGGER.info("ThreadedAnvilChunkStorage ({}): All chunks are saved", worldserver2.getChunkSource().chunkMap.getStorageName()); // Paper - move up
+             }
  
-     public static <T> T get(String key,T def){
+-            MinecraftServer.LOGGER.info("ThreadedAnvilChunkStorage: All dimensions are saved");
++            MinecraftServer.LOGGER.info("ThreadedChunkStorage: All dimensions are saved"); // Kaiiju
+         }
+ 
+         return flag3;
 diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
-index 50597a8b45bbd7dcc40b361da78358d9d01f5484..4709782f3e858edfa6ce25696462eb45909885ee 100644
+index 6ab9f83786dcfbd3156d2f2bd6da57baed1399f4..76ad4d8bce1611ead6f1596b2ba78267e3718655 100644
 --- a/src/main/java/net/minecraft/server/level/ChunkMap.java
 +++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
-@@ -212,7 +212,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+@@ -211,7 +211,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
      // Paper end - optimise chunk tick iteration
  
      public ChunkMap(ServerLevel world, LevelStorageSource.LevelStorageAccess session, DataFixer dataFixer, StructureTemplateManager structureTemplateManager, Executor executor, BlockableEventLoop<Runnable> mainThreadExecutor, LightChunkGetter chunkProvider, ChunkGenerator chunkGenerator, ChunkProgressListener worldGenerationProgressListener, ChunkStatusUpdateListener chunkStatusChangeListener, Supplier<DimensionDataStorage> persistentStateManagerFactory, int viewDistance, boolean dsync) {
 -        super(session.getDimensionPath(world.dimension()).resolve("region"), dataFixer, dsync);
-+        super(me.earthme.luminol.LuminolConfig.regionFormatName, me.earthme.luminol.LuminolConfig.regionFormatLinearCompressionLevel, session.getDimensionPath(world.dimension()).resolve("region"), dataFixer, dsync); // Kaiiju
++        super(me.earthme.luminol.config.modules.misc.RegionFormatConfig.regionFormatName, me.earthme.luminol.config.modules.misc.RegionFormatConfig.regionFormatLinearCompressionLevel, session.getDimensionPath(world.dimension()).resolve("region"), dataFixer, dsync); // Kaiiju
          // Paper - rewrite chunk system
          this.tickingGenerated = new AtomicInteger();
          //this.playerMap = new PlayerMap(); // Folia - region threading
-@@ -257,7 +257,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+@@ -256,7 +256,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
          this.lightEngine = new ThreadedLevelLightEngine(chunkProvider, this, this.level.dimensionType().hasSkyLight(), null, null); // Paper - rewrite chunk system
          this.distanceManager = new ChunkMap.ChunkDistanceManager(executor, mainThreadExecutor);
          this.overworldDataStorage = persistentStateManagerFactory;
 -        this.poiManager = new PoiManager(path.resolve("poi"), dataFixer, dsync, iregistrycustom, world);
-+        this.poiManager = new PoiManager(me.earthme.luminol.LuminolConfig.regionFormatName, me.earthme.luminol.LuminolConfig.regionFormatLinearCompressionLevel, path.resolve("poi"), dataFixer, dsync, iregistrycustom, world); // Kaiiju
++        this.poiManager = new PoiManager(me.earthme.luminol.config.modules.misc.RegionFormatConfig.regionFormatName, me.earthme.luminol.config.modules.misc.RegionFormatConfig.regionFormatLinearCompressionLevel, path.resolve("poi"), dataFixer, dsync, iregistrycustom, world); // Kaiiju
          this.setServerViewDistance(viewDistance);
          // Paper start
          this.dataRegionManager = new io.papermc.paper.chunk.SingleThreadChunkRegionManager(this.level, 2, (1.0 / 3.0), 1, 6, "Data", DataRegionData::new, DataRegionSectionData::new);
-@@ -823,13 +823,13 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+@@ -808,13 +808,13 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+     }
  
-     // Paper start - chunk status cache "api"
      public ChunkStatus getChunkStatusOnDiskIfCached(ChunkPos chunkPos) {
 -        net.minecraft.world.level.chunk.storage.RegionFile regionFile = regionFileCache.getRegionFileIfLoaded(chunkPos);
 +        dev.kaiijumc.kaiiju.region.AbstractRegionFile regionFile = regionFileCache.getRegionFileIfLoaded(chunkPos); // Kaiiju
@@ -629,7 +716,7 @@ index 50597a8b45bbd7dcc40b361da78358d9d01f5484..4709782f3e858edfa6ce25696462eb45
  
          if (regionFile == null || !regionFileCache.chunkExists(chunkPos)) {
              return null;
-@@ -847,7 +847,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+@@ -832,7 +832,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
      }
  
      public void updateChunkStatusOnDisk(ChunkPos chunkPos, @Nullable CompoundTag compound) throws IOException {
@@ -639,10 +726,10 @@ index 50597a8b45bbd7dcc40b361da78358d9d01f5484..4709782f3e858edfa6ce25696462eb45
          regionFile.setStatus(chunkPos.x, chunkPos.z, ChunkSerializer.getStatus(compound));
      }
 diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 722a5ec7f8e4995ac7025ca0785145d46bd66fcd..561681deaf647277ecde64eed4cfbd9f38b5fed1 100644
+index 10df17ad79092f3e226df08e58620694b3581758..da6269249a95d78f91e90416a96bf1b776fd9c97 100644
 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java
 +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -453,8 +453,8 @@ public class ServerLevel extends Level implements WorldGenLevel {
+@@ -446,8 +446,8 @@ public class ServerLevel extends Level implements WorldGenLevel {
  
      private static final class EntityRegionFileStorage extends net.minecraft.world.level.chunk.storage.RegionFileStorage {
  
@@ -653,22 +740,22 @@ index 722a5ec7f8e4995ac7025ca0785145d46bd66fcd..561681deaf647277ecde64eed4cfbd9f
          }
  
          protected void write(ChunkPos pos, net.minecraft.nbt.CompoundTag nbt) throws IOException {
-@@ -812,7 +812,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+@@ -808,7 +808,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
          // CraftBukkit end
          boolean flag2 = minecraftserver.forceSynchronousWrites();
          DataFixer datafixer = minecraftserver.getFixerUpper();
 -        this.entityStorage = new EntityRegionFileStorage(convertable_conversionsession.getDimensionPath(resourcekey).resolve("entities"), flag2); // Paper - rewrite chunk system  //EntityPersistentStorage<Entity> entitypersistentstorage = new EntityStorage(this, convertable_conversionsession.getDimensionPath(resourcekey).resolve("entities"), datafixer, flag2, minecraftserver);
-+        this.entityStorage = new EntityRegionFileStorage(me.earthme.luminol.LuminolConfig.regionFormatName, me.earthme.luminol.LuminolConfig.regionFormatLinearCompressionLevel, convertable_conversionsession.getDimensionPath(resourcekey).resolve("entities"), flag2); // Paper - rewrite chunk system  //EntityPersistentStorage<Entity> entitypersistentstorage = new EntityStorage(this, convertable_conversionsession.getDimensionPath(resourcekey).resolve("entities"), datafixer, flag2, minecraftserver); // Kaiiju
++        this.entityStorage = new EntityRegionFileStorage(me.earthme.luminol.config.modules.misc.RegionFormatConfig.regionFormatName, me.earthme.luminol.config.modules.misc.RegionFormatConfig.regionFormatLinearCompressionLevel, convertable_conversionsession.getDimensionPath(resourcekey).resolve("entities"), flag2); // Paper - rewrite chunk system  //EntityPersistentStorage<Entity> entitypersistentstorage = new EntityStorage(this, convertable_conversionsession.getDimensionPath(resourcekey).resolve("entities"), datafixer, flag2, minecraftserver); // Kaiiju
  
          // this.entityManager = new PersistentEntitySectionManager<>(Entity.class, new ServerLevel.EntityCallbacks(), entitypersistentstorage, this.entitySliceManager); // Paper // Paper - rewrite chunk system
          StructureTemplateManager structuretemplatemanager = minecraftserver.getStructureManager();
 diff --git a/src/main/java/net/minecraft/util/worldupdate/WorldUpgrader.java b/src/main/java/net/minecraft/util/worldupdate/WorldUpgrader.java
-index e16ef1b7c0bfe6d6194c09f6787a50fd9b28f55e..cc70b729663bececec45a03ec21a94792e5f2052 100644
+index 77dd632a266f4abed30b87b7909d77857c01e316..97007462c7f3d7231fff18ecf295f2574684bf9f 100644
 --- a/src/main/java/net/minecraft/util/worldupdate/WorldUpgrader.java
 +++ b/src/main/java/net/minecraft/util/worldupdate/WorldUpgrader.java
 @@ -61,7 +61,7 @@ public class WorldUpgrader {
      private volatile int skipped;
-     private final Object2FloatMap<ResourceKey<Level>> progressMap = Object2FloatMaps.synchronize(new Object2FloatOpenCustomHashMap(Util.identityStrategy()));
+     private final Reference2FloatMap<ResourceKey<Level>> progressMap = Reference2FloatMaps.synchronize(new Reference2FloatOpenHashMap());
      private volatile Component status = Component.translatable("optimizeWorld.stage.counting");
 -    public static final Pattern REGEX = Pattern.compile("^r\\.(-?[0-9]+)\\.(-?[0-9]+)\\.mca$");
 +    public static Pattern REGEX = Pattern.compile("^r\\.(-?[0-9]+)\\.(-?[0-9]+)\\.(linear | mca)$"); // Kaiiju
@@ -682,14 +769,14 @@ index e16ef1b7c0bfe6d6194c09f6787a50fd9b28f55e..cc70b729663bececec45a03ec21a9479
 -                builder1.put(resourcekey1, new ChunkStorage(path.resolve("region"), this.dataFixer, true));
 +                // Kaiiju start
 +                String worldName = this.levelStorage.getLevelId();
-+                dev.kaiijumc.kaiiju.region.RegionFileFormat formatName = me.earthme.luminol.LuminolConfig.regionFormatName;
-+                int linearCompression = me.earthme.luminol.LuminolConfig.regionFormatLinearCompressionLevel;
++                dev.kaiijumc.kaiiju.region.RegionFileFormat formatName = me.earthme.luminol.config.modules.misc.RegionFormatConfig.regionFormatName;
++                int linearCompression = me.earthme.luminol.config.modules.misc.RegionFormatConfig.regionFormatLinearCompressionLevel;
 +                builder1.put(resourcekey1, new ChunkStorage(formatName, linearCompression, path.resolve("region"), this.dataFixer, true));
 +                // Kaiiju end
              }
  
              ImmutableMap<ResourceKey<Level>, ChunkStorage> immutablemap1 = builder1.build();
-@@ -235,7 +240,7 @@ public class WorldUpgrader {
+@@ -241,7 +246,7 @@ public class WorldUpgrader {
          File file = this.levelStorage.getDimensionPath(world).toFile();
          File file1 = new File(file, "region");
          File[] afile = file1.listFiles((file2, s) -> {
@@ -698,14 +785,14 @@ index e16ef1b7c0bfe6d6194c09f6787a50fd9b28f55e..cc70b729663bececec45a03ec21a9479
          });
  
          if (afile == null) {
-@@ -254,7 +259,11 @@ public class WorldUpgrader {
+@@ -260,7 +265,11 @@ public class WorldUpgrader {
                      int l = Integer.parseInt(matcher.group(2)) << 5;
  
                      try {
 -                        RegionFile regionfile = new RegionFile(file2.toPath(), file1.toPath(), true);
 +                        // Kaiiju start
 +                        String worldName = this.levelStorage.getLevelId();
-+                        int linearCompression = me.earthme.luminol.LuminolConfig.regionFormatLinearCompressionLevel;
++                        int linearCompression = me.earthme.luminol.config.modules.misc.RegionFormatConfig.regionFormatLinearCompressionLevel;
 +                        dev.kaiijumc.kaiiju.region.AbstractRegionFile regionfile = dev.kaiijumc.kaiiju.region.AbstractRegionFileFactory.getAbstractRegionFile(linearCompression, file2.toPath(), file1.toPath(), true);
 +                        // Kaiiju end
  
@@ -727,25 +814,23 @@ index 5150d447c9dc2f539446749c8bee102050bab4ed..187ff795192c7eb56dffafa1ff6fa306
      }
  
 diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkStorage.java b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkStorage.java
-index 8ebecb588058da174b0e0e19e54fcddfeeca1422..1d880f27dd147da683fc30ed6f1bfa43ecdb7d93 100644
+index d16d7c2fed89fb1347df7ddd95856e7f08c22e8a..e4200692f6a33a12d00120f7a661de3e57a671dd 100644
 --- a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkStorage.java
 +++ b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkStorage.java
-@@ -37,11 +37,11 @@ public class ChunkStorage implements AutoCloseable {
-     public final RegionFileStorage regionFileCache;
-     // Paper end - async chunk loading
+@@ -36,9 +36,9 @@ public class ChunkStorage implements AutoCloseable {
+     @Nullable
+     private volatile LegacyStructureDataHandler legacyStructureHandler;
  
 -    public ChunkStorage(Path directory, DataFixer dataFixer, boolean dsync) {
 +    public ChunkStorage(dev.kaiijumc.kaiiju.region.RegionFileFormat format, int linearCompression, Path directory, DataFixer dataFixer, boolean dsync) { // Kaiiju
          this.fixerUpper = dataFixer;
-         // Paper start - async chunk io
-         // remove IO worker
--        this.regionFileCache = new RegionFileStorage(directory, dsync, true); // Paper - nuke IOWorker // Paper
-+        this.regionFileCache = new RegionFileStorage(format, linearCompression, directory, dsync, true); // Paper - nuke IOWorker // Paper
-         // Paper end - async chunk io
+-        this.regionFileCache = new RegionFileStorage(directory, dsync, true); // Paper - rewrite chunk system; async chunk IO & Attempt to recalculate regionfile header if it is corrupt
++        this.regionFileCache = new RegionFileStorage(format,linearCompression,directory, dsync, true); // Paper - rewrite chunk system; async chunk IO & Attempt to recalculate regionfile header if it is corrupt //Kaiiju
      }
  
+     public boolean isOldChunkAround(ChunkPos chunkPos, int checkRadius) {
 diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
-index 9248769e6d357f6eec68945fd7700e79b2942c41..024870a31469c40cd680be0399ce0e0e73839a0f 100644
+index 6cf83502a954cce9c562ec036bfeddb477d38b73..a450533cd01dab4ae165dc93f6c57553fee831c8 100644
 --- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
 +++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
 @@ -26,7 +26,7 @@ import net.minecraft.nbt.NbtIo; // Paper
@@ -757,7 +842,7 @@ index 9248769e6d357f6eec68945fd7700e79b2942c41..024870a31469c40cd680be0399ce0e0e
  
      private static final Logger LOGGER = LogUtils.getLogger();
      private static final int SECTOR_BYTES = 4096;
-@@ -50,6 +50,16 @@ public class RegionFile implements AutoCloseable {
+@@ -50,6 +50,17 @@ public class RegionFile implements AutoCloseable {
      public final java.util.concurrent.locks.ReentrantLock fileLock = new java.util.concurrent.locks.ReentrantLock(); // Paper
      public final Path regionFile; // Paper
  
@@ -771,10 +856,11 @@ index 9248769e6d357f6eec68945fd7700e79b2942c41..024870a31469c40cd680be0399ce0e0e
 +    }
 +    // Kaiiju end
 +
-     // Paper start - try to recover from RegionFile header corruption
++
+     // Paper start - Attempt to recalculate regionfile header if it is corrupt
      private static long roundToSectors(long bytes) {
          long sectors = bytes >>> 12; // 4096 = 2^12
-@@ -128,7 +138,7 @@ public class RegionFile implements AutoCloseable {
+@@ -128,7 +139,7 @@ public class RegionFile implements AutoCloseable {
      }
  
      // note: only call for CHUNK regionfiles
@@ -783,7 +869,7 @@ index 9248769e6d357f6eec68945fd7700e79b2942c41..024870a31469c40cd680be0399ce0e0e
          if (!this.canRecalcHeader) {
              return false;
          }
-@@ -954,10 +964,10 @@ public class RegionFile implements AutoCloseable {
+@@ -955,10 +966,10 @@ public class RegionFile implements AutoCloseable {
      private static int getChunkIndex(int x, int z) {
          return (x & 31) + (z & 31) * 32;
      }
@@ -796,7 +882,7 @@ index 9248769e6d357f6eec68945fd7700e79b2942c41..024870a31469c40cd680be0399ce0e0e
          final int offset = getChunkIndex(x, z);
          boolean previous = this.oversized[offset] == 1;
          this.oversized[offset] = (byte) (oversized ? 1 : 0);
-@@ -996,7 +1006,7 @@ public class RegionFile implements AutoCloseable {
+@@ -997,7 +1008,7 @@ public class RegionFile implements AutoCloseable {
          return this.regionFile.getParent().resolve(this.regionFile.getFileName().toString().replaceAll("\\.mca$", "") + "_oversized_" + x + "_" + z + ".nbt");
      }
  
@@ -806,7 +892,7 @@ index 9248769e6d357f6eec68945fd7700e79b2942c41..024870a31469c40cd680be0399ce0e0e
          try (DataInputStream out = new DataInputStream(new java.io.BufferedInputStream(new InflaterInputStream(Files.newInputStream(file))))) {
              return NbtIo.read((java.io.DataInput) out);
 diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
-index db571f658f636cdda1dcdbaffa0c4da67fae11ad..21537b14c6c6789da3db04577f1c93998397678d 100644
+index fe312b1aef579cb4bf81bdd967cf72ff880d7505..db9e4386ca95bdaba0a4a4e13e3a90d2bcfbae91 100644
 --- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
 +++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
 @@ -21,9 +21,13 @@ public class RegionFileStorage implements AutoCloseable {
@@ -891,7 +977,7 @@ index db571f658f636cdda1dcdbaffa0c4da67fae11ad..21537b14c6c6789da3db04577f1c9399
 @@ -123,28 +131,45 @@ public class RegionFileStorage implements AutoCloseable {
              }
              // Paper end - cache regionfile does not exist state
-             if (this.regionCache.size() >= io.papermc.paper.configuration.GlobalConfiguration.get().misc.regionFileCacheSize) { // Paper - configurable
+             if (this.regionCache.size() >= io.papermc.paper.configuration.GlobalConfiguration.get().misc.regionFileCacheSize) { // Paper - Sanitise RegionFileCache and make configurable
 -                ((RegionFile) this.regionCache.removeLast()).close();
 +                this.regionCache.removeLast().close(); // Kaiiju
              }
@@ -941,16 +1027,16 @@ index db571f658f636cdda1dcdbaffa0c4da67fae11ad..21537b14c6c6789da3db04577f1c9399
              }
              // Paper end
              return regionfile1;
-@@ -172,7 +197,7 @@ public class RegionFileStorage implements AutoCloseable {
+@@ -156,7 +181,7 @@ public class RegionFileStorage implements AutoCloseable {
+         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(dev.kaiijumc.kaiiju.region.AbstractRegionFile regionfile, ChunkPos chunkCoordinate) throws IOException { // Kaiiju
          synchronized (regionfile) {
              try (DataInputStream datainputstream = regionfile.getChunkDataInputStream(chunkCoordinate)) {
                  CompoundTag oversizedData = regionfile.getOversizedData(chunkCoordinate.x, chunkCoordinate.z);
-@@ -219,14 +244,14 @@ public class RegionFileStorage implements AutoCloseable {
+@@ -191,14 +216,14 @@ public class RegionFileStorage implements AutoCloseable {
      @Nullable
      public CompoundTag read(ChunkPos pos) throws IOException {
          // CraftBukkit start - SPIGOT-5680: There's no good reason to preemptively create files on read, save that for writing
@@ -967,7 +1053,7 @@ index db571f658f636cdda1dcdbaffa0c4da67fae11ad..21537b14c6c6789da3db04577f1c9399
          // We add the regionfile parameter to avoid the potential deadlock (on fileLock) if we went back to obtain a regionfile
          // if we decide to re-read
          // Paper end
-@@ -236,7 +261,7 @@ public class RegionFileStorage implements AutoCloseable {
+@@ -208,7 +233,7 @@ public class RegionFileStorage implements AutoCloseable {
  
          // Paper start
          if (regionfile.isOversized(pos.x, pos.z)) {
@@ -976,7 +1062,7 @@ index db571f658f636cdda1dcdbaffa0c4da67fae11ad..21537b14c6c6789da3db04577f1c9399
              return readOversizedChunk(regionfile, pos);
          }
          // Paper end
-@@ -250,12 +275,12 @@ public class RegionFileStorage implements AutoCloseable {
+@@ -222,12 +247,12 @@ public class RegionFileStorage implements AutoCloseable {
                      if (this.isChunkData) {
                          ChunkPos chunkPos = ChunkSerializer.getChunkCoordinate(nbttagcompound);
                          if (!chunkPos.equals(pos)) {
@@ -992,7 +1078,7 @@ index db571f658f636cdda1dcdbaffa0c4da67fae11ad..21537b14c6c6789da3db04577f1c9399
                              return null;
                          }
                      }
-@@ -289,13 +314,13 @@ public class RegionFileStorage implements AutoCloseable {
+@@ -261,13 +286,13 @@ public class RegionFileStorage implements AutoCloseable {
  
          return nbttagcompound;
          } finally { // Paper start
@@ -1008,25 +1094,25 @@ index db571f658f636cdda1dcdbaffa0c4da67fae11ad..21537b14c6c6789da3db04577f1c9399
          if (regionfile == null) {
              return;
          }
-@@ -325,7 +350,7 @@ public class RegionFileStorage implements AutoCloseable {
-     }
+@@ -298,7 +323,7 @@ public class RegionFileStorage implements AutoCloseable {
  
      protected void write(ChunkPos pos, @Nullable CompoundTag nbt) throws IOException {
--        RegionFile regionfile = this.getRegionFile(pos, nbt == null, true); // CraftBukkit // Paper // Paper start - rewrite chunk system
-+        dev.kaiijumc.kaiiju.region.AbstractRegionFile regionfile = this.getRegionFile(pos, nbt == null, true); // CraftBukkit // Paper // Paper start - rewrite chunk system // Kaiiju
+         // Paper start - rewrite chunk system
+-        RegionFile regionfile = this.getRegionFile(pos, nbt == null, true); // CraftBukkit
++        dev.kaiijumc.kaiiju.region.AbstractRegionFile regionfile = this.getRegionFile(pos, nbt == null, true); // CraftBukkit // Kaiiju
          if (nbt == null && regionfile == null) {
              return;
          }
-@@ -375,7 +400,7 @@ public class RegionFileStorage implements AutoCloseable {
-         }
-         // Paper end
-         } finally { // Paper start
+@@ -353,7 +378,7 @@ public class RegionFileStorage implements AutoCloseable {
+         // Paper end - Chunk save reattempt
+         // Paper start - rewrite chunk system
+         } finally {
 -            regionfile.fileLock.unlock();
 +            regionfile.getFileLock().unlock(); // Kaiiju
-         } // Paper end
+         }
+         // Paper end - rewrite chunk system
      }
- 
-@@ -384,7 +409,7 @@ public class RegionFileStorage implements AutoCloseable {
+@@ -363,7 +388,7 @@ public class RegionFileStorage implements AutoCloseable {
          ObjectIterator objectiterator = this.regionCache.values().iterator();
  
          while (objectiterator.hasNext()) {
@@ -1035,7 +1121,7 @@ index db571f658f636cdda1dcdbaffa0c4da67fae11ad..21537b14c6c6789da3db04577f1c9399
  
              try {
                  regionfile.close();
-@@ -400,7 +425,7 @@ public class RegionFileStorage implements AutoCloseable {
+@@ -379,7 +404,7 @@ public class RegionFileStorage implements AutoCloseable {
          ObjectIterator objectiterator = this.regionCache.values().iterator();
  
          while (objectiterator.hasNext()) {
@@ -1060,13 +1146,13 @@ index 4aac1979cf57300825a999c876fcf24d3170e68e..3b96582f15d0985b670b5b5a1548800d
          this.factory = factory;
          this.fixerUpper = dataFixer;
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-index bcbf7ba7c687ecaa530d4de3af45ebeb80dd15c5..f19db38e64854d051d4d8dbbb3ff4236b5d4537b 100644
+index 379c10e791a961d25d7de571f81ace1ac7d84381..e268ef6a373fa0e144104eb7fcfaf7bc9005c987 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
-@@ -561,7 +561,7 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+@@ -575,7 +575,7 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+                 world.getChunk(x, z); // make sure we're at ticket level 32 or lower
                  return true;
              }
- 
 -            net.minecraft.world.level.chunk.storage.RegionFile file;
 +            dev.kaiijumc.kaiiju.region.AbstractRegionFile file; // Kaiiju
              try {

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

@@ -5,10 +5,10 @@ Subject: [PATCH] Kaiiju Vanilla end portal teleportation
 
 
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 6f3e87661c3181b6537e4d6d96e50d8d5680c040..3a5c8f1f9a8173777b00d43c15e8e313526d3e28 100644
+index 09cdd28dcb2357ba3d7be316b7ca94dc93ac5dd0..d955a555d260d39812b84eb5319db619ec0f8d28 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -4108,12 +4108,17 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+@@ -4195,12 +4195,17 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
                          targetPos, 16, // load 16 blocks to be safe from block physics
                          ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor.Priority.HIGH,
                          (chunks) -> {
@@ -28,7 +28,7 @@ index 6f3e87661c3181b6537e4d6d96e50d8d5680c040..3a5c8f1f9a8173777b00d43c15e8e313
                              );
                          }
                      );
-@@ -4300,6 +4305,10 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+@@ -4387,6 +4392,10 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
          if (!this.canPortalAsync(takePassengers)) {
              return false;
          }
@@ -39,7 +39,7 @@ index 6f3e87661c3181b6537e4d6d96e50d8d5680c040..3a5c8f1f9a8173777b00d43c15e8e313
  
          Vec3 initialPosition = this.position();
          ChunkPos initialPositionChunk = new ChunkPos(
-@@ -4358,7 +4367,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+@@ -4445,7 +4454,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
              // place
              passengerTree.root.placeInAsync(
                  originWorld, destination, Entity.TELEPORT_FLAG_LOAD_CHUNK | (takePassengers ? Entity.TELEPORT_FLAG_TELEPORT_PASSENGERS : 0L),

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

@@ -1,6 +1,6 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Wed, 6 Dec 2023 23:43:00 +0800
+From: MrHua269 <novau233@163.com>
+Date: Mon, 25 Mar 2024 13:47:32 +0000
 Subject: [PATCH] Kaiiju Async path processing
 
 
@@ -299,15 +299,14 @@ index 0000000000000000000000000000000000000000..6b91852238f80d236fc44f766b115267
 +}
 diff --git a/src/main/java/dev/kaiijumc/kaiiju/path/AsyncPathProcessor.java b/src/main/java/dev/kaiijumc/kaiiju/path/AsyncPathProcessor.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..b4c27b33dffa8dce19c9db25d15bc57f48e05d4a
+index 0000000000000000000000000000000000000000..31f3ae25069f516255263ab50aca8ee6f1268f8f
 --- /dev/null
 +++ b/src/main/java/dev/kaiijumc/kaiiju/path/AsyncPathProcessor.java
-@@ -0,0 +1,53 @@
+@@ -0,0 +1,52 @@
 +package dev.kaiijumc.kaiiju.path;
 +
 +import com.google.common.util.concurrent.ThreadFactoryBuilder;
 +
-+import me.earthme.luminol.LuminolConfig;
 +import net.minecraft.world.level.pathfinder.Path;
 +import net.minecraft.world.entity.Entity;
 +
@@ -324,8 +323,8 @@ index 0000000000000000000000000000000000000000..b4c27b33dffa8dce19c9db25d15bc57f
 +
 +    private static final Executor pathProcessingExecutor = new ThreadPoolExecutor(
 +        1,
-+         LuminolConfig.asyncPathProcessingMaxThreads,
-+         LuminolConfig.asyncPathProcessingKeepalive, TimeUnit.SECONDS,
++         me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessingMaxThreads,
++         me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessingKeepalive, TimeUnit.SECONDS,
 +         new LinkedBlockingQueue<>(),
 +         new ThreadFactoryBuilder()
 +             .setNameFormat("petal-path-processor-%d")
@@ -474,48 +473,49 @@ index 0000000000000000000000000000000000000000..130d61324679c8600faa52255f3ad99f
 +        return WALK;
 +    }
 +}
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index 7ada58f2fa83a47908723bdf1e5c5fbbc2f5ffa9..e8cd180bab5c196db09ded74aea676b4412fc6e9 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -11,6 +11,7 @@ import org.apache.logging.log4j.LogManager;
- import org.apache.logging.log4j.Logger;
- import org.bukkit.Bukkit;
- 
-+import java.lang.Math;
- import java.util.*;
- import java.io.File;
- import java.io.IOException;
-@@ -58,7 +59,9 @@ public class LuminolConfig {
-     public static double entityWakeUpDurationRatioStandardDeviation = 0.2;
-     public static boolean loadChunksToActiveClimbingEntities = false;
-     public static int acquirePoiForStuckEntityInterval = 60;
--
-+    public static boolean asyncPathProcessing = false;
-+    public static int asyncPathProcessingMaxThreads = 0;
-+    public static int asyncPathProcessingKeepalive = 60;
- 
-     public static void init() throws IOException {
-         PARENT_FOLDER.mkdir();
-@@ -175,6 +178,16 @@ public class LuminolConfig {
-         entityWakeUpDurationRatioStandardDeviation = get("optimizations.entity_wakeup_duration_ratio_standard_deviation",entityWakeUpDurationRatioStandardDeviation);
-         loadChunksToActiveClimbingEntities = get("optimizations.load_chunks_to_active_climbing_entities",loadChunksToActiveClimbingEntities);
-         acquirePoiForStuckEntityInterval = get("optimizations.acquire_poi_for_stuck_entity_interval", acquirePoiForStuckEntityInterval);
+diff --git a/src/main/java/me/earthme/luminol/config/modules/optimizations/AsyncPathProcessingConfig.java b/src/main/java/me/earthme/luminol/config/modules/optimizations/AsyncPathProcessingConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..a5472bb9d453bbeee92738c8d1a57ef4fd9bf07e
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/optimizations/AsyncPathProcessingConfig.java
+@@ -0,0 +1,35 @@
++package me.earthme.luminol.config.modules.optimizations;
 +
-+        asyncPathProcessing = get("optimizations.async_pathfinding.enabled",asyncPathProcessing,"Config to enable the async pathfinder.");
-+        asyncPathProcessingMaxThreads = get("optimization.async_pathfinding.max-threads", asyncPathProcessingMaxThreads,"If it was set to 0(default),the thread count will be auto set(a quarter of the CPU thread count)");
-+        asyncPathProcessingKeepalive = get("optimization.async_pathfinding.keepalive", asyncPathProcessingKeepalive);
++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;
++
++public class AsyncPathProcessingConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean asyncPathProcessing = false;
++    @ConfigInfo(baseName = "max_threads")
++    public static int asyncPathProcessingMaxThreads = 0;
++    @ConfigInfo(baseName = "keep_alive_time")
++    public static int asyncPathProcessingKeepalive = 60;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.OPTIMIZATIONS;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "async_path_processing";
++    }
++
++    @Override
++    public void onLoaded(CommentedFileConfig config){
 +        if (asyncPathProcessingMaxThreads < 0)
 +            asyncPathProcessingMaxThreads = Math.max(Runtime.getRuntime().availableProcessors() + asyncPathProcessingMaxThreads, 1);
 +        else if (asyncPathProcessingMaxThreads == 0)
 +            asyncPathProcessingMaxThreads = Math.max(Runtime.getRuntime().availableProcessors() / 4, 1);
 +        if (!asyncPathProcessing)
 +            asyncPathProcessingMaxThreads = 0;
-     }
- 
-     public static <T> T get(String key,T def){
++    }
++}
 diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
-index 394913950ac8fbcfcdbce817bac95f3b6604beb7..fcf22d62b2bb61807ab54a3e4dca8500d9a1f8a7 100644
+index 54297b9dde40fe853d873d60373cd8c0a3c9466b..67210fc018349ab0a79740dee140fb60c82c431a 100644
 --- a/src/main/java/net/minecraft/world/entity/Mob.java
 +++ b/src/main/java/net/minecraft/world/entity/Mob.java
 @@ -297,6 +297,7 @@ public abstract class Mob extends LivingEntity implements Targeting {
@@ -527,15 +527,15 @@ index 394913950ac8fbcfcdbce817bac95f3b6604beb7..fcf22d62b2bb61807ab54a3e4dca8500
          if (this.target != null && (!io.papermc.paper.util.TickThread.isTickThreadFor(this.target) || this.target.isRemoved())) {
              this.target = null;
 diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java b/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java
-index ba4cdaf499c7ffef0c7fbdd575bdba841bcb7282..6e8e0afb5ec86358f4e3eb929b590fdea1564d21 100644
+index abcc3ef59475ac170fd10b4dd4a4f3371faf17e0..e1dc31deeb87d695ddf2308c27e2cf949e48e538 100644
 --- a/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java
 +++ b/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java
-@@ -78,6 +78,40 @@ public class AcquirePoi {
+@@ -68,6 +68,40 @@ public class AcquirePoi {
                          io.papermc.paper.util.PoiAccess.findNearestPoiPositions(poiManager, poiPredicate, predicate2, entity.blockPosition(), 48, 48*48, PoiManager.Occupancy.HAS_SPACE, false, 5, poiposes);
                          Set<Pair<Holder<PoiType>, BlockPos>> set = new java.util.HashSet<>(poiposes);
                          // Paper end - optimise POI access
 +                        // Kaiiju start - petal - Async path processing
-+                        if (me.earthme.luminol.LuminolConfig.asyncPathProcessing) {
++                        if (me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessing) {
 +                            // await on path async
 +                            Path possiblePath = findPathToPois(entity, set);
 +
@@ -571,7 +571,7 @@ index ba4cdaf499c7ffef0c7fbdd575bdba841bcb7282..6e8e0afb5ec86358f4e3eb929b590fde
                          Path path = findPathToPois(entity, set);
                          if (path != null && path.canReach()) {
                              BlockPos blockPos = path.getTarget();
-@@ -99,6 +133,7 @@ public class AcquirePoi {
+@@ -89,6 +123,7 @@ public class AcquirePoi {
                                  });
                              }
                          }
@@ -580,7 +580,7 @@ index ba4cdaf499c7ffef0c7fbdd575bdba841bcb7282..6e8e0afb5ec86358f4e3eb929b590fde
                          return true;
                      }
 diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/MoveToTargetSink.java b/src/main/java/net/minecraft/world/entity/ai/behavior/MoveToTargetSink.java
-index 98bf17441da3169d49de55fe89d79ebe250a2b7e..a93457a4c0f4ec8be3a105c6feeb5a189056d8cf 100644
+index 98bf17441da3169d49de55fe89d79ebe250a2b7e..74162661e5757bb2c732361042b5dd2c3ded43ee 100644
 --- a/src/main/java/net/minecraft/world/entity/ai/behavior/MoveToTargetSink.java
 +++ b/src/main/java/net/minecraft/world/entity/ai/behavior/MoveToTargetSink.java
 @@ -21,6 +21,7 @@ public class MoveToTargetSink extends Behavior<Mob> {
@@ -596,10 +596,10 @@ index 98bf17441da3169d49de55fe89d79ebe250a2b7e..a93457a4c0f4ec8be3a105c6feeb5a18
              WalkTarget walkTarget = brain.getMemory(MemoryModuleType.WALK_TARGET).get();
              boolean bl = this.reachedTarget(entity, walkTarget);
 -            if (!bl && this.tryComputePath(entity, walkTarget, world.getGameTime())) {
-+            if (!me.earthme.luminol.LuminolConfig.asyncPathProcessing && !bl && this.tryComputePath(entity, walkTarget, world.getGameTime())) { // Kaiiju - petal - async path processing means we can't know if the path is reachable here
++            if (!me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessing && !bl && this.tryComputePath(entity, walkTarget, world.getGameTime())) { // Kaiiju - petal - async path processing means we can't know if the path is reachable here
                  this.lastTargetPos = walkTarget.getTarget().currentBlockPosition();
                  return true;
-+            } else if (me.earthme.luminol.LuminolConfig.asyncPathProcessing && !bl) { return true; // Kaiiju - async pathfinding
++            } else if (me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessing && !bl) { return true; // Kaiiju - async pathfinding
              } else {
                  brain.eraseMemory(MemoryModuleType.WALK_TARGET);
                  if (bl) {
@@ -607,7 +607,7 @@ index 98bf17441da3169d49de55fe89d79ebe250a2b7e..a93457a4c0f4ec8be3a105c6feeb5a18
  
      @Override
      protected boolean canStillUse(ServerLevel world, Mob entity, long time) {
-+        if (me.earthme.luminol.LuminolConfig.asyncPathProcessing && !this.finishedProcessing) return true; // Kaiiju - petal - wait for processing
++        if (me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessing && !this.finishedProcessing) return true; // Kaiiju - petal - wait for processing
          if (this.path != null && this.lastTargetPos != null) {
              Optional<WalkTarget> optional = entity.getBrain().getMemory(MemoryModuleType.WALK_TARGET);
              boolean bl = optional.map(MoveToTargetSink::isWalkTargetSpectator).orElse(false);
@@ -616,7 +616,7 @@ index 98bf17441da3169d49de55fe89d79ebe250a2b7e..a93457a4c0f4ec8be3a105c6feeb5a18
      @Override
      protected void start(ServerLevel serverLevel, Mob mob, long l) {
 +        // Kaiiju start - petal - start processing
-+        if (me.earthme.luminol.LuminolConfig.asyncPathProcessing) {
++        if (me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessing) {
 +            Brain<?> brain = mob.getBrain();
 +            WalkTarget walkTarget = brain.getMemory(MemoryModuleType.WALK_TARGET).get();
 +
@@ -633,7 +633,7 @@ index 98bf17441da3169d49de55fe89d79ebe250a2b7e..a93457a4c0f4ec8be3a105c6feeb5a18
      @Override
      protected void tick(ServerLevel serverLevel, Mob mob, long l) {
 +        // Kaiiju start - petal - Async path processing
-+        if (me.earthme.luminol.LuminolConfig.asyncPathProcessing) {
++        if (me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessing) {
 +            if (this.path != null && !this.path.isProcessed()) return; // wait for processing
 +
 +            if (!this.finishedProcessing) {
@@ -705,7 +705,7 @@ index 98bf17441da3169d49de55fe89d79ebe250a2b7e..a93457a4c0f4ec8be3a105c6feeb5a18
      private boolean tryComputePath(Mob entity, WalkTarget walkTarget, long time) {
          BlockPos blockPos = walkTarget.getTarget().currentBlockPosition();
 diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/SetClosestHomeAsWalkTarget.java b/src/main/java/net/minecraft/world/entity/ai/behavior/SetClosestHomeAsWalkTarget.java
-index 271efbb027f6f5d69ac5bc5dc51102a1eb00ab31..a64be68194fb0fa205b3f3cb87406056832d1fe3 100644
+index 271efbb027f6f5d69ac5bc5dc51102a1eb00ab31..cd2a3edc03301286114834e721f5441e7b70474a 100644
 --- a/src/main/java/net/minecraft/world/entity/ai/behavior/SetClosestHomeAsWalkTarget.java
 +++ b/src/main/java/net/minecraft/world/entity/ai/behavior/SetClosestHomeAsWalkTarget.java
 @@ -57,6 +57,26 @@ public class SetClosestHomeAsWalkTarget {
@@ -713,7 +713,7 @@ index 271efbb027f6f5d69ac5bc5dc51102a1eb00ab31..a64be68194fb0fa205b3f3cb87406056
                                  return poiType.is(PoiTypes.HOME);
                              }, predicate, entity.blockPosition(), 48, PoiManager.Occupancy.ANY).collect(Collectors.toSet());
 +                            // Kaiiju start - petal - Async path processing
-+                            if (me.earthme.luminol.LuminolConfig.asyncPathProcessing) {
++                            if (me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessing) {
 +                                // await on path async
 +                                Path possiblePath = AcquirePoi.findPathToPois(entity, set);
 +
@@ -757,7 +757,7 @@ index 6771f2dc974317b6b152288bf41d1a95bc78a8e4..7a641747b17164b09bb8483cda7f69d1
                      Node node = path.getNode(i);
                      this.doorPos = new BlockPos(node.x, node.y + 1, node.z);
 diff --git a/src/main/java/net/minecraft/world/entity/ai/navigation/AmphibiousPathNavigation.java b/src/main/java/net/minecraft/world/entity/ai/navigation/AmphibiousPathNavigation.java
-index 9d3b32c852d660356e0f16d4cc10072b1c603e64..545f578d77398a00fbc626e048eac56626308792 100644
+index 9d3b32c852d660356e0f16d4cc10072b1c603e64..2e64fe17fb3ee1925db1fdb34dedba356aea070b 100644
 --- a/src/main/java/net/minecraft/world/entity/ai/navigation/AmphibiousPathNavigation.java
 +++ b/src/main/java/net/minecraft/world/entity/ai/navigation/AmphibiousPathNavigation.java
 @@ -12,10 +12,26 @@ public class AmphibiousPathNavigation extends PathNavigation {
@@ -780,7 +780,7 @@ index 9d3b32c852d660356e0f16d4cc10072b1c603e64..545f578d77398a00fbc626e048eac566
          this.nodeEvaluator = new AmphibiousNodeEvaluator(false);
          this.nodeEvaluator.setCanPassDoors(true);
 +        // Kaiiju start - petal - async path processing
-+        if (me.earthme.luminol.LuminolConfig.asyncPathProcessing)
++        if (me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessing)
 +            return new PathFinder(this.nodeEvaluator, range, nodeEvaluatorGenerator);
 +        else
 +        // Kaiiju end
@@ -788,7 +788,7 @@ index 9d3b32c852d660356e0f16d4cc10072b1c603e64..545f578d77398a00fbc626e048eac566
      }
  
 diff --git a/src/main/java/net/minecraft/world/entity/ai/navigation/FlyingPathNavigation.java b/src/main/java/net/minecraft/world/entity/ai/navigation/FlyingPathNavigation.java
-index 027eef4ace908147285c8d72b612d16e4f925672..6ba693159dcc0827563b5141d12a15ede43b6eda 100644
+index e35c38feb62c3345d82636081decc09db9f061ab..70f4104f8e49fd6b7df531673f3e1da123783409 100644
 --- a/src/main/java/net/minecraft/world/entity/ai/navigation/FlyingPathNavigation.java
 +++ b/src/main/java/net/minecraft/world/entity/ai/navigation/FlyingPathNavigation.java
 @@ -16,10 +16,26 @@ public class FlyingPathNavigation extends PathNavigation {
@@ -811,7 +811,7 @@ index 027eef4ace908147285c8d72b612d16e4f925672..6ba693159dcc0827563b5141d12a15ed
          this.nodeEvaluator = new FlyNodeEvaluator();
          this.nodeEvaluator.setCanPassDoors(true);
 +        // Kaiiju start - petal - async path processing
-+        if (me.earthme.luminol.LuminolConfig.asyncPathProcessing)
++        if (me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessing)
 +            return new PathFinder(this.nodeEvaluator, range, nodeEvaluatorGenerator);
 +        else
 +        // Kaiiju end
@@ -827,7 +827,7 @@ index 027eef4ace908147285c8d72b612d16e4f925672..6ba693159dcc0827563b5141d12a15ed
          if (!this.isDone()) {
              if (this.canUpdatePath()) {
 diff --git a/src/main/java/net/minecraft/world/entity/ai/navigation/GroundPathNavigation.java b/src/main/java/net/minecraft/world/entity/ai/navigation/GroundPathNavigation.java
-index c065d372ac5f1663db3c521e996ee03669d0bc31..c560435f92d770f1ad7869abaaf7d680b9a866eb 100644
+index b31ba4e2286eaee5028cb4dc236829d1a302a25a..aaa04a4b01575495e6e01f0d83b2bb03acc93822 100644
 --- a/src/main/java/net/minecraft/world/entity/ai/navigation/GroundPathNavigation.java
 +++ b/src/main/java/net/minecraft/world/entity/ai/navigation/GroundPathNavigation.java
 @@ -23,10 +23,26 @@ public class GroundPathNavigation extends PathNavigation {
@@ -850,7 +850,7 @@ index c065d372ac5f1663db3c521e996ee03669d0bc31..c560435f92d770f1ad7869abaaf7d680
          this.nodeEvaluator = new WalkNodeEvaluator();
          this.nodeEvaluator.setCanPassDoors(true);
 +        // Kaiiju start - petal - async path processing
-+        if (me.earthme.luminol.LuminolConfig.asyncPathProcessing)
++        if (me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessing)
 +            return new PathFinder(this.nodeEvaluator, range, nodeEvaluatorGenerator);
 +        else
 +        // Kaiiju end
@@ -858,10 +858,10 @@ index c065d372ac5f1663db3c521e996ee03669d0bc31..c560435f92d770f1ad7869abaaf7d680
      }
  
 diff --git a/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java b/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java
-index 147057bfd67d56857b5d3ab1ebd0f0a0c1793a9c..4e104f7ab240ffb53823b14ad6c2506c5e169f98 100644
+index 089baec30e0c16149b147a501d68958663519b96..f6484fefd28a028fbcd1a54d93c8607b65575d00 100644
 --- a/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java
 +++ b/src/main/java/net/minecraft/world/entity/ai/navigation/PathNavigation.java
-@@ -152,6 +152,10 @@ public abstract class PathNavigation {
+@@ -153,6 +153,10 @@ public abstract class PathNavigation {
              return null;
          } else if (!this.canUpdatePath()) {
              return null;
@@ -872,12 +872,12 @@ index 147057bfd67d56857b5d3ab1ebd0f0a0c1793a9c..4e104f7ab240ffb53823b14ad6c2506c
          } else if (this.path != null && !this.path.isDone() && positions.contains(this.targetPos)) {
              return this.path;
          } else {
-@@ -178,11 +182,29 @@ public abstract class PathNavigation {
+@@ -179,11 +183,29 @@ public abstract class PathNavigation {
              PathNavigationRegion pathNavigationRegion = new PathNavigationRegion(this.level, blockPos.offset(-i, -i, -i), blockPos.offset(i, i, i));
              Path path = this.pathFinder.findPath(pathNavigationRegion, this.mob, positions, followRange, distance, this.maxVisitedNodesMultiplier);
              this.level.getProfiler().pop();
 +            // Kaiiju start - petal - async path processing
-+            if (me.earthme.luminol.LuminolConfig.asyncPathProcessing) {
++            if (me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessing) {
 +                // assign early a target position. most calls will only have 1 position
 +                if (!positions.isEmpty()) this.targetPos = positions.iterator().next();
 +
@@ -902,7 +902,7 @@ index 147057bfd67d56857b5d3ab1ebd0f0a0c1793a9c..4e104f7ab240ffb53823b14ad6c2506c
  
              return path;
          }
-@@ -229,8 +251,8 @@ public abstract class PathNavigation {
+@@ -230,8 +252,8 @@ public abstract class PathNavigation {
              if (this.isDone()) {
                  return false;
              } else {
@@ -913,7 +913,7 @@ index 147057bfd67d56857b5d3ab1ebd0f0a0c1793a9c..4e104f7ab240ffb53823b14ad6c2506c
                      return false;
                  } else {
                      this.speedModifier = speed;
-@@ -253,6 +275,7 @@ public abstract class PathNavigation {
+@@ -254,6 +276,7 @@ public abstract class PathNavigation {
          if (this.hasDelayedRecomputation) {
              this.recomputePath();
          }
@@ -921,7 +921,7 @@ index 147057bfd67d56857b5d3ab1ebd0f0a0c1793a9c..4e104f7ab240ffb53823b14ad6c2506c
  
          if (!this.isDone()) {
              if (this.canUpdatePath()) {
-@@ -279,6 +302,7 @@ public abstract class PathNavigation {
+@@ -280,6 +303,7 @@ public abstract class PathNavigation {
      }
  
      protected void followThePath() {
@@ -929,7 +929,7 @@ index 147057bfd67d56857b5d3ab1ebd0f0a0c1793a9c..4e104f7ab240ffb53823b14ad6c2506c
          Vec3 vec3 = this.getTempMobPos();
          this.maxDistanceToWaypoint = this.mob.getBbWidth() > 0.75F ? this.mob.getBbWidth() / 2.0F : 0.75F - this.mob.getBbWidth() / 2.0F;
          Vec3i vec3i = this.path.getNextNodePos();
-@@ -434,7 +458,7 @@ public abstract class PathNavigation {
+@@ -435,7 +459,7 @@ public abstract class PathNavigation {
      public boolean shouldRecomputePath(BlockPos pos) {
          if (this.hasDelayedRecomputation) {
              return false;
@@ -939,7 +939,7 @@ index 147057bfd67d56857b5d3ab1ebd0f0a0c1793a9c..4e104f7ab240ffb53823b14ad6c2506c
              Vec3 vec3 = new Vec3(((double)node.x + this.mob.getX()) / 2.0D, ((double)node.y + this.mob.getY()) / 2.0D, ((double)node.z + this.mob.getZ()) / 2.0D);
              return pos.closerToCenterThan(vec3, (double)(this.path.getNodeCount() - this.path.getNextNodeIndex()));
 diff --git a/src/main/java/net/minecraft/world/entity/ai/navigation/WaterBoundPathNavigation.java b/src/main/java/net/minecraft/world/entity/ai/navigation/WaterBoundPathNavigation.java
-index ee8543afbbd681bf327a353530a7a635aa5ef592..0e6fd5c6d31e6b39e693866165f3dab3d483c920 100644
+index ee8543afbbd681bf327a353530a7a635aa5ef592..238b5f2dc5487dcf675152b8c19a40a6e16958dc 100644
 --- a/src/main/java/net/minecraft/world/entity/ai/navigation/WaterBoundPathNavigation.java
 +++ b/src/main/java/net/minecraft/world/entity/ai/navigation/WaterBoundPathNavigation.java
 @@ -15,10 +15,26 @@ public class WaterBoundPathNavigation extends PathNavigation {
@@ -962,7 +962,7 @@ index ee8543afbbd681bf327a353530a7a635aa5ef592..0e6fd5c6d31e6b39e693866165f3dab3
          this.allowBreaching = this.mob.getType() == EntityType.DOLPHIN;
          this.nodeEvaluator = new SwimNodeEvaluator(this.allowBreaching);
 +        // Kaiiju start - async path processing
-+        if (me.earthme.luminol.LuminolConfig.asyncPathProcessing)
++        if (me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessing)
 +            return new PathFinder(this.nodeEvaluator, range, nodeEvaluatorGenerator);
 +        else
 +        // Kaiiju end
@@ -970,7 +970,7 @@ index ee8543afbbd681bf327a353530a7a635aa5ef592..0e6fd5c6d31e6b39e693866165f3dab3
      }
  
 diff --git a/src/main/java/net/minecraft/world/entity/ai/sensing/NearestBedSensor.java b/src/main/java/net/minecraft/world/entity/ai/sensing/NearestBedSensor.java
-index 8db20db72cd51046213625fac46c35854c59ec5d..d40e00a0a8726c920ea43aaa1ed680054cbfd9a3 100644
+index 8db20db72cd51046213625fac46c35854c59ec5d..afa5d36f5f9e6f3a44a1e92f98a1d83c3af4d277 100644
 --- a/src/main/java/net/minecraft/world/entity/ai/sensing/NearestBedSensor.java
 +++ b/src/main/java/net/minecraft/world/entity/ai/sensing/NearestBedSensor.java
 @@ -57,6 +57,25 @@ public class NearestBedSensor extends Sensor<Mob> {
@@ -978,7 +978,7 @@ index 8db20db72cd51046213625fac46c35854c59ec5d..d40e00a0a8726c920ea43aaa1ed68005
              // don't ask me why it's unbounded. ask mojang.
              io.papermc.paper.util.PoiAccess.findAnyPoiPositions(poiManager, type -> type.is(PoiTypes.HOME), predicate, entity.blockPosition(), 48, PoiManager.Occupancy.ANY, false, Integer.MAX_VALUE, poiposes);
 +            // Kaiiju start - await on async path processing
-+            if (me.earthme.luminol.LuminolConfig.asyncPathProcessing) {
++            if (me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessing) {
 +                Path possiblePath = AcquirePoi.findPathToPois(entity, new java.util.HashSet<>(poiposes));
 +                dev.kaiijumc.kaiiju.path.AsyncPathProcessor.awaitProcessing(entity, possiblePath, path -> {
 +                    // read canReach check
@@ -1008,10 +1008,10 @@ index 8db20db72cd51046213625fac46c35854c59ec5d..d40e00a0a8726c920ea43aaa1ed68005
          }
      }
 diff --git a/src/main/java/net/minecraft/world/entity/animal/Bee.java b/src/main/java/net/minecraft/world/entity/animal/Bee.java
-index 25fd3aea2d66503018637781ccb8b5690c02e57b..3eb38f2ad12ee459dfaf0e9f917633c8db6d58e3 100644
+index 9f1791e60061934fc89a13258f3fab9f67f3a45c..489fab4847118b8ecb92e435d57d224104e7a3b6 100644
 --- a/src/main/java/net/minecraft/world/entity/animal/Bee.java
 +++ b/src/main/java/net/minecraft/world/entity/animal/Bee.java
-@@ -1077,7 +1077,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
+@@ -1084,7 +1084,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
                          } else {
                              Bee.this.pathfindRandomlyTowards(Bee.this.hivePos);
                          }
@@ -1020,7 +1020,7 @@ index 25fd3aea2d66503018637781ccb8b5690c02e57b..3eb38f2ad12ee459dfaf0e9f917633c8
                          boolean flag = this.pathfindDirectlyTowards(Bee.this.hivePos);
  
                          if (!flag) {
-@@ -1139,7 +1139,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
+@@ -1146,7 +1146,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal {
              } else {
                  Path pathentity = Bee.this.navigation.getPath();
  
@@ -1030,10 +1030,10 @@ index 25fd3aea2d66503018637781ccb8b5690c02e57b..3eb38f2ad12ee459dfaf0e9f917633c8
          }
      }
 diff --git a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java b/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java
-index c8e3d47b3f2dc919cca8ad397095437f1da6c762..dc7c35492c9481a45891ad32b45d7d46bc492461 100644
+index 295769d039f2a1e4f48912a60f9dbe267d8992c1..580da502c62ec5d669cb09932d99d1c7d711c965 100644
 --- a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java
 +++ b/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java
-@@ -390,6 +390,17 @@ public class Frog extends Animal implements VariantHolder<FrogVariant> {
+@@ -383,6 +383,17 @@ public class Frog extends Animal implements VariantHolder<FrogVariant> {
              super(frog, world);
          }
  
@@ -1051,12 +1051,12 @@ index c8e3d47b3f2dc919cca8ad397095437f1da6c762..dc7c35492c9481a45891ad32b45d7d46
          @Override
          public boolean canCutCorner(BlockPathTypes nodeType) {
              return nodeType != BlockPathTypes.WATER_BORDER && super.canCutCorner(nodeType);
-@@ -399,6 +410,11 @@ public class Frog extends Animal implements VariantHolder<FrogVariant> {
+@@ -392,6 +403,11 @@ public class Frog extends Animal implements VariantHolder<FrogVariant> {
          protected PathFinder createPathFinder(int range) {
              this.nodeEvaluator = new Frog.FrogNodeEvaluator(true);
              this.nodeEvaluator.setCanPassDoors(true);
 +            // Kaiiju start - petal - async path processing
-+            if (me.earthme.luminol.LuminolConfig.asyncPathProcessing)
++            if (me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessing)
 +                return new PathFinder(this.nodeEvaluator, range, nodeEvaluatorGenerator);
 +            else
 +            // Kaiiju end
@@ -1064,7 +1064,7 @@ index c8e3d47b3f2dc919cca8ad397095437f1da6c762..dc7c35492c9481a45891ad32b45d7d46
          }
      }
 diff --git a/src/main/java/net/minecraft/world/entity/monster/Drowned.java b/src/main/java/net/minecraft/world/entity/monster/Drowned.java
-index 991d728db2a3b64316fc2102cf3aee470327a62e..c99de04d082f7f9b08d25730460385c400b1b975 100644
+index 01897af1e6253b987734a24c052daf2ce1314092..b2f3f65caa92cfd9a8c65e617fde558506ca5a95 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/Drowned.java
 +++ b/src/main/java/net/minecraft/world/entity/monster/Drowned.java
 @@ -216,7 +216,6 @@ public class Drowned extends Zombie implements RangedAttackMob {
@@ -1085,7 +1085,7 @@ index 991d728db2a3b64316fc2102cf3aee470327a62e..c99de04d082f7f9b08d25730460385c4
  
              if (blockposition != null) {
 diff --git a/src/main/java/net/minecraft/world/entity/monster/Strider.java b/src/main/java/net/minecraft/world/entity/monster/Strider.java
-index 61162ecd43dc5e6f7898daecdec49f444e6d869b..26cdfe0dcf16c252648561f83e4d6a6757c0bd38 100644
+index 61162ecd43dc5e6f7898daecdec49f444e6d869b..864215e909224d180b47798e90a3c5846fa03dbd 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/Strider.java
 +++ b/src/main/java/net/minecraft/world/entity/monster/Strider.java
 @@ -563,10 +563,26 @@ public class Strider extends Animal implements ItemSteerable, Saddleable {
@@ -1108,7 +1108,7 @@ index 61162ecd43dc5e6f7898daecdec49f444e6d869b..26cdfe0dcf16c252648561f83e4d6a67
              this.nodeEvaluator = new WalkNodeEvaluator();
              this.nodeEvaluator.setCanPassDoors(true);
 +            // Kaiiju start - async path processing
-+            if (me.earthme.luminol.LuminolConfig.asyncPathProcessing)
++            if (me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessing)
 +                return new PathFinder(this.nodeEvaluator, range, nodeEvaluatorGenerator);
 +            else
 +            // Kaiiju end
@@ -1116,15 +1116,15 @@ index 61162ecd43dc5e6f7898daecdec49f444e6d869b..26cdfe0dcf16c252648561f83e4d6a67
          }
  
 diff --git a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java
-index 5e43912708f9074dee1bb351efa737a7e6796fc3..6b3279c74148e3e93364fe0859b543fba4e6933c 100644
+index 937f81a859953498abe73bea560c86e6560e1c33..7aadd36f0fe986635b495ab8c1426644620400cf 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java
 +++ b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java
-@@ -603,6 +603,16 @@ public class Warden extends Monster implements VibrationSystem {
+@@ -602,6 +602,16 @@ public class Warden extends Monster implements VibrationSystem {
              protected PathFinder createPathFinder(int range) {
                  this.nodeEvaluator = new WalkNodeEvaluator();
                  this.nodeEvaluator.setCanPassDoors(true);
 +                // Kaiiju start - petal - async path processing
-+                if (me.earthme.luminol.LuminolConfig.asyncPathProcessing)
++                if (me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessing)
 +                    return new PathFinder(this.nodeEvaluator, range, GroundPathNavigation.nodeEvaluatorGenerator) {
 +                        @Override
 +                        protected float distance(Node a, Node b) {
@@ -1137,10 +1137,10 @@ index 5e43912708f9074dee1bb351efa737a7e6796fc3..6b3279c74148e3e93364fe0859b543fb
                      @Override
                      protected float distance(Node a, Node b) {
 diff --git a/src/main/java/net/minecraft/world/level/block/ShulkerBoxBlock.java b/src/main/java/net/minecraft/world/level/block/ShulkerBoxBlock.java
-index d5fe3b8e2f5a8899f6afeb0600764284a617f261..4f15b9e4b1aba5375a2572ff28cea4e3d96eb82d 100644
+index 42407c5c0c09cd9d19bc7af92af8868bb038c686..39ed19562210f1329b22c630e667578473cda7cb 100644
 --- a/src/main/java/net/minecraft/world/level/block/ShulkerBoxBlock.java
 +++ b/src/main/java/net/minecraft/world/level/block/ShulkerBoxBlock.java
-@@ -238,6 +238,7 @@ public class ShulkerBoxBlock extends BaseEntityBlock {
+@@ -254,6 +254,7 @@ public class ShulkerBoxBlock extends BaseEntityBlock {
  
      @Override
      public VoxelShape getShape(BlockState state, BlockGetter world, BlockPos pos, CollisionContext context) {
@@ -1149,10 +1149,10 @@ index d5fe3b8e2f5a8899f6afeb0600764284a617f261..4f15b9e4b1aba5375a2572ff28cea4e3
          return blockEntity instanceof ShulkerBoxBlockEntity ? Shapes.create(((ShulkerBoxBlockEntity)blockEntity).getBoundingBox(state)) : Shapes.block();
      }
 diff --git a/src/main/java/net/minecraft/world/level/block/piston/MovingPistonBlock.java b/src/main/java/net/minecraft/world/level/block/piston/MovingPistonBlock.java
-index e941a4ce35c1bcc84836d04fb97cb1e7f292ae42..26f3c25f2dfda5f7c6213746efa8b883b655d2e1 100644
+index d3d1ad7901411574b85b0febd1c7ddaa8ad7c9f4..850065df2b95b0967660f246cd007bf9f53e26df 100644
 --- a/src/main/java/net/minecraft/world/level/block/piston/MovingPistonBlock.java
 +++ b/src/main/java/net/minecraft/world/level/block/piston/MovingPistonBlock.java
-@@ -102,6 +102,7 @@ public class MovingPistonBlock extends BaseEntityBlock {
+@@ -110,6 +110,7 @@ public class MovingPistonBlock extends BaseEntityBlock {
  
      @Override
      public VoxelShape getCollisionShape(BlockState state, BlockGetter world, BlockPos pos, CollisionContext context) {
@@ -1161,7 +1161,7 @@ index e941a4ce35c1bcc84836d04fb97cb1e7f292ae42..26f3c25f2dfda5f7c6213746efa8b883
          return pistonMovingBlockEntity != null ? pistonMovingBlockEntity.getCollisionShape(world, pos) : Shapes.empty();
      }
 diff --git a/src/main/java/net/minecraft/world/level/pathfinder/Path.java b/src/main/java/net/minecraft/world/level/pathfinder/Path.java
-index eea4c932d909145e7af848cf76e3f49dbb2deff2..7160459ec8ba81f66a85082a1fe7b06377180afa 100644
+index 3049edb5a8b5967e5242a3896b23665888eb3472..0da9acd785cf785d82be7aab0a1e2bfd70c62998 100644
 --- a/src/main/java/net/minecraft/world/level/pathfinder/Path.java
 +++ b/src/main/java/net/minecraft/world/level/pathfinder/Path.java
 @@ -27,6 +27,17 @@ public class Path {
@@ -1191,7 +1191,7 @@ index eea4c932d909145e7af848cf76e3f49dbb2deff2..7160459ec8ba81f66a85082a1fe7b063
              return false;
          } else if (o.nodes.size() != this.nodes.size()) {
 diff --git a/src/main/java/net/minecraft/world/level/pathfinder/PathFinder.java b/src/main/java/net/minecraft/world/level/pathfinder/PathFinder.java
-index d23481453717f715124156b5d83f6448f720d049..d806d941fe0610d84a50cf4c2051fb26b612efa8 100644
+index 8aa4ac3a6affbe888d6084a27b668c58dfda6c79..d8f443af840b1a4b1d2868fefd87d70dad55a764 100644
 --- a/src/main/java/net/minecraft/world/level/pathfinder/PathFinder.java
 +++ b/src/main/java/net/minecraft/world/level/pathfinder/PathFinder.java
 @@ -24,37 +24,80 @@ public class PathFinder {
@@ -1218,7 +1218,7 @@ index d23481453717f715124156b5d83f6448f720d049..d806d941fe0610d84a50cf4c2051fb26
 -        this.openSet.clear();
 -        this.nodeEvaluator.prepare(world, mob);
 -        Node node = this.nodeEvaluator.getStart();
-+        if(!me.earthme.luminol.LuminolConfig.asyncPathProcessing) this.openSet.clear(); // Kaiiju - petal - it's always cleared in processPath
++        if(!me.earthme.luminol.config.modules.optimizations.AsyncPathProcessingConfig.asyncPathProcessing) this.openSet.clear(); // Kaiiju - petal - it's always cleared in processPath
 +        // Kaiiju start - petal - use a generated evaluator if we have one otherwise run sync
 +        NodeEvaluator nodeEvaluator = this.nodeEvaluatorGenerator == null
 +                      ? this.nodeEvaluator
@@ -1230,13 +1230,13 @@ index d23481453717f715124156b5d83f6448f720d049..d806d941fe0610d84a50cf4c2051fb26
 +            dev.kaiijumc.kaiiju.path.NodeEvaluatorCache.removeNodeEvaluator(nodeEvaluator); // Kaiiju - petal - handle nodeEvaluatorGenerator
              return null;
          } else {
-             // Paper start - remove streams - and optimize collection
+             // Paper start - Perf: remove streams and optimize collection
              List<Map.Entry<Target, BlockPos>> map = Lists.newArrayList();
              for (BlockPos pos : positions) {
 -                map.add(new java.util.AbstractMap.SimpleEntry<>(this.nodeEvaluator.getGoal(pos.getX(), pos.getY(), pos.getZ()), pos));
 +                map.add(new java.util.AbstractMap.SimpleEntry<>(nodeEvaluator.getGoal(pos.getX(), pos.getY(), pos.getZ()), pos)); // Kaiiju - petal - handle nodeEvaluatorGenerator
              }
-             // Paper end
+             // Paper end - Perf: remove streams and optimize collection
 -            Path path = this.findPath(world.getProfiler(), node, map, followRange, distance, rangeMultiplier);
 -            this.nodeEvaluator.done();
 -            return path;
@@ -1264,7 +1264,7 @@ index d23481453717f715124156b5d83f6448f720d049..d806d941fe0610d84a50cf4c2051fb26
  
 -    @Nullable
 +    //@Nullable // Kaiiju - Always not null
-     // Paper start - optimize collection
+     // Paper start - Perf: remove streams and optimize collection
      private Path findPath(ProfilerFiller profiler, Node startNode, List<Map.Entry<Target, BlockPos>> positions, float followRange, int distance, float rangeMultiplier) {
          profiler.push("find_path");
          profiler.markForCharting(MetricCategory.PATH_FINDING);
@@ -1293,13 +1293,13 @@ index d23481453717f715124156b5d83f6448f720d049..d806d941fe0610d84a50cf4c2051fb26
  
                  for(int l = 0; l < k; ++l) {
                      Node node2 = this.neighbors[l];
-@@ -123,6 +166,7 @@ public class PathFinder {
+@@ -123,7 +166,6 @@ public class PathFinder {
              if (best == null || comparator.compare(path, best) < 0)
                  best = path;
          }
-+        //noinspection ConstantConditions // Kaiiju - petal - ignore this warning, we know that the above loop always runs at least once since positions is not empty
+-        profiler.pop();
          return best;
-         // Paper end
+         // Paper end - Perf: remove streams and optimize collection
      }
 diff --git a/src/main/java/net/minecraft/world/level/pathfinder/SwimNodeEvaluator.java b/src/main/java/net/minecraft/world/level/pathfinder/SwimNodeEvaluator.java
 index 0e2b14e7dfedf209d63279c81723fd7955122d78..079b278e2e262af433bb5bd0c12b3d8db4fa12fc 100644

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

@@ -0,0 +1,52 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 04:46:30 +0000
+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";
++    }
++}
+diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
+index 67210fc018349ab0a79740dee140fb60c82c431a..b90865dbfb3a4bd83e4cd3ba3b5b965036039f98 100644
+--- a/src/main/java/net/minecraft/world/entity/Mob.java
++++ b/src/main/java/net/minecraft/world/entity/Mob.java
+@@ -927,10 +927,11 @@ public abstract class Mob extends LivingEntity implements Targeting {
+             return;
+         }
+         // Paper end - Allow nerfed mobs to jump and float
++        int i = this.tickCount + this.getId(); // Folia - region threading //Luminol - Petal - Move up
++
+         this.level().getProfiler().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
+         this.level().getProfiler().pop();
+-        int i = this.tickCount + this.getId(); // Folia - region threading
+ 
+         if (i % 2 != 0 && this.tickCount > 1) {
+             this.level().getProfiler().push("targetSelector");

patches/server/0024-Pufferfish-Optimize-entity-coordinate-key.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Pufferfish Optimize entity coordinate key
 
 
 diff --git a/src/main/java/io/papermc/paper/util/MCUtil.java b/src/main/java/io/papermc/paper/util/MCUtil.java
-index 8f91b7f44baaf62b829a81afc0633311e6c13f19..a149d98be7b4744f18d4ed4940881e13a76e4a7c 100644
+index 08d282400644be5949f28eb879b333cc221da2cc..49ccb27a17bec1d4ff31bc8d72e4724d65adc20c 100644
 --- a/src/main/java/io/papermc/paper/util/MCUtil.java
 +++ b/src/main/java/io/papermc/paper/util/MCUtil.java
-@@ -213,7 +213,7 @@ public final class MCUtil {
+@@ -215,7 +215,7 @@ public final class MCUtil {
      }
  
      public static long getCoordinateKey(final Entity entity) {

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

@@ -1,14 +1,14 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 16:00:17 +0800
+From: MrHua269 <novau233@163.com>
+Date: Sun, 14 Jan 2024 00:40:35 +0000
 Subject: [PATCH] Pufferfish Cache climbing check for activation
 
 
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index cb32a3851a315f1f1b4fb6d26fdffbcb471bfc06..3c9ec0f5fef49b0abc42382551de11ab942b3b20 100644
+index d955a555d260d39812b84eb5319db619ec0f8d28..7834646fd6a894ff85973566d9aeda98e5b0c284 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -308,7 +308,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+@@ -311,7 +311,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
      public double yo;
      public double zo;
      private Vec3 position;
@@ -18,10 +18,10 @@ index cb32a3851a315f1f1b4fb6d26fdffbcb471bfc06..3c9ec0f5fef49b0abc42382551de11ab
      private Vec3 deltaMovement;
      private float yRot;
 diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 82996d0c2891871bd6ef9ff81aef123add08ebda..51dee7adc0dc534fac66bf3e8709865157dd763b 100644
+index fdb5ef574c14fafa1af50f4f656763119695f00e..bbfbeddcba884ae1964f7421fcdf179923bd0d2b 100644
 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
 +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -142,7 +142,6 @@ import org.bukkit.event.entity.EntityTeleportEvent;
+@@ -143,7 +143,6 @@ import org.bukkit.event.entity.EntityTeleportEvent;
  import org.bukkit.event.player.PlayerItemConsumeEvent;
  // CraftBukkit end
  
@@ -29,7 +29,7 @@ index 82996d0c2891871bd6ef9ff81aef123add08ebda..51dee7adc0dc534fac66bf3e87098651
  
  public abstract class LivingEntity extends Entity implements Attackable {
  
-@@ -2006,6 +2005,20 @@ public abstract class LivingEntity extends Entity implements Attackable {
+@@ -2043,6 +2042,20 @@ public abstract class LivingEntity extends Entity implements Attackable {
          return this.lastClimbablePos;
      }
  
@@ -51,15 +51,15 @@ index 82996d0c2891871bd6ef9ff81aef123add08ebda..51dee7adc0dc534fac66bf3e87098651
          if (this.isSpectator()) {
              return false;
 diff --git a/src/main/java/org/spigotmc/ActivationRange.java b/src/main/java/org/spigotmc/ActivationRange.java
-index d88988200016c1a3cc76c017dfb7deabf6fc17af..22daed525b023998a05884db603e2c7385ce0873 100644
+index f8718d91f4c15c74d6e6dd5f60f7f05f45f63655..50fafff765b2494c075784cc5342d086c8dc97b2 100644
 --- a/src/main/java/org/spigotmc/ActivationRange.java
 +++ b/src/main/java/org/spigotmc/ActivationRange.java
 @@ -305,7 +305,7 @@ public class ActivationRange
          if ( entity instanceof LivingEntity )
          {
              LivingEntity living = (LivingEntity) entity;
--            if ( living.onClimbable() || living.jumping || living.hurtTime > 0 || living.activeEffects.size() > 0 ) // Paper
-+            if ( living.onClimableCached() || living.jumping || living.hurtTime > 0 || living.activeEffects.size() > 0 ) // Paper // Pufferfish - use cached
+-            if ( living.onClimbable() || living.jumping || living.hurtTime > 0 || living.activeEffects.size() > 0 || living.isFreezing()) // Paper
++            if ( living.onClimableCached() || living.jumping || living.hurtTime > 0 || living.activeEffects.size() > 0 || living.isFreezing()) // Paper // Pufferfish - use cached
              {
                  return 1; // Paper
              }

patches/server/0026-Pufferfish-Improve-fluid-direction-caching.patch

@@ -147,7 +147,7 @@ index 0000000000000000000000000000000000000000..aa8467b9dda1f7707e41f50ac7b3e9d7
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/world/level/material/FlowingFluid.java b/src/main/java/net/minecraft/world/level/material/FlowingFluid.java
-index e21f4c5aff3a8e97101f6efc1349fbecf326b5ea..c55f51e6db55f9fa66f53eef0e7a56af5f81d742 100644
+index 6d8ff6c06af5545634f255ed17dc1e489ece2548..6411aa4ff6bd4cabb25c426fa8f4a7eedb969c03 100644
 --- a/src/main/java/net/minecraft/world/level/material/FlowingFluid.java
 +++ b/src/main/java/net/minecraft/world/level/material/FlowingFluid.java
 @@ -45,6 +45,8 @@ public abstract class FlowingFluid extends Fluid {
@@ -174,7 +174,7 @@ index e21f4c5aff3a8e97101f6efc1349fbecf326b5ea..c55f51e6db55f9fa66f53eef0e7a56af
      private final Map<FluidState, VoxelShape> shapes = Maps.newIdentityHashMap();
  
      public FlowingFluid() {}
-@@ -252,6 +262,8 @@ public abstract class FlowingFluid extends Fluid {
+@@ -251,6 +261,8 @@ public abstract class FlowingFluid extends Fluid {
              return false;
          }
          // Paper end - optimise collisions
@@ -183,7 +183,7 @@ index e21f4c5aff3a8e97101f6efc1349fbecf326b5ea..c55f51e6db55f9fa66f53eef0e7a56af
          Object2ByteLinkedOpenHashMap object2bytelinkedopenhashmap;
  
          if (!state.getBlock().hasDynamicShape() && !fromState.getBlock().hasDynamicShape()) {
-@@ -259,9 +271,16 @@ public abstract class FlowingFluid extends Fluid {
+@@ -258,9 +270,16 @@ public abstract class FlowingFluid extends Fluid {
          } else {
              object2bytelinkedopenhashmap = null;
          }
@@ -200,7 +200,7 @@ index e21f4c5aff3a8e97101f6efc1349fbecf326b5ea..c55f51e6db55f9fa66f53eef0e7a56af
          if (object2bytelinkedopenhashmap != null) {
              block_a = new Block.BlockStatePairKey(state, fromState, face);
              byte b0 = object2bytelinkedopenhashmap.getAndMoveToFirst(block_a);
-@@ -272,11 +291,22 @@ public abstract class FlowingFluid extends Fluid {
+@@ -271,11 +290,22 @@ public abstract class FlowingFluid extends Fluid {
          } else {
              block_a = null;
          }
@@ -223,7 +223,7 @@ index e21f4c5aff3a8e97101f6efc1349fbecf326b5ea..c55f51e6db55f9fa66f53eef0e7a56af
          if (object2bytelinkedopenhashmap != null) {
              if (object2bytelinkedopenhashmap.size() == 200) {
                  object2bytelinkedopenhashmap.removeLastByte();
-@@ -284,6 +314,11 @@ public abstract class FlowingFluid extends Fluid {
+@@ -283,6 +313,11 @@ public abstract class FlowingFluid extends Fluid {
  
              object2bytelinkedopenhashmap.putAndMoveToFirst(block_a, (byte) (flag ? 1 : 0));
          }

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

@@ -1,43 +1,40 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 16:05:32 +0800
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 04:55:43 +0000
 Subject: [PATCH] Pufferfish Optimize suffocation
 
 
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index 0929a5a167691bde7dedaa1e2812b34ad69913d6..de0855656ad3882b182aa5674fd0117288268e71 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -42,6 +42,7 @@ public class LuminolConfig {
-     public static int linearFlushThreads = 1;
- 
-     public static boolean reduceSensorWork = true;
-+    public static boolean enableSuffocationOptimization = true;
- 
-     public static void init() throws IOException {
-         PARENT_FOLDER.mkdir();
-@@ -104,6 +105,7 @@ public class LuminolConfig {
-             linearFlushThreads = Math.max(linearFlushThreads, 1);
- 
-         reduceSensorWork = get("optimizations.reduce_sensor_work",reduceSensorWork,"This optimization is from petal.You can find out more about it on petal's repository");
-+        enableSuffocationOptimization = get("optimizations.optimize_suffocation_check",enableSuffocationOptimization);
-     }
- 
-     public static <T> T get(String key,T def){
+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";
++    }
++}
 diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index 51dee7adc0dc534fac66bf3e8709865157dd763b..f13d26b280f095d006ffccb36af66bb7487cb8da 100644
+index bbfbeddcba884ae1964f7421fcdf179923bd0d2b..df789b13f57200c66ff4cc59e6b63949a6804e3d 100644
 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
 +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -19,6 +19,8 @@ import java.util.Optional;
- import java.util.UUID;
- import java.util.function.Predicate;
- import javax.annotation.Nullable;
-+
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.BlockUtil;
- import net.minecraft.advancements.CriteriaTriggers;
- import net.minecraft.commands.arguments.EntityAnchorArgument;
-@@ -420,7 +422,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+@@ -428,7 +428,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
              boolean flag = this instanceof net.minecraft.world.entity.player.Player;
  
              if (!this.level().isClientSide) {
@@ -46,7 +43,7 @@ index 51dee7adc0dc534fac66bf3e8709865157dd763b..f13d26b280f095d006ffccb36af66bb7
                      this.hurt(this.damageSources().inWall(), 1.0F);
                  } else if (flag && !this.level().getWorldBorder().isWithinBounds(this.getBoundingBox())) {
                      double d0 = this.level().getWorldBorder().getDistanceToBorder(this) + this.level().getWorldBorder().getDamageSafeZone();
-@@ -1410,6 +1412,19 @@ public abstract class LivingEntity extends Entity implements Attackable {
+@@ -1436,6 +1436,19 @@ public abstract class LivingEntity extends Entity implements Attackable {
          return this.getHealth() <= 0.0F;
      }
  
@@ -59,7 +56,7 @@ index 51dee7adc0dc534fac66bf3e8709865157dd763b..f13d26b280f095d006ffccb36af66bb7
 +    }
 +
 +    public boolean shouldCheckForSuffocation() {
-+        return !LuminolConfig.enableSuffocationOptimization || (tickCount % 10 == 0 && couldPossiblyBeHurt(1.0F));
++        return !me.earthme.luminol.config.modules.optimizations.SuffocationOptimizationConfig.enabled || (tickCount % 10 == 0 && couldPossiblyBeHurt(1.0F));
 +    }
 +    // Pufferfish end
 +
@@ -67,10 +64,10 @@ index 51dee7adc0dc534fac66bf3e8709865157dd763b..f13d26b280f095d006ffccb36af66bb7
      public boolean hurt(DamageSource source, float amount) {
          if (this.isInvulnerableTo(source)) {
 diff --git a/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java b/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java
-index 1e07febcf7a3dfb281728cc5e3e4f15dd776d7e0..c65ab566c6241dd6a44bd11a449ef0c4b2f6dc65 100644
+index 12440ee2dccc0a697fb403765f2e1b987ccc0283..de2471cfa96a23944f229f33ffdff88b6b7756e4 100644
 --- a/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java
 +++ b/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java
-@@ -150,6 +150,13 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob
+@@ -151,6 +151,13 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob
          this.bossEvent.setName(this.getDisplayName());
      }
  

patches/server/0028-Pufferfish-Early-return-optimization-for-target-find.patch

@@ -1,11 +1,11 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 16:07:30 +0800
+From: MrHua269 <novau233@163.com>
+Date: Tue, 6 Feb 2024 03:17:39 +0000
 Subject: [PATCH] Pufferfish Early return optimization for target finding
 
 
 diff --git a/src/main/java/net/minecraft/world/entity/ai/targeting/TargetingConditions.java b/src/main/java/net/minecraft/world/entity/ai/targeting/TargetingConditions.java
-index c157309ac78e7af084d3acb6e8b2bcd469a39d5e..ac5e5676b194a2a99e5cf53eb89c1152cac963b8 100644
+index c8a80c1b2fedff22e8a877d466062375ffb2f0d7..3c4f4af85a3f2d4f9f52827164e63727b916c33a 100644
 --- a/src/main/java/net/minecraft/world/entity/ai/targeting/TargetingConditions.java
 +++ b/src/main/java/net/minecraft/world/entity/ai/targeting/TargetingConditions.java
 @@ -75,9 +75,18 @@ public class TargetingConditions {
@@ -13,7 +13,7 @@ index c157309ac78e7af084d3acb6e8b2bcd469a39d5e..ac5e5676b194a2a99e5cf53eb89c1152
  
                  if (this.range > 0.0D) {
 -                    double d = this.testInvisible ? targetEntity.getVisibilityPercent(baseEntity) : 1.0D;
--                    double e = Math.max((this.useFollowRange ? this.getFollowRange(baseEntity) : this.range) * d, 2.0D); // Paper
+-                    double e = Math.max((this.useFollowRange ? this.getFollowRange(baseEntity) : this.range) * d, 2.0D); // Paper - Fix MC-145656
 +                    // Pufferfish start - check range before getting visibility
 +                    // d = invisibility percent, e = follow range adjusted for invisibility, f = distance
                      double f = baseEntity.distanceToSqr(targetEntity.getX(), targetEntity.getY(), targetEntity.getZ());

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

@@ -1,87 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 16:30:24 +0800
-Subject: [PATCH] Pufferfish Entity TTL
-
-
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index de0855656ad3882b182aa5674fd0117288268e71..d0c0b4daec59f23a989a8b8f66ea3c704b0e309c 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -4,13 +4,16 @@ import dev.kaiijumc.kaiiju.region.RegionFileFormat;
- import com.electronwill.nightconfig.core.file.CommentedFileConfig;
- import me.earthme.luminol.commands.TpsBarCommand;
- import me.earthme.luminol.functions.GlobalServerTpsBar;
-+import net.minecraft.core.registries.BuiltInRegistries;
- import net.minecraft.server.level.ServerLevel;
-+import net.minecraft.world.entity.EntityType;
- import org.apache.logging.log4j.LogManager;
- import org.apache.logging.log4j.Logger;
- import org.bukkit.Bukkit;
- 
- import java.util.Arrays;
- import java.util.List;
-+import java.util.Locale;
- import java.util.logging.Level;
- import java.io.File;
- import java.io.IOException;
-@@ -65,6 +68,22 @@ public class LuminolConfig {
-         }
-     }
- 
-+    private static void initEntityTTL() {
-+        // Set some defaults
-+        get("optimizations.entity_timeouts.SNOWBALL", -1);
-+        get("optimizations.entity_timeouts.LLAMA_SPIT", -1);
-+        MAIN_CONFIG.setComment("optimizations.entity_timeouts",
-+                """
-+                        These values define a entity's maximum lifespan. If an
-+                        entity is in this list and it has survived for longer than
-+                        that number of ticks, then it will be removed. Setting a value to
-+                        -1 disables this feature.""");
-+        for (EntityType<?> entityType : BuiltInRegistries.ENTITY_TYPE) {
-+            String type = EntityType.getKey(entityType).getPath().toUpperCase(Locale.ROOT);
-+            entityType.ttl = get("optimizations.entity_timeouts." + type, -1);
-+        }
-+    }
-+
-     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");
-@@ -106,6 +125,7 @@ public class LuminolConfig {
- 
-         reduceSensorWork = get("optimizations.reduce_sensor_work",reduceSensorWork,"This optimization is from petal.You can find out more about it on petal's repository");
-         enableSuffocationOptimization = get("optimizations.optimize_suffocation_check",enableSuffocationOptimization);
-+        initEntityTTL();
-     }
- 
-     public static <T> T get(String key,T def){
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 967c7a953084dc68a0ecd4b1a0f13ead7e72cb3d..8bdaab46c2e128aa58d13101170ce358146377a8 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -798,6 +798,12 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
-     }
- 
-     public void tick() {
-+        // Pufferfish start - entity TTL
-+        if (type != EntityType.PLAYER && type.ttl >= 0 && this.tickCount >= type.ttl) {
-+            discard();
-+            return;
-+        }
-+        // Pufferfish end - entity TTL
-         this.baseTick();
-     }
- 
-diff --git a/src/main/java/net/minecraft/world/entity/EntityType.java b/src/main/java/net/minecraft/world/entity/EntityType.java
-index 3f3494c20cd15a721090f1b36293562a6b834b14..4d60ac50a1d3860f2a2e9265aef9507d790220a3 100644
---- a/src/main/java/net/minecraft/world/entity/EntityType.java
-+++ b/src/main/java/net/minecraft/world/entity/EntityType.java
-@@ -309,6 +309,7 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
-     private ResourceLocation lootTable;
-     private final EntityDimensions dimensions;
-     private final FeatureFlagSet requiredFeatures;
-+    public int ttl = -1; // Pufferfish
- 
-     private static <T extends Entity> EntityType<T> register(String id, EntityType.Builder type) { // CraftBukkit - decompile error
-         return (EntityType) Registry.register(BuiltInRegistries.ENTITY_TYPE, id, (EntityType<T>) type.build(id)); // CraftBukkit - decompile error

patches/server/0029-Pufferfish-Reduce-chunk-loading-lookups.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Pufferfish Reduce chunk loading & lookups
 
 
 diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
-index bd5996eef2d946e9d7765b6b315bc5951158810e..0d51f435f18f3f9d59a3241a0b7fa1c4af841b72 100644
+index f33c03e81b7ff643741f56eea055e6af260de618..6563e625ebae47fc68e5010d36bd4b4d327c07b7 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
 +++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
 @@ -333,11 +333,17 @@ public class EnderMan extends Monster implements NeutralMob {

patches/server/0030-Pufferfish-Fix-Paper-6045-block-goal-shouldn-t-load-.patch

@@ -1,18 +1,18 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 16:09:27 +0800
+From: MrHua269 <novau233@163.com>
+Date: Tue, 6 Feb 2024 03:21:56 +0000
 Subject: [PATCH] Pufferfish Fix Paper#6045, block goal shouldn't load chunks
 
 
 diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/MoveToBlockGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/MoveToBlockGoal.java
-index 34f319ad09276c6f68dde449c79351de0d7d86f5..a719af0b512d9ef243d0d54f3b744b1b1a5f2772 100644
+index 07519c817cc6de04a98198c43a0c2b02ba3141eb..ee66be6e5aa45ec8448b6d30785a6e71200b09e3 100644
 --- a/src/main/java/net/minecraft/world/entity/ai/goal/MoveToBlockGoal.java
 +++ b/src/main/java/net/minecraft/world/entity/ai/goal/MoveToBlockGoal.java
-@@ -119,6 +119,7 @@ public abstract class MoveToBlockGoal extends Goal {
+@@ -120,6 +120,7 @@ public abstract class MoveToBlockGoal extends Goal {
                  for(int m = 0; m <= l; m = m > 0 ? -m : 1 - m) {
                      for(int n = m < l && m > -l ? l : 0; n <= l; n = n > 0 ? -n : 1 - n) {
                          mutableBlockPos.setWithOffset(blockPos, m, k - 1, n);
 +                        if (!this.mob.level().hasChunkAt(mutableBlockPos)) continue; // Pufferfish - if this block isn't loaded, continue
                          if (this.mob.isWithinRestriction(mutableBlockPos) && this.isValidTarget(this.mob.level(), mutableBlockPos)) {
                              this.blockPos = mutableBlockPos;
-                             setTargetPosition(mutableBlockPos.immutable()); // Paper
+                             this.mob.movingTarget = mutableBlockPos == BlockPos.ZERO ? null : mutableBlockPos.immutable(); // Paper

patches/server/0031-Pufferfish-Reduce-entity-fluid-lookups-if-no-fluids.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Pufferfish Reduce entity fluid lookups if no fluids
 
 
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 3c9ec0f5fef49b0abc42382551de11ab942b3b20..967c7a953084dc68a0ecd4b1a0f13ead7e72cb3d 100644
+index 7834646fd6a894ff85973566d9aeda98e5b0c284..21284dba89c8adbb46086afd9a900fb24ba3e3ea 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -5132,16 +5132,18 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+@@ -5262,16 +5262,18 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
      }
  
      public boolean updateFluidHeightAndDoFluidPushing(TagKey<Fluid> tag, double speed) {
@@ -34,7 +34,7 @@ index 3c9ec0f5fef49b0abc42382551de11ab942b3b20..967c7a953084dc68a0ecd4b1a0f13ead
              double d1 = 0.0D;
              boolean flag = this.isPushedByFluid();
              boolean flag1 = false;
-@@ -5149,14 +5151,61 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+@@ -5279,14 +5281,61 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
              int k1 = 0;
              BlockPos.MutableBlockPos blockposition_mutableblockposition = new BlockPos.MutableBlockPos();
  
@@ -102,7 +102,7 @@ index 3c9ec0f5fef49b0abc42382551de11ab942b3b20..967c7a953084dc68a0ecd4b1a0f13ead
  
                              if (d2 >= axisalignedbb.minY) {
                                  flag1 = true;
-@@ -5178,9 +5227,12 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+@@ -5308,9 +5357,12 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
                                  // CraftBukkit end
                              }
                          }
@@ -116,7 +116,7 @@ index 3c9ec0f5fef49b0abc42382551de11ab942b3b20..967c7a953084dc68a0ecd4b1a0f13ead
              if (vec3d.length() > 0.0D) {
                  if (k1 > 0) {
 diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
-index f0de72afad4bb571153436399386a6a8a70582a6..45b7527341fcb6d24f35318cedb522646b5ee1c2 100644
+index 796bbef3544e06b8e7aac7e8ac5f740a2613f4bd..2422ca3ffc6ab7178cacf933b8013f85e7de4bd9 100644
 --- a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
 +++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
 @@ -25,6 +25,7 @@ public class LevelChunkSection {
@@ -143,11 +143,11 @@ index f0de72afad4bb571153436399386a6a8a70582a6..45b7527341fcb6d24f35318cedb52264
          }
  
          this.updateBlockCallback(x, y, z, iblockdata1, state); // Paper - optimise collisions
-@@ -161,6 +164,7 @@ public class LevelChunkSection {
-                 if (fluid.isRandomlyTicking()) {
-                     this.tickingFluidCount = (short) (this.tickingFluidCount + 1);
-                 }
+@@ -162,6 +165,7 @@ public class LevelChunkSection {
+                     if (fluid.isRandomlyTicking()) {
+                         this.tickingFluidCount = (short) (this.tickingFluidCount + 1);
+                     }
 +                this.fluidStateCount++; // Pufferfish
-             }
+                 }
  
-             // Paper start - optimise collisions
+                 // Paper start - optimise collisions

patches/server/0032-Pufferfish-Only-check-for-spooky-season-once-an-hour.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Pufferfish Only check for spooky season once an hour
 
 
 diff --git a/src/main/java/net/minecraft/world/entity/ambient/Bat.java b/src/main/java/net/minecraft/world/entity/ambient/Bat.java
-index 5beaa849a250ea005733250ad3edfa8382224667..2028ae6cc50d86c579ec062536e8c6339196ce09 100644
+index 44fa2d4f90389f5526746bd94a2450c03340bd0b..864c3c72b6881a2a8223a9aa5a593f1a65bcc857 100644
 --- a/src/main/java/net/minecraft/world/entity/ambient/Bat.java
 +++ b/src/main/java/net/minecraft/world/entity/ambient/Bat.java
 @@ -3,6 +3,10 @@ package net.minecraft.world.entity.ambient;
@@ -19,7 +19,7 @@ index 5beaa849a250ea005733250ad3edfa8382224667..2028ae6cc50d86c579ec062536e8c633
  import net.minecraft.core.BlockPos;
  import net.minecraft.nbt.CompoundTag;
  import net.minecraft.network.syncher.EntityDataAccessor;
-@@ -237,13 +241,25 @@ public class Bat extends AmbientCreature {
+@@ -241,13 +245,25 @@ public class Bat extends AmbientCreature {
          }
      }
  

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

@@ -0,0 +1,79 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 05:19:37 +0000
+Subject: [PATCH] Pufferfish Entity TTL
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/optimizations/EntityTTLOptimizationConfig.java b/src/main/java/me/earthme/luminol/config/modules/optimizations/EntityTTLOptimizationConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..15697d69659b6e1e776acf5094684b5f0c079b57
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/optimizations/EntityTTLOptimizationConfig.java
+@@ -0,0 +1,38 @@
++package me.earthme.luminol.config.modules.optimizations;
++
++import com.electronwill.nightconfig.core.file.CommentedFileConfig;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++import net.minecraft.core.registries.BuiltInRegistries;
++import net.minecraft.world.entity.EntityType;
++
++import java.util.Locale;
++
++public class EntityTTLOptimizationConfig implements IConfigModule {
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.OPTIMIZATIONS;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "entity_time_outs";
++    }
++
++    @Override
++    public void onLoaded(CommentedFileConfig config) {
++        // Set some defaults
++        this.get("optimizations.entity_timeouts.SNOWBALL", -1,config);
++        this.get("optimizations.entity_timeouts.LLAMA_SPIT", -1,config);
++        config.setComment("optimizations.entity_timeouts",
++                """
++                        These values define a entity's maximum lifespan. If an
++                        entity is in this list and it has survived for longer than
++                        that number of ticks, then it will be removed. Setting a value to
++                        -1 disables this feature.""");
++        for (EntityType<?> entityType : BuiltInRegistries.ENTITY_TYPE) {
++            String type = EntityType.getKey(entityType).getPath().toUpperCase(Locale.ROOT);
++            entityType.ttl = this.get("optimizations.entity_timeouts." + type, -1,config);
++        }
++    }
++}
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 21284dba89c8adbb46086afd9a900fb24ba3e3ea..f8a410e9ed04d9a78d1a6a7e63673b1863d715f2 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -814,6 +814,12 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+     }
+ 
+     public void tick() {
++        // Pufferfish start - entity TTL
++        if (type != EntityType.PLAYER && type.ttl >= 0 && this.tickCount >= type.ttl) {
++            discard();
++            return;
++        }
++        // Pufferfish end - entity TTL
+         this.baseTick();
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/EntityType.java b/src/main/java/net/minecraft/world/entity/EntityType.java
+index f921c159c4f7556daf3c8405241de3607ba251ad..8deae3e95a26f4b42b2c2134e22f9649bd7a5391 100644
+--- a/src/main/java/net/minecraft/world/entity/EntityType.java
++++ b/src/main/java/net/minecraft/world/entity/EntityType.java
+@@ -313,6 +313,7 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
+     private ResourceLocation lootTable;
+     private final EntityDimensions dimensions;
+     private final FeatureFlagSet requiredFeatures;
++    public int ttl = -1; // Pufferfish
+ 
+     private static <T extends Entity> EntityType<T> register(String id, EntityType.Builder type) { // CraftBukkit - decompile error
+         return (EntityType) Registry.register(BuiltInRegistries.ENTITY_TYPE, id, (EntityType<T>) type.build(id)); // CraftBukkit - decompile error

patches/server/0034-Gale-Reduce-acquire-POI-for-stuck-entities.patch

@@ -1,90 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 17:30:32 +0800
-Subject: [PATCH] Gale Reduce acquire POI for stuck entities
-
-
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index fcd532898e099a809969603941b90fdd415b03c3..d032786938db9725e1be72dae63a1387bcb69d79 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -12,14 +12,10 @@ import org.apache.logging.log4j.Logger;
- import org.bukkit.Bukkit;
- 
- import java.util.*;
--import java.util.logging.Level;
- import java.io.File;
- import java.io.IOException;
- 
--import net.minecraft.core.registries.BuiltInRegistries;
- import net.minecraft.server.MinecraftServer;
--import org.bukkit.configuration.ConfigurationSection;
--import net.minecraft.world.entity.EntityType;
- 
- public class LuminolConfig {
-     private static final Logger logger = LogManager.getLogger();
-@@ -58,6 +54,7 @@ public class LuminolConfig {
-     public static int activationDistanceMod;
-     public static double entityWakeUpDurationRatioStandardDeviation = 0.2;
-     public static boolean loadChunksToActiveClimbingEntities = false;
-+    public static int acquirePoiForStuckEntityInterval = 60;
- 
- 
-     public static void init() throws IOException {
-@@ -171,6 +168,7 @@ public class LuminolConfig {
-         initDAB();
-         entityWakeUpDurationRatioStandardDeviation = get("optimizations.entity_wakeup_duration_ratio_standard_deviation",entityWakeUpDurationRatioStandardDeviation);
-         loadChunksToActiveClimbingEntities = get("optimizations.load_chunks_to_active_climbing_entities",loadChunksToActiveClimbingEntities);
-+        acquirePoiForStuckEntityInterval = get("optimizations.acquire_poi_for_stuck_entity_interval", acquirePoiForStuckEntityInterval);
-     }
- 
-     public static <T> T get(String key,T def){
-diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java b/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java
-index 8f8b29f80d1573981ccffd207dd6e0941e71a352..ba4cdaf499c7ffef0c7fbdd575bdba841bcb7282 100644
---- a/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java
-@@ -7,12 +7,14 @@ import java.util.HashSet;
- import java.util.Optional;
- import java.util.Set;
- import java.util.function.Predicate;
--import java.util.stream.Collectors;
- import javax.annotation.Nullable;
-+
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.core.BlockPos;
- import net.minecraft.core.GlobalPos;
- import net.minecraft.core.Holder;
- import net.minecraft.network.protocol.game.DebugPackets;
-+import net.minecraft.server.level.ServerLevel;
- import net.minecraft.util.RandomSource;
- import net.minecraft.world.entity.Mob;
- import net.minecraft.world.entity.PathfinderMob;
-@@ -26,6 +28,13 @@ import org.apache.commons.lang3.mutable.MutableLong;
- public class AcquirePoi {
-     public static final int SCAN_RANGE = 48;
- 
-+    // Gale start - Airplane - reduce acquire POI for stuck entities
-+    public static void addAdditionalTimeToMutableLongIfEntityIsStuck(MutableLong mutableLong, ServerLevel world, PathfinderMob entity) {
-+        long stuckEntityAdditionalWaitTime = LuminolConfig.acquirePoiForStuckEntityInterval;
-+        mutableLong.add(stuckEntityAdditionalWaitTime <= 0L ? 0L : entity.getNavigation().isStuck() ? stuckEntityAdditionalWaitTime : 0L);
-+    }
-+    // Gale end - Airplane - reduce acquire POI for stuck entities
-+
-     public static BehaviorControl<PathfinderMob> create(Predicate<Holder<PoiType>> poiPredicate, MemoryModuleType<GlobalPos> poiPosModule, boolean onlyRunIfChild, Optional<Byte> entityStatus) {
-         return create(poiPredicate, poiPosModule, poiPosModule, onlyRunIfChild, entityStatus);
-     }
-@@ -42,12 +51,13 @@ public class AcquirePoi {
-                         return false;
-                     } else if (mutableLong.getValue() == 0L) {
-                         mutableLong.setValue(world.getGameTime() + (long)world.random.nextInt(20));
-+                        addAdditionalTimeToMutableLongIfEntityIsStuck(mutableLong, world, entity); // Gale - Airplane - reduce acquire POI for stuck entities
-                         return false;
-                     } else if (world.getGameTime() < mutableLong.getValue()) {
-                         return false;
-                     } else {
-                         mutableLong.setValue(time + 20L + (long)world.getRandom().nextInt(20));
--                        if (entity.getNavigation().isStuck()) mutableLong.add(200); // Paper - Wait an additional 10s to check again if they're stuck
-+                        addAdditionalTimeToMutableLongIfEntityIsStuck(mutableLong, world, entity); // Gale - Airplane - reduce acquire POI for stuck entities
-                         PoiManager poiManager = world.getPoiManager();
-                         long2ObjectMap.long2ObjectEntrySet().removeIf((entry) -> {
-                             return !entry.getValue().isStillValid(time);

patches/server/0034-Pufferfish-Reduce-projectile-chunk-loading.patch

@@ -1,33 +1,39 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 16:35:37 +0800
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 05:45:24 +0000
 Subject: [PATCH] Pufferfish Reduce projectile chunk loading
 
 
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index d0c0b4daec59f23a989a8b8f66ea3c704b0e309c..11c1a367fbc25cb63738a00ad93fb0b0b3500e7d 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -46,6 +46,8 @@ public class LuminolConfig {
- 
-     public static boolean reduceSensorWork = true;
-     public static boolean enableSuffocationOptimization = true;
+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;
- 
-     public static void init() throws IOException {
-         PARENT_FOLDER.mkdir();
-@@ -126,6 +128,8 @@ public class LuminolConfig {
-         reduceSensorWork = get("optimizations.reduce_sensor_work",reduceSensorWork,"This optimization is from petal.You can find out more about it on petal's repository");
-         enableSuffocationOptimization = get("optimizations.optimize_suffocation_check",enableSuffocationOptimization);
-         initEntityTTL();
-+        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.");
-     }
- 
-     public static <T> T get(String key,T def){
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.OPTIMIZATIONS;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "projectile";
++    }
++}
 diff --git a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
-index 0c8f90a904c01105ba5fa6a8037150697bc2621e..527168199605c8c606c6dde563e4fe096b6f17ac 100644
+index 10d7c64fb3a9bafdcdae99f8dc87017722341337..c366da764e2e11018460430595c14b17480c6da7 100644
 --- a/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
 +++ b/src/main/java/net/minecraft/world/entity/projectile/Projectile.java
 @@ -4,6 +4,8 @@ import com.google.common.base.MoreObjects;
@@ -39,7 +45,7 @@ index 0c8f90a904c01105ba5fa6a8037150697bc2621e..527168199605c8c606c6dde563e4fe09
  import net.minecraft.core.BlockPos;
  import net.minecraft.nbt.CompoundTag;
  import net.minecraft.network.protocol.Packet;
-@@ -44,6 +46,36 @@ public abstract class Projectile extends Entity implements TraceableEntity {
+@@ -45,6 +47,36 @@ public abstract class Projectile extends Entity implements TraceableEntity {
          super(type, world);
      }
  
@@ -60,8 +66,8 @@ index 0c8f90a904c01105ba5fa6a8037150697bc2621e..527168199605c8c606c6dde563e4fe09
 +        if (previousX != newX || previousZ != newZ) {
 +            boolean isLoaded = ((net.minecraft.server.level.ServerChunkCache) this.level().getChunkSource()).getChunkAtIfLoadedMainThread(newX, newZ) != null;
 +            if (!isLoaded) {
-+                if (Projectile.loadedThisTick > me.earthme.luminol.LuminolConfig.maxProjectileLoadsPerTick) {
-+                    if (++this.loadedLifetime > me.earthme.luminol.LuminolConfig.maxProjectileLoadsPerProjectile) {
++                if (Projectile.loadedThisTick > me.earthme.luminol.config.modules.optimizations.ProjectileChunkReduceConfig.maxProjectileLoadsPerTick) {
++                    if (++this.loadedLifetime > me.earthme.luminol.config.modules.optimizations.ProjectileChunkReduceConfig.maxProjectileLoadsPerProjectile) {
 +                        this.discard();
 +                    }
 +                    return;

patches/server/0035-Gale-Skip-secondary-POI-sensor-if-absent.patch

@@ -1,24 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 17:30:32 +0800
-Subject: [PATCH] Gale Skip secondary POI sensor if absent
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/ai/sensing/SecondaryPoiSensor.java b/src/main/java/net/minecraft/world/entity/ai/sensing/SecondaryPoiSensor.java
-index cb1d91f9fe98f21c2afbe3894dfd9bca3bdd3ba6..75dc06a3041bfdfb08c914eb50cfa282ae9eb2fe 100644
---- a/src/main/java/net/minecraft/world/entity/ai/sensing/SecondaryPoiSensor.java
-+++ b/src/main/java/net/minecraft/world/entity/ai/sensing/SecondaryPoiSensor.java
-@@ -22,6 +22,13 @@ public class SecondaryPoiSensor extends Sensor<Villager> {
- 
-     @Override
-     protected void doTick(ServerLevel world, Villager entity) {
-+        // Gale start - Lithium - skip secondary POI sensor if absent
-+        var secondaryPoi = entity.getVillagerData().getProfession().secondaryPoi();
-+        if (secondaryPoi.isEmpty()) {
-+            entity.getBrain().eraseMemory(MemoryModuleType.SECONDARY_JOB_SITE);
-+            return;
-+        }
-+        // Gale end - Lithium - skip secondary POI sensor if absent
-         ResourceKey<Level> resourceKey = world.dimension();
-         BlockPos blockPos = entity.blockPosition();
-         List<GlobalPos> list = Lists.newArrayList();

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

@@ -1,93 +1,80 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 16:44:23 +0800
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 05:56:56 +0000
 Subject: [PATCH] Pufferfish Dynamic Activation of Brain
 
 
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index 11c1a367fbc25cb63738a00ad93fb0b0b3500e7d..4f6af1fa55047e7be9e57c1dd1c60e9d96d12187 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -11,13 +11,16 @@ import org.apache.logging.log4j.LogManager;
- import org.apache.logging.log4j.Logger;
- import org.bukkit.Bukkit;
- 
--import java.util.Arrays;
--import java.util.List;
--import java.util.Locale;
-+import java.util.*;
- import java.util.logging.Level;
- import java.io.File;
- import java.io.IOException;
- 
+diff --git a/src/main/java/me/earthme/luminol/config/modules/optimizations/EntityDABConfig.java b/src/main/java/me/earthme/luminol/config/modules/optimizations/EntityDABConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..af5893ba1f738ec9827d7b714682c314229292d9
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/optimizations/EntityDABConfig.java
+@@ -0,0 +1,60 @@
++package me.earthme.luminol.config.modules.optimizations;
++
++import com.electronwill.nightconfig.core.file.CommentedFileConfig;
++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 net.minecraft.core.registries.BuiltInRegistries;
 +import net.minecraft.server.MinecraftServer;
-+import org.bukkit.configuration.ConfigurationSection;
 +import net.minecraft.world.entity.EntityType;
++import java.util.Collections;
++import java.util.List;
 +
- public class LuminolConfig {
-     private static final Logger logger = LogManager.getLogger();
-     private static final File PARENT_FOLDER = new File("luminol_config");
-@@ -48,6 +51,12 @@ public class LuminolConfig {
-     public static boolean enableSuffocationOptimization = true;
-     public static int maxProjectileLoadsPerTick;
-     public static int maxProjectileLoadsPerProjectile;
-+    public static boolean dearEnabled;
-+    public static int startDistance;
++public class EntityDABConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled")
++    public static boolean dearEnabled = false;
++    @ConfigInfo(baseName = "start_distance",comments =
++            "This value determines how far away an entity has to be\n" +
++                    " from the player to start being effected by DEAR."
++    )
++    public static int startDistance = 12;
++    @DoNotLoad
 +    public static int startDistanceSquared;
-+    public static int maximumActivationPrio;
++    @ConfigInfo(baseName = "max-tick-freq",comments =
++            "This value defines how often in ticks, the furthest entity\n"+
++                    "will get their pathfinders and behaviors ticked. 20 = 1s")
++    public static int maximumActivationPrio = 20;
++    @ConfigInfo(baseName = "activation-dist-mod",comments =
++                                """
++                                This value defines how much distance modifies an entity's
++                                tick frequency. freq = (distanceToPlayer^2) / (2^value)
++                                If you want further away entities to tick less often, use 7.
++                                If you want further away entities to tick more often, try 9.""")
 +    public static int activationDistanceMod;
++    @ConfigInfo(baseName = "blacklisted-entities")
++    public static List<String> blackedEntities = Collections.emptyList();
 +
- 
-     public static void init() throws IOException {
-         PARENT_FOLDER.mkdir();
-@@ -86,6 +95,33 @@ public class LuminolConfig {
-         }
-     }
- 
-+    private static void initDAB(){
-+        dearEnabled = get("optimizations.dab.enabled", true);
-+        startDistance = get("optimizations.dab.start-distance", 12,
-+                "This value determines how far away an entity has to be\n"+
-+                "from the player to start being effected by DEAR.");
-+        startDistanceSquared = startDistance * startDistance;
-+        maximumActivationPrio = get("optimizations.dab.max-tick-freq",20,
-+                "This value defines how often in ticks, the furthest entity\n"+
-+                "will get their pathfinders and behaviors ticked. 20 = 1s");
-+        activationDistanceMod = get("optimizations.dab.activation-dist-mod",8,
-+                """
-+                        This value defines how much distance modifies an entity's
-+                        tick frequency. freq = (distanceToPlayer^2) / (2^value)
-+                        If you want further away entities to tick less often, use 7.
-+                        If you want further away entities to tick more often, try 9.""");
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.OPTIMIZATIONS;
++    }
 +
++    @Override
++    public String getBaseName() {
++        return "dab";
++    }
++
++    @Override
++    public void onLoaded(CommentedFileConfig config) {
 +        for (EntityType<?> entityType : BuiltInRegistries.ENTITY_TYPE) {
 +            entityType.dabEnabled = true; // reset all, before setting the ones to true
 +        }
-+        get("optimizations.dab.blacklisted-entities",Collections.<String>emptyList(), "A list of entities to ignore for activation")
-+                .forEach(name -> EntityType.byString(name).ifPresentOrElse(entityType -> {
++
++        blackedEntities.forEach(name -> EntityType.byString(name).ifPresentOrElse(entityType -> {
 +                    entityType.dabEnabled = false;
-+                }, () -> MinecraftServer.LOGGER.warn("Unknown entity \"" + name + "\"")));
++                    }, () -> MinecraftServer.LOGGER.warn("Unknown entity \"" + name + "\"")));
 +
-+        MAIN_CONFIG.setComment("optimizations.dab", "Optimizes entity brains when\n"+"they're far away from the player");
++        config.setComment("optimizations.dab", "Optimizes entity brains when\n" + "they're far away from the player");
 +    }
-+
-     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");
-@@ -130,6 +166,7 @@ public class LuminolConfig {
-         initEntityTTL();
-         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();
-     }
- 
-     public static <T> T get(String key,T def){
++}
 diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
-index 561681deaf647277ecde64eed4cfbd9f38b5fed1..2ba86122ccb444908c35ea5cc1e245f5068a054a 100644
+index da6269249a95d78f91e90416a96bf1b776fd9c97..25a2f23618cd02366f71e704638adfbaed9fa8c5 100644
 --- a/src/main/java/net/minecraft/server/level/ServerLevel.java
 +++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
-@@ -982,6 +982,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
+@@ -987,6 +987,7 @@ public class ServerLevel extends Level implements WorldGenLevel {
              this.timings.entityTick.startTiming(); // Spigot
              profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.ENTITY_TICK); try { // Folia - profiler
              regionizedWorldData.forEachTickingEntity((entity) -> { // Folia - regionised ticking
@@ -96,26 +83,26 @@ index 561681deaf647277ecde64eed4cfbd9f38b5fed1..2ba86122ccb444908c35ea5cc1e245f5
                      if (false && this.shouldDiscardEntity(entity)) { // CraftBukkit - We prevent spawning in general, so this butchering is not needed
                          entity.discard();
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 8bdaab46c2e128aa58d13101170ce358146377a8..56efbcc29adca0239ef09a269f0899a3a6e2801b 100644
+index f8a410e9ed04d9a78d1a6a7e63673b1863d715f2..4b3acc0de20b246e20e2cc91ba0eca493a675729 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -436,6 +436,11 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
-         return this.originWorld;
-     }
-     // Paper end
-+    // Pufferfish start
+@@ -483,6 +483,11 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+ 
+     // Folia - region ticking
+     // Paper end - optimise entity tracking
++    //Pufferfish start
 +    public boolean activatedPriorityReset = false; // DAB
-+    public int activatedPriority = LuminolConfig.maximumActivationPrio; // golf score
++    public int activatedPriority = me.earthme.luminol.config.modules.optimizations.EntityDABConfig.maximumActivationPrio; // golf score
 +    // Pufferfish end
-+    
++
      public float getBukkitYaw() {
          return this.yRot;
      }
 diff --git a/src/main/java/net/minecraft/world/entity/EntityType.java b/src/main/java/net/minecraft/world/entity/EntityType.java
-index 4d60ac50a1d3860f2a2e9265aef9507d790220a3..0867c85964952ec118ea7517cd5ef570be1ee982 100644
+index 8deae3e95a26f4b42b2c2134e22f9649bd7a5391..c09357c1ef84a29d972119cb496b0ae97f98e4f4 100644
 --- a/src/main/java/net/minecraft/world/entity/EntityType.java
 +++ b/src/main/java/net/minecraft/world/entity/EntityType.java
-@@ -301,6 +301,7 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
+@@ -305,6 +305,7 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
      private final boolean canSpawnFarFromPlayer;
      private final int clientTrackingRange;
      private final int updateInterval;
@@ -124,7 +111,7 @@ index 4d60ac50a1d3860f2a2e9265aef9507d790220a3..0867c85964952ec118ea7517cd5ef570
      private String descriptionId;
      @Nullable
 diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
-index d3f8aa29b05a3813c0ec6e2ea5a253868abd6b07..54e821351e46d25e8b0ead52d2c8dfecd1957544 100644
+index b90865dbfb3a4bd83e4cd3ba3b5b965036039f98..66c581585e6ca58eba0e8b7af0fa1f0c9f924f94 100644
 --- a/src/main/java/net/minecraft/world/entity/Mob.java
 +++ b/src/main/java/net/minecraft/world/entity/Mob.java
 @@ -234,10 +234,10 @@ public abstract class Mob extends LivingEntity implements Targeting {
@@ -140,7 +127,7 @@ index d3f8aa29b05a3813c0ec6e2ea5a253868abd6b07..54e821351e46d25e8b0ead52d2c8dfec
              this.targetSelector.tick();
          }
      }
-@@ -934,16 +934,20 @@ public abstract class Mob extends LivingEntity implements Targeting {
+@@ -935,16 +935,20 @@ public abstract class Mob extends LivingEntity implements Targeting {
  
          if (i % 2 != 0 && this.tickCount > 1) {
              this.level().getProfiler().push("targetSelector");
@@ -162,25 +149,16 @@ index d3f8aa29b05a3813c0ec6e2ea5a253868abd6b07..54e821351e46d25e8b0ead52d2c8dfec
              this.level().getProfiler().pop();
          }
 diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java b/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java
-index b738ee2d3801fadfd09313f05ae24593e56b0ec6..9306ab8d2b6eeb73f86d4d94c0065d461905d702 100644
+index 676f5485a4ca9252e911213dcda8d51776b637b6..0f53c206b4c0607e2cda5cfa4edeae5209e897bf 100644
 --- a/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java
 +++ b/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java
-@@ -11,6 +11,8 @@ import java.util.Set;
- import java.util.function.Predicate;
- import java.util.function.Supplier;
- import java.util.stream.Stream;
-+
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.util.profiling.ProfilerFiller;
- import org.slf4j.Logger;
- 
-@@ -53,9 +55,12 @@ public class GoalSelector {
+@@ -53,9 +53,12 @@ public class GoalSelector {
      }
  
      // Paper start
 -    public boolean inactiveTick() {
 +    public boolean inactiveTick(int tickRate, boolean inactive) { // Pufferfish start
-+        if (inactive && !LuminolConfig.dearEnabled) tickRate = 4; // reset to Paper's
++        if (inactive && !me.earthme.luminol.config.modules.optimizations.EntityDABConfig.dearEnabled) tickRate = 4; // reset to Paper's
 +        tickRate = Math.min(tickRate, this.newGoalRate);
          this.curRate++;
 -        return this.curRate % this.newGoalRate == 0;
@@ -206,10 +184,10 @@ index 5ad5f22e5aa26445e5eb229958e7bf356bdd460e..d241ca4d0295f9fce39c11197bd435cf
          this.level().getProfiler().pop();
          this.level().getProfiler().push("allayActivityUpdate");
 diff --git a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java
-index d5b97d4316390028f54aa9bb9fa52b0b003e32a0..b4793b88688bd568a428aa520e880f0038de45a7 100644
+index b21e180641d17438997a80e5bcb0ec7998d24a2e..33c160994f70f71446d665e7487913437c9f9db4 100644
 --- a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java
 +++ b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java
-@@ -280,9 +280,11 @@ public class Axolotl extends Animal implements LerpingModel, VariantHolder<Axolo
+@@ -275,9 +275,11 @@ public class Axolotl extends Animal implements LerpingModel, VariantHolder<Axolo
          return true;
      }
  
@@ -222,11 +200,11 @@ index d5b97d4316390028f54aa9bb9fa52b0b003e32a0..b4793b88688bd568a428aa520e880f00
          this.level().getProfiler().pop();
          this.level().getProfiler().push("axolotlActivityUpdate");
 diff --git a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java b/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java
-index 5000ebc5f19dee72a86360062b822aecd60beb47..c8e3d47b3f2dc919cca8ad397095437f1da6c762 100644
+index 580da502c62ec5d669cb09932d99d1c7d711c965..b94d775e366f5cb251e9199ff5022ad53129da76 100644
 --- a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java
 +++ b/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java
-@@ -164,9 +164,11 @@ public class Frog extends Animal implements VariantHolder<FrogVariant> {
-         return true;
+@@ -159,9 +159,11 @@ public class Frog extends Animal implements VariantHolder<FrogVariant> {
+ 
      }
  
 +    private int behaviorTick = 0; // Pufferfish
@@ -238,10 +216,10 @@ index 5000ebc5f19dee72a86360062b822aecd60beb47..c8e3d47b3f2dc919cca8ad397095437f
          this.level().getProfiler().pop();
          this.level().getProfiler().push("frogActivityUpdate");
 diff --git a/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java b/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java
-index 4aeab90e778629c355189dfe79c39c4b21f5f5ac..6ed4ac06c76b8d0d6e8db778cade15dbd1e3e5f5 100644
+index 958816ce2166248b542c96c10c398a52d769b4db..415afe3473d9f8a50b1edab8cfda6158e59836e6 100644
 --- a/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java
 +++ b/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java
-@@ -77,9 +77,11 @@ public class Tadpole extends AbstractFish {
+@@ -80,9 +80,11 @@ public class Tadpole extends AbstractFish {
          return SoundEvents.TADPOLE_FLOP;
      }
  
@@ -254,7 +232,7 @@ index 4aeab90e778629c355189dfe79c39c4b21f5f5ac..6ed4ac06c76b8d0d6e8db778cade15db
          this.level().getProfiler().pop();
          this.level().getProfiler().push("tadpoleActivityUpdate");
 diff --git a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
-index 111a244087e24f25ba8524a46a228da10cd9498a..ff12ba2b79cb2e7e0bfd0e3b58ff6cb9e770092b 100644
+index 5d247ac38fe8a61603b3d934f3000bcda773142b..2e4177cfb02616ef6fa689f6d378976e39484cfb 100644
 --- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
 +++ b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java
 @@ -191,9 +191,11 @@ public class Goat extends Animal {
@@ -270,7 +248,7 @@ index 111a244087e24f25ba8524a46a228da10cd9498a..ff12ba2b79cb2e7e0bfd0e3b58ff6cb9
          this.level().getProfiler().pop();
          this.level().getProfiler().push("goatActivityUpdate");
 diff --git a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java
-index 4257f2282152aee09533c9a2e53018d3e49effa4..e703320717ff620a19ff76d1c10066117c9895d5 100644
+index 01a2016ac82807d28ffe407b7dbb74bdbcde503e..9921b160fb21f72fbd28fe81ea66fbc3dc05f83f 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java
 +++ b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java
 @@ -128,9 +128,11 @@ public class Hoglin extends Animal implements Enemy, HoglinBase {
@@ -286,7 +264,7 @@ index 4257f2282152aee09533c9a2e53018d3e49effa4..e703320717ff620a19ff76d1c1006611
          this.level().getProfiler().pop();
          HoglinAi.updateActivity(this);
 diff --git a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java
-index 6407ddef8442fce4f310ac4babf3e3de0dd5fc9a..cfdc1650783d6855e0d4f33ec68aab48dbee09f0 100644
+index a9813da7f2b248f98f22e0ad2e7842915025ec12..83d83e3f84bb6bd58761671c6cd4c8683545ff4c 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java
 +++ b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java
 @@ -300,9 +300,11 @@ public class Piglin extends AbstractPiglin implements CrossbowAttackMob, Invento
@@ -302,10 +280,10 @@ index 6407ddef8442fce4f310ac4babf3e3de0dd5fc9a..cfdc1650783d6855e0d4f33ec68aab48
          this.level().getProfiler().pop();
          PiglinAi.updateActivity(this);
 diff --git a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java
-index b2bc3a832c310448046ccde37a04918aa6d63197..5e43912708f9074dee1bb351efa737a7e6796fc3 100644
+index 7aadd36f0fe986635b495ab8c1426644620400cf..0c947d7509d66647327bce885ad2c6051f41c56f 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java
 +++ b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java
-@@ -272,11 +272,13 @@ public class Warden extends Monster implements VibrationSystem {
+@@ -273,11 +273,13 @@ public class Warden extends Monster implements VibrationSystem {
  
      }
  
@@ -320,10 +298,10 @@ index b2bc3a832c310448046ccde37a04918aa6d63197..5e43912708f9074dee1bb351efa737a7
          this.level().getProfiler().pop();
          super.customServerAiStep();
 diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java
-index 4e9ccc518f37755e86687653f7724240db754682..a94661deaa6e1288bb957dc5d7711c5d03b9e460 100644
+index 3eeff0cd8563939c656b5ded8470cab016903f25..90d8cd94d987416a3e9f6e6d47a5b366d4687fe0 100644
 --- a/src/main/java/net/minecraft/world/entity/npc/Villager.java
 +++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java
-@@ -142,6 +142,8 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+@@ -143,6 +143,8 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
          return holder.is(PoiTypes.MEETING);
      });
  
@@ -332,7 +310,7 @@ index 4e9ccc518f37755e86687653f7724240db754682..a94661deaa6e1288bb957dc5d7711c5d
      public Villager(EntityType<? extends Villager> entityType, Level world) {
          this(entityType, world, VillagerType.PLAINS);
      }
-@@ -245,6 +247,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+@@ -246,6 +248,7 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
      }
      // Spigot End
  
@@ -340,7 +318,7 @@ index 4e9ccc518f37755e86687653f7724240db754682..a94661deaa6e1288bb957dc5d7711c5d
      @Override
      @Deprecated // Paper
      protected void customServerAiStep() {
-@@ -254,7 +257,11 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+@@ -255,7 +258,11 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
      protected void customServerAiStep(final boolean inactive) {
          // Paper end
          this.level().getProfiler().push("villagerBrain");
@@ -354,17 +332,10 @@ index 4e9ccc518f37755e86687653f7724240db754682..a94661deaa6e1288bb957dc5d7711c5d
          if (this.assignProfessionWhenSpawned) {
              this.assignProfessionWhenSpawned = false;
 diff --git a/src/main/java/org/spigotmc/ActivationRange.java b/src/main/java/org/spigotmc/ActivationRange.java
-index 22daed525b023998a05884db603e2c7385ce0873..e77e1c60a611c49489c65d66e54236a86c3093e3 100644
+index 50fafff765b2494c075784cc5342d086c8dc97b2..78b495ffbb1ca753714304e2a18035bcfd84b918 100644
 --- a/src/main/java/org/spigotmc/ActivationRange.java
 +++ b/src/main/java/org/spigotmc/ActivationRange.java
-@@ -1,5 +1,6 @@
- package org.spigotmc;
- 
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.core.BlockPos;
- import net.minecraft.server.MinecraftServer;
- import net.minecraft.server.level.ServerChunkCache;
-@@ -38,6 +39,10 @@ import co.aikar.timings.MinecraftTimings;
+@@ -38,6 +38,10 @@ import co.aikar.timings.MinecraftTimings;
  import net.minecraft.world.entity.schedule.Activity;
  import net.minecraft.world.level.Level;
  import net.minecraft.world.phys.AABB;
@@ -375,24 +346,24 @@ index 22daed525b023998a05884db603e2c7385ce0873..e77e1c60a611c49489c65d66e54236a8
  
  public class ActivationRange
  {
-@@ -230,6 +235,25 @@ public class ActivationRange
+@@ -230,6 +234,25 @@ public class ActivationRange
                  }
-                 // Paper end - configurable marker ticking
-                 ActivationRange.activateEntity(entity);
+                 // Paper end - Configurable marker ticking
+                 ActivationRange.activateEntity(entity, bbByType); // Folia - threaded regions
 +
 +                // Pufferfish start
-+                if (LuminolConfig.dearEnabled && entity.getType().dabEnabled) {
++                if (me.earthme.luminol.config.modules.optimizations.EntityDABConfig.dearEnabled && entity.getType().dabEnabled) {
 +                    if (!entity.activatedPriorityReset) {
 +                        entity.activatedPriorityReset = true;
-+                        entity.activatedPriority = LuminolConfig.maximumActivationPrio;
++                        entity.activatedPriority = me.earthme.luminol.config.modules.optimizations.EntityDABConfig.maximumActivationPrio;
 +                    }
 +                    Vec3 playerVec = player.position();
 +                    Vec3 entityVec = entity.position();
 +                    double diffX = playerVec.x - entityVec.x, diffY = playerVec.y - entityVec.y, diffZ = playerVec.z - entityVec.z;
 +                    int squaredDistance = (int) (diffX * diffX + diffY * diffY + diffZ * diffZ);
-+                    entity.activatedPriority = squaredDistance > LuminolConfig.startDistanceSquared ?
-+                      Math.max(1, Math.min(squaredDistance >> LuminolConfig.activationDistanceMod, entity.activatedPriority)) :
-+                      1;
++                    entity.activatedPriority = squaredDistance > me.earthme.luminol.config.modules.optimizations.EntityDABConfig.startDistanceSquared ?
++                            Math.max(1, Math.min(squaredDistance >> me.earthme.luminol.config.modules.optimizations.EntityDABConfig.activationDistanceMod, entity.activatedPriority)) :
++                            1;
 +                } else {
 +                    entity.activatedPriority = 1;
 +                }
@@ -401,7 +372,7 @@ index 22daed525b023998a05884db603e2c7385ce0873..e77e1c60a611c49489c65d66e54236a8
              }
              // Paper end
          }
-@@ -246,12 +270,12 @@ public class ActivationRange
+@@ -246,12 +269,12 @@ public class ActivationRange
          if ( io.papermc.paper.threadedregions.RegionizedServer.getCurrentTick() > entity.activatedTick ) // Folia - threaded regions
          {
              if ( entity.defaultActivationState )
@@ -410,7 +381,7 @@ index 22daed525b023998a05884db603e2c7385ce0873..e77e1c60a611c49489c65d66e54236a8
                  entity.activatedTick = io.papermc.paper.threadedregions.RegionizedServer.getCurrentTick(); // Folia - threaded regions
                  return;
              }
-             if ( entity.activationType.boundingBox.intersects( entity.getBoundingBox() ) )
+             if ( bbByType[entity.activationType.ordinal()].intersects( entity.getBoundingBox() ) ) // Folia - threaded regions
 -            {
 +            {  // Pufferfish - diff on change
                  entity.activatedTick = io.papermc.paper.threadedregions.RegionizedServer.getCurrentTick(); // Folia - threaded regions

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

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

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

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

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

@@ -1,99 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 21:23:06 +0800
-Subject: [PATCH] Try fixing folia spector teleportation
-
-
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index d032786938db9725e1be72dae63a1387bcb69d79..dcc52141b34b87a67c3d6070b68b58af4a7c4f26 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -31,6 +31,7 @@ public class LuminolConfig {
-     public static String[] tpsColors = new String[]{"GREEN","YELLOW","RED","PURPLE"};
-     public static String[] pingColors = new String[]{"GREEN","YELLOW","RED","PURPLE"};
-     public static boolean disableUsernameCheck = false;
-+    public static boolean fixSpectorTeleportFolia = false;
- 
-     public static boolean safeTeleportation = true;
-     public static boolean enableSandDuping = false;
-@@ -130,6 +131,7 @@ public class LuminolConfig {
-         tpsColors = get("misc.tpsbar_range_colors", List.of(tpsColors),"The bar and text color of each tps ranges.The last is the color of initial bar's color").toArray(String[]::new);
-         pingColors = get("misc.tpsbar_ping_range_colors",List.of(pingColors),"As same as the tpsColors").toArray(String[]::new);
-         disableUsernameCheck = get("misc.disable_username_check",disableUsernameCheck,"Disable username check that can accept usernames with other characters(such as Chinese).Not recommended to use");
-+        fixSpectorTeleportFolia = get("misc.fix_folia_spector_teleport",fixSpectorTeleportFolia);
- 
-         if (tpsbarEnabled){
-             initTpsbar();
-diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 97bfb92e52c3c5ef1cd22afe2b97c204eb45025a..710e87e388095f28af4983a04cb89ddb6be61986 100644
---- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
-+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -18,6 +18,9 @@ import java.util.Optional;
- import java.util.OptionalInt;
- import java.util.Set;
- import javax.annotation.Nullable;
-+
-+import io.papermc.paper.util.TickThread;
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.BlockUtil;
- import net.minecraft.ChatFormatting;
- import net.minecraft.CrashReport;
-@@ -835,18 +838,7 @@ public class ServerPlayer extends Player {
- 
-         Entity entity = this.getCamera();
- 
--        if (entity != this) {
--            if (entity.isAlive()) {
--                this.absMoveTo(entity.getX(), entity.getY(), entity.getZ(), entity.getYRot(), entity.getXRot());
--                this.serverLevel().getChunkSource().move(this);
--                if (this.wantsToStopRiding()) {
--                    this.setCamera(this);
--                }
--            } else {
--                this.setCamera(this);
--            }
--        }
--
-+        //Luminol - move up
-         CriteriaTriggers.TICK.trigger(this);
-         if (this.levitationStartPos != null) {
-             CriteriaTriggers.LEVITATION.trigger(this, this.levitationStartPos, this.tickCount - this.levitationStartTime);
-@@ -855,6 +847,38 @@ public class ServerPlayer extends Player {
-         this.trackStartFallingPosition();
-         this.trackEnteredOrExitedLavaOnVehicle();
-         this.advancements.flushDirty(this);
-+
-+        if (entity != this) {
-+            if (entity.isAlive()) {
-+                //Luminol start - Fix spector camera
-+                if (TickThread.isTickThreadFor(entity) || !LuminolConfig.fixSpectorTeleportFolia){
-+                    this.absMoveTo(entity.getX(), entity.getY(), entity.getZ(), entity.getYRot(), entity.getXRot());
-+                    this.serverLevel().getChunkSource().move(this);
-+                    if (this.wantsToStopRiding()) {
-+                        this.setCamera(this);
-+                    }
-+                }else{
-+                    this.teleportAsync(
-+                            ((ServerLevel) entity.level()),
-+                            entity.position,
-+                            entity.getYRot(),
-+                            entity.getXRot(),
-+                            null,
-+                            TeleportCause.SPECTATE,
-+                            Entity.TELEPORT_FLAG_LOAD_CHUNK | Entity.TELEPORT_FLAG_TELEPORT_PASSENGERS,
-+                            r -> {
-+                                this.serverLevel().getChunkSource().move(this);
-+                                if (this.wantsToStopRiding()) {
-+                                    this.setCamera(this);
-+                                }
-+                            }
-+                    );
-+                }
-+                //Luminol end
-+            } else {
-+                this.setCamera(this);
-+            }
-+        }
-     }
- 
-     public void doTick() {

patches/server/0038-Add-config-for-offline-mod-warning.patch

@@ -1,39 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Wed, 29 Nov 2023 21:15:32 +0800
-Subject: [PATCH] Add config for offline mod warning
-
-
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index dcc52141b34b87a67c3d6070b68b58af4a7c4f26..8bf7a0235ed292d6cb3beca9b786a69148e0b4d9 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -31,6 +31,7 @@ public class LuminolConfig {
-     public static String[] tpsColors = new String[]{"GREEN","YELLOW","RED","PURPLE"};
-     public static String[] pingColors = new String[]{"GREEN","YELLOW","RED","PURPLE"};
-     public static boolean disableUsernameCheck = false;
-+    public static boolean disableOfflineModeWarning = false;
-     public static boolean fixSpectorTeleportFolia = false;
- 
-     public static boolean safeTeleportation = true;
-@@ -132,6 +133,7 @@ public class LuminolConfig {
-         pingColors = get("misc.tpsbar_ping_range_colors",List.of(pingColors),"As same as the tpsColors").toArray(String[]::new);
-         disableUsernameCheck = get("misc.disable_username_check",disableUsernameCheck,"Disable username check that can accept usernames with other characters(such as Chinese).Not recommended to use");
-         fixSpectorTeleportFolia = get("misc.fix_folia_spector_teleport",fixSpectorTeleportFolia);
-+        disableOfflineModeWarning = get("misc.disable_offline_mode_warning",disableOfflineModeWarning);
- 
-         if (tpsbarEnabled){
-             initTpsbar();
-diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-index 4a1e068c27853a38db0641806626e7ac740bd8de..4cc62104942e58ededd5c838f4bd5c4db0d574d4 100644
---- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-+++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-@@ -278,7 +278,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
--        if (!this.usesAuthentication()) {
-+        if (!this.usesAuthentication() && !LuminolConfig.disableOfflineModeWarning) { //Luminol - Add config for offline mod warning
-             DedicatedServer.LOGGER.warn("**** SERVER IS RUNNING IN OFFLINE/INSECURE MODE!");
-             DedicatedServer.LOGGER.warn("The server will make no attempt to authenticate usernames. Beware.");
-             // Spigot start

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

@@ -1,6 +1,6 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 16:08:46 +0800
+From: MrHua269 <novau233@163.com>
+Date: Mon, 25 Mar 2024 13:48:33 +0000
 Subject: [PATCH] Pufferfish Improve container checking with a bitset
 
 
@@ -237,10 +237,10 @@ index d6cbe98e67fdbf8db46338a88ab1356dd63b50a3..20dd3a63b2f955b05a75eb240e33ae4c
      int LARGE_MAX_STACK_SIZE = 64;
      int DEFAULT_DISTANCE_LIMIT = 8;
 diff --git a/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecartContainer.java b/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecartContainer.java
-index 00187fbbeddfc17e1b6887f8bf0f50da23938470..f64edfdb03f99624daf1e05b5dc86d845c3018b6 100644
+index 756d0434472921992c9d84597d7c9c824e93614c..38c573d440946ca7ee6016ef92e9c1605031e611 100644
 --- a/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecartContainer.java
 +++ b/src/main/java/net/minecraft/world/entity/vehicle/AbstractMinecartContainer.java
-@@ -27,7 +27,10 @@ import org.bukkit.inventory.InventoryHolder;
+@@ -28,7 +28,10 @@ import org.bukkit.inventory.InventoryHolder;
  
  public abstract class AbstractMinecartContainer extends AbstractMinecart implements ContainerEntity {
  
@@ -251,7 +251,7 @@ index 00187fbbeddfc17e1b6887f8bf0f50da23938470..f64edfdb03f99624daf1e05b5dc86d84
      @Nullable
      public ResourceLocation lootTable;
      public long lootTableSeed;
-@@ -89,12 +92,18 @@ public abstract class AbstractMinecartContainer extends AbstractMinecart impleme
+@@ -90,12 +93,18 @@ public abstract class AbstractMinecartContainer extends AbstractMinecart impleme
  
      protected AbstractMinecartContainer(EntityType<?> type, Level world) {
          super(type, world);
@@ -272,7 +272,7 @@ index 00187fbbeddfc17e1b6887f8bf0f50da23938470..f64edfdb03f99624daf1e05b5dc86d84
      }
  
      @Override
-@@ -156,6 +165,10 @@ public abstract class AbstractMinecartContainer extends AbstractMinecart impleme
+@@ -164,6 +173,10 @@ public abstract class AbstractMinecartContainer extends AbstractMinecart impleme
      protected void readAdditionalSaveData(CompoundTag nbt) {
          super.readAdditionalSaveData(nbt);
          this.lootableData.loadNbt(nbt); // Paper
@@ -284,7 +284,7 @@ index 00187fbbeddfc17e1b6887f8bf0f50da23938470..f64edfdb03f99624daf1e05b5dc86d84
      }
  
 diff --git a/src/main/java/net/minecraft/world/level/block/entity/ChestBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/ChestBlockEntity.java
-index a71414397bd45ee7bcacfeef0041d80dfa25f114..d66806565770cb03a21794f99e5c4b0f3040b26a 100644
+index 9b1243d96e0694c62fc9e82e9be540bce0d2b3ad..3514022d898a24052c917ebf55dcef3e757d6836 100644
 --- a/src/main/java/net/minecraft/world/level/block/entity/ChestBlockEntity.java
 +++ b/src/main/java/net/minecraft/world/level/block/entity/ChestBlockEntity.java
 @@ -31,7 +31,10 @@ import org.bukkit.entity.HumanEntity;
@@ -362,10 +362,10 @@ index a71414397bd45ee7bcacfeef0041d80dfa25f114..d66806565770cb03a21794f99e5c4b0f
  
      @Override
 diff --git a/src/main/java/net/minecraft/world/level/block/entity/HopperBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/HopperBlockEntity.java
-index 72779080969fe9f058c19533ffc9dad5f9c47086..c90d578643490709936545ee9cbd41c8671eeb7a 100644
+index 82e7e76fecceb55522b5828a56f036e42ef55201..882e27de852c89c837d7943c5a9ae6fb3c2e896b 100644
 --- a/src/main/java/net/minecraft/world/level/block/entity/HopperBlockEntity.java
 +++ b/src/main/java/net/minecraft/world/level/block/entity/HopperBlockEntity.java
-@@ -47,7 +47,10 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+@@ -48,7 +48,10 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
  
      public static final int MOVE_ITEM_SPEED = 8;
      public static final int HOPPER_CONTAINER_SIZE = 5;
@@ -373,10 +373,10 @@ index 72779080969fe9f058c19533ffc9dad5f9c47086..c90d578643490709936545ee9cbd41c8
      private NonNullList<ItemStack> items;
 +    private gg.airplane.structs.ItemListWithBitset optimizedItems; // Pufferfish
 +    // Pufferfish end
-     private int cooldownTime;
-     private long tickedGameTime;
+     public int cooldownTime;
+     private long tickedGameTime = Long.MIN_VALUE; // Folia - region threading
  
-@@ -83,14 +86,37 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+@@ -94,14 +97,37 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
  
      public HopperBlockEntity(BlockPos pos, BlockState state) {
          super(BlockEntityType.HOPPER, pos, state);
@@ -416,19 +416,19 @@ index 72779080969fe9f058c19533ffc9dad5f9c47086..c90d578643490709936545ee9cbd41c8
          if (!this.tryLoadLootTable(nbt)) {
              ContainerHelper.loadAllItems(nbt, this.items);
          }
-@@ -493,6 +519,7 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+@@ -504,6 +530,7 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
      }
  
      private static boolean isFullContainer(Container inventory, Direction direction) {
 +        if (true) return inventory.isCompletelyFull(direction); // Pufferfish - use bitsets
-         // Paper start - optimize hoppers
+         // Paper start - Perf: Optimize Hoppers
          if (inventory instanceof WorldlyContainer worldlyContainer) {
              for (final int slot : worldlyContainer.getSlotsForFace(direction)) {
-@@ -515,7 +542,11 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+@@ -526,7 +553,11 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
      }
  
      private static boolean isEmptyContainer(Container inv, Direction facing) {
--        return allMatch(inv, facing, IS_EMPTY_TEST);
+-        return allMatch(inv, facing, IS_EMPTY_TEST); // Paper - Perf: Optimize Hoppers
 +        // Paper start
 +        // Pufferfish start - use bitsets
 +        //return allMatch(inv, facing, IS_EMPTY_TEST);
@@ -437,7 +437,7 @@ index 72779080969fe9f058c19533ffc9dad5f9c47086..c90d578643490709936545ee9cbd41c8
      }
  
      public static boolean suckInItems(Level world, Hopper hopper) {
-@@ -716,7 +747,7 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+@@ -727,7 +758,7 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
  
          if (HopperBlockEntity.canPlaceItemInContainer(to, stack, slot, side)) {
              boolean flag = false;
@@ -446,7 +446,7 @@ index 72779080969fe9f058c19533ffc9dad5f9c47086..c90d578643490709936545ee9cbd41c8
  
              if (itemstack1.isEmpty()) {
                  // Spigot start - SPIGOT-6693, InventorySubcontainer#setItem
-@@ -911,7 +942,10 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+@@ -922,7 +953,10 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
  
      @Override
      protected void setItems(NonNullList<ItemStack> list) {
@@ -459,13 +459,13 @@ index 72779080969fe9f058c19533ffc9dad5f9c47086..c90d578643490709936545ee9cbd41c8
  
      public static void entityInside(Level world, BlockPos pos, BlockState state, Entity entity, HopperBlockEntity blockEntity) {
 diff --git a/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
-index 3e638f12956e57548f76c7e2403ba370f7baa249..02364a148b347e3669275553004391e31d77c0b5 100644
+index f52ccd4f3e062af3c7cc6eaea5b074a3bbd21690..a5cd70b6ada2b44f64db0985483ee5eadc67003f 100644
 --- a/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
 +++ b/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
-@@ -96,12 +96,7 @@ public abstract class RandomizableContainerBlockEntity extends BaseContainerBloc
+@@ -94,12 +94,7 @@ public abstract class RandomizableContainerBlockEntity extends BaseContainerBloc
      public boolean isEmpty() {
          this.unpackLootTable((Player)null);
-         // Paper start
+         // Paper start - Perf: Optimize Hoppers
 -        for (final ItemStack itemStack : this.getItems()) {
 -            if (!itemStack.isEmpty()) {
 -                return false;
@@ -473,6 +473,6 @@ index 3e638f12956e57548f76c7e2403ba370f7baa249..02364a148b347e3669275553004391e3
 -        }
 -        return true;
 +        return this.isCompletelyEmpty(null); // Pufferfish - use super
-         // Paper end
+         // Paper end - Perf: Optimize Hoppers
      }
  

patches/server/0039-Add-config-for-root-user-warning.patch

@@ -1,39 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Thu, 30 Nov 2023 22:41:04 +0800
-Subject: [PATCH] Add config for root user warning
-
-
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index 8bf7a0235ed292d6cb3beca9b786a69148e0b4d9..7ada58f2fa83a47908723bdf1e5c5fbbc2f5ffa9 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -33,6 +33,7 @@ public class LuminolConfig {
-     public static boolean disableUsernameCheck = false;
-     public static boolean disableOfflineModeWarning = false;
-     public static boolean fixSpectorTeleportFolia = false;
-+    public static boolean disableRootUserWarning = false;
- 
-     public static boolean safeTeleportation = true;
-     public static boolean enableSandDuping = false;
-@@ -134,6 +135,7 @@ public class LuminolConfig {
-         disableUsernameCheck = get("misc.disable_username_check",disableUsernameCheck,"Disable username check that can accept usernames with other characters(such as Chinese).Not recommended to use");
-         fixSpectorTeleportFolia = get("misc.fix_folia_spector_teleport",fixSpectorTeleportFolia);
-         disableOfflineModeWarning = get("misc.disable_offline_mode_warning",disableOfflineModeWarning);
-+        disableRootUserWarning = get("misc.disable_root_user_warning",disableRootUserWarning);
- 
-         if (tpsbarEnabled){
-             initTpsbar();
-diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-index 4cc62104942e58ededd5c838f4bd5c4db0d574d4..964777e992974dc02ee106ec47efd2e04f3b76c3 100644
---- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-+++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-@@ -178,7 +178,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
-         }
- 
-         // Paper start - detect running as root
--        if (io.papermc.paper.util.ServerEnvironment.userIsRootOrAdmin()) {
-+        if (io.papermc.paper.util.ServerEnvironment.userIsRootOrAdmin() && !LuminolConfig.disableRootUserWarning) { //Luminol - Add config for root user warning
-             DedicatedServer.LOGGER.warn("****************************");
-             DedicatedServer.LOGGER.warn("YOU ARE RUNNING THIS SERVER AS AN ADMINISTRATIVE OR ROOT USER. THIS IS NOT ADVISED.");
-             DedicatedServer.LOGGER.warn("YOU ARE OPENING YOURSELF UP TO POTENTIAL RISKS WHEN DOING THIS.");

patches/server/0039-Gale-Variable-entity-wake-up-duration.patch

@@ -1,34 +1,40 @@
 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 <novau233@163.com>
+Date: Wed, 7 Feb 2024 06:00:22 +0000
 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;
+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;
- 
- 
-     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){
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.OPTIMIZATIONS;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "variable_entity_waking_up";
++    }
++}
 diff --git a/src/main/java/org/spigotmc/ActivationRange.java b/src/main/java/org/spigotmc/ActivationRange.java
-index e77e1c60a611c49489c65d66e54236a86c3093e3..51adf24b9274b6bc78ef94e77a0b2d73b1f2bbbb 100644
+index 78b495ffbb1ca753714304e2a18035bcfd84b918..e9331fe4d524215bbab9a410d16e4f1811f5ad31 100644
 --- a/src/main/java/org/spigotmc/ActivationRange.java
 +++ b/src/main/java/org/spigotmc/ActivationRange.java
-@@ -76,28 +76,40 @@ public class ActivationRange
+@@ -75,28 +75,41 @@ public class ActivationRange
          if (entity.activationType == ActivationType.VILLAGER) {
              if (inactiveFor > config.wakeUpInactiveVillagersEvery && worldData.wakeupInactiveRemainingVillagers > 0) { // Folia - threaded regions
                  worldData.wakeupInactiveRemainingVillagers--; // Folia - threaded regions
@@ -59,10 +65,10 @@ index e77e1c60a611c49489c65d66e54236a86c3093e3..51adf24b9274b6bc78ef94e77a0b2d73
      // 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 +76,7 @@ index e77e1c60a611c49489c65d66e54236a86c3093e3..51adf24b9274b6bc78ef94e77a0b2d73
 +    }
 +    // Gale end - variable entity wake-up duration
 +
-     static AABB maxBB = new AABB( 0, 0, 0, 0, 0, 0 );
++
+     // Folia - threaded regions - replaced by local variable
  
      /**

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

@@ -1,34 +1,40 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 17:21:11 +0800
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 06:03:02 +0000
 Subject: [PATCH] Gale Don't load chunks to activate climbing entities
 
 
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index 793dc5b35e9a0665d486a74ce5b776b43b941ee2..fcd532898e099a809969603941b90fdd415b03c3 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -57,6 +57,7 @@ public class LuminolConfig {
-     public static int maximumActivationPrio;
-     public static int activationDistanceMod;
-     public static double entityWakeUpDurationRatioStandardDeviation = 0.2;
-+    public static boolean loadChunksToActiveClimbingEntities = false;
- 
- 
-     public static void init() throws IOException {
-@@ -169,6 +170,7 @@ public class LuminolConfig {
-         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);
-+        loadChunksToActiveClimbingEntities = get("optimizations.load_chunks_to_active_climbing_entities",loadChunksToActiveClimbingEntities);
-     }
- 
-     public static <T> T get(String key,T def){
+diff --git a/src/main/java/me/earthme/luminol/config/modules/optimizations/LoadChunksToActiveClimbingEntitiesConfig.java b/src/main/java/me/earthme/luminol/config/modules/optimizations/LoadChunksToActiveClimbingEntitiesConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..ed62d25d6cd6dfcf8c5db20ced36eb3d3c79dafd
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/optimizations/LoadChunksToActiveClimbingEntitiesConfig.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 LoadChunksToActiveClimbingEntitiesConfig implements IConfigModule {
++    @ConfigInfo(baseName = "allow")
++    public static boolean allow = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.OPTIMIZATIONS;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "load_chunks_to_active_climbing_entities";
++    }
++}
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 56efbcc29adca0239ef09a269f0899a3a6e2801b..54daa1744c89e98136d0f594a35119d5fd3d6bc8 100644
+index 4b3acc0de20b246e20e2cc91ba0eca493a675729..2d78d28120af075bebee4d97428ed48cf27c9d78 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -5330,6 +5330,16 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+@@ -5460,6 +5460,16 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
          return this.feetBlockState;
      }
  
@@ -46,17 +52,17 @@ index 56efbcc29adca0239ef09a269f0899a3a6e2801b..54daa1744c89e98136d0f594a35119d5
          return this.chunkPosition;
      }
 diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-index f13d26b280f095d006ffccb36af66bb7487cb8da..ecbacbed29af51d949122b21c3ae9fc95885c6d8 100644
+index df789b13f57200c66ff4cc59e6b63949a6804e3d..c2d155882c94f875c96c13746ff0c5433ab25ed0 100644
 --- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
 +++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
-@@ -2027,19 +2027,43 @@ public abstract class LivingEntity extends Entity implements Attackable {
+@@ -2062,19 +2062,43 @@ public abstract class LivingEntity extends Entity implements Attackable {
  
      public boolean onClimableCached() {
          if (!this.blockPosition().equals(this.lastClimbingPosition)) {
 -            this.cachedOnClimable = this.onClimbable();
 -            this.lastClimbingPosition = this.blockPosition();
 +            // Gale start - don't load chunks to activate climbing entities
-+            Boolean onClimbableIfLoaded = this.onClimbable(LuminolConfig.loadChunksToActiveClimbingEntities);
++            Boolean onClimbableIfLoaded = this.onClimbable(me.earthme.luminol.config.modules.optimizations.LoadChunksToActiveClimbingEntitiesConfig.allow);
 +            if (onClimbableIfLoaded != null) {
 +                this.cachedOnClimable = onClimbableIfLoaded;
 +                this.lastClimbingPosition = this.blockPosition();

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

@@ -5,10 +5,10 @@ Subject: [PATCH] Gale Optimize sun burn tick
 
 
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 54daa1744c89e98136d0f594a35119d5fd3d6bc8..6f3e87661c3181b6537e4d6d96e50d8d5680c040 100644
+index 2d78d28120af075bebee4d97428ed48cf27c9d78..a4682b8bd269f52af26a03347e8d3869d2b1ba41 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -307,7 +307,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+@@ -310,7 +310,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
      public double xo;
      public double yo;
      public double zo;
@@ -17,7 +17,7 @@ index 54daa1744c89e98136d0f594a35119d5fd3d6bc8..6f3e87661c3181b6537e4d6d96e50d8d
      public BlockPos blockPosition; // Pufferfish - private->public
      private ChunkPos chunkPosition;
      private Vec3 deltaMovement;
-@@ -2026,9 +2026,17 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+@@ -2068,9 +2068,17 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
      /** @deprecated */
      @Deprecated
      public float getLightLevelDependentMagicValue() {
@@ -37,10 +37,10 @@ index 54daa1744c89e98136d0f594a35119d5fd3d6bc8..6f3e87661c3181b6537e4d6d96e50d8d
          this.absMoveTo(x, y, z);
          this.setYRot(yaw % 360.0F);
 diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
-index 54e821351e46d25e8b0ead52d2c8dfecd1957544..394913950ac8fbcfcdbce817bac95f3b6604beb7 100644
+index 97e099eea537aea8f8ffd031063949c363820701..71b1f576aff8dcf51dd888280b5b7a25a387d197 100644
 --- a/src/main/java/net/minecraft/world/entity/Mob.java
 +++ b/src/main/java/net/minecraft/world/entity/Mob.java
-@@ -1736,13 +1736,29 @@ public abstract class Mob extends LivingEntity implements Targeting {
+@@ -1750,13 +1750,29 @@ public abstract class Mob extends LivingEntity implements Targeting {
  
      }
  

patches/server/0041-Optimize-mob-spawning-Async-mob-spawn-state-calc.patch

@@ -1,483 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sat, 9 Dec 2023 22:19:49 +0800
-Subject: [PATCH] Optimize mob spawning(Async mob spawn state calc)
-
-
-diff --git a/src/main/java/com/destroystokyo/paper/util/misc/AreaMap.java b/src/main/java/com/destroystokyo/paper/util/misc/AreaMap.java
-index 41b9405d6759d865e0d14dd4f95163e9690e967d..091b1ae822e1c0517e59572e7a9bda11e998c0ee 100644
---- a/src/main/java/com/destroystokyo/paper/util/misc/AreaMap.java
-+++ b/src/main/java/com/destroystokyo/paper/util/misc/AreaMap.java
-@@ -26,7 +26,7 @@ public abstract class AreaMap<E> {
- 
-     // we use linked for better iteration.
-     // map of: coordinate to set of objects in coordinate
--    protected final Long2ObjectOpenHashMap<PooledLinkedHashSets.PooledObjectLinkedOpenHashSet<E>> areaMap = new Long2ObjectOpenHashMap<>(1024, 0.7f);
-+    protected Long2ObjectOpenHashMap<PooledLinkedHashSets.PooledObjectLinkedOpenHashSet<E>> areaMap = new Long2ObjectOpenHashMap<>(1024, 0.7f); // Pufferfish - not actually final
-     protected final PooledLinkedHashSets<E> pooledHashSets;
- 
-     protected final ChangeCallback<E> addCallback;
-@@ -160,7 +160,8 @@ public abstract class AreaMap<E> {
-     protected abstract PooledLinkedHashSets.PooledObjectLinkedOpenHashSet<E> getEmptySetFor(final E object);
- 
-     // expensive op, only for debug
--    protected void validate(final E object, final int viewDistance) {
-+    protected void validate0(final E object, final int viewDistance) { // Pufferfish - rename this thing just in case it gets used I'd rather a compile time error.
-+        if (true) throw new UnsupportedOperationException(); // Pufferfish - not going to put in the effort to fix this if it doesn't ever get used.
-         int entiesGot = 0;
-         int expectedEntries = (2 * viewDistance + 1);
-         expectedEntries *= expectedEntries;
-diff --git a/src/main/java/com/destroystokyo/paper/util/misc/PlayerAreaMap.java b/src/main/java/com/destroystokyo/paper/util/misc/PlayerAreaMap.java
-index 46954db7ecd35ac4018fdf476df7c8020d7ce6c8..1ad890a244bdf6df48a8db68cb43450e08c788a6 100644
---- a/src/main/java/com/destroystokyo/paper/util/misc/PlayerAreaMap.java
-+++ b/src/main/java/com/destroystokyo/paper/util/misc/PlayerAreaMap.java
-@@ -5,7 +5,7 @@ import net.minecraft.server.level.ServerPlayer;
- /**
-  * @author Spottedleaf
-  */
--public final class PlayerAreaMap extends AreaMap<ServerPlayer> {
-+public class PlayerAreaMap extends AreaMap<ServerPlayer> { // Pufferfish - not actually final
- 
-     public PlayerAreaMap() {
-         super();
-diff --git a/src/main/java/gg/pufferfish/pufferfish/util/AsyncPlayerAreaMap.java b/src/main/java/gg/pufferfish/pufferfish/util/AsyncPlayerAreaMap.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..fdcb62d12164024a5f354d60cc863821a18d1b2a
---- /dev/null
-+++ b/src/main/java/gg/pufferfish/pufferfish/util/AsyncPlayerAreaMap.java
-@@ -0,0 +1,31 @@
-+package gg.pufferfish.pufferfish.util;
-+
-+import com.destroystokyo.paper.util.misc.PlayerAreaMap;
-+import com.destroystokyo.paper.util.misc.PooledLinkedHashSets;
-+import java.util.concurrent.ConcurrentHashMap;
-+import net.minecraft.server.level.ServerPlayer;
-+
-+public final class AsyncPlayerAreaMap extends PlayerAreaMap {
-+	
-+	public AsyncPlayerAreaMap() {
-+		super();
-+		this.areaMap = new Long2ObjectOpenHashMapWrapper<>(new ConcurrentHashMap<>(1024, 0.7f));
-+	}
-+	
-+	public AsyncPlayerAreaMap(final PooledLinkedHashSets<ServerPlayer> pooledHashSets) {
-+		super(pooledHashSets);
-+		this.areaMap = new Long2ObjectOpenHashMapWrapper<>(new ConcurrentHashMap<>(1024, 0.7f));
-+	}
-+	
-+	public AsyncPlayerAreaMap(final PooledLinkedHashSets<ServerPlayer> pooledHashSets, final ChangeCallback<ServerPlayer> addCallback,
-+			final ChangeCallback<ServerPlayer> removeCallback) {
-+		this(pooledHashSets, addCallback, removeCallback, null);
-+	}
-+	
-+	public AsyncPlayerAreaMap(final PooledLinkedHashSets<ServerPlayer> pooledHashSets, final ChangeCallback<ServerPlayer> addCallback,
-+			final ChangeCallback<ServerPlayer> removeCallback, final ChangeSourceCallback<ServerPlayer> changeSourceCallback) {
-+		super(pooledHashSets, addCallback, removeCallback, changeSourceCallback);
-+		this.areaMap = new Long2ObjectOpenHashMapWrapper<>(new ConcurrentHashMap<>(1024, 0.7f));
-+	}
-+
-+}
-diff --git a/src/main/java/gg/pufferfish/pufferfish/util/Long2ObjectOpenHashMapWrapper.java b/src/main/java/gg/pufferfish/pufferfish/util/Long2ObjectOpenHashMapWrapper.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..facd55463d44cb7e3d2ca6892982f5497b8dded1
---- /dev/null
-+++ b/src/main/java/gg/pufferfish/pufferfish/util/Long2ObjectOpenHashMapWrapper.java
-@@ -0,0 +1,40 @@
-+package gg.pufferfish.pufferfish.util;
-+
-+import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
-+import java.util.Map;
-+import org.jetbrains.annotations.Nullable;
-+
-+public class Long2ObjectOpenHashMapWrapper<V> extends Long2ObjectOpenHashMap<V> {
-+	
-+	private final Map<Long, V> backingMap;
-+	
-+	public Long2ObjectOpenHashMapWrapper(Map<Long, V> map) {
-+		backingMap = map;
-+	}
-+	
-+	@Override
-+	public V put(Long key, V value) {
-+		return backingMap.put(key, value);
-+	}
-+	
-+	@Override
-+	public V get(Object key) {
-+		return backingMap.get(key);
-+	}
-+	
-+	@Override
-+	public V remove(Object key) {
-+		return backingMap.remove(key);
-+	}
-+	
-+	@Nullable
-+	@Override
-+	public V putIfAbsent(Long key, V value) {
-+		return backingMap.putIfAbsent(key, value);
-+	}
-+	
-+	@Override
-+	public int size() {
-+		return backingMap.size();
-+	}
-+}
-diff --git a/src/main/java/io/papermc/paper/threadedregions/RegionizedWorldData.java b/src/main/java/io/papermc/paper/threadedregions/RegionizedWorldData.java
-index 7ca275826609bcf96f103a8c50beaa47c3b4068b..dc5399bd5dba9dd33a7cfd644327c2568a6ad051 100644
---- a/src/main/java/io/papermc/paper/threadedregions/RegionizedWorldData.java
-+++ b/src/main/java/io/papermc/paper/threadedregions/RegionizedWorldData.java
-@@ -4,6 +4,7 @@ import com.destroystokyo.paper.util.maplist.ReferenceList;
- import com.destroystokyo.paper.util.misc.PlayerAreaMap;
- import com.destroystokyo.paper.util.misc.PooledLinkedHashSets;
- import com.mojang.logging.LogUtils;
-+import gg.pufferfish.pufferfish.util.AsyncPlayerAreaMap;
- import io.papermc.paper.chunk.system.scheduling.ChunkHolderManager;
- import io.papermc.paper.util.CoordinateUtils;
- import io.papermc.paper.util.TickThread;
-@@ -14,6 +15,7 @@ import it.unimi.dsi.fastutil.longs.Long2ReferenceMap;
- import it.unimi.dsi.fastutil.longs.Long2ReferenceOpenHashMap;
- import it.unimi.dsi.fastutil.objects.ObjectLinkedOpenHashSet;
- import it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet;
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.CrashReport;
- import net.minecraft.ReportedException;
- import net.minecraft.core.BlockPos;
-@@ -58,6 +60,10 @@ import java.util.HashMap;
- import java.util.Iterator;
- import java.util.List;
- import java.util.Map;
-+import java.util.concurrent.CompletableFuture;
-+import java.util.concurrent.LinkedBlockingQueue;
-+import java.util.concurrent.ThreadPoolExecutor;
-+import java.util.concurrent.TimeUnit;
- import java.util.function.Consumer;
- import java.util.function.Predicate;
- 
-@@ -145,6 +151,10 @@ public final class RegionizedWorldData {
-                 into.wanderingTraderSpawnDelay = Math.max(from.wanderingTraderSpawnDelay, into.wanderingTraderSpawnDelay);
-                 into.wanderingTraderSpawnChance = Math.max(from.wanderingTraderSpawnChance, into.wanderingTraderSpawnChance);
-             }
-+
-+            //Luminol start - Async mob spawning
-+            from.lastAsyncSpawnStateTask = null; //Discard the task currently processing
-+            //Luminol end
-         }
- 
-         @Override
-@@ -302,6 +312,10 @@ public final class RegionizedWorldData {
-                 regionizedWorldData.wanderingTraderSpawnDelay = from.wanderingTraderSpawnDelay;
-                 regionizedWorldData.villageSiegeState = new VillageSiegeState(); // just re set it, as the spawn pos will be invalid
-             }
-+
-+            //Luminol start - Async mob spawning
-+            from.lastAsyncSpawnStateTask = null; //Reset the task
-+            //Luminol end
-         }
-     };
- 
-@@ -398,6 +412,22 @@ public final class RegionizedWorldData {
-     public java.util.ArrayDeque<net.minecraft.world.level.block.RedstoneTorchBlock.Toggle> redstoneUpdateInfos;
-     public final Long2IntOpenHashMap chunksBeingWorkedOn = new Long2IntOpenHashMap();
- 
-+    //Luminol start - Asnc mob spawning
-+    public volatile CompletableFuture<NaturalSpawner.SpawnState> lastAsyncSpawnStateTask = null;
-+    public static ThreadPoolExecutor ASYNC_MOB_SPAWNING_EXECUTOR;
-+    public static void initMobSpawningExecutor(){
-+        if (LuminolConfig.enableAsyncMobSpawning){
-+            ASYNC_MOB_SPAWNING_EXECUTOR = new ThreadPoolExecutor(
-+                    1,
-+                    Integer.MAX_VALUE,
-+                    1,
-+                    TimeUnit.MINUTES,
-+                    new LinkedBlockingQueue<>()
-+            );
-+        }
-+    }
-+    //Luminol end
-+
-     public static final class TempCollisionList<T> {
-         final UnsafeList<T> list = new UnsafeList<>(64);
-         boolean inUse;
-@@ -430,7 +460,7 @@ public final class RegionizedWorldData {
- 
-     // Mob spawning
-     private final PooledLinkedHashSets<ServerPlayer> pooledHashSets = new PooledLinkedHashSets<>();
--    public final PlayerAreaMap mobSpawnMap = new PlayerAreaMap(this.pooledHashSets);
-+    public final PlayerAreaMap mobSpawnMap = new AsyncPlayerAreaMap(this.pooledHashSets); //Luminol - Async mob spawning
-     public int catSpawnerNextTick = 0;
-     public int patrolSpawnerNextTick = 0;
-     public int phantomSpawnerNextTick = 0;
-diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
-index e8cd180bab5c196db09ded74aea676b4412fc6e9..534f54be1495b1a8f754bec0eb1aba8306c1d902 100644
---- a/src/main/java/me/earthme/luminol/LuminolConfig.java
-+++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
-@@ -2,6 +2,7 @@ package me.earthme.luminol;
- 
- import dev.kaiijumc.kaiiju.region.RegionFileFormat;
- import com.electronwill.nightconfig.core.file.CommentedFileConfig;
-+import io.papermc.paper.threadedregions.RegionizedWorldData;
- import me.earthme.luminol.commands.TpsBarCommand;
- import me.earthme.luminol.functions.GlobalServerTpsBar;
- import net.minecraft.core.registries.BuiltInRegistries;
-@@ -62,6 +63,7 @@ public class LuminolConfig {
-     public static boolean asyncPathProcessing = false;
-     public static int asyncPathProcessingMaxThreads = 0;
-     public static int asyncPathProcessingKeepalive = 60;
-+    public static boolean enableAsyncMobSpawning = false;
- 
-     public static void init() throws IOException {
-         PARENT_FOLDER.mkdir();
-@@ -188,6 +190,8 @@ public class LuminolConfig {
-             asyncPathProcessingMaxThreads = Math.max(Runtime.getRuntime().availableProcessors() / 4, 1);
-         if (!asyncPathProcessing)
-             asyncPathProcessingMaxThreads = 0;
-+        enableAsyncMobSpawning = get("optimizations.enable_async_mob_spawning",enableAsyncMobSpawning);
-+        RegionizedWorldData.initMobSpawningExecutor();
-     }
- 
-     public static <T> T get(String key,T def){
-diff --git a/src/main/java/me/earthme/luminol/utils/AsyncMobSpawnExecutor.java b/src/main/java/me/earthme/luminol/utils/AsyncMobSpawnExecutor.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..88d5b188ccfb17fe1ae4b08f32565f27569cad5c
---- /dev/null
-+++ b/src/main/java/me/earthme/luminol/utils/AsyncMobSpawnExecutor.java
-@@ -0,0 +1,71 @@
-+package me.earthme.luminol.utils;
-+
-+import ca.spottedleaf.concurrentutil.collection.MultiThreadedQueue;
-+import net.minecraft.server.MinecraftServer;
-+import org.jetbrains.annotations.NotNull;
-+
-+import java.util.concurrent.Executor;
-+import java.util.concurrent.atomic.AtomicBoolean;
-+import java.util.concurrent.locks.LockSupport;
-+
-+public class AsyncMobSpawnExecutor implements Runnable, Executor {
-+    private final MultiThreadedQueue<Runnable> allTasks = new MultiThreadedQueue<>();
-+    private final Thread worker = new Thread(this);
-+    private AtomicBoolean shouldRunNext = new AtomicBoolean(true);
-+    private AtomicBoolean isRunning = new AtomicBoolean(false);
-+    private AtomicBoolean isIdle = new AtomicBoolean(false);
-+
-+    public boolean isRunning(){
-+        return this.isRunning.get();
-+    }
-+
-+    public void startExecutor(){
-+        this.worker.setDaemon(true);
-+        this.worker.setContextClassLoader(MinecraftServer.class.getClassLoader());
-+        this.worker.start();
-+    }
-+
-+    public void forceTerminate(){
-+        this.shouldRunNext.set(false);
-+        if (this.isRunning.get()){
-+            this.allTasks.clear();
-+            LockSupport.unpark(this.worker);
-+        }
-+    }
-+
-+    public void dropAllTasks(){
-+        this.allTasks.clear();
-+    }
-+
-+    @Override
-+    public void run() {
-+        this.isRunning.set(true);
-+        try {
-+            while (this.shouldRunNext.get()){
-+                final Runnable task = this.allTasks.poll();
-+                if (task != null){
-+                    this.isIdle.set(false);
-+
-+                    try {
-+                        task.run();
-+                    }catch (Exception e){
-+                        e.printStackTrace(); //TODO - Exception processing?
-+                    }
-+
-+                    continue;
-+                }
-+
-+                this.isIdle.set(true);
-+                LockSupport.park();
-+            }
-+        }finally {
-+            this.isRunning.set(false);
-+        }
-+    }
-+
-+    @Override
-+    public void execute(@NotNull Runnable command) {
-+        this.allTasks.offer(command);
-+        LockSupport.unpark(this.worker); //Notify
-+    }
-+}
-diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-index b9b1dfe04eda8498f0ceff0aee66489d2a02b814..c470eafef884075b6e4d170adc2ced96a4beb517 100644
---- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-+++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
-@@ -11,13 +11,15 @@ import java.util.Collections;
- import java.util.Iterator;
- import java.util.List;
- import java.util.Objects;
--import java.util.Optional;
- import java.util.concurrent.CompletableFuture;
- import java.util.concurrent.Executor;
- import java.util.function.BooleanSupplier;
- import java.util.function.Consumer;
- import java.util.function.Supplier;
- import javax.annotation.Nullable;
-+
-+import io.papermc.paper.threadedregions.RegionizedWorldData;
-+import me.earthme.luminol.LuminolConfig;
- import net.minecraft.Util;
- import net.minecraft.core.BlockPos;
- import net.minecraft.core.SectionPos;
-@@ -487,32 +489,38 @@ public class ServerChunkCache extends ChunkSource {
-             this.level.timings.countNaturalMobs.startTiming(); // Paper - timings
-             int l = this.distanceManager.getNaturalSpawnChunkCount();
-             // Paper start - per player mob spawning
--            NaturalSpawner.SpawnState spawnercreature_d; // moved down
-+            NaturalSpawner.SpawnState spawnercreature_d = null; // moved down
-             profiler.startTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.MOB_SPAWN_ENTITY_COUNT); try { // Folia - profiler
--            if ((this.spawnFriendlies || this.spawnEnemies) && this.level.paperConfig().entities.spawning.perPlayerMobSpawns) { // don't count mobs when animals and monsters are disabled
--                // re-set mob counts
--                for (ServerPlayer player : regionizedWorldData.getLocalPlayers()) { // Folia - region threading
--                    // Paper start - per player mob spawning backoff
--                    for (int ii = 0; ii < ServerPlayer.MOBCATEGORY_TOTAL_ENUMS; ii++) {
--                        player.mobCounts[ii] = 0;
--
--                        int newBackoff = player.mobBackoffCounts[ii] - 1; // TODO make configurable bleed // TODO use nonlinear algorithm?
--                        if (newBackoff < 0) {
--                            newBackoff = 0;
-+            if (!LuminolConfig.enableAsyncMobSpawning){ //Luminol
-+                if ((this.spawnFriendlies || this.spawnEnemies) && this.level.paperConfig().entities.spawning.perPlayerMobSpawns) { // don't count mobs when animals and monsters are disabled
-+                    // re-set mob counts
-+                    for (ServerPlayer player : regionizedWorldData.getLocalPlayers()) { // Folia - region threading
-+                        // Paper start - per player mob spawning backoff
-+                        for (int ii = 0; ii < ServerPlayer.MOBCATEGORY_TOTAL_ENUMS; ii++) {
-+                            player.mobCounts[ii] = 0;
-+
-+                            int newBackoff = player.mobBackoffCounts[ii] - 1; // TODO make configurable bleed // TODO use nonlinear algorithm?
-+                            if (newBackoff < 0) {
-+                                newBackoff = 0;
-+                            }
-+                            player.mobBackoffCounts[ii] = newBackoff;
-                         }
--                        player.mobBackoffCounts[ii] = newBackoff;
-+                        // Paper end - per player mob spawning backoff
-                     }
--                    // Paper end - per player mob spawning backoff
-+                    spawnercreature_d = NaturalSpawner.createState(l, regionizedWorldData.getLoadedEntities(), this::getFullChunk, null, true); // Folia - region threading
-+                } else {
-+                    spawnercreature_d = NaturalSpawner.createState(l, regionizedWorldData.getLoadedEntities(), this::getFullChunk, !this.level.paperConfig().entities.spawning.perPlayerMobSpawns ? new LocalMobCapCalculator(this.chunkMap) : null, false); // Folia - region threading
-                 }
--                spawnercreature_d = NaturalSpawner.createState(l, regionizedWorldData.getLoadedEntities(), this::getFullChunk, null, true); // Folia - region threading
--            } else {
--                spawnercreature_d = NaturalSpawner.createState(l, regionizedWorldData.getLoadedEntities(), this::getFullChunk, !this.level.paperConfig().entities.spawning.perPlayerMobSpawns ? new LocalMobCapCalculator(this.chunkMap) : null, false); // Folia - region threading
-+            }//Luminol
-+            //Luminol start - Async mob spawning
-+            if (!LuminolConfig.enableAsyncMobSpawning){
-+                regionizedWorldData.lastAsyncSpawnStateTask = CompletableFuture.completedFuture(spawnercreature_d);
-             }
-             } finally { profiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.MOB_SPAWN_ENTITY_COUNT); } // Folia - profiler
-             // Paper end
-             this.level.timings.countNaturalMobs.stopTiming(); // Paper - timings
- 
--            regionizedWorldData.lastSpawnState = spawnercreature_d; // Folia - region threading
-+            //regionizedWorldData.lastSpawnState = spawnercreature_d; // Folia - region threading //Luminol - Async mob spawning
-             gameprofilerfiller.popPush("filteringLoadedChunks");
-             // Paper - optimise chunk tick iteration
-             // Paper - optimise chunk tick iteration
-@@ -610,7 +618,12 @@ public class ServerChunkCache extends ChunkSource {
-                     chunk1.incrementInhabitedTime(j);
-                     if (spawn && flag2 && (this.spawnEnemies || this.spawnFriendlies) && this.level.getWorldBorder().isWithinBounds(chunkcoordintpair)) { // Spigot // Paper - optimise chunk tick iteration
-                         ++spawnChunkCount; // Folia - profiler
--                        NaturalSpawner.spawnForChunk(this.level, chunk1, spawnercreature_d, this.spawnFriendlies, this.spawnEnemies, flag1);
-+
-+                        //Luminol start - Async mob spawning
-+                        if (regionizedWorldData.lastAsyncSpawnStateTask != null && regionizedWorldData.lastAsyncSpawnStateTask.isDone()){
-+                            NaturalSpawner.spawnForChunk(this.level, chunk1, regionizedWorldData.lastAsyncSpawnStateTask.join(), this.spawnFriendlies, this.spawnEnemies, flag1);
-+                        }
-+                        //Luminol end
-                     }
- 
-                     if (true || this.level.shouldTickBlocksAt(chunkcoordintpair.toLong())) { // Paper - optimise chunk tick iteration
-@@ -667,6 +680,36 @@ public class ServerChunkCache extends ChunkSource {
-             gameprofilerfiller.pop();
-             gameprofilerfiller.pop();
-             this.chunkMap.tick();
-+
-+            //Luminol start - Async mob spawning
-+            if (LuminolConfig.enableAsyncMobSpawning){
-+                //Luminol - Copied down
-+                if ((this.spawnFriendlies || this.spawnEnemies) && this.level.paperConfig().entities.spawning.perPlayerMobSpawns) { // don't count mobs when animals and monsters are disabled
-+                    // re-set mob counts
-+                    for (ServerPlayer player : regionizedWorldData.getLocalPlayers()) { // Folia - region threading
-+                        // Paper start - per player mob spawning backoff
-+                        for (int ii = 0; ii < ServerPlayer.MOBCATEGORY_TOTAL_ENUMS; ii++) {
-+                            player.mobCounts[ii] = 0;
-+
-+                            int newBackoff = player.mobBackoffCounts[ii] - 1; // TODO make configurable bleed // TODO use nonlinear algorithm?
-+                            if (newBackoff < 0) {
-+                                newBackoff = 0;
-+                            }
-+                            player.mobBackoffCounts[ii] = newBackoff;
-+                        }
-+                        // Paper end - per player mob spawning backoff
-+                    }
-+
-+                    if (regionizedWorldData.lastAsyncSpawnStateTask == null || regionizedWorldData.lastAsyncSpawnStateTask.isDone()){
-+                        regionizedWorldData.lastAsyncSpawnStateTask = CompletableFuture.supplyAsync(() -> NaturalSpawner.createState(l, regionizedWorldData.getLoadedEntities(), this::getFullChunk, null, true),RegionizedWorldData.ASYNC_MOB_SPAWNING_EXECUTOR);
-+                    }
-+                } else {
-+                    if (regionizedWorldData.lastAsyncSpawnStateTask == null || regionizedWorldData.lastAsyncSpawnStateTask.isDone()){
-+                        regionizedWorldData.lastAsyncSpawnStateTask = CompletableFuture.supplyAsync(() -> NaturalSpawner.createState(l, regionizedWorldData.getLoadedEntities(), this::getFullChunk, !this.level.paperConfig().entities.spawning.perPlayerMobSpawns ? new LocalMobCapCalculator(this.chunkMap) : null, false), RegionizedWorldData.ASYNC_MOB_SPAWNING_EXECUTOR);
-+                    }
-+                }
-+            }
-+            //Luminol end
-         }
-     }
- 
-@@ -809,7 +852,7 @@ public class ServerChunkCache extends ChunkSource {
-     @VisibleForDebug
-     public NaturalSpawner.SpawnState getLastSpawnState() {
-         io.papermc.paper.threadedregions.RegionizedWorldData worldData = this.level.getCurrentWorldData(); // Folia - region threading
--        return worldData == null ? null : worldData.lastSpawnState; // Folia - region threading
-+        return worldData.lastAsyncSpawnStateTask != null && worldData.lastAsyncSpawnStateTask.isDone() ? worldData.lastAsyncSpawnStateTask.join() : null; // Folia - region threading //Luminol - Async mob spawning
-     }
- 
-     public void removeTicketsOnClosing() {
-diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
-index 5caca2a34849189ea42d2699f6d8672e0d7251cb..b21243d494fd1989e7d6c2b98b08e090dc2f38b7 100644
---- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java
-+++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
-@@ -1,6 +1,9 @@
- package net.minecraft.world.level;
- 
-+import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor;
- import com.mojang.logging.LogUtils;
-+import io.papermc.paper.threadedregions.RegionizedServer;
-+import io.papermc.paper.util.TickThread;
- import it.unimi.dsi.fastutil.objects.Object2IntMap;
- import it.unimi.dsi.fastutil.objects.Object2IntMaps;
- import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
-@@ -117,6 +120,15 @@ public final class NaturalSpawner {
-                     object2intopenhashmap.addTo(enumcreaturetype, 1);
-                     // Paper start
-                     if (countMobs) {
-+                        //Luminol start - Async mob spawning
-+                        if (!TickThread.isTickThread()){
-+                            RegionizedServer.getInstance().taskQueue.queueTickTaskQueue(chunk.level,chunk.locX,chunk.locZ,()->{
-+                                chunk.level.getChunkSource().chunkMap.updatePlayerMobTypeMap(entity);
-+                            });
-+                            return;
-+                        }
-+                        //Luminol end
-+
-                         chunk.level.getChunkSource().chunkMap.updatePlayerMobTypeMap(entity);
-                     }
-                     // Paper end

patches/server/0042-Added-back-worldborder-command.patch

@@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Mon, 11 Dec 2023 20:00:10 +0800
-Subject: [PATCH] Added back worldborder command
-
-
-diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java
-index 3435bdeaf723c64103f7c924ea42a4ec78f2ba01..a7732effbb2885b398d18df2e581f7a0f279a85a 100644
---- a/src/main/java/net/minecraft/commands/Commands.java
-+++ b/src/main/java/net/minecraft/commands/Commands.java
-@@ -202,7 +202,7 @@ public class Commands {
-         TitleCommand.register(this.dispatcher);
-         //TriggerCommand.register(this.dispatcher); // Folia - region threading - TODO later
-         WeatherCommand.register(this.dispatcher);
--        //WorldBorderCommand.register(this.dispatcher); // Folia - region threading - TODO later
-+        WorldBorderCommand.register(this.dispatcher); // Folia - region threading - TODO later //Lumino - Add back world border
-         if (JvmProfiler.INSTANCE.isAvailable()) {
-             JfrCommand.register(this.dispatcher);
-         }

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

@@ -0,0 +1,31 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Sun, 28 Jan 2024 09:30:22 +0000
+Subject: [PATCH] Gale Check frozen ticks before landing block
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index c2d155882c94f875c96c13746ff0c5433ab25ed0..84b47e6cea7ed9730f9c450ba8ba3167d71b2cc9 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -597,11 +597,10 @@ public abstract class LivingEntity extends Entity implements Attackable {
+     }
+ 
+     protected void tryAddFrost() {
+-        if (!this.getBlockStateOnLegacy().isAir()) {
+             int i = this.getTicksFrozen();
+ 
+             if (i > 0) {
+-                AttributeInstance attributemodifiable = this.getAttribute(Attributes.MOVEMENT_SPEED);
++                AttributeInstance attributemodifiable = this.getBlockStateOnLegacy().isAir() ? null : this.getAttribute(Attributes.MOVEMENT_SPEED); // Gale - Lithium - check frozen ticks before landing block
+ 
+                 if (attributemodifiable == null) {
+                     return;
+@@ -611,7 +610,6 @@ public abstract class LivingEntity extends Entity implements Attackable {
+ 
+                 attributemodifiable.addTransientModifier(new AttributeModifier(LivingEntity.SPEED_MODIFIER_POWDER_SNOW_UUID, "Powder snow slow", (double) f, AttributeModifier.Operation.ADDITION));
+             }
+-        }
+ 
+     }
+ 

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

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Sun, 28 Jan 2024 09:31:27 +0000
+Subject: [PATCH] Gale Don't trigger lootable refresh for non-player
+ interaction
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
+index a5cd70b6ada2b44f64db0985483ee5eadc67003f..e49be65c2d379027c2821c0db7f151bc3cd20a4b 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
+@@ -68,6 +68,7 @@ public abstract class RandomizableContainerBlockEntity extends BaseContainerBloc
+ 
+     @Override
+     public void unpackLootTable(@org.jetbrains.annotations.Nullable final Player player) {
++        if (player == null) return; // Gale - EMC - don't trigger lootable refresh for non-player interaction
+         // Copied from super with changes, always check the original method
+         net.minecraft.world.level.Level level = this.getLevel();
+         BlockPos blockPos = this.getBlockPos();

patches/server/0044-Gale-Use-platform-math-functions.patch

@@ -0,0 +1,187 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Sun, 28 Jan 2024 09:31:27 +0000
+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/src/main/java/io/papermc/paper/util/MCUtil.java b/src/main/java/io/papermc/paper/util/MCUtil.java
+index 49ccb27a17bec1d4ff31bc8d72e4724d65adc20c..34ccd489268c51c0aeecf5918878122b49c8d123 100644
+--- a/src/main/java/io/papermc/paper/util/MCUtil.java
++++ b/src/main/java/io/papermc/paper/util/MCUtil.java
+@@ -168,13 +168,11 @@ public final class MCUtil {
+     }
+ 
+     public static int fastFloor(double x) {
+-        int truncated = (int)x;
+-        return x < (double)truncated ? truncated - 1 : truncated;
++        return (int) Math.floor(x); // Gale - use platform math functions
+     }
+ 
+     public static int fastFloor(float x) {
+-        int truncated = (int)x;
+-        return x < (double)truncated ? truncated - 1 : truncated;
++        return (int) Math.floor(x); // Gale - use platform math functions
+     }
+ 
+     public static float normalizeYaw(float f) {
+@@ -235,11 +233,11 @@ public final class MCUtil {
+     }
+ 
+     public static int getChunkCoordinate(final double coordinate) {
+-        return MCUtil.fastFloor(coordinate) >> 4;
++        return ((int) Math.floor(coordinate)) >> 4; // Gale - use platform math functions
+     }
+ 
+     public static int getBlockCoordinate(final double coordinate) {
+-        return MCUtil.fastFloor(coordinate);
++        return (int) Math.floor(coordinate); // Gale - use platform math functions
+     }
+ 
+     public static long getBlockKey(final int x, final int y, final int z) {
+diff --git a/src/main/java/net/minecraft/util/Mth.java b/src/main/java/net/minecraft/util/Mth.java
+index 03854a2d26a3cfc1817acfdc28cbf151ba59e05b..d9e0224dc108a99c194d4947d18f2d855a341534 100644
+--- a/src/main/java/net/minecraft/util/Mth.java
++++ b/src/main/java/net/minecraft/util/Mth.java
+@@ -56,13 +56,11 @@ public class Mth {
+     }
+ 
+     public static int floor(float value) {
+-        int i = (int)value;
+-        return value < (float)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 < (double)i ? i - 1 : i;
++        return (int) Math.floor(value); // Gale - use platform math functions
+     }
+ 
+     public static long lfloor(double value) {
+@@ -79,13 +77,11 @@ public class Mth {
+     }
+ 
+     public static int ceil(float value) {
+-        int i = (int)value;
+-        return value > (float)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 > (double)i ? i + 1 : i;
++        return (int) Math.ceil(value); // Gale - use platform math functions
+     }
+ 
+     public static int clamp(int value, int min, int max) {
+@@ -121,15 +117,7 @@ public class Mth {
+     }
+ 
+     public static double absMax(double a, double b) {
+-        if (a < 0.0D) {
+-            a = -a;
+-        }
+-
+-        if (b < 0.0D) {
+-            b = -b;
+-        }
+-
+-        return Math.max(a, b);
++        return Math.max(Math.abs(a), Math.abs(b)); // Gale - use platform math functions
+     }
+ 
+     public static int floorDiv(int dividend, int divisor) {

patches/server/0045-Gale-Skip-entity-move-if-movement-is-zero.patch

@@ -0,0 +1,42 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Tue, 6 Feb 2024 04:21:05 +0000
+Subject: [PATCH] Gale Skip entity move if movement is zero
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index a4682b8bd269f52af26a03347e8d3869d2b1ba41..d78ad18ac3b69c893a23b6bb9a6837b6a82ebdc2 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -319,6 +319,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+     public float yRotO;
+     public float xRotO;
+     private AABB bb;
++    private boolean boundingBoxChanged = false; // Gale - VMP - skip entity move if movement is zero
+     public boolean onGround;
+     public boolean horizontalCollision;
+     public boolean verticalCollision;
+@@ -1104,6 +1105,11 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+     //Luminol end
+ 
+     public void move(MoverType movementType, 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
+         io.papermc.paper.util.TickThread.ensureTickThread("Cannot move an entity off-main");
+@@ -4957,6 +4963,11 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+     }
+ 
+     public final void setBoundingBox(AABB boundingBox) {
++        // Gale start - VMP - skip entity move if movement is zero
++        if (!this.bb.equals(boundingBox)) {
++            this.boundingBoxChanged = true;
++        }
++        // Gale end - VMP - skip entity move if movement is zero
+         // CraftBukkit start - block invalid bounding boxes
+         double minX = boundingBox.minX,
+                 minY = boundingBox.minY,

patches/server/0046-Gale-Optimize-world-generation-chunk-and-block-acces.patch

@@ -0,0 +1,192 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Fri, 9 Feb 2024 23:43:16 +0000
+Subject: [PATCH] Gale Optimize world generation chunk and block access
+
+
+diff --git a/src/main/java/me/jellysquid/mods/lithium/common/util/Pos.java b/src/main/java/me/jellysquid/mods/lithium/common/util/Pos.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..f2f10b651e4fbecdd1ea1bc28ebf40d685a67cee
+--- /dev/null
++++ b/src/main/java/me/jellysquid/mods/lithium/common/util/Pos.java
+@@ -0,0 +1,95 @@
++// Gale - Lithium - position utility
++
++package me.jellysquid.mods.lithium.common.util;
++
++import net.minecraft.core.SectionPos;
++import net.minecraft.world.level.LevelHeightAccessor;
++
++public class Pos {
++
++    public static class BlockCoord {
++        public static int getYSize(LevelHeightAccessor view) {
++            return view.getHeight();
++        }
++        public static int getMinY(LevelHeightAccessor view) {
++            return view.getMinBuildHeight();
++        }
++        public static int getMaxYInclusive(LevelHeightAccessor view) {
++            return view.getMaxBuildHeight() - 1;
++        }
++        public static int getMaxYExclusive(LevelHeightAccessor view) {
++            return view.getMaxBuildHeight();
++        }
++
++        public static int getMaxInSectionCoord(int sectionCoord) {
++            return 15 + getMinInSectionCoord(sectionCoord);
++        }
++
++        public static int getMaxYInSectionIndex(LevelHeightAccessor view, int sectionIndex){
++            return getMaxInSectionCoord(SectionYCoord.fromSectionIndex(view, sectionIndex));
++        }
++
++        public static int getMinInSectionCoord(int sectionCoord) {
++            return SectionPos.sectionToBlockCoord(sectionCoord);
++        }
++
++        public static int getMinYInSectionIndex(LevelHeightAccessor view, int sectionIndex) {
++            return getMinInSectionCoord(SectionYCoord.fromSectionIndex(view, sectionIndex));
++        }
++    }
++
++    public static class ChunkCoord {
++        public static int fromBlockCoord(int blockCoord) {
++            return SectionPos.blockToSectionCoord(blockCoord);
++        }
++
++        public static int fromBlockSize(int i) {
++            return i >> 4; //same method as fromBlockCoord, just be clear about coord/size semantic difference
++        }
++    }
++
++    public static class SectionYCoord {
++        public static int getNumYSections(LevelHeightAccessor view) {
++            return view.getSectionsCount();
++        }
++        public static int getMinYSection(LevelHeightAccessor view) {
++            return view.getMinSection();
++        }
++        public static int getMaxYSectionInclusive(LevelHeightAccessor view) {
++            return view.getMaxSection() - 1;
++        }
++        public static int getMaxYSectionExclusive(LevelHeightAccessor view) {
++            return view.getMaxSection();
++        }
++
++        public static int fromSectionIndex(LevelHeightAccessor view, int sectionCoord) {
++            return sectionCoord + SectionYCoord.getMinYSection(view);
++        }
++        public static int fromBlockCoord(int blockCoord) {
++            return SectionPos.blockToSectionCoord(blockCoord);
++        }
++    }
++
++    public static class SectionYIndex {
++        public static int getNumYSections(LevelHeightAccessor view) {
++            return view.getSectionsCount();
++        }
++        public static int getMinYSectionIndex(LevelHeightAccessor view) {
++            return 0;
++        }
++        public static int getMaxYSectionIndexInclusive(LevelHeightAccessor view) {
++            return view.getSectionsCount() - 1;
++        }
++        public static int getMaxYSectionIndexExclusive(LevelHeightAccessor view) {
++            return view.getSectionsCount();
++        }
++
++        public static int fromSectionCoord(LevelHeightAccessor view, int sectionCoord) {
++            return sectionCoord - SectionYCoord.getMinYSection(view);
++        }
++        public static int fromBlockCoord(LevelHeightAccessor view, int blockCoord) {
++            return fromSectionCoord(view, SectionPos.blockToSectionCoord(blockCoord));
++        }
++    }
++
++}
+diff --git a/src/main/java/net/minecraft/server/level/WorldGenRegion.java b/src/main/java/net/minecraft/server/level/WorldGenRegion.java
+index 33c1ef45ed620f8424c2c83dd30b674892ddffe3..60db67956d8455d02c7b315cbdcb952206d776db 100644
+--- a/src/main/java/net/minecraft/server/level/WorldGenRegion.java
++++ b/src/main/java/net/minecraft/server/level/WorldGenRegion.java
+@@ -8,6 +8,7 @@ import java.util.concurrent.atomic.AtomicLong;
+ import java.util.function.Predicate;
+ import java.util.function.Supplier;
+ import javax.annotation.Nullable;
++
+ import net.minecraft.Util;
+ import net.minecraft.core.BlockPos;
+ import net.minecraft.core.Direction;
+@@ -83,6 +84,10 @@ public class WorldGenRegion implements WorldGenLevel {
+     private Supplier<String> currentlyGenerating;
+     private final AtomicLong subTickCount = new AtomicLong();
+     private static final ResourceLocation WORLDGEN_REGION_RANDOM = new ResourceLocation("worldgen_region_random");
++    // Gale start - Lithium - optimize world generation chunk and block access
++    private ChunkAccess[] chunksArr;
++    private int minChunkX, minChunkZ;
++    // Gale end - Lithium - optimize world generation chunk and block access
+ 
+     // Folia start - region threading
+     @Override
+@@ -112,6 +117,11 @@ public class WorldGenRegion implements WorldGenLevel {
+             this.lastPos = ((ChunkAccess) chunks.get(chunks.size() - 1)).getPos();
+             this.structureManager = world.structureManager().forWorldGenRegion(this);
+         }
++        // Gale start - Lithium - optimize world generation chunk and block access
++        this.minChunkX = this.firstPos.x;
++        this.minChunkZ = this.firstPos.z;
++        this.chunksArr = chunks.toArray(new ChunkAccess[0]);
++        // Gale end - Lithium - optimize world generation chunk and block access
+     }
+ 
+     // Paper start - starlight
+@@ -150,9 +160,29 @@ public class WorldGenRegion implements WorldGenLevel {
+ 
+     @Override
+     public ChunkAccess getChunk(int chunkX, int chunkZ) {
+-        return this.getChunk(chunkX, chunkZ, ChunkStatus.EMPTY);
++        // Gale start - Lithium - optimize world generation chunk and block access - use the chunk array for faster access
++        int x = chunkX - this.minChunkX;
++        int z = chunkZ - this.minChunkZ;
++        int w = this.size;
++
++        if (x >= 0 && z >= 0 && x < w && z < w) {
++            return this.chunksArr[x + z * w];
++        } else {
++            throw new NullPointerException("No chunk exists at " + new ChunkPos(chunkX, chunkZ));
++        }
++        // Gale end - Lithium - optimize world generation chunk and block access - use the chunk array for faster access
+     }
+ 
++    // Gale start - Lithium - optimize world generation chunk and block access
++    /**
++     * Use our chunk fetch function
++     */
++    public ChunkAccess getChunk(BlockPos pos) {
++        // Skip checking chunk.getStatus().isAtLeast(ChunkStatus.EMPTY) here, because it is always true
++        return this.getChunk(SectionPos.blockToSectionCoord(pos.getX()), SectionPos.blockToSectionCoord(pos.getZ()));
++    }
++    // Gale end - Lithium - optimize world generation chunk and block access
++
+     @Nullable
+     @Override
+     public ChunkAccess getChunk(int chunkX, int chunkZ, ChunkStatus leastStatus, boolean create) {
+@@ -210,7 +240,17 @@ public class WorldGenRegion implements WorldGenLevel {
+ 
+     @Override
+     public BlockState getBlockState(BlockPos pos) {
+-        return this.getChunk(SectionPos.blockToSectionCoord(pos.getX()), SectionPos.blockToSectionCoord(pos.getZ())).getBlockState(pos);
++        // Gale start - Lithium - optimize world generation chunk and block access - avoid pointer de-referencing, make method easier to inline
++        int x = SectionPos.blockToSectionCoord(pos.getX()) - this.minChunkX;
++        int z = SectionPos.blockToSectionCoord(pos.getZ()) - this.minChunkZ;
++        int w = this.size;
++
++        if (x >= 0 && z >= 0 && x < w && z < w) {
++            return this.chunksArr[x + z * w].getBlockState(pos);
++        } else {
++            throw new NullPointerException("No chunk exists at " + new ChunkPos(pos));
++        }
++        // Gale end - Lithium - optimize world generation chunk and block access - avoid pointer de-referencing, make method easier to inline
+     }
+ 
+     @Override

patches/server/0047-Gale-Optimize-noise-generation.patch

@@ -0,0 +1,239 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Fri, 9 Feb 2024 23:44:23 +0000
+Subject: [PATCH] Gale Optimize noise generation
+
+
+diff --git a/src/main/java/net/minecraft/world/level/levelgen/synth/ImprovedNoise.java b/src/main/java/net/minecraft/world/level/levelgen/synth/ImprovedNoise.java
+index fb84d703b4461343d50510d7c9be32fc1f09ed22..93a11c95f96f975fafe03e77a2caace57675d130 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/synth/ImprovedNoise.java
++++ b/src/main/java/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.0D;
+         this.yo = random.nextDouble() * 256.0D;
+@@ -40,12 +61,14 @@ public final class ImprovedNoise {
+         double d = x + this.xo;
+         double e = y + this.yo;
+         double f = z + this.zo;
+-        int i = Mth.floor(d);
+-        int j = Mth.floor(e);
+-        int k = Mth.floor(f);
+-        double g = d - (double)i;
+-        double h = e - (double)j;
+-        double l = f - (double)k;
++        // Gale start - C2ME - optimize noise generation - optimize: remove frequent type conversions
++        double i = Math.floor(d);
++        double j = Math.floor(e);
++        double k = Math.floor(f);
++        double g = d - i;
++        double h = e - j;
++        double l = f - k;
++        // Gale end - C2ME - optimize noise generation - optimize: remove frequent type conversions
+         double o;
+         if (yScale != 0.0D) {
+             double m;
+@@ -55,25 +78,27 @@ public final class ImprovedNoise {
+                 m = h;
+             }
+ 
+-            o = (double)Mth.floor(m / yScale + (double)1.0E-7F) * yScale;
++            o = Math.floor(m / yScale + (double)1.0E-7F) * yScale; // Gale - C2ME - optimize noise generation - optimize: remove frequent type conversions
+         } else {
+             o = 0.0D;
+         }
+ 
+-        return this.sampleAndLerp(i, j, k, g, h - o, l, h);
++        return this.sampleAndLerp((int) i, (int) j, (int) k, g, h - o, l, h); // Gale - C2ME - optimize noise generation - optimize: remove frequent type conversions
+     }
+ 
+     public double noiseWithDerivative(double x, double y, double z, double[] ds) {
+         double d = x + this.xo;
+         double e = y + this.yo;
+         double f = z + this.zo;
+-        int i = Mth.floor(d);
+-        int j = Mth.floor(e);
+-        int k = Mth.floor(f);
+-        double g = d - (double)i;
+-        double h = e - (double)j;
+-        double l = f - (double)k;
+-        return this.sampleWithDerivative(i, j, k, g, h, l, ds);
++        // Gale start - C2ME - optimize noise generation - optimize: remove frequent type conversions
++        double i = Math.floor(d);
++        double j = Math.floor(e);
++        double k = Math.floor(f);
++        double g = d - i;
++        double h = e - j;
++        double l = f - k;
++        return this.sampleWithDerivative((int) i, (int) j, (int) k, g, h, l, ds);
++        // Gale end - C2ME - optimize noise generation - optimize: remove frequent type conversions
+     }
+ 
+     private static double gradDot(int hash, double x, double y, double z) {
+@@ -85,24 +110,69 @@ public final class ImprovedNoise {
+     }
+ 
+     private double sampleAndLerp(int sectionX, int sectionY, int sectionZ, double localX, double localY, double localZ, double fadeLocalY) {
+-        int i = this.p(sectionX);
+-        int j = this.p(sectionX + 1);
+-        int k = this.p(i + sectionY);
+-        int l = this.p(i + sectionY + 1);
+-        int m = this.p(j + sectionY);
+-        int n = this.p(j + sectionY + 1);
+-        double d = gradDot(this.p(k + sectionZ), localX, localY, localZ);
+-        double e = gradDot(this.p(m + sectionZ), localX - 1.0D, localY, localZ);
+-        double f = gradDot(this.p(l + sectionZ), localX, localY - 1.0D, localZ);
+-        double g = gradDot(this.p(n + sectionZ), localX - 1.0D, localY - 1.0D, localZ);
+-        double h = gradDot(this.p(k + sectionZ + 1), localX, localY, localZ - 1.0D);
+-        double o = gradDot(this.p(m + sectionZ + 1), localX - 1.0D, localY, localZ - 1.0D);
+-        double p = gradDot(this.p(l + sectionZ + 1), localX, localY - 1.0D, localZ - 1.0D);
+-        double q = gradDot(this.p(n + sectionZ + 1), localX - 1.0D, localY - 1.0D, localZ - 1.0D);
+-        double r = Mth.smoothstep(localX);
+-        double s = Mth.smoothstep(fadeLocalY);
+-        double t = Mth.smoothstep(localZ);
+-        return Mth.lerp3(r, s, t, d, e, f, g, h, o, p, q);
++        // Gale start - C2ME - optimize noise generation - inline math & small optimization: remove frequent type conversions and redundant ops
++        final int var0 = sectionX & 0xFF;
++        final int var1 = (sectionX + 1) & 0xFF;
++        final int var2 = this.p[var0] & 0xFF;
++        final int var3 = this.p[var1] & 0xFF;
++        final int var4 = (var2 + sectionY) & 0xFF;
++        final int var5 = (var3 + sectionY) & 0xFF;
++        final int var6 = (var2 + sectionY + 1) & 0xFF;
++        final int var7 = (var3 + sectionY + 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 + sectionZ) & 0xFF;
++        final int var13 = (var9 + sectionZ) & 0xFF;
++        final int var14 = (var10 + sectionZ) & 0xFF;
++        final int var15 = (var11 + sectionZ) & 0xFF;
++        final int var16 = (var8 + sectionZ + 1) & 0xFF;
++        final int var17 = (var9 + sectionZ + 1) & 0xFF;
++        final int var18 = (var10 + sectionZ + 1) & 0xFF;
++        final int var19 = (var11 + sectionZ + 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 = localX - 1.0;
++        final double var61 = localY - 1.0;
++        final double var62 = localZ - 1.0;
++        final double var87 = FLAT_SIMPLEX_GRAD[(var20) | 0] * localX + FLAT_SIMPLEX_GRAD[(var20) | 1] * localY + FLAT_SIMPLEX_GRAD[(var20) | 2] * localZ;
++        final double var88 = FLAT_SIMPLEX_GRAD[(var21) | 0] * var60 + FLAT_SIMPLEX_GRAD[(var21) | 1] * localY + FLAT_SIMPLEX_GRAD[(var21) | 2] * localZ;
++        final double var89 = FLAT_SIMPLEX_GRAD[(var22) | 0] * localX + FLAT_SIMPLEX_GRAD[(var22) | 1] * var61 + FLAT_SIMPLEX_GRAD[(var22) | 2] * localZ;
++        final double var90 = FLAT_SIMPLEX_GRAD[(var23) | 0] * var60 + FLAT_SIMPLEX_GRAD[(var23) | 1] * var61 + FLAT_SIMPLEX_GRAD[(var23) | 2] * localZ;
++        final double var91 = FLAT_SIMPLEX_GRAD[(var24) | 0] * localX + FLAT_SIMPLEX_GRAD[(var24) | 1] * localY + FLAT_SIMPLEX_GRAD[(var24) | 2] * var62;
++        final double var92 = FLAT_SIMPLEX_GRAD[(var25) | 0] * var60 + FLAT_SIMPLEX_GRAD[(var25) | 1] * localY + FLAT_SIMPLEX_GRAD[(var25) | 2] * var62;
++        final double var93 = FLAT_SIMPLEX_GRAD[(var26) | 0] * localX + 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 = localX * 6.0 - 15.0;
++        final double var96 = fadeLocalY * 6.0 - 15.0;
++        final double var97 = localZ * 6.0 - 15.0;
++        final double var98 = localX * var95 + 10.0;
++        final double var99 = fadeLocalY * var96 + 10.0;
++        final double var100 = localZ * var97 + 10.0;
++        final double var101 = localX * localX * localX * var98;
++        final double var102 = fadeLocalY * fadeLocalY * fadeLocalY * var99;
++        final double var103 = localZ * localZ * localZ * 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 sectionX, int sectionY, int sectionZ, double localX, double localY, double localZ, double[] ds) {
+diff --git a/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinNoise.java b/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinNoise.java
+index 97ef7288ea935f3d17c5b7a9eba642143c786c2b..6d084145f8529fa8b0439123f9a9812940cc62da 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinNoise.java
++++ b/src/main/java/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 */
+     @Deprecated
+@@ -131,6 +135,10 @@ public class PerlinNoise {
+         this.lowestFreqInputFactor = Math.pow(2.0D, (double)(-j));
+         this.lowestFreqValueFactor = Math.pow(2.0D, (double)(i - 1)) / (Math.pow(2.0D, (double)i) - 1.0D);
+         this.maxValue = this.edgeValue(2.0D);
++        // 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() {
+@@ -142,7 +150,27 @@ public class PerlinNoise {
+     }
+ 
+     public double getValue(double x, double y, double z) {
+-        return this.getValue(x, y, z, 0.0D, 0.0D, 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 */

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

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

patches/server/0049-Gale-Reduce-lambda-and-Optional-allocation-in-Entity.patch

@@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Sat, 6 Apr 2024 05:14:57 +0000
+Subject: [PATCH] Gale Reduce lambda and Optional allocation in
+ EntityBasedExplosionDamageCalculator
+
+
+diff --git a/src/main/java/net/minecraft/world/level/EntityBasedExplosionDamageCalculator.java b/src/main/java/net/minecraft/world/level/EntityBasedExplosionDamageCalculator.java
+index 2f9f15d99f8b31e9f13f7f32378b2a9e09bcb5e5..4e4dfb72d5a0b46917999b709c655ccfdae27183 100644
+--- a/src/main/java/net/minecraft/world/level/EntityBasedExplosionDamageCalculator.java
++++ b/src/main/java/net/minecraft/world/level/EntityBasedExplosionDamageCalculator.java
+@@ -15,9 +15,17 @@ public class EntityBasedExplosionDamageCalculator extends ExplosionDamageCalcula
+ 
+     @Override
+     public Optional<Float> getBlockExplosionResistance(Explosion explosion, BlockGetter world, BlockPos pos, BlockState blockState, FluidState fluidState) {
+-        return super.getBlockExplosionResistance(explosion, world, pos, blockState, fluidState).map((max) -> {
+-            return this.source.getBlockExplosionResistance(explosion, world, pos, blockState, fluidState, max);
+-        });
++        // Gale start - Lithium - reduce lambda and Optional allocation in EntityBasedExplosionDamageCalculator
++        Optional<Float> optionalBlastResistance = super.getBlockExplosionResistance(explosion, world, pos, blockState, fluidState);
++        if (optionalBlastResistance.isPresent()) {
++            float blastResistance = optionalBlastResistance.get();
++            float effectiveExplosionResistance = this.source.getBlockExplosionResistance(explosion, world, pos, blockState, fluidState, blastResistance);
++            if (effectiveExplosionResistance != blastResistance) {
++                return Optional.of(effectiveExplosionResistance);
++            }
++        }
++        return optionalBlastResistance;
++        // Gale end - Lithium - reduce lambda and Optional allocation in EntityBasedExplosionDamageCalculator
+     }
+ 
+     @Override

patches/server/0050-Gale-Replace-AI-goal-set-with-optimized-collection.patch

@@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Sat, 6 Apr 2024 05:17:19 +0000
+Subject: [PATCH] Gale Replace AI goal set with optimized collection
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java b/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java
+index 0f53c206b4c0607e2cda5cfa4edeae5209e897bf..6313020a80cab0b8df8d775431d4aa063c51ce18 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java
++++ b/src/main/java/net/minecraft/world/entity/ai/goal/GoalSelector.java
+@@ -13,6 +13,7 @@ import java.util.function.Supplier;
+ import java.util.stream.Stream;
+ import net.minecraft.util.profiling.ProfilerFiller;
+ import org.slf4j.Logger;
++import it.unimi.dsi.fastutil.objects.ObjectLinkedOpenHashSet;
+ 
+ public class GoalSelector {
+     private static final Logger LOGGER = LogUtils.getLogger();
+@@ -28,7 +29,7 @@ public class GoalSelector {
+         }
+     };
+     private final Map<Goal.Flag, WrappedGoal> lockedFlags = new EnumMap<>(Goal.Flag.class);
+-    private final Set<WrappedGoal> availableGoals = Sets.newLinkedHashSet();
++    private final Set<WrappedGoal> availableGoals = new ObjectLinkedOpenHashSet<>(); // Gale - Lithium - replace AI goal set with optimized collection
+     private final Supplier<ProfilerFiller> profiler;
+     private final EnumSet<Goal.Flag> disabledFlags = EnumSet.noneOf(Goal.Flag.class); // Paper unused, but dummy to prevent plugins from crashing as hard. Theyll need to support paper in a special case if this is super important, but really doesn't seem like it would be.
+     private final com.destroystokyo.paper.util.set.OptimizedSmallEnumSet<net.minecraft.world.entity.ai.goal.Goal.Flag> goalTypes = new com.destroystokyo.paper.util.set.OptimizedSmallEnumSet<>(Goal.Flag.class); // Paper - remove streams from pathfindergoalselector

patches/server/0051-Gale-Replace-AI-attributes-with-optimized-collection.patch

@@ -0,0 +1,42 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Sat, 6 Apr 2024 05:17:42 +0000
+Subject: [PATCH] Gale Replace AI attributes with optimized collections
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java b/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java
+index 683c9693754d1a87b7e8fccc757a0d0963351f60..d904cc2d882f62f74ff34f7e8266947798563ed4 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java
++++ b/src/main/java/net/minecraft/world/entity/ai/attributes/AttributeMap.java
+@@ -1,8 +1,6 @@
+ package net.minecraft.world.entity.ai.attributes;
+ 
+-import com.google.common.collect.Maps;
+ import com.google.common.collect.Multimap;
+-import com.google.common.collect.Sets;
+ import com.mojang.logging.LogUtils;
+ import java.util.Collection;
+ import java.util.Map;
+@@ -10,6 +8,9 @@ import java.util.Set;
+ import java.util.UUID;
+ import java.util.stream.Collectors;
+ import javax.annotation.Nullable;
++
++import it.unimi.dsi.fastutil.objects.Reference2ReferenceOpenHashMap;
++import it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet;
+ import net.minecraft.Util;
+ import net.minecraft.core.Holder;
+ import net.minecraft.core.registries.BuiltInRegistries;
+@@ -20,8 +21,10 @@ import org.slf4j.Logger;
+ 
+ public class AttributeMap {
+     private static final Logger LOGGER = LogUtils.getLogger();
+-    private final Map<Attribute, AttributeInstance> attributes = Maps.newHashMap();
+-    private final Set<AttributeInstance> dirtyAttributes = Sets.newHashSet();
++    // Gale start - Lithium - replace AI attributes with optimized collections
++    private final Map<Attribute, AttributeInstance> attributes = new Reference2ReferenceOpenHashMap<>(0);
++    private final Set<AttributeInstance> dirtyAttributes = new ReferenceOpenHashSet<>(0);
++    // Gale end - Lithium - replace AI attributes with optimized collections
+     private final AttributeSupplier supplier;
+     private final java.util.function.Function<Attribute, AttributeInstance> createInstance; // Pufferfish
+ 

patches/server/0052-Gale-Replace-throttle-tracker-map-with-optimized-col.patch

@@ -0,0 +1,61 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Sat, 6 Apr 2024 05:18:00 +0000
+Subject: [PATCH] Gale Replace throttle tracker map with optimized collection
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
+index a53dd1ea02bd19826cd9fd337459b08e9533bce8..dec666713a1d3b5e3f2aa4bcbe8094ade8be1b05 100644
+--- a/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerHandshakePacketListenerImpl.java
+@@ -1,5 +1,7 @@
+ package net.minecraft.server.network;
+ 
++import it.unimi.dsi.fastutil.objects.Object2LongMap;
++import it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap;
+ import net.minecraft.SharedConstants;
+ import net.minecraft.network.Connection;
+ import net.minecraft.network.chat.Component;
+@@ -13,7 +15,8 @@ import net.minecraft.server.MinecraftServer;
+ 
+ // CraftBukkit start
+ import java.net.InetAddress;
+-import java.util.HashMap;
++import java.util.Iterator;
++import java.util.Map;
+ // CraftBukkit end
+ 
+ public class ServerHandshakePacketListenerImpl implements ServerHandshakePacketListener {
+@@ -24,7 +27,7 @@ public class ServerHandshakePacketListenerImpl implements ServerHandshakePacketL
+     static final java.util.regex.Pattern PROP_PATTERN = java.util.regex.Pattern.compile("\\w{0,16}");
+     // Spigot end
+     // CraftBukkit start - add fields
+-    private static final HashMap<InetAddress, Long> throttleTracker = new HashMap<InetAddress, Long>();
++    private static final Object2LongOpenHashMap<InetAddress> throttleTracker = new Object2LongOpenHashMap<>(); // Gale - Dionysus - replace throttle tracker map with optimized collection
+     private static int throttleCounter = 0;
+     // CraftBukkit end
+     private static final Component IGNORE_STATUS_REASON = Component.translatable("disconnect.ignoring_status_request");
+@@ -51,7 +54,7 @@ public class ServerHandshakePacketListenerImpl implements ServerHandshakePacketL
+                     InetAddress address = ((java.net.InetSocketAddress) this.connection.getRemoteAddress()).getAddress();
+ 
+                     synchronized (ServerHandshakePacketListenerImpl.throttleTracker) {
+-                        if (ServerHandshakePacketListenerImpl.throttleTracker.containsKey(address) && !"127.0.0.1".equals(address.getHostAddress()) && currentTime - ServerHandshakePacketListenerImpl.throttleTracker.get(address) < connectionThrottle) {
++                        if (ServerHandshakePacketListenerImpl.throttleTracker.containsKey(address) && !"127.0.0.1".equals(address.getHostAddress()) && currentTime - ServerHandshakePacketListenerImpl.throttleTracker.getLong(address) < connectionThrottle) { // Gale - Dionysus - replace throttle tracker map with optimized collection
+                             ServerHandshakePacketListenerImpl.throttleTracker.put(address, currentTime);
+                             Component chatmessage = io.papermc.paper.adventure.PaperAdventure.asVanilla(io.papermc.paper.configuration.GlobalConfiguration.get().messages.kick.connectionThrottle); // Paper - Configurable connection throttle kick message
+                             this.connection.send(new ClientboundLoginDisconnectPacket(chatmessage));
+@@ -65,13 +68,7 @@ public class ServerHandshakePacketListenerImpl implements ServerHandshakePacketL
+                             ServerHandshakePacketListenerImpl.throttleCounter = 0;
+ 
+                             // Cleanup stale entries
+-                            java.util.Iterator iter = ServerHandshakePacketListenerImpl.throttleTracker.entrySet().iterator();
+-                            while (iter.hasNext()) {
+-                                java.util.Map.Entry<InetAddress, Long> entry = (java.util.Map.Entry) iter.next();
+-                                if (entry.getValue() > connectionThrottle) {
+-                                    iter.remove();
+-                                }
+-                            }
++                            throttleTracker.object2LongEntrySet().removeIf(entry -> entry.getLongValue() > connectionThrottle); // Gale - Dionysus - replace throttle tracker map with optimized collection
+                         }
+                     }
+                     } // Paper - Unix domain socket support

patches/server/0053-LinearPaper-Remove-all-locks-on-region-files.patch

@@ -0,0 +1,96 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 06:30:38 +0000
+Subject: [PATCH] LinearPaper Remove all locks on region files
+
+
+diff --git a/src/main/java/io/papermc/paper/chunk/system/io/RegionFileIOThread.java b/src/main/java/io/papermc/paper/chunk/system/io/RegionFileIOThread.java
+index b46acbc078f3d3bfb0f3ede3f1cc172f4b48c5df..812d8504c6abd16b34ee4abd976563f345f00d18 100644
+--- a/src/main/java/io/papermc/paper/chunk/system/io/RegionFileIOThread.java
++++ b/src/main/java/io/papermc/paper/chunk/system/io/RegionFileIOThread.java
+@@ -835,7 +835,8 @@ public final class RegionFileIOThread extends PrioritisedQueueExecutorThread {
+                     return Boolean.TRUE;
+                 }
+ 
+-                return file.hasChunk(chunkPos) ? Boolean.TRUE : Boolean.FALSE;
++                //return file.hasChunk(chunkPos) ? Boolean.TRUE : Boolean.FALSE;
++                return Boolean.TRUE;
+             });
+         }
+     }
+@@ -1146,7 +1147,7 @@ public final class RegionFileIOThread extends PrioritisedQueueExecutorThread {
+                 return function.apply(regionFile);
+             } finally {
+                 if (regionFile != null) {
+-                    regionFile.getFileLock().unlock(); // Kaiiju
++//                    regionFile.getFileLock().unlock(); // Kaiiju
+                 }
+             }
+         }
+@@ -1158,7 +1159,7 @@ public final class RegionFileIOThread extends PrioritisedQueueExecutorThread {
+             synchronized (cache) {
+                 regionFile = cache.getRegionFileIfLoaded(new ChunkPos(chunkX, chunkZ));
+                 if (regionFile != null) {
+-                    regionFile.getFileLock().lock(); // Kaiiju
++//                    regionFile.getFileLock().lock(); // Kaiiju
+                 }
+             }
+ 
+@@ -1166,7 +1167,7 @@ public final class RegionFileIOThread extends PrioritisedQueueExecutorThread {
+                 return function.apply(regionFile);
+             } finally {
+                 if (regionFile != null) {
+-                    regionFile.getFileLock().unlock(); // Kaiiju
++//                    regionFile.getFileLock().unlock(); // Kaiiju
+                 }
+             }
+         }
+diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
+index db9e4386ca95bdaba0a4a4e13e3a90d2bcfbae91..73fc6d393cb338fee7d866b99a4e25684d47e79b 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
++++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
+@@ -120,7 +120,7 @@ public class RegionFileStorage implements AutoCloseable {
+             // Paper start
+             if (lock) {
+                 // must be in this synchronized block
+-                regionfile.getFileLock().lock(); // Kaiiju
++//                regionfile.getFileLock().lock(); // Kaiiju
+             }
+             // Paper end
+             return regionfile;
+@@ -169,7 +169,7 @@ public class RegionFileStorage implements AutoCloseable {
+             // Paper start
+             if (lock) {
+                 // must be in this synchronized block
+-                regionfile1.getFileLock().lock(); // Kaiiju
++//                regionfile1.getFileLock().lock(); // Kaiiju
+             }
+             // Paper end
+             return regionfile1;
+@@ -249,7 +249,7 @@ public class RegionFileStorage implements AutoCloseable {
+                         if (!chunkPos.equals(pos)) {
+                             net.minecraft.server.MinecraftServer.LOGGER.error("Attempting to read chunk data at " + pos + " but got chunk data for " + chunkPos + " instead! Attempting regionfile recalculation for regionfile " + regionfile.getRegionFile().toAbsolutePath()); // Kaiiju
+                             if (regionfile.recalculateHeader()) {
+-                                regionfile.getFileLock().lock(); // otherwise we will unlock twice and only lock once. // Kaiiju
++//                                regionfile.getFileLock().lock(); // otherwise we will unlock twice and only lock once. // Kaiiju
+                                 return this.read(pos, regionfile);
+                             }
+                             net.minecraft.server.MinecraftServer.LOGGER.error("Can't recalculate regionfile header, regenerating chunk " + pos + " for " + regionfile.getRegionFile().toAbsolutePath()); // Kaiiju
+@@ -286,7 +286,7 @@ public class RegionFileStorage implements AutoCloseable {
+ 
+         return nbttagcompound;
+         } finally { // Paper start
+-            regionfile.getFileLock().unlock(); // Kaiiju
++//            regionfile.getFileLock().unlock(); // Kaiiju
+         } // Paper end
+     }
+ 
+@@ -378,7 +378,7 @@ public class RegionFileStorage implements AutoCloseable {
+         // Paper end - Chunk save reattempt
+         // Paper start - rewrite chunk system
+         } finally {
+-            regionfile.getFileLock().unlock(); // Kaiiju
++            //regionfile.getFileLock().unlock(); // Kaiiju
+         }
+         // Paper end - rewrite chunk system
+     }

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

@@ -0,0 +1,50 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Sun, 28 Jan 2024 09:11:58 +0000
+Subject: [PATCH] Sparkly Paper Optimize canSee checks
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
+index 76ad4d8bce1611ead6f1596b2ba78267e3718655..d1dc02b3e4f775c9bd79073a8e96243aa5ab6c24 100644
+--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
++++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
+@@ -1408,7 +1408,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+                 // Folia end - region threading
+ 
+                 // CraftBukkit start - respect vanish API
+-                if (flag && (!io.papermc.paper.util.TickThread.isTickThreadFor(player) || !player.getBukkitEntity().canSee(this.entity.getBukkitEntity()))) { // Paper - only consider hits // Folia - region threading
++                if (flag && (!io.papermc.paper.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
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 26f70965b45fa3c344781b569a651a4668d0621d..49f207b7e06a3f939dc6c9b4a078f6db7b779618 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -187,7 +187,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;
+@@ -2146,9 +2146,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 canSee(UUID uuid) {
+         org.bukkit.entity.Entity entity = this.getServer().getPlayer(uuid);
+         if (entity == null) {

patches/server/0055-Purpur-use-alternative-keep-alive.patch

@@ -0,0 +1,83 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 08:35:11 +0000
+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";
++    }
++}
+diff --git a/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+index 22f0d91df0a81040d72c499fbff32b3a9d41598f..c68910b2a2eb703406fb406a86783cf6ab48651e 100644
+--- a/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+@@ -51,6 +51,7 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+     private long keepAliveTime = Util.getMillis(); // Paper
+     private boolean keepAlivePending;
+     private long keepAliveChallenge;
++    private it.unimi.dsi.fastutil.longs.LongList keepAlives = new it.unimi.dsi.fastutil.longs.LongArrayList(); // Purpur
+     private int latency;
+     private volatile boolean suspendFlushingOnServerThread = false;
+     public final java.util.Map<java.util.UUID, net.kyori.adventure.resource.ResourcePackCallback> packCallbacks = new java.util.concurrent.ConcurrentHashMap<>(); // Paper - adventure resource pack callbacks
+@@ -103,6 +104,16 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+ 
+     @Override
+     public void handleKeepAlive(ServerboundKeepAlivePacket packet) {
++        // Purpur start
++        if (me.earthme.luminol.config.modules.optimizations.PurpurAlternativeKeepaliveConfig.useAlternateKeepAlive) {
++            long id = packet.getId();
++            if (keepAlives.size() > 0 && keepAlives.contains(id)) {
++                int ping = (int) (Util.getMillis() - id);
++                this.latency = (this.latency * 3 + ping) / 4;
++                keepAlives.clear(); // we got a valid response, lets roll with it and forget the rest
++            }
++        } else
++            // Purpur end
+         //PacketUtils.ensureRunningOnSameThread(packet, this, this.player.serverLevel()); // CraftBukkit // Paper - handle ServerboundKeepAlivePacket async
+         if (this.keepAlivePending && packet.getId() == this.keepAliveChallenge) {
+             int i = (int) (Util.getMillis() - this.keepAliveTime);
+@@ -221,6 +232,21 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+         long currentTime = Util.getMillis();
+         long elapsedTime = currentTime - this.keepAliveTime;
+ 
++        // Purpur start
++        if (me.earthme.luminol.config.modules.optimizations.PurpurAlternativeKeepaliveConfig.useAlternateKeepAlive) {
++            if (elapsedTime >= 1000L) { // 1 second
++                if (!processedDisconnect && keepAlives.size() * 1000L >= KEEPALIVE_LIMIT) {
++                    LOGGER.warn("{} was kicked due to keepalive timeout!", this.player.getScoreboardName());
++                    disconnect(ServerCommonPacketListenerImpl.TIMEOUT_DISCONNECTION_MESSAGE, org.bukkit.event.player.PlayerKickEvent.Cause.TIMEOUT);
++                } else {
++                    keepAliveTime = currentTime; // hijack this field for 1 second intervals
++                    keepAlives.add(currentTime); // currentTime is ID
++                    send(new ClientboundKeepAlivePacket(currentTime));
++                }
++            }
++        } else
++        // Purpur end
++
+         if (this.keepAlivePending) {
+             if (!this.processedDisconnect && elapsedTime >= KEEPALIVE_LIMIT) { // check keepalive limit, don't fire if already disconnected
+                 ServerGamePacketListenerImpl.LOGGER.warn("{} was kicked due to keepalive timeout!", this.player.getScoreboardName()); // more info

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

@@ -0,0 +1,583 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 08:51:49 +0000
+Subject: [PATCH] Leaves Protocol Core
+
+
+diff --git a/src/main/java/io/papermc/paper/threadedregions/RegionizedServer.java b/src/main/java/io/papermc/paper/threadedregions/RegionizedServer.java
+index 1ae61bc6603dd3ac290e3ead20416f9c5b63ff02..168ed2c21aed6a10f3aca259880b1b8bdbf98b78 100644
+--- a/src/main/java/io/papermc/paper/threadedregions/RegionizedServer.java
++++ b/src/main/java/io/papermc/paper/threadedregions/RegionizedServer.java
+@@ -314,6 +314,8 @@ public final class RegionizedServer {
+ 
+         // player list
+         MinecraftServer.getServer().getPlayerList().tick();
++
++        top.leavesmc.leaves.protocol.core.LeavesProtocolManager.handleTick(); //Leaves
+     }
+ 
+     private void tickPlayerSample() {
+diff --git a/src/main/java/net/minecraft/network/protocol/common/ServerboundCustomPayloadPacket.java b/src/main/java/net/minecraft/network/protocol/common/ServerboundCustomPayloadPacket.java
+index af86f752c33a2990405fea058b7c41c437ba9d46..bada9fae1e7178162429e1f5a1608b9c4a680a6c 100644
+--- a/src/main/java/net/minecraft/network/protocol/common/ServerboundCustomPayloadPacket.java
++++ b/src/main/java/net/minecraft/network/protocol/common/ServerboundCustomPayloadPacket.java
+@@ -20,7 +20,12 @@ public record ServerboundCustomPayloadPacket(CustomPacketPayload payload) implem
+ 
+     private static CustomPacketPayload readPayload(ResourceLocation id, FriendlyByteBuf buf) {
+         FriendlyByteBuf.Reader<? extends CustomPacketPayload> packetdataserializer_a = (FriendlyByteBuf.Reader) ServerboundCustomPayloadPacket.KNOWN_TYPES.get(id);
+-
++        // Leaves start - protocol
++        CustomPacketPayload leavesPayload = top.leavesmc.leaves.protocol.core.LeavesProtocolManager.getPayload(id, buf);
++        if (leavesPayload != null) {
++            return leavesPayload;
++        }
++        // Leaves end - protocol
+         return (CustomPacketPayload) (packetdataserializer_a != null ? (CustomPacketPayload) packetdataserializer_a.apply(buf) : readUnknownPayload(id, buf));
+     }
+ 
+diff --git a/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+index c68910b2a2eb703406fb406a86783cf6ab48651e..f935214ed80fe54038a96a5cd668a072cdf406ec 100644
+--- a/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
+@@ -139,6 +139,7 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+ 
+     @Override
+     public void handleCustomPayload(ServerboundCustomPayloadPacket packet) {
++        top.leavesmc.leaves.protocol.core.LeavesProtocolManager.handlePayload(player, packet.payload()); // Leaves - protocol
+         // Paper start - Brand support
+         if (packet.payload() instanceof net.minecraft.network.protocol.common.custom.BrandPayload brandPayload) {
+             this.player.clientBrandName = brandPayload.brand();
+@@ -156,6 +157,7 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+                 String channels = payload.toString(com.google.common.base.Charsets.UTF_8);
+                 for (String channel : channels.split("\0")) {
+                     this.getCraftPlayer().addChannel(channel);
++                    top.leavesmc.leaves.protocol.core.LeavesProtocolManager.handleMinecraftRegister(channel, player); // Leaves - protocol
+                 }
+             } catch (Exception ex) {
+                 ServerGamePacketListenerImpl.LOGGER.error("Couldn\'t register custom payload", ex);
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 90be312057221a5a78066d89783c5e22008d797d..0f172512085e9dfc0850451d2c6bbffb18221f8f 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
++++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -441,6 +441,8 @@ public abstract class PlayerList {
+             //return; // Folia - region threading - must still allow the player to connect, as we must add to chunk map before handling disconnect
+         }
+ 
++        top.leavesmc.leaves.protocol.core.LeavesProtocolManager.handlePlayerJoin(player); // Leaves - protocol
++
+         final net.kyori.adventure.text.Component jm = playerJoinEvent.joinMessage();
+ 
+         if (jm != null && !jm.equals(net.kyori.adventure.text.Component.empty())) { // Paper - Adventure
+@@ -696,6 +698,7 @@ public abstract class PlayerList {
+         return this.remove(entityplayer, net.kyori.adventure.text.Component.translatable("multiplayer.player.left", net.kyori.adventure.text.format.NamedTextColor.YELLOW, io.papermc.paper.configuration.GlobalConfiguration.get().messages.useDisplayNameInQuitMessage ? entityplayer.getBukkitEntity().displayName() : io.papermc.paper.adventure.PaperAdventure.asAdventure(entityplayer.getDisplayName())));
+     }
+     public net.kyori.adventure.text.Component remove(ServerPlayer entityplayer, net.kyori.adventure.text.Component leaveMessage) {
++        top.leavesmc.leaves.protocol.core.LeavesProtocolManager.handlePlayerLeave(entityplayer); // Leaves - protocol
+         // Paper end - Fix kick event leave message not being sent
+         ServerLevel worldserver = entityplayer.serverLevel();
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index c70eb23d9745bdbfcc340bb554cf0bf2db71f5de..dc223b536eadd2da6cf3c758a62d0ed81b5a7b3b 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -471,6 +471,7 @@ public final class CraftServer implements Server {
+             MapPalette.setMapColorCache(new CraftMapColorCache(this.logger));
+         }
+         datapackManager = new io.papermc.paper.datapack.PaperDatapackManager(console.getPackRepository()); // Paper
++        top.leavesmc.leaves.protocol.core.LeavesProtocolManager.init(); // Leaves - protocol
+     }
+ 
+     public boolean getCommandBlockOverride(String command) {
+@@ -1129,6 +1130,7 @@ public final class CraftServer implements Server {
+         io.papermc.paper.command.PaperCommands.registerCommands(this.console); // Paper
+         this.overrideAllCommandBlockCommands = this.commandsConfiguration.getStringList("command-block-overrides").contains("*");
+         this.ignoreVanillaPermissions = this.commandsConfiguration.getBoolean("ignore-vanilla-permissions");
++        top.leavesmc.leaves.protocol.core.LeavesProtocolManager.handleServerReload(); // Leaves - protocol
+ 
+         int pollCount = 0;
+ 
+diff --git a/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocol.java b/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocol.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..64a1d25973b032e8cab64bbffa6824a131676773
+--- /dev/null
++++ b/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocol.java
+@@ -0,0 +1,16 @@
++package top.leavesmc.leaves.protocol.core;
++
++import java.lang.annotation.ElementType;
++import java.lang.annotation.Retention;
++import java.lang.annotation.RetentionPolicy;
++import java.lang.annotation.Target;
++
++@Target(ElementType.TYPE)
++@Retention(RetentionPolicy.RUNTIME)
++public @interface LeavesProtocol {
++
++    String namespace() default "minecraft";
++
++    String[] namespaces() default {};
++
++}
+diff --git a/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocolManager.java b/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocolManager.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..8b7813c442733f5d4d3b2a072902099cbe596b37
+--- /dev/null
++++ b/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocolManager.java
+@@ -0,0 +1,344 @@
++package top.leavesmc.leaves.protocol.core;
++
++import net.minecraft.network.FriendlyByteBuf;
++import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
++import net.minecraft.resources.ResourceLocation;
++import net.minecraft.server.level.ServerPlayer;
++import org.apache.commons.lang.ArrayUtils;
++import org.jetbrains.annotations.NotNull;
++
++import java.io.File;
++import java.io.IOException;
++import java.lang.reflect.Constructor;
++import java.lang.reflect.InvocationTargetException;
++import java.lang.reflect.Method;
++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.ArrayList;
++import java.util.Collections;
++import java.util.Enumeration;
++import java.util.HashMap;
++import java.util.HashSet;
++import java.util.LinkedHashSet;
++import java.util.List;
++import java.util.Map;
++import java.util.Set;
++import java.util.jar.JarEntry;
++import java.util.jar.JarFile;
++
++public class LeavesProtocolManager {
++
++    private static final Map<LeavesProtocol, Map<ProtocolHandler.PayloadReceiver, Constructor<? extends CustomPacketPayload>>> KNOWN_TYPES = new HashMap<>();
++    private static final Map<LeavesProtocol, Map<ProtocolHandler.PayloadReceiver, Method>> KNOW_RECEIVERS = new HashMap<>();
++
++    private static final List<Method> TICKERS = new ArrayList<>();
++    private static final List<Method> PLAYER_JOIN = new ArrayList<>();
++    private static final List<Method> PLAYER_LEAVE = new ArrayList<>();
++    private static final List<Method> RELOAD_SERVER = new ArrayList<>();
++    private static final Map<LeavesProtocol, Map<ProtocolHandler.MinecraftRegister, Method>> MINECRAFT_REGISTER = new HashMap<>();
++
++    public static void init() {
++        //Luminol start - For the protocol supports of luminol
++        final Set<Class<?>> allClazz = getClasses("org.leavesmc.leaves.protocol");
++        allClazz.addAll(getClasses("me.earthme.luminol.protocols"));
++        //Luminol end
++        for (Class<?> clazz : allClazz) {
++            final LeavesProtocol protocol = clazz.getAnnotation(LeavesProtocol.class);
++            if (protocol != null) {
++                Set<Method> methods;
++                try {
++                    Method[] publicMethods = clazz.getMethods();
++                    Method[] privateMethods = clazz.getDeclaredMethods();
++                    methods = new HashSet<>(publicMethods.length + privateMethods.length, 1.0f);
++                    Collections.addAll(methods, publicMethods);
++                    Collections.addAll(methods, privateMethods);
++                } catch (NoClassDefFoundError e) {
++                    e.printStackTrace();
++                    return;
++                }
++
++                Map<ProtocolHandler.PayloadReceiver, Constructor<? extends CustomPacketPayload>> map = new HashMap<>();
++                for (final Method method : methods) {
++                    if (method.isBridge() || method.isSynthetic() || !Modifier.isStatic(method.getModifiers())) {
++                        continue;
++                    }
++
++                    method.setAccessible(true);
++
++                    final ProtocolHandler.Init init = method.getAnnotation(ProtocolHandler.Init.class);
++                    if (init != null) {
++                        try {
++                            method.invoke(null);
++                        } catch (InvocationTargetException | IllegalAccessException e) {
++                            e.printStackTrace();
++                        }
++                        continue;
++                    }
++
++                    final ProtocolHandler.PayloadReceiver receiver = method.getAnnotation(ProtocolHandler.PayloadReceiver.class);
++                    if (receiver != null) {
++                        try {
++                            map.put(receiver, receiver.payload().getConstructor(ResourceLocation.class, FriendlyByteBuf.class));
++                        } catch (NoSuchMethodException e) {
++                            e.printStackTrace();
++                            continue;
++                        }
++
++                        if (!KNOW_RECEIVERS.containsKey(protocol)) {
++                            KNOW_RECEIVERS.put(protocol, new HashMap<>());
++                        }
++
++                        KNOW_RECEIVERS.get(protocol).put(receiver, method);
++                        continue;
++                    }
++
++                    final ProtocolHandler.Ticker ticker = method.getAnnotation(ProtocolHandler.Ticker.class);
++                    if (ticker != null) {
++                        TICKERS.add(method);
++                        continue;
++                    }
++
++                    final ProtocolHandler.PlayerJoin playerJoin = method.getAnnotation(ProtocolHandler.PlayerJoin.class);
++                    if (playerJoin != null) {
++                        PLAYER_JOIN.add(method);
++                        continue;
++                    }
++
++                    final ProtocolHandler.PlayerLeave playerLeave = method.getAnnotation(ProtocolHandler.PlayerLeave.class);
++                    if (playerLeave != null) {
++                        PLAYER_LEAVE.add(method);
++                        continue;
++                    }
++
++                    final ProtocolHandler.ReloadServer reloadServer = method.getAnnotation(ProtocolHandler.ReloadServer.class);
++                    if (reloadServer != null) {
++                        RELOAD_SERVER.add(method);
++                        continue;
++                    }
++
++                    final ProtocolHandler.MinecraftRegister minecraftRegister = method.getAnnotation(ProtocolHandler.MinecraftRegister.class);
++                    if (minecraftRegister != null) {
++                        if (!MINECRAFT_REGISTER.containsKey(protocol)) {
++                            MINECRAFT_REGISTER.put(protocol, new HashMap<>());
++                        }
++
++                        MINECRAFT_REGISTER.get(protocol).put(minecraftRegister, method);
++                    }
++                }
++                KNOWN_TYPES.put(protocol, map);
++            }
++        }
++    }
++
++    public static CustomPacketPayload getPayload(ResourceLocation id, FriendlyByteBuf buf) {
++        for (LeavesProtocol protocol : KNOWN_TYPES.keySet()) {
++            if (!protocol.namespace().equals(id.getNamespace()) && !ArrayUtils.contains(protocol.namespaces(), id.getNamespace())) {
++                continue;
++            }
++
++            Map<ProtocolHandler.PayloadReceiver, Constructor<? extends CustomPacketPayload>> map = KNOWN_TYPES.get(protocol);
++            for (ProtocolHandler.PayloadReceiver receiver : map.keySet()) {
++                if (receiver.ignoreId() || receiver.payloadId().equals(id.getPath()) || ArrayUtils.contains(receiver.payloadIds(), id.getPath())) {
++                    try {
++                        return map.get(receiver).newInstance(id, buf);
++                    } catch (InvocationTargetException | InstantiationException | IllegalAccessException e) {
++                        e.printStackTrace();
++                    }
++                }
++            }
++        }
++        return null;
++    }
++
++    public static void handlePayload(ServerPlayer player, CustomPacketPayload payload) {
++        for (LeavesProtocol protocol : KNOW_RECEIVERS.keySet()) {
++            if (!protocol.namespace().equals(payload.id().getNamespace()) && !ArrayUtils.contains(protocol.namespaces(), payload.id().getNamespace())) {
++                continue;
++            }
++
++            Map<ProtocolHandler.PayloadReceiver, Method> map = KNOW_RECEIVERS.get(protocol);
++            for (ProtocolHandler.PayloadReceiver receiver : map.keySet()) {
++                if (payload.getClass() == receiver.payload()) {
++                    if (receiver.ignoreId() || receiver.payloadId().equals(payload.id().getPath()) ||
++                        ArrayUtils.contains(receiver.payloadIds(), payload.id().getPath())) {
++                        try {
++                            map.get(receiver).invoke(null, player, payload);
++                        } catch (InvocationTargetException | IllegalAccessException e) {
++                            e.printStackTrace();
++                        }
++                    }
++                }
++            }
++        }
++    }
++
++    public static void handleTick() {
++        if (!TICKERS.isEmpty()) {
++            try {
++                for (Method method : TICKERS) {
++                    method.invoke(null);
++                }
++            } catch (InvocationTargetException | IllegalAccessException e) {
++                e.printStackTrace();
++            }
++        }
++    }
++
++    public static void handlePlayerJoin(ServerPlayer player) {
++        if (!PLAYER_JOIN.isEmpty()) {
++            try {
++                for (Method method : PLAYER_JOIN) {
++                    method.invoke(null, player);
++                }
++            } catch (InvocationTargetException | IllegalAccessException e) {
++                e.printStackTrace();
++            }
++        }
++    }
++
++    public static void handlePlayerLeave(ServerPlayer player) {
++        if (!PLAYER_LEAVE.isEmpty()) {
++            try {
++                for (Method method : PLAYER_LEAVE) {
++                    method.invoke(null, player);
++                }
++            } catch (InvocationTargetException | IllegalAccessException e) {
++                e.printStackTrace();
++            }
++        }
++    }
++
++    public static void handleServerReload() {
++        if (!RELOAD_SERVER.isEmpty()) {
++            try {
++                for (Method method : RELOAD_SERVER) {
++                    method.invoke(null);
++                }
++            } catch (InvocationTargetException | IllegalAccessException e) {
++                e.printStackTrace();
++            }
++        }
++    }
++
++    public static void handleMinecraftRegister(String channelId, ServerPlayer player) {
++        for (LeavesProtocol protocol : MINECRAFT_REGISTER.keySet()) {
++            String[] channel = channelId.split(":");
++            if (!protocol.namespace().equals(channel[0]) && !ArrayUtils.contains(protocol.namespaces(), channel[0])) {
++                continue;
++            }
++
++            Map<ProtocolHandler.MinecraftRegister, Method> map = MINECRAFT_REGISTER.get(protocol);
++            for (ProtocolHandler.MinecraftRegister register : map.keySet()) {
++                if (register.ignoreId() || register.channelId().equals(channel[1]) ||
++                    ArrayUtils.contains(register.channelIds(), channel[1])) {
++                    try {
++                        map.get(register).invoke(null, player);
++                    } catch (InvocationTargetException | IllegalAccessException e) {
++                        e.printStackTrace();
++                    }
++                }
++            }
++        }
++    }
++
++    public static Set<Class<?>> getClasses(String pack) {
++        Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
++        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) {
++                        e.printStackTrace();
++                    }
++                }
++            }
++        } catch (IOException e) {
++            e.printStackTrace();
++        }
++        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) {
++                        e.printStackTrace();
++                    }
++                }
++            }
++        }
++    }
++
++    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) {
++                        e.printStackTrace();
++                    }
++                }
++            }
++        }
++    }
++
++    public record EmptyPayload(ResourceLocation id) implements CustomPacketPayload {
++
++        public EmptyPayload(ResourceLocation location, FriendlyByteBuf buf) {
++            this(location);
++        }
++
++        @Override
++        public void write(@NotNull FriendlyByteBuf buf) {
++        }
++    }
++
++    public record LeavesPayload(FriendlyByteBuf data, ResourceLocation id) implements CustomPacketPayload {
++
++        public LeavesPayload(ResourceLocation location, FriendlyByteBuf buf) {
++            this(new FriendlyByteBuf(buf.readBytes(buf.readableBytes())), location);
++        }
++
++        @Override
++        public void write(FriendlyByteBuf buf) {
++            buf.writeBytes(data);
++        }
++    }
++}
+diff --git a/src/main/java/top/leavesmc/leaves/protocol/core/ProtocolHandler.java b/src/main/java/top/leavesmc/leaves/protocol/core/ProtocolHandler.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..d696f001d2576d1b61cc732c81f22eb52205072b
+--- /dev/null
++++ b/src/main/java/top/leavesmc/leaves/protocol/core/ProtocolHandler.java
+@@ -0,0 +1,65 @@
++package top.leavesmc.leaves.protocol.core;
++
++import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
++
++import java.lang.annotation.ElementType;
++import java.lang.annotation.Retention;
++import java.lang.annotation.RetentionPolicy;
++import java.lang.annotation.Target;
++
++public class ProtocolHandler {
++
++    @Target(ElementType.METHOD)
++    @Retention(RetentionPolicy.RUNTIME)
++    public @interface Init {
++
++    }
++
++    @Target(ElementType.METHOD)
++    @Retention(RetentionPolicy.RUNTIME)
++    public @interface PayloadReceiver {
++
++        Class<? extends CustomPacketPayload> payload();
++
++        String[] payloadIds() default {};
++
++        String payloadId() default "";
++
++        boolean ignoreId() default false;
++    }
++
++    @Target(ElementType.METHOD)
++    @Retention(RetentionPolicy.RUNTIME)
++    public @interface Ticker {
++        int delay() default 0;
++    }
++
++    @Target(ElementType.METHOD)
++    @Retention(RetentionPolicy.RUNTIME)
++    public @interface PlayerJoin {
++
++    }
++
++    @Target(ElementType.METHOD)
++    @Retention(RetentionPolicy.RUNTIME)
++    public @interface PlayerLeave {
++
++    }
++
++    @Target(ElementType.METHOD)
++    @Retention(RetentionPolicy.RUNTIME)
++    public @interface ReloadServer {
++
++    }
++
++    @Target(ElementType.METHOD)
++    @Retention(RetentionPolicy.RUNTIME)
++    public @interface MinecraftRegister {
++
++        String channelId() default "";
++
++        String[] channelIds() default {};
++
++        boolean ignoreId() default false;
++    }
++}
+diff --git a/src/main/java/top/leavesmc/leaves/protocol/core/ProtocolUtils.java b/src/main/java/top/leavesmc/leaves/protocol/core/ProtocolUtils.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..5282c5ad3d26d06ab685ddaaf6fd9a4d49559717
+--- /dev/null
++++ b/src/main/java/top/leavesmc/leaves/protocol/core/ProtocolUtils.java
+@@ -0,0 +1,36 @@
++package top.leavesmc.leaves.protocol.core;
++
++import net.minecraft.network.FriendlyByteBuf;
++import net.minecraft.network.protocol.common.ClientboundCustomPayloadPacket;
++import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
++import net.minecraft.resources.ResourceLocation;
++import net.minecraft.server.level.ServerPlayer;
++import org.jetbrains.annotations.NotNull;
++
++import java.util.function.Consumer;
++
++public class ProtocolUtils {
++
++    public static void sendEmptyPayloadPacket(ServerPlayer player, ResourceLocation id) {
++        player.connection.send(new ClientboundCustomPayloadPacket(new LeavesProtocolManager.EmptyPayload(id)));
++    }
++
++    public static void sendPayloadPacket(ServerPlayer player, ResourceLocation id, Consumer<FriendlyByteBuf> consumer) {
++        player.connection.send(new ClientboundCustomPayloadPacket(new CustomPacketPayload() {
++            @Override
++            public void write(@NotNull FriendlyByteBuf buf) {
++                consumer.accept(buf);
++            }
++
++            @Override
++            @NotNull
++            public ResourceLocation id() {
++                return id;
++            }
++        }));
++    }
++
++    public static void sendPayloadPacket(ServerPlayer player, CustomPacketPayload payload) {
++        player.connection.send(new ClientboundCustomPayloadPacket(payload));
++    }
++}

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

@@ -0,0 +1,292 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 08:59:41 +0000
+Subject: [PATCH] Leaves Bladeren Protocol
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/gameplay/LeavesBladerenProtocolConfig.java b/src/main/java/me/earthme/luminol/config/modules/gameplay/LeavesBladerenProtocolConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..4950d33288d6bc3c4ce90ae12bbf4797e3989500
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/gameplay/LeavesBladerenProtocolConfig.java
+@@ -0,0 +1,28 @@
++package me.earthme.luminol.config.modules.gameplay;
++
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.HotReloadUnsupported;
++import me.earthme.luminol.config.IConfigModule;
++
++public class LeavesBladerenProtocolConfig implements IConfigModule {
++    @HotReloadUnsupported
++    @ConfigInfo(baseName = "enable_base_protocol")
++    public static boolean enableBaseProtocol = false;
++    @HotReloadUnsupported
++    @ConfigInfo(baseName = "enable_mspt_sync_protocol")
++    public static boolean msptSyncProtocol = false;
++    @HotReloadUnsupported
++    @ConfigInfo(baseName = "mspt_sync_interval")
++    public static int msptSyncTickInterval = 20;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.GAMEPLAY;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "leaves_bladeren_protocol";
++    }
++}
+diff --git a/src/main/java/top/leavesmc/leaves/protocol/bladeren/BladerenProtocol.java b/src/main/java/top/leavesmc/leaves/protocol/bladeren/BladerenProtocol.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..6415f17fa6c06199e59705a29605d2aef834fc17
+--- /dev/null
++++ b/src/main/java/top/leavesmc/leaves/protocol/bladeren/BladerenProtocol.java
+@@ -0,0 +1,150 @@
++package top.leavesmc.leaves.protocol.bladeren;
++
++import com.google.common.collect.Maps;
++import net.minecraft.nbt.CompoundTag;
++import net.minecraft.network.FriendlyByteBuf;
++import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
++import net.minecraft.resources.ResourceLocation;
++import net.minecraft.server.level.ServerPlayer;
++import org.jetbrains.annotations.Contract;
++import org.jetbrains.annotations.NotNull;
++import top.leavesmc.leaves.protocol.core.LeavesProtocol;
++import top.leavesmc.leaves.protocol.core.ProtocolHandler;
++import top.leavesmc.leaves.protocol.core.ProtocolUtils;
++
++import java.util.HashMap;
++import java.util.Map;
++import java.util.function.BiConsumer;
++
++@LeavesProtocol(namespace = "bladeren")
++public class BladerenProtocol {
++
++    public static final String PROTOCOL_ID = "bladeren";
++    public static final String PROTOCOL_VERSION = "1.0.0";
++
++    private static final ResourceLocation HELLO_ID = id("hello");
++    private static final ResourceLocation FEATURE_MODIFY_ID = id("feature_modify");
++
++    private static final Map<String, BiConsumer<ServerPlayer, CompoundTag>> registeredFeatures = Maps.newConcurrentMap();
++
++    @Contract("_ -> new")
++    public static @NotNull ResourceLocation id(String path) {
++        return new ResourceLocation(PROTOCOL_ID, path);
++    }
++
++    @ProtocolHandler.PayloadReceiver(payload = BladerenHelloPayload.class, payloadId = "hello")
++    private static void handleHello(@NotNull ServerPlayer player, @NotNull BladerenHelloPayload payload) {
++        if (me.earthme.luminol.config.modules.gameplay.LeavesBladerenProtocolConfig.enableBaseProtocol) {
++            String clientVersion = payload.version;
++            CompoundTag tag = payload.nbt;
++
++            if (tag != null) {
++                CompoundTag featureNbt = tag.getCompound("Features");
++                for (String name : featureNbt.getAllKeys()) {
++
++                    final BiConsumer<ServerPlayer,CompoundTag> target = registeredFeatures.get(name);
++
++                    if (target != null){
++                        target.accept(player, featureNbt.getCompound(name));
++                    }
++                }
++            }
++        }
++    }
++
++    @ProtocolHandler.PayloadReceiver(payload = BladerenFeatureModifyPayload.class, payloadId = "feature_modify")
++    private static void handleModify(@NotNull ServerPlayer player, @NotNull BladerenFeatureModifyPayload payload) {
++        if (me.earthme.luminol.config.modules.gameplay.LeavesBladerenProtocolConfig.enableBaseProtocol) {
++            String name = payload.name;
++            CompoundTag tag = payload.nbt;
++
++            final BiConsumer<ServerPlayer,CompoundTag> target = registeredFeatures.get(name);
++
++            if (target != null){
++                target.accept(player, tag);
++            }
++        }
++    }
++
++    @ProtocolHandler.PlayerJoin
++    public static void onPlayerJoin(@NotNull ServerPlayer player) {
++        if (me.earthme.luminol.config.modules.gameplay.LeavesBladerenProtocolConfig.enableBaseProtocol) {
++            CompoundTag tag = new CompoundTag();
++            LeavesFeatureSet.writeNBT(tag);
++            ProtocolUtils.sendPayloadPacket(player, new BladerenHelloPayload(PROTOCOL_VERSION, tag));
++        }
++    }
++
++    public static void registerFeature(String name, BiConsumer<ServerPlayer, CompoundTag> consumer) {
++        registeredFeatures.put(name, consumer);
++    }
++
++    public static class LeavesFeatureSet {
++
++        private static final Map<String, LeavesFeature> features = new HashMap<>();
++
++        public static void writeNBT(@NotNull CompoundTag tag) {
++            CompoundTag featureNbt = new CompoundTag();
++            features.values().forEach(feature -> feature.writeNBT(featureNbt));
++            tag.put("Features", featureNbt);
++        }
++
++        public static void register(LeavesFeature feature) {
++            features.put(feature.name, feature);
++        }
++    }
++
++    public record LeavesFeature(String name, String value) {
++
++        @NotNull
++        @Contract("_, _ -> new")
++        public static LeavesFeature of(String name, boolean value) {
++            return new LeavesFeature(name, Boolean.toString(value));
++        }
++
++        public void writeNBT(@NotNull CompoundTag rules) {
++            CompoundTag rule = new CompoundTag();
++            rule.putString("Feature", name);
++            rule.putString("Value", value);
++            rules.put(name, rule);
++        }
++    }
++
++    public record BladerenFeatureModifyPayload(String name, CompoundTag nbt) implements CustomPacketPayload {
++
++        public BladerenFeatureModifyPayload(ResourceLocation location, FriendlyByteBuf buf) {
++            this(buf.readUtf(), buf.readNbt());
++        }
++
++        @Override
++        public void write(@NotNull FriendlyByteBuf buf) {
++            buf.writeUtf(name);
++            buf.writeNbt(nbt);
++        }
++
++        @Override
++        @NotNull
++        public ResourceLocation id() {
++            return FEATURE_MODIFY_ID;
++        }
++    }
++
++    public record BladerenHelloPayload(String version, CompoundTag nbt) implements CustomPacketPayload {
++
++        public BladerenHelloPayload(ResourceLocation location, @NotNull FriendlyByteBuf buf) {
++            this(buf.readUtf(64), buf.readNbt());
++        }
++
++        @Override
++        public void write(@NotNull FriendlyByteBuf buf) {
++            buf.writeUtf(version);
++            buf.writeNbt(nbt);
++        }
++
++        @Override
++        @NotNull
++        public ResourceLocation id() {
++            return HELLO_ID;
++        }
++    }
++}
+diff --git a/src/main/java/top/leavesmc/leaves/protocol/bladeren/MsptSyncProtocol.java b/src/main/java/top/leavesmc/leaves/protocol/bladeren/MsptSyncProtocol.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..db63ea1cf65e6ca06bd1c6ce978193e068a9a951
+--- /dev/null
++++ b/src/main/java/top/leavesmc/leaves/protocol/bladeren/MsptSyncProtocol.java
+@@ -0,0 +1,90 @@
++package top.leavesmc.leaves.protocol.bladeren;
++
++import io.papermc.paper.threadedregions.ThreadedRegionizer;
++import io.papermc.paper.threadedregions.TickData;
++import io.papermc.paper.threadedregions.TickRegions;
++import it.unimi.dsi.fastutil.objects.ObjectArrayList;
++import it.unimi.dsi.fastutil.objects.ObjectLists;
++import net.minecraft.resources.ResourceLocation;
++import net.minecraft.server.level.ServerLevel;
++import net.minecraft.server.level.ServerPlayer;
++import org.jetbrains.annotations.Contract;
++import org.jetbrains.annotations.NotNull;
++import top.leavesmc.leaves.protocol.core.LeavesProtocol;
++import top.leavesmc.leaves.protocol.core.ProtocolHandler;
++import top.leavesmc.leaves.protocol.core.ProtocolUtils;
++
++import java.util.List;
++
++@LeavesProtocol(namespace = "bladeren")
++public class MsptSyncProtocol {
++
++    public static final String PROTOCOL_ID = "bladeren";
++
++    private static final ResourceLocation MSPT_SYNC = id("mspt_sync");
++
++    private static final List<ServerPlayer> players = ObjectLists.synchronize(new ObjectArrayList<>());
++
++    private static int tickCounter = 0;
++
++    @Contract("_ -> new")
++    public static @NotNull ResourceLocation id(String path) {
++        return new ResourceLocation(PROTOCOL_ID, path);
++    }
++
++    @ProtocolHandler.Init
++    public static void init() {
++        BladerenProtocol.registerFeature("mspt_sync", (player, compoundTag) -> {
++            if (compoundTag.getString("Value").equals("true"))  {
++                onPlayerSubmit(player);
++            } else {
++                onPlayerLoggedOut(player);
++            }
++        });
++    }
++
++    @ProtocolHandler.PlayerLeave
++    public static void onPlayerLoggedOut(@NotNull ServerPlayer player) {
++        if (me.earthme.luminol.config.modules.gameplay.LeavesBladerenProtocolConfig.msptSyncProtocol) {
++            players.remove(player);
++        }
++    }
++
++    @ProtocolHandler.Ticker
++    public static void tick() {
++        if (me.earthme.luminol.config.modules.gameplay.LeavesBladerenProtocolConfig.msptSyncProtocol) {
++            if (players.isEmpty()) {
++                return;
++            }
++
++            if (tickCounter++ % me.earthme.luminol.config.modules.gameplay.LeavesBladerenProtocolConfig.msptSyncTickInterval == 0) {
++                for (ServerPlayer player : players){
++                    final ThreadedRegionizer.ThreadedRegion<TickRegions.TickRegionData, TickRegions.TickRegionSectionData> region = ((ServerLevel) player.level()).regioniser.getRegionAtUnsynchronised(player.sectionX,player.sectionZ);
++
++                    if (region == null){
++                        continue;
++                    }
++
++                    final TickData.TickReportData reportData = region.getData().getRegionSchedulingHandle().getTickReport5s(System.nanoTime());
++
++                    if (reportData != null){
++                        final TickData.SegmentData tpsData = reportData.tpsData().segmentAll();
++                        final double mspt = reportData.timePerTickData().segmentAll().average() / 1.0E6;
++                        final double tps = tpsData.average();
++
++                        ProtocolUtils.sendPayloadPacket(player, MSPT_SYNC, buf -> {
++                            buf.writeDouble(mspt);
++                            buf.writeDouble(tps);
++                        });
++                    }
++                }
++            }
++        }
++    }
++
++    public static void onPlayerSubmit(@NotNull ServerPlayer player) {
++        if (me.earthme.luminol.config.modules.gameplay.LeavesBladerenProtocolConfig.msptSyncProtocol) {
++            players.add(player);
++        }
++    }
++}

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

@@ -0,0 +1,93 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Wed, 7 Feb 2024 09:00:10 +0000
+Subject: [PATCH] Leaves Fix Bladeren Protocol
+
+
+diff --git a/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocol.java b/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocol.java
+index 64a1d25973b032e8cab64bbffa6824a131676773..57a563b3f2d01719d490578907411d25ea07a658 100644
+--- a/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocol.java
++++ b/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocol.java
+@@ -8,9 +8,7 @@ import java.lang.annotation.Target;
+ @Target(ElementType.TYPE)
+ @Retention(RetentionPolicy.RUNTIME)
+ public @interface LeavesProtocol {
+-
+-    String namespace() default "minecraft";
+-
+-    String[] namespaces() default {};
++    
++    String[] namespace();
+ 
+ }
+diff --git a/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocolManager.java b/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocolManager.java
+index 8b7813c442733f5d4d3b2a072902099cbe596b37..1f5b37daa5cbb709eeacf3dc7a4f9b4a0dc05274 100644
+--- a/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocolManager.java
++++ b/src/main/java/top/leavesmc/leaves/protocol/core/LeavesProtocolManager.java
+@@ -60,7 +60,7 @@ public class LeavesProtocolManager {
+                     return;
+                 }
+ 
+-                Map<ProtocolHandler.PayloadReceiver, Constructor<? extends CustomPacketPayload>> map = new HashMap<>();
++                Map<ProtocolHandler.PayloadReceiver, Constructor<? extends CustomPacketPayload>> map = KNOWN_TYPES.getOrDefault(protocol, new HashMap<>());
+                 for (final Method method : methods) {
+                     if (method.isBridge() || method.isSynthetic() || !Modifier.isStatic(method.getModifiers())) {
+                         continue;
+@@ -135,13 +135,13 @@ public class LeavesProtocolManager {
+ 
+     public static CustomPacketPayload getPayload(ResourceLocation id, FriendlyByteBuf buf) {
+         for (LeavesProtocol protocol : KNOWN_TYPES.keySet()) {
+-            if (!protocol.namespace().equals(id.getNamespace()) && !ArrayUtils.contains(protocol.namespaces(), id.getNamespace())) {
++            if (!ArrayUtils.contains(protocol.namespace(), id.getNamespace())) {
+                 continue;
+             }
+ 
+             Map<ProtocolHandler.PayloadReceiver, Constructor<? extends CustomPacketPayload>> map = KNOWN_TYPES.get(protocol);
+             for (ProtocolHandler.PayloadReceiver receiver : map.keySet()) {
+-                if (receiver.ignoreId() || receiver.payloadId().equals(id.getPath()) || ArrayUtils.contains(receiver.payloadIds(), id.getPath())) {
++                if (receiver.ignoreId() || ArrayUtils.contains(receiver.payloadId(), id.getPath())) {
+                     try {
+                         return map.get(receiver).newInstance(id, buf);
+                     } catch (InvocationTargetException | InstantiationException | IllegalAccessException e) {
+@@ -155,15 +155,14 @@ public class LeavesProtocolManager {
+ 
+     public static void handlePayload(ServerPlayer player, CustomPacketPayload payload) {
+         for (LeavesProtocol protocol : KNOW_RECEIVERS.keySet()) {
+-            if (!protocol.namespace().equals(payload.id().getNamespace()) && !ArrayUtils.contains(protocol.namespaces(), payload.id().getNamespace())) {
++            if (!ArrayUtils.contains(protocol.namespace(), payload.id().getNamespace()))  {
+                 continue;
+             }
+ 
+             Map<ProtocolHandler.PayloadReceiver, Method> map = KNOW_RECEIVERS.get(protocol);
+             for (ProtocolHandler.PayloadReceiver receiver : map.keySet()) {
+                 if (payload.getClass() == receiver.payload()) {
+-                    if (receiver.ignoreId() || receiver.payloadId().equals(payload.id().getPath()) ||
+-                        ArrayUtils.contains(receiver.payloadIds(), payload.id().getPath())) {
++                    if (receiver.ignoreId() || ArrayUtils.contains(receiver.payloadId(), payload.id().getPath())) {
+                         try {
+                             map.get(receiver).invoke(null, player, payload);
+                         } catch (InvocationTargetException | IllegalAccessException e) {
+@@ -226,7 +225,7 @@ public class LeavesProtocolManager {
+     public static void handleMinecraftRegister(String channelId, ServerPlayer player) {
+         for (LeavesProtocol protocol : MINECRAFT_REGISTER.keySet()) {
+             String[] channel = channelId.split(":");
+-            if (!protocol.namespace().equals(channel[0]) && !ArrayUtils.contains(protocol.namespaces(), channel[0])) {
++            if (!ArrayUtils.contains(protocol.namespace(), channel[0])) {
+                 continue;
+             }
+ 
+diff --git a/src/main/java/top/leavesmc/leaves/protocol/core/ProtocolHandler.java b/src/main/java/top/leavesmc/leaves/protocol/core/ProtocolHandler.java
+index d696f001d2576d1b61cc732c81f22eb52205072b..92ad6e9b1c0d9640b80c1ebe739c613d989eec21 100644
+--- a/src/main/java/top/leavesmc/leaves/protocol/core/ProtocolHandler.java
++++ b/src/main/java/top/leavesmc/leaves/protocol/core/ProtocolHandler.java
+@@ -21,9 +21,7 @@ public class ProtocolHandler {
+ 
+         Class<? extends CustomPacketPayload> payload();
+ 
+-        String[] payloadIds() default {};
+-
+-        String payloadId() default "";
++        String[] payloadId();
+ 
+         boolean ignoreId() default false;
+     }

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

@@ -0,0 +1,153 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Thu, 8 Feb 2024 11:57:18 +0000
+Subject: [PATCH] Leaves carpet protocol support
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/gameplay/LeavesCarpetProtocolSupportConfig.java b/src/main/java/me/earthme/luminol/config/modules/gameplay/LeavesCarpetProtocolSupportConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0ef77515b213b74bdcf7dac70a02bfaa1c8804f5
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/gameplay/LeavesCarpetProtocolSupportConfig.java
+@@ -0,0 +1,22 @@
++package me.earthme.luminol.config.modules.gameplay;
++
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.HotReloadUnsupported;
++import me.earthme.luminol.config.IConfigModule;
++
++public class LeavesCarpetProtocolSupportConfig implements IConfigModule {
++    @HotReloadUnsupported
++    @ConfigInfo(baseName = "enabled")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.GAMEPLAY;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "leaves_carpet_protocol";
++    }
++}
+diff --git a/src/main/java/top/leavesmc/leaves/protocol/CarpetServerProtocol.java b/src/main/java/top/leavesmc/leaves/protocol/CarpetServerProtocol.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0542d66a3dfae2aa3ccb6ca3dced6b34024017ad
+--- /dev/null
++++ b/src/main/java/top/leavesmc/leaves/protocol/CarpetServerProtocol.java
+@@ -0,0 +1,113 @@
++package top.leavesmc.leaves.protocol;
++
++import me.earthme.luminol.config.modules.gameplay.LeavesCarpetProtocolSupportConfig;
++import net.minecraft.nbt.CompoundTag;
++import net.minecraft.network.FriendlyByteBuf;
++import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
++import net.minecraft.resources.ResourceLocation;
++import net.minecraft.server.MinecraftServer;
++import net.minecraft.server.level.ServerPlayer;
++import org.jetbrains.annotations.Contract;
++import org.jetbrains.annotations.NotNull;
++import top.leavesmc.leaves.protocol.core.LeavesProtocol;
++import top.leavesmc.leaves.protocol.core.ProtocolHandler;
++import top.leavesmc.leaves.protocol.core.ProtocolUtils;
++
++import java.util.HashMap;
++import java.util.Locale;
++import java.util.Map;
++
++@LeavesProtocol(namespace = "carpet")
++public class CarpetServerProtocol {
++
++    public static final String PROTOCOL_ID = "carpet";
++    public static final String VERSION = "leaves-carpet-1.0.0";
++
++    private static final ResourceLocation HELLO_ID = CarpetServerProtocol.id("hello");
++
++    private static final String HI = "69";
++    private static final String HELLO = "420";
++
++    @Contract("_ -> new")
++    public static @NotNull ResourceLocation id(String path) {
++        return new ResourceLocation(PROTOCOL_ID, path);
++    }
++
++    @ProtocolHandler.PlayerJoin
++    public static void onPlayerJoin(ServerPlayer player) {
++        if (LeavesCarpetProtocolSupportConfig.enabled) {
++            CompoundTag data = new CompoundTag();
++            data.putString(HI, VERSION);
++            ProtocolUtils.sendPayloadPacket(player, new CarpetPayload(data));
++        }
++    }
++
++    @ProtocolHandler.PayloadReceiver(payload = CarpetPayload.class, payloadId = "hello")
++    private static void handleHello(@NotNull ServerPlayer player, @NotNull CarpetServerProtocol.CarpetPayload payload) {
++        if (LeavesCarpetProtocolSupportConfig.enabled) {
++            if (payload.nbt.contains(HELLO)) {
++                MinecraftServer.LOGGER.info("Player " + player.getScoreboardName() + " joined with carpet " + payload.nbt.getString(HELLO));
++                CompoundTag data = new CompoundTag();
++                CarpetRules.write(data);
++                ProtocolUtils.sendPayloadPacket(player, new CarpetPayload(data));
++            }
++        }
++    }
++
++    public static class CarpetRules {
++
++        private static final Map<String, CarpetRule> rules = new HashMap<>();
++
++        public static void write(@NotNull CompoundTag tag) {
++            CompoundTag rulesNbt = new CompoundTag();
++            rules.values().forEach(rule -> rule.writeNBT(rulesNbt));
++
++            tag.put("Rules", rulesNbt);
++        }
++
++        public static void register(CarpetRule rule) {
++            rules.put(rule.name, rule);
++        }
++    }
++
++    public record CarpetRule(String identifier, String name, String value) {
++
++        @NotNull
++        @Contract("_, _, _ -> new")
++        public static CarpetRule of(String identifier, String name, Enum<?> value) {
++            return new CarpetRule(identifier, name, value.name().toLowerCase(Locale.ROOT));
++        }
++
++        @NotNull
++        @Contract("_, _, _ -> new")
++        public static CarpetRule of(String identifier, String name, boolean value) {
++            return new CarpetRule(identifier, name, Boolean.toString(value));
++        }
++
++        public void writeNBT(@NotNull CompoundTag rules) {
++            CompoundTag rule = new CompoundTag();
++            rule.putString("Value", value);
++            rule.putString("Manager", identifier);
++            rule.putString("Rule", name);
++            rules.put(name, rule);
++        }
++    }
++
++    public record CarpetPayload(CompoundTag nbt) implements CustomPacketPayload {
++
++        public CarpetPayload(ResourceLocation location, FriendlyByteBuf buf) {
++            this(buf.readNbt());
++        }
++
++        @Override
++        public void write(FriendlyByteBuf buf) {
++            buf.writeNbt(nbt);
++        }
++
++        @Override
++        @NotNull
++        public ResourceLocation id() {
++            return HELLO_ID;
++        }
++    }
++}

patches/server/0060-Threaded-region-start-tick-and-finished-tick-event.patch

@@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Fri, 9 Feb 2024 03:32:05 +0000
+Subject: [PATCH] Threaded region start tick and finished tick event
+
+
+diff --git a/src/main/java/io/papermc/paper/threadedregions/TickRegionScheduler.java b/src/main/java/io/papermc/paper/threadedregions/TickRegionScheduler.java
+index 865044d40a95d201765435cbc14b0384980eebf6..ab5f832aafc479eca1c5da012e180d6374e32325 100644
+--- a/src/main/java/io/papermc/paper/threadedregions/TickRegionScheduler.java
++++ b/src/main/java/io/papermc/paper/threadedregions/TickRegionScheduler.java
+@@ -389,7 +389,7 @@ public final class TickRegionScheduler {
+ 
+             final long scheduledStart = this.getScheduledStart();
+             final long scheduledEnd = scheduledStart + TIME_BETWEEN_TICKS;
+-
++            new me.earthme.luminol.api.events.TickRegionStartTickEvent(this.region == null ? -1 : this.region.region.id,System.nanoTime()); //Luminol - Threaded regions API
+             synchronized (this) {
+                 this.currentTickData = new TickTime(
+                     lastTickStart, scheduledStart, tickStart, cpuStart,
+@@ -424,6 +424,7 @@ public final class TickRegionScheduler {
+                 );
+ 
+                 this.addTickTime(time);
++                new me.earthme.luminol.api.events.TickRegionFinishedTickEvent(this.region == null ? -1 : this.region.region.id,System.nanoTime()); //Luminol - Threaded regions API
+                 TickRegionScheduler.setTickTask(null);
+                 if (this.region != null) {
+                     TickRegionScheduler.setTickingRegion(null);

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

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

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

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

patches/unapplied/api/0002-Threaded-region-remove-and-create-event.patch

@@ -0,0 +1,78 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Fri, 9 Feb 2024 03:28:48 +0000
+Subject: [PATCH] Threaded region remove and create event
+
+
+diff --git a/src/main/java/me/earthme/luminol/api/events/TickRegionCreateEvent.java b/src/main/java/me/earthme/luminol/api/events/TickRegionCreateEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..9f842aeb33e658f3db540b6195f848d2a56ce14f
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/events/TickRegionCreateEvent.java
+@@ -0,0 +1,32 @@
++package me.earthme.luminol.api.events;
++
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * This event was called when a new threaded region was created.When the event called,it means this region was already added to the region list
++ * Notice: It may be called when splitting or merging regions
++ */
++public class TickRegionCreateEvent extends Event {
++    private static final HandlerList handlers = new HandlerList();
++
++    private final long id;
++
++    public TickRegionCreateEvent(long id) {
++        this.id = id;
++    }
++
++    /**
++     * Get the id of the threaded region which was created
++     * @return The id of the threaded region
++     */
++    public long getId() {
++        return this.id;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return handlers;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/events/TickRegionRemoveEvent.java b/src/main/java/me/earthme/luminol/api/events/TickRegionRemoveEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..aa3d3868f9d0c3353380960db36ee60a6b4aeb03
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/events/TickRegionRemoveEvent.java
+@@ -0,0 +1,28 @@
++package me.earthme.luminol.api.events;
++
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * This event was called when a new threaded region was removed.When the event called,it means this region was already removed from the region list
++ * Notice: It may be called when splitting or merging regions
++ */
++public class TickRegionRemoveEvent extends Event {
++    private static final HandlerList handlers = new HandlerList();
++
++    private final long id;
++
++    public TickRegionRemoveEvent(long id) {
++        this.id = id;
++    }
++
++    public long getId() {
++        return this.id;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return handlers;
++    }
++}