fix: refresh initialCount in tidyUp to close zero-scan/regular-scan race

When a player runs /level shortly after island creation and the zero scan
is parked on awaitPendingZeros for newly-generated chunks (typical when
/po create teleports the player and that fires isNewChunk events inside
the island bounds), the regular scan's constructor reads DB initialCount
before the zero scan's setInitialIslandCount has fired, snapshotting
initialCount=0 into results. By the time the regular scan's tidyUp runs,
the zero scan has finished, persisted is populated, and reconcile
returns delta=0 — so results.initialCount stays at 0 and the level math
treats every block as player-placed (level = totalPoints / level_cost).

Refresh results.initialCount from the DB after reconcile so the live
computation picks up:
  (a) a zero scan's setInitialIslandCount that landed between our
      constructor and now,
  (b) any reconcile delta this scan just folded in.

This produces level=0 on a fresh island regardless of whether the
regular scan or the zero scan wins the race to tidyUp.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: tastybento

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

@@ -865,13 +865,24 @@ public void tidyUp() {
         // doesn't already know about is added to both the map and the
         // initialCount — that's what catches chunks pregenerated before the
         // island existed, async-load misses at zero-scan time, and late
-        // chunk decoration. The returned delta is folded into the in-memory
-        // results so the level math below sees the up-to-date baseline.
+        // chunk decoration.
         if (addon.getSettings().isZeroNewIslandLevels() && !addon.getSettings().isDonationsOnly()
                 && !scannedChunkValues.isEmpty()) {
-            long delta = addon.getManager().reconcileHandicapChunks(island, scannedChunkValues, zeroIsland);
-            if (delta != 0L && !zeroIsland) {
-                results.initialCount.addAndGet(delta);
+            addon.getManager().reconcileHandicapChunks(island, scannedChunkValues, zeroIsland);
+            if (!zeroIsland) {
+                // Race-safe refresh of the in-memory baseline. Between the
+                // constructor's snapshot and now, two updates can land on the
+                // database that this calculator instance won't otherwise see:
+                // (a) a still-in-flight zero scan's setInitialIslandCount —
+                //     happens when the player runs /level seconds after island
+                //     creation while the zero scan is parked on
+                //     awaitPendingZeros for newly-generated chunks;
+                // (b) the reconcile call above, which folds chunks the scan
+                //     just discovered into the initialCount.
+                // The level math below uses results.initialCount, so reading
+                // the DB value back here keeps the live computation aligned
+                // with the actual persisted baseline.
+                results.initialCount.set(addon.getInitialIslandCount(island));
             }
         }
 

src/test/java/world/bentobox/level/calculators/IslandLevelCalculatorTidyUpTest.java

@@ -232,6 +232,31 @@ void donatedBlocksExceedLimit() {
                 "donated points should be capped at 500 * 3 = 1500, not 1000 * 3 = 3000");
     }
 
+    @Test
+    @DisplayName("Race: zero scan setInitialIslandCount lands after constructor — refresh keeps level math honest")
+    void initialCountRefreshAfterReconcile() {
+        // Constructor reads 0 (zero scan still in flight, hasn't called
+        // setInitialIslandCount yet). By the time tidyUp runs, the zero scan
+        // has finished and the DB has 130. Without the refresh, results
+        // .initialCount stays at 0 from the constructor and the level math
+        // computes 200/100=2 instead of the correct (200-130)/100=0. The
+        // refresh inside tidyUp picks up the updated DB value, producing the
+        // expected level.
+        when(addon.getInitialIslandCount(any(Island.class))).thenReturn(0L, INITIAL_COUNT);
+        when(manager.getInitialCount(any(Island.class))).thenReturn(INITIAL_COUNT);
+
+        IslandLevelCalculator calc = newCalculator();
+        Results r = calc.getResults();
+        // Force a non-empty scanned-chunk map so the reconcile/refresh branch fires.
+        calc.getScannedChunkValues().put("world:1", 200L);
+        r.rawBlockCount.set(200L);
+        calc.tidyUp();
+
+        assertEquals(0L, r.getLevel(),
+                "level should be 0 — refresh pulls the up-to-date initialCount=130 from the DB, "
+                        + "so modifiedPoints = 200 - 130 = 70 → 0 levels");
+    }
+
     @Test
     @DisplayName("Donated blocks with no limit: full count is used")
     void donatedBlocksNoLimit() {