sindicate 0.13.0 → 0.15.0

package/src/world/waterLevels.js

@@ -0,0 +1,95 @@
+// THE WATER-LEVEL BAKE (world splits, step 3b) — R.wy, the per-vertex water surface every
+// carve, sheet, swimmer and bridge reads. Moved verbatim from the games (identical bodies;
+// western adds PASS 0 + the R.bd gates, which subsume fable's ungated loops — an unsolved
+// course simply runs the live passes).
+//
+//   PASS 0 — THE SURVEY GOVERNS (solved courses, R.bd present): wy = solved bed + baked
+//            reach depth, source/terminus lake pins, then strictly monotone — the uphill
+//            forgiveness below does not apply to a solved course.
+//   PASS 1 — raw level = lowest of the ±ww cross-section on the river-free ground, −1 m
+//            (cross-section reach capped at 10 m — the wide-trunk lesson: ±26 m banks
+//            reached distant low ground and PASS 2 dragged whole reaches to sea level).
+//   PASS 2 — terminus pin (end lake surface −0.8 / parent trunk's level at the join / the
+//            open sea), monotone-downhill, floor at sea level. Trunks must precede their
+//            tributaries in the array so a join reads a FINALIZED parent level.
+//   PASS 3 — riffle relief: water rides within riffleCut of the river-free ground (highest
+//            of centreline AND both banks at ±(ww+4)) so the monotone floor cannot gouge a
+//            slot-gorge across a rise ('rivers underground').
+//   PASS 4 — estuary descent: sea-reaching trunks ease to sea level anchored at the
+//            SHORELINE node (tails run out to sea), pin seaward, re-monotone the reach.
+//
+// groundFn(x, z) is the game's river-free pristine ground — rawHeight(x, z, true) in both
+// counties. Call this at the game's bake site (BELOW its rawHeight, per the TDZ law both
+// files document). Headless by law.
+import { lerp, smoothstep } from './geo.js';
+
+function riverWyAt(R, p) {                          // baked level of R nearest p — for confluences
+  let best = Infinity, wy = R.wy[0];
+  for (let i = 0; i < R.pts.length; i++) {
+    const d = Math.hypot(R.pts[i].x - p.x, R.pts[i].z - p.z);
+    if (d < best) { best = d; wy = R.wy[i]; }
+  }
+  return wy;
+}
+
+export function bakeWaterLevels(rivers, groundFn, { seaLevel, coastZ, riffleCut = 1.6 } = {}) {
+  // PASS 0
+  for (const R of rivers) {
+    if (!R.bd) continue;
+    const n = R.pts.length;
+    R.wy = R.bd.map((b, i) => b + R.wdep[i]);
+    if (R.srcLake) R.wy[0] = R.srcLake.level - 0.3;
+    if (R.endLake) R.wy[n - 1] = R.endLake.level - 0.8;
+    for (let i = 1; i < n; i++) R.wy[i] = Math.min(R.wy[i], R.wy[i - 1]);
+  }
+  // PASS 1
+  for (const R of rivers) {
+    if (R.bd) continue;
+    R.wy = R.pts.map((p, i, a) => {
+      const pa = a[Math.max(0, i - 1)], pb = a[Math.min(a.length - 1, i + 1)];
+      let tx = pb.x - pa.x, tz = pb.z - pa.z; const tl = Math.hypot(tx, tz) || 1; const nx = -tz / tl, nz = tx / tl;
+      const w = Math.min(R.ww[i], 10);
+      return Math.min(groundFn(p.x, p.z), groundFn(p.x + nx * w, p.z + nz * w), groundFn(p.x - nx * w, p.z - nz * w)) - 1.0;
+    });
+  }
+  // PASS 2
+  for (const R of rivers) {
+    if (R.bd) continue;
+    const n = R.wy.length;
+    R.wy[n - 1] = R.endLake ? R.endLake.level - 0.8
+               : R.parent != null ? riverWyAt(rivers[R.parent], R.pts[n - 1])
+               : seaLevel;
+    for (let i = 1; i < n; i++) R.wy[i] = Math.min(R.wy[i], R.wy[i - 1]);
+    for (let i = 0; i < n; i++) R.wy[i] = Math.max(R.wy[i], seaLevel);
+  }
+  // PASS 3
+  for (const R of rivers) {
+    if (R.bd) continue;
+    for (let i = 0; i < R.wy.length; i++) {
+      const p2 = R.pts[i], pa2 = R.pts[Math.max(0, i - 1)], pb2 = R.pts[Math.min(R.pts.length - 1, i + 1)];
+      let tx2 = pb2.x - pa2.x, tz2 = pb2.z - pa2.z; const tl2 = Math.hypot(tx2, tz2) || 1;
+      const nx2 = -tz2 / tl2, nz2 = tx2 / tl2, off2 = R.ww[i] + 4;
+      const gRef = Math.max(
+        groundFn(p2.x, p2.z),
+        groundFn(p2.x + nx2 * off2, p2.z + nz2 * off2),
+        groundFn(p2.x - nx2 * off2, p2.z - nz2 * off2),
+      );
+      R.wy[i] = Math.max(R.wy[i], gRef - riffleCut);
+    }
+  }
+  // PASS 4
+  for (const R of rivers) {
+    if (R.bd || R.parent != null || R.endLake) continue;
+    const n = R.wy.length;
+    if (R.pts[n - 1].z < coastZ) continue;
+    let iShore = n - 1;
+    while (iShore > 0 && groundFn(R.pts[iShore].x, R.pts[iShore].z) < seaLevel + 0.3) iShore--;
+    const K = Math.min(14, iShore);
+    for (let i = iShore - K; i <= iShore; i++) {
+      const t = smoothstep(iShore - K, iShore, i);
+      R.wy[i] = Math.max(seaLevel, lerp(R.wy[i], seaLevel, t));
+    }
+    for (let i = iShore + 1; i < n; i++) R.wy[i] = seaLevel;
+    for (let i = Math.max(1, iShore - Math.min(24, iShore)); i < n; i++) R.wy[i] = Math.min(R.wy[i], R.wy[i - 1]);
+  }
+}

