hoi4-agent-tools 4.4.0 → 4.6.0

package/dist/hoi4_agent_tools/map/world.js

@@ -12,13 +12,20 @@ import { generateWorldProvinces } from './world-provinces.js';
 import { clusterRegions, clusterStates, partitionWorldFromRequest, } from './partition.js';
 import { repairSeamCorners, smoothDiagonalContacts } from './partition-fields.js';
 import { PARTITION_PROVINCE_ERROR, PARTITION_PROVINCE_WARNING } from './partition-tuning.js';
+import { buildTerritoryAtoms, territoryGraphFromPartition } from './territory-graph.js';
+import { growTerritory } from './territory.js';
 import { geographyPartitionFields, provinceCountNote, surfacePartitionFields, } from './world-partition.js';
+import { adjacencyRowText, adjacencyRulesText } from './gameplay/crossings.js';
+import { convertInlandSeas } from './gameplay/inland-sea.js';
+import { planEconomy } from './gameplay/economy.js';
+import { prepareGameplay } from './gameplay/prepare.js';
 import { fractal, lattice } from './world-noise.js';
 import { calibratedColourMap, COLOUR_CLASSES, } from './colormap.js';
 import { ambientObjectText, applyEdgePolicy, assertFeaturesOutsideBand, edgeWaterDarkness, RIM_COLOUR_FACTOR, rimAdjacencyRows, rimHeight, rimStrength, } from './world-edge.js';
 import { landDistanceField, lakeHeight, normalizeLakes, waterColourLevel } from './water.js';
 import { overlayGeographyLakes, rasterizeGeographyKind } from './relief/land.js';
