141 lines
6.6 KiB
JavaScript
141 lines
6.6 KiB
JavaScript
import { MAP_H, MAP_W, indexOf } from "./grid.js";
|
|
|
|
export 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));
|
|
}
|
|
|
|
export 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,
|
|
};
|
|
}
|
|
|
|
export 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;
|
|
}
|