docs: curve v2 — TCRV spikeMax semantics, TerrainCurve v2 default, v1 retired (terrain-water task 06)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Core/README.md

@@ -17,7 +17,9 @@ dispatches on the file's first byte:
 - **v2 (primary)** — raw `ISLA` magic, u32 version gate, then tagged sections
   `[u32 tag][u64 length][payload]`. Unknown tags are skipped by length, so future sections are
   invisible to older readers. Validated on read: version, MapSize bounds, section lengths against
-  the file, biome/tier ordinal ranges.
+  the file, biome/tier ordinal ranges. Since the water-bodies stage, v2 files also carry the
+  optional `WBID`/`WBTB`/`WSRF` water sections (per-pixel body ids, the body table, quantized
+  surface levels) — parsed into `WorldBlueprint` and consumed by nothing at runtime yet.
 - **v1 (legacy)** — the positional `"ISLA_V1"` format, still written beside v2 as `_v1.dat` and
   still loadable (with a deprecation warning) until a future removal task.
 

Core/Scripts/BLUEPRINT_FORMAT.md

@@ -55,7 +55,11 @@ Every section: `[u32 tag][u64 payload-length in bytes][payload]`.
 | `HGTS` / `0x53544748` | `MapSize²` × `f32` height, **X outer / Y inner** | Mandatory. The second index is the map's north/south axis; the server consumes it as world **Z**. (This axis convention was never written down for v1 — it is now normative.) Length must equal `4·MapSize²`. |
 | `BIOM` / `0x4D4F4942` | `MapSize²` × `u8` biome ordinal, same pixel order | Mandatory. Ordinals from `Enums.cs::Biome` — **append-only, never reorder** (the ordinal IS the wire value). Writer refuses ordinals > 255; reader rejects ordinals ≥ the known biome count (parse-time validation; the palette's runtime Dirt fallback for in-memory values is unchanged). Length must equal `MapSize²`. |
 | `TOWN` / `0x4E574F54` | `i32 count`, then per town: `f32 X` · `f32 Y` · `u8 tier` · `u8 isHighwayNode` (0/1) | Tier ordinals from `Enums.cs::TownTier`, append-only, range-checked on read. The highway-node flag is what the generator's road topology was built from (v1 dropped it); carried and exposed on the parsed blueprint, consumed by nothing server-side yet. |
-| `RDHW` / `0x57484452` | `i32 pathCount`, then per path: `i32 pointCount` + `pointCount` × (`f32 X` · `f32 Y`) | Highway tier. **Tags, not file position, identify the tier** — the v1 order-fragility is gone. |
+| `TCRV` / `0x56524354` | 50 B: `u16 curveVersion` · input knots `f32 t1..t4` · `f32 spikeMax` · output bands `f32 sea` · `f32 orangeCeil` · `f32 redCeil` · `f32 plateauLo` · `f32 plateauHi` · `f32 peakCap` · `f32 tailSlope` | Optional — present iff the height-redistribution curve shaped this blueprint's `HGTS` (config `TerrainCurve: "v2"`); absent = raw legacy profile. **`spikeMax` semantics by version:** v1 = the pooled calibration max (identical every seed); **v2 = the SEED'S own effective raw pre-curve maximum** — the per-seed spike normalizer, which is why blueprints are no longer reproducible from curve constants alone and the value is recorded here. **Metadata only:** exported heights are already curved; nothing re-applies the map. The curve lives in `Tools/Scripts/HeightCurve.cs` (calibration provenance in its header + the task-05/06 reports). |
+| `WBID` / `0x44494257` | `MapSize²` × `u16` water-body id, same pixel order as `HGTS` | Optional (absent = no water data, e.g. a legacy re-encode). `0` = no water, `1` = **the** ocean body, `2..N` = lakes. Ids assigned in deterministic scan order (X outer / Y inner, first-encountered pixel), lakes labeled with the **same 4-connectivity as `CalculateTrueOcean`**. Membership is exactly the generator's water classification — the biome grid's Ocean/Lake pixels and this grid's nonzero pixels are the same set **by construction** (shared predicates). Length must equal `2·MapSize²`. |
+| `WBTB` / `0x42544257` | `i32 count`, then per body (20 B): `u16 id` · `u8 type` (0 ocean, 1 lake) · `u8 salinity` (0 fresh, 1 salt) · `f32 surfaceLevel` · `i32 pixelCount` · `f32 centroidX` · `f32 centroidY` | Optional, paired with `WBID`. **`surfaceLevel` is a documented TRANSITIONAL rule:** one flat level per body — `GetSeaLevel` at the body's pixel centroid (ocean: at the map centre) under the still-live latitude field; superseded by the flat-scalar sea model (minted, lands with the coast change set). The field's per-pixel slope is deliberately NOT baked into any section. **Salinity is a provisional default** (ocean salt, lake fresh) — a placeholder for the future fresh/salt irrigation mechanic, not a mechanic. |
+| `WSRF` / `0x46525357` | `MapSize²` × `u16` quantized water-surface elevation, same pixel order | Optional, paired with `WBID`. `0` is the reserved **no-water sentinel**; a real level `L` (raw height units) encodes as `1 + round(L × 32768)` so it can never encode to 0; decode `(q − 1)/32768` (`BlueprintFormat.EncodeWaterLevel`/`DecodeWaterLevel`). Covers `[0 … ~1.99997]` raw at `1/32768` raw ≈ **7.7 mm** of world height (1 raw = 251 m) — far finer than the 1 m voxel. Nonzero exactly where `WBID` is nonzero; the value is the pixel's body level. |
+| `RDHW` / `0x57484452` | `i32 pathCount`, then per path: `i32 pointCount` + `pointCount` × (`f32 X` · `f32 Y`) | Highway tier. **Tags, not file position, identify the tier** — the v1 order-fragility is gone. Road sections may legitimately be **present but empty** (zero paths): the `SkipRoads` config toggle exports a road-less iteration blueprint. |
 | `RDBR` / `0x52424452` | same layout | Branch tier. |
 | `RDRG` / `0x47524452` | same layout | Rugged tier. |
 | `RDTL` / `0x4C544452` | same layout | Trail tier. |
@@ -85,9 +89,38 @@ the file, not the original generation.
 
 ### Size
 
-`total = 8 (header) + Σ per section (12 + payload)`. The pixel grid dominates: `5·MapSize²` bytes
+`total = 8 (header) + Σ per section (12 + payload)`. The pixel grids dominate: without water
-(4 height + 1 biome) ≈ **320 MiB at 8K**, vs v1's `8·MapSize²` ≈ 512 MiB — the u8 biome section
+sections `5·MapSize²` bytes (4 height + 1 biome) ≈ **320 MiB at 8K**, vs v1's `8·MapSize²` ≈
-saves ~192 MiB at 8K.
+512 MiB — the u8 biome section saves ~192 MiB. With the water sections the per-pixel cost is
+`9·MapSize²` (adds 2 B `WBID` + 2 B `WSRF`) ≈ **576 MiB at 8K** plus a trivial `WBTB` (20 B per
+body).
+
+### Config knobs that shape blueprint content (not part of the byte format)
+
+- **`SeaLevelModel`** (`"flat"` | `"field"`) + **`SeaLevelValue`** (float; used when flat) —
+  D-033: selects what `MapGenerator.GetSeaLevel` returns. `"flat"` (the default, value 0.15) is
+  one scalar sea level everywhere; `"field"` is the legacy latitude Lerp (0.26 north → 0.15
+  south). Generator-only — all nine `GetSeaLevel` call sites inherit the model; nothing at
+  runtime computes sea level. The model in force shapes the coastline, masks, biomes, water
+  bodies, and `WBTB` levels of the blueprint being generated; the file itself does not record
+  which model produced it (the `WBTB` levels are the observable).
+- **`SkipRoads`** (bool, default false) — exports with present-but-empty road sections (see the
+  road-section table note).
+- **`TerrainCurve`** (`"v2"` | `"off"`, default `"v2"`; `"v1"` retired by the task-06
+  recalibration and rejected loudly) — whether the height-redistribution curve (storm ladder:
+  75 % orange coverage, 50 m plateau, **per-seed-normalized 420 m peaks**) shapes `HGTS`.
+  Biome/water classification is curve-invariant by construction (it classifies the retained
+  uncurved heights); town positions and everything 3D follow the curved terrain. When on,
+  `TCRV` records the effective parameters including the per-seed `spikeMax`.
+
+### Deliberately NOT a section: basins (`BSIN`)
+
+The priority-flood pit-fill that runs in the water-bodies stage is **diagnostics only** and
+serializes nothing. Rationale, on the record so nobody adds a basin section later without meeting
+the argument: basin geometry is a pure function of the heightmap, and it goes stale the moment the
+coast-smoothing change set (or any terrain change) touches heights — a serialized `BSIN` would be
+a cache with a silent invalidation hazard. The rivers stage recomputes basins fresh at generation
+time (measured ~12 s at 8K — cheap enough to never cache).
 
 ### Adding a new section (the intended extension path)
 

Core/Scripts/BlueprintFormat.cs

@@ -29,6 +29,27 @@ namespace IslaApocalypse.Core
 		public const uint TAG_ROADS_BRANCH  = 0x52424452; // "RDBR"
 		public const uint TAG_ROADS_RUGGED  = 0x47524452; // "RDRG"
 		public const uint TAG_ROADS_TRAIL   = 0x4C544452; // "RDTL"
+		public const uint TAG_WATER_BODY_IDS   = 0x44494257; // "WBID"
+		public const uint TAG_WATER_BODY_TABLE = 0x42544257; // "WBTB"
+		public const uint TAG_WATER_SURFACE    = 0x46525357; // "WSRF"
+		public const uint TAG_TERRAIN_CURVE    = 0x56524354; // "TCRV"
+
+		// WSRF quantization: u16, 0 reserved as the no-water sentinel. A real level L
+		// (raw blueprint height units) encodes as 1 + round(L × 32768), so a genuine
+		// level can never encode to 0. Decodes back via (q − 1) / 32768. Covers
+		// [0 .. ~1.99997] raw at 1/32768 raw resolution ≈ 7.7 mm of world height
+		// (1 raw unit = 251 m) — far below the 1 m voxel.
+		public const float WSRF_SCALE = 1f / 32768f;
+
+		public static ushort EncodeWaterLevel(float level)
+		{
+			return (ushort)Godot.Mathf.Clamp(1 + Godot.Mathf.RoundToInt(level * 32768f), 1, ushort.MaxValue);
+		}
+
+		public static float DecodeWaterLevel(ushort quantized)
+		{
+			return (quantized - 1) * WSRF_SCALE;
+		}
 
 		// MapSize sanity bounds, checked before any allocation on read.
 		public const int MIN_MAP_SIZE = 256;

Core/Scripts/BlueprintWriter.cs

@@ -31,8 +31,20 @@ namespace IslaApocalypse.Core
 				writer.Write(BlueprintFormat.VERSION);
 
 				WriteSection(writer, BlueprintFormat.TAG_PARAMS, w => WriteParams(w, bp));
+				if (bp.TerrainCurve != null)
+					WriteSection(writer, BlueprintFormat.TAG_TERRAIN_CURVE, w => WriteTerrainCurve(w, bp.TerrainCurve));
 				WriteSection(writer, BlueprintFormat.TAG_HEIGHTS, w => WriteHeights(w, bp));
 				WriteSection(writer, BlueprintFormat.TAG_BIOMES, w => WriteBiomes(w, bp));
+
+				// Water sections are written only when the blueprint carries water data
+				// (a legacy v1 re-encode has none — the sections are simply absent).
+				if (bp.WaterBodyIds != null)
+				{
+					WriteSection(writer, BlueprintFormat.TAG_WATER_BODY_IDS, w => WriteWaterBodyIds(w, bp));
+					WriteSection(writer, BlueprintFormat.TAG_WATER_BODY_TABLE, w => WriteWaterBodyTable(w, bp));
+					WriteSection(writer, BlueprintFormat.TAG_WATER_SURFACE, w => WriteWaterSurface(w, bp));
+				}
+
 				WriteSection(writer, BlueprintFormat.TAG_TOWNS, w => WriteTowns(w, bp));
 				WriteSection(writer, BlueprintFormat.TAG_ROADS_HIGHWAY, w => WriteRoadTier(w, bp.Highways));
 				WriteSection(writer, BlueprintFormat.TAG_ROADS_BRANCH, w => WriteRoadTier(w, bp.BranchRoads));
@@ -112,6 +124,71 @@ namespace IslaApocalypse.Core
 			}
 		}
 
