refactor: organize patches

it fix Leaves#489[https://github.com/LeavesMC/Leaves/issues/489]

.github/workflows/build_1.21.4.yml

@@ -15,39 +15,50 @@ jobs:
     steps:
       - name: Checkout Git Repository
         uses: actions/checkout@v4
+        
       - name: Setup Gradle
         uses: gradle/actions/setup-gradle@v4
+        
       - name: Set up JDK
         uses: actions/setup-java@v4
         with:
           distribution: 'zulu'
           java-version: '22'
+          
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
+        
       - name: Configure Git User Details
         run: git config --global user.email "ci@luminolmc.com" && git config --global user.name "LuminolMC CI"
+        
       - name: Apply Patches
         run: ./gradlew applyAllPatches
+        
       - name: CreateJar
         run: ./gradlew createMojmapPaperclipJar
+        
       - name: Publish to repo
         if: github.event_name != 'pull_request'
         continue-on-error: true
         run: |
-          export MAVEN_REPO_USER=${{ secrets.MAVEN_REPO_USER }}
-          export MAVEN_REPO_PASSWORD=${{ secrets.MAVEN_REPO_PASSWORD }}
-          ./gradlew publish -PpublishDevBundle=true
+          ./gradlew generateDevelopmentBundle publish -PpublishDevBundle=true
+        env:
+          PRIVATE_MAVEN_REPO_PASSWORD: ${{ secrets.PRIVATE_MAVEN_REPO_PASSWORD }}
+          PRIVATE_MAVEN_REPO_USERNAME: ${{ secrets.PRIVATE_MAVEN_REPO_USERNAME }}
+          
       - name: Upload Artifact
-        uses: "actions/upload-artifact@v4"
+        uses: actions/upload-artifact@v4
         with:
           name: "${{ env.project_id_b }} CI Artifacts"
-          path: "luminol-server/build/libs/*-paperclip.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: github.event_name != 'pull_request'
-        uses: ncipollo/release-action@v1.16.0
+        uses: ncipollo/release-action@v1
         with:
           tag: ${{ env.tag }}
           name: ${{ env.project_id_b }} ${{ env.mcversion }} - ${{ env.commit_id }}

README.md

@@ -33,7 +33,7 @@
 ```kotlin
 repositories {
     maven {
-        url = "https://maven.moliatopia.icu/repository/maven-snapshots/"
+        url = "https://repo.menthamc.com/repository/maven-public/"
     }
 }
 
@@ -47,8 +47,8 @@ dependencies {
 ```xml
 <repositories>
     <repository>
-        <id>moliatopia</id>
-        <url>https://maven.moliatopia.icu/repository/maven-snapshots/</url>
+        <id>menthamc</id>
+        <url>https://repo.menthamc.com/repository/maven-public/</url>
     </repository>
 </repositories>
 

README_EN.md

@@ -34,7 +34,7 @@ For gradle:
 ```kotlin
 repositories {
     maven {
-        url = "https://maven.moliatopia.icu/repository/maven-snapshots/"
+        url = "https://repo.menthamc.com/repository/maven-public/"
     }
 }
 
@@ -48,8 +48,8 @@ For maven
 ```xml
 <repositories>
     <repository>
-        <id>moliatopia</id>
-        <url>https://maven.moliatopia.icu/repository/maven-snapshots/</url>
+        <id>menthamc</id>
+        <url>https://repo.menthamc.com/repository/maven-public/</url>
     </repository>
 </repositories>
 

build.gradle.kts

@@ -81,12 +81,22 @@ subprojects {
 
     extensions.configure<PublishingExtension> {
         repositories {
-            /*
-            maven("https://repo.papermc.io/repository/maven-snapshots/") {
-                name = "paperSnapshots"
-                credentials(PasswordCredentials::class)
+            maven("https://repo.menthamc.com/repository/maven-snapshots/") {
+                name = "MenthaMC"
+                credentials(PasswordCredentials::class) {
+                    username = System.getenv("PRIVATE_MAVEN_REPO_USERNAME")
+                    password = System.getenv("PRIVATE_MAVEN_REPO_PASSWORD")
+                }
+            }
+        }
+    }
+
+    tasks.withType<Javadoc> {
+        options {
+            (this as StandardJavadocDocletOptions).apply {
+                addStringOption("-add-modules", "jdk.incubator.vector")
+                addStringOption("Xdoclint:none", "-quiet")
             }
-             */
         }
     }
 }

gradle.properties

@@ -2,7 +2,7 @@ group = me.earthme.luminol
 version=1.21.4-R0.1-SNAPSHOT
 mcVersion=1.21.4
 
-foliaRef=29867414449cede8010bac42dc9bf31dd21eb278
+foliaRef=cd49d650b27aa329358593a84ef77444538ef014
 
 org.gradle.configuration-cache=true
 org.gradle.caching=true

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

@@ -186,10 +186,10 @@ index 0000000000000000000000000000000000000000..ecde4462b08d701b8bff9f26902f1775
 +    RegionStats getRegionStats();
 +}
 diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
-index 015d852d5a0c01042a2153a6916d408660356c59..c7b6f3f6c42746297816c0650571990f565d5e68 100644
+index bff01411f4b2d3ecd9e6d807c3f450d72c108323..1d74f4814d5c87d6cd1320634e5610cac16d32c5 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
+@@ -4437,4 +4437,8 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
              }
          }
      }

luminol-api/paper-patches/features/0008-Leaves-Fix-SculkCatalyst-exp-skip.patch

@@ -0,0 +1,59 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: violetc <58360096+s-yh-china@users.noreply.github.com>
+Date: Sun, 6 Apr 2025 10:42:47 +0800
+Subject: [PATCH] Leaves Fix SculkCatalyst exp skip
+
+
+diff --git a/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java b/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java
+index 42ffb81708b327f765ba3235fdd1ab69cd7589fd..0a7e37420f8d024ffba1fd1c52edc50c10408e6e 100644
+--- a/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java
++++ b/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java
+@@ -25,17 +25,25 @@ public class EntityDeathEvent extends EntityEvent implements org.bukkit.event.Ca
+     private float deathSoundVolume;
+     private float deathSoundPitch;
+     // Paper end
++    private int rewardExp; // Leaves - exp fix
+ 
+     public EntityDeathEvent(@NotNull final LivingEntity entity, @NotNull DamageSource damageSource, @NotNull final List<ItemStack> drops) {
+         this(entity, damageSource, drops, 0);
+     }
+ 
+     public EntityDeathEvent(@NotNull final LivingEntity what, @NotNull DamageSource damageSource, @NotNull final List<ItemStack> drops, final int droppedExp) {
++    // Leaves start - exp fix
++        this(what, damageSource, drops, droppedExp, droppedExp);
++    }
++
++    public EntityDeathEvent(@NotNull final LivingEntity what, @NotNull DamageSource damageSource, @NotNull final List<ItemStack> drops, final int droppedExp, final int rewardExp) {
+         super(what);
+         this.damageSource = damageSource;
+         this.drops = drops;
+         this.dropExp = droppedExp;
++        this.rewardExp = rewardExp;
+     }
++    // Leaves end - exp fix
+ 
+     @NotNull
+     @Override
+@@ -75,6 +83,7 @@ public class EntityDeathEvent extends EntityEvent implements org.bukkit.event.Ca
+      */
+     public void setDroppedExp(int exp) {
+         this.dropExp = exp;
++        this.rewardExp = exp; // Leaves - exp fix
+     }
+ 
+     /**
+@@ -226,4 +235,14 @@ public class EntityDeathEvent extends EntityEvent implements org.bukkit.event.Ca
+         this.deathSoundPitch = pitch;
+     }
+     // Paper end
++
++    // Leaves start - exp fix
++    public int getRewardExp() {
++        return rewardExp;
++    }
++
++    public void setRewardExp(int rewardExp) {
++        this.rewardExp = rewardExp;
++    }
++    // Leaves end - exp fix
+ }

luminol-api/paper-patches/features/0010-Leaves-Fix-SculkCatalyst-exp-skip.patch

@@ -0,0 +1,88 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: violetc <58360096+s-yh-china@users.noreply.github.com>
+Date: Sun, 6 Apr 2025 10:42:47 +0800
+Subject: [PATCH] Fix SculkCatalyst exp skip
+
+
+diff --git a/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java b/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java
+index 42ffb81708b327f765ba3235fdd1ab69cd7589fd..0a7e37420f8d024ffba1fd1c52edc50c10408e6e 100644
+--- a/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java
++++ b/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java
+@@ -25,17 +25,25 @@ public class EntityDeathEvent extends EntityEvent implements org.bukkit.event.Ca
+     private float deathSoundVolume;
+     private float deathSoundPitch;
+     // Paper end
++    private int rewardExp; // Leaves - exp fix
+ 
+     public EntityDeathEvent(@NotNull final LivingEntity entity, @NotNull DamageSource damageSource, @NotNull final List<ItemStack> drops) {
+         this(entity, damageSource, drops, 0);
+     }
+ 
+     public EntityDeathEvent(@NotNull final LivingEntity what, @NotNull DamageSource damageSource, @NotNull final List<ItemStack> drops, final int droppedExp) {
++    // Leaves start - exp fix
++        this(what, damageSource, drops, droppedExp, droppedExp);
++    }
++
++    public EntityDeathEvent(@NotNull final LivingEntity what, @NotNull DamageSource damageSource, @NotNull final List<ItemStack> drops, final int droppedExp, final int rewardExp) {
+         super(what);
+         this.damageSource = damageSource;
+         this.drops = drops;
+         this.dropExp = droppedExp;
++        this.rewardExp = rewardExp;
+     }
++    // Leaves end - exp fix
+ 
+     @NotNull
+     @Override
+@@ -75,6 +83,7 @@ public class EntityDeathEvent extends EntityEvent implements org.bukkit.event.Ca
+      */
+     public void setDroppedExp(int exp) {
+         this.dropExp = exp;
++        this.rewardExp = exp; // Leaves - exp fix
+     }
+ 
+     /**
+@@ -226,4 +235,14 @@ public class EntityDeathEvent extends EntityEvent implements org.bukkit.event.Ca
+         this.deathSoundPitch = pitch;
+     }
+     // Paper end
++
++    // Leaves start - exp fix
++    public int getRewardExp() {
++        return rewardExp;
++    }
++
++    public void setRewardExp(int rewardExp) {
++        this.rewardExp = rewardExp;
++    }
++    // Leaves end - exp fix
+ }
+diff --git a/src/main/java/org/bukkit/event/entity/PlayerDeathEvent.java b/src/main/java/org/bukkit/event/entity/PlayerDeathEvent.java
+index ab7584873e46020148bceecbd42a43055684e6a0..7c99b1c6f5fc8e4ce442d111e7598ddb89d6ee05 100644
+--- a/src/main/java/org/bukkit/event/entity/PlayerDeathEvent.java
++++ b/src/main/java/org/bukkit/event/entity/PlayerDeathEvent.java
+@@ -18,6 +18,7 @@ public class PlayerDeathEvent extends EntityDeathEvent {
+     private boolean keepLevel = false;
+     private boolean keepInventory = false;
+     private boolean doExpDrop; // Paper - shouldDropExperience API
++    private boolean useApiExpDropStatus = false; // Leaves - exp fix
+     // Paper start - adventure
+     @org.jetbrains.annotations.ApiStatus.Internal
+     public PlayerDeathEvent(final @NotNull Player player, final @NotNull DamageSource damageSource, final @NotNull List<ItemStack> drops, final int droppedExp, final @Nullable net.kyori.adventure.text.Component deathMessage) {
+@@ -122,9 +123,16 @@ public class PlayerDeathEvent extends EntityDeathEvent {
+      */
+     public void setShouldDropExperience(boolean doExpDrop) {
+         this.doExpDrop = doExpDrop;
++        this.useApiExpDropStatus = true; // Leaves - exp fix
+     }
+     // Paper end - shouldDropExperience API
+ 
++    // Leaves start - exp fix
++    public boolean forceUseEventDropStatus() {
++        return this.useApiExpDropStatus;
++    }
++    // Leaves end - exp fix
++
+     @NotNull
+     @Override
+     public Player getEntity() {

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

@@ -118,7 +118,7 @@ index f2d2ddfd964bff914e41c0b4150fe1aad7866ebf..7defcd15c44601bfd2f7f55046038693
      }
  
 diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
-index dbf9231b1f01576906b90a3ddf0bf2cbbeb4590a..b17ace9118c94a756fa2901621c6b2b9bd9e5764 100644
+index 42987d278bf4abbad9d63485a1050f4abc3e7367..3bc0fc1d411d3c5e206695510ec9288ffbf8c277 100644
 --- a/net/minecraft/server/level/ServerPlayer.java
 +++ b/net/minecraft/server/level/ServerPlayer.java
 @@ -400,7 +400,9 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc

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

@@ -1,7 +1,7 @@
 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] Configurable tripwire dupe
+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

luminol-server/minecraft-patches/features/0017-Add-config-to-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] Add config to 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/minecraft-patches/features/0018-Add-config-to-revert-raid-changes.patch

