hoi4-agent-tools 4.5.0 → 4.6.0

package/dist/hoi4_agent_tools/map/gameplay/development.js

@@ -0,0 +1,168 @@
+/**
+ * The development model of a geography world (ADR 0063): population, state category,
+ * infrastructure, factories, resources and victory points follow from the fertility the model
+ * states, river access, the coast, passes and the model's sites, not from random rolls. Every
+ * number is a fixed function of those inputs, so two runs agree and a change in the model moves
+ * the economy in the direction the model says.
+ */
+import { nearestOnPolyline } from '../geography/index.js';
+import { LAND, centerOf } from './facts.js';
+import { fertilityOf } from './metrics.js';
+import { SITE_VICTORY_POINTS, SITE_WEIGHT, VICTORY_SITE_KINDS } from './sites.js';
+function clamp01(value) {
+    return value < 0 ? 0 : value > 1 ? 1 : value;
+}
+/** The ore a range gives, by its profile. */
+const RANGE_RESOURCE = {
+    ridge: 'steel',
+    massif: 'tungsten',
+    escarpment: 'chromium',
+    wall: 'steel',
+};
+export function developStates(base, metrics, sites, terrain, states, ports, options) {
+    const { geography, provinces, width, height } = base.input;
+    const kind = provinces.kind;
+    const count = base.view.count;
+    const fertility = new Float32Array(count);
+    const province = new Float32Array(count);
+    // Sites by province.
+    const siteStrength = new Float64Array(count);
+    const victorySites = new Map();
+    for (const { site, province: id } of sites) {
+        if (id === undefined)
+            continue;
+        siteStrength[id] = Math.max(siteStrength[id], SITE_WEIGHT[site.siteKind] * (0.4 + (site.importance * 0.6) / 5));
+        if (VICTORY_SITE_KINDS.has(site.siteKind))
+            victorySites.set(id, Math.max(victorySites.get(id) ?? 0, SITE_VICTORY_POINTS[site.importance - 1] ?? 3));
+    }
+    const gateProvince = new Set();
+    for (const [a, b] of base.crossings.gates) {
+        gateProvince.add(a);
+        gateProvince.add(b);
+    }
+    const hasSea = (id) => [...provinces.neighbors[id]].some((other) => kind[other] === 0);
+    const hasLake = (id) => [...provinces.neighbors[id]].some((other) => kind[other] === 2);
+    for (let id = 0; id < count; id += 1) {
+        if (kind[id] !== LAND)
+            continue;
+        const f = fertilityOf(metrics, id, terrain.get(id) ?? 'plains');
+        fertility[id] = f;
+        const river = clamp01(metrics.riverPixels[id] / Math.max(8, 2 * Math.sqrt(provinces.size[id])));
+        province[id] = clamp01(0.55 * f +
+            0.12 * river +
+            0.1 * (hasSea(id) ? 1 : 0) +
+            0.06 * (hasLake(id) ? 1 : 0) +
+            0.08 * (gateProvince.has(id) ? 1 : 0) +
+            0.3 * siteStrength[id] -
+            0.15 * metrics.mountain[id]);
+    }
+    // Ore from the ranges: provinces of mountain terrain near a range crest, richest first.
+    const resourcesOf = new Map();
+    const addResource = (id, name, amount) => {
+        const own = resourcesOf.get(id) ?? new Map();
+        own.set(name, (own.get(name) ?? 0) + amount);
+        resourcesOf.set(id, own);
+    };
+    for (const range of geography.ranges) {
+        const members = [];
+        for (let id = 0; id < count; id += 1) {
+            if (kind[id] !== LAND || metrics.mountain[id] < 0.3)
+                continue;
+            const centre = centerOf(provinces, id);
+            const near = nearestOnPolyline(range.path, geography.frame, centre.x / width, centre.y / height);
+            if (near.distance <= Math.max(near.halfWidth * 1.5, 0.004))
+                members.push(id);
+        }
+        if (members.length === 0)
+            continue;
+        members.sort((a, b) => metrics.mountain[b] - metrics.mountain[a] || a - b);
+        const deposits = Math.max(1, Math.ceil(members.length / 3));
+        let peak = 0;
+        for (const value of range.path.peak)
+            peak += value;
+        peak /= Math.max(1, range.path.peak.length);
+        const amount = 2 + Math.round(6 * peak);
+        const resource = RANGE_RESOURCE[range.profile] ?? 'steel';
+        for (const id of members.slice(0, deposits))
+            addResource(id, resource, amount);
+    }
+    // Rubber in the richest jungle.
+    const jungle = [...terrain]
+        .filter(([id, name]) => name === 'jungle' && kind[id] === LAND)
+        .map(([id]) => id)
+        .sort((a, b) => fertility[b] - fertility[a] || a - b);
+    for (const id of jungle.slice(0, Math.ceil(jungle.length * 0.4)))
+        addResource(id, 'rubber', 1 + Math.round(4 * fertility[id]));
+    // Mine sites name their resource (steel when they do not).
+    for (const { site, province: id } of sites)
+        if (site.siteKind === 'mine' && id !== undefined)
+            addResource(id, site.resource ?? 'steel', 2 + site.importance * 3);
+    const result = new Map();
+    const urban = new Set();
+    const categories = options.categories;
+    for (const state of states) {
+        let pixels = 0;
+        let fertilitySum = 0;
+        let developmentSum = 0;
+        let bestSite = 0;
+        let bestProvince = state.provinces[0];
+        for (const id of state.provinces) {
+            const size = provinces.size[id];
+            pixels += size;
+            fertilitySum += fertility[id] * size;
+            developmentSum += province[id] * size;
+            bestSite = Math.max(bestSite, siteStrength[id]);
+            if (province[id] > province[bestProvince] ||
+                (province[id] === province[bestProvince] &&
+                    provinces.size[id] > provinces.size[bestProvince]))
+                bestProvince = id;
+        }
+        const meanFertility = fertilitySum / pixels;
+        const development = clamp01(developmentSum / pixels + 0.25 * bestSite + (state.isCapital ? 0.25 : 0));
+        const barren = meanFertility < 0.1 && bestSite === 0 && !state.isCapital;
+        let index = Math.round(development * 5.2 + (state.isCapital ? 1 : 0) + bestSite * 1.5);
+        index = Math.max(barren ? 0 : 1, Math.min(categories.length - 1, index));
+        let category = categories[index];
+        if (options.allowedCategories !== undefined && !options.allowedCategories.has(category))
+            category = options.allowedCategories.has('rural')
+                ? 'rural'
+                : ([...options.allowedCategories][0] ?? 'rural');
+        const slots = options.slotsFor[category] ?? 2;
+        const civilian = Math.round(slots * (0.25 + 0.3 * development));
+        const military = Math.min(slots - civilian, Math.round(slots * 0.3 * development));
+        const stateResources = new Map();
+        for (const id of state.provinces)
+            for (const [name, amount] of resourcesOf.get(id) ?? [])
+                stateResources.set(name, (stateResources.get(name) ?? 0) + amount);
+        const victoryPoints = new Map();
+        for (const id of state.provinces) {
+            const value = victorySites.get(id);
+            if (value !== undefined)
+                victoryPoints.set(id, value);
+        }
+        for (const id of state.provinces)
+            if (options.capitalProvinces.has(id))
+                victoryPoints.set(id, Math.max(25, victoryPoints.get(id) ?? 0));
+        if (victoryPoints.size === 0)
+            victoryPoints.set(bestProvince, Math.max(1, Math.round(province[bestProvince] * 8)));
+        for (const [id, value] of victoryPoints)
+            if (value >= 8)
+                urban.add(id);
+        const airBase = state.isCapital ? 2 : 0;
+        result.set(state.id, {
+            id: state.id,
+            manpower: Math.max(1_000, Math.round((pixels * 180 * Math.max(0.08, development)) / 1_000) * 1_000),
+            category,
+            infrastructure: Math.max(1, Math.min(5, Math.round(1 + development * 3 + (state.isCapital ? 1 : 0)))),
+            civilian,
+            military,
+            dockyard: ports.dockyards.has(state.id) && slots - civilian - military > 0 ? 1 : 0,
+            airBase,
+            resources: stateResources,
+            victoryPoints,
+            development,
+            fertility: meanFertility,
+        });
+    }
+    return { states: result, urban, province, fertility };
+}

