@datamoc/mw_games 0.31.0 → 0.34.0

package/dist/roguelike/Cave.js

@@ -0,0 +1,216 @@
+import { hexDistance, hexNeighbors, hexToPixel } from '../core/Hex.js';
+import * as Random from '../core/Random.js';
+import { DUNGEON_KINDS } from './generate.js';
+import { Level } from './Level.js';
+/** the four orthogonal neighbours, the square-grid cave's whole step set */
+function squareNeighbours(x, y) {
+    return [
+        [x, y - 1],
+        [x, y + 1],
+        [x - 1, y],
+        [x + 1, y],
+    ];
+}
+function hexNeighbours(x, y) {
+    return hexNeighbors(x, y).map((cell) => [cell.x, cell.y]);
+}
+/** a regular flat-top hex is 2/sqrt(3) wider than tall, so pixel distance is true distance */
+const HEX_TILE_WIDTH = 2 / Math.sqrt(3);
+function hexPixelDistanceSquared(ax, ay, bx, by) {
+    const a = hexToPixel(ax, ay, HEX_TILE_WIDTH, 1);
+    const b = hexToPixel(bx, by, HEX_TILE_WIDTH, 1);
+    return (a.x - b.x) ** 2 + (a.y - b.y) ** 2;
+}
+export function generateCave(options) {
+    const { width, height } = options;
+    if (width < 5 || height < 5)
+        throw new Error('a cave needs at least 5x5 cells');
+    if (options.chambers.length < 1)
+        throw new Error('a cave needs at least one chamber');
+    const wall = options.wall ?? 0;
+    const floor = options.floor ?? 1;
+    const kinds = options.kinds ?? [];
+    const shape = options.shape ?? 'square';
+    const hex = shape === 'hex';
+    const neighbours = hex ? hexNeighbours : squareNeighbours;
+    //how far a cell is from a target: growth wants rings around the centre, a walk wants the
+    //step that closes in on the target in the picture the player sees
+    const growthDistance = (ax, ay, bx, by) => hex ? hexDistance({ x: ax, y: ay }, { x: bx, y: by }) : Math.abs(ax - bx) + Math.abs(ay - by);
+    const walkDistance = (ax, ay, bx, by) => hex ? hexPixelDistanceSquared(ax, ay, bx, by) : (ax - bx) ** 2 + (ay - by) ** 2;
+    if (options.random === undefined && options.seed === undefined)
+        throw new Error('a cave needs a seed or a random source');
+    const source = options.random;
+    const roll = (bound) => Random.int(bound, undefined, source);
+    const level = new Level(width, height, [...DUNGEON_KINDS, ...kinds], wall, shape);
+    const at = (x, y) => y * width + x;
+    const inner = (x, y) => level.insideWithBorder(x, y);
+    const open = new Uint8Array(width * height);
+    const carve = (x, y) => {
+        if (inner(x, y))
+            open[at(x, y)] = 1;
+    };
+    if (source === undefined)
+        Random.push(options.seed);
+    try {
+        const centres = new Map();
+        const cellsById = new Map();
+        for (const chamber of options.chambers) {
+            if (chamber.size < 1)
+                throw new Error(`cave chamber ${chamber.id} needs at least one cell`);
+            const cx = Random.range(Math.max(1, chamber.xRange[0]), Math.min(width - 2, chamber.xRange[1]), source);
+            const cy = Random.range(Math.max(1, chamber.yRange[0]), Math.min(height - 2, chamber.yRange[1]), source);
+            centres.set(chamber.id, { x: cx, y: cy });
+            // random growth: absorb frontier cells until `size` are carved; `jagged` is the
+            // chance a step picks any frontier cell instead of the one nearest the centre
+            const cells = [{ x: cx, y: cy }];
+            const seen = new Set([at(cx, cy)]);
+            const frontier = [];
+            const push = (x, y) => {
+                for (const [nx, ny] of neighbours(x, y)) {
+                    if (!inner(nx, ny) || seen.has(at(nx, ny)))
+                        continue;
+                    seen.add(at(nx, ny));
+                    frontier.push([nx, ny]);
+                }
+            };
+            push(cx, cy);
+            while (cells.length < chamber.size && frontier.length) {
+                let pick = 0;
+                if (roll(100) < (chamber.jagged ?? 0)) {
+                    pick = roll(frontier.length);
+                }
+                else {
+                    let best = Infinity;
+                    for (let index = 0; index < frontier.length; index++) {
+                        const distance = growthDistance(frontier[index][0], frontier[index][1], cx, cy);
+                        if (distance < best) {
+                            best = distance;
+                            pick = index;
+                        }
+                    }
+                }
+                const [nx, ny] = frontier.splice(pick, 1)[0];
+                cells.push({ x: nx, y: ny });
+                push(nx, ny);
+            }
+            for (const cell of cells)
+                carve(cell.x, cell.y);
+            cellsById.set(chamber.id, cells);
+        }
+        // a passage is a biased random walk from one chamber centre to another
+        const walk = (from, to, widthHexes, windiness) => {
+            let x = from.x;
+            let y = from.y;
+            for (let step = 0; step < width * height && (x !== to.x || y !== to.y); step++) {
+                carve(x, y);
+                if (widthHexes > 1)
+                    for (const [nx, ny] of neighbours(x, y).slice(0, widthHexes - 1))
+                        carve(nx, ny);
+                const steps = neighbours(x, y).filter(([nx, ny]) => inner(nx, ny));
+                let next = steps[0];
+                if (roll(100) < windiness) {
+                    next = steps[roll(steps.length)];
+                }
+                else {
+                    let best = Infinity;
+                    for (const option of steps) {
+                        const distance = walkDistance(option[0], option[1], to.x, to.y);
+                        if (distance < best) {
+                            best = distance;
+                            next = option;
+                        }
+                    }
+                }
+                [x, y] = next;
+            }
+            carve(to.x, to.y);
+        };
+        for (const chamber of options.chambers) {
+            for (const passage of chamber.passages) {
+                const from = centres.get(chamber.id);
+                const to = centres.get(passage.to);
+                if (!from || !to)
+                    throw new Error(`cave passage ${chamber.id} -> ${passage.to} names no chamber`);
+                if (roll(100) >= (passage.chance ?? 100))
+                    continue;
+                walk(from, to, Math.max(1, passage.width ?? 1), passage.windiness ?? 0);
+            }
+        }
+        // everything the game named must be walkable, whatever the rolls did
+        const mustBeClear = options.mustBeClear ?? [];
+        for (const point of mustBeClear) {
+            carve(point.x, point.y);
+            for (const [nx, ny] of neighbours(point.x, point.y))
+                carve(nx, ny);
+        }
+        // force-join every chamber centre and mustBeClear cell to the first chamber, so the
+        // cave is always connected even where `chance` left a passage out
+        const first = centres.get(options.chambers[0].id);
+        if (first) {
+            const reachable = () => {
+                const found = new Set([at(first.x, first.y)]);
+                const queue = [[first.x, first.y]];
+                while (queue.length) {
+                    const [x, y] = queue.pop();
+                    for (const [nx, ny] of neighbours(x, y)) {
+                        if (!inner(nx, ny) || !open[at(nx, ny)] || found.has(at(nx, ny)))
+                            continue;
+                        found.add(at(nx, ny));
+                        queue.push([nx, ny]);
+                    }
+                }
+                return found;
+            };
+            for (const target of [...centres.values(), ...mustBeClear]) {
+                if (!inner(target.x, target.y) || reachable().has(at(target.x, target.y)))
+                    continue;
+                walk(target, first, 1, 15);
+            }
+        }
+        const reserved = new Set();
+        const starts = [];
+        for (const start of options.starts ?? []) {
+            const centre = centres.get(start.chamber);
+            if (!centre)
+                throw new Error(`cave start ${start.side} names no chamber`);
+            carve(centre.x, centre.y);
+            reserved.add(at(centre.x, centre.y));
+            if (start.ring)
+                for (const [nx, ny] of neighbours(centre.x, centre.y)) {
+                    if (!inner(nx, ny))
+                        continue;
+                    carve(nx, ny);
+                    reserved.add(at(nx, ny));
+                }
+            starts.push({ side: start.side, x: centre.x, y: centre.y });
+        }
+        const villages = [];
+        const density = options.villageDensity ?? 0;
+        if (density > 0) {
+            const candidates = [];
+            for (let index = 0; index < open.length; index++)
+                if (open[index] && !reserved.has(index))
+                    candidates.push(index);
+            const wanted = Math.floor((candidates.length * density) / 1000);
+            for (let placed = 0; placed < wanted && candidates.length; placed++) {
+                const pick = roll(candidates.length);
+                const index = candidates.splice(pick, 1)[0];
+                villages.push({ x: index % width, y: Math.floor(index / width) });
+            }
+        }
+        for (let index = 0; index < open.length; index++)
+            if (open[index])
+                level.set(index % width, Math.floor(index / width), floor);
+        return {
+            level,
+            chambers: [...cellsById.entries()].map(([id, cells]) => ({ id, centre: centres.get(id), cells })),
+            starts,
+            villages,
+        };
+    }
+    finally {
+        if (source === undefined)
+            Random.pop();
+    }
+}
+//# sourceMappingURL=Cave.js.map

