@v12-engine/create 0.1.1 → 0.4.0

package/starters/examples/src/examples/nature/grass.ts

@@ -0,0 +1,64 @@
+/**
+ * The nature examples' grass and trees, to the rules: a layer of cells of their own (`natureGrass`) whose values are
+ * styles of grass (`FoliageStyleDef`: what hides, burns, is crushed and grows back), and a tree that burns. How they
+ * look is `./looks.ts`. A layer no map paints costs nothing, so the other categories' examples never pay for it
+ */
+import { type CellLayerDef, defineCellLayer, type FoliageStyleDef, presetFoliageStyles, type UnitTypeDef } from '@v12-engine/engine'
+
+/** The layer of grass: its id, which the look (`ground.cellLayers`) and the examples' maps name */
+export const GRASS = 'natureGrass'
+
+/** The styles of grass, by their value in the layer */
+export const STYLE = { meadow: 1, tallGrass: 2, dryGrass: 3, wheat: 4, thicket: 5, reeds: 6, snowGrass: 7, flowers: 8 } as const
+
+/** A style without its `speed`: a style that slows gives every map of the game the ground's speeds to weigh */
+const noSlowing = ({ speed: _slows, ...rest }: FoliageStyleDef): FoliageStyleDef => rest
+
+/**
+ * The layer: a short meadow, tall grass that hides who stands in it, dry grass that burns fast, wheat crushed
+ * underfoot, a thicket of bushes, reeds by the water, grass of the snow, and a meadow in flower. Each grows back a
+ * while after it burns or is crushed
+ */
+export const grassLayer: CellLayerDef = defineCellLayer({
+	id: GRASS,
+	name: 'Nature grass',
+	description: "The nature examples' grass and bushes: they sway, part, hide, burn and grow back",
+	color: [0.4, 0.75, 0.3],
+	values: [
+		{ value: STYLE.meadow, name: 'Meadow', color: [0.45, 0.72, 0.28], foliage: { ...presetFoliageStyles.meadow, regrows: 30, grows: 12 } },
+		{ value: STYLE.tallGrass, name: 'Tall grass', color: [0.3, 0.55, 0.2], foliage: { ...presetFoliageStyles.tallGrass, regrows: 30, grows: 15 } },
+		// catches from anything and burns out in three seconds, hot: what a fire runs through
+		{
+			value: STYLE.dryGrass,
+			name: 'Dry grass',
+			color: [0.8, 0.7, 0.4],
+			foliage: { ...presetFoliageStyles.dryGrass, burns: 3, fuel: 2, regrows: 40 }
+		},
+		{ value: STYLE.wheat, name: 'Wheat', color: [0.9, 0.8, 0.42], foliage: { ...presetFoliageStyles.wheat, regrows: 20, grows: 10 } },
+		{ value: STYLE.thicket, name: 'Thicket', color: [0.15, 0.35, 0.12], foliage: noSlowing(presetFoliageStyles.thicket) },
+		{ value: STYLE.reeds, name: 'Reeds', color: [0.4, 0.55, 0.3], foliage: noSlowing(presetFoliageStyles.reeds) },
+		{ value: STYLE.snowGrass, name: 'Snow grass', color: [0.8, 0.85, 0.85], foliage: presetFoliageStyles.snowGrass },
+		{ value: STYLE.flowers, name: 'Flowers', color: [0.8, 0.5, 0.7], foliage: { ...presetFoliageStyles.meadow, regrows: 30, grows: 12 } }
+	]
+})
+
+/** The nature examples' own unit types: a tree and a dead tree */
+export const TREE = 'natureTree'
+export const DEAD_TREE = 'natureDeadTree'
+
+/** A tree: scenery that stands in the way, burns for 20 seconds when set alight, and comes down burnt */
+export const tree: UnitTypeDef = {
+	id: TREE,
+	name: 'Tree',
+	kind: 'resource',
+	radius: 0.5,
+	footprint: { w: 1, d: 1 },
+	stats: { health: 1 },
+	sight: 0,
+	invulnerable: true,
+	fellable: true,
+	burns: { seconds: 20 }
+}
+
+/** A dead tree: grey and bare, it catches as easily and burns quicker */
+export const deadTree: UnitTypeDef = { ...tree, id: DEAD_TREE, name: 'Dead tree', burns: { seconds: 8 } }

