tweak

test.js

@@ -9,7 +9,6 @@ import {
   NAME_TEMPLATE_WEIGHTS,
   generateTemplateName,
 } from "./names.js";
-import { adminBoundaryMetrics, majorCityCoreIntegrity } from "./qualityMetrics.js";
 
 const result = document.getElementById("result");
 const logLines = [];
@@ -29,6 +28,146 @@ function assert(condition, message) {
   }
 }
 
+function terrainBoundaryTargetForMetrics(map, i) {
+  const lu = map.landuse[i];
+  const urbanPenalty = Math.min(1, (lu === 3 ? 1.45 : lu === 2 ? 1.12 : lu === 4 ? 0.95 : lu === 7 ? 0.90 : lu === 8 ? 0.64 : lu === 5 || lu === 6 ? 0.48 : 0) + map.populationDensity[i] * 1.35);
+  const majorRiver = Math.min(1, Math.max(map.river[i] - 0.32, 0) * 1.9 + Math.max(map.flowAccum[i] - 0.38, 0) * 0.75);
+  const minorStream = Math.min(1, map.river[i] * 0.34 + map.flowAccum[i] * 0.18);
+  const ridgeDivide = Math.min(1, map.ridgeField[i] * 1.55 + Math.max(0, map.elevation[i] - 0.54) * map.ridgeField[i] * 0.95);
+  const slopeBreak = Math.min(1, map.slope[i] * 0.58 + Math.max(0, map.slope[i] - 0.32) * 0.68);
+  const highGround = Math.max(0, map.elevation[i] - 0.56) * 0.22;
+  const valleyFloorPenalty = map.valleyField[i] * (majorRiver > 0.34 ? -0.10 : -0.62);
+  return Math.max(0, Math.min(1, ridgeDivide + majorRiver * 0.88 + minorStream * 0.22 + slopeBreak + highGround + valleyFloorPenalty - urbanPenalty * 0.72));
+}
+
+function adminBoundaryMetrics(map) {
+  let borderEdges = 0;
+  let targetSum = 0;
+  let denseUrbanEdges = 0;
+  let rightAngleRuns = 0;
+  let voronoiLikeEdges = 0;
+  let lowScoreFlatEdges = 0;
+  for (let y = 1; y < MAP_H - 1; y++) {
+    for (let x = 1; x < MAP_W - 1; x++) {
+      const i = indexOf(x, y);
+      if (!map.prefectureMask[i] || map.sea[i] || map.adminId[i] < 0) continue;
+      for (const [dx, dy] of [[1, 0], [0, 1]]) {
+        const ni = indexOf(x + dx, y + dy);
+        if (!map.prefectureMask[ni] || map.sea[ni] || map.adminId[ni] < 0 || map.adminId[ni] === map.adminId[i]) continue;
+        borderEdges++;
+        const edgeTarget = (terrainBoundaryTargetForMetrics(map, i) + terrainBoundaryTargetForMetrics(map, ni)) * 0.5;
+        targetSum += edgeTarget;
+        const urban = Math.max(map.populationDensity[i], map.populationDensity[ni]) > 0.58 || [2, 3, 4, 7, 8].includes(map.landuse[i]) || [2, 3, 4, 7, 8].includes(map.landuse[ni]);
+        if (urban) denseUrbanEdges++;
+        const ca = map.adminCenters[map.adminId[i]];
+        const cb = map.adminCenters[map.adminId[ni]];
+        if (ca && cb) {
+          const mx = x + dx * 0.5;
+          const my = y + dy * 0.5;
+          const dA = Math.hypot(mx - ca.x, my - ca.y);
+          const dB = Math.hypot(mx - cb.x, my - cb.y);
+          if (Math.abs(dA - dB) < 4.2 && edgeTarget < 0.40) voronoiLikeEdges++;
+        }
+        if (edgeTarget < 0.16 && Math.max(map.slope[i], map.slope[ni]) < 0.24 && Math.max(map.ridgeField[i], map.ridgeField[ni]) < 0.28 && Math.max(map.river[i], map.river[ni]) < 0.26) {
+          lowScoreFlatEdges++;
+        }
+        const sideA = indexOf(x + (dy ? 1 : 0), y + (dx ? 1 : 0));
+        const sideB = indexOf(x - (dy ? 1 : 0), y - (dx ? 1 : 0));
+        if (map.prefectureMask[sideA] && map.prefectureMask[sideB] && !map.sea[sideA] && !map.sea[sideB]) {
+          const turnA = map.adminId[sideA] !== map.adminId[i] && map.adminId[sideA] !== map.adminId[ni];
+          const turnB = map.adminId[sideB] !== map.adminId[i] && map.adminId[sideB] !== map.adminId[ni];
+          if ((turnA || turnB) && terrainBoundaryTargetForMetrics(map, i) < 0.46) rightAngleRuns++;
+        }
+      }
+    }
+  }
+
+  const ids = new Set([...map.adminId].filter((id, i) => id >= 0 && map.prefectureMask[i] && !map.sea[i]));
+  const areaById = new Map();
+  for (let i = 0; i < map.adminId.length; i++) {
+    if (map.prefectureMask[i] && !map.sea[i] && map.adminId[i] >= 0) areaById.set(map.adminId[i], (areaById.get(map.adminId[i]) || 0) + 1);
+  }
+  const areas = [...areaById.values()].sort((a, b) => a - b);
+  const medianArea = areas.length ? areas[Math.floor(areas.length / 2)] : 1;
+  const maxArea = areas.length ? areas[areas.length - 1] : 1;
+  let disconnectedMunicipalities = 0;
+  let maxComponents = 0;
+  const seen = new Uint8Array(MAP_W * MAP_H);
+  for (const id of ids) {
+    let comps = 0;
+    seen.fill(0);
+    for (let i = 0; i < map.adminId.length; i++) {
+      if (seen[i] || map.adminId[i] !== id || !map.prefectureMask[i] || map.sea[i]) continue;
+      comps++;
+      const queue = [i];
+      seen[i] = 1;
+      for (let q = 0; q < queue.length; q++) {
+        const cur = queue[q];
+        const x = cur % MAP_W;
+        const y = Math.floor(cur / MAP_W);
+        for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
+          const nx = x + dx;
+          const ny = y + dy;
+          if (nx < 0 || ny < 0 || nx >= MAP_W || ny >= MAP_H) continue;
+          const ni = indexOf(nx, ny);
+          if (seen[ni] || map.adminId[ni] !== id || !map.prefectureMask[ni] || map.sea[ni]) continue;
+          seen[ni] = 1;
+          queue.push(ni);
+        }
+      }
+    }
+    if (comps > 1) disconnectedMunicipalities++;
+    maxComponents = Math.max(maxComponents, comps);
+  }
+
+  const centerValidCount = map.adminCenters.filter((center) => {
+    const i = indexOf(center.x, center.y);
+    return map.prefectureMask[i] && !map.sea[i] && map.adminId[i] >= 0;
+  }).length;
+
+  return {
+    borderEdges,
+    avgTarget: borderEdges ? targetSum / borderEdges : 0,
+    denseUrbanRate: borderEdges ? denseUrbanEdges / borderEdges : 0,
+    rightAngleRate: borderEdges ? rightAngleRuns / borderEdges : 0,
+    voronoiLikeRate: borderEdges ? voronoiLikeEdges / borderEdges : 0,
+    lowScoreFlatRate: borderEdges ? lowScoreFlatEdges / borderEdges : 0,
+    areaDiversity: maxArea / Math.max(1, medianArea),
+    municipalityCount: ids.size,
+    disconnectedMunicipalities,
+    maxComponents,
+    centerValidRatio: map.adminCenters.length ? centerValidCount / map.adminCenters.length : 1,
+  };
+}
+
+function majorCityCoreIntegrity(map) {
+  const majorCities = map.modernCities.filter((city) => (city.population || 0) >= 180000);
+  if (majorCities.length === 0) return 1;
+  let sum = 0;
+  let checked = 0;
+  for (const city of majorCities) {
+    const counts = new Map();
+    const r = Math.ceil(Math.max(3, city.coreRadius || 4));
+    for (let dy = -r; dy <= r; dy++) {
+      for (let dx = -r; dx <= r; dx++) {
+        const x = city.x + dx;
+        const y = city.y + dy;
+        if (x < 0 || y < 0 || x >= MAP_W || y >= MAP_H || Math.hypot(dx, dy) > r) continue;
+        const i = indexOf(x, y);
+        if (!map.prefectureMask[i] || map.sea[i]) continue;
+        if (map.landuse[i] !== 3 && map.populationDensity[i] < 0.38) continue;
+        const id = map.adminId[i];
+        if (id >= 0) counts.set(id, (counts.get(id) || 0) + 1);
+      }
+    }
+    const total = [...counts.values()].reduce((a, b) => a + b, 0);
+    if (total === 0) continue;
+    sum += Math.max(...counts.values()) / total;
+    checked++;
+  }
+  return checked ? sum / checked : 1;
+}
+
 try {
   const map = generateMap(12345);
   const other = generateMap(54321);