/**
 * S-25 · S1 岛屿形状（六棱台几何）纯几何单测（Node，无 WebGL）。
 * -----------------------------------------------------------------------------
 * 最终几何契约（与 src/render/island-shape.ts 一致）：
 *  · 环表 6 个：y = 0 / −0.14 / −0.55 / −1.05 / −1.35 / −1.75，半径 1.975 / 1.94 / 1.86 / 1.60 / 1.38 / 1.24。
 *  · BAND_SEGS = [1,1,1,2,1]：**竖向**分段（第 3 带＝主岩带 RockA 分 2 段 ⇒ 中间环 y≈−1.20 / r≈1.49）。
 *  · bandVertex(band, edge, sub)：sub=0 ⇒ cornerVertex(band,edge)；sub=BAND_SEGS[band] ⇒ cornerVertex(band+1,edge)。
 *  · 墙 quad = (bv(b,e,s), bv(b,e+1,s), bv(b,e+1,s+1), bv(b,e,s+1)) ⇒ 相邻边共用竖线、相邻带共用上下边 ⇒ 无缝。
 *  · 三角形：墙 6×Σsegs×2 = 72；底面 fan 6；顶面 6（Lead 在 hexworld.ts 写）⇒ 84/地块 = 1.75×。
 *
 * 覆盖：
 *  1) 环半径单调不增 / 环高严格单调下降；底面 y=−1.75、r=BOTTOM_R=0.62×HEX_S。
 *  2) 底面封闭：6 个三角形、法线全部朝下、面积 ≈ 底面六边形面积、顶点 y 恒 = BOTTOM_Y。
 *  3) 无缝：bandVertex(b,e,segs) === bandVertex(b+1,e,0)；两端严格等于 cornerVertex。
 *  4) 三角形数：全 true = 72；某边 mask=false ⇒ 该边 0 个三角形。
 *  5) footprint：所有顶点（含噪声后）在地块六边形内（6 个边法向投影 ≤ HEX_INRADIUS − 0.004）。
 *  6) 噪声确定性：同 (q,r) 逐点相等；不同 (q,r) 不同；幅度在 ±0.03~0.10（切向 ±0.05）内。
 *  7) 顶面顶点 = hexCorner(k, HEX_S − 0.025) 逐点一致。
 *  8) 岩脊：2~3 条边；脊边在中间环上的顶点明显比非脊边更靠外。
 */
import { writeFileSync } from 'node:fs';
import {
  ISLAND_RINGS, RING_COUNT, BAND_SEGS, BAND_COUNT, BOTTOM_Y, BOTTOM_R, TOP_INSET,
  FOOTPRINT_MARGIN, Band, cornerVertex, bandVertex, tileWallTris, tileBottomTris,
  ridgeEdges, ringRadii, ringHeights, triArea, WALL_TRI_COUNT, BOTTOM_TRI_COUNT
} from '../src/render/island-shape';
import { HEX_S, HEX_INRADIUS, insetMargin, hexCorner, axialToWorld, dirUnit } from '../src/render/hex';

let checks = 0;
const fails: string[] = [];
const ok = (cond: boolean, msg: string): void => { checks++; if (!cond) { fails.push(msg); } };
const near = (a: number, b: number, tol = 1e-9): boolean => Math.abs(a - b) <= tol;
const sameV = (a: { x: number; y: number; z: number }, b: { x: number; y: number; z: number }): boolean =>
  a.x === b.x && a.y === b.y && a.z === b.z;
/** 世界坐标 → 相对地块中心的偏移。 */
const rel = (q: number, r: number, v: { x: number; y: number; z: number }): { x: number; z: number } => {
  const c = axialToWorld(q, r);
  return { x: v.x - c.x, z: v.z - c.z };
};
/** 顶点是否在地块 footprint 内（R4 A32：6 个边法向投影 ≤ HEX_INRADIUS − margin）。 */
const inFootprint = (q: number, r: number, v: { x: number; y: number; z: number }): boolean => {
  const p = rel(q, r, v);
  const lim = HEX_INRADIUS - FOOTPRINT_MARGIN;
  for (let j = 0; j < 6; j++) { const u = dirUnit(j); if (p.x * u.x + p.z * u.z > lim + 1e-12) return false; }
  return true;
};
/** 归一化后的三角形法线。 */
function normal(t: { a: { x: number; y: number; z: number }; b: { x: number; y: number; z: number }; c: { x: number; y: number; z: number } }): { x: number; y: number; z: number } {
  const ux = t.b.x - t.a.x, uy = t.b.y - t.a.y, uz = t.b.z - t.a.z;
  const vx = t.c.x - t.a.x, vy = t.c.y - t.a.y, vz = t.c.z - t.a.z;
  const nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
  const l = Math.hypot(nx, ny, nz) || 1;
  return { x: nx / l, y: ny / l, z: nz / l };
}