package/dist/hoi4_agent_tools/map/gameplay/economy.js

@@ -0,0 +1,75 @@
+/**
+ * The second stage of the geography-driven gameplay layer (ADR 0063): once states, strategic
+ * regions and owners exist, plan the ports, the development of every state, the names and the
+ * railway cost model from the model, and gather the notes they raise.
+ */
+import { computeMetrics } from './metrics.js';
+import { developStates } from './development.js';
+import { nameWorld } from './names.js';
+import { harbourScores, planPorts } from './ports.js';
+import { buildRailCost } from './rail-cost.js';
+import { locateSites } from './sites.js';
+export function planEconomy(base, input) {
+    const metrics = computeMetrics(base.input, base.view);
+    const sites = locateSites(base);
+    const harbours = harbourScores(base, metrics, sites);
+    const ports = planPorts(base, harbours, sites, input.states.map((state) => ({
+        id: state.id,
+        provinces: state.provinces,
+        owner: state.owner,
+        capital: state.isCapital,
+    })));
+    const development = developStates(base, metrics, sites, input.terrain, input.states, ports, input.options);
+    const victoryPoints = new Map();
+    for (const [id, state] of development.states)
+        victoryPoints.set(id, state.victoryPoints);
+    const names = nameWorld({
+        base,
+        metrics,
+        sites,
+        states: input.states,
+        regionOf: input.regionOf,
+        fixedStates: input.fixedStateNames,
+        fixedRegions: input.fixedRegionNames,
+        victoryPoints,
+        countryNames: input.countryNames,
+    });
+    const terrain = new Map(input.terrain);
+    for (const id of development.urban)
+        terrain.set(id, 'urban');
+    const trunk = new Set();
+    for (const state of development.states.values())
+        for (const [province, value] of state.victoryPoints)
+            if (value >= 8)
+                trunk.add(province + 1);
+    const railCost = buildRailCost(base, metrics, terrain, trunk);
+    const forts = new Map();
+    for (const { province, level } of base.crossings.forts)
+        forts.set(province, Math.max(forts.get(province) ?? 0, level));
+    const notes = [...ports.notes, ...names.notes];
+    let waterSites = 0;
+    for (const located of sites) {
+        if (located.province === undefined && !located.site.onWater)
+            waterSites += 1;
+    }
+    if (waterSites > 0)
+        notes.push({
+            code: 'MAP_SITE_UNPLACED',
+            severity: 'warning',
+            message: `${waterSites} site(s) of the model lie farther than a few pixels from any land province, so they name nothing and give no victory point`,
+            details: { sites: waterSites },
+        });
+    notes.push({
+        code: 'MAP_DEVELOPMENT_PLANNED',
+        severity: 'info',
+        message: `Planned ${ports.ports.size} port(s), ${development.states.size} state economies, ${names.counts.states.total - names.counts.states.placeholders} of ${names.counts.states.total} state names and ${base.crossings.summary.straits + base.crossings.summary.canals} crossing(s) from the geography model`,
+        details: {
+            ports: ports.ports.size,
+            states: development.states.size,
+            namedStates: names.counts.states.total - names.counts.states.placeholders,
+            namedRegions: names.counts.regions.total - names.counts.regions.placeholders,
+            sites: sites.length,
+        },
+    });
+    return { metrics, sites, harbours, ports, development, names, railCost, forts, notes };
+}