@@ -0,0 +1,197 @@
+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] Add config to 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..0d91ae860a5c506c634e88341d958618996cc5bc 100644
+--- a/net/minecraft/world/entity/raid/Raid.java
++++ b/net/minecraft/world/entity/raid/Raid.java
+@@ -325,7 +325,20 @@ public class Raid {
+                         }
+ 
+                         if (flag1) {
+-                            this.waveSpawnPos = this.getValidSpawnPos();
++                            // Luminol Start - Raid revert
++                            if (!me.earthme.luminol.config.modules.misc.RaidChangesConfig.pos_revert) {
++                                this.waveSpawnPos = this.getValidSpawnPos();
++                            } else {
++                                int n4 = 0;
++                                if (this.raidCooldownTicks < 100) {
++                                    n4 = 1;
++                                }
++                                if (this.raidCooldownTicks < 40) {
++                                    n4 = 2;
++                                }
++                                this.waveSpawnPos = this.getValidSpawnPos(n4);
++                            }
++                            // Luminol End - Raid revert
+                         }
+ 
+                         if (this.raidCooldownTicks == 300 || this.raidCooldownTicks % 20 == 0) {
+@@ -360,7 +373,14 @@ public class Raid {
+                 int i = 0;
+ 
+                 while (this.shouldSpawnGroup()) {
+-                    BlockPos blockPos = this.waveSpawnPos.orElseGet(() -> this.findRandomSpawnPos(20));
++                    // Luminol Start - Raid revert
++                    BlockPos blockPos;
++                    if (!me.earthme.luminol.config.modules.misc.RaidChangesConfig.pos_revert) {
++                        blockPos = this.waveSpawnPos.orElseGet(() -> this.findRandomSpawnPos(20));
++                    } else {
++                        blockPos = this.waveSpawnPos.isPresent() ? this.waveSpawnPos.get() : this.findRandomSpawnPos(i, 20);
++                    }
++                    // Luminol End - Raid revert
+                     if (blockPos != null) {
+                         this.started = true;
+                         this.spawnGroup(blockPos);
+@@ -372,7 +392,7 @@ public class Raid {
+                         i++;
+                     }
+ 
+-                    if (i > 5) {
++                    if (i > (me.earthme.luminol.config.modules.misc.RaidChangesConfig.pos_revert ? 3 : 5)) { // Luminol - Raid revert
+                         org.bukkit.craftbukkit.event.CraftEventFactory.callRaidStopEvent(this, org.bukkit.event.raid.RaidStopEvent.Reason.UNSPAWNABLE); // CraftBukkit
+                         this.stop();
+                         break;
+@@ -449,6 +469,17 @@ public class Raid {
+         return blockPos != null ? Optional.of(blockPos) : Optional.empty();
+     }
+ 
++    // Luminol Start - Raid revert
++    private Optional<BlockPos> getValidSpawnPos(int n) {
++        for (int i = 0; i < 3; ++i) {
++            BlockPos blockPos = this.findRandomSpawnPos(n, 1);
++            if (blockPos == null) continue;
++            return Optional.of(blockPos);
++        }
++        return Optional.empty();
++    }
++    // Luminol End - Raid revert
++
+     private boolean hasMoreWaves() {
+         return this.hasBonusWave() ? !this.hasSpawnedBonusWave() : !this.isFinalWave();
+     }
+@@ -674,7 +705,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) { // Leaves - Disable height check
+                 mutableBlockPos.set(i2, height, i3);
+                 if (!this.level.isVillage(mutableBlockPos) || i <= 7) {
+                     int i4 = 10;
+@@ -694,6 +725,26 @@ public class Raid {
+         return null;
+     }
+ 
++    // Luminol Start - Raid revert
++    @Nullable
++    private BlockPos findRandomSpawnPos(int n, int n2) {
++        int n3 = 2 - n;
++        BlockPos.MutableBlockPos mutableBlockPos = new BlockPos.MutableBlockPos();
++        SpawnPlacementType spawnPlacementType = SpawnPlacements.getPlacementType(EntityType.RAVAGER);
++        for (int i = 0; i < n2; ++i) {
++            float f = this.level.random.nextFloat() * ((float)Math.PI * 2);
++            int n4 = this.center.getX() + Mth.floor(Mth.cos(f) * 32.0f * (float)n3) + this.level.random.nextInt(5);
++            int n5 = this.center.getZ() + Mth.floor(Mth.sin(f) * 32.0f * (float)n3) + this.level.random.nextInt(5);
++            int n6 = this.level.getHeight(Heightmap.Types.WORLD_SURFACE, n4, n5);
++            mutableBlockPos.set(n4, n6, n5);
++            if (this.level.isVillage(mutableBlockPos) && n < 2) continue;
++            if (!this.level.hasChunksAt(mutableBlockPos.getX() - 10, mutableBlockPos.getZ() - 10, mutableBlockPos.getX() + 10, mutableBlockPos.getZ() + 10) || !this.level.isPositionEntityTicking(mutableBlockPos) || !spawnPlacementType.isSpawnPositionOk(this.level, mutableBlockPos, EntityType.RAVAGER) && (!this.level.getBlockState((BlockPos)mutableBlockPos.below()).is(Blocks.SNOW) || !this.level.getBlockState(mutableBlockPos).isAir())) continue;
++            return mutableBlockPos;
++        }
++        return null;
++    }
++    // Luminol End - Raid revert
++
+     private boolean addWaveMob(int wave, Raider raider) {
+         return this.addWaveMob(wave, raider, true);
+     }
+diff --git a/net/minecraft/world/entity/raid/Raider.java b/net/minecraft/world/entity/raid/Raider.java
+index 7c385baae81b9a987c0e1e4deb017884600331bc..75a8e0602c249df4b587a454e35f4cd7eab2a25c 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, entityhuman, org.bukkit.event.entity.EntityPotionEffectEvent.Cause.PATROL_CAPTAIN, true, true); // CraftBukkit // Luminol - Raid revert adapt Cross Region Damage trace
++                        }
++                        this.setPatrolLeader(false);
++                    }
++                }
++            }
++            // Leaves end - Revert raid changes
+         }
+ 
+         super.die(cause);
+@@ -153,7 +190,7 @@ public abstract class Raider extends PatrollingMonster {
+     }
+ 
+     public boolean hasRaid() {
+-        return this.level() instanceof ServerLevel serverLevel && (this.getCurrentRaid() != null || serverLevel.getRaidAt(this.blockPosition()) != null);
++        return !me.earthme.luminol.config.modules.misc.RaidChangesConfig.self_check && (this.level() instanceof ServerLevel serverLevel && (this.getCurrentRaid() != null || serverLevel.getRaidAt(this.blockPosition()) != null)); // Leaves - Disable raid self check
+     }
+ 
+     public boolean hasActiveRaid() {
+diff --git a/net/minecraft/world/item/component/OminousBottleAmplifier.java b/net/minecraft/world/item/component/OminousBottleAmplifier.java
+index 318f24d67be4daf6993ba547da0540be9c221a75..5607d2f21131510563f8fdc9079d1145483b11df 100644
+--- a/net/minecraft/world/item/component/OminousBottleAmplifier.java
++++ b/net/minecraft/world/item/component/OminousBottleAmplifier.java
+@@ -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)); // Luminol - Raid effect infinite
+         PotionContents.addPotionTooltip(list, tooltipAdder, 1.0F, context.tickRate());
+     }
+ }

luminol-server/minecraft-patches/features/0019-Add-config-to-enable-tick-command.patch