package/starters/examples/src/examples/nature/index.ts

@@ -0,0 +1,327 @@
+/**
+ * The nature examples on the rules' side: their list entries, maps and starts, and what they add to the game
+ * (`ExampleCategory`): a layer of grass (`./grass.ts`) with the foliage pack (it hides, burns, is crushed and grows
+ * back), trees that burn (the burning pack), and commands that change the wind and the weather for every player and
+ * light, put out and grow back a fire. The maps are made in code (`./maps.ts`)
+ */
+import {
+	burningOf,
+	burningPack,
+	defineCommand,
+	defineComponent,
+	type Entity,
+	foliagePack,
+	type Game,
+	gust,
+	ignite,
+	isBurning,
+	number,
+	oneOf,
+	putOut,
+	regrow,
+	setAlight,
+	stopFire,
+	type World,
+	exactMath
+} from '@v12-engine/engine'
+import { PLAYER, UNIT } from '../common/units'
+import type { ExampleCategory } from '../define'
+import { deadTree, GRASS, grassLayer, tree, TREE, DEAD_TREE } from './grass'
+import { type At, plant } from './land'
+import {
+	FIRE_START,
+	fireMap,
+	fireTrees,
+	forestMap,
+	forestTrees,
+	GLADE,
+	hillsMap,
+	hillsTrees,
+	lakeMap,
+	lakeTrees,
+	MEADOW_EAST,
+	MEADOW_WEST,
+	meadowMap,
+	meadowTrees,
+	valleyAt,
+	valleyMap,
+	valleyTrees,
+	SQUARE,
+	villageMap,
+	villageTrees
+} from './maps'
+import { WEATHER, type WeatherKind } from './weather'
+
+/** Whether a thing is one of the nature examples' trees */
+const isTree = (entity: Entity) => entity.alive && (entity.def.id === TREE || entity.def.id === DEAD_TREE)
+
+/** Every tree standing in the world */
+const treesOf = (world: World): Entity[] => [...world.units.values()].filter(isTree)
+
+// ---- commands: what a control of the card asks of the rules, for every player to see
+
+/** The wind for everyone: which way it blows (degrees from north, clockwise) and how hard (0 to 1), eased in over 2 s */
+export const setWind = defineCommand('nature.wind', { around: number, strength: number }, (world, _player, { around, strength }) => {
+	world.setEnvironment({ wind: { around, strength: Math.max(0, Math.min(1, strength)), gusts: 0.5 } }, { over: 2 })
+})
+
+/** A gust out from a point: the grass and the trees' grass round it bend away, then stand again */
+export const blowGust = defineCommand('nature.gust', { x: number, z: number }, (world, _player, { x, z }) => {
+	gust(world, { x, z }, { radius: 9, strength: 1.6, lasts: 1.2 })
+})
+
+/** The weather for everyone, eased in over 4 s: clear, rain, a storm or snow, and how much falls */
+export const setWeather = defineCommand(
+	'nature.weather',
+	{ kind: oneOf('clear', 'rain', 'storm', 'snow'), amount: number },
+	(world, _player, { kind, amount }) => {
+		world.setEnvironment(WEATHER[kind as WeatherKind](Math.max(0, Math.min(1, amount))), { over: 4 })
+	}
+)
+
+/** Sets the grass alight round a point, and the nearest tree to it */
+export const lightFire = defineCommand('nature.ignite', { x: number, z: number }, (world, _player, { x, z }) => {
+	ignite(world, GRASS, { kind: 'circle', x, z, radius: 1.8 })
+	const nearest = treesOf(world).sort((a, b) => exactMath.hypot(a.pos.x - x, a.pos.z - z) - exactMath.hypot(b.pos.x - x, b.pos.z - z))[0]
+	if (nearest && exactMath.hypot(nearest.pos.x - x, nearest.pos.z - z) < 4) setAlight(world, nearest)
+})
+
+/** Sets the wood alight: the trees nearest a point, a few of them */
+export const lightWood = defineCommand('nature.lightWood', { x: number, z: number }, (world, _player, { x, z }) => {
+	const near = treesOf(world).sort((a, b) => exactMath.hypot(a.pos.x - x, a.pos.z - z) - exactMath.hypot(b.pos.x - x, b.pos.z - z))
+	for (const each of near.slice(0, 3)) setAlight(world, each)
+})
+
+/** Puts every fire out: the grass stops burning where it is, the trees stand charred as far as they burnt */
+export const douse = defineCommand('nature.douse', {}, (world) => {
+	stopFire(world, GRASS)
+	for (const each of treesOf(world)) if (isBurning(each)) putOut(world, each)
+})
+
+/**
+ * Grows it all back over 8 seconds: the grass burnt, cut or crushed rises again (`regrow`), and trees stand again
+ * where the map had them, the charred ones new. Each example that burns says where its trees stand (`replant`)
+ */
+export const growBack = defineCommand('nature.regrow', {}, (world) => {
+	stopFire(world, GRASS)
+	const { width, depth } = world.terrain
+	regrow(world, GRASS, { kind: 'rect', x: 0, z: 0, width, depth }, { over: 8 })
+	for (const each of treesOf(world)) {
+		if (isBurning(each)) putOut(world, each)
+		if ((burningOf(world, each)?.share ?? 0) > 0) world.kill(each, undefined, false, 'removed')
+	}
+	const standing = new Set(treesOf(world).map((each) => Math.floor(each.pos.z) * width + Math.floor(each.pos.x)))
+	const places = world.state(replant).places.filter((at) => !standing.has(Math.floor(at.z) * width + Math.floor(at.x)))
+	plant(world, places)
+})
+
+/** Where the trees of a world that burns stood as it started: what `growBack` plants again. Kept in the world, so a save keeps it */
+const replant = defineComponent<{ places: At[] }>({ id: 'nature.replant', default: () => ({ places: [] }) })
+
+/** Sends the walkers of the meadow across it, to whichever side they are not on */
+export const stroll = defineCommand('nature.stroll', {}, (world) => {
+	const walkers = [...world.units.values()].filter((each) => each.alive && each.owner === PLAYER)
+	const middle = walkers.reduce((sum, each) => sum + each.pos.x, 0) / Math.max(1, walkers.length)
+	const to = middle < (MEADOW_WEST + MEADOW_EAST) / 2 ? MEADOW_EAST : MEADOW_WEST
+	for (const each of walkers) each.order('move', { x: to + (each.pos.x % 1) * 2, z: each.pos.z })
+})
+
+/** Walkers in a column on the meadow's west side */
+function walkers(world: World): void {
+	const types = [UNIT.knight, UNIT.footman, UNIT.footman, UNIT.archer, UNIT.mage, UNIT.footman, UNIT.archer]
+	types.forEach((type, i) => world.spawn(type, { at: { x: MEADOW_WEST + (i % 2) * 1.2, z: 17 + i * 3.4 }, owner: PLAYER }))
+}
+
+export const category: ExampleCategory = {
+	rules: (game: Game<any>) => {
+		game.unit(tree)
+		game.unit(deadTree)
+		game.component(replant)
+		// the grass: hidden in, burning (passing it to the trees standing in it), crushed, growing back
+		game.cellLayer(grassLayer)
+		game.pack(foliagePack({ layer: GRASS, fire: { lights: true, wind: 1.6, jump: 0.5 } }))
+		// trees burn: a burning tree lights those beside it (likelier downwind) and the grass round it
+		game.pack(burningPack({ spread: { chance: 0.08, reach: 1.8 }, lightsFoliage: true }))
+		for (const command of [setWind, blowGust, setWeather, lightFire, lightWood, douse, growBack, stroll]) game.command(command)
+	},
+	examples: [
+		{
+			id: 'nature-forest',
+			category: 'nature',
+			title: 'A forest in the wind',
+			summary: "A forest of the shared art's trees round a glade in flower. Turn the wind round and up, and send a gust through the glade.",
+			tags: ['trees', 'wind', 'grass', 'forest', 'gust', 'scenery'],
+			map: forestMap,
+			start: (world) => plant(world, forestTrees(forestMap()), 0.04),
+			environment: {
+				sky: [0.5, 0.68, 0.9],
+				clouds: { cover: 0.35, speed: 0.6 },
+				light: { sunUp: 40, sunAround: 150, sun: 1.35, sunColor: [1, 0.93, 0.8], ambient: 0.55, ambientColor: [0.85, 0.92, 1] },
+				wind: { around: 70, strength: 0.45, gusts: 0.5 },
+				fog: { start: 55, end: 170 },
+				mist: { ground: { base: 0, top: 1.2, density: 0.1, color: [0.85, 0.9, 0.92] } }
+			}
+		},
+		{
+			id: 'nature-meadow',
+			category: 'nature',
+			title: 'A meadow of every grass',
+			summary:
+				'Wheat, tall grass, flowers, dry grass, a thicket and reeds by a pond. Send the walkers across: the grass parts round them and lies down in a trail behind.',
+			tags: ['grass', 'meadow', 'trails', 'wheat', 'reeds', 'flowers', 'foliage', 'trample'],
+			map: meadowMap,
+			start: (world) => {
+				plant(world, meadowTrees(meadowMap()), 0)
+				walkers(world)
+			},
+			environment: {
+				sky: [0.55, 0.72, 0.92],
+				clouds: { cover: 0.3 },
+				light: { sunUp: 48, sunAround: 200, sun: 1.4, sunColor: [1, 0.95, 0.84], ambient: 0.6 },
+				wind: { around: 100, strength: 0.3, gusts: 0.4 },
+				fog: { start: 60, end: 170 }
+			}
+		},
+		{
+			id: 'nature-lake',
+			category: 'nature',
+			title: 'A lake and a waterfall',
+			summary:
+				'A river spills off a cliff into a lake, which runs out east as another. Waves roll to the shore and the falls mist at their foot; change the water and its waves.',
+			tags: ['water', 'waterfall', 'river', 'lake', 'waves', 'shore'],
+			map: lakeMap,
+			start: (world) => plant(world, lakeTrees(lakeMap()), 0.03),
+			environment: {
+				sky: [0.52, 0.7, 0.9],
+				clouds: { cover: 0.4 },
+				light: { sunUp: 34, sunAround: 120, sun: 1.3, sunColor: [1, 0.92, 0.8], ambient: 0.55 },
+				wind: { around: 160, strength: 0.3, gusts: 0.3 },
+				water: { shallow: [0.3, 0.62, 0.6], deep: [0.05, 0.2, 0.3], waves: { strength: 0.7 }, falls: { mist: 0.8 } },
+				fog: { start: 60, end: 180 }
+			}
+		},
+		{
+			id: 'nature-clouds',
+			category: 'nature',
+			title: 'Clouds and their shadows',
+			summary:
+				'Clouds drift over rolling hills, their shadows running over the woods. Change how much of the sky they cover, how high they float and how dark they shade.',
+			tags: ['clouds', 'shadows', 'sky', 'cloud layer', 'volumetric'],
+			map: hillsMap,
+			start: (world) => plant(world, hillsTrees(hillsMap())),
+			environment: {
+				sky: [0.48, 0.66, 0.9],
+				clouds: { cover: 0.45 },
+				cloudLayer: { height: 20, scale: 28, cover: 0.5, opacity: 0.65, shadows: 0.65 },
+				light: { sunUp: 52, sunAround: 160, sun: 1.45, ambient: 0.5 },
+				wind: { around: 110, strength: 0.5, gusts: 0.3 },
+				fog: { start: 70, end: 220 }
+			}
+		},
+		{
+			id: 'nature-mist',
+			category: 'nature',
+			title: 'Mist in a valley',
+			summary:
+				'Dawn in a deep valley: mist lies along its floor, the hills standing out of it, and drifts in wisps by the stream. Raise it, thicken it, colour it.',
+			tags: ['mist', 'fog', 'valley', 'dawn', 'atmosphere'],
+			map: valleyMap,
+			start: (world) => plant(world, valleyTrees(valleyMap()), 0.08),
+			environment: {
+				sky: [0.86, 0.72, 0.66],
+				clouds: { cover: 0.5, color: [1, 0.86, 0.8] },
+				light: { sunUp: 10, sunAround: 75, sun: 1.1, sunColor: [1, 0.72, 0.5], ambient: 0.5, ambientColor: [0.8, 0.78, 0.95] },
+				wind: { around: 20, strength: 0.15, gusts: 0.2 },
+				fog: { start: 40, end: 150, color: [0.85, 0.76, 0.74] },
+				mist: {
+					ground: { base: 0, top: 3.2, density: 0.55, color: [0.9, 0.84, 0.84] },
+					areas: [
+						{
+							id: 1,
+							name: 'by the stream',
+							shape: { kind: 'circle', ...valleyAt(0.45), radius: 12 },
+							base: 0,
+							top: 4.5,
+							density: 0.6,
+							softness: 4,
+							drift: { x: 0.4, z: 0.6 }
+						}
+					]
+				}
+			}
+		},
+		{
+			id: 'nature-weather',
+			category: 'nature',
+			title: 'Rain, storm and snow',
+			summary:
+				'A village under changing weather. Pick clear, rain, a storm or snow and how much falls: every player sees it come in over a few seconds, the wind with it.',
+			tags: ['weather', 'rain', 'snow', 'storm', 'wind', 'splashes'],
+			map: villageMap,
+			start: (world) => {
+				plant(world, villageTrees(villageMap()))
+				villagers(world)
+			},
+			environment: WEATHER.rain(0.6)
+		},
+		{
+			id: 'nature-time',
+			category: 'nature',
+			title: 'The time of day',
+			summary:
+				'A village from dawn to night: the sun goes round and down, the sky and mist turn, and the torches come up. Slide the hour, or let the day run.',
+			tags: ['time of day', 'day', 'night', 'dawn', 'dusk', 'lights', 'torches', 'sun'],
+			map: villageMap,
+			start: (world) => {
+				plant(world, villageTrees(villageMap()))
+				villagers(world)
+			}
+		},
+		{
+			id: 'nature-fire',
+			category: 'nature',
+			title: 'Fire, and growing back',
+			summary:
+				'A dry field by a wood, the wind blowing east. Light it and the fire runs downwind through the grass into the trees; put it out, let it rain, or grow it all back.',
+			tags: ['fire', 'burning', 'grass', 'trees', 'regrow', 'wind', 'restore'],
+			map: fireMap,
+			start: (world) => {
+				const places = fireTrees(fireMap())
+				world.setState(replant, { places })
+				plant(world, places, 0.1)
+			},
+			environment: {
+				sky: [0.62, 0.72, 0.86],
+				clouds: { cover: 0.25 },
+				light: { sunUp: 44, sunAround: 210, sun: 1.45, sunColor: [1, 0.92, 0.78], ambient: 0.55 },
+				wind: { around: 90, strength: 0.55, gusts: 0.4 },
+				fog: { start: 60, end: 180 }
+			}
+		},
+		{
+			id: 'nature-looks',
+			category: 'nature',
+			title: 'Looks of the world',
+			summary:
+				'One lake under many skies: a summer noon, golden hour, a blue night, a grey storm, a winter morning, an autumn haze. Pick one and watch the world cross-fade into it.',
+			tags: ['environment', 'presets', 'cross-fade', 'sky', 'light', 'mood', 'setEnvironment'],
+			map: lakeMap,
+			start: (world) => plant(world, lakeTrees(lakeMap()), 0.03)
+		}
+	]
+}
+
+/** A few villagers about the square: who the weather falls on */
+function villagers(world: World): void {
+	const at: At[] = [
+		{ x: 31, z: 30 },
+		{ x: 33.5, z: 33 },
+		{ x: 29.5, z: 32.5 },
+		{ x: 35, z: 29 },
+		{ x: 34, z: 36.5 }
+	]
+	const types = [UNIT.footman, UNIT.archer, UNIT.mage, UNIT.footman, UNIT.knight]
+	at.forEach((place, i) => world.spawn(types[i], { at: place, owner: PLAYER }))
+}
+
+export { FIRE_START, GLADE, SQUARE }