package/dist/hoi4_agent_tools/map/gameplay/facts.js

@@ -0,0 +1,264 @@
+/**
+ * Facts about the provinces of a generated world that the geography-driven stages share
+ * (ADR 0062, 0063): which model land, region, sea or lake each province belongs to, how the
+ * provinces border each other, and where they lie. Everything is computed from the province
+ * raster in single passes with typed arrays and no randomness, so two runs give the same facts.
+ */
+import { scanAreaStrip, } from '../geography/index.js';
+export const SEA = 0;
+export const LAND = 1;
+export const LAKE = 2;
+/** The coarse grid the model's areas are painted on for containment votes. */
+export const FACT_GRID_WIDTH = 1_024;
+export function factGrid(width, height) {
+    const scale = Math.min(1, FACT_GRID_WIDTH / width);
+    return {
+        width: Math.max(1, Math.round(width * scale)),
+        height: Math.max(1, Math.round(height * scale)),
+    };
+}
+/**
+ * Paint areas on a grid: each cell holds the 1-based position of the last area that covers it
+ * (0 for none), so later entries win where areas overlap.
+ */
+export function paintAreas(areas, grid) {
+    const data = new Uint16Array(grid.width * grid.height);
+    const strip = { y0: 0, y1: grid.height };
+    for (const [position, area] of areas.entries()) {
+        const value = position + 1;
+        scanAreaStrip(area, grid, strip, (y, x0, x1) => {
+            data.fill(value, y * grid.width + x0, y * grid.width + x1);
+        });
+    }
+    return data;
+}
+/**
+ * For every province the value its sampled pixels most often take in a painted raster; 0 when no
+ * sample falls on a painted cell. Ties go to the smaller value. `stride` samples every n-th pixel
+ * on both axes.
+ */
+export function provinceModes(view, raster, grid, stride = 3, only, minShare = 0) {
+    const votes = new Map();
+    const samples = new Int32Array(view.count);
+    const { width, height, pixel } = view;
+    for (let y = 0; y < height; y += stride) {
+        const gy = Math.min(grid.height - 1, Math.floor(((y + 0.5) * grid.height) / height));
+        for (let x = 0; x < width; x += stride) {
+            const gx = Math.min(grid.width - 1, Math.floor(((x + 0.5) * grid.width) / width));
+            const value = raster[gy * grid.width + gx];
+            const province = pixel[y * width + x];
+            if (only !== undefined && !only(province))
+                continue;
+            samples[province] += 1;
+            if (value === 0)
+                continue;
+            const key = province * 65_536 + value;
+            votes.set(key, (votes.get(key) ?? 0) + 1);
+        }
+    }
+    const best = new Int32Array(view.count);
+    const bestVotes = new Int32Array(view.count);
+    for (const [key, count] of [...votes].sort((left, right) => left[0] - right[0])) {
+        const province = Math.floor(key / 65_536);
+        if (count > bestVotes[province] && count >= minShare * samples[province]) {
+            bestVotes[province] = count;
+            best[province] = key - province * 65_536;
+        }
+    }
+    return best;
+}
+export function pairKey(a, b, count) {
+    return a < b ? a * count + b : b * count + a;
+}
+export function pairOf(key, count) {
+    const a = Math.floor(key / count);
+    return [a, key - a * count];
+}
+/**
+ * Every border between two provinces, wrapping across the east-west seam. Pixel pairs are the
+ * right-hand and lower neighbours of each pixel.
+ */
+export function buildBorderTable(input) {
+    const { width, height, pixel, count } = input.view;
+    const { heights, rivers } = input;
+    const table = new Map();
+    const visit = (a, b, p, q) => {
+        const key = pairKey(a, b, count);
+        let stat = table.get(key);
+        if (stat === undefined) {
+            stat = { count: 0, rivers: 0, step: 0, top: 0, sumX: 0, sumY: 0 };
+            table.set(key, stat);
+        }
+        stat.count += 1;
+        if (rivers[p] <= 11 || rivers[q] <= 11)
+            stat.rivers += 1;
+        const hp = heights[p];
+        const hq = heights[q];
+        stat.step += hp > hq ? hp - hq : hq - hp;
+        stat.top += hp > hq ? hp : hq;
+        stat.sumX += p % width;
+        stat.sumY += Math.floor(p / width);
+    };
+    for (let y = 0; y < height; y += 1) {
+        const row = y * width;
+        for (let x = 0; x < width; x += 1) {
+            const p = row + x;
+            const a = pixel[p];
+            const right = row + (x + 1 === width ? 0 : x + 1);
+            const b = pixel[right];
+            if (a !== b)
+                visit(a, b, p, right);
+            if (y + 1 < height) {
+                const c = pixel[p + width];
+                if (a !== c)
+                    visit(a, c, p, p + width);
+            }
+        }
+    }
+    return table;
+}
+export function centerOf(source, id) {
+    const size = source.size[id];
+    return { x: source.sumX[id] / size, y: source.sumY[id] / size };
+}
+/** Horizontal difference on a wrapping map. */
+export function wrapDelta(a, b, width) {
+    const delta = a - b;
+    const half = width / 2;
+    return delta > half ? delta - width : delta < -half ? delta + width : delta;
+}
+export function distanceOnMap(ax, ay, bx, by, width) {
+    const dx = wrapDelta(ax, bx, width);
+    const dy = ay - by;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+export function provinceFeatures(input) {
+    const { geography, view, kind } = input;
+    const grid = factGrid(view.width, view.height);
+    const landRaster = paintAreas(geography.lands.map((land) => land.area), grid);
+    const regionIndex = [];
+    const regionAreas = [];
+    for (const [position, region] of geography.regions.entries())
+        if (region.area !== undefined) {
+            regionIndex.push(position);
+            regionAreas.push(region.area);
+        }
+    const regionRaster = paintAreas(regionAreas, grid);
+    const seaRaster = paintAreas(geography.seas.map((sea) => sea.area), grid);
+    const lakeRaster = paintAreas(geography.lakes.map((lake) => lake.area), grid);
+    const isLand = (province) => kind[province] === LAND;
+    const isSea = (province) => kind[province] === SEA;
+    const lands = provinceModes(view, landRaster, grid, 3, isLand);
+    const regions = provinceModes(view, regionRaster, grid, 3, isLand);
+    const seas = provinceModes(view, seaRaster, grid, 3, isSea);
+    const lakes = provinceModes(view, lakeRaster, grid, 3, (province) => !isLand(province), 0.5);
+    const out = {
+        land: new Int32Array(view.count).fill(-1),
+        region: new Int32Array(view.count).fill(-1),
+        sea: new Int32Array(view.count).fill(-1),
+        lake: new Int32Array(view.count).fill(-1),
+    };
+    for (let province = 0; province < view.count; province += 1) {
+        if (lands[province] > 0)
+            out.land[province] = lands[province] - 1;
+        if (regions[province] > 0)
+            out.region[province] = regionIndex[regions[province] - 1];
+        // Water inside a lake polygon belongs to the lake (an inland sea), not to the sea drawn under it.
+        if (seas[province] > 0 && lakes[province] === 0)
+            out.sea[province] = seas[province] - 1;
+        if (lakes[province] > 0)
+            out.lake[province] = lakes[province] - 1;
+    }
+    return out;
+}
+/** Nearest province to a pixel position among `candidates`, by centre distance. */
+export function nearestProvince(source, width, candidates, x, y) {
+    let best;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const id of candidates) {
+        const centre = centerOf(source, id);
+        const d = distanceOnMap(centre.x, centre.y, x, y, width);
+        if (d < bestDistance) {
+            bestDistance = d;
+            best = id;
+        }
+    }
+    return best;
+}
+export function provinceViewOf(provinces, width, height) {
+    return { width, height, pixel: provinces.pixel, count: provinces.kind.length };
+}
+/**
+ * Pixels of province `a` that touch province `b` (4-connected), for each requested unordered pair
+ * `(a, b)` given as `a * count + b` in both orders as needed. One pass over the raster.
+ * Returns, for every requested key `a * count + b` (ordered), the pixel indices of `a` next to `b`.
+ */
+export function collectContacts(view, wanted) {
+    const { width, height, pixel, count } = view;
+    const out = new Map();
+    if (wanted.size === 0)
+        return out;
+    const touch = (own, other, at) => {
+        const key = own * count + other;
+        if (!wanted.has(key))
+            return;
+        let list = out.get(key);
+        if (list === undefined) {
+            list = [];
+            out.set(key, list);
+        }
+        if (list[list.length - 1] !== at)
+            list.push(at);
+    };
+    for (let y = 0; y < height; y += 1) {
+        const row = y * width;
+        for (let x = 0; x < width; x += 1) {
+            const p = row + x;
+            const a = pixel[p];
+            const right = row + (x + 1 === width ? 0 : x + 1);
+            const b = pixel[right];
+            if (a !== b) {
+                touch(a, b, p);
+                touch(b, a, right);
+            }
+            if (y + 1 < height) {
+                const q = p + width;
+                const c = pixel[q];
+                if (a !== c) {
+                    touch(a, c, p);
+                    touch(c, a, q);
+                }
+            }
+        }
+    }
+    return out;
+}
+/** The nearest pair of pixels between two contact lists, subsampled to at most `limit` each. */
+export function closestApproach(left, right, width, limit = 300) {
+    if (left.length === 0 || right.length === 0)
+        return undefined;
+    const stepL = Math.max(1, Math.ceil(left.length / limit));
+    const stepR = Math.max(1, Math.ceil(right.length / limit));
+    let best = Number.POSITIVE_INFINITY;
+    let bestL = -1;
+    let bestR = -1;
+    for (let i = 0; i < left.length; i += stepL) {
+        const lx = left[i] % width;
+        const ly = Math.floor(left[i] / width);
+        for (let j = 0; j < right.length; j += stepR) {
+            const dx = wrapDelta(lx, right[j] % width, width);
+            const dy = ly - Math.floor(right[j] / width);
+            const d = dx * dx + dy * dy;
+            if (d < best) {
+                best = d;
+                bestL = left[i];
+                bestR = right[j];
+            }
+        }
+    }
+    return {
+        gap: Math.sqrt(best),
+        from: { x: bestL % width, y: Math.floor(bestL / width) },
+        to: { x: bestR % width, y: Math.floor(bestR / width) },
+    };
+}