@@ -0,0 +1,167 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Thu, 1 May 2025 22:43:08 +0800
+Subject: [PATCH] Add config to enable tick command
+
+
+diff --git a/io/papermc/paper/threadedregions/RegionizedServer.java b/io/papermc/paper/threadedregions/RegionizedServer.java
+index 1382c695c4991488b113401e231875ddc74f6b01..68280b07a71dcdb42eaee6f62fbda074813a22e4 100644
+--- a/io/papermc/paper/threadedregions/RegionizedServer.java
++++ b/io/papermc/paper/threadedregions/RegionizedServer.java
+@@ -286,6 +286,11 @@ public final class RegionizedServer {
+         this.randomWalk();
+          */
+         ++this.tickCount;
++        // Luminol start - Add a config to enable tick command
++        if (me.earthme.luminol.config.modules.experiment.CommandTickConfig.enabled) {
++            MinecraftServer.tickRateManager.tick();
++        }
++        // Luminol end - Add a config to enable tick command
+         // expire invalid click command callbacks
+         io.papermc.paper.adventure.providers.ClickCallbackProviderImpl.CALLBACK_MANAGER.handleQueue((int)this.tickCount);
+ 
+@@ -308,6 +313,13 @@ public final class RegionizedServer {
+             this.globalTick(world, tickCount);
+         }
+ 
++        // Luminol start - Add a config to enable tick command
++        if (me.earthme.luminol.config.modules.experiment.CommandTickConfig.enabled) {
++            MinecraftServer.tickRateManager.reduceSprintTicks();
++            MinecraftServer.tickRateManager.endTickWork();
++        }
++        // Luminol end - Add a config to enable tick command
++
+         // tick connections
+         this.tickConnections();
+ 
+@@ -441,7 +453,7 @@ public final class RegionizedServer {
+     }
+ 
+     private void tickTime(final ServerLevel world, final int tickCount) {
+-        if (world.tickTime) {
++        if ((!me.earthme.luminol.config.modules.experiment.CommandTickConfig.enabled || world.tickRateManager().runsNormally()) && world.tickTime) { // Luminol - Add a config to enable tick command
+             if (world.getGameRules().getBoolean(GameRules.RULE_DAYLIGHT)) {
+                 world.setDayTime(world.levelData.getDayTime() + (long)tickCount);
+             }
+diff --git a/io/papermc/paper/threadedregions/TickRegionScheduler.java b/io/papermc/paper/threadedregions/TickRegionScheduler.java
+index 7123b3eb2f2e52946b8ef9de993a6828eb0bb6f7..82948984404a183711588932a4a026dc4c241feb 100644
+--- a/io/papermc/paper/threadedregions/TickRegionScheduler.java
++++ b/io/papermc/paper/threadedregions/TickRegionScheduler.java
+@@ -31,8 +31,8 @@ public final class TickRegionScheduler {
+         }
+     }
+ 
+-    public static final int TICK_RATE = 20;
+-    public static final long TIME_BETWEEN_TICKS = 1_000_000_000L / TICK_RATE; // ns
++    public static float TICK_RATE = 20; // Luminol - Add tick command support
++    public static long TIME_BETWEEN_TICKS = (long) (1_000_000_000L / TICK_RATE); // ns // Luminol - Add tick command support
+ 
+     // Folia start - watchdog
+     public static final FoliaWatchdogThread WATCHDOG_THREAD = new FoliaWatchdogThread();
+@@ -375,8 +375,23 @@ public final class TickRegionScheduler {
+             final long cpuStart = MEASURE_CPU_TIME ? THREAD_MX_BEAN.getCurrentThreadCpuTime() : 0L;
+             final long tickStart = System.nanoTime();
+ 
+-            // use max(), don't assume that tickStart >= scheduledStart
+-            final int tickCount = Math.max(1, this.tickSchedule.getPeriodsAhead(TIME_BETWEEN_TICKS, tickStart));
++            // Luminol start - Add a config to enable tick command
++            final int tickCount;
++            if (me.earthme.luminol.config.modules.experiment.CommandTickConfig.enabled) {
++                if (MinecraftServer.tickRateManager.isSprinting() && MinecraftServer.tickRateManager.checkShouldSprintThisTick()) {
++                    TICK_RATE = net.minecraft.server.commands.TickCommand.MAX_TICKRATE;
++                    TIME_BETWEEN_TICKS = (long) (1_000_000_000L / TICK_RATE);
++                    tickCount = 1;
++                } else {
++                    TICK_RATE = MinecraftServer.tickRateManager.tickrate();
++                    TIME_BETWEEN_TICKS = (long) (1_000_000_000L / TICK_RATE);
++                    tickCount = Math.max(1, this.tickSchedule.getPeriodsAhead(TIME_BETWEEN_TICKS, tickStart));
++                }
++            } else {
++                // use max(), don't assume that tickStart >= scheduledStart
++                tickCount = Math.max(1, this.tickSchedule.getPeriodsAhead(TIME_BETWEEN_TICKS, tickStart));
++            }
++            // Luminol end - Add tick command support
+ 
+             if (!this.tryMarkTicking()) {
+                 if (!this.cancelled.get()) {
+@@ -416,6 +431,11 @@ public final class TickRegionScheduler {
+             try {
+                 // next start isn't updated until the end of this tick
+                 this.tickRegion(tickCount, tickStart, scheduledEnd);
++                // Luminol start - Add a config to enable tick command
++                if (me.earthme.luminol.config.modules.experiment.CommandTickConfig.enabled) {
++                    MinecraftServer.tickRateManager.endTickWork();
++                }
++                // Luminol end - Add a config to enable tick command
+             } catch (final Throwable thr) {
+                 this.scheduler.regionFailed(this, false, thr);
+                 // regionFailed will schedule a shutdown, so we should avoid letting this region tick further
+diff --git a/net/minecraft/commands/Commands.java b/net/minecraft/commands/Commands.java
+index cfb37f2e428605965a37dc1eb83f302fe1bd6299..8f7b28e5688252207ad8ce9f3fb6f9c3b65d1adc 100644
+--- a/net/minecraft/commands/Commands.java
++++ b/net/minecraft/commands/Commands.java
+@@ -213,7 +213,11 @@ public class Commands {
+         //TeamMsgCommand.register(this.dispatcher); // Folia - region threading - TODO later
+         TeleportCommand.register(this.dispatcher);
+         TellRawCommand.register(this.dispatcher, context);
+-        //TickCommand.register(this.dispatcher); // Folia - region threading - TODO later
++        // Luminol start - Add a config to enable tick command
++        if (me.earthme.luminol.config.modules.experiment.CommandTickConfig.enabled) {
++            TickCommand.register(this.dispatcher); // Folia - region threading - TODO later
++        }
++        // Luminol end - Add a config to enable tick command
+         TimeCommand.register(this.dispatcher);
+         TitleCommand.register(this.dispatcher, context);
+         //TriggerCommand.register(this.dispatcher); // Folia - region threading - TODO later
+diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
+index ed00a29daccfee1d631bef27c0a3a4ae83140018..56f5568848d0f20b4d706c07dc8114594e0b5337 100644
+--- a/net/minecraft/server/MinecraftServer.java
++++ b/net/minecraft/server/MinecraftServer.java
+@@ -267,7 +267,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+     private String serverId;
+     public MinecraftServer.ReloadableResources resources;
+     private final StructureTemplateManager structureTemplateManager;
+-    private final ServerTickRateManager tickRateManager;
++    public static ServerTickRateManager tickRateManager; // Luminol - Add tick command support
+     protected WorldData worldData;
+     public PotionBrewing potionBrewing;
+     private FuelValues fuelValues;
+diff --git a/net/minecraft/server/ServerTickRateManager.java b/net/minecraft/server/ServerTickRateManager.java
+index 40338efd1c0e56d869d03f1d0687e7ff0fcbf11a..d0d90a25a10bbecfffceee1992af88c60d14fd87 100644
+--- a/net/minecraft/server/ServerTickRateManager.java
++++ b/net/minecraft/server/ServerTickRateManager.java
+@@ -105,7 +105,7 @@ public class ServerTickRateManager extends TickRateManager {
+             return false;
+         } else if (this.remainingSprintTicks > 0L) {
+             this.sprintTickStartTime = System.nanoTime();
+-            this.remainingSprintTicks--;
++            // this.remainingSprintTicks--; // Luminol - Add tick command support
+             return true;
+         } else {
+             this.finishTickSprint();
+@@ -113,6 +113,12 @@ public class ServerTickRateManager extends TickRateManager {
+         }
+     }
+ 
++    // Luminol start - Add tick command support
++    public void reduceSprintTicks() {
++        this.remainingSprintTicks--;
++    }
++    // Luminol end - Add tick command support
++
+     public void endTickWork() {
+         this.sprintTimeSpend = this.sprintTimeSpend + (System.nanoTime() - this.sprintTickStartTime);
+     }
+diff --git a/net/minecraft/server/commands/TickCommand.java b/net/minecraft/server/commands/TickCommand.java
+index 6b6c8ce49eda6806c8288d70848dd143ba2c4703..5d09d2c8bb45cc10b2a13100793249adc7b5a7e9 100644
+--- a/net/minecraft/server/commands/TickCommand.java
++++ b/net/minecraft/server/commands/TickCommand.java
+@@ -14,7 +14,7 @@ import net.minecraft.server.ServerTickRateManager;
+ import net.minecraft.util.TimeUtil;
+ 
+ public class TickCommand {
+-    private static final float MAX_TICKRATE = 10000.0F;
++    public static final float MAX_TICKRATE = 10000.0F; // Luminol - Add tick command support
+     private static final String DEFAULT_TICKRATE = String.valueOf(20);
+ 
+     public static void register(CommandDispatcher<CommandSourceStack> dispatcher) {

luminol-server/minecraft-patches/features/0024-Correct-player-respawn-place.patch

@@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Sat, 26 Apr 2025 21:47:45 +0800
+Subject: [PATCH] Correct player respawn place
+
+
+diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
+index 3bc0fc1d411d3c5e206695510ec9288ffbf8c277..b6df8df78105e08ca7be82524685d8b9422abf21 100644
+--- a/net/minecraft/server/level/ServerPlayer.java
++++ b/net/minecraft/server/level/ServerPlayer.java
+@@ -472,8 +472,10 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+         double amountX = selectMaxX - selectMinX;
+         double amountZ = selectMaxZ - selectMinZ;
+ 
+-        int selectX = amountX < 1.0 ? Mth.floor(worldBorder.getCenterX()) : (int)Mth.floor((amountX + 1.0) * random.nextDouble() + selectMinX);
+-        int selectZ = amountZ < 1.0 ? Mth.floor(worldBorder.getCenterZ()) : (int)Mth.floor((amountZ + 1.0) * random.nextDouble() + selectMinZ);
++        // Luminol start - Correct player respawn place
++        int selectX = amountX < 0.0 ? Mth.floor(worldBorder.getCenterX()) : (int)Mth.floor(amountX * random.nextDouble() + selectMinX);
++        int selectZ = amountZ < 0.0 ? Mth.floor(worldBorder.getCenterZ()) : (int)Mth.floor(amountZ * random.nextDouble() + selectMinZ);
++        // Luminol end - Correct player respawn place
+ 
+         return new BlockPos(selectX, 0, selectZ);
+     }
+@@ -484,10 +486,20 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+     }
+ 
+     private static BlockPos findSpawnAround(ServerLevel world, ServerPlayer player, BlockPos selected) {
++        // Luminol start - Correct player respawn place
++        BlockPos inChunk;
++        inChunk = PlayerRespawnLogic.getOverworldRespawnPos(world, selected.getX(), selected.getZ());
++        if (inChunk != null) {
++            AABB checkVolume = player.getBoundingBoxAt((double)inChunk.getX() + 0.5, (double)inChunk.getY(), (double)inChunk.getZ() + 0.5);
++            if (player.noCollisionNoLiquid(world, checkVolume)) {
++                return inChunk;
++            }
++        }
++        // Luminol end - Correct player respawn place
+         // try hard to find, so that we don't attempt another chunk load
+         for (int dz = -SPAWN_RADIUS_SELECTION_SEARCH; dz <= SPAWN_RADIUS_SELECTION_SEARCH; ++dz) {
+             for (int dx = -SPAWN_RADIUS_SELECTION_SEARCH; dx <= SPAWN_RADIUS_SELECTION_SEARCH; ++dx) {
+-                BlockPos inChunk = PlayerRespawnLogic.getOverworldRespawnPos(world, selected.getX() + dx, selected.getZ() + dz);
++                inChunk = PlayerRespawnLogic.getOverworldRespawnPos(world, selected.getX() + dx, selected.getZ() + dz); // Luminol - Correct player respawn place
+                 if (inChunk == null) {
+                     continue;
+                 }

luminol-server/minecraft-patches/features/0025-Command-IllegalArgumentException-crash-fix.patch

@@ -0,0 +1,52 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Thu, 24 Apr 2025 20:59:52 +0800
+Subject: [PATCH] Command IllegalArgumentException crash fix
+
+
+diff --git a/net/minecraft/server/commands/FillCommand.java b/net/minecraft/server/commands/FillCommand.java
+index 89154adfc659afa188cd771e70087e3b1a9c98b9..e622f96e6e116bf491bbea39da099e02ceaee502 100644
+--- a/net/minecraft/server/commands/FillCommand.java
++++ b/net/minecraft/server/commands/FillCommand.java
+@@ -210,6 +210,10 @@ public class FillCommand {
+             // Folia start - region threading
+                 } catch (CommandSyntaxException ex) {
+                     sendMessage(source, ex);
++                // Luminol Start - Server crash fix
++                } catch (IllegalArgumentException ex) {
++                    net.minecraft.server.commands.SetBlockCommand.processIAE(source, ex);
++                // Luminol End - Server crash fix
+                 }
+             }); return 0; // Folia end - region threading
+         }
+diff --git a/net/minecraft/server/commands/SetBlockCommand.java b/net/minecraft/server/commands/SetBlockCommand.java
+index 05b824409546ba8bacf7efdaeac106af89ff0715..55911d49c7650b344b46b2cfa9c4ae840ae433c8 100644
+--- a/net/minecraft/server/commands/SetBlockCommand.java
++++ b/net/minecraft/server/commands/SetBlockCommand.java
+@@ -86,6 +86,15 @@ public class SetBlockCommand {
+     }
+     // Folia end - region threading
+ 
++    // Luminol Start - Server crash fix
++    public static void processIAE(CommandSourceStack src, IllegalArgumentException ex) {
++        Component hoverText = Component.translatable("command.failed")
++                .withStyle(style -> style.withHoverEvent(new net.minecraft.network.chat.HoverEvent(net.minecraft.network.chat.HoverEvent.Action.SHOW_TEXT, Component.literal(ex.getMessage()))));
++        src.sendFailure(hoverText);
++        com.mojang.logging.LogUtils.getLogger().error(ex.getMessage(), ex);
++    }
++    // Luminol end - Server crash fix
++
+     private static int setBlock(
+         CommandSourceStack source, BlockPos pos, BlockInput state, SetBlockCommand.Mode mode, @Nullable Predicate<BlockInWorld> predicate
+     ) throws CommandSyntaxException {
+@@ -119,6 +128,10 @@ public class SetBlockCommand {
+         // Folia start - region threading
+                 } catch (CommandSyntaxException ex) {
+                     sendMessage(source, ex);
++                // Luminol Start - Server crash fix
++                } catch (IllegalArgumentException ex) {
++                    processIAE(source, ex);
++                // Luminol End - Server crash fix
+                 }
+             });
+         return 1;

luminol-server/minecraft-patches/features/0026-Creative-Item-Pick-Fix.patch

@@ -0,0 +1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Sat, 10 May 2025 19:46:16 +0800
+Subject: [PATCH] Creative Item Pick Fix
+
+
+diff --git a/net/minecraft/world/entity/item/ItemEntity.java b/net/minecraft/world/entity/item/ItemEntity.java
+index 7587130e021d494ae5013f7992b8f3c96590cbd7..17432ab5f9bb966e573e2d1177254df5c8958e48 100644
+--- a/net/minecraft/world/entity/item/ItemEntity.java
++++ b/net/minecraft/world/entity/item/ItemEntity.java
+@@ -435,7 +435,13 @@ public class ItemEntity extends Entity implements TraceableEntity {
+             Item item1 = item.getItem();
+             int count = item.getCount();
+             // CraftBukkit start - fire PlayerPickupItemEvent
+-            int canHold = entity.getInventory().canHold(item);
++            int canHold;
++            if (entity instanceof net.minecraft.server.level.ServerPlayer
++                    && ((net.minecraft.server.level.ServerPlayer) entity).gameMode.getGameModeForPlayer().equals(net.minecraft.world.level.GameType.CREATIVE)) {
++                canHold = count;
++            } else {
++                canHold = entity.getInventory().canHold(item);
++            }
+             int remaining = count - canHold;
+             boolean flyAtPlayer = false; // Paper
+ 

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

@@ -5,7 +5,7 @@ Subject: [PATCH] Force disable builtin spark plugin
 
 
 diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index ed00a29daccfee1d631bef27c0a3a4ae83140018..330af9f4de1c72387326816065350e71fe546efe 100644
+index 56f5568848d0f20b4d706c07dc8114594e0b5337..e62e8b9af7ad3e4454702ac86ad2b27973eba66f 100644
 --- a/net/minecraft/server/MinecraftServer.java
 +++ b/net/minecraft/server/MinecraftServer.java
 @@ -783,8 +783,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa

luminol-server/minecraft-patches/features/0030-Fix-incorrectly-synced-data-after-player-teleportati.patch

@@ -0,0 +1,33 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Fri, 2 May 2025 12:03:14 +0800
+Subject: [PATCH] Fix incorrectly synced data after player teleportation
+
+
+diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
+index b6df8df78105e08ca7be82524685d8b9422abf21..10e3a54f3e7aa02a5c9986d3694c02bef07a66bf 100644
+--- a/net/minecraft/server/level/ServerPlayer.java
++++ b/net/minecraft/server/level/ServerPlayer.java
+@@ -1812,14 +1812,20 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+             this.connection.send(new ClientboundChangeDifficultyPacket(
+                 worlddata.getDifficulty(), worlddata.isDifficultyLocked()
+             ));
+-            this.connection.send(new ClientboundSetExperiencePacket(
++            /*this.connection.send(new ClientboundSetExperiencePacket( // Luminol start - teleportAsync tweaks, will send in next tick, see the changes below
+                 this.experienceProgress, this.totalExperience, this.experienceLevel
+-            ));
++            ));*/ // Luminol end
+ 
+             playerlist.sendActivePlayerEffects(this);
+             playerlist.sendLevelInfo(this, destination);
+             playerlist.sendPlayerPermissionLevel(this);
+ 
++            // Luminol start - teleportAsync tweaks
++            this.lastSentExp = -1;
++            this.lastSentHealth = -1.0F;
++            this.lastSentFood = -1;
++            // Luminol end
++
+             // regular world add logic
+             this.unsetRemoved();
+             destination.addDuringTeleport(this);

luminol-server/minecraft-patches/features/0031-Fix-off-tickregion-sync-teleport.patch

@@ -0,0 +1,42 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Thu, 24 Apr 2025 23:11:13 +0800
+Subject: [PATCH] Fix off tickregion sync teleport
+
+
+diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
+index 4026d465687604965f105ded21a8206fd52bd375..771744d4540fcd163efcde43c27111680b25c928 100644
+--- a/net/minecraft/world/entity/Entity.java
++++ b/net/minecraft/world/entity/Entity.java
+@@ -4060,6 +4060,21 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         this.resetStoredPositions();
+     }
+ 
++    // Luminol start - Fix sync teleport issue
++    private boolean checkNearbyTickRegions(int destX, int destZ) {
++        // Dumb end gateway search the chunks in radius of 5 chunks, so we need keep 6(5+1) by default check radius
++        int sizeBx = Math.min(6, (int) (this.bb.maxX - this.bb.minX) + this.level.getCraftServer().getSimulationDistance());
++        int sizeBz = Math.min(6, (int) (this.bb.maxZ - this.bb.minZ) + this.level.getCraftServer().getSimulationDistance());
++
++        // check tick thread around these area
++        return ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(this.level,
++                (destX >> 4) - sizeBx,
++                (destZ >> 4) - sizeBz,
++                (destX >> 4) + sizeBx,
++                (destZ >> 4) + sizeBz);
++    }
++    // Luminol end
++
+     protected final void transform(TeleportTransition telpeort) {
+         PositionMoveRotation move = PositionMoveRotation.calculateAbsolute(
+             PositionMoveRotation.of(this), PositionMoveRotation.of(telpeort), telpeort.relatives()
+@@ -4157,7 +4172,8 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         // check for same region
+         if (destination == this.level()) {
+             Vec3 currPos = this.position();
+-            if (
++            // Luminol - Prevent entity sync teleported to the edge of tickregion
++            if (this.checkNearbyTickRegions((int) pos.x, (int) pos.z) && // Luminol - Fix sync teleport issue
+                 destination.regioniser.getRegionAtUnsynchronised(
+                     ca.spottedleaf.moonrise.common.util.CoordinateUtils.getChunkX(currPos), ca.spottedleaf.moonrise.common.util.CoordinateUtils.getChunkZ(currPos)
+                 ) == destination.regioniser.getRegionAtUnsynchronised(

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

@@ -5,10 +5,10 @@ Subject: [PATCH] Kaiiju Vanilla end portal teleportation
 
 
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index 4026d465687604965f105ded21a8206fd52bd375..8ec2b94add58d64d9b83d632427923720ec74990 100644
+index 771744d4540fcd163efcde43c27111680b25c928..2efc715857d49f69a8289bcf50f422960c00c8bd 100644
 --- a/net/minecraft/world/entity/Entity.java
 +++ b/net/minecraft/world/entity/Entity.java
-@@ -4275,14 +4275,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4291,14 +4291,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) -> {
@@ -31,7 +31,7 @@ index 4026d465687604965f105ded21a8206fd52bd375..8ec2b94add58d64d9b83d63242792372
                                      TeleportTransition.PLAY_PORTAL_SOUND.then(TeleportTransition.PLACE_PORTAL_TICKET),
                                      org.bukkit.event.player.PlayerTeleportEvent.TeleportCause.END_PORTAL
                                  )
-@@ -4297,11 +4301,15 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4313,11 +4317,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);
@@ -49,7 +49,7 @@ index 4026d465687604965f105ded21a8206fd52bd375..8ec2b94add58d64d9b83d63242792372
                                      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
+@@ -4495,6 +4503,10 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
          if (!this.canPortalAsync(destination, takePassengers)) {
              return false;
          }
@@ -60,7 +60,7 @@ index 4026d465687604965f105ded21a8206fd52bd375..8ec2b94add58d64d9b83d63242792372
  
          Vec3 initialPosition = this.position();
          ChunkPos initialPositionChunk = new ChunkPos(
-@@ -4543,9 +4555,14 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4559,9 +4571,14 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
                          info.postTeleportTransition().onTransition(teleported);
                      }
  

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

@@ -1,11 +1,11 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Suisuroru <qwertyuiop14077@qq.com>
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
 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 27478c973dc2e9ea2495f5b27127ef085bc5cdf3..9777a5b7ba9916e426ba87d6ee7cd56f0e43c195 100644
+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 {
@@ -20,7 +20,7 @@ index 27478c973dc2e9ea2495f5b27127ef085bc5cdf3..9777a5b7ba9916e426ba87d6ee7cd56f
  
      public boolean isWhiteListed(GameProfile profile) {
 diff --git a/net/minecraft/world/entity/player/Player.java b/net/minecraft/world/entity/player/Player.java
-index ad34d0e1ab16fb269b3cec2842bfc2f2c29b452e..40b91234fd2e4f4f134d309590ea6b605f764e83 100644
+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 {

luminol-server/minecraft-patches/features/0044-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 8ec2b94add58d64d9b83d632427923720ec74990..3ad00cc095588574218ca6d729ead119403202e0 100644
+index 2efc715857d49f69a8289bcf50f422960c00c8bd..18e6e9fe39a559ae043fdafcf4e4db467144e309 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 8ec2b94add58d64d9b83d632427923720ec74990..3ad00cc095588574218ca6d729ead119
          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");
-@@ -5045,6 +5052,11 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -5061,6 +5068,11 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
      }
  
      public final void setBoundingBox(AABB bb) {

luminol-server/minecraft-patches/features/0047-Gale-Faster-chunk-serialization.patch

@@ -0,0 +1,216 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Bacteriawa <A3167717663@hotmail.com>
+Date: Wed, 30 Nov 2022 21:51:16 +0100
+Subject: [PATCH] Gale Faster chunk serialization
+
+
+diff --git a/net/minecraft/util/BitStorage.java b/net/minecraft/util/BitStorage.java
+index 02502d50f0255f5bbcc0ecb965abb48cc1a112da..322a1ba06d6aed44ec67dc3f1831ac6b05c82fe0 100644
+--- a/net/minecraft/util/BitStorage.java
++++ b/net/minecraft/util/BitStorage.java
+@@ -21,6 +21,8 @@ public interface BitStorage extends ca.spottedleaf.moonrise.patches.block_counti
+ 
+     BitStorage copy();
+ 
++    <T> void compact(net.minecraft.world.level.chunk.Palette<T> srcPalette, net.minecraft.world.level.chunk.Palette<T> dstPalette, short[] out); // Gale - Lithium - faster chunk serialization
++
+     // Paper start - block counting
+     // provide default impl in case mods implement this...
+     @Override
+diff --git a/net/minecraft/util/SimpleBitStorage.java b/net/minecraft/util/SimpleBitStorage.java
+index e6306a68c8652d4c5d22d5ecb1416f5f931f76ee..2a3d34733b61c73729daa4da61f33e2c2e7b6c72 100644
+--- a/net/minecraft/util/SimpleBitStorage.java
++++ b/net/minecraft/util/SimpleBitStorage.java
+@@ -465,4 +465,36 @@ public class SimpleBitStorage implements BitStorage {
+             super(message);
+         }
+     }
++
++    // Gale start - Lithium - faster chunk serialization
++    @Override
++    public <T> void compact(net.minecraft.world.level.chunk.Palette<T> srcPalette, net.minecraft.world.level.chunk.Palette<T> dstPalette, short[] out) {
++        if (this.size >= Short.MAX_VALUE) throw new IllegalStateException("Array too large");
++        if (this.size != out.length) throw new IllegalStateException("Array size mismatch");
++
++        short[] mappings = new short[(int) (this.mask + 1)];
++
++        int idx = 0;
++
++        for (long word : this.data) {
++            long bits = word;
++
++            for (int elementIdx = 0; elementIdx < this.valuesPerLong; ++elementIdx) {
++                int value = (int) (bits & this.mask);
++                int remappedId = mappings[value];
++
++                if (remappedId == 0) {
++                    remappedId = dstPalette.idFor(srcPalette.valueFor(value)) + 1;
++                    mappings[value] = (short) remappedId;
++                }
++
++                out[idx] = (short) (remappedId - 1);
++                bits >>= this.bits;
++
++                ++idx;
++
++                if (idx >= this.size) return;
++            }
++        }
++    } // Gale end - Lithium - faster chunk serialization
+ }
+diff --git a/net/minecraft/util/ZeroBitStorage.java b/net/minecraft/util/ZeroBitStorage.java
+index 09fd99c9cbd23b5f3c899bfb00c9b89651948ed8..90a85a00c6208d2db65cafb164cd95e6128b6dc4 100644
+--- a/net/minecraft/util/ZeroBitStorage.java
++++ b/net/minecraft/util/ZeroBitStorage.java
+@@ -19,6 +19,8 @@ public class ZeroBitStorage implements BitStorage {
+         return 0;
+     }
+ 
++    @Override public <T> void compact(net.minecraft.world.level.chunk.Palette<T> srcPalette, net.minecraft.world.level.chunk.Palette<T> dstPalette, short[] out) {}  // Gale - Lithium - faster chunk serialization
++
+     @Override
+     public final void set(int index, int value) { // Paper - Perf: Optimize SimpleBitStorage
+         //Validate.inclusiveBetween(0L, (long)(this.size - 1), (long)index); // Paper - Perf: Optimize SimpleBitStorage
+diff --git a/net/minecraft/world/level/chunk/PaletteResize.java b/net/minecraft/world/level/chunk/PaletteResize.java
+index c723606fa0be811e580ba47de8c9c575583cc930..60d3176477c201643e1657751fcffad511b2994f 100644
+--- a/net/minecraft/world/level/chunk/PaletteResize.java
++++ b/net/minecraft/world/level/chunk/PaletteResize.java
+@@ -1,5 +1,5 @@
+ package net.minecraft.world.level.chunk;
+ 
+-interface PaletteResize<T> {
++public interface PaletteResize<T> {  // Gale - Lithium - faster chunk serialization - package -> public
+     int onResize(int bits, T objectAdded);
+ }
+diff --git a/net/minecraft/world/level/chunk/PalettedContainer.java b/net/minecraft/world/level/chunk/PalettedContainer.java
+index f5da433050fd3060e0335d4002d520ebe8cd691f..5a6e699df0a177ea6a919cad609a508678bff823 100644
+--- a/net/minecraft/world/level/chunk/PalettedContainer.java
++++ b/net/minecraft/world/level/chunk/PalettedContainer.java
+@@ -25,6 +25,21 @@ import net.minecraft.util.ThreadingDetector;
+ import net.minecraft.util.ZeroBitStorage;
+ 
+ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainerRO<T> {
++    // Gale start - Lithium - faster chunk serialization
++    private static final ThreadLocal<short[]> CACHED_ARRAY_4096 = ThreadLocal.withInitial(() -> new short[4096]);
++    private static final ThreadLocal<short[]> CACHED_ARRAY_64 = ThreadLocal.withInitial(() -> new short[64]);
++    private Optional<LongStream> asOptional(long[] data) {
++        return Optional.of(Arrays.stream(data));
++    }
++    private short[] getOrCreate(int size) {
++        return switch (size) {
++            case 64 -> CACHED_ARRAY_64.get();
++            case 4096 -> CACHED_ARRAY_4096.get();
++            default -> new short[size];
++        };
++    }
++    // Gale end - Lithium - faster chunk serialization
++
+     private static final int MIN_PALETTE_BITS = 0;
+     private final PaletteResize<T> dummyPaletteResize = (bits, objectAdded) -> 0;
+     public final IdMap<T> registry;
+@@ -344,28 +359,53 @@ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainer
+     public synchronized PalettedContainerRO.PackedData<T> pack(IdMap<T> registry, PalettedContainer.Strategy strategy) { // Paper - synchronize
+         this.acquire();
+ 
+-        PalettedContainerRO.PackedData var12;
++        // Gale start - Lithium - faster chunk serialization
++        Optional<LongStream> data = Optional.empty();
++        List<T> elements = null;
+         try {
+-            HashMapPalette<T> hashMapPalette = new HashMapPalette<>(registry, this.data.storage.getBits(), this.dummyPaletteResize);
+-            int size = strategy.size();
+-            int[] ints = new int[size];
+-            this.data.storage.unpack(ints);
+-            swapPalette(ints, id -> hashMapPalette.idFor(this.data.palette.valueFor(id)));
+-            int i = strategy.calculateBitsForSerialization(registry, hashMapPalette.getSize());
+-            Optional<LongStream> optional;
+-            if (i != 0) {
+-                SimpleBitStorage simpleBitStorage = new SimpleBitStorage(i, size, ints);
+-                optional = Optional.of(Arrays.stream(simpleBitStorage.getRaw()));
+-            } else {
+-                optional = Optional.empty();
++            // The palette that will be serialized
++            net.caffeinemc.mods.lithium.common.world.chunk.LithiumHashPalette<T> hashPalette = null;
++
++            final Palette<T> palette = this.data.palette();
++            final BitStorage storage = this.data.storage();
++            if (storage instanceof ZeroBitStorage || palette.getSize() == 1) {
++                // If the palette only contains one entry, don't attempt to repack it.
++                elements = List.of(palette.valueFor(0));
++            } else if (palette instanceof net.caffeinemc.mods.lithium.common.world.chunk.LithiumHashPalette<T> lithiumHashPalette) {
++                hashPalette = lithiumHashPalette;
+             }
+ 
+-            var12 = new PalettedContainerRO.PackedData<>(hashMapPalette.getEntries(), optional);
++            if (elements == null) {
++                var compactedPalette = new net.caffeinemc.mods.lithium.common.world.chunk.LithiumHashPalette<>(registry, storage.getBits(), this.dummyPaletteResize);
++                short[] array = this.getOrCreate(strategy.size());
++
++                storage.compact(this.data.palette(), compactedPalette, array);
++
++                // If the palette didn't change during compaction, do a simple copy of the data array
++                if (hashPalette != null && hashPalette.getSize() == compactedPalette.getSize() && storage.getBits() == strategy.calculateBitsForSerialization(registry, hashPalette.getSize())) { // paletteSize can de-sync from palette - see https://github.com/CaffeineMC/lithium-fabric/issues/279
++                    data = this.asOptional(storage.getRaw().clone());
++                    elements = hashPalette.getElements();
++                } else {
++                    int bits = strategy.calculateBitsForSerialization(registry, compactedPalette.getSize());
++                    if (bits != 0) {
++                        // Re-pack the integer array as the palette has changed size
++                        SimpleBitStorage copy = new SimpleBitStorage(bits, array.length);
++                        for (int i = 0; i < array.length; ++i)
++                            copy.set(i, array[i]);
++
++                        // We don't need to clone the data array as we are the sole owner of it
++                        data = this.asOptional(copy.getRaw());
++                    }
++
++                    elements = compactedPalette.getElements();
++                }
++            }
+         } finally {
+             this.release();
+         }
+ 
+-        return var12;
++        return new PalettedContainerRO.PackedData<>(elements, data);
++        // Gale end - Lithium - faster chunk serialization
+     }
+ 
+     private static <T> void swapPalette(int[] bits, IntUnaryOperator operator) {
+@@ -405,13 +445,30 @@ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainer
+ 
+     @Override
+     public void count(PalettedContainer.CountConsumer<T> countConsumer) {
+-        if (this.data.palette.getSize() == 1) {
+-            countConsumer.accept(this.data.palette.valueFor(0), this.data.storage.getSize());
+-        } else {
+-            Int2IntOpenHashMap map = new Int2IntOpenHashMap();
+-            this.data.storage.getAll(id -> map.addTo(id, 1));
+-            map.int2IntEntrySet().forEach(idEntry -> countConsumer.accept(this.data.palette.valueFor(idEntry.getIntKey()), idEntry.getIntValue()));
++        // Gale start - Lithium - faster chunk serialization
++        int len = this.data.palette().getSize();
++
++        // Do not allocate huge arrays if we're using a large palette
++        if (len > 4096) {
++            // VanillaCopy
++            if (this.data.palette.getSize() == 1) {
++                countConsumer.accept(this.data.palette.valueFor(0), this.data.storage.getSize());
++            } else {
++                Int2IntOpenHashMap map = new Int2IntOpenHashMap();
++                this.data.storage.getAll(id -> map.addTo(id, 1));
++                map.int2IntEntrySet().forEach(idEntry -> countConsumer.accept(this.data.palette.valueFor(idEntry.getIntKey()), idEntry.getIntValue()));
++            }
++        }
++        short[] counts = new short[len];
++        this.data.storage().getAll(i -> counts[i]++);
++
++        for (int i = 0; i < counts.length; i++) {
++            T obj = this.data.palette().valueFor(i);
++
++            if (obj != null)
++                countConsumer.accept(obj, counts[i]);
+         }
++        // Gale end - Lithium - faster chunk serialization
+     }
+ 
+     record Configuration<T>(Palette.Factory factory, int bits) {

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

@@ -1,105 +0,0 @@
-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/0051-Leaf-Remove-useless-creating-stats-json-bases-on-pla.patch

@@ -6,10 +6,10 @@ Subject: [PATCH] Leaf Remove useless creating stats json bases on player name
 
 
 diff --git a/net/minecraft/server/players/PlayerList.java b/net/minecraft/server/players/PlayerList.java
-index 751b011701d6ae373099226ea63ffbafcd24ce6a..27478c973dc2e9ea2495f5b27127ef085bc5cdf3 100644
+index e5e946462da9e56344428139768075b7bd228ec0..9777a5b7ba9916e426ba87d6ee7cd56f0e43c195 100644
 --- a/net/minecraft/server/players/PlayerList.java
 +++ b/net/minecraft/server/players/PlayerList.java
-@@ -1416,6 +1416,8 @@ public abstract class PlayerList {
+@@ -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");
@@ -18,7 +18,7 @@ index 751b011701d6ae373099226ea63ffbafcd24ce6a..27478c973dc2e9ea2495f5b27127ef08
              if (!file1.exists()) {
                  File file2 = new File(file, displayName + ".json"); // CraftBukkit
                  Path path = file2.toPath();
-@@ -1423,6 +1425,8 @@ public abstract class PlayerList {
+@@ -1427,6 +1429,8 @@ public abstract class PlayerList {
                      file2.renameTo(file1);
                  }
              }

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

@@ -5,10 +5,10 @@ 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
+index 10e3a54f3e7aa02a5c9986d3694c02bef07a66bf..ca67950e35c7f420846337e885d95b8eabca3f37 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
+@@ -1673,6 +1673,9 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
                      if (respawnComplete != null) {
                          respawnComplete.accept(ServerPlayer.this);
                      }
@@ -19,10 +19,10 @@ index b17ace9118c94a756fa2901621c6b2b9bd9e5764..8a728a3af515da522cd5fab1e731bbc0
              );
          });
 diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
-index 3ad00cc095588574218ca6d729ead119403202e0..ccf1914b4f48ecc0f4fe980510f42d5415ec1daa 100644
+index 18e6e9fe39a559ae043fdafcf4e4db467144e309..2ea6160492cb23e96271dfbfd3bd35fe03109d6a 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
+@@ -4175,6 +4175,31 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
          }
  
          // TODO any events that can modify go HERE
@@ -54,7 +54,7 @@ index 3ad00cc095588574218ca6d729ead119403202e0..ccf1914b4f48ecc0f4fe980510f42d54
  
          // check for same region
          if (destination == this.level()) {
-@@ -4276,7 +4301,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4292,7 +4317,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) {
@@ -74,7 +74,7 @@ index 3ad00cc095588574218ca6d729ead119403202e0..ccf1914b4f48ecc0f4fe980510f42d54
                      // 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
+@@ -4317,7 +4353,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
                          }
                      );
                  } else {
@@ -94,7 +94,7 @@ index 3ad00cc095588574218ca6d729ead119403202e0..ccf1914b4f48ecc0f4fe980510f42d54
                      // need to load chunk for heightmap
                      destination.moonrise$loadChunksAsync(
                          spawnPos, 0,
-@@ -4356,8 +4403,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4372,8 +4419,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());
@@ -114,7 +114,7 @@ index 3ad00cc095588574218ca6d729ead119403202e0..ccf1914b4f48ecc0f4fe980510f42d54
                  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
+@@ -4510,9 +4567,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
          if (!this.canPortalAsync(destination, takePassengers)) {
              return false;
          }
@@ -134,7 +134,7 @@ index 3ad00cc095588574218ca6d729ead119403202e0..ccf1914b4f48ecc0f4fe980510f42d54
          // Kaiiju end
  
          Vec3 initialPosition = this.position();
-@@ -4570,6 +4636,9 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -4586,6 +4652,9 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
                          tpComplete.accept(teleported);
                      }
                      // Kaiiju end

luminol-server/minecraft-patches/features/0055-Portal-Behavior-Modifiers.patch

@@ -0,0 +1,142 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Sun, 27 Apr 2025 14:26:01 +0800
+Subject: [PATCH] Portal Behavior Modifiers
+
+
+diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
+index d8e1febfa14be1c0f4869ae647bd17113660432b..9b8325a55889155766e034ff8847751ac551b2d2 100644
+--- a/net/minecraft/server/level/ServerLevel.java
++++ b/net/minecraft/server/level/ServerLevel.java
+@@ -1353,7 +1353,26 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+         if (levelChunk != null) levelChunk.getChunkHot().startTicking(); try { // KioCG
+         try {
+         // Folia end - profiler
++        // Luminol start - Entity portal-teleport speed fix
+         if (isActive) { // Paper - EAR 2
++            if (!(entity instanceof Player) && entity.flag_portal && entity.flag_compensate_ticks) { // Luminol - after portal compensate tick
++                entity.tick();
++                entity.tick();
++                entity.flag_compensate_ticks = false;
++                if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(entity)) {
++                    return;
++                }
++                if (entity.handlePortal()) {
++                    return;
++                }
++            } else if (!(entity instanceof Player) && entity.flag_portal) { // Luminol - portal teleport only
++                if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(entity)) {
++                    return;
++                }
++                if (entity.handlePortal()) {
++                    return;
++                }
++            } else {
+         entity.tick();
+         // Folia start - region threading
+         if (!ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(entity)) {
+@@ -1364,6 +1383,8 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+             // portalled
+             return;
+         }
++        }
++        // Luminol end - Entity portal-teleport speed fix
+         // Folia end - region threading
+         } else {entity.inactiveTick();} // Paper - EAR 2
+         profilerFiller.pop();
+diff --git a/net/minecraft/world/entity/Entity.java b/net/minecraft/world/entity/Entity.java
+index 2ea6160492cb23e96271dfbfd3bd35fe03109d6a..97879ba5080db09dde7cd76fe7b0ba502d8df572 100644
+--- a/net/minecraft/world/entity/Entity.java
++++ b/net/minecraft/world/entity/Entity.java
+@@ -343,6 +343,10 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     public long activatedTick = Integer.MIN_VALUE;
+     public boolean isTemporarilyActive;
+     public long activatedImmunityTick = Integer.MIN_VALUE;
++    // Luminol start - Entity portal-teleport speed fix
++    public boolean flag_portal = false;
++    public boolean flag_compensate_ticks = false;
++    // Luminol end - Entity portal-teleport speed fix
+ 
+     public void inactiveTick() {
+     }
+@@ -3305,6 +3309,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         } else {
+             if (this.portalProcess == null || !this.portalProcess.isSamePortal(portal)) {
+                 this.portalProcess = new PortalProcessor(portal, pos.immutable());
++                this.flag_portal = true; // Luminol - Entity portal-teleport speed fix
+             } else if (!this.portalProcess.isInsidePortalThisTick()) {
+                 this.portalProcess.updateEntryPosition(pos.immutable());
+                 this.portalProcess.setAsInsidePortalThisTick(true);
+@@ -3829,20 +3834,27 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+ 
+             EntityTreeNode curr;
+             while ((curr = queue.pollFirst()) != null) {
+-                EntityTreeNode[] passengers = curr.passengers;
++                restore(curr); // Luminol - EndGateway Portal Passengers Fix
++            }
++        }
++
++        // Luminol Start - EndGateway Portal Passengers Fix
++        private EntityTreeNode[] restore(EntityTreeNode entity) {
++                EntityTreeNode[] passengers = entity.passengers;
+                 if (passengers == null) {
+-                    continue;
++                    return null;
+                 }
+ 
+                 List<Entity> newPassengers = new java.util.ArrayList<>();
+                 for (EntityTreeNode passenger : passengers) {
++                    passenger.passengers = restore(passenger);
+                     newPassengers.add(passenger.root);
+-                    passenger.root.vehicle = curr.root;
++                    passenger.root.vehicle = entity.root;
+                 }
+-
+-                curr.root.passengers = ImmutableList.copyOf(newPassengers);
+-            }
++                entity.root.passengers = ImmutableList.copyOf(newPassengers);
++                return passengers;
+         }
++        // Luminol End - EndGateway Portal Passengers Fix
+ 
+         public void addTracker() {
+             for (final EntityTreeNode node : this.getFullTree()) {
+@@ -4561,6 +4573,13 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+ 
+     }
+ 
++    // Luminol start - Add afterPortalLogic
++    protected void afterPortalLogic() {
++        this.flag_compensate_ticks  = true; // Luminol - Entity portal-teleport speed fix
++        this.flag_portal = false; // Luminol - Entity portal-teleport speed fix
++    }
++    // Luminol end - Add afterPortalLogic
++
+     protected boolean portalToAsync(ServerLevel destination, BlockPos portalPos, boolean takePassengers,
+                                     PortalType type, java.util.function.Consumer<Entity> teleportComplete) {
+         ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread(this, "Cannot portal entity async");
+@@ -4644,6 +4663,8 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+                         info.postTeleportTransition().onTransition(teleported);
+                     }
+ 
++                    teleported.afterPortalLogic(); // Luminol - Add afterPortalLogic
++
+                     // Kaiiju start - vanilla end teleportation
+                     /*if (teleportComplete != null) {
+                         teleportComplete.accept(teleported);
+diff --git a/net/minecraft/world/entity/item/PrimedTnt.java b/net/minecraft/world/entity/item/PrimedTnt.java
+index 88570bb4aa02896545805d7721c45cf9599befea..f2d9ef4429b56785fd9d95abb9d734901d589828 100644
+--- a/net/minecraft/world/entity/item/PrimedTnt.java
++++ b/net/minecraft/world/entity/item/PrimedTnt.java
+@@ -251,4 +251,11 @@ public class PrimedTnt extends Entity implements TraceableEntity {
+         return !this.level().paperConfig().fixes.preventTntFromMovingInWater && super.isPushedByFluid();
+     }
+     // Paper end - Option to prevent TNT from moving in water
++
++    // Luminol start - Add afterPortalLogic
++    protected void afterPortalLogic() {
++        this.setUsedPortal(true);
++        super.afterPortalLogic();
++    }
++    // Luminol end - Add afterPortalLogic
+ }

luminol-server/minecraft-patches/features/0058-Leaves-Fix-SculkCatalyst-exp-skip.patch

@@ -0,0 +1,78 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: violetc <58360096+s-yh-china@users.noreply.github.com>
+Date: Sun, 6 Apr 2025 10:42:45 +0800
+Subject: [PATCH] Leaves Fix SculkCatalyst exp skip
+
+
+diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
+index ca67950e35c7f420846337e885d95b8eabca3f37..d9ea3db817878ff56a2772ce983ff95431e1326c 100644
+--- a/net/minecraft/server/level/ServerPlayer.java
++++ b/net/minecraft/server/level/ServerPlayer.java
+@@ -1358,7 +1358,7 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+         }
+ 
+         // SPIGOT-5478 must be called manually now
+-        if (event.shouldDropExperience()) this.dropExperience(this.serverLevel(), cause.getEntity()); // Paper - tie to event
++        if (shouldDropExperience(event.shouldDropExperience(), event.forceUseEventDropStatus())) this.dropExperience(this.serverLevel(), cause.getEntity()); // Paper - tie to event // Leaves - exp fix
+         // we clean the player's inventory after the EntityDeathEvent is called so plugins can get the exact state of the inventory.
+         if (!event.getKeepInventory()) {
+             // Paper start - PlayerDeathEvent#getItemsToKeep
+@@ -1392,6 +1392,15 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+         this.setClientLoaded(false);
+     }
+ 
++    // Leaves start - exp fix
++    private boolean shouldDropExperience(boolean eventResult, boolean forceUseEvent) {
++        if (forceUseEvent) {
++            return eventResult;
++        }
++        return wasExperienceConsumed() ? false : eventResult;
++    }
++    // Leaves end - exp fix
++
+     private void tellNeutralMobsThatIDied() {
+         AABB aabb = new AABB(this.blockPosition()).inflate(32.0, 10.0, 32.0);
+         this.level()
+diff --git a/net/minecraft/world/entity/LivingEntity.java b/net/minecraft/world/entity/LivingEntity.java
+index 2293c3db45e9ecce4e0d4b2f87b8e90228e44d94..658aa09aecf8d64145feedb82dc9be2a55201450 100644
+--- a/net/minecraft/world/entity/LivingEntity.java
++++ b/net/minecraft/world/entity/LivingEntity.java
+@@ -293,6 +293,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+     protected float appliedScale = 1.0F;
+     // CraftBukkit start
+     public int expToDrop;
++    public int expToReward; // Leaves - exp fix
+     public ArrayList<DefaultDrop> drops = new ArrayList<>(); // Paper - Restore vanilla drops behavior
+     public final org.bukkit.craftbukkit.attribute.CraftAttributeMap craftAttributes;
+     public boolean collides = true;
+@@ -1761,6 +1762,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+                         entity.killedEntity((ServerLevel) this.level(), this);
+                     }
+                     this.gameEvent(GameEvent.ENTITY_DIE);
++                    if (!this.wasExperienceConsumed()) this.dropExperience((ServerLevel) this.level(), damageSource.getEntity()); // Leaves - exp fix
+                 } else {
+                     this.dead = false;
+                     this.setHealth((float) deathEvent.getReviveHealth());
+@@ -1835,7 +1837,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+         this.drops = new ArrayList<>();
+         // this.dropEquipment(level); // CraftBukkit - moved up
+         // CraftBukkit end
+-        this.dropExperience(level, damageSource.getEntity());
++        // this.dropExperience(level, damageSource.getEntity()); // Leaves - exp fix
+         return deathEvent; // Paper
+     }
+ 
+diff --git a/net/minecraft/world/level/block/entity/SculkCatalystBlockEntity.java b/net/minecraft/world/level/block/entity/SculkCatalystBlockEntity.java
+index bd6693af6412fb08a28ca9a71d5c70d54f72c6e6..8c2e35d087150fb0fc67c7457a4af9298f4b41e1 100644
+--- a/net/minecraft/world/level/block/entity/SculkCatalystBlockEntity.java
++++ b/net/minecraft/world/level/block/entity/SculkCatalystBlockEntity.java
+@@ -96,8 +96,7 @@ public class SculkCatalystBlockEntity extends BlockEntity implements GameEventLi
+         public boolean handleGameEvent(ServerLevel level, Holder<GameEvent> gameEvent, GameEvent.Context context, Vec3 pos) {
+             if (gameEvent.is(GameEvent.ENTITY_DIE) && context.sourceEntity() instanceof LivingEntity livingEntity) {
+                 if (!livingEntity.wasExperienceConsumed()) {
+-                    DamageSource lastDamageSource = livingEntity.getLastDamageSource();
+-                    int experienceReward = livingEntity.getExperienceReward(level, Optionull.map(lastDamageSource, DamageSource::getEntity));
++                    int experienceReward = livingEntity.expToReward; // Leaves - exp fix
+                     if (livingEntity.shouldDropExperience() && experienceReward > 0) {
+                         this.sculkSpreader.addCursors(BlockPos.containing(pos.relative(Direction.UP, 0.5)), experienceReward);
+                         this.tryAwardItSpreadsAdvancement(level, livingEntity);

luminol-server/minecraft-patches/features/0059-Add-config-to-enable-Raytracing-tracker.patch

@@ -1,7 +1,7 @@
 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
+Subject: [PATCH] Add config to enable Raytracing tracker
 
 Based on the framework of EntityCulling(((((((
 
@@ -19,7 +19,7 @@ index 7eff847790394aecd058e7a61905da86163b4c6e..9099457f55a2829297ac1db8a69a98ff
                      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
+index 97879ba5080db09dde7cd76fe7b0ba502d8df572..002466add86b36529bff6787332b575d1f12305b 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;
@@ -31,7 +31,7 @@ index ccf1914b4f48ecc0f4fe980510f42d5415ec1daa..ceca76a5791e319dd7cc4048c9860b1d
  
      // CraftBukkit start
      private static final int CURRENT_LEVEL = 2;
-@@ -6049,4 +6049,46 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -6086,4 +6086,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
@@ -93,10 +93,10 @@ index d9cc1d7e56c37d5ce92544edc10e89dbc89dd15d..39e7689be243b9c99b507d665f659135
      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 ae049c5c3593525b991d865fec695c00ad408a59..ad34d0e1ab16fb269b3cec2842bfc2f2c29b452e 100644
+index c6252a245e9701f69db1fe167f6590095237553a..40b91234fd2e4f4f134d309590ea6b605f764e83 100644
 --- a/net/minecraft/world/entity/player/Player.java
 +++ b/net/minecraft/world/entity/player/Player.java
-@@ -210,6 +210,25 @@ public abstract class Player extends LivingEntity {
+@@ -211,6 +211,25 @@ public abstract class Player extends LivingEntity {
          return (org.bukkit.craftbukkit.entity.CraftHumanEntity) super.getBukkitEntity();
      }
      // CraftBukkit end
@@ -122,7 +122,7 @@ index ae049c5c3593525b991d865fec695c00ad408a59..ad34d0e1ab16fb269b3cec2842bfc2f2
  
      public Player(Level level, BlockPos pos, float yRot, GameProfile gameProfile) {
          super(EntityType.PLAYER, level);
-@@ -262,6 +281,26 @@ public abstract class Player extends LivingEntity {
+@@ -263,6 +282,26 @@ public abstract class Player extends LivingEntity {
  
      @Override
      public void tick() {
@@ -149,7 +149,7 @@ index ae049c5c3593525b991d865fec695c00ad408a59..ad34d0e1ab16fb269b3cec2842bfc2f2
          this.noPhysics = this.isSpectator();
          if (this.isSpectator() || this.isPassenger()) {
              this.setOnGround(false);
-@@ -1504,6 +1543,7 @@ public abstract class Player extends LivingEntity {
+@@ -1505,6 +1544,7 @@ public abstract class Player extends LivingEntity {
          if (this.containerMenu != null && this.hasContainerOpen()) {
              this.doCloseContainer();
          }

luminol-server/minecraft-patches/features/0060-Add-config-to-enable-Cross-Region-Damage-trace.patch

@@ -0,0 +1,148 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Tue, 29 Apr 2025 23:03:56 +0800
+Subject: [PATCH] Add config to enable Cross Region Damage trace
+
+
+diff --git a/net/minecraft/server/level/ServerPlayer.java b/net/minecraft/server/level/ServerPlayer.java
+index d9ea3db817878ff56a2772ce983ff95431e1326c..fd4e37719baced819100f7ad2d1cf0350950cb60 100644
+--- a/net/minecraft/server/level/ServerPlayer.java
++++ b/net/minecraft/server/level/ServerPlayer.java
+@@ -1378,6 +1378,13 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+             this.awardStat(Stats.ENTITY_KILLED_BY.get(killCredit.getType()));
+             killCredit.awardKillScore(this, cause);
+             this.createWitherRose(killCredit);
++        // Luminol Start - Cross Region Damage trace
++        } else if (me.earthme.luminol.config.modules.experiment.EntityDamageSourceTraceConfig.enabled) {
++            final LivingEntity entitylivingnew = this.getKillCreditOrigin();
++            if (entitylivingnew != null) {
++                this.damageTransferToAsync(entitylivingnew, cause);
++            }
++        // Luminol End - Cross Region Damage trace
+         }
+ 
+         this.level().broadcastEntityEvent(this, (byte)3);
+@@ -1392,6 +1399,24 @@ public class ServerPlayer extends Player implements ca.spottedleaf.moonrise.patc
+         this.setClientLoaded(false);
+     }
+ 
++    // Luminol Start - Cross Region Damage trace
++    private void damageTransferToAsync(LivingEntity entity, DamageSource cause) {
++        // Operations running on current entity
++        this.awardStat(Stats.ENTITY_KILLED_BY.get(entity.getType()));
++        this.createWitherRose(entity);
++
++        // the entity might be in another tickregion sometimes, so we need to schedule the task onto the entity
++        // to ensure thread safe
++        entity.getBukkitEntity().taskScheduler.schedule((LivingEntity nmsEntity) -> {
++            try {
++                nmsEntity.awardKillScore(this, cause);
++            } catch (Throwable ex) {
++                LOGGER.error(ex.getMessage(), ex);
++            }
++        }, null, 1L );
++    }
++    // Luminol End - Cross Region Damage trace
++
+     // Leaves start - exp fix
+     private boolean shouldDropExperience(boolean eventResult, boolean forceUseEvent) {
+         if (forceUseEvent) {
+diff --git a/net/minecraft/world/entity/LivingEntity.java b/net/minecraft/world/entity/LivingEntity.java
+index 658aa09aecf8d64145feedb82dc9be2a55201450..ccb1541e5ea0acf7ec34084a041652e2139ee724 100644
+--- a/net/minecraft/world/entity/LivingEntity.java
++++ b/net/minecraft/world/entity/LivingEntity.java
+@@ -1181,6 +1181,29 @@ public abstract class LivingEntity extends Entity implements Attackable {
+         }
+     }
+ 
++    // Luminol Start - raid revert adapt Cross Region Damage trace
++    public boolean addEffect(MobEffectInstance effectInstance, @Nullable Entity entity, EntityPotionEffectEvent.Cause cause, boolean fireEvent, boolean async) {
++        if (ca.spottedleaf.moonrise.common.util.TickThread.isTickThreadFor(entity)) {
++            return addEffect(effectInstance, entity, org.bukkit.event.entity.EntityPotionEffectEvent.Cause.PATROL_CAPTAIN, true);
++        } else if (me.earthme.luminol.config.modules.experiment.EntityDamageSourceTraceConfig.enabled) {
++            postToEntityThreadAddEffect(effectInstance, entity, org.bukkit.event.entity.EntityPotionEffectEvent.Cause.PATROL_CAPTAIN, true);
++            return true;
++        }
++        return false;
++    }
++
++    private void postToEntityThreadAddEffect(MobEffectInstance effectInstance, @Nullable Entity entity, EntityPotionEffectEvent.Cause cause, boolean fireEvent) {
++        if (entity != null)
++            entity.getBukkitEntity().taskScheduler.schedule((Entity nmsEntity) -> {
++                try {
++                    addEffect(effectInstance, nmsEntity, cause, fireEvent);
++                } catch (Throwable ex) {
++                    LOGGER.error(ex.getMessage(), ex);
++                }
++            }, null, 1L );
++    }
++    // Luminol End - raid revert adapt Cross Region Damage trace
++
+     public boolean canBeAffected(MobEffectInstance effectInstance) {
+         if (this.getType().is(EntityTypeTags.IMMUNE_TO_INFESTED)) {
+             return !effectInstance.is(MobEffects.INFESTED);
+@@ -1831,6 +1854,13 @@ public abstract class LivingEntity extends Entity implements Attackable {
+             final LivingEntity entityliving = this.getKillCredit();
+             if (entityliving != null) {
+                 entityliving.awardKillScore(this, damageSource);
++            // Luminol Start - Cross Region Damage trace
++            } else if (me.earthme.luminol.config.modules.experiment.EntityDamageSourceTraceConfig.enabled) {
++                final LivingEntity entitylivingnew = this.getKillCreditOrigin();
++                if (entitylivingnew != null) {
++                    this.damageTransferToAsync(entitylivingnew, damageSource);
++                }
++            // Luminol End - Cross Region Damage trace
+             }
+         }); // Paper end
+         this.postDeathDropItems(deathEvent); // Paper
+@@ -1841,6 +1871,18 @@ public abstract class LivingEntity extends Entity implements Attackable {
+         return deathEvent; // Paper
+     }
+ 
++    // Luminol Start - Cross Region Damage trace
++    private void damageTransferToAsync(LivingEntity entity, DamageSource damageSource) {
++        entity.getBukkitEntity().taskScheduler.schedule((LivingEntity nmsEntity) -> {
++            try {
++                nmsEntity.awardKillScore(this, damageSource);
++            } catch (Throwable ex) {
++                LOGGER.error(ex.getMessage(), ex);
++            }
++        }, null, 1L );
++    }
++    // Luminol End - Cross Region Damage trace
++
+     protected void dropEquipment(ServerLevel level) {
+     }
+     protected void postDeathDropItems(org.bukkit.event.entity.EntityDeathEvent event) {} // Paper - method for post death logic that cannot be ran before the event is potentially cancelled
+@@ -2474,6 +2516,18 @@ public abstract class LivingEntity extends Entity implements Attackable {
+         }
+     }
+ 
++    // Luminol Start - Cross Region Damage trace
++    @Nullable
++    public LivingEntity getKillCreditOrigin() {
++        if (this.lastHurtByPlayer != null) {
++            return this.lastHurtByPlayer;
++        } else if (this.lastHurtByMob != null) {
++            return this.lastHurtByMob;
++        }
++        return null;
++    }
++    // Luminol End - Cross Region Damage trace
++
+     public final float getMaxHealth() {
+         return (float)this.getAttributeValue(Attributes.MAX_HEALTH);
+     }
+diff --git a/net/minecraft/world/item/component/OminousBottleAmplifier.java b/net/minecraft/world/item/component/OminousBottleAmplifier.java
+index 5607d2f21131510563f8fdc9079d1145483b11df..f709880a8c1064298aa133617055e7aa5cc2be5e 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 // Luminol - Raid effect infinite
+     }
+ 
+     // Paper start - properly resend entities - collect packets for bundle

luminol-server/minecraft-patches/features/0061-Lithium-Fast-util.patch

@@ -0,0 +1,90 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Bacteriawa <A3167717663@hotmail.com>
+Date: Thu, 7 Nov 2024 21:50:47 +0100
+Subject: [PATCH] Lithium: Fast util
+
+This patch is based on the following mixins:
+* "net/caffeinemc/mods/lithium/mixin/math/fast_util/DirectionMixin.java"
+* "net/caffeinemc/mods/lithium/mixin/math/fast_util/AABBMixin.java"
+By: 2No2Name <2No2Name@web.de>
+As part of: Lithium (https://github.com/CaffeineMC/lithium-fabric)
+Licensed under: LGPL-3.0 (https://www.gnu.org/licenses/lgpl-3.0.html)
+
+diff --git a/net/minecraft/core/Direction.java b/net/minecraft/core/Direction.java
+index 216f97207dac88cc1dc3df59c6ee8a62c7614b4a..3a76b1ec8570e4c9f328e9d362b41057b092be45 100644
+--- a/net/minecraft/core/Direction.java
++++ b/net/minecraft/core/Direction.java
+@@ -217,7 +217,7 @@ public enum Direction implements StringRepresentable, ca.spottedleaf.moonrise.pa
+     }
+ 
+     public Direction getOpposite() {
+-        return this.opposite; // Paper - optimise collisions
++        return VALUES[this.oppositeIndex]; // Leaf - Lithium - fast util
+     }
+ 
+     public Direction getClockWise(Direction.Axis axis) {
+@@ -350,7 +350,7 @@ public enum Direction implements StringRepresentable, ca.spottedleaf.moonrise.pa
+     }
+ 
+     public static Direction getRandom(RandomSource random) {
+-        return Util.getRandom(VALUES, random);
++        return VALUES[random.nextInt(VALUES.length)]; // Leaf - Lithium - fast util
+     }
+ 
+     public static Direction getApproximateNearest(double x, double y, double z) {
+diff --git a/net/minecraft/world/phys/AABB.java b/net/minecraft/world/phys/AABB.java
+index 85148858db1fd5e9da8bbdde4b0d84110d80e373..82fb85089336f874349fa87e7cb9c14ab087ad8b 100644
+--- a/net/minecraft/world/phys/AABB.java
++++ b/net/minecraft/world/phys/AABB.java
+@@ -18,6 +18,15 @@ public class AABB {
+     public final double maxY;
+     public final double maxZ;
+ 
++    // Leaf start - Lithium - fast util
++    static {
++        assert Direction.Axis.X.ordinal() == 0;
++        assert Direction.Axis.Y.ordinal() == 1;
++        assert Direction.Axis.Z.ordinal() == 2;
++        assert Direction.Axis.values().length == 3;
++    }
++    // Leaf end - Lithium - fast util
++
+     public AABB(double x1, double y1, double z1, double x2, double y2, double z2) {
+         this.minX = Math.min(x1, x2);
+         this.minY = Math.min(y1, y2);
+@@ -79,11 +88,33 @@ public class AABB {
+     }
+ 
+     public double min(Direction.Axis axis) {
+-        return axis.choose(this.minX, this.minY, this.minZ);
++        // Leaf start - Lithium - fast util
++        switch (axis.ordinal()) {
++            case 0: //X
++                return this.minX;
++            case 1: //Y
++                return this.minY;
++            case 2: //Z
++                return this.minZ;
++        }
++
++        throw new IllegalArgumentException();
++        // Leaf end - Lithium - fast util
+     }
+ 
+     public double max(Direction.Axis axis) {
+-        return axis.choose(this.maxX, this.maxY, this.maxZ);
++        // Leaf start - Lithium - fast util
++        switch (axis.ordinal()) {
++            case 0: //X
++                return this.maxX;
++            case 1: //Y
++                return this.maxY;
++            case 2: //Z
++                return this.maxZ;
++        }
++
++        throw new IllegalArgumentException();
++        // Leaf end - Lithium - fast util
+     }
+ 
+     @Override

luminol-server/minecraft-patches/features/0062-Lithium-Skip-unnecessary-calculations-if-player-is-n.patch

@@ -0,0 +1,33 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Bacteriawa <A3167717663@hotmail.com>
+Date: Fri, 8 Nov 2024 00:22:44 +0800
+Subject: [PATCH] Lithium: Skip unnecessary calculations if player is not
+ flying or swing
+
+This patch is based on the following mixins:
+* "net/caffeinemc/mods/lithium/mixin/entity/fast_elytra_check/LivingEntityMixin.java"
+* "net/caffeinemc/mods/lithium/mixin/entity/fast_hand_swing/LivingEntityMixin.java"
+By: 2No2Name <2No2Name@web.de>
+As part of: Lithium (https://github.com/CaffeineMC/lithium-fabric)
+Licensed under: LGPL-3.0 (https://www.gnu.org/licenses/lgpl-3.0.html)
+
+diff --git a/net/minecraft/world/entity/LivingEntity.java b/net/minecraft/world/entity/LivingEntity.java
+index ccb1541e5ea0acf7ec34084a041652e2139ee724..4eddc407d04428516dc3607e4726d3ff58588c62 100644
+--- a/net/minecraft/world/entity/LivingEntity.java
++++ b/net/minecraft/world/entity/LivingEntity.java
+@@ -2698,6 +2698,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+     }
+ 
+     protected void updateSwingTime() {
++        if (!this.swinging && this.swingTime == 0) return; // Leaf - Lithium - entity.fast_hand_swing
+         int currentSwingDuration = this.getCurrentSwingDuration();
+         if (this.swinging) {
+             this.swingTime++;
+@@ -3623,6 +3624,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+     protected void updateFallFlying() {
+         this.checkSlowFallDistance();
+         if (!this.level().isClientSide) {
++            if (!this.isFallFlying() && this.fallFlyTicks == 0) return; // Leaf - Lithium - entity.fast_elytra_check
+             if (!this.canGlide()) {
+                 if (this.getSharedFlag(7) != false && !CraftEventFactory.callToggleGlideEvent(this, false).isCancelled()) // CraftBukkit
+                 this.setSharedFlag(7, false);

luminol-server/minecraft-patches/removed/0024-Fully-removed-player-teleport-event-and-entity-telep.patch

@@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Sat, 19 Apr 2025 20:38:20 +0800
+Subject: [PATCH] Fully removed player teleport event and entity teleport event
+ call
+
+
+diff --git a/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index a107d9ee24d0e39ce3e3e09bf27af1ea4ae35b96..e786177f9e36c1dfb0cdcfc641ab2e36d42f2451 100644
+--- a/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1764,7 +1764,7 @@ public class ServerGamePacketListenerImpl
+             final io.papermc.paper.entity.TeleportFlag.Relative flag = org.bukkit.craftbukkit.entity.CraftPlayer.deltaRelativeToAPI(relativeArgument);
+             if (flag != null) relativeFlags.add(flag);
+         }
+-        PlayerTeleportEvent event = new PlayerTeleportEvent(player, from.clone(), to.clone(), cause, java.util.Set.copyOf(relativeFlags));
++        /*PlayerTeleportEvent event = new PlayerTeleportEvent(player, from.clone(), to.clone(), cause, java.util.Set.copyOf(relativeFlags)); // Luminol - Fully remove EntityTeleportEvent and PlayerTeleportEvent
+         // Paper end - Teleport API
+         this.cserver.getPluginManager().callEvent(event);
+ 
+@@ -1773,9 +1773,10 @@ public class ServerGamePacketListenerImpl
+             to = event.isCancelled() ? event.getFrom() : event.getTo();
+             posMoveRotation = new PositionMoveRotation(CraftLocation.toVec3D(to), Vec3.ZERO, to.getYaw(), to.getPitch());
+         }
++        */ // Luminol - Fully remove EntityTeleportEvent and PlayerTeleportEvent
+ 
+         this.internalTeleport(posMoveRotation, relatives);
+-        return !event.isCancelled(); // CraftBukkit - Return event status
++        return true; //!event.isCancelled(); // CraftBukkit - Return event status // Luminol - Fully remove EntityTeleportEvent and PlayerTeleportEvent
+     }
+ 
+     public void teleport(Location dest) {
+diff --git a/net/minecraft/world/entity/LivingEntity.java b/net/minecraft/world/entity/LivingEntity.java
+index 6258b008ad3e00d41e9f3014572d6f7a06b1847c..1981f8e9e158ba7874dd3c9bde127654d56170ce 100644
+--- a/net/minecraft/world/entity/LivingEntity.java
++++ b/net/minecraft/world/entity/LivingEntity.java
+@@ -4226,7 +4226,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+                 this.setPos(x1, y1, z1);
+ 
+                 if (flag) {
+-                    if (!(this instanceof ServerPlayer)) {
++                    if (!(this instanceof ServerPlayer) && false) { // Luminol - Fully remove EntityTeleportEvent and PlayerTeleportEvent
+                         EntityTeleportEvent teleport = new EntityTeleportEvent(this.getBukkitEntity(), new Location(this.level().getWorld(), x1, y1, z1), new Location(this.level().getWorld(), x, d, z));
+                         this.level().getCraftServer().getPluginManager().callEvent(teleport);
+                         if (!teleport.isCancelled() && teleport.getTo() != null) { // Paper

luminol-server/minecraft-patches/removed/0044-Leaf-Smart-sort-entities-in-NearestLivingEntitySenso.patch

@@ -0,0 +1,125 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <mrhua269@gmail.com>
+Date: Fri, 18 Apr 2025 22:04:20 +0800
+Subject: [PATCH] Leaf Smart sort entities in NearestLivingEntitySensor
+
+
+diff --git a/net/minecraft/world/entity/ai/sensing/NearestLivingEntitySensor.java b/net/minecraft/world/entity/ai/sensing/NearestLivingEntitySensor.java
+index b0c5e41fefc7c9adf1a61bd5b52861736657d37e..b91c4aa042f6ac10e402bcf16a03d24d6dafec86 100644
+--- a/net/minecraft/world/entity/ai/sensing/NearestLivingEntitySensor.java
++++ b/net/minecraft/world/entity/ai/sensing/NearestLivingEntitySensor.java
+@@ -13,18 +13,107 @@ import net.minecraft.world.entity.ai.memory.NearestVisibleLivingEntities;
+ import net.minecraft.world.phys.AABB;
+ 
+ public class NearestLivingEntitySensor<T extends LivingEntity> extends Sensor<T> {
++
++    // Leaf start - Optimized entity sorting with buffer reuse
++    private static final int SMALL_ARRAY_THRESHOLD = 2;
++    private final ThreadLocal<LivingEntity[]> entityBuffer = ThreadLocal.withInitial(() -> new LivingEntity[0]);
++    private final ThreadLocal<long[]> bitsBuffer = ThreadLocal.withInitial(() -> new long[0]);
++
+     @Override
+     protected void doTick(ServerLevel level, T entity) {
+-        double attributeValue = entity.getAttributeValue(Attributes.FOLLOW_RANGE);
+-        AABB aabb = entity.getBoundingBox().inflate(attributeValue, attributeValue, attributeValue);
+-        List<LivingEntity> entitiesOfClass = level.getEntitiesOfClass(
+-            LivingEntity.class, aabb, matchableEntity -> matchableEntity != entity && matchableEntity.isAlive()
++        double range = entity.getAttributeValue(Attributes.FOLLOW_RANGE);
++        double rangeSqr = range * range;
++        AABB aabb = entity.getBoundingBox().inflate(range, range, range);
++
++        List<LivingEntity> entities = level.getEntitiesOfClass(
++            LivingEntity.class, aabb, e -> e != entity && e.isAlive() && entity.distanceToSqr(e) <= rangeSqr
+         );
+-        entitiesOfClass.sort(Comparator.comparingDouble(entity::distanceToSqr));
++
++        LivingEntity[] sorted = smartSort(entities, entity);
++        List<LivingEntity> sortedList = java.util.Arrays.asList(sorted);
++
+         Brain<?> brain = entity.getBrain();
+-        brain.setMemory(MemoryModuleType.NEAREST_LIVING_ENTITIES, entitiesOfClass);
+-        brain.setMemory(MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES, new NearestVisibleLivingEntities(level, entity, entitiesOfClass));
++        brain.setMemory(MemoryModuleType.NEAREST_LIVING_ENTITIES, sortedList);
++        brain.setMemory(MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES,
++            new NearestVisibleLivingEntities(level, entity, sortedList));
++    }
++
++    private LivingEntity[] smartSort(List<LivingEntity> entities, T reference) {
++        int size = entities.size();
++        if (size <= 1) return entities.toArray(new LivingEntity[0]);
++
++        LivingEntity[] entityBufferArray = this.entityBuffer.get();
++        long[] bitsBufferArray = this.bitsBuffer.get();
++        if (entityBufferArray.length < size) {
++            entityBufferArray = new LivingEntity[size];
++            entityBuffer.set(entityBufferArray);
++
++            bitsBufferArray = new long[size];
++            bitsBuffer.set(bitsBufferArray);
++        }
++
++        for (int i = 0; i < size; i++) {
++            LivingEntity e = entities.get(i);
++            entityBufferArray[i] = e;
++            bitsBufferArray[i] = Double.doubleToRawLongBits(reference.distanceToSqr(e));
++        }
++
++        fastRadixSort(entityBufferArray, bitsBufferArray, 0, size - 1, 62);
++
++        return java.util.Arrays.copyOf(entityBufferArray, size);
++    }
++
++    private void fastRadixSort(LivingEntity[] ents, long[] bits, int low, int high, int bit) {
++        if (bit < 0 || low >= high) return;
++
++        if (high - low <= SMALL_ARRAY_THRESHOLD) {
++            insertionSort(ents, bits, low, high);
++            return;
++        }
++
++        int i = low, j = high;
++        final long mask = 1L << bit;
++
++        while (i <= j) {
++            while (i <= j && (bits[i] & mask) == 0) i++;
++            while (i <= j && (bits[j] & mask) != 0) j--;
++
++            if (i < j) {
++                swap(ents, bits, i++, j--);
++            }
++        }
++
++        if (low < j) fastRadixSort(ents, bits, low, j, bit - 1);
++        if (i < high) fastRadixSort(ents, bits, i, high, bit - 1);
++    }
++
++    private void insertionSort(LivingEntity[] ents, long[] bits, int low, int high) {
++        for (int i = low + 1; i <= high; i++) {
++            int j = i;
++            LivingEntity e = ents[j];
++            long b = bits[j];
++
++            while (j > low && bits[j - 1] > b) {
++                ents[j] = ents[j - 1];
++                bits[j] = bits[j - 1];
++                j--;
++            }
++
++            ents[j] = e;
++            bits[j] = b;
++        }
++    }
++
++    private void swap(LivingEntity[] ents, long[] bits, int a, int b) {
++        LivingEntity te = ents[a];
++        ents[a] = ents[b];
++        ents[b] = te;
++
++        long tb = bits[a];
++        bits[a] = bits[b];
++        bits[b] = tb;
+     }
++    // Leaf end - Optimized entity sorting with buffer reuse
+ 
+     @Override
+     public Set<MemoryModuleType<?>> requires() {

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

@@ -18,7 +18,7 @@ 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 6c2d9c9621f665412f1a8ccc41083fb0e3a07ed5..fb0ba43c8102a205d1402f53d47823672d2edfbe 100644
+index ae7ee8c67a71b0bc319d8079094b1806fc3e305a..07e59bbfa94103d610ec63e695e51a961cd6eec5 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 @@ -314,7 +314,7 @@ public final class CraftServer implements Server {

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

@@ -23,7 +23,7 @@ index f42692cd4f0154705c3d5b030d281cfc333803ed..39cc976f65f826a00e2e637c139f9134
  
      @Override
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index fb0ba43c8102a205d1402f53d47823672d2edfbe..d8627561b5ffec33e0c42974aa5e3d421c8cfac2 100644
+index 07e59bbfa94103d610ec63e695e51a961cd6eec5..9c7a5d0a94417a65788330b7239aa746006407fa 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 {

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

@@ -5,7 +5,7 @@ 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
+index cd6e46fa68c009deb8dfebcecb88e058dfede0b0..ac4ab407095d998b1418d740ab54e8157bce6a02 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 {

luminol-server/paper-patches/features/0012-Leaves-Fix-SculkCatalyst-exp-skip.patch

@@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: violetc <58360096+s-yh-china@users.noreply.github.com>
+Date: Sun, 6 Apr 2025 10:42:46 +0800
+Subject: [PATCH] Leaves Fix SculkCatalyst exp skip
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+index bef7a026676ab59a84fc33c8af50ad2b9447fd8c..0a678458bcee4ced98d2880821dbff302f59b7f6 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
++++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -991,7 +991,7 @@ public class CraftEventFactory {
+         CraftLivingEntity entity = (CraftLivingEntity) victim.getBukkitEntity();
+         CraftDamageSource bukkitDamageSource = new CraftDamageSource(damageSource);
+         CraftWorld world = (CraftWorld) entity.getWorld();
+-        EntityDeathEvent event = new EntityDeathEvent(entity, bukkitDamageSource, new io.papermc.paper.util.TransformingRandomAccessList<>(drops, Entity.DefaultDrop::stack, FROM_FUNCTION), victim.getExpReward(world.getHandle(), damageSource.getEntity())); // Paper - Restore vanilla drops behavior
++        EntityDeathEvent event = new EntityDeathEvent(entity, bukkitDamageSource, new io.papermc.paper.util.TransformingRandomAccessList<>(drops, Entity.DefaultDrop::stack, FROM_FUNCTION), victim.getExpReward(world.getHandle(), damageSource.getEntity()), victim.getExperienceReward(world.getHandle(), damageSource.getEntity())); // Paper - Restore vanilla drops behavior // Leaves - exp fix
+         populateFields(victim, event); // Paper - make cancellable
+         Bukkit.getServer().getPluginManager().callEvent(event);
+ 
+@@ -1002,6 +1002,7 @@ public class CraftEventFactory {
+         playDeathSound(victim, event);
+         // Paper end
+         victim.expToDrop = event.getDroppedExp();
++        victim.expToReward = event.getRewardExp(); // Leaves - exp fix
+         lootCheck.run(); // Paper - advancement triggers before destroying items
+ 
+         // Paper start - Restore vanilla drops behavior
+@@ -1037,6 +1038,7 @@ public class CraftEventFactory {
+         victim.newLevel = event.getNewLevel();
+         victim.newTotalExp = event.getNewTotalExp();
+         victim.expToDrop = event.getDroppedExp();
++        victim.expToReward = event.getRewardExp(); // Leaves - exp fix
+         victim.newExp = event.getNewExp();
+ 
+         // Paper start - Restore vanilla drops behavior

luminol-server/paper-patches/files/src/main/java/me/earthme/luminol/config/modules/experiment/CommandTickConfig.java.patch

@@ -0,0 +1,25 @@
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/experiment/CommandTickConfig.java
+@@ -1,0 +_,22 @@
++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 CommandTickConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled", comments =
++            """
++                    Allow to use tick command""")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.EXPERIMENT;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "enable_tick_command";
++    }
++}

luminol-server/paper-patches/files/src/main/java/me/earthme/luminol/config/modules/experiment/EntityDamageSourceTraceConfig.java.patch

@@ -0,0 +1,25 @@
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/experiment/EntityDamageSourceTraceConfig.java
+@@ -1,0 +_,22 @@
++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 EntityDamageSourceTraceConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled", comments =
++            """
++                    Allow trace damage source cross different Region Scheduler.""")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.EXPERIMENT;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "entity-damage-source-trace";
++    }
++}

luminol-server/paper-patches/files/src/main/java/me/earthme/luminol/config/modules/misc/DisableHeightmapWarnConfig.java.patch

@@ -0,0 +1,25 @@
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/misc/DisableHeightmapWarnConfig.java
+@@ -1,0 +_,22 @@
++package me.earthme.luminol.config.modules.misc;
++
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++
++public class DisableHeightmapWarnConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled", comments =
++            """
++                    Disable heightmap-check's warning""")
++    public static boolean enabled = false;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.MISC;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "heightmap_warn_disable";
++    }
++}

luminol-server/paper-patches/files/src/main/java/me/earthme/luminol/config/modules/misc/RaidChangesConfig.java.patch

@@ -1,6 +1,6 @@
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/config/modules/misc/RaidChangesConfig.java
-@@ -1,0 +_,41 @@
+@@ -1,0 +_,54 @@
 +package me.earthme.luminol.config.modules.misc;
 +
 +import me.earthme.luminol.config.ConfigInfo;
@@ -10,28 +10,41 @@
 +public class RaidChangesConfig implements IConfigModule {
 +    @ConfigInfo(baseName = "allow-bad-omen-trigger-raid", comments =
 +            """
-+                    Allow players with ominous signs to\s
-+                    skip a 30-second cooldown and trigger\s
-+                    attacks directly""")
++                    Allow players with ominous signs to skip a\s
++                    30-second cooldown and trigger attacks directly""")
 +    public static boolean trigger = false;
 +
 +    @ConfigInfo(baseName = "give-bad-omen-when-kill-patrol-leader", comments =
 +            """
-+                    Enable players to obtain an ominous\s
-+                    omen effect when killing the patrol\s
-+                    team captain""")
++                    Enable players to obtain an ominous omen\s
++                    effect when killing the patrol team captain""")
 +    public static boolean effect = false;
 +
 +    @ConfigInfo(baseName = "bad-omen-infinite", comments =
 +            """
-+                    Enable bad omen effect infinite time.""")
++                    Enable bad omen effect infinite time
++                        --- this config is not old version's function""")
 +    public static boolean infinite = false;
 +
 +    @ConfigInfo(baseName = "skip-height-check", comments =
 +            """
-+                    disable y <= 96 check.""")
++                    Disable y <= 96 check.
++                    If you enabled revert_274911, this config will useless
++                    and always behavior of enabled""")
 +    public static boolean height_check = false;
 +
++    @ConfigInfo(baseName = "skip-self-raid-check", comments =
++            """
++                    Disable raid self check\s
++                        --- this config is not old version's function""")
++    public static boolean self_check = false;
++
++    @ConfigInfo(baseName = "revert-274911", comments =
++            """
++                    Revert Old raid's find spawn position logic
++                        --- This revert MC-274911""")
++    public static boolean pos_revert = false;
++
 +    @Override
 +    public EnumConfigCategory getCategory() {
 +        return EnumConfigCategory.MISC;

luminol-server/paper-patches/files/src/main/java/net/caffeinemc/mods/lithium/common/world/chunk/LithiumHashPalette.java.patch

@@ -0,0 +1,212 @@
+--- /dev/null
++++ b/src/main/java/net/caffeinemc/mods/lithium/common/world/chunk/LithiumHashPalette.java
+@@ -1,0 +_,209 @@
++// Lithium - faster chunk serialization
++
++package net.caffeinemc.mods.lithium.common.world.chunk;
++
++import it.unimi.dsi.fastutil.HashCommon;
++import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
++import net.minecraft.CrashReport;
++import net.minecraft.CrashReportCategory;
++import net.minecraft.ReportedException;
++import net.minecraft.core.IdMap;
++import net.minecraft.network.FriendlyByteBuf;
++import net.minecraft.network.VarInt;
++import net.minecraft.world.level.chunk.MissingPaletteEntryException;
++import net.minecraft.world.level.chunk.Palette;
++import net.minecraft.world.level.chunk.PaletteResize;
++import org.jetbrains.annotations.NotNull;
++
++import java.util.Arrays;
++import java.util.List;
++import java.util.function.Predicate;
++
++import static it.unimi.dsi.fastutil.Hash.FAST_LOAD_FACTOR;
++
++/**
++ * Generally provides better performance over the vanilla {@link net.minecraft.world.level.chunk.HashMapPalette} when calling
++ * {@link LithiumHashPalette#idFor(Object)} through using a faster backing map and reducing pointer chasing.
++ */
++public class LithiumHashPalette<T> implements Palette<T> {
++    private static final int ABSENT_VALUE = -1;
++
++    private final IdMap<T> idList;
++    private final PaletteResize<T> resizeHandler;
++    private final int indexBits;
++
++    private final Reference2IntOpenHashMap<T> table;
++    private T[] entries;
++    private int size = 0;
++
++    private LithiumHashPalette(IdMap<T> idList, PaletteResize<T> resizeHandler, int indexBits, T[] entries, Reference2IntOpenHashMap<T> table, int size) {
++        this.idList = idList;
++        this.resizeHandler = resizeHandler;
++        this.indexBits = indexBits;
++        this.entries = entries;
++        this.table = table;
++        this.size = size;
++    }
++
++    public LithiumHashPalette(IdMap<T> idList, int bits, PaletteResize<T> resizeHandler, List<T> list) {
++        this(idList, bits, resizeHandler);
++
++        for (T t : list) {
++            this.addEntry(t);
++        }
++    }
++
++    @SuppressWarnings("unchecked")
++    public LithiumHashPalette(IdMap<T> idList, int bits, PaletteResize<T> resizeHandler) {
++        this.idList = idList;
++        this.indexBits = bits;
++        this.resizeHandler = resizeHandler;
++
++        int capacity = 1 << bits;
++
++        this.entries = (T[]) new Object[capacity];
++        this.table = new Reference2IntOpenHashMap<>(capacity, FAST_LOAD_FACTOR);
++        this.table.defaultReturnValue(ABSENT_VALUE);
++    }
++
++    @Override
++    public int idFor(@NotNull T obj) {
++        int id = this.table.getInt(obj);
++
++        if (id == ABSENT_VALUE) {
++            id = this.computeEntry(obj);
++        }
++
++        return id;
++    }
++
++    @Override
++    public boolean maybeHas(@NotNull Predicate<T> predicate) {
++        for (int i = 0; i < this.size; ++i) {
++            if (predicate.test(this.entries[i])) {
++                return true;
++            }
++        }
++
++        return false;
++    }
++
++    private int computeEntry(T obj) {
++        int id = this.addEntry(obj);
++
++        if (id >= 1 << this.indexBits) {
++            if (this.resizeHandler == null) {
++                throw new IllegalStateException("Cannot grow");
++            } else {
++                id = this.resizeHandler.onResize(this.indexBits + 1, obj);
++            }
++        }
++
++        return id;
++    }
++
++    private int addEntry(T obj) {
++        int nextId = this.size;
++
++        if (nextId >= this.entries.length) {
++            this.resize(this.size);
++        }
++
++        this.table.put(obj, nextId);
++        this.entries[nextId] = obj;
++
++        this.size++;
++
++        return nextId;
++    }
++
++    private void resize(int neededCapacity) {
++        this.entries = Arrays.copyOf(this.entries, HashCommon.nextPowerOfTwo(neededCapacity + 1));
++    }
++
++    @Override
++    public @NotNull T valueFor(int id) {
++        T[] entries = this.entries;
++
++        T entry = null;
++        if (id >= 0 && id < entries.length) {
++            entry = entries[id];
++        }
++
++        if (entry != null) {
++            return entry;
++        } else {
++            throw this.missingPaletteEntryCrash(id);
++        }
++    }
++
++    private ReportedException missingPaletteEntryCrash(int id) {
++        try {
++            throw new MissingPaletteEntryException(id);
++        } catch (MissingPaletteEntryException e) {
++            CrashReport crashReport = CrashReport.forThrowable(e, "[Lithium] Getting Palette Entry");
++            CrashReportCategory crashReportCategory = crashReport.addCategory("Chunk section");
++            crashReportCategory.setDetail("IndexBits", this.indexBits);
++            crashReportCategory.setDetail("Entries", this.entries.length + " Elements: " + Arrays.toString(this.entries));
++            crashReportCategory.setDetail("Table", this.table.size() + " Elements: " + this.table);
++            return new ReportedException(crashReport);
++        }
++    }
++
++    @Override
++    public void read(FriendlyByteBuf buf) {
++        this.clear();
++
++        int entryCount = buf.readVarInt();
++
++        for (int i = 0; i < entryCount; ++i) {
++            this.addEntry(this.idList.byIdOrThrow(buf.readVarInt()));
++        }
++    }
++
++    @Override
++    public void write(FriendlyByteBuf buf) {
++        int size = this.size;
++        buf.writeVarInt(size);
++
++        for (int i = 0; i < size; ++i) {
++            buf.writeVarInt(this.idList.getId(this.valueFor(i)));
++        }
++    }
++
++    @Override
++    public int getSerializedSize() {
++        int size = VarInt.getByteSize(this.size);
++
++        for (int i = 0; i < this.size; ++i) {
++            size += VarInt.getByteSize(this.idList.getId(this.valueFor(i)));
++        }
++
++        return size;
++    }
++
++    @Override
++    public int getSize() {
++        return this.size;
++    }
++
++    @Override
++    public @NotNull Palette<T> copy(@NotNull PaletteResize<T> resizeHandler) {
++        return new LithiumHashPalette<>(this.idList, resizeHandler, this.indexBits, this.entries.clone(), this.table.clone(), this.size);
++    }
++
++    private void clear() {
++        Arrays.fill(this.entries, null);
++        this.table.clear();
++        this.size = 0;
++    }
++
++    public List<T> getElements() {
++        T[] copy = Arrays.copyOf(this.entries, this.size);
++        return Arrays.asList(copy);
++    }
++
++    public static <A> Palette<A> create(int bits, IdMap<A> idList, PaletteResize<A> listener, List<A> list) {
++        return new LithiumHashPalette<>(idList, bits, listener, list);
++    }
++}