fix: zero new island on large protection ranges via incremental capture

src/main/java/world/bentobox/level/Level.java

@@ -46,6 +46,7 @@
 import world.bentobox.level.listeners.IslandActivitiesListeners;
 import world.bentobox.level.listeners.JoinLeaveListener;
 import world.bentobox.level.listeners.MigrationListener;
+import world.bentobox.level.listeners.NewChunkListener;
 import world.bentobox.level.requests.LevelRequestHandler;
 import world.bentobox.level.requests.TopTenRequestHandler;
 import world.bentobox.visit.VisitAddon;
@@ -154,6 +155,10 @@ private void registerAllListeners() {
  registerListener(new IslandActivitiesListeners(this));
  registerListener(new JoinLeaveListener(this));
  registerListener(new MigrationListener(this));
+ // Accumulates generator block points into initialCount as new chunks
+ // are generated, so large protection ranges work with zero-new-island
+ // mode without forcing the initial scan to generate the whole area.
+ registerListener(new NewChunkListener(this));
  }
 
  private void registerGameModeCommands() {

src/main/java/world/bentobox/level/LevelsManager.java

@@ -480,7 +480,7 @@ public void removeEntry(World world, String uuid) {
 
  /**
  * Set an initial island count
- *
+ *
  * @param island - the island to set.
  * @param lv - initial island count
  */
@@ -489,6 +489,27 @@ public void setInitialIslandCount(@NonNull Island island, long lv) {
  handler.saveObjectAsync(levelsCache.get(island.getUniqueId()));
  }
 
+ /**
+ * Add a delta to the island's initial-count handicap. Used by the new-chunk
+ * listener to accumulate generator block points (sea floor, nether ceiling,
+ * etc.) into the initial count as chunks are generated during normal play.
+ * The initial count is subtracted from the live block total in the level
+ * calc, so generator blocks do not inflate the level.
+ *
+ * @param island the island
+ * @param delta the points to add (no-op when zero)
+ */
+ public void addToInitialCount(@NonNull Island island, long delta) {
+ if (delta == 0) {
+ return;
+ }
+ // Use getInitialCount so any legacy initialLevel is migrated first.
+ long current = getInitialCount(island);
+ IslandLevels data = getLevelsData(island);
+ data.setInitialCount(current + delta);
+ handler.saveObjectAsync(data);
+ }
+
  /**
  * Set the island level for the owner of the island that targetPlayer is a
  * member

src/main/java/world/bentobox/level/calculators/IslandLevelCalculator.java

@@ -366,8 +366,14 @@ private void loadChunks(CompletableFuture<List<Chunk>> r2, World world, Queue<Pa
  return;
  }
  Pair<Integer, Integer> p = pairList.poll();
- // We need to generate now all the time because some game modes are not voids
- Util.getChunkAtAsync(world, p.x, p.z, true).thenAccept(chunk -> {
+ // For zero-island scans, do not force chunk generation. Forcing the
+ // generator for every chunk in a large protection range (e.g. 1000 →
+ // ~16k chunks/dim) blows past the calculation timeout. Generator
+ // blocks that appear later (sea floor, nether ceiling, etc.) are
+ // picked up incrementally by NewChunkListener as chunks generate
+ // during normal play. Regular scans still generate, because some game
+ // modes are not voids.
+ Util.getChunkAtAsync(world, p.x, p.z, !zeroIsland).thenAccept(chunk -> {
  if (chunk != null) {
  chunkList.add(chunk);
  roseStackerCheck(chunk);

src/main/java/world/bentobox/level/listeners/NewChunkListener.java

@@ -0,0 +1,134 @@
+package world.bentobox.level.listeners;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.ChunkSnapshot;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.ChunkLoadEvent;
+
+import world.bentobox.bentobox.database.objects.Island;
+import world.bentobox.level.Level;
+
+/**
+ * Listens for freshly-generated chunks inside an island's protected area and
+ * adds the chunk's generator block points to the island's initial-count
+ * handicap.
+ * <p>
+ * Together with the {@code gen=false} initial zero scan in
+ * {@link world.bentobox.level.calculators.IslandLevelCalculator}, this lets
+ * zero-new-island-level mode work on islands with very large protection
+ * ranges. The initial scan only records what is already generated at island
+ * creation time (typically just the schematic chunks). As the player
+ * explores and new chunks are generated, this listener accumulates their
+ * generator block points into the initial count so they cancel out of the
+ * regular level calc — players only get credit for blocks they actually
+ * place.
+ */
+public class NewChunkListener implements Listener {
+
+ /**
+ * Snapshot of the main-thread state needed to score one chunk on a worker
+ * thread. Bundled into a record so the async scan helpers don't need to
+ * carry a dozen parameters each.
+ */
+ private record ScanContext(World world, int chunkBlockX, int chunkBlockZ, int minHeight, int maxHeight,
+ int minProtectedX, int maxProtectedX, int minProtectedZ, int maxProtectedZ,
+ int seaHeight, double underwaterMultiplier) {
+ }
+
+ private final Level addon;
+
+ public NewChunkListener(Level addon) {
+ this.addon = addon;
+ }
+
+ @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+ public void onChunkLoad(ChunkLoadEvent e) {
+ if (!e.isNewChunk()) {
+ return;
+ }
+ if (!addon.getSettings().isZeroNewIslandLevels()) {
+ return;
+ }
+ Chunk chunk = e.getChunk();
+ World world = chunk.getWorld();
+ if (!addon.isRegisteredGameModeWorld(world)) {
+ return;
+ }
+ // Use the chunk centre to look up the island that owns it.
+ // The + 8.0 keeps the addition in double arithmetic so SonarQube does not
+ // flag a theoretical int-overflow before the implicit widening.
+ Location centre = new Location(world, (chunk.getX() << 4) + 8.0, world.getMinHeight(),
+ (chunk.getZ() << 4) + 8.0);
+ Island island = addon.getIslands().getIslandAt(centre).orElse(null);
+ if (island == null || island.getOwner() == null) {
+ return;
+ }
+ // Capture all main-thread state before going async.
+ ChunkSnapshot snapshot = chunk.getChunkSnapshot();
+ ScanContext ctx = new ScanContext(world, chunk.getX() << 4, chunk.getZ() << 4,
+ world.getMinHeight(), world.getMaxHeight(),
+ island.getMinProtectedX(), island.getMaxProtectedX(),
+ island.getMinProtectedZ(), island.getMaxProtectedZ(),
+ addon.getPlugin().getIWM().getSeaHeight(world),
+ addon.getSettings().getUnderWaterMultiplier());
+
+ Bukkit.getScheduler().runTaskAsynchronously(addon.getPlugin(), () -> {
+ long total = scanSnapshot(snapshot, ctx);
+ if (total != 0L) {
+ Bukkit.getScheduler().runTask(addon.getPlugin(),
+ () -> addon.getManager().addToInitialCount(island, total));
+ }
+ });
+ }
+
+ private long scanSnapshot(ChunkSnapshot snapshot, ScanContext ctx) {
+ long total = 0L;
+ for (int x = 0; x < 16; x++) {
+ int globalX = ctx.chunkBlockX + x;
+ if (globalX >= ctx.minProtectedX && globalX < ctx.maxProtectedX) {
+ total += scanRow(snapshot, x, ctx);
+ }
+ }
+ return total;
+ }
+
+ private long scanRow(ChunkSnapshot snapshot, int x, ScanContext ctx) {
+ long total = 0L;
+ for (int z = 0; z < 16; z++) {
+ int globalZ = ctx.chunkBlockZ + z;
+ if (globalZ >= ctx.minProtectedZ && globalZ < ctx.maxProtectedZ) {
+ total += scanColumn(snapshot, x, z, ctx);
+ }
+ }
+ return total;
+ }
+
+ private long scanColumn(ChunkSnapshot snapshot, int x, int z, ScanContext ctx) {
+ long total = 0L;
+ for (int y = ctx.minHeight; y < ctx.maxHeight; y++) {
+ total += valueAt(snapshot, x, y, z, ctx);
+ }
+ return total;
+ }
+
+ private long valueAt(ChunkSnapshot snapshot, int x, int y, int z, ScanContext ctx) {
+ Material mat = snapshot.getBlockType(x, y, z);
+ if (mat.isAir()) {
+ return 0L;
+ }
+ Integer value = addon.getBlockConfig().getValue(ctx.world, mat);
+ if (value == null || value == 0) {
+ return 0L;
+ }
+ if (ctx.seaHeight > 0 && y <= ctx.seaHeight) {
+ return (long) (value * ctx.underwaterMultiplier);
+ }
+ return value;
+ }
+}

src/main/java/world/bentobox/level/Level.java

@@ -46,6 +46,7 @@
 import world.bentobox.level.listeners.IslandActivitiesListeners;
 import world.bentobox.level.listeners.JoinLeaveListener;
 import world.bentobox.level.listeners.MigrationListener;
+import world.bentobox.level.listeners.NewChunkListener;
 import world.bentobox.level.requests.LevelRequestHandler;
 import world.bentobox.level.requests.TopTenRequestHandler;
 import world.bentobox.visit.VisitAddon;
@@ -154,6 +155,10 @@ private void registerAllListeners() {
  registerListener(new IslandActivitiesListeners(this));
  registerListener(new JoinLeaveListener(this));
  registerListener(new MigrationListener(this));
+ // Accumulates generator block points into initialCount as new chunks
+ // are generated, so large protection ranges work with zero-new-island
+ // mode without forcing the initial scan to generate the whole area.
+ registerListener(new NewChunkListener(this));
  }
 
  private void registerGameModeCommands() {

src/main/java/world/bentobox/level/LevelsManager.java

@@ -480,7 +480,7 @@ public void removeEntry(World world, String uuid) {
 
  /**
  * Set an initial island count
- *
+ *
  * @param island - the island to set.
  * @param lv - initial island count
  */
@@ -489,6 +489,27 @@ public void setInitialIslandCount(@NonNull Island island, long lv) {
  handler.saveObjectAsync(levelsCache.get(island.getUniqueId()));
  }
 
+ /**
+ * Add a delta to the island's initial-count handicap. Used by the new-chunk
+ * listener to accumulate generator block points (sea floor, nether ceiling,
+ * etc.) into the initial count as chunks are generated during normal play.
+ * The initial count is subtracted from the live block total in the level
+ * calc, so generator blocks do not inflate the level.
+ *
+ * @param island the island
+ * @param delta the points to add (no-op when zero)
+ */
+ public void addToInitialCount(@NonNull Island island, long delta) {
+ if (delta == 0) {
+ return;
+ }
+ // Use getInitialCount so any legacy initialLevel is migrated first.
+ long current = getInitialCount(island);
+ IslandLevels data = getLevelsData(island);
+ data.setInitialCount(current + delta);
+ handler.saveObjectAsync(data);
+ }
+
  /**
  * Set the island level for the owner of the island that targetPlayer is a
  * member

src/main/java/world/bentobox/level/calculators/IslandLevelCalculator.java

@@ -366,8 +366,14 @@ private void loadChunks(CompletableFuture<List<Chunk>> r2, World world, Queue<Pa
  return;
  }
  Pair<Integer, Integer> p = pairList.poll();
- // We need to generate now all the time because some game modes are not voids
- Util.getChunkAtAsync(world, p.x, p.z, true).thenAccept(chunk -> {
+ // For zero-island scans, do not force chunk generation. Forcing the
+ // generator for every chunk in a large protection range (e.g. 1000 →
+ // ~16k chunks/dim) blows past the calculation timeout. Generator
+ // blocks that appear later (sea floor, nether ceiling, etc.) are
+ // picked up incrementally by NewChunkListener as chunks generate
+ // during normal play. Regular scans still generate, because some game
+ // modes are not voids.
+ Util.getChunkAtAsync(world, p.x, p.z, !zeroIsland).thenAccept(chunk -> {
  if (chunk != null) {
  chunkList.add(chunk);
  roseStackerCheck(chunk);

src/main/java/world/bentobox/level/listeners/NewChunkListener.java

@@ -0,0 +1,134 @@
+package world.bentobox.level.listeners;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.ChunkSnapshot;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.ChunkLoadEvent;
+
+import world.bentobox.bentobox.database.objects.Island;
+import world.bentobox.level.Level;
+
+/**
+ * Listens for freshly-generated chunks inside an island's protected area and
+ * adds the chunk's generator block points to the island's initial-count
+ * handicap.
+ * <p>
+ * Together with the {@code gen=false} initial zero scan in
+ * {@link world.bentobox.level.calculators.IslandLevelCalculator}, this lets
+ * zero-new-island-level mode work on islands with very large protection
+ * ranges. The initial scan only records what is already generated at island
+ * creation time (typically just the schematic chunks). As the player
+ * explores and new chunks are generated, this listener accumulates their
+ * generator block points into the initial count so they cancel out of the
+ * regular level calc — players only get credit for blocks they actually
+ * place.
+ */
+public class NewChunkListener implements Listener {
+
+ /**
+ * Snapshot of the main-thread state needed to score one chunk on a worker
+ * thread. Bundled into a record so the async scan helpers don't need to
+ * carry a dozen parameters each.
+ */
+ private record ScanContext(World world, int chunkBlockX, int chunkBlockZ, int minHeight, int maxHeight,
+ int minProtectedX, int maxProtectedX, int minProtectedZ, int maxProtectedZ,
+ int seaHeight, double underwaterMultiplier) {
+ }
+
+ private final Level addon;
+
+ public NewChunkListener(Level addon) {
+ this.addon = addon;
+ }
+
+ @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+ public void onChunkLoad(ChunkLoadEvent e) {
+ if (!e.isNewChunk()) {
+ return;
+ }
+ if (!addon.getSettings().isZeroNewIslandLevels()) {
+ return;
+ }
+ Chunk chunk = e.getChunk();
+ World world = chunk.getWorld();
+ if (!addon.isRegisteredGameModeWorld(world)) {
+ return;
+ }
+ // Use the chunk centre to look up the island that owns it.
+ // The + 8.0 keeps the addition in double arithmetic so SonarQube does not
+ // flag a theoretical int-overflow before the implicit widening.
+ Location centre = new Location(world, (chunk.getX() << 4) + 8.0, world.getMinHeight(),
+ (chunk.getZ() << 4) + 8.0);
+ Island island = addon.getIslands().getIslandAt(centre).orElse(null);
+ if (island == null || island.getOwner() == null) {
+ return;
+ }
+ // Capture all main-thread state before going async.
+ ChunkSnapshot snapshot = chunk.getChunkSnapshot();
+ ScanContext ctx = new ScanContext(world, chunk.getX() << 4, chunk.getZ() << 4,
+ world.getMinHeight(), world.getMaxHeight(),
+ island.getMinProtectedX(), island.getMaxProtectedX(),
+ island.getMinProtectedZ(), island.getMaxProtectedZ(),
+ addon.getPlugin().getIWM().getSeaHeight(world),
+ addon.getSettings().getUnderWaterMultiplier());
+
+ Bukkit.getScheduler().runTaskAsynchronously(addon.getPlugin(), () -> {
+ long total = scanSnapshot(snapshot, ctx);
+ if (total != 0L) {
+ Bukkit.getScheduler().runTask(addon.getPlugin(),
+ () -> addon.getManager().addToInitialCount(island, total));
+ }
+ });
+ }
+
+ private long scanSnapshot(ChunkSnapshot snapshot, ScanContext ctx) {
+ long total = 0L;
+ for (int x = 0; x < 16; x++) {
+ int globalX = ctx.chunkBlockX + x;
+ if (globalX >= ctx.minProtectedX && globalX < ctx.maxProtectedX) {
+ total += scanRow(snapshot, x, ctx);
+ }
+ }
+ return total;
+ }
+
+ private long scanRow(ChunkSnapshot snapshot, int x, ScanContext ctx) {
+ long total = 0L;
+ for (int z = 0; z < 16; z++) {
+ int globalZ = ctx.chunkBlockZ + z;
+ if (globalZ >= ctx.minProtectedZ && globalZ < ctx.maxProtectedZ) {
+ total += scanColumn(snapshot, x, z, ctx);
+ }
+ }
+ return total;
+ }
+
+ private long scanColumn(ChunkSnapshot snapshot, int x, int z, ScanContext ctx) {
+ long total = 0L;
+ for (int y = ctx.minHeight; y < ctx.maxHeight; y++) {
+ total += valueAt(snapshot, x, y, z, ctx);
+ }
+ return total;
+ }
+
+ private long valueAt(ChunkSnapshot snapshot, int x, int y, int z, ScanContext ctx) {
+ Material mat = snapshot.getBlockType(x, y, z);
+ if (mat.isAir()) {
+ return 0L;
+ }
+ Integer value = addon.getBlockConfig().getValue(ctx.world, mat);
+ if (value == null || value == 0) {
+ return 0L;
+ }
+ if (ctx.seaHeight > 0 && y <= ctx.seaHeight) {
+ return (long) (value * ctx.underwaterMultiplier);
+ }
+ return value;
+ }
+}

src/main/java/world/bentobox/level/Level.java

@@ -46,6 +46,7 @@
 import world.bentobox.level.listeners.IslandActivitiesListeners;
 import world.bentobox.level.listeners.JoinLeaveListener;
 import world.bentobox.level.listeners.MigrationListener;
+import world.bentobox.level.listeners.NewChunkListener;
 import world.bentobox.level.requests.LevelRequestHandler;
 import world.bentobox.level.requests.TopTenRequestHandler;
 import world.bentobox.visit.VisitAddon;
@@ -154,6 +155,10 @@ private void registerAllListeners() {
  registerListener(new IslandActivitiesListeners(this));
  registerListener(new JoinLeaveListener(this));
  registerListener(new MigrationListener(this));
+ // Accumulates generator block points into initialCount as new chunks
+ // are generated, so large protection ranges work with zero-new-island
+ // mode without forcing the initial scan to generate the whole area.
+ registerListener(new NewChunkListener(this));
  }
 
  private void registerGameModeCommands() {

src/main/java/world/bentobox/level/LevelsManager.java

@@ -480,7 +480,7 @@ public void removeEntry(World world, String uuid) {
 
  /**
  * Set an initial island count
- *
+ *
  * @param island - the island to set.
  * @param lv - initial island count
  */
@@ -489,6 +489,27 @@ public void setInitialIslandCount(@NonNull Island island, long lv) {
  handler.saveObjectAsync(levelsCache.get(island.getUniqueId()));
  }
 
+ /**
+ * Add a delta to the island's initial-count handicap. Used by the new-chunk
+ * listener to accumulate generator block points (sea floor, nether ceiling,
+ * etc.) into the initial count as chunks are generated during normal play.
+ * The initial count is subtracted from the live block total in the level
+ * calc, so generator blocks do not inflate the level.
+ *
+ * @param island the island
+ * @param delta the points to add (no-op when zero)
+ */
+ public void addToInitialCount(@NonNull Island island, long delta) {
+ if (delta == 0) {
+ return;
+ }
+ // Use getInitialCount so any legacy initialLevel is migrated first.
+ long current = getInitialCount(island);
+ IslandLevels data = getLevelsData(island);
+ data.setInitialCount(current + delta);
+ handler.saveObjectAsync(data);
+ }
+
  /**
  * Set the island level for the owner of the island that targetPlayer is a
  * member

src/main/java/world/bentobox/level/calculators/IslandLevelCalculator.java

@@ -366,8 +366,14 @@ private void loadChunks(CompletableFuture<List<Chunk>> r2, World world, Queue<Pa
  return;
  }
  Pair<Integer, Integer> p = pairList.poll();
- // We need to generate now all the time because some game modes are not voids
- Util.getChunkAtAsync(world, p.x, p.z, true).thenAccept(chunk -> {
+ // For zero-island scans, do not force chunk generation. Forcing the
+ // generator for every chunk in a large protection range (e.g. 1000 →
+ // ~16k chunks/dim) blows past the calculation timeout. Generator
+ // blocks that appear later (sea floor, nether ceiling, etc.) are
+ // picked up incrementally by NewChunkListener as chunks generate
+ // during normal play. Regular scans still generate, because some game
+ // modes are not voids.
+ Util.getChunkAtAsync(world, p.x, p.z, !zeroIsland).thenAccept(chunk -> {
  if (chunk != null) {
  chunkList.add(chunk);
  roseStackerCheck(chunk);

src/main/java/world/bentobox/level/listeners/NewChunkListener.java

@@ -0,0 +1,134 @@
+package world.bentobox.level.listeners;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.ChunkSnapshot;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.ChunkLoadEvent;
+
+import world.bentobox.bentobox.database.objects.Island;
+import world.bentobox.level.Level;
+
+/**
+ * Listens for freshly-generated chunks inside an island's protected area and
+ * adds the chunk's generator block points to the island's initial-count
+ * handicap.
+ * <p>
+ * Together with the {@code gen=false} initial zero scan in
+ * {@link world.bentobox.level.calculators.IslandLevelCalculator}, this lets
+ * zero-new-island-level mode work on islands with very large protection
+ * ranges. The initial scan only records what is already generated at island
+ * creation time (typically just the schematic chunks). As the player
+ * explores and new chunks are generated, this listener accumulates their
+ * generator block points into the initial count so they cancel out of the
+ * regular level calc — players only get credit for blocks they actually
+ * place.
+ */
+public class NewChunkListener implements Listener {
+
+ /**
+ * Snapshot of the main-thread state needed to score one chunk on a worker
+ * thread. Bundled into a record so the async scan helpers don't need to
+ * carry a dozen parameters each.
+ */
+ private record ScanContext(World world, int chunkBlockX, int chunkBlockZ, int minHeight, int maxHeight,
+ int minProtectedX, int maxProtectedX, int minProtectedZ, int maxProtectedZ,
+ int seaHeight, double underwaterMultiplier) {
+ }
+
+ private final Level addon;
+
+ public NewChunkListener(Level addon) {
+ this.addon = addon;
+ }
+
+ @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+ public void onChunkLoad(ChunkLoadEvent e) {
+ if (!e.isNewChunk()) {
+ return;
+ }
+ if (!addon.getSettings().isZeroNewIslandLevels()) {
+ return;
+ }
+ Chunk chunk = e.getChunk();
+ World world = chunk.getWorld();
+ if (!addon.isRegisteredGameModeWorld(world)) {
+ return;
+ }
+ // Use the chunk centre to look up the island that owns it.
+ // The + 8.0 keeps the addition in double arithmetic so SonarQube does not
+ // flag a theoretical int-overflow before the implicit widening.
+ Location centre = new Location(world, (chunk.getX() << 4) + 8.0, world.getMinHeight(),
+ (chunk.getZ() << 4) + 8.0);
+ Island island = addon.getIslands().getIslandAt(centre).orElse(null);
+ if (island == null || island.getOwner() == null) {
+ return;
+ }
+ // Capture all main-thread state before going async.
+ ChunkSnapshot snapshot = chunk.getChunkSnapshot();
+ ScanContext ctx = new ScanContext(world, chunk.getX() << 4, chunk.getZ() << 4,
+ world.getMinHeight(), world.getMaxHeight(),
+ island.getMinProtectedX(), island.getMaxProtectedX(),
+ island.getMinProtectedZ(), island.getMaxProtectedZ(),
+ addon.getPlugin().getIWM().getSeaHeight(world),
+ addon.getSettings().getUnderWaterMultiplier());
+
+ Bukkit.getScheduler().runTaskAsynchronously(addon.getPlugin(), () -> {
+ long total = scanSnapshot(snapshot, ctx);
+ if (total != 0L) {
+ Bukkit.getScheduler().runTask(addon.getPlugin(),
+ () -> addon.getManager().addToInitialCount(island, total));
+ }
+ });
+ }
+
+ private long scanSnapshot(ChunkSnapshot snapshot, ScanContext ctx) {
+ long total = 0L;
+ for (int x = 0; x < 16; x++) {
+ int globalX = ctx.chunkBlockX + x;
+ if (globalX >= ctx.minProtectedX && globalX < ctx.maxProtectedX) {
+ total += scanRow(snapshot, x, ctx);
+ }
+ }
+ return total;
+ }
+
+ private long scanRow(ChunkSnapshot snapshot, int x, ScanContext ctx) {
+ long total = 0L;
+ for (int z = 0; z < 16; z++) {
+ int globalZ = ctx.chunkBlockZ + z;
+ if (globalZ >= ctx.minProtectedZ && globalZ < ctx.maxProtectedZ) {
+ total += scanColumn(snapshot, x, z, ctx);
+ }
+ }
+ return total;
+ }
+
+ private long scanColumn(ChunkSnapshot snapshot, int x, int z, ScanContext ctx) {
+ long total = 0L;
+ for (int y = ctx.minHeight; y < ctx.maxHeight; y++) {
+ total += valueAt(snapshot, x, y, z, ctx);
+ }
+ return total;
+ }
+
+ private long valueAt(ChunkSnapshot snapshot, int x, int y, int z, ScanContext ctx) {
+ Material mat = snapshot.getBlockType(x, y, z);
+ if (mat.isAir()) {
+ return 0L;
+ }
+ Integer value = addon.getBlockConfig().getValue(ctx.world, mat);
+ if (value == null || value == 0) {
+ return 0L;
+ }
+ if (ctx.seaHeight > 0 && y <= ctx.seaHeight) {
+ return (long) (value * ctx.underwaterMultiplier);
+ }
+ return value;
+ }
+}

src/main/java/world/bentobox/level/Level.java

@@ -46,6 +46,7 @@
 import world.bentobox.level.listeners.IslandActivitiesListeners;
 import world.bentobox.level.listeners.JoinLeaveListener;
 import world.bentobox.level.listeners.MigrationListener;
+import world.bentobox.level.listeners.NewChunkListener;
 import world.bentobox.level.requests.LevelRequestHandler;
 import world.bentobox.level.requests.TopTenRequestHandler;
 import world.bentobox.visit.VisitAddon;
@@ -154,6 +155,10 @@ private void registerAllListeners() {
  registerListener(new IslandActivitiesListeners(this));
  registerListener(new JoinLeaveListener(this));
  registerListener(new MigrationListener(this));
+ // Accumulates generator block points into initialCount as new chunks
+ // are generated, so large protection ranges work with zero-new-island
+ // mode without forcing the initial scan to generate the whole area.
+ registerListener(new NewChunkListener(this));
  }
 
  private void registerGameModeCommands() {

src/main/java/world/bentobox/level/LevelsManager.java

@@ -480,7 +480,7 @@ public void removeEntry(World world, String uuid) {
 
  /**
  * Set an initial island count
- *
+ *
  * @param island - the island to set.
  * @param lv - initial island count
  */
@@ -489,6 +489,27 @@ public void setInitialIslandCount(@NonNull Island island, long lv) {
  handler.saveObjectAsync(levelsCache.get(island.getUniqueId()));
  }
 
+ /**
+ * Add a delta to the island's initial-count handicap. Used by the new-chunk
+ * listener to accumulate generator block points (sea floor, nether ceiling,
+ * etc.) into the initial count as chunks are generated during normal play.
+ * The initial count is subtracted from the live block total in the level
+ * calc, so generator blocks do not inflate the level.
+ *
+ * @param island the island
+ * @param delta the points to add (no-op when zero)
+ */
+ public void addToInitialCount(@NonNull Island island, long delta) {
+ if (delta == 0) {
+ return;
+ }
+ // Use getInitialCount so any legacy initialLevel is migrated first.
+ long current = getInitialCount(island);
+ IslandLevels data = getLevelsData(island);
+ data.setInitialCount(current + delta);
+ handler.saveObjectAsync(data);
+ }
+
  /**
  * Set the island level for the owner of the island that targetPlayer is a
  * member

src/main/java/world/bentobox/level/calculators/IslandLevelCalculator.java

@@ -366,8 +366,14 @@ private void loadChunks(CompletableFuture<List<Chunk>> r2, World world, Queue<Pa
  return;
  }
  Pair<Integer, Integer> p = pairList.poll();
- // We need to generate now all the time because some game modes are not voids
- Util.getChunkAtAsync(world, p.x, p.z, true).thenAccept(chunk -> {
+ // For zero-island scans, do not force chunk generation. Forcing the
+ // generator for every chunk in a large protection range (e.g. 1000 →
+ // ~16k chunks/dim) blows past the calculation timeout. Generator
+ // blocks that appear later (sea floor, nether ceiling, etc.) are
+ // picked up incrementally by NewChunkListener as chunks generate
+ // during normal play. Regular scans still generate, because some game
+ // modes are not voids.
+ Util.getChunkAtAsync(world, p.x, p.z, !zeroIsland).thenAccept(chunk -> {
  if (chunk != null) {
  chunkList.add(chunk);
  roseStackerCheck(chunk);

src/main/java/world/bentobox/level/listeners/NewChunkListener.java

@@ -0,0 +1,134 @@
+package world.bentobox.level.listeners;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.ChunkSnapshot;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.ChunkLoadEvent;
+
+import world.bentobox.bentobox.database.objects.Island;
+import world.bentobox.level.Level;
+
+/**
+ * Listens for freshly-generated chunks inside an island's protected area and
+ * adds the chunk's generator block points to the island's initial-count
+ * handicap.
+ * <p>
+ * Together with the {@code gen=false} initial zero scan in
+ * {@link world.bentobox.level.calculators.IslandLevelCalculator}, this lets
+ * zero-new-island-level mode work on islands with very large protection
+ * ranges. The initial scan only records what is already generated at island
+ * creation time (typically just the schematic chunks). As the player
+ * explores and new chunks are generated, this listener accumulates their
+ * generator block points into the initial count so they cancel out of the
+ * regular level calc — players only get credit for blocks they actually
+ * place.
+ */
+public class NewChunkListener implements Listener {
+
+ /**
+ * Snapshot of the main-thread state needed to score one chunk on a worker
+ * thread. Bundled into a record so the async scan helpers don't need to
+ * carry a dozen parameters each.
+ */
+ private record ScanContext(World world, int chunkBlockX, int chunkBlockZ, int minHeight, int maxHeight,
+ int minProtectedX, int maxProtectedX, int minProtectedZ, int maxProtectedZ,
+ int seaHeight, double underwaterMultiplier) {
+ }
+
+ private final Level addon;
+
+ public NewChunkListener(Level addon) {
+ this.addon = addon;
+ }
+
+ @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+ public void onChunkLoad(ChunkLoadEvent e) {
+ if (!e.isNewChunk()) {
+ return;
+ }
+ if (!addon.getSettings().isZeroNewIslandLevels()) {
+ return;
+ }
+ Chunk chunk = e.getChunk();
+ World world = chunk.getWorld();
+ if (!addon.isRegisteredGameModeWorld(world)) {
+ return;
+ }
+ // Use the chunk centre to look up the island that owns it.
+ // The + 8.0 keeps the addition in double arithmetic so SonarQube does not
+ // flag a theoretical int-overflow before the implicit widening.
+ Location centre = new Location(world, (chunk.getX() << 4) + 8.0, world.getMinHeight(),
+ (chunk.getZ() << 4) + 8.0);
+ Island island = addon.getIslands().getIslandAt(centre).orElse(null);
+ if (island == null || island.getOwner() == null) {
+ return;
+ }
+ // Capture all main-thread state before going async.
+ ChunkSnapshot snapshot = chunk.getChunkSnapshot();
+ ScanContext ctx = new ScanContext(world, chunk.getX() << 4, chunk.getZ() << 4,
+ world.getMinHeight(), world.getMaxHeight(),
+ island.getMinProtectedX(), island.getMaxProtectedX(),
+ island.getMinProtectedZ(), island.getMaxProtectedZ(),
+ addon.getPlugin().getIWM().getSeaHeight(world),
+ addon.getSettings().getUnderWaterMultiplier());
+
+ Bukkit.getScheduler().runTaskAsynchronously(addon.getPlugin(), () -> {
+ long total = scanSnapshot(snapshot, ctx);
+ if (total != 0L) {
+ Bukkit.getScheduler().runTask(addon.getPlugin(),
+ () -> addon.getManager().addToInitialCount(island, total));
+ }
+ });
+ }
+
+ private long scanSnapshot(ChunkSnapshot snapshot, ScanContext ctx) {
+ long total = 0L;
+ for (int x = 0; x < 16; x++) {
+ int globalX = ctx.chunkBlockX + x;
+ if (globalX >= ctx.minProtectedX && globalX < ctx.maxProtectedX) {
+ total += scanRow(snapshot, x, ctx);
+ }
+ }
+ return total;
+ }
+
+ private long scanRow(ChunkSnapshot snapshot, int x, ScanContext ctx) {
+ long total = 0L;
+ for (int z = 0; z < 16; z++) {
+ int globalZ = ctx.chunkBlockZ + z;
+ if (globalZ >= ctx.minProtectedZ && globalZ < ctx.maxProtectedZ) {
+ total += scanColumn(snapshot, x, z, ctx);
+ }
+ }
+ return total;
+ }
+
+ private long scanColumn(ChunkSnapshot snapshot, int x, int z, ScanContext ctx) {
+ long total = 0L;
+ for (int y = ctx.minHeight; y < ctx.maxHeight; y++) {
+ total += valueAt(snapshot, x, y, z, ctx);
+ }
+ return total;
+ }
+
+ private long valueAt(ChunkSnapshot snapshot, int x, int y, int z, ScanContext ctx) {
+ Material mat = snapshot.getBlockType(x, y, z);
+ if (mat.isAir()) {
+ return 0L;
+ }
+ Integer value = addon.getBlockConfig().getValue(ctx.world, mat);
+ if (value == null || value == 0) {
+ return 0L;
+ }
+ if (ctx.seaHeight > 0 && y <= ctx.seaHeight) {
+ return (long) (value * ctx.underwaterMultiplier);
+ }
+ return value;
+ }
+}

src/main/java/world/bentobox/level/Level.java

@@ -46,6 +46,7 @@
 import world.bentobox.level.listeners.IslandActivitiesListeners;
 import world.bentobox.level.listeners.JoinLeaveListener;
 import world.bentobox.level.listeners.MigrationListener;
+import world.bentobox.level.listeners.NewChunkListener;
 import world.bentobox.level.requests.LevelRequestHandler;
 import world.bentobox.level.requests.TopTenRequestHandler;
 import world.bentobox.visit.VisitAddon;
@@ -154,6 +155,10 @@ private void registerAllListeners() {
  registerListener(new IslandActivitiesListeners(this));
  registerListener(new JoinLeaveListener(this));
  registerListener(new MigrationListener(this));
+ // Accumulates generator block points into initialCount as new chunks
+ // are generated, so large protection ranges work with zero-new-island
+ // mode without forcing the initial scan to generate the whole area.
+ registerListener(new NewChunkListener(this));
  }
 
  private void registerGameModeCommands() {

src/main/java/world/bentobox/level/LevelsManager.java

@@ -480,7 +480,7 @@ public void removeEntry(World world, String uuid) {
 
  /**
  * Set an initial island count
- *
+ *
  * @param island - the island to set.
  * @param lv - initial island count
  */
@@ -489,6 +489,27 @@ public void setInitialIslandCount(@NonNull Island island, long lv) {
  handler.saveObjectAsync(levelsCache.get(island.getUniqueId()));
  }
 
+ /**
+ * Add a delta to the island's initial-count handicap. Used by the new-chunk
+ * listener to accumulate generator block points (sea floor, nether ceiling,
+ * etc.) into the initial count as chunks are generated during normal play.
+ * The initial count is subtracted from the live block total in the level
+ * calc, so generator blocks do not inflate the level.
+ *
+ * @param island the island
+ * @param delta the points to add (no-op when zero)
+ */
+ public void addToInitialCount(@NonNull Island island, long delta) {
+ if (delta == 0) {
+ return;
+ }
+ // Use getInitialCount so any legacy initialLevel is migrated first.
+ long current = getInitialCount(island);
+ IslandLevels data = getLevelsData(island);
+ data.setInitialCount(current + delta);
+ handler.saveObjectAsync(data);
+ }
+
  /**
  * Set the island level for the owner of the island that targetPlayer is a
  * member

src/main/java/world/bentobox/level/calculators/IslandLevelCalculator.java

@@ -366,8 +366,14 @@ private void loadChunks(CompletableFuture<List<Chunk>> r2, World world, Queue<Pa
  return;
  }
  Pair<Integer, Integer> p = pairList.poll();
- // We need to generate now all the time because some game modes are not voids
- Util.getChunkAtAsync(world, p.x, p.z, true).thenAccept(chunk -> {
+ // For zero-island scans, do not force chunk generation. Forcing the
+ // generator for every chunk in a large protection range (e.g. 1000 →
+ // ~16k chunks/dim) blows past the calculation timeout. Generator
+ // blocks that appear later (sea floor, nether ceiling, etc.) are
+ // picked up incrementally by NewChunkListener as chunks generate
+ // during normal play. Regular scans still generate, because some game
+ // modes are not voids.
+ Util.getChunkAtAsync(world, p.x, p.z, !zeroIsland).thenAccept(chunk -> {
  if (chunk != null) {
  chunkList.add(chunk);
  roseStackerCheck(chunk);

src/main/java/world/bentobox/level/listeners/NewChunkListener.java

@@ -0,0 +1,134 @@
+package world.bentobox.level.listeners;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.ChunkSnapshot;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.ChunkLoadEvent;
+
+import world.bentobox.bentobox.database.objects.Island;
+import world.bentobox.level.Level;
+
+/**
+ * Listens for freshly-generated chunks inside an island's protected area and
+ * adds the chunk's generator block points to the island's initial-count
+ * handicap.
+ * <p>
+ * Together with the {@code gen=false} initial zero scan in
+ * {@link world.bentobox.level.calculators.IslandLevelCalculator}, this lets
+ * zero-new-island-level mode work on islands with very large protection
+ * ranges. The initial scan only records what is already generated at island
+ * creation time (typically just the schematic chunks). As the player
+ * explores and new chunks are generated, this listener accumulates their
+ * generator block points into the initial count so they cancel out of the
+ * regular level calc — players only get credit for blocks they actually
+ * place.
+ */
+public class NewChunkListener implements Listener {
+
+ /**
+ * Snapshot of the main-thread state needed to score one chunk on a worker
+ * thread. Bundled into a record so the async scan helpers don't need to
+ * carry a dozen parameters each.
+ */
+ private record ScanContext(World world, int chunkBlockX, int chunkBlockZ, int minHeight, int maxHeight,
+ int minProtectedX, int maxProtectedX, int minProtectedZ, int maxProtectedZ,
+ int seaHeight, double underwaterMultiplier) {
+ }
+
+ private final Level addon;
+
+ public NewChunkListener(Level addon) {
+ this.addon = addon;
+ }
+
+ @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+ public void onChunkLoad(ChunkLoadEvent e) {
+ if (!e.isNewChunk()) {
+ return;
+ }
+ if (!addon.getSettings().isZeroNewIslandLevels()) {
+ return;
+ }
+ Chunk chunk = e.getChunk();
+ World world = chunk.getWorld();
+ if (!addon.isRegisteredGameModeWorld(world)) {
+ return;
+ }
+ // Use the chunk centre to look up the island that owns it.
+ // The + 8.0 keeps the addition in double arithmetic so SonarQube does not
+ // flag a theoretical int-overflow before the implicit widening.
+ Location centre = new Location(world, (chunk.getX() << 4) + 8.0, world.getMinHeight(),
+ (chunk.getZ() << 4) + 8.0);
+ Island island = addon.getIslands().getIslandAt(centre).orElse(null);
+ if (island == null || island.getOwner() == null) {
+ return;
+ }
+ // Capture all main-thread state before going async.
+ ChunkSnapshot snapshot = chunk.getChunkSnapshot();
+ ScanContext ctx = new ScanContext(world, chunk.getX() << 4, chunk.getZ() << 4,
+ world.getMinHeight(), world.getMaxHeight(),
+ island.getMinProtectedX(), island.getMaxProtectedX(),
+ island.getMinProtectedZ(), island.getMaxProtectedZ(),
+ addon.getPlugin().getIWM().getSeaHeight(world),
+ addon.getSettings().getUnderWaterMultiplier());
+
+ Bukkit.getScheduler().runTaskAsynchronously(addon.getPlugin(), () -> {
+ long total = scanSnapshot(snapshot, ctx);
+ if (total != 0L) {
+ Bukkit.getScheduler().runTask(addon.getPlugin(),
+ () -> addon.getManager().addToInitialCount(island, total));
+ }
+ });
+ }
+
+ private long scanSnapshot(ChunkSnapshot snapshot, ScanContext ctx) {
+ long total = 0L;
+ for (int x = 0; x < 16; x++) {
+ int globalX = ctx.chunkBlockX + x;
+ if (globalX >= ctx.minProtectedX && globalX < ctx.maxProtectedX) {
+ total += scanRow(snapshot, x, ctx);
+ }
+ }
+ return total;
+ }
+
+ private long scanRow(ChunkSnapshot snapshot, int x, ScanContext ctx) {
+ long total = 0L;
+ for (int z = 0; z < 16; z++) {
+ int globalZ = ctx.chunkBlockZ + z;
+ if (globalZ >= ctx.minProtectedZ && globalZ < ctx.maxProtectedZ) {
+ total += scanColumn(snapshot, x, z, ctx);
+ }
+ }
+ return total;
+ }
+
+ private long scanColumn(ChunkSnapshot snapshot, int x, int z, ScanContext ctx) {
+ long total = 0L;
+ for (int y = ctx.minHeight; y < ctx.maxHeight; y++) {
+ total += valueAt(snapshot, x, y, z, ctx);
+ }
+ return total;
+ }
+
+ private long valueAt(ChunkSnapshot snapshot, int x, int y, int z, ScanContext ctx) {
+ Material mat = snapshot.getBlockType(x, y, z);
+ if (mat.isAir()) {
+ return 0L;
+ }
+ Integer value = addon.getBlockConfig().getValue(ctx.world, mat);
+ if (value == null || value == 0) {
+ return 0L;
+ }
+ if (ctx.seaHeight > 0 && y <= ctx.seaHeight) {
+ return (long) (value * ctx.underwaterMultiplier);
+ }
+ return value;
+ }
+}

src/main/java/world/bentobox/level/Level.java

@@ -46,6 +46,7 @@
 import world.bentobox.level.listeners.IslandActivitiesListeners;
 import world.bentobox.level.listeners.JoinLeaveListener;
 import world.bentobox.level.listeners.MigrationListener;
+import world.bentobox.level.listeners.NewChunkListener;
 import world.bentobox.level.requests.LevelRequestHandler;
 import world.bentobox.level.requests.TopTenRequestHandler;
 import world.bentobox.visit.VisitAddon;
@@ -154,6 +155,10 @@ private void registerAllListeners() {
  registerListener(new IslandActivitiesListeners(this));
  registerListener(new JoinLeaveListener(this));
  registerListener(new MigrationListener(this));
+ // Accumulates generator block points into initialCount as new chunks
+ // are generated, so large protection ranges work with zero-new-island
+ // mode without forcing the initial scan to generate the whole area.
+ registerListener(new NewChunkListener(this));
  }
 
  private void registerGameModeCommands() {

src/main/java/world/bentobox/level/LevelsManager.java

@@ -480,7 +480,7 @@ public void removeEntry(World world, String uuid) {
 
  /**
  * Set an initial island count
- *
+ *
  * @param island - the island to set.
  * @param lv - initial island count
  */
@@ -489,6 +489,27 @@ public void setInitialIslandCount(@NonNull Island island, long lv) {
  handler.saveObjectAsync(levelsCache.get(island.getUniqueId()));
  }
 
+ /**
+ * Add a delta to the island's initial-count handicap. Used by the new-chunk
+ * listener to accumulate generator block points (sea floor, nether ceiling,
+ * etc.) into the initial count as chunks are generated during normal play.
+ * The initial count is subtracted from the live block total in the level
+ * calc, so generator blocks do not inflate the level.
+ *
+ * @param island the island
+ * @param delta the points to add (no-op when zero)
+ */
+ public void addToInitialCount(@NonNull Island island, long delta) {
+ if (delta == 0) {
+ return;
+ }
+ // Use getInitialCount so any legacy initialLevel is migrated first.
+ long current = getInitialCount(island);
+ IslandLevels data = getLevelsData(island);
+ data.setInitialCount(current + delta);
+ handler.saveObjectAsync(data);
+ }
+
  /**
  * Set the island level for the owner of the island that targetPlayer is a
  * member

src/main/java/world/bentobox/level/calculators/IslandLevelCalculator.java

@@ -366,8 +366,14 @@ private void loadChunks(CompletableFuture<List<Chunk>> r2, World world, Queue<Pa
  return;
  }
  Pair<Integer, Integer> p = pairList.poll();
- // We need to generate now all the time because some game modes are not voids
- Util.getChunkAtAsync(world, p.x, p.z, true).thenAccept(chunk -> {
+ // For zero-island scans, do not force chunk generation. Forcing the
+ // generator for every chunk in a large protection range (e.g. 1000 →
+ // ~16k chunks/dim) blows past the calculation timeout. Generator
+ // blocks that appear later (sea floor, nether ceiling, etc.) are
+ // picked up incrementally by NewChunkListener as chunks generate
+ // during normal play. Regular scans still generate, because some game
+ // modes are not voids.
+ Util.getChunkAtAsync(world, p.x, p.z, !zeroIsland).thenAccept(chunk -> {
  if (chunk != null) {
  chunkList.add(chunk);
  roseStackerCheck(chunk);

src/main/java/world/bentobox/level/listeners/NewChunkListener.java

@@ -0,0 +1,134 @@
+package world.bentobox.level.listeners;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.ChunkSnapshot;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.ChunkLoadEvent;
+
+import world.bentobox.bentobox.database.objects.Island;
+import world.bentobox.level.Level;
+
+/**
+ * Listens for freshly-generated chunks inside an island's protected area and
+ * adds the chunk's generator block points to the island's initial-count
+ * handicap.
+ * <p>
+ * Together with the {@code gen=false} initial zero scan in
+ * {@link world.bentobox.level.calculators.IslandLevelCalculator}, this lets
+ * zero-new-island-level mode work on islands with very large protection
+ * ranges. The initial scan only records what is already generated at island
+ * creation time (typically just the schematic chunks). As the player
+ * explores and new chunks are generated, this listener accumulates their
+ * generator block points into the initial count so they cancel out of the
+ * regular level calc — players only get credit for blocks they actually
+ * place.
+ */
+public class NewChunkListener implements Listener {
+
+ /**
+ * Snapshot of the main-thread state needed to score one chunk on a worker
+ * thread. Bundled into a record so the async scan helpers don't need to
+ * carry a dozen parameters each.
+ */
+ private record ScanContext(World world, int chunkBlockX, int chunkBlockZ, int minHeight, int maxHeight,
+ int minProtectedX, int maxProtectedX, int minProtectedZ, int maxProtectedZ,
+ int seaHeight, double underwaterMultiplier) {
+ }
+
+ private final Level addon;
+
+ public NewChunkListener(Level addon) {
+ this.addon = addon;
+ }
+
+ @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+ public void onChunkLoad(ChunkLoadEvent e) {
+ if (!e.isNewChunk()) {
+ return;
+ }
+ if (!addon.getSettings().isZeroNewIslandLevels()) {
+ return;
+ }
+ Chunk chunk = e.getChunk();
+ World world = chunk.getWorld();
+ if (!addon.isRegisteredGameModeWorld(world)) {
+ return;
+ }
+ // Use the chunk centre to look up the island that owns it.
+ // The + 8.0 keeps the addition in double arithmetic so SonarQube does not
+ // flag a theoretical int-overflow before the implicit widening.
+ Location centre = new Location(world, (chunk.getX() << 4) + 8.0, world.getMinHeight(),
+ (chunk.getZ() << 4) + 8.0);
+ Island island = addon.getIslands().getIslandAt(centre).orElse(null);
+ if (island == null || island.getOwner() == null) {
+ return;
+ }
+ // Capture all main-thread state before going async.
+ ChunkSnapshot snapshot = chunk.getChunkSnapshot();
+ ScanContext ctx = new ScanContext(world, chunk.getX() << 4, chunk.getZ() << 4,
+ world.getMinHeight(), world.getMaxHeight(),
+ island.getMinProtectedX(), island.getMaxProtectedX(),
+ island.getMinProtectedZ(), island.getMaxProtectedZ(),
+ addon.getPlugin().getIWM().getSeaHeight(world),
+ addon.getSettings().getUnderWaterMultiplier());
+
+ Bukkit.getScheduler().runTaskAsynchronously(addon.getPlugin(), () -> {
+ long total = scanSnapshot(snapshot, ctx);
+ if (total != 0L) {
+ Bukkit.getScheduler().runTask(addon.getPlugin(),
+ () -> addon.getManager().addToInitialCount(island, total));
+ }
+ });
+ }
+
+ private long scanSnapshot(ChunkSnapshot snapshot, ScanContext ctx) {
+ long total = 0L;
+ for (int x = 0; x < 16; x++) {
+ int globalX = ctx.chunkBlockX + x;
+ if (globalX >= ctx.minProtectedX && globalX < ctx.maxProtectedX) {
+ total += scanRow(snapshot, x, ctx);
+ }
+ }
+ return total;
+ }
+
+ private long scanRow(ChunkSnapshot snapshot, int x, ScanContext ctx) {
+ long total = 0L;
+ for (int z = 0; z < 16; z++) {
+ int globalZ = ctx.chunkBlockZ + z;
+ if (globalZ >= ctx.minProtectedZ && globalZ < ctx.maxProtectedZ) {
+ total += scanColumn(snapshot, x, z, ctx);
+ }
+ }
+ return total;
+ }
+
+ private long scanColumn(ChunkSnapshot snapshot, int x, int z, ScanContext ctx) {
+ long total = 0L;
+ for (int y = ctx.minHeight; y < ctx.maxHeight; y++) {
+ total += valueAt(snapshot, x, y, z, ctx);
+ }
+ return total;
+ }
+
+ private long valueAt(ChunkSnapshot snapshot, int x, int y, int z, ScanContext ctx) {
+ Material mat = snapshot.getBlockType(x, y, z);
+ if (mat.isAir()) {
+ return 0L;
+ }
+ Integer value = addon.getBlockConfig().getValue(ctx.world, mat);
+ if (value == null || value == 0) {
+ return 0L;
+ }
+ if (ctx.seaHeight > 0 && y <= ctx.seaHeight) {
+ return (long) (value * ctx.underwaterMultiplier);
+ }
+ return value;
+ }
+}

src/main/java/world/bentobox/level/Level.java

@@ -46,6 +46,7 @@
 import world.bentobox.level.listeners.IslandActivitiesListeners;
 import world.bentobox.level.listeners.JoinLeaveListener;
 import world.bentobox.level.listeners.MigrationListener;
+import world.bentobox.level.listeners.NewChunkListener;
 import world.bentobox.level.requests.LevelRequestHandler;
 import world.bentobox.level.requests.TopTenRequestHandler;
 import world.bentobox.visit.VisitAddon;
@@ -154,6 +155,10 @@ private void registerAllListeners() {
  registerListener(new IslandActivitiesListeners(this));
  registerListener(new JoinLeaveListener(this));
  registerListener(new MigrationListener(this));
+ // Accumulates generator block points into initialCount as new chunks
+ // are generated, so large protection ranges work with zero-new-island
+ // mode without forcing the initial scan to generate the whole area.
+ registerListener(new NewChunkListener(this));
  }
 
  private void registerGameModeCommands() {

src/main/java/world/bentobox/level/LevelsManager.java

@@ -480,7 +480,7 @@ public void removeEntry(World world, String uuid) {
 
  /**
  * Set an initial island count
- *
+ *
  * @param island - the island to set.
  * @param lv - initial island count
  */
@@ -489,6 +489,27 @@ public void setInitialIslandCount(@NonNull Island island, long lv) {
  handler.saveObjectAsync(levelsCache.get(island.getUniqueId()));
  }
 
+ /**
+ * Add a delta to the island's initial-count handicap. Used by the new-chunk
+ * listener to accumulate generator block points (sea floor, nether ceiling,
+ * etc.) into the initial count as chunks are generated during normal play.
+ * The initial count is subtracted from the live block total in the level
+ * calc, so generator blocks do not inflate the level.
+ *
+ * @param island the island
+ * @param delta the points to add (no-op when zero)
+ */
+ public void addToInitialCount(@NonNull Island island, long delta) {
+ if (delta == 0) {
+ return;
+ }
+ // Use getInitialCount so any legacy initialLevel is migrated first.
+ long current = getInitialCount(island);
+ IslandLevels data = getLevelsData(island);
+ data.setInitialCount(current + delta);
+ handler.saveObjectAsync(data);
+ }
+
  /**
  * Set the island level for the owner of the island that targetPlayer is a
  * member

src/main/java/world/bentobox/level/calculators/IslandLevelCalculator.java

@@ -366,8 +366,14 @@ private void loadChunks(CompletableFuture<List<Chunk>> r2, World world, Queue<Pa
  return;
  }
  Pair<Integer, Integer> p = pairList.poll();
- // We need to generate now all the time because some game modes are not voids
- Util.getChunkAtAsync(world, p.x, p.z, true).thenAccept(chunk -> {
+ // For zero-island scans, do not force chunk generation. Forcing the
+ // generator for every chunk in a large protection range (e.g. 1000 →
+ // ~16k chunks/dim) blows past the calculation timeout. Generator
+ // blocks that appear later (sea floor, nether ceiling, etc.) are
+ // picked up incrementally by NewChunkListener as chunks generate
+ // during normal play. Regular scans still generate, because some game
+ // modes are not voids.
+ Util.getChunkAtAsync(world, p.x, p.z, !zeroIsland).thenAccept(chunk -> {
  if (chunk != null) {
  chunkList.add(chunk);
  roseStackerCheck(chunk);

src/main/java/world/bentobox/level/listeners/NewChunkListener.java

@@ -0,0 +1,134 @@
+package world.bentobox.level.listeners;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.ChunkSnapshot;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.ChunkLoadEvent;
+
+import world.bentobox.bentobox.database.objects.Island;
+import world.bentobox.level.Level;
+
+/**
+ * Listens for freshly-generated chunks inside an island's protected area and
+ * adds the chunk's generator block points to the island's initial-count
+ * handicap.
+ * <p>
+ * Together with the {@code gen=false} initial zero scan in
+ * {@link world.bentobox.level.calculators.IslandLevelCalculator}, this lets
+ * zero-new-island-level mode work on islands with very large protection
+ * ranges. The initial scan only records what is already generated at island
+ * creation time (typically just the schematic chunks). As the player
+ * explores and new chunks are generated, this listener accumulates their
+ * generator block points into the initial count so they cancel out of the
+ * regular level calc — players only get credit for blocks they actually
+ * place.
+ */
+public class NewChunkListener implements Listener {
+
+ /**
+ * Snapshot of the main-thread state needed to score one chunk on a worker
+ * thread. Bundled into a record so the async scan helpers don't need to
+ * carry a dozen parameters each.
+ */
+ private record ScanContext(World world, int chunkBlockX, int chunkBlockZ, int minHeight, int maxHeight,
+ int minProtectedX, int maxProtectedX, int minProtectedZ, int maxProtectedZ,
+ int seaHeight, double underwaterMultiplier) {
+ }
+
+ private final Level addon;
+
+ public NewChunkListener(Level addon) {
+ this.addon = addon;
+ }
+
+ @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+ public void onChunkLoad(ChunkLoadEvent e) {
+ if (!e.isNewChunk()) {
+ return;
+ }
+ if (!addon.getSettings().isZeroNewIslandLevels()) {
+ return;
+ }
+ Chunk chunk = e.getChunk();
+ World world = chunk.getWorld();
+ if (!addon.isRegisteredGameModeWorld(world)) {
+ return;
+ }
+ // Use the chunk centre to look up the island that owns it.
+ // The + 8.0 keeps the addition in double arithmetic so SonarQube does not
+ // flag a theoretical int-overflow before the implicit widening.
+ Location centre = new Location(world, (chunk.getX() << 4) + 8.0, world.getMinHeight(),
+ (chunk.getZ() << 4) + 8.0);
+ Island island = addon.getIslands().getIslandAt(centre).orElse(null);
+ if (island == null || island.getOwner() == null) {
+ return;
+ }
+ // Capture all main-thread state before going async.
+ ChunkSnapshot snapshot = chunk.getChunkSnapshot();
+ ScanContext ctx = new ScanContext(world, chunk.getX() << 4, chunk.getZ() << 4,
+ world.getMinHeight(), world.getMaxHeight(),
+ island.getMinProtectedX(), island.getMaxProtectedX(),
+ island.getMinProtectedZ(), island.getMaxProtectedZ(),
+ addon.getPlugin().getIWM().getSeaHeight(world),
+ addon.getSettings().getUnderWaterMultiplier());
+
+ Bukkit.getScheduler().runTaskAsynchronously(addon.getPlugin(), () -> {
+ long total = scanSnapshot(snapshot, ctx);
+ if (total != 0L) {
+ Bukkit.getScheduler().runTask(addon.getPlugin(),
+ () -> addon.getManager().addToInitialCount(island, total));
+ }
+ });
+ }
+
+ private long scanSnapshot(ChunkSnapshot snapshot, ScanContext ctx) {
+ long total = 0L;
+ for (int x = 0; x < 16; x++) {
+ int globalX = ctx.chunkBlockX + x;
+ if (globalX >= ctx.minProtectedX && globalX < ctx.maxProtectedX) {
+ total += scanRow(snapshot, x, ctx);
+ }
+ }
+ return total;
+ }
+
+ private long scanRow(ChunkSnapshot snapshot, int x, ScanContext ctx) {
+ long total = 0L;
+ for (int z = 0; z < 16; z++) {
+ int globalZ = ctx.chunkBlockZ + z;
+ if (globalZ >= ctx.minProtectedZ && globalZ < ctx.maxProtectedZ) {
+ total += scanColumn(snapshot, x, z, ctx);
+ }
+ }
+ return total;
+ }
+
+ private long scanColumn(ChunkSnapshot snapshot, int x, int z, ScanContext ctx) {
+ long total = 0L;
+ for (int y = ctx.minHeight; y < ctx.maxHeight; y++) {
+ total += valueAt(snapshot, x, y, z, ctx);
+ }
+ return total;
+ }
+
+ private long valueAt(ChunkSnapshot snapshot, int x, int y, int z, ScanContext ctx) {
+ Material mat = snapshot.getBlockType(x, y, z);
+ if (mat.isAir()) {
+ return 0L;
+ }
+ Integer value = addon.getBlockConfig().getValue(ctx.world, mat);
+ if (value == null || value == 0) {
+ return 0L;
+ }
+ if (ctx.seaHeight > 0 && y <= ctx.seaHeight) {
+ return (long) (value * ctx.underwaterMultiplier);
+ }
+ return value;
+ }
+}

src/main/java/world/bentobox/level/Level.java

@@ -46,6 +46,7 @@
 import world.bentobox.level.listeners.IslandActivitiesListeners;
 import world.bentobox.level.listeners.JoinLeaveListener;
 import world.bentobox.level.listeners.MigrationListener;
+import world.bentobox.level.listeners.NewChunkListener;
 import world.bentobox.level.requests.LevelRequestHandler;
 import world.bentobox.level.requests.TopTenRequestHandler;
 import world.bentobox.visit.VisitAddon;
@@ -154,6 +155,10 @@ private void registerAllListeners() {
  registerListener(new IslandActivitiesListeners(this));
  registerListener(new JoinLeaveListener(this));
  registerListener(new MigrationListener(this));
+ // Accumulates generator block points into initialCount as new chunks
+ // are generated, so large protection ranges work with zero-new-island
+ // mode without forcing the initial scan to generate the whole area.
+ registerListener(new NewChunkListener(this));
  }
 
  private void registerGameModeCommands() {

src/main/java/world/bentobox/level/LevelsManager.java

@@ -480,7 +480,7 @@ public void removeEntry(World world, String uuid) {
 
  /**
  * Set an initial island count
- *
+ *
  * @param island - the island to set.
  * @param lv - initial island count
  */
@@ -489,6 +489,27 @@ public void setInitialIslandCount(@NonNull Island island, long lv) {
  handler.saveObjectAsync(levelsCache.get(island.getUniqueId()));
  }
 
+ /**
+ * Add a delta to the island's initial-count handicap. Used by the new-chunk
+ * listener to accumulate generator block points (sea floor, nether ceiling,
+ * etc.) into the initial count as chunks are generated during normal play.
+ * The initial count is subtracted from the live block total in the level
+ * calc, so generator blocks do not inflate the level.
+ *
+ * @param island the island
+ * @param delta the points to add (no-op when zero)
+ */
+ public void addToInitialCount(@NonNull Island island, long delta) {
+ if (delta == 0) {
+ return;
+ }
+ // Use getInitialCount so any legacy initialLevel is migrated first.
+ long current = getInitialCount(island);
+ IslandLevels data = getLevelsData(island);
+ data.setInitialCount(current + delta);
+ handler.saveObjectAsync(data);
+ }
+
  /**
  * Set the island level for the owner of the island that targetPlayer is a
  * member

src/main/java/world/bentobox/level/calculators/IslandLevelCalculator.java

@@ -366,8 +366,14 @@ private void loadChunks(CompletableFuture<List<Chunk>> r2, World world, Queue<Pa
  return;
  }
  Pair<Integer, Integer> p = pairList.poll();
- // We need to generate now all the time because some game modes are not voids
- Util.getChunkAtAsync(world, p.x, p.z, true).thenAccept(chunk -> {
+ // For zero-island scans, do not force chunk generation. Forcing the
+ // generator for every chunk in a large protection range (e.g. 1000 →
+ // ~16k chunks/dim) blows past the calculation timeout. Generator
+ // blocks that appear later (sea floor, nether ceiling, etc.) are
+ // picked up incrementally by NewChunkListener as chunks generate
+ // during normal play. Regular scans still generate, because some game
+ // modes are not voids.
+ Util.getChunkAtAsync(world, p.x, p.z, !zeroIsland).thenAccept(chunk -> {
  if (chunk != null) {
  chunkList.add(chunk);
  roseStackerCheck(chunk);

src/main/java/world/bentobox/level/listeners/NewChunkListener.java

@@ -0,0 +1,134 @@
+package world.bentobox.level.listeners;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.ChunkSnapshot;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.ChunkLoadEvent;
+
+import world.bentobox.bentobox.database.objects.Island;
+import world.bentobox.level.Level;
+
+/**
+ * Listens for freshly-generated chunks inside an island's protected area and
+ * adds the chunk's generator block points to the island's initial-count
+ * handicap.
+ * <p>
+ * Together with the {@code gen=false} initial zero scan in
+ * {@link world.bentobox.level.calculators.IslandLevelCalculator}, this lets
+ * zero-new-island-level mode work on islands with very large protection
+ * ranges. The initial scan only records what is already generated at island
+ * creation time (typically just the schematic chunks). As the player
+ * explores and new chunks are generated, this listener accumulates their
+ * generator block points into the initial count so they cancel out of the
+ * regular level calc — players only get credit for blocks they actually
+ * place.
+ */
+public class NewChunkListener implements Listener {
+
+ /**
+ * Snapshot of the main-thread state needed to score one chunk on a worker
+ * thread. Bundled into a record so the async scan helpers don't need to
+ * carry a dozen parameters each.
+ */
+ private record ScanContext(World world, int chunkBlockX, int chunkBlockZ, int minHeight, int maxHeight,
+ int minProtectedX, int maxProtectedX, int minProtectedZ, int maxProtectedZ,
+ int seaHeight, double underwaterMultiplier) {
+ }
+
+ private final Level addon;
+
+ public NewChunkListener(Level addon) {
+ this.addon = addon;
+ }
+
+ @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+ public void onChunkLoad(ChunkLoadEvent e) {
+ if (!e.isNewChunk()) {
+ return;
+ }
+ if (!addon.getSettings().isZeroNewIslandLevels()) {
+ return;
+ }
+ Chunk chunk = e.getChunk();
+ World world = chunk.getWorld();
+ if (!addon.isRegisteredGameModeWorld(world)) {
+ return;
+ }
+ // Use the chunk centre to look up the island that owns it.
+ // The + 8.0 keeps the addition in double arithmetic so SonarQube does not
+ // flag a theoretical int-overflow before the implicit widening.
+ Location centre = new Location(world, (chunk.getX() << 4) + 8.0, world.getMinHeight(),
+ (chunk.getZ() << 4) + 8.0);
+ Island island = addon.getIslands().getIslandAt(centre).orElse(null);
+ if (island == null || island.getOwner() == null) {
+ return;
+ }
+ // Capture all main-thread state before going async.
+ ChunkSnapshot snapshot = chunk.getChunkSnapshot();
+ ScanContext ctx = new ScanContext(world, chunk.getX() << 4, chunk.getZ() << 4,
+ world.getMinHeight(), world.getMaxHeight(),
+ island.getMinProtectedX(), island.getMaxProtectedX(),
+ island.getMinProtectedZ(), island.getMaxProtectedZ(),
+ addon.getPlugin().getIWM().getSeaHeight(world),
+ addon.getSettings().getUnderWaterMultiplier());
+
+ Bukkit.getScheduler().runTaskAsynchronously(addon.getPlugin(), () -> {
+ long total = scanSnapshot(snapshot, ctx);
+ if (total != 0L) {
+ Bukkit.getScheduler().runTask(addon.getPlugin(),
+ () -> addon.getManager().addToInitialCount(island, total));
+ }
+ });
+ }
+
+ private long scanSnapshot(ChunkSnapshot snapshot, ScanContext ctx) {
+ long total = 0L;
+ for (int x = 0; x < 16; x++) {
+ int globalX = ctx.chunkBlockX + x;
+ if (globalX >= ctx.minProtectedX && globalX < ctx.maxProtectedX) {
+ total += scanRow(snapshot, x, ctx);
+ }
+ }
+ return total;
+ }
+
+ private long scanRow(ChunkSnapshot snapshot, int x, ScanContext ctx) {
+ long total = 0L;
+ for (int z = 0; z < 16; z++) {
+ int globalZ = ctx.chunkBlockZ + z;
+ if (globalZ >= ctx.minProtectedZ && globalZ < ctx.maxProtectedZ) {
+ total += scanColumn(snapshot, x, z, ctx);
+ }
+ }
+ return total;
+ }
+
+ private long scanColumn(ChunkSnapshot snapshot, int x, int z, ScanContext ctx) {
+ long total = 0L;
+ for (int y = ctx.minHeight; y < ctx.maxHeight; y++) {
+ total += valueAt(snapshot, x, y, z, ctx);
+ }
+ return total;
+ }
+
+ private long valueAt(ChunkSnapshot snapshot, int x, int y, int z, ScanContext ctx) {
+ Material mat = snapshot.getBlockType(x, y, z);
+ if (mat.isAir()) {
+ return 0L;
+ }
+ Integer value = addon.getBlockConfig().getValue(ctx.world, mat);
+ if (value == null || value == 0) {
+ return 0L;
+ }
+ if (ctx.seaHeight > 0 && y <= ctx.seaHeight) {
+ return (long) (value * ctx.underwaterMultiplier);
+ }
+ return value;
+ }
+}