package/starters/examples/src/examples/nature/land.ts

@@ -0,0 +1,173 @@
+/**
+ * Land made in code for the nature examples' maps: the ground shaped by a function of where, cliffs raised, water
+ * poured, tiles and grass painted, scenery put down, and trees planted as the world starts. The engine alone: a map
+ * is data the rules read (`GameMap`), and the same seed lays the same land on every machine
+ */
+import { exactMath } from '@v12-engine/engine'
+import type { GameMap, MapDoodad, World } from '@v12-engine/engine'
+import { exampleField } from '../define'
+import { DEAD_TREE, GRASS, TREE } from './grass'
+
+/** A point of the map, in cells */
+export interface At {
+	x: number
+	z: number
+}
+
+/** A test of a cell (its middle) or a vertex: whether something goes there */
+export type Where = (x: number, z: number) => boolean
+
+/** Numbers from a seed, the same each time: what lays scenery out the same on every machine */
+export function seeded(seed: number): () => number {
+	let s = seed >>> 0
+	return () => {
+		s = (s + 0x6d2b79f5) >>> 0
+		let t = s
+		t = Math.imul(t ^ (t >>> 15), t | 1)
+		t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
+		return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+	}
+}
+
+/** A hash of a whole point, 0 to 1 */
+const hash = (x: number, z: number, seed: number) => {
+	const n = exactMath.sin(x * 127.1 + z * 311.7 + seed * 74.7) * 43758.5453
+	return n - Math.floor(n)
+}
+
+/** Smooth noise, 0 to 1, about `scale` cells from one hump to the next: what makes edges and hills look grown, not drawn */
+export function noise(x: number, z: number, scale: number, seed = 1): number {
+	const fx = x / scale
+	const fz = z / scale
+	const ix = Math.floor(fx)
+	const iz = Math.floor(fz)
+	const tx = fx - ix
+	const tz = fz - iz
+	const sx = tx * tx * (3 - 2 * tx)
+	const sz = tz * tz * (3 - 2 * tz)
+	const a = hash(ix, iz, seed)
+	const b = hash(ix + 1, iz, seed)
+	const c = hash(ix, iz + 1, seed)
+	const d = hash(ix + 1, iz + 1, seed)
+	return a + (b - a) * sx + (c - a) * sz + (a - b - c + d) * sx * sz
+}
+
+/** 0 below `from`, 1 above `to`, smooth between */
+export const smooth = (from: number, to: number, value: number): number => {
+	const t = Math.min(1, Math.max(0, (value - from) / (to - from)))
+	return t * t * (3 - 2 * t)
+}
+
+/** A flat field of `size` cells a side, one player in the middle, painted grass (`exampleField`) */
+export const field = (name: string, size: number): GameMap => exampleField({ name, size })
+
+/** The ground's height at every vertex, from a function of where it is (the field's is 1) */
+export function sculpt(map: GameMap, height: (x: number, z: number) => number): void {
+	const row = map.width + 1
+	for (let z = 0; z <= map.depth; z++) for (let x = 0; x <= map.width; x++) map.ground[z * row + x] = height(x, z)
+}
+
+/** Every cell `where` says, set to a value: the cell's middle is asked */
+function eachCell(map: GameMap, where: Where, set: (cell: number) => void): void {
+	for (let z = 0; z < map.depth; z++) for (let x = 0; x < map.width; x++) if (where(x + 0.5, z + 0.5)) set(z * map.width + x)
+}
+
+/** Paints a tile of the game's (`grass`, `darkGrass`, `dirt`, `road`, `sand`, `rock`, `snow`) where it says */
+export function paint(map: GameMap, tile: string, where: Where): void {
+	const value = map.tileset.indexOf(tile) + 1
+	if (value > 0) eachCell(map, where, (cell) => (map.tiles[cell] = value))
+}
+
+/** Grows a style of the nature grass (`STYLE`) where it says, over what grew there */
+export function grow(map: GameMap, style: number, where: Where): void {
+	const cells = (map.cells ??= {})
+	const layer = (cells[GRASS] ??= new Uint8Array(map.width * map.depth))
+	eachCell(map, where, (cell) => (layer[cell] = style))
+}
+
+/** Takes the grass away where it says: under water, on a road */
+export function mow(map: GameMap, where: Where): void {
+	const layer = map.cells?.[GRASS]
+	if (layer) eachCell(map, where, (cell) => (layer[cell] = 0))
+}
+
+/** Water where it says: deep where `deep` says too (nothing on foot crosses it), shallow (waded through) elsewhere */
+export function pour(map: GameMap, where: Where, deep: Where = () => false): void {
+	eachCell(map, where, (cell) => {
+		const x = (cell % map.width) + 0.5
+		const z = Math.floor(cell / map.width) + 0.5
+		map.water[cell] = deep(x, z) ? 2 : 1
+	})
+}
+
+/** Raises the cells it says to a cliff level (each `map.cliffHeight` over the one below) */
+export function raise(map: GameMap, level: number, where: Where): void {
+	eachCell(map, where, (cell) => (map.levels[cell] = level))
+}
+
+/** Whether a cell is dry and on the map's ground level: where a tree, a house or a walker may go */
+export const dryAt = (map: GameMap, x: number, z: number): boolean => {
+	if (x < 0 || z < 0 || x >= map.width || z >= map.depth) return false
+	return map.water[Math.floor(z) * map.width + Math.floor(x)] === 0
+}
+
+/** A ring round a middle, `radius` out, with a wobble of `rough` cells so it looks grown */
+export const blob =
+	(middle: At, radius: number, rough = 2, seed = 1): Where =>
+	(x, z) =>
+		exactMath.hypot(x - middle.x, z - middle.z) < radius + (noise(x, z, 6, seed) - 0.5) * 2 * rough
+
+/** A band along a line of points, `width` across, wobbling by `rough` */
+export function band(points: readonly At[], width: number, rough = 0.6, seed = 2): Where {
+	return (x, z) => distanceToLine(points, x, z) < width / 2 + (noise(x, z, 5, seed) - 0.5) * 2 * rough
+}
+
+/** How far a point is from a line of points, in cells */
+export function distanceToLine(points: readonly At[], x: number, z: number): number {
+	let best = Infinity
+	for (let i = 0; i + 1 < points.length; i++) {
+		const a = points[i]
+		const b = points[i + 1]
+		const dx = b.x - a.x
+		const dz = b.z - a.z
+		const t = Math.max(0, Math.min(1, ((x - a.x) * dx + (z - a.z) * dz) / (dx * dx + dz * dz || 1)))
+		best = Math.min(best, exactMath.hypot(x - (a.x + dx * t), z - (a.z + dz * t)))
+	}
+	return best
+}
+
+/** Places for trees in an area: as many as fit, `spacing` apart at least, the same for a seed */
+export function scatter(map: GameMap, where: Where, spacing: number, seed: number, most = 2000): At[] {
+	const random = seeded(seed)
+	const out: At[] = []
+	const tries = Math.min(most * 12, map.width * map.depth * 4)
+	for (let i = 0; i < tries && out.length < most; i++) {
+		const x = 1 + random() * (map.width - 2)
+		const z = 1 + random() * (map.depth - 2)
+		if (!where(x, z) || !dryAt(map, x, z)) continue
+		if (out.some((other) => exactMath.hypot(other.x - x, other.z - z) < spacing)) continue
+		out.push({ x, z })
+	}
+	return out
+}
+
+/** Plants trees at places, standing on cells' middles (a tree takes a cell): `dead` of them dead, at random */
+export function plant(world: World, places: readonly At[], dead = 0, seed = 5): void {
+	const random = seeded(seed)
+	const taken = new Set<number>()
+	for (const { x, z } of places) {
+		const cell = Math.floor(z) * world.terrain.width + Math.floor(x)
+		if (taken.has(cell)) continue
+		taken.add(cell)
+		world.spawn(random() < dead ? DEAD_TREE : TREE, { at: { x: Math.floor(x) + 0.5, z: Math.floor(z) + 0.5 }, owner: 0 })
+	}
+}
+
+/** Scenery put down on the map (`MapDoodad`): a house, a rock, a lamp. Drawn by the screen alone; the rules never see it */
+export function place(map: GameMap, model: string, at: At, options: { yaw?: number; scale?: number; blocks?: boolean; name?: string } = {}): void {
+	const { yaw = 0, scale = 1, blocks = false, name } = options
+	const doodad: MapDoodad = { id: map.doodads.length + 1, model, x: at.x, z: at.z, yaw, scale: [scale, scale, scale] }
+	if (blocks) Object.assign(doodad, { blocks: 'walk', radius: scale * 1.2 })
+	if (name) doodad.name = name
+	map.doodads.push(doodad)
+}