const TILES: ReadonlyArray<readonly [number, number]> = [
  [0, 0], [1, 0], [0, 1], [-1, 1], [-1, 0], [0, -1], [1, -1],
  [3, -2], [5, 5], [-7, 3], [2, -9], [-13, -4], [11, 7]
];
const ALL_TRUE: ReadonlyArray<boolean> = [true, true, true, true, true, true];

/* ------------------------------------------------------------------ 1) 环参数 */

const radii = ringRadii();
const heights = ringHeights();
ok(radii.length === RING_COUNT && heights.length === RING_COUNT, `ringRadii/ringHeights 长度 = ${RING_COUNT}`);
for (let i = 1; i < radii.length; i++) {
  ok(radii[i] <= radii[i - 1] + 1e-12, `环半径单调不增 r${i} ≤ r${i - 1}（${radii[i]} vs ${radii[i - 1]}）`);
}
for (let i = 1; i < heights.length; i++) {
  ok(heights[i] < heights[i - 1], `环高度严格单调下降 y${i} < y${i - 1}（${heights[i]} vs ${heights[i - 1]}）`);
}
ok(near(radii[0], HEX_S - TOP_INSET), '顶面半径 = HEX_S − 0.025' + radii[0]);
ok(near(radii[RING_COUNT - 1], 0.62 * HEX_S), '底面半径 = 0.62×HEX_S' + radii[RING_COUNT - 1]);
ok(near(BOTTOM_R, 0.62 * HEX_S), 'BOTTOM_R = 0.62×HEX_S');
ok(near(BOTTOM_Y, -1.75), 'BOTTOM_Y = −1.75' + BOTTOM_Y);
ok(BOTTOM_Y === heights[RING_COUNT - 1], 'BOTTOM_Y = 末环高度');
ok(BAND_COUNT === RING_COUNT - 1, 'BAND_COUNT = 环数 − 1');
ok(BAND_SEGS.length === BAND_COUNT, 'BAND_SEGS 长度 = BAND_COUNT');
ok(BAND_SEGS.reduce((a, b) => a + b, 0) === 6, 'BAND_SEGS 总和 = 6（墙 6×6×2 = 72）');
ok(WALL_TRI_COUNT === 72 && BOTTOM_TRI_COUNT === 6, '预算常量：墙 72 / 底面 6');

/* ------------------------------------------------------------------ 2) 底面封闭 */

for (const [q, r] of TILES) {
  const tris = tileBottomTris(q, r);
  ok(tris.length === 6, `tileBottomTris(${q},${r}) 恰 6 个三角形（实际 ${tris.length}）`);
  let area = 0;
  for (const t of tris) {
    area += triArea(t);
    const n = normal(t);
    ok(n.y < -0.9, `底面法线朝下 (${q},${r}) ny=${n.y.toFixed(4)}`);
    ok(t.band === Band.RockB, `底面 band = Band.RockB (${q},${r})`);
    ok(t.jit >= 0 && t.jit <= 1, `底面 jit ∈ [0,1] (${q},${r})`);
    ok(t.a.y === BOTTOM_Y && t.b.y === BOTTOM_Y && t.c.y === BOTTOM_Y, `底面顶点 y 恒 = BOTTOM_Y (${q},${r})`);
    ok(inFootprint(q, r, t.a) && inFootprint(q, r, t.b) && inFootprint(q, r, t.c), `底面顶点都在 footprint 内 (${q},${r})`);
  }
  // 参考面积：末环六边形（鞋带公式）
  const poly = [0, 1, 2, 3, 4, 5].map(k => cornerVertex(q, r, RING_COUNT - 1, k));
  let ref = 0;
  for (let k = 0; k < 6; k++) { const p = poly[k], n = poly[(k + 1) % 6]; ref += p.x * n.z - n.x * p.z; }
  ref = Math.abs(ref) * 0.5;
  ok(ref > 0, `底面多边形面积 > 0 (${q},${r})`);
  ok(Math.abs(area - ref) / ref < 0.02, `底面 fan 覆盖底面（相对误差 < 2%）(${q},${r}) area=${area.toFixed(4)} ref=${ref.toFixed(4)}`);
}

