@v12-engine/create 0.1.0 → 0.4.0

package/starters/examples/src/examples/dynamic-map/index.ts

@@ -0,0 +1,603 @@
+/**
+ * The dynamic-map examples on the rules' side: the ground changed while the game runs. A part of it is taken
+ * (`terrainPatch`), its heights, levels, water and paint changed, and put back (`world.reshapeGround`): every screen
+ * draws it again, the fog sees by its new levels and the ways are cut again where it changed, so units walk round
+ * what was raised and over what was lowered. Grass is a layer of cells (`world.setCells`), trees are things put down
+ * and taken away, and a region of new land is made by the engine's map generator (`generateMap`) as the game goes
+ */
+import {
+	defineCellLayer,
+	defineCommand,
+	defineComponent,
+	defineTimer,
+	type Entity,
+	type Game,
+	generateMap,
+	MAP_NEUTRAL,
+	mapTerrain,
+	type MapGenerator,
+	number,
+	oneOf,
+	presetFoliageStyles,
+	scatterPass,
+	terrainPass,
+	type TerrainPatch,
+	terrainPatch,
+	text,
+	tilesPass,
+	type UnitTypeDef,
+	type Vec2,
+	WATER_DEEP,
+	WATER_NONE,
+	WATER_SHALLOW,
+	type World,
+	exactMath
+} from '@v12-engine/engine'
+import { PLAYER, UNIT } from '../common/units'
+import { type ExampleCategory, type ExampleDef, exampleField } from '../define'
+
+/** The dynamic-map examples' own: a tree to plant and clear, and the grass they grow */
+export const TREE = 'dynamicMapTree'
+export const GRASS = 'dynamicMapGrass'
+
+/** How much higher a cliff's top is than its foot: what the maps of the engine use (`GameMap.cliffHeight`) */
+const CLIFF = 3
+
+const tree: UnitTypeDef = {
+	id: TREE,
+	name: 'Tree',
+	// a building of nobody's: put down while the game runs, it grows (`construction: 'self'`) and blocks the way
+	kind: 'building',
+	radius: 0.5,
+	footprint: { w: 1, d: 1 },
+	stats: { health: 60 },
+	sight: 0,
+	ignored: true,
+	fellable: true,
+	construction: 'self',
+	buildTime: 3
+}
+
+/**
+ * How high the ground of the field is as the map was made (the field is not at 0): what every height here is over,
+ * read as an example starts
+ */
+const groundBase = defineComponent<{ base: number }>({ id: 'dynamicMap.base', default: () => ({ base: 0 }) })
+const baseOf = (world: World) => world.state(groundBase).base
+
+/** The water's surface in the flooding example, over the field's ground, and where it is going */
+const flood = defineComponent<{ level: number; to: number }>({ id: 'dynamicMap.flood', default: () => ({ level: -3, to: -3 }) })
+
+// ---- the ground, a part at a time
+
+/** The part of the ground a rectangle of cells covers, inside the map; none where it is all outside */
+function rectOf(world: World, x0: number, z0: number, x1: number, z1: number) {
+	const { width, depth } = world.terrain
+	const x = Math.max(0, Math.floor(x0))
+	const z = Math.max(0, Math.floor(z0))
+	const w = Math.min(width, Math.ceil(x1)) - x
+	const d = Math.min(depth, Math.ceil(z1)) - z
+	return w > 0 && d > 0 ? { x, z, width: w, depth: d } : undefined
+}
+
+/**
+ * Changes a part of the ground: `change` is given the patch (`TerrainPatch`) and writes into it, then it is put back
+ * with `world.reshapeGround`, which tells every screen and cuts the ways again there
+ */
+function reshape(world: World, x0: number, z0: number, x1: number, z1: number, change: (patch: TerrainPatch) => void): void {
+	const rect = rectOf(world, x0, z0, x1, z1)
+	if (!rect) return
+	const patch = terrainPatch(world.terrain, rect)
+	change(patch)
+	world.reshapeGround(patch)
+}
+
+/** Each vertex of a patch, with where it is on the map and its index in `heights` and `waterHeights` */
+function eachVertex(patch: TerrainPatch, run: (x: number, z: number, i: number) => void): void {
+	for (let vz = 0; vz <= patch.depth; vz++) for (let vx = 0; vx <= patch.width; vx++) run(patch.x + vx, patch.z + vz, vz * (patch.width + 1) + vx)
+}
+
+/** Each cell of a patch, with where its middle is on the map and its index in the cells' layers */
+function eachCell(patch: TerrainPatch, run: (x: number, z: number, i: number) => void): void {
+	for (let cz = 0; cz < patch.depth; cz++) for (let cx = 0; cx < patch.width; cx++) run(patch.x + cx + 0.5, patch.z + cz + 0.5, cz * patch.width + cx)
+}
+
+/** How much of a brush reaches a point: 1 at its middle, easing to 0 at its edge */
+const falloff = (d: number, radius: number) => {
+	if (d >= radius) return 0
+	const edge = exactMath.cos((d / radius) * (Math.PI / 2))
+	return edge * edge
+}
+
+/** What the sculpting brush does */
+export const BRUSHES = ['Raise', 'Dig', 'Flatten', 'Plateau', 'Water'] as const
+
+/** The ground under a brush changed: raised or dug a little more each stroke, flattened, a plateau with cliffs, a pool */
+function sculptAt(world: World, at: Vec2, radius: number, brush: (typeof BRUSHES)[number]): void {
+	const base = baseOf(world)
+	const tile = { rock: world.registry.tile('rock'), dirt: world.registry.tile('dirt'), sand: world.registry.tile('sand') }
+	reshape(world, at.x - radius - 1, at.z - radius - 1, at.x + radius + 1, at.z + radius + 1, (patch) => {
+		if (brush === 'Plateau') {
+			// a level up: the cells inside are of level 1 and their corners a cliff's height up; the client draws the walls
+			eachCell(patch, (x, z, i) => {
+				if (exactMath.hypot(x - at.x, z - at.z) > radius) return
+				patch.levels[i] = Math.max(patch.levels[i], 1)
+				patch.tiles[i] = tile.rock
+			})
+			eachVertex(patch, (x, z, i) => {
+				if (exactMath.hypot(x - at.x, z - at.z) <= radius + 0.5) patch.heights[i] = Math.max(patch.heights[i], base + CLIFF)
+			})
+			return
+		}
+		if (brush === 'Water') {
+			// a hollow with water in it: deep in the middle, shallow at its edge, sand round it
+			eachVertex(patch, (x, z, i) => {
+				const d = exactMath.hypot(x - at.x, z - at.z)
+				patch.heights[i] = Math.min(patch.heights[i], base - 2.2 * falloff(d, radius + 0.5))
+				patch.waterHeights[i] = base - 0.35
+			})
+			eachCell(patch, (x, z, i) => {
+				const d = exactMath.hypot(x - at.x, z - at.z)
+				if (d < radius) patch.water[i] = d < radius * 0.6 ? WATER_DEEP : WATER_SHALLOW
+				if (d < radius + 1) patch.tiles[i] = tile.sand
+			})
+			return
+		}
+		eachVertex(patch, (x, z, i) => {
+			const f = falloff(exactMath.hypot(x - at.x, z - at.z), radius)
+			if (brush === 'Raise') patch.heights[i] += 1.4 * f
+			else if (brush === 'Dig') patch.heights[i] -= 1.4 * f
+			else patch.heights[i] = base + (patch.heights[i] - base) * (1 - f)
+		})
+		// a pit is earth, a hill's top rock
+		if (brush === 'Dig') eachCell(patch, (x, z, i) => falloff(exactMath.hypot(x - at.x, z - at.z), radius) > 0.5 && (patch.tiles[i] = tile.dirt))
+		if (brush === 'Flatten')
+			eachCell(patch, (x, z, i) => {
+				if (exactMath.hypot(x - at.x, z - at.z) >= radius * 0.8) return
+				patch.levels[i] = 0
+				patch.water[i] = WATER_NONE
+			})
+	})
+}
+
+/** The ground of the whole map as it was made: flat, grass, dry, of level 0 */
+function flatten(world: World): void {
+	const grass = world.registry.tile('grass')
+	const base = baseOf(world)
+	reshape(world, 0, 0, world.terrain.width, world.terrain.depth, (patch) => {
+		patch.heights.fill(base)
+		patch.waterHeights.fill(base)
+		patch.levels.fill(0)
+		patch.water.fill(WATER_NONE)
+		patch.tiles.fill(grass)
+	})
+}
+
+/** Footmen of the player's that walk back and forth between two points: what shows the ways changing */
+function walkers(world: World, from: Vec2, to: Vec2, count = 6): void {
+	for (let i = 0; i < count; i++) {
+		const at = { x: from.x + (i % 3) * 1.6 - 1.6, z: from.z + Math.floor(i / 3) * 1.6 }
+		const unit = world.spawn(UNIT.footman, { at, owner: PLAYER })
+		unit.order('patrol', { x: to.x + (i % 3) * 1.6 - 1.6, z: to.z - Math.floor(i / 3) * 1.6 })
+	}
+}
+
+/** Takes away everything an example put down, and lays the ground flat */
+function clear(world: World): void {
+	for (const each of [...world.entities.values()]) if (each.alive) world.kill(each, undefined, false, 'removed')
+	flatten(world)
+	if (world.terrain.cells[GRASS]) world.setCells(GRASS, { kind: 'rect', x: 0, z: 0, width: world.terrain.width, depth: world.terrain.depth }, 0)
+}
+
+// ---- the examples' layouts
+
+/** A field with footmen walking across it, to sculpt under their feet */
+function field(world: World): void {
+	walkers(world, { x: 24, z: 8 }, { x: 24, z: 40 })
+	sculptAt(world, { x: 15, z: 24 }, 5, 'Raise')
+	sculptAt(world, { x: 15, z: 24 }, 5, 'Raise')
+	sculptAt(world, { x: 34, z: 26 }, 4, 'Dig')
+}
+
+/** The river's valley: across the field, deep in the middle, shallow at its east end where it can be forded */
+function valley(world: World): void {
+	const base = baseOf(world)
+	const sand = world.registry.tile('sand')
+	const dirt = world.registry.tile('dirt')
+	reshape(world, 0, 16, world.terrain.width, 33, (patch) => {
+		eachVertex(patch, (x, z, i) => {
+			const across = falloff(Math.abs(z - 24.5), 8)
+			// the floor rises towards the ford in the east
+			const floor = x > 36 ? -0.9 : x > 32 ? -0.9 - ((36 - x) / 4) * 1.6 : -2.5
+			patch.heights[i] = base + floor * Math.min(1, across * 1.6)
+		})
+		eachCell(patch, (_x, z, i) => {
+			const d = Math.abs(z - 24.5)
+			patch.tiles[i] = d < 4 ? dirt : d < 6.5 ? sand : patch.tiles[i]
+		})
+	})
+	walkers(world, { x: 16, z: 8 }, { x: 16, z: 40 })
+	world.setState(flood, { level: -3, to: -3 })
+}
+
+/** A field, footmen walking across it: where the cliff will rise */
+function plain(world: World): void {
+	walkers(world, { x: 24, z: 9 }, { x: 24, z: 40 })
+}
+
+/** The west half grass, the east half sea: where new land is made */
+function shore(world: World): void {
+	sea(world)
+	walkers(world, { x: 10, z: 10 }, { x: 10, z: 38 }, 3)
+}
+
+/** The sea east of x 24 */
+function sea(world: World): void {
+	const base = baseOf(world)
+	const sand = world.registry.tile('sand')
+	reshape(world, 22, 0, world.terrain.width, world.terrain.depth, (patch) => {
+		eachVertex(patch, (x, _z, i) => {
+			patch.heights[i] = base - (x <= 23 ? 0 : 2.4 * Math.min(1, (x - 23) / 3))
+			patch.waterHeights[i] = base - 0.4
+		})
+		eachCell(patch, (x, _z, i) => {
+			patch.levels[i] = 0
+			patch.water[i] = x > 25 ? WATER_DEEP : x > 23.5 ? WATER_SHALLOW : WATER_NONE
+			patch.tiles[i] = sand
+		})
+	})
+}
+
+/** An empty meadow to plant: footmen at its west edge, to walk the road once it is cleared */
+function meadow(world: World): void {
+	for (let i = 0; i < 4; i++) world.spawn(UNIT.footman, { at: { x: 5, z: 22 + i * 1.4 }, owner: PLAYER })
+}
+
+/** Each example's layout, by its id */
+const LAYOUTS: Record<string, (world: World) => void> = {
+	'dynamic-map-sculpt': field,
+	'dynamic-map-water': valley,
+	'dynamic-map-cliffs': plain,
+	'dynamic-map-generate': shore,
+	'dynamic-map-forest': meadow,
+	'dynamic-map-paint': (world) => walkers(world, { x: 24, z: 10 }, { x: 24, z: 38 }, 3)
+}
+
+// ---- commands, sent by the examples' buttons and clicks
+
+/** The ground sculpted where the player clicked, or where the camera looks */
+export const sculpt = defineCommand(
+	'dynamicMap.sculpt',
+	{ x: number, z: number, radius: number, brush: oneOf(...BRUSHES) },
+	(world, _player, { x, z, radius, brush }) => sculptAt(world, { x, z }, Math.min(12, Math.max(1, radius)), brush)
+)
+
+/** The tiles the paint brush has */
+export const PAINTS = ['grass', 'darkGrass', 'dirt', 'road', 'sand', 'rock', 'snow'] as const
+
+/** The ground painted in a circle with a tile */
+export const paint = defineCommand(
+	'dynamicMap.paint',
+	{ x: number, z: number, radius: number, tile: oneOf(...PAINTS) },
+	(world, _player, { x, z, radius, tile }) => {
+		const index = world.registry.tile(tile)
+		reshape(world, x - radius, z - radius, x + radius + 1, z + radius + 1, (patch) =>
+			eachCell(patch, (cx, cz, i) => exactMath.hypot(cx - x, cz - z) <= radius && (patch.tiles[i] = index))
+		)
+	}
+)
+
+/** Snow spreading out from a point, a ring a step (`snowfall`) */
+const snowfall = defineTimer<{ x: number; z: number; ring: number }>({
+	id: 'dynamicMap.snowfall',
+	run(world, { x, z, ring }) {
+		const snow = world.registry.tile('snow')
+		const radius = ring * 1.5
+		reshape(world, x - radius - 1, z - radius - 1, x + radius + 1, z + radius + 1, (patch) =>
+			eachCell(patch, (cx, cz, i) => {
+				// a ragged edge: a cell near it is snow by a hash of where it is
+				const d = exactMath.hypot(cx - x, cz - z) + exactMath.sin(cx * 1.7 + cz * 2.3) * 0.8
+				if (d <= radius) patch.tiles[i] = snow
+			})
+		)
+		if (radius < 15) world.timers.after(0.25, snowfall, { x, z, ring: ring + 1 })
+	}
+})
+
+export const spreadSnow = defineCommand('dynamicMap.snow', { x: number, z: number }, (world, _player, at) =>
+	world.timers.after(0.05, snowfall, { ...at, ring: 1 })
+)
+
+/** A road painted from the west edge to the east, winding a little */
+export const road = defineCommand('dynamicMap.road', {}, (world) => {
+	const tile = world.registry.tile('road')
+	reshape(world, 0, 14, world.terrain.width, 34, (patch) =>
+		eachCell(patch, (x, z, i) => Math.abs(z - (24 + exactMath.sin(x / 6) * 4)) < 1.6 && (patch.tiles[i] = tile))
+	)
+})
+
+/** The water of the valley raised or lowered a step at a time to where it is going (`flood`) */
+const tide = defineTimer({
+	id: 'dynamicMap.tide',
+	run(world) {
+		const state = world.state(flood)
+		const step = Math.sign(state.to - state.level) * Math.min(0.15, Math.abs(state.to - state.level))
+		const level = state.level + step
+		world.setState(flood, { ...state, level })
+		reshape(world, 0, 15, world.terrain.width, 34, (patch) => {
+			const rowOf = patch.width + 1
+			const surface = baseOf(world) + level
+			eachVertex(patch, (_x, _z, i) => (patch.waterHeights[i] = surface))
+			// a cell is under water where its lowest corner is under the surface: deep past most of a unit's height
+			eachCell(patch, (_x, _z, i) => {
+				const cz = Math.floor(i / patch.width)
+				const cx = i % patch.width
+				const at = cz * rowOf + cx
+				const lowest = Math.min(patch.heights[at], patch.heights[at + 1], patch.heights[at + rowOf], patch.heights[at + rowOf + 1])
+				const depth = surface - lowest
+				patch.water[i] = depth > 1 ? WATER_DEEP : depth > 0.05 ? WATER_SHALLOW : WATER_NONE
+			})
+		})
+		if (Math.abs(state.to - level) > 1e-3) world.timers.after(0.2, tide)
+	}
+})
+
+/** The valley flooded up to a level, or drained (a level under its floor) */
+export const setFlood = defineCommand('dynamicMap.flood', { level: number }, (world, _player, { level }) => {
+	world.setState(flood, { ...world.state(flood), to: level })
+	world.timers.after(0.05, tide)
+})
+
+/** Where the cliff wall goes: across the field, from west to east */
+const WALL = { z0: 22, z1: 26, x0: 3, x1: 45 }
+
+/** A cliff wall raised across the field: a level up, a band of cells, with only its ends to go round */
+export const raiseWall = defineCommand('dynamicMap.wall', {}, (world) => {
+	const rock = world.registry.tile('rock')
+	const base = baseOf(world)
+	reshape(world, WALL.x0, WALL.z0, WALL.x1, WALL.z1, (patch) => {
+		patch.levels.fill(1)
+		patch.tiles.fill(rock)
+		patch.heights.fill(base + CLIFF)
+	})
+})
+
+/** A ramp cut through the wall in its middle: up the south side, over, down the north. The way across is open */
+export const cutRamp = defineCommand('dynamicMap.ramp', {}, (world) => {
+	const dirt = world.registry.tile('dirt')
+	const { z0, z1 } = WALL
+	const base = baseOf(world)
+	reshape(world, 21, z0 - 5, 28, z1 + 5, (patch) => {
+		eachVertex(patch, (x, z, i) => {
+			if (x < 22 || x > 27) return
+			// up over four cells from either side: no step a cell is a cliff's rise
+			const up = z < z0 ? (z - (z0 - 4)) / 4 : z > z1 ? (z1 + 4 - z) / 4 : 1
+			patch.heights[i] = Math.max(patch.heights[i], base + CLIFF * Math.max(0, Math.min(1, up)))
+		})
+		eachCell(patch, (x, z, i) => {
+			if (x < 22 || x > 27) return
+			if (z < z0 || z > z1) patch.levels[i] = 0
+			patch.tiles[i] = dirt
+		})
+	})
+})
+
+/** The wall and the ramp gone: the field flat again */
+export const lower = defineCommand('dynamicMap.lower', {}, (world) => flatten(world))
+
+/** Trees put down by the generator's scatter pass, as objects of the map, put in the world as it is laid */
+const SCATTER = 'dynamicMap.trees'
+
+/**
+ * The generator of the land that rises out of the sea: hills and levels with ramps (`terrainPass`), painted by height
+ * (`tilesPass`), trees in patches (`scatterPass`). The engine's passes; the trees a type of this example's
+ */
+const landMaker: MapGenerator = {
+	params: [],
+	tries: 1,
+	passes: [
+		terrainPass({ levels: 2, water: 0.08, roughness: 0.6, hills: 14 }),
+		tilesPass(),
+		scatterPass({ kind: SCATTER, density: 0.2, spacing: 1.6, avoid: 0, what: (ctx, at) => void ctx.addObject(TREE, MAP_NEUTRAL, at.x, at.z) })
+	]
+}
+
+/** The new land's cells: the sea's part of the map, its edges eased down into it */
+const LAND = { x: 24, z: 1, width: 23, depth: 46 }
+
+/** New land made out of the sea with a seed: generated as a small map of its own, then laid into the world's ground */
+export const raiseLand = defineCommand('dynamicMap.land', { seed: number }, (world, _player, { seed }) => {
+	// what stood on the old land goes with it
+	for (const each of world.query({ type: TREE })) if (each.pos.x > LAND.x) world.kill(each, undefined, false, 'removed')
+	const { map } = generateMap(landMaker, { seed, width: LAND.width, depth: LAND.depth, players: 1 }, world.registry)
+	const land = mapTerrain(map)
+	// its lowest dry ground laid at the field's height: the hills and plateaus over it, the ponds in it
+	const base = baseOf(world)
+	const landBase = lowestDry(land)
+	reshape(world, LAND.x, LAND.z, LAND.x + LAND.width, LAND.z + LAND.depth, (patch) => {
+		eachVertex(patch, (x, z, i) => {
+			const lx = x - LAND.x
+			const lz = z - LAND.z
+			// near its edge the land eases down into the sea round it
+			const edge = Math.min(lx, lz, LAND.width - lx, LAND.depth - lz)
+			const ease = Math.min(1, edge / 4)
+			const h = land.heights[lz * land.vertsX + lx]
+			patch.heights[i] = base - 2.4 + (h - landBase + 2.4) * ease
+			patch.waterHeights[i] = edge < 3 ? base - 0.4 : land.waterHeights[lz * land.vertsX + lx] - landBase + base
+		})
+		eachCell(patch, (x, z, i) => {
+			const lx = Math.floor(x - LAND.x)
+			const lz = Math.floor(z - LAND.z)
+			const c = lz * land.width + lx
+			const edge = Math.min(lx, lz, LAND.width - 1 - lx, LAND.depth - 1 - lz)
+			patch.levels[i] = edge < 4 ? 0 : land.levels[c]
+			patch.tiles[i] = land.tiles[c]
+			patch.water[i] = edge < 1 ? WATER_DEEP : edge < 2 ? WATER_SHALLOW : edge < 3 ? WATER_NONE : land.water[c]
+		})
+	})
+	// the generator's trees, where the land is dry and not too near its edge: growing up
+	for (const object of map.objects) {
+		if (object.type !== TREE) continue
+		const at = { x: LAND.x + object.x, z: LAND.z + object.z }
+		const edge = Math.min(object.x, object.z, LAND.width - object.x, LAND.depth - object.z)
+		if (edge < 4 || world.terrain.waterAt(at.x, at.z) !== WATER_NONE) continue
+		plant(world, at)
+	}
+})
+
+/** The lowest corner of a ground's dry cells of its lowest level: where the land meets the shore */
+function lowestDry(land: ReturnType<typeof mapTerrain>): number {
+	let lowest = Infinity
+	for (let cz = 0; cz < land.depth; cz++)
+		for (let cx = 0; cx < land.width; cx++) {
+			const c = cz * land.width + cx
+			if (land.levels[c] !== 0 || land.water[c] !== WATER_NONE) continue
+			lowest = Math.min(
+				lowest,
+				land.vertexHeight(cx, cz),
+				land.vertexHeight(cx + 1, cz),
+				land.vertexHeight(cx, cz + 1),
+				land.vertexHeight(cx + 1, cz + 1)
+			)
+		}
+	return Number.isFinite(lowest) ? lowest : land.heights[0]
+}
+
+/** The sea back where the land was */
+export const sink = defineCommand('dynamicMap.sink', {}, (world) => {
+	for (const each of world.query({ type: TREE })) if (each.pos.x > LAND.x) world.kill(each, undefined, false, 'removed')
+	sea(world)
+})
+
+/** A tree put down as a sapling that grows: nothing where something stands already */
+function plant(world: World, at: Vec2): Entity | undefined {
+	try {
+		return world.spawn(TREE, { at, owner: MAP_NEUTRAL, underConstruction: true })
+	} catch {
+		return undefined
+	}
+}
+
+/** Where the wood is planted: a disc of trees on every other cell, scattered by where each is */
+export const plantWood = defineCommand('dynamicMap.plant', {}, (world) => {
+	for (let z = 10; z < 40; z++)
+		for (let x = 10; x < 40; x++) {
+			if ((x + z) % 2 || exactMath.hypot(x + 0.5 - 25, z + 0.5 - 25) > 14) continue
+			if (Math.abs(exactMath.sin(x * 12.9898 + z * 78.233) * 43758.5453) % 1 > 0.55) continue
+			if (world.query({ near: { x: x + 0.5, z: z + 0.5 }, radius: 0.6, limit: 1 }).length) continue
+			plant(world, { x: x + 0.5, z: z + 0.5 })
+		}
+})
+
+/** Grass grown over the meadow, eased in on the screens over seconds (`setCells`' `over`) */
+export const growGrass = defineCommand('dynamicMap.grass', {}, (world) => {
+	world.setCells(GRASS, { kind: 'circle', x: 25, z: 25, radius: 19 }, 1, { over: 5 })
+})
+
+/** The band of the road through the wood */
+const inRoad = (x: number, z: number) => Math.abs(z - (25 + exactMath.sin(x / 5) * 2.5)) < 2
+
+/** A road cleared through the wood: its trees felled, its grass gone, its ground painted road. The footmen walk it */
+export const clearRoad = defineCommand('dynamicMap.clear', {}, (world) => {
+	for (const each of world.query({ type: TREE })) if (inRoad(each.pos.x, each.pos.z)) world.kill(each, undefined, false, 'felled')
+	const tile = world.registry.tile('road')
+	const cells: number[] = []
+	reshape(world, 0, 18, world.terrain.width, 32, (patch) =>
+		eachCell(patch, (x, z, i) => {
+			if (!inRoad(x, z)) return
+			patch.tiles[i] = tile
+			cells.push(Math.floor(z) * world.terrain.width + Math.floor(x))
+		})
+	)
+	if (world.terrain.cells[GRASS]) world.setCells(GRASS, cells, 0)
+	for (const each of world.query({ type: UNIT.footman, owner: PLAYER })) each.order('patrol', { x: 44, z: each.pos.z })
+})
+
+/** Takes everything away and lays the example out again */
+export const relay = defineCommand('dynamicMap.relay', { example: text }, (world, _player, { example }) => {
+	const layout = LAYOUTS[example]
+	if (!layout) return
+	clear(world)
+	layout(world)
+})
+
+const example = (id: string, title: string, summary: string, tags: string[]): ExampleDef => ({
+	id,
+	category: 'dynamic-map',
+	title,
+	summary,
+	tags,
+	map: () => exampleField({ name: title }),
+	start: (world) => {
+		world.setState(groundBase, { base: world.terrain.heights[0] })
+		LAYOUTS[id]?.(world)
+	},
+	source: ['examples/dynamic-map/index.ts', 'examples/dynamic-map/looks.ts']
+})
+
+export const category: ExampleCategory = {
+	rules: (game: Game<any>) => {
+		game.unit(tree)
+		game.component(flood)
+		game.component(groundBase)
+		game.cellLayer(
+			defineCellLayer({ id: GRASS, name: 'Grass (dynamic map)', values: [{ value: 1, name: 'Meadow', foliage: presetFoliageStyles.meadow }] })
+		)
+		for (const command of [
+			sculpt,
+			paint,
+			spreadSnow,
+			road,
+			setFlood,
+			raiseWall,
+			cutRamp,
+			lower,
+			raiseLand,
+			sink,
+			plantWood,
+			growGrass,
+			clearRoad,
+			relay
+		])
+			game.command(command)
+		for (const timer of [snowfall, tide]) game.timer(timer)
+	},
+	examples: [
+		example(
+			'dynamic-map-sculpt',
+			'Raise and dig',
+			'Click the ground to raise it, dig it, flatten it, lift a plateau with cliffs or sink a pool. The footmen walking across go over the hills and round the cliffs and water, the ways cut again as it changes.',
+			['terrain', 'sculpt', 'height', 'raise', 'dig', 'cliff', 'plateau', 'navigation', 'reshapeGround']
+		),
+		example(
+			'dynamic-map-paint',
+			'Paint the ground',
+			'Click to paint the ground with grass, dirt, road, sand, rock or snow; lay a winding road across; let snow spread out from the middle ring by ring.',
+			['terrain', 'paint', 'tiles', 'texture', 'road', 'snow']
+		),
+		example(
+			'dynamic-map-water',
+			'Flood and drain a valley',
+			'Flood the valley and the water rises step by step: deep water cuts the way, so the footmen go round by the shallow ford in the east. Drain it and they walk straight across again.',
+			['water', 'flood', 'drain', 'river', 'ford', 'navigation']
+		),
+		example(
+			'dynamic-map-cliffs',
+			'A cliff, then a ramp',
+			'Raise a cliff wall across the field and the footmen walking across go round its ends; cut a ramp through its middle and they take it, up and over.',
+			['cliff', 'ramp', 'levels', 'high ground', 'navigation', 'reshapeGround']
+		),
+		example(
+			'dynamic-map-generate',
+			'Land out of the sea',
+			"Raise new land out of the sea with the engine's map generator: hills, cliffs, ramps, ponds and a wood, made from a seed while the game runs. Another seed, other land.",
+			['generate', 'procedural', 'generator', 'seed', 'terrain', 'trees']
+		),
+		example(
+			'dynamic-map-forest',
+			'Plant, grow, clear',
+			'Plant a wood and watch it grow, grow grass under it, then clear a road through it: the trees felled, the grass taken off, the ground paved, and the footmen walk the new way.',
+			['trees', 'plant', 'grass', 'grow', 'clear', 'road', 'forest']
+		)
+	]
+}