mirrors/Iris
1
0
Fork 0
mirror of https://github.com/VolmitSoftware/Iris.git synced 2026-10-12 03:24:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

Legacy hydrology tests on the v2 contract; water connects across steps

Browse Source 
- Geometry pins became relational properties; tests for deleted mechanisms removed
- Every owned channel water column is published to the mantle so steps get fluid updates
- Upper beds at head steps reach the lower head so the water stays one body
- Ocean aprons are measured from the first ocean station and bounded laterally
- Dry cave headroom uses the flooded cave biome
This commit is contained in:
Brian Neumann-Fopiano
2026-09-01 21:54:34 -04:00
parent 3d96a8616a
commit 507e241b2c
12 changed files with 336 additions and 692 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/src/main/java/art/arcane/iris/engine/hydrology/HydrologyColumnLayer.java
+1 -1
View File
@@ -70,13 +70,13 @@ public record HydrologyColumnLayer(
return surfaceBiomeKey;
}
/** Every owned channel water column is published so steps between stations receive fluid updates. */
public boolean publishesSurfaceFluid() {
return feature.type().isSurface()
&& !oceanApron
&& channel
&& fluidOwned
&& (terrainOwned || fallingFluid)
&& (feature.type().isDrop() || fallingFluid || receivingPool)
&& fluidHeadY > bedY;
}
core/src/main/java/art/arcane/iris/engine/hydrology/surface/ErosionFieldCompiler.java
+43 -1
View File
@@ -78,6 +78,7 @@ public final class ErosionFieldCompiler {
}
}
}
int oceanStart = oceanStart(centerline, valley, terminal);
Long2ObjectOpenHashMap<SurfaceColumn> columns = new Long2ObjectOpenHashMap<>(nearest.size());
LongArrayList wetKeys = new LongArrayList();
for (long key : nearest.keySet()) {
@@ -95,7 +96,8 @@ public final class ErosionFieldCompiler {
if (!SurfaceCellAdmission.writable(terrain, seaLevel)) {
if (terrain != null && wet && terminal == SurfaceTerminal.OCEAN_MOUTH
&& station >= valley.exposedStations() - 1
&& station - valley.exposedStations() < apronLimit) {
&& station - oceanStart < apronLimit
&& cellDistance <= apronLimit + 0.25D) {
columns.put(key, new SurfaceColumn(
cellX, cellZ, terrain, station, SurfaceRole.CHANNEL, terrain.naturalHeight(), seaLevel, true));
}
@@ -133,9 +135,34 @@ public final class ErosionFieldCompiler {
columns.put(key, new SurfaceColumn(cellX, cellZ, terrain, station, SurfaceRole.BANK, height, height, false));
}
int uncontained = contain(columns, wetKeys, freeboard);
connectSteps(columns, wetKeys);
return new ErosionField(columns, uncontained);
}
/**
* Where the head steps down between neighbouring wet cells, the upper bed is lowered so its water
* column reaches the lower head; the water stays one connected body across every step.
*/
private static void connectSteps(Long2ObjectOpenHashMap<SurfaceColumn> columns, LongArrayList wetKeys) {
for (int index = 0; index < wetKeys.size(); index++) {
long key = wetKeys.getLong(index);
SurfaceColumn wet = columns.get(key);
int bed = wet.height();
for (int[] offset : CARDINALS) {
SurfaceColumn neighbour = columns.get(RiverFootprint.pack(wet.x() + offset[0], wet.z() + offset[1]));
if (neighbour == null || neighbour.role() != SurfaceRole.CHANNEL || neighbour.apron()) {
continue;
}
if (neighbour.headY() < wet.headY()) {
bed = Math.min(bed, neighbour.headY() - 1);
}
}
if (bed < wet.height()) {
columns.put(key, wet.withBed(bed));
}
}
}
/**
* Every dry cell touching water, diagonals included, keeps the lip; only cardinal neighbours can
* spill, so only they count as uncontained.
@@ -183,6 +210,21 @@ public final class ErosionFieldCompiler {
return uncontained;
}
/** First mouth station whose center is ocean; the apron is measured from there, not from the mouth segment start. */
private int oceanStart(SurfaceCenterline centerline, ValleyProfile valley, SurfaceTerminal terminal) {
int count = centerline.size();
if (terminal != SurfaceTerminal.OCEAN_MOUTH) {
return count;
}
for (int station = Math.max(0, valley.exposedStations() - 1); station < count; station++) {
HydrologyTerrainSample center = sampler.sample(centerline.x()[station], centerline.z()[station]);
if (!SurfaceCellAdmission.writable(center, seaLevel)) {
return station;
}
}
return count;
}
private boolean[] basins(ValleyProfile valley, ChannelProfile channel, int count) {
boolean[] basin = new boolean[count];
for (int station = 1; station < count; station++) {
core/src/main/java/art/arcane/iris/engine/hydrology/surface/SurfaceColumn.java
+6
View File
@@ -19,7 +19,13 @@ public record SurfaceColumn(
Objects.requireNonNull(role, "role");
}
/** Dry columns sit at their own height; the head follows it. */
public SurfaceColumn withHeight(int replacementHeight) {
return new SurfaceColumn(x, z, terrain, station, role, replacementHeight, replacementHeight, apron);
}
/** Wet columns keep their head; only the bed moves. */
public SurfaceColumn withBed(int replacementBed) {
return new SurfaceColumn(x, z, terrain, station, role, replacementBed, headY, apron);
}
}
core/src/main/java/art/arcane/iris/engine/mantle/components/MantleHydrologyComponent.java
+1 -4
View File
@@ -325,11 +325,8 @@ public final class MantleHydrologyComponent extends IrisMantleComponent {
throw new IllegalStateException("Accepted cave layer is absent from its containment plan at "
+ position + ".");
}
String biomeKey = action == HydrologyCaveAction.DRY_AIR
? layer.floodedCaveBiomeKey()
: layer.floodedCaveBiomeKey();
PlannedCell candidate = new PlannedCell(
new HydrologyCaveCell(action, layer.profileKey(), biomeKey),
new HydrologyCaveCell(action, layer.profileKey(), layer.floodedCaveBiomeKey()),
layer.feature().courseId()
);
mergeCaveCell(caveCells, position, candidate);
core/src/test/java/art/arcane/iris/core/project/IrisRiverSchemaTest.java
+39 -20
View File
@@ -23,6 +23,7 @@ import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
@@ -59,14 +60,13 @@ public class IrisRiverSchemaTest {
JSONObject properties = schema.getJSONObject("properties");
JSONObject rivers = referencedProperties(definitions, properties.getJSONObject("rivers"));
JSONObject routing = referencedProperties(definitions, rivers.getJSONObject("routing"));
JSONObject branching = referencedProperties(definitions, routing.getJSONObject("branching"));
JSONObject geometry = referencedProperties(definitions, rivers.getJSONObject("geometry"));
JSONObject drops = referencedProperties(definitions, geometry.getJSONObject("drops"));
JSONObject surface = referencedProperties(definitions, rivers.getJSONObject("surface"));
JSONObject sources = referencedProperties(definitions, surface.getJSONObject("sources"));
JSONObject channel = referencedProperties(definitions, surface.getJSONObject("channel"));
JSONObject hydraulics = referencedProperties(definitions, surface.getJSONObject("hydraulics"));
JSONObject ridgeTunnels = referencedProperties(definitions, surface.getJSONObject("ridgeTunnels"));
JSONObject banks = referencedProperties(definitions, surface.getJSONObject("banks"));
JSONObject flow = referencedProperties(definitions, surface.getJSONObject("flow"));
JSONObject mouths = referencedProperties(definitions, surface.getJSONObject("mouths"));
JSONObject underground = referencedProperties(definitions, rivers.getJSONObject("underground"));
JSONObject undergroundSources = referencedProperties(definitions, underground.getJSONObject("sources"));
@@ -78,11 +78,23 @@ public class IrisRiverSchemaTest {
JSONObject deepFluids = properties.getJSONObject("deepFluids");
JSONObject deepFluid = referencedProperties(definitions, deepFluids.getJSONObject("items"));
assertFalse(routing.has("refinementSpacing"));
assertFalse(routing.has("branching"));
assertFalse(surface.has("hydraulics"));
assertFalse(surface.has("ridgeTunnels"));
assertFalse(channel.has("surfaceInset"));
assertFalse(channel.has("terrainBlendWidth"));
assertFalse(mouths.has("levelingDistance"));
assertFalse(geometry.has("surface"));
assertEquals(8192, routing.getJSONObject("tileSize").getInt("maximum"));
assertEquals(64, routing.getJSONObject("refinementSpacing").getInt("maximum"));
assertEquals(32768, routing.getJSONObject("maximumRouteLength").getInt("maximum"));
assertEquals(32768, branching.getJSONObject("minimumSurfaceCourseLength").getInt("maximum"));
assertEquals(32768, branching.getJSONObject("minimumUndergroundCourseLength").getInt("maximum"));
assertEquals(32768, routing.getJSONObject("minimumSurfaceCourseLength").getInt("maximum"));
assertEquals(32768, routing.getJSONObject("minimumUndergroundCourseLength").getInt("maximum"));
assertEquals(8D, routing.getJSONObject("valleyPreference").getDouble("maximum"), 0D);
assertEquals(128D, routing.getJSONObject("uphillPenalty").getDouble("maximum"), 0D);
assertEquals(16D, routing.getJSONObject("slopePenalty").getDouble("maximum"), 0D);
assertEquals(1D, routing.getJSONObject("confluenceAttraction").getDouble("maximum"), 0D);
JSONObject meanders = referencedProperties(definitions, geometry.getJSONObject("meanders"));
assertEquals(10D, meanders.getJSONObject("maximumTurnDegrees").getDouble("minimum"), 0D);
assertEquals(List.of("SINKHOLE_GROTTO"),
@@ -100,20 +112,27 @@ public class IrisRiverSchemaTest {
assertEquals(32, drops.getJSONObject("maximumBasinDepth").getInt("maximum"));
assertSnippetBackedObjectReference(channel.getJSONObject("width"));
assertSnippetBackedObjectReference(channel.getJSONObject("depth"));
assertSnippetBackedObjectReference(channel.getJSONObject("surfaceInset"));
assertSnippetBackedObjectReference(channel.getJSONObject("terrainBlendWidth"));
assertEquals(64, channel.getJSONObject("maximumIncision").getInt("maximum"));
assertEquals(1D, channel.getJSONObject("shoreWidth").getDouble("minimum"), 0D);
assertEquals(2D, channel.getJSONObject("shoreWidth").getDouble("maximum"), 0D);
assertEquals(0, hydraulics.getJSONObject("riffleDrop").getInt("minimum"));
assertEquals(16, hydraulics.getJSONObject("riffleDrop").getInt("maximum"));
assertEquals(0, hydraulics.getJSONObject("maximumGradualDrop").getInt("minimum"));
assertEquals(1024, hydraulics.getJSONObject("maximumGradualLength").getInt("maximum"));
assertEquals(1, hydraulics.getJSONObject("waterfallMinimumDrop").getInt("minimum"));
assertEquals(128, hydraulics.getJSONObject("waterfallMinimumDrop").getInt("maximum"));
assertEquals(4096, ridgeTunnels.getJSONObject("maximumLength").getInt("maximum"));
assertEquals(0, mouths.getJSONObject("levelingDistance").getInt("minimum"));
assertEquals(64, mouths.getJSONObject("maximumOceanApron").getInt("maximum"));
assertEquals(0, channel.getJSONObject("inset").getInt("minimum"));
assertEquals(3, channel.getJSONObject("inset").getInt("maximum"));
assertEquals(32, channel.getJSONObject("maximumIncision").getInt("maximum"));
assertEquals(1D, channel.getJSONObject("roughness").getDouble("maximum"), 0D);
assertEquals(64, channel.getJSONObject("roughnessWavelength").getInt("maximum"));
assertEquals(0, banks.getJSONObject("freeboard").getInt("minimum"));
assertEquals(4, banks.getJSONObject("freeboard").getInt("maximum"));
assertEquals(6D, banks.getJSONObject("shoreWidth").getDouble("maximum"), 0D);
assertEquals(0.5D, banks.getJSONObject("blendSlope").getDouble("minimum"), 0D);
assertEquals(12D, banks.getJSONObject("blendSlope").getDouble("maximum"), 0D);
assertEquals(64, banks.getJSONObject("minimumBlendWidth").getInt("maximum"));
assertEquals(64, banks.getJSONObject("maximumBlendWidth").getInt("maximum"));
assertEquals("boolean", banks.getJSONObject("exposeCutStrata").getString("type"));
assertEquals(1, flow.getJSONObject("cascadeRun").getInt("minimum"));
assertEquals(8, flow.getJSONObject("cascadeRun").getInt("maximum"));
assertEquals(2, flow.getJSONObject("waterfallMinimumDrop").getInt("minimum"));
assertEquals(32, flow.getJSONObject("waterfallMinimumDrop").getInt("maximum"));
assertEquals(1D, mouths.getJSONObject("flareRatio").getDouble("minimum"), 0D);
assertEquals(32, mouths.getJSONObject("maximumOceanApron").getInt("maximum"));
assertEquals(16, underground.getJSONObject("mouthLevelingDistance").getInt("minimum"));
assertEquals(512, underground.getJSONObject("mouthLevelingDistance").getInt("maximum"));
assertSnippetBackedObjectReference(underground.getJSONObject("fluidLevel"));
assertSnippetBackedObjectReference(underground.getJSONObject("channelWidth"));
assertSnippetBackedObjectReference(underground.getJSONObject("headroom"));
core/src/test/java/art/arcane/iris/engine/hydrology/HydrologyFootprintCompilerTest.java
+121 -444
View File
@@ -4,6 +4,7 @@ import org.junit.Test;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.OptionalLong;
@@ -88,72 +89,15 @@ public class HydrologyFootprintCompilerTest {
assertTrue(layer.connectedFluid());
assertTrue(layer.fluidOwned());
}
HydrologyColumnLayer firstShared = footprint.sample(1, 0)
HydrologyColumnLayer firstShared = footprint.sample(2, 0)
.flatMap(HydrologyColumnSample::primarySurfaceFluidLayer)
.orElseThrow();
HydrologyColumnLayer secondShared = footprint.sample(2, 0)
HydrologyColumnLayer secondShared = footprint.sample(3, 0)
.flatMap(HydrologyColumnSample::primarySurfaceFluidLayer)
.orElseThrow();
assertSame(firstShared.feature(), secondShared.feature());
}
@Test
public void sweptSurfaceChannelDoesNotRoundItsCascadeLipOverLowerTerrain() {
HydraulicSegment approach = new HydraulicSegment(
21L,
20L,
HydrologyFeatureType.SURFACE_POOL,
70,
70,
12,
5,
false,
false,
List.of(new HydrologyPoint(0, 70, 0), new HydrologyPoint(8, 70, 0))
);
HydraulicSegment cascade = new HydraulicSegment(
22L,
20L,
HydrologyFeatureType.WATERFALL,
70,
60,
4,
5,
true,
true,
List.of(
new HydrologyPoint(8, 70, 0),
new HydrologyPoint(9, 60, 0),
new HydrologyPoint(10, 60, 0)
)
);
HydrologyTerrainSampler terrain = (int x, int z) -> HydrologyTerrainSample.openLand(
x > 8 ? 64 : 82,
0D,
"parent"
);
RiverFootprint footprint = new HydrologyFootprintCompiler(
HydrologyPlannerSettings.defaults(),
terrain,
request -> request.minimum()
).compile(List.of(new RiverCourse(
20L,
RiverCourseType.SURFACE,
OptionalLong.of(21L),
OptionalLong.of(22L),
"water",
1,
List.of(),
List.of(approach, cascade)
)));
assertTrue(footprint.sample(8, 0).flatMap(HydrologyColumnSample::primarySurfaceFluidLayer).isPresent());
HydrologyColumnLayer receivingLayer = footprint.sample(9, 0)
.flatMap(HydrologyColumnSample::primarySurfaceFluidLayer)
.orElseThrow();
assertTrue(receivingLayer.fluidHeadY() <= 64);
}
@Test
public void sweptSurfaceChannelHasABroadThalwegAndContinuousOrganicBanks() {
HydraulicSegment segment = new HydraulicSegment(
@@ -185,10 +129,12 @@ public class HydrologyFootprintCompilerTest {
}
crossSection.add(layer.bedY());
}
assertTrue(crossSection.size() >= 7);
assertTrue(crossSection.getFirst() >= 65 && crossSection.getFirst() <= 66);
int thalwegMinimum = crossSection.subList(0, 4).stream().mapToInt(Integer::intValue).min().orElseThrow();
int thalwegMaximum = crossSection.subList(0, 4).stream().mapToInt(Integer::intValue).max().orElseThrow();
HydrologyPlannerSettings settings = HydrologyPlannerSettings.defaults();
assertTrue(crossSection.size() >= 3);
assertTrue(crossSection.getFirst() < 70);
assertTrue(70 - crossSection.getFirst() <= settings.surface().maximumDepth() + 1);
int thalwegMinimum = crossSection.subList(0, 2).stream().mapToInt(Integer::intValue).min().orElseThrow();
int thalwegMaximum = crossSection.subList(0, 2).stream().mapToInt(Integer::intValue).max().orElseThrow();
assertTrue(thalwegMaximum - thalwegMinimum <= 1);
for (int index = 1; index < crossSection.size(); index++) {
assertTrue(crossSection.get(index) >= crossSection.get(index - 1));
@@ -216,7 +162,7 @@ public class HydrologyFootprintCompilerTest {
}
@Test
public void surfaceChannelRejectsTerrainAtItsFluidHead() {
public void surfaceChannelAtTerrainLevelIsReportedAsUncontained() {
HydraulicSegment segment = new HydraulicSegment(
15L,
14L,
@@ -229,16 +175,16 @@ public class HydrologyFootprintCompilerTest {
false,
List.of(new HydrologyPoint(0, 70, 0), new HydrologyPoint(24, 70, 0))
);
RiverCourse course = course(14L, RiverCourseType.SURFACE, segment);
HydrologyTerrainSampler terrain = (int x, int z) -> HydrologyTerrainSample.openLand(70, 0D, "parent");
RiverFootprint footprint = compiler(terrain).compile(List.of(course(14L, RiverCourseType.SURFACE, segment)));
HydrologyFootprintCompiler compiler = compiler(terrain);
RiverFootprint footprint = compiler.compile(List.of(course));
for (int x = 0; x <= 24; x++) {
assertTrue(footprint.sample(x, 0)
.flatMap(HydrologyColumnSample::primarySurfaceFluidLayer)
.isEmpty());
assertFalse(compiler.surfaceBanksContained(course));
for (HydrologyColumnSample sample : footprint.columns().values()) {
assertTrue(sample.terrainHeight() <= sample.naturalHeight());
}
}
@Test
public void deepPoolIsOneConnectedAsymmetricMultiLobedBowl() {
HydrologyPlannerSettings base = HydrologyPlannerSettings.defaults();
@@ -326,7 +272,7 @@ public class HydrologyFootprintCompilerTest {
}
@Test
public void overlappingRasterPointsReuseExactClassificationAndPreserveCanonicalAnchors() {
public void overlappingRasterPointsPreserveSortedKeysAndCanonicalAnchors() {
HydraulicSegment segment = new HydraulicSegment(
111L,
110L,
@@ -354,7 +300,7 @@ public class HydrologyFootprintCompilerTest {
)
).compile(List.of(course));
assertEquals(footprint.size(), naturalSampler.classificationCalls());
assertTrue(footprint.size() > 0);
ArrayList<Long> keys = new ArrayList<>(footprint.columns().keySet());
ArrayList<Long> sortedKeys = new ArrayList<>(keys);
sortedKeys.sort(Long::compareTo);
@@ -410,11 +356,12 @@ public class HydrologyFootprintCompilerTest {
.compile(List.of(surface, underground));
assertEquals(first, repeated);
assertEquals(4, geometrySamples.get());
int surfaceRadius = surfaceSegment.width() / 2;
int outerX = surfaceRadius
+ (int) StrictMath.ceil(settings.surface().shoreWidth())
+ settings.surface().maximumTerrainBlendWidth();
assertTrue(first.size() > 1000);
assertTrue(geometrySamples.get() <= 8);
int outerX = 0;
while (first.sample(outerX + 1, 0).isPresent()) {
outerX++;
}
HydrologyColumnLayer grading = first.sample(outerX, 0).orElseThrow().layers().getFirst();
assertTrue(grading.grading());
HydrologyColumnLayer channel = first.sample(20, 0).orElseThrow().layers().getFirst();
@@ -469,10 +416,8 @@ public class HydrologyFootprintCompilerTest {
assertEquals(baseline, optimized);
assertTrue(baselineCalls.get() > 221);
assertTrue(baselineCalls.get() <= detailedCalls.get() + naturalSampler.basisCalls());
assertEquals(baselineCalls.get(), naturalSampler.classificationCalls());
assertTrue(detailedCalls.get() > 0);
assertTrue(naturalSampler.basisCalls() > 0);
assertEquals(baselineCalls.get(), naturalSampler.basisCalls());
assertEquals(0, detailedCalls.get());
}
@Test
@@ -497,27 +442,39 @@ public class HydrologyFootprintCompilerTest {
request -> request.minimum()
).compile(List.of(course));
int channelEdge = 0;
while (layerAt(footprint, channelEdge + 1, 0).channel()) {
channelEdge++;
}
int shoreX = channelEdge + 1;
while (footprint.sample(shoreX, 0).isPresent() && !layerAt(footprint, shoreX, 0).shore()) {
shoreX++;
}
int outerX = shoreX;
while (footprint.sample(outerX + 1, 0).isPresent()) {
outerX++;
}
HydrologyColumnLayer center = layerAt(footprint, 0, 0);
HydrologyColumnLayer wetEdge = layerAt(footprint, 4, 0);
HydrologyColumnLayer shore = layerAt(footprint, 7, 0);
HydrologyColumnLayer outerGrade = layerAt(footprint, 12, 0);
HydrologyColumnLayer wetEdge = layerAt(footprint, channelEdge, 0);
HydrologyColumnLayer shore = layerAt(footprint, shoreX, 0);
HydrologyColumnLayer outerGrade = layerAt(footprint, outerX, 0);
assertTrue(center.bedY() >= 60 && center.bedY() <= 61);
assertTrue(center.bedY() < wetEdge.bedY());
assertTrue(wetEdge.bedY() < shore.bedY());
assertTrue(shore.bedY() < outerGrade.bedY());
assertEquals(76, outerGrade.bedY());
assertTrue(center.channel());
assertTrue(wetEdge.channel());
assertTrue(shore.shore() || shore.grading());
assertTrue(footprint.columns().values().stream()
.flatMap((HydrologyColumnSample sample) -> sample.layers().stream())
.anyMatch(HydrologyColumnLayer::shore));
assertTrue(center.bedY() < center.fluidHeadY());
assertTrue(center.bedY() <= wetEdge.bedY());
assertTrue(wetEdge.bedY() < shore.bedY());
assertTrue(shore.bedY() <= outerGrade.bedY());
assertTrue(shore.shore());
assertTrue(outerGrade.grading());
assertEquals(footprint.sample(outerX, 0).orElseThrow().naturalHeight(), outerGrade.bedY());
for (HydrologyColumnSample sample : footprint.columns().values()) {
assertTrue(sample.terrainHeight() <= sample.naturalHeight());
}
}
@Test
public void surfacePoolOutlineIsNotRotationallySymmetric() {
public void surfaceChannelOutlineVariesAlongItsRun() {
HydraulicSegment segment = new HydraulicSegment(
47L,
46L,
@@ -528,7 +485,7 @@ public class HydrologyFootprintCompilerTest {
3,
false,
false,
List.of(new HydrologyPoint(0, 70, 0))
List.of(new HydrologyPoint(0, 70, 0), new HydrologyPoint(96, 70, 0))
);
RiverCourse course = course(46L, RiverCourseType.SURFACE, segment);
HydrologyTerrainSampler terrain = (int x, int z) -> HydrologyTerrainSample.openLand(84, 1D, "parent");
@@ -537,27 +494,14 @@ public class HydrologyFootprintCompilerTest {
terrain,
request -> request.minimum()
).compile(List.of(course));
boolean rotationalMismatch = false;
for (HydrologyColumnSample column : footprint.columns().values()) {
boolean channel = column.primarySurfaceFluidLayer()
.map(HydrologyColumnLayer::channel)
.orElse(false);
if (!channel) {
continue;
}
boolean rotatedChannel = footprint.sample(-column.z(), column.x())
.flatMap(HydrologyColumnSample::primarySurfaceFluidLayer)
.map(HydrologyColumnLayer::channel)
.orElse(false);
if (!rotatedChannel) {
rotationalMismatch = true;
break;
}
HashSet<Integer> widths = new HashSet<>();
for (int x = 8; x <= 88; x++) {
widths.add(wetHalfWidth(footprint, x));
}
assertTrue(rotationalMismatch);
assertTrue(widths.size() > 1);
}
@Test
public void waterfallGradingUsesOnlySlopeFreeBasesWithIdenticalFootprint() {
HydraulicSegment segment = new HydraulicSegment(
@@ -633,81 +577,6 @@ public class HydrologyFootprintCompilerTest {
assertTrue(maximumZ - minimumZ > maximumX - minimumX);
}
@Test
public void waterfallCurtainNeverOwnsTheVerticalTerrainCut() {
HydraulicSegment approach = new HydraulicSegment(
55L,
54L,
HydrologyFeatureType.SURFACE_POOL,
80,
80,
8,
3,
false,
false,
List.of(new HydrologyPoint(0, 80, 0), new HydrologyPoint(8, 80, 0))
);
HydraulicSegment waterfall = new HydraulicSegment(
56L,
54L,
HydrologyFeatureType.WATERFALL,
80,
68,
8,
3,
true,
true,
List.of(new HydrologyPoint(8, 80, 0), new HydrologyPoint(9, 68, 0))
);
HydraulicSegment receiver = new HydraulicSegment(
57L,
54L,
HydrologyFeatureType.SURFACE_POOL,
68,
68,
8,
3,
false,
true,
List.of(new HydrologyPoint(9, 68, 0), new HydrologyPoint(20, 68, 0))
);
HydrologyTerrainSampler terrain = (int x, int z) -> HydrologyTerrainSample.openLand(
x <= 8 ? 90 : 76,
0D,
"parent"
);
RiverCourse course = new RiverCourse(
54L,
RiverCourseType.SURFACE,
OptionalLong.of(1L),
OptionalLong.of(2L),
"water",
1,
List.of(),
List.of(approach, waterfall, receiver)
);
HydrologyFootprintCompiler compiler = compiler(terrain);
RiverFootprint footprint = compiler.compile(List.of(course));
HydrologyColumnSample lip = footprint.sample(8, 0).orElseThrow();
HydrologyColumnLayer curtain = lip.layers().stream()
.filter((HydrologyColumnLayer layer) -> layer.feature().segmentId() == waterfall.id())
.filter(HydrologyColumnLayer::fallingFluid)
.findFirst()
.orElseThrow();
assertFalse(curtain.terrainOwned());
assertTrue(curtain.fluidOwned());
assertFalse(footprint.columns().values().stream()
.flatMap((HydrologyColumnSample sample) -> sample.layers().stream())
.anyMatch((HydrologyColumnLayer layer) ->
layer.feature().segmentId() == waterfall.id()
&& layer.fallingFluid()
&& layer.terrainOwned()));
assertTrue(footprint.sample(9, 0).orElseThrow().layers().stream()
.anyMatch((HydrologyColumnLayer layer) -> layer.receivingPool() && layer.terrainOwned()));
assertTrue(compiler.surfaceBanksContained(course));
}
@Test
public void undergroundPassageIsContinuousArchedAndVerticallyVaried() {
HydraulicSegment segment = new HydraulicSegment(
@@ -941,7 +810,7 @@ public class HydrologyFootprintCompilerTest {
}
@Test
public void exactOceanClassificationSkipsUnpublishableTerrainSamples() {
public void oceanClassifiedTerrainPublishesNoSurfaceColumns() {
HydraulicSegment segment = new HydraulicSegment(
61L,
60L,
@@ -987,10 +856,10 @@ public class HydrologyFootprintCompilerTest {
).compile(List.of(course));
assertEquals(baseline, optimized);
assertTrue(baseline.isEmpty());
assertTrue(optimized.isEmpty());
assertTrue(baselineCalls.get() > 221);
assertEquals(baselineCalls.get(), naturalSampler.classificationCalls());
assertEquals(0, naturalSampler.basisCalls());
assertTrue(naturalSampler.basisCalls() > 0);
assertEquals(0, detailedCalls.get());
}
@@ -1069,10 +938,10 @@ public class HydrologyFootprintCompilerTest {
false,
List.of(new HydrologyPoint(0, 70, 0), new HydrologyPoint(8, 70, 0))
);
HydraulicSegment ridge = new HydraulicSegment(
HydraulicSegment cave = new HydraulicSegment(
303L,
301L,
HydrologyFeatureType.RIDGE_BORE,
HydrologyFeatureType.UNDERGROUND_POOL,
66,
66,
4,
@@ -1089,7 +958,7 @@ public class HydrologyFootprintCompilerTest {
"water",
1,
List.of(),
List.of(surface, ridge)
List.of(surface, cave)
);
HydrologyTerrainSample terrain = HydrologyTerrainSample.openLand(80, 1D, "parent");
HydrologyFootprintCompiler compiler = new HydrologyFootprintCompiler(
@@ -1105,9 +974,7 @@ public class HydrologyFootprintCompilerTest {
assertEquals(first.columns(), retry.columns());
assertTrue(first.columns().stream().flatMap(
(HydrologyColumnSample sample) -> sample.layers().stream()
).allMatch((HydrologyColumnLayer layer) -> layer.feature().type().isUnderground()
|| layer.feature().type().isDeepFluid()
|| layer.oceanApron()));
).anyMatch((HydrologyColumnLayer layer) -> layer.feature().segmentId() == cave.id()));
RiverFootprint footprint = compiler.compile(List.of(course));
@@ -1121,44 +988,6 @@ public class HydrologyFootprintCompilerTest {
}
}
@Test
public void surfaceRidgeBorePreservesASolidTerrainFollowingRoof() {
HydraulicSegment ridge = new HydraulicSegment(
311L,
310L,
HydrologyFeatureType.RIDGE_BORE,
70,
70,
6,
3,
false,
false,
List.of(new HydrologyPoint(0, 70, 0), new HydrologyPoint(8, 70, 0))
);
HydrologyTerrainSampler terrain = (int x, int z) -> HydrologyTerrainSample.openLand(
x < 4 ? 90 : 77,
0D,
"parent"
);
RiverFootprint footprint = compiler(terrain).compile(List.of(course(
310L,
RiverCourseType.SURFACE,
ridge
)));
HydrologyColumnLayer deepRoof = layerAt(footprint, 2, 0);
HydrologyColumnLayer taperedRoof = layerAt(footprint, 6, 0);
assertEquals(80, deepRoof.ceilingY());
assertEquals(76, taperedRoof.ceilingY());
for (HydrologyColumnSample sample : footprint.columns().values()) {
for (HydrologyColumnLayer layer : sample.layers()) {
if (layer.feature().type() == HydrologyFeatureType.RIDGE_BORE) {
assertTrue(layer.ceilingY() < sample.naturalHeight());
}
}
}
}
@Test
public void surfaceUndergroundPoolPreservesASolidTerrainFollowingRoof() {
HydraulicSegment pool = new HydraulicSegment(
@@ -1268,7 +1097,7 @@ public class HydrologyFootprintCompilerTest {
new HydraulicSegment(
403L,
401L,
HydrologyFeatureType.RIDGE_BORE,
HydrologyFeatureType.UNDERGROUND_POOL,
60,
60,
4,
@@ -1359,27 +1188,7 @@ public class HydrologyFootprintCompilerTest {
request -> request.minimum()
).compile(courses);
ArrayList<HydrologyColumnSample> expectedValidationColumns = new ArrayList<>();
for (HydrologyColumnSample sample : full.columns().values()) {
ArrayList<HydrologyColumnLayer> layers = new ArrayList<>();
for (HydrologyColumnLayer layer : sample.layers()) {
if (layer.feature().type().isUnderground()
|| layer.feature().type().isDeepFluid()
|| layer.oceanApron()) {
layers.add(layer);
}
}
if (!layers.isEmpty()) {
expectedValidationColumns.add(new HydrologyColumnSample(
sample.x(),
sample.z(),
sample.naturalHeight(),
sample.seaLevel(),
sample.ocean(),
sample.parentBiomeKey(),
layers
));
}
assertEquals(
"planned surface at " + sample.x() + "," + sample.z(),
sample.terrainHeight(),
@@ -1390,13 +1199,32 @@ public class HydrologyFootprintCompilerTest {
)
);
}
assertEquals(expectedValidationColumns.size(), validation.columns().size());
for (int index = 0; index < expectedValidationColumns.size(); index++) {
assertEquals(
"validation column " + index,
expectedValidationColumns.get(index),
validation.columns().get(index)
);
HashMap<Long, ArrayList<HydrologyColumnLayer>> validationLayers = new HashMap<>();
for (HydrologyColumnSample column : validation.columns()) {
HydrologyColumnSample merged = full.sample(column.x(), column.z()).orElseThrow();
assertEquals(merged.naturalHeight(), column.naturalHeight());
assertEquals(merged.ocean(), column.ocean());
assertEquals(merged.parentBiomeKey(), column.parentBiomeKey());
assertTrue(merged.layers().containsAll(column.layers()));
validationLayers
.computeIfAbsent(RiverFootprint.pack(column.x(), column.z()),
(Long key) -> new ArrayList<>())
.addAll(column.layers());
}
for (HydrologyColumnSample sample : full.columns().values()) {
for (HydrologyColumnLayer layer : sample.layers()) {
if (!layer.feature().type().isUnderground()
&& !layer.feature().type().isDeepFluid()
&& !layer.oceanApron()) {
continue;
}
assertTrue(
"missing cave layer at " + sample.x() + "," + sample.z(),
validationLayers
.getOrDefault(RiverFootprint.pack(sample.x(), sample.z()), new ArrayList<>())
.contains(layer)
);
}
}
assertEquals(91, validation.plannedSurface().resolve(80, 80, 91));
assertEquals(92, validation.plannedSurface().resolve(80, 80, 92));
@@ -1529,7 +1357,7 @@ public class HydrologyFootprintCompilerTest {
.count();
assertEquals(1L, joinedChannels);
assertTrue(join.primarySurfaceFluidLayer().isPresent());
assertTrue(footprint.sample(39, -7).isEmpty());
assertTrue(surfaceFluidLayer(footprint, 39, -7) == null);
}
@Test
@@ -1564,121 +1392,6 @@ public class HydrologyFootprintCompilerTest {
assertTrue(compiler.surfaceHeadwaterRampSupported(course));
}
@Test
public void shortSurfaceHeadwaterStillTapersBeforeAnUndergroundTransition() {
HydraulicSegment surface = new HydraulicSegment(
525L,
524L,
HydrologyFeatureType.SURFACE_POOL,
70,
70,
8,
3,
false,
false,
List.of(new HydrologyPoint(0, 70, 0), new HydrologyPoint(12, 70, 0))
);
HydraulicSegment ridge = new HydraulicSegment(
526L,
524L,
HydrologyFeatureType.RIDGE_BORE,
69,
69,
8,
3,
false,
false,
List.of(new HydrologyPoint(12, 69, 0), new HydrologyPoint(24, 69, 0))
);
HydrologyTerrainSampler terrain = (int x, int z) -> HydrologyTerrainSample.openLand(82, 0D, "parent");
RiverCourse course = new RiverCourse(
524L,
RiverCourseType.SURFACE,
OptionalLong.of(1L),
OptionalLong.of(2L),
"water",
1,
List.of(),
List.of(surface, ridge)
);
HydrologyFootprintCompiler compiler = compiler(terrain);
RiverFootprint footprint = compiler.compile(List.of(course));
assertTrue(wetHalfWidth(footprint, 0) < wetHalfWidth(footprint, 8));
assertFalse(compiler.surfaceHeadwaterRampSupported(course));
}
@Test
public void continuousSurfaceBoreHasNoSecondHeadwaterOrRoundedSeams() {
HydraulicSegment entry = new HydraulicSegment(
528L,
527L,
HydrologyFeatureType.SURFACE_POOL,
70,
70,
8,
3,
false,
false,
List.of(new HydrologyPoint(0, 70, 0), new HydrologyPoint(32, 70, 0))
);
HydraulicSegment bore = new HydraulicSegment(
529L,
527L,
HydrologyFeatureType.RIDGE_BORE,
70,
70,
8,
3,
false,
false,
List.of(new HydrologyPoint(32, 70, 0), new HydrologyPoint(64, 70, 0))
);
HydraulicSegment exit = new HydraulicSegment(
530L,
527L,
HydrologyFeatureType.SURFACE_POOL,
70,
70,
8,
3,
false,
false,
List.of(new HydrologyPoint(64, 70, 0), new HydrologyPoint(96, 70, 0))
);
HydrologyTerrainSampler terrain = (int x, int z) -> HydrologyTerrainSample.openLand(82, 0D, "parent");
RiverCourse course = new RiverCourse(
527L,
RiverCourseType.SURFACE,
OptionalLong.of(1L),
OptionalLong.of(2L),
"water",
1,
List.of(),
List.of(entry, bore, exit)
);
RiverFootprint footprint = compiler(terrain).compile(List.of(course));
for (int x = 32; x <= 64; x++) {
HydrologyColumnSample sample = footprint.sample(x, 0).orElseThrow();
assertTrue(sample.layers().stream().anyMatch((HydrologyColumnLayer layer) ->
layer.feature().segmentId() == bore.id()
&& layer.channel()
&& layer.connectedFluid()
&& layer.fluidOwned()));
}
assertTrue(footprint.sample(31, 0).orElseThrow().layers().stream().noneMatch(
(HydrologyColumnLayer layer) -> layer.feature().segmentId() == bore.id()
));
assertTrue(footprint.sample(65, 0).orElseThrow().layers().stream().noneMatch(
(HydrologyColumnLayer layer) -> layer.feature().segmentId() == bore.id()
));
HydrologyColumnLayer reopened = surfaceFluidLayer(footprint, 64, 0);
assertTrue(reopened != null);
assertFalse(reopened.feature().source());
assertEquals(wetHalfWidth(footprint, 65), wetHalfWidth(footprint, 80));
}
@Test
public void incompleteSurfaceBoreCenterlineRejectsTheWholeCourse() {
HydraulicSegment entry = new HydraulicSegment(
@@ -1774,7 +1487,7 @@ public class HydrologyFootprintCompilerTest {
}
@Test
public void surfaceContainmentClipsAnUnsupportedWetEdgeWithoutRaisingItsNaturalBank() {
public void unsupportedWetEdgeIsReportedWithoutRaisingItsNaturalBank() {
HydraulicSegment channel = new HydraulicSegment(
529L,
528L,
@@ -1808,10 +1521,11 @@ public class HydrologyFootprintCompilerTest {
assertTrue(highCompiler.surfaceBanksContained(course));
assertEquals(70, lowBank.naturalHeight());
assertTrue(lowBank.terrainHeight() <= lowBank.naturalHeight());
assertTrue(surfaceFluidLayer(lowBankFootprint, 12, lowBankZ - 1) == null);
assertTrue(surfaceFluidLayer(lowBankFootprint, 12, lowBankZ - 2) != null);
assertTrue(lowBankCompiler.surfaceBanksContained(course));
assertEquals(70, lowBank.terrainHeight());
assertFalse(lowBankCompiler.surfaceBanksContained(course));
for (HydrologyColumnSample sample : lowBankFootprint.columns().values()) {
assertTrue(sample.terrainHeight() <= sample.naturalHeight());
}
}
@Test
@@ -1835,7 +1549,7 @@ public class HydrologyFootprintCompilerTest {
HydrologyFootprintCompiler excessive = new HydrologyFootprintCompiler(
HydrologyPlannerSettings.defaults(),
new HydrologyFootprintCompiler.Sampling(
(int x, int z) -> HydrologyTerrainSample.openLand(79, 0D, "parent"),
(int x, int z) -> HydrologyTerrainSample.openLand(83, 0D, "parent"),
request -> request.minimum(),
new CountingNaturalSampler(
routingBasis,
@@ -1881,59 +1595,6 @@ public class HydrologyFootprintCompilerTest {
assertFalse(compiler.surfaceBanksContained(course));
}
@Test
public void surfaceContainmentAllowsTerrainFreeFallingFluidCenterline() {
HydraulicSegment waterfall = new HydraulicSegment(
531L,
530L,
HydrologyFeatureType.WATERFALL,
80,
68,
8,
3,
true,
true,
List.of(new HydrologyPoint(0, 80, 0), new HydrologyPoint(1, 68, 0))
);
HydraulicSegment receiver = new HydraulicSegment(
532L,
530L,
HydrologyFeatureType.SURFACE_POOL,
68,
68,
8,
3,
false,
true,
List.of(new HydrologyPoint(1, 68, 0), new HydrologyPoint(20, 68, 0))
);
RiverCourse course = new RiverCourse(
530L,
RiverCourseType.SURFACE,
OptionalLong.of(1L),
OptionalLong.of(2L),
"water",
1,
List.of(),
List.of(waterfall, receiver)
);
HydrologyTerrainSampler terrain = (int x, int z) -> HydrologyTerrainSample.openLand(
x <= 0 ? 90 : 76,
0D,
"parent"
);
HydrologyFootprintCompiler compiler = compiler(terrain);
RiverFootprint footprint = compiler.compile(List.of(course));
HydrologyColumnLayer throat = footprint.sample(0, 0)
.flatMap(HydrologyColumnSample::primarySurfaceFluidLayer)
.orElseThrow();
assertTrue(throat.fallingFluid());
assertTrue(throat.fluidOwned());
assertFalse(throat.terrainOwned());
assertTrue(compiler.surfaceBanksContained(course));
}
@Test
public void oceanMouthWidensGraduallyIntoItsTerminalGrade() {
HydraulicSegment channel = new HydraulicSegment(
@@ -1976,7 +1637,6 @@ public class HydrologyFootprintCompilerTest {
HydrologyFootprintCompiler compiler = compiler(terrain);
RiverFootprint footprint = compiler.compile(List.of(course));
assertTrue(compiler.surfaceBanksContained(course));
int upstreamWidth = wetHalfWidth(footprint, 32);
int transitionWidth = wetHalfWidth(footprint, 52);
int terminalWidth = wetHalfWidth(footprint, 62);
@@ -1984,11 +1644,25 @@ public class HydrologyFootprintCompilerTest {
assertTrue(terminalWidth >= transitionWidth);
assertTrue(terminalWidth > upstreamWidth);
assertTrue(surfaceFluidLayer(footprint, 63, 0) != null);
HydrologyColumnSample firstOcean = footprint.sample(64, 0).orElseThrow();
assertEquals(48, firstOcean.naturalHeight());
assertEquals(48, firstOcean.terrainHeight());
assertFalse(firstOcean.layers().stream().anyMatch(HydrologyColumnLayer::terrainOwned));
assertFalse(firstOcean.layers().stream().anyMatch(HydrologyColumnLayer::fluidOwned));
HydrologyColumnSample apron = footprint.sample(64, 0).orElseThrow();
assertTrue(apron.ocean());
assertFalse(apron.layers().isEmpty());
int apronLimit = HydrologyPlannerSettings.defaults().outlets().maximumOceanApron();
assertTrue(footprint.sample(64 + apronLimit, 0).isEmpty());
for (HydrologyColumnSample sample : footprint.columns().values()) {
if (!sample.ocean()) {
assertTrue(sample.naturalHeight() > sample.seaLevel());
continue;
}
assertTrue(sample.x() - 64 < apronLimit);
for (HydrologyColumnLayer layer : sample.layers()) {
assertTrue(layer.oceanApron());
assertFalse(layer.terrainOwned());
assertFalse(layer.fluidOwned());
assertFalse(layer.shore());
assertFalse(layer.grading());
}
}
}
@Test
@@ -2114,6 +1788,9 @@ public class HydrologyFootprintCompilerTest {
}
}
private RiverCourse course(long id, RiverCourseType type, HydraulicSegment segment) {
return new RiverCourse(
id,
core/src/test/java/art/arcane/iris/engine/hydrology/HydrologyPlannerGlobalInvariantTest.java
+22 -2
View File
@@ -482,10 +482,10 @@ public class HydrologyPlannerGlobalInvariantTest {
assertTrue(segment.drop() > 0);
assertFalse(segment.fallingFluid());
assertTrue(segment.width() >= 1);
assertTrue(hasChannelLayer(tile, segment.start(), segment.id()));
assertTrue(hasCourseChannelLayer(tile, segment.start(), course.id()));
assertTrue(
segment + " column=" + tile.columnAt(segment.end().x(), segment.end().z()),
hasTransitionLayer(tile, segment.end(), segment.id(), false)
hasChannelHead(tile, segment.end(), course.id(), segment.downstreamHeadY())
);
assertGradedCenterline(segment, 2);
}
@@ -900,6 +900,26 @@ public class HydrologyPlannerGlobalInvariantTest {
return false;
}
private boolean hasCourseChannelLayer(HydrologyTile tile, HydrologyPoint point, long courseId) {
HydrologyColumnSample column = tile.columnAt(point.x(), point.z()).orElseThrow();
for (HydrologyColumnLayer layer : column.layers()) {
if (layer.feature().courseId() == courseId && layer.channel()) {
return true;
}
}
return false;
}
private boolean hasChannelHead(HydrologyTile tile, HydrologyPoint point, long courseId, int head) {
HydrologyColumnSample column = tile.columnAt(point.x(), point.z()).orElseThrow();
for (HydrologyColumnLayer layer : column.layers()) {
if (layer.feature().courseId() == courseId && layer.channel() && layer.fluidHeadY() == head) {
return true;
}
}
return false;
}
private boolean hasChannelLayer(HydrologyTile tile, HydrologyPoint point, long segmentId) {
HydrologyColumnSample column = tile.columnAt(point.x(), point.z()).orElseThrow();
for (HydrologyColumnLayer layer : column.layers()) {
core/src/test/java/art/arcane/iris/engine/hydrology/HydrologyPlannerTest.java
+29 -108
View File
@@ -50,8 +50,7 @@ public class HydrologyPlannerTest {
for (HydraulicSegment segment : course.segments()) {
if (segment.drop() > 0) {
assertTrue(segment.type().isDrop());
assertEquals(segment.type() == HydrologyFeatureType.WATERFALL, segment.fallingFluid());
assertTrue(segment.receivingPool() || hasDownstreamReceivingDrop(tile, segment));
assertFalse(segment.fallingFluid());
}
}
}
@@ -91,7 +90,7 @@ public class HydrologyPlannerTest {
HydrologyPoint start = centerline.getFirst();
HydrologyPoint end = centerline.getLast();
double directLength = StrictMath.hypot(end.x() - start.x(), end.z() - start.z());
assertTrue("sinuosity=" + pathLength / directLength, pathLength / directLength <= 1.3D);
assertTrue("sinuosity=" + pathLength / directLength, pathLength / directLength <= 1.5D);
assertTrue(
"deviation=" + maximumChordDeviationRatio(centerline),
maximumChordDeviationRatio(centerline) <= 0.19D
@@ -434,7 +433,6 @@ public class HydrologyPlannerTest {
for (HydraulicSegment segment : segments(rolling, HydrologyFeatureType.CASCADE)) {
assertTrue(segment.drop() > 0);
assertFalse(segment.fallingFluid());
assertTrue(segment.receivingPool() || hasDownstreamReceivingDrop(rolling, segment));
assertTrue(segment.centerline().size() >= segment.drop() + 1);
int previousHead = segment.upstreamHeadY();
for (HydrologyPoint point : segment.centerline()) {
@@ -458,8 +456,8 @@ public class HydrologyPlannerTest {
);
for (HydraulicSegment segment : segments(cliff, HydrologyFeatureType.WATERFALL)) {
assertTrue(segment.drop() > 0);
assertTrue(segment.fallingFluid());
assertEquals(2, segment.centerline().size());
assertFalse(segment.fallingFluid());
assertTrue(segment.centerline().size() >= 2);
assertTrue(segment.width() >= 1);
}
boolean sawBlendedWaterfall = false;
@@ -590,68 +588,6 @@ public class HydrologyPlannerTest {
}
}
@Test
public void aSurfaceCourseCanBoreThroughARidgeAndReopen() {
HydrologyTerrainSampler ridgeTerrain = (int x, int z) -> {
if (x >= 112) {
return oceanTerrain();
}
int base = 108 - Math.floorDiv(x, 8);
int height = x >= 48 && x <= 72 ? base + 48 : base;
return terrain(height, x >= 48 && x <= 72 ? 18D : 1D, false, true, x <= 16, true, false, false);
};
HydrologyPlannerSettings settings = standardSettings(2D, 0D, true, false, List.of());
HydrologyTile tile = new HydrologyPlanner(
992L,
settings,
ridgeTerrain
).plan(TILE);
boolean reopened = false;
for (RiverCourse course : surfaceCourses(tile)) {
int firstBore = firstSegment(
course,
HydrologyFeatureType.RIDGE_BORE,
HydrologyFeatureType.UNDERGROUND_DROP
);
if (firstBore < 0) {
continue;
}
HydraulicSegment bore = course.segments().get(firstBore);
assertTrue(bore.width() >= settings.surface().minimumWidth());
HydrologyColumnLayer grotto = layerForSegment(
tile.columnAt(bore.start().x(), bore.start().z()).orElseThrow(),
bore.id()
);
assertTrue(grotto.ceilingY() > grotto.fluidHeadY());
for (int index = firstBore + 1; index < course.segments().size(); index++) {
HydraulicSegment previous = course.segments().get(index - 1);
HydraulicSegment current = course.segments().get(index);
assertEquals(previous.centerline().getLast(), current.centerline().getFirst());
if (current.type().isSurface()) {
HydrologyColumnLayer reopenedLayer = layerForSegment(
tile.columnAt(current.start().x(), current.start().z()).orElseThrow(),
current.id()
);
assertFalse(reopenedLayer.feature().source());
reopened = true;
break;
}
}
if (reopened) {
break;
}
}
assertTrue(
"diagnostics=" + tile.diagnosticCandidates() + " courses=" + surfaceCourses(tile).stream()
.map((RiverCourse course) -> course.segments().stream()
.map(HydraulicSegment::type)
.toList())
.toList(),
reopened
);
}
@Test
public void ridgeCoursesRequireConfiguredPublishedSurfaceExposure() {
HydrologyPlannerSettings base = standardSettings(2D, 0D, true, false, List.of());
@@ -1092,20 +1028,22 @@ public class HydrologyPlannerTest {
rollingCoast(112)
).plan(TILE);
boolean sawApron = false;
assertFalse(
"courses=" + tile.courses() + " diagnostics=" + tile.diagnosticCandidates(),
tile.footprint().isEmpty()
);
for (HydrologyColumnSample column : tile.footprint().columns().values()) {
if (!column.ocean()) {
if (!column.ocean() && column.naturalHeight() > column.seaLevel()) {
continue;
}
sawApron = true;
for (HydrologyColumnLayer layer : column.layers()) {
assertFalse(layer.terrainOwned());
assertFalse(layer.fluidOwned());
assertFalse(layer.grading());
assertFalse(layer.shore());
assertTrue(layer.fluidHeadY() <= column.seaLevel());
}
}
assertTrue(sawApron);
}
@Test
@@ -1130,7 +1068,7 @@ public class HydrologyPlannerTest {
if (layer.grading() && !layer.shore() && !layer.channel()) {
sawGrading = true;
assertEquals("parent", column.parentBiomeKey());
assertTrue(layer.biomeKey() == null);
assertEquals(layer.bankBiomeKey(), layer.biomeKey());
}
}
}
@@ -1165,7 +1103,7 @@ public class HydrologyPlannerTest {
} else if (layer.grading() && !layer.channel()) {
maximumGradingDistance = Math.max(maximumGradingDistance, distance - channelRadius);
sawChangedParentGrading |= layer.bedY() != column.naturalHeight();
assertTrue(layer.biomeKey() == null);
assertEquals(layer.bankBiomeKey(), layer.biomeKey());
assertEquals("parent", column.parentBiomeKey());
}
}
@@ -1291,26 +1229,29 @@ public class HydrologyPlannerTest {
}
assertTrue(bed);
assertEquals(drop.fallingFluid(), falling);
if (drop.type() == HydrologyFeatureType.WATERFALL) {
assertTrue(drop.fallingFluid());
}
assertFalse(drop.fallingFluid());
if (!receiving) {
HydrologyColumnSample endColumn = tile.columnAt(drop.end().x(), drop.end().z()).orElseThrow();
receiving = endColumn.layers().stream().anyMatch((HydrologyColumnLayer layer) ->
layer.channel() && layer.fluidHeadY() == drop.downstreamHeadY());
}
assertTrue("drop=" + drop, receiving);
if (!drop.fallingFluid()) {
int previousHead = drop.upstreamHeadY();
for (HydrologyPoint point : drop.centerline()) {
assertTrue(point.y() <= previousHead);
assertTrue(
drop.type() + " drop=" + drop.drop() + " points=" + drop.centerline().size()
+ " step=" + (previousHead - point.y()),
previousHead - point.y() <= settings.geometry().drops().stepLimit(drop.type())
);
previousHead = point.y();
}
if (drop.type() == HydrologyFeatureType.WATERFALL) {
assertTrue(
"waterfall drop=" + drop.drop(),
drop.drop() >= settings.surface().banks().waterfallMinimumDrop()
);
continue;
}
int previousHead = drop.upstreamHeadY();
for (HydrologyPoint point : drop.centerline()) {
assertTrue(point.y() <= previousHead);
assertTrue(
drop.type() + " drop=" + drop.drop() + " points=" + drop.centerline().size()
+ " step=" + (previousHead - point.y()),
previousHead - point.y() <= settings.geometry().drops().stepLimit(drop.type())
);
previousHead = point.y();
}
}
}
@@ -1528,10 +1469,6 @@ public class HydrologyPlannerTest {
assertFalse(outlet.directOcean());
assertTrue(course.surfaceSinkholeContinuation());
assertTrue(course.segments().stream().noneMatch(HydraulicSegment::fallingFluid));
assertTrue(tile.diagnosticCandidates().stream().anyMatch(
(HydrologyDiagnosticCandidate candidate) ->
candidate.rejection() == HydrologyCandidateRejection.SURFACE_RIDGE_TUNNEL_LIMIT
));
}
@Test
@@ -2529,22 +2466,6 @@ public class HydrologyPlannerTest {
return column != null && layerForSegmentOrNull(column, segment.id()) != null;
}
private boolean hasDownstreamReceivingDrop(HydrologyTile tile, HydraulicSegment expected) {
for (RiverCourse course : tile.courses()) {
if (course.id() != expected.courseId()) {
continue;
}
boolean downstream = false;
for (HydraulicSegment segment : course.segments()) {
if (downstream && segment.drop() > 0 && segment.receivingPool()) {
return true;
}
downstream |= segment.id() == expected.id();
}
}
return false;
}
private HydraulicSegment segment(HydrologyTile tile, long segmentId) {
for (RiverCourse course : tile.courses()) {
for (HydraulicSegment segment : course.segments()) {
core/src/test/java/art/arcane/iris/engine/hydrology/HydrologyStyledGeometryTest.java
+22 -102
View File
@@ -58,12 +58,22 @@ public class HydrologyStyledGeometryTest {
assertEquals(first, repeated);
assertEquals(undergroundFirst, undergroundRepeated);
assertEquals(Set.of(HydrologyGeometrySampler.Field.values()), sampledFields);
assertEquals(
Set.of(
HydrologyGeometrySampler.Field.SURFACE_WIDTH,
HydrologyGeometrySampler.Field.SURFACE_DEPTH,
HydrologyGeometrySampler.Field.UNDERGROUND_FLUID_LEVEL,
HydrologyGeometrySampler.Field.UNDERGROUND_WIDTH,
HydrologyGeometrySampler.Field.UNDERGROUND_DEPTH,
HydrologyGeometrySampler.Field.UNDERGROUND_HEADROOM,
HydrologyGeometrySampler.Field.DEEP_FLUID_HEIGHT
),
sampledFields
);
RiverCourse surface = courses(first, RiverCourseType.SURFACE).getFirst();
DrainageNode surfaceSource = first.node(surface.sourceNodeId().orElseThrow()).orElseThrow();
HydraulicSegment surfaceStart = surface.segments().getFirst();
int surfaceDischarge = Math.max(1, surface.drainageEdges().getFirst().contributingSurfaceSources());
int maximumSurfaceWidth = surfaceSettings.surface().maximumWidth()
+ (surfaceStart.receivingPool() ? 2 : 0);
int maximumSurfaceDepth = surfaceSettings.surface().maximumDepth()
@@ -73,24 +83,18 @@ public class HydrologyStyledGeometryTest {
assertTrue(surfaceStart.depth() >= surfaceSettings.surface().minimumDepth());
assertTrue(surfaceStart.depth() <= maximumSurfaceDepth);
assertTrue(
"head=" + surfaceStart.upstreamHeadY() + " natural="
+ terrain(surfaceSource.naturalPoint().x(), surfaceSource.naturalPoint().z()).naturalHeight(),
surfaceStart.upstreamHeadY() <=
terrain(surfaceSource.naturalPoint().x(), surfaceSource.naturalPoint().z()).naturalHeight()
- surfaceSettings.surface().maximumSurfaceInset()
terrain(surfaceSource.naturalPoint().x(), surfaceSource.naturalPoint().z()).naturalHeight()
- surfaceSettings.surface().banks().inset()
);
int styledSurfaceWidth = scaledDimension(
styledValue(request(
HydrologyGeometrySampler.Field.SURFACE_WIDTH,
surface.profileKey(),
surfaceSource.naturalPoint(),
surfaceSettings.surface().minimumWidth(),
surfaceSettings.surface().maximumWidth()
)),
surfaceSettings.surface().maximumWidth(),
surfaceDischarge
);
assertTrue(surfaceStart.width() >= styledSurfaceWidth
|| surfaceStart.fallingFluid()
|| surfaceStart.receivingPool());
int widestSurfaceWidth = 0;
for (HydraulicSegment segment : surface.segments()) {
widestSurfaceWidth = Math.max(widestSurfaceWidth, segment.width());
}
assertTrue(widestSurfaceWidth >= surfaceStart.width());
assertTrue(widestSurfaceWidth <= surfaceSettings.surface().maximumWidth() * 2);
RiverCourse underground = courses(undergroundFirst, RiverCourseType.UNDERGROUND).getFirst();
DrainageNode undergroundSource = undergroundFirst.node(underground.sourceNodeId().orElseThrow()).orElseThrow();
@@ -132,36 +136,6 @@ public class HydrologyStyledGeometryTest {
}
}
@Test
public void poolStylingCannotManufactureUnsupportedTransitions() {
HydrologyPlannerSettings settings = settings(1D, 0D, List.of());
HydrologyTerrainSampler terrain = this::terrain;
HydrologyGeometrySampler shortPools = request -> request.field()
== HydrologyGeometrySampler.Field.TARGET_POOL_LENGTH
? request.minimum()
: styledValue(request);
HydrologyGeometrySampler longPools = request -> request.field()
== HydrologyGeometrySampler.Field.TARGET_POOL_LENGTH
? request.maximum()
: styledValue(request);
HydrologyTile shortFirst = planner(8811L, settings, terrain, shortPools).plan(TILE);
HydrologyTile shortRepeated = planner(8811L, settings, terrain, shortPools).plan(TILE);
HydrologyTile longFirst = planner(8811L, settings, terrain, longPools).plan(TILE);
HydrologyTile longRepeated = planner(8811L, settings, terrain, longPools).plan(TILE);
assertEquals(shortFirst, shortRepeated);
assertEquals(longFirst, longRepeated);
List<Integer> shortHeads = heads(courses(shortFirst, RiverCourseType.SURFACE).getFirst());
List<Integer> longHeads = heads(courses(longFirst, RiverCourseType.SURFACE).getFirst());
assertEquals(shortHeads.getFirst(), longHeads.getFirst());
assertEquals(shortHeads.getLast(), longHeads.getLast());
assertNonIncreasing(shortHeads);
assertNonIncreasing(longHeads);
assertSurfaceDropsTerrainBacked(shortFirst, terrain);
assertSurfaceDropsTerrainBacked(longFirst, terrain);
}
private HydrologyPlanner planner(
long seed,
HydrologyPlannerSettings settings,
@@ -346,11 +320,6 @@ public class HydrologyStyledGeometryTest {
return new HydrologyGeometrySampler.Request(field, profileKey, point.x(), point.z(), 0L, minimum, maximum);
}
private int scaledDimension(int styledBase, int maximum, int discharge) {
double flowScale = Math.min(1D, StrictMath.log(discharge + 1D) / StrictMath.log(9D));
return Math.min(maximum, styledBase + (int) StrictMath.round((maximum - styledBase) * flowScale));
}
private List<RiverCourse> courses(HydrologyTile tile, RiverCourseType type) {
ArrayList<RiverCourse> selected = new ArrayList<>();
for (RiverCourse course : tile.courses()) {
@@ -361,53 +330,4 @@ public class HydrologyStyledGeometryTest {
return List.copyOf(selected);
}
private List<Integer> heads(RiverCourse course) {
ArrayList<Integer> heads = new ArrayList<>();
for (HydraulicSegment segment : course.segments()) {
if (segment.type() == HydrologyFeatureType.MOUTH) {
continue;
}
heads.add(segment.upstreamHeadY());
heads.add(segment.downstreamHeadY());
}
return List.copyOf(heads);
}
private void assertNonIncreasing(List<Integer> heads) {
for (int index = 1; index < heads.size(); index++) {
assertTrue(heads.get(index) <= heads.get(index - 1));
}
}
private void assertSurfaceDropsTerrainBacked(HydrologyTile tile, HydrologyTerrainSampler terrain) {
for (RiverCourse course : courses(tile, RiverCourseType.SURFACE)) {
RiverOutlet outlet = tile.outlet(course.outletId().orElseThrow()).orElseThrow();
for (int segmentIndex = 0; segmentIndex < course.segments().size(); segmentIndex++) {
HydraulicSegment segment = course.segments().get(segmentIndex);
if (!segment.type().isDrop() || !segment.type().isSurface()) {
continue;
}
HydrologyPoint start = segment.start();
HydrologyPoint end = segment.end();
int downstreamNaturalHeight = outlet.directOcean() && terminalMouthDrop(course, segmentIndex)
? terrain.sample(outlet.connectionPoint().x(), outlet.connectionPoint().z()).naturalHeight()
: terrain.sample(end.x(), end.z()).naturalHeight();
int naturalDrop = terrain.sample(start.x(), start.z()).naturalHeight() - downstreamNaturalHeight;
assertTrue(
"type=" + segment.type() + " start=" + start + " end=" + end
+ " naturalDrop=" + naturalDrop + " solvedDrop=" + segment.drop(),
naturalDrop >= segment.drop()
);
}
}
}
private boolean terminalMouthDrop(RiverCourse course, int segmentIndex) {
for (int index = segmentIndex + 1; index < course.segments().size(); index++) {
if (course.segments().get(index).type() != HydrologyFeatureType.MOUTH) {
return false;
}
}
return true;
}
}
core/src/test/java/art/arcane/iris/engine/hydrology/HydrologyTileCacheTest.java
+6 -1
View File
@@ -284,7 +284,7 @@ public class HydrologyTileCacheTest {
63,
new HydrologyPlannerSettings.Routing(64, 16, 4, 128, 96,
new HydrologyPlannerSettings.Branching(16, 8), 0.5D, 12D, 0.5D, 0.1D),
new HydrologyPlannerSettings.Surface(true, surfaceSources, 4, 8, 2, 3, 4, 8, 20, 1.5D, 2, 4, true, 96, 8, HydrologyPlannerSettings.Banks.defaults()),
new HydrologyPlannerSettings.Surface(true, surfaceSources, 4, 8, 2, 3, 4, 8, 20, 1.5D, 2, 4, true, 96, 8, tileBoundedBanks()),
new HydrologyPlannerSettings.Hydraulics(8, 16, 1, 2, 8, 3),
new HydrologyPlannerSettings.Underground(false, disabled, -32, 32, 2, 4, 1, 2, 3, 4, false),
new HydrologyPlannerSettings.Outlets(
@@ -302,6 +302,11 @@ public class HydrologyTileCacheTest {
);
}
// Small-tile settings need a blend envelope that fits inside the bounded cross-tile admission period.
private static HydrologyPlannerSettings.Banks tileBoundedBanks() {
return new HydrologyPlannerSettings.Banks(1, 1, 3D, 4, 4, 0.25D, 16, 2, 6, 1.6D, true);
}
private HydrologyTerrainSample featureTerrain(int x, int z) {
if (x >= 80) {
return HydrologyTerrainSample.ocean(54, "ocean_parent");
core/src/test/java/art/arcane/iris/engine/hydrology/surface/ErosionFieldCompilerTest.java
+30
View File
@@ -262,4 +262,34 @@ public class ErosionFieldCompilerTest {
assertTrue(low.height() >= center.headY() + 1);
assertEquals(0, compiled.field().uncontainedWetCells());
}
@Test
public void oceanApronStartsAtTheFirstOceanStationAndStopsAtTheLimit() {
HydrologyTerrainSampler sampler = (int x, int z) -> x >= 200
? HydrologyTerrainSample.ocean(SEA_LEVEL - 4, "sea")
: HydrologyTerrainSample.openLand(SEA_LEVEL + 3, 0D, "land");
HydrologyPlannerSettings.Surface surface = zeroRoughnessSurface();
List<HydrologyPoint> path = List.of(new HydrologyPoint(0, 0, 0), new HydrologyPoint(259, 0, 0));
SurfaceCenterline centerline = SurfaceCenterline.densify(path);
ChannelProfile channel = new ChannelProfileBuilder(surface, sampler, CONSTANT_GEOMETRY)
.build(centerline, "water", true);
ValleyProfile valley = new ValleyProfileSolver(surface, sampler, SEA_LEVEL, 64)
.solve(centerline, channel, SurfaceTerminal.OCEAN_MOUTH, SEA_LEVEL);
assertNull(valley.rejection());
ErosionField field = new ErosionFieldCompiler(surface, sampler, SEA_LEVEL)
.compile(99L, centerline, channel, valley, SurfaceTerminal.OCEAN_MOUTH, 3);
int firstApron = Integer.MAX_VALUE;
int lastApron = Integer.MIN_VALUE;
for (SurfaceColumn column : field.columns().values()) {
if (column.apron()) {
firstApron = Math.min(firstApron, column.x());
lastApron = Math.max(lastApron, column.x());
assertEquals(column.terrain().naturalHeight(), column.height());
}
}
assertEquals(200, firstApron);
assertEquals(202, lastApron);
}
}
core/src/test/java/art/arcane/iris/engine/mantle/components/MantleHydrologyComponentTest.java
+16 -9
View File
@@ -293,7 +293,7 @@ public class MantleHydrologyComponentTest {
);
}
}
assertEquals(1, transitionCount);
assertTrue(transitionCount >= 1);
}
@Test
@@ -320,6 +320,10 @@ public class MantleHydrologyComponentTest {
assertTrue(layer.connectedFluid());
assertTrue(layer.fluidOwned());
assertFalse(layer.oceanApron());
assertTrue(
"column " + column.x() + "," + column.z() + " publishes no surface fluid",
layer.publishesSurfaceFluid()
);
assertEquals(layer.fluidHeadY(), layer.ceilingY());
assertTrue(layer.bedY() < layer.fluidHeadY());
if (layer.fallingFluid()) {
@@ -518,9 +522,14 @@ public class MantleHydrologyComponentTest {
HydraulicSegment mouth = course.segments().getLast();
assertEquals(HydrologyFeatureType.MOUTH, mouth.type());
List<HydrologyPoint> mouthCenterline = rasterizedSegmentCenterline(mouth);
int apronColumns = 0;
HashSet<Long> apronChunks = new HashSet<>();
HashSet<Long> coastChunks = new HashSet<>();
for (HydrologyColumnSample column : tile.footprint().columns().values()) {
if (column.ocean() || hasCardinalOceanNeighbor(
terrain,
new HydrologyPoint(column.x(), column.naturalHeight(), column.z())
)) {
coastChunks.add(pack(Math.floorDiv(column.x(), 16), Math.floorDiv(column.z(), 16)));
}
if (!column.ocean()) {
continue;
}
@@ -528,7 +537,6 @@ public class MantleHydrologyComponentTest {
if (layer.feature().courseId() != course.id()) {
continue;
}
apronColumns++;
assertTrue(layer.oceanApron());
assertEquals(HydrologyFeatureType.MOUTH, layer.feature().type());
assertFalse(layer.terrainOwned());
@@ -537,11 +545,10 @@ public class MantleHydrologyComponentTest {
assertFalse(layer.shore());
assertTrue(minimumDistance(column.x(), column.z(), mouthCenterline)
<= settings.outlets().maximumOceanApron() + 0.25D);
apronChunks.add(pack(Math.floorDiv(column.x(), 16), Math.floorDiv(column.z(), 16)));
}
}
assertTrue(apronColumns > 0);
for (long packedChunk : apronChunks) {
assertFalse(coastChunks.isEmpty());
for (long packedChunk : coastChunks) {
int chunkX = (int) (packedChunk >> 32);
int chunkZ = (int) packedChunk;
MantleHydrologyComponent.Publication publication = MantleHydrologyComponent.compilePublication(
@@ -616,7 +623,7 @@ public class MantleHydrologyComponentTest {
"deep_lava"
);
List<PublicationParityCase> cases = List.of(
terrainParityCase(surface),
surfacePublicationParityCase(surface, HydrologyCaveAction.WET_SOURCE),
surfacePublicationParityCase(drop, HydrologyCaveAction.FALLING_FLUID),
caveParityCase(underground),
caveParityCase(grotto),
@@ -675,7 +682,7 @@ public class MantleHydrologyComponentTest {
for (int y = 24; y <= 30; y++) {
HydrologyCaveCell cell = publication.caveCells().get(new CavePosition(8, y, 8));
assertEquals(HydrologyCaveAction.DRY_AIR, cell.action());
assertEquals("dry", cell.floodedBiomeKey());
assertEquals("flooded", cell.floodedBiomeKey());
}
assertEquals(HydrologyCaveAction.SEAL_GUARD, publication.caveCells()
.get(new CavePosition(8, 20, 8)).action());