@v12-engine/engine 0.1.1 → 0.4.0

package/dist/abilities/effects/sight.js

@@ -0,0 +1,39 @@
+import { detection, distanceToEdge } from "../../entity.js";
+import { valueOf } from "../amounts.js";
+import { defineEffect } from "../effects.js";
+//#region src/abilities/effects/sight.ts
+/**
+* Sight: the engine's effects that show a spot (`EffectTypes.reveal`) and find what is invisible (`detect`)
+*/
+var near = [];
+/** The caster's team sees the spot for a while, with nothing standing there */
+var revealEffect = defineEffect({
+	type: "reveal",
+	run: (context, effect) => {
+		const { world, caster, point } = context;
+		world.reveal(world.player(caster.owner).team, point, valueOf(context, effect.radius, void 0, 8), valueOf(context, effect.duration, void 0, 5));
+	},
+	fields: ["duration"]
+});
+/** Finds what is invisible around the spot: the caster's team sees it for as long as `duration` says */
+var detectEffect = defineEffect({
+	type: "detect",
+	run: (context, effect) => {
+		const { world, caster, point } = context;
+		const team = world.player(caster.owner).team;
+		const radius = valueOf(context, effect.radius, void 0, 10);
+		const seconds = valueOf(context, effect.duration, void 0, 8);
+		for (const entity of world.spatial.query(point.x, point.z, radius, near)) {
+			if (!entity.alive || !world.sight.isInvisible(entity) || !world.areEnemies(caster.owner, entity.owner)) continue;
+			if (distanceToEdge(point, entity) > radius) continue;
+			let found = entity.get(detection);
+			if (!found) entity.set(detection, found = /* @__PURE__ */ new Map());
+			found.set(team, Math.max(found.get(team) ?? 0, seconds));
+		}
+	},
+	fields: ["duration"]
+});
+//#endregion
+export { detectEffect, revealEffect };
+
+//# sourceMappingURL=sight.js.map

package/dist/abilities/effects/sight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sight.js","names":[],"sources":["../../../src/abilities/effects/sight.ts"],"sourcesContent":["/**\n * Sight: the engine's effects that show a spot (`EffectTypes.reveal`) and find what is invisible (`detect`)\n */\nimport { detection, distanceToEdge, type Entity } from '#engine/entity'\nimport { valueOf } from '../amounts'\nimport { defineEffect } from '../effects'\n\nconst near: Entity[] = []\n\n/** The caster's team sees the spot for a while, with nothing standing there */\nexport const revealEffect = defineEffect({ type: 'reveal', run: (context, effect) => {\n\t\tconst { world, caster, point } = context\n\t\tworld.reveal(world.player(caster.owner).team, point, valueOf(context, effect.radius, undefined, 8), valueOf(context, effect.duration, undefined, 5))\n\t}, fields: ['duration'] })\n\n/** Finds what is invisible around the spot: the caster's team sees it for as long as `duration` says */\nexport const detectEffect = defineEffect({ type: 'detect', run: (context, effect) => {\n\t\tconst { world, caster, point } = context\n\t\tconst team = world.player(caster.owner).team\n\t\tconst radius = valueOf(context, effect.radius, undefined, 10)\n\t\tconst seconds = valueOf(context, effect.duration, undefined, 8)\n\t\tfor (const entity of world.spatial.query(point.x, point.z, radius, near)) {\n\t\t\tif (!entity.alive || !world.sight.isInvisible(entity) || !world.areEnemies(caster.owner, entity.owner)) continue\n\t\t\tif (distanceToEdge(point, entity) > radius) continue\n\t\t\tlet found = entity.get(detection)\n\t\t\tif (!found) entity.set(detection, (found = new Map()))\n\t\t\tfound.set(team, Math.max(found.get(team) ?? 0, seconds))\n\t\t}\n\t}, fields: ['duration'] })\n"],"mappings":";;;;;;;AAOA,IAAM,OAAiB,CAAC;;AAGxB,IAAa,eAAe,aAAa;CAAE,MAAM;CAAU,MAAM,SAAS,WAAW;EACnF,MAAM,EAAE,OAAO,QAAQ,UAAU;EACjC,MAAM,OAAO,MAAM,OAAO,OAAO,KAAK,CAAC,CAAC,MAAM,OAAO,QAAQ,SAAS,OAAO,QAAQ,KAAA,GAAW,CAAC,GAAG,QAAQ,SAAS,OAAO,UAAU,KAAA,GAAW,CAAC,CAAC;CACpJ;CAAG,QAAQ,CAAC,UAAU;AAAE,CAAC;;AAG1B,IAAa,eAAe,aAAa;CAAE,MAAM;CAAU,MAAM,SAAS,WAAW;EACnF,MAAM,EAAE,OAAO,QAAQ,UAAU;EACjC,MAAM,OAAO,MAAM,OAAO,OAAO,KAAK,CAAC,CAAC;EACxC,MAAM,SAAS,QAAQ,SAAS,OAAO,QAAQ,KAAA,GAAW,EAAE;EAC5D,MAAM,UAAU,QAAQ,SAAS,OAAO,UAAU,KAAA,GAAW,CAAC;EAC9D,KAAK,MAAM,UAAU,MAAM,QAAQ,MAAM,MAAM,GAAG,MAAM,GAAG,QAAQ,IAAI,GAAG;GACzE,IAAI,CAAC,OAAO,SAAS,CAAC,MAAM,MAAM,YAAY,MAAM,KAAK,CAAC,MAAM,WAAW,OAAO,OAAO,OAAO,KAAK,GAAG;GACxG,IAAI,eAAe,OAAO,MAAM,IAAI,QAAQ;GAC5C,IAAI,QAAQ,OAAO,IAAI,SAAS;GAChC,IAAI,CAAC,OAAO,OAAO,IAAI,WAAY,wBAAQ,IAAI,IAAI,CAAE;GACrD,MAAM,IAAI,MAAM,KAAK,IAAI,MAAM,IAAI,IAAI,KAAK,GAAG,OAAO,CAAC;EACxD;CACD;CAAG,QAAQ,CAAC,UAAU;AAAE,CAAC"}