/* ------------------------------------------------------------------ 3) 无缝（相邻带 / 相邻边） */

for (const [q, r] of TILES) {
  for (let b = 0; b < BAND_COUNT; b++) {
    const segs = BAND_SEGS[b];
    for (let e = 0; e < 6; e++) {
      // 两端严格等于角点
      ok(sameV(bandVertex(q, r, b, e, 0), cornerVertex(q, r, b, e)), `带起点 = cornerVertex(${b},${e}) (${q},${r})`);
      ok(sameV(bandVertex(q, r, b, e, segs), cornerVertex(q, r, b + 1, e)), `带终点 = cornerVertex(${b + 1},${e}) (${q},${r})`);
      // 相邻带首尾相接（无缝）
      if (b + 1 < BAND_COUNT) {
        ok(sameV(bandVertex(q, r, b, e, segs), bandVertex(q, r, b + 1, e, 0)),
          `相邻带连续：带${b}底 ≡ 带${b + 1}顶 (${q},${r}) e${e}`);
      }
      // 相邻边共用同一条竖线（同一函数体 ⇒ 逐分量相等）
      for (let s = 0; s <= segs; s++) {
        ok(sameV(bandVertex(q, r, b, e + 1, s), bandVertex(q, r, b, (e + 1) % 6, s)),
          `相邻边共用竖线 (${q},${r}) b${b}e${e}s${s}`);
      }
    }
  }
}

/* ------------------------------------------------------------------ 4) 三角形数 + 每边归属 */

const vkey = (v: { x: number; y: number; z: number }): string => `${v.x.toFixed(9)}|${v.y.toFixed(9)}|${v.z.toFixed(9)}`;

for (const [q, r] of TILES) {
  const wall = tileWallTris(q, r, ALL_TRUE);
  ok(wall.length === 72, `tileWallTris(${q},${r}) 全 true = 72（实际 ${wall.length}）`);

  // 每个 (带, 边, 段) 的 quad 恰好由 2 个三角形构成，且所有三角形被恰好归属一次（无缝、无重叠）
  const seen = new Set<number>();
  let dup = 0;
  for (let b = 0; b < BAND_COUNT; b++) {
    for (let e = 0; e < 6; e++) {
      for (let s = 0; s < BAND_SEGS[b]; s++) {
        const qk = new Set([
          vkey(bandVertex(q, r, b, e, s)),
          vkey(bandVertex(q, r, b, (e + 1) % 6, s)),
          vkey(bandVertex(q, r, b, (e + 1) % 6, s + 1)),
          vkey(bandVertex(q, r, b, e, s + 1))
        ]);
        const hit = wall.map((t, i) => ({ t, i })).filter(({ t }) =>
          qk.has(vkey(t.a)) && qk.has(vkey(t.b)) && qk.has(vkey(t.c)));
        ok(hit.length === 2, `quad b${b}e${e}s${s} 恰有 2 个三角形（实际 ${hit.length}）(${q},${r})`);
        for (const { i } of hit) { if (seen.has(i)) dup++; seen.add(i); }
      }
    }
  }
  ok(seen.size === 72 && dup === 0, `72 个三角形被恰好归属一次（覆盖 ${seen.size} / 重复 ${dup}）(${q},${r})`);

  // 每条边的三角形数 = Σ_b BAND_SEGS[b] × 2 = 12
  const edgeTris = (tris: ReadonlyArray<{ a: { x: number; y: number; z: number }; b: { x: number; y: number; z: number }; c: { x: number; y: number; z: number } }>, e0: number): number => {
    let cnt = 0;
    for (const t of tris) {
      for (let b = 0; b < BAND_COUNT; b++) {
        for (let s = 0; s < BAND_SEGS[b]; s++) {
          const qk = new Set([
            vkey(bandVertex(q, r, b, e0, s)),
            vkey(bandVertex(q, r, b, (e0 + 1) % 6, s)),
            vkey(bandVertex(q, r, b, (e0 + 1) % 6, s + 1)),
            vkey(bandVertex(q, r, b, e0, s + 1))
          ]);
          if (qk.has(vkey(t.a)) && qk.has(vkey(t.b)) && qk.has(vkey(t.c))) { cnt++; break; }
        }
      }
    }
    return cnt;
  };
  for (let e0 = 0; e0 < 6; e0++) {
    ok(edgeTris(wall, e0) === 12, `边 ${e0} 全 true 时 12 个三角形（实际 ${edgeTris(wall, e0)}）(${q},${r})`);
    const mask = [true, true, true, true, true, true];
    mask[e0] = false;
    const part = tileWallTris(q, r, mask);
    ok(part.length === 72 - 12, `关掉边 ${e0} ⇒ 60 个三角形（实际 ${part.length}）`);
    ok(edgeTris(part, e0) === 0, `mask=false 的边 ${e0} 不建墙（残留 ${edgeTris(part, e0)} 个）`);
  }
  ok(tileWallTris(q, r, [false, false, false, false, false, false]).length === 0, '全关 ⇒ 0 个三角形');
}