package/src/world/waterMeshes.js

@@ -0,0 +1,168 @@
+// THE WATER MESHES (world splits, step 6) — river ribbons, lake sheets and the sea plane,
+// moved verbatim from western's zones.js. All geometry + per-vertex hydraulic bakes; the
+// MATERIALS stay the game's choice (one shared waterMaterial across lakes, one shared
+// riverMaterial across courses — each distinct refracting material pays its own viewport
+// copy per frame, so sharing collapses the copies however many bodies the county gains).
+import * as THREE from 'three/webgpu';
+
+// A river ribbon: walk the path in ~2m steps, emit left/right cross-section verts at ±w,
+// bake the still-water depth (level − bed) + downstream UVs per vertex, strip the quads.
+// Emitted as ~200 m CHUNKS (each its own geometry + bounding sphere) rather than one
+// course-long mesh: a 3.6 km course has a county-sized bounding sphere, so frustumCulled
+// never actually culled, and refraction pays a viewport copy per DRAW. Boundary
+// cross-section rows are duplicated into both neighbouring chunks — identical baked values
+// from identical inputs, so the strip has no seam.
+export function buildRiverMesh(scene, R, mat, { heightAt }) {
+  const L = THREE.MathUtils.lerp, pts = [];
+  // Reference half-width for the flow bake: the course's own source→mouth hydraulic ramp,
+  // PER STATION — not one course-wide constant. The solved widths are that ramp ±25 %
+  // pool/riffle modulation, and it is the MODULATION continuity should answer to: against a
+  // constant reference, a narrow upstream pool computes faster than a wide downstream riffle
+  // (measured: pools averaged 0.50 m/s to the riffles' 0.44), which is backwards. Against
+  // the local ramp, wide-for-here runs slow and narrow-for-here runs quick, the whole course over.
+  const wEnd = R.pts.length - 1 || 1;
+  const wrefAt = (f) => L(R.wsrc ?? R.w, R.w, f);
+  for (let i = 0; i < R.pts.length - 1; i++) {
+    const a = R.pts[i], b = R.pts[i + 1], steps = Math.max(1, Math.round(Math.hypot(b.x - a.x, b.z - a.z) / 2));
+    for (let s = 0; s < steps; s++) { const t = s / steps; pts.push({ x: L(a.x, b.x, t), z: L(a.z, b.z, t), wy: L(R.wy[i], R.wy[i + 1], t), ww: L(R.ww[i], R.ww[i + 1], t), wr: wrefAt((i + t) / wEnd) }); }
+  }
+  const e = R.pts.length - 1; pts.push({ x: R.pts[e].x, z: R.pts[e].z, wy: R.wy[e], ww: R.ww[e], wr: wrefAt(1) });
+
+  // cross-section resolution scales with the river's width — ~2.4m across (odd → centreline)
+  const K = Math.max(9, Math.min(41, 2 * Math.round(Math.max(...R.ww) / 2.4) + 1));
+  const CHUNK_LEN = 200;   // m of course per geometry
+  const meshes = [];
+  const newChunk = () => ({ verts: [], depths: [], uvs: [], flows: [], drops: [], bWy: [], bX: [], bZ: [], rows: 0 });
+  const pushRow = (c, row) => {
+    for (const [dst, src] of [[c.verts, row.verts], [c.depths, row.depths], [c.uvs, row.uvs],
+      [c.flows, row.flows], [c.drops, row.drops], [c.bWy, row.bWy], [c.bX, row.bX], [c.bZ, row.bZ]]) dst.push(...src);
+    c.rows++;
+  };
+  const flush = (c) => {
+    const idx = [];
+    for (let i = 0; i < c.rows - 1; i++) for (let k = 0; k < K - 1; k++) {
+      const a = i * K + k, b = a + 1, q = (i + 1) * K + k, d = q + 1;
+      idx.push(a, q, b, b, q, d);
+    }
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.Float32BufferAttribute(c.verts, 3));
+    geo.setAttribute('aDepth', new THREE.Float32BufferAttribute(c.depths, 1));
+    geo.setAttribute('uv', new THREE.Float32BufferAttribute(c.uvs, 2));
+    geo.setAttribute('aFlow', new THREE.Float32BufferAttribute(c.flows, 2));
+    geo.setAttribute('aDrop', new THREE.Float32BufferAttribute(c.drops, 1));
+    geo.setIndex(idx);
+    const mesh = new THREE.Mesh(geo, mat);
+    // per-chunk bake data — refreshRiverDepths already iterates N meshes, so each chunk
+    // re-derives its own aDepth after the terrain pads mutate heightAt
+    mesh.userData.riverVerts = { wy: Float32Array.from(c.bWy), x: Float32Array.from(c.bX), z: Float32Array.from(c.bZ) };
+    geo.computeBoundingSphere();
+    mesh.frustumCulled = true; // refraction pays a viewport copy per DRAW — never draw off-screen chunks
+    scene.add(mesh);
+    meshes.push(mesh);
+  };
+  let cur = newChunk(), chunkStart = 0, along = 0;
+  for (let i = 0; i < pts.length; i++) {
+    const p = pts[i], pa = pts[Math.max(0, i - 1)], pb = pts[Math.min(pts.length - 1, i + 1)];
+    let tx = pb.x - pa.x, tz = pb.z - pa.z; const tl = Math.hypot(tx, tz) || 1; tx /= tl; tz /= tl;
+    const nx = -tz, nz = tx;                                    // perpendicular in the XZ plane
+    if (i > 0) along += Math.hypot(p.x - pts[i - 1].x, p.z - pts[i - 1].z);
+    // rapids strength: how fast the water level DROPS just downstream of here (per metre)
+    const pd = pts[Math.min(pts.length - 1, i + 3)];
+    const dDist = Math.hypot(pd.x - p.x, pd.z - p.z) || 1;
+    const drop = Math.max(0, (p.wy - pd.wy) / dDist);
+    const row = newChunk();                                     // one cross-section, built once…
+    for (let k = 0; k < K; k++) {
+      const side = (k / (K - 1)) * 2 - 1;                       // -1 (left bank) … 0 (centre) … 1 (right bank)
+      const vx = p.x + nx * p.ww * side, vz = p.z + nz * p.ww * side;
+      const g = heightAt(vx, vz);
+      // wet verts sit at water level; DRY verts dive a fixed metre BELOW the surface, so the
+      // sheet submerges and the waterline is the smooth surface/terrain intersection
+      row.verts.push(vx, g < p.wy ? p.wy : p.wy - 1.0, vz);
+      row.depths.push(p.wy - g);                                // ≤0 on dry verts → transparent + bank foam at the line
+      row.bWy.push(p.wy); row.bX.push(vx); row.bZ.push(vz);
+      row.uvs.push((side + 1) * 0.5, along * 0.1);              // V runs down the WHOLE course — seamless across chunks
+      // downstream velocity (m/s), BAKED FROM THE HYDRAULICS instead of a universal
+      // constant (every reach of every course at the same speed — a pool as fast as a
+      // rapid). Slope sets the pace (drop is already per-metre, from the reach-baked wy
+      // three nodes downstream), width modulates it by continuity against the local ramp
+      // (wr above): the solved courses run ±25 % pool/riffle width, so a narrow riffle
+      // visibly quickens and a wide pool slows to a crawl.
+      const v = THREE.MathUtils.clamp(0.4 + 10 * drop, 0.3, 2.4) * (p.wr / p.ww);
+      row.flows.push(tx * v, tz * v);
+      row.drops.push(drop);
+    }
+    pushRow(cur, row);
+    if (along - chunkStart >= CHUNK_LEN && i < pts.length - 1) {
+      flush(cur);
+      cur = newChunk(); chunkStart = along;
+      pushRow(cur, row);                                        // …and shared by both sides of the cut
+    }
+  }
+  flush(cur);
+  return meshes;
+}
+
+// A lake sheet: one plane per body at the survey level − drop, per-vertex aDepth bake, dry
+// verts dived below the surface, per-vertex aRClip so ONE shared material keeps per-lake
+// sprawl clip. The shared material is the game's (waterMaterial({ rClip: 'attribute' })).
+export function buildLake(scene, Lk, mat, { heightAt, drop = 0.8 }) {
+  const rClip = Lk.rClip ?? Lk.r * 0.85;
+  const wr = rClip + 4;
+  const wseg = THREE.MathUtils.clamp(Math.round((wr * 2) / 1.8), 16, 64);    // ~1.8m facets
+  const wgeo = new THREE.PlaneGeometry(wr * 2, wr * 2, wseg, wseg);
+  const waterY = Lk.level - drop;
+  const dp = wgeo.attributes.position, aDepth = new Float32Array(dp.count);
+  const aRClip = new Float32Array(dp.count).fill(rClip);     // per-vertex so the shared shader keeps per-lake sprawl clip
+  for (let i = 0; i < dp.count; i++) {
+    const g = heightAt(Lk.x + dp.getX(i), Lk.z - dp.getY(i));
+    aDepth[i] = waterY - g;
+    if (g >= waterY) dp.setZ(i, -drop); // dry verts dive below the surface (plane local +z is world up)
+  }
+  wgeo.setAttribute('aDepth', new THREE.BufferAttribute(aDepth, 1));
+  wgeo.setAttribute('aRClip', new THREE.BufferAttribute(aRClip, 1));
+  const lake = new THREE.Mesh(wgeo, mat);
+  lake.rotation.x = -Math.PI / 2;
+  lake.position.set(Lk.x, waterY, Lk.z);
+  scene.add(lake);
+  return lake;
+}
+
+// The sea: a flat ocean plane at seaLevel, shown only where land dips below it past coastZ.
+export function buildSea(scene, mat, { worldSize, seaLevel, coastZ, heightAt }) {
+  const SEG = 256;
+  const geo = new THREE.PlaneGeometry(worldSize, worldSize, SEG, SEG);
+  const pos = geo.attributes.position, aDepth = new Float32Array(pos.count);
+  for (let i = 0; i < pos.count; i++) {
+    const X = pos.getX(i), Z = -pos.getY(i);
+    aDepth[i] = Z > coastZ ? Math.max(0, seaLevel - heightAt(X, Z)) : 0;
+  }
+  geo.setAttribute('aDepth', new THREE.BufferAttribute(aDepth, 1));
+  const mesh = new THREE.Mesh(geo, mat);
+  mesh.rotation.x = -Math.PI / 2;
+  mesh.position.y = seaLevel;
+  mesh.frustumCulled = false;
+  scene.add(mesh);
+  return mesh;
+}
+
+// Rivers v2: re-derive every river vert's depth from the CURRENT terrain — pads that
+// register during world.build mutate heightAt AFTER the ribbons bake, leaving stale aDepth.
+// Called at the END of world.build; re-runnable whenever terrain changes.
+export function refreshRiverDepths(waters, { heightAt }) {
+  let fixed = 0;
+  for (const m of waters ?? []) {
+    const rb = m.userData?.riverVerts;
+    if (!rb) continue;
+    const pos = m.geometry.attributes.position, aD = m.geometry.attributes.aDepth;
+    for (let i = 0; i < aD.count; i++) {
+      const g = heightAt(rb.x[i], rb.z[i]);
+      const d = rb.wy[i] - g;
+      if (Math.abs(d - aD.getX(i)) > 0.02) fixed++;
+      aD.setX(i, d);
+      pos.setY(i, g < rb.wy[i] ? rb.wy[i] : rb.wy[i] - 1.0);
+    }
+    aD.needsUpdate = true; pos.needsUpdate = true;
+    m.geometry.computeBoundingSphere();
+  }
+  if (fixed) console.log(`[rivers] depth refresh: ${fixed} verts re-derived after terrain pads`);
+}