+		private static void WriteTerrainCurve(BinaryWriter writer, TerrainCurveInfo c)
+		{
+			writer.Write(c.Version);
+			writer.Write(c.T1); writer.Write(c.T2); writer.Write(c.T3); writer.Write(c.T4);
+			writer.Write(c.SpikeMax);
+			writer.Write(c.Sea); writer.Write(c.OrangeCeil); writer.Write(c.RedCeil);
+			writer.Write(c.PlateauLo); writer.Write(c.PlateauHi); writer.Write(c.PeakCap);
+			writer.Write(c.TailSlope);
+		}
+
+		private static void WriteWaterBodyIds(BinaryWriter writer, WorldBlueprint bp)
+		{
+			int n = bp.MapSize;
+			for (int x = 0; x < n; x++)
+				for (int y = 0; y < n; y++)
+					writer.Write(bp.WaterBodyIds[x, y]);
+		}
+
+		private static void WriteWaterBodyTable(BinaryWriter writer, WorldBlueprint bp)
+		{
+			writer.Write(bp.WaterBodies.Count);
+			foreach (WaterBodyInfo body in bp.WaterBodies)
+			{
+				writer.Write(body.Id);
+				writer.Write(body.Type);
+				writer.Write(body.Salinity);
+				writer.Write(body.SurfaceLevel);
+				writer.Write(body.PixelCount);
+				writer.Write(body.Centroid.X);
+				writer.Write(body.Centroid.Y);
+			}
+		}
+
+		private static void WriteWaterSurface(BinaryWriter writer, WorldBlueprint bp)
+		{
+			int n = bp.MapSize;
+
+			// A parsed blueprint carries the quantized surface verbatim; a freshly
+			// generated one derives it from body ids + per-body levels.
+			if (bp.WaterSurfaceQ != null)
+			{
+				for (int x = 0; x < n; x++)
+					for (int y = 0; y < n; y++)
+						writer.Write(bp.WaterSurfaceQ[x, y]);
+				return;
+			}
+
+			// id -> encoded level lookup (ids are small and dense: 1..N)
+			int maxId = 0;
+			foreach (WaterBodyInfo body in bp.WaterBodies)
+				if (body.Id > maxId) maxId = body.Id;
+			ushort[] encoded = new ushort[maxId + 1];
+			foreach (WaterBodyInfo body in bp.WaterBodies)
+				encoded[body.Id] = BlueprintFormat.EncodeWaterLevel(body.SurfaceLevel);
+
+			for (int x = 0; x < n; x++)
+			{
+				for (int y = 0; y < n; y++)
+				{
+					ushort id = bp.WaterBodyIds[x, y];
+					writer.Write(id == 0 ? (ushort)0 : encoded[id]);
+				}
+			}
+		}
+
 		private static void WriteTowns(BinaryWriter writer, WorldBlueprint bp)
 		{
 			writer.Write(bp.Towns.Count);

Core/Scripts/ConfigManager.cs

@@ -14,6 +14,25 @@ namespace IslaApocalypse.Core // Change this if your namespace is different
 		public static float DensityMultiplier = 1.0f; // <-- Replaces TownCount
 		public static int ChunkRadius = 24; // Default chunk size, can be overridden by config
 
+		// Iteration toggle: skip the ~25-min A* road pass entirely. The blueprint is
+		// still exported (road sections present but empty) — an iteration artifact,
+		// not a shippable world. Default false.
+		public static bool SkipRoads = false;
+
+		// Sea-level model (D-033, terrain-water task 04): "flat" = one scalar sea
+		// level everywhere (SeaLevelValue); "field" = the legacy latitude Lerp
+		// (0.26 north .. 0.15 south). Generator-only — the runtime never computes
+		// sea level. Default: flat 0.15.
+		public static string SeaLevelModel = "flat";
+		public static float SeaLevelValue = 0.15f;
+
+		// Height-redistribution curve (tasks 05/06, graduation M-7): "v2" applies the
+		// calibrated storm-ladder curve with the per-seed peak spike (HeightCurve.cs);
+		// "off" is the raw legacy profile. "v1" was dropped with the v2 recalibration
+		// (task-05 blueprints are regenerable). Biome classification is curve-invariant
+		// by construction either way. Default: v2.
+		public static string TerrainCurve = "v2";
+
 		public static void LoadConfig()
 		{
 			string path = "res://ServerConfig.json";
@@ -63,6 +82,38 @@ namespace IslaApocalypse.Core // Change this if your namespace is different
 				ChunkRadius = (int)data["ChunkRadius"];
 			}
 
+			// Extract the SkipRoads iteration toggle
+			if (data.ContainsKey("SkipRoads"))
+			{
+				SkipRoads = (bool)data["SkipRoads"];
+			}
+
+			// Extract the sea-level model
+			if (data.ContainsKey("SeaLevelModel"))
+			{
+				string model = (string)data["SeaLevelModel"];
+				if (model == "flat" || model == "field")
+					SeaLevelModel = model;
+				else
+					GD.PrintErr($"[ConfigManager] Unknown SeaLevelModel '{model}'. Keeping '{SeaLevelModel}'.");
+			}
+			if (data.ContainsKey("SeaLevelValue"))
+			{
+				SeaLevelValue = (float)data["SeaLevelValue"];
+			}
+
+			// Extract the terrain-curve gate
+			if (data.ContainsKey("TerrainCurve"))
+			{
+				string curve = (string)data["TerrainCurve"];
+				if (curve == "off" || curve == "v2")
+					TerrainCurve = curve;
+				else if (curve == "v1")
+					GD.PrintErr($"[ConfigManager] TerrainCurve 'v1' was retired by the v2 recalibration (task 06). Keeping '{TerrainCurve}' — use \"v2\" or \"off\".");
+				else
+					GD.PrintErr($"[ConfigManager] Unknown TerrainCurve '{curve}'. Keeping '{TerrainCurve}'.");
+			}
+
 			switch (profile)
 			{
 				case "4K":

Core/Scripts/MapDataParser.cs

@@ -36,6 +36,46 @@ namespace IslaApocalypse.Core
 		public string GeneratorGitHash = ""; // short hash of the generator repo, "" if unknown
 	}
 
+	/// <summary>
+	/// One water body from the blueprint's WBTB section: the ocean (exactly one, id 1)
+	/// or a lake (ids 2..N). SurfaceLevel is the documented TRANSITIONAL rule — one flat
+	/// level per body, GetSeaLevel at the body's pixel centroid under the still-live
+	/// latitude field; superseded when the flat-scalar sea model lands. Salinity is a
+	/// provisional placeholder for the future fresh/salt mechanic (ocean salt, lake fresh).
+	/// </summary>
+	public class WaterBodyInfo
+	{
+		public const byte TYPE_OCEAN = 0;
+		public const byte TYPE_LAKE = 1;
+		public const byte SALINITY_FRESH = 0;
+		public const byte SALINITY_SALT = 1;
+
+		public ushort Id;
+		public byte Type;
+		public byte Salinity;
+		public float SurfaceLevel;   // raw blueprint height units
+		public int PixelCount;
+		public Vector2 Centroid;     // map pixels
+	}
+
+	/// <summary>
+	/// The height-redistribution curve that shaped this blueprint's heights (v2 TCRV
+	/// section, terrain-water task 05). Null when the blueprint was generated with the
+	/// curve off (or predates it) — heights are then the raw legacy profile. Pure
+	/// metadata: the server never re-applies the curve; exported heights are already
+	/// curved.
+	/// </summary>
+	public class TerrainCurveInfo
+	{
+		public ushort Version;
+		// Input knots. SpikeMax is the spike domain's top: under curve v1 it was the
+		// pooled calibration max (identical every seed); from v2 it is the SEED'S own
+		// effective raw maximum — blueprints are no longer reproducible from curve
+		// constants alone, which is exactly why it is recorded here.
+		public float T1, T2, T3, T4, SpikeMax;
+		public float Sea, OrangeCeil, RedCeil, PlateauLo, PlateauHi, PeakCap, TailSlope; // output bands
+	}
+
 	public class WorldBlueprint
 	{
 		public int MapSize;
@@ -53,6 +93,16 @@ namespace IslaApocalypse.Core
 		// generation parameters. Params is null when the source was a legacy v1 file.
 		public int FormatVersion = 1;
 		public BlueprintParams Params;
+
+		// Water-bodies data (v2 WBID/WBTB/WSRF sections, terrain-water task 03).
+		// Null / empty when the source carries no water sections (legacy v1, or a v2
+		// written before the water stage existed). Consumed by nothing at runtime yet.
+		public ushort[,] WaterBodyIds;                        // 0 = no water, 1 = ocean, 2..N = lakes
+		public List<WaterBodyInfo> WaterBodies = new List<WaterBodyInfo>();
+		public ushort[,] WaterSurfaceQ;                       // quantized levels — BlueprintFormat.DecodeWaterLevel
+
+		// The curve that shaped HeightMap (v2 TCRV section); null = raw legacy profile.
+		public TerrainCurveInfo TerrainCurve;
 	}
 
 	// 2. The Parser Utility
@@ -172,6 +222,10 @@ namespace IslaApocalypse.Core
 				else if (tag == BlueprintFormat.TAG_ROADS_BRANCH) sectionOk = ParseRoadTier(reader, blueprint.BranchRoads);
 				else if (tag == BlueprintFormat.TAG_ROADS_RUGGED) sectionOk = ParseRoadTier(reader, blueprint.RuggedRoads);
 				else if (tag == BlueprintFormat.TAG_ROADS_TRAIL) sectionOk = ParseRoadTier(reader, blueprint.TrailRoads);
+				else if (tag == BlueprintFormat.TAG_WATER_BODY_IDS) sectionOk = ParseWaterGrid(reader, blueprint, payloadLength, isSurface: false);
+				else if (tag == BlueprintFormat.TAG_WATER_SURFACE) sectionOk = ParseWaterGrid(reader, blueprint, payloadLength, isSurface: true);
+				else if (tag == BlueprintFormat.TAG_WATER_BODY_TABLE) sectionOk = ParseWaterBodyTable(reader, blueprint);
+				else if (tag == BlueprintFormat.TAG_TERRAIN_CURVE) sectionOk = ParseTerrainCurve(reader, blueprint);
 				else
 				{
 					// The property the redesign exists to buy: future sections (water,
@@ -294,6 +348,61 @@ namespace IslaApocalypse.Core
 			return true;
 		}
 
+		private static bool ParseWaterGrid(BinaryReader reader, WorldBlueprint blueprint, ulong payloadLength, bool isSurface)
+		{
+			int n = blueprint.MapSize;
+			string name = isSurface ? "WSRF" : "WBID";
+			if (payloadLength != 2UL * (ulong)n * (ulong)n)
+			{
+				GD.PrintErr($"[MapDataParser] ERROR: {name} section is {payloadLength} bytes, expected {2UL * (ulong)n * (ulong)n}.");
+				return false;
+			}
+			ushort[,] grid = new ushort[n, n];
+			for (int x = 0; x < n; x++)
+				for (int y = 0; y < n; y++)
+					grid[x, y] = reader.ReadUInt16();
+			if (isSurface) blueprint.WaterSurfaceQ = grid;
+			else blueprint.WaterBodyIds = grid;
+			return true;
+		}
+
+		private static bool ParseWaterBodyTable(BinaryReader reader, WorldBlueprint blueprint)
+		{
+			int count = reader.ReadInt32();
+			for (int i = 0; i < count; i++)
+			{
+				var body = new WaterBodyInfo();
+				body.Id = reader.ReadUInt16();
+				body.Type = reader.ReadByte();
+				body.Salinity = reader.ReadByte();
+				body.SurfaceLevel = reader.ReadSingle();
+				body.PixelCount = reader.ReadInt32();
+				body.Centroid = new Vector2(reader.ReadSingle(), reader.ReadSingle());
+				if (body.Type > WaterBodyInfo.TYPE_LAKE)
+				{
+					GD.PrintErr($"[MapDataParser] ERROR: water body {i} has unknown type {body.Type}.");
+					return false;
+				}
+				blueprint.WaterBodies.Add(body);
+			}
+			return true;
+		}
+
+		private static bool ParseTerrainCurve(BinaryReader reader, WorldBlueprint blueprint)
+		{
+			var c = new TerrainCurveInfo();
+			c.Version = reader.ReadUInt16();
+			c.T1 = reader.ReadSingle(); c.T2 = reader.ReadSingle();
+			c.T3 = reader.ReadSingle(); c.T4 = reader.ReadSingle();
+			c.SpikeMax = reader.ReadSingle();
+			c.Sea = reader.ReadSingle(); c.OrangeCeil = reader.ReadSingle();
+			c.RedCeil = reader.ReadSingle(); c.PlateauLo = reader.ReadSingle();
+			c.PlateauHi = reader.ReadSingle(); c.PeakCap = reader.ReadSingle();
+			c.TailSlope = reader.ReadSingle();
+			blueprint.TerrainCurve = c;
+			return true;
+		}
+
 		private static bool ParseRoadTier(BinaryReader reader, List<Vector2[]> into)
 		{
 			int pathCount = reader.ReadInt32();

Core/Scripts/README.md

@@ -39,10 +39,11 @@ rendering.
 - **`BlueprintWriter.cs`** — writes a `WorldBlueprint` as a v2 file. Blueprint-typed on purpose:
   the map generator and the round-trip harness are both just callers.
 - **`MapDataParser.cs`** — decodes a `.dat` blueprint into a `WorldBlueprint` (heightmap, biome map,
-  towns, four road tiers, and — v2 only — the embedded generation params and per-town highway-node
+  towns, four road tiers, and — v2 only — the embedded generation params, per-town highway-node
-  flag). Dispatches on the first byte: v2 tagged-section files get validation (version gate, size
+  flag, and the optional water-bodies data: `WaterBodyIds`, `WaterBodies` table, `WaterSurfaceQ`).
+  Dispatches on the first byte: v2 tagged-section files get validation (version gate, size
   bounds, section-length and ordinal range checks); legacy v1 files still load, intact, with a
-  deprecation warning.
+  deprecation warning. Nothing at runtime consumes the water data yet.
 - **`ChunkData.cs`** — one chunk's density and block-ID fields, `+1` padded on every axis so the
   mesher can reach into the neighbouring chunk, plus the per-column data the renderer needs.
 - **`Constants.cs`** — chunk dimensions, `ISO_LEVEL`, `VOXEL_SCALE`, and the visual/road tunables

ServerConfig.json

@@ -2,5 +2,7 @@
   "WorldSeed": 1409879727,
   "MapProfile": "8K",
   "TownDensity": "Normal",
-  "ChunkRadius": 32
+  "ChunkRadius": 32,
+  "SeaLevelModel": "flat",
+  "SeaLevelValue": 0.15
 }

Tools/README.md

@@ -17,6 +17,10 @@ Builds the topographical and logistical foundation of the island before any 3D e
 - **Topography:** FastNoiseLite plus distance-falloff maths for a guaranteed mainland island, a
   mountain spine, dynamic temperature-driven sea level, and an impact crater pushed into the northern
   coast (carved at 80 % of its radius so a landbridge always survives).
+- **Water bodies:** the classified water promoted into explicit blueprint data (ocean + labeled
+  lakes with transitional per-body levels — `WBID`/`WBTB`/`WSRF` sections), plus priority-flood
+  basin diagnostics. The `SkipRoads` config toggle turns a full ~26-min generation into a ~80 s
+  road-less iteration cycle.
 - **Logistics:** `AStarGrid2D` pathfinding producing a looping continental highway, a branch to the
   mountain hub, and county roads daisy-chained outward with Prim's algorithm. Paths are decimated
   (Ramer–Douglas–Peucker) then smoothed (4 Chaikin passes).

Tools/Scripts/HeightCurve.cs

@@ -0,0 +1,135 @@
+using Godot;
+
+/// <summary>
+/// The height-redistribution curve, v2 (terrain-water task 06) — a pure, static,
+/// monotonic piecewise map over raw blueprint heights (D-035: numbers in, numbers
+/// out; the per-seed spike maximum is an explicit PARAMETER, not hidden state).
+///
+/// v2 changes (developer's task-05 hillshade-gate verdict; everything below the
+/// plateau step is behaviorally byte-identical to v1):
+///   - PER-SEED SPIKE NORMALIZATION: the spike's input domain runs from t4 to the
+///     current seed's own raw pre-curve maximum (hMaxSeed), so every island's
+///     tallest pixel reaches the ceiling — v1 mapped against the pooled
+///     calibration max and mid-range seeds topped out at 110–175 m.
+///   - STIFFER SPIKE: ease-in 0.1u + 0.9·u⁴ (was 0.2u + 0.8·u³) — a wall, not a ramp.
+///   - PEAK CEILING 420 m above sea (was 220 m).
+///
+/// Lower knots/bands are v1's, calibrated 2026-08-07 from batch 04's ten flat-sea
+/// heightmaps (pooled above-sea land CDF, 340,618,126 samples): P75/P90/P93/P96.
+///
+/// Shape (strictly monotonic; every segment's normalized slope bounded below by a
+/// positive constant; asserted numerically per generation against the EFFECTIVE
+/// per-seed curve once hMaxSeed is known):
+///   h ≤ sea (0.15)      identity — water and the below-sea world untouched
+///   sea → t1            smooth toe, ease-out blend (gentle rolling, never flat)
+///   t1 → t2             linear rise into the red band
+///   t2 → t3             smooth shoulder up to the plateau shelf
+///   t3 → t4             near-flat plateau step (small positive slope)
+///   t4 → spikeMax       accelerating u⁴ spike to the 420 m peak cap (per-seed domain)
+///   h > spikeMax        linear tail (strict monotonicity, no clamp; reachable only
+///                       in the degenerate near-flat guard case)
+/// </summary>
+public static class HeightCurve
+{
+	public const ushort VERSION = 2;
+
+	// Input knots — v1 calibration, unchanged (see class header).
+	public const float T1 = 0.628736f;       // P75 — orange coverage boundary
+	public const float T2 = 0.819152f;       // P90
+	public const float T3 = 0.879340f;       // P93
+	public const float T4 = 0.962922f;       // P96
+
+	// Output bands — the storm ladder. Lower anchors unchanged from v1.
+	public const float SEA = 0.15f;
+	public const float ORANGE_CEIL = 0.206f;             // 1000-yr storm ceiling
+	public const float RED_CEIL = 0.27f;                 // biblical ceiling
+	public const float PLATEAU_LO = SEA + 50f / 251f;    // ≈ 0.34924 (50 m above sea)
+	public const float PLATEAU_HI = PLATEAU_LO + 0.02f;  // ≈ 0.36924 (~5 m step relief)
+	public const float PEAK_CAP = SEA + 420f / 251f;     // ≈ 1.82869 (420 m above sea; v1: 220 m)
+	public const float TAIL_SLOPE = 0.25f;               // above spikeMax (degenerate guard only)
+
+	// Degenerate/near-flat guard: the spike domain is [T4, max(hMaxSeed, T4 + SPIKE_MIN_SPAN)],
+	// so a pathological seed whose raw max sits at or below t4 still yields a positive,
+	// monotonic domain (its cap is then simply never reached; heights above spikeMax — none in
+	// practice — would ride the tail).
+	public const float SPIKE_MIN_SPAN = 0.01f;
+
+	/// <summary>The effective spike-domain top for a seed's raw maximum, guard applied.</summary>
+	public static float EffectiveSpikeMax(float hMaxSeed)
+	{
+		return Mathf.Max(hMaxSeed, T4 + SPIKE_MIN_SPAN);
+	}
+
+	/// <param name="h">Raw pre-curve height.</param>
+	/// <param name="hMaxSeed">The seed's raw pre-curve maximum (post noise/falloff/Trench/spine,
+	/// pre-carve) — the same field the curve consumes. Makes the map seed-dependent (v2).</param>
+	public static float Apply(float h, float hMaxSeed)
+	{
+		if (h <= SEA) return h;
+
+		float u, s;
+		if (h < T1)
+		{
+			u = (h - SEA) / (T1 - SEA);
+			s = 0.3f * u + 0.7f * (u * (2f - u));            // ease-out, slope ≥ 0.3
+			return SEA + s * (ORANGE_CEIL - SEA);
+		}
+		if (h < T2)
+		{
+			u = (h - T1) / (T2 - T1);
+			return ORANGE_CEIL + u * (RED_CEIL - ORANGE_CEIL); // linear
+		}
+		if (h < T3)
+		{
+			u = (h - T2) / (T3 - T2);
+			s = 0.2f * u + 0.8f * (u * u * (3f - 2f * u));   // smoothstep blend, slope ≥ 0.2
+			return RED_CEIL + s * (PLATEAU_LO - RED_CEIL);
+		}
+		if (h < T4)
+		{
+			u = (h - T3) / (T4 - T3);
+			return PLATEAU_LO + u * (PLATEAU_HI - PLATEAU_LO); // near-flat, small positive slope
+		}
+		float spikeMax = EffectiveSpikeMax(hMaxSeed);
+		if (h < spikeMax)
+		{
+			u = (h - T4) / (spikeMax - T4);
+			s = 0.1f * u + 0.9f * (u * u * u * u);           // ease-in u⁴ wall, slope ≥ 0.1
+			return PLATEAU_HI + s * (PEAK_CAP - PLATEAU_HI);
+		}
+		return PEAK_CAP + (h - spikeMax) * TAIL_SLOPE;
+	}
+
+	/// <summary>
+	/// Numeric strict-monotonicity check of the EFFECTIVE per-seed curve — call once
+	/// per generation after hMaxSeed is known, before the curve pass. A violation is
+	/// a build bug, not a data condition — fail loudly and refuse to generate.
+	/// </summary>
+	public static void AssertMonotonic(float hMaxSeed)
+	{
+		float prevH = -7f;
+		float prev = Apply(prevH, hMaxSeed);
+
+		// Successive double samples can round to the SAME float32 — only strictly
+		// increasing float samples are compared (task-05 incident fix, kept).
+		void Check(double hd)
+		{
+			float h = (float)hd;
+			if (h <= prevH) return;
+			float v = Apply(h, hMaxSeed);
+			if (v <= prev)
+				throw new System.InvalidOperationException(
+					$"[HeightCurve] MONOTONICITY VIOLATION at h={h} (hMaxSeed={hMaxSeed}): {v} <= {prev}. Refusing to generate.");
+			prev = v;
+			prevH = h;
+		}
+
+		// Coarse below the identity region, fine through every knot, out past the
+		// per-seed spike top and the tail.
+		double top = System.Math.Max(2.0, EffectiveSpikeMax(hMaxSeed) + 0.5);
+		for (double h = -7.0 + 0.01; h < 0.10; h += 0.01) Check(h);
+		for (double h = 0.10; h <= top; h += 0.0001) Check(h);
+		for (double h = top + 0.05; h <= top + 6.0; h += 0.05) Check(h);
+		GD.Print($"[HeightCurve] Monotonicity assertion passed (v{VERSION}, effective spikeMax {EffectiveSpikeMax(hMaxSeed):F6}).");
+	}
+}

Tools/Scripts/HeightCurve.cs.uid

@@ -0,0 +1 @@
+uid://ljv7x1fwm3os

Tools/Scripts/MapGenerator.cs

@@ -26,12 +26,34 @@ public partial class MapGenerator : TextureRect
 	private float _impactRadius;
 
 	private float[,] _heightMap;
+
+	// Classification heightmap (task 05): the UNCURVED heights (plus the crater
+	// carve), i.e. exactly what the curve-off pipeline produces. Biome rules, the
+	// two flood fills, and the shared water predicates read THIS map, so biome and
+	// water output is identical with the curve on or off — the bit-identical-biomes
+	// oracle holds by construction. Towns, roads, diagnostics, and the exported
+	// heights use the curved _heightMap (they live in the 3D world). When the curve
+	// is off this is the SAME array as _heightMap (aliased, no copy).
+	private float[,] _heightMapClassify;
+	private bool _curveOn;
+
+	// The seed's raw pre-curve height maximum (post noise/falloff/Trench/spine,
+	// pre-carve) — the v2 curve's per-seed spike normalizer. Computed in
+	// GenerateTopography pass 1; recorded in TCRV (effective, guard applied).
+	private float _hMaxSeed = float.MinValue;
+
 	private float[,] _tempMap;
 	private Biome[,] _biomeMap;
 	private bool[,] _isTrueOcean;
 	private bool[,] _isMainland;
 	internal List<TownData> _towns = new List<TownData>();
 
+	// Water-bodies stage outputs (terrain-water task 03): 0 = no water, 1 = the
+	// ocean, 2..N = lakes. Filled by IdentifyWaterBodies, serialized by the v2
+	// writer, consumed by nothing at runtime yet.
+	internal ushort[,] _waterBodyIds;
+	internal List<WaterBodyInfo> _waterBodies;
+
 	internal List<Vector2[]> _highwayPaths = new List<Vector2[]>();
 	internal List<Vector2[]> _branchPaths = new List<Vector2[]>();
 	internal List<Vector2[]> _ruggedPaths = new List<Vector2[]>();
@@ -53,6 +75,10 @@ public partial class MapGenerator : TextureRect
 		this.CustomMinimumSize = new Vector2(MapSize, MapSize);
 
 		_heightMap = new float[MapSize, MapSize];
+		_curveOn = ConfigManager.TerrainCurve == "v2";
+		// (The monotonicity assertion now runs inside GenerateTopography, against the
+		// effective per-seed curve, once hMaxSeed is known.)
+		_heightMapClassify = _curveOn ? new float[MapSize, MapSize] : _heightMap;
 		_tempMap = new float[MapSize, MapSize];
 		_biomeMap = new Biome[MapSize, MapSize];
 		_isTrueOcean = new bool[MapSize, MapSize];
@@ -78,12 +104,19 @@ public partial class MapGenerator : TextureRect
 		// A future water stage slots in as another CaptureStage call at its own boundary.
 
 		GenerateTopography();
-		GD.Print($"{T()} Topography done (height + temperature).");
+		GD.Print($"{T()} Topography done (height + temperature). TerrainCurve: {(_curveOn ? "v1" : "off")}.");
+
+		DrawHeightStageTexture();
+		await CaptureStage("0_height");
 
 		CalculateTrueOcean();
 		CalculateMainland();
 		GD.Print($"{T()} Ocean and mainland masks done.");
 
+		IdentifyWaterBodies();
+		DrawWaterStageTexture();
+		await CaptureStage("0_water");
+
 		AssignBiomesAndDraw();
 		GD.Print($"{T()} Biomes done.");
 		await CaptureStage("1_biomes");
@@ -92,12 +125,27 @@ public partial class MapGenerator : TextureRect
 		GD.Print($"{T()} Towns placed: {_towns.Count}.");
 		await CaptureStage("2_towns");
 
+		if (ConfigManager.SkipRoads)
+		{
+			// Iteration toggle (terrain-water task 03): the road pass is ~25 min of a
+			// ~26-min generation. Skipping it leaves all four road lists empty, so the
+			// export writes present-but-empty road sections.
+			GD.Print("==========================================================");
+			GD.Print($"{T()} ⚠⚠ SKIPROADS IS ON — ROAD GENERATION SKIPPED ENTIRELY.");
+			GD.Print($"{T()} ⚠⚠ This blueprint has NO ROADS. It is an ITERATION");
+			GD.Print($"{T()} ⚠⚠ ARTIFACT, not a world. Do not judge or ship it.");
+			GD.Print("==========================================================");
+		}
+		else
+		{
 			// NEW: We await the roads so the engine doesn't freeze!
 			await GenerateRoadsAsync();
+		}
 
 		ExportMapData();
 		GD.Print($"{T()} Blueprint exported.");
 
+		if (!ConfigManager.SkipRoads)
 			await CaptureStage("3_roads");
 		GD.Print($"{T()} GENERATION COMPLETE.");
 	}
