Added config for: Pufferfish Reduce entity fluid lookups if no fluids

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

@@ -6,7 +6,7 @@ Subject: [PATCH] Add config for unsafe teleportation
 
 diff --git a/src/main/java/me/earthme/luminol/config/modules/fixes/UnsafeTeleportationConfig.java b/src/main/java/me/earthme/luminol/config/modules/fixes/UnsafeTeleportationConfig.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..1b0de6f0ccab72c409a63dc1904829008e30328e
+index 0000000000000000000000000000000000000000..ea374875f529b30db17e8b8cb07b99a600b722dc
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/config/modules/fixes/UnsafeTeleportationConfig.java
 @@ -0,0 +1,20 @@
@@ -17,7 +17,7 @@ index 0000000000000000000000000000000000000000..1b0de6f0ccab72c409a63dc190482900
 +import me.earthme.luminol.config.IConfigModule;
 +
 +public class UnsafeTeleportationConfig implements IConfigModule {
-+    @ConfigInfo(baseName = "enabled", comments = "If you want to use sand duping,please turn on this")
++    @ConfigInfo(baseName = "enabled", comments = "Allow non player entities enter end portals if enabled.If you want to use sand duping,please turn on this")
 +    public static boolean enabled = false;
 +
 +    @Override

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

@@ -6,7 +6,7 @@ Subject: [PATCH] Add config for vanilla random
 
 diff --git a/src/main/java/me/earthme/luminol/config/modules/fixes/VanillaRandomSourceConfig.java b/src/main/java/me/earthme/luminol/config/modules/fixes/VanillaRandomSourceConfig.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..ee247014c9a2ec1bbb7f25ef41da110a270154d6
+index 0000000000000000000000000000000000000000..0e6bfc03be660415c333024b56ac6565e3b61ab1
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/config/modules/fixes/VanillaRandomSourceConfig.java
 @@ -0,0 +1,20 @@
@@ -17,7 +17,7 @@ index 0000000000000000000000000000000000000000..ee247014c9a2ec1bbb7f25ef41da110a
 +import me.earthme.luminol.config.IConfigModule;
 +
 +public class VanillaRandomSourceConfig implements IConfigModule {
-+    @ConfigInfo(baseName = "enable_for_player_entity")
++    @ConfigInfo(baseName = "enable_for_player_entity",comments = "Related with RNG cracks")
 +    public static boolean useLegacyRandomSourceForPlayers = false;
 +
 +    @Override

patches/server/0010-Add-a-simple-membar.patch

@@ -1,22 +1,78 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: MrHua269 <novau233@163.com>
 Date: Sun, 2 Jun 2024 12:18:05 +0000
-Subject: [PATCH] Ram bar
+Subject: [PATCH] Add a simple membar
 
 
+diff --git a/src/main/java/me/earthme/luminol/commands/MembarCommand.java b/src/main/java/me/earthme/luminol/commands/MembarCommand.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..a5cbad6b947b1c3e1499bc6d311e17a5eb570c2f
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/commands/MembarCommand.java
+@@ -0,0 +1,47 @@
++package me.earthme.luminol.commands;
++
++import me.earthme.luminol.config.modules.misc.MembarConfig;
++import me.earthme.luminol.functions.GlobalServerMemoryBar;
++import net.kyori.adventure.text.Component;
++import net.kyori.adventure.text.format.TextColor;
++import org.bukkit.command.Command;
++import org.bukkit.command.CommandSender;
++import org.bukkit.entity.Player;
++import org.jetbrains.annotations.NotNull;
++
++public class MembarCommand extends Command {
++    public MembarCommand(@NotNull String name) {
++        super(name);
++        this.setPermission("luminol.commands.membar");
++        this.setDescription("Show the memory usage through a bossbar");
++        this.setUsage("/membar");
++    }
++
++    @Override
++    public boolean execute(@NotNull CommandSender sender, @NotNull String commandLabel, @NotNull String[] args) {
++        if (!testPermission(sender)){
++            return true;
++        }
++
++        if (!MembarConfig.memoryBarEnabled){
++            sender.sendMessage(Component.text("Membar was already disabled!").color(TextColor.color(255,0,0)));
++            return true;
++        }
++
++        if (!(sender instanceof Player player)){
++            sender.sendMessage(Component.text("Only player can use this command!").color(TextColor.color(255,0,0)));
++            return true;
++        }
++
++        if (GlobalServerMemoryBar.isPlayerVisible(player)) {
++            player.sendMessage(Component.text("Disabled mem bar").color(TextColor.color(0,255,0)));
++            GlobalServerMemoryBar.setVisibilityForPlayer(player,false);
++            return true;
++        }
++
++        player.sendMessage(Component.text("Enabled mem bar").color(TextColor.color(0,255,0)));
++        GlobalServerMemoryBar.setVisibilityForPlayer(player,true);
++
++        return true;
++    }
++}
 diff --git a/src/main/java/me/earthme/luminol/config/modules/misc/MembarConfig.java b/src/main/java/me/earthme/luminol/config/modules/misc/MembarConfig.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..b177d6b0b01af233f7b10200748bc791a912ddb0
+index 0000000000000000000000000000000000000000..b632c4a636974535bf001f010de1dcb6b25868c0
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/config/modules/misc/MembarConfig.java
-@@ -0,0 +1,39 @@
+@@ -0,0 +1,50 @@
 +package me.earthme.luminol.config.modules.misc;
 +
 +import com.electronwill.nightconfig.core.file.CommentedFileConfig;
++import me.earthme.luminol.commands.MembarCommand;
 +import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.DoNotLoad;
 +import me.earthme.luminol.config.EnumConfigCategory;
 +import me.earthme.luminol.config.IConfigModule;
 +import me.earthme.luminol.functions.GlobalServerMemoryBar;
++import org.bukkit.Bukkit;
 +
 +import java.util.List;
 +
@@ -30,6 +86,9 @@ index 0000000000000000000000000000000000000000..b177d6b0b01af233f7b10200748bc791
 +    @ConfigInfo(baseName = "update_interval_ticks")
 +    public static int updateInterval = 15;
 +
++    @DoNotLoad
++    private static boolean inited = false;
++
 +    @Override
 +    public EnumConfigCategory getCategory() {
 +        return EnumConfigCategory.MISC;
@@ -47,11 +106,16 @@ index 0000000000000000000000000000000000000000..b177d6b0b01af233f7b10200748bc791
 +        }else{
 +            GlobalServerMemoryBar.cancelBarUpdateTask();
 +        }
++
++        if (!inited){
++            Bukkit.getCommandMap().register("membar","luminol",new MembarCommand("membar"));
++            inited = true;
++        }
 +    }
 +}
 diff --git a/src/main/java/me/earthme/luminol/functions/GlobalServerMemoryBar.java b/src/main/java/me/earthme/luminol/functions/GlobalServerMemoryBar.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..fdd57d5825aced511a65ee056a773c1fbe4f12bd
