@v12-engine/engine 0.1.1 → 0.4.0

package/dist/burning.js

@@ -0,0 +1,795 @@
+import { cos, exp, sin } from "./exactMath.js";
+import { defineComponent } from "./components.js";
+import { defineEvent } from "./events.js";
+import { deposit, edgeDistance } from "./entity.js";
+import { defineHook, defineHookType } from "./hooks.js";
+import { areaReach, effectArea, inArea } from "./abilities/shapes.js";
+import { defineEffect, effectFilter } from "./abilities/effects.js";
+import { mapInfo } from "./names.js";
+import { foliageFireOf } from "./foliage.js";
+//#region src/burning.ts
+/**
+* The burning pack's id (`burningPack`), for `hasPack`
+*
+* @beta
+*/
+var BURNING = "burning";
+/**
+* Asked before a thing catches fire (`BurnStart`): a handler refuses it or changes its chance. Once for every try:
+* of a call, a spread, or grass burning beside it; so a handler does little
+*
+* @beta
+*/
+var burnStart = /* @__PURE__ */ defineHookType({ id: "burning.start" });
+/**
+* Something caught fire: how, who lit the fire it is of, what kind of burning it is. What a game's rules and its computer
+* players hear; the screens are told by what burns (`onFire`)
+*
+* @beta
+*/
+var burnStarted = defineEvent({ id: "burning.started" });
+/**
+* Something burnt down: what kind of burning it was, who lit it, and what it left where it stood (`BurnsDef.leaves`), where
+* it left a thing
+*
+* @beta
+*/
+var burnt = defineEvent({ id: "burning.burnt" });
+/**
+* Something that burnt was put out (`putOut`, an ability): it stands, charred as far as it burnt
+*
+* @beta
+*/
+var burnPutOut = defineEvent({ id: "burning.putOut" });
+/**
+* What burns or burnt and was put out, on the thing itself (`FireShown`): told to everyone who sees it as it is (no
+* part of it one player's, so that what a team remembers of a tree is the same for each of them), kept by a save.
+* `snapshotOf(entity.state, onFire)` on a screen; `isBurning` and `burningOf` in the rules
+*
+* @beta
+*/
+var onFire = /* @__PURE__ */ defineComponent({
+	id: "burning",
+	replicate: "everyone",
+	same: (a, b) => a.how === b.how && a.since === b.since && a.ends === b.ends && a.out === b.out
+});
+/** What burns in a world (`FireList`), kept by a save */
+var fireList = /* @__PURE__ */ defineComponent({
+	id: "burning.list",
+	default: () => ({
+		ids: [],
+		by: [],
+		ends: []
+	})
+});
+/** How much a gale makes a try downwind likelier (`BurningSpread.wind` 1, the wind's strength 1: e² ≈ 7.4 times), and upwind less */
+var WIND = 2;
+/** How often a burning thing that tries nothing is looked at, to see it still stands, in seconds */
+var LOOK_EVERY = 1;
+/** How often who stands by a burning thing is hurt (`BurningOptions.damage`), in seconds */
+var SCORCH_EVERY = .5;
+/**
+* How likely a burning cell of grass is to light a thing that burns on it or beside it at one of its tries (four a
+* second, `FoliageFire.every`, `FoliageFire.lights`): of grass of `fuel` 1, in still air and dry. A tree a front
+* reaches, three or four cells about it burning, catches in a second or two, seldom in the first tick
+*/
+var FROM_GRASS = .05;
+/** Where the pack keeps its rules, on the pack, for the calls made on a world of its game */
+var RULES = Symbol("burning rules");
+/**
+* The pack's rules: its settings, and what a tick and the calls do with a world's `fireList` and `onFire`. One a pack,
+* for every world of its game: what it keeps of a world is scratch, emptied as each call ends
+*/
+var BurningRules = class {
+	/** What burns, as the pack was told, before its type is asked */
+	decides;
+	/** The defaults of `BurnsDef` */
+	base;
+	/** Whether fire passes from one thing to the next, and how: none for never */
+	spread;
+	/** Damage a second to who stands by */
+	damage;
+	/** How far that reaches */
+	damageReach;
+	/** The type it is dealt as */
+	damageType;
+	/** The most that burns at once */
+	maxBurning;
+	/** Whether what burns tries the grass about it: the layers named, or every layer of the foliage pack (`true`) */
+	lightsFoliage;
+	/** The system that runs it */
+	system;
+	/** The air as last worked out (`airOf`) */
+	air;
+	/** How each type burns where the game decides nothing in code, by its definition: null for one that does not */
+	typed = /* @__PURE__ */ new WeakMap();
+	/** Scratch of a call: what a search found */
+	found = [];
+	/** Scratch of a call: what of it may catch, or be hurt, in order of their ids */
+	near = [];
+	/** Scratch of a tick: what caught in it, how, and who lit the fire it caught from */
+	fresh = [];
+	/** Scratch of a tick: the cells of grass that caught from what burns in it (`lightsFoliage`), by layer, cell and whose */
+	grassCaught = {
+		layers: [],
+		cells: [],
+		by: [],
+		keys: /* @__PURE__ */ new Set()
+	};
+	/** The link to the grass of each game seen, by its packs: none where neither way is on, or the game has no grass that burns */
+	links = /* @__PURE__ */ new WeakMap();
+	/** Scratch of a tick: who is hurt in it, and by whom */
+	hurt = [];
+	/** The thing being burnt down right now: its death is given its `how` (the `death` hook) */
+	ending;
+	constructor(options) {
+		this.decides = options.burns;
+		this.base = {
+			seconds: Math.max(0, options.seconds ?? 20),
+			leaves: options.leaves ?? "felled",
+			wood: options.wood ?? false,
+			how: options.how ?? "burnt"
+		};
+		const spread = options.spread === true ? {} : options.spread || void 0;
+		this.spread = spread && {
+			reach: Math.max(0, spread.reach ?? 1.5),
+			chance: Math.min(1, Math.max(0, spread.chance ?? .15)),
+			wind: Math.max(0, spread.wind ?? 1),
+			every: Math.max(0, spread.every ?? 1)
+		};
+		this.damage = Math.max(0, options.damage ?? 0);
+		this.damageReach = Math.max(0, options.damageReach ?? 1);
+		this.damageType = options.damageType ?? "magic";
+		this.maxBurning = Math.max(0, Math.floor(options.maxBurning ?? 2e3));
+		this.lightsFoliage = options.lightsFoliage ?? false;
+		this.system = {
+			name: "burning",
+			phase: "resolve",
+			update: (world) => {
+				const list = world.states.has(fireList) ? world.state(fireList) : void 0;
+				const grass = this.linkOf(world);
+				if (list?.ids.length || grass?.fromGrass && grass.fire.anyBurning(world)) this.tick(world, list, grass);
+			}
+		};
+	}
+	/** The link to the grass of a world's game (`GrassLink`): none where neither way is on or it has no grass that burns */
+	linkOf(world) {
+		const packs = world.registry.assembly?.rules.packs;
+		if (!packs) return void 0;
+		let link = this.links.get(packs);
+		if (link === void 0) {
+			const fire = foliageFireOf(world);
+			const lights = this.lightsFoliage;
+			const toGrass = !fire ? [] : fire.layers.flatMap((layer, l) => lights === true || Array.isArray(lights) && lights.includes(layer) ? [l] : []);
+			link = fire && (fire.lights || toGrass.length) ? {
+				fire,
+				toGrass,
+				fromGrass: fire.lights
+			} : null;
+			this.links.set(packs, link);
+		}
+		return link ?? void 0;
+	}
+	/** How a thing burns (`Burns`): none for what does not */
+	burnsOf(world, entity) {
+		const decided = this.decides?.(world, entity);
+		if (decided === void 0) {
+			let typed = this.typed.get(entity.def);
+			if (typed === void 0) this.typed.set(entity.def, typed = this.burnsBy(entity, void 0) ?? null);
+			return typed ?? void 0;
+		}
+		return this.burnsBy(entity, decided);
+	}
+	/** How a thing burns, as the game decided in code (`decided`) over its type, over the pack */
+	burnsBy(entity, decided) {
+		const own = decided ?? entity.def.burns ?? (entity.def.fellable ? true : void 0);
+		if (!own) return void 0;
+		const def = entity.def.burns;
+		const typed = typeof def === "object" ? def : void 0;
+		const said = typeof own === "object" ? own : void 0;
+		return {
+			seconds: Math.max(0, said?.seconds ?? typed?.seconds ?? this.base.seconds),
+			leaves: said?.leaves ?? typed?.leaves ?? this.base.leaves,
+			wood: said?.wood ?? typed?.wood ?? this.base.wood,
+			how: said?.how ?? typed?.how ?? this.base.how
+		};
+	}
+	/** The air over the map now (`Air`), worked out again as the map's environment changes */
+	airOf(world) {
+		const environment = world.state(mapInfo).environment;
+		if (this.air && this.air.of === environment) return this.air;
+		const wind = environment?.wind;
+		const strength = Math.min(1, Math.max(0, wind?.strength ?? 0));
+		const turn = (wind?.around ?? 0) % 360 * Math.PI / 180;
+		return this.air = {
+			of: environment,
+			strength,
+			x: strength ? sin(turn) : 0,
+			z: strength ? -cos(turn) : 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;
+	}
+	/** How many ticks a stretch of seconds is: at least one */
+	ticks(world, seconds) {
+		return Math.max(1, Math.round(seconds / world.dt));
+	}
+	/**
+	* Sets a thing alight, as `setAlight` says: asked of the game (`burnStart`) at `chance`, once, rolled where it is not
+	* sure, under the most that may burn; started (`start`). Whether it caught
+	*/
+	light(world, entity, cause, by, from, chance, options = {}) {
+		if (!entity.alive || isBurning(entity)) return false;
+		const burns = this.burnsOf(world, entity);
+		if (!burns) return false;
+		if (world.states.has(fireList) && world.state(fireList).ids.length >= this.maxBurning) return false;
+		if (world.hooks.has(burnStart)) {
+			const asked = world.hooks.run(burnStart, {
+				entity,
+				cause,
+				...from ? { from } : {},
+				...by ? { by: world.entities.get(by) } : {},
+				how: options.how ?? burns.how,
+				chance,
+				cancelled: false
+			});
+			if (asked.cancelled) return false;
+			chance = held(asked.chance);
+		}
+		if (!this.happens(world, chance)) return false;
+		return this.start(world, entity, cause, by, options);
+	}
+	/**
+	* A thing catches, asked and rolled already (by `light`, or at a try of a spread or of the grass): set burning for
+	* its time, under the most that may burn, and told (`burnStarted`). Into the list first, then marked (`onFire`):
+	* what is marked is never outside the list, whatever throws (one listed and not marked is dropped at its next
+	* turn). Whether it caught
+	*/
+	start(world, entity, cause, by, options = {}) {
+		if (!entity.alive || isBurning(entity)) return false;
+		const burns = this.burnsOf(world, entity);
+		if (!burns) return false;
+		const list = world.state(fireList);
+		if (list.ids.length >= this.maxBurning) return false;
+		const how = options.how ?? burns.how;
+		const { tick } = world;
+		const length = this.ticks(world, options.seconds ?? burns.seconds);
+		const was = entity.get(onFire);
+		const done = was?.out !== void 0 && was.ends > was.since ? Math.min(1, (was.out - was.since) / (was.ends - was.since)) : 0;
+		const since = tick - Math.round(done * length);
+		const ends = Math.max(tick + 1, since + length);
+		insertId(list, entity.id, by, ends);
+		entity.set(onFire, {
+			how,
+			since,
+			ends
+		});
+		world.events.emit(burnStarted, {
+			entity: entity.id,
+			cause,
+			how,
+			...by ? { by } : {}
+		});
+		return true;
+	}
+	/** Puts out a thing that burns: it stands, charred as far as it burnt. Whether it burnt */
+	putOut(world, entity) {
+		const state = entity.get(onFire);
+		if (!state || state.out !== void 0) return false;
+		entity.set(onFire, {
+			...state,
+			out: world.tick
+		});
+		if (world.states.has(fireList)) removeId(world.state(fireList), entity.id);
+		world.events.emit(burnPutOut, { entity: entity.id });
+		return true;
+	}
+	/**
+	* A tick: what burns out burns down, what tries its neighbours this tick tries them (things, and the grass about it
+	* once a second where the pack says), burning grass whose turn it is tries what stands beside it
+	* (`FoliageFire.lights`), who stands by is hurt. What caught is set alight at the end, in order (things by their
+	* ids, cells by layer and index), and tries nothing this tick: nothing lights within what lit it
+	*/
+	tick(world, list, grass) {
+		const { tick } = world;
+		const spread = this.spread;
+		const stride = spread ? this.ticks(world, spread.every) : 1;
+		const look = this.ticks(world, LOOK_EVERY);
+		const tries = !!spread && spread.chance > 0;
+		const scorch = this.ticks(world, SCORCH_EVERY);
+		const toGrass = grass?.toGrass.length ? grass : void 0;
+		const fresh = this.fresh;
+		const hurt = this.hurt;
+		const caught = this.grassCaught;
+		fresh.length = 0;
+		hurt.length = 0;
+		caught.layers.length = caught.cells.length = caught.by.length = 0;
+		caught.keys.clear();
+		let out;
+		if (list?.ids.length) {
+			const { ids, by, ends } = list;
+			let kept = 0;
+			for (let i = 0; i < ids.length; i++) {
+				const id = ids[i];
+				const whose = by[i];
+				const end = ends[i];
+				const trying = tries && turnOf(id, stride) === tick % stride;
+				const looking = turnOf(id, look) === tick % look;
+				if (end > tick && !trying && !looking) {
+					ids[kept] = id;
+					by[kept] = whose;
+					ends[kept++] = end;
+					continue;
+				}
+				const entity = world.entities.get(id);
+				const state = entity?.get(onFire);
+				if (!entity || !entity.alive || !state || state.out !== void 0) continue;
+				if (end <= tick) {
+					(out ??= []).push({
+						entity,
+						by: whose
+					});
+					continue;
+				}
+				ids[kept] = id;
+				by[kept] = whose;
+				ends[kept++] = end;
+				if (trying && ids.length + fresh.length < this.maxBurning) this.tryAround(world, entity, whose, spread);
+				if (toGrass && looking) this.tryGrass(world, entity, whose, toGrass);
+			}
+			ids.length = kept;
+			by.length = kept;
+			ends.length = kept;
+			if (this.damage && ids.length) this.scorch(world, list, scorch);
+		}
+		if (grass?.fromGrass) this.fromGrass(world, grass.fire, list?.ids.length ?? 0);
+		if (fresh.length) {
+			fresh.sort((a, b) => a.entity.id - b.entity.id);
+			let last = -1;
+			for (const each of fresh) {
+				if (each.entity.id === last) continue;
+				last = each.entity.id;
+				this.start(world, each.entity, each.cause, each.by);
+			}
+			fresh.length = 0;
+		}
+		if (caught.cells.length) {
+			grass.fire.lightCaught(world, caught.layers, caught.cells, caught.by);
+			caught.layers.length = caught.cells.length = caught.by.length = 0;
+			caught.keys.clear();
+		}
+		if (hurt.length) {
+			const amount = this.damage * scorch * world.dt;
+			hurt.sort((a, b) => a.unit.id - b.unit.id);
+			let last = -1;
+			for (const each of hurt) {
+				const { unit } = each;
+				if (unit.id === last || !unit.alive) continue;
+				last = unit.id;
+				world.damage(unit, amount, each.by ? world.entities.get(each.by) : void 0, {
+					damageType: this.damageType,
+					tags: ["fire"],
+					how: "burnt"
+				});
+			}
+			hurt.length = 0;
+		}
+		if (out) for (const each of out) this.burnDown(world, each.entity, each.by);
+	}
+	/**
+	* A burning thing's try at what burns within its reach (`BurningSpread`): each by the spread's chance, likelier
+	* downwind and less upwind, asked of the game (`burnStart`, once a try) and rolled in order of their ids. Into the
+	* tick's fresh
+	*/
+	tryAround(world, entity, by, spread) {
+		const near = this.near;
+		near.length = 0;
+		const { x, z } = entity.pos;
+		for (const other of world.spatial.queryStatic(x, z, spread.reach + entity.def.radius, this.found)) if (other !== entity && other.alive && !other.hidden && !isBurning(other)) near.push(other);
+		if (!near.length) return;
+		near.sort((a, b) => a.id - b.id);
+		const air = this.airOf(world);
+		const hooked = world.hooks.has(burnStart);
+		for (const other of near) {
+			if (edgeDistance(entity, other) > spread.reach) continue;
+			const burns = this.burnsOf(world, other);
+			if (!burns) continue;
+			let chance = spread.chance;
+			if (air.strength && spread.wind) {
+				const dx = other.pos.x - x;
+				const dz = other.pos.z - z;
+				const far = Math.sqrt(dx * dx + dz * dz);
+				if (far > 0) chance *= exp(WIND * spread.wind * air.strength * (dx * air.x + dz * air.z) / far);
+			}
+			chance = Math.min(1, chance);
+			if (hooked) {
+				const asked = world.hooks.run(burnStart, {
+					entity: other,
+					cause: "spread",
+					from: entity,
+					...by ? { by: world.entities.get(by) } : {},
+					how: burns.how,
+					chance,
+					cancelled: false
+				});
+				if (asked.cancelled) continue;
+				chance = held(asked.chance);
+			}
+			if (this.happens(world, chance)) this.fresh.push({
+				entity: other,
+				by,
+				cause: "spread"
+			});
+		}
+		near.length = 0;
+	}
+	/**
+	* A burning thing's try at the grass under it and one cell round (`lightsFoliage`), once a second: each cell of the
+	* layers it lights that may catch, by the grass's chance (`FoliageFireRules.chanceFrom`: its style, the wet, the
+	* wind by this pack's `wind`), asked of the game (`foliageIgnite`, `burning`, once a try) and rolled, in order of
+	* the layers and the cells. Into the tick's grass caught, as many as the grass has room for
+	*/
+	tryGrass(world, entity, by, link) {
+		const { fire, toGrass } = link;
+		const caught = this.grassCaught;
+		let room = fire.room(world) - caught.cells.length;
+		if (room <= 0) return;
+		const { width, depth } = world.terrain;
+		const size = width * depth;
+		const { x, z, hw, hd } = entity.rect;
+		const weight = this.spread?.wind ?? 1;
+		for (const l of toGrass) for (let cz = Math.max(Math.floor(z - hd) - 1, 0); cz <= Math.min(Math.ceil(z + hd), depth - 1); cz++) for (let cx = Math.max(Math.floor(x - hw) - 1, 0); cx <= Math.min(Math.ceil(x + hw), width - 1); cx++) {
+			const cell = cz * width + cx;
+			const key = l * size + cell;
+			if (caught.keys.has(key)) continue;
+			const chance = fire.chanceFrom(world, l, cell, entity.pos.x, entity.pos.z, weight);
+			if (!(chance > 0) || !this.happens(world, fire.ask(world, l, cell, "burning", void 0, by, chance, entity))) continue;
+			caught.keys.add(key);
+			caught.layers.push(l);
+			caught.cells.push(cell);
+			caught.by.push(by);
+			if (--room <= 0) return;
+		}
+	}
+	/**
+	* The burning grass whose turn it is this tick (`FoliageFire.every`), at what burns and stands on its cell or one
+	* next to it (`FoliageFire.lights`): each by `FROM_GRASS` and the cell's heat, likelier downwind (by the grass's
+	* `wind`), asked of the game (`burnStart`, `foliage`, once a try) and rolled, cell by cell in order and what stands
+	* by each in order of their ids. Into the tick's fresh, under the most that may burn
+	*/
+	fromGrass(world, fire, burning) {
+		if (burning + this.fresh.length >= this.maxBurning) return;
+		const { width } = world.terrain;
+		const { grid } = world;
+		const air = this.airOf(world);
+		const weight = fire.wind;
+		const hooked = world.hooks.has(burnStart);
+		const near = this.near;
+		fire.eachTrying(world, (l, cell, by, heat) => {
+			if (burning + this.fresh.length >= this.maxBurning) return;
+			const cx = cell % width;
+			const cz = (cell - cx) / width;
+			const x = cx + .5;
+			const z = cz + .5;
+			near.length = 0;
+			for (let dz = -1; dz <= 1; dz++) for (let dx = -1; dx <= 1; dx++) {
+				const id = grid.occupantAt(cx + dx, cz + dz);
+				if (id <= 0 || near.some((each) => each.id === id)) continue;
+				const other = world.entities.get(id);
+				if (other && other.alive && !other.hidden && !isBurning(other)) near.push(other);
+			}
+			if (!near.length) return;
+			near.sort((a, b) => a.id - b.id);
+			for (const other of near) {
+				const burns = this.burnsOf(world, other);
+				if (!burns) continue;
+				let chance = FROM_GRASS * heat;
+				if (air.strength && weight) {
+					const dx = other.pos.x - x;
+					const dz = other.pos.z - 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);
+				}
+				chance = Math.min(1, chance);
+				if (hooked) {
+					const asked = world.hooks.run(burnStart, {
+						entity: other,
+						cause: "foliage",
+						layer: fire.layers[l],
+						cell,
+						...by ? { by: world.entities.get(by) } : {},
+						how: burns.how,
+						chance,
+						cancelled: false
+					});
+					if (asked.cancelled) continue;
+					chance = held(asked.chance);
+				}
+				if (this.happens(world, chance)) this.fresh.push({
+					entity: other,
+					by,
+					cause: "foliage"
+				});
+			}
+			near.length = 0;
+		});
+	}
+	/**
+	* Who stands by what burns, into the tick's hurt: units on the ground, each on its turn (once in `stride` ticks, by a
+	* hash of its id), looked at for something burning within `damageReach` of it; hurt once, by whoever lit the first
+	* of those in order of their ids. Done from the units, of which there are fewer than trees in a forest fire
+	*/
+	scorch(world, list, stride) {
+		const turn = world.tick % stride;
+		const reach = this.damageReach;
+		for (const unit of world.units.values()) {
+			if (turnOf(unit.id, stride) !== turn) continue;
+			if (!unit.alive || unit.hidden || unit.flying || unit.def.kind !== "unit" || unit.def.footprint) continue;
+			let first;
+			for (const thing of world.spatial.queryStatic(unit.pos.x, unit.pos.z, reach + unit.def.radius, this.found)) {
+				if (thing === unit || !isBurning(thing) || first && first.id < thing.id || edgeDistance(thing, unit) > reach) continue;
+				first = thing;
+			}
+			if (!first) continue;
+			const at = placeOf(list.ids, first.id);
+			this.hurt.push({
+				unit,
+				by: list.ids[at] === first.id ? list.by[at] : 0
+			});
+		}
+	}
+	/**
+	* A thing burnt down: told (`burnt`), killed as its `leaves` says (`felled`, or `burnt`, its death's `how` the kind of
+	* burning), and what it leaves put down where it stood, with its wood where it keeps it
+	*/
+	burnDown(world, entity, whose) {
+		const state = entity.get(onFire);
+		if (!entity.alive || !state) return;
+		const burns = this.burnsOf(world, entity) ?? this.base;
+		const by = whose ? world.entities.get(whose) : void 0;
+		const at = {
+			x: entity.pos.x,
+			z: entity.pos.z
+		};
+		const { owner } = entity;
+		const wood = entity.get(deposit)?.amount;
+		const leaves = burns.leaves;
+		this.ending = {
+			entity,
+			how: state.how
+		};
+		try {
+			world.kill(entity, by, false, leaves === "felled" ? "felled" : "burnt");
+		} finally {
+			this.ending = void 0;
+		}
+		let left;
+		if (leaves !== "felled" && leaves !== "nothing" && world.registry.units.has(leaves)) {
+			left = world.spawn(leaves, owner, at);
+			const holds = left.get(deposit);
+			if (burns.wood && holds && wood !== void 0) holds.amount = wood;
+		}
+		world.events.emit(burnt, {
+			entity: entity.id,
+			how: state.how,
+			...whose ? { by: whose } : {},
+			...left ? { left: left.id } : {}
+		});
+	}
+};
+/** A chance a handler of `burnStart` left, held to 0 to 1 */
+var held = (chance) => Math.min(1, Math.max(0, chance || 0));
+/**
+* Which tick of every `stride` a burning thing tries those about it on: of a hash of its id, so that a forest's trees
+* take their turns spread over the ticks
+*/
+var turnOf = (id, stride) => (Math.imul(id, 2654435761) >>> 16) % stride;
+/** Where an id is, or would go, in a list of ids in order */
+function placeOf(ids, id) {
+	let low = 0;
+	let high = ids.length;
+	while (low < high) {
+		const middle = low + high >> 1;
+		if (ids[middle] < id) low = middle + 1;
+		else high = middle;
+	}
+	return low;
+}
+/** A thing put into what burns, in order of the ids, once, with who lit it and when it burns down */
+function insertId(list, id, by, ends) {
+	const at = placeOf(list.ids, id);
+	if (list.ids[at] === id) return;
+	list.ids.splice(at, 0, id);
+	list.by.splice(at, 0, by);
+	list.ends.splice(at, 0, ends);
+}
+/** A thing taken out of what burns, where it is there */
+function removeId(list, id) {
+	const at = placeOf(list.ids, id);
+	if (list.ids[at] !== id) return;
+	list.ids.splice(at, 1);
+	list.by.splice(at, 1);
+	list.ends.splice(at, 1);
+}
+/** The pack's rules of a world's game: none where it has no burning pack. `what` names the call that asks, which throws then */
+function rulesOf(world, what) {
+	const pack = world.registry.assembly?.rules.packs?.find((each) => each.id === BURNING);
+	if (!pack) throw new Error(`${what}: the game has no burning pack (burningPack)`);
+	return pack[RULES] ??= new BurningRules(pack.options);
+}
+/** The pack's rules of a world's game, where it has the pack */
+function rulesIfAny(world) {
+	const pack = world.registry.assembly?.rules.packs?.find((each) => each.id === BURNING);
+	return pack && (pack[RULES] ??= new BurningRules(pack.options));
+}
+/**
+* Sets a thing alight: it burns for its time (`BurnsDef.seconds`), then burns down and leaves what it leaves
+* (`BurnsDef.leaves`). `by`: who lit it, whom its damage and its kill are by; `how`: another kind of burning than its
+* own; `seconds`: another time. The game is asked first (`burnStart`). One that burns already, does not burn, or is
+* past the most that may burn at once (`BurningOptions.maxBurning`) does not catch. One put out before goes on from
+* as far as it had burnt. Whether it caught
+*
+* @beta
+*/
+function setAlight(world, entity, options = {}) {
+	const { by, ...rest } = options;
+	return rulesOf(world, "setAlight").light(world, entity, "light", by?.id ?? 0, void 0, 1, rest);
+}
+/**
+* Puts out a thing that burns: it stands, charred as far as it burnt, and may be set alight again. Whether it burnt
+*
+* @beta
+*/
+function putOut(world, entity) {
+	return rulesOf(world, "putOut").putOut(world, entity);
+}
+/**
+* Whether a thing burns now: not one put out, nor one burnt down (or killed by other means while it burnt)
+*
+* @beta
+*/
+function isBurning(entity) {
+	if (!entity.alive) return false;
+	const state = entity.get(onFire);
+	return !!state && state.out === void 0;
+}
+/**
+* What the rules know of a thing that burns or burnt (`BurningInfo`): none for one that never caught
+*
+* @beta
+*/
+function burningOf(world, entity) {
+	const state = entity.get(onFire);
+	if (!state) return void 0;
+	const now = state.out ?? world.tick;
+	const length = Math.max(1, state.ends - state.since);
+	const burning = isBurning(entity);
+	const info = {
+		burning,
+		how: state.how,
+		share: Math.min(1, Math.max(0, (now - state.since) / length)),
+		left: burning ? Math.max(0, state.ends - world.tick) * world.dt : 0
+	};
+	const list = world.states.has(fireList) ? world.state(fireList) : void 0;
+	const at = list && state.out === void 0 ? placeOf(list.ids, entity.id) : -1;
+	if (list && at >= 0 && list.ids[at] === entity.id && list.by[at]) info.by = list.by[at];
+	return info;
+}
+/** What `burningThings` gives where nothing burns */
+var NONE = Object.freeze([]);
+/**
+* The ids of what burns now, in order: for a game's rules and its computer players (one killed by other means, a
+* catapult's blast, is taken out within a second). Not to be kept or changed: the pack's own list
+*
+* @beta
+*/
+function burningThings(world) {
+	rulesOf(world, "burningThings");
+	return world.states.has(fireList) ? world.state(fireList).ids : NONE;
+}
+/**
+* Whether a thing burns at all in a world's game (`BurningOptions.burns`, `UnitTypeDef.burns`, trees): false in a game
+* without the burning pack
+*
+* @beta
+*/
+function canBurn(world, entity) {
+	return !!rulesIfAny(world)?.burnsOf(world, entity);
+}
+/**
+* The `burn` effect (`EffectTypes.burn`): sets alight what burns where it lands, by the caster (`light`), or puts it
+* out (`putOut`). Over its area (`radius`, `shape`), else the unit it was cast on, else what stands where it landed;
+* of those, what its fields of whom say (`affects`, `kinds`, `tags`, `layers`, `ifBuff`, `only`, `where`, `sort`,
+* `limit`: everything that burns, trees and what is the neutral player's among it, when it says none), and what the
+* game lets it reach (`beforeEffect`)
+*/
+var burnEffect = /* @__PURE__ */ defineEffect({
+	type: "burn",
+	run(context, effect) {
+		const { world, caster, target, point } = context;
+		const rules = rulesOf(world, "burn effect");
+		const area = effectArea(context, effect);
+		let things;
+		if (area) {
+			const reach = areaReach(area);
+			things = world.spatial.query(area.x, area.z, reach, []).filter((thing) => thing.alive && !thing.hidden && inArea(area, thing.pos, thing.def.radius));
+		} else if (target) things = [target];
+		else things = world.spatial.queryStatic(point.x, point.z, .5, []).filter((thing) => {
+			const { x, z, hw, hd } = thing.rect;
+			return thing.alive && Math.abs(point.x - x) < hw && Math.abs(point.z - z) < hd;
+		});
+		const putting = effect.act === "putOut";
+		things = things.filter((thing) => putting ? isBurning(thing) : !!rules.burnsOf(world, thing));
+		things = effectFilter(context, effect, things, "all").sort((a, b) => a.id - b.id);
+		for (const thing of things) if (putting) rules.putOut(world, thing);
+		else rules.light(world, thing, "light", caster.id, void 0, 1, {
+			...effect.how !== void 0 ? { how: effect.how } : {},
+			...effect.seconds !== void 0 ? { seconds: effect.seconds } : {}
+		});
+	},
+	fields: [
+		{
+			path: "act",
+			kind: "choice",
+			options: ["light", "putOut"],
+			hint: "What it does to what burns where it lands: sets it alight, or puts it out"
+		},
+		{
+			path: "how",
+			kind: "text",
+			hint: "What kind of burning it sets off, for the screen and the death: its own (burnt) when left out"
+		},
+		{
+			path: "seconds",
+			kind: "number",
+			min: 0,
+			hint: "Seconds what it sets alight burns: its own when left out"
+		}
+	]
+});
+/** A death of a thing burnt down given its kind of burning (`DeathEvent.how`): what its look's `death.how` goes by */
+var burntDeath = /* @__PURE__ */ defineHook({
+	hook: "death",
+	id: "burning",
+	run(world, death) {
+		const ending = rulesIfAny(world)?.ending;
+		if (ending && ending.entity === death.entity) death.how = ending.how;
+	}
+});
+/**
+* Things that burn (`BurningOptions`): trees by default (what can be felled), any type that says `burns`
+* (`UnitTypeDef.burns`: a wooden wall, a hut), or what the game decides in code. Set alight by `setAlight`, an ability
+* (`{ type: 'burn', act: 'light' }`), the grass's fire (`FoliageFire.lights`) or one another (`spread`), a thing burns
+* for its seconds and burns down: felled, burnt away, or leaving a thing of its own (a charred stump), with or
+* without its wood. Put out with `putOut`. Its look says what plays on it while it burns (`UnitLook.burning`: fire
+* by default, or a game's own effect for its own kind of burning, `how`). Off unless a game turns it on:
+*
+*     export const rules = { ...myGame, packs: [burningPack({ spread: { chance: 0.2 }, damage: 10 })] }
+*
+* What burns is not woken (`world.wake`): a forest costs nothing a tick while nothing in it burns
+*
+* @beta
+*/
+function burningPack(options = {}) {
+	const rules = new BurningRules(options);
+	return {
+		id: BURNING,
+		options,
+		systems: [rules.system],
+		hooks: [burntDeath],
+		components: [onFire, fireList],
+		events: [
+			burnStarted,
+			burnt,
+			burnPutOut
+		],
+		effects: [burnEffect],
+		[RULES]: rules
+	};
+}
+//#endregion
+export { BURNING, burnPutOut, burnStart, burnStarted, burningOf, burningPack, burningThings, burnt, canBurn, isBurning, onFire, putOut, setAlight };
+
+//# sourceMappingURL=burning.js.map