package/dist/hoi4_agent_tools/map/gameplay/inland-sea.js

@@ -0,0 +1,66 @@
+import { LAKE, SEA, labelComponents } from '../relief/grid.js';
+import { factGrid, paintAreas } from './facts.js';
+/**
+ * Turn the lake bodies that belong to inland-sea lakes into sea. `kind` is modified in place (and
+ * `elevation`, to the sea value the province generator expects).
+ */
+export function convertInlandSeas(kind, elevation, width, height, geography) {
+    const wanted = geography.lakes
+        .map((lake, position) => ({ lake, position }))
+        .filter(({ lake }) => lake.gameplay === 'inland-sea');
+    if (wanted.length === 0)
+        return { converted: [], missing: [] };
+    const grid = factGrid(width, height);
+    const painted = paintAreas(wanted.map(({ lake }) => lake.area), grid);
+    const components = labelComponents(width, height, (index) => kind[index] === LAKE);
+    const votes = new Map();
+    for (let y = 0; y < height; y += 2) {
+        const gy = Math.min(grid.height - 1, Math.floor(((y + 0.5) * grid.height) / height));
+        for (let x = 0; x < width; x += 2) {
+            const label = components.label[y * width + x];
+            if (label < 0)
+                continue;
+            const value = painted[gy * grid.width + Math.min(grid.width - 1, Math.floor(((x + 0.5) * grid.width) / width))];
+            if (value === 0)
+                continue;
+            const key = label * 4_096 + (value - 1);
+            votes.set(key, (votes.get(key) ?? 0) + 1);
+        }
+    }
+    // A body belongs to the inland-sea lake with most of its samples; it must be mostly inside it.
+    const total = new Map();
+    for (let y = 0; y < height; y += 2)
+        for (let x = 0; x < width; x += 2) {
+            const label = components.label[y * width + x];
+            if (label >= 0)
+                total.set(label, (total.get(label) ?? 0) + 1);
+        }
+    const owner = new Map();
+    for (const [key, count] of [...votes].sort((a, b) => a[0] - b[0])) {
+        const label = Math.floor(key / 4_096);
+        const lake = key - label * 4_096;
+        if (count * 2 < (total.get(label) ?? 0))
+            continue;
+        const best = owner.get(label);
+        const bestCount = best === undefined ? 0 : (votes.get(label * 4_096 + best) ?? 0);
+        if (count > bestCount)
+            owner.set(label, lake);
+    }
+    const pixelsOf = new Map();
+    for (let index = 0; index < kind.length; index += 1) {
+        const label = components.label[index];
+        if (label < 0 || !owner.has(label))
+            continue;
+        kind[index] = SEA;
+        elevation[index] = -0.15;
+        const lake = owner.get(label);
+        pixelsOf.set(lake, (pixelsOf.get(lake) ?? 0) + 1);
+    }
+    const converted = [...pixelsOf]
+        .sort((a, b) => a[0] - b[0])
+        .map(([lake, pixels]) => ({ lake: wanted[lake].position, pixels }));
+    const missing = wanted
+        .filter((_, position) => !pixelsOf.has(position))
+        .map(({ position }) => position);
+    return { converted, missing };
+}