@@ -206,6 +254,17 @@ public partial class MapGenerator : TextureRect
 			BranchRoads = _branchPaths,
 			RuggedRoads = _ruggedPaths,
 			TrailRoads = _trailPaths,
+			WaterBodyIds = _waterBodyIds,
+			WaterBodies = _waterBodies ?? new List<WaterBodyInfo>(),
+			TerrainCurve = _curveOn ? new TerrainCurveInfo
+			{
+				Version = HeightCurve.VERSION,
+				T1 = HeightCurve.T1, T2 = HeightCurve.T2, T3 = HeightCurve.T3, T4 = HeightCurve.T4,
+				SpikeMax = HeightCurve.EffectiveSpikeMax(_hMaxSeed), // per-seed (v2)
+				Sea = HeightCurve.SEA, OrangeCeil = HeightCurve.ORANGE_CEIL, RedCeil = HeightCurve.RED_CEIL,
+				PlateauLo = HeightCurve.PLATEAU_LO, PlateauHi = HeightCurve.PLATEAU_HI,
+				PeakCap = HeightCurve.PEAK_CAP, TailSlope = HeightCurve.TAIL_SLOPE
+			} : null,
 			FormatVersion = 2,
 			Params = new BlueprintParams
 			{
@@ -348,23 +407,51 @@ public partial class MapGenerator : TextureRect
 				}
 
 				// --- 4. COMBINE HEIGHT ---