+index 0000000000000000000000000000000000000000..a33a45194273cc1b4e4157a5449c7994968a3480
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/functions/GlobalServerMemoryBar.java
 @@ -0,0 +1,186 @@
@@ -82,14 +146,14 @@ index 0000000000000000000000000000000000000000..fdd57d5825aced511a65ee056a773c1f
 +public class GlobalServerMemoryBar {
 +    protected static final MinecraftInternalPlugin NULL_PLUGIN = new MinecraftInternalPlugin();
 +    protected static final Map<UUID, BossBar> uuid2Bossbars = new HashMap<>();
-+    protected static volatile ScheduledTask tpsbarTask = null;
++    protected static volatile ScheduledTask membarTask = null;
 +    private static final Logger logger = LogManager.getLogger();
 +
 +    public static void init(){
 +        cancelBarUpdateTask();
 +
 +        Bukkit.getGlobalRegionScheduler().runAtFixedRate(NULL_PLUGIN, c -> {
-+            tpsbarTask = c;
++            membarTask = c;
 +            try {
 +                update();
 +            }catch (Exception e){
@@ -101,11 +165,11 @@ index 0000000000000000000000000000000000000000..fdd57d5825aced511a65ee056a773c1f
 +    public static void removeAllBars(){
 +        for (Map.Entry<UUID,BossBar> barEntry : uuid2Bossbars.entrySet()){
 +            final UUID playerUUID = barEntry.getKey();
-+            final BossBar tpsBar = barEntry.getValue();
++            final BossBar memBar = barEntry.getValue();
 +
 +            final Player targetPlayer = Bukkit.getPlayer(playerUUID);{
 +                if (targetPlayer != null){
-+                    targetPlayer.hideBossBar(tpsBar);
++                    targetPlayer.hideBossBar(memBar);
 +                }
 +            }
 +        }
@@ -116,11 +180,11 @@ index 0000000000000000000000000000000000000000..fdd57d5825aced511a65ee056a773c1f
 +    public static void cancelBarUpdateTask(){
 +        removeAllBars();
 +
-+        if (tpsbarTask == null || tpsbarTask.isCancelled()){
++        if (membarTask == null || membarTask.isCancelled()){
 +            return;
 +        }
 +
-+        tpsbarTask.cancel();
++        membarTask.cancel();
 +    }
 +
 +    public static boolean isPlayerVisible(Player player){
@@ -189,12 +253,12 @@ index 0000000000000000000000000000000000000000..fdd57d5825aced511a65ee056a773c1f
 +            }
 +
 +            if (targetBossbar != null){
-+                updateTpsBar(targetBossbar,used,xmx);
++                updateMembar(targetBossbar,used,xmx);
 +            }
 +        }
 +    }
 +
-+    private static void updateTpsBar(@NotNull BossBar bar,long used,long xmx){
++    private static void updateMembar(@NotNull BossBar bar, long used, long xmx){
 +        double percent = Math.max(Math.min((float) used / xmx, 1.0F), 0.0F);
 +        bar.name(MiniMessage.miniMessage().deserialize(
 +                MembarConfig.memBarFormat,
@@ -212,7 +276,7 @@ index 0000000000000000000000000000000000000000..fdd57d5825aced511a65ee056a773c1f
 +        final String content = "<%s><text></%s>";
 +        final String replaced = String.format(content,colorString,colorString);
 +
-+        return MiniMessage.miniMessage().deserialize(replaced,Placeholder.parsed("text", String.valueOf(max)));
++        return MiniMessage.miniMessage().deserialize(replaced,Placeholder.parsed("text", String.format("%.2f", (double)max / (1024 * 1024))));
 +    }
 +
 +    private static @NotNull Component getMemoryComponent(long used,long max){
@@ -222,7 +286,7 @@ index 0000000000000000000000000000000000000000..fdd57d5825aced511a65ee056a773c1f
 +        final String content = "<%s><text></%s>";
 +        final String replaced = String.format(content,colorString,colorString);
 +
-+        return MiniMessage.miniMessage().deserialize(replaced,Placeholder.parsed("text", String.valueOf(used / 1024 * 1024)));
++        return MiniMessage.miniMessage().deserialize(replaced,Placeholder.parsed("text", String.format("%.2f", (double)used / (1024 * 1024))));
 +    }
 +
 +    private static BossBar.Color barColorFromMemory(double memPercent){
@@ -242,7 +306,7 @@ index 0000000000000000000000000000000000000000..fdd57d5825aced511a65ee056a773c1f
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-index 6f86f25efbd4e6e79476c1563dc8f4c114c10695..67f1205ec362bbb191b642641c45c7bcc53c7625 100644
+index 09bde51d3da062c5788151c15c448eaf2a02ea1b..dcdfc70e6c9b021b941a667f288ea09e3c1935e2 100644
 --- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
 @@ -851,6 +851,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface
@@ -254,7 +318,7 @@ index 6f86f25efbd4e6e79476c1563dc8f4c114c10695..67f1205ec362bbb191b642641c45c7bc
          //Util.shutdownExecutors(); // Paper - moved into super
          SkullBlockEntity.clear();
 diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index c04058a95dc4990cd8034b381f95affcdc77dd93..71bc115203933f3992315caf4e10ec8dc44955ba 100644
+index db32beabfa7ba17b1c46d36fa1dc27bc20e06feb..25bdaec097572ee58432516ae5983f4841587046 100644
 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
 +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
 @@ -303,6 +303,7 @@ public class ServerPlayer extends Player {

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

@@ -31,7 +31,7 @@ index 0000000000000000000000000000000000000000..502b93c7bda9e8577a1901a8777b7cf9
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
-index 09bde51d3da062c5788151c15c448eaf2a02ea1b..6f86f25efbd4e6e79476c1563dc8f4c114c10695 100644
+index dcdfc70e6c9b021b941a667f288ea09e3c1935e2..67f1205ec362bbb191b642641c45c7bcc53c7625 100644
 --- a/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
 +++ b/src/main/java/net/minecraft/server/dedicated/DedicatedServer.java
 @@ -294,7 +294,7 @@ public class DedicatedServer extends MinecraftServer implements ServerInterface

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

@@ -6,10 +6,10 @@ Subject: [PATCH] Try fixing folia spector teleportation
 
 diff --git a/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaSpectorTeleportationFixConfig.java b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaSpectorTeleportationFixConfig.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..8487799cdfb776eaca33b57f7c99ae3aeadb890d
+index 0000000000000000000000000000000000000000..01f8c6ff3662569be5a4ff998bcd4fbbcb555105
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaSpectorTeleportationFixConfig.java
-@@ -0,0 +1,20 @@
+@@ -0,0 +1,25 @@
 +package me.earthme.luminol.config.modules.fixes;
 +
 +import me.earthme.luminol.config.ConfigInfo;
@@ -17,7 +17,12 @@ index 0000000000000000000000000000000000000000..8487799cdfb776eaca33b57f7c99ae3a
 +import me.earthme.luminol.config.IConfigModule;
 +
 +public class FoliaSpectorTeleportationFixConfig implements IConfigModule {
-+    @ConfigInfo(baseName = "enabled")
++    @ConfigInfo(baseName = "enabled", comments =
++            """
++                    The teleportation of spector players would call absMoveTo directly.\s
++                    And when the camera teleported to another region,this would call absMoveTo\s
++                     to let the spector player move to another region without any checks, which \s
++                    would trigger the async catcher and crash the server""")
 +    public static boolean fixSpectorTeleportFolia = false;
 +
 +    @Override
@@ -31,10 +36,10 @@ index 0000000000000000000000000000000000000000..8487799cdfb776eaca33b57f7c99ae3a
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 11b5155820d38a42e62f68fe0f70fe4daf80f5d1..90f4cc0bd3722400411e6b1aa2d03205a350ee8a 100644
+index 25bdaec097572ee58432516ae5983f4841587046..4286420c207aa8920ae2966874b27aa81cbbc468 100644
 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
 +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -892,6 +892,11 @@ public class ServerPlayer extends Player {
+@@ -893,6 +893,11 @@ public class ServerPlayer extends Player {
          }
  
          Entity entity = this.getCamera();

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

@@ -6,10 +6,10 @@ Subject: [PATCH] Teleport async if entity was moving to another region at once
 
 diff --git a/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaEntityMovingFixConfig.java b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaEntityMovingFixConfig.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..73d99a105a18231901e691922b0c283adae0cc79
+index 0000000000000000000000000000000000000000..0e51d465db3554ac80d00c6b85cc1f013f3949ba
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaEntityMovingFixConfig.java
-@@ -0,0 +1,22 @@
+@@ -0,0 +1,28 @@
 +package me.earthme.luminol.config.modules.fixes;
 +
 +import me.earthme.luminol.config.ConfigInfo;
@@ -17,7 +17,13 @@ index 0000000000000000000000000000000000000000..73d99a105a18231901e691922b0c283a
 +import me.earthme.luminol.config.IConfigModule;
 +
 +public class FoliaEntityMovingFixConfig implements IConfigModule {
-+    @ConfigInfo(baseName = "enabled")
++    @ConfigInfo(baseName = "enabled", comments =
++            """
++                    A simple fix of a issue on folia\s
++                    (Some times the entity would\s
++                    have a large moment that cross the\s
++                    different tick regions and it would\s
++                    make the server crashed)  but sometimes it might doesn't work""")
 +    public static boolean enabled = false;
 +    @ConfigInfo(baseName = "warn_on_detected")
 +    public static boolean warnOnDetected = true;

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

@@ -6,10 +6,10 @@ Subject: [PATCH] Try fixing folia off region POI accessing issue
 
 diff --git a/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaPOIAccessOffRegionFixConfig.java b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaPOIAccessOffRegionFixConfig.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..343c85ded7e7abc22fac0aaeb7be786e9bd7b39a
+index 0000000000000000000000000000000000000000..7812a71f05dd32646037afd22cdabf72bb23b0d1
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaPOIAccessOffRegionFixConfig.java
-@@ -0,0 +1,20 @@
+@@ -0,0 +1,25 @@
 +package me.earthme.luminol.config.modules.fixes;
 +
 +import me.earthme.luminol.config.ConfigInfo;
@@ -17,7 +17,12 @@ index 0000000000000000000000000000000000000000..343c85ded7e7abc22fac0aaeb7be786e
 +import me.earthme.luminol.config.IConfigModule;
 +
 +public class FoliaPOIAccessOffRegionFixConfig implements IConfigModule {
-+    @ConfigInfo(baseName = "enabled")
++    @ConfigInfo(baseName = "enabled", comments =
++            """
++                    The POIManager of folia has something which has not been patched\s
++                     for regionized ticking and these would trigger the async catcher\s
++                    and make the server crash.If you would like to prevent it and didn't\s
++                    mind the side effect(currently unknown), you can enable this""")
 +    public static boolean enabled = false;
 +
 +    @Override

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

@@ -6,10 +6,10 @@ Subject: [PATCH] Prevent teleportAsync calling during moving event being
 
 diff --git a/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaTeleportAsyncFixConfig.java b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaTeleportAsyncFixConfig.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..b8aceab54bb60000e7c56810140271022f5147a2
+index 0000000000000000000000000000000000000000..8f1449545d6d217b46a9ffae705123daefe55b25
 --- /dev/null
 +++ b/src/main/java/me/earthme/luminol/config/modules/fixes/FoliaTeleportAsyncFixConfig.java
-@@ -0,0 +1,22 @@
+@@ -0,0 +1,24 @@
 +package me.earthme.luminol.config.modules.fixes;
 +
 +import me.earthme.luminol.config.ConfigInfo;
@@ -17,7 +17,9 @@ index 0000000000000000000000000000000000000000..b8aceab54bb60000e7c5681014027102
 +import me.earthme.luminol.config.IConfigModule;
 +
 +public class FoliaTeleportAsyncFixConfig implements IConfigModule {
-+    @ConfigInfo(baseName = "enabled")
++    @ConfigInfo(baseName = "enabled", comments =
++            "A fix which fixed some bugs of teleportAsync " +
++            "that caused by plugins(such as Residence)")
 +    public static boolean enabled = false;
 +    @ConfigInfo(baseName = "throw_on_detected")
 +    public static boolean throwOnDetected = true;
@@ -33,10 +35,10 @@ index 0000000000000000000000000000000000000000..b8aceab54bb60000e7c5681014027102
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 20f8c9bfdde62f1572e22319ebb752d12d9d5bac..24f4370b35d2cc50340de36d81b6c6d9aa250e4c 100644
+index 4286420c207aa8920ae2966874b27aa81cbbc468..eeb89cfdaf0fee522f0ff1eac43dfd85de329b9a 100644
 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
 +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -347,6 +347,10 @@ public class ServerPlayer extends Player {
+@@ -348,6 +348,10 @@ public class ServerPlayer extends Player {
      public double lastEntitySpawnRadiusSquared = -1.0;
      // Paper end - optimise chunk tick iteration
  

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

@@ -1,153 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: M2ke4U <79621885+MrHua269@users.noreply.github.com>
-Date: Sun, 26 Nov 2023 16:10:26 +0800
-Subject: [PATCH] Pufferfish Reduce entity fluid lookups if no fluids
-
-
-diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 94c9f407f526b2d43cf61725b414b113de03c67d..94bac805d032015587e88b4de3cf7064a534e736 100644
---- a/src/main/java/net/minecraft/world/entity/Entity.java
-+++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -5317,16 +5317,18 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-     }
- 
-     public boolean updateFluidHeightAndDoFluidPushing(TagKey<Fluid> tag, double speed) {
--        if (this.touchingUnloadedChunk()) {
-+        if (false && this.touchingUnloadedChunk()) { // Pufferfish - cost of a lookup here is the same cost as below, so skip
-             return false;
-         } else {
-             AABB axisalignedbb = this.getBoundingBox().deflate(0.001D);
--            int i = Mth.floor(axisalignedbb.minX);
--            int j = Mth.ceil(axisalignedbb.maxX);
--            int k = Mth.floor(axisalignedbb.minY);
--            int l = Mth.ceil(axisalignedbb.maxY);
--            int i1 = Mth.floor(axisalignedbb.minZ);
--            int j1 = Mth.ceil(axisalignedbb.maxZ);
-+            // Pufferfish start - rename
-+            int minBlockX = Mth.floor(axisalignedbb.minX);
-+            int maxBlockX = Mth.ceil(axisalignedbb.maxX);
-+            int minBlockY = Mth.floor(axisalignedbb.minY);
-+            int maxBlockY = Mth.ceil(axisalignedbb.maxY);
-+            int minBlockZ = Mth.floor(axisalignedbb.minZ);
-+            int maxBlockZ = Mth.ceil(axisalignedbb.maxZ);
-+            // Pufferfish end
-             double d1 = 0.0D;
-             boolean flag = this.isPushedByFluid();
-             boolean flag1 = false;
-@@ -5334,14 +5336,61 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-             int k1 = 0;
-             BlockPos.MutableBlockPos blockposition_mutableblockposition = new BlockPos.MutableBlockPos();
- 
--            for (int l1 = i; l1 < j; ++l1) {
--                for (int i2 = k; i2 < l; ++i2) {
--                    for (int j2 = i1; j2 < j1; ++j2) {
--                        blockposition_mutableblockposition.set(l1, i2, j2);
--                        FluidState fluid = this.level().getFluidState(blockposition_mutableblockposition);
-+            // Pufferfish start - based off CollisionUtil.getCollisionsForBlocksOrWorldBorder
-+            final int minSection = io.papermc.paper.util.WorldUtil.getMinSection(this.level());
-+            final int maxSection = io.papermc.paper.util.WorldUtil.getMaxSection(this.level());
-+            final int minBlock = minSection << 4;
-+            final int maxBlock = (maxSection << 4) | 15;
-+
-+            // special cases:
-+            if (minBlockY > maxBlock || maxBlockY < minBlock) {
-+                // no point in checking
-+                return false;
-+            }
-+
-+            int minYIterate = Math.max(minBlock, minBlockY);
-+            int maxYIterate = Math.min(maxBlock, maxBlockY);
-+
-+            int minChunkX = minBlockX >> 4;
-+            int maxChunkX = maxBlockX >> 4;
-+
-+            int minChunkZ = minBlockZ >> 4;
-+            int maxChunkZ = maxBlockZ >> 4;
-+
-+            for (int currChunkZ = minChunkZ; currChunkZ <= maxChunkZ; ++currChunkZ) {
-+                int minZ = currChunkZ == minChunkZ ? minBlockZ & 15 : 0; // coordinate in chunk
-+                int maxZ = currChunkZ == maxChunkZ ? maxBlockZ & 15 : 16; // coordinate in chunk
-+
-+                for (int currChunkX = minChunkX; currChunkX <= maxChunkX; ++currChunkX) {
-+                    int minX = currChunkX == minChunkX ? minBlockX & 15 : 0; // coordinate in chunk
-+                    int maxX = currChunkX == maxChunkX ? maxBlockX & 15 : 16; // coordinate in chunk
-+
-+                    net.minecraft.world.level.chunk.ChunkAccess chunk = this.level().getChunkIfLoadedImmediately(currChunkX, currChunkZ);
-+                    if (chunk == null) {
-+                        return false; // if we're touching an unloaded chunk then it's false
-+                    }
-+
-+                    net.minecraft.world.level.chunk.LevelChunkSection[] sections = chunk.getSections();
-+
-+                    for (int currY = minYIterate; currY < maxYIterate; ++currY) {
-+                        net.minecraft.world.level.chunk.LevelChunkSection section = sections[(currY >> 4) - minSection];
-+
-+                        if (section == null || section.hasOnlyAir() || section.fluidStateCount == 0) { // if no fluids, nothing in this section
-+                            // empty
-+                            // skip to next section
-+                            currY = (currY & ~(15)) + 15; // increment by 15: iterator loop increments by the extra one
-+                            continue;
-+                        }
-+
-+                        net.minecraft.world.level.chunk.PalettedContainer<BlockState> blocks = section.states;
-+
-+                        for (int currZ = minZ; currZ < maxZ; ++currZ) {
-+                            for (int currX = minX; currX < maxX; ++currX) {
-+                                FluidState fluid = blocks.get(currX & 15, currY & 15, currZ & 15).getFluidState();
- 
-                         if (fluid.is(tag)) {
--                            double d2 = (double) ((float) i2 + fluid.getHeight(this.level(), blockposition_mutableblockposition));
-+                            blockposition_mutableblockposition.set((currChunkX << 4) + currX, currY, (currChunkZ << 4) + currZ);
-+                            double d2 = (double) ((float) currY + fluid.getHeight(this.level(), blockposition_mutableblockposition));
- 
-                             if (d2 >= axisalignedbb.minY) {
-                                 flag1 = true;
-@@ -5363,9 +5412,12 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
-                                 // CraftBukkit end
-                             }
-                         }
-+                            }
-+                        }
-                     }
-                 }
-             }
-+            // Pufferfish end
- 
-             if (vec3d.length() > 0.0D) {
-                 if (k1 > 0) {
-diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
-index a2a5aef769ee8bb638a5a9f3da9812fa4a85dda5..7288261b8924d08e93abecb664e2273c624a325b 100644
---- a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
-+++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
-@@ -25,6 +25,7 @@ public class LevelChunkSection {
-     public final PalettedContainer<BlockState> states;
-     // CraftBukkit start - read/write
-     private PalettedContainer<Holder<Biome>> biomes;
-+    public short fluidStateCount; // Pufferfish
-     public final com.destroystokyo.paper.util.maplist.IBlockDataList tickingList = new com.destroystokyo.paper.util.maplist.IBlockDataList(); // Paper
-     // Paper start - optimise collisions
-     private int specialCollidingBlocks;
-@@ -102,6 +103,7 @@ public class LevelChunkSection {
- 
-         if (!fluid.isEmpty()) {
-             --this.tickingFluidCount;
-+            --this.fluidStateCount; // Pufferfish
-         }
- 
-         if (!state.isAir()) {
-@@ -116,6 +118,7 @@ public class LevelChunkSection {
- 
-         if (!fluid1.isEmpty()) {
-             ++this.tickingFluidCount;
-+            ++this.fluidStateCount; // Pufferfish
-         }
- 
-         this.updateBlockCallback(x, y, z, iblockdata1, state); // Paper - optimise collisions
-@@ -162,6 +165,7 @@ public class LevelChunkSection {
-                     if (fluid.isRandomlyTicking()) {
-                         this.tickingFluidCount = (short) (this.tickingFluidCount + 1);
-                     }
-+                this.fluidStateCount++; // Pufferfish
-                 }
- 
-                 // Paper start - optimise collisions

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

@@ -0,0 +1,218 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Sun, 16 Jun 2024 10:56:41 +0000
+Subject: [PATCH] Pufferfish Reduce entity fluid lookups if no fluids
+
+
+diff --git a/src/main/java/me/earthme/luminol/config/modules/optimizations/ReduceEntityFluidLookupConfig.java b/src/main/java/me/earthme/luminol/config/modules/optimizations/ReduceEntityFluidLookupConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0523b3da3fb254bce1998bae6410c6323ccac2ef
+--- /dev/null
++++ b/src/main/java/me/earthme/luminol/config/modules/optimizations/ReduceEntityFluidLookupConfig.java
+@@ -0,0 +1,20 @@
++package me.earthme.luminol.config.modules.optimizations;
++
++import me.earthme.luminol.config.ConfigInfo;
++import me.earthme.luminol.config.EnumConfigCategory;
++import me.earthme.luminol.config.IConfigModule;
++
++public class ReduceEntityFluidLookupConfig implements IConfigModule {
++    @ConfigInfo(baseName = "enabled", comments = "See the optimization on Pufferfish")
++    public static boolean enabled = true;
++
++    @Override
++    public EnumConfigCategory getCategory() {
++        return EnumConfigCategory.OPTIMIZATIONS;
++    }
++
++    @Override
++    public String getBaseName() {
++        return "reduce_entity_fluid_lookups_if_no_fluids";
++    }
++}
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 94c9f407f526b2d43cf61725b414b113de03c67d..46369f332765d5995d7d6884d9b0dd3151729160 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -5320,6 +5320,11 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         if (this.touchingUnloadedChunk()) {
+             return false;
+         } else {
++            //Luminol start - Configurable pufferfish optimization: Reduce entity fluid lookups if no fluids
++            if (me.earthme.luminol.config.modules.optimizations.ReduceEntityFluidLookupConfig.enabled){
++                return this.updateFluidHeightAndDoFluidPushingPufferfish$half(tag, speed);
++            }
++            //Luminol end
+             AABB axisalignedbb = this.getBoundingBox().deflate(0.001D);
+             int i = Mth.floor(axisalignedbb.minX);
+             int j = Mth.ceil(axisalignedbb.maxX);
+@@ -5393,6 +5398,133 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         }
+     }
+ 
++    //Luminol start - Configurable pufferfish optimization: Reduce entity fluid lookups if no fluids
++    private boolean updateFluidHeightAndDoFluidPushingPufferfish$half(TagKey<Fluid> tag, double speed) {
++        AABB axisalignedbb = this.getBoundingBox().deflate(0.001D);
++        // Pufferfish start - rename
++        int minBlockX = Mth.floor(axisalignedbb.minX);
++        int maxBlockX = Mth.ceil(axisalignedbb.maxX);
++        int minBlockY = Mth.floor(axisalignedbb.minY);
++        int maxBlockY = Mth.ceil(axisalignedbb.maxY);
++        int minBlockZ = Mth.floor(axisalignedbb.minZ);
++        int maxBlockZ = Mth.ceil(axisalignedbb.maxZ);
++        // Pufferfish end
++        double d1 = 0.0D;
++        boolean flag = this.isPushedByFluid();
++        boolean flag1 = false;
++        Vec3 vec3d = Vec3.ZERO;
++        int k1 = 0;
++        BlockPos.MutableBlockPos blockposition_mutableblockposition = new BlockPos.MutableBlockPos();
++
++        // Pufferfish start - based off CollisionUtil.getCollisionsForBlocksOrWorldBorder
++        final int minSection = io.papermc.paper.util.WorldUtil.getMinSection(this.level());
++        final int maxSection = io.papermc.paper.util.WorldUtil.getMaxSection(this.level());
++        final int minBlock = minSection << 4;
++        final int maxBlock = (maxSection << 4) | 15;
++
++        // special cases:
++        if (minBlockY > maxBlock || maxBlockY < minBlock) {
++            // no point in checking
++            return false;
++        }
++
++        int minYIterate = Math.max(minBlock, minBlockY);
++        int maxYIterate = Math.min(maxBlock, maxBlockY);
++
++        int minChunkX = minBlockX >> 4;
++        int maxChunkX = maxBlockX >> 4;
++
++        int minChunkZ = minBlockZ >> 4;
++        int maxChunkZ = maxBlockZ >> 4;
++
++        for (int currChunkZ = minChunkZ; currChunkZ <= maxChunkZ; ++currChunkZ) {
++            int minZ = currChunkZ == minChunkZ ? minBlockZ & 15 : 0; // coordinate in chunk
++            int maxZ = currChunkZ == maxChunkZ ? maxBlockZ & 15 : 16; // coordinate in chunk
++
++            for (int currChunkX = minChunkX; currChunkX <= maxChunkX; ++currChunkX) {
++                int minX = currChunkX == minChunkX ? minBlockX & 15 : 0; // coordinate in chunk
++                int maxX = currChunkX == maxChunkX ? maxBlockX & 15 : 16; // coordinate in chunk
++
++                net.minecraft.world.level.chunk.ChunkAccess chunk = this.level().getChunkIfLoadedImmediately(currChunkX, currChunkZ);
++                if (chunk == null) {
++                    return false; // if we're touching an unloaded chunk then it's false
++                }
++
++                net.minecraft.world.level.chunk.LevelChunkSection[] sections = chunk.getSections();
++
++                for (int currY = minYIterate; currY < maxYIterate; ++currY) {
++                    net.minecraft.world.level.chunk.LevelChunkSection section = sections[(currY >> 4) - minSection];
++
++                    if (section == null || section.hasOnlyAir() || section.fluidStateCount == 0) { // if no fluids, nothing in this section
++                        // empty
++                        // skip to next section
++                        currY = (currY & ~(15)) + 15; // increment by 15: iterator loop increments by the extra one
++                        continue;
++                    }
++
++                    net.minecraft.world.level.chunk.PalettedContainer<BlockState> blocks = section.states;
++
++                    for (int currZ = minZ; currZ < maxZ; ++currZ) {
++                        for (int currX = minX; currX < maxX; ++currX) {
++                            FluidState fluid = blocks.get(currX & 15, currY & 15, currZ & 15).getFluidState();
++
++                            if (fluid.is(tag)) {
++                                blockposition_mutableblockposition.set((currChunkX << 4) + currX, currY, (currChunkZ << 4) + currZ);
++                                double d2 = (double) ((float) currY + fluid.getHeight(this.level(), blockposition_mutableblockposition));
++
++                                if (d2 >= axisalignedbb.minY) {
++                                    flag1 = true;
++                                    d1 = Math.max(d2 - axisalignedbb.minY, d1);
++                                    if (flag) {
++                                        Vec3 vec3d1 = fluid.getFlow(this.level(), blockposition_mutableblockposition);
++
++                                        if (d1 < 0.4D) {
++                                            vec3d1 = vec3d1.scale(d1);
++                                        }
++
++                                        vec3d = vec3d.add(vec3d1);
++                                        ++k1;
++                                    }
++                                    // CraftBukkit start - store last lava contact location
++                                    if (tag == FluidTags.LAVA) {
++                                        this.lastLavaContact = blockposition_mutableblockposition.immutable();
++                                    }
++                                    // CraftBukkit end
++                                }
++                            }
++                        }
++                    }
++                }
++            }
++        }
++        // Pufferfish end
++
++        if (vec3d.length() > 0.0D) {
++            if (k1 > 0) {
++                vec3d = vec3d.scale(1.0D / (double) k1);
++            }
++
++            if (!(this instanceof Player)) {
++                vec3d = vec3d.normalize();
++            }
++
++            Vec3 vec3d2 = this.getDeltaMovement();
++
++            vec3d = vec3d.scale(speed * 1.0D);
++            double d3 = 0.003D;
++
++            if (Math.abs(vec3d2.x) < 0.003D && Math.abs(vec3d2.z) < 0.003D && vec3d.length() < 0.0045000000000000005D) {
++                vec3d = vec3d.normalize().scale(0.0045000000000000005D);
++            }
++
++            this.setDeltaMovement(this.getDeltaMovement().add(vec3d));
++        }
++
++        this.fluidHeight.put(tag, d1);
++        return flag1;
++    }
++    //Luminol end
++
+     public boolean touchingUnloadedChunk() {
+         AABB axisalignedbb = this.getBoundingBox().inflate(1.0D);
+         int i = Mth.floor(axisalignedbb.minX);
+diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
+index a2a5aef769ee8bb638a5a9f3da9812fa4a85dda5..7288261b8924d08e93abecb664e2273c624a325b 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
++++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
+@@ -25,6 +25,7 @@ public class LevelChunkSection {
+     public final PalettedContainer<BlockState> states;
+     // CraftBukkit start - read/write
+     private PalettedContainer<Holder<Biome>> biomes;
++    public short fluidStateCount; // Pufferfish
+     public final com.destroystokyo.paper.util.maplist.IBlockDataList tickingList = new com.destroystokyo.paper.util.maplist.IBlockDataList(); // Paper
+     // Paper start - optimise collisions
+     private int specialCollidingBlocks;
+@@ -102,6 +103,7 @@ public class LevelChunkSection {
+ 
+         if (!fluid.isEmpty()) {
+             --this.tickingFluidCount;
++            --this.fluidStateCount; // Pufferfish
+         }
+ 
+         if (!state.isAir()) {
+@@ -116,6 +118,7 @@ public class LevelChunkSection {
+ 
+         if (!fluid1.isEmpty()) {
+             ++this.tickingFluidCount;
++            ++this.fluidStateCount; // Pufferfish
+         }
+ 
+         this.updateBlockCallback(x, y, z, iblockdata1, state); // Paper - optimise collisions
+@@ -162,6 +165,7 @@ public class LevelChunkSection {
+                     if (fluid.isRandomlyTicking()) {
+                         this.tickingFluidCount = (short) (this.tickingFluidCount + 1);
+                     }
++                this.fluidStateCount++; // Pufferfish
+                 }
+ 
+                 // Paper start - optimise collisions

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

@@ -31,10 +31,10 @@ index 0000000000000000000000000000000000000000..ed62d25d6cd6dfcf8c5db20ced36eb3d
 +    }
 +}
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 18c6fe66fa944f5e5b7892df4d8fef4c7346d3bc..a9e32fba699c718011abc52d91ec7158ab22b5ea 100644
+index 2be071c9c4a0e9e32d08f0694903e6b25aa35042..f946655347a3a2b83351e67c9be4beb0d63de32d 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -5515,6 +5515,16 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -5595,6 +5595,16 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
          return this.inBlockState;
      }
  

patches/server/0053-KioCG-Chunk-API.patch

@@ -183,10 +183,10 @@ index 12c46e7a3f6a8675921d95dee97ece4a83252282..573cca66b905c5decb0e59c58cfa861d
          } else {
              passenger.stopRiding();
 diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-index 24f4370b35d2cc50340de36d81b6c6d9aa250e4c..c04058a95dc4990cd8034b381f95affcdc77dd93 100644
+index eeb89cfdaf0fee522f0ff1eac43dfd85de329b9a..71bc115203933f3992315caf4e10ec8dc44955ba 100644
 --- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
 +++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
-@@ -351,6 +351,25 @@ public class ServerPlayer extends Player {
+@@ -352,6 +352,25 @@ public class ServerPlayer extends Player {
      public boolean handlingMoveEvent = false;
      //Luminol end
  
@@ -212,7 +212,7 @@ index 24f4370b35d2cc50340de36d81b6c6d9aa250e4c..c04058a95dc4990cd8034b381f95affc
      public ServerPlayer(MinecraftServer server, ServerLevel world, GameProfile profile, ClientInformation clientOptions) {
          super(world, world.getSharedSpawnPos(), world.getSharedSpawnAngle(), profile);
          this.chatVisibility = ChatVisiblity.FULL;
-@@ -923,6 +942,12 @@ public class ServerPlayer extends Player {
+@@ -924,6 +943,12 @@ public class ServerPlayer extends Player {
          this.trackEnteredOrExitedLavaOnVehicle();
          this.updatePlayerAttributes();
          this.advancements.flushDirty(this);
@@ -242,10 +242,10 @@ index ee972fa1a2bc023ed18eaceae21c8c8244754e6a..0fe6afb51246701309c88febeb61aaf7
 +    // KioCG end
  }
 diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
-index 546063255bf29cba839d73cf2778a798150658f5..00d801aa1ffce0ccd8e7176f614d831ae09259d3 100644
+index eb3eedad69fae7119bb5d995c30cac6ed9f44a14..81c97ae378c35b7faeaca103b7b9240e7bd0d90c 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -5957,4 +5957,6 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+@@ -6037,4 +6037,6 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
          return ((net.minecraft.server.level.ServerChunkCache) level.getChunkSource()).isPositionTicking(this);
      }
      // Paper end - Expose entity id counter