fix: fix global entity count max limit problem

if latest task is not done, skip this tick so that we can not block thread and run the task have not done, after it done, the new data will be processed in the next tick

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -1,7 +1,7 @@
 name: Bug反馈 Bug report
 description:
   报告Bug，插件不兼容情况，以及其他相关问题。
-  Report issues with plugin incompatbility or other behavior related issues.
+  Report issues with plugin incompatibility or other behavior related issues.
 labels:
   - bug
   - pending
@@ -25,7 +25,7 @@ body:
         LophineMC服务端发行版本 LophineMC server release version (contains the git commit's hash)<br>
         通过执行`/version`命令将获取到的内容复制到这里。 Run `/version` on your server and paste the full, unmodified output here.
       placeholder: >
-        e.g. git-Lophine-"0635a89" (MC: 1.20.4)
+        e.g. git-Lophine-"fa1ab90" (MC: 1.21.8)
     validations:
       required: true
   - type: textarea
@@ -41,7 +41,7 @@ body:
     attributes:
       label: 观测到的实际行为 Observed/Actual behavior
       description: 你实际看到的。 What you actually saw.
-      placeholder: e.g. 使用 /tpsbar [NAME] 命令切换不了TPSBAR
+      placeholder: e.g. 使用 /tpsbar 命令切换不了TPSBAR
     validations:
       required: true
   - type: textarea
@@ -65,6 +65,20 @@ body:
         To list plugins, run `/plugins`. For datapacks, run `/datapack list`.
     validations:
       required: true
+  - type: textarea
+    id: config-file-list
+    attributes:
+      label: 配置文件列表（如果可以）。 Config File List (if possible).
+      description:
+        服务器上的配置文件列表。
+        All config files on your server.
+        例如以下文件（或者文件夹）：
+        Example files (or folders)：
+         - \spigot.yml
+         - \bukkit.yml
+         - \config\\\*
+         - \lophine_config\\\*
+         - \luminol_config\\\*
   - type: textarea
     id: other
     attributes:

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -28,7 +28,7 @@ body:
     validations:
       required: true
   - type: textarea
-    id: othre
+    id: other
     attributes:
       label: 其他 Other
       description: 添加其他的信息。 Add any other context or screenshots about the feature request below.

.github/workflows/build.yml

@@ -30,7 +30,7 @@ jobs:
     environment: default
     steps:
       - name: Checkout Git Repository
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
 
       - name: Set Up JDK
         uses: actions/setup-java@v5

gradle.properties

@@ -4,7 +4,7 @@ mcVersion=1.21.8
 release=2
 # 0 for skip release, 1 for pre-release, 2 for release
 
-luminolRef=3032dbc331d34b229440b8935287711bf2557306
+luminolRef=1958fdc8b66b75b23a001490288cc618a76808e3
 
 org.gradle.configuration-cache=true
 org.gradle.caching=true

lophine-server/luminol-patches/features/0001-Rebrand-to-Lophine.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Rebrand to Lophine
 
 
 diff --git a/src/main/java/me/earthme/luminol/config/ConfigManager.java b/src/main/java/me/earthme/luminol/config/ConfigManager.java
-index a5208f5426ea2e5d8f50c51fe17718ea1d63eef5..c80c578f1a3786bd7413c9a7af8ae125fe7975bb 100644
+index 0bebc2cc87fb9c1c526e4de4f3bc157552307a72..cb1657939b86c039fcfe6403d3f202c2c5879e88 100644
 --- a/src/main/java/me/earthme/luminol/config/ConfigManager.java
 +++ b/src/main/java/me/earthme/luminol/config/ConfigManager.java
-@@ -21,6 +21,7 @@ public class ConfigManager {
+@@ -23,6 +23,7 @@ public class ConfigManager {
  
      public static void initConfigs() {
          configfiles.put("luminol", ConfigsInstance.of("luminol", "me.earthme.luminol.config.modules"));

lophine-server/minecraft-patches/features/0036-Instant-Block-Updater.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Instant Block Updater
 
 
 diff --git a/io/papermc/paper/threadedregions/RegionizedWorldData.java b/io/papermc/paper/threadedregions/RegionizedWorldData.java
-index f3d07efc347ff3cd06011484af0e75b5d93e6ec7..52f520667abba68af88834a771b6bcb40d1bd806 100644
+index d0de3b22f6cef6eb213b7ff688a514a67f84fbcf..3b39b8f7ccb278cf910e3cc4e00da29790465a81 100644
 --- a/io/papermc/paper/threadedregions/RegionizedWorldData.java
 +++ b/io/papermc/paper/threadedregions/RegionizedWorldData.java
-@@ -519,7 +519,7 @@ public final class RegionizedWorldData {
+@@ -524,7 +524,7 @@ public final class RegionizedWorldData {
          this.world = world;
          this.blockLevelTicks = new LevelTicks<>(world::isPositionTickingWithEntitiesLoaded, world, true);
          this.fluidLevelTicks = new LevelTicks<>(world::isPositionTickingWithEntitiesLoaded, world, false);

lophine-server/minecraft-patches/features/0041-Global-Entities-Counter.patch

@@ -0,0 +1,136 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Wed, 3 Dec 2025 16:28:34 +0800
+Subject: [PATCH] Global Entities Counter
+
+
+diff --git a/io/papermc/paper/threadedregions/RegionizedWorldData.java b/io/papermc/paper/threadedregions/RegionizedWorldData.java
+index 3b39b8f7ccb278cf910e3cc4e00da29790465a81..7cc41630a39c1e29840d70eee78473d06b7c11cd 100644
+--- a/io/papermc/paper/threadedregions/RegionizedWorldData.java
++++ b/io/papermc/paper/threadedregions/RegionizedWorldData.java
+@@ -520,6 +520,9 @@ public final class RegionizedWorldData {
+     public final Map<Long, ChunkSectionItemEntityMovementTracker> itemEntityMovementTrackerMap = new it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap<>();
+     // Luminol end
+ 
++    public int uniqueId = -1; // Lophine - Global Entities Counter
++    public boolean underGlobalEntitiesCounter = false; // Lophine - Global Entities Counter
++
+     public RegionizedWorldData(final ServerLevel world) {
+         this.world = world;
+         this.blockLevelTicks = new LevelTicks<>(world::isPositionTickingWithEntitiesLoaded, world, true);
+@@ -529,6 +532,15 @@ public final class RegionizedWorldData {
+         this.wireHandler = new alternate.current.wire.WireHandler(world);
+         this.turbo = new io.papermc.paper.redstone.RedstoneWireTurbo((RedStoneWireBlock)Blocks.REDSTONE_WIRE);
+ 
++        // Lophine start - Global Entities Counter
++        if (fun.bm.lophine.config.modules.experiment.GlobalEntitiesCounter.enabled) {
++            uniqueId = fun.bm.lophine.utils.EntitiesCounterUtil.generateUniqueId();
++            fun.bm.lophine.utils.EntitiesCounterUtil.reportAreaMap(world, spawnChunkTracker, uniqueId);
++            fun.bm.lophine.utils.EntitiesCounterUtil.addDataToLoaded(world, loadedEntities, uniqueId);
++            underGlobalEntitiesCounter = true;
++        }
++        // Lophine end - Global Entities Counter
++
+         // tasks may be drained before the region ticks, so we must set up the tick data early just in case
+         this.updateTickData();
+     }
+diff --git a/net/minecraft/server/level/ServerChunkCache.java b/net/minecraft/server/level/ServerChunkCache.java
+index 05bad0366bd36b8134290a0cceb4d4dfcbbd0544..604681c8fda696dcc824b1b36b53c0d8434ec5c2 100644
+--- a/net/minecraft/server/level/ServerChunkCache.java
++++ b/net/minecraft/server/level/ServerChunkCache.java
+@@ -516,6 +516,25 @@ public class ServerChunkCache extends ChunkSource implements ca.spottedleaf.moon
+         this.chunkMap.tick(hasTimeLeft);
+         profilerFiller.pop();
+         this.clearCache();
++        // Lophine start - Global Entities Counter
++        if (fun.bm.lophine.config.modules.experiment.GlobalEntitiesCounter.enabled) {
++            io.papermc.paper.threadedregions.RegionizedWorldData regionizedWorldData = this.level.getCurrentWorldData();
++            if (regionizedWorldData != null) {
++                if (regionizedWorldData.underGlobalEntitiesCounter) {
++                    if (regionizedWorldData.getLocalPlayers().isEmpty()) {
++                        fun.bm.lophine.utils.EntitiesCounterUtil.onWorldDataUnload(level, regionizedWorldData.uniqueId);
++                        regionizedWorldData.underGlobalEntitiesCounter = false;
++                    }
++                } else {
++                    if (!regionizedWorldData.getLocalPlayers().isEmpty()) {
++                        fun.bm.lophine.utils.EntitiesCounterUtil.reportAreaMap(level, regionizedWorldData.spawnChunkTracker, regionizedWorldData.uniqueId);
++                        fun.bm.lophine.utils.EntitiesCounterUtil.addDataToLoaded(level, (ca.spottedleaf.moonrise.common.list.ReferenceList<Entity>) regionizedWorldData.getLoadedEntities(), regionizedWorldData.uniqueId);
++                        regionizedWorldData.underGlobalEntitiesCounter = true;
++                    }
++                }
++            }
++        }
++        // Lophine end - Global Entities Counter
+     }
+ 
+     private void tickChunks() {
+@@ -580,7 +599,13 @@ public class ServerChunkCache extends ChunkSource implements ca.spottedleaf.moon
+             }
+             spawnState = NaturalSpawner.createState(naturalSpawnChunkCount, regionizedWorldData.getLoadedEntities(), this::getFullChunk, null, true); // Folia - region threading - note: function only cares about loaded entities, doesn't need all
+         } else {
++            // Lophine start - Global Entities Counter
++            if (fun.bm.lophine.config.modules.experiment.GlobalEntitiesCounter.enabled) {
++                spawnState = fun.bm.lophine.utils.EntitiesCounterUtil.runRemainingTasks(level, regionizedWorldData.getLoadedEntities(), this::getFullChunk, !this.level.paperConfig().entities.spawning.perPlayerMobSpawns ? new LocalMobCapCalculator(this.chunkMap) : null, false);
++            } else {
+             spawnState = NaturalSpawner.createState(naturalSpawnChunkCount, regionizedWorldData.getLoadedEntities(), this::getFullChunk, !this.level.paperConfig().entities.spawning.perPlayerMobSpawns ? new LocalMobCapCalculator(this.chunkMap) : null, false); // Folia - region threading - note: function only cares about loaded entities, doesn't need all
++            }
++            // Lophine end - Global Entities Counter
+         }
+         } finally { foliaProfiler.stopTimer(ca.spottedleaf.leafprofiler.LProfilerRegistry.MOB_SPAWN_ENTITY_COUNT); } // Folia - profiler
+         // Paper end - Optional per player mob spawns
+@@ -589,7 +614,7 @@ public class ServerChunkCache extends ChunkSource implements ca.spottedleaf.moon
+         boolean _boolean = this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && !this.level.getLocalPlayers().isEmpty(); // CraftBukkit // Folia - region threading
+         int _int = this.level.getGameRules().getInt(GameRules.RULE_RANDOMTICKING);
+         List<MobCategory> filteredSpawningCategories;
+-        if (_boolean && (this.spawnEnemies || this.spawnFriendlies)) {
++        if (spawnState != null && _boolean && (this.spawnEnemies || this.spawnFriendlies)) { // Lophine - Global Entities Counter
+             // Paper start - PlayerNaturallySpawnCreaturesEvent
+             for (ServerPlayer entityPlayer : this.level.getLocalPlayers()) { // Folia - region threading
+                 int chunkRange = Math.min(level.spigotConfig.mobSpawnRange, entityPlayer.getBukkitEntity().getViewDistance());
+@@ -646,7 +671,7 @@ public class ServerChunkCache extends ChunkSource implements ca.spottedleaf.moon
+             this.level.tickThunder(chunk);
+         }
+ 
+-        if (!spawnCategories.isEmpty()) {
++        if (spawnState != null && !spawnCategories.isEmpty()) { // Lophine - Global Entities Counter
+             if (this.level.getWorldBorder().isWithinBounds(pos)) { // Paper - rewrite chunk system
+                 NaturalSpawner.spawnForChunk(this.level, chunk, spawnState, spawnCategories);
+             }
+diff --git a/net/minecraft/server/level/ServerLevel.java b/net/minecraft/server/level/ServerLevel.java
+index c0ba36849da0983117901f0cd04b2c785df0010b..0b0d9322632ef1a751add633bdcb87ec84f82704 100644
+--- a/net/minecraft/server/level/ServerLevel.java
++++ b/net/minecraft/server/level/ServerLevel.java
+@@ -729,6 +729,11 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+     }
+ 
+     public void tick(BooleanSupplier hasTimeLeft, io.papermc.paper.threadedregions.TickRegions.TickRegionData region) { // Folia - regionised ticking
++        // Lophine start - Global Entities Counter
++        if (fun.bm.lophine.config.modules.experiment.GlobalEntitiesCounter.enabled) {
++            if (fun.bm.lophine.utils.EntitiesCounterUtil.canRunNewTask(this)) fun.bm.lophine.utils.EntitiesCounterUtil.tick(this);
++        }
++        // Lophine end - Global Entities Counter
+         final io.papermc.paper.threadedregions.RegionizedWorldData regionizedWorldData = this.getCurrentWorldData(); // Folia - regionised ticking
+         final ca.spottedleaf.leafprofiler.RegionizedProfiler.Handle profiler = io.papermc.paper.threadedregions.TickRegionScheduler.getProfiler(); // Folia - profiler
+         ProfilerFiller profilerFiller = Profiler.get();
+diff --git a/net/minecraft/world/level/NaturalSpawner.java b/net/minecraft/world/level/NaturalSpawner.java
+index 81f4707cf1a7cbdfcfc519cfbe1052cde77aa755..5c53e2d61ce8483d5d9e93e9f3112074c704a546 100644
+--- a/net/minecraft/world/level/NaturalSpawner.java
++++ b/net/minecraft/world/level/NaturalSpawner.java
+@@ -113,7 +113,7 @@ public final class NaturalSpawner {
+         return new NaturalSpawner.SpawnState(spawnableChunkCount, map, potentialCalculator, calculator);
+     }
+ 
+-    static Biome getRoughBiome(BlockPos pos, ChunkAccess chunk) {
++    public static Biome getRoughBiome(BlockPos pos, ChunkAccess chunk) { // Lophine - protected -> public
+         return chunk.getNoiseBiome(QuartPos.fromBlock(pos.getX()), QuartPos.fromBlock(pos.getY()), QuartPos.fromBlock(pos.getZ())).value();
+     }
+ 
+@@ -584,7 +584,7 @@ public final class NaturalSpawner {
+         private EntityType<?> lastCheckedType;
+         private double lastCharge;
+ 
+-        SpawnState(
++        public SpawnState( // Lophine - protected -> public
+             int spawnableChunkCount,
+             Object2IntOpenHashMap<MobCategory> mobCategoryCounts,
+             PotentialCalculator spawnPotential,

lophine-server/paper-patches/features/0007-add-cancel-task-by-task-id-in-FoliaGlobalRegionSched.patch

@@ -0,0 +1,101 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Sat, 22 Nov 2025 01:43:26 +0800
+Subject: [PATCH] add cancel task by task id in FoliaGlobalRegionScheduler
+
+
+diff --git a/src/main/java/io/papermc/paper/threadedregions/scheduler/FoliaGlobalRegionScheduler.java b/src/main/java/io/papermc/paper/threadedregions/scheduler/FoliaGlobalRegionScheduler.java
+index d306f911757a4d556c82c0070d4837db87afc497..7c9d3e4c399b2ea246a76b4550ba12e45e75078e 100644
+--- a/src/main/java/io/papermc/paper/threadedregions/scheduler/FoliaGlobalRegionScheduler.java
++++ b/src/main/java/io/papermc/paper/threadedregions/scheduler/FoliaGlobalRegionScheduler.java
+@@ -17,6 +17,8 @@ public class FoliaGlobalRegionScheduler implements GlobalRegionScheduler {
+     private long tickCount = 0L;
+     private final Object stateLock = new Object();
+     private final Long2ObjectOpenHashMap<List<GlobalScheduledTask>> tasksByDeadline = new Long2ObjectOpenHashMap<>();
++    private int lastTaskId = 1; // Lophine - add task id
++    private final Object stateLockForTaskId = new Object(); // Lophine - add task id
+ 
+     public void tick() {
+         final List<GlobalScheduledTask> run;
+@@ -65,7 +67,7 @@ public class FoliaGlobalRegionScheduler implements GlobalRegionScheduler {
+             throw new IllegalPluginAccessException("Plugin attempted to register task while disabled");
+         }
+ 
+-        final GlobalScheduledTask ret = new GlobalScheduledTask(plugin, -1, task);
++        final GlobalScheduledTask ret = new GlobalScheduledTask(plugin, -1, task, this.getNextTaskId()); // Lophine - add task id
+ 
+         this.scheduleInternal(ret, delayTicks);
+ 
+@@ -92,7 +94,7 @@ public class FoliaGlobalRegionScheduler implements GlobalRegionScheduler {
+             throw new IllegalPluginAccessException("Plugin attempted to register task while disabled");
+         }
+ 
+-        final GlobalScheduledTask ret = new GlobalScheduledTask(plugin, periodTicks, task);
++        final GlobalScheduledTask ret = new GlobalScheduledTask(plugin, periodTicks, task, this.getNextTaskId()); // Lophine - add task id
+ 
+         this.scheduleInternal(ret, initialDelayTicks);
+ 
+@@ -134,7 +136,33 @@ public class FoliaGlobalRegionScheduler implements GlobalRegionScheduler {
+         }
+     }
+ 
+-    private final class GlobalScheduledTask implements ScheduledTask, Runnable {
++    // Lophine start - add cancel task by task id
++    public void cancelTask(final int taskId) {
++        synchronized (this.stateLock) {
++            for (final List<GlobalScheduledTask> tasks : this.tasksByDeadline.values()) {
++                for (final GlobalScheduledTask task : tasks) {
++                    if (task.getTaskId() == taskId) {
++                        task.cancel();
++                        return;
++                    }
++                }
++            }
++        }
++    }
++
++    private int getNextTaskId() {
++        synchronized (this.stateLockForTaskId) {
++            if (this.lastTaskId == Integer.MAX_VALUE) {
++                this.lastTaskId = 1;
++            } else {
++                ++this.lastTaskId;
++            }
++        }
++        return this.lastTaskId;
++    }
++    // Lophine end - add cancel task by task id
++
++    public final class GlobalScheduledTask implements ScheduledTask, Runnable { // Lophine - private -> public
+ 
+         private static final int STATE_IDLE                = 0;
+         private static final int STATE_EXECUTING           = 1;
+@@ -146,13 +174,15 @@ public class FoliaGlobalRegionScheduler implements GlobalRegionScheduler {
+         private final long repeatDelay; // in ticks
+         private Consumer<ScheduledTask> run;
+         private volatile int state;
++        private int taskId; // Lophine - add task id
+ 
+         private static final VarHandle STATE_HANDLE = ConcurrentUtil.getVarHandle(GlobalScheduledTask.class, "state", int.class);
+ 
+-        private GlobalScheduledTask(final Plugin plugin, final long repeatDelay, final Consumer<ScheduledTask> run) {
++        private GlobalScheduledTask(final Plugin plugin, final long repeatDelay, final Consumer<ScheduledTask> run, int taskId) { // Lophine - add task id
+             this.plugin = plugin;
+             this.repeatDelay = repeatDelay;
+             this.run = run;
++            this.taskId = taskId; // Lophine - add task id
+         }
+ 
+         private final int getStateVolatile() {
+@@ -263,5 +293,11 @@ public class FoliaGlobalRegionScheduler implements GlobalRegionScheduler {
+                 }
+             }
+         }
++
++        // Lophine start - add task id
++        public int getTaskId() {
++            return taskId;
++        }
++        // Lophine end - add task id
+     }
+ }

lophine-server/src/main/java/fun/bm/lophine/LophineLogger.java

@@ -3,8 +3,6 @@ package fun.bm.lophine;
 import com.mojang.logging.LogUtils;
 import org.slf4j.Logger;
 
-import java.util.logging.Level;
-
 public class LophineLogger {
     public static final Logger LOGGER = LogUtils.getClassLogger(); // only provided for some Logger can not be initialized
 }

lophine-server/src/main/java/fun/bm/lophine/config/modules/experiment/GlobalEntitiesCounter.java

@@ -0,0 +1,20 @@
+package fun.bm.lophine.config.modules.experiment;
+
+import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
+import me.earthme.luminol.config.flags.ConfigInfo;
+import me.earthme.luminol.config.flags.HotReloadUnsupported;
+import me.earthme.luminol.enums.EnumConfigCategory;
+
+@ConfigClassInfo(name = "global_entities_counter", category = EnumConfigCategory.EXPERIMENT)
+public class GlobalEntitiesCounter implements IConfigModule {
+    @HotReloadUnsupported
+    @ConfigInfo(name = "enabled", comments = """
+            Enable global entities counter.
+            You need to set per-player-mob-spawns to false on paper-world-defaults.yml or paper-world.yml""")
+    public static boolean enabled = false;
+
+    @HotReloadUnsupported
+    @ConfigInfo(name = "async", comments = "Enable Asynchronous(maybe cause bugs)")
+    public static boolean async = false;
+}

lophine-server/src/main/java/fun/bm/lophine/config/modules/experiment/RedStoneConfig.java

@@ -6,10 +6,11 @@ import me.earthme.luminol.config.flags.ConfigInfo;
 import me.earthme.luminol.config.flags.HotReloadUnsupported;
 import me.earthme.luminol.config.flags.TransformedConfig;
 import me.earthme.luminol.enums.EnumConfigCategory;
+
 /*
-* This is a config module for redstone in experimental level
-* If we think configs from here is stable for future, we will move them to function module directory
-*/
+ * This is a config module for redstone in experimental level
+ * If we think configs from here is stable for future, we will move them to function module directory
+ */
 @ConfigClassInfo(category = EnumConfigCategory.EXPERIMENT, name = "redstone")
 public class RedStoneConfig implements IConfigModule {
     @TransformedConfig(name = "enabled", directory = {"experiment", "redstone-ignore-upwards-update"})

lophine-server/src/main/java/fun/bm/lophine/config/modules/fixes/UpdateSuppressionCrashFixConfig.java

@@ -8,6 +8,6 @@ import me.earthme.luminol.enums.EnumConfigCategory;
 @ConfigClassInfo(category = EnumConfigCategory.FIXES, name = "update-suppression-crash-fix")
 public class UpdateSuppressionCrashFixConfig implements IConfigModule {
     @ConfigInfo(name = "enabled", comments = """
-            Should crashes caused by update suppression be prevented?""")
+            Should crash caused by update suppression be prevented?""")
     public static boolean enabled = true;
 }

lophine-server/src/main/java/fun/bm/lophine/utils/EntitiesCounterUtil.java

@@ -0,0 +1,184 @@
+package fun.bm.lophine.utils;
+
+import ca.spottedleaf.moonrise.common.list.ReferenceList;
+import ca.spottedleaf.moonrise.common.misc.PositionCountingAreaMap;
+import fun.bm.lophine.config.modules.experiment.GlobalEntitiesCounter;
+import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.Mob;
+import net.minecraft.world.entity.MobCategory;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.LocalMobCapCalculator;
+import net.minecraft.world.level.NaturalSpawner;
+import net.minecraft.world.level.PotentialCalculator;
+import net.minecraft.world.level.biome.MobSpawnSettings;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.WeakHashMap;
+import java.util.concurrent.CompletableFuture;
+
+import static net.minecraft.world.level.NaturalSpawner.getRoughBiome;
+
+public class EntitiesCounterUtil {
+    private static final WeakHashMap<ServerLevel, WeakHashMap<Integer, ReferenceList<Entity>>> globalLoadedEntities = new WeakHashMap<>();
+    private static final WeakHashMap<ServerLevel, Object2IntOpenHashMap<MobCategory>> mobsMap = new WeakHashMap<>();
+    private static final WeakHashMap<ServerLevel, WeakHashMap<Integer, PositionCountingAreaMap<ServerPlayer>>> mobsAreaMap = new WeakHashMap<>();
+    private static final WeakHashMap<ServerLevel, Integer> spawnableChunkCount = new WeakHashMap<>();
+    private static final WeakHashMap<ServerLevel, CompletableFuture<Void>> tasks = new WeakHashMap<>();
+    private static final Set<Integer> UniqueIds = new HashSet<>();
+
+    private static int lastUsedId = 0;
+
+    public static int generateUniqueId() {
+        synchronized (UniqueIds) {
+            int id = lastUsedId;
+            while (UniqueIds.contains(id)) {
+                id++;
+            }
+
+            lastUsedId = id;
+            UniqueIds.add(id);
+            return id;
+        }
+    }
+
+    public static void onWorldDataUnload(ServerLevel level, int uniqueId) {
+        synchronized (UniqueIds) {
+            UniqueIds.remove(uniqueId);
+        }
+        synchronized (globalLoadedEntities) {
+            globalLoadedEntities.get(level).remove(uniqueId);
+        }
+        synchronized (mobsMap) {
+            mobsAreaMap.get(level).remove(uniqueId);
+        }
+    }
+
+    public static void addDataToLoaded(ServerLevel level, ReferenceList<Entity> data, int uniqueId) {
+        WeakHashMap<Integer, ReferenceList<Entity>> data0 = globalLoadedEntities.computeIfAbsent(level, k -> new WeakHashMap<>());
+        if (data0.containsKey(uniqueId)) return;
+        data0.put(uniqueId, data);
+    }
+
+    public static void reportAreaMap(ServerLevel level, PositionCountingAreaMap<ServerPlayer> areaMap, int uniqueId) {
+        WeakHashMap<Integer, PositionCountingAreaMap<ServerPlayer>> areaMap0 = mobsAreaMap.computeIfAbsent(level, k -> new WeakHashMap<>());
+        if (areaMap0.containsKey(uniqueId)) return;
+        areaMap0.put(uniqueId, areaMap);
+    }
+
+    public static int getTotalChunkCount(ServerLevel level) {
+        return spawnableChunkCount.getOrDefault(level, 0);
+    }
+
+    public static @Nullable Object2IntOpenHashMap<MobCategory> getMobsMap(ServerLevel level) {
+        return mobsMap.get(level);
+    }
+
+    public static boolean canRunNewTask(ServerLevel level) {
+        CompletableFuture<Void> task = tasks.get(level);
+        return task == null || task.isDone();
+    }
+
+    public static void tick(ServerLevel level) {
+        Runnable task = () -> {
+            WeakHashMap<Integer, ReferenceList<Entity>> data0 = globalLoadedEntities.get(level);
+            Object2IntOpenHashMap<MobCategory> map = new Object2IntOpenHashMap<>();
+            for (ReferenceList<Entity> data : data0.values()) {
+                for (Entity entity : GlobalEntitiesCounter.enabled ? data.copy() : data) {
+                    // Lophine start - Copy from net/minecraft/world/level/NaturalSpawner
+                    MobCategory category = entity.getType().getCategory();
+                    if (category != MobCategory.MISC) {
+                        // Paper start - Only count natural spawns
+                        if (!entity.level().paperConfig().entities.spawning.countAllMobsForSpawning &&
+                                !(entity.spawnReason == CreatureSpawnEvent.SpawnReason.NATURAL ||
+                                        entity.spawnReason == CreatureSpawnEvent.SpawnReason.CHUNK_GEN)) {
+                            continue;
+                        }
+                        // Paper end - Only count natural spawns
+                        map.addTo(category, 1);
+                    }
+                    // Lophine start - Copy from net/minecraft/world/level/NaturalSpawner
+                }
+            }
+            mobsMap.put(level, map);
+            for (ServerLevel world : mobsAreaMap.keySet()) {
+                int count = 0;
+                WeakHashMap<Integer, PositionCountingAreaMap<ServerPlayer>> collection = mobsAreaMap.get(level);
+                if (collection == null) continue;
+                for (PositionCountingAreaMap<ServerPlayer> areaMap : collection.values()) {
+                    count += areaMap.getTotalPositions();
+                }
+                spawnableChunkCount.put(world, count);
+            }
+        };
+        if (GlobalEntitiesCounter.async) {
+            tasks.put(level, CompletableFuture.runAsync(task));
+        } else {
+            task.run();
+        }
+    }
+
+    public static NaturalSpawner.SpawnState runRemainingTasks(
+            ServerLevel level, Iterable<Entity> entities, NaturalSpawner.ChunkGetter chunkGetter, LocalMobCapCalculator calculator, final boolean countMobs
+    ) {
+        Object2IntOpenHashMap<MobCategory> map = getMobsMap(level);
+        if (map == null) return null; // skip if no data
+        // Lophine start - Copy from net/minecraft/world/level/NaturalSpawner
+        PotentialCalculator potentialCalculator = new PotentialCalculator();
+        for (Entity entity : entities) {
+            // Paper start - Only count natural spawns
+            if (!entity.level().paperConfig().entities.spawning.countAllMobsForSpawning &&
+                    !(entity.spawnReason == CreatureSpawnEvent.SpawnReason.NATURAL ||
+                            entity.spawnReason == CreatureSpawnEvent.SpawnReason.CHUNK_GEN)) {
+                continue;
+            }
+            // Paper end - Only count natural spawns
+            BlockPos blockPos = entity.blockPosition();
+            chunkGetter.query(ChunkPos.asLong(blockPos), chunk -> {
+                MobSpawnSettings.MobSpawnCost mobSpawnCost = getRoughBiome(blockPos, chunk).getMobSettings().getMobSpawnCost(entity.getType());
+                if (mobSpawnCost != null) {
+                    potentialCalculator.addCharge(entity.blockPosition(), mobSpawnCost.charge());
+                }
+
+                if (calculator != null && entity instanceof Mob) { // Paper - Optional per player mob spawns
+                    calculator.addMob(chunk.getPos(), entity.getType().getCategory());
+                }
+
+                // Paper start - Optional per player mob spawns
+                if (countMobs) {
+                    chunk.level.getChunkSource().chunkMap.updatePlayerMobTypeMap(entity);
+                }
+                // Paper end - Optional per player mob spawns
+            });
+        }
+        return new NaturalSpawner.SpawnState(getTotalChunkCount(level), map, potentialCalculator, calculator);
+        // Lophine end - Copy from net/minecraft/world/level/NaturalSpawner
+    }
+
+    public static class ChunkCounter {
+        private final int chunkCount;
+        private int timeout = 20;
+
+        public void tick() {
+            timeout--;
+        }
+
+        public ChunkCounter(int chunkCount) {
+            this.chunkCount = chunkCount;
+        }
+
+        public boolean timeout() {
+            return timeout <= 0;
+        }
+
+        public int getChunkCount() {
+            return chunkCount;
+        }
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/LeavesConfig.java

@@ -0,0 +1,4 @@
+package org.leavesmc.leaves;
+
+public class LeavesConfig {
+}

lophine-server/src/main/java/org/leavesmc/leaves/bot/BotList.java

@@ -25,6 +25,7 @@ import com.mojang.logging.LogUtils;
 import fun.bm.lophine.config.modules.function.FakeplayerConfig;
 import io.papermc.paper.adventure.PaperAdventure;
 import io.papermc.paper.threadedregions.RegionizedServer;
+import io.papermc.paper.threadedregions.scheduler.FoliaGlobalRegionScheduler;
 import net.kyori.adventure.text.format.NamedTextColor;
 import net.kyori.adventure.text.format.Style;
 import net.minecraft.nbt.CompoundTag;
@@ -238,7 +239,7 @@ public class BotList {
         }
 
         if (bot.removeTaskId != -1) {
-            Bukkit.getScheduler().cancelTask(bot.removeTaskId);
+            ((FoliaGlobalRegionScheduler) Bukkit.getGlobalRegionScheduler()).cancelTask(bot.removeTaskId);
             bot.removeTaskId = -1;
         }
 

lophine-server/src/main/java/org/leavesmc/leaves/bot/ServerBot.java

@@ -473,7 +473,7 @@ public class ServerBot extends ServerPlayer {
 
         playerConnection.send(this.getAddEntityPacket(entityTracker.serverEntity));
         if (login) {
-            Bukkit.getScheduler().runTaskLater(MinecraftInternalPlugin.INSTANCE, () -> playerConnection.send(new ClientboundRotateHeadPacket(this, (byte) ((getYRot() * 256f) / 360f))), 10);
+            Bukkit.getGlobalRegionScheduler().runDelayed(MinecraftInternalPlugin.INSTANCE, (unused) -> playerConnection.send(new ClientboundRotateHeadPacket(this, (byte) ((getYRot() * 256f) / 360f))), 10);
         } else {
             playerConnection.send(new ClientboundRotateHeadPacket(this, (byte) ((getYRot() * 256f) / 360f)));
         }
@@ -499,7 +499,7 @@ public class ServerBot extends ServerPlayer {
         Component defaultMessage = this.getCombatTracker().getDeathMessage();
 
         BotDeathEvent event = new BotDeathEvent(this.getBukkitEntity(), PaperAdventure.asAdventure(defaultMessage), flag);
-        this.getServer().server.getPluginManager().callEvent(event);
+        MinecraftServer.getServer().server.getPluginManager().callEvent(event);
 
         if (event.isCancelled()) {
             if (this.getHealth() <= 0) {

lophine-server/src/main/java/org/leavesmc/leaves/command/bot/subcommands/RemoveCommand.java

@@ -20,6 +20,7 @@ package org.leavesmc.leaves.command.bot.subcommands;
 import com.mojang.brigadier.arguments.StringArgumentType;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import io.papermc.paper.adventure.PaperAdventure;
+import io.papermc.paper.threadedregions.scheduler.FoliaGlobalRegionScheduler;
 import net.minecraft.world.entity.LivingEntity;
 import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
@@ -102,12 +103,12 @@ public class RemoveCommand extends BotSubcommand {
             boolean isReschedule = bot.removeTaskId != -1;
 
             if (isReschedule) {
-                Bukkit.getScheduler().cancelTask(bot.removeTaskId);
+                ((FoliaGlobalRegionScheduler) Bukkit.getGlobalRegionScheduler()).cancelTask(bot.removeTaskId);
             }
-            bot.removeTaskId = Bukkit.getScheduler().runTaskLater(MinecraftInternalPlugin.INSTANCE, () -> {
+            bot.removeTaskId = ((FoliaGlobalRegionScheduler.GlobalScheduledTask) Bukkit.getGlobalRegionScheduler().runDelayed(MinecraftInternalPlugin.INSTANCE, (unused) -> {
                 bot.removeTaskId = -1;
                 removeBot(bot, sender);
-            }, removeTimeSeconds * 20L).getTaskId();
+            }, removeTimeSeconds * 20L)).getTaskId();
 
             sender.sendMessage(join(spaces(),
                     text("Bot", GRAY),

lophine-server/src/main/java/org/leavesmc/leaves/protocol/servux/ServuxEntityDataProtocol.java

@@ -17,6 +17,7 @@
 
 package org.leavesmc.leaves.protocol.servux;
 
+import ca.spottedleaf.moonrise.common.util.TickThread;
 import com.mojang.logging.LogUtils;
 import fun.bm.lophine.config.modules.function.protocol.ServuxProtocolConfig;
 import io.netty.buffer.Unpooled;
@@ -31,6 +32,7 @@ import net.minecraft.util.RandomSource;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.phys.Vec3;
 import org.leavesmc.leaves.protocol.core.LeavesCustomPayload;
 import org.leavesmc.leaves.protocol.core.LeavesProtocol;
 import org.leavesmc.leaves.protocol.core.ProtocolHandler;
@@ -104,6 +106,7 @@ public class ServuxEntityDataProtocol implements LeavesProtocol {
 
     public static void onBlockEntityRequest(ServerPlayer player, BlockPos pos) {
         player.getBukkitEntity().taskScheduler.schedule((LivingEntity nmsEntity) -> {
+            if (!TickThread.isTickThreadFor(nmsEntity.level(), pos)) return;
             BlockEntity be = nmsEntity.level().getBlockEntity(pos);
             CompoundTag nbt = be != null ? be.saveWithFullMetadata(nmsEntity.registryAccess()) : new CompoundTag();
 
@@ -115,7 +118,9 @@ public class ServuxEntityDataProtocol implements LeavesProtocol {
     }
 
     public static void onEntityRequest(ServerPlayer player, int entityId) {
+        final Vec3 pos = player.position();
         player.getBukkitEntity().taskScheduler.schedule((LivingEntity nmsEntity) -> {
+            if (!TickThread.isTickThreadFor(nmsEntity.level(), pos)) return;
             Entity entity = nmsEntity.level().getEntity(entityId);
             CompoundTag nbt = TagUtil.saveEntityWithoutId(entity);
 

lophine-server/src/main/java/org/leavesmc/leaves/protocol/servux/ServuxStructuresProtocol.java

@@ -103,7 +103,7 @@ public class ServuxStructuresProtocol implements LeavesProtocol {
         final ChunkPos pos = chunk.getPos();
 
         if (chunkHasStructureReferences(pos.x, pos.z, chunk.getLevel())) {
-            final Map<ChunkPos, Timeout> map = timeouts.computeIfAbsent(uuid, (u) -> new HashMap<>());
+            final Map<ChunkPos, Timeout> map = timeouts.computeIfAbsent(uuid, (u) -> new ConcurrentHashMap<>());
             map.computeIfAbsent(pos, (p) -> new Timeout(tickCounter - ServuxProtocolConfig.maxDelay));
         }
     }
@@ -304,7 +304,7 @@ public class ServuxStructuresProtocol implements LeavesProtocol {
     }
 
     public static void addOrRefreshTimeouts(final UUID uuid, final Map<Structure, LongSet> references, final long tickCounter) {
-        Map<ChunkPos, Timeout> map = timeouts.computeIfAbsent(uuid, (u) -> new HashMap<>());
+        Map<ChunkPos, Timeout> map = timeouts.computeIfAbsent(uuid, (u) -> new ConcurrentHashMap<>());
 
         for (LongSet chunks : references.values()) {
             for (Long chunkPosLong : chunks) {