1690 lines
73 KiB
JavaScript
1690 lines
73 KiB
JavaScript
import { INF, MAP_H, MAP_W, SIZE, MinHeap, clamp, fbm, hash2, indexOf, inside, pickEntities, rand, valueNoise, xyOf } from "./mapUtils.js";
|
|
import { distanceToNearest, influenceFromPaths, influenceFromPoints, samplePath } from "./mapGeneratorHelpers.js";
|
|
import { LANDUSE } from "./landuseCodes.js";
|
|
|
|
// Lightweight Human Geography V2
|
|
// --------------------------------
|
|
// This replaces the heavy iterative human stage with a sparse skeleton + raster
|
|
// synthesis model:
|
|
// 1. build terrain-derived human context once
|
|
// 2. place villages/towns/cities by region quotas
|
|
// 3. make sparse approximate transport paths without full-resolution A*
|
|
// 4. synthesize population and land-use fields in one raster pass
|
|
|
|
export function generateMapFeatures(seed, terrain) {
|
|
const {
|
|
elevation,
|
|
moisture,
|
|
slope,
|
|
sea,
|
|
river,
|
|
floodplain,
|
|
plain,
|
|
agriculture,
|
|
ridgeField,
|
|
valleyField,
|
|
basinField,
|
|
coastalLowland,
|
|
flowAccum,
|
|
arcSpineField,
|
|
branchRidgeField,
|
|
depositionalLowland,
|
|
alluvialFanField,
|
|
deltaField,
|
|
portSuitability,
|
|
crossingSuitability,
|
|
passSuitability,
|
|
prefectureMask,
|
|
prefectureRegionId,
|
|
naturalBarrierScore,
|
|
} = terrain;
|
|
|
|
function regionIdAt(x, y) {
|
|
if (!inside(x, y)) return -1;
|
|
const i = indexOf(x, y);
|
|
if (sea[i]) return -1;
|
|
if (prefectureMask?.[i]) return 0;
|
|
if (!prefectureRegionId) return 0;
|
|
const id = prefectureRegionId?.[i];
|
|
return id !== undefined && id >= 0 ? id : -1;
|
|
}
|
|
|
|
function inFocusedPrefecture(p) {
|
|
return Boolean(p && inside(p.x, p.y) && prefectureMask[indexOf(p.x, p.y)] && !sea[indexOf(p.x, p.y)]);
|
|
}
|
|
|
|
function localConfluenceScore(x, y) {
|
|
let arms = 0;
|
|
let strong = 0;
|
|
for (const [dx, dy] of [[1,0],[-1,0],[0,1],[0,-1],[1,1],[-1,1],[1,-1],[-1,-1]]) {
|
|
const nx = x + dx;
|
|
const ny = y + dy;
|
|
if (!inside(nx, ny)) continue;
|
|
const rv = river[indexOf(nx, ny)];
|
|
if (rv > 0.18) arms++;
|
|
if (rv > 0.34) strong++;
|
|
}
|
|
return clamp((arms >= 3 ? 0.22 : arms === 2 ? 0.09 : 0) + strong * 0.04);
|
|
}
|
|
|
|
// --- 1. Human context: one full raster pass -----------------------------
|
|
const developable = new Float32Array(SIZE);
|
|
const ruralSuitability = new Float32Array(SIZE);
|
|
const townSuitability = new Float32Array(SIZE);
|
|
const valleySettlement = new Float32Array(SIZE);
|
|
const coastalSettlement = new Float32Array(SIZE);
|
|
const confluenceField = new Float32Array(SIZE);
|
|
const barrierCost = new Float32Array(SIZE);
|
|
const corridorCost = new Float32Array(SIZE);
|
|
const settlementCluster = new Float32Array(SIZE);
|
|
const settlementScore = new Float32Array(SIZE);
|
|
|
|
for (let y = 0; y < MAP_H; y++) {
|
|
for (let x = 0; x < MAP_W; x++) {
|
|
const i = indexOf(x, y);
|
|
if (sea[i]) {
|
|
barrierCost[i] = INF;
|
|
corridorCost[i] = INF;
|
|
continue;
|
|
}
|
|
const depositional = (depositionalLowland?.[i] || 0) + (alluvialFanField?.[i] || 0) * 0.62 + (deltaField?.[i] || 0) * 0.90;
|
|
const highPenalty = Math.max(0, elevation[i] - 0.56);
|
|
const lowSlope = clamp(1 - slope[i] * 2.3);
|
|
const confluence = x > 0 && y > 0 && x < MAP_W - 1 && y < MAP_H - 1 ? localConfluenceScore(x, y) : 0;
|
|
const openPlainPotential = clamp(plain[i] * 0.68 + agriculture[i] * 0.54 + basinField[i] * 0.30 + lowSlope * 0.22 - river[i] * 0.18 - valleyField[i] * 0.08 - ridgeField[i] * 0.22 - slope[i] * 0.26);
|
|
const spine = (arcSpineField?.[i] || 0) * 0.58 + (branchRidgeField?.[i] || 0) * 0.38;
|
|
confluenceField[i] = confluence;
|
|
|
|
developable[i] = clamp(
|
|
plain[i] * 0.34 +
|
|
agriculture[i] * 0.24 +
|
|
basinField[i] * 0.24 +
|
|
valleyField[i] * 0.24 +
|
|
coastalLowland[i] * 0.18 +
|
|
depositional * 0.22 +
|
|
lowSlope * 0.10 -
|
|
slope[i] * 0.82 -
|
|
ridgeField[i] * 0.52 -
|
|
spine * 0.24 -
|
|
highPenalty * 1.14 -
|
|
floodplain[i] * 0.03
|
|
);
|
|
valleySettlement[i] = clamp(
|
|
valleyField[i] * 0.52 +
|
|
river[i] * 0.08 +
|
|
confluence * 0.38 +
|
|
depositional * 0.20 +
|
|
basinField[i] * 0.16 +
|
|
plain[i] * 0.08 +
|
|
lowSlope * 0.12 -
|
|
slope[i] * 0.54 -
|
|
ridgeField[i] * 0.30 -
|
|
spine * 0.16 -
|
|
highPenalty * 0.70 -
|
|
floodplain[i] * 0.10
|
|
);
|
|
coastalSettlement[i] = clamp(
|
|
coastalLowland[i] * 0.50 +
|
|
(portSuitability?.[i] || 0) * 0.30 +
|
|
(deltaField?.[i] || 0) * 0.20 +
|
|
plain[i] * 0.10 -
|
|
slope[i] * 0.52 -
|
|
ridgeField[i] * 0.24 -
|
|
spine * 0.12
|
|
);
|
|
const clusterNoise = 0.72 + fbm(x * 0.34 + 13, y * 0.34 - 31, seed + 7001) * 0.46 + valueNoise(x, y, seed + 7002, 8) * 0.16;
|
|
settlementCluster[i] = clamp((developable[i] * 0.42 + valleySettlement[i] * 0.12 + coastalSettlement[i] * 0.22 + agriculture[i] * 0.48 + plain[i] * 0.32 + openPlainPotential * 0.46) * clusterNoise);
|
|
ruralSuitability[i] = clamp(
|
|
agriculture[i] * 0.54 +
|
|
developable[i] * 0.30 +
|
|
valleySettlement[i] * 0.18 +
|
|
coastalSettlement[i] * 0.20 +
|
|
openPlainPotential * 0.34 +
|
|
settlementCluster[i] * 0.30 -
|
|
Math.max(0, elevation[i] - 0.64) * 0.56
|
|
);
|
|
townSuitability[i] = clamp(
|
|
developable[i] * 0.38 +
|
|
agriculture[i] * 0.18 +
|
|
valleySettlement[i] * 0.16 +
|
|
coastalSettlement[i] * 0.30 +
|
|
confluence * 0.20 +
|
|
basinField[i] * 0.18 +
|
|
plain[i] * 0.26 +
|
|
openPlainPotential * 0.44 +
|
|
settlementCluster[i] * 0.22 -
|
|
slope[i] * 0.34 -
|
|
ridgeField[i] * 0.17 -
|
|
spine * 0.10
|
|
);
|
|
settlementScore[i] = clamp(ruralSuitability[i] * 0.58 + townSuitability[i] * 0.34 + confluence * 0.10);
|
|
const naturalBarrier = naturalBarrierScore?.[i] || 0;
|
|
barrierCost[i] = 1 + slope[i] * 6.4 + ridgeField[i] * 3.2 + spine * 2.2 + highPenalty * 5.8 + river[i] * 0.25 + naturalBarrier * 1.2 - valleyField[i] * 0.55 - plain[i] * 0.30 - coastalLowland[i] * 0.14;
|
|
corridorCost[i] = Math.max(0.25, barrierCost[i] - developable[i] * 0.42 - valleySettlement[i] * 0.36 - coastalSettlement[i] * 0.12 + hash2(x, y, seed + 7011) * 0.05);
|
|
}
|
|
}
|
|
|
|
// --- region statistics ---------------------------------------------------
|
|
const regionStats = new Map();
|
|
function ensureRegion(regionId) {
|
|
let st = regionStats.get(regionId);
|
|
if (!st) {
|
|
st = {
|
|
id: regionId,
|
|
area: 0,
|
|
developableCells: 0,
|
|
developableSum: 0,
|
|
valleyCells: 0,
|
|
coastCells: 0,
|
|
townCells: 0,
|
|
plainCells: 0,
|
|
minX: MAP_W,
|
|
minY: MAP_H,
|
|
maxX: 0,
|
|
maxY: 0,
|
|
};
|
|
regionStats.set(regionId, st);
|
|
}
|
|
return st;
|
|
}
|
|
for (let y = 0; y < MAP_H; y++) {
|
|
for (let x = 0; x < MAP_W; x++) {
|
|
const i = indexOf(x, y);
|
|
if (sea[i]) continue;
|
|
const regionId = regionIdAt(x, y);
|
|
if (regionId < 0) continue;
|
|
const st = ensureRegion(regionId);
|
|
st.area++;
|
|
st.developableSum += developable[i];
|
|
if (developable[i] > 0.16) st.developableCells++;
|
|
if (valleySettlement[i] > 0.24) st.valleyCells++;
|
|
if (coastalSettlement[i] > 0.25) st.coastCells++;
|
|
if (townSuitability[i] > 0.28) st.townCells++;
|
|
if (plain[i] > 0.24) st.plainCells++;
|
|
st.minX = Math.min(st.minX, x);
|
|
st.minY = Math.min(st.minY, y);
|
|
st.maxX = Math.max(st.maxX, x);
|
|
st.maxY = Math.max(st.maxY, y);
|
|
}
|
|
}
|
|
|
|
function visibilityFactor(regionId, st) {
|
|
if (!st || st.area <= 0) return 0;
|
|
// Treat the focused prefecture and neighboring prefectures with the same
|
|
// density curve. Only genuinely clipped map-edge slivers are downscaled.
|
|
return clamp(Math.sqrt(st.area / 1900), 0.32, 1.05);
|
|
}
|
|
|
|
function pickRegionalPoints(scoreArray, {
|
|
stride = 1,
|
|
threshold = 0.25,
|
|
minDistance = 6,
|
|
totalMax = 100,
|
|
seedOffset = 0,
|
|
quotaForRegion,
|
|
predicate = () => true,
|
|
kind = "Point",
|
|
extraScore = () => 0,
|
|
}) {
|
|
const byRegion = new Map();
|
|
for (let y = 2; y < MAP_H - 2; y += stride) {
|
|
for (let x = 2; x < MAP_W - 2; x += stride) {
|
|
const i = indexOf(x, y);
|
|
if (sea[i] || !predicate(x, y, i)) continue;
|
|
const regionId = regionIdAt(x, y);
|
|
if (regionId < 0) continue;
|
|
const score = scoreArray[i] + extraScore(x, y, i) + hash2(x, y, seed + seedOffset) * 0.055;
|
|
if (score < threshold) continue;
|
|
if (!byRegion.has(regionId)) byRegion.set(regionId, []);
|
|
byRegion.get(regionId).push({ x, y, score, kind, regionId });
|
|
}
|
|
}
|
|
const out = [];
|
|
for (const [regionId, candidates] of [...byRegion.entries()].sort((a, b) => a[0] - b[0])) {
|
|
const st = regionStats.get(regionId);
|
|
const quota = quotaForRegion ? quotaForRegion(regionId, st) : 0;
|
|
if (quota <= 0) continue;
|
|
out.push(...pickEntities(candidates, {
|
|
max: quota,
|
|
minDistance,
|
|
threshold,
|
|
seed: seed + seedOffset + regionId * 1009,
|
|
jitter: 0.04,
|
|
}));
|
|
}
|
|
return out.sort((a, b) => b.score - a.score).slice(0, totalMax);
|
|
}
|
|
|
|
function pickGlobalPoints(scoreArray, { threshold, max, minDistance, seedOffset = 0, predicate = () => true, stride = 1 }) {
|
|
const candidates = [];
|
|
for (let y = 2; y < MAP_H - 2; y += stride) {
|
|
for (let x = 2; x < MAP_W - 2; x += stride) {
|
|
const i = indexOf(x, y);
|
|
if (sea[i] || !predicate(x, y, i)) continue;
|
|
const score = scoreArray[i] + hash2(x, y, seed + seedOffset) * 0.07;
|
|
if (score >= threshold) candidates.push({ x, y, score, regionId: regionIdAt(x, y) });
|
|
}
|
|
}
|
|
return pickEntities(candidates, { max, minDistance, threshold, seed: seed + seedOffset });
|
|
}
|
|
|
|
// --- 2. Sparse points ----------------------------------------------------
|
|
let ports = pickGlobalPoints(portSuitability || coastalSettlement, {
|
|
threshold: 0.30 + rand(seed, 1001) * 0.08,
|
|
max: 10,
|
|
minDistance: 13,
|
|
seedOffset: 1000,
|
|
predicate: (x, y, i) => coastalSettlement[i] > 0.14 || (portSuitability?.[i] || 0) > 0.25,
|
|
}).map((p, n) => {
|
|
const i = indexOf(p.x, p.y);
|
|
const harborPotential = (portSuitability?.[i] || 0) + coastalLowland[i] * 0.22 + (deltaField?.[i] || 0) * 0.08 - slope[i] * 0.18;
|
|
const portClass = n === 0 ? "major" : n < 3 && harborPotential > 0.34 ? "regional" : harborPotential > 0.24 ? "fishing" : "lake";
|
|
const kind = portClass === "major" ? "Major Port" : portClass === "regional" ? "Regional Port" : portClass === "lake" ? "Lake Port" : "Fishing Port";
|
|
return { ...p, harborPotential, portClass, kind, score: harborPotential };
|
|
}).sort((a, b) => b.harborPotential - a.harborPotential);
|
|
if (ports.length && !ports.some((p) => p.portClass === "major")) {
|
|
ports[0].portClass = "major";
|
|
ports[0].kind = "Major Port";
|
|
}
|
|
const commercialPorts = ports.filter((p) => p.portClass === "major" || p.portClass === "regional");
|
|
|
|
const crossings = pickGlobalPoints(crossingSuitability || confluenceField, {
|
|
threshold: 0.30 + rand(seed, 1011) * 0.06,
|
|
max: 18,
|
|
minDistance: 9,
|
|
seedOffset: 1010,
|
|
predicate: (x, y, i) => river[i] > 0.12 || confluenceField[i] > 0.09,
|
|
}).map((p) => ({ ...p, kind: "River Crossing" }));
|
|
|
|
const passes = pickGlobalPoints(passSuitability || valleySettlement, {
|
|
threshold: 0.18 + rand(seed, 1021) * 0.06,
|
|
max: 12,
|
|
minDistance: 11,
|
|
seedOffset: 1020,
|
|
predicate: (x, y, i) => elevation[i] > 0.42 && !sea[i],
|
|
}).map((p) => ({ ...p, kind: "Pass" }));
|
|
|
|
const villageScore = new Float32Array(SIZE);
|
|
for (let i = 0; i < SIZE; i++) {
|
|
if (sea[i]) continue;
|
|
villageScore[i] = clamp(ruralSuitability[i] * 0.50 + agriculture[i] * 0.48 + plain[i] * 0.42 + Math.max(0, plain[i] * 1.12 + agriculture[i] * 0.78 + basinField[i] * 0.30 - river[i] * 0.36 - valleyField[i] * 0.14 - flowAccum[i] * 0.10) * 0.58 + valleySettlement[i] * 0.06 + coastalSettlement[i] * 0.34 + settlementCluster[i] * 0.22 - river[i] * 0.10 - flowAccum[i] * 0.04);
|
|
}
|
|
let villages = pickRegionalPoints(villageScore, {
|
|
stride: 2,
|
|
threshold: 0.18 + rand(seed, 1031) * 0.030,
|
|
totalMax: 280,
|
|
minDistance: 4,
|
|
seedOffset: 1030,
|
|
kind: "Village",
|
|
quotaForRegion: (regionId, st) => {
|
|
if (!st || st.developableCells < 10) return 0;
|
|
const vf = visibilityFactor(regionId, st);
|
|
const raw = (st.developableCells / 28 + st.plainCells / 42 + st.valleyCells / 34 + st.coastCells / 32 + 3.2) * vf;
|
|
const min = st.area > 2600 ? 20 : st.area > 1400 ? 12 : st.area > 520 ? 5 : st.area > 220 ? 2 : 0;
|
|
const max = st.area > 3600 ? 72 : st.area > 2200 ? 50 : st.area > 900 ? 25 : 10;
|
|
return Math.round(clamp(raw + rand(seed, 1033 + regionId * 19) * 1.5, min, max));
|
|
},
|
|
}).map((p, n) => {
|
|
const i = indexOf(p.x, p.y);
|
|
const kind = coastalSettlement[i] > 0.36 ? "Coastal Village" : valleySettlement[i] > 0.46 ? "Valley Village" : "Village";
|
|
const population = Math.round((900 + Math.pow(rand(seed, 18000 + n * 17 + p.x * 3 + p.y), 1.30) * 9800 + ruralSuitability[i] * 4700 + agriculture[i] * 3600) / 100) * 100;
|
|
return { ...p, kind, population };
|
|
});
|
|
|
|
// Supplemental open-plain villages: broad Japanese-style farmland should not be empty
|
|
// just because it lacks a river/confluence anchor.
|
|
const openPlainVillageScore = new Float32Array(SIZE);
|
|
for (let i = 0; i < SIZE; i++) {
|
|
if (sea[i]) continue;
|
|
const open = Math.max(0, plain[i] * 0.92 + agriculture[i] * 0.72 + basinField[i] * 0.26 + (depositionalLowland?.[i] || 0) * 0.20 - river[i] * 0.22 - valleyField[i] * 0.10 - flowAccum[i] * 0.08 - slope[i] * 0.24 - ridgeField[i] * 0.14);
|
|
openPlainVillageScore[i] = clamp(open + settlementCluster[i] * 0.16 + ruralSuitability[i] * 0.18);
|
|
}
|
|
const supplementalPlainVillages = pickRegionalPoints(openPlainVillageScore, {
|
|
stride: 2,
|
|
threshold: 0.235 + rand(seed, 1036) * 0.020,
|
|
totalMax: 120,
|
|
minDistance: 5,
|
|
seedOffset: 1035,
|
|
kind: "Plain Village",
|
|
predicate: (x, y, i) => plain[i] > 0.20 && agriculture[i] > 0.16 && river[i] < 0.30 && valleyField[i] < 0.52 && slope[i] < 0.32,
|
|
quotaForRegion: (regionId, st) => {
|
|
if (!st || st.plainCells < 24) return 0;
|
|
const vf = visibilityFactor(regionId, st);
|
|
const raw = (st.plainCells / 62 + st.developableCells / 180 + 1.4) * vf;
|
|
const min = st.plainCells > 360 ? 6 : st.plainCells > 160 ? 3 : st.plainCells > 70 ? 1 : 0;
|
|
const max = st.plainCells > 720 ? 24 : st.plainCells > 360 ? 16 : st.plainCells > 140 ? 8 : 3;
|
|
return Math.round(clamp(raw + rand(seed, 1037 + regionId * 29) * 1.4, min, max));
|
|
},
|
|
extraScore: (x, y, i) => Math.max(0, plain[i] * 0.34 + agriculture[i] * 0.26 - river[i] * 0.20 - valleyField[i] * 0.12),
|
|
}).filter((p) => distanceToNearest(villages, p.x, p.y) >= 4.5)
|
|
.map((p, n) => {
|
|
const i = indexOf(p.x, p.y);
|
|
const population = Math.round((1100 + Math.pow(rand(seed, 18220 + n * 31 + p.x * 7 + p.y), 1.12) * 7600 + agriculture[i] * 3900 + plain[i] * 2200) / 100) * 100;
|
|
return { ...p, kind: "Plain Village", population };
|
|
});
|
|
villages = [...villages, ...supplementalPlainVillages];
|
|
|
|
const villageInfluence = influenceFromPoints(villages, 6, (v) => clamp((v.population || 1800) / 4200, 0.35, 1.2));
|
|
|
|
const marketScore = new Float32Array(SIZE);
|
|
for (let y = 2; y < MAP_H - 2; y++) {
|
|
for (let x = 2; x < MAP_W - 2; x++) {
|
|
const i = indexOf(x, y);
|
|
if (sea[i]) continue;
|
|
const openPlainMarket = Math.max(0, plain[i] * 0.68 + agriculture[i] * 0.52 + basinField[i] * 0.24 + (depositionalLowland?.[i] || 0) * 0.18 - river[i] * 0.16 - valleyField[i] * 0.06 - slope[i] * 0.18);
|
|
const featurePull = Math.max(
|
|
distanceToNearest(ports, x, y) < 10 ? 0.16 : 0,
|
|
distanceToNearest(crossings, x, y) < 6 ? 0.035 : 0,
|
|
confluenceField[i] * 0.08
|
|
);
|
|
const valleyMouth = valleyField[i] > 0.22 && (plain[i] > 0.22 || basinField[i] > 0.18 || coastalLowland[i] > 0.18) ? 0.14 : 0;
|
|
marketScore[i] = clamp(
|
|
townSuitability[i] * 0.50 +
|
|
agriculture[i] * 0.30 +
|
|
plain[i] * 0.28 +
|
|
openPlainMarket * 0.74 +
|
|
coastalSettlement[i] * 0.22 +
|
|
villageInfluence[i] * 0.28 +
|
|
featurePull +
|
|
valleyMouth +
|
|
basinField[i] * 0.14 +
|
|
plain[i] * 0.22 +
|
|
coastalLowland[i] * 0.08 -
|
|
slope[i] * 0.18 -
|
|
ridgeField[i] * 0.08 -
|
|
river[i] * 0.08 -
|
|
flowAccum[i] * 0.035
|
|
);
|
|
}
|
|
}
|
|
|
|
let markets = pickRegionalPoints(marketScore, {
|
|
stride: 2,
|
|
threshold: 0.245 + rand(seed, 1041) * 0.035,
|
|
totalMax: 110,
|
|
minDistance: 6,
|
|
seedOffset: 1040,
|
|
kind: "Market Town",
|
|
quotaForRegion: (regionId, st) => {
|
|
if (!st || st.townCells < 8) return 0;
|
|
const vf = visibilityFactor(regionId, st);
|
|
const raw = (st.developableCells / 92 + st.plainCells / 108 + st.valleyCells / 92 + st.coastCells / 72 + 2.7) * vf;
|
|
const min = st.area > 2600 ? 9 : st.area > 1200 ? 5 : st.area > 520 ? 2 : 0;
|
|
const max = st.area > 3600 ? 30 : st.area > 2200 ? 22 : st.area > 800 ? 10 : 5;
|
|
return Math.round(clamp(raw + rand(seed, 1043 + regionId * 23) * 0.8, min, max));
|
|
},
|
|
extraScore: (x, y, i) => (distanceToNearest(commercialPorts, x, y) < 10 ? 0.12 : 0) + coastalSettlement[i] * 0.08 + Math.max(0, plain[i] * 0.32 + agriculture[i] * 0.20 - river[i] * 0.16) * 0.09 + confluenceField[i] * 0.035,
|
|
}).map((p, n) => {
|
|
const i = indexOf(p.x, p.y);
|
|
const kind = coastalSettlement[i] > 0.38 && distanceToNearest(ports, p.x, p.y) < 11 ? "Port Town" : valleySettlement[i] > 0.48 ? "Valley Market Town" : "Market Town";
|
|
const population = Math.round((9000 + Math.pow(rand(seed, 18100 + n * 19 + p.x * 5 + p.y), 1.02) * 70000 + marketScore[i] * 40000 + villageInfluence[i] * 7800 + Math.max(0, plain[i] * 0.48 + agriculture[i] * 0.30 + basinField[i] * 0.18 - river[i] * 0.14) * 22000 + coastalSettlement[i] * 12000) / 1000) * 1000;
|
|
return { ...p, kind, population };
|
|
});
|
|
|
|
const openPlainMarketScore = new Float32Array(SIZE);
|
|
for (let i = 0; i < SIZE; i++) {
|
|
if (sea[i]) continue;
|
|
const open = Math.max(0, plain[i] * 0.86 + agriculture[i] * 0.64 + basinField[i] * 0.28 + (depositionalLowland?.[i] || 0) * 0.22 - river[i] * 0.20 - valleyField[i] * 0.10 - flowAccum[i] * 0.08 - slope[i] * 0.24 - ridgeField[i] * 0.16);
|
|
openPlainMarketScore[i] = clamp(open + townSuitability[i] * 0.20 + villageInfluence[i] * 0.18 + settlementCluster[i] * 0.12);
|
|
}
|
|
const supplementalPlainMarkets = pickRegionalPoints(openPlainMarketScore, {
|
|
stride: 2,
|
|
threshold: 0.335 + rand(seed, 1046) * 0.025,
|
|
totalMax: 55,
|
|
minDistance: 9,
|
|
seedOffset: 1045,
|
|
kind: "Plain Market Town",
|
|
predicate: (x, y, i) => plain[i] > 0.22 && agriculture[i] > 0.18 && river[i] < 0.28 && valleyField[i] < 0.50 && slope[i] < 0.30,
|
|
quotaForRegion: (regionId, st) => {
|
|
if (!st || st.plainCells < 60) return 0;
|
|
const vf = visibilityFactor(regionId, st);
|
|
const raw = (st.plainCells / 260 + st.developableCells / 520 + 0.45) * vf;
|
|
const min = st.plainCells > 520 ? 2 : st.plainCells > 220 ? 1 : 0;
|
|
const max = st.plainCells > 900 ? 8 : st.plainCells > 420 ? 5 : st.plainCells > 160 ? 2 : 1;
|
|
return Math.round(clamp(raw + rand(seed, 1047 + regionId * 31) * 0.9, min, max));
|
|
},
|
|
extraScore: (x, y, i) => Math.max(0, plain[i] * 0.24 + agriculture[i] * 0.18 - river[i] * 0.14 - valleyField[i] * 0.08),
|
|
}).filter((p) => distanceToNearest(markets, p.x, p.y) >= 8.5 && distanceToNearest(villages, p.x, p.y) >= 3.5)
|
|
.map((p, n) => {
|
|
const i = indexOf(p.x, p.y);
|
|
const population = Math.round((10000 + Math.pow(rand(seed, 18340 + n * 37 + p.x * 11 + p.y), 1.02) * 52000 + openPlainMarketScore[i] * 26000 + agriculture[i] * 9000 + plain[i] * 8000) / 1000) * 1000;
|
|
return { ...p, kind: "Plain Market Town", population };
|
|
});
|
|
markets = [...markets, ...supplementalPlainMarkets];
|
|
|
|
const defenseScore = new Float32Array(SIZE);
|
|
for (let i = 0; i < SIZE; i++) {
|
|
if (sea[i]) continue;
|
|
defenseScore[i] = clamp(
|
|
confluenceField[i] * 0.38 +
|
|
townSuitability[i] * 0.16 +
|
|
ridgeField[i] * clamp(1 - Math.abs(elevation[i] - 0.52) / 0.25) * 0.42 +
|
|
plain[i] * 0.08 -
|
|
floodplain[i] * 0.36 -
|
|
coastalLowland[i] * 0.08
|
|
);
|
|
}
|
|
const castles = pickGlobalPoints(defenseScore, {
|
|
threshold: 0.34 + rand(seed, 1051) * 0.06,
|
|
max: 5,
|
|
minDistance: 16,
|
|
seedOffset: 1050,
|
|
}).map((p) => ({
|
|
...p,
|
|
kind: elevation[indexOf(p.x, p.y)] > 0.55 ? "Mountain Castle" : elevation[indexOf(p.x, p.y)] > 0.38 ? "Hilltop Castle" : "Flatland Castle",
|
|
}));
|
|
|
|
const castleTowns = castles.map((c, n) => {
|
|
const near = markets.slice().sort((a, b) => Math.hypot(a.x - c.x, a.y - c.y) - Math.hypot(b.x - c.x, b.y - c.y))[0];
|
|
const x = near && Math.hypot(near.x - c.x, near.y - c.y) < 10 ? near.x : c.x;
|
|
const y = near && Math.hypot(near.x - c.x, near.y - c.y) < 10 ? near.y : c.y;
|
|
return { x, y, score: c.score, kind: "Castle Town", population: 12000 + Math.round(rand(seed, 1060 + n) * 22000 / 1000) * 1000, regionId: regionIdAt(x, y) };
|
|
});
|
|
|
|
// --- 3. Cities by region, without detailed urban flood-fill --------------
|
|
function estimateUrbanCapacity(p, radius = 22, densityBias = 1.0) {
|
|
if (!p || !inside(p.x, p.y)) return 0;
|
|
const centerRegion = regionIdAt(p.x, p.y);
|
|
let capacity = 0;
|
|
const r = Math.ceil(radius);
|
|
for (let dy = -r; dy <= r; dy++) {
|
|
for (let dx = -r; dx <= r; dx++) {
|
|
const x = p.x + dx;
|
|
const y = p.y + dy;
|
|
if (!inside(x, y)) continue;
|
|
const i = indexOf(x, y);
|
|
if (sea[i]) continue;
|
|
if (centerRegion >= 0 && regionIdAt(x, y) !== centerRegion) continue;
|
|
const d = Math.hypot(dx, dy);
|
|
if (d > radius) continue;
|
|
const dev = developable[i];
|
|
if (dev < 0.04) continue;
|
|
const radial = clamp(1 - d / Math.max(1, radius));
|
|
const terrainMultiplier = clamp(0.60 + plain[i] * 0.48 + agriculture[i] * 0.22 + basinField[i] * 0.28 + coastalLowland[i] * 0.18 + valleyField[i] * 0.08 - slope[i] * 0.42 - ridgeField[i] * 0.18, 0.26, 1.38);
|
|
capacity += dev * (900 + 6200 * Math.pow(radial, 1.25)) * terrainMultiplier * densityBias;
|
|
}
|
|
}
|
|
return Math.max(26000, Math.round(capacity / 1000) * 1000);
|
|
}
|
|
|
|
const urbanCandidates = [
|
|
...markets.map((p) => ({ ...p, candidateKind: "town" })),
|
|
...castleTowns.map((p) => ({ ...p, candidateKind: "castleTown" })),
|
|
...commercialPorts.map((p) => ({ ...p, candidateKind: "port" })),
|
|
...crossings.filter((p) => confluenceField[indexOf(p.x, p.y)] > 0.12).map((p) => ({ ...p, candidateKind: "crossing" })),
|
|
];
|
|
|
|
const cityCandidateByRegion = new Map();
|
|
for (const p of urbanCandidates) {
|
|
const i = indexOf(p.x, p.y);
|
|
const regionId = regionIdAt(p.x, p.y);
|
|
if (regionId < 0) continue;
|
|
const st = regionStats.get(regionId);
|
|
const cityRadius = st && st.area > 2400 ? 30 : st && st.area > 900 ? 26 : 22;
|
|
const capacity = estimateUrbanCapacity(p, cityRadius, p.candidateKind === "town" ? 1.14 : p.candidateKind === "port" ? 1.10 : 1.06);
|
|
const score =
|
|
Math.log10(capacity + 1) * 0.72 +
|
|
townSuitability[i] * 1.40 +
|
|
developable[i] * 1.05 +
|
|
confluenceField[i] * 0.22 +
|
|
(p.candidateKind === "port" ? 0.48 : 0) +
|
|
(p.candidateKind === "castleTown" ? 0.22 : 0) +
|
|
hash2(p.x, p.y, seed + 12000) * 0.16;
|
|
if (!cityCandidateByRegion.has(regionId)) cityCandidateByRegion.set(regionId, []);
|
|
cityCandidateByRegion.get(regionId).push({ ...p, score, capacity, regionId });
|
|
}
|
|
|
|
const modernCities = [];
|
|
const usedCitySites = [];
|
|
for (const [regionId, list] of [...cityCandidateByRegion.entries()].sort((a, b) => a[0] - b[0])) {
|
|
const st = regionStats.get(regionId);
|
|
if (!st || st.developableCells < 30) continue;
|
|
const vf = visibilityFactor(regionId, st);
|
|
const maxCities = clamp(
|
|
Math.round((st.developableCells / 560 + 1.15) * vf + rand(seed, 12100 + regionId * 17) * 1.4),
|
|
(st.area > 900 || st.developableCells > 180) ? 1 : 0,
|
|
st.area > 3600 ? 6 : st.area > 2200 ? 4 : st.area > 900 ? 3 : 1
|
|
);
|
|
const selected = pickEntities(list, {
|
|
max: maxCities,
|
|
minDistance: 17,
|
|
threshold: 0,
|
|
seed: seed + 12110 + regionId * 313,
|
|
jitter: 0.02,
|
|
});
|
|
for (const p of selected) {
|
|
if (usedCitySites.some((q) => Math.hypot(q.x - p.x, q.y - p.y) < 12)) continue;
|
|
usedCitySites.push(p);
|
|
modernCities.push(p);
|
|
}
|
|
}
|
|
|
|
// No focused-prefecture fallback: all prefecture regions use the same city
|
|
// selection rules, so the highlighted region is not overwritten after the
|
|
// regional pass.
|
|
|
|
modernCities.sort((a, b) => b.capacity - a.capacity || b.score - a.score);
|
|
for (const [rank, city] of modernCities.entries()) {
|
|
const isFirstInRegion = !modernCities.slice(0, rank).some((c) => c.regionId === city.regionId);
|
|
const isPrefecturalCapital = inFocusedPrefecture(city) && !modernCities.slice(0, rank).some((c) => c.isPrefecturalCapital);
|
|
const isRegionalCapital = isFirstInRegion;
|
|
const rawPop = isRegionalCapital
|
|
? 300000 + rand(seed, 12201 + city.regionId * 17) * 740000
|
|
: 68000 + Math.pow(rand(seed, 12202 + rank * 19 + city.x), 0.62) * 430000;
|
|
const capMultiplier = isRegionalCapital ? 1.68 : 1.28;
|
|
const population = Math.round(Math.min(rawPop, city.capacity * capMultiplier) / 1000) * 1000;
|
|
city.population = Math.max(isRegionalCapital ? 260000 : 52000, population);
|
|
city.isPrefecturalCapital = isPrefecturalCapital;
|
|
city.isRegionalCapital = isRegionalCapital;
|
|
city.rank = isPrefecturalCapital ? "Prefectural Capital" : isRegionalCapital ? "Regional Capital" : city.population >= 200000 ? "Regional City" : "Local City";
|
|
city.kind = city.rank;
|
|
city.urbanRadius = clamp(5.8 + Math.sqrt(city.population) / 72, 8, isRegionalCapital ? 34 : 24);
|
|
city.coreRadius = clamp(1.8 + Math.sqrt(city.population) / 380, 2.2, isRegionalCapital ? 6.5 : 5.6);
|
|
city.sprawlRadius = clamp(city.urbanRadius * (isRegionalCapital ? 1.45 : city.population >= 120000 ? 1.28 : 1.15), city.urbanRadius + 2, isRegionalCapital ? 44 : 30);
|
|
city.urbanWeight = clamp(0.95 + Math.log10(Math.max(10000, city.population)) * 0.29, 1.08, 2.5);
|
|
}
|
|
|
|
function cityPopulationCap(city) {
|
|
const radius = city?.isRegionalCapital ? 29 : city?.population >= 350000 ? 26 : 18;
|
|
const bias = city?.isRegionalCapital ? 1.12 : 1.0;
|
|
return estimateUrbanCapacity(city, radius, bias);
|
|
}
|
|
|
|
// --- 4. Field-derived transport corridors -------------------------------
|
|
const preliminaryUrbanInfluence = influenceFromPoints(modernCities, 18, (c) => clamp((c.population || 60000) / 260000, 0.55, 2.0));
|
|
const preliminaryTownInfluence = influenceFromPoints([...markets, ...commercialPorts], 10, (p) => p.portClass === "major" ? 1.35 : clamp((p.population || 12000) / 36000, 0.42, 1.1));
|
|
const preliminaryVillageInfluence = influenceFromPoints(villages, 7, (v) => clamp((v.population || 1800) / 5200, 0.22, 0.9));
|
|
const settlementDemand = new Float32Array(SIZE);
|
|
const urbanEdge = new Float32Array(SIZE);
|
|
const logisticsPreSuitability = new Float32Array(SIZE);
|
|
|
|
for (let y = 0; y < MAP_H; y++) {
|
|
for (let x = 0; x < MAP_W; x++) {
|
|
const i = indexOf(x, y);
|
|
if (sea[i]) continue;
|
|
const density = clamp(preliminaryUrbanInfluence[i] * 0.62 + preliminaryTownInfluence[i] * 0.34 + preliminaryVillageInfluence[i] * 0.16);
|
|
settlementDemand[i] = density;
|
|
urbanEdge[i] = clamp(1 - Math.abs(density - 0.46) / 0.32);
|
|
logisticsPreSuitability[i] = clamp(
|
|
agriculture[i] * 0.30 +
|
|
plain[i] * 0.24 +
|
|
basinField[i] * 0.14 +
|
|
coastalLowland[i] * 0.12 +
|
|
preliminaryTownInfluence[i] * 0.18 +
|
|
urbanEdge[i] * 0.34 -
|
|
preliminaryUrbanInfluence[i] * 0.20 -
|
|
slope[i] * 0.50 -
|
|
ridgeField[i] * 0.32
|
|
);
|
|
}
|
|
}
|
|
|
|
function buildTransportCostFields() {
|
|
const expressway = new Float32Array(SIZE);
|
|
const rail = new Float32Array(SIZE);
|
|
const national = new Float32Array(SIZE);
|
|
const local = new Float32Array(SIZE);
|
|
const expresswayPotential = new Float32Array(SIZE);
|
|
const railPotential = new Float32Array(SIZE);
|
|
const nationalPotential = new Float32Array(SIZE);
|
|
const localPotential = new Float32Array(SIZE);
|
|
|
|
for (let y = 0; y < MAP_H; y++) {
|
|
for (let x = 0; x < MAP_W; x++) {
|
|
const i = indexOf(x, y);
|
|
if (sea[i]) {
|
|
expressway[i] = rail[i] = national[i] = local[i] = INF;
|
|
continue;
|
|
}
|
|
if (elevation[i] > 0.72) {
|
|
expressway[i] = rail[i] = national[i] = INF;
|
|
local[i] = Math.max(2.8, 1.4 + slope[i] * 2.2 + ridgeField[i] * 1.4);
|
|
continue;
|
|
}
|
|
const density = settlementDemand[i];
|
|
const mediumDensity = clamp(1 - Math.abs(density - 0.42) / 0.30);
|
|
const highDensity = clamp((density - 0.32) / 0.50);
|
|
const lowland = clamp(plain[i] * 0.48 + basinField[i] * 0.28 + valleyField[i] * 0.24 + coastalLowland[i] * 0.26 + agriculture[i] * 0.16);
|
|
const pass = passSuitability?.[i] || 0;
|
|
const crossing = crossingSuitability?.[i] || 0;
|
|
const waterCrossingPenalty = river[i] > 0.18 ? (1 - crossing) * (0.60 + river[i] * 1.1) : 0;
|
|
const highMountain = clamp((elevation[i] - 0.58) * 2.6 + ridgeField[i] * 0.65);
|
|
const denseCorePenalty = clamp((density - 0.66) / 0.28);
|
|
const openPlainParallelPenalty = clamp(plain[i] * 0.48 + agriculture[i] * 0.26 - density * 0.20 - valleyField[i] * 0.20 - coastalLowland[i] * 0.12);
|
|
|
|
expresswayPotential[i] = clamp(
|
|
mediumDensity * 0.62 +
|
|
urbanEdge[i] * 0.38 +
|
|
logisticsPreSuitability[i] * 0.54 +
|
|
lowland * 0.36 +
|
|
agriculture[i] * 0.16 -
|
|
denseCorePenalty * 0.54 -
|
|
slope[i] * 0.64 -
|
|
highMountain * 0.58 -
|
|
river[i] * 0.14
|
|
);
|
|
railPotential[i] = clamp(
|
|
highDensity * 0.80 +
|
|
preliminaryTownInfluence[i] * 0.22 +
|
|
lowland * 0.46 +
|
|
valleyField[i] * 0.22 +
|
|
coastalLowland[i] * 0.22 -
|
|
slope[i] * 1.05 -
|
|
highMountain * 0.82 -
|
|
ridgeField[i] * 0.34
|
|
);
|
|
nationalPotential[i] = clamp(
|
|
density * 0.46 +
|
|
preliminaryTownInfluence[i] * 0.32 +
|
|
preliminaryVillageInfluence[i] * 0.20 +
|
|
agriculture[i] * 0.24 +
|
|
valleyField[i] * 0.28 +
|
|
coastalLowland[i] * 0.26 +
|
|
pass * 0.18 +
|
|
crossing * 0.18 -
|
|
slope[i] * 0.36 -
|
|
ridgeField[i] * 0.18
|
|
);
|
|
localPotential[i] = clamp(
|
|
preliminaryVillageInfluence[i] * 0.52 +
|
|
agriculture[i] * 0.38 +
|
|
coastalSettlement[i] * 0.30 +
|
|
valleySettlement[i] * 0.30 +
|
|
developable[i] * 0.18 -
|
|
slope[i] * 0.26 -
|
|
ridgeField[i] * 0.10
|
|
);
|
|
|
|
expressway[i] = Math.max(0.18, 1.45 - expresswayPotential[i] * 1.06 + denseCorePenalty * 1.25 + slope[i] * 3.5 + highMountain * 2.9 + waterCrossingPenalty * 1.4 + openPlainParallelPenalty * 0.10 + hash2(x, y, seed + 13301) * 0.05);
|
|
rail[i] = Math.max(0.16, 1.38 - railPotential[i] * 1.08 + slope[i] * 5.6 + highMountain * 4.2 + waterCrossingPenalty * 1.1 + hash2(x, y, seed + 13302) * 0.04);
|
|
national[i] = Math.max(0.16, 1.22 - nationalPotential[i] * 0.88 + slope[i] * 1.65 + ridgeField[i] * 0.72 + Math.max(0, elevation[i] - 0.68) * 1.2 - pass * 0.30 + waterCrossingPenalty * 0.72 + hash2(x, y, seed + 13303) * 0.06);
|
|
local[i] = Math.max(0.14, 1.10 - localPotential[i] * 0.88 + slope[i] * 1.05 + ridgeField[i] * 0.42 + Math.max(0, elevation[i] - 0.72) * 0.90 + waterCrossingPenalty * 0.45 + hash2(x, y, seed + 13304) * 0.08);
|
|
}
|
|
}
|
|
return { expressway, rail, national, local, expresswayPotential, railPotential, nationalPotential, localPotential };
|
|
}
|
|
|
|
const transportFields = buildTransportCostFields();
|
|
|
|
function chooseCorridorSeeds(potentialField, spacing, maxCount, threshold, predicate = () => true, seedOffset = 0) {
|
|
const candidates = [];
|
|
for (let y = 3; y < MAP_H - 3; y += 2) {
|
|
for (let x = 3; x < MAP_W - 3; x += 2) {
|
|
const i = indexOf(x, y);
|
|
if (sea[i] || !predicate(x, y, i)) continue;
|
|
const score = potentialField[i] + hash2(x, y, seed + seedOffset) * 0.055;
|
|
if (score >= threshold) candidates.push({ x, y, score, regionId: regionIdAt(x, y) });
|
|
}
|
|
}
|
|
return pickEntities(candidates, { max: maxCount, minDistance: spacing, threshold, seed: seed + seedOffset, jitter: 0.03 });
|
|
}
|
|
|
|
function corridorAllowance(i) {
|
|
return clamp(settlementDemand[i] * 0.58 + valleyField[i] * 0.42 + coastalLowland[i] * 0.36 - plain[i] * 0.18 - agriculture[i] * 0.14);
|
|
}
|
|
|
|
function traceCorridorByCost(start, goalRegionPredicate, costField, penaltyField, options = {}) {
|
|
if (!start || !inside(start.x, start.y)) return [];
|
|
const startIndex = indexOf(start.x, start.y);
|
|
if (sea[startIndex] || costField[startIndex] >= INF) return [];
|
|
const score = new Float32Array(SIZE);
|
|
const cameFrom = new Int32Array(SIZE);
|
|
const closed = new Uint8Array(SIZE);
|
|
score.fill(INF);
|
|
cameFrom.fill(-1);
|
|
const heap = new MinHeap();
|
|
score[startIndex] = 0;
|
|
heap.push({ i: startIndex, f: 0 });
|
|
const curvePenalty = options.curvePenalty ?? 0.12;
|
|
const penaltyStrength = options.penaltyStrength ?? 1.0;
|
|
const sameRegion = options.regionId ?? regionIdAt(start.x, start.y);
|
|
const minGoalDistance = options.minGoalDistance ?? 18;
|
|
const maxExpanded = options.maxExpanded ?? SIZE * 2;
|
|
let goalIndex = -1;
|
|
let expanded = 0;
|
|
|
|
while (heap.length && expanded++ < maxExpanded) {
|
|
const current = heap.pop();
|
|
if (!current || closed[current.i]) continue;
|
|
closed[current.i] = 1;
|
|
const [cx, cy] = xyOf(current.i);
|
|
if (current.i !== startIndex && Math.hypot(cx - start.x, cy - start.y) >= minGoalDistance && goalRegionPredicate(cx, cy, current.i)) {
|
|
goalIndex = current.i;
|
|
break;
|
|
}
|
|
for (let dy = -1; dy <= 1; dy++) {
|
|
for (let dx = -1; dx <= 1; dx++) {
|
|
if (!dx && !dy) continue;
|
|
const nx = cx + dx;
|
|
const ny = cy + dy;
|
|
if (!inside(nx, ny)) continue;
|
|
const ni = indexOf(nx, ny);
|
|
if (closed[ni] || sea[ni] || costField[ni] >= INF) continue;
|
|
if (sameRegion >= 0 && options.keepRegion !== false && regionIdAt(nx, ny) !== sameRegion) continue;
|
|
const prev = cameFrom[current.i];
|
|
let turn = 0;
|
|
if (prev >= 0) {
|
|
const [px, py] = xyOf(prev);
|
|
const ax = cx - px;
|
|
const ay = cy - py;
|
|
turn = Math.abs(ax * dy - ay * dx) > 0 ? curvePenalty : 0;
|
|
}
|
|
const existing = penaltyField?.[ni] || 0;
|
|
const antiConcentration = existing * penaltyStrength * (1 - corridorAllowance(ni) * 0.72);
|
|
const nd = score[current.i] + (costField[ni] + antiConcentration + turn) * Math.hypot(dx, dy);
|
|
if (nd < score[ni]) {
|
|
score[ni] = nd;
|
|
cameFrom[ni] = current.i;
|
|
heap.push({ i: ni, f: nd });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (goalIndex < 0) return [];
|
|
const path = [];
|
|
for (let p = goalIndex; p >= 0; p = cameFrom[p]) {
|
|
path.push(xyOf(p));
|
|
if (p === startIndex) break;
|
|
}
|
|
return path.reverse();
|
|
}
|
|
|
|
function addCorridorInfluencePenalty(penaltyField, corridor, radius = 7, strength = 0.35) {
|
|
for (const [x, y] of corridor || []) {
|
|
for (let dy = -radius; dy <= radius; dy++) {
|
|
for (let dx = -radius; dx <= radius; dx++) {
|
|
const nx = x + dx;
|
|
const ny = y + dy;
|
|
if (!inside(nx, ny)) continue;
|
|
const d = Math.hypot(dx, dy);
|
|
if (d > radius) continue;
|
|
const i = indexOf(nx, ny);
|
|
if (sea[i]) continue;
|
|
const openPlain = clamp(plain[i] * 0.54 + agriculture[i] * 0.34 - settlementDemand[i] * 0.24 - valleyField[i] * 0.22 - coastalLowland[i] * 0.18);
|
|
const allowParallel = corridorAllowance(i);
|
|
penaltyField[i] = Math.max(penaltyField[i], strength * (1 - d / radius) * (0.48 + openPlain * 1.15 - allowParallel * 0.42));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function endpointFromPath(path) {
|
|
const p = path?.[path.length - 1];
|
|
return p ? { x: p[0], y: p[1], regionId: regionIdAt(p[0], p[1]) } : null;
|
|
}
|
|
|
|
function generateCorridorsFromField({ potentialField, costField, spacing, maxCount, threshold, minLength, penaltyRadius, penaltyStrength, curvePenalty, seedOffset, startPredicate, goalPredicate }) {
|
|
const paths = [];
|
|
const penaltyField = new Float32Array(SIZE);
|
|
const seeds = chooseCorridorSeeds(potentialField, spacing, maxCount * 2, threshold, startPredicate, seedOffset);
|
|
const usedEndpoints = [];
|
|
for (const start of seeds) {
|
|
if (paths.length >= maxCount) break;
|
|
if (distanceToNearest(usedEndpoints, start.x, start.y) < spacing * 0.55) continue;
|
|
const path = traceCorridorByCost(
|
|
start,
|
|
(x, y, i) => goalPredicate(start, x, y, i, usedEndpoints),
|
|
costField,
|
|
penaltyField,
|
|
{ curvePenalty, penaltyStrength: penaltyStrength * 2.2, minGoalDistance: minLength, regionId: start.regionId }
|
|
);
|
|
if (path.length < minLength) continue;
|
|
paths.push(path);
|
|
usedEndpoints.push(start);
|
|
const end = endpointFromPath(path);
|
|
if (end) usedEndpoints.push(end);
|
|
addCorridorInfluencePenalty(penaltyField, path, penaltyRadius, penaltyStrength);
|
|
}
|
|
return paths;
|
|
}
|
|
|
|
function rasterizeNetworkComponents(paths, mode, potentialField) {
|
|
const occupied = new Uint8Array(SIZE);
|
|
for (const path of paths) {
|
|
for (const [x, y] of path || []) {
|
|
if (inside(x, y) && !sea[indexOf(x, y)]) occupied[indexOf(x, y)] = 1;
|
|
}
|
|
}
|
|
const componentId = new Int32Array(SIZE);
|
|
componentId.fill(-1);
|
|
const components = [];
|
|
for (let i = 0; i < SIZE; i++) {
|
|
if (!occupied[i] || componentId[i] >= 0) continue;
|
|
const id = components.length;
|
|
const queue = [i];
|
|
const cells = [];
|
|
const boundary = [];
|
|
componentId[i] = id;
|
|
for (let q = 0; q < queue.length; q++) {
|
|
const cur = queue[q];
|
|
cells.push(cur);
|
|
const x = cur % MAP_W;
|
|
const y = Math.floor(cur / MAP_W);
|
|
let edge = false;
|
|
for (let dy = -1; dy <= 1; dy++) {
|
|
for (let dx = -1; dx <= 1; dx++) {
|
|
if (!dx && !dy) continue;
|
|
const nx = x + dx;
|
|
const ny = y + dy;
|
|
if (!inside(nx, ny)) { edge = true; continue; }
|
|
const ni = indexOf(nx, ny);
|
|
if (!occupied[ni]) {
|
|
edge = true;
|
|
continue;
|
|
}
|
|
if (componentId[ni] < 0) {
|
|
componentId[ni] = id;
|
|
queue.push(ni);
|
|
}
|
|
}
|
|
}
|
|
if (edge) boundary.push({ x, y, i: cur });
|
|
}
|
|
let lengthScore = 0;
|
|
let densityScore = 0;
|
|
let townScore = 0;
|
|
let logisticsScore = 0;
|
|
let capitalScore = 0;
|
|
const sampleStride = Math.max(1, Math.floor(cells.length / 80));
|
|
for (let c = 0; c < cells.length; c += sampleStride) {
|
|
const ci = cells[c];
|
|
const x = ci % MAP_W;
|
|
const y = Math.floor(ci / MAP_W);
|
|
lengthScore += sampleStride;
|
|
densityScore += settlementDemand[ci] * sampleStride;
|
|
logisticsScore += logisticsPreSuitability[ci] * sampleStride;
|
|
for (const p of [...modernCities, ...markets]) {
|
|
const d = Math.hypot(p.x - x, p.y - y);
|
|
if (d <= 9) townScore += ((p.population || 8000) / 50000) * (1 - d / 9);
|
|
}
|
|
for (const cty of modernCities) {
|
|
if (!cty.isPrefecturalCapital) continue;
|
|
const d = Math.hypot(cty.x - x, cty.y - y);
|
|
if (d <= 14) capitalScore += 5.0 * (1 - d / 14);
|
|
}
|
|
}
|
|
const importance =
|
|
Math.sqrt(lengthScore) * 1.20 +
|
|
densityScore * 0.38 +
|
|
townScore * 0.55 +
|
|
logisticsScore * 0.24 +
|
|
capitalScore;
|
|
components.push({ id, mode, cells, boundary, importance, length: cells.length, repairCount: 0, potential: cells.reduce((sum, ci) => sum + (potentialField?.[ci] || 0), 0) / Math.max(1, cells.length) });
|
|
}
|
|
return { occupied, componentId, components };
|
|
}
|
|
|
|
function componentAnchor(component, target, costField, usedAnchors = []) {
|
|
if (!component?.boundary?.length) return null;
|
|
let best = null;
|
|
let bestScore = INF;
|
|
const stride = Math.max(1, Math.floor(component.boundary.length / 90));
|
|
for (let k = 0; k < component.boundary.length; k += stride) {
|
|
const p = component.boundary[k];
|
|
if (costField[p.i] >= INF) continue;
|
|
if (distanceToNearest(usedAnchors, p.x, p.y) < 8) continue;
|
|
const d = target ? Math.hypot(p.x - target.x, p.y - target.y) : 0;
|
|
const score = d + costField[p.i] * 3.5 - corridorAllowance(p.i) * 2.4 + hash2(p.x, p.y, seed + 13701) * 1.8;
|
|
if (score < bestScore) {
|
|
bestScore = score;
|
|
best = { x: p.x, y: p.y, componentId: component.id, regionId: regionIdAt(p.x, p.y) };
|
|
}
|
|
}
|
|
return best;
|
|
}
|
|
|
|
function repairTransportConnectivity(paths, mode, costField, potentialField, options = {}) {
|
|
const debug = { mode, components: [], repairs: [] };
|
|
const raster = rasterizeNetworkComponents(paths, mode, potentialField);
|
|
debug.components = raster.components.map((c) => ({
|
|
id: c.id,
|
|
mode,
|
|
importance: c.importance,
|
|
length: c.length,
|
|
potential: c.potential,
|
|
cells: c.cells.filter((_, k) => k % Math.max(1, Math.floor(c.cells.length / 140)) === 0).map((i) => xyOf(i)),
|
|
}));
|
|
const important = raster.components
|
|
.filter((c) => c.length >= (options.minComponentCells ?? 18) && c.importance >= (options.minImportance ?? 8))
|
|
.sort((a, b) => b.importance - a.importance)
|
|
.slice(0, options.maxComponents ?? 8);
|
|
if (important.length < 2) return debug;
|
|
|
|
const networkPenalty = influenceFromPaths(paths, options.penaltyRadius ?? 8);
|
|
const usedAnchors = [];
|
|
const maxRepairs = options.maxRepairs ?? 4;
|
|
for (let r = 0; r < maxRepairs; r++) {
|
|
let bestPair = null;
|
|
let bestScore = INF;
|
|
for (let a = 0; a < important.length; a++) {
|
|
for (let b = a + 1; b < important.length; b++) {
|
|
const ca = important[a];
|
|
const cb = important[b];
|
|
if (ca.repairCount >= 2 || cb.repairCount >= 2) continue;
|
|
const centerA = ca.boundary[Math.floor(ca.boundary.length / 2)] || { x: 0, y: 0 };
|
|
const centerB = cb.boundary[Math.floor(cb.boundary.length / 2)] || { x: 0, y: 0 };
|
|
const d = Math.hypot(centerA.x - centerB.x, centerA.y - centerB.y);
|
|
if (d < (options.minRepairDistance ?? 14) || d > (options.maxRepairDistance ?? 120)) continue;
|
|
const score = d / Math.sqrt(ca.importance + cb.importance) + (ca.repairCount + cb.repairCount) * 18;
|
|
if (score < bestScore) {
|
|
bestScore = score;
|
|
bestPair = [ca, cb];
|
|
}
|
|
}
|
|
}
|
|
if (!bestPair) break;
|
|
const [aComp, bComp] = bestPair;
|
|
const roughTarget = bComp.boundary[Math.floor(bComp.boundary.length / 2)];
|
|
const start = componentAnchor(aComp, roughTarget, costField, usedAnchors);
|
|
const goalTarget = start ? componentAnchor(bComp, start, costField, usedAnchors) : null;
|
|
if (!start || !goalTarget) break;
|
|
const path = traceCorridorByCost(
|
|
start,
|
|
(x, y, i) => raster.componentId[i] === bComp.id || (potentialField[i] > (options.highPotentialThreshold ?? 0.42) && Math.hypot(x - goalTarget.x, y - goalTarget.y) < 5),
|
|
costField,
|
|
networkPenalty,
|
|
{
|
|
curvePenalty: options.curvePenalty ?? 0.14,
|
|
penaltyStrength: options.penaltyStrength ?? 1.8,
|
|
minGoalDistance: Math.min(12, Math.max(5, Math.hypot(start.x - goalTarget.x, start.y - goalTarget.y) * 0.35)),
|
|
keepRegion: false,
|
|
maxExpanded: SIZE,
|
|
}
|
|
);
|
|
if (path.length < (options.minAddedLength ?? 6) || path.length > (options.maxAddedLength ?? 120)) {
|
|
aComp.repairCount++;
|
|
continue;
|
|
}
|
|
paths.push(path);
|
|
debug.repairs.push({ mode, path, from: aComp.id, to: bComp.id });
|
|
usedAnchors.push(start, goalTarget);
|
|
aComp.repairCount++;
|
|
bComp.repairCount++;
|
|
addCorridorInfluencePenalty(networkPenalty, path, options.penaltyRadius ?? 8, options.addedPenalty ?? 0.38);
|
|
}
|
|
return debug;
|
|
}
|
|
|
|
function routeLight(a, b, snapRadius = 3, costField = transportFields.local) {
|
|
if (!a || !b) return [];
|
|
const steps = Math.max(2, Math.ceil(Math.hypot(a.x - b.x, a.y - b.y) * 1.15));
|
|
const out = [];
|
|
let lastKey = "";
|
|
for (let s = 0; s <= steps; s++) {
|
|
const t = s / steps;
|
|
const fx = a.x + (b.x - a.x) * t;
|
|
const fy = a.y + (b.y - a.y) * t;
|
|
let best = null;
|
|
let bestCost = INF;
|
|
const radius = snapRadius + (s > 0 && s < steps ? 1 : 0);
|
|
for (let dy = -radius; dy <= radius; dy++) {
|
|
for (let dx = -radius; dx <= radius; dx++) {
|
|
const x = Math.round(fx + dx);
|
|
const y = Math.round(fy + dy);
|
|
if (!inside(x, y)) continue;
|
|
const i = indexOf(x, y);
|
|
if (sea[i] || costField[i] >= INF) continue;
|
|
const lineDist = Math.hypot(x - fx, y - fy);
|
|
const cost = lineDist * 0.72 + costField[i] * 0.74 - valleySettlement[i] * 0.20 - developable[i] * 0.12 + hash2(x, y, seed + 13000 + s) * 0.05;
|
|
if (cost < bestCost) {
|
|
bestCost = cost;
|
|
best = [x, y];
|
|
}
|
|
}
|
|
}
|
|
if (!best) continue;
|
|
const key = `${best[0]},${best[1]}`;
|
|
if (key !== lastKey) {
|
|
out.push(best);
|
|
lastKey = key;
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
|
|
function importantNodesForRegion(regionId) {
|
|
const inRegion = (p) => regionIdAt(p.x, p.y) === regionId;
|
|
return [
|
|
...modernCities.filter(inRegion).map((p) => ({ ...p, nodeWeight: 8 + (p.population || 0) / 120000 })),
|
|
...markets.filter(inRegion).map((p) => ({ ...p, nodeWeight: 3.2 + (p.population || 0) / 25000 })),
|
|
...commercialPorts.filter(inRegion).map((p) => ({ ...p, nodeWeight: p.portClass === "major" ? 6.5 : 4.6 })),
|
|
...passes.filter(inRegion).map((p) => ({ ...p, nodeWeight: 2.2 })),
|
|
].sort((a, b) => b.nodeWeight - a.nodeWeight).slice(0, (regionStats.get(regionId)?.area || 0) > 2200 ? 16 : 10);
|
|
}
|
|
|
|
const premodernRoads = [];
|
|
const nationalRoads = [];
|
|
const minorRoads = [];
|
|
const railways = [];
|
|
const branchRailways = [];
|
|
const externalRoads = [];
|
|
const externalRailways = [];
|
|
const expressways = [];
|
|
const ringRoads = [];
|
|
const ringRailways = [];
|
|
const ringExpressways = [];
|
|
const externalExpressways = [];
|
|
const icAccessRoads = [];
|
|
const interchanges = [];
|
|
const externalGateways = [];
|
|
|
|
// Premodern roads connect castles/markets/ports sparsely.
|
|
for (const c of castles) {
|
|
const near = [...markets, ...ports, ...crossings].sort((a, b) => Math.hypot(a.x - c.x, a.y - c.y) - Math.hypot(b.x - c.x, b.y - c.y)).slice(0, 2);
|
|
for (const n of near) {
|
|
const path = routeLight(c, n, 2);
|
|
if (path.length > 2) premodernRoads.push(path);
|
|
}
|
|
}
|
|
|
|
nationalRoads.push(...generateCorridorsFromField({
|
|
potentialField: transportFields.nationalPotential,
|
|
costField: transportFields.national,
|
|
spacing: 17,
|
|
maxCount: 42,
|
|
threshold: 0.30,
|
|
minLength: 20,
|
|
penaltyRadius: 6,
|
|
penaltyStrength: 0.34,
|
|
curvePenalty: 0.10,
|
|
seedOffset: 13400,
|
|
startPredicate: (x, y, i) => transportFields.nationalPotential[i] > 0.27 && regionIdAt(x, y) >= 0,
|
|
goalPredicate: (start, x, y, i, used) => {
|
|
if (regionIdAt(x, y) !== start.regionId) return false;
|
|
if (transportFields.nationalPotential[i] < 0.34) return false;
|
|
if (distanceToNearest(used, x, y) < 11) return false;
|
|
const d = Math.hypot(x - start.x, y - start.y);
|
|
return d > 22 && d < 76;
|
|
},
|
|
}));
|
|
|
|
railways.push(...generateCorridorsFromField({
|
|
potentialField: transportFields.railPotential,
|
|
costField: transportFields.rail,
|
|
spacing: 24,
|
|
maxCount: 18,
|
|
threshold: 0.30,
|
|
minLength: 24,
|
|
penaltyRadius: 7,
|
|
penaltyStrength: 0.42,
|
|
curvePenalty: 0.30,
|
|
seedOffset: 13500,
|
|
startPredicate: (x, y, i) => transportFields.railPotential[i] > 0.26 && settlementDemand[i] > 0.16 && regionIdAt(x, y) >= 0,
|
|
goalPredicate: (start, x, y, i, used) => {
|
|
if (regionIdAt(x, y) !== start.regionId) return false;
|
|
if (transportFields.railPotential[i] < 0.30 || settlementDemand[i] < 0.18) return false;
|
|
if (distanceToNearest(used, x, y) < 15) return false;
|
|
const d = Math.hypot(x - start.x, y - start.y);
|
|
return d > 28 && d < 88;
|
|
},
|
|
}));
|
|
|
|
expressways.push(...generateCorridorsFromField({
|
|
potentialField: transportFields.expresswayPotential,
|
|
costField: transportFields.expressway,
|
|
spacing: 29,
|
|
maxCount: 10,
|
|
threshold: 0.30,
|
|
minLength: 30,
|
|
penaltyRadius: 9,
|
|
penaltyStrength: 0.55,
|
|
curvePenalty: 0.16,
|
|
seedOffset: 13600,
|
|
startPredicate: (x, y, i) => transportFields.expresswayPotential[i] > 0.27 && regionIdAt(x, y) >= 0,
|
|
goalPredicate: (start, x, y, i, used) => {
|
|
if (regionIdAt(x, y) !== start.regionId) return false;
|
|
if (transportFields.expresswayPotential[i] < 0.30) return false;
|
|
if (distanceToNearest(used, x, y) < 18) return false;
|
|
const d = Math.hypot(x - start.x, y - start.y);
|
|
return d > 34 && d < 104;
|
|
},
|
|
}));
|
|
|
|
// External gateways at land edges; used by naming/UI and later transport work.
|
|
for (const regionId of [...regionStats.keys()].sort((a, b) => a - b)) {
|
|
const st = regionStats.get(regionId);
|
|
if (!st || st.area < 140) continue;
|
|
const edgeCandidates = [];
|
|
for (let y = st.minY; y <= st.maxY; y += 3) {
|
|
for (const x of [st.minX, st.maxX]) {
|
|
if (!inside(x, y)) continue;
|
|
const i = indexOf(x, y);
|
|
if (!sea[i] && regionIdAt(x, y) === regionId && (x < 5 || y < 5 || x > MAP_W - 6 || y > MAP_H - 6)) edgeCandidates.push({ x, y, score: developable[i] + valleySettlement[i] });
|
|
}
|
|
}
|
|
for (let x = st.minX; x <= st.maxX; x += 3) {
|
|
for (const y of [st.minY, st.maxY]) {
|
|
if (!inside(x, y)) continue;
|
|
const i = indexOf(x, y);
|
|
if (!sea[i] && regionIdAt(x, y) === regionId && (x < 5 || y < 5 || x > MAP_W - 6 || y > MAP_H - 6)) edgeCandidates.push({ x, y, score: developable[i] + valleySettlement[i] });
|
|
}
|
|
}
|
|
const gateway = pickEntities(edgeCandidates, { max: (regionStats.get(regionId)?.area || 0) > 2200 ? 2 : 1, minDistance: 16, seed: seed + 13200 + regionId * 11 })[0];
|
|
if (gateway) {
|
|
gateway.kind = "External Gateway";
|
|
gateway.regionId = regionId;
|
|
externalGateways.push(gateway);
|
|
const target = importantNodesForRegion(regionId)[0];
|
|
if (target) {
|
|
const path = routeLight(gateway, target, 3, transportFields.national);
|
|
if (path.length > 2) externalRoads.push(path);
|
|
}
|
|
}
|
|
}
|
|
|
|
const transportDebugLayers = {
|
|
expresswayPotential: transportFields.expresswayPotential,
|
|
railPotential: transportFields.railPotential,
|
|
nationalRoadPotential: transportFields.nationalPotential,
|
|
slopeSeaPenalty: (() => {
|
|
const out = new Float32Array(SIZE);
|
|
for (let i = 0; i < SIZE; i++) out[i] = sea[i] ? 1 : clamp(slope[i] * 1.55 + Math.max(0, elevation[i] - 0.58) * 2.2 + ridgeField[i] * 0.42);
|
|
return out;
|
|
})(),
|
|
components: [],
|
|
repairedSegments: [],
|
|
unservedSettlements: [],
|
|
};
|
|
for (const repair of [
|
|
repairTransportConnectivity(expressways, "expressway", transportFields.expressway, transportFields.expresswayPotential, {
|
|
minImportance: 8.5,
|
|
minComponentCells: 18,
|
|
maxComponents: 7,
|
|
maxRepairs: 3,
|
|
maxRepairDistance: 115,
|
|
penaltyRadius: 9,
|
|
penaltyStrength: 2.3,
|
|
curvePenalty: 0.16,
|
|
highPotentialThreshold: 0.38,
|
|
}),
|
|
repairTransportConnectivity(railways, "rail", transportFields.rail, transportFields.railPotential, {
|
|
minImportance: 9.5,
|
|
minComponentCells: 16,
|
|
maxComponents: 8,
|
|
maxRepairs: 4,
|
|
maxRepairDistance: 105,
|
|
penaltyRadius: 7,
|
|
penaltyStrength: 2.0,
|
|
curvePenalty: 0.34,
|
|
highPotentialThreshold: 0.36,
|
|
}),
|
|
repairTransportConnectivity(nationalRoads, "national", transportFields.national, transportFields.nationalPotential, {
|
|
minImportance: 7.5,
|
|
minComponentCells: 12,
|
|
maxComponents: 10,
|
|
maxRepairs: 6,
|
|
maxRepairDistance: 95,
|
|
penaltyRadius: 6,
|
|
penaltyStrength: 1.7,
|
|
curvePenalty: 0.11,
|
|
highPotentialThreshold: 0.34,
|
|
}),
|
|
]) {
|
|
transportDebugLayers.components.push(...repair.components);
|
|
transportDebugLayers.repairedSegments.push(...repair.repairs);
|
|
}
|
|
|
|
function generateLocalRoadsForUnservedSettlements() {
|
|
const trunkInfluence = influenceFromPaths([...nationalRoads, ...railways, ...externalRoads], 8);
|
|
const candidates = [...villages, ...markets, ...ports]
|
|
.filter((p) => inside(p.x, p.y) && !sea[indexOf(p.x, p.y)])
|
|
.map((p) => {
|
|
const i = indexOf(p.x, p.y);
|
|
const settlementWeight = p.portClass ? 1.2 : p.population ? clamp(p.population / 18000, 0.35, 1.4) : 0.45;
|
|
return { ...p, score: settlementWeight + transportFields.localPotential[i] * 0.65 - trunkInfluence[i] * 1.15 };
|
|
})
|
|
.filter((p) => p.score > 0.18 && trunkInfluence[indexOf(p.x, p.y)] < 0.26)
|
|
.sort((a, b) => b.score - a.score)
|
|
.slice(0, 90);
|
|
const localPenalty = new Float32Array(SIZE);
|
|
const paths = [];
|
|
const served = [];
|
|
for (const start of candidates) {
|
|
if (paths.length >= 75) break;
|
|
if (distanceToNearest(served, start.x, start.y) < 4.5) continue;
|
|
const path = traceCorridorByCost(
|
|
start,
|
|
(x, y, i) => trunkInfluence[i] > 0.20 || (paths.length > 8 && localPenalty[i] > 0.05),
|
|
transportFields.local,
|
|
localPenalty,
|
|
{ curvePenalty: 0.08, penaltyStrength: 1.15, minGoalDistance: 5, regionId: start.regionId, maxExpanded: SIZE }
|
|
);
|
|
if (path.length < 4 || path.length > 70) continue;
|
|
paths.push(path);
|
|
served.push(start);
|
|
addCorridorInfluencePenalty(localPenalty, path, 4, 0.22);
|
|
}
|
|
return paths;
|
|
}
|
|
|
|
minorRoads.push(...generateLocalRoadsForUnservedSettlements());
|
|
for (const path of expressways) {
|
|
for (const p of samplePath(path, 24)) {
|
|
const i = indexOf(p.x, p.y);
|
|
if (sea[i] || transportFields.expresswayPotential[i] < 0.24) continue;
|
|
if (interchanges.every((q) => Math.hypot(q.x - p.x, q.y - p.y) > 14)) {
|
|
interchanges.push({ x: p.x, y: p.y, kind: "Interchange", score: transportFields.expresswayPotential[i], regionId: regionIdAt(p.x, p.y) });
|
|
}
|
|
}
|
|
}
|
|
|
|
// Land-use road influence intentionally excludes expressways. Expressways
|
|
// are through-corridors here, not automatic suburbanization generators.
|
|
// A narrow field controls land-use attachment, while a broader field raises
|
|
// population density around trunk roads without painting a wide suburb band.
|
|
const roadLanduseInfluence = influenceFromPaths([...nationalRoads, ...ringRoads, ...externalRoads], 2.25);
|
|
const roadInfluence = influenceFromPaths([...nationalRoads, ...ringRoads, ...externalRoads], 5.0);
|
|
const roadDensityInfluence = influenceFromPaths([...nationalRoads, ...ringRoads, ...externalRoads], 9.0);
|
|
const railInfluence2 = influenceFromPaths([...railways, ...branchRailways, ...externalRailways], 4);
|
|
|
|
const stations = [];
|
|
const usedStationKeys = new Set();
|
|
function addStation(x, y, kind = "Station", score = 1) {
|
|
x = Math.round(x); y = Math.round(y);
|
|
if (!inside(x, y) || sea[indexOf(x, y)]) return;
|
|
const key = `${x},${y}`;
|
|
if (usedStationKeys.has(key)) return;
|
|
usedStationKeys.add(key);
|
|
stations.push({ x, y, kind, score, regionId: regionIdAt(x, y) });
|
|
}
|
|
for (const city of modernCities) addStation(city.x, city.y, city.isPrefecturalCapital || city.isRegionalCapital ? "Major Station" : "Station", 1.5);
|
|
for (const path of railways) for (const p of samplePath(path, 14)) addStation(p.x, p.y, "Station", 0.8);
|
|
const stationInfluence = influenceFromPoints(stations, 7, (s) => s.kind === "Major Station" ? 1.35 : 0.85);
|
|
const stationDensityInfluence = influenceFromPoints(stations, 10, (s) => s.kind === "Major Station" ? 1.85 : 1.05);
|
|
|
|
// --- 5. Approximate city/town influence and land-use ---------------------
|
|
const cityInfluence = new Float32Array(SIZE);
|
|
const coreInfluence = new Float32Array(SIZE);
|
|
const oldTownInfluence = influenceFromPoints([...markets, ...castleTowns, ...ports], 7, (p) => p.kind === "Major Port" ? 1.2 : 0.9);
|
|
const populationDensity = new Float32Array(SIZE);
|
|
|
|
function addKernel(grid, p, radius, weight, exponent = 1.7, terrainWeighted = true, combine = "max") {
|
|
const r = Math.ceil(radius);
|
|
const angle = hash2(p.x, p.y, seed + 14901) * Math.PI * 2;
|
|
const stretch = 1.35 + hash2(p.x, p.y, seed + 14902) * 0.85;
|
|
const squeeze = 0.62 + hash2(p.x, p.y, seed + 14903) * 0.28;
|
|
const ca = Math.cos(angle);
|
|
const sa = Math.sin(angle);
|
|
for (let dy = -r; dy <= r; dy++) {
|
|
for (let dx = -r; dx <= r; dx++) {
|
|
const x = p.x + dx;
|
|
const y = p.y + dy;
|
|
if (!inside(x, y)) continue;
|
|
const i = indexOf(x, y);
|
|
if (sea[i]) continue;
|
|
const along = (dx * ca + dy * sa) / stretch;
|
|
const across = (-dx * sa + dy * ca) / squeeze;
|
|
const baseD = Math.hypot(along, across);
|
|
const conduit = clamp(
|
|
plain[i] * 0.18 +
|
|
valleySettlement[i] * 0.26 +
|
|
coastalSettlement[i] * 0.16 +
|
|
roadDensityInfluence[i] * 0.34 +
|
|
roadInfluence[i] * 0.22 +
|
|
railInfluence2[i] * 0.26 +
|
|
stationDensityInfluence[i] * 0.12
|
|
);
|
|
const barrier = clamp(
|
|
slope[i] * 0.62 +
|
|
ridgeField[i] * 0.74 +
|
|
Math.max(0, elevation[i] - 0.58) * 0.82 +
|
|
(river[i] > 0.68 ? 0.60 : river[i] > 0.34 ? 0.22 : 0)
|
|
);
|
|
const noise = 0.78 + hash2(x, y, seed + 14910 + Math.round((p.population || 0) / 1000)) * 0.46;
|
|
const d = baseD * (1.10 - conduit * 0.42 + barrier * 0.62) * noise;
|
|
if (d > radius) continue;
|
|
const terrain = terrainWeighted ? clamp(0.06 + developable[i] * 1.08 + valleySettlement[i] * 0.24 + coastalSettlement[i] * 0.14 + conduit * 0.38 - barrier * 0.70, 0, 1.42) : 1;
|
|
const v = weight * Math.pow(1 - d / Math.max(1, radius), exponent) * terrain;
|
|
if (combine === "add") grid[i] = Math.min(3.4, grid[i] + v);
|
|
else if (v > grid[i]) grid[i] = v;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const city of modernCities) {
|
|
addKernel(cityInfluence, city, city.sprawlRadius || Math.round((city.urbanRadius || 10) * 1.4), (city.urbanWeight || 1.0) * (city.isRegionalCapital ? 0.38 : 0.30), 2.75, true, "add");
|
|
addKernel(cityInfluence, city, city.urbanRadius || 10, city.urbanWeight || 1.0, 1.18, true, "add");
|
|
addKernel(coreInfluence, city, city.coreRadius || 3, (city.urbanWeight || 1.0) * 1.10, 1.65, true, "max");
|
|
}
|
|
const townInfluence = influenceFromPoints(markets, 6, (m) => clamp((m.population || 10000) / 26000, 0.45, 1.25));
|
|
|
|
// Industrial/logistics/new town placeholders remain lightweight. They are
|
|
// routed by land-use proximity rather than expensive search passes.
|
|
const industrialZones = [];
|
|
for (const p of [...commercialPorts, ...modernCities.slice(0, 5)]) {
|
|
const candidates = [];
|
|
for (let dy = -10; dy <= 10; dy++) {
|
|
for (let dx = -10; dx <= 10; dx++) {
|
|
const x = p.x + dx;
|
|
const y = p.y + dy;
|
|
if (!inside(x, y)) continue;
|
|
const i = indexOf(x, y);
|
|
if (sea[i]) continue;
|
|
const d = Math.hypot(dx, dy);
|
|
if (d < 3 || d > 10) continue;
|
|
const score = coastalLowland[i] * 0.22 + developable[i] * 0.22 + roadInfluence[i] * 0.20 + plain[i] * 0.12 - slope[i] * 0.25 + hash2(x, y, seed + 14000) * 0.06;
|
|
if (score > 0.22) candidates.push({ x, y, score, kind: "Industrial Zone", regionId: regionIdAt(x, y) });
|
|
}
|
|
}
|
|
const z = pickEntities(candidates, { max: 1, minDistance: 6, seed: seed + 14010 + p.x * 3 + p.y })[0];
|
|
if (z && industrialZones.every((q) => Math.hypot(q.x - z.x, q.y - z.y) > 13)) industrialZones.push(z);
|
|
if (industrialZones.length >= 8) break;
|
|
}
|
|
const industrialInfluence = influenceFromPoints(industrialZones, 5, () => 1.0);
|
|
|
|
const satelliteCities = [];
|
|
const newTowns = [];
|
|
const logisticsScore = new Float32Array(SIZE);
|
|
for (let y = 2; y < MAP_H - 2; y++) {
|
|
for (let x = 2; x < MAP_W - 2; x++) {
|
|
const i = indexOf(x, y);
|
|
if (sea[i]) continue;
|
|
const flatAgriculturalCorridor = clamp(
|
|
agriculture[i] * 0.34 +
|
|
plain[i] * 0.24 +
|
|
developable[i] * 0.20 +
|
|
basinField[i] * 0.12 +
|
|
coastalLowland[i] * 0.08 +
|
|
roadInfluence[i] * 0.26 +
|
|
railInfluence2[i] * 0.18 +
|
|
stationInfluence[i] * 0.10 -
|
|
slope[i] * 0.44 -
|
|
ridgeField[i] * 0.32
|
|
);
|
|
const nearMajorCity = modernCities.some((c) => Math.hypot(c.x - x, c.y - y) < 4);
|
|
logisticsScore[i] = nearMajorCity ? 0 : flatAgriculturalCorridor;
|
|
}
|
|
}
|
|
const logisticsParks = pickGlobalPoints(logisticsScore, {
|
|
threshold: 0.34,
|
|
max: 18,
|
|
minDistance: 12,
|
|
seedOffset: 1450,
|
|
predicate: (x, y, i) => logisticsScore[i] > 0.30 && (roadInfluence[i] > 0.10 || railInfluence2[i] > 0.08 || stationInfluence[i] > 0.08),
|
|
}).map((p) => ({ ...p, kind: "Logistics Park", score: logisticsScore[indexOf(p.x, p.y)], population: 0 }));
|
|
const logisticsInfluence = influenceFromPoints(logisticsParks, 4.8, () => 1.0);
|
|
|
|
function addFinalLocalAccessForUnservedSettlements() {
|
|
const accessInfluence = influenceFromPaths([...nationalRoads, ...railways, ...externalRoads, ...minorRoads], 7);
|
|
const candidates = [
|
|
...markets.filter((p) => (p.population || 0) >= 5000),
|
|
...ports,
|
|
...logisticsParks,
|
|
...villages.filter((p) => (elevation[indexOf(p.x, p.y)] > 0.48 || slope[indexOf(p.x, p.y)] > 0.30 || p.kind === "Valley Village") && (p.population || 0) >= 1200),
|
|
]
|
|
.filter((p) => inside(p.x, p.y) && !sea[indexOf(p.x, p.y)] && accessInfluence[indexOf(p.x, p.y)] < 0.18)
|
|
.map((p) => ({ ...p, score: (p.population || 7000) / 18000 + (p.portClass ? 0.8 : 0) + (p.kind === "Logistics Park" ? 1.0 : 0) + transportFields.localPotential[indexOf(p.x, p.y)] }))
|
|
.sort((a, b) => b.score - a.score)
|
|
.slice(0, 55);
|
|
const localPenalty = influenceFromPaths(minorRoads, 4);
|
|
for (const start of candidates) {
|
|
const path = traceCorridorByCost(
|
|
start,
|
|
(x, y, i) => accessInfluence[i] > 0.20 || localPenalty[i] > 0.10,
|
|
transportFields.local,
|
|
localPenalty,
|
|
{ curvePenalty: 0.08, penaltyStrength: 1.0, minGoalDistance: 4, regionId: start.regionId, maxExpanded: Math.floor(SIZE * 0.55) }
|
|
);
|
|
transportDebugLayers.unservedSettlements.push({ x: start.x, y: start.y, kind: start.kind || "Unserved Settlement", mode: "local-access", repaired: path.length >= 4 && path.length <= 64 });
|
|
if (path.length < 4 || path.length > 64) continue;
|
|
minorRoads.push(path);
|
|
transportDebugLayers.repairedSegments.push({ mode: "local", path, from: "unserved", to: "network" });
|
|
addCorridorInfluencePenalty(localPenalty, path, 4, 0.20);
|
|
}
|
|
}
|
|
addFinalLocalAccessForUnservedSettlements();
|
|
var landuse = new Uint8Array(SIZE);
|
|
|
|
// Re-run land-use classification after landuse allocation. The loop above is
|
|
// intentionally inside a helper to keep all thresholds in one place.
|
|
function classifyLanduse() {
|
|
landuse.fill(LANDUSE.RURAL);
|
|
let maxDensity = 0;
|
|
const baseNoiseSeed = seed + 15000;
|
|
const urbanCapacity = new Float32Array(SIZE);
|
|
const ruralDensityFloor = new Float32Array(SIZE);
|
|
for (let y = 0; y < MAP_H; y++) {
|
|
for (let x = 0; x < MAP_W; x++) {
|
|
const i = indexOf(x, y);
|
|
if (sea[i]) continue;
|
|
const transport = Math.max(roadLanduseInfluence[i] * 0.95, railInfluence2[i] * 0.95, stationInfluence[i] * 0.82);
|
|
const densityTransport = Math.max(roadDensityInfluence[i] * 0.95, stationDensityInfluence[i] * 1.05, railInfluence2[i] * 0.85);
|
|
const urban = cityInfluence[i] * 0.76 + stationInfluence[i] * 0.30 + roadInfluence[i] * 0.14 + railInfluence2[i] * 0.10;
|
|
const core = coreInfluence[i];
|
|
const oldTown = oldTownInfluence[i] * 0.70 + townInfluence[i] * 0.38;
|
|
const rural = villageInfluence[i] * 0.24 + ruralSuitability[i] * 0.30;
|
|
const riverUrban = clamp(river[i] * 0.12 + valleyField[i] * 0.10 + plain[i] * 0.08 + basinField[i] * 0.08 - floodplain[i] * 0.10);
|
|
urbanCapacity[i] = clamp(
|
|
developable[i] * 0.66 +
|
|
plain[i] * 0.16 +
|
|
basinField[i] * 0.16 +
|
|
valleyField[i] * 0.16 +
|
|
coastalLowland[i] * 0.12 +
|
|
roadInfluence[i] * 0.14 + roadDensityInfluence[i] * 0.16 + transport * 0.08 +
|
|
riverUrban * 0.14 -
|
|
slope[i] * 0.18 -
|
|
ridgeField[i] * 0.12 -
|
|
floodplain[i] * 0.08
|
|
);
|
|
const highPenaltyDensity = Math.max(0, elevation[i] - 0.58);
|
|
const agrarianDensity = clamp(
|
|
agriculture[i] * 0.045 +
|
|
ruralSuitability[i] * 0.035 +
|
|
developable[i] * 0.028 +
|
|
plain[i] * 0.018 +
|
|
basinField[i] * 0.014 +
|
|
valleySettlement[i] * 0.014 +
|
|
coastalSettlement[i] * 0.012 +
|
|
villageInfluence[i] * 0.040 +
|
|
townInfluence[i] * 0.022 +
|
|
roadDensityInfluence[i] * 0.038 +
|
|
stationDensityInfluence[i] * 0.020 +
|
|
railInfluence2[i] * 0.012 -
|
|
slope[i] * 0.030 -
|
|
ridgeField[i] * 0.020 -
|
|
highPenaltyDensity * 0.058
|
|
);
|
|
const remoteWilderness = elevation[i] > 0.60 && slope[i] > 0.34 && ridgeField[i] > 0.38 && densityTransport < 0.035 && villageInfluence[i] < 0.025 && townInfluence[i] < 0.025 && cityInfluence[i] < 0.025;
|
|
ruralDensityFloor[i] = remoteWilderness ? 0 : clamp(agrarianDensity, 0, elevation[i] > 0.62 || slope[i] > 0.42 ? 0.052 : 0.105);
|
|
populationDensity[i] = clamp(
|
|
urban * 0.66 +
|
|
core * 0.46 +
|
|
oldTown * 0.28 +
|
|
townInfluence[i] * 0.16 +
|
|
villageInfluence[i] * 0.14 +
|
|
roadDensityInfluence[i] * 0.42 +
|
|
stationDensityInfluence[i] * 0.34 +
|
|
railInfluence2[i] * 0.12 +
|
|
transport * 0.05 +
|
|
agrarianDensity * 0.34
|
|
);
|
|
maxDensity = Math.max(maxDensity, populationDensity[i]);
|
|
|
|
if (elevation[i] > 0.67 || (slope[i] > 0.56 && ridgeField[i] > 0.30) || ridgeField[i] > 0.70) {
|
|
landuse[i] = LANDUSE.FOREST;
|
|
continue;
|
|
}
|
|
if (industrialInfluence[i] > 0.22 && urbanCapacity[i] > 0.10) {
|
|
landuse[i] = LANDUSE.INDUSTRIAL;
|
|
continue;
|
|
}
|
|
if (logisticsInfluence[i] > 0.24 && urbanCapacity[i] > 0.08 && (roadInfluence[i] > 0.08 || railInfluence2[i] > 0.06)) {
|
|
landuse[i] = LANDUSE.LOGISTICS;
|
|
continue;
|
|
}
|
|
if (core > 0.38 && urbanCapacity[i] > 0.10) {
|
|
landuse[i] = LANDUSE.CBD;
|
|
continue;
|
|
}
|
|
if (oldTown > 0.18 && urbanCapacity[i] > 0.09) {
|
|
landuse[i] = LANDUSE.OLD_URBAN;
|
|
continue;
|
|
}
|
|
|
|
const suburbanity = urban * 0.88 + transport * 0.23 + stationInfluence[i] * 0.12 + townInfluence[i] * 0.08 + riverUrban * 0.08;
|
|
const edgeTaper = clamp(cityInfluence[i] * 0.52 + stationInfluence[i] * 0.16 + roadLanduseInfluence[i] * 0.10 + 0.28);
|
|
const sprawlBias = clamp(0.58 + hash2(x, y, baseNoiseSeed) * 0.42);
|
|
const sprawlScore = suburbanity * sprawlBias * edgeTaper - core * 0.12;
|
|
if (sprawlScore > 0.24 && urbanCapacity[i] > 0.10) {
|
|
landuse[i] = LANDUSE.SUBURB;
|
|
} else if (roadLanduseInfluence[i] > 0.30 && urbanCapacity[i] > 0.10 && (townInfluence[i] > 0.05 || cityInfluence[i] > 0.11)) {
|
|
landuse[i] = LANDUSE.SUBURB;
|
|
} else if (agriculture[i] > 0.16 || rural > 0.18 || (developable[i] > 0.13 && plain[i] > 0.13) || (basinField[i] > 0.18 && slope[i] < 0.34) || (coastalLowland[i] > 0.16 && slope[i] < 0.32)) {
|
|
landuse[i] = LANDUSE.FARMLAND;
|
|
} else {
|
|
const usablePlain = slope[i] < 0.30 && (plain[i] > 0.18 || developable[i] > 0.20 || basinField[i] > 0.20 || coastalLowland[i] > 0.18);
|
|
landuse[i] = elevation[i] > 0.58 || slope[i] > 0.38 ? LANDUSE.FOREST : usablePlain ? LANDUSE.FARMLAND : LANDUSE.RURAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
const baseLanduse = landuse.slice();
|
|
const isBuilt = (lu) => lu >= LANDUSE.OLD_URBAN && lu <= LANDUSE.ROADSIDE;
|
|
for (let y = 1; y < MAP_H - 1; y++) {
|
|
for (let x = 1; x < MAP_W - 1; x++) {
|
|
const i = indexOf(x, y);
|
|
if (sea[i] || baseLanduse[i] === LANDUSE.FOREST) continue;
|
|
const transport = Math.max(roadLanduseInfluence[i] * 0.95, railInfluence2[i] * 0.95, stationInfluence[i] * 0.82);
|
|
const densityTransport = Math.max(roadDensityInfluence[i] * 0.95, stationDensityInfluence[i] * 1.05, railInfluence2[i] * 0.85);
|
|
let urbanNeighbors = 0;
|
|
let cbdNeighbors = 0;
|
|
for (let dy = -1; dy <= 1; dy++) {
|
|
for (let dx = -1; dx <= 1; dx++) {
|
|
if (!dx && !dy) continue;
|
|
const lu = baseLanduse[indexOf(x + dx, y + dy)];
|
|
if (isBuilt(lu)) urbanNeighbors++;
|
|
if (lu === LANDUSE.CBD) cbdNeighbors++;
|
|
}
|
|
}
|
|
if (baseLanduse[i] === LANDUSE.OLD_URBAN && coreInfluence[i] > 0.31 && cbdNeighbors >= 3) {
|
|
landuse[i] = LANDUSE.CBD;
|
|
continue;
|
|
}
|
|
if ((baseLanduse[i] === LANDUSE.FARMLAND || baseLanduse[i] === LANDUSE.RURAL) && urbanCapacity[i] > 0.10) {
|
|
const fringeChance = urbanNeighbors * 0.055 + cityInfluence[i] * 0.13 + transport * 0.12 + stationInfluence[i] * 0.08;
|
|
const noise = 0.23 + hash2(x, y, seed + 15050) * 0.24;
|
|
if (fringeChance > 0.34 + noise) {
|
|
landuse[i] = LANDUSE.SUBURB;
|
|
}
|
|
}
|
|
if ((river[i] > 0.10 || railInfluence2[i] > 0.16 || roadLanduseInfluence[i] > 0.22) && urbanNeighbors >= 3 && landuse[i] <= LANDUSE.FARMLAND && urbanCapacity[i] > 0.09) {
|
|
landuse[i] = cbdNeighbors >= 1 || coreInfluence[i] > 0.15 ? LANDUSE.OLD_URBAN : LANDUSE.SUBURB;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const park of logisticsParks) {
|
|
const r = 3;
|
|
for (let dy = -r; dy <= r; dy++) {
|
|
for (let dx = -r; dx <= r; dx++) {
|
|
const x = park.x + dx;
|
|
const y = park.y + dy;
|
|
if (!inside(x, y)) continue;
|
|
const i = indexOf(x, y);
|
|
if (sea[i] || landuse[i] === LANDUSE.CBD || landuse[i] === LANDUSE.FOREST) continue;
|
|
if (Math.hypot(dx, dy) <= r && (agriculture[i] > 0.18 || plain[i] > 0.15 || roadInfluence[i] > 0.06 || railInfluence2[i] > 0.05)) {
|
|
landuse[i] = LANDUSE.LOGISTICS;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (maxDensity > 0) {
|
|
for (let i = 0; i < SIZE; i++) {
|
|
if (sea[i]) continue;
|
|
const lu = landuse[i];
|
|
let floor = ruralDensityFloor[i];
|
|
if (lu === LANDUSE.FARMLAND) {
|
|
floor = Math.max(floor, clamp(0.024 + agriculture[i] * 0.044 + ruralSuitability[i] * 0.024 + roadDensityInfluence[i] * 0.030 + stationDensityInfluence[i] * 0.026 + villageInfluence[i] * 0.018, 0, 0.110));
|
|
} else if (lu === LANDUSE.LOGISTICS) {
|
|
floor = Math.max(floor, clamp(0.018 + roadDensityInfluence[i] * 0.026 + railInfluence2[i] * 0.014 + logisticsInfluence[i] * 0.012, 0, 0.060));
|
|
} else if (lu === LANDUSE.RURAL) {
|
|
floor = Math.max(floor, clamp(0.012 + ruralSuitability[i] * 0.020 + developable[i] * 0.014 + roadDensityInfluence[i] * 0.024 + stationDensityInfluence[i] * 0.020, 0, 0.070));
|
|
} else if (lu === LANDUSE.FOREST) {
|
|
floor = Math.min(floor, (roadDensityInfluence[i] > 0.04 || villageInfluence[i] > 0.03) ? 0.026 : 0);
|
|
}
|
|
const normalized = populationDensity[i] / maxDensity;
|
|
populationDensity[i] = clamp(Math.max(normalized, floor));
|
|
if (lu === LANDUSE.FOREST && floor === 0 && populationDensity[i] < 0.012) populationDensity[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
classifyLanduse();
|
|
|
|
for (const city of modernCities) {
|
|
let urbanFootprintCells = 0;
|
|
let coreFootprintCells = 0;
|
|
const r = Math.ceil((city.urbanRadius || 8) * 1.3);
|
|
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 (!inside(x, y)) continue;
|
|
const i = indexOf(x, y);
|
|
if (sea[i]) continue;
|
|
if (Math.hypot(dx, dy) > r) continue;
|
|
if (landuse[i] >= LANDUSE.OLD_URBAN && landuse[i] <= LANDUSE.ROADSIDE) urbanFootprintCells++;
|
|
if (landuse[i] === LANDUSE.CBD) coreFootprintCells++;
|
|
}
|
|
}
|
|
city.urbanFootprintCells = urbanFootprintCells;
|
|
city.coreFootprintCells = coreFootprintCells;
|
|
}
|
|
|
|
const transportDebug = {
|
|
humanStageVersion: "v2-sparse-raster",
|
|
aStarRoutes: 0,
|
|
regionalNodeCount: [...regionStats.keys()].reduce((sum, regionId) => sum + importantNodesForRegion(regionId).length, 0),
|
|
fieldCorridorTransport: true,
|
|
expresswayFieldCorridors: expressways.length,
|
|
railFieldCorridors: railways.length,
|
|
nationalRoadFieldCorridors: nationalRoads.length,
|
|
localRoadFieldCorridors: minorRoads.length,
|
|
layers: transportDebugLayers,
|
|
nationalRoadPopulationCoverage: 0,
|
|
nationalRoadUncoveredPopulation: 0,
|
|
};
|
|
|
|
return {
|
|
ports,
|
|
crossings,
|
|
passes,
|
|
settlementCluster,
|
|
settlementScore,
|
|
villages,
|
|
markets,
|
|
castles,
|
|
castleTowns,
|
|
premodernRoads,
|
|
minorRoads,
|
|
modernCities,
|
|
populationDensity,
|
|
railways,
|
|
branchRailways,
|
|
ringRailways,
|
|
externalRailways,
|
|
stations,
|
|
industrialZones,
|
|
nationalRoads,
|
|
ringRoads,
|
|
expressways,
|
|
ringExpressways,
|
|
icAccessRoads,
|
|
externalRoads,
|
|
externalExpressways,
|
|
interchanges,
|
|
logisticsParks,
|
|
satelliteCities,
|
|
newTowns,
|
|
landuse,
|
|
stationInfluence,
|
|
roadInfluence,
|
|
roadDensityInfluence,
|
|
stationDensityInfluence,
|
|
railInfluence2,
|
|
villageInfluence,
|
|
externalGateways,
|
|
cityPopulationCap,
|
|
transportDebug,
|
|
};
|
|
}
|