@v12-engine/create 0.1.1 → 0.4.0

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

@@ -0,0 +1,570 @@
+/**
+ * The destruction examples on the rules' side: buildings, trees, rocks, fences and grass to break, and what breaks
+ * them (a meteor, a shockwave, kegs of powder, catapults). The rules only say what dies, and how (`DamageOptions.how`);
+ * how it comes apart on the screen is the look's (`./looks.ts`: `UnitLook.death`), with the client's physics
+ */
+import {
+	type AreaShape,
+	createMap,
+	defineCellLayer,
+	defineCommand,
+	defineComponent,
+	defineTimer,
+	entityDied,
+	type Entity,
+	FOLIAGE_STATE,
+	foliageStateLayer,
+	type Game,
+	MAP_NEUTRAL,
+	mapTerrain,
+	number,
+	oneOf,
+	presetFoliageStyles,
+	terrainPatch,
+	text,
+	type UnitTypeDef,
+	type Vec2,
+	type World,
+	exactMath
+} from '@v12-engine/engine'
+import { ENEMY, PLAYER, UNIT } from '../common/units'
+import { type ExampleCategory, type ExampleDef, exampleField } from '../define'
+
+/** The destruction examples' own unit types: what stands to be broken, and what breaks it */
+export const D = {
+	house: 'destructionHouse',
+	hut: 'destructionHut',
+	tower: 'destructionTower',
+	wall: 'destructionWall',
+	fence: 'destructionFence',
+	tree: 'destructionTree',
+	rock: 'destructionRock',
+	keg: 'destructionKeg',
+	catapult: 'destructionCatapult',
+	blast: 'destructionBlast'
+} as const
+
+/** The words for how something died (`DamageOptions.how`): each look says what it does for each (`death.how`) */
+export const HOW = {
+	crumble: 'destructionCrumble',
+	explode: 'destructionExplode',
+	topple: 'destructionTopple',
+	sink: 'destructionSink',
+	shatter: 'destructionShatter',
+	planks: 'destructionPlanks',
+	// a meteor, a keg going off: blown apart, away from the blast
+	blasted: 'destructionBlasted',
+	// a shockwave: flung far, in many pieces
+	swept: 'destructionSwept',
+	// a catapult's boulder
+	crushed: 'destructionCrushed'
+} as const
+
+/** The layer of grass the examples lay and burn: their own, drawn by `./looks.ts`, no pack of the game's needed */
+export const GRASS = 'destructionGrass'
+
+/** Whether what falls in this world grows back by itself, after how many seconds: the regrowing example's alone */
+const regrowing = defineComponent<{ after: number } | null>({ id: 'destruction.regrowing', default: () => null })
+
+/** A number from 0 to 1 for a whole number: the same everywhere, for scattering things the same on every machine */
+const hash = (n: number): number => {
+	let h = Math.imul(n ^ 0x9e3779b9, 0x85ebca6b)
+	h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35)
+	return ((h ^ (h >>> 16)) >>> 0) / 4294967296
+}
+
+/**
+ * A tree, a rock: scenery to break. A building of nobody's rather than a resource, so that each is drawn as a model of
+ * its own, whose meshes the client can split into pieces as it dies (`death.shatter`); trees as resources are drawn
+ * many to a batch, and fall or throw solids (`death.debris`) instead
+ */
+const scenery = (id: string, name: string, own: Partial<UnitTypeDef>): UnitTypeDef => ({
+	id,
+	name,
+	kind: 'building',
+	radius: 0.5,
+	footprint: { w: 1, d: 1 },
+	stats: { health: 60 },
+	sight: 0,
+	// nobody hits it on their own: only what the examples throw at it
+	ignored: true,
+	// what falls may grow back: put down as a site that builds itself (`construction: 'self'`), its look growing with it
+	construction: 'self',
+	buildTime: 5,
+	...own
+})
+
+const building = (id: string, name: string, size: number, health: number, own: Partial<UnitTypeDef> = {}): UnitTypeDef => ({
+	id,
+	name,
+	kind: 'building',
+	radius: size / 2,
+	footprint: { w: size, d: size },
+	stats: { health, armor: 2 },
+	sight: 4,
+	construction: 'self',
+	buildTime: 4,
+	...own
+})
+
+const types: UnitTypeDef[] = [
+	building(D.house, 'House', 3, 900),
+	building(D.hut, 'Hut', 2, 500),
+	building(D.tower, 'Watch tower', 2, 700),
+	// a length of wall or fence: three cells along x, one deep
+	{ ...building(D.wall, 'Stone wall', 3, 600), footprint: { w: 3, d: 1 }, radius: 0.5 },
+	{ ...building(D.fence, 'Fence', 3, 120), footprint: { w: 3, d: 1 }, radius: 0.5 },
+	building(D.keg, 'Keg of powder', 1, 40, { stats: { health: 40 } }),
+	scenery(D.tree, 'Tree', { fellable: true }),
+	scenery(D.rock, 'Rock', { footprint: { w: 2, d: 2 }, radius: 1, stats: { health: 300 }, buildTime: 4 }),
+	{
+		id: D.catapult,
+		name: 'Catapult',
+		kind: 'unit',
+		radius: 0.8,
+		stats: { health: 500, attackDamage: 160, attackSpeed: 0.5, attackRange: 16, moveSpeed: 2.5, armor: 10 },
+		sight: 18,
+		// a boulder thrown in an arc, landing where it was aimed: all near it hurt, trees brought down
+		attacks: [
+			{
+				damagePoint: 0.6,
+				acquisitionRange: 16,
+				projectileSpeed: 14,
+				splash: 2,
+				ground: true,
+				fells: true,
+				how: HOW.crushed,
+				targets: ['building', 'unit']
+			}
+		]
+	},
+	{
+		// where a blast comes from: what flung pieces fly away from. Here for a second, then gone; nothing sees or hits it
+		id: D.blast,
+		name: 'Blast',
+		kind: 'unit',
+		radius: 0.1,
+		stats: { health: 1, moveSpeed: 0 },
+		sight: 0,
+		invulnerable: true,
+		targetableBy: [],
+		lifetime: 1
+	}
+]
+
+// ---- what breaks things
+
+/**
+ * Hurts everything within `radius` of a point as a blast does: in full at its heart, less to the edge, killing what it
+ * kills `how` it says, from a blast at the point (what the pieces fly away from). The grass under it burns black, and
+ * what is left of the ground is dug into a crater `depth` deep. What it hit, nearest first
+ */
+export function blast(world: World, at: Vec2, options: { radius: number; damage: number; how: string; crater?: number; except?: Entity }): Entity[] {
+	const from = world.spawn(D.blast, { at, owner: MAP_NEUTRAL })
+	const hit = world.query({ near: at, radius: options.radius, sort: 'nearest', ...(options.except && { except: [options.except, from] }) })
+	for (const each of hit) {
+		if (each === from || each.def.id === D.blast) continue
+		const away = exactMath.hypot(each.pos.x - at.x, each.pos.z - at.z)
+		const share = 1 - 0.6 * Math.min(1, away / options.radius)
+		world.damage(each, options.damage * share, from, { how: options.how, tags: ['blast'] })
+	}
+	burnGrass(world, { kind: 'circle', x: at.x, z: at.z, radius: options.radius * 0.8 })
+	if (options.crater) crater(world, at, options.radius * 0.6, options.crater)
+	return hit
+}
+
+/** The grass in an area burnt black: its state layer set (`FOLIAGE_STATE.burnt`), drawn as stubble over ash */
+export function burnGrass(world: World, where: AreaShape): void {
+	const layer = world.terrain.cells[GRASS]
+	if (!layer) return
+	world.setCells(foliageStateLayer(GRASS), where, FOLIAGE_STATE.burnt)
+}
+
+/** The ground dug into a bowl round a point (`World.reshapeGround`): deepest at the middle, `depth` down, painted dirt */
+export function crater(world: World, at: Vec2, radius: number, depth: number): void {
+	const { terrain } = world
+	const x = Math.max(0, Math.floor(at.x - radius - 1))
+	const z = Math.max(0, Math.floor(at.z - radius - 1))
+	const width = Math.min(terrain.width - x, Math.ceil(radius * 2 + 2))
+	const deep = Math.min(terrain.depth - z, Math.ceil(radius * 2 + 2))
+	const patch = terrainPatch(terrain, { x, z, width, depth: deep })
+	const dirt = world.registry.tile('dirt')
+	for (let vz = 0; vz <= deep; vz++)
+		for (let vx = 0; vx <= width; vx++) {
+			const d = exactMath.hypot(x + vx - at.x, z + vz - at.z) / radius
+			if (d >= 1) continue
+			// a bowl with a lip: down in the middle, a little up at its rim
+			const bowl = exactMath.cos((d * Math.PI) / 2)
+			const down = bowl * bowl * depth - exactMath.sin(d * Math.PI) * depth * 0.15
+			patch.heights[vz * (width + 1) + vx] -= down
+		}
+	for (let cz = 0; cz < deep; cz++)
+		for (let cx = 0; cx < width; cx++)
+			if (exactMath.hypot(x + cx + 0.5 - at.x, z + cz + 0.5 - at.z) < radius * 0.85) patch.tiles[cz * width + cx] = dirt
+	world.reshapeGround(patch)
+}
+
+/** Grass laid over an area */
+const grass = (world: World, where: AreaShape) => world.setCells(GRASS, where, 1)
+
+/** Trees round a point in a disc, a cell apart at least, scattered the same every time; none within `clear` of the middle */
+function grove(world: World, at: Vec2, radius: number, clear = 0, every = 0.45): void {
+	for (let z = Math.floor(at.z - radius); z <= at.z + radius; z++)
+		for (let x = Math.floor(at.x - radius); x <= at.x + radius; x++) {
+			const d = exactMath.hypot(x + 0.5 - at.x, z + 0.5 - at.z)
+			if (d > radius || d < clear || hash(x * 131 + z * 7919) > every) continue
+			// every other cell at most, so they stand apart
+			if ((x + z) % 2) continue
+			world.spawn(D.tree, { at: { x: x + 0.5, z: z + 0.5 }, owner: MAP_NEUTRAL })
+		}
+}
+
+/** Takes away everything an example put down: what it lays out again starts on an empty field */
+function clear(world: World): void {
+	for (const each of [...world.entities.values()]) if (each.alive) world.kill(each, undefined, false, 'removed')
+}
+
+// ---- the examples' layouts
+
+/** Five buildings in a row, each to be brought down its own way */
+function row(world: World): void {
+	const kinds = [D.house, D.hut, D.tower, D.house, D.hut, D.house]
+	kinds.forEach((type, i) => world.spawn(type, { at: { x: 8.5 + i * 6.5, z: 24.5 }, owner: ENEMY }))
+	grass(world, { kind: 'rect', x: 4, z: 18, width: 40, depth: 12 })
+}
+
+/** A village: houses and huts round a square, fences, trees about it, rocks, grass, and its people */
+function village(world: World): void {
+	const houses: [string, number, number][] = [
+		[D.house, 18.5, 28.5],
+		[D.house, 29.5, 28.5],
+		[D.hut, 24, 32],
+		[D.hut, 16, 21],
+		[D.hut, 32, 21],
+		[D.tower, 24, 15]
+	]
+	for (const [type, x, z] of houses) world.spawn(type, { at: { x, z }, owner: ENEMY })
+	for (let i = 0; i < 3; i++) world.spawn(D.fence, { at: { x: 14.5 + i * 3, z: 16.5 }, owner: ENEMY })
+	for (let i = 0; i < 3; i++) world.spawn(D.fence, { at: { x: 27.5 + i * 3, z: 16.5 }, owner: ENEMY })
+	for (const [x, z] of [
+		[11, 26],
+		[37, 26],
+		[20, 37],
+		[30, 37]
+	])
+		world.spawn(D.rock, { at: { x, z }, owner: MAP_NEUTRAL })
+	grove(world, { x: 24, z: 24 }, 18, 10, 0.6)
+	grass(world, { kind: 'circle', x: 24, z: 24, radius: 16 })
+	for (let i = 0; i < 6; i++) world.spawn(UNIT.footman, { at: { x: 21 + (i % 3) * 1.5, z: 22 + Math.floor(i / 3) * 1.5 }, owner: ENEMY })
+}
+
+/** A hero in a clearing in a wood: what the shockwave goes out from */
+function clearing(world: World): void {
+	world.spawn(UNIT.knight, { at: { x: 24, z: 24 }, owner: PLAYER })
+	grove(world, { x: 24, z: 24 }, 16, 4, 0.4)
+	for (const [x, z] of [
+		[18, 18],
+		[30, 19],
+		[17, 30],
+		[31, 31],
+		[24, 33]
+	])
+		world.spawn(D.rock, { at: { x, z }, owner: MAP_NEUTRAL })
+	for (let i = 0; i < 3; i++) world.spawn(D.fence, { at: { x: 20.5 + i * 3, z: 37.5 }, owner: MAP_NEUTRAL })
+	grass(world, { kind: 'circle', x: 24, z: 24, radius: 20 })
+}
+
+/** A fort of walls and towers with kegs of powder along a winding line through it: one lit, the rest go in turn */
+function fort(world: World): void {
+	for (let i = 0; i < 6; i++) {
+		world.spawn(D.wall, { at: { x: 12.5 + i * 3, z: 34.5 }, owner: ENEMY })
+		world.spawn(D.wall, { at: { x: 12.5 + i * 3, z: 14.5 }, owner: ENEMY })
+	}
+	for (const [x, z] of [
+		[10, 14],
+		[30, 14],
+		[10, 35],
+		[30, 35]
+	])
+		world.spawn(D.tower, { at: { x, z }, owner: ENEMY })
+	world.spawn(D.house, { at: { x: 16.5, z: 24.5 }, owner: ENEMY })
+	world.spawn(D.house, { at: { x: 25.5, z: 27.5 }, owner: ENEMY })
+	world.spawn(D.hut, { at: { x: 25, z: 20 }, owner: ENEMY })
+	// the kegs: a line that winds from the gate through the fort and past every building
+	for (const [x, z] of KEGS) world.spawn(D.keg, { at: { x: x + 0.5, z: z + 0.5 }, owner: ENEMY })
+	grass(world, { kind: 'rect', x: 6, z: 10, width: 30, depth: 30 })
+	grove(world, { x: 40, z: 24 }, 6, 0, 0.7)
+}
+
+/** Where the kegs stand, in the order the fire takes them */
+const KEGS: [number, number][] = [
+	[34, 24],
+	[32, 24],
+	[30, 23],
+	[28, 22],
+	[28, 20],
+	[27, 17],
+	[25, 16],
+	[22, 17],
+	[20, 18],
+	[19, 20],
+	[20, 22],
+	[22, 23],
+	[22, 25],
+	[21, 27],
+	[19, 28],
+	[16, 28],
+	[13, 27],
+	[12, 25],
+	[12, 22],
+	[13, 19],
+	[12, 16],
+	[13, 31],
+	[16, 32],
+	[20, 32],
+	[24, 31],
+	[28, 31],
+	[29, 33]
+]
+
+/** A grove, rocks and grass to smash: all of it grows back, a few seconds after it fell */
+function meadow(world: World): void {
+	world.setState(regrowing, { after: 4 })
+	grove(world, { x: 24, z: 26 }, 11, 0, 0.7)
+	for (const [x, z] of [
+		[18, 20],
+		[30, 21],
+		[24, 32]
+	])
+		world.spawn(D.rock, { at: { x, z }, owner: MAP_NEUTRAL })
+	grass(world, { kind: 'circle', x: 24, z: 26, radius: 14 })
+}
+
+/** A stone fort on the far side of the field, and catapults on the near side to knock it down */
+function siege(world: World): void {
+	for (let i = 0; i < 5; i++) world.spawn(D.wall, { at: { x: 16.5 + i * 3, z: 30.5 }, owner: ENEMY })
+	world.spawn(D.tower, { at: { x: 14, z: 31 }, owner: ENEMY })
+	world.spawn(D.tower, { at: { x: 34, z: 31 }, owner: ENEMY })
+	world.spawn(D.house, { at: { x: 20.5, z: 35.5 }, owner: ENEMY })
+	world.spawn(D.house, { at: { x: 28.5, z: 35.5 }, owner: ENEMY })
+	world.spawn(D.hut, { at: { x: 24, z: 40 }, owner: ENEMY })
+	grove(world, { x: 24, z: 37 }, 12, 6, 0.4)
+	for (let i = 0; i < 4; i++) world.spawn(D.catapult, { at: { x: 15 + i * 6, z: 12 }, owner: PLAYER, facing: Math.PI / 2 })
+	grass(world, { kind: 'rect', x: 4, z: 26, width: 40, depth: 18 })
+}
+
+/** Each example's layout, by its id: what it starts with, and what Lay it out again lays */
+const LAYOUTS: Record<string, (world: World) => void> = {
+	'destruction-collapse': row,
+	'destruction-meteor': village,
+	'destruction-shockwave': clearing,
+	'destruction-chain': fort,
+	'destruction-regrow': meadow,
+	'destruction-siege': siege
+}
+
+// ---- commands, sent by the examples' buttons
+
+/** Brings the first building of the row still standing down, `how` the button says */
+export const raze = defineCommand('destruction.raze', { how: oneOf(...Object.values(HOW)) }, (world, _player, { how }) => {
+	const standing = world.query({ kinds: ['building'], owner: ENEMY }).sort((a, b) => a.pos.x - b.pos.x)[0]
+	if (!standing) return
+	// hit from in front, where the camera is: a toppled one falls away from it
+	const from = world.spawn(D.blast, { at: { x: standing.pos.x - 1, z: standing.pos.z - 6 }, owner: MAP_NEUTRAL })
+	// more than it has, past its armour
+	world.damage(standing, standing.maxHealth * 10, from, { how })
+})
+
+/** Hurts every building to a share of its health: what its look shows under a half, a quarter */
+export const hurt = defineCommand('destruction.hurt', { share: number }, (world, _player, { share }) => {
+	for (const each of world.query({ kinds: ['building'], owner: ENEMY })) each.health = Math.max(1, Math.min(each.health, each.maxHealth * share))
+})
+
+/** A meteor comes down at a point: a big blast, a crater, everything round it broken and flung away */
+export const meteor = defineCommand('destruction.meteor', { x: number, z: number, size: number }, (world, _player, { x, z, size }) => {
+	world.fx('explosion', { at: { x, z }, params: { size: 2.6 * size, shake: 1.4 } })
+	world.fx('ground-crack', { at: { x, z }, params: { size: 2.2 * size } })
+	world.fx('shockwave', { at: { x, z }, params: { size: 3 * size } })
+	blast(world, { x, z }, { radius: 9.5 * size, damage: 2500, how: HOW.blasted, crater: 1.6 * size })
+})
+
+/** How fast the shockwave goes out, in cells a second, and how far */
+const WAVE = { speed: 8, reach: 20 }
+
+/** A ring that goes out from the hero, fells what it passes */
+const waveTimer = defineTimer<{ x: number; z: number; step: number; hero: number }>({
+	id: 'destruction.wave',
+	run(world, { x, z, step, hero }) {
+		const reach = Math.min(WAVE.reach, (step + 1) * WAVE.speed * 0.1)
+		const inner = step * WAVE.speed * 0.1
+		const from = world.entities.get(hero)
+		const ring = world.query({ near: { x, z }, radius: reach, where: (each) => exactMath.hypot(each.pos.x - x, each.pos.z - z) >= inner - 0.5 })
+		for (const each of ring) if (each !== from && each.def.id !== D.blast) world.damage(each, 5000, from, { how: HOW.swept })
+		// the grass in the ring laid flat, away from the hero
+		const cells = []
+		for (let cz = Math.floor(z - reach); cz <= z + reach; cz++)
+			for (let cx = Math.floor(x - reach); cx <= x + reach; cx++) {
+				const d = exactMath.hypot(cx + 0.5 - x, cz + 0.5 - z)
+				if (d < reach && d >= inner - 1 && cx >= 0 && cz >= 0 && cx < world.terrain.width && cz < world.terrain.depth)
+					cells.push(cz * world.terrain.width + cx)
+			}
+		if (world.terrain.cells[GRASS]) world.setCells(foliageStateLayer(GRASS), cells, FOLIAGE_STATE.flattened)
+		if (reach < WAVE.reach) world.timers.after(0.1, waveTimer, { x, z, step: step + 1, hero })
+	}
+})
+
+/** The hero sends a shockwave out round it */
+export const shockwave = defineCommand('destruction.shockwave', {}, (world) => {
+	const hero = world.query({ type: UNIT.knight, limit: 1 })[0]
+	if (!hero) return
+	const { x, z } = hero.pos
+	world.fx('shockwave', { at: { x, z }, params: { size: 6 } })
+	world.fx('impact-ring', { at: { x, z }, params: { size: 4 } })
+	world.fx('ground-crack', { at: { x, z }, params: { size: 1.5 } })
+	world.timers.after(0.05, waveTimer, { x, z, step: 0, hero: hero.id })
+})
+
+/** A keg that went off: the blast it makes a moment after, which sets off the kegs near it */
+const kegBlast = defineTimer<{ x: number; z: number }>({
+	id: 'destruction.kegBlast',
+	run(world, at) {
+		world.fx('explosion', { at, params: { size: 1.3, shake: 0.5 } })
+		blast(world, at, { radius: 4.3, damage: 900, how: HOW.blasted, crater: 0.35 })
+	}
+})
+
+/** Lights the first keg: the rest go one after another */
+export const fuse = defineCommand('destruction.fuse', {}, (world) => {
+	const first = world.query({ type: D.keg }).sort((a, b) => b.pos.x - a.pos.x)[0]
+	if (first) world.damage(first, 1000, undefined, { how: HOW.blasted })
+})
+
+/** Everything in the meadow smashed at once: it grows back by itself (`regrowing`) */
+export const smash = defineCommand('destruction.smash', {}, (world) => {
+	world.fx('shockwave', { at: { x: 24, z: 26 }, params: { size: 5 } })
+	blast(world, { x: 24, z: 26 }, { radius: 16, damage: 5000, how: HOW.shatter })
+	world.timers.after(6, grassBack, { x: 24, z: 26, radius: 16 })
+})
+
+/** Burnt grass grows back: whole again, eased in over a few seconds on the screens (`setCells`' `over`) */
+const grassBack = defineTimer<{ x: number; z: number; radius: number }>({
+	id: 'destruction.grassBack',
+	run(world, { x, z, radius }) {
+		world.setCells(foliageStateLayer(GRASS), { kind: 'circle', x, z, radius }, FOLIAGE_STATE.whole, { over: 4 })
+	}
+})
+
+/** A tree, a rock that fell grows back where it stood (`regrowing`): put down as a site that builds itself */
+const regrow = defineTimer<{ type: string; x: number; z: number }>({
+	id: 'destruction.regrow',
+	run(world, { type, x, z }) {
+		try {
+			world.spawn(type, { at: { x, z }, owner: MAP_NEUTRAL, underConstruction: true })
+		} catch {
+			// something stands there now: it does not come back
+		}
+	}
+})
+
+/** A catapult told to throw at what of the fort is nearest it */
+function aim(world: World, catapult: Entity): void {
+	const target = world.query({ near: catapult, kinds: ['building'], owner: ENEMY, sort: 'nearest', limit: 1 })[0]
+	if (target) catapult.order('attack', target)
+}
+
+/** The catapults told to throw at the fort: each at what of it is nearest, and at the next as that falls */
+export const bombard = defineCommand('destruction.bombard', {}, (world) => {
+	for (const catapult of world.query({ type: D.catapult })) aim(world, catapult)
+})
+
+/** Takes everything away and lays the example out again, as it started */
+export const relay = defineCommand('destruction.relay', { example: text }, (world, _player, { example }) => {
+	const layout = LAYOUTS[example]
+	if (!layout) return
+	clear(world)
+	// the ground and the grass as they were: flat, grass whole again
+	const { terrain } = world
+	const patch = terrainPatch(terrain, { x: 0, z: 0, width: terrain.width, depth: terrain.depth })
+	const grassTile = world.registry.tile('grass')
+	// as high as a new map's ground stands, which the field is
+	patch.heights.fill(mapTerrain(createMap({ name: 'ground', width: 1, depth: 1, players: 1, tileset: world.registry.tileIds })).heights[0])
+	patch.tiles.fill(grassTile)
+	world.reshapeGround(patch)
+	if (terrain.cells[GRASS]) {
+		world.setCells(GRASS, { kind: 'rect', x: 0, z: 0, width: terrain.width, depth: terrain.depth }, 0)
+		world.setCells(foliageStateLayer(GRASS), { kind: 'rect', x: 0, z: 0, width: terrain.width, depth: terrain.depth }, FOLIAGE_STATE.whole)
+	}
+	layout(world)
+})
+
+const example = (id: string, title: string, summary: string, tags: string[], own: Partial<ExampleDef> = {}): ExampleDef => ({
+	id,
+	category: 'destruction',
+	title,
+	summary,
+	tags,
+	map: () => exampleField({ name: title, players: 2 }),
+	start: (world) => LAYOUTS[id]?.(world),
+	source: ['examples/destruction/index.ts', 'examples/destruction/looks.ts'],
+	...own
+})
+
+export const category: ExampleCategory = {
+	rules: (game: Game<any>) => {
+		for (const type of types) game.unit(type)
+		game.component(regrowing)
+		game.cellLayer(
+			defineCellLayer({ id: GRASS, name: 'Grass (destruction)', values: [{ value: 1, name: 'Meadow', foliage: presetFoliageStyles.meadow }] })
+		)
+		for (const command of [raze, hurt, meteor, shockwave, fuse, smash, bombard, relay]) game.command(command)
+		for (const timer of [waveTimer, kegBlast, regrow, grassBack]) game.timer(timer)
+		game.on(entityDied, (world, { entity, killer, reason }) => {
+			// a catapult that brought something down throws at the next
+			if (killer?.def.id === D.catapult && killer.alive) aim(world, killer)
+			// a keg that is hit goes off a moment later: that is what sets the next one off
+			if (entity.def.id === D.keg && reason !== 'removed') world.timers.after(0.18, kegBlast, { x: entity.pos.x, z: entity.pos.z })
+			// in the regrowing example, scenery that fell comes back
+			const regrows = world.state(regrowing)
+			if (regrows && reason !== 'removed' && (entity.def.id === D.tree || entity.def.id === D.rock))
+				world.timers.after(regrows.after + hash(entity.id) * 3, regrow, { type: entity.def.id, x: entity.pos.x, z: entity.pos.z })
+		})
+	},
+	examples: [
+		example(
+			'destruction-collapse',
+			'Six ways to come down',
+			'A row of buildings, and a button for each way one breaks: crumbling into pieces of itself, blown apart, toppled, sunk, shattered, thrown down as planks. Hurt them first to see smoke and fire.',
+			['building', 'collapse', 'crumble', 'explode', 'topple', 'shatter', 'debris', 'physics', 'damaged']
+		),
+		example(
+			'destruction-meteor',
+			'Meteor on a village',
+			'Call a meteor down on a village: it digs a crater, burns the grass, and blows the houses, fences, trees, rocks and people round it apart, every piece flung away from the blast.',
+			['meteor', 'blast', 'crater', 'explosion', 'trees', 'rocks', 'grass', 'physics', 'shatter']
+		),
+		example(
+			'destruction-shockwave',
+			'Shockwave through a forest',
+			'The knight sends a shockwave out: a ring that goes out through the wood, breaking every tree, rock and fence it passes and laying the grass flat, all of it flung away from him.',
+			['shockwave', 'trees', 'forest', 'rocks', 'grass', 'ring', 'physics']
+		),
+		example(
+			'destruction-chain',
+			'Chain reaction',
+			'Kegs of powder wind through a fort. Light the first: each keg that goes off sets off the next, and the walls, towers and houses beside them come down with it.',
+			['chain', 'explosion', 'kegs', 'barrels', 'fort', 'walls', 'timers']
+		),
+		example(
+			'destruction-regrow',
+			'Smashed, then grown back',
+			'Smash a grove, its rocks and its grass: a few seconds later each tree and rock grows back where it stood, and the grass after it.',
+			['regrow', 'respawn', 'trees', 'rocks', 'grass', 'construction']
+		),
+		example(
+			'destruction-siege',
+			'Catapults on a fort',
+			'Four catapults throw boulders at a stone fort: walls smoke and burn as they are hurt and crumble when they fall, and the trees round the fort are knocked down where boulders land.',
+			['siege', 'catapult', 'splash', 'walls', 'damaged', 'fells', 'trees']
+		)
+	]
+}