/* ------------------------------------------------------------------ 5) footprint + 只向内收 */

for (const [q, r] of TILES) {
  for (let ring = 0; ring < RING_COUNT; ring++) {
    for (let k = 0; k < 6; k++) {
      const v = cornerVertex(q, r, ring, k);
      ok(inFootprint(q, r, v), `角点 (${q},${r}) r${ring}k${k} 在 footprint 内`);
      ok(insetMargin(rel(q, r, v).x, rel(q, r, v).z) >= 0, `角点 (${q},${r}) r${ring}k${k} insetMargin ≥ 0`);
      ok(v.y === ISLAND_RINGS[ring].y, `角点 (${q},${r}) r${ring}k${k} 高度 = 标称环高`);
    }
  }
  for (let b = 0; b < BAND_COUNT; b++) {
    for (let e = 0; e < 6; e++) {
      for (let s = 0; s <= BAND_SEGS[b]; s++) {
        const v = bandVertex(q, r, b, e, s);
        ok(inFootprint(q, r, v), `带顶点 (${q},${r}) b${b}e${e}s${s} 在 footprint 内`);
        ok(insetMargin(rel(q, r, v).x, rel(q, r, v).z) >= 0, `带顶点 (${q},${r}) b${b}e${e}s${s} insetMargin ≥ 0`);
        ok(v.y >= ISLAND_RINGS[b + 1].y - 1e-9 && v.y <= ISLAND_RINGS[b].y + 1e-9,
          `带顶点 (${q},${r}) b${b}e${e}s${s} 高度在两环之间`);
      }
    }
  }
}

/* ------------------------------------------------------------------ 6) 噪声确定性 + 幅度 */

