@v12-engine/engine 0.1.0 → 0.4.0

package/dist/attacks.d.ts

@@ -18,7 +18,7 @@ export declare function reaches(targets: AttackDef['targets'], target: {
 export declare function attackStat(stats: Readonly<Stats>, attack: AttackDef | undefined, which: keyof AttackStats): number;
 /**
  * The first of an attacker's attacks that reaches the target where it is (its `targets`), by place, or -1 for none:
- * the engine's `GameRules.combat.pickAttack`
+ * the engine's `RuleSettings.combat.pickAttack`
  *
  * @beta
  */
@@ -32,14 +32,14 @@ export declare function defaultPickAttack(world: World, attacker: Entity, target
 export declare function tooNear(attacker: Entity, target: Entity, weapon: number): boolean;
 /**
  * Which of an attacker's attacks it uses against a target, by place in `UnitTypeDef.attacks`, as the game's rules pick
- * it (`GameRules.combat.pickAttack`): -1 for none, its attacks reach not where the target is
+ * it (`RuleSettings.combat.pickAttack`): -1 for none, its attacks reach not where the target is
  *
  * @beta
  */
 export declare function pickAttack(world: World, attacker: Entity, target: Entity): number;
 /**
  * The farthest any attack of a type looks for enemies by itself (`AttackDef.acquisitionRange`): the engine's
- * `GameRules.combat.acquisitionRange`. 0 for what does not attack
+ * `RuleSettings.combat.acquisitionRange`. 0 for what does not attack
  *
  * @beta
  */

package/dist/attacks.js

@@ -0,0 +1,127 @@
+import { statsOf } from "./stats.js";
+import { edgeDistance } from "./entity.js";
+import { layerOf } from "./abilities/buffs.js";
+//#region src/attacks.ts
+var KINDS = [
+	"unit",
+	"building",
+	"resource"
+];
+/**
+* Whether an attack that is for these targets is for this one
+*
+* @beta
+*/
+function reaches(targets, target, layer) {
+	const flying = layer ? layer === "air" : target.def.flying === true;
+	if (!targets) return !flying;
+	if (flying ? !targets.includes("air") : targets.includes("air") && !targets.includes("ground")) return false;
+	return targets.includes(target.def.kind) || !targets.some((entry) => KINDS.includes(entry));
+}
+/**
+* The stats an attack reads when it names none of its own (`AttackDef.stats`)
+*
+* @internal
+*/
+var ATTACK_STATS = Object.freeze({
+	damage: "attackDamage",
+	speed: "attackSpeed",
+	range: "attackRange"
+});
+/**
+* How hard, how fast or how far an attack hits, from the attacker's stats: the stat the attack names
+* (`AttackDef.stats`), or the unit's own (`attackDamage`, `attackSpeed`, `attackRange`). The unit's own for no attack
+*
+* @beta
+*/
+function attackStat(stats, attack, which) {
+	return stats[attack?.stats?.[which] ?? ATTACK_STATS[which]] ?? 0;
+}
+/**
+* The first of an attacker's attacks that reaches the target where it is (its `targets`), by place, or -1 for none:
+* the engine's `RuleSettings.combat.pickAttack`
+*
+* @beta
+*/
+function defaultPickAttack(world, attacker, target) {
+	const attacks = attacker.def.attacks;
+	if (!attacks) return -1;
+	const layer = target.flying ? layerOf(world, target) : "ground";
+	let reaching = -1;
+	let distance = -1;
+	for (let i = 0; i < attacks.length; i++) {
+		if (!reaches(attacks[i].targets, target, layer)) continue;
+		const near = attacks[i].minRange;
+		if (!near) return i;
+		if (distance < 0) distance = edgeDistance(attacker, target);
+		if (distance >= near) return i;
+		if (reaching < 0) reaching = i;
+	}
+	return reaching;
+}
+/**
+* Whether a target is too near for one of an attacker's attacks (`AttackDef.minRange`), by place in its attacks: within
+* its dead zone, edge to edge
+*
+* @beta
+*/
+function tooNear(attacker, target, weapon) {
+	const near = attacker.def.attacks?.[weapon]?.minRange;
+	return !!near && edgeDistance(attacker, target) < near;
+}
+/**
+* Which of an attacker's attacks it uses against a target, by place in `UnitTypeDef.attacks`, as the game's rules pick
+* it (`RuleSettings.combat.pickAttack`): -1 for none, its attacks reach not where the target is
+*
+* @beta
+*/
+function pickAttack(world, attacker, target) {
+	return attacker.def.attacks?.length ? world.settings.combat.pickAttack(world, attacker, target) : -1;
+}
+/**
+* The farthest any attack of a type looks for enemies by itself (`AttackDef.acquisitionRange`): the engine's
+* `RuleSettings.combat.acquisitionRange`. 0 for what does not attack
+*
+* @beta
+*/
+function farthestAcquisition(def) {
+	let most = 0;
+	for (const attack of def.attacks ?? []) if (attack.acquisitionRange > most) most = attack.acquisitionRange;
+	return most;
+}
+/**
+* How far the farthest of a unit's attacks reaches, by its stats (its `attackRange`, or a stat an attack names): what
+* it may hit anything from. 0 for what does not attack
+*
+* @beta
+*/
+function farthestReach(def, stats) {
+	const attacks = def.attacks;
+	if (!attacks?.length) return 0;
+	let most = attackStat(stats, attacks[0], "range");
+	for (let i = 1; i < attacks.length; i++) most = Math.max(most, attackStat(stats, attacks[i], "range"));
+	return most;
+}
+/**
+* How far an attacker's attack reaches a target: the range of the one it uses against it (`pickAttack`), the first's
+* when none does
+*
+* @beta
+*/
+function rangeAgainst(world, attacker, target) {
+	const attacks = attacker.def.attacks;
+	const attack = attacks && attacks.length > 1 ? attacks[Math.max(pickAttack(world, attacker, target), 0)] : attacks?.[0];
+	return attackStat(statsOf(world, attacker), attack, "range");
+}
+/**
+* The first of a type's attacks that can be told to attack the ground (`AttackDef.ground`), by place, or -1 for none
+*
+* @beta
+*/
+function groundAttack(def) {
+	return def.attacks?.findIndex((attack) => attack.ground) ?? -1;
+}
+//#endregion
+export { ATTACK_STATS, attackStat, defaultPickAttack, farthestAcquisition, farthestReach, groundAttack, pickAttack, rangeAgainst, reaches, tooNear };
+
+//# sourceMappingURL=attacks.js.map

package/dist/attacks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attacks.js","names":[],"sources":["../src/attacks.ts"],"sourcesContent":["import { layerOf } from '#engine/abilities/buffs'\nimport type { AttackDef, AttackStats, Layer, Stats, UnitTypeDef } from '#engine/defs'\nimport { edgeDistance, type Entity } from '#engine/entity'\nimport { statsOf } from '#engine/stats'\nimport type { World } from '#engine/world'\n\n/*\n * A unit's attacks (`UnitTypeDef.attacks`, the classic RTS two weapons): what each reaches, which one it uses against\n * a target, and its numbers by the stats it reads. Apart from the combat system, for what counts room and reach\n * (`engagement.ts`, the stances pack) to ask without loading it\n */\n\nconst KINDS = ['unit', 'building', 'resource']\n\n/**\n * Whether an attack that is for these targets is for this one\n *\n * @beta\n */\nexport function reaches(targets: AttackDef['targets'], target: { def: UnitTypeDef }, layer?: Layer): boolean {\n\tconst flying = layer ? layer === 'air' : target.def.flying === true\n\tif (!targets) return !flying\n\tif (flying ? !targets.includes('air') : targets.includes('air') && !targets.includes('ground')) return false\n\t// kinds only count when some are named\n\treturn targets.includes(target.def.kind) || !targets.some((entry) => KINDS.includes(entry))\n}\n\n/**\n * The stats an attack reads when it names none of its own (`AttackDef.stats`)\n *\n * @internal\n */\nexport const ATTACK_STATS: Readonly<Required<AttackStats>> = Object.freeze({ damage: 'attackDamage', speed: 'attackSpeed', range: 'attackRange' })\n\n/**\n * How hard, how fast or how far an attack hits, from the attacker's stats: the stat the attack names\n * (`AttackDef.stats`), or the unit's own (`attackDamage`, `attackSpeed`, `attackRange`). The unit's own for no attack\n *\n * @beta\n */\nexport function attackStat(stats: Readonly<Stats>, attack: AttackDef | undefined, which: keyof AttackStats): number {\n\treturn stats[attack?.stats?.[which] ?? ATTACK_STATS[which]] ?? 0\n}\n\n/**\n * The first of an attacker's attacks that reaches the target where it is (its `targets`), by place, or -1 for none:\n * the engine's `RuleSettings.combat.pickAttack`\n *\n * @beta\n */\nexport function defaultPickAttack(world: World, attacker: Entity, target: Entity): number {\n\tconst attacks = attacker.def.attacks\n\tif (!attacks) return -1\n\tconst layer = target.flying ? layerOf(world, target) : 'ground'\n\t// the first that reaches where it is and of which it is not too near (`AttackDef.minRange`); else the first that\n\t// reaches where it is, too near or not (the unit steps back to use it)\n\tlet reaching = -1\n\tlet distance = -1\n\tfor (let i = 0; i < attacks.length; i++) {\n\t\tif (!reaches(attacks[i].targets, target, layer)) continue\n\t\tconst near = attacks[i].minRange\n\t\tif (!near) return i\n\t\tif (distance < 0) distance = edgeDistance(attacker, target)\n\t\tif (distance >= near) return i\n\t\tif (reaching < 0) reaching = i\n\t}\n\treturn reaching\n}\n\n/**\n * Whether a target is too near for one of an attacker's attacks (`AttackDef.minRange`), by place in its attacks: within\n * its dead zone, edge to edge\n *\n * @beta\n */\nexport function tooNear(attacker: Entity, target: Entity, weapon: number): boolean {\n\tconst near = attacker.def.attacks?.[weapon]?.minRange\n\treturn !!near && edgeDistance(attacker, target) < near\n}\n\n/**\n * Which of an attacker's attacks it uses against a target, by place in `UnitTypeDef.attacks`, as the game's rules pick\n * it (`RuleSettings.combat.pickAttack`): -1 for none, its attacks reach not where the target is\n *\n * @beta\n */\nexport function pickAttack(world: World, attacker: Entity, target: Entity): number {\n\treturn attacker.def.attacks?.length ? world.settings.combat.pickAttack(world, attacker, target) : -1\n}\n\n/**\n * The farthest any attack of a type looks for enemies by itself (`AttackDef.acquisitionRange`): the engine's\n * `RuleSettings.combat.acquisitionRange`. 0 for what does not attack\n *\n * @beta\n */\nexport function farthestAcquisition(def: UnitTypeDef): number {\n\tlet most = 0\n\tfor (const attack of def.attacks ?? []) if (attack.acquisitionRange > most) most = attack.acquisitionRange\n\treturn most\n}\n\n/**\n * How far the farthest of a unit's attacks reaches, by its stats (its `attackRange`, or a stat an attack names): what\n * it may hit anything from. 0 for what does not attack\n *\n * @beta\n */\nexport function farthestReach(def: UnitTypeDef, stats: Readonly<Stats>): number {\n\tconst attacks = def.attacks\n\tif (!attacks?.length) return 0\n\tlet most = attackStat(stats, attacks[0], 'range')\n\tfor (let i = 1; i < attacks.length; i++) most = Math.max(most, attackStat(stats, attacks[i], 'range'))\n\treturn most\n}\n\n/**\n * How far an attacker's attack reaches a target: the range of the one it uses against it (`pickAttack`), the first's\n * when none does\n *\n * @beta\n */\nexport function rangeAgainst(world: World, attacker: Entity, target: Entity): number {\n\tconst attacks = attacker.def.attacks\n\tconst attack = attacks && attacks.length > 1 ? attacks[Math.max(pickAttack(world, attacker, target), 0)] : attacks?.[0]\n\treturn attackStat(statsOf(world, attacker), attack, 'range')\n}\n\n/**\n * The first of a type's attacks that can be told to attack the ground (`AttackDef.ground`), by place, or -1 for none\n *\n * @beta\n */\nexport function groundAttack(def: UnitTypeDef): number {\n\treturn def.attacks?.findIndex((attack) => attack.ground) ?? -1\n}\n"],"mappings":";;;;AAYA,IAAM,QAAQ;CAAC;CAAQ;CAAY;AAAU;;;;;;AAO7C,SAAgB,QAAQ,SAA+B,QAA8B,OAAwB;CAC5G,MAAM,SAAS,QAAQ,UAAU,QAAQ,OAAO,IAAI,WAAW;CAC/D,IAAI,CAAC,SAAS,OAAO,CAAC;CACtB,IAAI,SAAS,CAAC,QAAQ,SAAS,KAAK,IAAI,QAAQ,SAAS,KAAK,KAAK,CAAC,QAAQ,SAAS,QAAQ,GAAG,OAAO;CAEvG,OAAO,QAAQ,SAAS,OAAO,IAAI,IAAI,KAAK,CAAC,QAAQ,MAAM,UAAU,MAAM,SAAS,KAAK,CAAC;AAC3F;;;;;;AAOA,IAAa,eAAgD,OAAO,OAAO;CAAE,QAAQ;CAAgB,OAAO;CAAe,OAAO;AAAc,CAAC;;;;;;;AAQjJ,SAAgB,WAAW,OAAwB,QAA+B,OAAkC;CACnH,OAAO,MAAM,QAAQ,QAAQ,UAAU,aAAa,WAAW;AAChE;;;;;;;AAQA,SAAgB,kBAAkB,OAAc,UAAkB,QAAwB;CACzF,MAAM,UAAU,SAAS,IAAI;CAC7B,IAAI,CAAC,SAAS,OAAO;CACrB,MAAM,QAAQ,OAAO,SAAS,QAAQ,OAAO,MAAM,IAAI;CAGvD,IAAI,WAAW;CACf,IAAI,WAAW;CACf,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;EACxC,IAAI,CAAC,QAAQ,QAAQ,EAAE,CAAC,SAAS,QAAQ,KAAK,GAAG;EACjD,MAAM,OAAO,QAAQ,EAAE,CAAC;EACxB,IAAI,CAAC,MAAM,OAAO;EAClB,IAAI,WAAW,GAAG,WAAW,aAAa,UAAU,MAAM;EAC1D,IAAI,YAAY,MAAM,OAAO;EAC7B,IAAI,WAAW,GAAG,WAAW;CAC9B;CACA,OAAO;AACR;;;;;;;AAQA,SAAgB,QAAQ,UAAkB,QAAgB,QAAyB;CAClF,MAAM,OAAO,SAAS,IAAI,UAAU,OAAO,EAAE;CAC7C,OAAO,CAAC,CAAC,QAAQ,aAAa,UAAU,MAAM,IAAI;AACnD;;;;;;;AAQA,SAAgB,WAAW,OAAc,UAAkB,QAAwB;CAClF,OAAO,SAAS,IAAI,SAAS,SAAS,MAAM,SAAS,OAAO,WAAW,OAAO,UAAU,MAAM,IAAI;AACnG;;;;;;;AAQA,SAAgB,oBAAoB,KAA0B;CAC7D,IAAI,OAAO;CACX,KAAK,MAAM,UAAU,IAAI,WAAW,CAAC,GAAG,IAAI,OAAO,mBAAmB,MAAM,OAAO,OAAO;CAC1F,OAAO;AACR;;;;;;;AAQA,SAAgB,cAAc,KAAkB,OAAgC;CAC/E,MAAM,UAAU,IAAI;CACpB,IAAI,CAAC,SAAS,QAAQ,OAAO;CAC7B,IAAI,OAAO,WAAW,OAAO,QAAQ,IAAI,OAAO;CAChD,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,OAAO,KAAK,IAAI,MAAM,WAAW,OAAO,QAAQ,IAAI,OAAO,CAAC;CACrG,OAAO;AACR;;;;;;;AAQA,SAAgB,aAAa,OAAc,UAAkB,QAAwB;CACpF,MAAM,UAAU,SAAS,IAAI;CAC7B,MAAM,SAAS,WAAW,QAAQ,SAAS,IAAI,QAAQ,KAAK,IAAI,WAAW,OAAO,UAAU,MAAM,GAAG,CAAC,KAAK,UAAU;CACrH,OAAO,WAAW,QAAQ,OAAO,QAAQ,GAAG,QAAQ,OAAO;AAC5D;;;;;;AAOA,SAAgB,aAAa,KAA0B;CACtD,OAAO,IAAI,SAAS,WAAW,WAAW,OAAO,MAAM,KAAK;AAC7D"}

package/dist/burning.d.ts

@@ -0,0 +1,267 @@
+import type { DamageType } from './defs';
+import { type Entity, type EntityId } from './entity';
+import { type Cancellable } from './hooks';
+import type { GamePack } from './packs/pack';
+import type { World } from './world';
+/**
+ * The burning pack's id (`burningPack`), for `hasPack`
+ *
+ * @beta
+ */
+export declare const BURNING = "burning";
+/**
+ * How a thing burns (`UnitTypeDef.burns`, `BurningOptions`): for how long, what is left of it, whether its wood is kept,
+ * and what kind of burning it is. What a type does not say is the pack's, then what each field says it is when left
+ * out. Plain data: the editor writes it
+ *
+ * @beta
+ */
+export interface BurnsDef {
+    /** Seconds it burns before it is burnt down: 20 when left out */
+    seconds?: number;
+    /**
+     * What is left once it has burnt down: `felled` (it comes down, as a tree a blast brings down: the death's reason is
+     * `felled`), `nothing` (it burns away: the reason is `burnt`), or the id of a unit type put down where it stood (a
+     * charred stump, a heap of ash: the reason `burnt` too). `felled` when left out
+     */
+    leaves?: 'felled' | 'nothing' | (string & {});
+    /**
+     * Whether what it leaves keeps its wood: a resource left in its place (`leaves` a type with `resource`) holds what
+     * it had left of its own. No when left out, and what is left holds what its type says
+     */
+    wood?: boolean;
+    /**
+     * What kind of burning it is, for the screen (the look's `burning.how`) and its death (`death.how`): `burnt` when
+     * left out. Another word for another kind: a blight that withers it, frost that shatters it
+     */
+    how?: string;
+}
+/**
+ * How fire passes from a burning thing to what burns about it (`BurningOptions.spread`): how far, how likely, how much
+ * the wind decides, how often it tries. It passes to what stands (trees, buildings, a wall): a unit that burns is set
+ * alight by a call or an ability alone
+ *
+ * @beta
+ */
+export interface BurningSpread {
+    /** How far it reaches, edge to edge, in cells: 1.5 when left out */
+    reach?: number;
+    /** How likely a try is to light one thing within reach in still air, 0 to 1: 0.15 when left out */
+    chance?: number;
+    /** How much the wind decides which way it goes (`MapEnvironment.wind`), 0 (not at all) and up: 1 when left out */
+    wind?: number;
+    /** Seconds between a burning thing's tries: 1 when left out */
+    every?: number;
+}
+/**
+ * What the burning pack is made with (`burningPack`): what burns, how (the defaults of `BurnsDef`, under what a type
+ * says), whether fire passes from one thing to the next, what it does to those who stand by, and how much may burn
+ *
+ * @beta
+ */
+export interface BurningOptions extends BurnsDef {
+    /**
+     * What burns, and how, in code: `true` (as its type and the pack say), a `BurnsDef` over those, or `false`. Where it
+     * says nothing, its type's `burns`; where that says nothing, what can be felled (`fellable`: trees)
+     */
+    burns?: (world: World, entity: Entity) => boolean | BurnsDef | undefined;
+    /** Whether a burning thing lights what burns about it (`BurningSpread`): `true` for the defaults. Never when left out */
+    spread?: BurningSpread | boolean;
+    /**
+     * Damage a second to units on the ground within `damageReach` of a burning thing, by whoever lit it (the first of
+     * those about it, in order of their ids): none when left out. Dealt twice a second, each unit on a turn of its own
+     */
+    damage?: number;
+    /** How far its heat hurts, edge to edge, in cells: 1 when left out */
+    damageReach?: number;
+    /** The type that damage is dealt as: magic when left out */
+    damageType?: DamageType;
+    /** The most things that burn at once: past it, nothing more catches until something has burnt down. 2000 when left out */
+    maxBurning?: number;
+    /**
+     * Whether a burning thing may set alight the grass about it, in a game with the foliage pack too (`foliagePack`):
+     * the cells under it and one cell round, of every layer of that pack, or of those named. No when left out. It
+     * passes as fire does, not at once: once a second while it burns, each cell by a chance of its own (0.2 for a style
+     * of `flammable` 1 in still, dry air, likelier downwind), asked of the game (`foliageIgnite`, `cause: 'burning'`),
+     * under the most that may burn there (`FoliageFire.maxBurning`). What caught is set alight at the end of this pack's
+     * turn, and tries nothing before its own next turn. The other way is that pack's to say (`FoliageFire.lights`)
+     */
+    lightsFoliage?: boolean | readonly string[];
+}
+/**
+ * What sets a thing alight: set alight by a call or an ability (`light`), caught from a burning thing about it
+ * (`spread`), or from burning grass (`foliage`)
+ *
+ * @beta
+ */
+export type BurnCause = 'light' | 'spread' | 'foliage';
+/**
+ * A thing about to catch fire (the `burnStart` hook): `cancel()` keeps it from catching; `chance` is a handler's to
+ * change (a wet grove, a building that does not burn while it is being built). Asked once a try
+ *
+ * @beta
+ */
+export interface BurnStart extends Cancellable {
+    /** What is about to catch */
+    readonly entity: Entity;
+    /** How it catches */
+    readonly cause: BurnCause;
+    /** The burning thing it catches from, for a spread */
+    readonly from?: Entity;
+    /** The layer of grass of the burning cell it catches from, for one caught from grass (`foliage`) */
+    readonly layer?: string;
+    /** The burning cell it catches from, by its index in that layer, for one caught from grass (`foliage`) */
+    readonly cell?: number;
+    /** Who set alight the fire it is of, where someone did */
+    readonly by?: Entity;
+    /** What kind of burning it is (`BurnsDef.how`) */
+    readonly how: string;
+    /**
+     * How likely it is to catch, 0 to 1: 1 for one set alight, the spread's chance in the wind for one caught from a
+     * burning thing, the grass's for one caught from grass (`FoliageFire.lights`). What a handler leaves it at is held
+     * to 0 to 1 (more than 1 is sure, less than 0 never)
+     */
+    chance: number;
+}
+/**
+ * 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
+ */
+export declare const burnStart: import("./hooks").HookKey<BurnStart>;
+/**
+ * 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
+ */
+export declare const burnStarted: import("./events").EventKey<{
+    entity: EntityId;
+    cause: BurnCause;
+    how: string;
+    by?: EntityId;
+}>;
+/**
+ * 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
+ */
+export declare const burnt: import("./events").EventKey<{
+    entity: EntityId;
+    how: string;
+    by?: EntityId;
+    left?: EntityId;
+}>;
+/**
+ * Something that burnt was put out (`putOut`, an ability): it stands, charred as far as it burnt
+ *
+ * @beta
+ */
+export declare const burnPutOut: import("./events").EventKey<{
+    entity: EntityId;
+}>;
+/**
+ * What burns, as everyone who sees it is told (`onFire`): the kind of burning, the tick it started and the tick it burns
+ * down at; `out`, the tick it was put out at, for one that burns no more (charred as far as it came: `(out - since) /
+ * (ends - since)`). A screen draws how far it has burnt from these and its own tick, with nothing sent as it goes
+ *
+ * @beta
+ */
+export interface FireShown {
+    /** What kind of burning it is (`BurnsDef.how`) */
+    how: string;
+    /** The tick it started to burn at: as far back as it had burnt already, for one lit again */
+    since: number;
+    /** The tick it burns down at */
+    ends: number;
+    /** The tick it was put out at, for one that burns no more */
+    out?: number;
+}
+/**
+ * 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
+ */
+export declare const onFire: import("./components").Component<FireShown, FireShown>;
+/**
+ * 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
+ */
+export declare function setAlight(world: World, entity: Entity, options?: {
+    by?: Entity;
+    how?: string;
+    seconds?: number;
+}): boolean;
+/**
+ * Puts out a thing that burns: it stands, charred as far as it burnt, and may be set alight again. Whether it burnt
+ *
+ * @beta
+ */
+export declare function putOut(world: World, entity: Entity): boolean;
+/**
+ * Whether a thing burns now: not one put out, nor one burnt down (or killed by other means while it burnt)
+ *
+ * @beta
+ */
+export declare function isBurning(entity: Entity): boolean;
+/**
+ * What the rules know of a thing that burns, or burnt and was put out (`burningOf`)
+ *
+ * @beta
+ */
+export interface BurningInfo {
+    /** Whether it burns now (`isBurning`): false for one put out, or burnt down */
+    burning: boolean;
+    /** What kind of burning it is (`BurnsDef.how`) */
+    how: string;
+    /** How far it has burnt, 0 (just caught) to 1 (about to burn down) */
+    share: number;
+    /** Seconds it still burns: 0 for one put out, or burnt down */
+    left: number;
+    /** Who set alight the fire it is of, where someone did */
+    by?: EntityId;
+}
+/**
+ * What the rules know of a thing that burns or burnt (`BurningInfo`): none for one that never caught
+ *
+ * @beta
+ */
+export declare function burningOf(world: World, entity: Entity): BurningInfo | undefined;
+/**
+ * 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
+ */
+export declare function burningThings(world: World): readonly EntityId[];
+/**
+ * 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
+ */
+export declare function canBurn(world: World, entity: Entity): boolean;
+/**
+ * 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
+ */
+export declare function burningPack(options?: BurningOptions): GamePack;