hoi4-agent-tools 4.3.0 → 4.5.0

package/dist/hoi4_agent_tools/map/relief/terrain-synthesis.js

@@ -0,0 +1,304 @@
+import { LAKE, LAND, chamferDistance } from './grid.js';
+import { landDistanceField, lakeHeight } from '../water.js';
+import { BARRIER_CREST, BARRIER_FORT_LINE, BARRIER_LAKE_SHORE, BARRIER_RIVER, BARRIER_STEEP, BARRIER_WALL, } from './fields.js';
+import { checkRangesAndFeatures, reliefStatistics, straightRiverShare, } from './checks.js';
+import { buildFullResolutionHeights } from './full-resolution.js';
+import { RIVER_PIXEL_CAP, synthesizeHydrology } from './hydrology.js';
+import { DEFAULT_RELIEF, LAND_FLOOR, HEIGHT_CEILING, peakHeight, synthesizeMacroRelief, } from './macro-relief.js';
+import { rasterizeRivers } from './river-raster.js';
+/** Red channel response of the normal map per height step (base game: about 2.6). */
+export const NORMAL_RESPONSE = 2.6;
+function normalMap(floats, width, height, signal) {
+    const halfWidth = width / 2;
+    const halfHeight = height / 2;
+    const out = new Uint8Array(halfWidth * halfHeight * 3);
+    const gain = NORMAL_RESPONSE / 127;
+    const at = (x, y) => floats[(y < 0 ? 0 : y >= height ? height - 1 : y) * width + (x < 0 ? 0 : x >= width ? width - 1 : x)];
+    for (let y = 0; y < halfHeight; y += 1) {
+        if (y % 64 === 0)
+            signal?.throwIfAborted();
+        for (let x = 0; x < halfWidth; x += 1) {
+            const dx = at(2 * x + 2, 2 * y) - at(2 * x - 2, 2 * y);
+            const dy = at(2 * x, 2 * y - 2) - at(2 * x, 2 * y + 2);
+            const nx = -gain * dx;
+            const ny = gain * dy;
+            const length = Math.sqrt(nx * nx + ny * ny + 1);
+            const o = (y * halfWidth + x) * 3;
+            out[o] = Math.round(128 + (nx / length) * 127);
+            out[o + 1] = Math.round(128 + (ny / length) * 127);
+            out[o + 2] = Math.round(128 + (1 / length) * 127);
+        }
+    }
+    return out;
+}
+function barrierField(width, height, kind, heights, riverBitmap, macro, signal) {
+    const strength = new Uint8Array(width * height);
+    const sources = new Uint8Array(width * height);
+    for (let y = 0; y < height; y += 1) {
+        if (y % 64 === 0)
+            signal?.throwIfAborted();
+        const my = y >> 1;
+        for (let x = 0; x < width; x += 1) {
+            const index = y * width + x;
+            if (kind[index] !== LAND)
+                continue;
+            let value = 0;
+            let flags = 0;
+            const river = riverBitmap[index];
+            if (river <= 11) {
+                flags |= BARRIER_RIVER;
+                value = Math.max(value, river >= 3 ? 100 + 14 * (river - 3) : 100);
+            }
+            if (x > 0 && x < width - 1 && y > 0 && y < height - 1) {
+                const gx = (heights[index + 1] - heights[index - 1]) / 2;
+                const gy = (heights[index + width] - heights[index - width]) / 2;
+                const gradient = Math.sqrt(gx * gx + gy * gy);
+                if (gradient >= 2) {
+                    flags |= BARRIER_STEEP;
+                    value = Math.max(value, Math.min(200, 60 + 25 * (gradient - 2)));
+                }
+                if (kind[index - 1] === LAKE ||
+                    kind[index + 1] === LAKE ||
+                    kind[index - width] === LAKE ||
+                    kind[index + width] === LAKE) {
+                    flags |= BARRIER_LAKE_SHORE;
+                    value = Math.max(value, 90);
+                }
+            }
+            const cell = my * macro.width + (x >> 1);
+            if (macro.crest[cell] === 1 && macro.footprint[cell] >= 0.4) {
+                flags |= BARRIER_CREST;
+                value = Math.max(value, 150);
+            }
+            const wall = macro.barrier[cell];
+            if (wall === 1) {
+                flags |= BARRIER_WALL;
+                value = 255;
+            }
+            else if (wall === 2) {
+                flags |= BARRIER_FORT_LINE;
+                value = Math.max(value, 180);
+            }
+            strength[index] = Math.round(value);
+            sources[index] = flags;
+        }
+    }
+    return { width, height, strength, sources };
+}
+/** Build relief, hydrology, normals and fields for a geography model on a map of the given size. */
+export function synthesizeTerrain(input) {
+    const { geography, width, height, seed, kind } = input;
+    const relief = { ...DEFAULT_RELIEF, ...input.relief };
+    const total = width * height;
+    let landPixels = 0;
+    for (let index = 0; index < total; index += 1)
+        if (kind[index] === LAND)
+            landPixels += 1;
+    const notes = [];
+    const stage = input.onStage ?? (() => undefined);
+    stage('macro relief');
+    const macro = synthesizeMacroRelief({
+        geography,
+        width,
+        height,
+        seed,
+        kind,
+        relief,
+        signal: input.signal,
+    });
+    const adjust = input.adjustHeight;
+    if (adjust !== undefined)
+        for (let y = 0; y < macro.height; y += 1)
+            for (let x = 0; x < macro.width; x += 1) {
+                const cell = y * macro.width + x;
+                if (macro.kind[cell] === LAND)
+                    macro.heights[cell] = adjust(2 * x + 1, 2 * y + 1, macro.heights[cell]);
+            }
+    stage('hydrology');
+    const hydrology = synthesizeHydrology({
+        geography,
+        macro,
+        seed,
+        density: input.rivers?.density,
+        count: input.rivers?.count,
+        rainfall: input.rainfall,
+        landPixels,
+        signal: input.signal,
+    });
+    for (const note of hydrology.notes)
+        notes.push(note);
+    stage('full-resolution heights');
+    const floats = buildFullResolutionHeights({
+        macro: { ...macro, heights: hydrology.heights },
+        kind,
+        width,
+        height,
+        seed,
+        detail: relief.detail,
+        signal: input.signal,
+    });
+    stage('river pixels');
+    const raster = rasterizeRivers({
+        rivers: hydrology.rivers,
+        macroWidth: macro.width,
+        macroHeight: macro.height,
+        kind,
+        width,
+        height,
+        heights: floats,
+        seed,
+        pixelCap: Math.min(RIVER_PIXEL_CAP, Math.floor(0.025 * landPixels)),
+        signal: input.signal,
+    });
+    for (const note of raster.notes)
+        notes.push(note);
+    stage('quantise');
+    // Quantise once, at the end, monotonically: land from the floor, water by the bank rule.
+    const landDistance = landDistanceField(kind, width, height);
+    const heights = new Uint8Array(total);
+    const elevation = new Float32Array(total);
+    const snow = new Uint8Array(total);
+    for (let y = 0; y < height; y += 1) {
+        if (y % 64 === 0)
+            input.signal?.throwIfAborted();
+        for (let x = 0; x < width; x += 1) {
+            const index = y * width + x;
+            if (kind[index] === LAND) {
+                let value = floats[index];
+                value = value < LAND_FLOOR ? LAND_FLOOR : value > HEIGHT_CEILING ? HEIGHT_CEILING : value;
+                floats[index] = value;
+                const quantised = Math.round(value);
+                heights[index] = quantised;
+                elevation[index] = Math.min(1, Math.max(0, (quantised - LAND_FLOOR) / 110));
+                const line = macro.snowLine[(y >> 1) * macro.width + (x >> 1)];
+                if (line < 255 && quantised >= line)
+                    snow[index] = 1;
+            }
+            else {
+                const water = lakeHeight(landDistance[index]);
+                floats[index] = water;
+                heights[index] = water;
+                elevation[index] = (water - 94) / 30;
+            }
+        }
+    }
+    stage('normals and fields');
+    const normals = normalMap(floats, width, height, input.signal);
+    const barrier = barrierField(width, height, kind, heights, raster.bitmap, macro, input.signal);
+    const valley = {
+        width: macro.width,
+        height: macro.height,
+        scale: 2,
+        data: hydrology.valley,
+    };
+    const crestDistance = chamferDistance(macro.crest, macro.width, macro.height, 255);
+    const crestData = new Uint8Array(crestDistance.length);
+    for (let index = 0; index < crestData.length; index += 1)
+        crestData[index] = Math.min(255, Math.round(crestDistance[index] * 2));
+    const mountainData = new Uint8Array(macro.footprint.length);
+    for (let index = 0; index < mountainData.length; index += 1)
+        mountainData[index] =
+            macro.kind[index] === LAND ? Math.round(macro.footprint[index] * 255) : 0;
+    const fields = {
+        barrier,
+        valley,
+        crestDistance: { width: macro.width, height: macro.height, scale: 2, data: crestData },
+        mountain: { width: macro.width, height: macro.height, scale: 2, data: mountainData },
+    };
+    stage('checks');
+    const heightRaster = { width, height, kind, heights };
+    const statistics = reliefStatistics(heightRaster);
+    for (const note of checkRangesAndFeatures(geography, macro.ranges, heightRaster, (peak) => peakHeight(peak, macro.scale), (peak) => peakHeight(peak, macro.scale)))
+        notes.push(note);
+    if (geography.ranges.length > 0 && statistics.landPixels > 0 && statistics.p99 < 150)
+        notes.push({
+            code: 'MAP_RELIEF_FLAT',
+            severity: 'warning',
+            message: `The 99th percentile of land height is ${statistics.p99} although the model has ${geography.ranges.length} range(s); raise their peaks, or relief.scale`,
+            details: { p99: statistics.p99, ranges: geography.ranges.length },
+        });
+    // Rivers: the report, the straight-run metric and the density.
+    const entries = [];
+    const paths = [];
+    let riverCount = 0;
+    let named = 0;
+    let distributaries = 0;
+    hydrology.rivers.forEach((river, index) => {
+        const pixelRiver = raster.rivers[index];
+        const path = pixelRiver.pixels;
+        if (path.length === 0)
+            return;
+        riverCount += 1;
+        paths.push({ id: river.id, pixels: path });
+        if (river.junction === 'distributary')
+            distributaries += 1;
+        else if (river.named)
+            named += 1;
+        const first = path[0];
+        const last = path[path.length - 1];
+        const chordX = (first % width) - (last % width);
+        const chordY = Math.floor(first / width) - Math.floor(last / width);
+        const chord = Math.sqrt(chordX * chordX + chordY * chordY);
+        let widest = 3;
+        for (const value of river.width)
+            if (value > widest)
+                widest = value;
+        const parentId = river.parent >= 0 ? hydrology.rivers[river.parent].id : undefined;
+        entries.push({
+            id: river.id,
+            ...(river.name === undefined ? {} : { name: river.name }),
+            named: river.named,
+            pixels: path.length,
+            sinuosity: path.length <= 1 ? 1 : Math.round((chord / (path.length - 1)) * 1000) / 1000,
+            mouth: river.endsIn,
+            ...(parentId === undefined ? {} : { parent: parentId }),
+            junction: river.junction,
+            width: widest,
+            order: river.order,
+            complete: pixelRiver.complete,
+        });
+    });
+    const straight = straightRiverShare(raster.bitmap, width, height);
+    const straightShare = straight.river === 0 ? 0 : straight.straight / straight.river;
+    if (straight.river > 400 && straightShare > 0.03)
+        notes.push({
+            code: 'MAP_RIVER_STRAIGHT_RUN',
+            severity: 'warning',
+            message: `${(straightShare * 100).toFixed(1)}% of river pixels lie on straight stretches of 41 pixels or more (the base game: 1.1%); the ground there is flat, so the relief gives the rivers nothing to bend around`,
+            details: { riverPixels: straight.river, straightPixels: straight.straight },
+        });
+    const share = landPixels === 0 ? 0 : raster.pixels / landPixels;
+    if (landPixels > 20_000 &&
+        (share > 0.03 || (input.rivers?.density === undefined && share < 0.01)))
+        notes.push({
+            code: 'MAP_RIVER_DENSITY',
+            severity: 'warning',
+            message: `Rivers cover ${(share * 100).toFixed(2)}% of the land (${raster.pixels} pixels); the base game has 2.3% and long networks slow the game`,
+            details: { pixels: raster.pixels, landShare: Math.round(share * 10_000) / 10_000 },
+        });
+    const riverStatistics = {
+        pixels: raster.pixels,
+        landShare: share,
+        count: riverCount,
+        named,
+        distributaries,
+        streams: riverCount - named - distributaries,
+        straightShare: Math.round(straightShare * 10_000) / 10_000,
+    };
+    return {
+        width,
+        height,
+        heights,
+        normals,
+        riverBitmap: raster.bitmap,
+        riverOrder: raster.order,
+        elevation,
+        snow,
+        fields,
+        rivers: entries,
+        riverPaths: paths,
+        relief: statistics,
+        riverStatistics,
+        notes,
+    };
+}