{
  const a1 = cornerVertex(2, -3, 2, 1), a2 = cornerVertex(2, -3, 2, 1);
  ok(sameV(a1, a2), 'cornerVertex 两次调用逐分量相等');
  const b1 = bandVertex(2, -3, 3, 4, 1), b2 = bandVertex(2, -3, 3, 4, 1);
  ok(sameV(b1, b2), 'bandVertex 两次调用逐分量相等');
  ok(!sameV(a1, cornerVertex(3, -3, 2, 1)), '不同 (q,r) 的角点不同');
  ok(!sameV(b1, bandVertex(3, -3, 3, 4, 1)), '不同 (q,r) 的带顶点不同');
  // 不同地块的相对位置不应是常量偏移
  const relSet = new Set<string>();
  for (const [q, r] of TILES) {
    const v = cornerVertex(q, r, 2, 0);
    const p = rel(q, r, v);
    relSet.add(`${p.x.toFixed(9)},${p.z.toFixed(9)}`);
  }
  ok(relSet.size >= TILES.length - 1, `不同地块的角点相对位置各不相同（${relSet.size}/${TILES.length}）`);

  // 幅度：法向 ±[0.03, 0.10]、切向 ±0.05（末环更小）。
  // 说明：角点的径向位移被「只向内收」夹紧 ⇒ 实际只会向内（0 或 −[0.03,0.10]），绝不为正。
  let maxRad = 0, maxTan = 0, minInward = Infinity, inwardCnt = 0, inwardBig = 0;
  for (const [q, r] of TILES) {
    for (let ring = 1; ring < RING_COUNT - 1; ring++) {
      for (let k = 0; k < 6; k++) {
        const v = cornerVertex(q, r, ring, k);
        const p = rel(q, r, v);
        const u = hexCorner(k, 1);
        const rad = p.x * u.x + p.z * u.z;             // 径向分量
        const tan = -p.x * u.z + p.z * u.x;            // 切向分量
        const dn = rad - radii[ring];
        ok(dn <= 1e-9, `角点只向内收（径向位移 ≤ 0）(${q},${r}) r${ring}k${k} dn=${dn.toFixed(5)}`);
        ok(Math.abs(dn) <= 0.10 + 1e-9, `法向位移幅度 ≤ 0.10 (${q},${r}) r${ring}k${k} dn=${dn.toFixed(4)}`);
        ok(Math.abs(tan) <= 0.05 + 1e-9, `切向位移幅度 ≤ 0.05 (${q},${r}) r${ring}k${k} tan=${tan.toFixed(4)}`);
        if (dn < -1e-6) { inwardCnt++; minInward = Math.min(minInward, -dn); if (-dn >= 0.03 - 1e-9) inwardBig++; }
        maxRad = Math.max(maxRad, Math.abs(dn));
        maxTan = Math.max(maxTan, Math.abs(tan));
      }
    }
  }
  ok(maxRad >= 0.085, `噪声幅度达到区间上沿（max 法向 ${maxRad.toFixed(4)}）`);
  ok(maxTan >= 0.035, `噪声幅度达到区间上沿（max 切向 ${maxTan.toFixed(4)}）`);
  ok(inwardCnt > 0, `存在向内的法向噪声（${inwardCnt} 个采样）`);
  // 注：向内位移的下界 0.03 可能被 footprint 夹紧削掉一点点（极窄边缘），只要求「绝大多数」在区间内
  ok(inwardBig >= inwardCnt * 0.5, `向内位移多数 ≥ 0.03（${inwardBig}/${inwardCnt}，最小 ${minInward.toFixed(4)}）`);

  // 带中段（中间环）的位移：法向 ±0.03~0.10 + 切向 ±0.05（岩脊边再 +0.10）
  let maxBand = 0, bandPos = 0, bandNeg = 0;
  for (const [q, r] of TILES) {
    const c = axialToWorld(q, r);
    for (let e = 0; e < 6; e++) {
      const A = cornerVertex(q, r, 3, e), B = cornerVertex(q, r, 4, e);
      const base = { x: (A.x + B.x) * 0.5 - c.x, z: (A.z + B.z) * 0.5 - c.z };
      const v = bandVertex(q, r, 3, e, 1);
      const p = rel(q, r, v);
      const d = Math.hypot(p.x - base.x, p.z - base.z);
      const ridge = ridgeEdges(q, r).indexOf(e) >= 0 ? 0.10 : 0;
      ok(d <= 0.15 + ridge + 1e-9, `中间环顶点位移幅度 ≤ 0.15(+岩脊 0.10) (${q},${r}) e${e} d=${d.toFixed(4)}`);
      const n = dirUnit(e + 1);
      const comp = (p.x - base.x) * n.x + (p.z - base.z) * n.z;
      if (comp > 1e-6) bandPos++; else if (comp < -1e-6) bandNeg++;
      maxBand = Math.max(maxBand, d);
    }
  }
  ok(maxBand >= 0.05, `中间环顶点噪声非零（max ${maxBand.toFixed(4)}）`);
  ok(bandPos > 0 && bandNeg > 0, `中间环噪声有正有负（外 ${bandPos} / 内 ${bandNeg}）`);

  // 末环（底面）：幅度更小，且 y 恒定
  for (const [q, r] of TILES) {
    for (let k = 0; k < 6; k++) {
      const v = cornerVertex(q, r, RING_COUNT - 1, k);
      const p = rel(q, r, v);
      const u = hexCorner(k, 1);
      const dn = p.x * u.x + p.z * u.z - radii[RING_COUNT - 1];
      const tan = -p.x * u.z + p.z * u.x;
      ok(Math.abs(dn) <= 0.04 + 1e-9, `底面角点法向幅度 ≤ 0.04 (${q},${r}) k${k} dn=${dn.toFixed(4)}`);
      ok(Math.abs(tan) <= 0.035 + 1e-9, `底面角点切向幅度 ≤ 0.035 (${q},${r}) k${k}`);
      ok(v.y === BOTTOM_Y, `底面角点 y = BOTTOM_Y (${q},${r}) k${k}`);
    }
  }
}

/* ------------------------------------------------------------------ 7) 顶面逐点一致（0.3.3） */

{
  const c = axialToWorld(0, 0);
  for (let k = 0; k < 6; k++) {
    const p = hexCorner(k, HEX_S - 0.025);
    const v = cornerVertex(0, 0, 0, k);
    ok(v.x === c.x + p.x && v.y === 0 && v.z === c.z + p.z, `顶面角点 ${k} = hexCorner(${k}, HEX_S−0.025)（逐分量一致）`);
  }
  // 顶面半径不得因噪声变大
  for (const [q, r] of TILES) {
    for (let k = 0; k < 6; k++) {
      const p = rel(q, r, cornerVertex(q, r, 0, k));
      ok(near(Math.hypot(p.x, p.z), HEX_S - 0.025, 1e-12), `顶面角点半径恒 = HEX_S−0.025 (${q},${r}) k${k}`);
    }
  }
}

