hoi4-agent-tools 4.3.0 → 4.5.0

package/dist/hoi4_agent_tools/map/colormap.js

@@ -0,0 +1,128 @@
+/**
+ * Calibrated land colour map (ADR 0054, stage A). The engine overlays the colour map on the
+ * terrain atlas at strength 0.75 in gamma space, so a bright colour map leaves the pale atlas
+ * almost untouched while the base game's dark, varied one darkens and saturates it. The tables
+ * below are the base game's measured class means (mean value 74, 1,084 distinct 5-bit colours);
+ * variation comes from deterministic low-frequency noise and a hillshade term, so one terrain
+ * class is never one flat colour.
+ */
+import { fractal, lattice } from './world-noise.js';
+export const COLOUR_CLASSES = [
+    'plains',
+    'farmland',
+    'forest',
+    'hills',
+    'desert',
+    'mountain',
+    'marsh',
+    'jungle',
+    'snow',
+    'urban',
+    'lakes',
+    'ocean',
+];
+/** Means of the base game's land colour map by graphical terrain (measured on 1.19.3.0). */
+const VANILLA_TEMPERATE = {
+    plains: [68, 68, 41],
+    farmland: [76, 74, 42],
+    forest: [47, 55, 24],
+    hills: [64, 66, 36],
+    desert: [118, 98, 64],
+    mountain: [59, 60, 35],
+    marsh: [51, 55, 30],
+    jungle: [36, 51, 16],
+    snow: [55, 58, 35],
+    urban: [69, 73, 43],
+    lakes: [82, 101, 128],
+    ocean: [79, 102, 141],
+};
+/** Per-channel multipliers applied to the vanilla table for the other palette sets. */
+const LOOK_ADJUSTMENTS = {
+    fertile: {
+        plains: [0.88, 1.1, 0.92],
+        farmland: [0.9, 1.1, 0.9],
+        hills: [0.92, 1.06, 0.95],
+        forest: [0.95, 1.08, 0.95],
+        desert: [0.9, 0.97, 0.96],
+        marsh: [0.95, 1.05, 0.95],
+    },
+    arid: {
+        plains: [1.18, 1.05, 0.95],
+        farmland: [1.12, 1.03, 0.95],
+        hills: [1.15, 1.02, 0.95],
+        forest: [1.15, 1.0, 0.95],
+        marsh: [1.1, 1.0, 0.95],
+        desert: [1.04, 1.0, 0.98],
+    },
+};
+export function colourTable(look, overrides) {
+    const table = { ...VANILLA_TEMPERATE };
+    if (look === 'fertile' || look === 'arid') {
+        for (const [name, factor] of Object.entries(LOOK_ADJUSTMENTS[look])) {
+            const base = VANILLA_TEMPERATE[name];
+            table[name] = [
+                Math.min(255, base[0] * factor[0]),
+                Math.min(255, base[1] * factor[1]),
+                Math.min(255, base[2] * factor[2]),
+            ];
+        }
+    }
+    if (overrides !== undefined)
+        for (const [name, color] of Object.entries(overrides))
+            table[name] = color;
+    return table;
+}
+/** Number of standard deviations of the value noise that one unit of `fractal()` spans. */
+const NOISE_SIGMA = 0.1;
+/**
+ * The half-resolution colour map as BGRA bytes, rows top to bottom. Deterministic: the noise is
+ * integer-hash based and every operation is addition, subtraction, multiplication or division.
+ */
+export function calibratedColourMap(input) {
+    const { width, height, seed, classes, moisture, heights, lights } = input;
+    const halfWidth = width / 2;
+    const halfHeight = height / 2;
+    const table = colourTable(input.look, input.overrides);
+    const colours = COLOUR_CLASSES.map((name) => table[name]);
+    const output = new Uint8Array(halfWidth * halfHeight * 4);
+    const large = Math.max(40, width / 14);
+    const medium = Math.max(16, width / 70);
+    const heightAt = (x, y) => heights[Math.min(height - 1, Math.max(0, y)) * width + Math.min(width - 1, Math.max(0, x))];
+    for (let y = 0; y < halfHeight; y += 1)
+        for (let x = 0; x < halfWidth; x += 1) {
+            const sx = x * 2;
+            const sy = y * 2;
+            const source = sy * width + sx;
+            const base = colours[classes[source]];
+            const water = classes[source] === 10 || classes[source] === 11;
+            const offset = (y * halfWidth + x) * 4;
+            let factor;
+            let wet = 0;
+            let hue = 0;
+            if (water) {
+                // The sea floor under the water layer is nearly uniform in the base game.
+                factor = 1 + (lattice(seed + 17, sx, sy) - 0.5) * 2 * 0.03;
+            }
+            else {
+                const low = (fractal(seed + 4201, sx, sy, large, 4) - 0.5) / NOISE_SIGMA;
+                const mid = (fractal(seed + 6007, sx, sy, medium, 3) - 0.5) / NOISE_SIGMA;
+                hue = (fractal(seed + 8803, sx, sy, large * 0.5, 3) - 0.5) / NOISE_SIGMA;
+                const dx = heightAt(sx + 2, sy) - heightAt(sx - 2, sy);
+                const dy = heightAt(sx, sy + 2) - heightAt(sx, sy - 2);
+                const shade = Math.max(-0.22, Math.min(0.22, (0.7071 * (dx + dy)) / 14));
+                factor = 1 + 0.14 * low + 0.07 * mid + shade;
+                wet = (moisture[source] - 0.5) * 2;
+            }
+            factor = Math.min(1.75, Math.max(0.5, factor));
+            const jitter = (channel) => 1 + (lattice(seed + 29 + channel, sx, sy) - 0.5) * (water ? 0.06 : 0.16);
+            // Wet ground is greener, dry ground warmer; the hue drifts slowly across the land.
+            const red = base[0] * factor * jitter(0) * (1 - 0.06 * wet) * (1 + 0.06 * hue);
+            const green = base[1] * factor * jitter(1) * (1 + 0.03 * wet);
+            const blue = base[2] * factor * jitter(2) * (1 - 0.08 * hue);
+            output[offset] = Math.min(255, Math.max(0, Math.round(blue)));
+            output[offset + 1] = Math.min(255, Math.max(0, Math.round(green)));
+            output[offset + 2] = Math.min(255, Math.max(0, Math.round(red)));
+            output[offset + 3] = lights[source];
+        }
+    return output;
+}

