Added config for secondary POI optimizations

patches/server/0053-Teleport-async-if-the-entity-was-moving-to-another-r.patch

@@ -0,0 +1,80 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Fri, 26 Jan 2024 10:58:48 +0000
+Subject: [PATCH] Teleport async if the entity was moving to another region
+
+
+diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
+index e91061b96701bc46f5a6ed8315eb6c8da8a74f3a..55d0ae641f1de570a293d1d6fe03da3ab2bba1c4 100644
+--- a/src/main/java/me/earthme/luminol/LuminolConfig.java
++++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
+@@ -43,6 +43,8 @@ public class LuminolConfig {
+     public static boolean enableVoidTrading = false;
+     public static boolean allowIncorrectTripwireUpdating = false;
+     public static boolean useVanillaRandomSource = false;
++    public static boolean fixLargePosMoving = false;
++    public static boolean warnOnLargeMovingDetected = true;
+ 
+     public static RegionFileFormat regionFormatName = RegionFileFormat.ANVIL;
+     public static int regionFormatLinearCompressionLevel = 1;
+@@ -165,6 +167,8 @@ public class LuminolConfig {
+         enableVoidTrading = get("fixes.enable_void_trading",enableVoidTrading);
+         allowIncorrectTripwireUpdating = get("fixes.allow_incorrect_trip_wire_updaing",allowIncorrectTripwireUpdating);
+         useVanillaRandomSource = get("fixes.use_vanilla_random_source",useVanillaRandomSource,"RNG feature related");
++        fixLargePosMoving = get("fixes.fix_large_pos_moving", fixLargePosMoving,"Fix an entity moving issue on folia which is not fixed yet");
++        warnOnLargeMovingDetected = get("fixes.warn_on_large_pos_moving",warnOnLargeMovingDetected);
+ 
+         regionFormatName = RegionFileFormat.fromString(get("save.region-format.format", regionFormatName.name()));
+         if (regionFormatName.equals(RegionFileFormat.INVALID)) {
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 9bd6d4881280196a437161a9375ac8ee5e0f9231..18fdb265714584d4ee759d86cc8a10b13742e153 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -7,6 +7,7 @@ import com.google.common.collect.Lists;
+ import com.google.common.collect.Sets;
+ import com.google.common.collect.UnmodifiableIterator;
+ import com.mojang.logging.LogUtils;
++import io.papermc.paper.util.TickThread;
+ import it.unimi.dsi.fastutil.objects.Object2DoubleArrayMap;
+ import it.unimi.dsi.fastutil.objects.Object2DoubleMap;
+ import java.util.Arrays;
+@@ -1084,9 +1085,39 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+     }
+     // Paper end - detailed watchdog information
+ 
++    //Luminol start - Fix large pos moving
++    private volatile boolean preventMoving = false;
++    //Luminol end
++
+     public void move(MoverType movementType, Vec3 movement) {
+         // Paper start - detailed watchdog information
+         io.papermc.paper.util.TickThread.ensureTickThread("Cannot move an entity off-main");
++        //Luminol start - Fix high position moving
++        if (LuminolConfig.fixLargePosMoving && TickThread.isTickThread()){ //Except the threads because it may be called by the chunk system worker thread
++            if (this.preventMoving){
++                return;
++            }
++
++            var finalPosition = movement.add(this.position);
++            if (!TickThread.isTickThreadFor(((ServerLevel) this.level),finalPosition)){
++                this.preventMoving = true;
++                this.teleportAsync(
++                        (ServerLevel) this.level(),
++                        finalPosition,
++                        this.getYRot(), this.getXRot(),
++                        null, PlayerTeleportEvent.TeleportCause.UNKNOWN,
++                        Entity.TELEPORT_FLAG_LOAD_CHUNK | Entity.TELEPORT_FLAG_TELEPORT_PASSENGERS,
++                        result -> {
++                            this.preventMoving = false;
++                        }
++                );
++                if (LuminolConfig.warnOnLargeMovingDetected){
++                    MinecraftServer.LOGGER.warn("Entity {} with entityId {} has tried moving to another region!",this.type.getCategory().getName(),this.getId());
++                }
++                return;
++            }
++        }
++        //Luminol end
+         synchronized (this.posLock) {
+             this.moveStartX = this.getX();
+             this.moveStartY = this.getY();

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

@@ -0,0 +1,50 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Sun, 28 Jan 2024 09:51:56 +0000
+Subject: [PATCH] Sparkly Paper Optimize canSee checks
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
+index 4709782f3e858edfa6ce25696462eb45909885ee..3cba356b74362c2fc010d0c1bfb6eeecb449908e 100644
+--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
++++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
+@@ -1419,7 +1419,7 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+                 // Folia end - region threading
+ 
+                 // CraftBukkit start - respect vanish API
+-                if (flag && (!io.papermc.paper.util.TickThread.isTickThreadFor(player) || !player.getBukkitEntity().canSee(this.entity.getBukkitEntity()))) { // Paper - only consider hits // Folia - region threading
++                if (flag && (!io.papermc.paper.util.TickThread.isTickThreadFor(player) || !player.getBukkitEntity().canSeeChunkMapUpdatePlayer(this.entity.getBukkitEntity()))) { // Paper - only consider hits // Folia - region threading // SparklyPaper - optimize canSee checks
+                     flag = false;
+                 }
+                 // CraftBukkit end
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 06c92a2d3ecb3b747c2303819f72c1c41967af8c..7ae6925732c347ec97c94c5fdfd0012fbe6820fc 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -183,7 +183,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     private boolean hasPlayedBefore = false;
+     private final ConversationTracker conversationTracker = new ConversationTracker();
+     private final Set<String> channels = new HashSet<String>();
+-    private final Map<UUID, Set<WeakReference<Plugin>>> invertedVisibilityEntities = new HashMap<>();
++    private final Map<UUID, Set<WeakReference<Plugin>>> invertedVisibilityEntities = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(); // SparklyPaper - optimize canSee checks
+     private final Set<UUID> unlistedEntities = new HashSet<>(); // Paper
+     private static final WeakHashMap<Plugin, WeakReference<Plugin>> pluginWeakReferences = new WeakHashMap<>();
+     private int hash = 0;
+@@ -2075,9 +2075,16 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+ 
+     @Override
+     public boolean canSee(org.bukkit.entity.Entity entity) {
+-        return this.equals(entity) || entity.isVisibleByDefault() ^ this.invertedVisibilityEntities.containsKey(entity.getUniqueId()); // SPIGOT-7312: Can always see self
++        return this.equals(entity) || entity.isVisibleByDefault() ^ (!invertedVisibilityEntities.isEmpty() && this.invertedVisibilityEntities.containsKey(entity.getUniqueId())); // SPIGOT-7312: Can always see self // SparklyPaper - optimize canSee checks
+     }
+ 
++    // SparklyPaper - optimize canSee checks
++    // The check in ChunkMap#updatePlayer already rejects if it is the same entity, so we don't need to check it twice, especially because CraftPlayer's equals check is a bit expensive
++    public boolean canSeeChunkMapUpdatePlayer(org.bukkit.entity.Entity entity) {
++        return entity.isVisibleByDefault() ^ (!invertedVisibilityEntities.isEmpty() && this.invertedVisibilityEntities.containsKey(entity.getUniqueId())); // SPIGOT-7312: Can always see self // SparklyPaper - optimize canSee checks
++    }
++    // SparklyPaper end
++
+     public boolean canSee(UUID uuid) {
+         org.bukkit.entity.Entity entity = this.getServer().getPlayer(uuid);
+         if (entity == null) {

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

@@ -0,0 +1,42 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Sun, 28 Jan 2024 09:52:09 +0000
+Subject: [PATCH] Gale Skip entity move if movement is zero
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 18fdb265714584d4ee759d86cc8a10b13742e153..ec255db477e6308cc0fbe336b7bebeac75b97b2a 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -317,6 +317,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+     public float yRotO;
+     public float xRotO;
+     private AABB bb;
++    private boolean boundingBoxChanged = false; // Gale - VMP - skip entity move if movement is zero
+     public boolean onGround;
+     public boolean horizontalCollision;
+     public boolean verticalCollision;
+@@ -1090,6 +1091,11 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+     //Luminol end
+ 
+     public void move(MoverType movementType, Vec3 movement) {
++        // Gale start - VMP - skip entity move if movement is zero
++        if (!this.boundingBoxChanged && movement.equals(Vec3.ZERO)) {
++            return;
++        }
++        // Gale end - VMP - skip entity move if movement is zero
+         // Paper start - detailed watchdog information
+         io.papermc.paper.util.TickThread.ensureTickThread("Cannot move an entity off-main");
+         //Luminol start - Fix high position moving
+@@ -4875,6 +4881,11 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+     }
+ 
+     public final void setBoundingBox(AABB boundingBox) {
++        // Gale start - VMP - skip entity move if movement is zero
++        if (!this.bb.equals(boundingBox)) {
++            this.boundingBoxChanged = true;
++        }
++        // Gale end - VMP - skip entity move if movement is zero
+         // CraftBukkit start - block invalid bounding boxes
+         double minX = boundingBox.minX,
+                 minY = boundingBox.minY,

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

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

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

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Sun, 28 Jan 2024 09:52:48 +0000
+Subject: [PATCH] Gale Don't trigger lootable refresh for non-player
+ interaction
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
+index 02364a148b347e3669275553004391e31d77c0b5..6c6ed0e9877c7e0c9804f3c2c786a61c301e318f 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/RandomizableContainerBlockEntity.java
+@@ -70,6 +70,7 @@ public abstract class RandomizableContainerBlockEntity extends BaseContainerBloc
+     }
+ 
+     public void unpackLootTable(@Nullable Player player) {
++        if (player == null) return; // Gale - EMC - don't trigger lootable refresh for non-player interaction
+         if (this.level != null && this.lootableData.shouldReplenish(player) && this.level.getServer() != null) { // Paper - don't unpack loot table if not in world
+             LootTable lootTable = this.level.getServer().getLootData().getLootTable(this.lootTable);
+             if (player instanceof ServerPlayer) {

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

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

patches/server/0059-Added-config-for-secondary-POI-optimizations.patch

@@ -0,0 +1,56 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: MrHua269 <novau233@163.com>
+Date: Sun, 28 Jan 2024 10:48:45 +0000
+Subject: [PATCH] Added config for secondary POI optimizations
+
+
+diff --git a/src/main/java/me/earthme/luminol/LuminolConfig.java b/src/main/java/me/earthme/luminol/LuminolConfig.java
+index 55d0ae641f1de570a293d1d6fe03da3ab2bba1c4..e531453e3d25700e38ff41548c7e32e278a6304d 100644
+--- a/src/main/java/me/earthme/luminol/LuminolConfig.java
++++ b/src/main/java/me/earthme/luminol/LuminolConfig.java
+@@ -68,6 +68,7 @@ public class LuminolConfig {
+     public static int asyncPathProcessingKeepalive = 60;
+     public static boolean enableAsyncMobSpawning = false;
+     public static boolean useAlternateKeepAlive = false;
++    public static boolean skipSecondaryPOIIfIsEmpty = true;
+ 
+     public static boolean pcaSyncProtocol = false;
+     public static String pcaSyncPlayerEntity = "NOBODY";
+@@ -211,6 +212,7 @@ public class LuminolConfig {
+         enableAsyncMobSpawning = get("optimizations.enable_async_mob_spawning",enableAsyncMobSpawning);
+         RegionizedWorldData.initMobSpawningExecutor();
+         useAlternateKeepAlive = get("optimizations.enable_alternative_keep_alive_handling",useAlternateKeepAlive,"Enabling this sends a keepalive packet once per second to a player, and only kicks for timeout if none of them were responded to in 30 seconds. Responding to any of them in any order will keep the player connected. AKA, it won't kick your players because one packet gets dropped somewhere along the lines(From purpur)");
++        skipSecondaryPOIIfIsEmpty = get("optimizations.skip_secondary_poi_if_is_empty",skipSecondaryPOIIfIsEmpty);
+ 
+         pcaSyncProtocol = get("gameplay.enable_pca_sync_protocol",pcaSyncProtocol);
+         pcaSyncPlayerEntity = get("gameplay.pca_sync_player_entity",pcaSyncPlayerEntity,"Available values: NOBODY,EVERYBODY,OPS,OPS_AND_SELF");
+diff --git a/src/main/java/net/minecraft/world/entity/ai/sensing/SecondaryPoiSensor.java b/src/main/java/net/minecraft/world/entity/ai/sensing/SecondaryPoiSensor.java
+index 75dc06a3041bfdfb08c914eb50cfa282ae9eb2fe..6a95fe3f648a54b3cbb2b38a294028043c8012c9 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/sensing/SecondaryPoiSensor.java
++++ b/src/main/java/net/minecraft/world/entity/ai/sensing/SecondaryPoiSensor.java
+@@ -4,6 +4,8 @@ import com.google.common.collect.ImmutableSet;
+ import com.google.common.collect.Lists;
+ import java.util.List;
+ import java.util.Set;
++
++import me.earthme.luminol.LuminolConfig;
+ import net.minecraft.core.BlockPos;
+ import net.minecraft.core.GlobalPos;
+ import net.minecraft.resources.ResourceKey;
+@@ -23,10 +25,12 @@ public class SecondaryPoiSensor extends Sensor<Villager> {
+     @Override
+     protected void doTick(ServerLevel world, Villager entity) {
+         // Gale start - Lithium - skip secondary POI sensor if absent
+-        var secondaryPoi = entity.getVillagerData().getProfession().secondaryPoi();
+-        if (secondaryPoi.isEmpty()) {
+-            entity.getBrain().eraseMemory(MemoryModuleType.SECONDARY_JOB_SITE);
+-            return;
++        if (LuminolConfig.skipSecondaryPOIIfIsEmpty){
++            var secondaryPoi = entity.getVillagerData().getProfession().secondaryPoi();
++            if (secondaryPoi.isEmpty()) {
++                entity.getBrain().eraseMemory(MemoryModuleType.SECONDARY_JOB_SITE);
++                return;
++            }
+         }
+         // Gale end - Lithium - skip secondary POI sensor if absent
+         ResourceKey<Level> resourceKey = world.dimension();