@v12-engine/engine 0.1.1 → 0.4.0

package/dist/generate.js

@@ -0,0 +1,1062 @@
+import { atan, atan2, cos, hypot, sin } from "./exactMath.js";
+import { createMap } from "./map/types.js";
+import { Rng } from "./rng.js";
+import "./terrain.js";
+import { mapTerrain } from "./map/terrain.js";
+import { layeredNoise } from "./noise.js";
+import { checkMap } from "./mapCheck.js";
+//#region src/generate.ts
+/**
+* Maps made by a generator (world plan G1): a map from a seed and a few sliders, made of passes a game adds to,
+* replaces or leaves out, each a function of a context that holds the map, the seed's numbers, noise that repeats
+* across the map, the symmetry and what the passes before put down. Deterministic: the engine's `Rng`, nothing of
+* the clock. The engine's own passes shape the ground (`terrainPass`), paint it (`tilesPass`), seat the players
+* (`startsPass`), scatter things over it (`scatterPass`: trees now, rocks and houses the same way later), put
+* resources near the starts (`resourcesPass`) and lay roads (`roadsPass`); `generateMap` runs them and checks the map
+* (`checkMap`), trying the next seed where a start is cut off or blocked. A game declares its generator
+* (`Rules.generator`), for the editor and the page to find; `presetGenerator` is the engine's to take whole
+*/
+/**
+* The map a generator makes of options: its passes run in order on a map of the size and players asked, with the
+* game's tiles; then checked (`checkMap`). A map with a problem that keeps it from being played (a start cut off from
+* the others, or where nothing walks) is thrown away and the next seed tried, `tries` times; the last is given with
+* its problems. The map says how it was made (`GameMap.generated`)
+*
+* @beta
+*/
+function generateMap(generator, options, registry) {
+	const tries = Math.max(1, generator.tries ?? 4);
+	let last;
+	for (let attempt = 0; attempt < tries; attempt++) {
+		const seed = options.seed + attempt;
+		const map = createMap({
+			name: options.name ?? `Generated ${seed}`,
+			width: options.width,
+			depth: options.depth,
+			players: options.players,
+			game: registry.module?.id,
+			tileset: registry.tileIds
+		});
+		const ctx = createContext(map, {
+			...options,
+			seed
+		}, registry, generator);
+		for (const pass of generator.passes) pass.run(ctx);
+		map.generated = {
+			seed,
+			options: {
+				...options,
+				seed
+			}
+		};
+		const problems = checkMap(map, registry);
+		last = {
+			map,
+			problems,
+			seed
+		};
+		if (!problems.some(unplayable)) return last;
+	}
+	return last;
+}
+/** What keeps a map from being played, so that the next seed is tried: an error, or a start cut off from the others or blocked */
+var unplayable = (problem) => problem.error || problem.rule === "starts-apart" || problem.rule === "start-blocked";
+var SYMMETRIES = [
+	"none",
+	"x",
+	"z",
+	"both",
+	"half",
+	"quarter"
+];
+/**
+* The places a point is mirrored or turned to, the point first (as the editor's `mirrors`)
+*
+* @beta
+*/
+function symmetricPlaces(symmetry, width, depth, x, z) {
+	const out = [{
+		x,
+		z
+	}];
+	const add = (px, pz) => {
+		if (!out.some((other) => Math.abs(other.x - px) < 1e-6 && Math.abs(other.z - pz) < 1e-6)) out.push({
+			x: px,
+			z: pz
+		});
+	};
+	switch (symmetry) {
+		case "x":
+			add(width - x, z);
+			break;
+		case "z":
+			add(x, depth - z);
+			break;
+		case "both":
+			add(width - x, z);
+			add(x, depth - z);
+			add(width - x, depth - z);
+			break;
+		case "half":
+			add(width - x, depth - z);
+			break;
+		case "quarter": {
+			const cx = width / 2;
+			const cz = depth / 2;
+			for (let k = 1; k < 4; k++) {
+				let px = x - cx;
+				let pz = z - cz;
+				for (let i = 0; i < k; i++) [px, pz] = [-pz, px];
+				add(cx + px, cz + pz);
+			}
+			break;
+		}
+	}
+	return out;
+}
+/** How many places a mirrored set has at most: four, for quarter turns and both ways */
+var MIRRORS = 4;
+/** The first of a point's mirrored set, by row then column: where a noise is read, so the noise is mirrored as the map is */
+function firstPlace(symmetry, width, depth, x, z, out) {
+	out.x = x;
+	out.z = z;
+	const take = (px, pz) => takeFirst(out, px, pz);
+	switch (symmetry) {
+		case "x":
+			take(width - x, z);
+			break;
+		case "z":
+			take(x, depth - z);
+			break;
+		case "both":
+			take(width - x, z);
+			take(x, depth - z);
+			take(width - x, depth - z);
+			break;
+		case "half":
+			take(width - x, depth - z);
+			break;
+		case "quarter": {
+			const cx = width / 2;
+			const cz = depth / 2;
+			let px = x - cx;
+			let pz = z - cz;
+			for (let k = 1; k < 4; k++) {
+				[px, pz] = [-pz, px];
+				take(cx + px, cz + pz);
+			}
+			break;
+		}
+	}
+}
+/** The earlier of a place and another, by row then column, kept in `out` */
+function takeFirst(out, px, pz) {
+	if (pz < out.z - 1e-6 || Math.abs(pz - out.z) < 1e-6 && px < out.x) {
+		out.x = px;
+		out.z = pz;
+	}
+}
+function createContext(map, options, registry, generator) {
+	const { width, depth } = map;
+	const symmetry = options.symmetry ?? "none";
+	if (!SYMMETRIES.includes(symmetry)) throw new Error(`generateMap: there is no symmetry "${symmetry}": ${SYMMETRIES.join(", ")}`);
+	if (symmetry === "quarter" && (width !== depth || width % 2)) throw new Error("generateMap: quarter turns need a square map with even sides");
+	const rng = new Rng(options.seed);
+	const defaults = Object.fromEntries(generator.params.map((param) => [param.id, param.default]));
+	const given = options.params ?? {};
+	const noises = /* @__PURE__ */ new Map();
+	const placed = [];
+	let nextId = 1;
+	const mirrors = new Int32Array(width * depth * MIRRORS).fill(-1);
+	const canon = new Int32Array(width * depth);
+	for (let c = 0; c < canon.length; c++) {
+		const cx = c % width;
+		const cz = (c - cx) / width;
+		let first = c;
+		let n = 0;
+		for (const place of symmetricPlaces(symmetry, width, depth, cx + .5, cz + .5)) {
+			const mx = Math.floor(place.x);
+			const mz = Math.floor(place.z);
+			if (mx < 0 || mz < 0 || mx >= width || mz >= depth) continue;
+			const m = mz * width + mx;
+			mirrors[c * MIRRORS + n++] = m;
+			first = Math.min(first, m);
+		}
+		canon[c] = first;
+	}
+	const GRID = 8;
+	const cols = Math.ceil(width / GRID);
+	const rows = Math.ceil(depth / GRID);
+	const grid = Array.from({ length: cols * rows }, () => []);
+	let widest = 0;
+	const point = {
+		x: 0,
+		z: 0
+	};
+	const drawn = /* @__PURE__ */ new Map();
+	return {
+		map,
+		rng,
+		options,
+		registry,
+		param: (id, fallback) => given[id] ?? defaults[id] ?? fallback,
+		symmetric: (x, z) => symmetricPlaces(symmetry, width, depth, x, z),
+		canonical: (cx, cz) => canon[cz * width + cx] === cz * width + cx,
+		once: (x, z, draw) => {
+			const cx = Math.min(Math.max(Math.floor(x), 0), width - 1);
+			const cz = Math.min(Math.max(Math.floor(z), 0), depth - 1);
+			const key = canon[cz * width + cx];
+			if (drawn.has(key)) return drawn.get(key);
+			const value = draw();
+			drawn.set(key, value);
+			return value;
+		},
+		mirrorsOf: (c) => {
+			const out = [];
+			for (let i = 0; i < MIRRORS; i++) {
+				const m = mirrors[c * MIRRORS + i];
+				if (m >= 0) out.push(m);
+			}
+			return out;
+		},
+		setCell: (array, c, value) => {
+			for (let i = 0; i < MIRRORS; i++) {
+				const m = mirrors[c * MIRRORS + i];
+				if (m >= 0) array[m] = value;
+			}
+		},
+		noise(name, cells = [
+			32,
+			16,
+			8
+		]) {
+			let known = noises.get(name);
+			if (!known) {
+				let salt = 0;
+				for (const letter of name) salt = salt * 31 + letter.charCodeAt(0) >>> 0;
+				const size = Math.max(width, depth);
+				const noise = layeredNoise(options.seed + salt, cells.map((each) => Math.max(1, Math.round(size / each))));
+				known = symmetry === "none" ? (x, z) => noise(x / size, z / size) : (x, z) => {
+					firstPlace(symmetry, width, depth, x, z, point);
+					return noise(point.x / size, point.z / size);
+				};
+				noises.set(name, known);
+			}
+			return known;
+		},
+		placed,
+		mark: (kind, x, z, radius) => {
+			placed.push({
+				kind,
+				x,
+				z,
+				radius
+			});
+			widest = Math.max(widest, radius);
+			const gx = Math.min(Math.max(Math.floor(x / GRID), 0), cols - 1);
+			const gz = Math.min(Math.max(Math.floor(z / GRID), 0), rows - 1);
+			grid[gz * cols + gx].push(placed.length - 1);
+		},
+		free: (x, z, radius, kinds) => {
+			const reach = Math.ceil((radius + widest) / GRID);
+			const gx = Math.floor(x / GRID);
+			const gz = Math.floor(z / GRID);
+			for (let dz = -reach; dz <= reach; dz++) for (let dx = -reach; dx <= reach; dx++) {
+				const gxx = gx + dx;
+				const gzz = gz + dz;
+				if (gxx < 0 || gzz < 0 || gxx >= cols || gzz >= rows) continue;
+				for (const i of grid[gzz * cols + gxx]) {
+					const each = placed[i];
+					if (kinds && !kinds.includes(each.kind)) continue;
+					if (hypot(each.x - x, each.z - z) < radius + each.radius) return false;
+				}
+			}
+			return true;
+		},
+		levelAt: (x, z) => {
+			const cx = Math.min(Math.max(Math.floor(x), 0), width - 1);
+			const cz = Math.min(Math.max(Math.floor(z), 0), depth - 1);
+			return map.levels[cz * width + cx];
+		},
+		walkable: (x, z) => {
+			if (x < 0 || z < 0 || x >= width || z >= depth) return false;
+			return map.water[Math.floor(z) * width + Math.floor(x)] !== 2;
+		},
+		addDoodad(doodad) {
+			const { scale = 1, yaw = 0, ...rest } = doodad;
+			const made = {
+				id: nextId++,
+				yaw,
+				scale: typeof scale === "number" ? [
+					scale,
+					scale,
+					scale
+				] : scale,
+				...rest
+			};
+			map.doodads.push(made);
+			return made;
+		},
+		addObject(type, owner, x, z, more = {}) {
+			const made = {
+				id: nextId++,
+				type,
+				owner,
+				x,
+				z,
+				facing: 0,
+				scale: 1,
+				...more
+			};
+			map.objects.push(made);
+			return made;
+		},
+		addCamp(x, z, units, more = {}) {
+			const made = {
+				id: nextId++,
+				x,
+				z,
+				units,
+				...more
+			};
+			map.camps.push(made);
+			return made;
+		},
+		addRegion(name, shape, more = {}) {
+			const made = {
+				id: nextId++,
+				name,
+				shape,
+				...more
+			};
+			map.regions.push(made);
+			return made;
+		}
+	};
+}
+/**
+* The lie of a bay, for `terrainPass`'s `shape`: the corners high, the ground falling to a sea in the middle, an
+* island in it. With `water` at 0.25–0.35 the sea takes the middle and the shore runs round it; the starts in the
+* corners (`startsPass` with a spread of 0.4), the way between them along the shore
+*
+* @beta
+*/
+function basinShape(options = {}) {
+	const island = Math.min(Math.max(options.island ?? .14, 0), .5);
+	const roughness = Math.min(Math.max(options.roughness ?? .25, 0), 1);
+	const height = Math.min(Math.max(options.height ?? .4, 0), 1);
+	return (x, z, noise, map) => {
+		const d = hypot((x / map.width - .5) * 2, (z / map.depth - .5) * 2) / Math.SQRT2;
+		const r = island > 0 ? d / island : 1;
+		return d + (r < 1 ? (1 - r * r * r * r) * height : 0) + (noise - .5) * roughness;
+	};
+}
+/** Whether a cell is on the map */
+var on = (map, cx, cz) => cx >= 0 && cz >= 0 && cx < map.width && cz < map.depth;
+/** The four cells next to one */
+var NEIGHBOURS = [
+	[-1, 0],
+	[1, 0],
+	[0, -1],
+	[0, 1]
+];
+/** How steep a cell is, in radians, from the heights at its corners: as `Terrain.slopeAt` has it, read straight off the terrain */
+function cellSlope(terrain, cx, cz) {
+	const { heights, vertsX } = terrain;
+	const v = cz * vertsX + cx;
+	const dx = (heights[v + 1] + heights[v + vertsX + 1] - heights[v] - heights[v + vertsX]) / 2;
+	const dz = (heights[v + vertsX] + heights[v + vertsX + 1] - heights[v] - heights[v + 1]) / 2;
+	return atan(hypot(dx, dz));
+}
+/** The engine's passes reach the mirror table of the context they are given; a context of a game's own has none, and mirrors by `symmetric` */
+function internals(ctx) {
+	const own = ctx;
+	if (own.mirrorsOf && own.setCell) return own;
+	const { width } = ctx.map;
+	const mirrorsOf = (c) => {
+		const cx = c % width;
+		const cz = (c - cx) / width;
+		return ctx.symmetric(cx + .5, cz + .5).flatMap((place) => {
+			const mx = Math.floor(place.x);
+			const mz = Math.floor(place.z);
+			return on(ctx.map, mx, mz) ? [mz * width + mx] : [];
+		});
+	};
+	return {
+		mirrorsOf,
+		setCell: (array, c, value) => mirrorsOf(c).forEach((m) => array[m] = value)
+	};
+}
+/**
+* The ground: a height field of noise, mirrored as the map is, quantised into cliff levels with the ground rolling
+* within each, water in the low ground, and ramps cut between the levels so that every part can be walked to
+*
+* @beta
+*/
+function terrainPass(options = {}) {
+	return {
+		id: "terrain",
+		name: "The ground",
+		run(ctx) {
+			const { map } = ctx;
+			const { width, depth } = map;
+			const levels = Math.min(Math.max(Math.round(options.levels ?? ctx.param("levels", 2)), 1), 4);
+			const waterShare = Math.min(Math.max(options.water ?? ctx.param("water", .15), 0), .6);
+			const roughness = Math.min(Math.max(options.roughness ?? ctx.param("roughness", .4), 0), 1);
+			const hills = Math.max(4, options.hills ?? ctx.param("hills", 24));
+			const plateau = ctx.noise("plateau", [hills * 2, hills]);
+			const roll = ctx.noise("roll", [
+				hills / 2,
+				hills / 4,
+				hills / 8
+			]);
+			const values = new Float32Array(width * depth);
+			for (let c = 0; c < values.length; c++) {
+				const x = c % width + .5;
+				const z = Math.floor(c / width) + .5;
+				values[c] = options.shape ? options.shape(x, z, plateau(x, z), map) : plateau(x, z);
+			}
+			const stride = Math.max(1, Math.floor(values.length / 16384));
+			const sorted = Float32Array.from({ length: Math.floor(values.length / stride) }, (_, i) => values[i * stride]).sort();
+			const quantile = (q) => sorted[Math.min(Math.max(Math.round(q * (sorted.length - 1)), 0), sorted.length - 1)];
+			const waterAt = quantile(waterShare);
+			const steps = Array.from({ length: levels - 1 }, (_, i) => quantile(waterShare + (1 - waterShare) * (i + 1) / levels));
+			for (let c = 0; c < values.length; c++) {
+				let level = 0;
+				for (const step of steps) if (values[c] >= step) level++;
+				map.levels[c] = level;
+				map.water[c] = values[c] < waterAt ? 2 : 0;
+			}
+			const { setCell } = internals(ctx);
+			const counts = /* @__PURE__ */ new Int32Array(5);
+			for (let round = 0; round < 2; round++) {
+				const before = map.levels.slice();
+				for (let c = 0; c < before.length; c++) {
+					const cx = c % width;
+					const cz = (c - cx) / width;
+					if (!ctx.canonical(cx, cz)) continue;
+					counts.fill(0);
+					for (let dz = -1; dz <= 1; dz++) for (let dx = -1; dx <= 1; dx++) if (on(map, cx + dx, cz + dz)) counts[before[(cz + dz) * width + cx + dx]]++;
+					let best = before[c];
+					let most = counts[best];
+					for (let level = 0; level < counts.length; level++) if (counts[level] > most) [best, most] = [level, counts[level]];
+					if (best !== before[c]) setCell(map.levels, c, best);
+				}
+			}
+			for (let c = 0; c < values.length; c++) if (map.levels[c] > 0) map.water[c] = 0;
+			const deep = map.water.slice();
+			for (let c = 0; c < deep.length; c++) {
+				if (deep[c] !== 2) continue;
+				const cx = c % width;
+				const cz = (c - cx) / width;
+				let rim = false;
+				for (const [dx, dz] of NEIGHBOURS) if (on(map, cx + dx, cz + dz) && deep[(cz + dz) * width + cx + dx] !== 2) rim = true;
+				if (rim) map.water[c] = 1;
+			}
+			const vx = width + 1;
+			for (let iz = 0; iz <= depth; iz++) for (let ix = 0; ix <= width; ix++) {
+				const v = iz * vx + ix;
+				map.ground[v] = 1 + (roll(ix, iz) - .5) * roughness * 1.5;
+			}
+			if (options.ramps !== false) cutRamps(ctx, Math.max(2, Math.round(options.rampWidth ?? 3)));
+		}
+	};
+}
+/**
+* Ramps between the levels, so that every part of the ground joins the rest: the parts of a level (a flood fill on the
+* level map, water left out) joined by a ramp each across the straightest stretch of cliff between two of them, the
+* nearest the middle of both first, until all are one; mirrored as the map is
+*/
+function cutRamps(ctx, rampWidth) {
+	const { map } = ctx;
+	const { width, depth, levels, water, ramps } = map;
+	const { setCell } = internals(ctx);
+	const part = new Int32Array(width * depth).fill(-1);
+	const parts = [];
+	const queue = new Int32Array(width * depth);
+	for (let start = 0; start < part.length; start++) {
+		if (part[start] >= 0 || water[start] === 2) continue;
+		const id = parts.length;
+		const sum = {
+			cells: 0,
+			x: 0,
+			z: 0
+		};
+		parts.push(sum);
+		let head = 0;
+		let tail = 0;
+		queue[tail++] = start;
+		part[start] = id;
+		while (head < tail) {
+			const c = queue[head++];
+			const cx = c % width;
+			const cz = (c - cx) / width;
+			sum.cells++;
+			sum.x += cx + .5;
+			sum.z += cz + .5;
+			for (const [dx, dz] of NEIGHBOURS) {
+				const nx = cx + dx;
+				const nz = cz + dz;
+				if (!on(map, nx, nz)) continue;
+				const n = nz * width + nx;
+				if (part[n] >= 0 || water[n] === 2 || levels[n] !== levels[c]) continue;
+				part[n] = id;
+				queue[tail++] = n;
+			}
+		}
+	}
+	for (const each of parts) {
+		each.x /= each.cells;
+		each.z /= each.cells;
+	}
+	if (parts.length < 2) return;
+	const half = Math.floor(rampWidth / 2);
+	const candidates = [];
+	const straight = (cx, cz, dx, dz) => {
+		const low = cz * width + cx;
+		const high = (cz + dz) * width + cx + dx;
+		if (Math.abs(levels[low] - levels[high]) !== 1) return void 0;
+		const cells = [];
+		for (let along = -half; along < rampWidth - half; along++) for (let deep = -1; deep <= 2; deep++) {
+			const x = cx + dz * along + dx * deep;
+			const z = cz + dx * along + dz * deep;
+			if (!on(map, x, z)) return void 0;
+			const c = z * width + x;
+			if (water[c] !== 0) return void 0;
+			if (levels[c] !== (deep <= 0 ? levels[low] : levels[high])) return void 0;
+			if (deep >= 0 && deep <= 1) cells.push(c);
+		}
+		return cells;
+	};
+	for (let cz = 0; cz < depth; cz++) for (let cx = 0; cx < width; cx++) {
+		if (!ctx.canonical(cx, cz)) continue;
+		for (const [dx, dz] of [[1, 0], [0, 1]]) {
+			if (!on(map, cx + dx, cz + dz)) continue;
+			const cells = straight(cx, cz, dx, dz);
+			if (!cells) continue;
+			const a = part[cz * width + cx];
+			const b = part[(cz + dz) * width + cx + dx];
+			if (a < 0 || b < 0 || a === b) continue;
+			const mx = (parts[a].x + parts[b].x) / 2;
+			const mz = (parts[a].z + parts[b].z) / 2;
+			candidates.push({
+				a,
+				b,
+				cells,
+				cost: hypot(cx + .5 - mx, cz + .5 - mz)
+			});
+		}
+	}
+	candidates.sort((p, q) => p.cost - q.cost);
+	const root = parts.map((_, i) => i);
+	const find = (i) => root[i] === i ? i : root[i] = find(root[i]);
+	for (const candidate of candidates) {
+		const a = find(candidate.a);
+		const b = find(candidate.b);
+		if (a === b) continue;
+		root[a] = b;
+		for (const c of candidate.cells) setCell(ramps, c, 1);
+	}
+}
+/**
+* The paint: each cell a tile by what the ground is there, through the game's tiles by name
+*
+* @beta
+*/
+function tilesPass(options = {}) {
+	return {
+		id: "tiles",
+		name: "The paint",
+		run(ctx) {
+			const { map, registry } = ctx;
+			const { width, depth } = map;
+			const tiles = registry.tileIds;
+			if (!tiles.length) return;
+			const terrain = mapTerrain(map);
+			const moisture = ctx.noise("moisture", [20, 10]);
+			let top = 0;
+			for (const level of map.levels) top = Math.max(top, level);
+			const by = options.by ?? ((cell, ids) => {
+				const has = (id) => ids.includes(id) ? id : void 0;
+				if (cell.shore) return has("sand");
+				if (cell.slope > .5) return has("rock");
+				if (cell.level === top && top >= 3) return has("snow") ?? has("rock");
+				if (cell.moisture < .35) return has("dirt");
+			});
+			for (let cz = 0; cz < depth; cz++) for (let cx = 0; cx < width; cx++) {
+				const c = cz * width + cx;
+				if (map.water[c] === 2) continue;
+				let shore = map.water[c] === 1;
+				if (!shore) {
+					for (const [dx, dz] of NEIGHBOURS) if (on(map, cx + dx, cz + dz) && map.water[(cz + dz) * width + cx + dx] !== 0) shore = true;
+				}
+				const id = by({
+					x: cx,
+					z: cz,
+					level: map.levels[c],
+					slope: cellSlope(terrain, cx, cz),
+					moisture: moisture(cx + .5, cz + .5),
+					shore
+				}, tiles);
+				map.tiles[c] = id ? registry.tile(id) : 0;
+			}
+		}
+	};
+}
+/**
+* The starts: as far apart as the symmetry allows (mirrored from one, or around the middle), each on flat, dry ground
+* (a clearing made for it), the player's `start` set, and what the game puts there
+*
+* @beta
+*/
+function startsPass(options = {}) {
+	return {
+		id: "starts",
+		name: "The starts",
+		run(ctx) {
+			const { map, rng } = ctx;
+			const { width, depth } = map;
+			const players = map.players.filter((player) => player.id !== 0 && player.id !== 90);
+			if (!players.length) return;
+			const clearing = Math.max(2, options.clearing ?? 6);
+			const spread = Math.min(Math.max(options.spread ?? .36, .1), .48);
+			const symmetry = ctx.options.symmetry ?? "none";
+			const setSize = ctx.symmetric(width * .3, depth * .2).length;
+			const seeds = Math.ceil(players.length / setSize);
+			const places = [];
+			const angle0 = symmetry === "none" ? rng.next() * Math.PI * 2 : symmetry === "x" ? Math.PI : symmetry === "z" ? Math.PI / 2 : Math.PI * 1.25;
+			for (let i = 0; i < seeds + players.length && places.length < players.length; i++) {
+				const angle = angle0 + i * Math.PI * 2 / Math.max(seeds * setSize, 1);
+				const x = width / 2 + cos(angle) * width * spread;
+				const z = depth / 2 + sin(angle) * depth * spread;
+				for (const place of ctx.symmetric(x, z)) if (places.length < players.length) places.push(place);
+			}
+			players.forEach((player, i) => {
+				const at = dryGround(ctx, places[i], clearing);
+				clear(ctx, at, clearing);
+				player.start = {
+					x: at.x,
+					z: at.z
+				};
+				ctx.mark("start", at.x, at.z, clearing);
+				options.from?.(player, at, ctx);
+			});
+		}
+	};
+}
+/**
+* The nearest place to one that is not in the water, at a cell's middle: for a pass of a game's own that puts something
+* down where the ground may be wet
+*
+* @beta
+*/
+var nearestDryGround = (ctx, at, reach) => dryGround(ctx, at, reach);
+/**
+* The ground around a place made flat and dry: one level (the one there, or `level`), no water, no ramps, the ground at
+* one height eased into what is around; mirrored as the map is, unless `alone`. What a start's clearing and a mine's
+* are made with, for a pass of a game's own
+*
+* @beta
+*/
+var clearGround = (ctx, at, radius, alone = false, level) => clear(ctx, at, radius, alone, level ?? ctx.levelAt(at.x, at.z));
+/** The nearest place to one that is not in the water, at a cell's middle */
+function dryGround(ctx, at, reach) {
+	const { map } = ctx;
+	const { width, depth } = map;
+	const cx = Math.min(Math.max(Math.floor(at.x), 1), width - 2);
+	const cz = Math.min(Math.max(Math.floor(at.z), 1), depth - 2);
+	for (let r = 0; r <= reach * 3; r++) for (let dz = -r; dz <= r; dz++) for (let dx = -r; dx <= r; dx++) {
+		if (Math.max(Math.abs(dx), Math.abs(dz)) !== r) continue;
+		const x = cx + dx;
+		const z = cz + dz;
+		if (x < 1 || z < 1 || x >= width - 1 || z >= depth - 1) continue;
+		if (map.water[z * width + x] === 0) return {
+			x: x + .5,
+			z: z + .5
+		};
+	}
+	return {
+		x: cx + .5,
+		z: cz + .5
+	};
+}
+/** The ground around a place made flat and dry: one level, no water, no ramps, the ground at one height. Mirrored, unless `alone` */
+function clear(ctx, at, radius, alone = false, level = ctx.levelAt(at.x, at.z)) {
+	const { map } = ctx;
+	const { width, depth } = map;
+	const vx = width + 1;
+	let height = 0;
+	let count = 0;
+	for (let iz = Math.max(Math.floor(at.z - radius), 0); iz <= Math.min(Math.ceil(at.z + radius), depth); iz++) for (let ix = Math.max(Math.floor(at.x - radius), 0); ix <= Math.min(Math.ceil(at.x + radius), width); ix++) {
+		height += map.ground[iz * vx + ix];
+		count++;
+	}
+	height /= Math.max(count, 1);
+	for (const place of alone ? [at] : ctx.symmetric(at.x, at.z)) {
+		for (let cz = Math.max(Math.floor(place.z - radius), 0); cz < Math.min(Math.ceil(place.z + radius), depth); cz++) for (let cx = Math.max(Math.floor(place.x - radius), 0); cx < Math.min(Math.ceil(place.x + radius), width); cx++) {
+			if (hypot(cx + .5 - place.x, cz + .5 - place.z) > radius) continue;
+			const c = cz * width + cx;
+			map.levels[c] = level;
+			map.water[c] = 0;
+			map.ramps[c] = 0;
+		}
+		for (let iz = Math.max(Math.floor(place.z - radius), 0); iz <= Math.min(Math.ceil(place.z + radius), depth); iz++) for (let ix = Math.max(Math.floor(place.x - radius), 0); ix <= Math.min(Math.ceil(place.x + radius), width); ix++) {
+			const d = hypot(ix - place.x, iz - place.z);
+			if (d > radius) continue;
+			const t = Math.min(Math.max((d - radius * .6) / (radius * .4), 0), 1);
+			const v = iz * vx + ix;
+			map.ground[v] = height + (map.ground[v] - height) * t * t * (3 - 2 * t);
+		}
+	}
+}
+/**
+* Things scattered over the map: as many as the density says, in patches of a noise, at least `spacing` apart, off
+* the starts and what else they avoid, where they may go; each put down by `what`, mirrored as the map is. Trees now;
+* rocks, houses, ruins and the rest the same way, with another `what`
+*
+* @beta
+*/
+function scatterPass(options) {
+	return {
+		id: `scatter:${options.kind}`,
+		name: `Scattered: ${options.kind}`,
+		run(ctx) {
+			const { map, rng } = ctx;
+			const { width, depth } = map;
+			const density = Math.min(Math.max(options.density ?? ctx.param(options.kind, .12), 0), 1);
+			if (density <= 0) return;
+			const spacing = Math.max(.5, options.spacing ?? 1.5);
+			const radius = options.radius ?? spacing / 2;
+			const avoid = options.avoid ?? 10;
+			const patches = Math.min(Math.max(options.patches ?? .6, 0), 1);
+			const noise = ctx.noise(`scatter:${options.kind}`, [
+				24,
+				12,
+				6
+			]);
+			let made;
+			const terrain = () => made ??= mapTerrain(map);
+			const cell = spacing;
+			const cols = Math.ceil(width / cell);
+			const rows = Math.ceil(depth / cell);
+			const grid = Array.from({ length: cols * rows }, () => []);
+			const tooClose = (x, z) => {
+				const gx = Math.floor(x / cell);
+				const gz = Math.floor(z / cell);
+				for (let dz = -1; dz <= 1; dz++) for (let dx = -1; dx <= 1; dx++) {
+					const gxx = gx + dx;
+					const gzz = gz + dz;
+					if (gxx < 0 || gzz < 0 || gxx >= cols || gzz >= rows) continue;
+					for (const other of grid[gzz * cols + gxx]) if (hypot(other.x - x, other.z - z) < spacing) return true;
+				}
+				return false;
+			};
+			const put = (x, z) => {
+				grid[Math.floor(z / cell) * cols + Math.floor(x / cell)].push({
+					x,
+					z
+				});
+				ctx.mark(options.kind, x, z, radius);
+				options.what(ctx, {
+					x,
+					z
+				});
+			};
+			for (let cz = 0; cz < depth; cz++) for (let cx = 0; cx < width; cx++) {
+				if (!ctx.canonical(cx, cz)) continue;
+				const c = cz * width + cx;
+				const x = cx + rng.next();
+				const z = cz + rng.next();
+				const n = noise(x, z);
+				const chance = density * (1 - patches + patches * Math.min(Math.max((n - .35) / .3, 0), 1) * 2);
+				if (rng.next() >= chance) continue;
+				if (map.water[c] !== 0) continue;
+				if (options.where) {
+					const shore = NEIGHBOURS.some(([dx, dz]) => on(map, cx + dx, cz + dz) && map.water[(cz + dz) * width + cx + dx] !== 0);
+					if (!options.where({
+						x,
+						z,
+						level: map.levels[c],
+						slope: cellSlope(terrain(), cx, cz),
+						noise: n,
+						shore
+					})) continue;
+				}
+				if (map.ramps[c]) continue;
+				if (!ctx.free(x, z, avoid, ["start"])) continue;
+				if (options.avoidKinds && Object.entries(options.avoidKinds).some(([kind, far]) => !ctx.free(x, z, far, [kind]))) continue;
+				const places = ctx.symmetric(x, z).filter((place) => place.x >= 0 && place.z >= 0 && place.x < width && place.z < depth);
+				if (places.some((place) => tooClose(place.x, place.z))) continue;
+				for (const place of places) put(place.x, place.z);
+			}
+		}
+	};
+}
+/**
+* Resources: one near each start (towards the map's middle, as far as `main` says), and more spread over the map,
+* mirrored as the map is, each put down by the game
+*
+* @beta
+*/
+function resourcesPass(options) {
+	return {
+		id: "resources",
+		name: "The resources",
+		run(ctx) {
+			const { map, rng } = ctx;
+			const { width, depth } = map;
+			const main = options.main ?? 8;
+			const spacing = options.spacing ?? 20;
+			const clearing = options.clearing ?? 3;
+			for (const player of map.players) {
+				if (!player.start || main === false) continue;
+				const toward = atan2(depth / 2 - player.start.z, width / 2 - player.start.x) + (rng.next() - .5) * .8;
+				const at = dryGround(ctx, {
+					x: player.start.x + cos(toward) * main,
+					z: player.start.z + sin(toward) * main
+				}, 4);
+				if (clearing > 0) clear(ctx, at, clearing, true, ctx.levelAt(player.start.x, player.start.z));
+				ctx.mark("resource", at.x, at.z, 3);
+				options.from(ctx, at, player);
+			}
+			const extra = Math.max(0, Math.round(options.extra ?? 2));
+			let placed = 0;
+			for (let attempt = 0; attempt < extra * 40 && placed < extra; attempt++) {
+				const x = 4 + rng.next() * (width - 8);
+				const z = 4 + rng.next() * (depth - 8);
+				if (!ctx.canonical(Math.floor(x), Math.floor(z))) continue;
+				const places = ctx.symmetric(x, z);
+				if (!places.every((place) => ctx.walkable(place.x, place.z) && ctx.free(place.x, place.z, spacing, ["start", "resource"]))) continue;
+				for (const place of places) {
+					const at = dryGround(ctx, place, 4);
+					if (clearing > 0) clear(ctx, at, clearing, true);
+					ctx.mark("resource", at.x, at.z, 3);
+					options.from(ctx, at);
+				}
+				placed++;
+			}
+		}
+	};
+}
+/**
+* Roads between the starts (or places given), the way something on foot would go (over the level map, by ramps, around
+* water; the gentlest ground preferred), painted with a tile
+*
+* @beta
+*/
+function roadsPass(options) {
+	return {
+		id: "roads",
+		name: "The roads",
+		run(ctx) {
+			const { map, registry } = ctx;
+			if (!registry.tileIds.includes(options.tile)) return;
+			const tile = registry.tile(options.tile);
+			const wide = Math.max(1, Math.round(options.width ?? 2));
+			const places = options.between ?? map.players.flatMap((player) => player.start ? [player.start] : []);
+			const terrain = mapTerrain(map);
+			for (let i = 0; i < places.length; i++) for (let j = i + 1; j < places.length; j++) {
+				const path = findPath(map, terrain, places[i], places[j]);
+				for (const c of path) {
+					const cx = c % map.width;
+					const cz = (c - cx) / map.width;
+					for (let dz = 0; dz < wide; dz++) for (let dx = 0; dx < wide; dx++) {
+						const x = cx + dx - Math.floor(wide / 2);
+						const z = cz + dz - Math.floor(wide / 2);
+						if (on(map, x, z) && map.water[z * map.width + x] === 0) map.tiles[z * map.width + x] = tile;
+					}
+				}
+			}
+		}
+	};
+}
+/** The cells of the way from one place to another over the level map: A* with the gentlest ground preferred; nothing where there is none */
+function findPath(map, terrain, from, to) {
+	const { width, depth, levels, ramps, water } = map;
+	const start = Math.floor(from.z) * width + Math.floor(from.x);
+	const goal = Math.floor(to.z) * width + Math.floor(to.x);
+	const passable = (a, b) => levels[a] === levels[b] || ramps[a] > 0 || ramps[b] > 0;
+	const cost = new Float32Array(width * depth).fill(Infinity);
+	const came = new Int32Array(width * depth).fill(-1);
+	const closed = new Uint8Array(width * depth);
+	const heapCells = [];
+	const heapCosts = [];
+	const push = (estimate, c) => {
+		heapCells.push(c);
+		heapCosts.push(estimate);
+		let i = heapCells.length - 1;
+		while (i > 0) {
+			const parent = i - 1 >> 1;
+			if (heapCosts[parent] <= heapCosts[i]) break;
+			[heapCosts[parent], heapCosts[i]] = [heapCosts[i], heapCosts[parent]];
+			[heapCells[parent], heapCells[i]] = [heapCells[i], heapCells[parent]];
+			i = parent;
+		}
+	};
+	const pop = () => {
+		const top = heapCells[0];
+		const lastCell = heapCells.pop();
+		const lastCost = heapCosts.pop();
+		if (heapCells.length) {
+			heapCells[0] = lastCell;
+			heapCosts[0] = lastCost;
+			let i = 0;
+			for (;;) {
+				const l = i * 2 + 1;
+				const r = l + 1;
+				let best = i;
+				if (l < heapCells.length && heapCosts[l] < heapCosts[best]) best = l;
+				if (r < heapCells.length && heapCosts[r] < heapCosts[best]) best = r;
+				if (best === i) break;
+				[heapCosts[best], heapCosts[i]] = [heapCosts[i], heapCosts[best]];
+				[heapCells[best], heapCells[i]] = [heapCells[i], heapCells[best]];
+				i = best;
+			}
+		}
+		return top;
+	};
+	const h = (c) => hypot(c % width - goal % width, Math.floor(c / width) - Math.floor(goal / width));
+	cost[start] = 0;
+	push(h(start), start);
+	while (heapCells.length) {
+		const c = pop();
+		if (closed[c]) continue;
+		closed[c] = 1;
+		if (c === goal) break;
+		const cx = c % width;
+		const cz = (c - cx) / width;
+		for (const [dx, dz] of NEIGHBOURS) {
+			const nx = cx + dx;
+			const nz = cz + dz;
+			if (!on(map, nx, nz)) continue;
+			const n = nz * width + nx;
+			if (closed[n] || water[n] === 2 || !passable(c, n)) continue;
+			const step = 1 + terrain.slopeAt(nx + .5, nz + .5) * 4 + (water[n] ? 2 : 0);
+			const next = cost[c] + step;
+			if (next >= cost[n]) continue;
+			cost[n] = next;
+			came[n] = c;
+			push(next + h(n), n);
+		}
+	}
+	if (came[goal] < 0 && goal !== start) return [];
+	const path = [];
+	for (let c = goal; c >= 0; c = came[c]) {
+		path.push(c);
+		if (c === start) break;
+	}
+	return path.reverse();
+}
+/**
+* A generator to take whole: hills and water, the paint, the starts, trees in patches and rocks about, with the
+* parameters `levels`, `water`, `roughness`, `hills`, `trees` and `rocks`; what the trees and rocks are is the game's
+* to say
+*
+* @beta
+*/
+function presetGenerator(options = {}) {
+	const { trees = [], rocks = [], treeScale = {} } = options;
+	const scale = treeScale.scale ?? 1;
+	const vary = treeScale.vary ?? .2;
+	return {
+		params: [
+			{
+				id: "levels",
+				name: "Cliff levels",
+				description: "How many levels the ground rises through",
+				default: 2,
+				min: 1,
+				max: 4,
+				step: 1
+			},
+			{
+				id: "water",
+				name: "Water",
+				description: "How much of the map is under water",
+				default: .15,
+				min: 0,
+				max: .5,
+				step: .05
+			},
+			{
+				id: "roughness",
+				name: "Roughness",
+				description: "How much the ground rolls",
+				default: .4,
+				min: 0,
+				max: 1,
+				step: .05
+			},
+			{
+				id: "hills",
+				name: "Hills",
+				description: "How many cells a hill is across",
+				default: 24,
+				min: 8,
+				max: 64,
+				step: 4
+			},
+			{
+				id: "trees",
+				name: "Trees",
+				description: "How much of the map is woods",
+				default: trees.length ? .12 : 0,
+				min: 0,
+				max: .5,
+				step: .02
+			},
+			{
+				id: "rocks",
+				name: "Rocks",
+				description: "How many rocks lie about",
+				default: rocks.length ? .02 : 0,
+				min: 0,
+				max: .2,
+				step: .01
+			}
+		],
+		passes: [
+			terrainPass(),
+			tilesPass(),
+			startsPass({ from: options.start }),
+			...trees.length ? [scatterPass({
+				kind: "trees",
+				spacing: 1.6,
+				what: (ctx, at) => {
+					const size = scale * (1 + (ctx.rng.next() - .5) * 2 * vary);
+					ctx.addDoodad({
+						model: trees[ctx.rng.int(0, trees.length - 1)],
+						x: at.x,
+						z: at.z,
+						yaw: ctx.rng.next() * Math.PI * 2,
+						scale: size,
+						blocks: "walk",
+						radius: .5
+					});
+				}
+			})] : [],
+			...rocks.length ? [scatterPass({
+				kind: "rocks",
+				spacing: 3,
+				patches: .3,
+				avoidKinds: { trees: 1 },
+				what: (ctx, at) => {
+					const size = scale * (.8 + ctx.rng.next() * .6);
+					ctx.addDoodad({
+						model: rocks[ctx.rng.int(0, rocks.length - 1)],
+						x: at.x,
+						z: at.z,
+						yaw: ctx.rng.next() * Math.PI * 2,
+						scale: size,
+						blocks: "walk",
+						radius: .6
+					});
+				}
+			})] : []
+		]
+	};
+}
+//#endregion
+export { basinShape, clearGround, generateMap, nearestDryGround, presetGenerator, resourcesPass, roadsPass, scatterPass, startsPass, symmetricPlaces, terrainPass, tilesPass };
+
+//# sourceMappingURL=generate.js.map