+				// PASS 1 stores the RAW pre-curve height and tracks the seed maximum;
+				// the curve (which is per-seed in v2 — its spike normalizes against
+				// hMaxSeed) and the crater carve are applied in PASS 2 below.
 				float rawBase = (_noise.GetNoise2D(x, y) + 1.0f) / 2.0f;
 				float finalH = rawBase + mountainSpine - (finalFalloff * FalloffStrength);
+				if (finalH > _hMaxSeed) _hMaxSeed = finalH;
+				_heightMap[x, y] = finalH;
+			}
+		}
 
+		// The v2 curve is SEED-DEPENDENT: its spike maps [t4, hMaxSeed] onto the peak
+		// band, so the monotonicity assertion must run against the EFFECTIVE per-seed
+		// curve — after hMaxSeed is known, before any pixel is curved.
+		if (_curveOn) HeightCurve.AssertMonotonic(_hMaxSeed);
+
+		// --- PASS 2: curve (task 05/06) + crater carve ---
+		// Curve applied AFTER noise + falloff + Trench, BEFORE the crater carve, so
+		// the carve cuts into curved terrain and the rim/bowl shape is untouched by
+		// the curve. Identity at and below sea + this ordering preserve the
+		// Trench/ocean-border guarantee and the crater by construction. classifyH
+		// stays uncurved — see _heightMapClassify; hMaxSeed never touches it.
+		float physicalCraterRadius = _impactRadius * 0.80f;
+		for (int x = 0; x < MapSize; x++)
+		{
+			for (int y = 0; y < MapSize; y++)
+			{
+				float raw = _heightMap[x, y];
+				float classifyH = raw;
+				float curvedH = _curveOn ? HeightCurve.Apply(raw, _hMaxSeed) : raw;
 
 				// --- 5. CARVE THE CRATER (The Flooded Bay & Landbridge Fix!) ---
 				float distToCrater = new Vector2(x, y).DistanceTo(_impactCenter);
 
 				// We only carve the physical hole at 80% of the radius to guarantee a landbridge!
-				float physicalCraterRadius = _impactRadius * 0.80f; 
 				if (distToCrater < physicalCraterRadius)
 				{
 					float craterDepth = 1.0f - (distToCrater / physicalCraterRadius);
 					// Dialed back to -0.15f as per your excellent instinct!
-					finalH = Mathf.Lerp(finalH, GetSeaLevel(temperature) - 0.15f, craterDepth * 0.9f); 
+					float carveTarget = GetSeaLevel(_tempMap[x, y]) - 0.15f;
+					classifyH = Mathf.Lerp(classifyH, carveTarget, craterDepth * 0.9f);
+					curvedH = Mathf.Lerp(curvedH, carveTarget, craterDepth * 0.9f);
 				}
 
-				_heightMap[x, y] = finalH;
+				_heightMapClassify[x, y] = classifyH;
+				_heightMap[x, y] = curvedH;
 			}
 		}
 	}
