hoi4-agent-tools 4.3.0 → 4.4.0

package/dist/hoi4_agent_tools/map/water.js

@@ -0,0 +1,227 @@
+/**
+ * Lake and water conventions (ADR 0053). The engine draws a water layer everywhere with an alpha
+ * that depends on the heightmap, so what a lake looks like is decided by its height, not by its
+ * province type alone. These functions are shared by the generator and the validators.
+ */
+import { fractal } from './world-noise.js';
+const SEA = 0;
+const LAND = 1;
+const LAKE = 2;
+/** Engine constant: the water surface is a plane at 9.5 world units, heightmap value 95. */
+export const WATER_SURFACE_HEIGHT = 95;
+/** Height of sea and lake interiors in the base game (99.995% of its sea pixels). */
+export const WATER_INTERIOR_HEIGHT = 89;
+/** Largest height at which the water layer is fully opaque. */
+export const WATER_OPAQUE_HEIGHT = 91;
+/** Lowest height of land; coasts rise to this value. */
+export const LAND_MINIMUM_HEIGHT = 96;
+/**
+ * Heights of lake pixels at distance 1, 2, ... from the shore; deeper pixels use the interior
+ * height. Only the shore ring is translucent, so the lake reads as open water, not as specks.
+ */
+export const LAKE_BANK_HEIGHTS = [93, 91];
+/** A lake pixel within this distance of land may stand above `WATER_OPAQUE_HEIGHT` (up to 95). */
+export const LAKE_BANK_ALLOWANCE_PX = 3;
+export const LAKE_BANK_MAXIMUM_HEIGHT = 95;
+/** Enclosed water below this size is not a lake; it becomes land. */
+export const LAKE_MINIMUM_PIXELS = 60;
+/**
+ * Opacity of the water layer at a heightmap value: `1 - saturate((h / 95.7 - 0.954) * 25)`, as
+ * `pdxwater.shader` computes it (on a 3 x 3 average of the heightmap, which this ignores).
+ */
+export function waterAlpha(height) {
+    const t = (height / 95.7 - 0.954) * 25;
+    return 1 - Math.min(1, Math.max(0, t));
+}
+/** Height of a lake pixel `distance` pixels from the nearest land (1 is adjacent to land). */
+export function lakeHeight(distance) {
+    return distance >= 1 && distance <= LAKE_BANK_HEIGHTS.length
+        ? LAKE_BANK_HEIGHTS[distance - 1]
+        : WATER_INTERIOR_HEIGHT;
+}
+/**
+ * Four-neighbour distance from the nearest land pixel through water: 0 on land, 1 for water
+ * next to land, capped at `limit`. Pixels the search does not reach hold `limit`.
+ */
+export function landDistanceField(kind, width, height, limit = 255) {
+    const total = width * height;
+    const distance = new Uint8Array(total).fill(limit);
+    const queue = new Int32Array(total);
+    let head = 0;
+    let tail = 0;
+    for (let pixel = 0; pixel < total; pixel += 1)
+        if (kind[pixel] === LAND) {
+            distance[pixel] = 0;
+            queue[tail++] = pixel;
+        }
+    while (head < tail) {
+        const pixel = queue[head++];
+        const next = distance[pixel] + 1;
+        if (next >= limit)
+            continue;
+        const x = pixel % width;
+        const visit = (other) => {
+            if (distance[other] === limit && kind[other] !== LAND) {
+                distance[other] = next;
+                queue[tail++] = other;
+            }
+        };
+        if (x > 0)
+            visit(pixel - 1);
+        if (x < width - 1)
+            visit(pixel + 1);
+        if (pixel >= width)
+            visit(pixel - width);
+        if (pixel < total - width)
+            visit(pixel + width);
+    }
+    return distance;
+}
+/**
+ * Enforce the lake rules on a raster of 0 sea, 1 land and 2 lake (modified in place, with the
+ * matching elevation values): lake water that touches the open sea is sea, and enclosed water
+ * below `LAKE_MINIMUM_PIXELS` is land. Every change is reported.
+ */
+export function normalizeLakes(kind, elevation, width, height, minimumPixels = LAKE_MINIMUM_PIXELS) {
+    const total = width * height;
+    const notes = [];
+    const seen = new Uint8Array(total);
+    const queue = new Int32Array(total);
+    for (let start = 0; start < total; start += 1) {
+        if (kind[start] !== LAKE || seen[start])
+            continue;
+        let head = 0;
+        let tail = 0;
+        const found = { sea: false };
+        queue[tail++] = start;
+        seen[start] = 1;
+        while (head < tail) {
+            const pixel = queue[head++];
+            const x = pixel % width;
+            const visit = (other) => {
+                if (kind[other] === SEA)
+                    found.sea = true;
+                else if (kind[other] === LAKE && !seen[other]) {
+                    seen[other] = 1;
+                    queue[tail++] = other;
+                }
+            };
+            if (x > 0)
+                visit(pixel - 1);
+            if (x < width - 1)
+                visit(pixel + 1);
+            if (pixel >= width)
+                visit(pixel - width);
+            if (pixel < total - width)
+                visit(pixel + width);
+        }
+        if (!found.sea && tail >= minimumPixels)
+            continue;
+        const toSea = found.sea;
+        for (let index = 0; index < tail; index += 1) {
+            const pixel = queue[index];
+            kind[pixel] = toSea ? SEA : LAND;
+            elevation[pixel] = toSea ? -0.15 : 0.02;
+        }
+        const x = start % width;
+        notes.push({
+            code: toSea ? 'MAP_LAKE_CONNECTED_TO_SEA' : 'MAP_LAKE_TOO_SMALL',
+            message: toSea
+                ? `Lake water of ${tail} pixels touches the open sea and was written as sea`
+                : `Enclosed water of ${tail} pixels is below the ${minimumPixels} pixel lake floor and was written as land`,
+            pixels: tail,
+            x,
+            y: (start - x) / width,
+        });
+    }
+    return notes;
+}
+/**
+ * Sea tint by distance from land in vanilla-map pixels, fitted to the base game's water colour
+ * map: bright over the shelf, falling to a dark deep blue (measured means 59,102,138 at the
+ * coast, 83,130,175 at 5 to 10 pixels, 34,57,78 beyond 160).
+ */
+const SEA_CURVE = [
+    [0, 59, 102, 138],
+    [3, 73, 120, 161],
+    [7, 83, 130, 175],
+    [15, 69, 111, 153],
+    [30, 57, 92, 130],
+    [60, 45, 74, 106],
+    [120, 36, 60, 86],
+    [200, 34, 57, 78],
+];
+const LAKE_INTERIOR_TINT = [58, 102, 147];
+const LAKE_SHORE_TINT = [78, 128, 168];
+const DEEPEST_TINT = [26, 43, 59];
+const VANILLA_MAP_WIDTH = 5632;
+function curveAt(curve, distance) {
+    if (distance <= curve[0][0])
+        return [curve[0][1], curve[0][2], curve[0][3]];
+    for (let index = 1; index < curve.length; index += 1) {
+        const upper = curve[index];
+        if (distance <= upper[0]) {
+            const lower = curve[index - 1];
+            const t = (distance - lower[0]) / (upper[0] - lower[0]);
+            return [
+                lower[1] + (upper[1] - lower[1]) * t,
+                lower[2] + (upper[2] - lower[2]) * t,
+                lower[3] + (upper[3] - lower[3]) * t,
+            ];
+        }
+    }
+    const last = curve.at(-1);
+    return [last[1], last[2], last[3]];
+}
+/**
+ * One level of the water colour map as BGRA bytes (alpha 255), sampling the full-resolution
+ * rasters every `2 ** (level + 1)` pixels. Pure arithmetic plus value noise: platform-stable.
+ */
+export function waterColourLevel(input, level) {
+    const { width, height, kind, landDistance } = input;
+    const factor = 2 ** (level + 1);
+    const levelWidth = width / factor;
+    const levelHeight = height / factor;
+    const scale = Math.min(1.5, Math.max(0.35, width / VANILLA_MAP_WIDTH));
+    const patch = Math.max(48, width / 9);
+    const output = new Uint8Array(levelWidth * levelHeight * 4);
+    for (let y = 0; y < levelHeight; y += 1)
+        for (let x = 0; x < levelWidth; x += 1) {
+            const sx = x * factor;
+            const sy = y * factor;
+            const pixel = sy * width + sx;
+            const distance = landDistance[pixel];
+            let r;
+            let g;
+            let b;
+            const noise = fractal(input.seed + 3571, sx, sy, patch, 3) - 0.5;
+            if (kind[pixel] === LAKE) {
+                const t = Math.min(1, Math.max(0, (distance - 1) / 7));
+                const variation = 1 + noise * 0.3;
+                r = (LAKE_SHORE_TINT[0] + (LAKE_INTERIOR_TINT[0] - LAKE_SHORE_TINT[0]) * t) * variation;
+                g = (LAKE_SHORE_TINT[1] + (LAKE_INTERIOR_TINT[1] - LAKE_SHORE_TINT[1]) * t) * variation;
+                b = (LAKE_SHORE_TINT[2] + (LAKE_INTERIOR_TINT[2] - LAKE_SHORE_TINT[2]) * t) * variation;
+            }
+            else {
+                const [cr, cg, cb] = curveAt(SEA_CURVE, distance / scale);
+                // Open water varies in large patches; the shelf stays calmer.
+                const strength = 0.25 + 0.75 * Math.min(1, distance / (60 * scale));
+                const variation = Math.min(1.5, Math.max(0.6, 1 + noise * 2 * strength));
+                r = cr * variation;
+                g = cg * variation;
+                b = cb * variation;
+            }
+            const darkness = input.darken?.(sx, sy) ?? 0;
+            if (darkness > 0) {
+                r += (DEEPEST_TINT[0] - r) * darkness;
+                g += (DEEPEST_TINT[1] - g) * darkness;
+                b += (DEEPEST_TINT[2] - b) * darkness;
+            }
+            const offset = (y * levelWidth + x) * 4;
+            output[offset] = Math.min(255, Math.max(0, Math.round(b)));
+            output[offset + 1] = Math.min(255, Math.max(0, Math.round(g)));
+            output[offset + 2] = Math.min(255, Math.max(0, Math.round(r)));
+            output[offset + 3] = 255;
+        }
+    return output;
+}

