@v12-engine/engine 0.1.0 → 0.4.0

package/dist/foliage.js

@@ -0,0 +1,1478 @@
+import { cos, exp, sin } from "./exactMath.js";
+import { defineComponent } from "./components.js";
+import { defineEvent } from "./events.js";
+import { gusted } from "./engineEvents.js";
+import { replicateEvent } from "./replication.js";
+import { moving } from "./entity.js";
+import { defineHookType } from "./hooks.js";
+import { areaReach, effectArea, inArea } from "./abilities/shapes.js";
+import { defineEffect } from "./abilities/effects.js";
+import { areaShapeOf, inShape, shapeBounds } from "./areas.js";
+import { concealmentPack } from "./concealment.js";
+import { FoliageRegrowth, REGROWTH, regrowState } from "./foliageRegrowth.js";
+import "./map/types.js";
+import { mapInfo } from "./names.js";
+//#region src/foliage.ts
+/**
+* The id of the foliage pack (`foliagePack`), for `hasPack`
+*
+* @beta
+*/
+var FOLIAGE = "foliage";
+/**
+* What has happened to a cell of grass or bushes, as the values of the layer's state layer (`foliageStateLayer`):
+* `whole` (0: as it grew, and what a cell never touched is), `flattened` (crushed under what walked over it, or by
+* `ruin`), `cut` (down to stubble: fire does not cross it), `burning`, `burnt` (charred: by a fire, or scorched by
+* `ruin`), `growing` (coming back to whole). The style stays in the layer itself, so that what grows back is what
+* stood there. Values past these are kept for states to come
+*
+* @beta
+*/
+var FOLIAGE_STATE = {
+	whole: 0,
+	flattened: 1,
+	cut: 2,
+	burning: 3,
+	burnt: 4,
+	growing: 5
+};
+var STATE_NAMES = Object.keys(FOLIAGE_STATE);
+/**
+* The state a value of a state layer says (`FOLIAGE_STATE`): `whole` for a value that is none of them
+*
+* @beta
+*/
+var foliageStateOf = (value) => STATE_NAMES.find((name) => FOLIAGE_STATE[name] === value) ?? "whole";
+/** What a state layer's id ends with, after the id of the layer it is the state of */
+var STATE = ".state";
+/**
+* The id of the layer of cells that keeps what happened to each cell of a layer of grass or bushes (`FOLIAGE_STATE`):
+* `grass.state` for `grass`. A layer like any other (`Terrain.cells`, `world.setCells`): saved, told to the players who
+* see a cell and to the others as it comes into their sight, kept with a map that starts with a field already burnt.
+* No game lists it (`Rules.cellLayers`), so the editor does not offer it to paint
+*
+* @beta
+*/
+var foliageStateLayer = (layer) => `${layer}${STATE}`;
+/**
+* The layer a state layer is the state of (`foliageStateLayer`): none for a layer that is not one
+*
+* @beta
+*/
+var foliageLayerOfState = (layer) => layer.endsWith(STATE) && layer.length > 6 ? layer.slice(0, -6) : void 0;
+/**
+* The layers a foliage pack was made with, each with its settings: the first, then those beside it (`FoliageOptions.also`)
+*
+* @beta
+*/
+function foliageLayers(options) {
+	const { also, fire: _, ...first } = options;
+	return [first, ...also ?? []];
+}
+/**
+* What a style of a layer is to the rules, by its value: what the value says (`CellLayerValue.foliage`, the game's
+* code with its data and the map's over it) over the layer's own (`FoliageLayerOptions.style`). None for 0, which is
+* no grass. A value the layer does not list is the layer's own style
+*
+* @beta
+*/
+function foliageStyle(game, layer, value) {
+	if (!value) return void 0;
+	const pack = game.packs?.find((each) => each.id === FOLIAGE);
+	const base = pack ? foliageLayers(pack.options).find((each) => each.layer === layer)?.style : void 0;
+	const own = game.cellLayers?.find((def) => def.id === layer)?.values?.find((each) => each.value === value)?.foliage;
+	return {
+		...base,
+		...own
+	};
+}
+/** The fields of a style, and what each holds */
+var STYLE_FIELDS = {
+	conceals: "boolean",
+	concealsTaller: "boolean",
+	height: "number",
+	speed: "number",
+	walkable: "boolean",
+	flammable: "share",
+	burns: "number",
+	fuel: "number",
+	regrows: "regrows",
+	grows: "number",
+	trample: "trample"
+};
+/**
+* Why a style said as data is not one (`FoliageStyleDef`), where it is first wrong: nothing for one that is. `what`
+* names it in what is said
+*
+* @beta
+*/
+function foliageStyleProblem(said, what) {
+	if (typeof said !== "object" || said === null || Array.isArray(said)) return `${what} is no style of grass: { conceals, flammable, burns… }`;
+	for (const [field, value] of Object.entries(said)) {
+		const kind = STYLE_FIELDS[field];
+		if (!kind) return `${what}.${field} is nothing a style of grass says (${Object.keys(STYLE_FIELDS).join(", ")})`;
+		const number = typeof value === "number" && Number.isFinite(value) && value >= 0;
+		if (kind === "boolean" && typeof value !== "boolean") return `${what}.${field} is no yes or no`;
+		if (kind === "number" && !number) return `${what}.${field} is no number from 0`;
+		if (kind === "share" && !(number && value <= 1)) return `${what}.${field} is no number from 0 to 1`;
+		if (kind === "regrows" && value !== false && !number) return `${what}.${field} is seconds, or false for never`;
+		if (kind === "trample" && value !== "none" && value !== "crush") return `${what}.${field} is none or crush`;
+	}
+}
+/**
+* Asked before a cell of grass catches fire (`FoliageIgnite`): a handler refuses it or changes its chance. For every
+* cell a fire tries, so a handler does little
+*
+* @beta
+*/
+var foliageIgnite = /* @__PURE__ */ defineHookType({ id: "foliage.ignite" });
+/**
+* Cells of grass caught fire this tick, by layer and cause: what a game's rules and its computer players hear. The
+* screens are told by the state layer's cells, each as far as it sees
+*
+* @beta
+*/
+var foliageIgnited = defineEvent({ id: "foliage.ignited" });
+/**
+* Cells of grass burnt out this tick: charred now, to grow back where their style says
+*
+* @beta
+*/
+var foliageBurnt = defineEvent({ id: "foliage.burnt" });
+/**
+* Cells of grass were ruined (`ruin`, `firebreak`, an ability, what tramples): how, and by whom where someone did
+*
+* @beta
+*/
+var foliageRuined = defineEvent({ id: "foliage.ruined" });
+/**
+* Cells of grass are whole again: grown back by themselves, or by `regrow` (by whom, where it said)
+*
+* @beta
+*/
+var foliageRegrown = defineEvent({ id: "foliage.regrown" });
+/**
+* The last burning cell of a layer went out: burnt out, put out or stopped
+*
+* @beta
+*/
+var foliageFireOut = defineEvent({ id: "foliage.fireOut" });
+/**
+* Grass and bushes in the rules, on a layer of cells whose values are styles (`CellLayerValue.foliage`,
+* `FoliageStyleDef`): the styles that conceal hide who stands in them (as `concealmentPack`, patch by patch, while
+* they stand whole), a style may slow or stop one on foot, be crushed under who walks over it, be ruined and grow
+* back, catch fire and pass it on (`FoliageFire`). What happened to each cell is kept in the layer's state layer
+* (`foliageStateLayer`). One a game:
+*
+*     export const rules = { ...myGame, packs: [foliagePack({ layer: 'grass', fire: { damage: 8 } })] }
+*
+* A layer of the pack is not given to `concealmentPack` too: the pack hides in it by itself. Its styles are read from
+* the game's layers as laid (`foliageStyle`: the code, the game's `data.json`, the map's definitions), so a style the
+* editor made hides and slows as one of the code's. What it does today: hiding by style and state, a style's
+* `speed` and `walkable`, trampling (`trample: 'crush'`, by who `tramples` says), fire (`ignite`, `FoliageFire`) with
+* `firebreak`, `extinguish` and `stopFire`, ruin (`ruin`) and growing back (`regrow`, by itself where a style
+* `regrows`), and the `foliage` ability effect
+*
+* @beta
+*/
+function foliagePack(options) {
+	const layers = foliageLayers(options);
+	const hooks = [];
+	const systems = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const each of layers) {
+		const { layer } = each;
+		if (!layer) throw new Error("foliagePack: a layer is named by its id (Rules.cellLayers)");
+		if (foliageLayerOfState(layer) !== void 0) throw new Error(`foliagePack: "${layer}" is the state of a layer, not a layer of grass`);
+		if (seen.has(layer)) throw new Error(`foliagePack: the layer "${layer}" is given twice`);
+		seen.add(layer);
+		const hiding = concealmentPack({
+			...foliageConcealment(each),
+			eachUnit: trampling(each)
+		});
+		hooks.push(...hiding.hooks ?? []);
+		systems.push(...hiding.systems ?? []);
+	}
+	const fire = new FoliageFireRules(options);
+	if (fire.on) systems.push(fire.system);
+	systems.push(fire.regrowth.system);
+	return {
+		id: FOLIAGE,
+		options,
+		hooks,
+		systems,
+		components: [fireState, regrowState],
+		events: [
+			foliageIgnited,
+			foliageBurnt,
+			foliageRuined,
+			foliageRegrown,
+			foliageFireOut
+		],
+		effects: [foliageEffect],
+		[FIRE]: fire,
+		[REGROWTH]: fire.regrowth
+	};
+}
+/**
+* How a layer of the pack hides (`ConcealmentOptions`): in the cells whose style conceals and whose state is whole or
+* growing back (`conceals`), the patches worked out again as either layer changes (`follows`); a unit taller than a
+* style that says so seen over it (`seenBy`, asked only of who would be hidden)
+*/
+function foliageConcealment({ layer, conceal = {} }) {
+	const state = foliageStateLayer(layer);
+	let last;
+	const known = /* @__PURE__ */ new WeakMap();
+	/** What each value is to hiding in the world's game, worked out once for its layers of cells */
+	const stylesOf = (world) => {
+		const { cellLayers } = world.registry;
+		if (last?.of === cellLayers) return last;
+		let styles = known.get(cellLayers);
+		if (!styles) {
+			styles = {
+				of: cellLayers,
+				conceals: /* @__PURE__ */ new Uint8Array(256),
+				over: (/* @__PURE__ */ new Float32Array(256)).fill(Infinity),
+				taller: false
+			};
+			const game = {
+				cellLayers,
+				packs: world.registry.assembly?.rules.packs
+			};
+			for (let value = 1; value < 256; value++) {
+				const style = foliageStyle(game, layer, value);
+				styles.conceals[value] = style?.conceals ? 1 : 0;
+				styles.over[value] = style?.conceals && style.concealsTaller === false ? style.height ?? 1 : Infinity;
+				if (styles.over[value] !== Infinity) styles.taller = true;
+			}
+			known.set(cellLayers, styles);
+		}
+		return last = styles;
+	};
+	const { heightOf = (_world, entity) => entity.def.radius * 2, seenBy, ...rest } = conceal;
+	return {
+		...rest,
+		layer,
+		follows: [state],
+		conceals(world, cell) {
+			const { cells } = world.terrain;
+			if (!(last?.of === world.registry.cellLayers ? last : stylesOf(world)).conceals[cells[layer][cell]]) return false;
+			const states = cells[state];
+			if (!states) return true;
+			const now = states[cell];
+			return now === FOLIAGE_STATE.whole || now === FOLIAGE_STATE.growing;
+		},
+		seenBy(world, entity, team) {
+			const styles = stylesOf(world);
+			if (styles.taller) {
+				const { width } = world.terrain;
+				const over = styles.over[world.terrain.cells[layer]?.[Math.floor(entity.pos.z) * width + Math.floor(entity.pos.x)] ?? 0];
+				if (over !== Infinity && heightOf(world, entity) > over) return true;
+			}
+			return seenBy?.(world, entity, team) ?? false;
+		}
+	};
+}
+/** Who tramples when the layer does not say: units on the ground that walk (not structures, not what flies or sails) */
+var onFoot = (_world, entity) => !entity.def.footprint && !entity.flying && !entity.def.naval && entity.def.kind === "unit";
+/** Who crushed the cells put among a tick's from `had` on: one alone, or nobody named where another did too */
+function noteBy(trampled, entity, had) {
+	if (trampled.cells.length === had) return;
+	trampled.by = trampled.by === void 0 || trampled.by === entity ? entity : null;
+}
+/** How a layer of the pack is trampled, told of each unit by the hiding count (`ConcealmentOptions.eachUnit`) */
+function trampling({ layer, tramples = onFoot }) {
+	const state = foliageStateLayer(layer);
+	let last;
+	const known = /* @__PURE__ */ new WeakMap();
+	const worlds = /* @__PURE__ */ new WeakMap();
+	const stylesOf = (world) => {
+		const { cellLayers } = world.registry;
+		if (last?.of === cellLayers) return last;
+		let styles = known.get(cellLayers);
+		if (!styles) {
+			styles = {
+				of: cellLayers,
+				crushes: /* @__PURE__ */ new Uint8Array(256),
+				any: false
+			};
+			const game = {
+				cellLayers,
+				packs: world.registry.assembly?.rules.packs
+			};
+			for (let value = 1; value < 256; value++) if (foliageStyle(game, layer, value)?.trample === "crush") {
+				styles.crushes[value] = 1;
+				styles.any = true;
+			}
+			known.set(cellLayers, styles);
+		}
+		return last = styles;
+	};
+	/** A cell crushed this tick, where its style is and it stands whole or growing */
+	const crush = (world, styles, trampled, cell) => {
+		const { cells } = world.terrain;
+		if (!styles.crushes[cells[layer]?.[cell] ?? 0] || trampled.stamp[cell] === trampled.tick) return;
+		const now = cells[state]?.[cell] ?? FOLIAGE_STATE.whole;
+		if (now !== FOLIAGE_STATE.whole && now !== FOLIAGE_STATE.growing) return;
+		trampled.stamp[cell] = trampled.tick;
+		trampled.cells.push(cell);
+	};
+	return {
+		unit(world, entity, cell) {
+			const styles = last?.of === world.registry.cellLayers ? last : stylesOf(world);
+			if (!styles.any) return;
+			const { terrain } = world;
+			const cells = terrain.cells[layer];
+			const radius = entity.def.radius;
+			if (!cells || radius <= .5 && !styles.crushes[cells[cell]]) return;
+			if (entity.get(moving)?.status !== "moving" || !tramples(world, entity)) return;
+			let trampled = worlds.get(world);
+			if (!trampled || trampled.stamp.length !== cells.length) worlds.set(world, trampled = {
+				cells: [],
+				stamp: new Int32Array(cells.length).fill(-1),
+				tick: -1,
+				by: void 0
+			});
+			if (trampled.tick !== world.tick) {
+				trampled.tick = world.tick;
+				trampled.cells.length = 0;
+				trampled.by = void 0;
+			}
+			const had = trampled.cells.length;
+			crush(world, styles, trampled, cell);
+			if (radius <= .5) return noteBy(trampled, entity, had);
+			const { width, depth } = terrain;
+			const { x, z } = entity.pos;
+			for (let cz = Math.max(0, Math.floor(z - radius)); cz <= Math.min(depth - 1, Math.floor(z + radius)); cz++) for (let cx = Math.max(0, Math.floor(x - radius)); cx <= Math.min(width - 1, Math.floor(x + radius)); cx++) {
+				const dx = cx + .5 - x;
+				const dz = cz + .5 - z;
+				if (dx * dx + dz * dz <= radius * radius) crush(world, styles, trampled, cz * width + cx);
+			}
+			noteBy(trampled, entity, had);
+		},
+		done(world) {
+			const trampled = worlds.get(world);
+			if (!trampled || trampled.tick !== world.tick || !trampled.cells.length) return false;
+			const crushed = ruin(world, layer, trampled.cells, {
+				how: "crush",
+				...trampled.by && { by: trampled.by }
+			});
+			trampled.cells.length = 0;
+			trampled.by = void 0;
+			return crushed.length > 0;
+		}
+	};
+}
+/**
+* How likely a burning cell is to light a cell beside it at a try: of a style that catches as dry grass does
+* (`flammable` 1), lit by one that burns as hot as 1 (`fuel`), on flat ground, in still air and dry. About a cell a
+* second at a try every quarter of a second
+*/
+var CATCH = .08;
+/** What a cell across a corner catches by, of what one across a side does: it is farther, and a front of the two as round as it is wide */
+var CORNER = .5;
+/** How much a gale makes a try downwind likelier (`FoliageFire.wind` 1, the wind's strength 1: e² ≈ 7.4 times) and upwind less (a seventh) */
+var WIND = 2;
+/** How much a slope of 1 (45°) makes a try uphill likelier (`FoliageFire.slope` 1: e ≈ 2.7 times), and downhill less */
+var SLOPE = 1;
+/** What part of a try's chance a jump over a gap of one cell has (`FoliageFire.jump`) */
+var JUMP = .5;
+/** How likely a cell burning in rain or snow of amount 1 is to go out at a try */
+var DOUSE = .25;
+/** How often who stands in a burning cell is hurt (`FoliageFire.damage`), in seconds */
+var SCORCH_EVERY = .5;
+/**
+* How likely a burning thing is to light a cell of grass beside it at a try, once a second (`BurningOptions.lightsFoliage`):
+* of a style that catches as dry grass does (`flammable` 1), in still air and dry. A tree burning in a meadow lights a
+* cell of its eight in about its first second, and seldom all of them at once
+*/
+var FROM_THING = .2;
+/** The eight ways about a cell, row by row: the order the cells beside a burning one are tried in */
+var WAYS_X = [
+	-1,
+	0,
+	1,
+	-1,
+	1,
+	-1,
+	0,
+	1
+];
+var WAYS_Z = [
+	-1,
+	-1,
+	-1,
+	0,
+	0,
+	1,
+	1,
+	1
+];
+/** What burns in a world (`FireState`): plain data, kept by a save */
+var fireState = /* @__PURE__ */ defineComponent({
+	id: "foliage.fire",
+	default: () => ({
+		burning: {},
+		waiting: []
+	})
+});
+/** Where the pack keeps its fire's rules, on the pack, for the calls made on a world of its game */
+var FIRE = Symbol("foliage fire");
+/**
+* A fire's rules, the pack's: its settings, what it worked out of the game and the map (styles, the air), and what a
+* tick and the calls do with a world's `fireState`. One a pack, for every world of its game: what it keeps of a world
+* is scratch, emptied as each call ends. The burning pack reaches it for its link to the grass (`foliageFireOf`)
+*
+* @internal
+*/
+var FoliageFireRules = class {
+	/** Whether anything burns in the game (`FoliageOptions.fire` not `false`) */
+	on;
+	/** The pack's layers, in order: the order a tick goes through them in */
+	layers;
+	/** Each layer's state layer (`foliageStateLayer`) */
+	states;
+	/** What `FoliageFire` says, each as it is when left out: whether a burning cell lights those about it */
+	spread;
+	/** Seconds between a burning cell's tries */
+	every;
+	/** How much the wind decides */
+	wind;
+	/** How much faster uphill */
+	slope;
+	/** The wind's strength from which a fire jumps a gap of one cell: none for never */
+	jump;
+	/** How wet everything is, 0 to 1 */
+	wet;
+	/** Whether rain and snow damp it and put it out */
+	weather;
+	/** The most cells that burn at once */
+	maxBurning;
+	/** Seconds after which a fire dies: none for never */
+	lasts;
+	/** Damage a second to who stands in a burning cell */
+	damage;
+	/** The type that damage is dealt as */
+	damageType;
+	/** Whether a burning cell may light what burns beside it (`FoliageFire.lights`), in a game with the burning pack */
+	lights;
+	/** The system that runs it */
+	system;
+	/** What grows back of the pack's layers, and when (`FoliageRegrowth`): what is ruined, and what burns out */
+	regrowth;
+	/** What each style is to the fire, as last worked out (`stylesOf`) */
+	styles;
+	/** The air as last worked out (`airOf`) */
+	air;
+	/** The road's tile of each game seen, by its tiles: 0 where it has none */
+	roads = /* @__PURE__ */ new WeakMap();
+	/** Scratch of a tick: the cells caught in it, by layer, so that one tried twice catches once */
+	caught;
+	/** Scratch of a tick, by layer: what caught (cells, by whom, when its fire was lit) */
+	fresh;
+	/** Scratch of a tick, by layer: the cells that burnt out in it */
+	out;
+	constructor(options) {
+		const fire = options.fire === false ? void 0 : options.fire ?? {};
+		this.on = !!fire;
+		this.layers = foliageLayers(options).map((each) => each.layer);
+		this.states = this.layers.map(foliageStateLayer);
+		this.spread = fire?.spread !== false;
+		this.every = Math.max(0, fire?.every ?? .25);
+		this.wind = Math.max(0, fire?.wind ?? 1);
+		this.slope = Math.max(0, fire?.slope ?? 1);
+		this.jump = fire?.jump;
+		this.wet = Math.min(1, Math.max(0, fire?.wet ?? 0));
+		this.weather = fire?.weather !== false;
+		this.maxBurning = Math.max(0, Math.floor(fire?.maxBurning ?? 4e3));
+		this.lasts = fire?.lasts;
+		this.damage = Math.max(0, fire?.damage ?? 0);
+		this.damageType = fire?.damageType ?? "magic";
+		this.lights = !!fire?.lights;
+		this.caught = this.layers.map(() => /* @__PURE__ */ new Set());
+		this.fresh = this.layers.map(() => ({
+			cells: [],
+			by: [],
+			lit: []
+		}));
+		this.out = this.layers.map(() => []);
+		this.regrowth = new FoliageRegrowth({
+			layers: this.layers,
+			states: this.states,
+			state: FOLIAGE_STATE,
+			style: foliageStyle,
+			regrown: (world, layer, cells, by) => world.events.emit(foliageRegrown, {
+				layer,
+				cells,
+				...by ? { by } : {}
+			})
+		});
+		this.system = {
+			name: "foliage.fire",
+			phase: "resolve",
+			update: (world) => {
+				if (!world.states.has(fireState)) return;
+				this.tick(world, world.state(fireState));
+			}
+		};
+	}
+	/** The index of a layer of the pack, for a call (`what`) given it: throws for one the pack has not */
+	indexOf(what, layer) {
+		const index = this.layers.indexOf(layer);
+		if (index < 0) throw new Error(`${what}: "${layer}" is no layer of the foliage pack (${this.layers.join(", ")})`);
+		return index;
+	}
+	/** How many ticks apart a cell's tries are (`every`): at least one */
+	stride(world) {
+		return Math.max(1, Math.round(this.every / world.dt));
+	}
+	/** What each style is to the fire, by layer and value, worked out once for a game's layers of cells */
+	stylesOf(world) {
+		const { cellLayers } = world.registry;
+		if (this.styles?.of === cellLayers) return this.styles;
+		const game = {
+			cellLayers,
+			packs: world.registry.assembly?.rules.packs
+		};
+		const styles = {
+			of: cellLayers,
+			flammable: [],
+			fuel: [],
+			burns: []
+		};
+		for (const layer of this.layers) {
+			const flammable = /* @__PURE__ */ new Float64Array(256);
+			const fuel = /* @__PURE__ */ new Float64Array(256);
+			const burns = /* @__PURE__ */ new Float64Array(256);
+			for (let value = 1; value < 256; value++) {
+				const style = foliageStyle(game, layer, value);
+				flammable[value] = Math.min(1, Math.max(0, style?.flammable ?? 0));
+				fuel[value] = Math.max(0, style?.fuel ?? 1);
+				burns[value] = Math.max(0, style?.burns ?? 6);
+			}
+			styles.flammable.push(flammable);
+			styles.fuel.push(fuel);
+			styles.burns.push(burns);
+		}
+		return this.styles = styles;
+	}
+	/** The index of the game's `road` tile, which never burns: 0 for a game without one */
+	roadOf(world) {
+		const { tiles } = world.registry;
+		let road = this.roads.get(tiles);
+		if (road === void 0) {
+			road = tiles.findIndex((tile) => tile.id === "road") + 1;
+			this.roads.set(tiles, road);
+		}
+		return road;
+	}
+	/** The air over the map now (`FireAir`), worked out again as the map's environment changes */
+	airOf(world) {
+		const info = world.state(mapInfo);
+		const environment = info.environment;
+		if (this.air && this.air.of === environment) return this.air;
+		const said = environment ?? {};
+		const strength = Math.min(1, Math.max(0, said.wind?.strength ?? 0));
+		const turn = (said.wind?.around ?? 0) % 360 * Math.PI / 180;
+		const wx = strength ? sin(turn) : 0;
+		const wz = strength ? -cos(turn) : 0;
+		const ways = /* @__PURE__ */ new Float64Array(8);
+		const jumps = /* @__PURE__ */ new Uint8Array(8);
+		for (let way = 0; way < 8; way++) {
+			const dx = WAYS_X[way];
+			const dz = WAYS_Z[way];
+			const corner = dx !== 0 && dz !== 0;
+			const along = (dx * wx + dz * wz) / (corner ? Math.SQRT2 : 1);
+			ways[way] = (corner ? CORNER : 1) * (strength && this.wind ? exp(WIND * this.wind * strength * along) : 1);
+			jumps[way] = this.jump !== void 0 && strength > 0 && strength >= this.jump && along >= .5 ? 1 : 0;
+		}
+		const weather = said.weather;
+		const falls = this.weather && (weather?.kind === "rain" || weather?.kind === "snow") ? Math.min(1, Math.max(0, weather?.amount ?? 0)) : 0;
+		const areas = falls && weather?.areas?.length ? weather.areas.flatMap((area) => {
+			const shape = areaShapeOf(area.shape, info.regions ?? []);
+			return shape ? [{
+				shape,
+				amount: Math.min(1, Math.max(0, area.amount ?? 1))
+			}] : [];
+		}) : void 0;
+		return this.air = {
+			of: environment,
+			strength,
+			x: wx,
+			z: wz,
+			ways,
+			jumps,
+			falls,
+			areas
+		};
+	}
+	/** How much rain or snow falls on a cell, 0 to 1 */
+	fallsOn(air, x, z) {
+		if (!air.falls || !air.areas) return air.falls;
+		let most = 0;
+		for (const area of air.areas) if (area.amount > most && inShape(area.shape, {
+			x: x + .5,
+			z: z + .5
+		})) most = area.amount;
+		return air.falls * most;
+	}
+	/**
+	* Whether a cell of a layer (`l`) may catch fire: grass of a style that burns, whole or growing back, and not on
+	* water, a road, what blocks the way or under a building
+	*/
+	mayCatch(world, styles, road, l, cell) {
+		const { terrain } = world;
+		const value = terrain.cells[this.layers[l]]?.[cell];
+		if (!value || !styles.flammable[l][value]) return false;
+		const state = terrain.cells[this.states[l]]?.[cell] ?? FOLIAGE_STATE.whole;
+		if (state !== FOLIAGE_STATE.whole && state !== FOLIAGE_STATE.growing) return false;
+		if (terrain.water[cell] || (terrain.blocked[cell] & 2) !== 0 || road && terrain.tiles[cell] === road) return false;
+		const x = cell % terrain.width;
+		return world.grid.occupantAt(x, (cell - x) / terrain.width) <= 0;
+	}
+	/** How many cells burn now, over the pack's layers */
+	burningIn(state) {
+		let count = 0;
+		for (const layer of this.layers) count += state.burning[layer]?.cells.length ?? 0;
+		return count;
+	}
+	/**
+	* Asks the game whether a cell catches (`foliageIgnite`), at a chance: the chance it says, 0 where it refuses. The
+	* chance as it is where nobody listens
+	*/
+	ask(world, l, cell, cause, from, by, chance, thing) {
+		if (!world.hooks.has(foliageIgnite)) return chance;
+		const { width } = world.terrain;
+		const x = cell % width;
+		const asked = world.hooks.run(foliageIgnite, {
+			layer: this.layers[l],
+			cell,
+			x: x + .5,
+			z: (cell - x) / width + .5,
+			cause,
+			...from !== void 0 ? { from } : {},
+			...thing ? { thing } : {},
+			...by ? { by: world.entities.get(by) } : {},
+			chance,
+			cancelled: false
+		});
+		return asked.cancelled ? 0 : Math.min(1, Math.max(0, asked.chance || 0));
+	}
+	/** Whether something with a chance happens: by the world's numbers where it is neither sure nor never */
+	happens(world, chance) {
+		return chance >= 1 || chance > 0 && world.rng.next() < chance;
+	}
+	/** Sets grass alight (`ignite`): the cells that caught, in order */
+	ignite(world, layer, cells, by) {
+		const l = this.indexOf("ignite", layer);
+		if (!this.on) return [];
+		const state = world.state(fireState);
+		const styles = this.stylesOf(world);
+		const road = this.roadOf(world);
+		const id = by?.id ?? 0;
+		const room = this.maxBurning - this.burningIn(state);
+		const lit = [];
+		const tried = /* @__PURE__ */ new Set();
+		for (const cell of cells) {
+			if (tried.has(cell)) continue;
+			tried.add(cell);
+			if (!this.mayCatch(world, styles, road, l, cell)) continue;
+			if (state.waiting.some((each) => each.cell === cell && each.layer === layer)) continue;
+			if (!this.happens(world, this.ask(world, l, cell, "ignite", void 0, id, 1))) continue;
+			if (lit.length < room) lit.push(cell);
+			else state.waiting.push({
+				layer,
+				cell,
+				lit: world.tick,
+				by: id
+			});
+		}
+		lit.sort((a, b) => a - b);
+		this.light(world, state, l, lit, () => id, () => world.tick, "ignite");
+		return lit;
+	}
+	/**
+	* Cells of a layer catch fire, in order of their indices, each once, by whom and with the tick its fire was lit:
+	* into the layer's list in order (a cell listed already, set otherwise since and lit again, is there once, with its
+	* new fire), then set burning (one `setCells`), and told (`foliageIgnited`, by whom). In the list first: a cell set
+	* burning is never outside it, whatever throws in what is told of the change (one listed whose state is not burning
+	* is dropped at the fire's next tick)
+	*/
+	light(world, state, l, cells, byOf, litOf, cause) {
+		if (!cells.length) return;
+		const layer = this.layers[l];
+		const fire = state.burning[layer] ??= {
+			cells: [],
+			ends: [],
+			lit: [],
+			by: []
+		};
+		if (fire.cells.length) {
+			let listed;
+			for (const cell of cells) if (indexIn(fire.cells, cell) >= 0) (listed ??= /* @__PURE__ */ new Set()).add(cell);
+			if (listed) {
+				let kept = 0;
+				for (let i = 0; i < fire.cells.length; i++) {
+					if (listed.has(fire.cells[i])) continue;
+					fire.cells[kept] = fire.cells[i];
+					fire.ends[kept] = fire.ends[i];
+					fire.lit[kept] = fire.lit[i];
+					fire.by[kept] = fire.by[i];
+					kept++;
+				}
+				this.shorten(fire, kept);
+			}
+		}
+		const values = world.terrain.cells[layer];
+		const burns = this.stylesOf(world).burns[l];
+		const { tick, dt } = world;
+		let i = fire.cells.length - 1;
+		let j = cells.length - 1;
+		for (let k = 0; k < cells.length; k++) {
+			fire.cells.push(0);
+			fire.ends.push(0);
+			fire.lit.push(0);
+			fire.by.push(0);
+		}
+		for (let w = fire.cells.length - 1; j >= 0; w--) if (i >= 0 && fire.cells[i] > cells[j]) {
+			fire.cells[w] = fire.cells[i];
+			fire.ends[w] = fire.ends[i];
+			fire.lit[w] = fire.lit[i];
+			fire.by[w] = fire.by[i];
+			i--;
+		} else {
+			const cell = cells[j];
+			fire.cells[w] = cell;
+			fire.ends[w] = tick + Math.max(1, Math.round(burns[values[cell]] / dt));
+			fire.lit[w] = litOf(j);
+			fire.by[w] = byOf(j);
+			j--;
+		}
+		world.setCells(this.states[l], cells, FOLIAGE_STATE.burning);
+		const first = byOf(0);
+		let whom;
+		for (let k = 1; k < cells.length && !whom; k++) if (byOf(k) !== first) whom = [first];
+		if (!whom) return void world.events.emit(foliageIgnited, {
+			layer,
+			cells: [...cells],
+			cause,
+			...first ? { by: first } : {}
+		});
+		for (let k = 0; k < cells.length; k++) if (!whom.includes(byOf(k))) whom.push(byOf(k));
+		for (const by of whom) world.events.emit(foliageIgnited, {
+			layer,
+			cells: cells.filter((_, k) => byOf(k) === by),
+			cause,
+			...by ? { by } : {}
+		});
+	}
+	/**
+	* Takes cells out of a layer's fire (those `which` holds, or all of them) and sets them to `to` (burnt, or cut by a
+	* firebreak; left as they are for none, where the caller sets them): those that burnt, in order. What waits there
+	* to be lit waits no more. Told: `foliageBurnt` for what was put out, `foliageFireOut` where nothing burns any more
+	*/
+	quench(world, state, l, which, to) {
+		const layer = this.layers[l];
+		if (state.waiting.length) state.waiting = state.waiting.filter((each) => each.layer !== layer || which !== void 0 && !which.has(each.cell));
+		const fire = state.burning[layer];
+		if (!fire) return [];
+		const out = [];
+		let kept = 0;
+		for (let i = 0; i < fire.cells.length; i++) {
+			const cell = fire.cells[i];
+			if (which === void 0 || which.has(cell)) {
+				out.push(cell);
+				continue;
+			}
+			fire.cells[kept] = cell;
+			fire.ends[kept] = fire.ends[i];
+			fire.lit[kept] = fire.lit[i];
+			fire.by[kept] = fire.by[i];
+			kept++;
+		}
+		if (!out.length) return out;
+		this.shorten(fire, kept);
+		if (to !== void 0) world.setCells(this.states[l], out, to);
+		if (to === FOLIAGE_STATE.burnt) world.events.emit(foliageBurnt, {
+			layer,
+			cells: [...out]
+		});
+		this.over(world, state, l);
+		return out;
+	}
+	/** A layer's list cut to its first `length` */
+	shorten(fire, length) {
+		fire.cells.length = length;
+		fire.ends.length = length;
+		fire.lit.length = length;
+		fire.by.length = length;
+	}
+	/** Where nothing of a layer burns any more: its list gone and told (`foliageFireOut`). Nothing where it burns, or had no list */
+	over(world, state, l) {
+		const layer = this.layers[l];
+		const fire = state.burning[layer];
+		if (!fire || fire.cells.length) return;
+		delete state.burning[layer];
+		world.events.emit(foliageFireOut, { layer });
+	}
+	/** A tick of the fire: what burns out, what catches, what waits and has room now, who is hurt */
+	tick(world, state) {
+		const { layers } = this;
+		let burning = this.burningIn(state);
+		if (!burning && !state.waiting.length) return;
+		const { tick, terrain } = world;
+		const { width, depth, heights, vertsX } = terrain;
+		const styles = this.stylesOf(world);
+		const road = this.roadOf(world);
+		const air = this.airOf(world);
+		const stride = this.stride(world);
+		const turn = tick % stride;
+		const lasts = this.lasts === void 0 ? Infinity : Math.max(1, Math.round(this.lasts / world.dt));
+		const hooked = world.hooks.has(foliageIgnite);
+		const max = this.maxBurning;
+		let fresh = 0;
+		for (let l = 0; l < layers.length; l++) {
+			this.caught[l].clear();
+			const each = this.fresh[l];
+			each.cells.length = each.by.length = each.lit.length = 0;
+			this.out[l].length = 0;
+		}
+		for (let l = 0; l < layers.length; l++) {
+			const fire = state.burning[layers[l]];
+			if (!fire) continue;
+			const out = this.out[l];
+			const values = terrain.cells[layers[l]];
+			const states = terrain.cells[this.states[l]];
+			const fuel = styles.fuel[l];
+			const { cells, ends, lit, by } = fire;
+			let kept = 0;
+			for (let i = 0; i < cells.length; i++) {
+				const cell = cells[i];
+				const from = lit[i];
+				const whose = by[i];
+				if (states?.[cell] !== FOLIAGE_STATE.burning || !values?.[cell]) {
+					burning--;
+					continue;
+				}
+				if (ends[i] <= tick || from + lasts <= tick) {
+					out.push(cell);
+					burning--;
+					continue;
+				}
+				const x = cell % width;
+				const z = (cell - x) / width;
+				if (turnOf(cell, stride) === turn) {
+					const wet = this.fallsOn(air, x, z);
+					if (wet && world.rng.next() < wet * DOUSE) {
+						out.push(cell);
+						burning--;
+						continue;
+					}
+					if (this.spread && burning + fresh < max) {
+						const dry = (1 - Math.min(1, this.wet + wet)) * fuel[values[cell]];
+						if (dry > 0) fresh += this.tryAround(world, styles, road, air, l, cell, x, z, dry, from, whose, burning + fresh, hooked, width, depth, heights, vertsX);
+					}
+				}
+				cells[kept] = cell;
+				ends[kept] = ends[i];
+				lit[kept] = from;
+				by[kept] = whose;
+				kept++;
+			}
+			this.shorten(fire, kept);
+		}
+		let waited;
+		while (state.waiting.length && burning + fresh < max) {
+			const next = state.waiting.shift();
+			const l = layers.indexOf(next.layer);
+			if (l < 0 || this.caught[l].has(next.cell) || !this.mayCatch(world, styles, road, l, next.cell)) continue;
+			this.caught[l].add(next.cell);
+			(waited ??= []).push(next);
+			fresh++;
+		}
+		for (let l = 0; l < layers.length; l++) {
+			const out = this.out[l];
+			if (out.length) {
+				world.setCells(this.states[l], out, FOLIAGE_STATE.burnt);
+				world.events.emit(foliageBurnt, {
+					layer: layers[l],
+					cells: [...out]
+				});
+				this.regrowth.ruined(world, l, out);
+			}
+			const each = this.fresh[l];
+			if (each.cells.length) {
+				const order = each.cells.map((_, k) => k).sort((a, b) => each.cells[a] - each.cells[b]);
+				const sorted = order.map((k) => each.cells[k]);
+				this.light(world, state, l, sorted, (k) => each.by[order[k]], (k) => each.lit[order[k]], "spread");
+			}
+			const lit = waited?.filter((each) => each.layer === layers[l]).sort((a, b) => a.cell - b.cell);
+			if (lit?.length) this.light(world, state, l, lit.map((each) => each.cell), (k) => lit[k].by, (k) => lit[k].lit, "ignite");
+			this.over(world, state, l);
+		}
+		if (this.damage && tick % Math.max(1, Math.round(SCORCH_EVERY / world.dt)) === 0) this.scorch(world, state);
+	}
+	/**
+	* A burning cell's try at the cells about it (and under it, of the pack's other layers): each that may catch, by a
+	* chance of its style, the burning one's (`dry`: its fuel, less what is wet), the wind's way, the slope, and what
+	* the game says (`foliageIgnite`). Across a gap of one cell downwind in a wind strong enough (`jump`). Into the
+	* tick's caught cells; how many caught
+	*/
+	tryAround(world, styles, road, air, l, cell, x, z, dry, from, by, burning, hooked, width, depth, heights, vertsX) {
+		const max = this.maxBurning;
+		let caught = 0;
+		const here = this.slope ? cellHeight(heights, vertsX, x, z) : 0;
+		for (let m = 0; m < this.layers.length; m++) {
+			const flammable = styles.flammable[m];
+			const values = world.terrain.cells[this.layers[m]];
+			if (!values) continue;
+			if (m !== l && this.catchable(world, styles, road, m, cell)) {
+				const chance = CATCH * dry * flammable[values[cell]];
+				if (this.happens(world, hooked ? this.ask(world, m, cell, "spread", cell, by, chance) : chance)) {
+					this.caught[m].add(cell);
+					this.fresh[m].cells.push(cell);
+					this.fresh[m].by.push(by);
+					this.fresh[m].lit.push(from);
+					if (burning + ++caught >= max) return caught;
+				}
+			}
+			for (let way = 0; way < 8; way++) {
+				let nx = x + WAYS_X[way];
+				let nz = z + WAYS_Z[way];
+				if (nx < 0 || nz < 0 || nx >= width || nz >= depth) continue;
+				let next = nz * width + nx;
+				let share = air.ways[way];
+				if (!this.catchable(world, styles, road, m, next)) {
+					if (!air.jumps[way] || this.caught[m].has(next) || world.terrain.cells[this.states[m]]?.[next] === FOLIAGE_STATE.burning) continue;
+					nx += WAYS_X[way];
+					nz += WAYS_Z[way];
+					if (nx < 0 || nz < 0 || nx >= width || nz >= depth) continue;
+					next = nz * width + nx;
+					if (!this.catchable(world, styles, road, m, next)) continue;
+					share *= JUMP;
+				}
+				let chance = CATCH * dry * share * flammable[values[next]];
+				if (this.slope) {
+					const rise = cellHeight(heights, vertsX, nx, nz) - here;
+					if (rise) {
+						const dx = nx - x;
+						const dz = nz - z;
+						chance *= exp(SLOPE * this.slope * Math.max(-1, Math.min(1, rise / Math.sqrt(dx * dx + dz * dz))));
+					}
+				}
+				if (!this.happens(world, hooked ? this.ask(world, m, next, "spread", cell, by, chance) : chance)) continue;
+				this.caught[m].add(next);
+				this.fresh[m].cells.push(next);
+				this.fresh[m].by.push(by);
+				this.fresh[m].lit.push(from);
+				if (burning + ++caught >= max) return caught;
+			}
+		}
+		return caught;
+	}
+	/** Whether a cell of a layer may catch now: as `mayCatch`, and not caught already this tick */
+	catchable(world, styles, road, l, cell) {
+		return !this.caught[l].has(cell) && this.mayCatch(world, styles, road, l, cell);
+	}
+	/** How many more cells may burn now, over the pack's layers (`maxBurning`) */
+	room(world) {
+		return this.maxBurning - (world.states.has(fireState) ? this.burningIn(world.state(fireState)) : 0);
+	}
+	/** Whether any cell of the pack's layers burns now */
+	anyBurning(world) {
+		if (!world.states.has(fireState)) return false;
+		const { burning } = world.state(fireState);
+		for (const layer of this.layers) if (burning[layer]?.cells.length) return true;
+		return false;
+	}
+	/**
+	* The burning cells whose turn to try about them it is this tick (once in `every` a cell, as the fire's own tries:
+	* `turnOf`), still burning and not out this tick, in order of the layers and their cells: each told with who lit its
+	* fire and its heat (its style's `fuel`, less what is wet and falls on it), those with any
+	*/
+	eachTrying(world, visit) {
+		if (!world.states.has(fireState)) return;
+		const state = world.state(fireState);
+		const { tick, terrain } = world;
+		const { width } = terrain;
+		const stride = this.stride(world);
+		const turn = tick % stride;
+		const styles = this.stylesOf(world);
+		const air = this.airOf(world);
+		const lasts = this.lasts === void 0 ? Infinity : Math.max(1, Math.round(this.lasts / world.dt));
+		for (let l = 0; l < this.layers.length; l++) {
+			const fire = state.burning[this.layers[l]];
+			if (!fire) continue;
+			const values = terrain.cells[this.layers[l]];
+			const states = terrain.cells[this.states[l]];
+			const fuel = styles.fuel[l];
+			const { cells, ends, lit, by } = fire;
+			for (let i = 0; i < cells.length; i++) {
+				const cell = cells[i];
+				if (turnOf(cell, stride) !== turn || states?.[cell] !== FOLIAGE_STATE.burning || !values?.[cell]) continue;
+				if (ends[i] <= tick || lit[i] + lasts <= tick) continue;
+				const x = cell % width;
+				const heat = (1 - Math.min(1, this.wet + this.fallsOn(air, x, (cell - x) / width))) * fuel[values[cell]];
+				if (heat > 0) visit(l, cell, by[i], heat);
+			}
+		}
+	}
+	/**
+	* How likely a cell of a layer is to catch at a try of a burning thing standing at `x`, `z` beside it
+	* (`BurningOptions.lightsFoliage`): `FROM_THING` by its style's `flammable`, less what is wet and falls on it, weighed
+	* by the wind (by `weight`: the burning pack's), 1 at the most. 0 where it may not catch now
+	*/
+	chanceFrom(world, l, cell, x, z, weight) {
+		const styles = this.stylesOf(world);
+		if (!this.mayCatch(world, styles, this.roadOf(world), l, cell)) return 0;
+		const { width } = world.terrain;
+		const cx = cell % width;
+		const cz = (cell - cx) / width;
+		const air = this.airOf(world);
+		let chance = FROM_THING * styles.flammable[l][world.terrain.cells[this.layers[l]][cell]] * (1 - Math.min(1, this.wet + this.fallsOn(air, cx, cz)));
+		if (chance > 0 && air.strength && weight) {
+			const dx = cx + .5 - x;
+			const dz = cz + .5 - z;
+			const far = Math.sqrt(dx * dx + dz * dz);
+			if (far > 0) chance *= exp(WIND * weight * air.strength * (dx * air.x + dz * air.z) / far);
+		}
+		return Math.min(1, chance);
+	}
+	/**
+	* Cells found caught from burning things at the burning pack's turn (`BurningOptions.lightsFoliage`; by layer, cell
+	* and who lit the thing, in any order): lit (`burning`), in order of the layers and the cells, each once, those that
+	* may still catch, as many as there is room for (`maxBurning`: the rest do not catch, as a spread's past it). How
+	* many caught
+	*/
+	lightCaught(world, layers, cells, by) {
+		if (!cells.length) return 0;
+		const order = cells.map((_, k) => k).sort((a, b) => layers[a] - layers[b] || cells[a] - cells[b] || a - b);
+		const state = world.state(fireState);
+		const styles = this.stylesOf(world);
+		const road = this.roadOf(world);
+		let room = this.maxBurning - this.burningIn(state);
+		let caught = 0;
+		for (let l = 0; l < this.layers.length && room > 0; l++) {
+			const lit = [];
+			const whose = [];
+			for (const k of order) {
+				if (layers[k] !== l || room <= 0) continue;
+				const cell = cells[k];
+				if (lit.length && lit[lit.length - 1] === cell) continue;
+				if (!this.mayCatch(world, styles, road, l, cell)) continue;
+				lit.push(cell);
+				whose.push(by[k]);
+				room--;
+			}
+			this.light(world, state, l, lit, (k) => whose[k], () => world.tick, "burning");
+			caught += lit.length;
+		}
+		return caught;
+	}
+	/** Who stands in a burning cell is hurt, by whoever lit its fire: units on the ground, once whatever burns there */
+	scorch(world, state) {
+		const { terrain } = world;
+		const { width, depth } = terrain;
+		const amount = this.damage * Math.max(1, Math.round(SCORCH_EVERY / world.dt)) * world.dt;
+		const hurt = [];
+		for (const unit of world.units.values()) {
+			if (!unit.alive || unit.hidden || unit.flying || unit.def.footprint || unit.def.kind !== "unit") continue;
+			const { x, z } = unit.pos;
+			if (x < 0 || z < 0 || x >= width || z >= depth) continue;
+			const cell = Math.floor(z) * width + Math.floor(x);
+			for (let l = 0; l < this.layers.length; l++) {
+				if (terrain.cells[this.states[l]]?.[cell] !== FOLIAGE_STATE.burning) continue;
+				const fire = state.burning[this.layers[l]];
+				const at = fire ? indexIn(fire.cells, cell) : -1;
+				if (at < 0) continue;
+				hurt.push({
+					unit,
+					by: fire.by[at]
+				});
+				break;
+			}
+		}
+		for (const { unit, by } of hurt) {
+			if (!unit.alive) continue;
+			world.damage(unit, amount, by ? world.entities.get(by) : void 0, {
+				damageType: this.damageType,
+				tags: ["fire"],
+				how: "burnt"
+			});
+		}
+	}
+};
+/**
+* Which tick of every `stride` a burning cell tries the cells about it on: of a hash of its index, so that a front's
+* cells take their turns spread over the ticks, and the wait from catching to trying is no shorter one way than another
+*/
+var turnOf = (cell, stride) => (Math.imul(cell, 2654435761) >>> 16) % stride;
+/** The height of a cell's middle: its corners' */
+var cellHeight = (heights, vertsX, x, z) => {
+	const i = z * vertsX + x;
+	return (heights[i] + heights[i + 1] + heights[i + vertsX] + heights[i + vertsX + 1]) / 4;
+};
+/** Where a cell is in a list of cells in order: -1 where it is not */
+function indexIn(cells, cell) {
+	let low = 0;
+	let high = cells.length - 1;
+	while (low <= high) {
+		const middle = low + high >> 1;
+		const at = cells[middle];
+		if (at === cell) return middle;
+		if (at < cell) low = middle + 1;
+		else high = middle - 1;
+	}
+	return -1;
+}
+/** The fire's rules of a world's game: none where it has no foliage pack. `what` names the call that asks, which throws then */
+function fireOf(world, what) {
+	const pack = world.registry.assembly?.rules.packs?.find((each) => each.id === FOLIAGE);
+	if (!pack) throw new Error(`${what}: the game has no foliage pack (foliagePack)`);
+	return pack[FIRE] ??= new FoliageFireRules(pack.options);
+}
+/**
+* The grass's fire of a world's game, for the burning pack's link to it (`BurningOptions.lightsFoliage`,
+* `FoliageFire.lights`): none where it has no foliage pack, or one whose grass never burns
+*
+* @internal
+*/
+function foliageFireOf(world) {
+	const pack = world.registry.assembly?.rules.packs?.find((each) => each.id === FOLIAGE);
+	if (!pack) return void 0;
+	const fire = pack[FIRE] ??= new FoliageFireRules(pack.options);
+	return fire.on ? fire : void 0;
+}
+/** The cells a call is given, as indices: of a shape, the cells whose middle is in it; indices as they are */
+function cellsOf(world, where) {
+	if (Array.isArray(where)) return where;
+	const { width, depth } = world.terrain;
+	const shape = where;
+	const { x0, z0, x1, z1 } = shapeBounds(shape);
+	const cells = [];
+	for (let cz = Math.max(Math.floor(z0), 0); cz < Math.min(Math.ceil(z1), depth); cz++) for (let cx = Math.max(Math.floor(x0), 0); cx < Math.min(Math.ceil(x1), width); cx++) if (inShape(shape, {
+		x: cx + .5,
+		z: cz + .5
+	})) cells.push(cz * width + cx);
+	return cells;
+}
+/**
+* Sets grass alight: the cells there that can burn start burning (`foliageIgnite` is asked of each), and the fire
+* goes on from them. `by`: who lit it, whom its damage is dealt by. A cell catches where its style burns
+* (`flammable` over 0), it stands whole or grows back, and it is not on water, a road (the game's `road` tile), what
+* blocks the way or under a building. Past the most that may burn at once (`FoliageFire.maxBurning`), the rest wait
+* their turn. Returns the cells that caught, in order; none in a game whose grass does not burn (`fire: false`)
+*
+* @beta
+*/
+function ignite(world, layer, where, options = {}) {
+	return fireOf(world, "ignite").ignite(world, layer, cellsOf(world, where), options.by);
+}
+/**
+* Puts out what burns there: the cells stop burning as they are, burnt. Returns the cells put out, in order
+*
+* @beta
+*/
+function extinguish(world, layer, where) {
+	const fire = fireOf(world, "extinguish");
+	const l = fire.indexOf("extinguish", layer);
+	if (!world.states.has(fireState)) return [];
+	const out = fire.quench(world, world.state(fireState), l, new Set(cellsOf(world, where)), FOLIAGE_STATE.burnt);
+	fire.regrowth.ruined(world, l, out);
+	return out;
+}
+/**
+* Cuts grass down to stubble, which fire does not cross: `ruin` with `cut`. What burns there stops burning, cut. A
+* cell burnt already, or cut, is left as it is. Returns the cells cut, in order
+*
+* @beta
+*/
+function firebreak(world, layer, where, options = {}) {
+	return ruinAs(world, "firebreak", layer, where, "cut", options.by);
+}
+/**
+* Puts out every fire of a layer, or of all the pack's layers when none is named: what burns is burnt, what waits its
+* turn is not lit. Returns how many cells were burning
+*
+* @beta
+*/
+function stopFire(world, layer) {
+	const fire = fireOf(world, "stopFire");
+	const which = layer === void 0 ? fire.layers.map((_, l) => l) : [fire.indexOf("stopFire", layer)];
+	if (!world.states.has(fireState)) return 0;
+	const state = world.state(fireState);
+	let count = 0;
+	for (const l of which) {
+		const out = fire.quench(world, state, l, void 0, FOLIAGE_STATE.burnt);
+		fire.regrowth.ruined(world, l, out);
+		count += out.length;
+	}
+	return count;
+}
+/**
+* Ruins grass: cut to stubble (`cut`, state `cut`: a firebreak), crushed flat (`crush`, state `flattened`, as what
+* tramples it does) or scorched black (`scorch`, state `burnt`: nothing left to burn) (`FoliageRuin`). What burns there
+* goes out as it is ruined. It hides nobody and does not burn until it has grown back (`regrow`, or by itself after
+* its style's `regrows` seconds, over its `grows`). A cell is left as it is where it is that already, or burnt (nothing
+* to cut or crush), or cut (nothing to crush). Told (`foliageRuined`), by `by` where it says. Changes the state layer
+* alone: the ways are not weighed again. Returns the cells ruined, in order
+*
+* @beta
+*/
+function ruin(world, layer, where, options) {
+	return ruinAs(world, "ruin", layer, where, options.how, options.by);
+}
+/** What each way of ruining makes a cell (`FOLIAGE_STATE`) */
+var RUINED = {
+	cut: FOLIAGE_STATE.cut,
+	crush: FOLIAGE_STATE.flattened,
+	scorch: FOLIAGE_STATE.burnt
+};
+/** Whether a cell in a state can be ruined so (`ruin`): not where it is that already, nor where nothing is left to cut or crush */
+function ruinable(how, state) {
+	if (state === FOLIAGE_STATE.burnt) return false;
+	if (how === "cut") return state !== FOLIAGE_STATE.cut;
+	if (how === "crush") return state !== FOLIAGE_STATE.flattened && state !== FOLIAGE_STATE.cut;
+	return true;
+}
+/** `ruin`, said as `what` (a call of its own, `firebreak`): the cells ruined, in order */
+function ruinAs(world, what, layer, where, how, by) {
+	const fire = fireOf(world, what);
+	const l = fire.indexOf(what, layer);
+	const to = RUINED[how];
+	if (to === void 0) throw new Error(`${what}: "${how}" is no way to ruin grass (cut, crush, scorch)`);
+	const { cells } = world.terrain;
+	const values = cells[layer];
+	const states = cells[foliageStateLayer(layer)];
+	const ruined = [...new Set(cellsOf(world, where))].filter((cell) => values?.[cell] && ruinable(how, states?.[cell] ?? FOLIAGE_STATE.whole)).sort((a, b) => a - b);
+	if (!ruined.length) return ruined;
+	if (world.states.has(fireState)) fire.quench(world, world.state(fireState), l, new Set(ruined), to);
+	world.setCells(foliageStateLayer(layer), ruined, to);
+	world.events.emit(foliageRuined, {
+		layer,
+		cells: [...ruined],
+		how,
+		...by ? { by: by.id } : {}
+	});
+	fire.regrowth.ruined(world, l, ruined);
+	return ruined;
+}
+/**
+* Has ruined or burnt grass (cut, flattened, burnt) grow back to what it was: over `over` seconds (growing, which
+* hides and burns as whole grass does, and whole at its end), or at once when left out or 0, when grass growing back
+* already stands whole at once too. What it waited for by itself (`regrows`) it waits for no more. Told as it is whole
+* (`foliageRegrown`), by `by` where it says. Returns the cells that started to, in order
+*
+* @beta
+*/
+function regrow(world, layer, where, options = {}) {
+	const fire = fireOf(world, "regrow");
+	const l = fire.indexOf("regrow", layer);
+	const { over = 0, by } = options;
+	if (!(over >= 0) || !Number.isFinite(over)) throw new Error(`regrow: over is seconds, 0 or more (not ${over})`);
+	const cells = [...new Set(cellsOf(world, where))].sort((a, b) => a - b);
+	return fire.regrowth.regrow(world, l, cells, over > 0 ? Math.max(1, Math.round(over / world.dt)) : 0, by?.id ?? 0);
+}
+/**
+* Takes grass away for good: the cells are no style any more (0), and nothing grows back. Returns the cells cleared
+*
+* @beta
+*/
+function clearFoliage(world, layer, where) {
+	return paint(world, "clearFoliage", layer, where, 0);
+}
+/** The game a world is of, as `foliageStyle` reads it: its layers of cells as laid (its data and the map's over the code), its packs */
+var gameOf = (world) => ({
+	cellLayers: world.registry.cellLayers,
+	packs: world.registry.assembly?.rules.packs
+});
+/** Paints a layer's cells with a value, checked, and its state whole there again: the cells that changed, in order */
+function paint(world, what, layer, where, value) {
+	const def = world.registry.cellLayers.find((each) => each.id === layer);
+	if (!def) throw new Error(`${what}: the game has no layer of cells "${layer}" (Rules.cellLayers)`);
+	const values = def.values?.map((each) => each.value) ?? [1];
+	if (value !== 0 && !values.includes(value)) throw new Error(`${what}: ${value} is no style of the layer "${layer}" (${values.join(", ")}, or 0 for none)`);
+	const fire = world.states.has(fireState) ? foliageFireOf(world) : void 0;
+	const l = fire ? fire.layers.indexOf(layer) : -1;
+	if (fire && l >= 0) fire.quench(world, world.state(fireState), l, new Set(cellsOf(world, where)), void 0);
+	const changed = world.setCells(layer, where, value);
+	const state = foliageStateLayer(layer);
+	const whole = world.terrain.cells[state] ? world.setCells(state, where, FOLIAGE_STATE.whole) : [];
+	if (!whole.length) return changed.sort((a, b) => a - b);
+	return [.../* @__PURE__ */ new Set([...changed, ...whole])].sort((a, b) => a - b);
+}
+/**
+* Paints grass of a style: `world.setCells` on the layer, checked (a value the layer has a style for, or 0), the
+* cells whole again. Returns the cells that changed
+*
+* @beta
+*/
+function setFoliage(world, layer, where, value) {
+	return paint(world, "setFoliage", layer, where, value);
+}
+/**
+* The grass at a point as the rules know it (`FoliageCell`): its style, what happened to it, whether it burns. None
+* where no grass is, or off the map
+*
+* @beta
+*/
+function foliageAt(world, layer, x, z) {
+	const { terrain } = world;
+	if (!(x >= 0 && z >= 0 && x < terrain.width && z < terrain.depth)) return void 0;
+	const cell = Math.floor(z) * terrain.width + Math.floor(x);
+	const value = terrain.cells[layer]?.[cell] ?? 0;
+	if (!value) return void 0;
+	const state = foliageStateOf(terrain.cells[foliageStateLayer(layer)]?.[cell] ?? FOLIAGE_STATE.whole);
+	const found = {
+		cell,
+		value,
+		style: foliageStyle(gameOf(world), layer, value),
+		state,
+		burning: state === "burning",
+		left: 0
+	};
+	const fire = state === "burning" && world.states.has(fireState) ? world.state(fireState).burning[layer] : void 0;
+	const at = fire ? indexIn(fire.cells, cell) : -1;
+	if (at < 0) return found;
+	const rules = fireOf(world, "foliageAt");
+	const lasts = rules.lasts === void 0 ? Infinity : fire.lit[at] + Math.max(1, Math.round(rules.lasts / world.dt));
+	found.left = Math.max(0, Math.min(fire.ends[at], lasts) - world.tick) * world.dt;
+	if (fire.by[at]) found.by = fire.by[at];
+	return found;
+}
+/** What `burningCells` gives where nothing burns */
+var NONE = Object.freeze([]);
+/**
+* The cells of a layer that burn now, in order of their indices: for a game's rules and its computer players. Not to
+* be kept or changed: the pack's own list. None in a game whose grass does not burn
+*
+* @beta
+*/
+function burningCells(world, layer) {
+	fireOf(world, "burningCells").indexOf("burningCells", layer);
+	return world.states.has(fireState) && world.state(fireState).burning[layer]?.cells || NONE;
+}
+/** The cells an effect's area takes in (`effectArea`): those whose middle is in it */
+function cellsInArea(world, area) {
+	const { width, depth } = world.terrain;
+	const reach = areaReach(area);
+	const cells = [];
+	for (let cz = Math.max(Math.floor(area.z - reach), 0); cz < Math.min(Math.ceil(area.z + reach), depth); cz++) for (let cx = Math.max(Math.floor(area.x - reach), 0); cx < Math.min(Math.ceil(area.x + reach), width); cx++) if (inArea(area, {
+		x: cx + .5,
+		z: cz + .5
+	})) cells.push(cz * width + cx);
+	return cells;
+}
+/**
+* The `foliage` effect (`EffectTypes.foliage`): does to the grass where it lands what its `act` says, by the caster.
+* Over its area (`radius`, `shape`), or the cell it landed on; on its `layer`, or every layer of the pack
+*/
+var foliageEffect = /* @__PURE__ */ defineEffect({
+	type: "foliage",
+	run(context, effect) {
+		const { world, caster, point } = context;
+		const area = effectArea(context, effect);
+		const { width, depth } = world.terrain;
+		const cells = area ? cellsInArea(world, area) : point.x >= 0 && point.z >= 0 && point.x < width && point.z < depth ? [Math.floor(point.z) * width + Math.floor(point.x)] : [];
+		if (!cells.length) return;
+		for (const layer of effect.layer !== void 0 ? [effect.layer] : fireOf(world, "foliage effect").layers) if (effect.act === "ignite") ignite(world, layer, cells, { by: caster });
+		else if (effect.act === "extinguish") extinguish(world, layer, cells);
+		else if (effect.act === "ruin") ruin(world, layer, cells, {
+			how: effect.how ?? "cut",
+			by: caster
+		});
+		else if (effect.act === "regrow") regrow(world, layer, cells, {
+			...effect.over !== void 0 ? { over: effect.over } : {},
+			by: caster
+		});
+		else if (effect.act === "clear") clearFoliage(world, layer, cells);
+	},
+	fields: [
+		{
+			path: "act",
+			kind: "choice",
+			options: [
+				"ignite",
+				"extinguish",
+				"ruin",
+				"regrow",
+				"clear"
+			],
+			hint: "What it does to the grass where it lands: sets it alight, puts it out, ruins it, has it grow back, or takes it away"
+		},
+		{
+			path: "layer",
+			kind: "text",
+			hint: "The layer of grass it does it to: every layer of the foliage pack when left out"
+		},
+		{
+			path: "how",
+			kind: "choice",
+			options: [
+				"cut",
+				"crush",
+				"scorch"
+			],
+			hint: "How it ruins: cut when left out"
+		},
+		{
+			path: "over",
+			kind: "number",
+			min: 0,
+			hint: "Seconds what it has grow back takes to: at once when left out"
+		}
+	]
+});
+/**
+* A gust of wind at a place, on the screen of every player who sees it (`WindGust`): the grass bends to it there (a
+* ring outwards as it spreads, or a push one way where it says `around`), as `client.gust` bends it on one screen. A
+* player is told where their team sees its middle or any of its edge; an observer always. Nothing it does decides
+* anything: it is not in the world's state or a save, and it changes nothing of the world
+*
+* @beta
+*/
+function gust(world, at, gust) {
+	const { radius, strength, around, lasts } = gust;
+	if (!(radius > 0) || !Number.isFinite(radius)) throw new Error(`gust: a radius over 0 (not ${radius})`);
+	if (!(strength >= 0) || !Number.isFinite(strength)) throw new Error(`gust: a strength of 0 or more (not ${strength})`);
+	if (around !== void 0 && !Number.isFinite(around)) throw new Error(`gust: around in degrees (not ${around})`);
+	if (lasts !== void 0 && !(lasts > 0 && Number.isFinite(lasts))) throw new Error(`gust: lasts over 0 seconds (not ${lasts})`);
+	if (!Number.isFinite(at.x) || !Number.isFinite(at.z)) throw new Error(`gust: a place on the map (not ${at.x}, ${at.z})`);
+	world.events.emit(gusted, {
+		x: at.x,
+		z: at.z,
+		gust: {
+			radius,
+			strength,
+			...around !== void 0 && { around },
+			...lasts !== void 0 && { lasts }
+		}
+	});
+}
+/** The places of a gust a team must see one of to be told of it: its middle and four points of its edge */
+var GUST_EDGE = [
+	[0, 0],
+	[1, 0],
+	[-1, 0],
+	[0, 1],
+	[0, -1]
+];
+/** A gust of wind (`gust`): to each player whose team sees its middle or its edge, as a `gust` message */
+var toldGust = replicateEvent(gusted, "gust", ({ x, z, gust }, view) => {
+	const { radius } = gust;
+	if (!GUST_EDGE.some(([dx, dz]) => view.sees(x + dx * radius, z + dz * radius))) return void 0;
+	const round = (value) => Math.round(value * 100) / 100;
+	return {
+		type: "gust",
+		x: Math.round(x * 10) / 10,
+		z: Math.round(z * 10) / 10,
+		radius: round(radius),
+		strength: round(gust.strength),
+		...gust.around !== void 0 && { around: round(gust.around) },
+		...gust.lasts !== void 0 && { lasts: round(gust.lasts) }
+	};
+});
+//#endregion
+export { FOLIAGE, FOLIAGE_STATE, FoliageFireRules, burningCells, clearFoliage, extinguish, firebreak, foliageAt, foliageBurnt, foliageFireOf, foliageFireOut, foliageIgnite, foliageIgnited, foliageLayerOfState, foliageLayers, foliagePack, foliageRegrown, foliageRuined, foliageStateLayer, foliageStateOf, foliageStyle, foliageStyleProblem, gust, ignite, regrow, ruin, setFoliage, stopFire, toldGust };
+
+//# sourceMappingURL=foliage.js.map