package/dist/hoi4_agent_tools/map/render.js

@@ -2,6 +2,8 @@ import sharp from 'sharp';
 import { compareCodeUnits, canonicalJson, sha256Bytes } from '../core/canonical.js';
 import { assertRenderDimensions, RenderBudget, RENDER_MAX_PIXELS } from '../core/render-budget.js';
 import { ServiceError } from '../core/result.js';
+import { borderQualityInputFromIndex } from './border-quality-input.js';
+import { borderEdgePixels, forEachBorderEdge, measureBorderNaturalness } from './border-quality.js';
 import { buildMapCatalog } from './catalog.js';
 import { validateMapAsync } from './validation.js';
 function stableColor(key) {
@@ -155,10 +157,44 @@ function mapCoordinateToPixel(index, x, z) {
         ? undefined
         : pixel;
 }
+const borderRunColors = {
+    province: { r: 255, g: 255, b: 255 },
+    state: { r: 255, g: 64, b: 64 },
+    region: { r: 255, g: 224, b: 64 },
+    country: { r: 255, g: 64, b: 255 },
+};
+/**
+ * Border naturalness: the state borders (the province borders when there are no states) in green
+ * where they follow a river, slope, lake shore or terrain change and in orange where they do not,
+ * and the worst artificial run of every layer drawn two pixels wide in the layer's colour.
+ */
+async function paintBorderQuality(index, bytes, signal) {
+    const raster = index.raster;
+    const { input } = borderQualityInputFromIndex(index);
+    const measured = await measureBorderNaturalness(input, {
+        collectPaint: true,
+        ...(signal === undefined ? {} : { signal }),
+    });
+    const surface = input.layers.find(({ name }) => name === 'state') ?? input.layers[0];
+    if (surface !== undefined)
+        forEachBorderEdge(measured.table, surface.labels, (key, natural) => {
+            const [pixel] = borderEdgePixels(raster.width, key);
+            setPixel(bytes, raster.width, raster.height, pixel % raster.width, Math.floor(pixel / raster.width), natural ? { r: 86, g: 214, b: 126 } : { r: 226, g: 128, b: 48 });
+        });
+    for (const layer of input.layers) {
+        const color = borderRunColors[layer.name] ?? { r: 255, g: 255, b: 255 };
+        for (const keys of measured.paint?.get(layer.name) ?? [])
+            for (const key of keys)
+                for (const pixel of borderEdgePixels(raster.width, key))
+                    setPixel(bytes, raster.width, raster.height, pixel % raster.width, Math.floor(pixel / raster.width), color);
+    }
+}
 async function applyOverlays(index, bytes, overlays, signal) {
     const raster = index.raster;
     if (raster === undefined)
         return;
+    if (overlays.has('border-quality'))
+        await paintBorderQuality(index, bytes, signal);
     if (overlays.has('coastlines')) {
         for (let y = 0; y < raster.height; y += 1) {
             if (y % 32 === 0)