package/dist/roguelike/Cave.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cave.js","sourceRoot":"","sources":["../../src/roguelike/Cave.ts"],"names":[],"mappings":"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"}

package/dist/roguelike/Overworld.d.ts

@@ -0,0 +1,89 @@
+import type { LevelShape } from './Level.ts';
+/**
+ * An overworld map: a whole realm as plain tile data.
+ *
+ * The world-map counterpart to `generateDungeon` and `generateCave`: elevation and moisture
+ * fields from seeded value noise classify each cell into water, plains, forest, hills,
+ * mountains, desert or swamp (the `seaLevel` knob decides how much is sea); rivers run from
+ * high ground down to the sea or a lake, merging when they meet and never crossing a
+ * mountain ridge (a ridge stops a river as a lake instead); settlements place themselves by
+ * suitability (near water, on buildable ground, spaced apart) and join into a road network
+ * that prefers flat ground and fords a river where it must cross one; points of interest
+ * carry a `leadsTo` id a game feeds its `Overworld` locations with; and every cell carries a
+ * coarse region id so encounter tables and names can hang off a region instead of a cell.
+ *
+ * `shape: 'hex'` generates the same realm on a hex grid (odd-q offset coordinates, the `Level`
+ * convention): the noise is sampled where each hex is drawn so landmasses are not stretched,
+ * rivers and roads step across the six edges, spacing and "near water" count hex distance.
+ *
+ * Deterministic: the same seed gives the same realm on every platform, drawn from the
+ * framework `Random` stack. Sizes up to a few hundred tiles a side generate on load; a
+ * bigger realm is a `threads.spawn` task like any other long job.
+ *
+ * @example
+ * ```ts
+ * import { generateOverworld } from '@datamoc/mw_games/roguelike';
+ *
+ * const realm = generateOverworld({ width: 96, height: 64, seed: 42 });
+ * console.log(realm.terrain[0]); // 'water' | 'plains' | 'forest' | ...
+ * console.log(realm.settlements.length); // roads join every one of them
+ * ```
+ */
+export type OverworldTerrain = 'water' | 'plains' | 'forest' | 'hills' | 'mountains' | 'desert' | 'swamp';
+export interface OverworldOptions {
+    width: number;
+    height: number;
+    seed: number;
+    /** elevation below which a cell is sea; 0..1, defaults to 0.4 */
+    seaLevel?: number;
+    /** river sources attempted on high ground; defaults to `width * height / 600` */
+    rivers?: number;
+    /** settlements to place by suitability; defaults to `width * height / 500` */
+    settlements?: number;
+    /** points of interest to place; defaults to `width * height / 900` */
+    pointsOfInterest?: number;
+    /** the coarse region grid's cell side, in tiles; defaults to 12 */
+    regionSize?: number;
+    /** how stretched the noise is: larger values give broader landmasses; defaults to 6 */
+    noiseScale?: number;
+    /** the grid the realm is laid out on; defaults to `'square'` */
+    shape?: LevelShape;
+}
+export interface OverworldSettlement {
+    x: number;
+    y: number;
+    kind: 'village' | 'town' | 'castle';
+}
+export interface OverworldInterest {
+    x: number;
+    y: number;
+    kind: 'ruin' | 'shrine' | 'dungeon';
+    /** the id a game's `Overworld` location this point leads to carries */
+    leadsTo: string;
+}
+export interface OverworldResult {
+    /** row-major terrain ids, `width * height` entries */
+    terrain: OverworldTerrain[];
+    /** row-major elevation, 0..1, the field `terrain` was classified from */
+    elevation: number[];
+    /** row-major moisture, 0..1 */
+    moisture: number[];
+    /** each river's cells from its source to its mouth or lake */
+    rivers: Array<Array<{
+        x: number;
+        y: number;
+    }>>;
+    /** each road's cells, settlement to settlement; river crossings are the ford sites */
+    roads: Array<Array<{
+        x: number;
+        y: number;
+    }>>;
+    settlements: OverworldSettlement[];
+    pointsOfInterest: OverworldInterest[];
+    /** coarse region id per cell, row-major; region r's cells share `(y / regionSize) * cols + (x / regionSize)` */
+    regions: number[];
+    /** how many columns the coarse region grid has */
+    regionColumns: number;
+}
+export declare function generateOverworld(options: OverworldOptions): OverworldResult;
+//# sourceMappingURL=Overworld.d.ts.map