package/dist/hoi4_agent_tools/map/geography/geometry.js

@@ -0,0 +1,284 @@
+/**
+ * Planar geometry for the geography model, in normalised frame coordinates. Only `+ - * /` and
+ * `sqrt` are used so results are identical on every platform.
+ */
+/** Distance under which a point counts as lying on a boundary. */
+export const BOUNDARY_EPSILON = 1e-9;
+export function boundsOf(xs, ys) {
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (let index = 0; index < xs.length; index++) {
+        const x = xs[index], y = ys[index];
+        if (x < x0)
+            x0 = x;
+        if (x > x1)
+            x1 = x;
+        if (y < y0)
+            y0 = y;
+        if (y > y1)
+            y1 = y;
+    }
+    return { x0, y0, x1, y1 };
+}
+export function unionBounds(items) {
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (const item of items) {
+        if (item.x0 < x0)
+            x0 = item.x0;
+        if (item.y0 < y0)
+            y0 = item.y0;
+        if (item.x1 > x1)
+            x1 = item.x1;
+        if (item.y1 > y1)
+            y1 = item.y1;
+    }
+    return { x0, y0, x1, y1 };
+}
+export function boundsContain(bounds, x, y) {
+    return (x >= bounds.x0 - BOUNDARY_EPSILON &&
+        x <= bounds.x1 + BOUNDARY_EPSILON &&
+        y >= bounds.y0 - BOUNDARY_EPSILON &&
+        y <= bounds.y1 + BOUNDARY_EPSILON);
+}
+export function boundsOverlap(a, b) {
+    return a.x0 <= b.x1 && b.x0 <= a.x1 && a.y0 <= b.y1 && b.y0 <= a.y1;
+}
+/** Shoelace area in frame units; positive for a counter-clockwise ring with y pointing up. */
+export function signedArea(xs, ys) {
+    let sum = 0;
+    const n = xs.length;
+    for (let index = 0, previous = n - 1; index < n; previous = index++)
+        sum += xs[previous] * ys[index] - xs[index] * ys[previous];
+    return sum / 2;
+}
+function orientation(ax, ay, bx, by, cx, cy) {
+    const value = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
+    return value > 0 ? 1 : value < 0 ? -1 : 0;
+}
+function onSegment(ax, ay, bx, by, px, py) {
+    return (px >= Math.min(ax, bx) &&
+        px <= Math.max(ax, bx) &&
+        py >= Math.min(ay, by) &&
+        py <= Math.max(ay, by));
+}
+/** Closed segments `ab` and `cd` share at least one point (touching and overlapping count). */
+export function segmentsIntersect(ax, ay, bx, by, cx, cy, dx, dy) {
+    const o1 = orientation(ax, ay, bx, by, cx, cy);
+    const o2 = orientation(ax, ay, bx, by, dx, dy);
+    const o3 = orientation(cx, cy, dx, dy, ax, ay);
+    const o4 = orientation(cx, cy, dx, dy, bx, by);
+    if (o1 !== o2 && o3 !== o4)
+        return true;
+    if (o1 === 0 && onSegment(ax, ay, bx, by, cx, cy))
+        return true;
+    if (o2 === 0 && onSegment(ax, ay, bx, by, dx, dy))
+        return true;
+    if (o3 === 0 && onSegment(cx, cy, dx, dy, ax, ay))
+        return true;
+    if (o4 === 0 && onSegment(cx, cy, dx, dy, bx, by))
+        return true;
+    return false;
+}
+/** Distance from a point to the closed segment `ab`, and the position along it (0 to 1). */
+export function pointSegment(px, py, ax, ay, bx, by) {
+    const dx = bx - ax, dy = by - ay;
+    const lengthSquared = dx * dx + dy * dy;
+    let t = lengthSquared === 0 ? 0 : ((px - ax) * dx + (py - ay) * dy) / lengthSquared;
+    if (t < 0)
+        t = 0;
+    else if (t > 1)
+        t = 1;
+    const qx = ax + t * dx - px, qy = ay + t * dy - py;
+    return { distance: Math.sqrt(qx * qx + qy * qy), t };
+}
+/** Even-odd containment; a point within `BOUNDARY_EPSILON` of the ring counts as inside. */
+export function ringContains(xs, ys, px, py) {
+    let inside = false;
+    const n = xs.length;
+    for (let index = 0, previous = n - 1; index < n; previous = index++) {
+        const ax = xs[previous], ay = ys[previous], bx = xs[index], by = ys[index];
+        if (pointSegment(px, py, ax, ay, bx, by).distance <= BOUNDARY_EPSILON)
+            return true;
+        if (ay > py !== by > py && px < ((bx - ax) * (py - ay)) / (by - ay) + ax)
+            inside = !inside;
+    }
+    return inside;
+}
+/** Uniform grid over segments, so intersection tests stay near-linear on long rings. */
+export class SegmentGrid {
+    xs;
+    ys;
+    closed;
+    cells = new Map();
+    size;
+    minX;
+    minY;
+    cellWidth;
+    cellHeight;
+    constructor(xs, ys, closed, bounds) {
+        this.xs = xs;
+        this.ys = ys;
+        this.closed = closed;
+        const segments = closed ? xs.length : xs.length - 1;
+        this.size = Math.max(1, Math.min(64, Math.ceil(Math.sqrt(segments))));
+        this.minX = bounds.x0;
+        this.minY = bounds.y0;
+        this.cellWidth = Math.max((bounds.x1 - bounds.x0) / this.size, 1e-12);
+        this.cellHeight = Math.max((bounds.y1 - bounds.y0) / this.size, 1e-12);
+        for (let segment = 0; segment < segments; segment++) {
+            const [ax, ay, bx, by] = this.endpoints(segment);
+            const [cx0, cx1] = this.span(Math.min(ax, bx), Math.max(ax, bx), this.minX, this.cellWidth);
+            const [cy0, cy1] = this.span(Math.min(ay, by), Math.max(ay, by), this.minY, this.cellHeight);
+            for (let cy = cy0; cy <= cy1; cy++)
+                for (let cx = cx0; cx <= cx1; cx++) {
+                    const key = cy * this.size + cx;
+                    const list = this.cells.get(key);
+                    if (list === undefined)
+                        this.cells.set(key, [segment]);
+                    else
+                        list.push(segment);
+                }
+        }
+    }
+    get segmentCount() {
+        return this.closed ? this.xs.length : this.xs.length - 1;
+    }
+    endpoints(segment) {
+        const next = (segment + 1) % this.xs.length;
+        return [this.xs[segment], this.ys[segment], this.xs[next], this.ys[next]];
+    }
+    span(low, high, origin, cell) {
+        const clamp = (value) => Math.max(0, Math.min(this.size - 1, value));
+        return [clamp(Math.floor((low - origin) / cell)), clamp(Math.floor((high - origin) / cell))];
+    }
+    /** Visit candidate segments that share a grid cell with the box; stop when `visit` returns true. */
+    candidates(x0, y0, x1, y1, visit) {
+        const [cx0, cx1] = this.span(x0, x1, this.minX, this.cellWidth);
+        const [cy0, cy1] = this.span(y0, y1, this.minY, this.cellHeight);
+        for (let cy = cy0; cy <= cy1; cy++)
+            for (let cx = cx0; cx <= cx1; cx++) {
+                const list = this.cells.get(cy * this.size + cx);
+                if (list === undefined)
+                    continue;
+                for (const segment of list)
+                    if (visit(segment))
+                        return true;
+            }
+        return false;
+    }
+}
+/**
+ * First pair of segments that cross, touch or overlap, ignoring neighbours that only share their
+ * common vertex. A spike (a segment that doubles back on its neighbour) counts as an overlap.
+ */
+export function findSelfIntersection(xs, ys, closed) {
+    const n = xs.length;
+    const segments = closed ? n : n - 1;
+    if (segments < 2)
+        return undefined;
+    const grid = new SegmentGrid(xs, ys, closed, boundsOf(xs, ys));
+    for (let i = 0; i < segments; i++) {
+        const [ax, ay, bx, by] = grid.endpoints(i);
+        let found;
+        grid.candidates(Math.min(ax, bx), Math.min(ay, by), Math.max(ax, bx), Math.max(ay, by), (j) => {
+            if (j <= i)
+                return false;
+            const adjacent = j === i + 1 || (closed && i === 0 && j === segments - 1);
+            const [cx, cy, dx, dy] = grid.endpoints(j);
+            if (adjacent) {
+                // Neighbours legitimately meet at one vertex; they overlap when they double back.
+                const shared = j === i + 1 ? [bx, by, ax, ay, dx, dy] : [ax, ay, bx, by, cx, cy];
+                const [sx, sy, ux, uy, vx, vy] = shared;
+                const cross = (ux - sx) * (vy - sy) - (uy - sy) * (vx - sx);
+                const dot = (ux - sx) * (vx - sx) + (uy - sy) * (vy - sy);
+                if (cross === 0 && dot > 0) {
+                    found = [i, j];
+                    return true;
+                }
+                return false;
+            }
+            if (segmentsIntersect(ax, ay, bx, by, cx, cy, dx, dy)) {
+                found = [i, j];
+                return true;
+            }
+            return false;
+        });
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+}
+/** True when any segment of ring `a` meets any segment of ring `b`. */
+export function ringsIntersect(axs, ays, bxs, bys) {
+    const boundsA = boundsOf(axs, ays), boundsB = boundsOf(bxs, bys);
+    if (!boundsOverlap(boundsA, boundsB))
+        return false;
+    const grid = new SegmentGrid(axs, ays, true, boundsA);
+    const n = bxs.length;
+    for (let index = 0; index < n; index++) {
+        const next = (index + 1) % n;
+        const cx = bxs[index], cy = bys[index], dx = bxs[next], dy = bys[next];
+        const hit = grid.candidates(Math.min(cx, dx), Math.min(cy, dy), Math.max(cx, dx), Math.max(cy, dy), (segment) => {
+            const [ax, ay, bx, by] = grid.endpoints(segment);
+            return segmentsIntersect(ax, ay, bx, by, cx, cy, dx, dy);
+        });
+        if (hit)
+            return true;
+    }
+    return false;
+}
+/** Area centroid of a simple ring (the vertex mean for a zero-area ring). */
+export function ringCentroid(xs, ys) {
+    const area = signedArea(xs, ys);
+    const n = xs.length;
+    if (Math.abs(area) < 1e-15) {
+        let sx = 0, sy = 0;
+        for (let index = 0; index < n; index++) {
+            sx += xs[index];
+            sy += ys[index];
+        }
+        return [sx / n, sy / n];
+    }
+    let cx = 0, cy = 0;
+    for (let index = 0, previous = n - 1; index < n; previous = index++) {
+        const cross = xs[previous] * ys[index] - xs[index] * ys[previous];
+        cx += (xs[previous] + xs[index]) * cross;
+        cy += (ys[previous] + ys[index]) * cross;
+    }
+    return [cx / (6 * area), cy / (6 * area)];
+}
+/**
+ * The midpoint of the longest horizontal span of the shape through its centroid height, which
+ * lies inside the shape even when the shape is concave. Deterministic and cheap.
+ */
+export function interiorPoint(rings, centroidY, bounds) {
+    const candidates = [
+        centroidY,
+        ...[0.5, 0.25, 0.75, 0.375, 0.625].map((f) => bounds.y0 + (bounds.y1 - bounds.y0) * f),
+    ];
+    let best;
+    let bestLength = -1;
+    for (const y of candidates) {
+        const crossings = [];
+        for (const ring of rings) {
+            const n = ring.xs.length;
+            for (let index = 0, previous = n - 1; index < n; previous = index++) {
+                const ay = ring.ys[previous], by = ring.ys[index];
+                if (ay > y !== by > y) {
+                    const ax = ring.xs[previous], bx = ring.xs[index];
+                    crossings.push(ax + ((y - ay) * (bx - ax)) / (by - ay));
+                }
+            }
+        }
+        crossings.sort((a, b) => a - b);
+        for (let index = 0; index + 1 < crossings.length; index += 2) {
+            const length = crossings[index + 1] - crossings[index];
+            if (length > bestLength) {
+                bestLength = length;
+                best = [(crossings[index] + crossings[index + 1]) / 2, y];
+            }
+        }
+        if (best !== undefined && y === centroidY && bestLength > 0)
+            break;
+    }
+    return best ?? [(bounds.x0 + bounds.x1) / 2, (bounds.y0 + bounds.y1) / 2];
+}

package/dist/hoi4_agent_tools/map/geography/index.js

@@ -0,0 +1,6 @@
+export * from './geometry.js';
+export * from './model.js';
+export * from './preparation.js';
+export * from './preview.js';
+export * from './raster.js';
+export * from './resolve.js';

package/dist/hoi4_agent_tools/map/geography/model.js

@@ -0,0 +1,196 @@
+import { boundsContain, pointSegment, ringContains } from './geometry.js';
+/** Fixed order of kinds wherever features are listed together. */
+export const GEOGRAPHY_FEATURE_KINDS = [
+    'sea',
+    'land',
+    'region',
+    'range',
+    'pass',
+    'volcano',
+    'plateau',
+    'river',
+    'lake',
+    'biome',
+    'strait',
+    'site',
+    'road',
+    'place',
+];
+function areaContains(area, x, y) {
+    if (!boundsContain(area.bounds, x, y))
+        return false;
+    let inside = false;
+    for (const ring of area.outers)
+        if (boundsContain(ring.bounds, x, y) && ringContains(ring.xs, ring.ys, x, y)) {
+            inside = true;
+            break;
+        }
+    if (!inside)
+        return false;
+    for (const hole of area.holes)
+        if (boundsContain(hole.bounds, x, y) && ringContainsStrictly(hole, x, y))
+            return false;
+    return true;
+}
+/** A hole boundary belongs to the shape: only points strictly inside the hole are excluded. */
+function ringContainsStrictly(ring, x, y) {
+    let inside = false;
+    const n = ring.xs.length;
+    for (let index = 0, previous = n - 1; index < n; previous = index++) {
+        const ay = ring.ys[previous], by = ring.ys[index];
+        if (ay > y !== by > y) {
+            const ax = ring.xs[previous], bx = ring.xs[index];
+            if (x < ax + ((y - ay) * (bx - ax)) / (by - ay))
+                inside = !inside;
+        }
+    }
+    return inside;
+}
+/** Surface lookup over the water and land features, usable before a full model exists. */
+export function findSurface(features, x, y) {
+    for (const lake of features.lakes)
+        if (areaContains(lake.area, x, y))
+            return { surface: 'lake', id: lake.id };
+    for (const land of features.lands)
+        if (areaContains(land.area, x, y))
+            return { surface: 'land', id: land.id };
+    for (const sea of features.seas)
+        if (areaContains(sea.area, x, y))
+            return { surface: 'sea', id: sea.id };
+    return { surface: 'open-water' };
+}
+export function resolvedAreaContains(area, x, y) {
+    return areaContains(area, x, y);
+}
+/**
+ * Distance from a point to the nearest ring edge of the area, inside or outside, in map-width
+ * units (`aspect` is height over width, so one unit is the whole map width on both axes).
+ */
+export function areaBoundaryDistance(area, x, y, aspect) {
+    let best = Infinity;
+    for (const ring of [...area.outers, ...area.holes]) {
+        const n = ring.xs.length;
+        for (let index = 0, previous = n - 1; index < n; previous = index++) {
+            const found = pointSegment(x, y * aspect, ring.xs[previous], ring.ys[previous] * aspect, ring.xs[index], ring.ys[index] * aspect).distance;
+            if (found < best)
+                best = found;
+        }
+    }
+    return best;
+}
+/** The resolved model with lookup by id and by point. Construct it with `resolveGeography`. */
+export class ResolvedGeography {
+    frame;
+    hash;
+    name;
+    description;
+    seas;
+    lands;
+    regions;
+    ranges;
+    passes;
+    volcanoes;
+    plateaus;
+    rivers;
+    lakes;
+    biomes;
+    straits;
+    sites;
+    roads;
+    places;
+    climate;
+    pointCount;
+    byId;
+    constructor(data) {
+        this.frame = data.frame;
+        this.hash = data.hash;
+        if (data.name !== undefined)
+            this.name = data.name;
+        if (data.description !== undefined)
+            this.description = data.description;
+        this.seas = data.seas;
+        this.lands = data.lands;
+        this.regions = data.regions;
+        this.ranges = data.ranges;
+        this.passes = data.passes;
+        this.volcanoes = data.volcanoes;
+        this.plateaus = data.plateaus;
+        this.rivers = data.rivers;
+        this.lakes = data.lakes;
+        this.biomes = data.biomes;
+        this.straits = data.straits;
+        this.sites = data.sites;
+        this.roads = data.roads;
+        this.places = data.places;
+        this.climate = data.climate;
+        this.pointCount = data.pointCount;
+        this.byId = new Map(this.features().map((feature) => [feature.id, feature]));
+    }
+    /** Every feature, grouped by `GEOGRAPHY_FEATURE_KINDS` and sorted by id inside a group. */
+    features() {
+        return [
+            ...this.seas,
+            ...this.lands,
+            ...this.regions,
+            ...this.ranges,
+            ...this.passes,
+            ...this.volcanoes,
+            ...this.plateaus,
+            ...this.rivers,
+            ...this.lakes,
+            ...[...this.biomes].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)),
+            ...this.straits,
+            ...this.sites,
+            ...this.roads,
+            ...this.places,
+        ];
+    }
+    get featureCount() {
+        return this.byId.size;
+    }
+    /** The feature with this id, of any kind. */
+    find(id) {
+        return this.byId.get(id);
+    }
+    /** The feature with this id when it has the given kind. */
+    get(kind, id) {
+        const feature = this.byId.get(id);
+        return feature?.kind === kind ? feature : undefined;
+    }
+    list(kind) {
+        const lists = {
+            sea: this.seas,
+            land: this.lands,
+            region: this.regions,
+            range: this.ranges,
+            pass: this.passes,
+            volcano: this.volcanoes,
+            plateau: this.plateaus,
+            river: this.rivers,
+            lake: this.lakes,
+            biome: this.biomes,
+            strait: this.straits,
+            site: this.sites,
+            road: this.roads,
+            place: this.places,
+        };
+        return lists[kind];
+    }
+    /** The first land (by id) containing the point, if any. */
+    landIdAt(x, y) {
+        for (const land of this.lands)
+            if (areaContains(land.area, x, y))
+                return land.id;
+        return undefined;
+    }
+    /**
+     * What the model says is at a point. Lakes carve land; land beats sea; a point in no feature is
+     * open water. Boundaries belong to the feature (a coastline point is land).
+     */
+    surfaceAt(x, y) {
+        return findSurface(this, x, y);
+    }
+    isLandAt(x, y) {
+        return this.surfaceAt(x, y).surface === 'land';
+    }
+}