package/dist/abilities/effects/spawn.d.ts

@@ -1,2 +1,5 @@
-/** Brings a unit of the caster's into the world where it landed, like a ward. `duration` is how long it lasts */
-export declare const spawnEffect: import("../effects").EffectKind<"spawn">;
+/**
+ * Brings a unit into the world where it landed, like a ward: the caster's, or the neutral player's (`owner`).
+ * `duration` is how long it lasts; `looksLike` draws it as the target or the caster is, and `data` gives it components
+ */
+export declare const spawnEffect: import("../effects").EffectType<"spawn">;

package/dist/abilities/effects/spawn.js

@@ -0,0 +1,40 @@
+import { valueOf } from "../amounts.js";
+import { defineEffect } from "../effects.js";
+//#region src/abilities/effects/spawn.ts
+/**
+* The engine's effect that brings a unit into the world (`EffectTypes.spawn`)
+*/
+/**
+* Brings a unit into the world where it landed, like a ward: the caster's, or the neutral player's (`owner`).
+* `duration` is how long it lasts; `looksLike` draws it as the target or the caster is, and `data` gives it components
+*/
+var spawnEffect = defineEffect({
+	type: "spawn",
+	run: (context, effect) => {
+		const { world, caster, point } = context;
+		if (!effect.unit) return;
+		const lifetime = effect.duration === void 0 ? void 0 : valueOf(context, effect.duration);
+		const looksLike = effect.looksLike === "target" ? context.target : effect.looksLike === "caster" ? caster : void 0;
+		const data = effect.data && Object.fromEntries(Object.entries(effect.data).map(([id, value]) => {
+			const component = world.registry.component(id);
+			return [id, component?.load ? component.load(value, world.registry) : value];
+		}));
+		world.spawn(effect.unit, effect.owner === "neutral" ? world.neutral : caster.owner, point, {
+			facing: caster.facing,
+			lifetime,
+			looksLike,
+			data
+		});
+	},
+	fields: [
+		"unit",
+		"duration",
+		"owner",
+		"looksLike",
+		"data"
+	]
+});
+//#endregion
+export { spawnEffect };
+
+//# sourceMappingURL=spawn.js.map