@@ -385,7 +472,7 @@ public partial class MapGenerator : TextureRect
 				Vector2I neighbor = current + dir;
 				if (neighbor.X >= 0 && neighbor.X < MapSize && neighbor.Y >= 0 && neighbor.Y < MapSize)
 				{
-					if (!_isTrueOcean[neighbor.X, neighbor.Y] && _heightMap[neighbor.X, neighbor.Y] < GetSeaLevel(_tempMap[neighbor.X, neighbor.Y]))
+					if (!_isTrueOcean[neighbor.X, neighbor.Y] && _heightMapClassify[neighbor.X, neighbor.Y] < GetSeaLevel(_tempMap[neighbor.X, neighbor.Y]))
 					{
 						_isTrueOcean[neighbor.X, neighbor.Y] = true;
 						queue.Enqueue(neighbor);
@@ -400,7 +487,7 @@ public partial class MapGenerator : TextureRect
 		Queue<Vector2I> queue = new Queue<Vector2I>();
 		Vector2I center = new Vector2I(MapSize / 2, MapSize / 2); 
 
-		if (_heightMap[center.X, center.Y] >= GetSeaLevel(_tempMap[center.X, center.Y]))
+		if (_heightMapClassify[center.X, center.Y] >= GetSeaLevel(_tempMap[center.X, center.Y]))
 		{
 			queue.Enqueue(center);
 			_isMainland[center.X, center.Y] = true;
@@ -416,7 +503,7 @@ public partial class MapGenerator : TextureRect
 				Vector2I neighbor = current + dir;
 				if (neighbor.X >= 0 && neighbor.X < MapSize && neighbor.Y >= 0 && neighbor.Y < MapSize)
 				{
-					if (!_isMainland[neighbor.X, neighbor.Y] && _heightMap[neighbor.X, neighbor.Y] >= GetSeaLevel(_tempMap[neighbor.X, neighbor.Y]))
+					if (!_isMainland[neighbor.X, neighbor.Y] && _heightMapClassify[neighbor.X, neighbor.Y] >= GetSeaLevel(_tempMap[neighbor.X, neighbor.Y]))
 					{
 						_isMainland[neighbor.X, neighbor.Y] = true;
 						queue.Enqueue(neighbor);
@@ -426,6 +513,358 @@ public partial class MapGenerator : TextureRect
 		}
 	}
 
+	// =====================================================================
+	// SHARED WATER PREDICATES (terrain-water task 03)
+	// The single source of per-pixel water truth. AssignBiomesAndDraw and
+	// IdentifyWaterBodies both call these; correspondence between the biome
+	// grid and the water-body grid holds BY CONSTRUCTION, not by parallel
+	// implementations agreeing.
+	// =====================================================================
+	private bool IsWaterPixel(int x, int y) => _heightMapClassify[x, y] < GetSeaLevel(_tempMap[x, y]);
+	private bool IsOceanPixel(int x, int y) => IsWaterPixel(x, y) && _isTrueOcean[x, y];
+	private bool IsLakePixel(int x, int y) => IsWaterPixel(x, y) && !_isTrueOcean[x, y];
+
+	/// <summary>
+	/// The water-bodies stage (terrain-water task 03). Promotes the world's EXISTING
+	/// water into explicit data: body 1 = the ocean (all IsOceanPixel pixels), bodies
+	/// 2..N = lakes, connected-component labeled with the SAME 4-connectivity as
+	/// CalculateTrueOcean's flood fill (Up/Down/Left/Right), in deterministic scan
+	/// order (X outer, Y inner; a body's id is fixed by its first-encountered pixel).
+	/// Membership comes only from the shared predicates — this stage groups pixels,
+	/// it never adds or removes any.
+	///
+	/// Each body carries ONE surface level: GetSeaLevel at the body's pixel centroid
+	/// (ocean: at the map centre). This is the documented TRANSITIONAL rule — see
+	/// BLUEPRINT_FORMAT.md (WBTB) — superseded when the flat-scalar sea model lands.
+	/// </summary>
+	private void IdentifyWaterBodies()
+	{
+		ulong t0 = Time.GetTicksMsec();
+		_waterBodyIds = new ushort[MapSize, MapSize];
+		_waterBodies = new List<WaterBodyInfo>();
+
+		// --- Body 1: the ocean, one body, first-class ---
+		long oceanCount = 0;
+		double oceanCx = 0, oceanCy = 0;
+		for (int x = 0; x < MapSize; x++)
+		{
+			for (int y = 0; y < MapSize; y++)
+			{
+				if (IsOceanPixel(x, y))
+				{
+					_waterBodyIds[x, y] = 1;
+					oceanCount++;
+					oceanCx += x; oceanCy += y;
+				}
+			}
+		}
+		Vector2 oceanCentroid = oceanCount > 0
+			? new Vector2((float)(oceanCx / oceanCount), (float)(oceanCy / oceanCount))
+			: Vector2.Zero;
+		_waterBodies.Add(new WaterBodyInfo
+		{
+			Id = 1,
+			Type = WaterBodyInfo.TYPE_OCEAN,
+			Salinity = WaterBodyInfo.SALINITY_SALT, // provisional default
+			SurfaceLevel = GetSeaLevel(_tempMap[MapSize / 2, MapSize / 2]), // ocean: map centre
+			PixelCount = (int)oceanCount,
+			Centroid = oceanCentroid
+		});
+
+		// --- Bodies 2..N: lakes, 4-connected like CalculateTrueOcean ---
+		Vector2I[] directions = { Vector2I.Up, Vector2I.Down, Vector2I.Left, Vector2I.Right };
+		Queue<Vector2I> queue = new Queue<Vector2I>();
+		int nextId = 2;
+		long lakePixels = 0;
+
+		for (int x = 0; x < MapSize; x++)
+		{
+			for (int y = 0; y < MapSize; y++)
+			{
+				if (_waterBodyIds[x, y] != 0 || !IsLakePixel(x, y)) continue;
+
+				if (nextId > ushort.MaxValue)
+				{
+					GD.PrintErr($"[WaterBodies] ⚠⚠ More than {ushort.MaxValue - 1} water bodies — u16 id space exhausted. Remaining lakes left unlabeled.");
+					x = MapSize; break;
+				}
+
+				ushort id = (ushort)nextId++;
+				long count = 0;
+				double cx = 0, cy = 0;
+
+				_waterBodyIds[x, y] = id;
+				queue.Enqueue(new Vector2I(x, y));
+				while (queue.Count > 0)
+				{
+					Vector2I current = queue.Dequeue();
+					count++; cx += current.X; cy += current.Y;
+					foreach (var dir in directions)
+					{
+						Vector2I nb = current + dir;
+						if (nb.X < 0 || nb.X >= MapSize || nb.Y < 0 || nb.Y >= MapSize) continue;
+						if (_waterBodyIds[nb.X, nb.Y] != 0 || !IsLakePixel(nb.X, nb.Y)) continue;
+						_waterBodyIds[nb.X, nb.Y] = id;
+						queue.Enqueue(nb);
+					}
+				}
+
+				lakePixels += count;
+				int centX = Mathf.Clamp((int)Mathf.Round((float)(cx / count)), 0, MapSize - 1);
+				int centY = Mathf.Clamp((int)Mathf.Round((float)(cy / count)), 0, MapSize - 1);
+				_waterBodies.Add(new WaterBodyInfo
+				{
+					Id = id,
+					Type = WaterBodyInfo.TYPE_LAKE,
+					Salinity = WaterBodyInfo.SALINITY_FRESH, // provisional default
+					SurfaceLevel = GetSeaLevel(_tempMap[centX, centY]),
+					PixelCount = (int)count,
+					Centroid = new Vector2((float)(cx / count), (float)(cy / count))
+				});
+			}
+		}
+
+		double seconds = (Time.GetTicksMsec() - t0) / 1000.0;
+		GD.Print($"{T()} [WaterBodies] {_waterBodies.Count} bodies in {seconds:F1}s: ocean {oceanCount} px, {_waterBodies.Count - 1} lakes totalling {lakePixels} px.");
+
+		RunPriorityFloodDiagnostics();
+	}
+
+	/// <summary>
+	/// Priority-flood pit-filling over the post-topography heightmap — VALIDATED
+	/// DIAGNOSTICS ONLY. Serializes nothing (deliberately no BSIN section: basin data
+	/// goes stale the moment coast smoothing changes terrain; the rivers stage
+	/// recomputes fresh — see BLUEPRINT_FORMAT.md). Reports closed-basin statistics
+	/// and asserts two invariants: (a) filled ≥ original everywhere; (b) on the filled
+	/// surface every pixel has a non-ascending 8-neighbour path to the map border
+	/// (checked in full via a reverse BFS, not a sample).
+	/// </summary>
+	private void RunPriorityFloodDiagnostics()
+	{
+		ulong t0 = Time.GetTicksMsec();
+		int n = MapSize;
+		int total = n * n;
+
+		// 1-D row-major copies (idx = x * n + y) for speed.
+		float[] original = new float[total];
+		for (int x = 0; x < n; x++)
+			for (int y = 0; y < n; y++)
+				original[x * n + y] = _heightMap[x, y];
+		float[] filled = (float[])original.Clone();
+
+		// --- Priority-flood (Barnes et al. variant: heap + plain pit queue) ---
+		bool[] visited = new bool[total];
+		var heap = new PriorityQueue<int, float>();
+		var pit = new Queue<int>();
+
+		void Seed(int idx) { if (!visited[idx]) { visited[idx] = true; heap.Enqueue(idx, filled[idx]); } }
+		for (int x = 0; x < n; x++) { Seed(x * n); Seed(x * n + (n - 1)); }
+		for (int y = 0; y < n; y++) { Seed(y); Seed((n - 1) * n + y); }
+
+		while (heap.Count > 0 || pit.Count > 0)
+		{
+			int c = pit.Count > 0 ? pit.Dequeue() : heap.Dequeue();
+			float fc = filled[c];
+			int cx = c / n, cy = c % n;
+			for (int dx = -1; dx <= 1; dx++)
+			{
+				for (int dy = -1; dy <= 1; dy++)
+				{
+					if (dx == 0 && dy == 0) continue;
+					int nx = cx + dx, ny = cy + dy;
+					if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
+					int ni = nx * n + ny;
+					if (visited[ni]) continue;
+					visited[ni] = true;
+					if (filled[ni] <= fc) { filled[ni] = fc; pit.Enqueue(ni); }
+					else heap.Enqueue(ni, filled[ni]);
+				}
+			}
+		}
+		double floodSeconds = (Time.GetTicksMsec() - t0) / 1000.0;
+
+		// --- Invariant (a): filled ≥ original everywhere ---
+		long invariantAViolations = 0;
+		for (int i = 0; i < total; i++)
+			if (filled[i] < original[i]) invariantAViolations++;
+
+		// --- Invariant (b): full reverse BFS from the border over non-descending
+		// edges; a pixel is reachable iff it has a non-ascending 8-neighbour path
+		// down to the border on the filled surface. ---
+		bool[] reachable = new bool[total];
+		var bfs = new Queue<int>();
+		void SeedB(int idx) { if (!reachable[idx]) { reachable[idx] = true; bfs.Enqueue(idx); } }
+		for (int x = 0; x < n; x++) { SeedB(x * n); SeedB(x * n + (n - 1)); }
+		for (int y = 0; y < n; y++) { SeedB(y); SeedB((n - 1) * n + y); }
+		while (bfs.Count > 0)
+		{
+			int c = bfs.Dequeue();
+			float fc = filled[c];
+			int cx = c / n, cy = c % n;
+			for (int dx = -1; dx <= 1; dx++)
+			{
+				for (int dy = -1; dy <= 1; dy++)
+				{
+					if (dx == 0 && dy == 0) continue;
+					int nx = cx + dx, ny = cy + dy;
+					if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
+					int ni = nx * n + ny;
+					if (reachable[ni] || filled[ni] < fc) continue;
+					reachable[ni] = true;
+					bfs.Enqueue(ni);
+				}
+			}
+		}
+		long invariantBViolations = 0;
+		for (int i = 0; i < total; i++)
+			if (!reachable[i]) invariantBViolations++;
+
+		if (invariantAViolations > 0)
+			GD.PrintErr($"[PriorityFlood] ⚠⚠ INVARIANT (a) VIOLATED: {invariantAViolations} pixels have filled < original.");
+		if (invariantBViolations > 0)
+			GD.PrintErr($"[PriorityFlood] ⚠⚠ INVARIANT (b) VIOLATED: {invariantBViolations} pixels lack a non-ascending path to the border.");
+
+		// --- Closed-basin statistics on LAND (shared predicate), 8-connected ---
+		long landPixels = 0, basinLandPixels = 0;
+		var basinAreas = new List<long>();
+		var basinDepths = new List<float>();
+		bool[] counted = new bool[total];
+		var comp = new Queue<int>();
+		for (int x = 0; x < n; x++)
+		{
+			for (int y = 0; y < n; y++)
+			{
+				int i = x * n + y;
+				bool land = !IsWaterPixel(x, y);
+				if (land) landPixels++;
+				if (!land || counted[i] || filled[i] <= original[i]) continue;
+
+				long area = 0; float maxDepth = 0f;
+				counted[i] = true;
+				comp.Enqueue(i);
+				while (comp.Count > 0)
+				{
+					int c = comp.Dequeue();
+					area++;
+					float d = filled[c] - original[c];
+					if (d > maxDepth) maxDepth = d;
+					int cx2 = c / n, cy2 = c % n;
+					for (int dx = -1; dx <= 1; dx++)
+					{
+						for (int dy = -1; dy <= 1; dy++)
+						{
+							if (dx == 0 && dy == 0) continue;
+							int nx = cx2 + dx, ny = cy2 + dy;
+							if (nx < 0 || nx >= n || ny < 0 || ny >= n) continue;
+							int ni = nx * n + ny;
+							if (counted[ni] || filled[ni] <= original[ni] || IsWaterPixel(nx, ny)) continue;
+							counted[ni] = true;
+							comp.Enqueue(ni);
+						}
+					}
+				}
+				basinLandPixels += area;
+				basinAreas.Add(area);
+				basinDepths.Add(maxDepth);
+			}
+		}
+
+		basinAreas.Sort();
+		basinDepths.Sort();
+		long P(List<long> s, double q) => s.Count == 0 ? 0 : s[Mathf.Clamp((int)(q * s.Count), 0, s.Count - 1)];
+		float Pf(List<float> s, double q) => s.Count == 0 ? 0 : s[Mathf.Clamp((int)(q * s.Count), 0, s.Count - 1)];
+
+		double totalSeconds = (Time.GetTicksMsec() - t0) / 1000.0;
+		GD.Print($"{T()} [PriorityFlood] flood {floodSeconds:F1}s, total (with invariants+stats) {totalSeconds:F1}s.");
+		GD.Print($"{T()} [PriorityFlood] invariants: (a) {(invariantAViolations == 0 ? "PASS" : "FAIL")}, (b) {(invariantBViolations == 0 ? "PASS" : "FAIL")} (full check, no sampling).");
+		GD.Print($"{T()} [PriorityFlood] closed basins on land: {basinAreas.Count}; land px in basins {basinLandPixels}/{landPixels} ({(landPixels > 0 ? 100.0 * basinLandPixels / landPixels : 0):F1}%).");
+		GD.Print($"{T()} [PriorityFlood] area px: p50 {P(basinAreas, 0.5)}, p90 {P(basinAreas, 0.9)}, max {(basinAreas.Count > 0 ? basinAreas[basinAreas.Count - 1] : 0)}; " +
+			$"count ≥100px {basinAreas.FindAll(a => a >= 100).Count}, ≥1000px {basinAreas.FindAll(a => a >= 1000).Count}, ≥10000px {basinAreas.FindAll(a => a >= 10000).Count}.");
+		GD.Print($"{T()} [PriorityFlood] max depth (raw h): p50 {Pf(basinDepths, 0.5):F4}, p90 {Pf(basinDepths, 0.9):F4}, max {(basinDepths.Count > 0 ? basinDepths[basinDepths.Count - 1] : 0):F4}; " +
+			$"deeper than 0.01: {basinDepths.FindAll(d => d > 0.01f).Count}, deeper than 0.05: {basinDepths.FindAll(d => d > 0.05f).Count}.");
+	}
+
+	/// <summary>
+	/// Paints the height-stage snapshot (task 05): hypsometric tint by storm-ladder
+	/// band × Lambert hillshade from the height gradient (NW light), over the CURVED
+	/// heights — this is the snapshot that makes relief visible. Runs in both curve
+	/// modes; with the curve off it shows the legacy profile under the same bands.
+	/// Pure numeric pass over the heightmap.
+	/// </summary>
+	private void DrawHeightStageTexture()
+	{
+		Image img = Image.CreateEmpty(MapSize, MapSize, false, Image.Format.Rgba8);
+		Vector3 light = new Vector3(-0.55f, -0.55f, 0.63f).Normalized(); // NW, ~39° up
+
+		Color deepSea = new Color(0.07f, 0.15f, 0.32f);
+		Color shallowSea = new Color(0.25f, 0.45f, 0.65f);
+		Color green = new Color(0.44f, 0.62f, 0.36f);   // orange band terrain: lowland green
+		Color tan = new Color(0.76f, 0.70f, 0.46f);     // red band: tan
+		Color brown = new Color(0.55f, 0.41f, 0.28f);   // shoulder + plateau: brown
+		Color white = new Color(0.97f, 0.97f, 0.98f);   // peaks
+		Color grey = new Color(0.72f, 0.72f, 0.70f);
+
+		int n = MapSize;
+		for (int x = 0; x < n; x++)
+		{
+			for (int y = 0; y < n; y++)
+			{
+				float h = _heightMap[x, y];
+				float sea = GetSeaLevel(_tempMap[x, y]);
+
+				Color tint;
+				if (h < sea)
+				{
+					float depth = Mathf.Clamp((sea - h) / 0.5f, 0f, 1f);
+					tint = shallowSea.Lerp(deepSea, depth);
+				}
+				else if (h < HeightCurve.ORANGE_CEIL) tint = green;
+				else if (h < HeightCurve.RED_CEIL) tint = tan;
+				else if (h < HeightCurve.PLATEAU_HI) tint = brown;
+				else
+				{
+					float t2 = Mathf.Clamp((h - HeightCurve.PLATEAU_HI) / (HeightCurve.PEAK_CAP - HeightCurve.PLATEAU_HI), 0f, 1f);
+					tint = grey.Lerp(white, t2);
+				}
+
+				// Lambert hillshade on the world-scale gradient (1 px = 1 m, height ×251 m).
+				int xm = x > 0 ? x - 1 : x, xp = x < n - 1 ? x + 1 : x;
+				int ym = y > 0 ? y - 1 : y, yp = y < n - 1 ? y + 1 : y;
+				float gx = (_heightMap[xp, y] - _heightMap[xm, y]) * 251f / (xp - xm == 0 ? 1 : xp - xm);
+				float gy = (_heightMap[x, yp] - _heightMap[x, ym]) * 251f / (yp - ym == 0 ? 1 : yp - ym);
+				Vector3 nrm = new Vector3(-gx, -gy, 1f).Normalized();
+				float shade = Mathf.Clamp(nrm.Dot(light), 0f, 1f);
+
+				Color c = tint * (0.35f + 0.65f * shade);
+				c.A = 1f;
+				img.SetPixel(x, y, c);
+			}
+		}
+		Texture = ImageTexture.CreateFromImage(img);
+	}
+
+	/// <summary>
+	/// Paints the water-stage snapshot from the stage's own outputs (the biome grid
+	/// does not exist yet at this point in the pipeline): ocean deep blue, lakes a
+	/// distinct lighter blue, land neutral grey.
+	/// </summary>
+	private void DrawWaterStageTexture()
+	{
+		Image img = Image.CreateEmpty(MapSize, MapSize, false, Image.Format.Rgba8);
+		Color land = new Color(0.45f, 0.45f, 0.42f);
+		Color ocean = new Color(0.05f, 0.2f, 0.45f);
+		Color lake = new Color(0.35f, 0.7f, 0.9f);
+		for (int x = 0; x < MapSize; x++)
+		{
+			for (int y = 0; y < MapSize; y++)
+			{
+				ushort id = _waterBodyIds[x, y];
+				img.SetPixel(x, y, id == 0 ? land : (id == 1 ? ocean : lake));
+			}
+		}
+		Texture = ImageTexture.CreateFromImage(img);
+	}
+
 	private void AssignBiomesAndDraw()
 	{
 		Image mapImage = Image.CreateEmpty(MapSize, MapSize, false, Image.Format.Rgba8);
@@ -433,13 +872,21 @@ public partial class MapGenerator : TextureRect
 		{
 			for (int y = 0; y < MapSize; y++)
 			{
-				float h = _heightMap[x, y];
+				// Biome rules classify against the UNCURVED heights (task 05) — the
+				// bit-identical-biomes oracle. Beach/mountain/snow bands and the
+				// water split all read the classify map.
+				float h = _heightMapClassify[x, y];
 				float t = _tempMap[x, y];
 				Biome b;
 
 				float currentSeaLevel = GetSeaLevel(t);
 
-				if (h < currentSeaLevel) b = _isTrueOcean[x, y] ? Biome.Ocean : Biome.Lake;
+				// Water classification comes from the SHARED predicates (task 03), so the
+				// water-bodies stage and the biome classifier cannot disagree. Same rules
+				// as before, verbatim: below local sea level -> Ocean if true-ocean
+				// connected, else Lake.
+				if (IsOceanPixel(x, y)) b = Biome.Ocean;
+				else if (IsLakePixel(x, y)) b = Biome.Lake;
 				else
 				{
 					float baseDist = new Vector2(x, y).DistanceTo(_impactCenter);
@@ -685,12 +1132,20 @@ public partial class MapGenerator : TextureRect
 			if (t < minTemp || t > maxTemp) continue;
 
 			float centerH = _heightMap[rx, ry];
-			// Sample slope a bit wider (10px) due to higher resolution
+			// Sample slope a bit wider (10px) due to higher resolution.
+			// Samples are clamped to map bounds (task 05): candidates spawn at
+			// [20, MapSize-20] but slopeRadius is 40 at 8K, so the unclamped reads
+			// were out of bounds near the border — previously unreachable only
+			// because border land stayed underwater and failed the sea test first.
 			int slopeRadius = (int)(MapSize * 0.005f); // Automatically scales!
-			if (Mathf.Abs(_heightMap[rx+slopeRadius, ry] - centerH) > maxSlope) continue;
+			int sxHi = Mathf.Clamp(rx + slopeRadius, 0, MapSize - 1);
-			if (Mathf.Abs(_heightMap[rx-slopeRadius, ry] - centerH) > maxSlope) continue;
+			int sxLo = Mathf.Clamp(rx - slopeRadius, 0, MapSize - 1);
-			if (Mathf.Abs(_heightMap[rx, ry+slopeRadius] - centerH) > maxSlope) continue;
+			int syHi = Mathf.Clamp(ry + slopeRadius, 0, MapSize - 1);
-			if (Mathf.Abs(_heightMap[rx, ry-slopeRadius] - centerH) > maxSlope) continue;
+			int syLo = Mathf.Clamp(ry - slopeRadius, 0, MapSize - 1);
+			if (Mathf.Abs(_heightMap[sxHi, ry] - centerH) > maxSlope) continue;
+			if (Mathf.Abs(_heightMap[sxLo, ry] - centerH) > maxSlope) continue;
+			if (Mathf.Abs(_heightMap[rx, syHi] - centerH) > maxSlope) continue;
+			if (Mathf.Abs(_heightMap[rx, syLo] - centerH) > maxSlope) continue;
 
 			bool nearTrueOcean = false;
 			bool nearAnyWater = false;
@@ -887,7 +1342,13 @@ public partial class MapGenerator : TextureRect
 		return astar.GetPointPath(from, to);
 	}
 
-	private float GetSeaLevel(float t) => Mathf.Lerp(0.26f, 0.15f, Mathf.Clamp(t, 0f, 1f));
+	// Sea-level model gate (D-033, task 04): "flat" returns the configured scalar;
+	// "field" is the legacy latitude Lerp. Pure numeric mapping either way (D-035);
+	// all nine call sites inherit whichever model config selects.
+	private float GetSeaLevel(float t) =>
+		ConfigManager.SeaLevelModel == "flat"
+			? ConfigManager.SeaLevelValue
+			: Mathf.Lerp(0.26f, 0.15f, Mathf.Clamp(t, 0f, 1f));
 
 	private Vector2I FindClosestPixel(Vector2 pos, HashSet<Vector2I> set) {
 		Vector2I closest = new Vector2I(0,0); float min = float.MaxValue;

Tools/Scripts/README.md

@@ -11,14 +11,29 @@ Generates the entire 2D blueprint. Roughly in order:
 2. **Topography** — FastNoiseLite base height plus a mountain spine, minus a squircle distance
    falloff, giving a guaranteed island. Noise frequency is divided by `scaleFactor`
    (`MapSize / 1024f`) so terrain features stay the same real-world size at any map profile.
-3. **Sea level and water** — temperature-driven sea level; flood fill separates true ocean from
+   When `TerrainCurve: "v2"` (the default), the calibrated height-redistribution curve
-   inland lakes; a mainland fill guarantees one contiguous landmass.
+   (`HeightCurve.cs` — flat farmable lowlands, 50 m plateau shelf, and a per-seed-normalized
+   spike to the 420 m peak cap: every island's tallest point reaches the ceiling) reshapes
+   above-sea terrain after noise/falloff/Trench and before the crater carve; biome
+   classification reads a retained uncurved map, so biomes are identical either way. Drops the
+   `0_height` hillshade snapshot (hypsometric bands × NW hillshade) in both modes.
+3. **Sea level and water** — sea level per the configured model (`SeaLevelModel`: `"flat"` scalar
+   — the default, `SeaLevelValue` 0.15 — or the legacy `"field"` latitude Lerp); flood fill
+   separates true ocean from inland lakes; a mainland fill guarantees one contiguous landmass.
 4. **The crater** — placed along the northern coast and carved to below sea level, but only out to
    **80 % of its radius**, which guarantees a landbridge rather than severing the island.
-5. **Biomes and towns** — biome zoning by height and temperature; tiered town placement (Capitol,
+5. **Water bodies** — promotes the classified water into explicit data: the ocean as body 1, each
+   lake connected-component labeled (same 4-connectivity as the true-ocean fill), one transitional
+   surface level per body. Classification comes from the shared `IsOceanPixel`/`IsLakePixel`
+   predicates that the biome stage also uses, so the two can never disagree. A priority-flood
+   pit-fill runs here as validated diagnostics (basin statistics to console; serializes nothing).
+   Drops the `0_water` snapshot.
+6. **Biomes and towns** — biome zoning by height and temperature; tiered town placement (Capitol,
    Hubs, Villages, Outposts, POIs) filtered by slope, water proximity and spacing.
-6. **Roads** — see below.
+7. **Roads** — see below. Skipped entirely when the `SkipRoads` config toggle is on (the ~25-min
-7. **Export** — writes the `.dat` blueprint (dual-write: the v2 tagged container under the primary
+   A\* pass is the bottleneck; a skip run exports a road-less iteration blueprint in ~80 s with a
+   loud console banner).
+8. **Export** — writes the `.dat` blueprint (dual-write: the v2 tagged container under the primary
    seed name, plus the legacy v1 format beside it as `_v1.dat` — see
    `Core/Scripts/BLUEPRINT_FORMAT.md`), then renders the PNG snapshot. The v2 file embeds the
    resolved generation params (seed, MapSize, crater radius, density, impact centre, provenance).
@@ -55,8 +70,11 @@ Road colours on the snapshot, useful for identifying a road: **red** = Highway,
 **dark brown** = Rugged, **light brown** = Trail.
 
 ### Outputs
-`MapData_Seed_<seed>.dat` (v2), `MapData_Seed_<seed>_v1.dat` (legacy dual-write), and
+`MapData_Seed_<seed>.dat` (v2), `MapData_Seed_<seed>_v1.dat` (legacy dual-write), and the staged
-`Map_Seed_<seed>.png`, all to `user://`.
+snapshots `Map_Seed_<seed>_{0_height,0_water,1_biomes,2_towns,3_roads}.png`, all to `user://`.
+(`0_height` is the hypsometric hillshade of the curved terrain; `0_water` is painted from the
+water stage's own outputs — ocean deep blue, lakes lighter blue, land neutral; `3_roads` is
+absent on a SkipRoads run.)
 
 ## `RoundTripHarness.cs`
 

Tools/Scripts/RoundTripHarness.cs

@@ -119,6 +119,8 @@ public partial class RoundTripHarness : Node
 		ok &= CompareRoads("Branch", a.BranchRoads, b.BranchRoads);
 		ok &= CompareRoads("Rugged", a.RuggedRoads, b.RuggedRoads);
 		ok &= CompareRoads("Trail", a.TrailRoads, b.TrailRoads);
+		ok &= CompareWater(a, b);
+		ok &= CompareTerrainCurve(a, b);
 
 		if (ok)
 			GD.Print($"[Harness] Semantic equality holds: {a.MapSize}x{a.MapSize} grid, " +
@@ -127,6 +129,86 @@ public partial class RoundTripHarness : Node
 		return ok;
 	}
 
+	// Water sections (WBID/WBTB/WSRF) are compared whenever the SOURCE carries them —
+	// the regression test grows with the format. A source without water (legacy v1)
+	// must round-trip to a file without water.
+	private bool CompareWater(WorldBlueprint a, WorldBlueprint b)
+	{
+		if (a.WaterBodyIds == null && b.WaterBodyIds == null)
+		{
+			GD.Print("[Harness] Water sections: absent in source — nothing to compare (and none reappeared).");
+			return true;
+		}
+		if (a.WaterBodyIds == null || b.WaterBodyIds == null)
+		{
+			GD.PrintErr($"[Harness] Water sections presence mismatch: source {(a.WaterBodyIds != null ? "has" : "lacks")} them, reread {(b.WaterBodyIds != null ? "has" : "lacks")} them.");
+			return false;
+		}
+
+		bool ok = true;
+		long idDiffs = 0, surfDiffs = 0;
+		int n = a.MapSize;
+		for (int x = 0; x < n; x++)
+		{
+			for (int y = 0; y < n; y++)
+			{
+				if (a.WaterBodyIds[x, y] != b.WaterBodyIds[x, y]) idDiffs++;
+				ushort sa = a.WaterSurfaceQ != null ? a.WaterSurfaceQ[x, y] : (ushort)0;
+				ushort sb = b.WaterSurfaceQ != null ? b.WaterSurfaceQ[x, y] : (ushort)0;
+				if (sa != sb) surfDiffs++;
+			}
+		}
+		if (idDiffs > 0) { GD.PrintErr($"[Harness] {idDiffs} WBID pixels differ."); ok = false; }
+		if (surfDiffs > 0) { GD.PrintErr($"[Harness] {surfDiffs} WSRF pixels differ."); ok = false; }
+
+		if (a.WaterBodies.Count != b.WaterBodies.Count)
+		{
+			GD.PrintErr($"[Harness] Water body count mismatch: {a.WaterBodies.Count} vs {b.WaterBodies.Count}");
+			ok = false;
+		}
+		else
+		{
+			for (int i = 0; i < a.WaterBodies.Count; i++)
+			{
+				var wa = a.WaterBodies[i];
+				var wb = b.WaterBodies[i];
+				if (wa.Id != wb.Id || wa.Type != wb.Type || wa.Salinity != wb.Salinity ||
+					System.BitConverter.SingleToInt32Bits(wa.SurfaceLevel) != System.BitConverter.SingleToInt32Bits(wb.SurfaceLevel) ||
+					wa.PixelCount != wb.PixelCount || wa.Centroid != wb.Centroid)
+				{
+					GD.PrintErr($"[Harness] Water body {i} mismatch (id {wa.Id} vs {wb.Id}).");
+					ok = false;
+				}
+			}
+		}
+
+		if (ok) GD.Print($"[Harness] Water sections equal: {a.WaterBodies.Count} bodies, WBID+WSRF grids identical.");
+		return ok;
+	}
+
+	private bool CompareTerrainCurve(WorldBlueprint a, WorldBlueprint b)
+	{
+		if (a.TerrainCurve == null && b.TerrainCurve == null)
+		{
+			GD.Print("[Harness] TCRV: absent in source — nothing to compare (and none reappeared).");
+			return true;
+		}
+		if (a.TerrainCurve == null || b.TerrainCurve == null)
+		{
+			GD.PrintErr("[Harness] TCRV presence mismatch between source and reread.");
+			return false;
+		}
+		var ca = a.TerrainCurve; var cb = b.TerrainCurve;
+		bool same = ca.Version == cb.Version;
+		float[] fa = { ca.T1, ca.T2, ca.T3, ca.T4, ca.SpikeMax, ca.Sea, ca.OrangeCeil, ca.RedCeil, ca.PlateauLo, ca.PlateauHi, ca.PeakCap, ca.TailSlope };
+		float[] fb = { cb.T1, cb.T2, cb.T3, cb.T4, cb.SpikeMax, cb.Sea, cb.OrangeCeil, cb.RedCeil, cb.PlateauLo, cb.PlateauHi, cb.PeakCap, cb.TailSlope };
+		for (int i = 0; i < fa.Length; i++)
+			if (System.BitConverter.SingleToInt32Bits(fa[i]) != System.BitConverter.SingleToInt32Bits(fb[i])) same = false;
+		if (!same) { GD.PrintErr("[Harness] TCRV fields differ."); return false; }
+		GD.Print($"[Harness] TCRV equal (curve v{ca.Version}).");
+		return true;
+	}
+
 	private bool CompareRoads(string tier, List<Vector2[]> a, List<Vector2[]> b)
 	{
 		if (a.Count != b.Count)