package/dist/hoi4_agent_tools/map/world-context.js

@@ -68,6 +68,8 @@ export function buildWorldContext(base) {
         .filter((file) => /^common\/terrain\/[^/]+\.txt$/u.test(normalized(file.relativePath)))
         .sort((a, b) => compareCodeUnits(normalized(a.relativePath), normalized(b.relativePath)));
     const terrainIndex = new Map();
+    const unrendered = [];
+    const entries = [];
     for (const file of terrainFiles) {
         const candidates = new Map();
         const terrain = assignments(documentFor(file).root, 'terrain');
@@ -102,9 +104,25 @@ export function buildWorldContext(base) {
                         invalid(file, 'Graphical terrain refers to a missing terrain palette entry.');
                     index = Math.min(index, value);
                 }
+                const name = entry.key.value;
+                const textureValue = firstScalar(entry.value, 'texture')?.value;
+                entries.push({
+                    name,
+                    index,
+                    type,
+                    ...(textureValue !== undefined && /^\d+$/u.test(textureValue)
+                        ? { texture: Number(textureValue) }
+                        : {}),
+                    permSnow: firstScalar(entry.value, 'perm_snow')?.value === 'yes',
+                });
+                // Texture 255 names no atlas tile: the engine draws nothing useful for that index, so it
+                // is never chosen to represent a category (the base game's `lakes` entry is one).
+                if (firstScalar(entry.value, 'texture')?.value === '255') {
+                    unrendered.push({ name, index, type, reason: 'texture = 255 selects no atlas tile' });
+                    continue;
+                }
                 // Prefer ordinary category variants over cross-category names or permanent snow.
                 // Within an equal rank, the lowest declared index is the stable representative.
-                const name = entry.key.value;
                 let rank = name === type ? 0 : name.startsWith(`${type}_`) || /^terrain_\d+$/u.test(name) ? 1 : 2;
                 if (firstScalar(entry.value, 'perm_snow')?.value === 'yes')
                     rank += 4;
@@ -119,6 +137,11 @@ export function buildWorldContext(base) {
         for (const [type, candidate] of candidates)
             terrainIndex.set(type, candidate.index);
     }
+    if (entries.length > 0)
+        context.terrainEntries = entries.sort((a, b) => a.index - b.index || compareCodeUnits(a.name, b.name));
+    const gaps = unrendered.filter(({ type }) => !terrainIndex.has(type));
+    if (gaps.length > 0)
+        context.unrenderedTerrain = gaps;
     if (terrainIndex.size > 0)
         context.terrainIndex = new Map([...terrainIndex].sort(([a], [b]) => compareCodeUnits(a, b)));
     const categoryFiles = base.activeFiles.all

package/dist/hoi4_agent_tools/map/world-edge.js

@@ -0,0 +1,335 @@
+/**
+ * World edge and seam policy (ADR 0061). The engine wraps the map horizontally and draws it as a
+ * sphere for day and night, so land that touches column 0 or the last column is cut by a straight
+ * line where the world repeats. This module keeps land away from the seam and the poles, or ends
+ * it in an impassable rim, and writes the north and south frame borders the base map has.
+ */
+import { ServiceError } from '../core/result.js';
+import { valueNoise } from './world-noise.js';
+const SEA = 0;
+const LAND = 1;
+/** Lowest height of the rim range at its inner foot, and its height at the seam. */
+export const RIM_FOOT_HEIGHT = 150;
+export const RIM_SEAM_HEIGHT = 230;
+/** The darkest rim colour multiplier, at the seam. */
+export const RIM_COLOUR_FACTOR = 0.55;
+/**
+ * Resolve the optional `edge` input against the world size. Omitting it keeps the previous
+ * behaviour (`none`); an `edge` object without a mode asks for the open-sea band.
+ */
+export function resolveEdge(input, width, height) {
+    if (input === undefined)
+        return { mode: 'none', bandPx: 0, polarPx: 0, rimPx: 0 };
+    const mode = input.mode ?? 'sea-band';
+    const quarter = Math.floor(width / 4);
+    const polarLimit = Math.floor(height / 4);
+    const bandPx = input.bandPx ?? Math.min(Math.max(192, Math.round(0.04 * width)), quarter);
+    const polarPx = input.polarPx ?? Math.min(64, Math.floor(height / 8));
+    const rimPx = input.rimPx ?? Math.min(160, quarter);
+    if (bandPx > quarter || rimPx > quarter || polarPx > polarLimit)
+        throw new ServiceError('MAP_EDGE_BAND_TOO_WIDE', 'The edge band and rim may not exceed a quarter of the world width, nor the polar band a quarter of its height', { width, height, bandPx, rimPx, polarPx, maximumWidth: quarter, maximumHeight: polarLimit });
+    if (mode === 'none')
+        return { mode, bandPx: 0, polarPx: 0, rimPx: 0 };
+    return {
+        mode,
+        bandPx: mode === 'sea-band' ? bandPx : 0,
+        polarPx,
+        rimPx: mode === 'rim' ? rimPx : 0,
+    };
+}
+/** Cities and named land features may not stand where the policy clears land. */
+export function assertFeaturesOutsideBand(edge, width, height, features) {
+    if (edge.mode === 'none')
+        return;
+    const offenders = features.filter((feature) => {
+        if (feature.kind === 'sea')
+            return false;
+        const northSouth = feature.y < edge.polarPx || feature.y >= height - edge.polarPx;
+        const eastWest = edge.mode === 'sea-band' && (feature.x < edge.bandPx || feature.x >= width - edge.bandPx);
+        return northSouth || eastWest;
+    });
+    if (offenders.length === 0)
+        return;
+    throw new ServiceError('MAP_EDGE_FEATURE_IN_BAND', `${offenders.length} named feature(s) stand inside the world edge band, where land is cleared: ${offenders
+        .slice(0, 5)
+        .map((feature) => `${feature.name} (${Math.round(feature.x)}, ${Math.round(feature.y)})`)
+        .join('; ')}. Move them inland or choose edge.mode "none" or "rim".`, {
+        mode: edge.mode,
+        bandPx: edge.bandPx,
+        polarPx: edge.polarPx,
+        features: offenders.slice(0, 20),
+    });
+}
+/** Per-row (east-west) and per-column (north-south) clearing limits with a ragged outline. */
+function limits(edge, width, height, seed) {
+    const rows = new Int32Array(height);
+    const columns = new Int32Array(width);
+    const scaleY = Math.max(8, edge.bandPx / 3);
+    const scaleX = Math.max(8, edge.polarPx / 1.5);
+    for (let y = 0; y < height; y += 1)
+        rows[y] =
+            edge.mode === 'sea-band'
+                ? edge.bandPx + Math.round(valueNoise(seed + 9187, y / scaleY, 0.5) * edge.bandPx * 0.5)
+                : 0;
+    for (let x = 0; x < width; x += 1)
+        columns[x] =
+            edge.polarPx > 0
+                ? edge.polarPx + Math.round(valueNoise(seed + 9293, x / scaleX, 0.5) * edge.polarPx * 0.5)
+                : 0;
+    return { rows, columns };
+}
+function landComponents(kind, width) {
+    const label = new Int32Array(kind.length).fill(-1);
+    const sizes = [];
+    const queue = new Int32Array(kind.length);
+    const total = kind.length;
+    for (let start = 0; start < total; start += 1) {
+        if (kind[start] !== LAND || label[start] !== -1)
+            continue;
+        const id = sizes.length;
+        let head = 0;
+        let tail = 0;
+        queue[tail++] = start;
+        label[start] = id;
+        while (head < tail) {
+            const pixel = queue[head++];
+            const x = pixel % width;
+            const visit = (other) => {
+                if (kind[other] === LAND && label[other] === -1) {
+                    label[other] = id;
+                    queue[tail++] = other;
+                }
+            };
+            if (x > 0)
+                visit(pixel - 1);
+            if (x < width - 1)
+                visit(pixel + 1);
+            if (pixel >= width)
+                visit(pixel - width);
+            if (pixel < total - width)
+                visit(pixel + width);
+        }
+        sizes.push(tail);
+    }
+    return { label, sizes };
+}
+/**
+ * Clear land and lakes from the east, west, north and south bands (modifying `kind` and
+ * `elevation` in place). The outline is ragged so the cleared coast does not read as a ruled
+ * line; land fragments the clearing detached sink when smaller than `minimumIsland`.
+ */
+export function applyEdgePolicy(kind, elevation, width, height, edge, seed, minimumIsland) {
+    if (edge.mode === 'none')
+        return { notes: [], clearedLandPixels: 0 };
+    const before = landComponents(kind, width);
+    const { rows, columns } = limits(edge, width, height, seed);
+    const cleared = new Uint8Array(kind.length);
+    let clearedLand = 0;
+    for (let y = 0; y < height; y += 1)
+        for (let x = 0; x < width; x += 1) {
+            const limitX = rows[y];
+            const clear = x < limitX || x >= width - limitX || y < columns[x] || y >= height - columns[x];
+            if (!clear)
+                continue;
+            const pixel = y * width + x;
+            cleared[pixel] = 1;
+            if (kind[pixel] === LAND)
+                clearedLand += 1;
+            if (kind[pixel] !== SEA)
+                kind[pixel] = SEA;
+        }
+    const after = landComponents(kind, width);
+    let sunk = 0;
+    for (let pixel = 0; pixel < kind.length; pixel += 1) {
+        if (kind[pixel] !== LAND)
+            continue;
+        const size = after.sizes[after.label[pixel]];
+        if (size < before.sizes[before.label[pixel]] && size < minimumIsland) {
+            kind[pixel] = SEA;
+            cleared[pixel] = 1;
+            sunk += 1;
+        }
+    }
+    reshapeClearedCoast(kind, elevation, cleared, width, height);
+    const notes = [];
+    if (clearedLand + sunk > 0)
+        notes.push({
+            code: 'MAP_EDGE_LAND_CLEARED',
+            severity: 'warning',
+            message: `The ${edge.mode} edge policy cleared ${clearedLand} land pixels to open sea${sunk > 0 ? ` and sank ${sunk} pixels of fragments it detached` : ''}; land that must reach the edge needs edge.mode "rim"`,
+            details: { mode: edge.mode, clearedLandPixels: clearedLand, sunkFragmentPixels: sunk },
+        });
+    return { notes, clearedLandPixels: clearedLand + sunk };
+}
+/**
+ * Give the new coast a shelf and a coastal land ramp, as the reference interpretation does for
+ * its own coast: cleared sea deepens from the shore, and land next to the cut rises from sea
+ * level. Cleared pixels away from any coast become the deep sea value.
+ */
+function reshapeClearedCoast(kind, elevation, cleared, width, height) {
+    const total = kind.length;
+    const ramp = Math.max(4, Math.round(Math.min(width, height) / 120));
+    const distance = new Uint16Array(total).fill(65535);
+    const queue = new Int32Array(total);
+    let head = 0;
+    let tail = 0;
+    for (let pixel = 0; pixel < total; pixel += 1) {
+        if (cleared[pixel])
+            elevation[pixel] = -0.15;
+        if (kind[pixel] !== LAND)
+            continue;
+        const x = pixel % width;
+        const touchesCleared = (x > 0 && cleared[pixel - 1] === 1 && kind[pixel - 1] === SEA) ||
+            (x < width - 1 && cleared[pixel + 1] === 1 && kind[pixel + 1] === SEA) ||
+            (pixel >= width && cleared[pixel - width] === 1 && kind[pixel - width] === SEA) ||
+            (pixel < total - width && cleared[pixel + width] === 1 && kind[pixel + width] === SEA);
+        if (touchesCleared) {
+            distance[pixel] = 0;
+            queue[tail++] = pixel;
+        }
+    }
+    while (head < tail) {
+        const pixel = queue[head++];
+        const next = distance[pixel] + 1;
+        if (next > ramp)
+            continue;
+        const x = pixel % width;
+        const visit = (other) => {
+            if (distance[other] !== 65535)
+                return;
+            // Land spreads inland; the shelf spreads only over cleared water.
+            if (kind[other] === LAND || (kind[other] === SEA && cleared[other] === 1)) {
+                distance[other] = next;
+                queue[tail++] = other;
+            }
+        };
+        if (x > 0)
+            visit(pixel - 1);
+        if (x < width - 1)
+            visit(pixel + 1);
+        if (pixel >= width)
+            visit(pixel - width);
+        if (pixel < total - width)
+            visit(pixel + width);
+    }
+    for (let pixel = 0; pixel < total; pixel += 1) {
+        const d = distance[pixel];
+        if (d === 65535)
+            continue;
+        const t = Math.min(1, d / ramp);
+        const factor = t * t * (3 - 2 * t);
+        if (kind[pixel] === LAND)
+            elevation[pixel] = elevation[pixel] * factor;
+        else
+            elevation[pixel] = -0.15 * factor;
+    }
+}
+function smooth(t) {
+    const clamped = Math.min(1, Math.max(0, t));
+    return clamped * clamped * (3 - 2 * clamped);
+}
+/**
+ * Rim strength 0 to 1 at a column: 0 at the inner foot, 1 at the seam. Zero outside `rim` mode.
+ */
+export function rimStrength(edge, width, x) {
+    if (edge.mode !== 'rim')
+        return 0;
+    const distance = Math.min(x, width - 1 - x);
+    return distance >= edge.rimPx ? 0 : smooth(1 - distance / edge.rimPx);
+}
+/** The rim height for an existing land height at the given strength. */
+export function rimHeight(existing, strength) {
+    if (strength <= 0)
+        return existing;
+    const target = RIM_FOOT_HEIGHT + (RIM_SEAM_HEIGHT - RIM_FOOT_HEIGHT) * strength;
+    return Math.min(255, Math.round(existing + (target - existing) * strength));
+}
+/**
+ * Darkening of the water colour map toward the deepest tint, 0 to 1: full at the seam, none at
+ * the inner edge of the band, and a shorter fade at the poles.
+ */
+export function edgeWaterDarkness(edge, width, height, x, y) {
+    if (edge.mode === 'none')
+        return 0;
+    const sideDistance = Math.min(x, width - 1 - x);
+    const side = edge.mode === 'sea-band' ? smooth(1 - sideDistance / (edge.bandPx * 1.2)) : 0;
+    const poleDistance = Math.min(y, height - 1 - y);
+    const pole = edge.polarPx > 0 ? smooth(1 - poleDistance / (edge.polarPx * 1.2)) * 0.8 : 0;
+    return Math.max(side, pole);
+}
+/**
+ * Impassable rows for every pair of distinct land provinces that meet across the seam, in
+ * `adjacencies.csv` order (rows are sorted by the lower then the higher province ID).
+ */
+export function rimAdjacencyRows(input) {
+    const { provincePixels, provinceKinds, width, height } = input;
+    const pairs = new Set();
+    for (let y = 0; y < height; y += 1) {
+        const left = provincePixels[y * width];
+        const right = provincePixels[y * width + width - 1];
+        if (left === right || provinceKinds[left] !== LAND || provinceKinds[right] !== LAND)
+            continue;
+        const low = Math.min(left, right) + 1;
+        const high = Math.max(left, right) + 1;
+        pairs.add(`${low};${high}`);
+    }
+    return [...pairs]
+        .sort((a, b) => {
+        const [al, ah] = a.split(';').map(Number);
+        const [bl, bh] = b.split(';').map(Number);
+        return al - bl || ah - bh;
+    })
+        .map((pair) => `${pair};impassable;-1;-1;-1;-1;-1;;World rim`);
+}
+/** Heights and positions of the base map's frame meshes, scaled to the world size. */
+export function frameBorderPositions(width, height) {
+    return {
+        top: height + 142,
+        bottom: -140,
+        logoX: Math.round(0.5327 * width),
+        logoZ: height + 82,
+    };
+}
+/**
+ * `ambient_object.txt` with the wind entity and the north, south and logo frame borders. Ambient
+ * water objects and the DLC wall mesh of the base map are left out: their positions belong to
+ * the base map's geography.
+ */
+export function ambientObjectText(width, height) {
+    const frame = frameBorderPositions(width, height);
+    const block = (type, options) => [
+        'type={',
+        `\ttype="${type}"`,
+        '\tuse_animation=no',
+        ...(options.scale === undefined ? [] : [`\tscale=${options.scale.toFixed(6)}`]),
+        '\talways_visible=yes',
+        '\tobject={',
+        `\t\tname="${options.name}"`,
+        '\t\tposition={',
+        `\t\t\t${options.position.join(' ')} `,
+        '\t\t}',
+        '\t\trotation={',
+        '\t\t\t0 0 0 ',
+        '\t\t}',
+        '\t}',
+        '}',
+    ].join('\n');
+    return `${[
+        block('ambient_wind_entity', { name: 'ambient_wind', position: [0, 0, 0] }),
+        block('frame_border_entity', {
+            scale: 100,
+            name: 'frame_border_entity_top',
+            position: [0, 0, frame.top],
+        }),
+        block('frame_border_bottom_entity', {
+            scale: 100,
+            name: 'frame_border_bottom_entity_bottom',
+            position: [0, 0, frame.bottom],
+        }),
+        block('frame_border_logo_entity', {
+            scale: 300,
+            name: 'frame_border_logo_entity_top',
+            position: [frame.logoX, -1, frame.logoZ],
+        }),
+    ].join('\n')}\n`;
+}

package/dist/hoi4_agent_tools/map/world-noise.js

@@ -0,0 +1,34 @@
+/** Deterministic value noise shared by world generation. Only + - * / are used, so the output is
+ * identical on every platform. */
+export function lattice(seed, x, y) {
+    let hash = Math.imul(x, 374761393) + Math.imul(y, 668265263) + Math.imul(seed, 982451653);
+    hash = Math.imul(hash ^ (hash >>> 13), 1274126177);
+    return ((hash ^ (hash >>> 16)) >>> 0) / 4294967296;
+}
+export function smooth(t) {
+    return t * t * (3 - 2 * t);
+}
+export function valueNoise(seed, x, y) {
+    const x0 = Math.floor(x);
+    const y0 = Math.floor(y);
+    const tx = smooth(x - x0);
+    const ty = smooth(y - y0);
+    const a = lattice(seed, x0, y0);
+    const b = lattice(seed, x0 + 1, y0);
+    const c = lattice(seed, x0, y0 + 1);
+    const d = lattice(seed, x0 + 1, y0 + 1);
+    return a + (b - a) * tx + (c - a) * ty + (a - b - c + d) * tx * ty;
+}
+export function fractal(seed, x, y, scale, octaves = 5) {
+    let total = 0;
+    let amplitude = 1;
+    let weight = 0;
+    let frequency = 1 / scale;
+    for (let octave = 0; octave < octaves; octave += 1) {
+        total += valueNoise(seed + octave * 101, x * frequency, y * frequency) * amplitude;
+        weight += amplitude;
+        amplitude *= 0.5;
+        frequency *= 2;
+    }
+    return total / weight;
+}