-import { synthesizeTerrain } from './relief/terrain-synthesis.js';
+import { checkTerrainRivers, synthesizeTerrain, } from './relief/terrain-synthesis.js';
+import { assignUnreachedRealmLand, resolveRealmRules } from './world-realms.js';
 // ---------------------------------------------------------------------------------------------
 // Deterministic randomness and noise
 export class Random {
@@ -506,6 +513,48 @@ export function generateWorld(spec, context, options = {}) {
     let seamRepaired = geography !== undefined ? repairSeamCorners(surface.kind, width, height) : [];
     // A geography model gets its relief and rivers from the synthesis of ADR 0056; every other world
     // keeps the original elevation classes and drainage, byte for byte.
+    if (options.riverCheck === true && geography !== undefined) {
+        const checked = checkTerrainRivers({
+            geography,
+            width,
+            height,
+            seed: spec.seed,
+            kind: surface.kind,
+            relief: spec.relief,
+            rivers: { density: spec.riverDensity, count: spec.riverCount },
+            adjustHeight: edge.mode === 'rim'
+                ? (x, _y, value) => rimHeight(value, rimStrength(edge, width, x))
+                : undefined,
+            signal: options.signal,
+        });
+        for (const note of checked) {
+            if (note.severity === 'error')
+                throw new ServiceError(note.code, note.message, note.details);
+            notes.push({
+                code: note.code,
+                severity: note.severity,
+                message: note.message,
+                ...(note.details === undefined ? {} : { details: note.details }),
+            });
+        }
+        return {
+            files: [],
+            warnings: [],
+            notes,
+            summary: {
+                width,
+                height,
+                landProvinces: 0,
+                seaProvinces: 0,
+                lakeProvinces: 0,
+                states: 0,
+                landRegions: 0,
+                seaRegions: 0,
+                countries: spec.countries.length,
+                rivers: 0,
+            },
+        };
+    }
     const synthesized = geography === undefined
         ? undefined
         : synthesizeTerrain({
@@ -534,6 +583,26 @@ export function generateWorld(spec, context, options = {}) {
         }
         notes.push(terrainSummaryNote(synthesized, geography));
     }
+    // A lake the model calls an inland sea becomes navigable water (ADR 0062).
+    const inland = geography === undefined || synthesized === undefined
+        ? undefined
+        : convertInlandSeas(surface.kind, surface.elevation, width, height, geography);
+    if (inland !== undefined && geography !== undefined) {
+        for (const { lake, pixels } of inland.converted)
+            notes.push({
+                code: 'MAP_INLAND_SEA_CREATED',
+                severity: 'info',
+                message: `Lake ${geography.lakes[lake].id} is an inland sea: its ${pixels} water pixels are written as sea provinces so ships and ports can use them`,
+                details: { lakeId: geography.lakes[lake].id, pixels },
+            });
+        for (const lake of inland.missing)
+            notes.push({
+                code: 'MAP_INLAND_SEA_NO_WATER',
+                severity: 'info',
+                message: `Lake ${geography.lakes[lake].id} is an inland sea but has no separate water body: it joined the open sea or was too small to keep`,
+                details: { lakeId: geography.lakes[lake].id },
+            });
+    }
     const drainage = synthesized === undefined
         ? generateWorldDrainage({
             width,
@@ -627,6 +696,25 @@ export function generateWorld(spec, context, options = {}) {
     const countNote = provinceCountNote(count, featurePartition === undefined ? 'legacy' : 'feature-aware');
     if (countNote !== undefined)
         notes.push(countNote);
+    // Crossings, passes and walls of a geography world (ADR 0062).
+    const gameplay = geography === undefined || synthesized === undefined
+        ? undefined
+        : prepareGameplay({
+            width,
+            height,
+            geography,
+            provinces,
+            heights: synthesized.heights,
+            riverBitmap: drainage.riverPixels,
+            fields: synthesized.fields,
+            riverPaths: synthesized.riverPaths,
+            autoStraits: spec.autoStraits,
+            impassableLimit: spec.impassableRowLimit,
+            inlandSeas: inland?.converted.map(({ lake }) => lake) ?? [],
+        });
+    if (gameplay !== undefined)
+        for (const note of gameplay.notes)
+            notes.push(note);
     const center = (id) => ({
         x: provinces.sumX[id] / provinces.size[id],
         y: provinces.sumY[id] / provinces.size[id],
@@ -763,7 +851,9 @@ export function generateWorld(spec, context, options = {}) {
     const countryCount = spec.countries.length;
     const interpretationWarnings = [];
     const referenceOwners = new Map();
-    if (reference?.inferredCountries.length === countryCount && countryCount > 1) {
+    if (spec.realms === undefined &&
+        reference?.inferredCountries.length === countryCount &&
+        countryCount > 1) {
         const indexes = new Map();
         const unresolved = [];
         for (const [index, country] of spec.countries.entries()) {
@@ -831,7 +921,20 @@ export function generateWorld(spec, context, options = {}) {
         }
         return selected;
     };
-    const namedCities = (spec.referenceCities ?? []).map((city) => {
+    // Sites of the model that anchor a country (its capital) choose that country's capital province.
+    const siteAnchors = geography === undefined
+        ? []
+        : geography.sites.flatMap((site) => site.country === undefined || site.onWater
+            ? []
+            : [
+                {
+                    name: site.name ?? site.id,
+                    x: site.at.x * width,
+                    y: site.at.y * height,
+                    countryTag: site.country,
+                },
+            ]);
+    const namedCities = [...(spec.referenceCities ?? []), ...siteAnchors].map((city) => {
         const pixel = city.x >= 0 && city.y >= 0 && city.x < width && city.y < height
             ? Math.floor(city.y) * width + Math.floor(city.x)
             : undefined;
@@ -844,6 +947,17 @@ export function generateWorld(spec, context, options = {}) {
     });
     const capitals = [];
     const largest = [...landIds].sort((left, right) => provinces.size[right] - provinces.size[left] || left - right);
+    const realmRules = spec.realms === undefined
+        ? undefined
+        : resolveRealmRules(spec.realms, {
+            width,
+            height,
+            pixelProvince: provinces.pixel,
+            provinceSize: provinces.size,
+            isLand: (id) => provinces.kind[id] === LAND,
+        });
+    if (realmRules !== undefined)
+        capitals.push(...realmRules.capitals);
     while (capitals.length < countryCount) {
         const countryIndex = capitals.length;
         const regionCandidates = largest.filter((id) => referenceOwners.get(id) === countryIndex && !capitals.includes(id));
@@ -879,20 +993,41 @@ export function generateWorld(spec, context, options = {}) {
     }
     const shares = spec.countries.map((country) => Math.max(0.05, country.share ?? 1));
     const owned = new Array(countryCount).fill(0);
-    for (const [id, country] of referenceOwners) {
+    for (const [id, country] of realmRules?.forced ?? referenceOwners) {
         owner.set(id, country);
         owned[country] += provinces.size[id];
     }
+    const unownedLand = realmRules?.unowned ?? new Set();
+    const blockedFor = (index, id) => unownedLand.has(id) || realmRules?.excluded[index].has(id) === true;
     const frontiers = capitals.map((capital, index) => {
-        owner.set(capital, index);
-        if (!referenceOwners.has(capital))
+        if (!owner.has(capital))
             owned[index] += provinces.size[capital];
+        owner.set(capital, index);
+        if (realmRules !== undefined)
+            return [...owner]
+                .filter(([, country]) => country === index)
+                .flatMap(([id]) => [...provinces.neighbors[id]]);
         return [...provinces.neighbors[capital]];
     });
-    for (;;) {
+    let grownByTerritory = false;
+    // The feature-aware partition grows generated countries along its natural lines (ADR 0060).
+    // Workspace-owned countries keep the realm growth with its forced and blocked land (ADR 0069).
+    if (featurePartition !== undefined && referenceOwners.size === 0 && realmRules === undefined) {
+        const atoms = buildTerritoryAtoms(territoryGraphFromPartition(featurePartition.graph, provinces.sumX, provinces.sumY), landIds.map((id) => [id]));
+        const grown = growTerritory(atoms, spec.countries.map((country, index) => ({
+            tag: country.tag,
+            weight: shares[index],
+            seeds: [atoms.atomOfProvince[capitals[index]]],
+        })), { seed: spec.seed });
+        for (const [atom, id] of landIds.entries())
+            if (grown.owner[atom] >= 0)
+                owner.set(id, grown.owner[atom]);
+        grownByTerritory = true;
+    }
+    while (!grownByTerritory) {
         let chosen = -1;
         for (let index = 0; index < countryCount; index += 1) {
-            frontiers[index] = frontiers[index].filter((id) => provinces.kind[id] === LAND && !owner.has(id));
+            frontiers[index] = frontiers[index].filter((id) => provinces.kind[id] === LAND && !owner.has(id) && !blockedFor(index, id));
             if (frontiers[index].length === 0)
                 continue;
             if (chosen < 0 || owned[index] / shares[index] < owned[chosen] / shares[chosen])
@@ -908,9 +1043,21 @@ export function generateWorld(spec, context, options = {}) {
             if (!owner.has(neighbor))
                 frontier.push(neighbor);
     }
+    // Land no workspace country reached follows the island rule; the rest of the land is unowned.
+    if (realmRules !== undefined)
+        assignUnreachedRealmLand({
+            landIds,
+            owner,
+            unowned: unownedLand,
+            capitals,
+            excluded: realmRules.excluded,
+            islands: spec.realms?.islands ?? 'nearest',
+            part: (id) => landParts.get(id),
+            center,
+        });
     // Islands no country reached go to the nearest capital's country.
     for (const id of landIds)
-        if (!owner.has(id)) {
+        if (!owner.has(id) && !unownedLand.has(id)) {
             const c = center(id);
             let best = 0;
             for (const [index, capital] of capitals.entries())
@@ -946,7 +1093,7 @@ export function generateWorld(spec, context, options = {}) {
     // States: within each region and country, clusters of about provincesPerState.
     const groups = new Map();
     for (const id of landIds) {
-        const key = `${regionOf.get(id)}:${owner.get(id)}`;
+        const key = `${regionOf.get(id)}:${owner.get(id) ?? -1}`;
         const list = groups.get(key) ?? [];
         list.push(id);
         groups.set(key, list);
@@ -970,7 +1117,7 @@ export function generateWorld(spec, context, options = {}) {
             const draft = {
                 id: states.length + 1,
                 provinces: sorted,
-                owner: spec.countries[countryIndex].tag,
+                ...(countryIndex < 0 ? {} : { owner: spec.countries[countryIndex].tag }),
                 region,
                 capital: sorted[0],
                 manpower: 0,
@@ -983,12 +1130,33 @@ export function generateWorld(spec, context, options = {}) {
                 resources: new Map(),
                 victoryPoints: new Map(),
                 navalBases: new Map(),
+                forts: new Map(),
             };
             states.push(draft);
             for (const id of sorted)
                 stateOf.set(id, draft);
         }
     }
+    // Names from reference labels (the nearest province to each label), which win over any other.
+    const stateNames = new Map();
+    const regionNames = new Map();
+    for (const label of spec.referenceLabels ?? []) {
+        if (label.kind === 'state') {
+            const nearby = nearestProvince(label, landIds);
+            const state = stateOf.get(nearby);
+            const previous = stateNames.get(state.id);
+            stateNames.set(state.id, previous === undefined ? label.name : `${previous} / ${label.name}`);
+        }
+        else if (label.kind === 'sea' || label.kind === 'region') {
+            const members = label.kind === 'sea' ? seaIds : landIds;
+            if (members.length === 0)
+                continue;
+            const region = regionOf.get(nearestProvince(label, members));
+            const previous = regionNames.get(region);
+            regionNames.set(region, previous === undefined ? label.name : `${previous} / ${label.name}`);
+        }
+    }
+    const lakeNames = new Map();
     // State values from size, terrain and development, with the country capital boosted.
     const categories = [
         'wasteland',
@@ -1016,112 +1184,153 @@ export function generateWorld(spec, context, options = {}) {
         state.capital = capital;
         countryCapitalState.set(spec.countries[index].tag, state);
     }
-    for (const state of states) {
-        const pixels = state.provinces.reduce((sum, id) => sum + provinces.size[id], 0);
-        const habitability = state.provinces.reduce((sum, id) => {
-            const value = {
-                plains: 1,
-                forest: 0.8,
-                hills: 0.6,
-                jungle: 0.5,
-                marsh: 0.4,
-                desert: 0.25,
-                mountain: 0.3,
-                urban: 1.5,
-            }[terrain.get(id) ?? 'plains'] ?? 0.5;
-            return sum + value * provinces.size[id];
-        }, 0) / pixels;
-        const isCapital = countryCapitalState.get(state.owner) === state;
-        const development = Math.min(1, habitability * (0.5 + random.next()) * (isCapital ? 1.8 : 1));
-        state.manpower = Math.max(1_000, Math.round((pixels * 180 * development) / 1_000) * 1_000);
-        const categoryIndex = Math.max(0, Math.min(categories.length - 1, Math.round(development * 5.2 + (isCapital ? 1 : 0))));
-        state.category = categories[categoryIndex];
-        if (context.stateCategories !== undefined && !context.stateCategories.has(state.category))
-            state.category = context.stateCategories.has('rural')
-                ? 'rural'
-                : ([...context.stateCategories][0] ?? 'rural');
-        const slots = slotsFor[state.category] ?? 2;
-        state.infrastructure = Math.max(1, Math.min(5, Math.round(1 + development * 3 + (isCapital ? 1 : 0))));
-        state.civilian = Math.round(slots * (0.25 + random.next() * 0.3));
-        state.military = Math.min(slots - state.civilian, Math.round(slots * random.next() * 0.3));
-        if (isCapital) {
-            terrain.set(state.capital, 'urban');
-            state.airBase = 2;
-        }
-        const coastalProvinces = state.provinces.filter(coastal);
-        if (coastalProvinces.length > 0 && (isCapital || random.next() < 0.35)) {
-            state.navalBases.set(coastalProvinces[0], isCapital ? 3 : 1);
-            if (slots - state.civilian - state.military > 0 && random.next() < 0.5)
-                state.dockyard = 1;
-        }
-        for (const id of state.provinces) {
-            const kindOfLand = terrain.get(id);
-            const roll = random.next();
-            const add = (resource, amount) => state.resources.set(resource, (state.resources.get(resource) ?? 0) + amount);
-            if (kindOfLand === 'desert' && roll < 0.3)
-                add('oil', 2 + random.int(6));
-            if ((kindOfLand === 'mountain' || kindOfLand === 'hills') && roll < 0.35)
-                add('steel', 2 + random.int(8));
-            if (kindOfLand === 'mountain' && roll < 0.15)
-                add('tungsten', 1 + random.int(4));
-            if (kindOfLand === 'hills' && roll > 0.85)
-                add('chromium', 1 + random.int(4));
-            if (kindOfLand === 'jungle' && roll < 0.35)
-                add('rubber', 1 + random.int(5));
-            if (kindOfLand === 'plains' && roll < 0.05)
-                add('aluminium', 1 + random.int(4));
-        }
-        state.victoryPoints.set(state.capital, isCapital ? 25 : Math.max(1, Math.round(development * 8)));
-    }
     const cityNames = new Map();
-    for (const city of namedCities) {
-        const state = stateOf.get(city.province);
-        cityNames.set(city.province, city.name);
-        state.victoryPoints.set(city.province, Math.max(5, state.victoryPoints.get(city.province) ?? 0));
-        terrain.set(city.province, 'urban');
-    }
-    // Each coastal territory needs a port even when its capital lies inland or on another island.
-    const portChecked = new Set();
-    for (const start of landIds) {
-        if (portChecked.has(start))
-            continue;
-        const queue = [start];
-        portChecked.add(start);
-        let bestCoast;
-        let hasPort = false;
-        for (const id of queue) {
-            if (stateOf.get(id).navalBases.has(id))
-                hasPort = true;
-            if (coastal(id) &&
-                (bestCoast === undefined || provinces.size[id] > provinces.size[bestCoast]))
-                bestCoast = id;
-            for (const next of provinces.neighbors[id])
-                if (!portChecked.has(next) &&
-                    provinces.kind[next] === LAND &&
-                    owner.get(next) === owner.get(start)) {
-                    portChecked.add(next);
-                    queue.push(next);
-                }
+    // A geography world gets its economy, ports, names and railway costs from the model (ADR 0063);
+    // every other world keeps the random economy below, byte for byte.
+    const economy = gameplay === undefined || spec.developmentModel === 'legacy'
+        ? undefined
+        : planEconomy(gameplay, {
+            states: states.map((state) => ({
+                id: state.id,
+                provinces: state.provinces,
+                owner: state.owner,
+                isCapital: state.owner !== undefined && countryCapitalState.get(state.owner) === state,
+            })),
+            terrain,
+            options: {
+                categories,
+                slotsFor,
+                allowedCategories: context.stateCategories,
+                capitalProvinces: new Set(capitals),
+            },
+            regionOf,
+            fixedStateNames: stateNames,
+            fixedRegionNames: regionNames,
+            countryNames: new Map(spec.countries.map(({ tag, name }) => [tag, name])),
+        });
+    if (economy !== undefined) {
+        for (const state of states) {
+            const plan = economy.development.states.get(state.id);
+            state.manpower = plan.manpower;
+            state.category = plan.category;
+            state.infrastructure = plan.infrastructure;
+            state.civilian = plan.civilian;
+            state.military = plan.military;
+            state.dockyard = plan.dockyard;
+            state.airBase = plan.airBase;
+            state.resources = plan.resources;
+            state.victoryPoints = plan.victoryPoints;
+            for (const id of state.provinces) {
+                const port = economy.ports.ports.get(id);
+                if (port !== undefined)
+                    state.navalBases.set(id, port.level);
+                const fort = economy.forts.get(id);
+                if (fort !== undefined)
+                    state.forts.set(id, fort);
+            }
         }
-        if (!hasPort && bestCoast !== undefined)
-            stateOf.get(bestCoast).navalBases.set(bestCoast, 1);
+        for (const id of economy.development.urban)
+            terrain.set(id, 'urban');
+        for (const [id, name] of economy.names.victory)
+            cityNames.set(id, name);
+        for (const [id, name] of economy.names.states)
+            stateNames.set(id, name);
+        for (const [id, name] of economy.names.regions)
+            regionNames.set(id, name);
+        for (const [id, name] of economy.names.lakes)
+            lakeNames.set(id, name);
+        for (const note of economy.notes)
+            notes.push(note);
     }
-    const stateNames = new Map();
-    const regionNames = new Map();
-    for (const label of spec.referenceLabels ?? []) {
-        if (label.kind === 'state') {
-            const nearby = nearestProvince(label, landIds);
-            const state = stateOf.get(nearby);
-            const previous = stateNames.get(state.id);
-            stateNames.set(state.id, previous === undefined ? label.name : `${previous} / ${label.name}`);
+    if (economy === undefined) {
+        for (const state of states) {
+            const pixels = state.provinces.reduce((sum, id) => sum + provinces.size[id], 0);
+            const habitability = state.provinces.reduce((sum, id) => {
+                const value = {
+                    plains: 1,
+                    forest: 0.8,
+                    hills: 0.6,
+                    jungle: 0.5,
+                    marsh: 0.4,
+                    desert: 0.25,
+                    mountain: 0.3,
+                    urban: 1.5,
+                }[terrain.get(id) ?? 'plains'] ?? 0.5;
+                return sum + value * provinces.size[id];
+            }, 0) / pixels;
+            const isCapital = state.owner !== undefined && countryCapitalState.get(state.owner) === state;
+            const development = Math.min(1, habitability * (0.5 + random.next()) * (isCapital ? 1.8 : 1));
+            state.manpower = Math.max(1_000, Math.round((pixels * 180 * development) / 1_000) * 1_000);
+            const categoryIndex = Math.max(0, Math.min(categories.length - 1, Math.round(development * 5.2 + (isCapital ? 1 : 0))));
+            state.category = categories[categoryIndex];
+            if (context.stateCategories !== undefined && !context.stateCategories.has(state.category))
+                state.category = context.stateCategories.has('rural')
+                    ? 'rural'
+                    : ([...context.stateCategories][0] ?? 'rural');
+            const slots = slotsFor[state.category] ?? 2;
+            state.infrastructure = Math.max(1, Math.min(5, Math.round(1 + development * 3 + (isCapital ? 1 : 0))));
+            state.civilian = Math.round(slots * (0.25 + random.next() * 0.3));
+            state.military = Math.min(slots - state.civilian, Math.round(slots * random.next() * 0.3));
+            if (isCapital) {
+                terrain.set(state.capital, 'urban');
+                state.airBase = 2;
+            }
+            const coastalProvinces = state.provinces.filter(coastal);
+            if (coastalProvinces.length > 0 && (isCapital || random.next() < 0.35)) {
+                state.navalBases.set(coastalProvinces[0], isCapital ? 3 : 1);
+                if (slots - state.civilian - state.military > 0 && random.next() < 0.5)
+                    state.dockyard = 1;
+            }
+            for (const id of state.provinces) {
+                const kindOfLand = terrain.get(id);
+                const roll = random.next();
+                const add = (resource, amount) => state.resources.set(resource, (state.resources.get(resource) ?? 0) + amount);
+                if (kindOfLand === 'desert' && roll < 0.3)
+                    add('oil', 2 + random.int(6));
+                if ((kindOfLand === 'mountain' || kindOfLand === 'hills') && roll < 0.35)
+                    add('steel', 2 + random.int(8));
+                if (kindOfLand === 'mountain' && roll < 0.15)
+                    add('tungsten', 1 + random.int(4));
+                if (kindOfLand === 'hills' && roll > 0.85)
+                    add('chromium', 1 + random.int(4));
+                if (kindOfLand === 'jungle' && roll < 0.35)
+                    add('rubber', 1 + random.int(5));
+                if (kindOfLand === 'plains' && roll < 0.05)
+                    add('aluminium', 1 + random.int(4));
+            }
+            state.victoryPoints.set(state.capital, isCapital ? 25 : Math.max(1, Math.round(development * 8)));
         }
-        else if (label.kind === 'sea' || label.kind === 'region') {
-            const members = label.kind === 'sea' ? seaIds : landIds;
-            if (members.length === 0)
+        for (const city of namedCities) {
+            const state = stateOf.get(city.province);
+            cityNames.set(city.province, city.name);
+            state.victoryPoints.set(city.province, Math.max(5, state.victoryPoints.get(city.province) ?? 0));
+            terrain.set(city.province, 'urban');
+        }
+        // Each coastal territory needs a port even when its capital lies inland or on another island.
+        const portChecked = new Set();
+        for (const start of landIds) {
+            if (portChecked.has(start))
                 continue;
-            const region = regionOf.get(nearestProvince(label, members));
-            const previous = regionNames.get(region);
-            regionNames.set(region, previous === undefined ? label.name : `${previous} / ${label.name}`);
+            const queue = [start];
+            portChecked.add(start);
+            let bestCoast;
+            let hasPort = false;
+            for (const id of queue) {
+                if (stateOf.get(id).navalBases.has(id))
+                    hasPort = true;
+                if (coastal(id) &&
+                    (bestCoast === undefined || provinces.size[id] > provinces.size[bestCoast]))
+                    bestCoast = id;
+                for (const next of provinces.neighbors[id])
+                    if (!portChecked.has(next) &&
+                        provinces.kind[next] === LAND &&
+                        owner.get(next) === owner.get(start)) {
+                        portChecked.add(next);
+                        queue.push(next);
+                    }
+            }
+            if (!hasPort && bestCoast !== undefined)
+                stateOf.get(bestCoast).navalBases.set(bestCoast, 1);
         }
     }
     // Province IDs: 1-based in reading order of the province's first pixel; 0 is the null row.
@@ -1140,6 +1349,7 @@ export function generateWorld(spec, context, options = {}) {
     const files = [];
     const add = (relativePath, content, mediaType = 'text/plain') => files.push({ relativePath, content, mediaType });
     const countryNames = new Map(spec.countries.map(({ tag, name }) => [tag, name]));
+    const ownerName = (state) => state.owner === undefined ? 'Free Land' : (countryNames.get(state.owner) ?? state.owner);
     const map = context.mapRoot;
     // provinces.bmp
     const rgb = new Array(width * height);
@@ -1189,8 +1399,11 @@ export function generateWorld(spec, context, options = {}) {
             message: `The rim edge policy wrote ${rimRows.length} impassable adjacency row(s) for provinces that meet across the seam`,
             details: { rows: rimRows.length },
         });
-    add(`${map}/adjacencies.csv`, text(`From;To;Type;Through;start_x;start_y;stop_x;stop_y;adjacency_rule_name;Comment\r\n${rimRows.map((row) => `${row}\r\n`).join('')}-1;-1;;-1;-1;-1;-1;-1;-1\r\n`));
-    add(`${map}/adjacency_rules.txt`, text('# No straits or canals in this world yet.\n'));
+    const crossingRows = (gameplay?.crossings.rows ?? []).map(adjacencyRowText);
+    add(`${map}/adjacencies.csv`, text(`From;To;Type;Through;start_x;start_y;stop_x;stop_y;adjacency_rule_name;Comment\r\n${[...crossingRows, ...rimRows].map((row) => `${row}\r\n`).join('')}-1;-1;;-1;-1;-1;-1;-1;-1\r\n`));
+    add(`${map}/adjacency_rules.txt`, text(gameplay === undefined
+        ? '# No straits or canals in this world yet.\n'
+        : adjacencyRulesText(gameplay.crossings.rules)));
     add(`${map}/positions.txt`, text(''));
     add(`${map}/ambient_object.txt`, text(spec.ambientFrame === true
         ? ambientObjectText(width, height)
@@ -1529,7 +1742,16 @@ export function generateWorld(spec, context, options = {}) {
             ...(state.military > 0 ? [`\t\t\tarms_factory = ${state.military}`] : []),
             ...(state.dockyard > 0 ? [`\t\t\tdockyard = ${state.dockyard}`] : []),
             ...(state.airBase > 0 ? [`\t\t\tair_base = ${state.airBase}`] : []),
-            ...[...state.navalBases].map(([id, level]) => `\t\t\t${provinceId(id)} = { naval_base = ${level} }`),
+            ...[
+                ...state.navalBases.keys(),
+                ...[...state.forts.keys()].filter((id) => !state.navalBases.has(id)).sort((a, b) => a - b),
+            ].map((id) => {
+                const parts = [
+                    ...(state.navalBases.has(id) ? [`naval_base = ${state.navalBases.get(id)}`] : []),
+                    ...(state.forts.has(id) ? [`bunker = ${state.forts.get(id)}`] : []),
+                ];
+                return `\t\t\t${provinceId(id)} = { ${parts.join(' ')} }`;
+            }),
         ];
         add(`${context.statesRoot}/${state.id}-${slug(stateNames.get(state.id) ?? `STATE_${state.id}`).slice(0, 80)}.txt`, text([
             'state = {',
@@ -1543,8 +1765,9 @@ export function generateWorld(spec, context, options = {}) {
                     `\tresources = {\n${resources.map(([resource, amount]) => `\t\t${resource} = ${amount}`).join('\n')}\n\t}`,
                 ]),
             '\thistory = {',
-            `\t\towner = ${state.owner}`,
-            `\t\tadd_core_of = ${state.owner}`,
+            ...(state.owner === undefined
+                ? []
+                : [`\t\towner = ${state.owner}`, `\t\tadd_core_of = ${state.owner}`]),
             ...[...state.victoryPoints].map(([id, value]) => `\t\tvictory_points = { ${provinceId(id)} ${value} }`),
             '\t\tbuildings = {',
             ...buildings,
@@ -1559,7 +1782,8 @@ export function generateWorld(spec, context, options = {}) {
     const countryLocalisation = [];
     const countryLines = [];
     const countryColors = [];
-    for (const [index, country] of spec.countries.entries()) {
+    // Workspace-owned countries keep their own tags, files, histories, flags and names.
+    for (const [index, country] of (spec.realms === undefined ? spec.countries : []).entries()) {
         const color = country.color ?? {
             r: 60 + random.int(170),
             g: 60 + random.int(170),
@@ -1658,10 +1882,12 @@ export function generateWorld(spec, context, options = {}) {
             add(`gfx/flags/${folder}${country.tag}.tga`, encodeTga(flagWidth, flagHeight, (_x, y) => y < flagHeight / 3 ? light : y < (flagHeight * 2) / 3 ? color : dark), 'image/x-tga');
         void index;
     }
-    add('common/country_tags/zz_world_countries.txt', text(`${countryLines.join('\n')}\n`));
-    add('common/countries/colors.txt', text(`${countryColors.join('\n')}\n`));
+    if (spec.realms === undefined) {
+        add('common/country_tags/zz_world_countries.txt', text(`${countryLines.join('\n')}\n`));
+        add('common/countries/colors.txt', text(`${countryColors.join('\n')}\n`));
+    }
     if (spec.startingScenario) {
-        for (const tag of context.inheritedCountryTags ?? [])
+        for (const tag of spec.realms === undefined ? (context.inheritedCountryTags ?? []) : [])
             if (!countryNames.has(tag))
                 add(`history/countries/${tag} - inactive world.txt`, text('# Inherited tag has no territory or active starting country in this world.\n'));
         add('common/on_actions/world.txt', text('# Old-world startup hooks are replaced for this generated map.\non_actions = { }\n'));
@@ -1675,44 +1901,70 @@ export function generateWorld(spec, context, options = {}) {
         states
             .filter((state) => state.owner === left.tag)
             .reduce((sum, state) => sum + state.manpower, 0) || (left.tag < right.tag ? -1 : 1));
-    const majors = ranked.slice(0, Math.min(7, ranked.length));
-    add('common/bookmarks/world.txt', text([
-        'bookmarks = {',
-        '\tbookmark = {',
-        '\t\tname = "WORLD_BOOKMARK_NAME"',
-        '\t\tdesc = "WORLD_BOOKMARK_DESC"',
-        `\t\tdate = ${spec.startDate}.12`,
-        '\t\tpicture = "GFX_select_date_1936"',
-        `\t\tdefault_country = "${majors[0].tag}"`,
-        '\t\tdefault = yes',
-        ...majors.map((country) => `\t\t"${country.tag}" = {\n\t\t\thistory = "${country.tag}_WORLD_DESC"\n\t\t\tideology = ${country.ideology ?? 'neutrality'}\n\t\t}`),
-        '\t\t"---" = {\n\t\t\thistory = "WORLD_OTHER_DESC"\n\t\t}',
-        '\t\teffect = {\n\t\t\trandomize_weather = 22345\n\t\t}',
-        '\t}',
-        '}',
-        '',
-    ].join('\n')));
+    const majors = spec.realms === undefined ? ranked.slice(0, Math.min(7, ranked.length)) : [];
+    if (spec.realms === undefined)
+        add('common/bookmarks/world.txt', text([
+            'bookmarks = {',
+            '\tbookmark = {',
+            '\t\tname = "WORLD_BOOKMARK_NAME"',
+            '\t\tdesc = "WORLD_BOOKMARK_DESC"',
+            `\t\tdate = ${spec.startDate}.12`,
+            '\t\tpicture = "GFX_select_date_1936"',
+            `\t\tdefault_country = "${majors[0].tag}"`,
+            '\t\tdefault = yes',
+            ...majors.map((country) => `\t\t"${country.tag}" = {\n\t\t\thistory = "${country.tag}_WORLD_DESC"\n\t\t\tideology = ${country.ideology ?? 'neutrality'}\n\t\t}`),
+            '\t\t"---" = {\n\t\t\thistory = "WORLD_OTHER_DESC"\n\t\t}',
+            '\t\teffect = {\n\t\t\trandomize_weather = 22345\n\t\t}',
+            '\t}',
+            '}',
+            '',
+        ].join('\n')));
+    const realmSummary = () => {
+        const landPixels = landIds.reduce((sum, id) => sum + provinces.size[id], 0);
+        const weights = spec.countries.reduce((sum, country) => sum + (country.share ?? 1), 0);
+        return {
+            countries: spec.countries.map((country, index) => {
+                const ownedStates = states.filter((state) => state.owner === country.tag);
+                const pixels = ownedStates.reduce((sum, state) => sum + state.provinces.reduce((inner, id) => inner + provinces.size[id], 0), 0);
+                return {
+                    tag: country.tag,
+                    capitalState: countryCapitalState.get(country.tag).id,
+                    capitalProvince: provinceId(capitals[index]),
+                    states: ownedStates.map(({ id }) => id),
+                    provinces: ownedStates.reduce((sum, state) => sum + state.provinces.length, 0),
+                    landShare: Math.round((pixels / landPixels) * 10_000) / 10_000,
+                    targetShare: Math.round(((country.share ?? 1) / weights) * 10_000) / 10_000,
+                };
+            }),
+            unownedStates: states.filter((state) => state.owner === undefined).map(({ id }) => id),
+        };
+    };
     // Localisation for everything named above.
     add(`${context.localisationRoot}/replace/world_l_english.yml`, localisation([
         ...states.map((state) => [
             `STATE_${state.id}`,
-            stateNames.get(state.id) ??
-                `${countryNames.get(state.owner) ?? state.owner} District ${state.id}`,
+            stateNames.get(state.id) ?? `${ownerName(state)} District ${state.id}`,
         ]),
         ...states.flatMap((state) => [...state.victoryPoints.keys()].map((id) => [
             `VICTORY_POINTS_${provinceId(id)}`,
-            cityNames.get(id) ??
-                `${countryNames.get(state.owner) ?? state.owner} Settlement ${provinceId(id)}`,
+            cityNames.get(id) ?? `${ownerName(state)} Settlement ${provinceId(id)}`,
         ])),
         ...[...regionMembers.keys()]
             .sort((a, b) => a - b)
             .map((region) => [`STRATEGICREGION_${region}`, regionNames.get(region) ?? `Region ${region}`]),
         ...(spec.referenceLabels ?? []).map((label, index) => [`WORLD_GEOGRAPHY_${index + 1}`, label.name]),
+        ...[...lakeNames]
+            .sort((a, b) => a[0] - b[0])
+            .map(([id, name]) => [`PROV${provinceId(id)}`, name]),
         ...continentNames.map((name, index) => [`world_continent_${index + 1}`, name]),
         ...countryLocalisation,
-        ['WORLD_BOOKMARK_NAME', spec.worldName ?? 'A New World'],
-        ['WORLD_BOOKMARK_DESC', 'Nations of an unfamiliar map at the dawn of the war.'],
-        ['WORLD_OTHER_DESC', 'Any other nation of this world.'],
+        ...(spec.realms === undefined
+            ? [
+                ['WORLD_BOOKMARK_NAME', spec.worldName ?? 'A New World'],
+                ['WORLD_BOOKMARK_DESC', 'Nations of an unfamiliar map at the dawn of the war.'],
+                ['WORLD_OTHER_DESC', 'Any other nation of this world.'],
+            ]
+            : []),
         ...majors.map((country) => [
             `${country.tag}_WORLD_DESC`,
             `${country.name} begins the game among the strongest nations.`,
@@ -1723,6 +1975,8 @@ export function generateWorld(spec, context, options = {}) {
         warnings: [...interpretationWarnings, ...drainage.warnings],
         notes,
         ...(synthesized === undefined ? {} : { terrain: synthesized }),
+        ...(economy === undefined ? {} : { railCost: economy.railCost }),
+        ...(gameplay === undefined ? {} : { gameplay: { crossings: gameplay.crossings, economy } }),
         summary: {
             width,
             height,
@@ -1735,5 +1989,6 @@ export function generateWorld(spec, context, options = {}) {
             countries: spec.countries.length,
             rivers: riverCount,
         },
+        ...(spec.realms === undefined ? {} : { realms: realmSummary() }),
     };
 }