256 lines
15 KiB
JavaScript
256 lines
15 KiB
JavaScript
import { generateMap, MAP_W, MAP_H, indexOf } from "./mapGenerator.js";
|
|
import { CUSTOM_NAMES } from "./names.js";
|
|
import { adminBoundaryMetrics, majorCityCoreIntegrity } from "./qualityMetrics.js";
|
|
|
|
const result = document.getElementById("result");
|
|
const logLines = [];
|
|
let failed = 0;
|
|
|
|
function assert(condition, message) {
|
|
if (condition) logLines.push(`OK: ${message}`);
|
|
else {
|
|
failed += 1;
|
|
logLines.push(`NG: ${message}`);
|
|
}
|
|
}
|
|
|
|
try {
|
|
const map = generateMap(12345);
|
|
const other = generateMap(54321);
|
|
const size = MAP_W * MAP_H;
|
|
const urbanCellCount = [...map.landuse].filter((value) => value >= 2 && value <= 8).length;
|
|
const cityPopulations = map.modernCities.map((city) => city.population || 0);
|
|
const maxPopulation = Math.max(...cityPopulations);
|
|
const minPopulation = Math.min(...cityPopulations);
|
|
const landElevations = [...map.elevation].filter((_, i) => !map.sea[i]);
|
|
const meanElevation = landElevations.reduce((sum, value) => sum + value, 0) / landElevations.length;
|
|
const elevationStdDev = Math.sqrt(landElevations.reduce((sum, value) => sum + (value - meanElevation) ** 2, 0) / landElevations.length);
|
|
const modernPaths = [
|
|
...map.railways,
|
|
...map.branchRailways,
|
|
...map.externalRailways,
|
|
...(map.ringRailways || []),
|
|
...map.nationalRoads,
|
|
...(map.ringRoads || []),
|
|
...map.expressways,
|
|
...(map.ringExpressways || []),
|
|
...map.externalRoads,
|
|
...map.externalExpressways,
|
|
];
|
|
const endpointDegree = new Map();
|
|
for (const path of modernPaths) {
|
|
if (path.length < 2) continue;
|
|
for (const point of [path[0], path[path.length - 1]]) {
|
|
const key = point.join(",");
|
|
endpointDegree.set(key, (endpointDegree.get(key) || 0) + 1);
|
|
}
|
|
}
|
|
const maxModernEndpointDegree = Math.max(0, ...endpointDegree.values());
|
|
let maxCoastalElevationStep = 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.sea[i]) continue;
|
|
for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) {
|
|
const ni = indexOf(x + dx, y + dy);
|
|
if (map.sea[ni]) maxCoastalElevationStep = Math.max(maxCoastalElevationStep, Math.abs(map.elevation[i] - map.elevation[ni]));
|
|
}
|
|
}
|
|
}
|
|
let railExpressHighMountainCells = 0;
|
|
for (const path of [...map.railways, ...map.branchRailways, ...(map.ringRailways || []), ...map.externalRailways, ...map.expressways, ...(map.ringExpressways || []), ...map.externalExpressways]) {
|
|
for (const [x, y] of path) {
|
|
const i = indexOf(x, y);
|
|
if (map.elevation[i] > 0.82) railExpressHighMountainCells += 1;
|
|
}
|
|
}
|
|
let trunkHighElevationCells = 0;
|
|
for (const path of modernPaths) {
|
|
for (const [x, y] of path) {
|
|
if (map.elevation[indexOf(x, y)] > 0.72) trunkHighElevationCells += 1;
|
|
}
|
|
}
|
|
const flatPlainCells = [...map.plain].filter((value, i) => !map.sea[i] && value > 0.72 && map.slope[i] < 0.12).length;
|
|
const largeMountainCities = map.modernCities.filter((city) => {
|
|
const i = indexOf(city.x, city.y);
|
|
return (city.population || 0) >= 250000 && (map.elevation[i] > 0.66 || map.plain[i] < 0.18 || map.slope[i] > 0.88);
|
|
});
|
|
const capitalInside = map.prefecturalCapital && map.prefectureMask[indexOf(map.prefecturalCapital.x, map.prefecturalCapital.y)];
|
|
const allNameable = map.entitiesForNames || [];
|
|
const uniqueNames = new Set(allNameable.map((item) => item.name));
|
|
const duplicateNameRatio = allNameable.length ? 1 - uniqueNames.size / allNameable.length : 0;
|
|
const coastalSuffixes = ["\u6d5c", "\u6e4a", "\u6e2f", "\u6d66", "\u6d25", "\u5d0e", "\u6e7e"];
|
|
const mountainSuffixes = ["\u8c37", "\u5ce0", "\u5c3e\u6839", "\u5c71", "\u6ca2", "\u9e93"];
|
|
const farInlandCoastalNames = allNameable.filter((p) => {
|
|
const i = indexOf(p.x, p.y);
|
|
return !p.portClass && (map.coastalLowland[i] || 0) < 0.12 && coastalSuffixes.some((suffix) => p.name?.endsWith(suffix));
|
|
}).length;
|
|
const flatCoastalMountainNames = allNameable.filter((p) => {
|
|
const i = indexOf(p.x, p.y);
|
|
return (map.coastalLowland[i] || 0) > 0.35 && (map.slope[i] || 0) < 0.18 && mountainSuffixes.some((suffix) => p.name?.endsWith(suffix));
|
|
}).length;
|
|
const villageClusterMean = map.villages.length
|
|
? map.villages.reduce((sum, p) => sum + (map.settlementCluster?.[indexOf(p.x, p.y)] || 0), 0) / map.villages.length
|
|
: 0;
|
|
const meaningfulTransportNodes = [
|
|
...map.modernCities,
|
|
...map.ports,
|
|
...map.markets,
|
|
...map.externalGateways,
|
|
...map.interchanges,
|
|
...map.industrialZones,
|
|
...map.logisticsParks,
|
|
];
|
|
const endpointPaths = [
|
|
...map.railways,
|
|
...map.branchRailways,
|
|
...map.externalRailways,
|
|
...map.nationalRoads,
|
|
...map.expressways,
|
|
...map.externalRoads,
|
|
...map.externalExpressways,
|
|
...(map.icAccessRoads || []),
|
|
];
|
|
const endpointDistances = endpointPaths.flatMap((path) => path.length >= 2 ? [path[0], path[path.length - 1]] : [])
|
|
.map(([x, y]) => Math.min(...meaningfulTransportNodes.map((p) => Math.hypot(p.x - x, p.y - y))));
|
|
const saneEndpointRatio = endpointDistances.length
|
|
? endpointDistances.filter((d) => d <= 10).length / endpointDistances.length
|
|
: 1;
|
|
const adminMetrics = adminBoundaryMetrics(map);
|
|
const cityCoreIntegrity = majorCityCoreIntegrity(map);
|
|
|
|
assert(map.elevation.length === size, "elevation length matches map size");
|
|
assert(map.sea.length === size, "sea length matches map size");
|
|
assert(map.river.length === size, "river length matches map size");
|
|
assert(map.landuse.length === size, "land-use length matches map size");
|
|
assert(map.adminId.length === size, "municipal id length matches map size");
|
|
assert(map.prefectureMask.length === size, "prefecture mask length matches map size");
|
|
assert(map.populationDensity.length === size, "population density length matches map size");
|
|
assert(map.ridgeField.length === size && map.valleyField.length === size && map.flowAccum.length === size, "causal terrain fields match map size");
|
|
assert(map.erosionField.length === size && map.depositionField.length === size, "erosion and deposition fields match map size");
|
|
assert(map.settlementCluster.length === size, "settlement cluster field matches map size");
|
|
assert(Array.isArray(map.bridges) && Array.isArray(map.tunnels) && Array.isArray(map.harborWorks), "legacy bridge/tunnel arrays and harbor arrays exist");
|
|
assert(map.prefectureRegionId.length === size && Array.isArray(map.regionalPrefectureBorders), "neighbor prefecture regions exist");
|
|
assert(Array.isArray(map.tributaryRivers) && Array.isArray(map.smallStreams), "river hierarchy arrays exist");
|
|
assert(Array.isArray(map.icAccessRoads), "IC access road array exists");
|
|
assert(Array.isArray(map.satelliteCities), "satelliteCities is an array");
|
|
assert(Array.isArray(map.ringRoads) && Array.isArray(map.ringExpressways) && Array.isArray(map.ringRailways), "ring transport arrays exist");
|
|
|
|
assert(Array.isArray(map.mainRivers), "mainRivers is an array");
|
|
assert(Array.isArray(map.minorRoads), "minorRoads is an array");
|
|
assert(Array.isArray(map.externalGateways), "externalGateways is an array");
|
|
|
|
let prefectureComponents = 0;
|
|
const seenPrefecture = new Uint8Array(size);
|
|
for (let i = 0; i < size; i++) {
|
|
if (!map.prefectureMask[i] || seenPrefecture[i]) continue;
|
|
prefectureComponents++;
|
|
const queue = [i];
|
|
seenPrefecture[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 (let dy = -1; dy <= 1; dy++) {
|
|
for (let dx = -1; dx <= 1; dx++) {
|
|
if (dx === 0 && dy === 0) continue;
|
|
const nx = x + dx;
|
|
const ny = y + dy;
|
|
if (nx < 0 || ny < 0 || nx >= MAP_W || ny >= MAP_H) continue;
|
|
const ni = ny * MAP_W + nx;
|
|
if (!map.prefectureMask[ni] || seenPrefecture[ni]) continue;
|
|
seenPrefecture[ni] = 1;
|
|
queue.push(ni);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
assert(prefectureComponents === 1, "prefecture area is a single connected component");
|
|
assert(map.prefectureBorder.length > 0, "prefecture border exists");
|
|
assert(map.adminBorders.length > 0, "municipal borders exist");
|
|
assert(map.mainRivers.length > 0, "at least one major river exists");
|
|
assert(map.tributaryRivers.length > 0, "tributary river network exists");
|
|
assert(map.smallStreams.length > 0, "small stream network exists");
|
|
assert(map.harborWorks.length <= map.ports.length, "harbor works are attached to ports");
|
|
assert(map.ports.some((p) => p.portClass === "major"), "at least one major port is classified");
|
|
assert(map.ports.every((p) => ["major", "regional", "fishing", "lake"].includes(p.portClass)), "ports have explicit classes");
|
|
assert(map.externalGateways.length > 0, "external gateways exist");
|
|
assert(map.minorRoads.length > 0, "minor roads exist");
|
|
assert(map.adminCenters.length >= 12, "municipality count is sufficiently large");
|
|
assert(adminMetrics.municipalityCount >= 10, "terrain snapping preserves a reasonable municipality count");
|
|
assert(adminMetrics.centerValidRatio >= 0.95, "municipality centers remain on valid assigned land cells");
|
|
assert(adminMetrics.maxComponents <= 4, "municipal topology repair prevents excessive disconnected fragments");
|
|
assert(adminMetrics.disconnectedMunicipalities <= Math.max(2, Math.ceil(adminMetrics.municipalityCount * 0.20)), "most municipalities remain connected after terrain snapping");
|
|
assert(adminMetrics.avgTarget > 0.18, "admin borders align with terrain target features often enough");
|
|
assert(adminMetrics.denseUrbanRate < 0.42, "admin borders avoid excessive dense urban crossings");
|
|
assert(adminMetrics.rightAngleRate < 0.46, "admin borders avoid excessive unsupported stair-step artifacts");
|
|
assert(adminMetrics.voronoiLikeRate < 0.58, "admin borders are not dominated by weak-terrain center bisectors");
|
|
assert(adminMetrics.lowScoreFlatRate < 0.40, "admin borders avoid excessive low-score flat-plain cuts");
|
|
assert(adminMetrics.areaDiversity > 1.45, "municipality areas retain natural size diversity");
|
|
assert(cityCoreIntegrity >= 0.62, "major city cores remain mostly inside one municipality");
|
|
assert(urbanCellCount > 1000, "large-city urbanized cells are broad enough");
|
|
const cbdCells = [...map.landuse].filter((value) => value === 3).length;
|
|
assert(cbdCells > 0, "CBD is represented as land-use cells rather than markers");
|
|
assert(map.modernCities.every((city) => Number.isFinite(city.population) && city.population > 0), "modern cities have population properties");
|
|
assert(maxPopulation / Math.max(1, minPopulation) > 3, "city populations vary strongly");
|
|
assert(map.totalPopulation >= cityPopulations.reduce((sum, value) => sum + value, 0), "total population includes city and satellite populations");
|
|
assert(Math.max(...map.populationDensity) > 0.9, "population density is normalized and populated");
|
|
assert(elevationStdDev > 0.18, "terrain relief has sufficient contrast");
|
|
assert(maxCoastalElevationStep < 0.12, "coastline and elevation do not create cliff artifacts");
|
|
assert(railExpressHighMountainCells === 0, "railways and expressways avoid huge mountain cells");
|
|
assert(trunkHighElevationCells === 0, "trunk roads, railways, and expressways avoid high-elevation cells");
|
|
assert(flatPlainCells >= 160, "broad flat plains exist as actual low-slope cells");
|
|
assert(largeMountainCities.length === 0, "large cities are not placed on unsuitable mountain sites");
|
|
assert(capitalInside, "prefectural capital is inside the prefecture");
|
|
assert(maxModernEndpointDegree <= 10, "modern transport endpoints are not over-centralized");
|
|
assert(map.entitiesForNames.every((item) => item.id && item.name), "nameable entities have ids and names");
|
|
assert(map.entitiesForNames.every((item) => !String(item.name).includes("\uFFFD")), "generated names contain no replacement characters");
|
|
assert(duplicateNameRatio < 0.18, "generated place-name duplicates stay low");
|
|
assert(farInlandCoastalNames <= Math.max(2, Math.ceil(allNameable.length * 0.12)), "coastal suffixes are not overused far inland");
|
|
assert(flatCoastalMountainNames <= Math.max(2, Math.ceil(allNameable.length * 0.10)), "mountain suffixes are not overused on flat coastal lowlands");
|
|
assert(villageClusterMean > 0.16, "villages prefer clustered valley, basin, coastal, and agricultural cells");
|
|
assert(saneEndpointRatio >= 0.76, "transport endpoints stay near meaningful generated nodes");
|
|
if (Object.keys(CUSTOM_NAMES).length > 0) {
|
|
assert(map.entitiesForNames.every((item) => !CUSTOM_NAMES[item.id] || item.name === CUSTOM_NAMES[item.id]), "CUSTOM_NAMES override generated names");
|
|
} else {
|
|
assert(true, "CUSTOM_NAMES override hook remains available");
|
|
}
|
|
|
|
assert(
|
|
map.adminCenters.length !== other.adminCenters.length ||
|
|
map.villages.length !== other.villages.length ||
|
|
map.markets.length !== other.markets.length,
|
|
"feature counts vary between seeds"
|
|
);
|
|
|
|
const againA = generateMap(999);
|
|
const againB = generateMap(999);
|
|
assert(JSON.stringify(againA.modernCities) === JSON.stringify(againB.modernCities), "generation is deterministic for the same seed");
|
|
assert(JSON.stringify(againA.entitiesForNames.map((item) => [item.id, item.name])) === JSON.stringify(againB.entitiesForNames.map((item) => [item.id, item.name])), "generated names are deterministic for the same seed");
|
|
assert(JSON.stringify(againA.adminCenters.map((item) => [item.id, item.x, item.y, item.name])) === JSON.stringify(againB.adminCenters.map((item) => [item.id, item.x, item.y, item.name])), "municipal centers are deterministic for the same seed");
|
|
assert(JSON.stringify([...againA.adminId]) === JSON.stringify([...againB.adminId]), "municipal adminId snapping is deterministic for the same seed");
|
|
|
|
for (const seed of [101, 2026, 54321]) {
|
|
const seeded = generateMap(seed);
|
|
const metrics = adminBoundaryMetrics(seeded);
|
|
const invalidLandCells = [...seeded.adminId].filter((id, i) => seeded.prefectureMask[i] && !seeded.sea[i] && id < 0).length;
|
|
assert(invalidLandCells === 0, `seed ${seed}: every prefecture land cell has a valid adminId`);
|
|
assert(seeded.adminBorders.length > 0, `seed ${seed}: municipal borders exist`);
|
|
assert(metrics.municipalityCount >= 8, `seed ${seed}: municipality count remains reasonable`);
|
|
assert(metrics.centerValidRatio >= 0.90, `seed ${seed}: municipality centers remain valid`);
|
|
assert(metrics.maxComponents <= 5, `seed ${seed}: topology repair limits disconnected fragments`);
|
|
assert(metrics.avgTarget > 0.14, `seed ${seed}: borders retain terrain-boundary affinity`);
|
|
assert(metrics.denseUrbanRate < 0.50, `seed ${seed}: borders avoid excessive dense urban cuts`);
|
|
assert(metrics.voronoiLikeRate < 0.66, `seed ${seed}: weak-terrain Voronoi-like border ratio stays bounded`);
|
|
assert(metrics.lowScoreFlatRate < 0.50, `seed ${seed}: low-score flat border ratio stays bounded`);
|
|
assert(metrics.areaDiversity > 1.25, `seed ${seed}: municipality sizes are not overly uniform`);
|
|
assert(majorCityCoreIntegrity(seeded) >= 0.55, `seed ${seed}: major city cores remain coherent`);
|
|
assert(seeded.prefecturalCapital && seeded.adminId[indexOf(seeded.prefecturalCapital.x, seeded.prefecturalCapital.y)] >= 0, `seed ${seed}: capital municipality is not deleted`);
|
|
}
|
|
|
|
result.className = failed === 0 ? "ok" : "ng";
|
|
result.textContent = `${failed === 0 ? "All tests passed." : `${failed} tests failed.`}\n\n${logLines.join("\n")}`;
|
|
} catch (error) {
|
|
result.className = "ng";
|
|
result.textContent = String(error?.stack || error);
|
|
}
|