Update build_1.21.4.yml (#75)

* feat: Disable Heightmap Warning

* description: fix text in raid Config

.github/workflows/build_1.21.4.yml

@@ -1,10 +1,10 @@
-name: Luminol CI - dev/1.21.4-hardfork
+name: Luminol CI - dev/1.21.4-hardfork-with-new-scheduler
 
 on:
     push:
-      branches: [ "dev/1.21.4-hardfork" ]
+      branches: [ "dev/1.21.4-hardfork-with-new-scheduler" ]
     pull_request:
-      branches: [ "dev/1.21.4-hardfork" ]
+      branches: [ "dev/1.21.4-hardfork-with-new-scheduler" ]
 
 permissions: write-all
 
@@ -31,6 +31,7 @@ jobs:
       - name: CreateJar
         run: ./gradlew createMojmapPaperclipJar
       - name: Publish to repo
+        if: github.event_name != 'pull_request'
         continue-on-error: true
         run: |
           export MAVEN_REPO_USER=${{ secrets.MAVEN_REPO_USER }}
@@ -40,23 +41,28 @@ jobs:
         uses: "actions/upload-artifact@v4"
         with:
           name: "${{ env.project_id_b }} CI Artifacts"
-          path: "luminol-server/build/libs/*.jar"
+          path: "luminol-server/build/libs/*-paperclip-*-mojmap.jar"
       - name: SetENV
+        if: github.event_name != 'pull_request'
         run: sh scripts/SetENV.sh
       - name: Create Release
-        if: "!contains(github.event.commits[0].message, '[release skip]')"
+        if: github.event_name != 'pull_request'
-        uses: ncipollo/release-action@v1.14.0
+        uses: ncipollo/release-action@v1.16.0
         with:
           tag: ${{ env.tag }}
           name: ${{ env.project_id_b }} ${{ env.mcversion }} - ${{ env.commit_id }}
           body: |
+            > [!CAUTION]
+            > 🚨You are trying to download experimental builds!
+            > **<u>DO NOT</u>** use these builds in production, as there may be many bugs and corruption issues.
+            > Please report any and all issues you encounter!
+            
             📦Version: `${{ env.mcversion }}` | Commit ${{ env.commit_id }} [![download](https://img.shields.io/github/downloads/LuminolMC/${{ env.project_id }}/${{ env.tag }}/total?color=red&style=flat-square)](https://github.com/LuminolMC/${{ env.project_id }}/download/${{ env.tag }}/${{ env.jar }})
             This release is automatically compiled by GitHub Actions
             ### Commit Message
             ${{ env.commit_msg }}
           artifacts: |
             ${{ env.jar_dir }}
-            ${{ env.jar_dir_bundler }}
           generateReleaseNotes: true
           prerelease: ${{ env.pre }}
           makeLatest: ${{ env.make_latest }}

.gitignore

@@ -10,9 +10,8 @@ build
 /luminol-api/build.gradle.kts
 /folia-server/build.gradle.kts
 /folia-server/src/minecraft
-/paper-server
 /folia-api/build.gradle.kts
+/paper-server
 /paper-api
-/paper-api-generator
 
 .idea/

Jenkinsfile

@@ -0,0 +1,48 @@
+pipeline {
+    agent any
+
+    stages {
+        stage('Configure git') {
+            steps {
+                script {
+                    sh 'git config --global user.name "luminolmc"'
+                    sh 'git config --global user.email "luminolmc@noreply.github.com"'
+                }
+            }
+        }
+
+        stage('Apply patches') {
+            steps {
+                script {
+                    sh 'chmod +x gradlew'
+                    sh './gradlew applyAllPatches'
+                }
+            }
+        }
+
+        stage('Build paperclip jar') {
+            steps {
+                script {
+                    sh './gradlew createMojmapPaperclipJar'
+                }
+            }
+        }
+
+        stage('Upload artifacts') {
+            steps {
+               script {
+                   archiveArtifacts(
+                       artifacts: "luminol-server/build/libs/*.jar",
+                       allowEmptyArchive: false
+                   )
+               }
+            }
+        }
+    }
+
+    post {
+        always {
+            cleanWs()
+        }
+    }
+}

README.md

@@ -24,7 +24,7 @@
 要构建一个paperclip jar，你需要运行以下命令。你可以在build/libs中找到jar（注意：需要`JDK21`）
 
  ```shell
- ./gradlew applyPatches && ./gradlew createMojmapPaperclipJar
+ ./gradlew applyAllPatches && ./gradlew createMojmapPaperclipJar
 ```
 
 ## 使用API
@@ -38,7 +38,7 @@ repositories {
 }
 
 dependencies {
-    compileOnly("me.earthme.luminol:luminol-api:1.21.4-R0.1-20250111.144052-34")
+    compileOnly("me.earthme.luminol:luminol-api:$VERSION")
 }
  ```
 
@@ -56,7 +56,7 @@ dependencies {
     <dependency>
         <groupId>me.earthme.luminol</groupId>
         <artifactId>luminol-api</artifactId>
-        <version>1.21.4-R0.1-20250111.144052-34</version>
+        <version>$VERSION</version>
     </dependency>
 </dependencies>
 ```
@@ -64,7 +64,7 @@ dependencies {
 ## 联系方式
 > 如果您对这个项目感兴趣或有任何问题，请随时向我们提问。
 
-**QQ群: [368632360](http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=MfosKhcDd8Fdxn1MREuZ8Krbf9T6jiBC&authKey=3cm6qdHohON3gHnuD63FK4k07fIbrWnY4hdyq8OmELsfjMVP1kbFTJY9mRyM2Rkj&noverify=0&group_code=368632360)** | QQ频道: [点击加入](https://pd.qq.com/s/eq9krf9j) | Telegram: [点击加入](https://t.me/LuminolMC) | Discord: [点击加入](https://discord.gg/Qd7m3V6eDx)
+**QQ群: [1015048616](http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=QML5kIVsniPi1PlZvnjHQT_02EHsZ5Jc&authKey=%2FTCJsZC7JFQ9sxAroPCKuYnlV57Z5fyqp36ewXZk3Sn4iJ9p4MB1JKdc%2FFcX3HOM&noverify=0&group_code=1015048616)** | QQ频道: [点击加入](https://pd.qq.com/s/eq9krf9j) | Telegram: [点击加入](https://t.me/LuminolMinecraft) | Discord: [点击加入](https://discord.gg/Qd7m3V6eDx)
 
 
 ## 关于 Issue

README_EN.md

@@ -25,7 +25,7 @@ Any versions are available in the [release](https://github.com/LuminolMC/Luminol
 To build a paperclip jar, you need to run the following command. You can find the jar in build/libs(Note: JDK21 is needed)
 
  ```shell
- ./gradlew applyPatches && ./gradlew createMojmapPaperclipJar
+ ./gradlew applyAllPatches && ./gradlew createMojmapPaperclipJar
 ```
 
 ## Using API
@@ -39,7 +39,7 @@ repositories {
 }
 
 dependencies {
-    compileOnly("me.earthme.luminol:luminol-api:1.21.4-R0.1-20250111.144052-34")
+    compileOnly("me.earthme.luminol:luminol-api:$VERSION")
 }
  ```
 
@@ -57,7 +57,7 @@ For maven
 <dependency>
     <groupId>me.earthme.luminol</groupId>
     <artifactId>luminol-api</artifactId>
-    <version>1.21.4-R0.1-20250111.144052-34</version>
+    <version>$VERSION</version>
 </dependency>
 </dependencies>
 ```
@@ -65,7 +65,7 @@ For maven
 ## Contact
 > If you are interested in this project or have any issue, feel free to ask us.
 
-**QQ Group: [368632360](http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=MfosKhcDd8Fdxn1MREuZ8Krbf9T6jiBC&authKey=3cm6qdHohON3gHnuD63FK4k07fIbrWnY4hdyq8OmELsfjMVP1kbFTJY9mRyM2Rkj&noverify=0&group_code=368632360)** | QQ Channel: [Click To Join](https://pd.qq.com/s/eq9krf9j) | Telegram: [Click To Join](https://t.me/LuminolMC) | Discord: [Click To Join](https://discord.gg/Qd7m3V6eDx)
+**QQ Group: [1015048616](http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=hTPlI5j6XB8pgk4sdx6RkjhBPGG1r4IR&authKey=pnu6uCKQP7Sja2CJWC15Qi3BeI%2FAsh8tU4m5muufMBjbB3zz%2BwHBZCTRRdSNKhld&noverify=0&group_code=1015048616)** | QQ Channel: [Click To Join](https://pd.qq.com/s/eq9krf9j) | Telegram: [Click To Join](https://t.me/LuminolMinecraft) | Discord: [Click To Join](https://discord.gg/Qd7m3V6eDx)
 
 ## About Issue
 When you meet any problems, just ask us, we will do our best to solve it, but remember to state your problem clear and provide enough logs etc.</br>

build.gradle.kts

@@ -3,7 +3,7 @@ import org.gradle.api.tasks.testing.logging.TestLogEvent
 
 plugins {
     java // TODO java launcher tasks
-    id("io.papermc.paperweight.patcher") version "2.0.0-beta.14"
+    id("io.papermc.paperweight.patcher") version "2.0.0-SNAPSHOT"
 }
 
 paperweight {

docs/CONTRIBUTING.md

@@ -21,23 +21,24 @@
 在开始开发之前，您首先需要拥有以下软件作为开发环境：
 
 - `git`
-- `JDK 17 或更高版本`
+- `JDK 21 或更高版本`
 
 ## 了解补丁（Patches）
 
 Luminol 使用和 Folia 一样的补丁系统，并为了针对不同部分的修改分成了两个目录：
 
 - `luminol-api` - 对 `Folia-API` / `Paper-API` / `Spigot-API` / `Bukkit` 进行的修改。
+- `luminol-server` - 对 Minecraft 标准服务器原有逻辑进行的修改。
 
 补丁系统是基于 git 的，你可以在这里了解 git 的基本内容: <https://git-scm.com/docs/gittutorial>
 
 如果你已经 Fork 了主储存库，那么下面你应该这么做：
 
 1. 将你的仓库 clone 到本地；
-2. 在你的 IDE 或 终端 内执行 Gradle 的 `applyPatches` 任务，如果是在终端内，你可以执行 `./gradlew applyPatches`；
+2. 在你的 IDE 或 终端 内执行 Gradle 的 `applyAllPatches` 任务，如果是在终端内，你可以执行 `./gradlew applyAllPatches`；
-3. 进入 `luminol-api` 文件夹进行修改。
+3. 进入 仓库根目录下的 `luminol-api` 和 `luminol-server` 文件夹进行修改。
 
-顺便一提，`luminol-api` 并不是正常的 git 仓库：
+顺便一提，仓库根目录下的 `luminol-api` 和 `luminol-server` 并不是正常的 git 仓库：
 
 - 在应用补丁前，基点将会指向未被更改的源码
 - 在基点后的每一个提交都是一个补丁
@@ -47,11 +48,12 @@ Luminol 使用和 Folia 一样的补丁系统，并为了针对不同部分的
 
 按照以下步骤增加一个补丁是非常简单的：
 
-1. 对 `luminol-api` 进行修改；
+1. 对 `luminol-api` 和 `luminol-server` 进行修改；
-2. 使用 git 添加你的修改，比如 `git add .`；
+2. 使用 git 添加你的修改，比如 `git add .`（不要提交新建的文件的修改）；
 3. 使用 `git commit -m <提交信息>` 进行提交；
-4. 运行 Gradle 任务 `rebuildPatches` 将你的提交转化为一个补丁；
+4. 运行 Gradle 任务 `rebuildAllServerPatches` 将你的提交转化为一个补丁；
-5. 将你生成的补丁文件进行推送。
+5. 运行 Gradle 任务 `fixupPaperApiFilePatches` 生成新建文件的补丁文件（注意不要提交）；
+6. 将你生成的补丁文件进行推送。
 
 这样做以后，你就可以将你的补丁文件进行 PR 提交。
 
@@ -60,8 +62,9 @@ Luminol 使用和 Folia 一样的补丁系统，并为了针对不同部分的
 你可以使用以下方法来修改一个补丁的内容：
 
 1. 在 HEAD 上直接进行修改；
-2. 使用 `git commit -a --fixup <hash>` 来进行一个更正提交；
+2. 使用 `git commit -a --fixup <hash>` 来进行一个更正提交；（不要提交对在luminol新建文件的修改）
    - 如果你想要更改提交信息，你也可以用 `--squash` 来代替 `--fixup`。
 3. 使用 `git rebase -i --autosquash base` 来进行自动变基，你只需要输入 `:q` 来关闭确认页面即可；
-4. 运行 Gradle 任务 `rebuildPatches` 来修改已被修改的补丁；
+4. 运行 Gradle 任务 `rebuildAllServerPatches` 来修改已被修改的补丁；
-5. 将修改后的补丁 PR 发回储存库。
+5. 运行 Gradle 任务 `fixupPaperApiFilePatches` 来修改已被修改的在luminol新建文件的补丁（注意不要提交）；
+6. 将修改后的补丁 PR 发回储存库。

docs/CONTRIBUTING_EN.md

@@ -10,20 +10,20 @@ 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.
+If there are 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.
+But, if your PR is from an organization, we can NOT edit your PR, so we must merge your PR manually.
 
-So, don't use orgnization accounts for fork!
+So, don't use organization 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.
+Before coding, you need these pieces of software / tools as Dev Environment.
 
 - `git`
-- `JDK 17 or higher`
+- `JDK 21 or higher`
 
 ## Understanding "Patches"
 
@@ -31,40 +31,43 @@ 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`.
+- `luminol-server` - Modifications to Minecraft Official Server's source logic.
 
 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.)
+2. Run Gradle's `applyAllPatches` task in your IDE or terminal (You can run `./gradlew applyAllPatches` directly in terminal.)
-3. Enter `luminol-api` directory to carry out modifications.
+3. Enter `luminol-api` and `luminol-server` directory to carry out modifications.
 
-BTW, `luminol-api` and are not normal git repositories.
+BTW, `luminol-api` and `luminol-server` 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.
+- Only commits after the last commit of Paper will be considered as Luminol patches.
 
 ## Adding new patches
 
-It's very easy to to add patches by following the steps below:
+It's very easy to add patches by following the steps below:
 
-1. Modify the code of `luminol-api`
+1. Modify the code of `luminol-api` and `luminol-server`
 2. Add these changes to the local git repository (For example, `git add .`)
-3. Commit these changes using `git commit -m <Commit Message>`
+3. Commit these changes using `git commit -m <Commit Message>` (PS: do not commit new-created files)
-4. Run Gradle's task `rebuildPatches` to convert your commits to a new patch
+4. Run Gradle's task `rebuildAllServerPatches` to convert your commits to a new patch
-5. Push your patches to your repository
+5. Run Gradle's task `fixupPaperApiFilePatches` to generate newly created files to new patches (PS: do not commit again before you run this task)
+6. 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:
+You can modify an 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
+2. Run `git commit -a --fixup <hash>` in your terminal to make a fix-up commit (PS: do not commit changes of luminol-created files)
     - 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
+4. Run Gradle's task `rebuildAllServerPatches` to modify existing patches 
-5. Push and PR again
+5. Run Gradle's task `fixupPaperApiFilePatches` to regenerate luminol-created files to patches (PS: do not commit again before you run this task)
+6. Push and PR again

gradle.properties

@@ -2,7 +2,7 @@ group = me.earthme.luminol
 version=1.21.4-R0.1-SNAPSHOT
 mcVersion=1.21.4
 
-foliaRef=92efc63ec30ae445120c361b2c66b73cf8686302
+foliaRef=80ab57dcbe5fa96cc2f7fe34ecba94162d8dd5e9
 
 org.gradle.configuration-cache=true
 org.gradle.caching=true

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

@@ -1,6 +1,6 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: MrHua269 <wangxyper@163.com>
-Date: Sun, 12 Jan 2025 11:45:16 +0800
+Date: Tue, 11 Feb 2025 09:16:49 +0800
 Subject: [PATCH] KioCG Chunk API
 
 
@@ -16,13 +16,13 @@ index d434277342b2db19f98e032d3a316b27d728b840..e188353ad193f6203533790ae52fafc0
 +    long getChunkHotAvg(); // KioCG
  }
 diff --git a/src/main/java/org/bukkit/entity/Player.java b/src/main/java/org/bukkit/entity/Player.java
-index 7d21ee64c9b9c14412a1eddb63fae812a91e7d9c..83e8a442a909ca2595d2eb0946c804e0814bc9a8 100644
+index 494dca2ee48a03953d47050b178496df12bc48c5..a65d64b1ef64cf1cf213cec00e7f73cc7ad2b79c 100644
 --- a/src/main/java/org/bukkit/entity/Player.java
 +++ b/src/main/java/org/bukkit/entity/Player.java
-@@ -3892,4 +3892,6 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
+@@ -3918,4 +3918,6 @@ public interface Player extends HumanEntity, Conversable, OfflinePlayer, PluginM
+      * @param score New death screen score of player
       */
-     void sendEntityEffect(org.bukkit.@NotNull EntityEffect effect, @NotNull Entity target);
+     void setDeathScreenScore(int score);
-     // Paper end - entity effect API
 +
 +    long getNearbyChunkHot(); // KioCG
  }

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

@@ -6,10 +6,10 @@ Subject: [PATCH] Pufferfish SIMD Utilities
 
 diff --git a/src/main/java/gg/pufferfish/pufferfish/simd/SIMDChecker.java b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDChecker.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..f00c008c03e2533f568085838cf13cb9b5b32cd9
+index 0000000000000000000000000000000000000000..856de1331b15542c00e01990f471fa5152722c11
 --- /dev/null
 +++ b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDChecker.java
-@@ -0,0 +1,39 @@
+@@ -0,0 +1,35 @@
 +package gg.pufferfish.pufferfish.simd;
 +
 +import jdk.incubator.vector.FloatVector;
@@ -26,24 +26,20 @@ index 0000000000000000000000000000000000000000..f00c008c03e2533f568085838cf13cb9
 +	@Deprecated
 +	public static boolean canEnable(Logger logger) {
 +		try {
-+			if (SIMDDetection.getJavaVersion() < 17 || SIMDDetection.getJavaVersion() > 21) {
++			SIMDDetection.testRun = true;
++
++			VectorSpecies<Integer> ISPEC = IntVector.SPECIES_PREFERRED;
++			VectorSpecies<Float> FSPEC = FloatVector.SPECIES_PREFERRED;
++
++			logger.info("Max SIMD vector size on this system is {} bits (int)", ISPEC.vectorBitSize());
++			logger.info("Max SIMD vector size on this system is " + FSPEC.vectorBitSize() + " bits (float)");
++
++			if (ISPEC.elementSize() < 2 || FSPEC.elementSize() < 2) {
++				logger.warn("SIMD is not properly supported on this system!");
 +				return false;
-+			} else {
-+				SIMDDetection.testRun = true;
-+				
-+				VectorSpecies<Integer> ISPEC = IntVector.SPECIES_PREFERRED;
-+				VectorSpecies<Float> FSPEC = FloatVector.SPECIES_PREFERRED;
-+
-+                logger.info("Max SIMD vector size on this system is {} bits (int)", ISPEC.vectorBitSize());
-+				logger.info("Max SIMD vector size on this system is " + FSPEC.vectorBitSize() + " bits (float)");
-+				
-+				if (ISPEC.elementSize() < 2 || FSPEC.elementSize() < 2) {
-+					logger.warn("SIMD is not properly supported on this system!");
-+					return false;
-+				}
-+
-+				return true;
 +			}
++
++			return true;
 +		} catch (NoClassDefFoundError | Exception ignored) {} // Basically, we don't do anything. This lets us detect if it's not functional and disable it.
 +		return false;
 +	}
@@ -51,10 +47,10 @@ index 0000000000000000000000000000000000000000..f00c008c03e2533f568085838cf13cb9
 +}
 diff --git a/src/main/java/gg/pufferfish/pufferfish/simd/SIMDDetection.java b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDDetection.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..cd953435a6179eaae7c9cc250a791cae26c5567b
+index 0000000000000000000000000000000000000000..0a64cd0e88083ac4af6674ad0fb07b771109c737
 --- /dev/null
 +++ b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDDetection.java
-@@ -0,0 +1,35 @@
+@@ -0,0 +1,34 @@
 +package gg.pufferfish.pufferfish.simd;
 +
 +import org.slf4j.Logger;
@@ -63,7 +59,6 @@ index 0000000000000000000000000000000000000000..cd953435a6179eaae7c9cc250a791cae
 +public class SIMDDetection {
 +	
 +	public static boolean isEnabled = false;
-+	public static boolean versionLimited = false;
 +	public static boolean testRun = false;
 +	
 +	@Deprecated
@@ -90,3 +85,118 @@ index 0000000000000000000000000000000000000000..cd953435a6179eaae7c9cc250a791cae
 +	}
 +	
 +}
+diff --git a/src/main/java/gg/pufferfish/pufferfish/simd/VectorMapPalette.java b/src/main/java/gg/pufferfish/pufferfish/simd/VectorMapPalette.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..c26dcaaa2e85882730c854099df80d69eec70f33
+--- /dev/null
++++ b/src/main/java/gg/pufferfish/pufferfish/simd/VectorMapPalette.java
+@@ -0,0 +1,84 @@
++package gg.pufferfish.pufferfish.simd;
++
++import jdk.incubator.vector.FloatVector;
++import jdk.incubator.vector.IntVector;
++import jdk.incubator.vector.VectorMask;
++import jdk.incubator.vector.VectorSpecies;
++import org.bukkit.map.MapPalette;
++
++import java.awt.*;
++
++@Deprecated
++public class VectorMapPalette {
++
++    private static final VectorSpecies<Integer> I_SPEC = IntVector.SPECIES_PREFERRED;
++    private static final VectorSpecies<Float> F_SPEC = FloatVector.SPECIES_PREFERRED;
++
++    @Deprecated
++    public static void matchColorVectorized(int[] in, byte[] out) {
++        int speciesLength = I_SPEC.length();
++        int i;
++        for (i = 0; i < in.length - speciesLength; i += speciesLength) {
++            float[] redsArr = new float[speciesLength];
++            float[] bluesArr = new float[speciesLength];
++            float[] greensArr = new float[speciesLength];
++            int[] alphasArr = new int[speciesLength];
++
++            for (int j = 0; j < speciesLength; j++) {
++                alphasArr[j] = (in[i + j] >> 24) & 0xFF;
++                redsArr[j] = (in[i + j] >> 16) & 0xFF;
++                greensArr[j] = (in[i + j] >> 8) & 0xFF;
++                bluesArr[j] = (in[i + j] >> 0) & 0xFF;
++            }
++
++            IntVector alphas = IntVector.fromArray(I_SPEC, alphasArr, 0);
++            FloatVector reds = FloatVector.fromArray(F_SPEC, redsArr, 0);
++            FloatVector greens = FloatVector.fromArray(F_SPEC, greensArr, 0);
++            FloatVector blues = FloatVector.fromArray(F_SPEC, bluesArr, 0);
++            IntVector resultIndex = IntVector.zero(I_SPEC);
++            VectorMask<Integer> modificationMask = VectorMask.fromLong(I_SPEC, 0xffffffff);
++
++            modificationMask = modificationMask.and(alphas.lt(128).not());
++            FloatVector bestDistances = FloatVector.broadcast(F_SPEC, Float.MAX_VALUE);
++
++            for (int c = 4; c < MapPalette.colors.length; c++) {
++                // We're using 32-bit floats here because it's 2x faster and nobody will know the difference.
++                // For correctness, the original algorithm uses 64-bit floats instead. Completely unnecessary.
++                FloatVector compReds = FloatVector.broadcast(F_SPEC, MapPalette.colors[c].getRed());
++                FloatVector compGreens = FloatVector.broadcast(F_SPEC, MapPalette.colors[c].getGreen());
++                FloatVector compBlues = FloatVector.broadcast(F_SPEC, MapPalette.colors[c].getBlue());
++
++                FloatVector rMean = reds.add(compReds).div(2.0f);
++                FloatVector rDiff = reds.sub(compReds);
++                FloatVector gDiff = greens.sub(compGreens);
++                FloatVector bDiff = blues.sub(compBlues);
++
++                FloatVector weightR = rMean.div(256.0f).add(2);
++                FloatVector weightG = FloatVector.broadcast(F_SPEC, 4.0f);
++                FloatVector weightB = FloatVector.broadcast(F_SPEC, 255.0f).sub(rMean).div(256.0f).add(2.0f);
++
++                FloatVector distance = weightR.mul(rDiff).mul(rDiff).add(weightG.mul(gDiff).mul(gDiff)).add(weightB.mul(bDiff).mul(bDiff));
++
++                // Now we compare to the best distance we've found.
++                // This mask contains a "1" if better, and a "0" otherwise.
++                VectorMask<Float> bestDistanceMask = distance.lt(bestDistances);
++                bestDistances = bestDistances.blend(distance, bestDistanceMask); // Update the best distances
++
++                // Update the result array
++                // We also AND with the modification mask because we don't want to interfere if the alpha value isn't large enough.
++                resultIndex = resultIndex.blend(c, bestDistanceMask.cast(I_SPEC).and(modificationMask)); // Update the results
++            }
++
++            for (int j = 0; j < speciesLength; j++) {
++                int index = resultIndex.lane(j);
++                out[i + j] = (byte) (index < 128 ? index : -129 + (index - 127));
++            }
++        }
++
++        // For the final ones, fall back to the regular method
++        for (; i < in.length; i++) {
++            out[i] = MapPalette.matchColor(new Color(in[i], true));
++        }
++    }
++
++}
+diff --git a/src/main/java/org/bukkit/map/MapPalette.java b/src/main/java/org/bukkit/map/MapPalette.java
+index 6995f9cc08d162e3adcd3a28f6bfa6d329661999..83ea70a16b4090a8c628784f2807cd16e7065103 100644
+--- a/src/main/java/org/bukkit/map/MapPalette.java
++++ b/src/main/java/org/bukkit/map/MapPalette.java
+@@ -45,7 +45,7 @@ public final class MapPalette {
+     }
+ 
+     @NotNull
+-    static final Color[] colors = {
++    public static final Color[] colors = { // Luminol - package-private -> public
+         c(0, 0, 0, 0), c(0, 0, 0, 0), c(0, 0, 0, 0), c(0, 0, 0, 0),
+         c(89, 125, 39), c(109, 153, 48), c(127, 178, 56), c(67, 94, 29),
+         c(174, 164, 115), c(213, 201, 140), c(247, 233, 163), c(130, 123, 86),
+@@ -216,9 +216,11 @@ public final class MapPalette {
+         temp.getRGB(0, 0, temp.getWidth(), temp.getHeight(), pixels, 0, temp.getWidth());
+ 
+         byte[] result = new byte[temp.getWidth() * temp.getHeight()];
++        if ((mapColorCache != null && mapColorCache.isCached()) || !gg.pufferfish.pufferfish.simd.SIMDDetection.isEnabled) { // Luminol - Pufferfish - vectorized map color conversion
+         for (int i = 0; i < pixels.length; i++) {
+             result[i] = matchColor(new Color(pixels[i], true));
+         }
++        } else gg.pufferfish.pufferfish.simd.VectorMapPalette.matchColorVectorized(pixels, result); // Luminol - Pufferfish - vectorized map color conversion
+         return result;
+     }
+ 

luminol-api/paper-patches/features/0007-FoliaPR-Add-TPS-From-Region.patch

@@ -1,68 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MrHua269 <wangxyper@163.com>
-Date: Sun, 12 Jan 2025 15:39:43 +0800
-Subject: [PATCH] FoliaPR Add TPS From Region
-
-
-diff --git a/src/main/java/org/bukkit/Bukkit.java b/src/main/java/org/bukkit/Bukkit.java
-index 9196b1e62b328b1e9790b966600aba9681dd0ddc..c4ebe5b9c27277dcc984aa582af2a5e5e12ca936 100644
---- a/src/main/java/org/bukkit/Bukkit.java
-+++ b/src/main/java/org/bukkit/Bukkit.java
-@@ -2441,6 +2441,28 @@ public final class Bukkit {
-     }
-     // Paper end
- 
-+    // Folia start
-+    /**
-+     * Gets the current location TPS.
-+     *
-+     * @param location the location for which to get the TPS
-+     * @return current location TPS (5s, 15s, 1m, 5m, 15m in Folia-Server), or null if the region doesn't exist
-+     */
-+    public double @Nullable [] getTPS(Location location) {
-+        return server.getTPS(location);
-+    }
-+
-+    /**
-+     * Gets the current chunk TPS.
-+     *
-+     * @param chunk the chunk for which to get the TPS
-+     * @return current chunk TPS (5s, 15s, 1m, 5m, 15m in Folia-Server), or null if the region doesn't exist
-+     */
-+    public double @Nullable [] getTPS(Chunk chunk){
-+        return server.getTPS(chunk);
-+    }
-+    // Folia end
-+
-     /**
-      * Get the advancement specified by this key.
-      *
-diff --git a/src/main/java/org/bukkit/Server.java b/src/main/java/org/bukkit/Server.java
-index 11923ef0ea75f702273ba5481ac6d46cc0f17697..6bba6c555e8873057693f60ac1a4b6281b299258 100644
---- a/src/main/java/org/bukkit/Server.java
-+++ b/src/main/java/org/bukkit/Server.java
-@@ -2123,6 +2123,24 @@ public interface Server extends PluginMessageRecipient, net.kyori.adventure.audi
-     double getAverageTickTime();
-     // Paper end
- 
-+    // Folia start
-+    /**
-+     * Gets the current location TPS.
-+     *
-+     * @param location the location for which to get the TPS
-+     * @return current location TPS (5s, 15s, 1m, 5m, 15m in Folia-Server), or null if the region doesn't exist
-+     */
-+    public double @Nullable [] getTPS(Location location);
-+
-+    /**
-+     * Gets the current chunk TPS.
-+     *
-+     * @param chunk the chunk for which to get the TPS
-+     * @return current chunk TPS (5s, 15s, 1m, 5m, 15m in Folia-Server), or null if the region doesn't exist
-+     */
-+    public double @Nullable [] getTPS(Chunk chunk);
-+    // Folia end
-+
-     // Paper start
-     /**
-      * Gets the active {@link org.bukkit.command.CommandMap}

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

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

luminol-api/paper-patches/features/0008-Purpur-Lobotomize-stuck-villagers.patch

@@ -0,0 +1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Thu, 30 Jan 2025 09:29:03 +0800
+Subject: [PATCH] Purpur Lobotomize stuck villagers
+
+
+diff --git a/src/main/java/org/bukkit/entity/Villager.java b/src/main/java/org/bukkit/entity/Villager.java
+index 1db3742024e9cd1b70af2d52b4b756a544c019df..9c722a762c88a88bb5ef18c3b9eab8b371360dac 100644
+--- a/src/main/java/org/bukkit/entity/Villager.java
++++ b/src/main/java/org/bukkit/entity/Villager.java
+@@ -367,4 +367,14 @@ public interface Villager extends AbstractVillager {
+      */
+     public void clearReputations();
+     // Paper end
++
++    // Purpur start
++
++    /**
++     * Check if villager is currently lobotomized
++     *
++     * @return True if lobotomized
++     */
++    boolean isLobotomized();
++    // Purpur end
+ }

luminol-api/paper-patches/features/0009-Add-missing-teleportation-apis-for-folia.patch

@@ -0,0 +1,357 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Fri, 31 Jan 2025 20:28:47 +0800
+Subject: [PATCH] Add missing teleportation apis for folia
+
+
+diff --git a/src/main/java/me/earthme/luminol/api/entity/EntityTeleportAsyncEvent.java b/src/main/java/me/earthme/luminol/api/entity/EntityTeleportAsyncEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..a31c803831dad3d31386924cbe27deff59855fc9
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/entity/EntityTeleportAsyncEvent.java
+@@ -0,0 +1,68 @@
++package me.earthme.luminol.api.entity;
++
++import org.apache.commons.lang3.Validate;
++import org.bukkit.Location;
++import org.bukkit.entity.Entity;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.bukkit.event.player.PlayerTeleportEvent;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A simple event fired when a teleportAsync was called
++ * @see org.bukkit.entity.Entity#teleportAsync(org.bukkit.Location, org.bukkit.event.player.PlayerTeleportEvent.TeleportCause)
++ * @see org.bukkit.entity.Entity#teleportAsync(org.bukkit.Location)
++ * (Also fired when teleportAsync called from nms)
++ */
++public class EntityTeleportAsyncEvent extends Event {
++    private static final HandlerList HANDLERS = new HandlerList();
++
++    private final Entity entity;
++    private final PlayerTeleportEvent.TeleportCause teleportCause;
++    private final Location destination;
++
++    public EntityTeleportAsyncEvent(Entity entity, PlayerTeleportEvent.TeleportCause teleportCause, Location destination) {
++        Validate.notNull(entity, "entity cannot be a null value!");
++        Validate.notNull(teleportCause, "teleportCause cannot be a null value!");
++        Validate.notNull(destination, "destination cannot be a null value!");
++
++        this.entity = entity;
++        this.teleportCause = teleportCause;
++        this.destination = destination;
++    }
++
++    /**
++     * Get the entity is about to be teleported
++     * @return that entity
++     */
++    public @NotNull Entity getEntity() {
++        return this.entity;
++    }
++
++    /**
++     * Get the cause of the teleport
++     * @return the cause
++     */
++    public @NotNull PlayerTeleportEvent.TeleportCause getTeleportCause() {
++        return this.teleportCause;
++    }
++
++    /**
++     * Get the destination of the teleport
++     * @return the destination
++     */
++    public @NotNull Location getDestination() {
++        return this.destination;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLERS;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLERS;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/entity/PostEntityPortalEvent.java b/src/main/java/me/earthme/luminol/api/entity/PostEntityPortalEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..dd3087b407ccf4e96448701e6fbf75705498f982
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/entity/PostEntityPortalEvent.java
+@@ -0,0 +1,41 @@
++package me.earthme.luminol.api.entity;
++
++import org.apache.commons.lang3.Validate;
++import org.bukkit.entity.Entity;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A simple event created for missing teleport events api of folia
++ * This event is fired when the entity portal process has been done
++ */
++public class PostEntityPortalEvent extends Event {
++    private static final HandlerList HANDLER_LIST = new HandlerList();
++
++    private final Entity teleportedEntity;
++
++    public PostEntityPortalEvent(Entity teleportedEntity) {
++        Validate.notNull(teleportedEntity, "teleportedEntity cannot be null!");
++
++        this.teleportedEntity = teleportedEntity;
++    }
++
++    /**
++     * Get the entity which was teleported
++     * @return the entity which was teleported
++     */
++    public Entity getTeleportedEntity() {
++        return this.teleportedEntity;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLER_LIST;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLER_LIST;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/entity/PreEntityPortalEvent.java b/src/main/java/me/earthme/luminol/api/entity/PreEntityPortalEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..fc844429e3ecfe2529c0a49b8a5d958eeb188ad9
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/entity/PreEntityPortalEvent.java
+@@ -0,0 +1,78 @@
++package me.earthme.luminol.api.entity;
++
++import org.apache.commons.lang3.Validate;
++import org.bukkit.Location;
++import org.bukkit.World;
++import org.bukkit.entity.Entity;
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A simple event created for missing teleport events api of folia
++ * This event will be fired when a portal teleportation is about to happen
++ */
++public class PreEntityPortalEvent extends Event implements Cancellable {
++    private static final HandlerList HANDLERS = new HandlerList();
++
++    private final Entity entity;
++    private final Location portalPos;
++    private final World destination;
++
++    private boolean cancelled = false;
++
++    public PreEntityPortalEvent(Entity entity, Location portalPos, World destination) {
++        Validate.notNull(entity, "entity cannot be null!");
++        Validate.notNull(portalPos, "portalPos cannot be null!");
++        Validate.notNull(destination, "destination cannot be null!");
++
++        this.entity = entity;
++        this.portalPos = portalPos;
++        this.destination = destination;
++    }
++
++    /**
++     * Get the entity that is about to teleport
++     * @return the entity
++     */
++    public @NotNull Entity getEntity() {
++        return this.entity;
++    }
++
++    /**
++     * Get the location of the portal
++     * @return the portal location
++     */
++    public @NotNull Location getPortalPos() {
++        return this.portalPos;
++    }
++
++    /**
++     * Get the destination world
++     * @return the destination world
++     */
++    public @NotNull World getDestination() {
++        return this.destination;
++    }
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLERS;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLERS;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/entity/player/PostPlayerRespawnEvent.java b/src/main/java/me/earthme/luminol/api/entity/player/PostPlayerRespawnEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..9a561455560dfeee1d8762297ebf15a7c11de4d1
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/entity/player/PostPlayerRespawnEvent.java
+@@ -0,0 +1,40 @@
++package me.earthme.luminol.api.entity.player;
++
++import org.apache.commons.lang3.Validate;
++import org.bukkit.entity.Player;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A simple event fired when the respawn process of player is done
++ */
++public class PostPlayerRespawnEvent extends Event {
++    private static final HandlerList HANDLERS = new HandlerList();
++
++    private final Player player;
++
++    public PostPlayerRespawnEvent(Player player) {
++        Validate.notNull(player, "Player cannot be a null value!");
++
++        this.player = player;
++    }
++
++    /**
++     * Get the respawned player
++     * @return the player
++     */
++    public @NotNull Player getPlayer() {
++        return this.player;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLERS;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLERS;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/portal/EndPlatformCreateEvent.java b/src/main/java/me/earthme/luminol/api/portal/EndPlatformCreateEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..cf87a7cce5d1ebec9709b762595609344807150b
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/portal/EndPlatformCreateEvent.java
+@@ -0,0 +1,35 @@
++package me.earthme.luminol.api.portal;
++
++import org.bukkit.event.Cancellable;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A event fired when an end platform is created.
++ */
++public class EndPlatformCreateEvent extends Event implements Cancellable {
++    private static final HandlerList HANDLERS = new HandlerList();
++
++    private boolean cancelled = false;
++
++    @Override
++    public boolean isCancelled() {
++        return this.cancelled;
++    }
++
++    @Override
++    public void setCancelled(boolean cancel) {
++        this.cancelled = cancel;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLERS;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLERS;
++    }
++}
+diff --git a/src/main/java/me/earthme/luminol/api/portal/PortalLocateEvent.java b/src/main/java/me/earthme/luminol/api/portal/PortalLocateEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..e09ffb99aad6f6acca3d6a411877715b90413eb0
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/api/portal/PortalLocateEvent.java
+@@ -0,0 +1,53 @@
++package me.earthme.luminol.api.portal;
++
++import org.apache.commons.lang3.Validate;
++import org.bukkit.Location;
++import org.bukkit.event.Event;
++import org.bukkit.event.HandlerList;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A event fired when the portal process started locating the destination position
++ * Notice: If you changed the destination to an another position in end teleportation.The end platform won't create under the entity and won't create
++ * if the position is out of current tick region
++ */
++public class PortalLocateEvent extends Event {
++    private static final HandlerList HANDLERS = new HandlerList();
++
++    private final Location original;
++    private final Location destination;
++
++    public PortalLocateEvent(Location original, Location destination) {
++        Validate.notNull(original, "original couldn't be null!");
++        Validate.notNull(destination, "destination couldn't be null!");
++
++        this.original = original;
++        this.destination = destination;
++    }
++
++    /**
++     * Get the destination position of this teleportation
++     * @return the destination position
++     */
++    public Location getDestination() {
++        return this.destination;
++    }
++
++    /**
++     * Get the original portal position of this teleportation
++     * @return the original portal position
++     */
++    public Location getOriginal() {
++        return this.original;
++    }
++
++    @Override
++    public @NotNull HandlerList getHandlers() {
++        return HANDLERS;
++    }
++
++    @NotNull
++    public static HandlerList getHandlerList() {
++        return HANDLERS;
++    }
++}

luminol-server/build.gradle.kts.patch

@@ -67,8 +67,8 @@
      implementation("ca.spottedleaf:concurrentutil:0.0.3")
      implementation("org.jline:jline-terminal-ffm:3.27.1") // use ffm on java 22+
      implementation("org.jline:jline-terminal-jni:3.27.1") // fall back to jni on java 21
-@@ -200,6 +_,13 @@
+@@ -201,26 +_,33 @@
-     implementation("me.lucko:spark-paper:1.10.119-SNAPSHOT")
+     implementation("me.lucko:spark-paper:1.10.119-20241121.092015-1")
  }
  
 +// Pufferfish Start
@@ -81,7 +81,13 @@
  tasks.jar {
      manifest {
          val git = Git(rootProject.layout.projectDirectory.path)
-@@ -212,14 +_,14 @@
+         val mcVersion = rootProject.providers.gradleProperty("mcVersion").get()
+         val build = System.getenv("BUILD_NUMBER") ?: null
+-        val buildTime = if (build != null) Instant.now() else Instant.EPOCH
++        val buildTime = Instant.now() // Always use current as build time
+         val gitHash = git.exec(providers, "rev-parse", "--short=7", "HEAD").get().trim()
+         val implementationVersion = "$mcVersion-${build ?: "DEV"}-$gitHash"
+         val date = git.exec(providers, "show", "-s", "--format=%ci", gitHash).get().trim()
          val gitBranch = git.exec(providers, "rev-parse", "--abbrev-ref", "HEAD").get().trim()
          attributes(
              "Main-Class" to "org.bukkit.craftbukkit.Main",
@@ -101,10 +107,11 @@
              "Build-Number" to (build ?: ""),
              "Build-Time" to buildTime.toString(),
              "Git-Branch" to gitBranch,
-@@ -350,3 +_,9 @@
+@@ -351,3 +_,10 @@
      classpath(tasks.createReobfPaperclipJar.flatMap { it.outputZip })
      mainClass.set(null as String?)
  }
++
 +// Pufferfish Start
 +tasks.withType<JavaCompile> {
 +    val compilerArgs = options.compilerArgs

luminol-server/minecraft-patches/features/0001-Luminol-config-base.patch

@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MrHua269 <wangxyper@163.com>
+From: MrHua269 <mrhua269@gmail.com>
-Date: Sun, 12 Jan 2025 10:15:52 +0800
+Date: Sat, 22 Mar 2025 17:36:17 +0800
-Subject: [PATCH] Add luminol config framework
+Subject: [PATCH] Luminol config base
 
 
 diff --git a/net/minecraft/server/Main.java b/net/minecraft/server/Main.java
@@ -17,7 +17,7 @@ index 9aa664537cc37e44db46d5a2a64ae3116938c681..8d6a6534a134e99e5ee2652d7b0c858d
              Bootstrap.bootStrap();
              Bootstrap.validate();
 diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
-index 341e400f789e0eda29827e2c45c483a470d2e982..8f348d140ab98e23ee0debe4bacac51fee49c35e 100644
+index e3b7184e20bda4983ee1fc5463d91ca0cdd8ec1f..375f4a59333ee1d75fb1acb8c2cbada7866bd48e 100644
 --- a/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/net/minecraft/server/dedicated/DedicatedServer.java
 @@ -212,6 +212,8 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface

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

@@ -5,10 +5,10 @@ Subject: [PATCH] Add config for server mod name
 
 
 diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index faf72dd6dff74296c73cb058aaabd1f9f475a072..46375fa81b36b89b79c22f0a7ac6d610ab1183d4 100644
+index be82a6b43b1f0c644c53d08a6e16bc2876c8c1e0..9261d83f28af5e057d060741ab900f8cde8f992b 100644
 --- a/net/minecraft/server/MinecraftServer.java
 +++ b/net/minecraft/server/MinecraftServer.java
-@@ -1967,7 +1967,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1968,7 +1968,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
  
      @DontObfuscate
      public String getServerModName() {

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

@@ -27,7 +27,7 @@ index 1fa5e6a12b943e889bde566038a632a6adcf319e..c1f6a3b3a8fa990b8e9b052341ab31bd
      }
  }
 diff --git a/net/minecraft/world/level/block/EndPortalBlock.java b/net/minecraft/world/level/block/EndPortalBlock.java
-index 177735cf744e564081e4c140a0f8210c3a07e037..7274f2d7df9228f34305a21abde6d114a495c1cb 100644
+index 554d75ac1374d7d93977a10e06fcf51259830c97..17c1ce4397c5953bb92aaa3b56c179b7c24a0736 100644
 --- a/net/minecraft/world/level/block/EndPortalBlock.java
 +++ b/net/minecraft/world/level/block/EndPortalBlock.java
 @@ -67,6 +67,11 @@ public class EndPortalBlock extends BaseEntityBlock implements Portal {

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

@@ -5,7 +5,7 @@ Subject: [PATCH] Add config for vanilla random
 
 
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index 597520a680bc1a54055b99f93724682a4d940458..4cfc228a60a147409b8afc4cb138ce6437a9b667 100644
+index 2cd2ce1060f567be6c72b7bc9d02651ec7166203..f69fd922fa67cd366dbb93c34fa15659ba76c844 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
 @@ -255,7 +255,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess

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

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

luminol-server/minecraft-patches/features/0005-Add-tpsbar-with-chunkhot-membar-and-regionbar.patch

@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: MrHua269 <wangxyper@163.com>
-Date: Sun, 12 Jan 2025 11:29:49 +0800
+Date: Sun, 12 Jan 2025 10:27:31 +0800
-Subject: [PATCH] KioCG Chunk API and display of chunkhot in tpsbar
+Subject: [PATCH] Add tpsbar with chunkhot membar and regionbar
 
 
 diff --git a/ca/spottedleaf/moonrise/paper/util/BaseChunkSystemHooks.java b/ca/spottedleaf/moonrise/paper/util/BaseChunkSystemHooks.java
@@ -17,7 +17,7 @@ index 8d67b4629c69d3039b199aaad45533d1acde114e..f7bfeca4b11b9860241d5eb80b6df420
          ((ca.spottedleaf.moonrise.patches.chunk_tick_iteration.ChunkTickServerLevel)(ServerLevel)chunk.getLevel()).moonrise$removeChunkForPlayerTicking(chunk); // Moonrise - chunk tick iteration
      }
 diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index ff71466ec0848d16121e351e30c31bb419af8b99..330af9f4de1c72387326816065350e71fe546efe 100644
+index 9261d83f28af5e057d060741ab900f8cde8f992b..fc088edaa36e7e68ddd23c57e351ef3b31ed5ad8 100644
 --- a/net/minecraft/server/MinecraftServer.java
 +++ b/net/minecraft/server/MinecraftServer.java
 @@ -1666,7 +1666,44 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
@@ -65,11 +65,25 @@ index ff71466ec0848d16121e351e30c31bb419af8b99..330af9f4de1c72387326816065350e71
          if (false && nanos - this.lastServerStatus >= STATUS_EXPIRE_TIME_NANOS) { // Folia - region threading
              this.lastServerStatus = nanos;
              this.status = this.buildServerStatus();
+diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
+index 375f4a59333ee1d75fb1acb8c2cbada7866bd48e..3abe2881e8a80bd6c128e96b976deebe3ada4678 100644
+--- a/net/minecraft/server/dedicated/DedicatedServer.java
++++ b/net/minecraft/server/dedicated/DedicatedServer.java
+@@ -766,6 +766,9 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
+ 
+     @Override
+     public void stopServer() {
++        me.earthme.luminol.functions.GlobalServerTpsBar.cancelBarUpdateTask(); //Luminol - Tpsbar
++        me.earthme.luminol.functions.GlobalServerMemoryBar.cancelBarUpdateTask(); //Luminol - Memory bar
++        me.earthme.luminol.functions.GlobalServerRegionBar.cancelBarUpdateTask(); //Luminol - Region bar
+         super.stopServer();
+         //Util.shutdownExecutors(); // Paper - Improved watchdog support; moved into super
+         SkullBlockEntity.clear();
 diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
-index ad121d609bcc1d9b53a1a20d4e25cf9dfa480fb8..887a12b0b33a24f77e3dc118688f9e5b14d6f62f 100644
+index f2d2ddfd964bff914e41c0b4150fe1aad7866ebf..7defcd15c44601bfd2f7f55046038693264defee 100644
 --- a/net/minecraft/server/level/ServerLevel.java
 +++ b/net/minecraft/server/level/ServerLevel.java
-@@ -1347,6 +1347,8 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -1339,6 +1339,8 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
          final int timerId = isActive ? entity.getType().tickTimerId : entity.getType().inactiveTickTimerId;
          final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler();
          profiler.startTimer(timerId);
@@ -78,7 +92,7 @@ index ad121d609bcc1d9b53a1a20d4e25cf9dfa480fb8..887a12b0b33a24f77e3dc118688f9e5b
          try {
          // Folia end - profiler
          if (isActive) { // Paper - EAR 2
-@@ -1364,6 +1366,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -1356,6 +1358,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
          } else {entity.inactiveTick();} // Paper - EAR 2
          profilerFiller.pop();
          } finally { profiler.stopTimer(timerId); } // Folia - profiler
@@ -86,7 +100,7 @@ index ad121d609bcc1d9b53a1a20d4e25cf9dfa480fb8..887a12b0b33a24f77e3dc118688f9e5b
  
          for (Entity entity1 : entity.getPassengers()) {
              this.tickPassenger(entity, entity1, isActive); // Paper - EAR 2
-@@ -1383,6 +1386,8 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -1375,6 +1378,8 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
              final int timerId = isActive ? passengerEntity.getType().tickTimerId : passengerEntity.getType().inactiveTickTimerId;
              final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler();
              profiler.startTimer(timerId);
@@ -95,7 +109,7 @@ index ad121d609bcc1d9b53a1a20d4e25cf9dfa480fb8..887a12b0b33a24f77e3dc118688f9e5b
              try {
              // Folia end - profiler
              passengerEntity.setOldPosAndRot();
-@@ -1416,6 +1421,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+@@ -1409,6 +1414,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
                  this.tickPassenger(passengerEntity, entity, isActive); // Paper - EAR 2
              }
              } finally { profiler.stopTimer(timerId); } // Folia - profiler
@@ -104,10 +118,21 @@ index ad121d609bcc1d9b53a1a20d4e25cf9dfa480fb8..887a12b0b33a24f77e3dc118688f9e5b
      }
  
 diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
-index 57f30de55968046a9ac053fe5052bf4070f87e44..f24c9a593a6b7e664a91ec1a132dd74fbbd20bc6 100644
+index dbf9231b1f01576906b90a3ddf0bf2cbbeb4590a..b17ace9118c94a756fa2901621c6b2b9bd9e5764 100644
 --- a/net/minecraft/server/level/ServerPlayer.java
 +++ b/net/minecraft/server/level/ServerPlayer.java
-@@ -1012,7 +1012,34 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+@@ -400,7 +400,9 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+     public com.destroystokyo.paper.event.entity.PlayerNaturallySpawnCreaturesEvent playerNaturallySpawnedEvent; // Paper - PlayerNaturallySpawnCreaturesEvent
+     public @Nullable String clientBrandName = null; // Paper - Brand support
+     public org.bukkit.event.player.PlayerQuitEvent.QuitReason quitReason = null; // Paper - Add API for quit reason; there are a lot of changes to do if we change all methods leading to the event
+-
++    public volatile boolean isTpsBarVisible = false; //Luminol - Tps bar
++    public volatile boolean isMemBarVisible = false; //Luminol - Memory bar
++    public volatile boolean isRegionBarVisible = false; //Luminol - Region bar
+     // Paper start - rewrite chunk system
+     private ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.PlayerChunkLoaderData chunkLoader;
+     private final ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.ViewDistanceHolder viewDistanceHolder = new ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader.ViewDistanceHolder();
+@@ -1013,8 +1015,35 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
          this.trackEnteredOrExitedLavaOnVehicle();
          this.updatePlayerAttributes();
          this.advancements.flushDirty(this);
@@ -117,8 +142,8 @@ index 57f30de55968046a9ac053fe5052bf4070f87e44..f24c9a593a6b7e664a91ec1a132dd74f
 +            this.nearbyChunkHot = this.refreshNearbyChunkHot();
 +        }
 +        // KioCG end
-+    }
+     }
-+
+ 
 +    // KioCG start - ChunkHot
 +    private volatile long nearbyChunkHot = 0;
 +
@@ -136,12 +161,13 @@ index 57f30de55968046a9ac053fe5052bf4070f87e44..f24c9a593a6b7e664a91ec1a132dd74f
 +            }
 +        }
 +        return total;
-     }
++    }
 +    // KioCG end
 +
- 
++
      private void updatePlayerAttributes() {
          AttributeInstance attribute = this.getAttribute(Attributes.BLOCK_INTERACTION_RANGE);
+         if (attribute != null) {
 diff --git a/net/minecraft/world/entity/AreaEffectCloud.java b/net/minecraft/world/entity/AreaEffectCloud.java
 index 23b342cc31c7e72ade0e1ccad86a9ccf34380f13..249cb7326c8e4012dcffdb6bbb7bfc1f1eeb7b33 100644
 --- a/net/minecraft/world/entity/AreaEffectCloud.java
@@ -159,10 +185,10 @@ index 23b342cc31c7e72ade0e1ccad86a9ccf34380f13..249cb7326c8e4012dcffdb6bbb7bfc1f
 +    // KioCG end
  }
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index 88ca22ed6af613370ca8691ad9ebeb113e1637fe..41313532c739027351d6fd848aa1c515aa4acd4a 100644
+index f69fd922fa67cd366dbb93c34fa15659ba76c844..cc8efa162fbe7ce6a91629239bf18d7b6b096a8a 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
-@@ -5940,4 +5940,6 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -5919,4 +5919,6 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
          return ((ServerLevel) this.level).isPositionEntityTicking(this.blockPosition());
      }
      // Paper end - Expose entity id counter
@@ -186,10 +212,10 @@ index f003a65b34027dff14455860815c7d719c5289fa..6f9f8e52d2311343a0c0c3900a466c6a
 +    // KioCG end
  }
 diff --git a/net/minecraft/world/entity/Mob.java b/net/minecraft/world/entity/Mob.java
-index 6394b0899095b047ca9266135fc44aa0c32467cf..af7dbb0f2df0ec42c2c16bc58ba16b6c65d3ebcb 100644
+index da922d4c0ffa0f40d5e8dd69487bf30dbbbeed87..94a7b95f41c2954561f9c3cb0f61210c0c058f1d 100644
 --- a/net/minecraft/world/entity/Mob.java
 +++ b/net/minecraft/world/entity/Mob.java
-@@ -1720,4 +1720,11 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
+@@ -1722,4 +1722,11 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab
      public float[] getArmorDropChances() {
          return this.armorDropChances;
      }
@@ -234,10 +260,10 @@ index 6655d06e2011e20e7346dfe57527795269094d8a..48aa6fcb5c16fdbb4ae902cbb72c6b8e
 +    // KioCG end
  }
 diff --git a/net/minecraft/world/entity/player/Player.java b/net/minecraft/world/entity/player/Player.java
-index eaa77200d6bc33faeefdc2d07b73ee7ddcd3afe8..5ff6973a033033ce1562762bb6f57268e1193900 100644
+index e70919757dee4b02384ded3551c8f580d289584a..ae049c5c3593525b991d865fec695c00ad408a59 100644
 --- a/net/minecraft/world/entity/player/Player.java
 +++ b/net/minecraft/world/entity/player/Player.java
-@@ -1544,6 +1544,13 @@ public abstract class Player extends LivingEntity {
+@@ -1546,6 +1546,13 @@ public abstract class Player extends LivingEntity {
          return true;
      }
  

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

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

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

@@ -19,7 +19,7 @@ index 159f2f169d26b436a70006f7bc9bdc481315dd32..2b366fea4d8d376b150786fdc00fd5e2
              && !this.iKnowThisMayNotBeTheBestIdeaButPleaseDisableUsernameValidation) {
              Validate.validState(StringUtil.isReasonablePlayerName(packet.name()), "Invalid characters in username");
 diff --git a/net/minecraft/server/players/GameProfileCache.java b/net/minecraft/server/players/GameProfileCache.java
-index 6fb3712f33a84a3612752dcfd9e97d67066f610e..26d37cf8fec2e8b0d3c3c1bbe4693d4c6ca4d4f9 100644
+index 6fb3712f33a84a3612752dcfd9e97d67066f610e..1999188b5667035362ba579a80b30336c5c7fc38 100644
 --- a/net/minecraft/server/players/GameProfileCache.java
 +++ b/net/minecraft/server/players/GameProfileCache.java
 @@ -77,7 +77,7 @@ public class GameProfileCache {
@@ -27,7 +27,27 @@ index 6fb3712f33a84a3612752dcfd9e97d67066f610e..26d37cf8fec2e8b0d3c3c1bbe4693d4c
  
      private static Optional<GameProfile> lookupGameProfile(GameProfileRepository profileRepo, String name) {
 -        if (!StringUtil.isValidPlayerName(name)) {
-+        if (!StringUtil.isValidPlayerName(name) && false) { // Luminol - Add config for username check - Directly return, skip unnecessary following logic
++        if (!StringUtil.isValidPlayerName(name, false)) { // Luminol - Add config for username check - Directly return, skip unnecessary following logic
              return createUnknownProfile(name);
          } else {
              final AtomicReference<GameProfile> atomicReference = new AtomicReference<>();
+diff --git a/net/minecraft/util/StringUtil.java b/net/minecraft/util/StringUtil.java
+index 77947e6915facee44588943fcd3e5b513de37e77..d9f95c5cf4bd2946244c153db0fd21c8d51ae20d 100644
+--- a/net/minecraft/util/StringUtil.java
++++ b/net/minecraft/util/StringUtil.java
+@@ -62,8 +62,14 @@ public class StringUtil {
+     public static boolean isAllowedChatCharacter(char character) {
+         return character != 167 && character >= ' ' && character != 127;
+     }
++    // Luminol start - Add config for username checks
++    public static boolean isValidPlayerName(String username){
++        return isValidPlayerName(username, !me.earthme.luminol.config.modules.misc.UsernameCheckConfig.enabled);
++    }
++    // Luminol end
+ 
+-    public static boolean isValidPlayerName(String playerName) {
++    public static boolean isValidPlayerName(String playerName, boolean byPass) { // Luminol - Add config for username checks
++        if (byPass) return playerName.length() <= 16; // Luminol - Add config for username checks
+         return playerName.length() <= 16 && playerName.chars().filter(i -> i <= 32 || i >= 127).findAny().isEmpty();
+     }
+ 

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

@@ -5,7 +5,7 @@ Subject: [PATCH] Add config for offline mode warning
 
 
 diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
-index cc80198a5d5f4e9188ef35944d077200f03ac43b..82f80e152a8b7426d711df7df6eae9043cf35e69 100644
+index 3abe2881e8a80bd6c128e96b976deebe3ada4678..a0a8b0c7d091f63f023f15a2620b03ae2126782e 100644
 --- a/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/net/minecraft/server/dedicated/DedicatedServer.java
 @@ -285,7 +285,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface

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

@@ -17,16 +17,3 @@ index 41a9cc693183e96c83837692e93b177a521d6789..f4a2d1a2d467808b9cb75fc32765ddc2
              throw new ProfilePublicKey.ValidationException(INVALID_SIGNATURE, org.bukkit.event.player.PlayerKickEvent.Cause.INVALID_PUBLIC_KEY_SIGNATURE); // Paper - kick event causes
          } else {
              return new ProfilePublicKey(data);
-diff --git a/net/minecraft/world/level/block/TripWireHookBlock.java b/net/minecraft/world/level/block/TripWireHookBlock.java
-index 6a7e5a642e2eaf7d5dffadb81738f7385a38c0af..f16500a50904aade3d984b908b11b8edd9c05ba1 100644
---- a/net/minecraft/world/level/block/TripWireHookBlock.java
-+++ b/net/minecraft/world/level/block/TripWireHookBlock.java
-@@ -215,7 +215,7 @@ public class TripWireHookBlock extends Block {
-                     BlockState blockState2 = blockStates[i2];
-                     if (blockState2 != null) {
-                         BlockState blockState3 = level.getBlockState(blockPos1);
--                        if (blockState3.is(Blocks.TRIPWIRE) || blockState3.is(Blocks.TRIPWIRE_HOOK)) {
-+                        if (me.earthme.luminol.config.modules.misc.TripwireConfig.enabled || blockState3.is(Blocks.TRIPWIRE) || blockState3.is(Blocks.TRIPWIRE_HOOK)) { // Luminol - Add config for tripwire dupe
-                             level.setBlock(blockPos1, blockState2.trySetValue(ATTACHED, Boolean.valueOf(flag2)), 3);
-                         }
-                     }

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

@@ -5,7 +5,7 @@ Subject: [PATCH] Add config to disable entity tick catchers
 
 
 diff --git a/net/minecraft/world/level/Level.java b/net/minecraft/world/level/Level.java
-index 5ea7fdf1e337da4c207dd6a53ca942480dd31922..926f5c91eb59277704618fe1910f3dbb38cff002 100644
+index 78f4dd7032d18b8e020a4576e4ac012c1d472e67..120e25ca0544980d1bfc1498e1386f965dae7044 100644
 --- a/net/minecraft/world/level/Level.java
 +++ b/net/minecraft/world/level/Level.java
 @@ -1547,6 +1547,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl

luminol-server/minecraft-patches/features/0012-Add-config-for-tripwire-dupe.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: HaHaWTH <102713261+HaHaWTH@users.noreply.github.com>
+Date: Mon, 24 Feb 2025 06:00:00 -0800
+Subject: [PATCH] Add config for tripwire dupe
+
+
+diff --git a/net/minecraft/world/level/block/TripWireHookBlock.java b/net/minecraft/world/level/block/TripWireHookBlock.java
+index 9aace993c6c18f1a50610e4766225485984b8167..07ffe289b9556b45a9ef7db5357d85b14fe23feb 100644
+--- a/net/minecraft/world/level/block/TripWireHookBlock.java
++++ b/net/minecraft/world/level/block/TripWireHookBlock.java
+@@ -215,7 +215,7 @@ public class TripWireHookBlock extends Block {
+                     BlockState blockState2 = blockStates[i2];
+                     if (blockState2 != null) {
+                         BlockState blockState3 = level.getBlockState(blockPos1);
+-                        if (blockState3.is(Blocks.TRIPWIRE) || blockState3.is(Blocks.TRIPWIRE_HOOK)) {
++                        if (me.earthme.luminol.config.modules.misc.AllowTripwireDupe.enabled || blockState3.is(Blocks.TRIPWIRE) || blockState3.is(Blocks.TRIPWIRE_HOOK)) {
+                             if (!io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates || !blockState3.is(Blocks.TRIPWIRE)) level.setBlock(blockPos1, blockState2.trySetValue(ATTACHED, Boolean.valueOf(flag2)), 3); // Paper - prevent tripwire from updating
+                         }
+                     }

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

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

luminol-server/minecraft-patches/features/0014-Add-experiment-config-for-entity-to-clean-memory-val.patch

@@ -0,0 +1,53 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Sat, 8 Mar 2025 09:56:15 +0800
+Subject: [PATCH] Add experiment config for entity to clean memory value which
+ is not belong to current tickregion
+
+
+diff --git a/net/minecraft/world/entity/ai/Brain.java b/net/minecraft/world/entity/ai/Brain.java
+index 65b2b3ece213d901cdd585093e2fafcd2ef4a7cd..d61fba01feecce3610cd390f490d3097c5db19c4 100644
+--- a/net/minecraft/world/entity/ai/Brain.java
++++ b/net/minecraft/world/entity/ai/Brain.java
+@@ -399,7 +399,7 @@ public class Brain<E extends LivingEntity> {
+     }
+ 
+     public void tick(ServerLevel level, E entity) {
+-        this.forgetOutdatedMemories();
++        this.forgetOutdatedMemories(entity); // Luminol - Add config to force clean entity memory that don't belong to current tick region
+         this.tickSensors(level, entity);
+         this.startEachNonRunningBehavior(level, entity);
+         this.tickEachRunningBehavior(level, entity);
+@@ -411,10 +411,31 @@ public class Brain<E extends LivingEntity> {
+         }
+     }
+ 
+-    private void forgetOutdatedMemories() {
++    private void forgetOutdatedMemories(E owner) { // Luminol - Add config to force clean entity memory that don't belong to current tick region
+         for (Entry<MemoryModuleType<?>, Optional<? extends ExpirableValue<?>>> entry : this.memories.entrySet()) {
+             if (entry.getValue().isPresent()) {
+                 ExpirableValue<?> expirableValue = (ExpirableValue<?>)entry.getValue().get();
++                // Luminol start - Add config to force clean entity memory that don't belong to current tick region
++                final Object value = expirableValue.getValue();
++                final net.minecraft.world.level.Level ownerLevel = owner.level();
++
++                // type: entity
++                if (me.earthme.luminol.config.modules.experiment.ForceCleanupEntityBrainMemoryConfig.enabledForEntity && value instanceof LivingEntity entity) {
++                    if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(entity)) {
++                        this.eraseMemory(entry.getKey());
++                        continue;
++                    }
++                }
++
++                // type: block_pos
++                if (me.earthme.luminol.config.modules.experiment.ForceCleanupEntityBrainMemoryConfig.enabledForBlockPos && value instanceof net.minecraft.core.BlockPos blockPos) {
++                    if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(ownerLevel, blockPos)) {
++                        this.eraseMemory(entry.getKey());
++                        continue;
++                    }
++                }
++                // Luminol end
++
+                 if (expirableValue.hasExpired()) {
+                     this.eraseMemory(entry.getKey());
+                 }

luminol-server/minecraft-patches/features/0015-Add-experiment-config-for-force-enabling-data-comman.patch

@@ -0,0 +1,21 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Kercute <A3167717663@hotmail.com>
+Date: Sun, 16 Mar 2025 23:31:41 +0800
+Subject: [PATCH] Add experiment config for force enabling data command
+
+
+diff --git a/net/minecraft/commands/Commands.java b/net/minecraft/commands/Commands.java
+index 009e6405a11a391adca41a7c4ecafbf3254d799d..cfb37f2e428605965a37dc1eb83f302fe1bd6299 100644
+--- a/net/minecraft/commands/Commands.java
++++ b/net/minecraft/commands/Commands.java
+@@ -162,7 +162,9 @@ public class Commands {
+         ClearInventoryCommands.register(this.dispatcher, context);
+         //CloneCommands.register(this.dispatcher, context); // Folia - region threading - TODO
+         DamageCommand.register(this.dispatcher, context);
+-        //DataCommands.register(this.dispatcher); // Folia - region threading - TODO
++        if(me.earthme.luminol.config.modules.experiment.CommandDataConfig.enabled) {
++            DataCommands.register(this.dispatcher); // Folia - region threading - TODO
++        }
+         //DataPackCommand.register(this.dispatcher); // Folia - region threading - TODO
+         //DebugCommand.register(this.dispatcher); // Folia - region threading - TODO
+         DefaultGameModeCommands.register(this.dispatcher);

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

@@ -55,7 +55,7 @@ index 51c126735ace8fdde89ad97b5cab62f244212db0..c7d4d944eb198ac53a3eeae717a25c7d
 +    public void moonrise$write(final abomination.IRegionFile regionFile) throws IOException; // Luminol - Configurable region file format
  }
 diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index 46375fa81b36b89b79c22f0a7ac6d610ab1183d4..c00378ba258647787bb9138e319b0f6a0b00e1ed 100644
+index fc088edaa36e7e68ddd23c57e351ef3b31ed5ad8..5d709b3b47702e7607dafa4a38380c801b228e2d 100644
 --- a/net/minecraft/server/MinecraftServer.java
 +++ b/net/minecraft/server/MinecraftServer.java
 @@ -986,10 +986,10 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa

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

@@ -1,36 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MrHua269 <wangxyper@163.com>
-Date: Sun, 12 Jan 2025 10:53:24 +0800
-Subject: [PATCH] Try fixing folia spector teleportation
-
-
-diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
-index b4a4eec6029f1aee5f3b0da6938a9b23db36d5f9..57f30de55968046a9ac053fe5052bf4070f87e44 100644
---- a/net/minecraft/server/level/ServerPlayer.java
-+++ b/net/minecraft/server/level/ServerPlayer.java
-@@ -975,8 +975,24 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
-         }
- 
-         Entity camera = this.getCamera();
-+        //Luminol start - Fix folia spector teleportation
-+        if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(camera) && me.earthme.luminol.config.modules.fixes.FoliaSpectorTeleportationFixConfig.fixSpectorTeleportFolia){
-+            this.setCamera(this);
-+        }
-+        //Luminol end
-+
-         if (camera != this) {
--            if (camera.isAlive()) {
-+            // Luminol start - Fix folia spector teleportation
-+            var flag = false;
-+            var cameraPos = camera.blockPosition();
-+            var cameraLevel = camera.level();
-+            if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(cameraLevel, cameraPos) && me.earthme.luminol.config.modules.fixes.FoliaSpectorTeleportationFixConfig.fixSpectorTeleportFolia){
-+                this.setCamera(this);
-+                flag = true;
-+            }
-+            // Luminol end
-+
-+            if (camera.isAlive() && !flag) { // Luminol - Fix folia spector teleportation
-                 this.absMoveTo(camera.getX(), camera.getY(), camera.getZ(), camera.getYRot(), camera.getXRot());
-                 this.serverLevel().getChunkSource().move(this);
-                 if (this.wantsToStopRiding()) {

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

@@ -5,10 +5,10 @@ Subject: [PATCH] Teleport async if entity was moving to another region at once
 
 
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index 4cfc228a60a147409b8afc4cb138ce6437a9b667..c87db2d497ca9ed2e8aad5f1bc52555ff0952b80 100644
+index cc8efa162fbe7ce6a91629239bf18d7b6b096a8a..4026d465687604965f105ded21a8206fd52bd375 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
-@@ -1099,6 +1099,10 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -1100,6 +1100,10 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
      }
      // Paper end - detailed watchdog information
  
@@ -19,7 +19,7 @@ index 4cfc228a60a147409b8afc4cb138ce6437a9b667..c87db2d497ca9ed2e8aad5f1bc52555f
      public void move(MoverType type, Vec3 movement) {
          final Vec3 originalMovement = movement; // Paper - Expose pre-collision velocity
          // Paper start - detailed watchdog information
-@@ -1109,6 +1113,32 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -1110,6 +1114,32 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
              this.moveStartZ = this.getZ();
              this.moveVector = movement;
          }

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

@@ -1,11 +1,11 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MrHua269 <wangxyper@163.com>
+From: MrHua269 <mrhua269@gmail.com>
-Date: Sun, 12 Jan 2025 11:00:49 +0800
+Date: Sat, 22 Mar 2025 17:36:44 +0800
 Subject: [PATCH] Force disable builtin spark plugin
 
 
 diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index c00378ba258647787bb9138e319b0f6a0b00e1ed..ff71466ec0848d16121e351e30c31bb419af8b99 100644
+index 5d709b3b47702e7607dafa4a38380c801b228e2d..c2027b8d4a5f9fccacb93ba108e34c36285aec7b 100644
 --- a/net/minecraft/server/MinecraftServer.java
 +++ b/net/minecraft/server/MinecraftServer.java
 @@ -783,8 +783,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
@@ -65,7 +65,7 @@ index c00378ba258647787bb9138e319b0f6a0b00e1ed..ff71466ec0848d16121e351e30c31bb4
          new com.destroystokyo.paper.event.server.ServerTickStartEvent((int)region.getCurrentTick()).callEvent(); // Paper - Server Tick Events // Folia - region threading
          // Folia start - region threading
          if (region != null) {
-@@ -1706,7 +1707,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1744,7 +1745,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
          long remaining = scheduledEnd - endTime; // Folia - region ticking
          new com.destroystokyo.paper.event.server.ServerTickEndEvent((int)io.papermc.paper.threadedregions.RegionizedServer.getCurrentTick(), ((double)(endTime - startTime) / 1000000D), remaining).callEvent(); // Folia - region ticking
          // Paper end - Server Tick Events
@@ -75,7 +75,7 @@ index c00378ba258647787bb9138e319b0f6a0b00e1ed..ff71466ec0848d16121e351e30c31bb4
      }
  
 diff --git a/net/minecraft/server/dedicated/DedicatedServer.java b/net/minecraft/server/dedicated/DedicatedServer.java
-index 82f80e152a8b7426d711df7df6eae9043cf35e69..298d9eb8e303fb4eaae58dcc5c9f29e23150496f 100644
+index a0a8b0c7d091f63f023f15a2620b03ae2126782e..d7c922540b46e289395aeed514c98e43dc298e7b 100644
 --- a/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/net/minecraft/server/dedicated/DedicatedServer.java
 @@ -214,7 +214,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface

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

@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: MrHua269 <wangxyper@163.com>
 Date: Sun, 12 Jan 2025 11:03:09 +0800
-Subject: [PATCH] Merge Paper #11945 for temporary hooper behavior fix
+Subject: [PATCH] Merge Paper #11945 for temporary hopper behavior fix
 
 A hopper optimization fix on Paper's pr : https://github.com/PaperMC/Paper/pull/11945
 

luminol-server/minecraft-patches/features/0020-Set-old-pos-before-moving-entity-by-piston.patch

@@ -1,18 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MrHua269 <wangxyper@163.com>
-Date: Sun, 12 Jan 2025 11:02:06 +0800
-Subject: [PATCH] Set old pos before moving entity by piston
-
-
-diff --git a/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java b/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java
-index 3df23feff6937b6a2dbeff82e489a9a4ff644843..5d98069b61df57792e6b0cab809f2996b7d45c88 100644
---- a/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java
-+++ b/net/minecraft/world/level/block/piston/PistonMovingBlockEntity.java
-@@ -195,6 +195,7 @@ public class PistonMovingBlockEntity extends BlockEntity {
- 
-     private static void moveEntityByPiston(Direction noClipDirection, Entity entity, double progress, Direction direction) {
-         NOCLIP.set(noClipDirection);
-+        if (me.earthme.luminol.config.modules.fixes.FoliaPistonIssueFixConfig.enabled) entity.setOldPosAndRot(); // Luminol- Try fixing folia issue #311
-         entity.move(MoverType.PISTON, new Vec3(progress * direction.getStepX(), progress * direction.getStepY(), progress * direction.getStepZ()));
-         entity.applyEffectsFromBlocks();
-         NOCLIP.set(null);

luminol-server/minecraft-patches/features/0021-Fix-uncorrected-death-check-of-folia.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Tue, 11 Feb 2025 13:34:47 +0800
+Subject: [PATCH] Fix uncorrected death check of folia
+
+
+diff --git a/net/minecraft/world/inventory/AbstractContainerMenu.java b/net/minecraft/world/inventory/AbstractContainerMenu.java
+index acca8c51d2030c675c157b10d0bbc6af631afe61..d0b688e69979c5e7b8267ac96bd71bcd33444c41 100644
+--- a/net/minecraft/world/inventory/AbstractContainerMenu.java
++++ b/net/minecraft/world/inventory/AbstractContainerMenu.java
+@@ -689,7 +689,7 @@ public abstract class AbstractContainerMenu {
+     }
+ 
+     private static void dropOrPlaceInInventory(Player player, ItemStack stack) {
+-        boolean flag = player.isRemoved() && player.getRemovalReason() != Entity.RemovalReason.CHANGED_DIMENSION;
++        boolean flag = !player.isAlive(); //player.isRemoved() && player.getRemovalReason() != Entity.RemovalReason.CHANGED_DIMENSION; // Luminol - Fix uncorrected death check of folia
+         boolean flag1 = player instanceof ServerPlayer serverPlayer && serverPlayer.hasDisconnected();
+         if (flag || flag1) {
+             player.drop(stack, false);

luminol-server/minecraft-patches/features/0022-Fix-a-series-issue-around-entity-memory-typed-Global.patch

@@ -0,0 +1,104 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Sat, 8 Mar 2025 09:55:40 +0800
+Subject: [PATCH] Fix a series issue around entity memory typed GlobalPos and
+ WalkTarget
+
+
+diff --git a/net/minecraft/world/entity/ai/behavior/BabyFollowAdult.java b/net/minecraft/world/entity/ai/behavior/BabyFollowAdult.java
+index a9be3acbf4ea52d2988347abfa6f4f8c02b1da26..751f3dde8e6bc2c0365e8672f5079af0379a69de 100644
+--- a/net/minecraft/world/entity/ai/behavior/BabyFollowAdult.java
++++ b/net/minecraft/world/entity/ai/behavior/BabyFollowAdult.java
+@@ -25,6 +25,14 @@ public class BabyFollowAdult {
+                         return false;
+                     } else {
+                         LivingEntity ageableMob = instance.get(nearestVisibleAdult); // CraftBukkit - type
++
++                        // Luminol start - Fix off world entity following which caused async issue
++                        if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(ageableMob)) {
++                            nearestVisibleAdult.erase();
++                            return true;
++                        }
++                        // Luminol end
++
+                         if (mob.closerThan(ageableMob, followRange.getMaxValue() + 1) && !mob.closerThan(ageableMob, followRange.getMinValue())) {
+                             // CraftBukkit start
+                             org.bukkit.event.entity.EntityTargetLivingEntityEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityTargetLivingEvent(mob, ageableMob, org.bukkit.event.entity.EntityTargetEvent.TargetReason.FOLLOW_LEADER);
+diff --git a/net/minecraft/world/entity/ai/behavior/BehaviorUtils.java b/net/minecraft/world/entity/ai/behavior/BehaviorUtils.java
+index 2664d72c3b6906d0505df2e63c0e5075eba9461b..f03c3c512ea48c2a89eebae62484922d28e4f831 100644
+--- a/net/minecraft/world/entity/ai/behavior/BehaviorUtils.java
++++ b/net/minecraft/world/entity/ai/behavior/BehaviorUtils.java
+@@ -69,6 +69,11 @@ public class BehaviorUtils {
+     }
+ 
+     public static void setWalkAndLookTargetMemories(LivingEntity entity, PositionTracker positionTracker, float speedModifier, int closeEnoughDist) {
++        // Luminol - Do not set walk target if target position is out of current tick region
++        if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(entity.level(), positionTracker.currentBlockPosition())) {
++            return;
++        }
++        // Luminol end
+         WalkTarget walkTarget = new WalkTarget(positionTracker, speedModifier, closeEnoughDist);
+         entity.getBrain().setMemory(MemoryModuleType.LOOK_TARGET, positionTracker);
+         entity.getBrain().setMemory(MemoryModuleType.WALK_TARGET, walkTarget);
+diff --git a/net/minecraft/world/entity/ai/behavior/SleepInBed.java b/net/minecraft/world/entity/ai/behavior/SleepInBed.java
+index bc6a5cacd67d46e0beb97adf30d98c1034be1a44..dd35eef062c36a409b6d3e701664db504c4c7631 100644
+--- a/net/minecraft/world/entity/ai/behavior/SleepInBed.java
++++ b/net/minecraft/world/entity/ai/behavior/SleepInBed.java
+@@ -42,6 +42,12 @@ public class SleepInBed extends Behavior<LivingEntity> {
+                     }
+                 }
+ 
++                // Luminol - Prevent off-tick-region chunk operations
++                final net.minecraft.world.level.Level currentLevel = owner.level();
++                if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(currentLevel, globalPos.pos())) {
++                    return false;
++                }
++                // Luminol -end
+                 BlockState blockState = level.getBlockStateIfLoaded(globalPos.pos()); // Paper - Prevent sync chunk loads when villagers try to find beds
+                 if (blockState == null) { return false; } // Paper - Prevent sync chunk loads when villagers try to find beds
+                 return globalPos.pos().closerToCenterThan(owner.position(), 2.0) && blockState.is(BlockTags.BEDS) && !blockState.getValue(BedBlock.OCCUPIED);
+diff --git a/net/minecraft/world/entity/animal/allay/AllayAi.java b/net/minecraft/world/entity/animal/allay/AllayAi.java
+index 36a9887f8be04c5c3fda6d926d819a9e5b2a79f2..5681592bdeb050d875c4c5d0dfaf6e015beb1c74 100644
+--- a/net/minecraft/world/entity/animal/allay/AllayAi.java
++++ b/net/minecraft/world/entity/animal/allay/AllayAi.java
+@@ -114,6 +114,17 @@ public class AllayAi {
+         Optional<GlobalPos> memory = brain.getMemory(MemoryModuleType.LIKED_NOTEBLOCK_POSITION);
+         if (memory.isPresent()) {
+             GlobalPos globalPos = memory.get();
++            // Luminol start - Do not like item if they were out of current tickregion
++            final Level targetLevel = entity.level().getServer().getLevel(globalPos.dimension());
++            final BlockPos targetPos = globalPos.pos();
++
++            // thread checks
++            if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(targetLevel, targetPos)) {
++                brain.eraseMemory(MemoryModuleType.LIKED_NOTEBLOCK_POSITION); // The memory value is not being belong to current tick region anymore
++                return Optional.empty();
++            }
++            // Luminol end
++
+             if (shouldDepositItemsAtLikedNoteblock(entity, brain, globalPos)) {
+                 return Optional.of(new BlockPosTracker(globalPos.pos().above()));
+             }
+diff --git a/net/minecraft/world/entity/animal/sniffer/Sniffer.java b/net/minecraft/world/entity/animal/sniffer/Sniffer.java
+index 62ca7871d1e5d0fe611948ad43e44c23fdc2d3f8..cd0fc85fbefce4669b4cb637ec3b2628da57adbf 100644
+--- a/net/minecraft/world/entity/animal/sniffer/Sniffer.java
++++ b/net/minecraft/world/entity/animal/sniffer/Sniffer.java
+@@ -257,7 +257,17 @@ public class Sniffer extends Animal {
+ 
+     private boolean canDig(BlockPos pos) {
+         return this.level().getBlockState(pos).is(BlockTags.SNIFFER_DIGGABLE_BLOCK)
+-            && this.getExploredPositions().noneMatch(globalPos -> GlobalPos.of(this.level().dimension(), pos).equals(globalPos))
++            && this.getExploredPositions().noneMatch(globalPos -> { // Luminol start - Do not pathfind out of tickregion
++                // thread checks
++                final Level targetLevel = net.minecraft.server.MinecraftServer.getServer().getLevel(globalPos.dimension());
++                final BlockPos targetPos = globalPos.pos();
++
++                if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(targetLevel, targetPos)) {
++                    return false;
++                }
++
++                return GlobalPos.of(this.level().dimension(), pos).equals(globalPos); // Original logic
++            }) // Luminol end
+             && Optional.ofNullable(this.getNavigation().createPath(pos, 1)).map(Path::canReach).orElse(false);
+     }
+ 

luminol-server/minecraft-patches/features/0022-Fix-incorrect-ifn-check-on-folia-s-tracker-process.patch

@@ -1,19 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MrHua269 <wangxyper@163.com>
-Date: Sun, 26 Jan 2025 23:11:33 +0800
-Subject: [PATCH] Fix incorrect ifn check on folia's tracker process
-
-
-diff --git a/net/minecraft/server/level/ChunkMap.java b/net/minecraft/server/level/ChunkMap.java
-index 4bdb05948e9102304364f3681ce353f1cf2a0aee..5c507be097051de9a43a31bbc6190c3db7688667 100644
---- a/net/minecraft/server/level/ChunkMap.java
-+++ b/net/minecraft/server/level/ChunkMap.java
-@@ -902,7 +902,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
-                         // Folia start - region threading
-                         for (Entity possible : this.level.getCurrentWorldData().trackerEntities) {
-                             ChunkMap.TrackedEntity trackedEntity1 = possible.moonrise$getTrackedEntity();
--                            if (trackedEntity == null) {
-+                            if (trackedEntity1 == null) {
-                                 continue;
-                             }
-                             // Folia end - region threading

luminol-server/minecraft-patches/features/0023-Do-not-search-the-block-out-of-current-region.patch

@@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Sun, 9 Mar 2025 11:39:01 +0800
+Subject: [PATCH] Do not search the block out of current region
+
+
+diff --git a/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java b/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
+index 61887e6b052bca715c90dff5d9cd657e0b3f6a78..95e2dff6782bf7767ecb1a23e618862919ea71aa 100644
+--- a/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
++++ b/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
+@@ -422,6 +422,7 @@ public class TheEndGatewayBlockEntity extends TheEndPortalBlockEntity {
+                 if (i != 0 || i1 != 0 || allowBedrock) {
+                     for (int y = level.getMaxY(); y > (blockPos == null ? level.getMinY() : blockPos.getY()); y--) {
+                         BlockPos blockPos1 = new BlockPos(pos.getX() + i, y, pos.getZ() + i1);
++                        if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor((Level) level, blockPos1)) continue; // Luminol - Do not search the block out of current region as we might be at the edge of the tickregion
+                         BlockState blockState = level.getBlockState(blockPos1);
+                         if (blockState.isCollisionShapeFullBlock(level, blockPos1) && (allowBedrock || !blockState.is(Blocks.BEDROCK))) {
+                             blockPos = blockPos1;

luminol-server/minecraft-patches/features/0024-Use-the-correct-list-length-while-generating-tick-re.patch

@@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Sat, 22 Mar 2025 20:48:24 +0800
+Subject: [PATCH] Use the correct list length while generating tick report
+
+
+diff --git a/io/papermc/paper/threadedregions/TickData.java b/io/papermc/paper/threadedregions/TickData.java
+index 0383e4dcd611a7568597f46308060f3d7288a564..f53c37d047856f1569b6f637c54ebad03c42006e 100644
+--- a/io/papermc/paper/threadedregions/TickData.java
++++ b/io/papermc/paper/threadedregions/TickData.java
+@@ -178,7 +178,8 @@ public final class TickData {
+             } else {
+                 long totalTickTime = 0L;
+                 long totalCpuTime = 0L;
+-                for (int k = 0, len2 = collapsedData.size(); k < len2; ++k) {
++                //for (int k = 0, len2 = collapsedData.size(); k < len2; ++k) {
++                for (int k = 0, len2 = toCollapse.size(); k < len2; ++k) { // Luminol - Use the correct list length
+                     final TickRegionScheduler.TickTime time = toCollapse.get(k);
+                     totalTickTime += time.tickLength();
+                     totalCpuTime += time.supportCPUTime() ? time.tickCpuTime() : 0L;

luminol-server/minecraft-patches/features/0025-Try-rewriting-update-queue-polling.patch

@@ -0,0 +1,124 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Sun, 23 Mar 2025 15:51:35 +0800
+Subject: [PATCH] Try rewriting update queue polling
+
+
+diff --git a/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ThreadedTicketLevelPropagator.java b/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ThreadedTicketLevelPropagator.java
+index 310a8f80debadd64c2d962ebf83b7d0505ce6e42..59d77f04fd0f1c7b7af0314e533b72e1858a7e21 100644
+--- a/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ThreadedTicketLevelPropagator.java
++++ b/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ThreadedTicketLevelPropagator.java
+@@ -151,6 +151,15 @@ public abstract class ThreadedTicketLevelPropagator {
+     private boolean performUpdate(final Section section, final UpdateQueue.UpdateQueueNode node, final Propagator propagator,
+                                   final ReentrantAreaLock ticketLock, final ReentrantAreaLock schedulingLock,
+                                   final List<ChunkProgressionTask> scheduledTasks, final List<NewChunkHolder> changedFullStatus) {
++        // Luminol - Try rewriting update queue polling
++        if (section == null) {
++            if (node != null) {
++                this.updateQueue.remove(node);
++            }
++            return false;
++        }
++        // Luminol end
++
+         final int sectionX = section.sectionX;
+         final int sectionZ = section.sectionZ;
+ 
+@@ -334,6 +343,7 @@ public abstract class ThreadedTicketLevelPropagator {
+ 
+         // finished
+         if (node != null) {
++            node.releaseUpdating(); // Luminol - Try rewriting update queue polling
+             this.updateQueue.remove(node);
+         }
+ 
+@@ -468,7 +478,8 @@ public abstract class ThreadedTicketLevelPropagator {
+             }
+         }
+ 
+-        public UpdateQueueNode acquireNextOrWait(final long maxOrder) {
++        // Luminol start - Try rewriting update queue polling
++        /*public UpdateQueueNode acquireNextOrWait(final long maxOrder) {
+             final List<UpdateQueueNode> blocking = new ArrayList<>();
+ 
+             node_search:
+@@ -502,8 +513,63 @@ public abstract class ThreadedTicketLevelPropagator {
+                 await(blocking.get(0));
+             }
+ 
++            return null;
++        }*/
++
++        public UpdateQueueNode acquireNextOrWait(final long maxOrder) {
++            UpdateQueueNode firstConflict = null;
++            UpdateQueueNode prevProcessed = null;
++
++            for (UpdateQueueNode curr = this.getHeadAcquire(); curr != null && curr.order <= maxOrder; curr = curr.getNextVolatile()) {
++                if (curr.getSectionVolatile() == null) {
++                    continue;
++                }
++
++                if (!curr.tryAcquireUpdating()) {
++                    continue;
++                }
++
++                if (curr.getSectionVolatile() == null) {
++                    curr.releaseUpdating();
++                    continue;
++                }
++
++                boolean hasConflict = false;
++                for (UpdateQueueNode checked = prevProcessed; checked != null; checked = checked.getNextVolatile()) {
++                    if (checked != curr && curr.intersects(checked)) {
++                        hasConflict = true;
++                        break;
++                    }
++                }
++
++                if (hasConflict) {
++                    if (firstConflict == null) {
++                        firstConflict = curr;
++                    }
++                    curr.releaseUpdating();
++                    continue;
++                }
++
++                if (firstConflict != null) {
++                    this.append(firstConflict);
++                }
++
++                if (prevProcessed == null) {
++                    prevProcessed = curr;
++                } else {
++                    prevProcessed.setNextPlain(curr);
++                }
++
++                return curr;
++            }
++
++            if (firstConflict != null) {
++                this.append(firstConflict);
++            }
++
+             return null;
+         }
++        // Luminol end
+ 
+         public UpdateQueueNode peek() {
+             for (UpdateQueueNode head = this.getHeadOpaque(), curr = head;;) {
+@@ -689,6 +755,15 @@ public abstract class ThreadedTicketLevelPropagator {
+             private final boolean getAndSetUpdatingVolatile(final boolean value) {
+                 return (boolean)UPDATING_HANDLE.getAndSet(this, value);
+             }
++            // Luminol - Try rewriting update queue polling
++            public final boolean tryAcquireUpdating() {
++                return (boolean) UPDATING_HANDLE.compareAndSet(this, false, true);
++            }
++
++            public final void releaseUpdating() {
++                UPDATING_HANDLE.setVolatile(this, false);
++            }
++            // Luminol end
+         }
+     }
+ 

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

@@ -5,24 +5,16 @@ Subject: [PATCH] Kaiiju Vanilla end portal teleportation
 
 
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index c87db2d497ca9ed2e8aad5f1bc52555ff0952b80..88ca22ed6af613370ca8691ad9ebeb113e1637fe 100644
+index 4026d465687604965f105ded21a8206fd52bd375..8ec2b94add58d64d9b83d632427923720ec74990 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
-@@ -110,6 +110,7 @@ import net.minecraft.world.level.block.Rotation;
+@@ -4275,14 +4275,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
- import net.minecraft.world.level.block.SoundType;
- import net.minecraft.world.level.block.state.BlockState;
- import net.minecraft.world.level.border.WorldBorder;
-+import net.minecraft.world.level.dimension.LevelStem;
- import net.minecraft.world.level.entity.EntityAccess;
- import net.minecraft.world.level.entity.EntityInLevelCallback;
- import net.minecraft.world.level.gameevent.DynamicGameEventListener;
-@@ -4265,13 +4266,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
                          targetPos, 16, // load 16 blocks to be safe from block physics
                          ca.spottedleaf.concurrentutil.util.Priority.HIGH,
                          (chunks) -> {
 -                            net.minecraft.world.level.levelgen.feature.EndPlatformFeature.createEndPlatform(destination, targetPos.below(), true, null);
+-
 +                            //net.minecraft.world.level.levelgen.feature.EndPlatformFeature.createEndPlatform(destination, targetPos.below(), true, null);  // Kaiiju - Vanilla end teleportation - moved down
- 
 +                            // Kaiiju start - Vanilla end teleportation
 +                            Vec3 finalPos;
 +                            if (this instanceof Player) finalPos = Vec3.atBottomCenterOf(targetPos.below());
@@ -32,23 +24,43 @@ index c87db2d497ca9ed2e8aad5f1bc52555ff0952b80..88ca22ed6af613370ca8691ad9ebeb11
                              // on the obsidian, we need to spawn at targetPos.y - 1
                              portalInfoCompletable.complete(
                                  new net.minecraft.world.level.portal.TeleportTransition(
--                                    destination, Vec3.atBottomCenterOf(targetPos.below()), Vec3.ZERO, 90.0f, 0.0f,
+-                                    destination, Vec3.atBottomCenterOf(targetPos.below()), Vec3.ZERO, Direction.WEST.toYRot(), 0.0f,
-+                                    destination, finalPos, this.getDeltaMovement(), 90.0f, 0.0f, // Kaiiju - Vanilla end teleportation
+-                                    Relative.union(Relative.DELTA, Set.of(Relative.X_ROT)),
++                                    destination, finalPos, this.getDeltaMovement(), Direction.WEST.toYRot(), 0.0f, // Kaiiju - Vanilla end teleportation
++                                    //Relative.union(Relative.DELTA, Set.of(Relative.X_ROT)), // Kaiiju - Vanilla end teleportation
                                      TeleportTransition.PLAY_PORTAL_SOUND.then(TeleportTransition.PLACE_PORTAL_TICKET),
                                      org.bukkit.event.player.PlayerTeleportEvent.TeleportCause.END_PORTAL
                                  )
-@@ -4467,6 +4473,10 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4297,11 +4301,15 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+                         ca.spottedleaf.concurrentutil.util.Priority.HIGH,
+                         (chunks) -> {
+                             BlockPos adjustedSpawn = destination.getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, spawnPos);
+-
++                            // Kaiiju start - Vanilla end teleportation
++                            Vec3 finalPos;
++                            if (this instanceof Player) finalPos = Vec3.atBottomCenterOf(adjustedSpawn.below());
++                            else finalPos = Vec3.atBottomCenterOf(adjustedSpawn);
++                            // Kaiiju end
+                             // done
+                             portalInfoCompletable.complete(
+                                 new net.minecraft.world.level.portal.TeleportTransition(
+-                                    destination, Vec3.atBottomCenterOf(adjustedSpawn), Vec3.ZERO, 0.0f, 0.0f,
++                                    destination, finalPos, this.getDeltaMovement(), 0.0f, 0.0f, // Kaiiju - Vanilla end teleportation
+                                     Relative.union(Relative.DELTA, Relative.ROTATION),
+                                     TeleportTransition.PLAY_PORTAL_SOUND.then(TeleportTransition.PLACE_PORTAL_TICKET),
+                                     org.bukkit.event.player.PlayerTeleportEvent.TeleportCause.END_PORTAL
+@@ -4479,6 +4487,10 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
          if (!this.canPortalAsync(destination, takePassengers)) {
              return false;
          }
 +        // Kaiiju start - sync end platform spawning & entity teleportation
-+        final java.util.function.Consumer<Entity> tpComplete = type == PortalType.END && destination.getTypeKey() == LevelStem.END ?
++        final java.util.function.Consumer<Entity> tpComplete = type == PortalType.END && destination.getTypeKey() == net.minecraft.world.level.dimension.LevelStem.END ?
 +              e -> net.minecraft.world.level.levelgen.feature.EndPlatformFeature.createEndPlatform(destination, ServerLevel.END_SPAWN_POINT.below(), true, null) : teleportComplete;
 +        // Kaiiju end
  
          Vec3 initialPosition = this.position();
          ChunkPos initialPositionChunk = new ChunkPos(
-@@ -4531,9 +4541,14 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4543,9 +4555,14 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
                          info.postTeleportTransition().onTransition(teleported);
                      }
  

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

@@ -5,10 +5,10 @@ Subject: [PATCH] Kaiiju Entity tick and removal limiter
 
 
 diff --git a/io/papermc/paper/threadedregions/RegionizedWorldData.java b/io/papermc/paper/threadedregions/RegionizedWorldData.java
-index c6e487a4c14e6b82533881d01f32349b9ae28728..2c747cb8a724cd25c9d724908f92b320741600de 100644
+index b8f1f042342d3fed5fa26df0de07e8e2b0937130..4d9837f11da4dc59fdb945fdb4849c4d1519f5dc 100644
 --- a/io/papermc/paper/threadedregions/RegionizedWorldData.java
 +++ b/io/papermc/paper/threadedregions/RegionizedWorldData.java
-@@ -354,6 +354,7 @@ public final class RegionizedWorldData {
+@@ -358,6 +358,7 @@ public final class RegionizedWorldData {
      private final IteratorSafeOrderedReferenceSet<Mob> navigatingMobs = new IteratorSafeOrderedReferenceSet<>();
      public final ReferenceList<Entity> trackerEntities = new ReferenceList<>(EMPTY_ENTITY_ARRAY); // Moonrise - entity tracker
      public final ReferenceList<Entity> trackerUnloadedEntities = new ReferenceList<>(EMPTY_ENTITY_ARRAY); // Moonrise - entity tracker
@@ -17,7 +17,7 @@ index c6e487a4c14e6b82533881d01f32349b9ae28728..2c747cb8a724cd25c9d724908f92b320
      // block ticking
      private final ObjectLinkedOpenHashSet<BlockEventData> blockEvents = new ObjectLinkedOpenHashSet<>();
 diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
-index d34ad333b6ea3855a24a58fcd80ccf19b2bbf41c..ad121d609bcc1d9b53a1a20d4e25cf9dfa480fb8 100644
+index 7defcd15c44601bfd2f7f55046038693264defee..5a87825606047f058df8de84bf933d216b5878b0 100644
 --- a/net/minecraft/server/level/ServerLevel.java
 +++ b/net/minecraft/server/level/ServerLevel.java
 @@ -808,6 +808,7 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe

luminol-server/minecraft-patches/features/0029-Purpur-Use-alternative-keep-alive.patch

@@ -1,11 +1,11 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: MrHua269 <wangxyper@163.com>
 Date: Sun, 12 Jan 2025 11:43:15 +0800
-Subject: [PATCH] Purpur use alternative keep alive
+Subject: [PATCH] Purpur Use alternative keep alive
 
 
 diff --git a/net/minecraft/server/network/ServerCommonPacketListenerImpl.java b/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
-index 6eca15223b92aedac74233db886e2c1248750e2c..7507f32b5f0f7fbbf35eeaaf03bf9d99694c1683 100644
+index f7f89695f40e4aff39d324e6a7948a8a3a8c04b3..bceef2e8cd9a84ca32f17085839dff0232f2ee31 100644
 --- a/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
 +++ b/net/minecraft/server/network/ServerCommonPacketListenerImpl.java
 @@ -41,6 +41,7 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
@@ -16,7 +16,7 @@ index 6eca15223b92aedac74233db886e2c1248750e2c..7507f32b5f0f7fbbf35eeaaf03bf9d99
      private int latency;
      private volatile boolean suspendFlushingOnServerThread = false;
      // CraftBukkit start
-@@ -130,6 +131,16 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+@@ -131,6 +132,16 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
  
      @Override
      public void handleKeepAlive(ServerboundKeepAlivePacket packet) {
@@ -33,7 +33,7 @@ index 6eca15223b92aedac74233db886e2c1248750e2c..7507f32b5f0f7fbbf35eeaaf03bf9d99
          if (this.keepAlivePending && packet.getId() == this.keepAliveChallenge) {
              int i = (int)(Util.getMillis() - this.keepAliveTime);
              this.latency = (this.latency * 3 + i) / 4;
-@@ -250,7 +261,22 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+@@ -255,7 +266,22 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
          // Paper start - give clients a longer time to respond to pings as per pre 1.12.2 timings
          // This should effectively place the keepalive handling back to "as it was" before 1.12.2
          final long elapsedTime = millis - this.keepAliveTime;
@@ -57,7 +57,7 @@ index 6eca15223b92aedac74233db886e2c1248750e2c..7507f32b5f0f7fbbf35eeaaf03bf9d99
              if (this.keepAlivePending) {
                  if (!this.processedDisconnect && elapsedTime >= KEEPALIVE_LIMIT) { // check keepalive limit, don't fire if already disconnected
                      this.disconnect(TIMEOUT_DISCONNECTION_MESSAGE, org.bukkit.event.player.PlayerKickEvent.Cause.TIMEOUT); // Paper - kick event cause
-@@ -263,6 +289,7 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
+@@ -268,6 +294,7 @@ public abstract class ServerCommonPacketListenerImpl implements ServerCommonPack
                  this.send(new ClientboundKeepAlivePacket(this.keepAliveChallenge));
              }
          }

luminol-server/minecraft-patches/features/0030-Purpur-Lobotomize-stuck-villagers.patch

@@ -0,0 +1,88 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Thu, 30 Jan 2025 08:42:29 +0800
+Subject: [PATCH] Purpur Lobotomize stuck villagers
+
+
+diff --git a/net/minecraft/world/entity/npc/Villager.java b/net/minecraft/world/entity/npc/Villager.java
+index 7ea74aeb905b95e5919d74df5fbc5e8f7a9985e3..b61da3d0d7d24b674cae155b95f7fab0669f4a20 100644
+--- a/net/minecraft/world/entity/npc/Villager.java
++++ b/net/minecraft/world/entity/npc/Villager.java
+@@ -193,6 +193,53 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+         this.setVillagerData(this.getVillagerData().setType(villagerType).setProfession(VillagerProfession.NONE));
+     }
+ 
++    // Purpur start
++    private boolean isLobotomized = false; public boolean isLobotomized() { return this.isLobotomized; } // Purpur
++    private int notLobotomizedCount = 0; // Purpur
++
++    private boolean checkLobotomized() {
++        int interval = me.earthme.luminol.config.modules.optimizations.LobotomizeVillageConfig.villagerLobotomizeCheckInterval;
++        boolean shouldCheckForTradeLocked = me.earthme.luminol.config.modules.optimizations.LobotomizeVillageConfig.villagerLobotomizeWaitUntilTradeLocked;
++        if (this.notLobotomizedCount > 3) {
++            // check half as often if not lobotomized for the last 3+ consecutive checks
++            interval *= 2;
++        }
++        if (this.level().getGameTime() % interval == 0) {
++            // offset Y for short blocks like dirt_path/farmland
++            this.isLobotomized = !(shouldCheckForTradeLocked && this.getVillagerXp() == 0) && !canTravelFrom(BlockPos.containing(this.position().x, this.getBoundingBox().minY + 0.0625D, this.position().z));
++
++            if (this.isLobotomized) {
++                this.notLobotomizedCount = 0;
++            } else {
++                this.notLobotomizedCount++;
++            }
++        }
++        return this.isLobotomized;
++    }
++    // Purpur end
++
++    private boolean canTravelFrom(BlockPos pos) {
++        return canTravelTo(pos.east()) || canTravelTo(pos.west()) || canTravelTo(pos.north()) || canTravelTo(pos.south());
++    }
++
++    private boolean canTravelTo(BlockPos pos) {
++        net.minecraft.world.level.block.state.BlockState state = this.level().getBlockStateIfLoaded(pos);
++        if (state == null) {
++            // chunk not loaded
++            return false;
++        }
++        net.minecraft.world.level.block.Block bottom = state.getBlock();
++        if (bottom instanceof net.minecraft.world.level.block.FenceBlock ||
++                bottom instanceof net.minecraft.world.level.block.FenceGateBlock ||
++                bottom instanceof net.minecraft.world.level.block.WallBlock) {
++            // bottom block is too tall to get over
++            return false;
++        }
++        net.minecraft.world.level.block.Block top = level().getBlockState(pos.above()).getBlock();
++        // only if both blocks have no collision
++        return !bottom.hasCollision && !top.hasCollision;
++    }
++
+     @Override
+     public Brain<Villager> getBrain() {
+         return (Brain<Villager>)super.getBrain();
+@@ -289,11 +336,21 @@ public class Villager extends AbstractVillager implements ReputationEventHandler
+         // Paper start - EAR 2
+         this.customServerAiStep(level, false);
+     }
+-    protected void customServerAiStep(ServerLevel level, final boolean inactive) {
++    protected void customServerAiStep(ServerLevel level, boolean inactive) { // Purpur - not final
+         // Paper end - EAR 2
+         ProfilerFiller profilerFiller = Profiler.get();
+         profilerFiller.push("villagerBrain");
+-        if (!inactive) this.getBrain().tick(level, this); // Paper - EAR 2
++        // Purpur start
++        if (me.earthme.luminol.config.modules.optimizations.LobotomizeVillageConfig.villagerLobotomizeEnabled) {
++            // treat as inactive if lobotomized
++            inactive = inactive || checkLobotomized();
++        } else {
++            this.isLobotomized = false;
++        }
++        // Purpur end
++        if (!inactive) {
++            this.getBrain().tick(level, this); // Paper - EAR 2
++        } else if (this.isLobotomized && shouldRestock()) restock(); // Purpur - Lobotomize stuck villagers
+         profilerFiller.pop();
+         if (this.assignProfessionWhenSpawned) {
+             this.assignProfessionWhenSpawned = false;

luminol-server/minecraft-patches/features/0031-Purpur-Barrels-and-enderchests-6-rows.patch

@@ -0,0 +1,172 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Suisuroru <qwertyuiop14077@qq.com>
+Date: Thu, 20 Feb 2025 01:00:28 +0800
+Subject: [PATCH] Purpur-Barrels-and-enderchests-6-rows
+
+
+diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
+index 751b011701d6ae373099226ea63ffbafcd24ce6a..e5e946462da9e56344428139768075b7bd228ec0 100644
+--- a/net/minecraft/server/players/PlayerList.java
++++ b/net/minecraft/server/players/PlayerList.java
+@@ -1103,6 +1103,10 @@ public abstract class PlayerList {
+         player.getBukkitEntity().recalculatePermissions(); // CraftBukkit
+         this.server.getCommands().sendCommands(player);
+         } // Paper - Add sendOpLevel API
++
++        // Purpur start - Barrels and enderchests 6 rows
++        player.enderChestSlotCount = me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.enderchestRows < 7 && me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.enderchestRows > 0 ? 9 * me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.enderchestRows : 27;
++        // Purpur end - Barrels and enderchests 6 rows
+     }
+ 
+     public boolean isWhiteListed(GameProfile profile) {
+diff --git a/net/minecraft/world/entity/player/Player.java b/net/minecraft/world/entity/player/Player.java
+index ae049c5c3593525b991d865fec695c00ad408a59..c6252a245e9701f69db1fe167f6590095237553a 100644
+--- a/net/minecraft/world/entity/player/Player.java
++++ b/net/minecraft/world/entity/player/Player.java
+@@ -200,6 +200,7 @@ public abstract class Player extends LivingEntity {
+     private int currentImpulseContextResetGraceTime;
+     public boolean affectsSpawning = true; // Paper - Affects Spawning API
+     public net.kyori.adventure.util.TriState flyingFallDamage = net.kyori.adventure.util.TriState.NOT_SET; // Paper - flying fall damage
++    public int enderChestSlotCount = -1; // Purpur - Barrels and enderchests 6 rows
+ 
+     // CraftBukkit start
+     public boolean fauxSleeping;
+diff --git a/net/minecraft/world/inventory/ChestMenu.java b/net/minecraft/world/inventory/ChestMenu.java
+index 280169afbd637eeb67ddf7eaeb4eecd464a128d5..461705345dd897c8304c884272531af836f8854f 100644
+--- a/net/minecraft/world/inventory/ChestMenu.java
++++ b/net/minecraft/world/inventory/ChestMenu.java
+@@ -66,10 +66,30 @@ public class ChestMenu extends AbstractContainerMenu {
+         return new ChestMenu(MenuType.GENERIC_9x6, containerId, playerInventory, 6);
+     }
+ 
++    // Purpur start - Barrels and enderchests 6 rows
++    public static ChestMenu oneRow(int syncId, Inventory playerInventory, Container inventory) {
++        return new ChestMenu(MenuType.GENERIC_9x1, syncId, playerInventory, inventory, 1);
++        }
++
++    public static ChestMenu twoRows(int syncId, Inventory playerInventory, Container inventory) {
++        return new ChestMenu(MenuType.GENERIC_9x2, syncId, playerInventory, inventory, 2);
++        }
++    // Purpur end - Barrels and enderchests 6 rows
++
+     public static ChestMenu threeRows(int containerId, Inventory playerInventory, Container container) {
+         return new ChestMenu(MenuType.GENERIC_9x3, containerId, playerInventory, container, 3);
+     }
+ 
++    // Purpur start - Barrels and enderchests 6 rows
++    public static ChestMenu fourRows(int syncId, Inventory playerInventory, Container inventory) {
++        return new ChestMenu(MenuType.GENERIC_9x4, syncId, playerInventory, inventory, 4);
++    }
++
++    public static ChestMenu fiveRows(int syncId, Inventory playerInventory, Container inventory) {
++        return new ChestMenu(MenuType.GENERIC_9x5, syncId, playerInventory, inventory, 5);
++    }
++    // Purpur end - Barrels and enderchests 6 rows
++
+     public static ChestMenu sixRows(int containerId, Inventory playerInventory, Container container) {
+         return new ChestMenu(MenuType.GENERIC_9x6, containerId, playerInventory, container, 6);
+     }
+diff --git a/net/minecraft/world/inventory/PlayerEnderChestContainer.java b/net/minecraft/world/inventory/PlayerEnderChestContainer.java
+index a6a359bab2a727f4631b633a8bb370dd40decc75..5fab998cdec92a2bd965e6b48cc6189b195dc86d 100644
+--- a/net/minecraft/world/inventory/PlayerEnderChestContainer.java
++++ b/net/minecraft/world/inventory/PlayerEnderChestContainer.java
+@@ -25,11 +25,18 @@ public class PlayerEnderChestContainer extends SimpleContainer {
+     }
+ 
+     public PlayerEnderChestContainer(Player owner) {
+-        super(27);
++        super(me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.enderchestRows < 7 && me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.enderchestRows > 0 ? 9 * me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.enderchestRows : 27);
+         this.owner = owner;
+         // CraftBukkit end
+     }
+ 
++    // Purpur start - Barrels and enderchests 6 rows
++        @Override
++    public int getContainerSize() {
++        return owner.enderChestSlotCount < 0 ? super.getContainerSize() : owner.enderChestSlotCount;
++    }
++    // Purpur end - Barrels and enderchests 6 rows
++
+     public void setActiveChest(EnderChestBlockEntity enderChestBlockEntity) {
+         this.activeChest = enderChestBlockEntity;
+     }
+diff --git a/net/minecraft/world/level/block/EnderChestBlock.java b/net/minecraft/world/level/block/EnderChestBlock.java
+index f5533960708bdbaf2eacefbc7c7c3123b7d26502..bf9801f1370c8d5e6ca459207b221ef2e92dac9e 100644
+--- a/net/minecraft/world/level/block/EnderChestBlock.java
++++ b/net/minecraft/world/level/block/EnderChestBlock.java
+@@ -85,8 +85,14 @@ public class EnderChestBlock extends AbstractChestBlock<EnderChestBlockEntity> i
+                 enderChestInventory.setActiveChest(enderChestBlockEntity); // Needs to happen before ChestMenu.threeRows as it is required for opening animations
+                 if (level instanceof ServerLevel serverLevel && player.openMenu(
+                     new SimpleMenuProvider(
+-                        (containerId, playerInventory, player1) -> ChestMenu.threeRows(containerId, playerInventory, enderChestInventory), CONTAINER_TITLE
+-                    )
++                            (containerId, playerInventory, player1) -> switch (me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.enderchestRows) {
++                    case 6 -> ChestMenu.sixRows(containerId, playerInventory, enderChestInventory);
++                    case 5 -> ChestMenu.fiveRows(containerId, playerInventory, enderChestInventory);
++                    case 4 -> ChestMenu.fourRows(containerId, playerInventory, enderChestInventory);
++                    case 2 -> ChestMenu.twoRows(containerId, playerInventory, enderChestInventory);
++                    case 1 -> ChestMenu.oneRow(containerId, playerInventory, enderChestInventory);
++                    default -> ChestMenu.threeRows(containerId, playerInventory, enderChestInventory);
++                }, CONTAINER_TITLE) // Purpur - Barrels and enderchests 6 rows
+                 ).isPresent()) {
+                 // Paper end - Fix InventoryOpenEvent cancellation - moved up;
+                     player.awardStat(Stats.OPEN_ENDERCHEST);
+diff --git a/net/minecraft/world/level/block/entity/BarrelBlockEntity.java b/net/minecraft/world/level/block/entity/BarrelBlockEntity.java
+index 0f808855f58281578c2758513787f0f7330c9291..5b6ee21c21686dad86717b87c0033149cefad142 100644
+--- a/net/minecraft/world/level/block/entity/BarrelBlockEntity.java
++++ b/net/minecraft/world/level/block/entity/BarrelBlockEntity.java
+@@ -55,7 +55,17 @@ public class BarrelBlockEntity extends RandomizableContainerBlockEntity {
+         this.maxStack = i;
+     }
+     // CraftBukkit end
+-    private NonNullList<ItemStack> items = NonNullList.withSize(27, ItemStack.EMPTY);
++    // Purpur start - Barrels and enderchests 6 rows
++    private NonNullList<ItemStack> items = NonNullList.withSize(switch (me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.barrelRows) {
++        case 6 -> 54;
++        case 5 -> 45;
++        case 4 -> 36;
++        case 2 -> 18;
++        case 1 -> 9;
++        default -> 27;
++        }, ItemStack.EMPTY);
++    // Purpur end - Barrels and enderchests 6 rows
++
+     public final ContainerOpenersCounter openersCounter = new ContainerOpenersCounter() {
+         @Override
+         protected void onOpen(Level level, BlockPos pos, BlockState state) {
+@@ -107,7 +117,16 @@ public class BarrelBlockEntity extends RandomizableContainerBlockEntity {
+ 
+     @Override
+     public int getContainerSize() {
+-        return 27;
++        // Purpur start - Barrels and enderchests 6 rows
++        return switch (me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.barrelRows) {
++            case 6 -> 54;
++            case 5 -> 45;
++            case 4 -> 36;
++            case 2 -> 18;
++            case 1 -> 9;
++            default -> 27;
++        };
++    // Purpur end - Barrels and enderchests 6 rows
+     }
+ 
+     @Override
+@@ -127,7 +146,16 @@ public class BarrelBlockEntity extends RandomizableContainerBlockEntity {
+ 
+     @Override
+     protected AbstractContainerMenu createMenu(int id, Inventory player) {
+-        return ChestMenu.threeRows(id, player, this);
++        // Purpur start - Barrels and enderchests 6 rows
++        return switch (me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.barrelRows) {
++            case 6 -> ChestMenu.sixRows(id, player, this);
++            case 5 -> ChestMenu.fiveRows(id, player, this);
++            case 4 -> ChestMenu.fourRows(id, player, this);
++            case 2 -> ChestMenu.twoRows(id, player, this);
++            case 1 -> ChestMenu.oneRow(id, player, this);
++            default -> ChestMenu.threeRows(id, player, this);
++        };
++        // Purpur end - Barrels and enderchests 6 rows
+     }
+ 
+     @Override

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

@@ -5,7 +5,7 @@ Subject: [PATCH] Petal Reduce sensor work
 
 
 diff --git a/net/minecraft/world/entity/Mob.java b/net/minecraft/world/entity/Mob.java
-index af7dbb0f2df0ec42c2c16bc58ba16b6c65d3ebcb..53e78475e721a05e9757235d0849eae3878007cd 100644
+index 94a7b95f41c2954561f9c3cb0f61210c0c058f1d..dbe0fc0c46f66c61a2f286d521302719b28917c1 100644
 --- a/net/minecraft/world/entity/Mob.java
 +++ b/net/minecraft/world/entity/Mob.java
 @@ -866,11 +866,11 @@ public abstract class Mob extends LivingEntity implements EquipmentUser, Leashab

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

@@ -5,7 +5,7 @@ Subject: [PATCH] Pufferfish Cache climbing check for activation
 
 
 diff --git a/io/papermc/paper/entity/activation/ActivationRange.java b/io/papermc/paper/entity/activation/ActivationRange.java
-index ba8b5a0ebe652bfaf5c1498c19d12a91a192bf8e..76e0b50b2dc9c718a67f89de720a891b398cec2a 100644
+index c260741a87513b89a5cc62c543fb9f990f86491e..beb9b3b3cd5ca60bd2cdada937bff8a1da639da5 100644
 --- a/io/papermc/paper/entity/activation/ActivationRange.java
 +++ b/io/papermc/paper/entity/activation/ActivationRange.java
 @@ -225,7 +225,7 @@ public final class ActivationRange {
@@ -18,10 +18,10 @@ index ba8b5a0ebe652bfaf5c1498c19d12a91a192bf8e..76e0b50b2dc9c718a67f89de720a891b
              }
              if (entity instanceof final Mob mob && mob.getTarget() != null) {
 diff --git a/net/minecraft/world/entity/LivingEntity.java b/net/minecraft/world/entity/LivingEntity.java
-index 5ba06cf6b26baa5acae9d64111ee3f61533e7867..d7eb8022a1606760d8e81bc752241eff4496ef4c 100644
+index 6258b008ad3e00d41e9f3014572d6f7a06b1847c..2293c3db45e9ecce4e0d4b2f87b8e90228e44d94 100644
 --- a/net/minecraft/world/entity/LivingEntity.java
 +++ b/net/minecraft/world/entity/LivingEntity.java
-@@ -2039,6 +2039,20 @@ public abstract class LivingEntity extends Entity implements Attackable {
+@@ -2044,6 +2044,20 @@ public abstract class LivingEntity extends Entity implements Attackable {
          return this.lastClimbablePos;
      }
  

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

@@ -5,7 +5,7 @@ Subject: [PATCH] Gale Variable entity wake-up duration
 
 
 diff --git a/io/papermc/paper/entity/activation/ActivationRange.java b/io/papermc/paper/entity/activation/ActivationRange.java
-index 76e0b50b2dc9c718a67f89de720a891b398cec2a..e3d2371e36b48bb820931394e5b4182152f57630 100644
+index beb9b3b3cd5ca60bd2cdada937bff8a1da639da5..3c9fc433155dd235668ded700d51d95434ba745f 100644
 --- a/io/papermc/paper/entity/activation/ActivationRange.java
 +++ b/io/papermc/paper/entity/activation/ActivationRange.java
 @@ -54,27 +54,39 @@ public final class ActivationRange {

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

@@ -5,7 +5,7 @@ Subject: [PATCH] Gale Skip entity move if movement is zero
 
 
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index 41313532c739027351d6fd848aa1c515aa4acd4a..d58f2bfde617ab55a550cbf8eb0187c9663d38fc 100644
+index 8ec2b94add58d64d9b83d632427923720ec74990..3ad00cc095588574218ca6d729ead119403202e0 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
 @@ -1104,7 +1104,14 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
@@ -23,7 +23,7 @@ index 41313532c739027351d6fd848aa1c515aa4acd4a..d58f2bfde617ab55a550cbf8eb0187c9
          final Vec3 originalMovement = movement; // Paper - Expose pre-collision velocity
          // Paper start - detailed watchdog information
          ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread("Cannot move an entity off-main");
-@@ -5031,6 +5038,11 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -5045,6 +5052,11 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
      }
  
      public final void setBoundingBox(AABB bb) {

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

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

luminol-server/minecraft-patches/features/0043-Leaf-Remove-useless-creating-stats-json-bases-on-pla.patch

@@ -0,0 +1,29 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Sat, 8 Mar 2025 21:14:53 +0800
+Subject: [PATCH] Leaf Remove useless creating stats json bases on player name
+ logic
+
+
+diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
+index e5e946462da9e56344428139768075b7bd228ec0..9777a5b7ba9916e426ba87d6ee7cd56f0e43c195 100644
+--- a/net/minecraft/server/players/PlayerList.java
++++ b/net/minecraft/server/players/PlayerList.java
+@@ -1420,6 +1420,8 @@ public abstract class PlayerList {
+         if (serverStatsCounter == null) {
+             File file = this.server.getWorldPath(LevelResource.PLAYER_STATS_DIR).toFile();
+             File file1 = new File(file, uuid + ".json");
++            // Leaf start - Remove useless creating stats json bases on player name logic
++            /*
+             if (!file1.exists()) {
+                 File file2 = new File(file, displayName + ".json"); // CraftBukkit
+                 Path path = file2.toPath();
+@@ -1427,6 +1429,8 @@ public abstract class PlayerList {
+                     file2.renameTo(file1);
+                 }
+             }
++            */
++            // Leaf end - Remove useless creating stats json bases on player name logic
+ 
+             serverStatsCounter = new ServerStatsCounter(this.server, file1);
+             // this.stats.put(uuid, serverStatsCounter); // CraftBukkit

luminol-server/minecraft-patches/features/0044-Leaf-Replace-brain-maps-with-optimized-collection.patch

@@ -0,0 +1,31 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Sat, 8 Mar 2025 21:20:11 +0800
+Subject: [PATCH] Leaf Replace brain maps with optimized collection
+
+
+diff --git a/net/minecraft/world/entity/ai/Brain.java b/net/minecraft/world/entity/ai/Brain.java
+index d61fba01feecce3610cd390f490d3097c5db19c4..67b71145e4feb4835a79a6007b04511a2c3b938a 100644
+--- a/net/minecraft/world/entity/ai/Brain.java
++++ b/net/minecraft/world/entity/ai/Brain.java
+@@ -45,14 +45,14 @@ public class Brain<E extends LivingEntity> {
+     static final Logger LOGGER = LogUtils.getLogger();
+     private final Supplier<Codec<Brain<E>>> codec;
+     private static final int SCHEDULE_UPDATE_DELAY = 20;
+-    private final Map<MemoryModuleType<?>, Optional<? extends ExpirableValue<?>>> memories = Maps.newHashMap();
+-    private final Map<SensorType<? extends Sensor<? super E>>, Sensor<? super E>> sensors = Maps.newLinkedHashMap();
++    private final Map<MemoryModuleType<?>, Optional<? extends ExpirableValue<?>>> memories = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(); // Leaf - Replace brain maps with optimized collection
++    private final Map<SensorType<? extends Sensor<? super E>>, Sensor<? super E>> sensors = new it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap<>(); // Leaf - Replace brain maps with optimized collection
+     private final Map<Integer, Map<Activity, Set<BehaviorControl<? super E>>>> availableBehaviorsByPriority = Maps.newTreeMap();
+     private Schedule schedule = Schedule.EMPTY;
+-    private final Map<Activity, Set<Pair<MemoryModuleType<?>, MemoryStatus>>> activityRequirements = Maps.newHashMap();
+-    private final Map<Activity, Set<MemoryModuleType<?>>> activityMemoriesToEraseWhenStopped = Maps.newHashMap();
+-    private Set<Activity> coreActivities = Sets.newHashSet();
+-    private final Set<Activity> activeActivities = Sets.newHashSet();
++    private final Map<Activity, Set<Pair<MemoryModuleType<?>, MemoryStatus>>> activityRequirements = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(); // Leaf - Replace brain maps with optimized collection
++    private final Map<Activity, Set<MemoryModuleType<?>>> activityMemoriesToEraseWhenStopped = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(); // Leaf - Replace brain maps with optimized collection
++    private Set<Activity> coreActivities = new it.unimi.dsi.fastutil.objects.ObjectOpenHashSet<>(); // Leaf - Replace brain maps with optimized collection
++    private final Set<Activity> activeActivities = new it.unimi.dsi.fastutil.objects.ObjectOpenHashSet<>(); // Leaf - Replace brain maps with optimized collection
+     private Activity defaultActivity = Activity.IDLE;
+     private long lastScheduleUpdate = -9999L;
+ 

luminol-server/minecraft-patches/features/0045-Leaf-Paper-PR-Prevent-zombie-reinforcements-loading-.patch

@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Sat, 8 Mar 2025 21:21:11 +0800
+Subject: [PATCH] Leaf Paper PR: Prevent zombie reinforcements loading chunks
+
+
+diff --git a/net/minecraft/world/entity/monster/Zombie.java b/net/minecraft/world/entity/monster/Zombie.java
+index cf231380febd6d316eb902d43c636135ee0d7fa4..731473610e068a613d67efaee08ded810fe86cf0 100644
+--- a/net/minecraft/world/entity/monster/Zombie.java
++++ b/net/minecraft/world/entity/monster/Zombie.java
+@@ -348,6 +348,13 @@ public class Zombie extends Monster {
+                     int i2 = floor1 + Mth.nextInt(this.random, 7, 40) * Mth.nextInt(this.random, -1, 1);
+                     int i3 = floor2 + Mth.nextInt(this.random, 7, 40) * Mth.nextInt(this.random, -1, 1);
+                     BlockPos blockPos = new BlockPos(i1, i2, i3);
++
++                    // Paper start - Prevent reinforcement checks from loading chunks
++                    if (this.level().getChunkIfLoadedImmediately(blockPos.getX() >> 4, blockPos.getZ() >> 4) == null) {
++                        continue;
++                    }
++                    // Paper end - Prevent reinforcement checks from loading chunks
++
+                     if (SpawnPlacements.isSpawnPositionOk(type, level, blockPos)
+                         && SpawnPlacements.checkSpawnRules(type, level, EntitySpawnReason.REINFORCEMENT, blockPos, level.random)) {
+                         zombie.setPos(i1, i2, i3);

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

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

luminol-server/minecraft-patches/features/0047-Add-missing-teleportation-apis-for-folia.patch

@@ -0,0 +1,169 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Fri, 31 Jan 2025 20:28:45 +0800
+Subject: [PATCH] Add missing teleportation apis for folia
+
+
+diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
+index b17ace9118c94a756fa2901621c6b2b9bd9e5764..8a728a3af515da522cd5fab1e731bbc0607f0596 100644
+--- a/net/minecraft/server/level/ServerPlayer.java
++++ b/net/minecraft/server/level/ServerPlayer.java
+@@ -1660,6 +1660,9 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+                     if (respawnComplete != null) {
+                         respawnComplete.accept(ServerPlayer.this);
+                     }
++                    // Luminol - Add missing teleportation apis
++                    new me.earthme.luminol.api.entity.player.PostPlayerRespawnEvent(ServerPlayer.this.getBukkitEntity()).callEvent();
++                    // Luminol end
+                 }
+             );
+         });
+diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
+index 3ad00cc095588574218ca6d729ead119403202e0..ccf1914b4f48ecc0f4fe980510f42d5415ec1daa 100644
+--- a/net/minecraft/world/entity/Entity.java
++++ b/net/minecraft/world/entity/Entity.java
+@@ -4160,6 +4160,31 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         }
+ 
+         // TODO any events that can modify go HERE
++        // Luminol start - Add missing teleportation apis
++        org.bukkit.Location destinationLoc;
++
++        if (pitch == null) {
++            if (yaw == null) {
++                destinationLoc = io.papermc.paper.util.MCUtil.toLocation(destination, pos, Float.NaN, Float.NaN);
++            } else {
++                destinationLoc = io.papermc.paper.util.MCUtil.toLocation(destination, pos, yaw, Float.NaN);
++            }
++        }else {
++            if (yaw == null) {
++                destinationLoc = io.papermc.paper.util.MCUtil.toLocation(destination, pos, Float.NaN, pitch);
++            }else {
++                destinationLoc = io.papermc.paper.util.MCUtil.toLocation(destination, pos, yaw, pitch);
++            }
++        }
++
++        final me.earthme.luminol.api.entity.EntityTeleportAsyncEvent wrapped = new me.earthme.luminol.api.entity.EntityTeleportAsyncEvent(
++                this.getBukkitEntity(),
++                cause,
++                destinationLoc
++        );
++
++        wrapped.callEvent();
++        // Luminol end
+ 
+         // check for same region
+         if (destination == this.level()) {
+@@ -4276,7 +4301,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+             // we just select the spawn position
+             case END: {
+                 if (destination.getTypeKey() == net.minecraft.world.level.dimension.LevelStem.END) {
+-                    BlockPos targetPos = ServerLevel.END_SPAWN_POINT;
++                    BlockPos targetPos = ServerLevel.END_SPAWN_POINT; // Luminol - Rename
++                    // Luminol start - Add missing teleportation apis
++                    final org.bukkit.Location orginalPortalLocation = io.papermc.paper.util.MCUtil.toLocation(origin, originPortal);
++                    final org.bukkit.Location targetPortalLocation = io.papermc.paper.util.MCUtil.toLocation(destination, targetPos);
++
++                    final me.earthme.luminol.api.portal.PortalLocateEvent portalLocateEvent = new me.earthme.luminol.api.portal.PortalLocateEvent(
++                            orginalPortalLocation,
++                            targetPortalLocation
++                    );
++
++                    portalLocateEvent.callEvent();
++                    // Luminol end
+                     // need to load chunks so we can create the platform
+                     destination.moonrise$loadChunksAsync(
+                         targetPos, 16, // load 16 blocks to be safe from block physics
+@@ -4301,7 +4337,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+                         }
+                     );
+                 } else {
+-                    BlockPos spawnPos = destination.getSharedSpawnPos();
++                    BlockPos spawnPos = destination.getSharedSpawnPos(); // Luminol - Rename
++                    // Luminol start - Add missing teleportation apis
++                    final org.bukkit.Location orginalPortalLocation = io.papermc.paper.util.MCUtil.toLocation(origin, originPortal);
++                    final org.bukkit.Location targetPortalLocation = io.papermc.paper.util.MCUtil.toLocation(destination, spawnPos);
++
++                    final me.earthme.luminol.api.portal.PortalLocateEvent portalLocateEvent = new me.earthme.luminol.api.portal.PortalLocateEvent(
++                            orginalPortalLocation,
++                            targetPortalLocation
++                    );
++
++                    portalLocateEvent.callEvent();
++                    // Luminol end
+                     // need to load chunk for heightmap
+                     destination.moonrise$loadChunksAsync(
+                         spawnPos, 0,
+@@ -4356,8 +4403,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+ 
+                 WorldBorder destinationBorder = destination.getWorldBorder();
+                 double dimensionScale = net.minecraft.world.level.dimension.DimensionType.getTeleportationScale(origin.dimensionType(), destination.dimensionType());
+-                BlockPos targetPos = destination.getWorldBorder().clampToBounds(this.getX() * dimensionScale, this.getY(), this.getZ() * dimensionScale);
++                BlockPos targetPos = destination.getWorldBorder().clampToBounds(this.getX() * dimensionScale, this.getY(), this.getZ() * dimensionScale); // Luminol - Rename
++                // Luminol start - Add missing teleportation apis
++                final org.bukkit.Location orginalPortalLocation = io.papermc.paper.util.MCUtil.toLocation(origin, originPortal);
++                final org.bukkit.Location targetPortalLocation = io.papermc.paper.util.MCUtil.toLocation(destination, targetPos);
++
++                final me.earthme.luminol.api.portal.PortalLocateEvent portalLocateEvent = new me.earthme.luminol.api.portal.PortalLocateEvent(
++                        orginalPortalLocation,
++                        targetPortalLocation
++                );
+ 
++                portalLocateEvent.callEvent();
++                // Luminol end
+                 ca.spottedleaf.concurrentutil.completable.CallbackCompletable<BlockUtil.FoundRectangle> portalFound
+                     = new ca.spottedleaf.concurrentutil.completable.CallbackCompletable<>();
+ 
+@@ -4494,9 +4551,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         if (!this.canPortalAsync(destination, takePassengers)) {
+             return false;
+         }
++        // Luminol start - Add missing teleportation events
++        if (!new me.earthme.luminol.api.entity.PreEntityPortalEvent(
++                this.getBukkitEntity(),
++                io.papermc.paper.util.MCUtil.toLocation(this.level, portalPos),
++                destination.getWorld()
++        ).callEvent()) {
++            return false;
++        }
++        // Luminol end
+         // Kaiiju start - sync end platform spawning & entity teleportation
+         final java.util.function.Consumer<Entity> tpComplete = type == PortalType.END && destination.getTypeKey() == net.minecraft.world.level.dimension.LevelStem.END ?
+-              e -> net.minecraft.world.level.levelgen.feature.EndPlatformFeature.createEndPlatform(destination, ServerLevel.END_SPAWN_POINT.below(), true, null) : teleportComplete;
++              e -> { if (new me.earthme.luminol.api.portal.EndPlatformCreateEvent().callEvent() && ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(e.level, ServerLevel.END_SPAWN_POINT.below())) net.minecraft.world.level.levelgen.feature.EndPlatformFeature.createEndPlatform(destination, ServerLevel.END_SPAWN_POINT.below(), true, null); } : teleportComplete; // Luminol - Add missing teleportation events & Fix teleportation api threading issue
+         // Kaiiju end
+ 
+         Vec3 initialPosition = this.position();
+@@ -4570,6 +4636,9 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+                         tpComplete.accept(teleported);
+                     }
+                     // Kaiiju end
++                    // Luminol start - Add missing teleportation events
++                    new me.earthme.luminol.api.entity.PostEntityPortalEvent(teleported.getBukkitEntity()).callEvent();
++                    // Luminol end
+                 }
+             );
+         });
+diff --git a/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java b/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
+index 95e2dff6782bf7767ecb1a23e618862919ea71aa..386c38273e21ba6b48f9fad67fddc39255138e14 100644
+--- a/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
++++ b/net/minecraft/world/level/block/entity/TheEndGatewayBlockEntity.java
+@@ -193,6 +193,18 @@ public class TheEndGatewayBlockEntity extends TheEndPortalBlockEntity {
+             portalTile.trySearchForExit(portalWorld, portalPos);
+             return false;
+         }
++        // Luminol start - Add missing teleportation apis
++        final org.bukkit.Location orginalPortalLocation = io.papermc.paper.util.MCUtil.toLocation(toTeleport.level(), portalPos);
++        final org.bukkit.Location targetPortalLocation = io.papermc.paper.util.MCUtil.toLocation(portalWorld, teleportPos);
++
++        final me.earthme.luminol.api.portal.PortalLocateEvent portalLocateEvent = new me.earthme.luminol.api.portal.PortalLocateEvent(
++                orginalPortalLocation,
++                targetPortalLocation
++        );
++
++        portalLocateEvent.callEvent();
++        // Luminol end
++
+ 
+         // note: we handle the position from the TeleportTransition
+         net.minecraft.world.level.portal.TeleportTransition teleport = net.minecraft.world.level.block.EndGatewayBlock.getTeleportTransition(

luminol-server/minecraft-patches/features/0048-Leaves-Disable-moved-wrongly-threshold.patch

@@ -0,0 +1,47 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: adabugra <57899270+adabugra@users.noreply.github.com>
+Date: Fri, 31 Jan 2025 19:17:01 +0300
+Subject: [PATCH] Leaves Disable moved wrongly threshold
+
+
+diff --git a/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index a107d9ee24d0e39ce3e3e09bf27af1ea4ae35b96..225045400f152a9a8f030d6fe367764b00d99b24 100644
+--- a/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -581,7 +581,7 @@ public class ServerGamePacketListenerImpl
+                     return;
+                 }
+                 // Paper end - Prevent moving into unloaded chunks
+-                if (d7 - d6 > Math.max(100.0, Math.pow((double) (org.spigotmc.SpigotConfig.movedTooQuicklyMultiplier * (float) i * speed), 2)) && !this.isSingleplayerOwner()) {
++                if (!me.earthme.luminol.config.modules.misc.DisableMovedWronglyThreshold.enabled && d7 - d6 > Math.max(100.0, Math.pow((double) (org.spigotmc.SpigotConfig.movedTooQuicklyMultiplier * (float) i * speed), 2)) && !this.isSingleplayerOwner()) { // Leaves - disable can
+                     // CraftBukkit end
+                     LOGGER.warn(
+                         "{} (vehicle of {}) moved too quickly! {},{},{}", rootVehicle.getName().getString(), this.player.getName().getString(), d3, d4, d5
+@@ -611,7 +611,7 @@ public class ServerGamePacketListenerImpl
+                 d5 = d2 - rootVehicle.getZ();
+                 d7 = d3 * d3 + d4 * d4 + d5 * d5;
+                 boolean flag2 = false;
+-                if (d7 > org.spigotmc.SpigotConfig.movedWronglyThreshold) { // Spigot
++                if (!me.earthme.luminol.config.modules.misc.DisableMovedWronglyThreshold.enabled && d7 > org.spigotmc.SpigotConfig.movedWronglyThreshold) { // Spigot / Leaves - disable can
+                     flag2 = true; // Paper - diff on change, this should be moved wrongly
+                     LOGGER.warn("{} (vehicle of {}) moved wrongly! {}", rootVehicle.getName().getString(), this.player.getName().getString(), Math.sqrt(d7));
+                 }
+@@ -1437,7 +1437,7 @@ public class ServerGamePacketListenerImpl
+ 
+                                 if (this.shouldCheckPlayerMovement(isFallFlying)) {
+                                     float f2 = isFallFlying ? 300.0F : 100.0F;
+-                                    if (d7 - d6 > Math.max(f2, Mth.square(org.spigotmc.SpigotConfig.movedTooQuicklyMultiplier * (float) i * speed))) {
++                                    if (!me.earthme.luminol.config.modules.misc.DisableMovedWronglyThreshold.enabled && d7 - d6 > Math.max(f2, Mth.square(org.spigotmc.SpigotConfig.movedTooQuicklyMultiplier * (float) i * speed))) { // Leaves - disable can
+                                         // CraftBukkit end
+                                         // Paper start - Add fail move event
+                                         io.papermc.paper.event.player.PlayerFailMoveEvent event = fireFailMove(io.papermc.paper.event.player.PlayerFailMoveEvent.FailReason.MOVED_TOO_QUICKLY,
+@@ -1509,7 +1509,8 @@ public class ServerGamePacketListenerImpl
+                             d5 = d2 - this.player.getZ();
+                             d7 = d3 * d3 + d4 * d4 + d5 * d5;
+                             boolean movedWrongly = false; // Paper - Add fail move event; rename
+-                            if (!this.player.isChangingDimension()
++                            if (!me.earthme.luminol.config.modules.misc.DisableMovedWronglyThreshold.enabled // Leaves - disable can
++                                && !this.player.isChangingDimension()
+                                 && d7 > org.spigotmc.SpigotConfig.movedWronglyThreshold // Spigot
+                                 && !this.player.isSleeping()
+                                 && !this.player.gameMode.isCreative()

luminol-server/minecraft-patches/features/0049-Leaves-Fix-Incorrect-Collision-Behavior-for-Block-Sh.patch

@@ -0,0 +1,37 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Sat, 8 Feb 2025 14:25:16 +0800
+Subject: [PATCH] Leaves Fix Incorrect Collision Behavior for Block Shape
+
+
+diff --git a/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java b/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java
+index 471b6d49d77e03665ffc269d17ab46f225e3ce1c..c574f9a23868a35ef694e432ba581d2f00e39da7 100644
+--- a/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java
++++ b/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java
+@@ -101,6 +101,14 @@ public final class CollisionUtil {
+                (box1.minZ - box2.maxZ) < -COLLISION_EPSILON && (box1.maxZ - box2.minZ) > COLLISION_EPSILON;
+     }
+ 
++    // Leaves start
++    public static boolean voxelShapeIntersectVanilla(final net.minecraft.world.phys.AABB box1, final net.minecraft.world.phys.AABB box2) {
++        return box1.minX < box2.maxX && box1.maxX > box2.minX &&
++               box1.minY < box2.maxY && box1.maxY > box2.minY &&
++               box1.minZ < box2.maxZ && box1.maxZ > box2.minZ;
++    }
++    // Leaves end
++
+     // assume !isEmpty(target) && abs(source_move) >= COLLISION_EPSILON
+     public static double collideX(final AABB target, final AABB source, final double source_move) {
+         if ((source.minY - target.maxY) < -COLLISION_EPSILON && (source.maxY - target.minY) > COLLISION_EPSILON &&
+@@ -2026,7 +2034,10 @@ public final class CollisionUtil {
+                                     AABB singleAABB = ((CollisionVoxelShape)blockCollision).moonrise$getSingleAABBRepresentation();
+                                     if (singleAABB != null) {
+                                         singleAABB = singleAABB.move((double)blockX, (double)blockY, (double)blockZ);
+-                                        if (!voxelShapeIntersect(aabb, singleAABB)) {
++                                        // Leaves start - Fix incorrect collision behavior for block shape
++                                        boolean isBlockShape = blockCollision == net.minecraft.world.phys.shapes.Shapes.block();
++                                        if (isBlockShape && !voxelShapeIntersectVanilla(aabb, singleAABB) || !isBlockShape && !voxelShapeIntersect(aabb, singleAABB)) {
++                                        // Leaves end - Fix incorrect collision behavior for block shape
+                                             continue;
+                                         }
+ 

luminol-server/minecraft-patches/features/0050-Raytracing-tracker-experiment.patch

@@ -0,0 +1,159 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Wed, 5 Feb 2025 15:22:19 +0800
+Subject: [PATCH] Raytracing tracker experiment
+
+Based on the framework of EntityCulling(((((((
+
+diff --git a/net/minecraft/server/level/ChunkMap.java b/net/minecraft/server/level/ChunkMap.java
+index 7eff847790394aecd058e7a61905da86163b4c6e..9099457f55a2829297ac1db8a69a98ff717d9a86 100644
+--- a/net/minecraft/server/level/ChunkMap.java
++++ b/net/minecraft/server/level/ChunkMap.java
+@@ -1208,7 +1208,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+                 double d1 = vec3_dx * vec3_dx + vec3_dz * vec3_dz; // Paper
+                 double d2 = d * d;
+                 // Paper start - Configurable entity tracking range by Y
+-                boolean flag = d1 <= d2;
++                boolean flag = d1 <= d2 && !entity.isCulled(); // Luminol - Ray tracing entity tracker
+                 if (flag && level.paperConfig().entities.trackingRangeY.enabled) {
+                     double rangeY = level.paperConfig().entities.trackingRangeY.get(this.entity, -1);
+                     if (rangeY != -1) {
+diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
+index ccf1914b4f48ecc0f4fe980510f42d5415ec1daa..ceca76a5791e319dd7cc4048c9860b1df065b95a 100644
+--- a/net/minecraft/world/entity/Entity.java
++++ b/net/minecraft/world/entity/Entity.java
+@@ -135,7 +135,7 @@ import net.minecraft.world.scores.ScoreHolder;
+ import net.minecraft.world.scores.Team;
+ import org.slf4j.Logger;
+ 
+-public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess, ScoreHolder, ca.spottedleaf.moonrise.patches.chunk_system.entity.ChunkSystemEntity, ca.spottedleaf.moonrise.patches.entity_tracker.EntityTrackerEntity {  // Paper - rewrite chunk system // Paper - optimise entity tracker
++public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess, ScoreHolder, ca.spottedleaf.moonrise.patches.chunk_system.entity.ChunkSystemEntity, ca.spottedleaf.moonrise.patches.entity_tracker.EntityTrackerEntity, dev.tr7zw.entityculling.versionless.access.Cullable {  // Paper - rewrite chunk system // Paper - optimise entity tracker // Luminol - Ray tracing entity tracker
+ 
+     // CraftBukkit start
+     private static final int CURRENT_LEVEL = 2;
+@@ -6049,4 +6049,46 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     // Paper end - Expose entity id counter
+ 
+     public boolean shouldTickHot() { return this.tickCount > 20 * 10 && this.isAlive(); } // KioCG
++
++    private long lasttime = 0;
++    private boolean culled = false;
++    private boolean outOfCamera = false;
++
++    @Override
++    public void setTimeout() {
++        this.lasttime = System.currentTimeMillis() + 1000;
++    }
++
++    @Override
++    public boolean isForcedVisible() {
++        return this.lasttime > System.currentTimeMillis();
++    }
++
++    @Override
++    public void setCulled(boolean value) {
++        this.culled = value;
++        if (!value) {
++            setTimeout();
++        }
++    }
++
++    @Override
++    public boolean isCulled() {
++        if (!me.earthme.luminol.config.modules.experiment.RayTrackingEntityTrackerConfig.enabled)
++            return false;
++        return this.culled;
++    }
++
++    @Override
++    public void setOutOfCamera(boolean value) {
++        this.outOfCamera = value;
++    }
++
++    @Override
++    public boolean isOutOfCamera() {
++        if (!me.earthme.luminol.config.modules.experiment.RayTrackingEntityTrackerConfig.enabled)
++            return false;
++        return this.outOfCamera;
++    }
++
+ }
+diff --git a/net/minecraft/world/entity/EntityType.java b/net/minecraft/world/entity/EntityType.java
+index d9cc1d7e56c37d5ce92544edc10e89dbc89dd15d..39e7689be243b9c99b507d665f6591359115287b 100644
+--- a/net/minecraft/world/entity/EntityType.java
++++ b/net/minecraft/world/entity/EntityType.java
+@@ -1097,6 +1097,9 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
+     public final int passengerTickTimerId;
+     public final int passengerInactiveTickTimerId;
+     // Folia end - profiler
++    // Luminol - Raytracing entity tracker
++    public boolean skipRaytracningCheck = false;
++    // Luminol end
+ 
+     public EntityType(
+         EntityType.EntityFactory<T> factory,
+diff --git a/net/minecraft/world/entity/player/Player.java b/net/minecraft/world/entity/player/Player.java
+index c6252a245e9701f69db1fe167f6590095237553a..40b91234fd2e4f4f134d309590ea6b605f764e83 100644
+--- a/net/minecraft/world/entity/player/Player.java
++++ b/net/minecraft/world/entity/player/Player.java
+@@ -211,6 +211,25 @@ public abstract class Player extends LivingEntity {
+         return (org.bukkit.craftbukkit.entity.CraftHumanEntity) super.getBukkitEntity();
+     }
+     // CraftBukkit end
++    // Luminol start - Raytracing entity tracker
++    public dev.tr7zw.entityculling.CullTask cullTask;
++    {
++        if (!me.earthme.luminol.config.modules.experiment.RayTrackingEntityTrackerConfig.enabled) {
++            this.cullTask = null;
++        }else {
++            final com.logisticscraft.occlusionculling.OcclusionCullingInstance culling = new com.logisticscraft.occlusionculling.OcclusionCullingInstance(
++                    me.earthme.luminol.config.modules.experiment.RayTrackingEntityTrackerConfig.tracingDistance,
++                    new dev.tr7zw.entityculling.DefaultChunkDataProvider(this.level())
++            );
++
++            this.cullTask = new dev.tr7zw.entityculling.CullTask(
++                    culling, this,
++                    me.earthme.luminol.config.modules.experiment.RayTrackingEntityTrackerConfig.hitboxLimit,
++                    me.earthme.luminol.config.modules.experiment.RayTrackingEntityTrackerConfig.checkIntervalMs
++            );
++        }
++    }
++    // Luminol end
+ 
+     public Player(Level level, BlockPos pos, float yRot, GameProfile gameProfile) {
+         super(EntityType.PLAYER, level);
+@@ -263,6 +282,26 @@ public abstract class Player extends LivingEntity {
+ 
+     @Override
+     public void tick() {
++        // Luminol start - Ray tracing entity tracker
++        if (!me.earthme.luminol.config.modules.experiment.RayTrackingEntityTrackerConfig.enabled) {
++            if (this.cullTask != null) this.cullTask.signalStop();
++            this.cullTask = null;
++        }else {
++            final com.logisticscraft.occlusionculling.OcclusionCullingInstance culling = new com.logisticscraft.occlusionculling.OcclusionCullingInstance(
++                    me.earthme.luminol.config.modules.experiment.RayTrackingEntityTrackerConfig.tracingDistance,
++                    new dev.tr7zw.entityculling.DefaultChunkDataProvider(this.level())
++            );
++
++            this.cullTask = new dev.tr7zw.entityculling.CullTask(
++                    culling, this,
++                    me.earthme.luminol.config.modules.experiment.RayTrackingEntityTrackerConfig.hitboxLimit,
++                    me.earthme.luminol.config.modules.experiment.RayTrackingEntityTrackerConfig.checkIntervalMs
++            );
++        }
++        if (this.cullTask != null) this.cullTask.setup();
++        if (this.cullTask != null) this.cullTask.requestCullSignal(); // Luminol - Ray tracing entity tracker
++        // Luminol end
++
+         this.noPhysics = this.isSpectator();
+         if (this.isSpectator() || this.isPassenger()) {
+             this.setOnGround(false);
+@@ -1505,6 +1544,7 @@ public abstract class Player extends LivingEntity {
+         if (this.containerMenu != null && this.hasContainerOpen()) {
+             this.doCloseContainer();
+         }
++        if (this.cullTask != null) this.cullTask.signalStop(); // Luminol - Ray tracing entity tracker
+     }
+ 
+     // Folia start - region threading

luminol-server/minecraft-patches/features/0051-Correct-isWatched-method-in-ScheduledTaskThreadPool.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Fri, 4 Apr 2025 08:17:32 +0800
+Subject: [PATCH] Correct isWatched method in ScheduledTaskThreadPool
+
+
+diff --git a/io/papermc/paper/threadedregions/ScheduledTaskThreadPool.java b/io/papermc/paper/threadedregions/ScheduledTaskThreadPool.java
+index 5c591b0d6eac45d6094ce44bf62ad976bf995e66..287d8b929d1c0802705a7ff276e4146682203061 100644
+--- a/io/papermc/paper/threadedregions/ScheduledTaskThreadPool.java
++++ b/io/papermc/paper/threadedregions/ScheduledTaskThreadPool.java
+@@ -1229,7 +1229,7 @@ public final class ScheduledTaskThreadPool {
+         }
+ 
+         public boolean isWatched() {
+-            return (boolean)TAKEN_HANDLE.getVolatile(this);
++            return (boolean)WATCHED_HANDLE.getVolatile(this); // Luminol - Try fixing scheduling call issue
+         }
+ 
+         public long getLastTaskNotify() {

luminol-server/minecraft-patches/features/0052-Leaves-Revert-raid-changes.patch

@@ -0,0 +1,105 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Fri, 11 Apr 2025 16:53:57 +0800
+Subject: [PATCH] Leaves-Revert-raid-changes
+
+
+diff --git a/net/minecraft/world/effect/BadOmenMobEffect.java b/net/minecraft/world/effect/BadOmenMobEffect.java
+index 80f17f33f670018240c854df589cf90cdeab6e70..8672757a4d5fb5c247599782fece6b8d7d6ec921 100644
+--- a/net/minecraft/world/effect/BadOmenMobEffect.java
++++ b/net/minecraft/world/effect/BadOmenMobEffect.java
+@@ -22,6 +22,11 @@ class BadOmenMobEffect extends MobEffect {
+             && !serverPlayer.isSpectator()
+             && level.getDifficulty() != Difficulty.PEACEFUL
+             && level.isVillage(serverPlayer.blockPosition())) {
++            // Leaves start - Revert raid changes
++            if (me.earthme.luminol.config.modules.misc.RaidChangesConfig.trigger) {
++                return level.getRaids().createOrExtendRaid(serverPlayer, serverPlayer.blockPosition()) == null;
++            }
++            // Leaves end - Revert raid changes
+             Raid raidAt = level.getRaidAt(serverPlayer.blockPosition());
+             if (raidAt == null || raidAt.getRaidOmenLevel() < raidAt.getMaxRaidOmenLevel()) {
+                 serverPlayer.addEffect(new MobEffectInstance(MobEffects.RAID_OMEN, 600, amplifier));
+diff --git a/net/minecraft/world/entity/raid/Raid.java b/net/minecraft/world/entity/raid/Raid.java
+index 2f45befbb50645f1bfb5961ad725f3670ff0d592..84c6eb2c27510938f590f6c6baa5a94c4c08c4ad 100644
+--- a/net/minecraft/world/entity/raid/Raid.java
++++ b/net/minecraft/world/entity/raid/Raid.java
+@@ -674,7 +674,7 @@ public class Raid {
+             int i2 = this.center.getX() + Mth.floor(Mth.cos(f2) * 32.0F * f) + this.level.random.nextInt(3) * Mth.floor(f);
+             int i3 = this.center.getZ() + Mth.floor(Mth.sin(f2) * 32.0F * f) + this.level.random.nextInt(3) * Mth.floor(f);
+             int height = this.level.getHeight(Heightmap.Types.WORLD_SURFACE, i2, i3);
+-            if (Mth.abs(height - this.center.getY()) <= 96) {
++            if (me.earthme.luminol.config.modules.misc.RaidChangesConfig.height_check || Mth.abs(height - this.center.getY()) <= 96) { // Disable height check
+                 mutableBlockPos.set(i2, height, i3);
+                 if (!this.level.isVillage(mutableBlockPos) || i <= 7) {
+                     int i4 = 10;
+diff --git a/net/minecraft/world/entity/raid/Raider.java b/net/minecraft/world/entity/raid/Raider.java
+index 7c385baae81b9a987c0e1e4deb017884600331bc..a0d86c3cc86da734a3cd10d554aaecb5c0b82e59 100644
+--- a/net/minecraft/world/entity/raid/Raider.java
++++ b/net/minecraft/world/entity/raid/Raider.java
+@@ -125,6 +125,43 @@ public abstract class Raider extends PatrollingMonster {
+ 
+                 currentRaid.removeFromRaid(this, false);
+             }
++
++            // Leaves start - Revert raid changes
++            if (this.level() instanceof ServerLevel serverLevel) {
++                if (me.earthme.luminol.config.modules.misc.RaidChangesConfig.effect && !this.hasRaid()) {
++                    ItemStack itemstack = this.getItemBySlot(EquipmentSlot.HEAD);
++                    net.minecraft.world.entity.player.Player entityhuman = null;
++                    if (entity instanceof net.minecraft.world.entity.player.Player player) {
++                        entityhuman = player;
++                    } else if (entity instanceof net.minecraft.world.entity.animal.Wolf wolf) {
++                        LivingEntity entityliving = wolf.getOwner();
++                        if (wolf.isTame() && entityliving instanceof net.minecraft.world.entity.player.Player player) {
++                            entityhuman = player;
++                        }
++                    }
++
++                    if (entityhuman != null && !itemstack.isEmpty() && this.isCaptain()) {
++                        net.minecraft.world.effect.MobEffectInstance mobeffect = entityhuman.getEffect(net.minecraft.world.effect.MobEffects.BAD_OMEN);
++                        int i = 1;
++
++                        if (mobeffect != null) {
++                            i += mobeffect.getAmplifier();
++                            entityhuman.removeEffectNoUpdate(net.minecraft.world.effect.MobEffects.BAD_OMEN);
++                            } else {
++                            --i;
++                        }
++
++                        i = net.minecraft.util.Mth.clamp(i, 0, 4);
++                        net.minecraft.world.effect.MobEffectInstance mobeffect1 = new net.minecraft.world.effect.MobEffectInstance(net.minecraft.world.effect.MobEffects.BAD_OMEN, me.earthme.luminol.config.modules.misc.RaidChangesConfig.infinite ? net.minecraft.world.effect.MobEffectInstance.INFINITE_DURATION : 120000, i, false, false, true);
++
++                        if (!serverLevel.getGameRules().getBoolean(net.minecraft.world.level.GameRules.RULE_DISABLE_RAIDS)) {
++                            entityhuman.addEffect(mobeffect1, org.bukkit.event.entity.EntityPotionEffectEvent.Cause.PATROL_CAPTAIN); // CraftBukkit
++                        }
++                        this.setPatrolLeader(false);
++                    }
++                }
++            }
++            // Leaves end - Revert raid changes
+         }
+ 
+         super.die(cause);
+diff --git a/net/minecraft/world/item/component/OminousBottleAmplifier.java b/net/minecraft/world/item/component/OminousBottleAmplifier.java
+index 318f24d67be4daf6993ba547da0540be9c221a75..9a6820fce3977419fd81d802720c318ac15d07c4 100644
+--- a/net/minecraft/world/item/component/OminousBottleAmplifier.java
++++ b/net/minecraft/world/item/component/OminousBottleAmplifier.java
+@@ -28,7 +28,7 @@ public record OminousBottleAmplifier(int value) implements ConsumableListener, T
+ 
+     @Override
+     public void onConsume(Level level, LivingEntity entity, ItemStack stack, Consumable consumable) {
+-        entity.addEffect(new MobEffectInstance(MobEffects.BAD_OMEN, 120000, this.value, false, false, true)); // Paper - properly resend entities - diff on change for below
++        entity.addEffect(new MobEffectInstance(MobEffects.BAD_OMEN, me.earthme.luminol.config.modules.misc.RaidChangesConfig.infinite ? net.minecraft.world.effect.MobEffectInstance.INFINITE_DURATION : 120000, this.value, false, false, true)); // Paper - properly resend entities - diff on change for below
+     }
+ 
+     // Paper start - properly resend entities - collect packets for bundle
+@@ -40,7 +40,7 @@ public record OminousBottleAmplifier(int value) implements ConsumableListener, T
+ 
+     @Override
+     public void addToTooltip(Item.TooltipContext context, Consumer<Component> tooltipAdder, TooltipFlag tooltipFlag) {
+-        List<MobEffectInstance> list = List.of(new MobEffectInstance(MobEffects.BAD_OMEN, 120000, this.value, false, false, true));
++        List<MobEffectInstance> list = List.of(new MobEffectInstance(MobEffects.BAD_OMEN, me.earthme.luminol.config.modules.misc.RaidChangesConfig.infinite ? net.minecraft.world.effect.MobEffectInstance.INFINITE_DURATION : 120000, this.value, false, false, true));
+         PotionContents.addPotionTooltip(list, tooltipAdder, 1.0F, context.tickRate());
+     }
+ }

luminol-server/minecraft-patches/features/0053-Disable-Heightmap-Warning.patch

@@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Sun, 13 Apr 2025 11:07:04 +0800
+Subject: [PATCH] Disable Heightmap Warning
+
+
+diff --git a/net/minecraft/world/level/levelgen/Heightmap.java b/net/minecraft/world/level/levelgen/Heightmap.java
+index 3b27bcfbbe0529d1526adc30760c846b4011645f..95747ae41cea0d4b577c58ef44959a18e0a46672 100644
+--- a/net/minecraft/world/level/levelgen/Heightmap.java
++++ b/net/minecraft/world/level/levelgen/Heightmap.java
+@@ -123,7 +123,8 @@ public class Heightmap {
+         if (raw.length == data.length) {
+             System.arraycopy(data, 0, raw, 0, data.length);
+         } else {
+-            LOGGER.warn("Ignoring heightmap data for chunk " + chunk.getPos() + ", size does not match; expected: " + raw.length + ", got: " + data.length);
++            if (!me.earthme.luminol.config.modules.misc.DisableHeightmapWarnConfig.enabled)
++                LOGGER.warn("Ignoring heightmap data for chunk " + chunk.getPos() + ", size does not match; expected: " + raw.length + ", got: " + data.length);
+             primeHeightmaps(chunk, EnumSet.of(type));
+         }
+     }

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

@@ -5,7 +5,7 @@ Subject: [PATCH] Rebrand to Luminol
 
 
 diff --git a/src/main/java/com/destroystokyo/paper/Metrics.java b/src/main/java/com/destroystokyo/paper/Metrics.java
-index f5ff71e31516327be71924926938f1c9f0e503df..1ea251a202dc6386a110ee515d3329902f14e08e 100644
+index f5ff71e31516327be71924926938f1c9f0e503df..338e61f5cfa0c556245228462df45954ac52bc4f 100644
 --- a/src/main/java/com/destroystokyo/paper/Metrics.java
 +++ b/src/main/java/com/destroystokyo/paper/Metrics.java
 @@ -592,7 +592,7 @@ public class Metrics {
@@ -13,16 +13,21 @@ index f5ff71e31516327be71924926938f1c9f0e503df..1ea251a202dc6386a110ee515d332990
              // Only start Metrics, if it's enabled in the config
              if (config.getBoolean("enabled", true)) {
 -                Metrics metrics = new Metrics("Folia", serverUUID, logFailedRequests, Bukkit.getLogger()); // Folia - we have our own bstats page
-+                Metrics metrics = new Metrics("Luminol", serverUUID, logFailedRequests, Bukkit.getLogger()); // Folia - we have our own bstats page //Luminol
++                Metrics metrics = new Metrics("Luminol", serverUUID, logFailedRequests, Bukkit.getLogger()); // Folia - we have our own bstats page // Luminol
  
                  metrics.addCustomChart(new Metrics.SimplePie("minecraft_version", () -> {
                      String minecraftVersion = Bukkit.getVersion();
-@@ -610,7 +610,7 @@ public class Metrics {
+@@ -606,11 +606,11 @@ public class Metrics {
+                 final String implVersion = org.bukkit.craftbukkit.Main.class.getPackage().getImplementationVersion();
+                 if (implVersion != null) {
+                     final String buildOrHash = implVersion.substring(implVersion.lastIndexOf('-') + 1);
+-                    paperVersion = "git-Folia-%s-%s".formatted(Bukkit.getServer().getMinecraftVersion(), buildOrHash); // Folia - we have our own bstats page
++                    paperVersion = "git-Luminol-%s-%s".formatted(Bukkit.getServer().getMinecraftVersion(), buildOrHash); // Folia - we have our own bstats page // Luminol - Rebrand to Luminol
                  } else {
                      paperVersion = "unknown";
                  }
 -                metrics.addCustomChart(new Metrics.SimplePie("folia_version", () -> paperVersion)); // Folia - we have our own bstats page
-+                metrics.addCustomChart(new Metrics.SimplePie("luminol_version", () -> paperVersion)); // Folia - we have our own bstats page //Luminol
++                metrics.addCustomChart(new Metrics.SimplePie("luminol_version", () -> paperVersion)); // Folia - we have our own bstats page // Luminol
  
                  metrics.addCustomChart(new Metrics.DrilldownPie("java_version", () -> {
                      Map<String, Map<String, Integer>> map = new HashMap<>();

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

@@ -1,6 +1,6 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: MrHua269 <wangxyper@163.com>
-Date: Sun, 12 Jan 2025 10:17:53 +0800
+Date: Tue, 11 Feb 2025 11:58:56 +0800
 Subject: [PATCH] Add config for server mod name
 
 
@@ -17,32 +17,3 @@ index 6ed2114f577ce12d2d493985e798609c7d83f15e..7a5dcf3b7108794b9a224004730eb396
          this.server = server;
      }
  
-diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/ServerModNameConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/ServerModNameConfig.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..94e7c8910e3623163528a844fd7a08b3ffe5826b
---- /dev/null
-+++ b/src/main/java/me/earthme/luminol/config/modules/misc/ServerModNameConfig.java
-@@ -0,0 +1,23 @@
-+package me.earthme.luminol.config.modules.misc;
-+
-+import me.earthme.luminol.config.ConfigInfo;
-+import me.earthme.luminol.config.EnumConfigCategory;
-+import me.earthme.luminol.config.IConfigModule;
-+
-+public class ServerModNameConfig implements IConfigModule {
-+    @ConfigInfo(baseName = "name")
-+    public static String serverModName = "Luminol";
-+
-+    @ConfigInfo(baseName = "vanilla_spoof")
-+    public static boolean fakeVanilla = false;
-+
-+    @Override
-+    public EnumConfigCategory getCategory() {
-+        return EnumConfigCategory.MISC;
-+    }
-+
-+    @Override
-+    public String getBaseName() {
-+        return "server_mod_name";
-+    }
-+}

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

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

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

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

luminol-server/paper-patches/features/0004-Add-tpsbar-with-chunkhot-membar-and-region-bar.patch

@@ -0,0 +1,71 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Sat, 22 Mar 2025 09:24:55 +0800
+Subject: [PATCH] Add tpsbar with chunkhot membar and region bar
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
+index de8b9048c8395c05b8688bc9d984b8ad680f15b3..f42692cd4f0154705c3d5b030d281cfc333803ed 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
+@@ -437,4 +437,12 @@ public class CraftChunk implements Chunk {
+     static {
+         Arrays.fill(FULL_LIGHT, (byte) 0xFF);
+     }
++
++    // KioCG start - ChunkHot
++    @Override
++    public long getChunkHotAvg() {
++        final net.minecraft.world.level.chunk.LevelChunk target = this.worldServer.getChunkIfLoaded(this.x,this.z);
++        return target == null ? -1 : target.getChunkHot().getAverage();
++    }
++    // KioCG end
+ }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 512ef437119041b33b62ef4675bdd1b27fd9a403..628211a282ef0553a0229b6cadacd2727d967873 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -2442,6 +2442,15 @@ 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
++            //Luminol start - Membar
++            getHandle().isMemBarVisible = data.getBoolean("membarVisible");
++            //Luminol end
++            //Luminol start - Regionbar
++            getHandle().isRegionBarVisible = data.getBoolean("regionbarVisible");
++            //Luminol end
+         }
+     }
+ 
+@@ -2463,6 +2472,15 @@ 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
++        //Luminol start - Membar
++        data.putBoolean("membarVisible", handle.isMemBarVisible);
++        //Luminol end
++        //Luminol start - Regionbar
++        data.putBoolean("regionbarVisible", handle.isRegionBarVisible);
++        //Luminol end
+         // Paper start - persist for use in offline save data
+         if (!nbttagcompound.contains("Paper")) {
+             nbttagcompound.put("Paper", new CompoundTag());
+@@ -3672,4 +3690,11 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     public void setSimplifyContainerDesyncCheck(final boolean simplifyContainerDesyncCheck) {
+         this.simplifyContainerDesyncCheck = simplifyContainerDesyncCheck;
+     }
++
++    // KioCG start - ChunkHot
++    @Override
++    public long getNearbyChunkHot() {
++        return this.getHandle().getNearbyChunkHot();
++    }
++    // KioCG end
+ }

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

@@ -18,10 +18,10 @@ index a0b84535a9d3833d4df692b85b272f145559dd80..c2ba46408b5ad727d7a17f21d47b2898
              return;
          }
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 20bcfeef39746d547ef17ccf2b66d44ce1e6e354..e4d7dc84132284af599c2c8d5fe1e63943ab2e0f 100644
+index 935ac76cec67ea661a392ff02396aa7aefd56268..58275b09c75b9913c2249c5c8190027143121070 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -313,7 +313,7 @@ public final class CraftServer implements Server {
+@@ -314,7 +314,7 @@ public final class CraftServer implements Server {
      public static Exception excessiveVelEx; // Paper - Velocity warnings
      private final io.papermc.paper.logging.SysoutCatcher sysoutCatcher = new io.papermc.paper.logging.SysoutCatcher(); // Paper
      private final io.papermc.paper.potion.PaperPotionBrewer potionBrewer; // Paper - Custom Potion Mixes
@@ -30,7 +30,7 @@ index 20bcfeef39746d547ef17ccf2b66d44ce1e6e354..e4d7dc84132284af599c2c8d5fe1e639
  
      // Paper start - Folia region threading API
      private final io.papermc.paper.threadedregions.scheduler.FoliaRegionScheduler regionizedScheduler = new io.papermc.paper.threadedregions.scheduler.FoliaRegionScheduler(); // Folia - region threading
-@@ -491,7 +491,7 @@ public final class CraftServer implements Server {
+@@ -492,7 +492,7 @@ public final class CraftServer implements Server {
          }
          this.potionBrewer = new io.papermc.paper.potion.PaperPotionBrewer(console); // Paper - custom potion mixes
          datapackManager = new io.papermc.paper.datapack.PaperDatapackManager(console.getPackRepository()); // Paper
@@ -39,7 +39,7 @@ index 20bcfeef39746d547ef17ccf2b66d44ce1e6e354..e4d7dc84132284af599c2c8d5fe1e639
      }
  
      public boolean getCommandBlockOverride(String command) {
-@@ -1155,7 +1155,7 @@ public final class CraftServer implements Server {
+@@ -1156,7 +1156,7 @@ public final class CraftServer implements Server {
          this.reloadData();
          org.spigotmc.SpigotConfig.registerCommands(); // Spigot
          io.papermc.paper.command.PaperCommands.registerCommands(this.console); // Paper
@@ -48,7 +48,7 @@ index 20bcfeef39746d547ef17ccf2b66d44ce1e6e354..e4d7dc84132284af599c2c8d5fe1e639
          this.overrideAllCommandBlockCommands = this.commandsConfiguration.getStringList("command-block-overrides").contains("*");
          this.ignoreVanillaPermissions = this.commandsConfiguration.getBoolean("ignore-vanilla-permissions");
  
-@@ -1184,7 +1184,7 @@ public final class CraftServer implements Server {
+@@ -1185,7 +1185,7 @@ public final class CraftServer implements Server {
          this.loadPlugins();
          this.enablePlugins(PluginLoadOrder.STARTUP);
          this.enablePlugins(PluginLoadOrder.POSTWORLD);

luminol-server/paper-patches/features/0006-Purpur-Lobotomize-stuck-villagers.patch

@@ -0,0 +1,22 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Tue, 11 Feb 2025 12:01:39 +0800
+Subject: [PATCH] Purpur Lobotomize stuck villagers
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftVillager.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftVillager.java
+index bd515cdfbcc6fb0d17f70150d8b0bab60949db49..b6038fedea6251226b3b3db0f4b7a1f3d2276ab0 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftVillager.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftVillager.java
+@@ -381,4 +381,11 @@ public class CraftVillager extends CraftAbstractVillager implements Villager {
+         getHandle().getGossips().gossips.clear();
+     }
+     // Paper end
++
++    // Purpur start
++    @Override
++    public boolean isLobotomized() {
++        return getHandle().isLobotomized();
++    }
++    // Purpur end
+ }

luminol-server/paper-patches/features/0007-Purpur-Barrels-and-enderchests-6-rows.patch

@@ -0,0 +1,52 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Suisuroru <qwertyuiop14077@qq.com>
+Date: Thu, 20 Feb 2025 01:00:29 +0800
+Subject: [PATCH] Purpur-Barrels-and-enderchests-6-rows
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftContainer.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftContainer.java
+index 1ce328bed5cf3d087a3f7dc9236153381d758493..20f2b9945eaa58e05b417d9cca7c30dd0496cf72 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftContainer.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftContainer.java
+@@ -145,9 +145,26 @@ public class CraftContainer extends AbstractContainerMenu {
+             case PLAYER:
+             case CHEST:
+             case ENDER_CHEST:
+-            case BARREL:
+-                this.delegate = new ChestMenu(net.minecraft.world.inventory.MenuType.GENERIC_9x3, windowId, bottom, top, top.getContainerSize() / 9);
++                // Purpur start - Barrels and enderchests 6 rows
++                this.delegate = new ChestMenu(switch (me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.enderchestRows) {
++                    case 6 -> net.minecraft.world.inventory.MenuType.GENERIC_9x6;
++                    case 5 -> net.minecraft.world.inventory.MenuType.GENERIC_9x5;
++                    case 4 -> net.minecraft.world.inventory.MenuType.GENERIC_9x4;
++                    case 2 -> net.minecraft.world.inventory.MenuType.GENERIC_9x2;
++                    case 1 -> net.minecraft.world.inventory.MenuType.GENERIC_9x1;
++                    default -> net.minecraft.world.inventory.MenuType.GENERIC_9x3;
++                }, windowId, bottom, top, top.getContainerSize() / 9);
+                 break;
++            case BARREL:
++                this.delegate = new ChestMenu(switch (me.earthme.luminol.config.modules.misc.ContainerExpansionConfig.barrelRows) {
++                    case 6 -> net.minecraft.world.inventory.MenuType.GENERIC_9x6;
++                    case 5 -> net.minecraft.world.inventory.MenuType.GENERIC_9x5;
++                    case 4 -> net.minecraft.world.inventory.MenuType.GENERIC_9x4;
++                    case 2 -> net.minecraft.world.inventory.MenuType.GENERIC_9x2;
++                    case 1 -> net.minecraft.world.inventory.MenuType.GENERIC_9x1;
++                    default -> net.minecraft.world.inventory.MenuType.GENERIC_9x3;
++                    }, windowId, bottom, top, top.getContainerSize() / 9);
++                // Purpur end - Barrels and enderchests 6 rows
+             case DISPENSER:
+             case DROPPER:
+                 this.delegate = new DispenserMenu(windowId, bottom, top);
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
+index c6159c70f7a37b9bffe268b91905ce848d1d2927..1ae08daecb7f072e0afaae327bad64e43c3ae027 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftInventory.java
+@@ -84,7 +84,7 @@ public class CraftInventory implements Inventory {
+ 
+     @Override
+     public void setContents(ItemStack[] items) {
+-        Preconditions.checkArgument(items.length <= this.getSize(), "Invalid inventory size (%s); expected %s or less", items.length, this.getSize());
++    // Preconditions.checkArgument(items.length <= this.getSize(), "Invalid inventory size (%s); expected %s or less", items.length, this.getSize()); // Purpur - Barrels and enderchests 6 rows
+ 
+         for (int i = 0; i < this.getSize(); i++) {
+             if (i >= items.length) {

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

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

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

@@ -1,14 +1,14 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: MrHua269 <wangxyper@163.com>
-Date: Sun, 12 Jan 2025 15:35:44 +0800
+Date: Tue, 11 Feb 2025 11:46:26 +0800
 Subject: [PATCH] SparklyPaper Optimize canSee checks
 
 
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-index d5249c32d397aa5faa31fab6a28edea2da9c57c9..2d3591a4ce3371869e01ccbb66c4c78bfa207105 100644
+index 628211a282ef0553a0229b6cadacd2727d967873..583c2acc6d620b4411c65c2b285d323d7c9c1b98 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
-@@ -208,7 +208,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+@@ -210,7 +210,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>();
@@ -17,7 +17,7 @@ index d5249c32d397aa5faa31fab6a28edea2da9c57c9..2d3591a4ce3371869e01ccbb66c4c78b
      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;
-@@ -2262,9 +2262,16 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+@@ -2306,9 +2306,16 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
  
      @Override
      public boolean canSee(org.bukkit.entity.Entity entity) {

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

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

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

@@ -0,0 +1,41 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Tue, 11 Feb 2025 12:03:38 +0800
+Subject: [PATCH] Leaf Secure seed and matter seed command
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
+index f42692cd4f0154705c3d5b030d281cfc333803ed..39cc976f65f826a00e2e637c139f9134c5e74715 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftChunk.java
+@@ -206,7 +206,12 @@ public class CraftChunk implements Chunk {
+     @Override
+     public boolean isSlimeChunk() {
+         // 987234911L is deterimined in EntitySlime when seeing if a slime can spawn in a chunk
+-        return this.worldServer.paperConfig().entities.spawning.allChunksAreSlimeChunks || WorldgenRandom.seedSlimeChunk(this.getX(), this.getZ(), this.getWorld().getSeed(), worldServer.spigotConfig.slimeSeed).nextInt(10) == 0; // Paper
++        // Leaf start - Matter - Secure Seed
++        boolean isSlimeChunk = me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled
++            ? worldServer.getChunk(this.getX(), this.getZ()).isSlimeChunk()
++            : WorldgenRandom.seedSlimeChunk(this.getX(), this.getZ(), this.getWorld().getSeed(), worldServer.spigotConfig.slimeSeed).nextInt(10) == 0; // Paper
++        return this.worldServer.paperConfig().entities.spawning.allChunksAreSlimeChunks || isSlimeChunk;
++        // Leaf end - Matter - Secure Seed
+     }
+ 
+     @Override
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 58275b09c75b9913c2249c5c8190027143121070..cb406334c316aaf7fc66060b90781eaace883c01 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -1423,7 +1423,11 @@ public final class CraftServer implements Server {
+             registryAccess = levelDataAndDimensions.dimensions().dimensionsRegistryAccess();
+         } else {
+             LevelSettings levelSettings;
+-            WorldOptions worldOptions = new WorldOptions(creator.seed(), creator.generateStructures(), false);
++            // Leaf start - Matter - Secure Seed
++            WorldOptions worldOptions = me.earthme.luminol.config.modules.misc.SecureSeedConfig.enabled
++                ? new WorldOptions(creator.seed(), su.plo.matter.Globals.createRandomWorldSeed(), creator.generateStructures(), false)
++                : new WorldOptions(creator.seed(), creator.generateStructures(), false);
++            // Leaf end - Matter - Secure Seed
+             WorldDimensions worldDimensions;
+ 
+             DedicatedServerProperties.WorldDimensionData properties = new DedicatedServerProperties.WorldDimensionData(GsonHelper.parse((creator.generatorSettings().isEmpty()) ? "{}" : creator.generatorSettings()), creator.type().name().toLowerCase(Locale.ROOT));

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

@@ -0,0 +1,22 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <wangxyper@163.com>
+Date: Tue, 11 Feb 2025 11:46:44 +0800
+Subject: [PATCH] Tick regions api
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index 82d26889661a944e057be0c450fb5a296122ea8e..4f320a91fb8abe21cbb7b01fdc34330def5b2448 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -2517,4 +2517,11 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+         return this.adventure$pointers;
+     }
+     // Paper end
++
++    // Luminol start - Tick regions api
++    @Override
++    public me.earthme.luminol.api.ThreadedRegionizer getThreadedRegionizer() {
++        return new me.earthme.luminol.api.impl.ThreadedRegionizerImpl(this.world);
++    }
++    // Luminol end
+ }

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

@@ -1,37 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MrHua269 <wangxyper@163.com>
-Date: Sun, 12 Jan 2025 10:53:24 +0800
-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..01f8c6ff3662569be5a4ff998bcd4fbbcb555105
---- /dev/null
-+++ b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaSpectorTeleportationFixConfig.java
-@@ -0,0 +1,25 @@
-+package me.earthme.luminol.config.modules.fixes;
-+
-+import me.earthme.luminol.config.ConfigInfo;
-+import me.earthme.luminol.config.EnumConfigCategory;
-+import me.earthme.luminol.config.IConfigModule;
-+
-+public class FoliaSpectorTeleportationFixConfig implements IConfigModule {
-+    @ConfigInfo(baseName = "enabled", comments =
-+            """
-+                    The teleportation of spector players would call absMoveTo directly.\s
-+                    And when the camera teleported to another region,this would call absMoveTo\s
-+                     to let the spector player move to another region without any checks, which \s
-+                    would trigger the async catcher and crash the server""")
-+    public static boolean fixSpectorTeleportFolia = false;
-+
-+    @Override
-+    public EnumConfigCategory getCategory() {
-+        return EnumConfigCategory.FIXES;
-+    }
-+
-+    @Override
-+    public String getBaseName() {
-+        return "folia.fix_spector_teleportation";
-+    }
-+}

luminol-server/paper-patches/features/0020-Set-old-pos-before-moving-entity-by-piston.patch

@@ -1,32 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MrHua269 <wangxyper@163.com>
-Date: Sun, 12 Jan 2025 11:02:07 +0800
-Subject: [PATCH] Set old pos before moving entity by piston
-
-
-diff --git a/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaPistonIssueFixConfig.java b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaPistonIssueFixConfig.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..6edfb1d36a88d319151d28ba14873269736f84b6
---- /dev/null
-+++ b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaPistonIssueFixConfig.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 FoliaPistonIssueFixConfig implements IConfigModule {
-+    @ConfigInfo(baseName = "enabled")
-+    public static boolean enabled = false;
-+
-+    @Override
-+    public EnumConfigCategory getCategory() {
-+        return EnumConfigCategory.FIXES;
-+    }
-+
-+    @Override
-+    public String getBaseName() {
-+        return "folia.fix_piston_moving_issue";
-+    }
-+}

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

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

luminol-server/paper-patches/features/0033-FoliaPR-Add-TPS-From-Region.patch

@@ -1,53 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MrHua269 <wangxyper@163.com>
-Date: Sun, 12 Jan 2025 15:38:13 +0800
-Subject: [PATCH] FoliaPR Add TPS From Region
-
-
-diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index e4d7dc84132284af599c2c8d5fe1e63943ab2e0f..4d39ecd36f9b6caa7696ea1571201cce61f761d9 100644
---- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -3129,6 +3129,42 @@ public final class CraftServer implements Server {
-         };
-     }
- 
-+    // Folia start
-+    @Override
-+    public double[] getTPS(org.bukkit.Location location) {
-+        final int x = location.blockX() >> 4;
-+        final int z = location.blockZ() >> 4;
-+        final ServerLevel world = ((CraftWorld) location.getWorld()).getHandle();
-+        return getTPSFromRegion(world, x, z);
-+    }
-+
-+    @Override
-+    public double[] getTPS(org.bukkit.Chunk chunk) {
-+        final int x = chunk.getX();
-+        final int z = chunk.getZ();
-+        final ServerLevel world = ((CraftWorld) chunk.getWorld()).getHandle();
-+        return getTPSFromRegion(world, x, z);
-+    }
-+
-+    private double[] getTPSFromRegion(ServerLevel world, int x, int z) {
-+        io.papermc.paper.threadedregions.ThreadedRegionizer.ThreadedRegion<io.papermc.paper.threadedregions.TickRegions.TickRegionData, io.papermc.paper.threadedregions.TickRegions.TickRegionSectionData>
-+            region = world.regioniser.getRegionAtSynchronised(x, z);
-+        if (region == null) {
-+            return null;
-+        } else {
-+            io.papermc.paper.threadedregions.TickRegions.TickRegionData regionData = region.getData();
-+            final long currTime = System.nanoTime();
-+            return new double[] {
-+                regionData.getRegionSchedulingHandle().getTickReport5s(currTime).tpsData().segmentAll().average(),
-+                regionData.getRegionSchedulingHandle().getTickReport15s(currTime).tpsData().segmentAll().average(),
-+                regionData.getRegionSchedulingHandle().getTickReport1m(currTime).tpsData().segmentAll().average(),
-+                regionData.getRegionSchedulingHandle().getTickReport5m(currTime).tpsData().segmentAll().average(),
-+                regionData.getRegionSchedulingHandle().getTickReport15m(currTime).tpsData().segmentAll().average(),
-+            };
-+        }
-+    }
-+    // Folia end
-+
-     // Paper start - adventure sounds
-     @Override
-     public void playSound(final net.kyori.adventure.sound.Sound sound) {

luminol-server/paper-patches/files/src/main/java/abomination/IRegionFile.java.patch

@@ -0,0 +1,42 @@
+--- /dev/null
++++ b/src/main/java/abomination/IRegionFile.java
+@@ -1,0 +_,39 @@
++package abomination;
++
++import ca.spottedleaf.moonrise.patches.chunk_system.storage.ChunkSystemRegionFile;
++import net.minecraft.nbt.CompoundTag;
++import net.minecraft.world.level.ChunkPos;
++
++import java.io.DataInputStream;
++import java.io.DataOutputStream;
++import java.io.IOException;
++import java.nio.ByteBuffer;
++import java.nio.file.Path;
++
++public interface IRegionFile extends ChunkSystemRegionFile, AutoCloseable {
++    Path getPath();
++
++    DataInputStream getChunkDataInputStream(ChunkPos pos) throws IOException;
++
++    boolean doesChunkExist(ChunkPos pos) throws Exception;
++
++    DataOutputStream getChunkDataOutputStream(ChunkPos pos) throws IOException;
++
++    void flush() throws IOException;
++
++    void clear(ChunkPos pos) throws IOException;
++
++    boolean hasChunk(ChunkPos pos);
++
++    void close() throws IOException;
++
++    void write(ChunkPos pos, ByteBuffer buf) throws IOException;
++
++    CompoundTag getOversizedData(int x, int z) throws IOException;
++
++    boolean isOversized(int x, int z);
++
++    boolean recalculateHeader() throws IOException;
++
++    void setOversized(int x, int z, boolean oversized) throws IOException;
++}

luminol-server/paper-patches/files/src/main/java/abomination/LinearRegionFile.java.patch

@@ -1,61 +1,6 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: MrHua269 <wangxyper@163.com>
-Date: Sun, 12 Jan 2025 10:49:22 +0800
-Subject: [PATCH] Add configurable region format framework & linear v2 region
- format support
-
-
-diff --git a/src/main/java/abomination/IRegionFile.java b/src/main/java/abomination/IRegionFile.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..fda43a34c89d75e3036f14da3c6efcf157189b22
---- /dev/null
-+++ b/src/main/java/abomination/IRegionFile.java
-@@ -0,0 +1,39 @@
-+package abomination;
-+
-+import ca.spottedleaf.moonrise.patches.chunk_system.storage.ChunkSystemRegionFile;
-+import net.minecraft.nbt.CompoundTag;
-+import net.minecraft.world.level.ChunkPos;
-+
-+import java.io.DataInputStream;
-+import java.io.DataOutputStream;
-+import java.io.IOException;
-+import java.nio.ByteBuffer;
-+import java.nio.file.Path;
-+
-+public interface IRegionFile extends ChunkSystemRegionFile, AutoCloseable {
-+    Path getPath();
-+
-+    DataInputStream getChunkDataInputStream(ChunkPos pos) throws IOException;
-+
-+    boolean doesChunkExist(ChunkPos pos) throws Exception;
-+
-+    DataOutputStream getChunkDataOutputStream(ChunkPos pos) throws IOException;
-+
-+    void flush() throws IOException;
-+
-+    void clear(ChunkPos pos) throws IOException;
-+
-+    boolean hasChunk(ChunkPos pos);
-+
-+    void close() throws IOException;
-+
-+    void write(ChunkPos pos, ByteBuffer buf) throws IOException;
-+
-+    CompoundTag getOversizedData(int x, int z) throws IOException;
-+
-+    boolean isOversized(int x, int z);
-+
-+    boolean recalculateHeader() throws IOException;
-+
-+    void setOversized(int x, int z, boolean oversized) throws IOException;
-+}
-diff --git a/src/main/java/abomination/LinearRegionFile.java b/src/main/java/abomination/LinearRegionFile.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..bb0fcf5f47b5ae3d86e1d0572f951236afdcd017
 --- /dev/null
 +++ b/src/main/java/abomination/LinearRegionFile.java
-@@ -0,0 +1,622 @@
+@@ -1,0 +_,622 @@
 +package abomination;
 +
 +import ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO;
@@ -678,142 +623,3 @@ index 0000000000000000000000000000000000000000..bb0fcf5f47b5ae3d86e1d0572f951236
 +        }
 +    }
 +}
-diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/RegionFormatConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/RegionFormatConfig.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..eb689b6b79143ffaf1eadcba84feca0c632d1407
---- /dev/null
-+++ b/src/main/java/me/earthme/luminol/config/modules/misc/RegionFormatConfig.java
-@@ -0,0 +1,59 @@
-+package me.earthme.luminol.config.modules.misc;
-+
-+import abomination.LinearRegionFile;
-+import com.electronwill.nightconfig.core.file.CommentedFileConfig;
-+import me.earthme.luminol.config.*;
-+import me.earthme.luminol.utils.EnumRegionFormat;
-+import net.minecraft.server.MinecraftServer;
-+
-+public class RegionFormatConfig implements IConfigModule {
-+    @HotReloadUnsupported
-+    @ConfigInfo(baseName = "format")
-+    public static String format = "MCA";
-+    @HotReloadUnsupported
-+    @ConfigInfo(baseName = "linear_compression_level")
-+    public static int linearCompressionLevel = 1;
-+    @HotReloadUnsupported
-+    @ConfigInfo(baseName = "linear_io_thread_count")
-+    public static int linearIoThreadCount = 6;
-+    @HotReloadUnsupported
-+    @ConfigInfo(baseName = "linear_io_flush_delay_ms")
-+    public static int linearIoFlushDelayMs = 100;
-+    @HotReloadUnsupported
-+    @ConfigInfo(baseName = "linear_use_virtual_thread")
-+    public static boolean linearUseVirtualThread = true;
-+
-+    @DoNotLoad
-+    public static EnumRegionFormat regionFormat;
-+
-+    @Override
-+    public EnumConfigCategory getCategory() {
-+        return EnumConfigCategory.MISC;
-+    }
-+
-+    @Override
-+    public String getBaseName() {
-+        return "region_format";
-+    }
-+
-+    @Override
-+    public void onLoaded(CommentedFileConfig configInstance) {
-+        regionFormat = EnumRegionFormat.fromString(format.toUpperCase());
-+
-+        if (regionFormat == null) {
-+            throw new RuntimeException("Invalid region format: " + format);
-+        }
-+
-+        if (regionFormat == EnumRegionFormat.LINEAR_V2) {
-+            if (RegionFormatConfig.linearCompressionLevel > 23 || RegionFormatConfig.linearCompressionLevel < 1) {
-+                MinecraftServer.LOGGER.error("Linear region compression level should be between 1 and 22 in config: {}", RegionFormatConfig.linearCompressionLevel);
-+                MinecraftServer.LOGGER.error("Falling back to compression level 1.");
-+                RegionFormatConfig.linearCompressionLevel = 1;
-+            }
-+
-+            LinearRegionFile.SAVE_DELAY_MS = linearIoFlushDelayMs;
-+            LinearRegionFile.SAVE_THREAD_MAX_COUNT = linearIoThreadCount;
-+            LinearRegionFile.USE_VIRTUAL_THREAD = linearUseVirtualThread;
-+        }
-+    }
-+}
-diff --git a/src/main/java/me/earthme/luminol/utils/EnumRegionFormat.java b/src/main/java/me/earthme/luminol/utils/EnumRegionFormat.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..73b4f9b5f608322839cf1e37fbf1d3a147247c60
---- /dev/null
-+++ b/src/main/java/me/earthme/luminol/utils/EnumRegionFormat.java
-@@ -0,0 +1,40 @@
-+package me.earthme.luminol.utils;
-+
-+import abomination.LinearRegionFile;
-+import me.earthme.luminol.config.modules.misc.RegionFormatConfig;
-+import net.minecraft.world.level.chunk.storage.RegionFile;
-+import org.jetbrains.annotations.Nullable;
-+
-+public enum EnumRegionFormat {
-+    MCA("mca", "mca" , (info) -> new RegionFile(info.info(), info.filePath(), info.folder(), info.sync())),
-+    LINEAR_V2("linear_v2", "linear" ,(info) -> new LinearRegionFile(info.info(), info.filePath(), info.folder(), info.sync(), RegionFormatConfig.linearCompressionLevel));
-+
-+    private final String name;
-+    private final String argument;
-+    private final IRegionCreateFunction creator;
-+
-+    EnumRegionFormat(String name, String argument, IRegionCreateFunction creator) {
-+        this.name = name;
-+        this.argument = argument;
-+        this.creator = creator;
-+    }
-+
-+    @Nullable
-+    public static EnumRegionFormat fromString(String string) {
-+        for (EnumRegionFormat format : values()) {
-+            if (format.name.equalsIgnoreCase(string)) {
-+                return format;
-+            }
-+        }
-+
-+        return null;
-+    }
-+
-+    public IRegionCreateFunction getCreator() {
-+        return this.creator;
-+    }
-+
-+    public String getArgument() {
-+        return this.argument;
-+    }
-+}
-diff --git a/src/main/java/me/earthme/luminol/utils/IRegionCreateFunction.java b/src/main/java/me/earthme/luminol/utils/IRegionCreateFunction.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..fb87ef13803122aa5a2e7f0c578de359140d4f31
---- /dev/null
-+++ b/src/main/java/me/earthme/luminol/utils/IRegionCreateFunction.java
-@@ -0,0 +1,9 @@
-+package me.earthme.luminol.utils;
-+
-+import abomination.IRegionFile;
-+
-+import java.io.IOException;
-+
-+public interface IRegionCreateFunction {
-+    IRegionFile create(RegionCreatorInfo info) throws IOException;
-+}
-diff --git a/src/main/java/me/earthme/luminol/utils/RegionCreatorInfo.java b/src/main/java/me/earthme/luminol/utils/RegionCreatorInfo.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..5af068489646ed70330d8c6242ec88f536c4c289
---- /dev/null
-+++ b/src/main/java/me/earthme/luminol/utils/RegionCreatorInfo.java
-@@ -0,0 +1,7 @@
-+package me.earthme.luminol.utils;
-+
-+import net.minecraft.world.level.chunk.storage.RegionStorageInfo;
-+
-+import java.nio.file.Path;
-+
-+public record RegionCreatorInfo (RegionStorageInfo info, Path filePath, Path folder, boolean sync) {}

luminol-server/paper-patches/files/src/main/java/com/kiocg/ChunkHot.java.patch

@@ -0,0 +1,93 @@
+--- /dev/null
++++ b/src/main/java/com/kiocg/ChunkHot.java
+@@ -1,0 +_,90 @@
++package com.kiocg;
++
++import java.util.Arrays;
++
++public class ChunkHot {
++    // 热度统计总区间数量
++    private static final int TIMES_LENGTH = 10;
++    // 当前统计区间下标
++    private int index = -1;
++
++    // 热度统计区间
++    private final long[] times = new long[TIMES_LENGTH];
++    // 存放临时的区间数值
++    // 用于修正正在统计的当前区间热度没有计入总值的问题
++    private long temp;
++    // 所有区间的热度总值
++    private long total;
++
++    // 用于每个具体统计的计算
++    private long nanos;
++    // 当前统计是否进行中
++    private volatile boolean started = false;
++
++    /**
++     * 更新区间下标
++     */
++    public void nextTick() {
++        this.index = ++this.index % TIMES_LENGTH;
++    }
++
++    /**
++     * 开始统计一个新区间
++     */
++    public void start() {
++        started = true;
++        temp = times[this.index];
++        times[this.index] = 0L;
++    }
++
++    public boolean isStarted(){
++        return this.started;
++    }
++
++    /**
++     * 结束当前区间的统计
++     * 将统计值更新入热度总值
++     */
++    public void stop() {
++        started = false;
++        total -= temp;
++        total += times[this.index];
++    }
++
++    /**
++     * 开始一个具体统计
++     */
++    public void startTicking() {
++        if (!started) return;
++        nanos = System.nanoTime();
++    }
++
++    /**
++     * 结束一个具体统计
++     * 将统计值计入当前热度区间
++     */
++    public void stopTickingAndCount() {
++        if (!started) return;
++        // 定义一个具体统计的最大值为 1,000,000
++        // 有时候某个具体统计的计算值会在某1刻飙升，可能是由于保存数据到磁盘？
++        times[this.index] += Math.min(System.nanoTime() - nanos, 1000000L);
++    }
++
++    /**
++     * 清空统计 (当区块卸载时)
++     */
++    public void clear() {
++        started = false;
++        Arrays.fill(times, 0L);
++        temp = 0L;
++        total = 0L;
++        nanos = 0L;
++    }
++
++    /**
++     * @return 获取区块热度平均值
++     */
++    public long getAverage() {
++        return total / ((long) TIMES_LENGTH * 20L);
++    }
++}

luminol-server/paper-patches/files/src/main/java/com/logisticscraft/occlusionculling/DataProvider.java.patch

@@ -0,0 +1,37 @@
+--- /dev/null
++++ b/src/main/java/com/logisticscraft/occlusionculling/DataProvider.java
+@@ -1,0 +_,34 @@
++package com.logisticscraft.occlusionculling;
++
++import com.logisticscraft.occlusionculling.util.Vec3d;
++
++public interface DataProvider {
++
++    /**
++     * Prepares the requested chunk. Returns true if the chunk is ready, false when
++     * not loaded. Should not reload the chunk when the x and y are the same as the
++     * last request!
++     *
++     * @param chunkX
++     * @param chunkZ
++     * @return
++     */
++    boolean prepareChunk(int chunkX, int chunkZ);
++
++    /**
++     * Location is inside the chunk.
++     *
++     * @param x
++     * @param y
++     * @param z
++     * @return
++     */
++    boolean isOpaqueFullCube(int x, int y, int z);
++
++    default void cleanup() {
++    }
++
++    default void checkingPosition(Vec3d[] targetPoints, int size, Vec3d viewerPosition) {
++    }
++
++}

luminol-server/paper-patches/files/src/main/java/com/logisticscraft/occlusionculling/OcclusionCullingInstance.java.patch

@@ -0,0 +1,518 @@
+--- /dev/null
++++ b/src/main/java/com/logisticscraft/occlusionculling/OcclusionCullingInstance.java
+@@ -1,0 +_,515 @@
++package com.logisticscraft.occlusionculling;
++
++import java.util.Arrays;
++import java.util.BitSet;
++
++import com.logisticscraft.occlusionculling.cache.ArrayOcclusionCache;
++import com.logisticscraft.occlusionculling.cache.OcclusionCache;
++import com.logisticscraft.occlusionculling.util.MathUtilities;
++import com.logisticscraft.occlusionculling.util.Vec3d;
++
++public class OcclusionCullingInstance {
++
++    private static final int ON_MIN_X = 0x01;
++    private static final int ON_MAX_X = 0x02;
++    private static final int ON_MIN_Y = 0x04;
++    private static final int ON_MAX_Y = 0x08;
++    private static final int ON_MIN_Z = 0x10;
++    private static final int ON_MAX_Z = 0x20;
++    
++    private final int reach;
++    private final double aabbExpansion;
++    private final DataProvider provider;
++    private final OcclusionCache cache;
++    
++    // Reused allocated data structures
++    private final BitSet skipList = new BitSet(); // Grows bigger in case some mod introduces giant hitboxes
++    private final Vec3d[] targetPoints = new Vec3d[15];
++    private final Vec3d targetPos = new Vec3d(0, 0, 0);
++    private final int[] cameraPos = new int[3];
++    private final boolean[] dotselectors = new boolean[14];
++    private boolean allowRayChecks = false;
++    private final int[] lastHitBlock = new int[3];
++    private boolean allowWallClipping = false;
++
++
++    public OcclusionCullingInstance(int maxDistance, DataProvider provider) {
++        this(maxDistance, provider, new ArrayOcclusionCache(maxDistance), 0.5);
++    }
++    
++    public OcclusionCullingInstance(int maxDistance, DataProvider provider, OcclusionCache cache, double aabbExpansion) {
++        this.reach = maxDistance;
++        this.provider = provider;
++        this.cache = cache;
++        this.aabbExpansion = aabbExpansion;
++        for(int i = 0; i < targetPoints.length; i++) {
++            targetPoints[i] = new Vec3d(0, 0, 0);
++        }
++    }
++
++    public boolean isAABBVisible(Vec3d aabbMin, Vec3d aabbMax, Vec3d viewerPosition) {
++        try {
++            int maxX = MathUtilities.floor(aabbMax.x
++                 + aabbExpansion);
++            int maxY = MathUtilities.floor(aabbMax.y
++                 + aabbExpansion);
++            int maxZ = MathUtilities.floor(aabbMax.z
++                 + aabbExpansion);
++            int minX = MathUtilities.floor(aabbMin.x
++                 - aabbExpansion);
++            int minY = MathUtilities.floor(aabbMin.y
++                - aabbExpansion);
++            int minZ = MathUtilities.floor(aabbMin.z
++                 - aabbExpansion);
++
++            cameraPos[0] = MathUtilities.floor(viewerPosition.x);
++            cameraPos[1] = MathUtilities.floor(viewerPosition.y);
++            cameraPos[2] = MathUtilities.floor(viewerPosition.z);
++            
++            Relative relX = Relative.from(minX, maxX, cameraPos[0]);
++            Relative relY = Relative.from(minY, maxY, cameraPos[1]);
++            Relative relZ = Relative.from(minZ, maxZ, cameraPos[2]);
++            
++            if(relX == Relative.INSIDE && relY == Relative.INSIDE && relZ == Relative.INSIDE) {
++                return true; // We are inside of the AABB, don't cull
++            }
++            
++            skipList.clear();
++
++            // Just check the cache first
++            int id = 0;
++            for (int x = minX; x <= maxX; x++) {
++                for (int y = minY; y <= maxY; y++) {
++                    for (int z = minZ; z <= maxZ; z++) {
++                        int cachedValue = getCacheValue(x, y, z);
++
++                        if (cachedValue == 1) {
++                            // non-occluding
++                            return true;
++                        }
++
++                        if (cachedValue != 0) {
++                            // was checked and it wasn't visible
++                            skipList.set(id);
++                        }
++                        id++;
++                    }
++                }
++            }
++            
++            // only after the first hit wall the cache becomes valid.
++            allowRayChecks = false;
++            
++            // since the cache wasn't helpfull 
++            id = 0;
++            for (int x = minX; x <= maxX; x++) {
++                byte visibleOnFaceX = 0;
++                byte faceEdgeDataX = 0;
++                faceEdgeDataX |= (x == minX) ? ON_MIN_X : 0;
++                faceEdgeDataX |= (x == maxX) ? ON_MAX_X : 0;
++                visibleOnFaceX |= (x == minX && relX == Relative.POSITIVE) ? ON_MIN_X : 0;
++                visibleOnFaceX |= (x == maxX && relX == Relative.NEGATIVE) ? ON_MAX_X : 0; 
++                for (int y = minY; y <= maxY; y++) {
++                    byte faceEdgeDataY = faceEdgeDataX;
++                    byte visibleOnFaceY = visibleOnFaceX;
++                    faceEdgeDataY |= (y == minY) ? ON_MIN_Y : 0;
++                    faceEdgeDataY |= (y == maxY) ? ON_MAX_Y : 0;
++                    visibleOnFaceY |= (y == minY && relY == Relative.POSITIVE) ? ON_MIN_Y : 0;
++                    visibleOnFaceY |= (y == maxY && relY == Relative.NEGATIVE) ? ON_MAX_Y : 0;
++                    for (int z = minZ; z <= maxZ; z++) {
++                        byte faceEdgeData = faceEdgeDataY;
++                        byte visibleOnFace = visibleOnFaceY;
++                        faceEdgeData |= (z == minZ) ? ON_MIN_Z : 0;
++                        faceEdgeData |= (z == maxZ) ? ON_MAX_Z : 0;
++                        visibleOnFace |= (z == minZ && relZ == Relative.POSITIVE) ? ON_MIN_Z : 0;
++                        visibleOnFace |= (z == maxZ && relZ == Relative.NEGATIVE) ? ON_MAX_Z : 0;
++                        if(skipList.get(id)) { // was checked and it wasn't visible
++                            id++;
++                            continue;
++                        }
++                        
++                        if (visibleOnFace != 0) {
++                            targetPos.set(x, y, z);
++                            if (isVoxelVisible(viewerPosition, targetPos, faceEdgeData, visibleOnFace)) {
++                                return true;
++                            }
++                        }
++                        id++;
++                    }
++                }
++            }
++
++            return false;
++        } catch (Throwable t) {
++            // Failsafe
++            t.printStackTrace();
++        }
++        return true;
++    }
++
++    /**
++     * @param viewerPosition
++     * @param position
++     * @param faceData contains rather this Block is on the outside for a given face
++     * @param visibleOnFace contains rather a face should be concidered
++     * @return
++     */
++    private boolean isVoxelVisible(Vec3d viewerPosition, Vec3d position, byte faceData, byte visibleOnFace) {
++        int targetSize = 0;
++        Arrays.fill(dotselectors, false);
++        if((visibleOnFace & ON_MIN_X) == ON_MIN_X){
++            dotselectors[0] = true;
++            if((faceData & ~ON_MIN_X) != 0) {
++                dotselectors[1] = true;
++                dotselectors[4] = true;
++                dotselectors[5] = true;
++            }
++            dotselectors[8] = true;
++        }
++        if((visibleOnFace & ON_MIN_Y) == ON_MIN_Y){
++            dotselectors[0] = true;
++            if((faceData & ~ON_MIN_Y) != 0) {
++                dotselectors[3] = true;
++                dotselectors[4] = true;
++                dotselectors[7] = true;
++            }
++            dotselectors[9] = true;
++        }
++        if((visibleOnFace & ON_MIN_Z) == ON_MIN_Z){
++            dotselectors[0] = true;
++            if((faceData & ~ON_MIN_Z) != 0) {
++                dotselectors[1] = true;
++                dotselectors[4] = true;
++                dotselectors[5] = true;
++            }
++            dotselectors[10] = true;
++        }
++        if((visibleOnFace & ON_MAX_X) == ON_MAX_X){
++            dotselectors[4] = true;
++            if((faceData & ~ON_MAX_X) != 0) {
++                dotselectors[5] = true;
++                dotselectors[6] = true;
++                dotselectors[7] = true;
++            }
++            dotselectors[11] = true;
++        }
++        if((visibleOnFace & ON_MAX_Y) == ON_MAX_Y){
++            dotselectors[1] = true;
++            if((faceData & ~ON_MAX_Y) != 0) {
++                dotselectors[2] = true;
++                dotselectors[5] = true;
++                dotselectors[6] = true;
++            }
++            dotselectors[12] = true;
++        }
++        if((visibleOnFace & ON_MAX_Z) == ON_MAX_Z){
++            dotselectors[2] = true;
++            if((faceData & ~ON_MAX_Z) != 0) {
++                dotselectors[3] = true;
++                dotselectors[6] = true;
++                dotselectors[7] = true;
++            }
++            dotselectors[13] = true;
++        }
++
++        if (dotselectors[0])targetPoints[targetSize++].setAdd(position, 0.05, 0.05, 0.05);
++        if (dotselectors[1])targetPoints[targetSize++].setAdd(position, 0.05, 0.95, 0.05);
++        if (dotselectors[2])targetPoints[targetSize++].setAdd(position, 0.05, 0.95, 0.95);
++        if (dotselectors[3])targetPoints[targetSize++].setAdd(position, 0.05, 0.05, 0.95);
++        if (dotselectors[4])targetPoints[targetSize++].setAdd(position, 0.95, 0.05, 0.05);
++        if (dotselectors[5])targetPoints[targetSize++].setAdd(position, 0.95, 0.95, 0.05);
++        if (dotselectors[6])targetPoints[targetSize++].setAdd(position, 0.95, 0.95, 0.95);
++        if (dotselectors[7])targetPoints[targetSize++].setAdd(position, 0.95, 0.05, 0.95);
++        // middle points
++        if (dotselectors[8])targetPoints[targetSize++].setAdd(position, 0.05, 0.5, 0.5);
++        if (dotselectors[9])targetPoints[targetSize++].setAdd(position, 0.5, 0.05, 0.5);
++        if (dotselectors[10])targetPoints[targetSize++].setAdd(position, 0.5, 0.5, 0.05);
++        if (dotselectors[11])targetPoints[targetSize++].setAdd(position, 0.95, 0.5, 0.5);
++        if (dotselectors[12])targetPoints[targetSize++].setAdd(position, 0.5, 0.95, 0.5);
++        if (dotselectors[13])targetPoints[targetSize++].setAdd(position, 0.5, 0.5, 0.95);
++
++        return isVisible(viewerPosition, targetPoints, targetSize);
++    }
++
++    private boolean rayIntersection(int[] b, Vec3d rayOrigin, Vec3d rayDir) {
++        Vec3d rInv = new Vec3d(1, 1, 1).div(rayDir);
++
++        double t1 = (b[0] - rayOrigin.x) * rInv.x;
++        double t2 = (b[0] + 1 - rayOrigin.x) * rInv.x;
++        double t3 = (b[1] - rayOrigin.y) * rInv.y;
++        double t4 = (b[1] + 1 - rayOrigin.y) * rInv.y;
++        double t5 = (b[2] - rayOrigin.z) * rInv.z;
++        double t6 = (b[2] + 1 - rayOrigin.z) * rInv.z;
++
++        double tmin = Math.max(Math.max(Math.min(t1, t2), Math.min(t3, t4)), Math.min(t5, t6));
++        double tmax = Math.min(Math.min(Math.max(t1, t2), Math.max(t3, t4)), Math.max(t5, t6));
++
++        // if tmax > 0, ray (line) is intersecting AABB, but the whole AABB is behind us
++        if (tmax > 0) {
++            return false;
++        }
++
++        // if tmin > tmax, ray doesn't intersect AABB
++        if (tmin > tmax) {
++            return false;
++        }
++
++        return true;
++    }
++
++    /**
++     * returns the grid cells that intersect with this Vec3d<br>
++     * <a href=
++     * "http://playtechs.blogspot.de/2007/03/raytracing-on-grid.html">http://playtechs.blogspot.de/2007/03/raytracing-on-grid.html</a>
++     * <p>
++     * Caching assumes that all Vec3d's are inside the same block
++     */
++    private boolean isVisible(Vec3d start, Vec3d[] targets, int size) {
++        // start cell coordinate
++        int x = cameraPos[0];
++        int y = cameraPos[1];
++        int z = cameraPos[2];
++
++        for (int v = 0; v < size; v++) {
++            // ray-casting target
++            Vec3d target = targets[v];
++
++            double relativeX = start.x - target.getX();
++            double relativeY = start.y - target.getY();
++            double relativeZ = start.z - target.getZ();
++
++            if(allowRayChecks && rayIntersection(lastHitBlock, start, new Vec3d(relativeX, relativeY, relativeZ).normalize())) {
++                continue;
++            }
++            
++            // horizontal and vertical cell amount spanned
++            double dimensionX = Math.abs(relativeX);
++            double dimensionY = Math.abs(relativeY);
++            double dimensionZ = Math.abs(relativeZ);
++
++            // distance between horizontal intersection points with cell border as a
++            // fraction of the total Vec3d length
++            double dimFracX = 1f / dimensionX;
++            // distance between vertical intersection points with cell border as a fraction
++            // of the total Vec3d length
++            double dimFracY = 1f / dimensionY;
++            double dimFracZ = 1f / dimensionZ;
++
++            // total amount of intersected cells
++            int intersectCount = 1;
++
++            // 1, 0 or -1
++            // determines the direction of the next cell (horizontally / vertically)
++            int x_inc, y_inc, z_inc;
++
++            // the distance to the next horizontal / vertical intersection point with a cell
++            // border as a fraction of the total Vec3d length
++            double t_next_y, t_next_x, t_next_z;
++
++            if (dimensionX == 0f) {
++                x_inc = 0;
++                t_next_x = dimFracX; // don't increment horizontally because the Vec3d is perfectly vertical
++            } else if (target.x > start.x) {
++                x_inc = 1; // target point is horizontally greater than starting point so increment every
++                // step by 1
++                intersectCount += MathUtilities.floor(target.x) - x; // increment total amount of intersecting cells
++                t_next_x = (float) ((x + 1 - start.x) * dimFracX); // calculate the next horizontal
++                // intersection
++                // point based on the position inside
++                // the first cell
++            } else {
++                x_inc = -1; // target point is horizontally smaller than starting point so reduce every step
++                // by 1
++                intersectCount += x - MathUtilities.floor(target.x); // increment total amount of intersecting cells
++                t_next_x = (float) ((start.x - x)
++                    * dimFracX); // calculate the next horizontal
++                // intersection point
++                // based on the position inside
++                // the first cell
++            }
++
++            if (dimensionY == 0f) {
++                y_inc = 0;
++                t_next_y = dimFracY; // don't increment vertically because the Vec3d is perfectly horizontal
++            } else if (target.y > start.y) {
++                y_inc = 1; // target point is vertically greater than starting point so increment every
++                // step by 1
++                intersectCount += MathUtilities.floor(target.y) - y; // increment total amount of intersecting cells
++                t_next_y = (float) ((y + 1 - start.y)
++                    * dimFracY); // calculate the next vertical
++                // intersection
++                // point based on the position inside
++                // the first cell
++            } else {
++                y_inc = -1; // target point is vertically smaller than starting point so reduce every step
++                // by 1
++                intersectCount += y - MathUtilities.floor(target.y); // increment total amount of intersecting cells
++                t_next_y = (float) ((start.y - y)
++                    * dimFracY); // calculate the next vertical intersection
++                // point
++                // based on the position inside
++                // the first cell
++            }
++
++            if (dimensionZ == 0f) {
++                z_inc = 0;
++                t_next_z = dimFracZ; // don't increment vertically because the Vec3d is perfectly horizontal
++            } else if (target.z > start.z) {
++                z_inc = 1; // target point is vertically greater than starting point so increment every
++                // step by 1
++                intersectCount += MathUtilities.floor(target.z) - z; // increment total amount of intersecting cells
++                t_next_z = (float) ((z + 1 - start.z)
++                    * dimFracZ); // calculate the next vertical
++                // intersection
++                // point based on the position inside
++                // the first cell
++            } else {
++                z_inc = -1; // target point is vertically smaller than starting point so reduce every step
++                // by 1
++                intersectCount += z - MathUtilities.floor(target.z); // increment total amount of intersecting cells
++                t_next_z = (float) ((start.z - z)
++                    * dimFracZ); // calculate the next vertical intersection
++                // point
++                // based on the position inside
++                // the first cell
++            }
++
++            boolean finished = stepRay(start, x, y, z,
++                dimFracX, dimFracY, dimFracZ, intersectCount, x_inc, y_inc,
++                z_inc, t_next_y, t_next_x, t_next_z);
++            provider.cleanup();
++            if (finished) {
++                cacheResult(targets[0], true);
++                return true;
++            } else {
++                allowRayChecks = true;
++            }
++        }
++        cacheResult(targets[0], false);
++        return false;
++    }
++
++    private boolean stepRay(Vec3d start, int currentX, int currentY,
++                            int currentZ, double distInX, double distInY,
++                            double distInZ, int n, int x_inc, int y_inc,
++                            int z_inc, double t_next_y, double t_next_x,
++                            double t_next_z) {
++        allowWallClipping = true; // initially allow rays to go through walls till they are on the outside
++        // iterate through all intersecting cells (n times)
++        for (; n > 1; n--) { // n-1 times because we don't want to check the last block
++            // towards - where from
++
++
++            // get cached value, 0 means uncached (default)
++            int cVal = getCacheValue(currentX, currentY, currentZ);
++
++            if (cVal == 2 && !allowWallClipping) {
++                // block cached as occluding, stop ray
++                lastHitBlock[0] = currentX;
++                lastHitBlock[1] = currentY;
++                lastHitBlock[2] = currentZ;
++                return false;
++            }
++
++            if (cVal == 0) {
++                // save current cell
++                int chunkX = currentX >> 4;
++                int chunkZ = currentZ >> 4;
++
++                if (!provider.prepareChunk(chunkX, chunkZ)) { // Chunk not ready
++                    return false;
++                }
++
++                if (provider.isOpaqueFullCube(currentX, currentY, currentZ)) {
++                    if (!allowWallClipping) {
++                        cache.setLastHidden();
++                        lastHitBlock[0] = currentX;
++                        lastHitBlock[1] = currentY;
++                        lastHitBlock[2] = currentZ;
++                        return false;
++                    }
++                } else {
++                    // outside of wall, now clipping is not allowed
++                    allowWallClipping = false;
++                    cache.setLastVisible();
++                }
++            }
++            
++            if(cVal == 1) {
++                // outside of wall, now clipping is not allowed
++                allowWallClipping = false;
++            }
++
++
++            if (t_next_y < t_next_x && t_next_y < t_next_z) { // next cell is upwards/downwards because the distance to
++                // the next vertical
++                // intersection point is smaller than to the next horizontal intersection point
++                currentY += y_inc; // move up/down
++                t_next_y += distInY; // update next vertical intersection point
++            } else if (t_next_x < t_next_y && t_next_x < t_next_z) { // next cell is right/left
++                currentX += x_inc; // move right/left
++                t_next_x += distInX; // update next horizontal intersection point
++            } else {
++                currentZ += z_inc; // move right/left
++                t_next_z += distInZ; // update next horizontal intersection point
++            }
++
++        }
++        return true;
++    }
++
++    // -1 = invalid location, 0 = not checked yet, 1 = visible, 2 = occluding
++    private int getCacheValue(int x, int y, int z) {
++        x -= cameraPos[0];
++        y -= cameraPos[1];
++        z -= cameraPos[2];
++        if (Math.abs(x) > reach - 2 || Math.abs(y) > reach - 2
++            || Math.abs(z) > reach - 2) {
++            return -1;
++        }
++
++        // check if target is already known
++        return cache.getState(x + reach, y + reach, z + reach);
++    }
++
++    
++    private void cacheResult(int x, int y, int z, boolean result) {
++        int cx = x - cameraPos[0] + reach;
++        int cy = y - cameraPos[1] + reach;
++        int cz = z - cameraPos[2] + reach;
++        if (result) {
++            cache.setVisible(cx, cy, cz);
++        } else {
++            cache.setHidden(cx, cy, cz);
++        }
++    }
++    
++    private void cacheResult(Vec3d vector, boolean result) {
++        int cx = MathUtilities.floor(vector.x) - cameraPos[0] + reach;
++        int cy = MathUtilities.floor(vector.y) - cameraPos[1] + reach;
++        int cz = MathUtilities.floor(vector.z) - cameraPos[2] + reach;
++        if (result) {
++            cache.setVisible(cx, cy, cz);
++        } else {
++            cache.setHidden(cx, cy, cz);
++        }
++    }
++
++    public void resetCache() {
++        this.cache.resetCache();
++    }
++
++    private enum Relative {
++        INSIDE, POSITIVE, NEGATIVE;
++
++        public static Relative from(int min, int max, int pos) {
++            if (max > pos && min > pos) {
++                return POSITIVE;
++            } else if (min < pos && max < pos) {
++                return NEGATIVE;
++            }
++            return INSIDE;
++        }
++    }
++
++}

luminol-server/paper-patches/files/src/main/java/com/logisticscraft/occlusionculling/cache/ArrayOcclusionCache.java.patch

@@ -0,0 +1,60 @@
+--- /dev/null
++++ b/src/main/java/com/logisticscraft/occlusionculling/cache/ArrayOcclusionCache.java
+@@ -1,0 +_,57 @@
++package com.logisticscraft.occlusionculling.cache;
++
++import java.util.Arrays;
++
++public class ArrayOcclusionCache implements OcclusionCache {
++
++    private final int reachX2;
++    private final byte[] cache;
++    private int positionKey;
++    private int entry;
++    private int offset;
++
++    public ArrayOcclusionCache(int reach) {
++        this.reachX2 = reach * 2;
++        this.cache = new byte[(reachX2 * reachX2 * reachX2) / 4];
++    }
++
++    @Override
++    public void resetCache() {
++        Arrays.fill(cache, (byte) 0);
++    }
++
++    @Override
++    public void setVisible(int x, int y, int z) {
++        positionKey = x + y * reachX2 + z * reachX2 * reachX2;
++        entry = positionKey / 4;
++        offset = (positionKey % 4) * 2;
++        cache[entry] |= 1 << offset;
++    }
++
++    @Override
++    public void setHidden(int x, int y, int z) {
++        positionKey = x + y * reachX2 + z * reachX2 * reachX2;
++        entry = positionKey / 4;
++        offset = (positionKey % 4) * 2;
++        cache[entry] |= 1 << offset + 1;
++    }
++
++    @Override
++    public int getState(int x, int y, int z) {
++        positionKey = x + y * reachX2 + z * reachX2 * reachX2;
++        entry = positionKey / 4;
++        offset = (positionKey % 4) * 2;
++        return cache[entry] >> offset & 3;
++    }
++
++    @Override
++    public void setLastVisible() {
++        cache[entry] |= 1 << offset;
++    }
++
++    @Override
++    public void setLastHidden() {
++        cache[entry] |= 1 << offset + 1;
++    }
++
++}

luminol-server/paper-patches/files/src/main/java/com/logisticscraft/occlusionculling/cache/OcclusionCache.java.patch

@@ -0,0 +1,20 @@
+--- /dev/null
++++ b/src/main/java/com/logisticscraft/occlusionculling/cache/OcclusionCache.java
+@@ -1,0 +_,17 @@
++package com.logisticscraft.occlusionculling.cache;
++
++public interface OcclusionCache {
++
++    void resetCache();
++
++    void setVisible(int x, int y, int z);
++
++    void setHidden(int x, int y, int z);
++
++    int getState(int x, int y, int z);
++
++    void setLastHidden();
++
++    void setLastVisible();
++
++}

luminol-server/paper-patches/files/src/main/java/com/logisticscraft/occlusionculling/util/MathUtilities.java.patch

@@ -0,0 +1,28 @@
+--- /dev/null
++++ b/src/main/java/com/logisticscraft/occlusionculling/util/MathUtilities.java
+@@ -1,0 +_,25 @@
++package com.logisticscraft.occlusionculling.util;
++
++/**
++ * Contains MathHelper methods
++ */
++public final class MathUtilities {
++
++    private MathUtilities() {
++    }
++
++    public static int floor(double d) {
++        int i = (int) d;
++        return d < (double) i ? i - 1 : i;
++    }
++
++    public static int fastFloor(double d) {
++        return (int) (d + 1024.0) - 1024;
++    }
++
++    public static int ceil(double d) {
++        int i = (int) d;
++        return d > (double) i ? i + 1 : i;
++    }
++
++}