/* ------------------------------------------------------------------ 8) 岩脊 */

{
  for (const [q, r] of TILES) {
    const re = ridgeEdges(q, r);
    ok(re.length === 2 || re.length === 3, `ridgeEdges(${q},${r}) = 2~3 条（实际 ${re.length}）`);
    ok(new Set(re).size === re.length, `ridgeEdges(${q},${r}) 无重复`);
    const re2 = ridgeEdges(q, r);
    ok(re.length === re2.length && re.every((e, i) => e === re2[i]), `ridgeEdges(${q},${r}) 确定性`);
  }
  // 脊边在中间环（带 3 的中段）上的顶点更靠外（聚合比较，抵消噪声）
  let ridgeSum = 0, ridgeCnt = 0, plainSum = 0, plainCnt = 0;
  for (const [q, r] of TILES) {
    const re = new Set(ridgeEdges(q, r));
    for (let e = 0; e < 6; e++) {
      const v = bandVertex(q, r, 3, e, 1);           // 带 3 的中间环顶点
      const p = rel(q, r, v);
      const rad = Math.hypot(p.x, p.z);
      if (re.has(e)) { ridgeSum += rad; ridgeCnt++; } else { plainSum += rad; plainCnt++; }
    }
  }
  const rm = ridgeSum / Math.max(1, ridgeCnt), pm = plainSum / Math.max(1, plainCnt);
  ok(ridgeCnt > 0 && plainCnt > 0, `岩脊采样：脊 ${ridgeCnt} 个 / 非脊 ${plainCnt} 个`);
  ok(rm > pm + 0.03, `脊边中间环顶点更靠外（脊 ${rm.toFixed(4)} vs 非脊 ${pm.toFixed(4)}）`);
}

/* ------------------------------------------------------------------ 9) 侧壁绕序（法线朝外） */

for (const [q, r] of TILES) {
  const wall = tileWallTris(q, r, ALL_TRUE);
  let bad = 0;
  for (const t of wall) {
    const n = normal(t);
    const cx = (t.a.x + t.b.x + t.c.x) / 3, cz = (t.a.z + t.b.z + t.c.z) / 3;
    const cc = axialToWorld(q, r);
    const ox = cx - cc.x, oz = cz - cc.z;
    const l = Math.hypot(ox, oz) || 1;
    if (n.x * (ox / l) + n.z * (oz / l) < -1e-9) bad++;
    ok(t.jit >= 0 && t.jit <= 1, '侧壁 jit ∈ [0,1]');
  }
  ok(bad === 0, `侧壁法线全部朝外 (${q},${r})，反向 ${bad} 个`);
  // 面带单调有序：草沿 → 土上 → 土下 → 岩A → 岩B（颜色层级不倒退）
  const order = [Band.Lip, Band.SoilUp, Band.SoilLow, Band.RockA, Band.RockB];
  let last = -1;
  let mono = true;
  for (const t of wall) {
    const idx = order.indexOf(t.band);
    if (idx < 0) { mono = false; break; }
    if (idx < last) { mono = false; break; }
    last = idx;
  }
  ok(mono, `侧壁面带自上而下单调（${q},${r}）`);
  ok(wall[0].band === Band.Lip, `最上一带 = Band.Lip (${q},${r})`);
}

/* ------------------------------------------------------------------ 输出 */

const out = { checks, fails: fails.length, list: fails.slice(0, 30) };
const file = process.argv[2] ?? '/tmp/island-shape.json';
try { writeFileSync(file, JSON.stringify(out, null, 2)); } catch { /* 目录不存在时忽略 */ }
if (fails.length > 0) {
  console.error(`S-25 岛屿形状（S1 六棱台几何）：${checks} 断言，失败 ${fails.length} 条`);
  for (const f of fails.slice(0, 20)) { console.error(' - ' + f); }
  process.exit(1);
}
console.log(`S-25 岛屿形状（S1 六棱台几何）：${checks} 断言全部通过（墙 72 + 底面 6 = 78/地块，顶面 6 由 Lead 写 ⇒ 84/地块 = 1.75×）`);