package/dist/abilities/effects/spawn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn.js","names":[],"sources":["../../../src/abilities/effects/spawn.ts"],"sourcesContent":["/**\n * The engine's effect that brings a unit into the world (`EffectTypes.spawn`)\n */\nimport { valueOf } from '../amounts'\nimport { defineEffect } from '../effects'\n\n/**\n * Brings a unit into the world where it landed, like a ward: the caster's, or the neutral player's (`owner`).\n * `duration` is how long it lasts; `looksLike` draws it as the target or the caster is, and `data` gives it components\n */\nexport const spawnEffect = defineEffect({ type: 'spawn', run: (context, effect) => {\n\t\tconst { world, caster, point } = context\n\t\tif (!effect.unit) return\n\t\tconst lifetime = effect.duration === undefined ? undefined : valueOf(context, effect.duration)\n\t\tconst looksLike = effect.looksLike === 'target' ? context.target : effect.looksLike === 'caster' ? caster : undefined\n\t\t// the form a save keeps a component in: what its `load` reads\n\t\tconst data = effect.data && Object.fromEntries(Object.entries(effect.data).map(([id, value]) => {\n\t\t\tconst component = world.registry.component(id)\n\t\t\treturn [id, component?.load ? component.load(value, world.registry) : value]\n\t\t}))\n\t\tworld.spawn(effect.unit, effect.owner === 'neutral' ? world.neutral : caster.owner, point, {\n\t\t\tfacing: caster.facing,\n\t\t\tlifetime,\n\t\t\tlooksLike,\n\t\t\tdata\n\t\t})\n\t}, fields: ['unit', 'duration', 'owner', 'looksLike', 'data'] })\n"],"mappings":";;;;;;;;;;AAUA,IAAa,cAAc,aAAa;CAAE,MAAM;CAAS,MAAM,SAAS,WAAW;EACjF,MAAM,EAAE,OAAO,QAAQ,UAAU;EACjC,IAAI,CAAC,OAAO,MAAM;EAClB,MAAM,WAAW,OAAO,aAAa,KAAA,IAAY,KAAA,IAAY,QAAQ,SAAS,OAAO,QAAQ;EAC7F,MAAM,YAAY,OAAO,cAAc,WAAW,QAAQ,SAAS,OAAO,cAAc,WAAW,SAAS,KAAA;EAE5G,MAAM,OAAO,OAAO,QAAQ,OAAO,YAAY,OAAO,QAAQ,OAAO,IAAI,CAAC,CAAC,KAAK,CAAC,IAAI,WAAW;GAC/F,MAAM,YAAY,MAAM,SAAS,UAAU,EAAE;GAC7C,OAAO,CAAC,IAAI,WAAW,OAAO,UAAU,KAAK,OAAO,MAAM,QAAQ,IAAI,KAAK;EAC5E,CAAC,CAAC;EACF,MAAM,MAAM,OAAO,MAAM,OAAO,UAAU,YAAY,MAAM,UAAU,OAAO,OAAO,OAAO;GAC1F,QAAQ,OAAO;GACf;GACA;GACA;EACD,CAAC;CACF;CAAG,QAAQ;EAAC;EAAQ;EAAY;EAAS;EAAa;CAAM;AAAE,CAAC"}

package/dist/abilities/effects/timed.d.ts

@@ -1,4 +1,4 @@
 /** `effects` happen at the spot, `delay` seconds from now */
-export declare const afterEffect: import("../effects").EffectKind<"after">;
+export declare const afterEffect: import("../effects").EffectType<"after">;
 /** For `duration` seconds `effects` happen to what is at the spot, over and over, and `onEnd` to what is there at the end */
-export declare const zoneEffect: import("../effects").EffectKind<"zone">;
+export declare const zoneEffect: import("../effects").EffectType<"zone">;

package/dist/abilities/effects/timed.js

@@ -0,0 +1,96 @@
+import { at } from "../../defs.js";
+import { effectOrigin } from "../land.js";
+import { valueOf } from "../amounts.js";
+import { effectHeading, shaped } from "../shapes.js";
+import { defineEffect } from "../effects.js";
+//#region src/abilities/effects/timed.ts
+/**
+* Later and over time: the engine's effects that go off after a while (`EffectTypes.after`) and over and over in a
+* place (`zone`)
+*/
+/** Where the effects of a context go off from and the way they face, kept for later where some have a shape (AB10) */
+function kept(context, effects, own) {
+	if (!shaped(effects) && (!own || own === "circle")) return {};
+	const from = effectOrigin(context);
+	return {
+		from: {
+			x: from.x,
+			z: from.z
+		},
+		heading: effectHeading(context)
+	};
+}
+/** `effects` happen at the spot, `delay` seconds from now */
+var afterEffect = defineEffect({
+	type: "after",
+	run: (context, effect) => {
+		const { world, caster, ability, level, point } = context;
+		world.delayed.push({
+			left: at(effect.delay, level),
+			caster,
+			ability,
+			level,
+			point: {
+				x: point.x,
+				z: point.z
+			},
+			effects: effect.effects ?? [],
+			impact: effect.impact,
+			...kept(context, effect.effects)
+		});
+	},
+	fields: [
+		"delay",
+		"effects",
+		"impact"
+	]
+});
+/** For `duration` seconds `effects` happen to what is at the spot, over and over, and `onEnd` to what is there at the end */
+var zoneEffect = defineEffect({
+	type: "zone",
+	run: (context, effect) => {
+		const { world, caster, ability, level, point, target } = context;
+		const followed = effect.follow === "caster" ? caster : effect.follow === "target" ? target : void 0;
+		const at = followed?.pos ?? point;
+		const lists = [
+			...effect.effects ?? [],
+			...effect.onEnd ?? [],
+			...effect.onEnter ?? [],
+			...effect.onLeave ?? [],
+			...effect.edge ?? []
+		];
+		world.zones.push({
+			id: world.newId(),
+			caster,
+			ability,
+			level,
+			x: at.x,
+			z: at.z,
+			left: valueOf(context, effect.duration, void 0, 1),
+			next: 0,
+			effect,
+			...kept(context, lists, effect.shape),
+			...followed && {
+				follows: followed.id,
+				from: {
+					x: at.x,
+					z: at.z
+				},
+				heading: followed.facing
+			}
+		});
+	},
+	fields: [
+		"duration",
+		"effects",
+		"onEnd",
+		"follow",
+		"onEnter",
+		"onLeave",
+		"edge"
+	]
+});
+//#endregion
+export { afterEffect, zoneEffect };
+
+//# sourceMappingURL=timed.js.map

package/dist/abilities/effects/timed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timed.js","names":[],"sources":["../../../src/abilities/effects/timed.ts"],"sourcesContent":["/**\n * Later and over time: the engine's effects that go off after a while (`EffectTypes.after`) and over and over in a\n * place (`zone`)\n */\nimport { at, type EffectDef, type EffectShape } from '#engine/defs'\nimport { valueOf } from '../amounts'\nimport { defineEffect, type EffectContext } from '../effects'\nimport { effectOrigin } from '../land'\nimport { effectHeading, shaped } from '../shapes'\n\n/** Where the effects of a context go off from and the way they face, kept for later where some have a shape (AB10) */\nfunction kept(context: EffectContext, effects: readonly EffectDef[] | undefined, own?: EffectShape) {\n\tif (!shaped(effects) && (!own || own === 'circle')) return {}\n\tconst from = effectOrigin(context)\n\treturn { from: { x: from.x, z: from.z }, heading: effectHeading(context) }\n}\n\n/** `effects` happen at the spot, `delay` seconds from now */\nexport const afterEffect = defineEffect({ type: 'after', run: (context, effect) => {\n\t\tconst { world, caster, ability, level, point } = context\n\t\tworld.delayed.push({\n\t\t\tleft: at(effect.delay, level),\n\t\t\tcaster,\n\t\t\tability,\n\t\t\tlevel,\n\t\t\tpoint: { x: point.x, z: point.z },\n\t\t\teffects: effect.effects ?? [],\n\t\t\timpact: effect.impact,\n\t\t\t...kept(context, effect.effects)\n\t\t})\n\t}, fields: ['delay', 'effects', 'impact'] })\n\n/** For `duration` seconds `effects` happen to what is at the spot, over and over, and `onEnd` to what is there at the end */\nexport const zoneEffect = defineEffect({ type: 'zone', run: (context, effect) => {\n\t\tconst { world, caster, ability, level, point, target } = context\n\t\t// one that goes with a unit is where it is, the way it faces (AB11)\n\t\tconst followed = effect.follow === 'caster' ? caster : effect.follow === 'target' ? target : undefined\n\t\tconst at = followed?.pos ?? point\n\t\tconst lists = [...(effect.effects ?? []), ...(effect.onEnd ?? []), ...(effect.onEnter ?? []), ...(effect.onLeave ?? []), ...(effect.edge ?? [])]\n\t\tworld.zones.push({\n\t\t\tid: world.newId(),\n\t\t\tcaster,\n\t\t\tability,\n\t\t\tlevel,\n\t\t\tx: at.x,\n\t\t\tz: at.z,\n\t\t\tleft: valueOf(context, effect.duration, undefined, 1),\n\t\t\tnext: 0,\n\t\t\teffect,\n\t\t\t...kept(context, lists, effect.shape),\n\t\t\t...(followed && { follows: followed.id, from: { x: at.x, z: at.z }, heading: followed.facing })\n\t\t})\n\t}, fields: ['duration', 'effects', 'onEnd', 'follow', 'onEnter', 'onLeave', 'edge'] })\n"],"mappings":";;;;;;;;;;;AAWA,SAAS,KAAK,SAAwB,SAA2C,KAAmB;CACnG,IAAI,CAAC,OAAO,OAAO,MAAM,CAAC,OAAO,QAAQ,WAAW,OAAO,CAAC;CAC5D,MAAM,OAAO,aAAa,OAAO;CACjC,OAAO;EAAE,MAAM;GAAE,GAAG,KAAK;GAAG,GAAG,KAAK;EAAE;EAAG,SAAS,cAAc,OAAO;CAAE;AAC1E;;AAGA,IAAa,cAAc,aAAa;CAAE,MAAM;CAAS,MAAM,SAAS,WAAW;EACjF,MAAM,EAAE,OAAO,QAAQ,SAAS,OAAO,UAAU;EACjD,MAAM,QAAQ,KAAK;GAClB,MAAM,GAAG,OAAO,OAAO,KAAK;GAC5B;GACA;GACA;GACA,OAAO;IAAE,GAAG,MAAM;IAAG,GAAG,MAAM;GAAE;GAChC,SAAS,OAAO,WAAW,CAAC;GAC5B,QAAQ,OAAO;GACf,GAAG,KAAK,SAAS,OAAO,OAAO;EAChC,CAAC;CACF;CAAG,QAAQ;EAAC;EAAS;EAAW;CAAQ;AAAE,CAAC;;AAG5C,IAAa,aAAa,aAAa;CAAE,MAAM;CAAQ,MAAM,SAAS,WAAW;EAC/E,MAAM,EAAE,OAAO,QAAQ,SAAS,OAAO,OAAO,WAAW;EAEzD,MAAM,WAAW,OAAO,WAAW,WAAW,SAAS,OAAO,WAAW,WAAW,SAAS,KAAA;EAC7F,MAAM,KAAK,UAAU,OAAO;EAC5B,MAAM,QAAQ;GAAC,GAAI,OAAO,WAAW,CAAC;GAAI,GAAI,OAAO,SAAS,CAAC;GAAI,GAAI,OAAO,WAAW,CAAC;GAAI,GAAI,OAAO,WAAW,CAAC;GAAI,GAAI,OAAO,QAAQ,CAAC;EAAE;EAC/I,MAAM,MAAM,KAAK;GAChB,IAAI,MAAM,MAAM;GAChB;GACA;GACA;GACA,GAAG,GAAG;GACN,GAAG,GAAG;GACN,MAAM,QAAQ,SAAS,OAAO,UAAU,KAAA,GAAW,CAAC;GACpD,MAAM;GACN;GACA,GAAG,KAAK,SAAS,OAAO,OAAO,KAAK;GACpC,GAAI,YAAY;IAAE,SAAS,SAAS;IAAI,MAAM;KAAE,GAAG,GAAG;KAAG,GAAG,GAAG;IAAE;IAAG,SAAS,SAAS;GAAO;EAC9F,CAAC;CACF;CAAG,QAAQ;EAAC;EAAY;EAAW;EAAS;EAAU;EAAW;EAAW;CAAM;AAAE,CAAC"}

package/dist/abilities/effects/trade.d.ts

@@ -1 +1 @@
-export declare const exchangeEffect: import("../effects").EffectKind<"exchange">;
+export declare const exchangeEffect: import("../effects").EffectType<"exchange">;

package/dist/abilities/effects/trade.js

@@ -0,0 +1,25 @@
+import { at } from "../../defs.js";
+import { defineEffect } from "../effects.js";
+import { exchange } from "../../trade.js";
+//#region src/abilities/effects/trade.ts
+/**
+* A market's: the caster's owner trades one resource for another at a rate (`EffectTypes.exchange`, `exchange` in
+* `trade.ts`)
+*/
+var exchangeEffect = defineEffect({
+	type: "exchange",
+	run: (context, effect) => {
+		const { world, caster, level } = context;
+		exchange(world, caster.owner, effect.sell, effect.buy, at(effect.amount, level), effect.rate);
+	},
+	fields: [
+		"sell",
+		"buy",
+		"amount",
+		"rate"
+	]
+});
+//#endregion
+export { exchangeEffect };
+
+//# sourceMappingURL=trade.js.map

package/dist/abilities/effects/trade.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trade.js","names":[],"sources":["../../../src/abilities/effects/trade.ts"],"sourcesContent":["/**\n * A market's: the caster's owner trades one resource for another at a rate (`EffectTypes.exchange`, `exchange` in\n * `trade.ts`)\n */\nimport { at } from '#engine/defs'\nimport { exchange } from '#engine/trade'\nimport { defineEffect } from '../effects'\n\nexport const exchangeEffect = defineEffect({ type: 'exchange', run: (context, effect) => {\n\t\tconst { world, caster, level } = context\n\t\texchange(world, caster.owner, effect.sell, effect.buy, at(effect.amount, level), effect.rate)\n\t}, fields: ['sell', 'buy', 'amount', 'rate'] })\n"],"mappings":";;;;;;;;AAQA,IAAa,iBAAiB,aAAa;CAAE,MAAM;CAAY,MAAM,SAAS,WAAW;EACvF,MAAM,EAAE,OAAO,QAAQ,UAAU;EACjC,SAAS,OAAO,OAAO,OAAO,OAAO,MAAM,OAAO,KAAK,GAAG,OAAO,QAAQ,KAAK,GAAG,OAAO,IAAI;CAC7F;CAAG,QAAQ;EAAC;EAAQ;EAAO;EAAU;CAAM;AAAE,CAAC"}

package/dist/abilities/effects.d.ts

@@ -2,11 +2,18 @@ import { type AbilityDef, type EffectCommon, type EffectDef, type EffectFields,
 import type { EditableField } from '#engine/gameData';
 import { type Dash, type Entity } from '#engine/entity';
 import { type Vec2 } from '#engine/math';
-import type { World } from '#engine/world';
-/** @beta */
+import type { Missile, World, Zone } from '#engine/world';
+/**
+ * What an effect is run with: the world, the caster, the ability and its level, the target and where it landed
+ *
+ * @beta
+ */
 export interface EffectContext {
+    /** The world the ability is cast in */
     world: World;
+    /** The unit that cast the ability */
     caster: Entity;
+    /** The definition of the ability being cast */
     ability: AbilityDef;
     /** Level the ability was cast at */
     level: number;
@@ -14,6 +21,23 @@ export interface EffectContext {
     target?: Entity;
     /** Where the ability landed: the target, the chosen spot, or the caster */
     point: Vec2;
+    /**
+     * What the effects go off from, when not the caster: a unit of its (a ball, a shadow, a soldier) or a place. A
+     * missile starts there and aims from there, an area of the effects never takes it in, and the strike the screens
+     * hear says it came from there; the caster stays who does it (whose the damage and the kills are, whose stats scale
+     * it). The caster when left out (`effectOrigin`)
+     *
+     * @beta
+     */
+    origin?: Entity | Vec2;
+    /**
+     * The way the effects face, for those with a shape (`EffectCommon.shape`): radians, as a unit's `facing`. From where
+     * they go off from to where they landed when left out (`effectHeading`): a zone keeps the way it was cast, or the way
+     * the unit it follows faces
+     *
+     * @beta
+     */
+    heading?: number;
     /** How far what carried the effect here has come, for what a missile does */
     distance?: number;
     /**
@@ -25,6 +49,20 @@ export interface EffectContext {
     stacks?: number;
     /** The ability went off charged, see `charge` on the ability */
     charged?: boolean;
+    /**
+     * For an ability held to charge and let go (`AbilityDef.hold`): how full it was, 0 let go at once to 1 full. Its
+     * amounts are grown by it (`HoldDef.scale`); a game's own amounts read it. Carried by its missiles
+     *
+     * @beta
+     */
+    held?: number;
+    /**
+     * For the effects of a trigger set off by damage (`onDamaged`, `onAbilityHit`, an `onHit`): the damage that did,
+     * after armor and shields, for the formula `byDamage` and a game's own amounts
+     *
+     * @beta
+     */
+    damage?: number;
     /**
      * For an effect that is kept up all the time (a passive asked every round): the seconds since it was last asked.
      * Something that works per second multiplies by this, rather than counting on how often it is asked
@@ -40,11 +78,12 @@ export interface EffectContext {
 export type EffectHandler = (context: EffectContext, effect: EffectDef) => void;
 /**
  * A kind of effect: its type and what it does (`defineEffect`). The engine's are the game's from the start; a game
- * lists its own in `GameModule.effects`, and one of a type the engine has takes its place
+ * lists its own in `Rules.effects`, and one of a type the engine has takes its place
  *
  * @beta
  */
-export interface EffectKind<K extends keyof EffectTypes = keyof EffectTypes> {
+export interface EffectType<K extends keyof EffectTypes = keyof EffectTypes> {
+    /** The effect type this is the definition of: the `type` an effect of it carries in an ability's list */
     readonly type: K;
     /** Carries out an effect of the type, for a cast (or a passive asked, a missile's hit...) */
     run(context: EffectContext, effect: EffectOf<K>): void;
@@ -62,36 +101,42 @@ export interface EffectKind<K extends keyof EffectTypes = keyof EffectTypes> {
  *
  * @beta
  */
-export interface EffectKindOptions {
+export interface EffectTypeOptions {
+    /** The fields an effect of the type reads, each the name of an engine field (`EffectFields`) or a full `EditableField` */
     fields?: readonly (keyof EffectFields | EditableField)[];
 }
 /**
- * A kind of effect, its type and what it does together: `defineEffect('pull', (context, effect) => ...)`, listed in
- * `GameModule.effects`. Its fields are said by declaring the type in `EffectTypes`
+ * A kind of effect, its type and what it does together: `defineEffect({ type: 'pull', run: (context, effect) => ... })`, listed in
+ * `Rules.effects`. Its fields are said by declaring the type in `EffectTypes`
  * (`declare module '@v12-engine/engine' { interface EffectTypes { pull: { distance: number } } }`), so that a handler
  * reads them typed, and an ability's effect of the type is checked for them
  *
- * @beta
+ * @public
  */
-export declare function defineEffect<K extends keyof EffectTypes>(type: K, run: (context: EffectContext, effect: EffectOf<K>) => void, options?: EffectKindOptions): EffectKind<K>;
+export declare function defineEffect<K extends keyof EffectTypes>(def: {
+    type: K;
+    run: (context: EffectContext, effect: EffectOf<K>) => void;
+} & EffectTypeOptions): EffectType<K>;
 /**
- * Who an effect applies to
+ * Whether an effect may reach a target, as the game says (the `beforeEffect` hook): what a game's own effect asks of
+ * each unit it does something to without `effectTargets` (which asks it of every one it gives). True where no handler is
+ * there. `missile`: the missile that reached it, for a missile's hit
  *
  * @beta
  */
-export declare function effectTargets(context: EffectContext, effect: EffectDef, fallback: 'enemies' | 'allies'): Entity[];
+export declare function mayReach(context: EffectContext, effect: EffectDef, target: Entity, missile?: Missile): boolean;
 /**
- * What the attacks of a unit do on top of their damage: the `onHit` effects among what its abilities, and
- * the items it carries, do all the time. Called for every attack that lands
+ * Who an effect applies to: the caster (`on: 'caster'`), the target or the caster (no `radius`), or who is within its
+ * `radius` of where it landed, as `affects` (`fallback` when it says nothing), `layers`, `kinds`, `tags`, `ifBuff`, `only` and
+ * what keeps out of the ability's way (`avoids`) say, the unit it went off from aside (`EffectContext.origin`); and of
+ * those, who the game lets it reach (`beforeEffect`, `mayReach`). A handler of a game's own effect calls it as the
+ * engine's do: who it gives is told to `effectLanded` once the handler is done
+ *
+ * @beta
  */
-export declare function onHit(world: World, attacker: Entity, target: Entity): void;
+export declare function effectTargets(context: EffectContext, effect: EffectDef, fallback: 'enemies' | 'allies'): Entity[];
 /** Whether an ability of the caster is charged: its `charge` buff is on it with as many stacks as it can have */
 export declare function isCharged(world: World, caster: Entity, ability: AbilityDef): boolean;
-/**
- * What the passives of the caster do whenever it casts an ability: for a hero, one of the abilities it learns.
- * Called once the ability went off, and not for one that went off charged: what spends a charge does not count to the next
- */
-export declare function onCast(world: World, caster: Entity, cast: AbilityDef): void;
 /**
  * Takes someone off the ground for a leap or a throw. Up there it is nobody's obstacle: it pushes no one
  * on its way over them, and goes straight over what cannot be walked
@@ -104,10 +149,39 @@ export declare function onCast(world: World, caster: Entity, cast: AbilityDef):
  */
 export declare function startDash(world: World, entity: Entity, dash: Omit<Dash, 'from'>): void;
 /**
- * What killing someone sets off: the `onKill` effects among what the abilities of the killer do all the time.
- * `attack` says whether it was one of its attacks that killed
+ * Takes a missile of an ability out of the world before it is done: blocked by a wall of wind, caught, swallowed. It
+ * hits nothing more, and every screen is told (`missileRemoved`). With `end`, what happens where it ends
+ * (`EffectFields.onEnd`) happens where it is, as if it had come to the end of its way. False for one that is not in the
+ * world (`world.missiles`) any more
+ *
+ * @beta
+ */
+export declare function removeMissile(world: World, missile: Missile, options?: {
+    end?: boolean;
+}): boolean;
+/**
+ * Ends a zone of an ability (`world.zones`) before its time: what happens at its end (`onEnd`) happens now, unless
+ * `onEnd` is false (a zone called off, not finished). False for one that is not in the world any more
+ *
+ * @beta
+ */
+export declare function endZone(world: World, zone: Zone, options?: {
+    onEnd?: boolean;
+}): boolean;
+/**
+ * Splits a missile where it is now (`EffectFields.split`), as it would once done: what a game's own recast does (Vel'Koz's
+ * Plasma Fission). It is gone, its `onEnd` not happening; false for one not in the world, or with no caster or ability left
+ *
+ * @beta
+ */
+export declare function splitMissile(world: World, missile: Missile): boolean;
+/**
+ * Turns a missile that is steered (`EffectFields.steer`) towards a point, as its owner's `steer` command does: it turns
+ * that way as it flies, as fast as its `rate` lets it. False for one that is not steered, or not in the world
+ *
+ * @beta
  */
-export declare function onKill(world: World, killer: Entity, victim: Entity, attack: boolean): void;
+export declare function steerMissile(world: World, missile: Missile, point: Vec2): boolean;
 /** Moves the missiles of abilities along, and lets them do what they do to what they pass through and where they come down */
 export declare function updateMissiles(world: World, dt: number): void;
 /** What abilities left behind to happen later, and the ground they go on working on */
@@ -119,4 +193,4 @@ export declare const toldMissileHit: import("..").ReplicatedEvent;
 /** Mana given or taken: its side's alone */
 export declare const toldMana: import("..").ReplicatedEvent;
 /** The missiles of abilities in flight the player is told of: their side's, and those where they see (`Snapshot.missiles`); none to a computer */
-export declare const missilesPart: import("..").SnapshotPart<keyof import("..").Snapshot>;
+export declare const missilesPart: import("..").SnapshotField<keyof import("..").Snapshot>;