package/dist/roguelike/Overworld.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Overworld.d.ts","sourceRoot":"","sources":["../../src/roguelike/Overworld.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,WAAW,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE1G,MAAM,WAAW,gBAAgB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IAEb,iEAAiE;IACjE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iFAAiF;IACjF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8EAA8E;IAC9E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sEAAsE;IACtE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mEAAmE;IACnE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uFAAuF;IACvF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,KAAK,CAAC,EAAE,UAAU,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IACnC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;CACpC;AAED,MAAM,WAAW,iBAAiB;IACjC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;IACpC,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC/B,sDAAsD;IACtD,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,yEAAyE;IACzE,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,8DAA8D;IAC9D,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;IAC/C,sFAAsF;IACtF,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;IAC9C,WAAW,EAAE,mBAAmB,EAAE,CAAC;IACnC,gBAAgB,EAAE,iBAAiB,EAAE,CAAC;IACtC,gHAAgH;IAChH,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,kDAAkD;IAClD,aAAa,EAAE,MAAM,CAAC;CACtB;AA+ED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,gBAAgB,GAAG,eAAe,CAkK5E"}

package/dist/roguelike/Overworld.js

@@ -0,0 +1,325 @@
+import { hexDistance, hexNeighbors, hexRange } from '../core/Hex.js';
+import * as Random from '../core/Random.js';
+/** seeded value noise: a lattice of random values, smoothly interpolated, a few octaves */
+function valueNoise(random, width, height, scale, hex) {
+    const latticeSide = (side) => Math.max(2, Math.ceil(side / scale) + 2);
+    const columns = latticeSide(width);
+    const rows = latticeSide(height);
+    const lattice = new Float64Array(columns * rows);
+    for (let index = 0; index < lattice.length; index++)
+        lattice[index] = random();
+    const smooth = (t) => t * t * (3 - 2 * t);
+    const field = new Array(width * height).fill(0);
+    for (let octave = 0; octave < 3; octave++) {
+        const factor = 1 << octave;
+        const weight = 1 / (factor * factor);
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                //on a hex grid sample where the cell is drawn: columns are 0.866 apart and
+                //odd columns sit half a row lower
+                const gx = ((hex ? x * HEX_COLUMN_PITCH : x) / scale) * factor;
+                const gy = ((hex ? y + (x & 1) / 2 : y) / scale) * factor;
+                const x0 = Math.floor(gx) % (columns - 1);
+                const y0 = Math.floor(gy) % (rows - 1);
+                const fx = smooth(gx - Math.floor(gx));
+                const fy = smooth(gy - Math.floor(gy));
+                const at = (lx, ly) => lattice[((y0 + ly) % rows) * columns + ((x0 + lx) % columns)];
+                const top = at(0, 0) * (1 - fx) + at(1, 0) * fx;
+                const bottom = at(0, 1) * (1 - fx) + at(1, 1) * fx;
+                field[y * width + x] += (top * (1 - fy) + bottom * fy) * weight;
+            }
+        }
+    }
+    const total = 1 + 1 / 4 + 1 / 16;
+    for (let index = 0; index < field.length; index++)
+        field[index] /= total;
+    return field;
+}
+/** distance between hex columns in units of the row height: 3/4 of a flat-top hex's width */
+const HEX_COLUMN_PITCH = Math.sqrt(3) / 2;
+const EIGHT = [
+    [0, -1],
+    [0, 1],
+    [-1, 0],
+    [1, 0],
+    [-1, -1],
+    [1, -1],
+    [-1, 1],
+    [1, 1],
+];
+/**
+ * Visit the cells a river or road may step to from `(x, y)`: the eight surrounding squares
+ * (flagged diagonal for the corners), or the six hexes, every one an edge neighbour.
+ */
+function forEachStep(hex, x, y, visit) {
+    if (hex) {
+        for (const cell of hexNeighbors(x, y))
+            visit(cell.x, cell.y, false);
+        return;
+    }
+    for (const [dx, dy] of EIGHT)
+        visit(x + dx, y + dy, dx !== 0 && dy !== 0);
+}
+/** how much a road dislikes crossing each terrain; water is only crossable at a ford */
+const ROAD_COST = {
+    plains: 1,
+    forest: 3,
+    hills: 5,
+    desert: 2,
+    swamp: 6,
+    water: 24,
+    mountains: 40,
+};
+export function generateOverworld(options) {
+    const { width, height } = options;
+    if (width < 16 || height < 16)
+        throw new Error('an overworld needs at least 16x16 tiles');
+    const seaLevel = options.seaLevel ?? 0.4;
+    if (!(seaLevel > 0 && seaLevel < 1))
+        throw new Error('seaLevel must be between 0 and 1');
+    const scale = options.noiseScale ?? 6;
+    const hex = options.shape === 'hex';
+    const at = (x, y) => y * width + x;
+    const inside = (x, y) => x >= 0 && y >= 0 && x < width && y < height;
+    Random.push(options.seed);
+    try {
+        //a terrain field from elevation and moisture, both seeded; landmasses read as
+        //coherent shapes rather than scattered peaks because the noise octaves overlap
+        const elevation = valueNoise(() => Random.float(), width, height, scale, hex);
+        const moisture = valueNoise(() => Random.float(), width, height, scale * 1.5, hex);
+        const terrain = new Array(width * height);
+        const classify = (x, y) => {
+            const index = at(x, y);
+            const up = elevation[index];
+            const wet = moisture[index];
+            if (up < seaLevel)
+                return 'water';
+            if (up > 0.78)
+                return 'mountains';
+            if (up > 0.62)
+                return 'hills';
+            if (wet < 0.3)
+                return 'desert';
+            if (wet > 0.72)
+                return up < seaLevel + 0.08 ? 'swamp' : 'forest';
+            return 'plains';
+        };
+        for (let y = 0; y < height; y++)
+            for (let x = 0; x < width; x++)
+                terrain[at(x, y)] = classify(x, y);
+        //rivers: walk downhill from high ground to the sea or a lake; two rivers that
+        //meet merge (the second stops on the first), and a ridge that stops a walk
+        //drowns its basin cell into a lake instead of crossing the mountains
+        const riverCells = new Set();
+        const rivers = [];
+        const riverTarget = options.rivers ?? Math.max(1, Math.floor((width * height) / 600));
+        const highGround = [];
+        for (let index = 0; index < terrain.length; index++)
+            if (elevation[index] > 0.7 && terrain[index] !== 'water')
+                highGround.push(index);
+        for (let attempt = 0; attempt < riverTarget * 4 && rivers.length < riverTarget; attempt++) {
+            if (highGround.length === 0)
+                break;
+            const sourceIndex = highGround[Random.int(highGround.length)];
+            const path = [];
+            let x = sourceIndex % width;
+            let y = Math.floor(sourceIndex / width);
+            const walked = new Set();
+            for (let step = 0; step < width + height; step++) {
+                const index = at(x, y);
+                if (riverCells.has(index) || terrain[index] === 'water') {
+                    if (path.length > 0)
+                        path.push({ x, y });
+                    break;
+                }
+                path.push({ x, y });
+                walked.add(index);
+                let best;
+                forEachStep(hex, x, y, (nx, ny) => {
+                    if (!inside(nx, ny))
+                        return;
+                    const candidate = { x: nx, y: ny, up: elevation[at(nx, ny)] };
+                    if (!best || candidate.up < best.up)
+                        best = candidate;
+                });
+                if (!best || best.up >= elevation[at(x, y)]) {
+                    //no way down: a ridge or a basin. Drown the cell as a lake and stop here
+                    terrain[at(x, y)] = 'water';
+                    break;
+                }
+                [x, y] = [best.x, best.y];
+            }
+            if (path.length >= 2) {
+                for (const cell of path)
+                    riverCells.add(at(cell.x, cell.y));
+                rivers.push(path);
+            }
+        }
+        //settlements: buildable ground near water, spaced apart; a castle prefers hills,
+        //a town the plains, and everything else reads as a village
+        const settlements = [];
+        const nearWater = (x, y) => {
+            if (hex)
+                return hexRange({ x, y }, 3).some((cell) => inside(cell.x, cell.y) && terrain[at(cell.x, cell.y)] === 'water');
+            for (let dy = -3; dy <= 3; dy++)
+                for (let dx = -3; dx <= 3; dx++) {
+                    const nx = x + dx;
+                    const ny = y + dy;
+                    if (inside(nx, ny) && terrain[at(nx, ny)] === 'water')
+                        return true;
+                }
+            return false;
+        };
+        const spaced = (x, y, distance) => settlements.every((settlement) => (hex
+            ? hexDistance(settlement, { x, y })
+            : Math.abs(settlement.x - x) + Math.abs(settlement.y - y)) >= distance);
+        const wanted = options.settlements ?? Math.max(2, Math.floor((width * height) / 500));
+        for (let attempt = 0; attempt < wanted * 60 && settlements.length < wanted; attempt++) {
+            const x = Random.int(width);
+            const y = Random.int(height);
+            const kind = terrain[at(x, y)];
+            if ((kind !== 'plains' && kind !== 'hills' && kind !== 'forest') || !nearWater(x, y))
+                continue;
+            if (!spaced(x, y, 8))
+                continue;
+            settlements.push({ x, y, kind: kind === 'hills' ? 'castle' : 'town' });
+        }
+        for (const settlement of settlements)
+            if (settlement.kind === 'town' && Random.int(2) === 0)
+                settlement.kind = 'village';
+        //roads: a Dijkstra tree over the settlements, preferring flat ground; a water or
+        //river cell on a route is a ford or bridge site, which is why water is expensive
+        //rather than impassable here
+        const roads = [];
+        const from = settlements[0];
+        if (from) {
+            const connected = [from];
+            const pending = settlements.slice(1);
+            while (pending.length) {
+                let bestRoute;
+                for (const to of pending) {
+                    for (const start of connected) {
+                        const path = roadBetween(terrain, width, height, start, to, hex);
+                        if (path && (!bestRoute || path.length < bestRoute.path.length))
+                            bestRoute = { path, to };
+                    }
+                }
+                if (!bestRoute)
+                    break;
+                roads.push(bestRoute.path);
+                connected.push(bestRoute.to);
+                pending.splice(pending.indexOf(bestRoute.to), 1);
+            }
+        }
+        //points of interest away from settlements, each leading somewhere
+        const pointsOfInterest = [];
+        const wantedInterest = options.pointsOfInterest ?? Math.max(1, Math.floor((width * height) / 900));
+        for (let attempt = 0; attempt < wantedInterest * 40 && pointsOfInterest.length < wantedInterest; attempt++) {
+            const x = Random.int(width);
+            const y = Random.int(height);
+            const kind = terrain[at(x, y)];
+            if (kind === 'water' || kind === 'mountains')
+                continue;
+            if (!spaced(x, y, 6))
+                continue;
+            const kinds = ['ruin', 'shrine', 'dungeon'];
+            const interest = kinds[Random.int(kinds.length)];
+            pointsOfInterest.push({
+                x,
+                y,
+                kind: interest,
+                leadsTo: `overworld-${interest}-${pointsOfInterest.length}`,
+            });
+        }
+        //regions: a coarse id per cell, so a game hangs encounters and names off a region
+        const regionSize = Math.max(2, options.regionSize ?? 12);
+        const regionColumns = Math.ceil(width / regionSize);
+        const regions = new Array(width * height);
+        for (let y = 0; y < height; y++)
+            for (let x = 0; x < width; x++)
+                regions[at(x, y)] = Math.floor(y / regionSize) * regionColumns + Math.floor(x / regionSize);
+        return { terrain, elevation, moisture, rivers, roads, settlements, pointsOfInterest, regions, regionColumns };
+    }
+    finally {
+        Random.pop();
+    }
+}
+/** one road: Dijkstra from one settlement to another over per-terrain costs */
+function roadBetween(terrain, width, height, from, to, hex) {
+    const at = (x, y) => y * width + x;
+    const inside = (x, y) => x >= 0 && y >= 0 && x < width && y < height;
+    const total = width * height;
+    const distance = new Float64Array(total).fill(Infinity);
+    const previous = new Int32Array(total).fill(-1);
+    const start = at(from.x, from.y);
+    const goal = at(to.x, to.y);
+    distance[start] = 0;
+    //a binary heap keyed by distance: with per-terrain costs this stays fast at the
+    //'few hundred tiles a side' sizes an overworld is allowed to load with
+    const heap = [start];
+    const inHeap = new Uint8Array(total);
+    const swapDown = (position) => {
+        while (true) {
+            const left = position * 2 + 1;
+            const right = left + 1;
+            let smallest = position;
+            if (left < heap.length && distance[heap[left]] < distance[heap[smallest]])
+                smallest = left;
+            if (right < heap.length && distance[heap[right]] < distance[heap[smallest]])
+                smallest = right;
+            if (smallest === position)
+                return;
+            [heap[position], heap[smallest]] = [heap[smallest], heap[position]];
+            position = smallest;
+        }
+    };
+    const pop = () => {
+        const top = heap[0];
+        const last = heap.pop();
+        if (heap.length) {
+            heap[0] = last;
+            swapDown(0);
+        }
+        inHeap[top] = 0;
+        return top;
+    };
+    const push = (cell) => {
+        heap.push(cell);
+        inHeap[cell] = 1;
+        let position = heap.length - 1;
+        while (position > 0) {
+            const parent = (position - 1) >> 1;
+            if (distance[heap[parent]] <= distance[heap[position]])
+                break;
+            [heap[position], heap[parent]] = [heap[parent], heap[position]];
+            position = parent;
+        }
+    };
+    while (heap.length) {
+        const current = pop();
+        if (current === goal) {
+            const path = [];
+            for (let cell = goal; cell !== -1; cell = previous[cell])
+                path.push({ x: cell % width, y: Math.floor(cell / width) });
+            return path.reverse();
+        }
+        const cx = current % width;
+        const cy = Math.floor(current / width);
+        forEachStep(hex, cx, cy, (nx, ny, diagonal) => {
+            if (!inside(nx, ny))
+                return;
+            const next = at(nx, ny);
+            if (distance[current] === Infinity)
+                return;
+            const step = ROAD_COST[terrain[next]] * (diagonal ? 1.5 : 1);
+            if (distance[current] + step < distance[next]) {
+                distance[next] = distance[current] + step;
+                previous[next] = current;
+                if (!inHeap[next])
+                    push(next);
+            }
+        });
+    }
+    return undefined;
+}
+//# sourceMappingURL=Overworld.js.map