Merge W2F-hydroplanner

core/src/test/java/art/arcane/iris/generation/hydrology/HydrologyPlannerTest.java

@@ -133,6 +133,33 @@ public class HydrologyPlannerTest {
         assertTileContentsEqual(tile, planner.plan(EARLY_OWNER_TILE));
     }
 
+    @Test
+    public void evictedOwnerIsRestoredFromItsPlannedTileWithoutDrafting() {
+        AtomicInteger samples = new AtomicInteger();
+        HydrologyTerrainSampler counted = (int x, int z) -> {
+            samples.incrementAndGet();
+            return EARLY_OWNER_TERRAIN.sample(x, z);
+        };
+        HydrologyPlanner planner = new HydrologyPlanner(77L, EARLY_OWNER_SETTINGS, counted);
+        HydrologyTile tile = planner.plan(EARLY_OWNER_TILE);
+        CrossTileResolvedOwner original = tile.resolvedOwner();
+        planner.clearOwnerDrafts();
+        AtomicInteger lookups = new AtomicInteger();
+        planner.usePlannedTiles(key -> {
+            lookups.incrementAndGet();
+            return key.equals(EARLY_OWNER_TILE) ? tile : null;
+        });
+        samples.set(0);
+
+        CrossTileResolvedOwner restored = planner.resolveIndependentOwner(EARLY_OWNER_TILE);
+
+        assertEquals(original, restored);
+        assertEquals(0, samples.get());
+        assertEquals(1, lookups.get());
+        assertSame(restored, planner.resolveIndependentOwner(EARLY_OWNER_TILE));
+        assertEquals(1, lookups.get());
+    }
+
     @Test
     public void restoringPreparedTileKeepsExistingCanonicalOwner() {
         HydrologyPlanner planner = new HydrologyPlanner(77L, EARLY_OWNER_SETTINGS, EARLY_OWNER_TERRAIN);
@@ -381,6 +408,48 @@ public class HydrologyPlannerTest {
         }
     }
 
+    @Test
+    public void earlyOwnersStayInsideTheirScope() throws Exception {
+        org.junit.Assume.assumeTrue(Runtime.getRuntime().availableProcessors() > 2);
+        HydrologyPlannerSettings settings = withPeriodTwo(standardSettings(4D, 2D, true, false, List.of()));
+        HydrologyPlanner planner = new HydrologyPlanner(77L, settings, (x, z) -> blockedTerrain());
+        planner.limitEarlyOwners(key -> key.tileX() >= -1);
+        AutoCloseable admission = earlyAdmission(planner, new HydrologyTileKey(-1, -1));
+        Map<HydrologyTileKey, HydrologyForkJoin.Task<?>> tasks = earlyTasks(admission);
+        Method prepare = admission.getClass().getDeclaredMethod("prepare");
+        prepare.setAccessible(true);
+        CapturingHydrologyPool pool = new CapturingHydrologyPool();
+        try {
+            pool.submit(() -> {
+                prepare.invoke(admission);
+                return null;
+            }).get(5, TimeUnit.SECONDS);
+            assertEquals(List.of(new HydrologyTileKey(0, -1),
+                    new HydrologyTileKey(-1, -2), new HydrologyTileKey(-1, 0),
+                    new HydrologyTileKey(0, -2), new HydrologyTileKey(0, 0)), new ArrayList<>(tasks.keySet()));
+            assertEquals(new ArrayList<>(tasks.values()), pool.submitted);
+        } finally {
+            tasks.clear();
+            admission.close();
+            pool.shutdownNow();
+        }
+        planner.limitEarlyOwners(null);
+        AutoCloseable unlimited = earlyAdmission(planner, new HydrologyTileKey(-1, -1));
+        Map<HydrologyTileKey, HydrologyForkJoin.Task<?>> unlimitedTasks = earlyTasks(unlimited);
+        CapturingHydrologyPool unlimitedPool = new CapturingHydrologyPool();
+        try {
+            unlimitedPool.submit(() -> {
+                prepare.invoke(unlimited);
+                return null;
+            }).get(5, TimeUnit.SECONDS);
+            assertEquals(8, unlimitedTasks.size());
+        } finally {
+            unlimitedTasks.clear();
+            unlimited.close();
+            unlimitedPool.shutdownNow();
+        }
+    }
+
     private static final class CapturingHydrologyPool extends ForkJoinPool {
         private final ArrayList<Runnable> submitted = new ArrayList<>();
 

core/src/test/java/art/arcane/iris/generation/hydrology/HydrologyTileCacheTest.java

@@ -38,11 +38,15 @@ import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import org.mockito.ArgumentCaptor;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
@@ -590,6 +594,48 @@ public class HydrologyTileCacheTest {
         assertEquals(16, planned.size());
     }
 
+    @Test
+    @SuppressWarnings("unchecked")
+    public void pregenScopeLimitsEarlyOwnersToTheTilesTheAreaComposesFrom() {
+        HydrologyPlanner planner = mock(HydrologyPlanner.class);
+        HydrologyPlannerSettings settings = stalePrefetchSettings();
+        when(planner.settings()).thenReturn(settings);
+        when(planner.plan(any(HydrologyTileKey.class))).thenReturn(mock(HydrologyTile.class));
+        HydrologyTileCache cache = new HydrologyTileCache(planner, 128, new LinkedBlockingQueue<Runnable>()::add);
+        ArgumentCaptor<Predicate<HydrologyTileKey>> scope = ArgumentCaptor.forClass(Predicate.class);
+
+        HydrologyTileCache.PregenerationScope pregen = cache.preparePregeneration(
+                new HydrologyTileCache.PregenerationArea(0, 0, -1536, -1536, 2047, 2047));
+        verify(planner).limitEarlyOwners(scope.capture());
+        for (HydrologyTileKey key : prefetchRectangle(-2, 2, -2, 2)) {
+            assertTrue(key.toString(), scope.getValue().test(key));
+        }
+        assertFalse(scope.getValue().test(new HydrologyTileKey(-3, 0)));
+        assertFalse(scope.getValue().test(new HydrologyTileKey(0, 3)));
+
+        pregen.close();
+        verify(planner).limitEarlyOwners(null);
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void plannerFindsTilesThisCachePlanned() {
+        HydrologyPlanner planner = mock(HydrologyPlanner.class);
+        HydrologyTile tile = mock(HydrologyTile.class);
+        HydrologyPlannerSettings settings = stalePrefetchSettings();
+        when(planner.settings()).thenReturn(settings);
+        when(planner.plan(any(HydrologyTileKey.class))).thenReturn(tile);
+        HydrologyTileCache cache = new HydrologyTileCache(planner, 128);
+        ArgumentCaptor<Function<HydrologyTileKey, HydrologyTile>> planned = ArgumentCaptor.forClass(Function.class);
+        verify(planner).usePlannedTiles(planned.capture());
+        HydrologyTileKey key = new HydrologyTileKey(3, -2);
+
+        assertNull(planned.getValue().apply(key));
+        assertSame(tile, cache.get(key));
+        assertSame(tile, planned.getValue().apply(key));
+        verify(planner, times(1)).plan(key);
+    }
+
     @Test
     public void invalidPregenBoundsLeaveQueuedPrefetchIntact() {
         HydrologyPlanner planner = mock(HydrologyPlanner.class);