@v12-engine/engine 0.1.1 → 0.4.0

package/dist/abilities/chance.js

@@ -0,0 +1,77 @@
+import { at } from "../defs.js";
+import { heroState } from "../hero.js";
+import { casterFacts } from "./scaled.js";
+//#region src/abilities/chance.ts
+/**
+* Chance and conditions of effects (E2E-PLAN AB6): an effect that happens by `chance`, drawn from the world's numbers so
+* that every run comes out the same, and what an `if` asks of a unit (`UnitCondition`): a buff, health below a share, a
+* hero, the tags of its type, enemy or ally; or code
+*/
+/** What code of an effect is asked with, as it lands */
+var asked = (context) => ({
+	level: context.level,
+	caster: casterFacts(context.world, context.caster),
+	effect: context
+});
+/**
+* Whether an effect that happens by chance (`EffectCommon.chance`) does this time: a draw from the world's numbers
+* (`world.rng`) under its share at the context's level, or what its code says for the target. True with no chance, and
+* then nothing is drawn (the world's numbers go on as they were); nothing is drawn for a share of 0 or of 1 either
+*
+* @beta
+*/
+function byChance(context, chance, target) {
+	if (chance === void 0) return true;
+	const share = typeof chance === "function" ? chance(asked(context), target) : at(chance, context.level);
+	if (share >= 1) return true;
+	if (!(share > 0)) return false;
+	return context.world.rng.next() < share;
+}
+/**
+* Whether the type of a unit has one of the tags (`UnitTypeDef.tags`)
+*
+* @beta
+*/
+function hasTag(entity, tags) {
+	const own = entity.def.tags;
+	return !!own && tags.some((tag) => own.includes(tag));
+}
+/**
+* Whether what an `if` asks of a unit holds (`UnitCondition`, or code), as the effect of the context lands: every part
+* it says. Nothing said holds; of no unit, nothing said does not
+*
+* @beta
+*/
+function conditionHolds(context, condition, unit) {
+	if (!condition) return true;
+	if (!unit) return false;
+	if (typeof condition === "function") return condition(asked(context), unit);
+	return unitMatches(context.world, condition, unit, context.caster.owner);
+}
+/**
+* Whether what a `UnitCondition` says holds of a unit, out of an effect: every part it says. `is` (enemy or ally) is
+* asked of the player `of`: it never holds with none. What an `if` asks (`conditionHolds`), what an effect's `where`
+* asks and what a query of the world asks (`world.query`)
+*
+* @beta
+*/
+function unitMatches(world, condition, unit, of) {
+	const { buff, noBuff, healthBelow, healthAbove, hero, structure, tags, notTags, is } = condition;
+	if (buff !== void 0 && !unit.buffs.some((instance) => instance.id === buff)) return false;
+	if (noBuff !== void 0 && unit.buffs.some((instance) => instance.id === noBuff)) return false;
+	if (healthBelow !== void 0 && !(unit.health < healthBelow * unit.maxHealth)) return false;
+	if (healthAbove !== void 0 && !(unit.health >= healthAbove * unit.maxHealth)) return false;
+	if (hero !== void 0 && unit.has(heroState) !== hero) return false;
+	if (structure !== void 0 && unit.isStructure !== structure) return false;
+	if (tags && !hasTag(unit, tags)) return false;
+	if (notTags && hasTag(unit, notTags)) return false;
+	if (is !== void 0) {
+		if (of === void 0) return false;
+		if (is === "enemy" ? !world.areEnemies(of, unit.owner) : !world.areAllies(of, unit.owner)) return false;
+	}
+	return true;
+}
+//#endregion
+export { byChance, conditionHolds, hasTag, unitMatches };
+
+//# sourceMappingURL=chance.js.map

package/dist/abilities/chance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chance.js","names":[],"sources":["../../src/abilities/chance.ts"],"sourcesContent":["/**\n * Chance and conditions of effects (E2E-PLAN AB6): an effect that happens by `chance`, drawn from the world's numbers so\n * that every run comes out the same, and what an `if` asks of a unit (`UnitCondition`): a buff, health below a share, a\n * hero, the tags of its type, enemy or ally; or code\n */\nimport { at, type EffectValue, type EffectValueContext, type UnitCondition, type UnitConditionCheck } from '#engine/defs'\nimport type { Entity, PlayerId } from '#engine/entity'\nimport type { World } from '#engine/world'\nimport { heroState } from '#engine/hero'\nimport type { EffectContext } from './effects'\nimport { casterFacts } from './scaled'\n\n/** What code of an effect is asked with, as it lands */\nconst asked = (context: EffectContext): EffectValueContext => ({ level: context.level, caster: casterFacts(context.world, context.caster), effect: context })\n\n/**\n * Whether an effect that happens by chance (`EffectCommon.chance`) does this time: a draw from the world's numbers\n * (`world.rng`) under its share at the context's level, or what its code says for the target. True with no chance, and\n * then nothing is drawn (the world's numbers go on as they were); nothing is drawn for a share of 0 or of 1 either\n *\n * @beta\n */\nexport function byChance(context: EffectContext, chance: EffectValue | undefined, target?: Entity): boolean {\n\tif (chance === undefined) return true\n\tconst share = typeof chance === 'function' ? chance(asked(context), target) : at(chance, context.level)\n\tif (share >= 1) return true\n\tif (!(share > 0)) return false\n\treturn context.world.rng.next() < share\n}\n\n/**\n * Whether the type of a unit has one of the tags (`UnitTypeDef.tags`)\n *\n * @beta\n */\nexport function hasTag(entity: Entity, tags: readonly string[]): boolean {\n\tconst own = entity.def.tags\n\treturn !!own && tags.some((tag) => own.includes(tag))\n}\n\n/**\n * Whether what an `if` asks of a unit holds (`UnitCondition`, or code), as the effect of the context lands: every part\n * it says. Nothing said holds; of no unit, nothing said does not\n *\n * @beta\n */\nexport function conditionHolds(context: EffectContext, condition: UnitCondition | UnitConditionCheck | undefined, unit: Entity | undefined): boolean {\n\tif (!condition) return true\n\tif (!unit) return false\n\tif (typeof condition === 'function') return condition(asked(context), unit)\n\treturn unitMatches(context.world, condition, unit, context.caster.owner)\n}\n\n/**\n * Whether what a `UnitCondition` says holds of a unit, out of an effect: every part it says. `is` (enemy or ally) is\n * asked of the player `of`: it never holds with none. What an `if` asks (`conditionHolds`), what an effect's `where`\n * asks and what a query of the world asks (`world.query`)\n *\n * @beta\n */\nexport function unitMatches(world: World, condition: UnitCondition, unit: Entity, of?: PlayerId): boolean {\n\tconst { buff, noBuff, healthBelow, healthAbove, hero, structure, tags, notTags, is } = condition\n\tif (buff !== undefined && !unit.buffs.some((instance) => instance.id === buff)) return false\n\tif (noBuff !== undefined && unit.buffs.some((instance) => instance.id === noBuff)) return false\n\tif (healthBelow !== undefined && !(unit.health < healthBelow * unit.maxHealth)) return false\n\tif (healthAbove !== undefined && !(unit.health >= healthAbove * unit.maxHealth)) return false\n\tif (hero !== undefined && unit.has(heroState) !== hero) return false\n\tif (structure !== undefined && unit.isStructure !== structure) return false\n\tif (tags && !hasTag(unit, tags)) return false\n\tif (notTags && hasTag(unit, notTags)) return false\n\tif (is !== undefined) {\n\t\tif (of === undefined) return false\n\t\tif (is === 'enemy' ? !world.areEnemies(of, unit.owner) : !world.areAllies(of, unit.owner)) return false\n\t}\n\treturn true\n}\n"],"mappings":";;;;;;;;;;AAaA,IAAM,SAAS,aAAgD;CAAE,OAAO,QAAQ;CAAO,QAAQ,YAAY,QAAQ,OAAO,QAAQ,MAAM;CAAG,QAAQ;AAAQ;;;;;;;;AAS3J,SAAgB,SAAS,SAAwB,QAAiC,QAA0B;CAC3G,IAAI,WAAW,KAAA,GAAW,OAAO;CACjC,MAAM,QAAQ,OAAO,WAAW,aAAa,OAAO,MAAM,OAAO,GAAG,MAAM,IAAI,GAAG,QAAQ,QAAQ,KAAK;CACtG,IAAI,SAAS,GAAG,OAAO;CACvB,IAAI,EAAE,QAAQ,IAAI,OAAO;CACzB,OAAO,QAAQ,MAAM,IAAI,KAAK,IAAI;AACnC;;;;;;AAOA,SAAgB,OAAO,QAAgB,MAAkC;CACxE,MAAM,MAAM,OAAO,IAAI;CACvB,OAAO,CAAC,CAAC,OAAO,KAAK,MAAM,QAAQ,IAAI,SAAS,GAAG,CAAC;AACrD;;;;;;;AAQA,SAAgB,eAAe,SAAwB,WAA2D,MAAmC;CACpJ,IAAI,CAAC,WAAW,OAAO;CACvB,IAAI,CAAC,MAAM,OAAO;CAClB,IAAI,OAAO,cAAc,YAAY,OAAO,UAAU,MAAM,OAAO,GAAG,IAAI;CAC1E,OAAO,YAAY,QAAQ,OAAO,WAAW,MAAM,QAAQ,OAAO,KAAK;AACxE;;;;;;;;AASA,SAAgB,YAAY,OAAc,WAA0B,MAAc,IAAwB;CACzG,MAAM,EAAE,MAAM,QAAQ,aAAa,aAAa,MAAM,WAAW,MAAM,SAAS,OAAO;CACvF,IAAI,SAAS,KAAA,KAAa,CAAC,KAAK,MAAM,MAAM,aAAa,SAAS,OAAO,IAAI,GAAG,OAAO;CACvF,IAAI,WAAW,KAAA,KAAa,KAAK,MAAM,MAAM,aAAa,SAAS,OAAO,MAAM,GAAG,OAAO;CAC1F,IAAI,gBAAgB,KAAA,KAAa,EAAE,KAAK,SAAS,cAAc,KAAK,YAAY,OAAO;CACvF,IAAI,gBAAgB,KAAA,KAAa,EAAE,KAAK,UAAU,cAAc,KAAK,YAAY,OAAO;CACxF,IAAI,SAAS,KAAA,KAAa,KAAK,IAAI,SAAS,MAAM,MAAM,OAAO;CAC/D,IAAI,cAAc,KAAA,KAAa,KAAK,gBAAgB,WAAW,OAAO;CACtE,IAAI,QAAQ,CAAC,OAAO,MAAM,IAAI,GAAG,OAAO;CACxC,IAAI,WAAW,OAAO,MAAM,OAAO,GAAG,OAAO;CAC7C,IAAI,OAAO,KAAA,GAAW;EACrB,IAAI,OAAO,KAAA,GAAW,OAAO;EAC7B,IAAI,OAAO,UAAU,CAAC,MAAM,WAAW,IAAI,KAAK,KAAK,IAAI,CAAC,MAAM,UAAU,IAAI,KAAK,KAAK,GAAG,OAAO;CACnG;CACA,OAAO;AACR"}

package/dist/abilities/charges.d.ts

@@ -26,3 +26,21 @@ export declare function readyAgain(state: AbilityState): void;
  * @beta
  */
 export declare function restoreCharges(world: World, entity: Entity, ability: string, count?: number): void;
+/**
+ * Sets how many seconds an entity's ability waits before it can be used again (`AbilityState.cooldown`), whatever it
+ * had left: 0 makes it ready. What a game's effect or hook does where the data's `cooldown` is not the way (a
+ * cooldown that depends on what the cast hit, a recast that starts it). False for an ability the entity does not have
+ *
+ * @beta
+ */
+export declare function setCooldown(entity: Entity, ability: string, seconds: number): boolean;
+/**
+ * Takes seconds off what is left of an entity's ability's cooldown (`AbilityState.cooldown`): a number of them, or a
+ * `share` of what is left (0.5: half). Never below 0. A kill that cuts a cooldown, a hit that refunds a part of it.
+ * False for an ability the entity does not have
+ *
+ * @beta
+ */
+export declare function reduceCooldown(entity: Entity, ability: string, by: number | {
+    share: number;
+}): boolean;

package/dist/abilities/charges.js

@@ -0,0 +1,101 @@
+import { at } from "../defs.js";
+import { cooldownOf } from "../stats.js";
+import { chargesLeft } from "../shared.js";
+//#region src/abilities/charges.ts
+/**
+* Charges: an ability used so many times before it waits (`AbilityDef.charges`). A use spends one, and one comes back
+* every `refill` seconds while it holds fewer than it can. What a state says nothing of is full, so an ability learned,
+* a level gone up and a save from before it all start full without anyone filling them in
+*/
+/** Seconds a use takes to come back: shortened as the cooldown is, but for what is carried or brought along (`plain`) */
+function refillOf(world, caster, ability, level, plain) {
+	const seconds = at(ability.charges?.refill, level);
+	return plain ? seconds : cooldownOf(world, caster, seconds);
+}
+/** One of the spells a hero brought along rather than learned: nothing shortens those */
+var brought = (caster, id) => caster.def.hero?.spells?.includes(id) ?? false;
+/** Full again: what it says of its uses goes, so that it holds all it can */
+function fill(state) {
+	delete state.charges;
+	delete state.refill;
+}
+/**
+* Spends a use of an ability with charges, as it goes off: the refill starts, where it was not running already.
+* `plain` for what nothing shortens (an item's, a spell brought along). Nothing for one without charges, and nothing
+* while the debug switch for no cooldowns is on
+*/
+function spendUse(world, caster, ability, state, plain) {
+	const left = chargesLeft(ability, state);
+	if (left === void 0 || world.cheats.noCooldowns) return;
+	state.charges = Math.max(left - 1, 0);
+	if (!((state.refill ?? 0) > 0)) state.refill = refillOf(world, caster, ability, state.level, plain);
+}
+/**
+* The seconds of a tick go by for the uses of an ability (`pass`: Infinity fills them at once): one back every
+* `refill`, until it holds all it can. `item` for the ability of something carried
+*/
+function refillUses(world, caster, state, pass, item = false) {
+	if (state.charges === void 0) return;
+	const ability = world.registry.abilities.has(state.id) ? world.registry.ability(state.id) : void 0;
+	const max = ability && chargesLeft(ability, { level: state.level });
+	if (!ability || max === void 0 || pass === Infinity) return fill(state);
+	state.refill = (state.refill ?? 0) - pass;
+	while (state.refill <= 0) {
+		state.charges++;
+		if (state.charges >= max) return fill(state);
+		const next = refillOf(world, caster, ability, state.level, item || brought(caster, ability.id));
+		if (next <= 0) return fill(state);
+		state.refill += next;
+	}
+}
+/** Ready again at once, with all the uses it holds: a hero revived, the `refresh` effect */
+function readyAgain(state) {
+	state.cooldown = 0;
+	fill(state);
+}
+/**
+* Gives an entity's ability with charges uses back, up to all it holds: `count` of them, or all when left out. What a
+* game's effect or hook does where the data's `refill` is not the way (a kill gives one back). Its cooldown stays
+*
+* @beta
+*/
+function restoreCharges(world, entity, ability, count = Infinity) {
+	const state = entity.abilities.find((known) => known.id === ability);
+	if (!state || state.charges === void 0) return;
+	const max = world.registry.abilities.has(ability) ? chargesLeft(world.registry.ability(ability), { level: state.level }) : void 0;
+	if (max === void 0 || state.charges + count >= max) return fill(state);
+	state.charges += Math.max(Math.floor(count), 0);
+}
+/** The state of an entity's ability, by its id */
+var stateOf = (entity, ability) => entity.abilities.find((known) => known.id === ability);
+/**
+* Sets how many seconds an entity's ability waits before it can be used again (`AbilityState.cooldown`), whatever it
+* had left: 0 makes it ready. What a game's effect or hook does where the data's `cooldown` is not the way (a
+* cooldown that depends on what the cast hit, a recast that starts it). False for an ability the entity does not have
+*
+* @beta
+*/
+function setCooldown(entity, ability, seconds) {
+	const state = stateOf(entity, ability);
+	if (!state) return false;
+	state.cooldown = Math.max(seconds, 0);
+	return true;
+}
+/**
+* Takes seconds off what is left of an entity's ability's cooldown (`AbilityState.cooldown`): a number of them, or a
+* `share` of what is left (0.5: half). Never below 0. A kill that cuts a cooldown, a hit that refunds a part of it.
+* False for an ability the entity does not have
+*
+* @beta
+*/
+function reduceCooldown(entity, ability, by) {
+	const state = stateOf(entity, ability);
+	if (!state) return false;
+	const seconds = typeof by === "number" ? by : state.cooldown * by.share;
+	state.cooldown = Math.max(state.cooldown - seconds, 0);
+	return true;
+}
+//#endregion
+export { readyAgain, reduceCooldown, refillUses, restoreCharges, setCooldown, spendUse };
+
+//# sourceMappingURL=charges.js.map

package/dist/abilities/charges.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"charges.js","names":[],"sources":["../../src/abilities/charges.ts"],"sourcesContent":["/**\n * Charges: an ability used so many times before it waits (`AbilityDef.charges`). A use spends one, and one comes back\n * every `refill` seconds while it holds fewer than it can. What a state says nothing of is full, so an ability learned,\n * a level gone up and a save from before it all start full without anyone filling them in\n */\nimport { type AbilityDef, at } from '#engine/defs'\nimport type { AbilityState, Entity } from '#engine/entity'\nimport { chargesLeft } from '#engine/shared'\nimport { cooldownOf } from '#engine/stats'\nimport type { World } from '#engine/world'\n\n/** Seconds a use takes to come back: shortened as the cooldown is, but for what is carried or brought along (`plain`) */\nfunction refillOf(world: World, caster: Entity, ability: AbilityDef, level: number, plain: boolean): number {\n\tconst seconds = at(ability.charges?.refill, level)\n\treturn plain ? seconds : cooldownOf(world, caster, seconds)\n}\n\n/** One of the spells a hero brought along rather than learned: nothing shortens those */\nconst brought = (caster: Entity, id: string) => caster.def.hero?.spells?.includes(id) ?? false\n\n/** Full again: what it says of its uses goes, so that it holds all it can */\nfunction fill(state: AbilityState): void {\n\tdelete state.charges\n\tdelete state.refill\n}\n\n/**\n * Spends a use of an ability with charges, as it goes off: the refill starts, where it was not running already.\n * `plain` for what nothing shortens (an item's, a spell brought along). Nothing for one without charges, and nothing\n * while the debug switch for no cooldowns is on\n */\nexport function spendUse(world: World, caster: Entity, ability: AbilityDef, state: AbilityState, plain: boolean): void {\n\tconst left = chargesLeft(ability, state)\n\tif (left === undefined || world.cheats.noCooldowns) return\n\tstate.charges = Math.max(left - 1, 0)\n\tif (!((state.refill ?? 0) > 0)) state.refill = refillOf(world, caster, ability, state.level, plain)\n}\n\n/**\n * The seconds of a tick go by for the uses of an ability (`pass`: Infinity fills them at once): one back every\n * `refill`, until it holds all it can. `item` for the ability of something carried\n */\nexport function refillUses(world: World, caster: Entity, state: AbilityState, pass: number, item = false): void {\n\tif (state.charges === undefined) return\n\tconst ability = world.registry.abilities.has(state.id) ? world.registry.ability(state.id) : undefined\n\tconst max = ability && chargesLeft(ability, { level: state.level })\n\tif (!ability || max === undefined || pass === Infinity) return fill(state)\n\tstate.refill = (state.refill ?? 0) - pass\n\twhile (state.refill <= 0) {\n\t\tstate.charges++\n\t\tif (state.charges >= max) return fill(state)\n\t\tconst next = refillOf(world, caster, ability, state.level, item || brought(caster, ability.id))\n\t\tif (next <= 0) return fill(state)\n\t\tstate.refill += next\n\t}\n}\n\n/** Ready again at once, with all the uses it holds: a hero revived, the `refresh` effect */\nexport function readyAgain(state: AbilityState): void {\n\tstate.cooldown = 0\n\tfill(state)\n}\n\n/**\n * Gives an entity's ability with charges uses back, up to all it holds: `count` of them, or all when left out. What a\n * game's effect or hook does where the data's `refill` is not the way (a kill gives one back). Its cooldown stays\n *\n * @beta\n */\nexport function restoreCharges(world: World, entity: Entity, ability: string, count = Infinity): void {\n\tconst state = entity.abilities.find((known) => known.id === ability)\n\tif (!state || state.charges === undefined) return\n\tconst max = world.registry.abilities.has(ability) ? chargesLeft(world.registry.ability(ability), { level: state.level }) : undefined\n\tif (max === undefined || state.charges + count >= max) return fill(state)\n\tstate.charges += Math.max(Math.floor(count), 0)\n}\n\n/** The state of an entity's ability, by its id */\nconst stateOf = (entity: Entity, ability: string): AbilityState | undefined => entity.abilities.find((known) => known.id === ability)\n\n/**\n * Sets how many seconds an entity's ability waits before it can be used again (`AbilityState.cooldown`), whatever it\n * had left: 0 makes it ready. What a game's effect or hook does where the data's `cooldown` is not the way (a\n * cooldown that depends on what the cast hit, a recast that starts it). False for an ability the entity does not have\n *\n * @beta\n */\nexport function setCooldown(entity: Entity, ability: string, seconds: number): boolean {\n\tconst state = stateOf(entity, ability)\n\tif (!state) return false\n\tstate.cooldown = Math.max(seconds, 0)\n\treturn true\n}\n\n/**\n * Takes seconds off what is left of an entity's ability's cooldown (`AbilityState.cooldown`): a number of them, or a\n * `share` of what is left (0.5: half). Never below 0. A kill that cuts a cooldown, a hit that refunds a part of it.\n * False for an ability the entity does not have\n *\n * @beta\n */\nexport function reduceCooldown(entity: Entity, ability: string, by: number | { share: number }): boolean {\n\tconst state = stateOf(entity, ability)\n\tif (!state) return false\n\tconst seconds = typeof by === 'number' ? by : state.cooldown * by.share\n\tstate.cooldown = Math.max(state.cooldown - seconds, 0)\n\treturn true\n}\n"],"mappings":";;;;;;;;;;AAYA,SAAS,SAAS,OAAc,QAAgB,SAAqB,OAAe,OAAwB;CAC3G,MAAM,UAAU,GAAG,QAAQ,SAAS,QAAQ,KAAK;CACjD,OAAO,QAAQ,UAAU,WAAW,OAAO,QAAQ,OAAO;AAC3D;;AAGA,IAAM,WAAW,QAAgB,OAAe,OAAO,IAAI,MAAM,QAAQ,SAAS,EAAE,KAAK;;AAGzF,SAAS,KAAK,OAA2B;CACxC,OAAO,MAAM;CACb,OAAO,MAAM;AACd;;;;;;AAOA,SAAgB,SAAS,OAAc,QAAgB,SAAqB,OAAqB,OAAsB;CACtH,MAAM,OAAO,YAAY,SAAS,KAAK;CACvC,IAAI,SAAS,KAAA,KAAa,MAAM,OAAO,aAAa;CACpD,MAAM,UAAU,KAAK,IAAI,OAAO,GAAG,CAAC;CACpC,IAAI,GAAG,MAAM,UAAU,KAAK,IAAI,MAAM,SAAS,SAAS,OAAO,QAAQ,SAAS,MAAM,OAAO,KAAK;AACnG;;;;;AAMA,SAAgB,WAAW,OAAc,QAAgB,OAAqB,MAAc,OAAO,OAAa;CAC/G,IAAI,MAAM,YAAY,KAAA,GAAW;CACjC,MAAM,UAAU,MAAM,SAAS,UAAU,IAAI,MAAM,EAAE,IAAI,MAAM,SAAS,QAAQ,MAAM,EAAE,IAAI,KAAA;CAC5F,MAAM,MAAM,WAAW,YAAY,SAAS,EAAE,OAAO,MAAM,MAAM,CAAC;CAClE,IAAI,CAAC,WAAW,QAAQ,KAAA,KAAa,SAAS,UAAU,OAAO,KAAK,KAAK;CACzE,MAAM,UAAU,MAAM,UAAU,KAAK;CACrC,OAAO,MAAM,UAAU,GAAG;EACzB,MAAM;EACN,IAAI,MAAM,WAAW,KAAK,OAAO,KAAK,KAAK;EAC3C,MAAM,OAAO,SAAS,OAAO,QAAQ,SAAS,MAAM,OAAO,QAAQ,QAAQ,QAAQ,QAAQ,EAAE,CAAC;EAC9F,IAAI,QAAQ,GAAG,OAAO,KAAK,KAAK;EAChC,MAAM,UAAU;CACjB;AACD;;AAGA,SAAgB,WAAW,OAA2B;CACrD,MAAM,WAAW;CACjB,KAAK,KAAK;AACX;;;;;;;AAQA,SAAgB,eAAe,OAAc,QAAgB,SAAiB,QAAQ,UAAgB;CACrG,MAAM,QAAQ,OAAO,UAAU,MAAM,UAAU,MAAM,OAAO,OAAO;CACnE,IAAI,CAAC,SAAS,MAAM,YAAY,KAAA,GAAW;CAC3C,MAAM,MAAM,MAAM,SAAS,UAAU,IAAI,OAAO,IAAI,YAAY,MAAM,SAAS,QAAQ,OAAO,GAAG,EAAE,OAAO,MAAM,MAAM,CAAC,IAAI,KAAA;CAC3H,IAAI,QAAQ,KAAA,KAAa,MAAM,UAAU,SAAS,KAAK,OAAO,KAAK,KAAK;CACxE,MAAM,WAAW,KAAK,IAAI,KAAK,MAAM,KAAK,GAAG,CAAC;AAC/C;;AAGA,IAAM,WAAW,QAAgB,YAA8C,OAAO,UAAU,MAAM,UAAU,MAAM,OAAO,OAAO;;;;;;;;AASpI,SAAgB,YAAY,QAAgB,SAAiB,SAA0B;CACtF,MAAM,QAAQ,QAAQ,QAAQ,OAAO;CACrC,IAAI,CAAC,OAAO,OAAO;CACnB,MAAM,WAAW,KAAK,IAAI,SAAS,CAAC;CACpC,OAAO;AACR;;;;;;;;AASA,SAAgB,eAAe,QAAgB,SAAiB,IAAyC;CACxG,MAAM,QAAQ,QAAQ,QAAQ,OAAO;CACrC,IAAI,CAAC,OAAO,OAAO;CACnB,MAAM,UAAU,OAAO,OAAO,WAAW,KAAK,MAAM,WAAW,GAAG;CAClE,MAAM,WAAW,KAAK,IAAI,MAAM,WAAW,SAAS,CAAC;CACrD,OAAO;AACR"}

package/dist/abilities/control.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Crowd control that takes a unit's orders (E2E-PLAN AB5): a buff's `control` (`fear`, `charm`, `taunt`, or code) steers
+ * its carrier every tick in place of its orders, which wait as they do through a stun and go on after; new orders are
+ * refused while it lasts (`giveOrder`). Run by the order system (`systems/orders.ts`)
+ */
+import type { ControlKind } from '#engine/defs';
+import { type Entity } from '#engine/entity';
+import type { World } from '#engine/world';
+/**
+ * A unit a buff's control holds (`BuffDef.control`): the buff, and who put it on. Set the first tick it holds it, and
+ * taken off the first tick after, as what it was told goes on. Saved with the unit, told to everyone who sees it
+ *
+ * @beta
+ */
+export declare const controlled: import("#engine/components").Component<{
+    buff: string;
+    source: number;
+}, {
+    buff: string;
+    source: number;
+}>;
+/**
+ * One tick of a unit under a control: the first, what it was doing is put off (a channel broken off, the rest to start
+ * over after); then it does what the control says. False when nothing controls it, after it let go of one
+ */
+export declare function steerControlled(world: World, entity: Entity, dt: number): boolean;
+/** Whether a control buff (`BuffDef.control`) holds its carrier as its id says: the words there are */
+export declare const CONTROL_KINDS: readonly ControlKind[];

package/dist/abilities/control.js

@@ -0,0 +1,113 @@
+import { cos, hypot, sin } from "../exactMath.js";
+import { orderSays } from "../orders/facts.js";
+import { defineComponent } from "../components.js";
+import { edgeDistance, fighting, moving } from "../entity.js";
+import { controlOf } from "./buffs.js";
+import { halt, moveTo, moveToEntity } from "../systems/movement.js";
+import { canAttack, engage } from "../systems/combat.js";
+import { clearOrders, resetStance } from "../orders/queue.js";
+//#region src/abilities/control.ts
+/**
+* A unit a buff's control holds (`BuffDef.control`): the buff, and who put it on. Set the first tick it holds it, and
+* taken off the first tick after, as what it was told goes on. Saved with the unit, told to everyone who sees it
+*
+* @beta
+*/
+var controlled = defineComponent({
+	id: "core.controlled",
+	replicate: "everyone"
+});
+/** How far ahead of itself a frightened unit runs, each time it looks where to */
+var FLEE_STEP = 4;
+/** Ticks between two looks where to run, or to walk after whom it is charmed by */
+var RETHINK = 8;
+/** How close a charmed unit comes to who charmed it */
+var CHARMED_RANGE = .5;
+/**
+* One tick of a unit under a control: the first, what it was doing is put off (a channel broken off, the rest to start
+* over after); then it does what the control says. False when nothing controls it, after it let go of one
+*/
+function steerControlled(world, entity, dt) {
+	const instance = entity.buffs.length ? controlOf(world, entity) : void 0;
+	const held = entity.get(controlled);
+	if (!instance) {
+		if (held) release(world, entity);
+		return false;
+	}
+	if (!held || held.buff !== instance.id || held.source !== instance.source) {
+		if (!held) putOff(world, entity);
+		entity.set(controlled, {
+			buff: instance.id,
+			source: instance.source
+		});
+	}
+	const source = world.get(instance.source);
+	const control = world.registry.buff(instance.id).control;
+	if (typeof control === "function") control(world, entity, instance, dt, source?.alive ? source : void 0);
+	else steer(world, entity, control, source?.alive ? source : void 0, dt);
+	return true;
+}
+/** What it was doing waits: a channel is broken off, the rest starts over once the control lets go */
+function putOff(world, entity) {
+	if (orderSays(world, entity, "channelling")) {
+		clearOrders(world, entity);
+		return;
+	}
+	const order = entity.orders[0];
+	if (order?.started) {
+		world.registry.order(order.type).end?.(world, entity, order);
+		order.started = false;
+	}
+	resetStance(world, entity);
+}
+/** The control let go: it stands, and what it was told starts over */
+function release(world, entity) {
+	entity.remove(controlled);
+	resetStance(world, entity);
+}
+function steer(world, entity, kind, source, dt) {
+	const m = entity.get(moving);
+	if (kind === "taunt") {
+		if (!source) return halt(world, entity);
+		if (entity.get(fighting) && canAttack(world, entity, source, true)) {
+			engage(world, entity, source, dt, !!m, true);
+			return;
+		}
+		if (m) moveToEntity(world, entity, source, CHARMED_RANGE);
+		return;
+	}
+	if (!m) return;
+	const rethink = m.status !== "moving" || (world.tick + entity.id) % RETHINK === 0;
+	if (kind === "charm") {
+		if (!source) return halt(world, entity);
+		if (edgeDistance(entity, source) > CHARMED_RANGE && rethink) moveToEntity(world, entity, source, CHARMED_RANGE);
+		return;
+	}
+	if (!rethink) return;
+	let dx = source ? entity.pos.x - source.pos.x : sin(entity.facing);
+	let dz = source ? entity.pos.z - source.pos.z : cos(entity.facing);
+	const length = hypot(dx, dz);
+	if (length < 1e-6) {
+		dx = sin(entity.facing);
+		dz = cos(entity.facing);
+	} else {
+		dx /= length;
+		dz /= length;
+	}
+	const aim = {
+		x: entity.pos.x + dx * FLEE_STEP,
+		z: entity.pos.z + dz * FLEE_STEP
+	};
+	const spot = (entity.flying ? world.air : world.nav).closestPoint(aim, FLEE_STEP) ?? aim;
+	moveTo(world, entity, spot);
+}
+/** Whether a control buff (`BuffDef.control`) holds its carrier as its id says: the words there are */
+var CONTROL_KINDS = [
+	"fear",
+	"charm",
+	"taunt"
+];
+//#endregion
+export { CONTROL_KINDS, controlled, steerControlled };
+
+//# sourceMappingURL=control.js.map

package/dist/abilities/control.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.js","names":[],"sources":["../../src/abilities/control.ts"],"sourcesContent":["/**\n * Crowd control that takes a unit's orders (E2E-PLAN AB5): a buff's `control` (`fear`, `charm`, `taunt`, or code) steers\n * its carrier every tick in place of its orders, which wait as they do through a stun and go on after; new orders are\n * refused while it lasts (`giveOrder`). Run by the order system (`systems/orders.ts`)\n */\nimport type { BuffControl, ControlKind } from '#engine/defs'\nimport { defineComponent } from '#engine/components'\nimport { type Entity, edgeDistance, fighting, moving } from '#engine/entity'\nimport { cos, hypot, sin } from '#engine/exactMath'\nimport { orderSays } from '#engine/orders/facts'\nimport { clearOrders, resetStance } from '#engine/orders/queue'\nimport { canAttack, engage } from '#engine/systems/combat'\nimport { halt, moveTo, moveToEntity } from '#engine/systems/movement'\nimport type { World } from '#engine/world'\nimport { controlOf } from './buffs'\n\n/**\n * A unit a buff's control holds (`BuffDef.control`): the buff, and who put it on. Set the first tick it holds it, and\n * taken off the first tick after, as what it was told goes on. Saved with the unit, told to everyone who sees it\n *\n * @beta\n */\nexport const controlled = defineComponent<{ buff: string; source: number }>({ id: 'core.controlled', replicate: 'everyone' })\n\n/** How far ahead of itself a frightened unit runs, each time it looks where to */\nconst FLEE_STEP = 4\n/** Ticks between two looks where to run, or to walk after whom it is charmed by */\nconst RETHINK = 8\n/** How close a charmed unit comes to who charmed it */\nconst CHARMED_RANGE = 0.5\n\n/**\n * One tick of a unit under a control: the first, what it was doing is put off (a channel broken off, the rest to start\n * over after); then it does what the control says. False when nothing controls it, after it let go of one\n */\nexport function steerControlled(world: World, entity: Entity, dt: number): boolean {\n\tconst instance = entity.buffs.length ? controlOf(world, entity) : undefined\n\tconst held = entity.get(controlled)\n\tif (!instance) {\n\t\tif (held) release(world, entity)\n\t\treturn false\n\t}\n\tif (!held || held.buff !== instance.id || held.source !== instance.source) {\n\t\tif (!held) putOff(world, entity)\n\t\tentity.set(controlled, { buff: instance.id, source: instance.source })\n\t}\n\tconst source = world.get(instance.source)\n\tconst control = world.registry.buff(instance.id).control!\n\tif (typeof control === 'function') (control as BuffControl)(world, entity, instance, dt, source?.alive ? source : undefined)\n\telse steer(world, entity, control, source?.alive ? source : undefined, dt)\n\treturn true\n}\n\n/** What it was doing waits: a channel is broken off, the rest starts over once the control lets go */\nfunction putOff(world: World, entity: Entity): void {\n\tif (orderSays(world, entity, 'channelling')) {\n\t\tclearOrders(world, entity)\n\t\treturn\n\t}\n\tconst order = entity.orders[0]\n\tif (order?.started) {\n\t\tworld.registry.order(order.type).end?.(world, entity, order)\n\t\torder.started = false\n\t}\n\tresetStance(world, entity)\n}\n\n/** The control let go: it stands, and what it was told starts over */\nfunction release(world: World, entity: Entity): void {\n\tentity.remove(controlled)\n\tresetStance(world, entity)\n}\n\nfunction steer(world: World, entity: Entity, kind: ControlKind, source: Entity | undefined, dt: number): void {\n\tconst m = entity.get(moving)\n\tif (kind === 'taunt') {\n\t\tif (!source) return halt(world, entity)\n\t\t// at who taunted it, with what it has; walking up to them where it cannot strike them\n\t\tif (entity.get(fighting) && canAttack(world, entity, source, true)) {\n\t\t\tengage(world, entity, source, dt, !!m, true)\n\t\t\treturn\n\t\t}\n\t\tif (m) moveToEntity(world, entity, source, CHARMED_RANGE)\n\t\treturn\n\t}\n\tif (!m) return\n\tconst rethink = m.status !== 'moving' || (world.tick + entity.id) % RETHINK === 0\n\tif (kind === 'charm') {\n\t\tif (!source) return halt(world, entity)\n\t\tif (edgeDistance(entity, source) > CHARMED_RANGE && rethink) moveToEntity(world, entity, source, CHARMED_RANGE)\n\t\treturn\n\t}\n\t// fear: away from who frightened it, the way it faces when there is nobody to run from\n\tif (!rethink) return\n\tlet dx = source ? entity.pos.x - source.pos.x : sin(entity.facing)\n\tlet dz = source ? entity.pos.z - source.pos.z : cos(entity.facing)\n\tconst length = hypot(dx, dz)\n\tif (length < 1e-6) {\n\t\tdx = sin(entity.facing)\n\t\tdz = cos(entity.facing)\n\t} else {\n\t\tdx /= length\n\t\tdz /= length\n\t}\n\tconst aim = { x: entity.pos.x + dx * FLEE_STEP, z: entity.pos.z + dz * FLEE_STEP }\n\tconst spot = (entity.flying ? world.air : world.nav).closestPoint(aim, FLEE_STEP) ?? aim\n\tmoveTo(world, entity, spot)\n}\n\n/** Whether a control buff (`BuffDef.control`) holds its carrier as its id says: the words there are */\nexport const CONTROL_KINDS: readonly ControlKind[] = ['fear', 'charm', 'taunt']\n"],"mappings":";;;;;;;;;;;;;;;AAsBA,IAAa,aAAa,gBAAkD;CAAE,IAAI;CAAmB,WAAW;AAAW,CAAC;;AAG5H,IAAM,YAAY;;AAElB,IAAM,UAAU;;AAEhB,IAAM,gBAAgB;;;;;AAMtB,SAAgB,gBAAgB,OAAc,QAAgB,IAAqB;CAClF,MAAM,WAAW,OAAO,MAAM,SAAS,UAAU,OAAO,MAAM,IAAI,KAAA;CAClE,MAAM,OAAO,OAAO,IAAI,UAAU;CAClC,IAAI,CAAC,UAAU;EACd,IAAI,MAAM,QAAQ,OAAO,MAAM;EAC/B,OAAO;CACR;CACA,IAAI,CAAC,QAAQ,KAAK,SAAS,SAAS,MAAM,KAAK,WAAW,SAAS,QAAQ;EAC1E,IAAI,CAAC,MAAM,OAAO,OAAO,MAAM;EAC/B,OAAO,IAAI,YAAY;GAAE,MAAM,SAAS;GAAI,QAAQ,SAAS;EAAO,CAAC;CACtE;CACA,MAAM,SAAS,MAAM,IAAI,SAAS,MAAM;CACxC,MAAM,UAAU,MAAM,SAAS,KAAK,SAAS,EAAE,CAAC,CAAC;CACjD,IAAI,OAAO,YAAY,YAAY,QAAyB,OAAO,QAAQ,UAAU,IAAI,QAAQ,QAAQ,SAAS,KAAA,CAAS;MACtH,MAAM,OAAO,QAAQ,SAAS,QAAQ,QAAQ,SAAS,KAAA,GAAW,EAAE;CACzE,OAAO;AACR;;AAGA,SAAS,OAAO,OAAc,QAAsB;CACnD,IAAI,UAAU,OAAO,QAAQ,aAAa,GAAG;EAC5C,YAAY,OAAO,MAAM;EACzB;CACD;CACA,MAAM,QAAQ,OAAO,OAAO;CAC5B,IAAI,OAAO,SAAS;EACnB,MAAM,SAAS,MAAM,MAAM,IAAI,CAAC,CAAC,MAAM,OAAO,QAAQ,KAAK;EAC3D,MAAM,UAAU;CACjB;CACA,YAAY,OAAO,MAAM;AAC1B;;AAGA,SAAS,QAAQ,OAAc,QAAsB;CACpD,OAAO,OAAO,UAAU;CACxB,YAAY,OAAO,MAAM;AAC1B;AAEA,SAAS,MAAM,OAAc,QAAgB,MAAmB,QAA4B,IAAkB;CAC7G,MAAM,IAAI,OAAO,IAAI,MAAM;CAC3B,IAAI,SAAS,SAAS;EACrB,IAAI,CAAC,QAAQ,OAAO,KAAK,OAAO,MAAM;EAEtC,IAAI,OAAO,IAAI,QAAQ,KAAK,UAAU,OAAO,QAAQ,QAAQ,IAAI,GAAG;GACnE,OAAO,OAAO,QAAQ,QAAQ,IAAI,CAAC,CAAC,GAAG,IAAI;GAC3C;EACD;EACA,IAAI,GAAG,aAAa,OAAO,QAAQ,QAAQ,aAAa;EACxD;CACD;CACA,IAAI,CAAC,GAAG;CACR,MAAM,UAAU,EAAE,WAAW,aAAa,MAAM,OAAO,OAAO,MAAM,YAAY;CAChF,IAAI,SAAS,SAAS;EACrB,IAAI,CAAC,QAAQ,OAAO,KAAK,OAAO,MAAM;EACtC,IAAI,aAAa,QAAQ,MAAM,IAAI,iBAAiB,SAAS,aAAa,OAAO,QAAQ,QAAQ,aAAa;EAC9G;CACD;CAEA,IAAI,CAAC,SAAS;CACd,IAAI,KAAK,SAAS,OAAO,IAAI,IAAI,OAAO,IAAI,IAAI,IAAI,OAAO,MAAM;CACjE,IAAI,KAAK,SAAS,OAAO,IAAI,IAAI,OAAO,IAAI,IAAI,IAAI,OAAO,MAAM;CACjE,MAAM,SAAS,MAAM,IAAI,EAAE;CAC3B,IAAI,SAAS,MAAM;EAClB,KAAK,IAAI,OAAO,MAAM;EACtB,KAAK,IAAI,OAAO,MAAM;CACvB,OAAO;EACN,MAAM;EACN,MAAM;CACP;CACA,MAAM,MAAM;EAAE,GAAG,OAAO,IAAI,IAAI,KAAK;EAAW,GAAG,OAAO,IAAI,IAAI,KAAK;CAAU;CACjF,MAAM,QAAQ,OAAO,SAAS,MAAM,MAAM,MAAM,IAAA,CAAK,aAAa,KAAK,SAAS,KAAK;CACrF,OAAO,OAAO,QAAQ,IAAI;AAC3B;;AAGA,IAAa,gBAAwC;CAAC;CAAQ;CAAS;AAAO"}

package/dist/abilities/dispel.js

@@ -0,0 +1,51 @@
+import { removeBuff } from "./buffs.js";
+import { summoned } from "../summoned.js";
+import { valueOf } from "./amounts.js";
+import { defineEffect, effectTargets } from "./effects.js";
+//#region src/abilities/dispel.ts
+/**
+* Takes buffs off a unit, as a dispel does: the good ones of an enemy of `by`, the bad ones of a friend. Those that say
+* they cannot be (`BuffDef.dispellable: false`) stay. How many it took
+*
+* @beta
+*/
+function dispelBuffs(world, entity, by) {
+	const enemy = world.areEnemies(by.owner, entity.owner);
+	let taken = 0;
+	for (const instance of [...entity.buffs]) {
+		const def = world.registry.buff(instance.id);
+		if (!!def.harmful === enemy) continue;
+		if (!(typeof def.dispellable === "function" ? def.dispellable(world, entity, instance, by) : def.dispellable !== false)) continue;
+		removeBuff(world, entity, instance.id);
+		taken++;
+	}
+	return taken;
+}
+/**
+* The effect types of the dispel family, among them `dispel`, which the engine adds to its effect types
+*
+* @internal
+*/
+var dispelEffects = [defineEffect({
+	type: "dispel",
+	run: (context, effect) => {
+		const { world, caster } = context;
+		const hurt = valueOf(context, effect.amount);
+		for (const entity of effectTargets(context, {
+			...effect,
+			affects: effect.affects ?? "all"
+		}, "enemies")) {
+			if (!entity.isUnit) continue;
+			dispelBuffs(world, entity, caster);
+			if (hurt > 0 && entity.has(summoned) && world.areEnemies(caster.owner, entity.owner)) world.damage(entity, hurt, caster, {
+				damageType: "magic",
+				ability: context.ability.id
+			});
+		}
+	},
+	fields: ["amount"]
+})];
+//#endregion
+export { dispelBuffs, dispelEffects };
+
+//# sourceMappingURL=dispel.js.map

package/dist/abilities/dispel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispel.js","names":[],"sources":["../../src/abilities/dispel.ts"],"sourcesContent":["import type { Entity } from '#engine/entity'\nimport { summoned } from '#engine/summons'\nimport type { World } from '#engine/world'\nimport { removeBuff } from './buffs'\nimport { defineEffect, type EffectType, effectTargets } from './effects'\nimport { valueOf } from './amounts'\n\n/*\n * Dispelling and spell immunity. A dispel takes what is good off enemies and what is bad off friends, and hurts what a\n * spell brought into the world; a unit immune to spells is not touched by abilities, those of its friends too, unless\n * an ability says it gets through (`AbilityDef.piercesImmunity`)\n */\n\n/**\n * Takes buffs off a unit, as a dispel does: the good ones of an enemy of `by`, the bad ones of a friend. Those that say\n * they cannot be (`BuffDef.dispellable: false`) stay. How many it took\n *\n * @beta\n */\nexport function dispelBuffs(world: World, entity: Entity, by: Entity): number {\n\tconst enemy = world.areEnemies(by.owner, entity.owner)\n\tlet taken = 0\n\tfor (const instance of [...entity.buffs]) {\n\t\tconst def = world.registry.buff(instance.id)\n\t\tif (!!def.harmful === enemy) continue\n\t\tconst dispellable = typeof def.dispellable === 'function' ? def.dispellable(world, entity, instance, by) : def.dispellable !== false\n\t\tif (!dispellable) continue\n\t\tremoveBuff(world, entity, instance.id)\n\t\ttaken++\n\t}\n\treturn taken\n}\n\n/**\n * The effect types of the dispel family, among them `dispel`, which the engine adds to its effect types\n *\n * @internal\n */\nexport const dispelEffects: EffectType[] = [\n\t/**\n\t * Takes the good buffs off enemies and the bad ones off friends, where it lands (`radius`, or the target alone), and\n\t * deals `amount` to every unit there a spell brought (`summoned`), which is magic\n\t */\n\tdefineEffect({ type: 'dispel', run: (context, effect) => {\n\t\t\tconst { world, caster } = context\n\t\t\tconst hurt = valueOf(context, effect.amount)\n\t\t\tfor (const entity of effectTargets(context, { ...effect, affects: effect.affects ?? 'all' }, 'enemies')) {\n\t\t\t\tif (!entity.isUnit) continue\n\t\t\t\tdispelBuffs(world, entity, caster)\n\t\t\t\tif (hurt > 0 && entity.has(summoned) && world.areEnemies(caster.owner, entity.owner))\n\t\t\t\t\tworld.damage(entity, hurt, caster, { damageType: 'magic', ability: context.ability.id })\n\t\t\t}\n\t\t}, fields: ['amount'] })\n]\n"],"mappings":";;;;;;;;;;;AAmBA,SAAgB,YAAY,OAAc,QAAgB,IAAoB;CAC7E,MAAM,QAAQ,MAAM,WAAW,GAAG,OAAO,OAAO,KAAK;CACrD,IAAI,QAAQ;CACZ,KAAK,MAAM,YAAY,CAAC,GAAG,OAAO,KAAK,GAAG;EACzC,MAAM,MAAM,MAAM,SAAS,KAAK,SAAS,EAAE;EAC3C,IAAI,CAAC,CAAC,IAAI,YAAY,OAAO;EAE7B,IAAI,EADgB,OAAO,IAAI,gBAAgB,aAAa,IAAI,YAAY,OAAO,QAAQ,UAAU,EAAE,IAAI,IAAI,gBAAgB,QAC7G;EAClB,WAAW,OAAO,QAAQ,SAAS,EAAE;EACrC;CACD;CACA,OAAO;AACR;;;;;;AAOA,IAAa,gBAA8B,CAK1C,aAAa;CAAE,MAAM;CAAU,MAAM,SAAS,WAAW;EACvD,MAAM,EAAE,OAAO,WAAW;EAC1B,MAAM,OAAO,QAAQ,SAAS,OAAO,MAAM;EAC3C,KAAK,MAAM,UAAU,cAAc,SAAS;GAAE,GAAG;GAAQ,SAAS,OAAO,WAAW;EAAM,GAAG,SAAS,GAAG;GACxG,IAAI,CAAC,OAAO,QAAQ;GACpB,YAAY,OAAO,QAAQ,MAAM;GACjC,IAAI,OAAO,KAAK,OAAO,IAAI,QAAQ,KAAK,MAAM,WAAW,OAAO,OAAO,OAAO,KAAK,GAClF,MAAM,OAAO,QAAQ,MAAM,QAAQ;IAAE,YAAY;IAAS,SAAS,QAAQ,QAAQ;GAAG,CAAC;EACzF;CACD;CAAG,QAAQ,CAAC,QAAQ;AAAE,CAAC,CACzB"}

package/dist/abilities/effectFields.d.ts

@@ -1,7 +1,7 @@
 import type { EffectCommon, EffectFields } from '#engine/defs';
 import type { EditableField } from '#engine/gameData';
 /** The fields every effect may have, whatever its type (`EffectCommon`): offered on every row of effects */
-export declare const COMMON_EFFECT_FIELDS: Readonly<Record<keyof EffectCommon, EditableField>>;
+export declare const COMMON_EFFECT_FIELDS: Readonly<Record<keyof EffectCommon, EditableField | readonly EditableField[]>>;
 /**
  * The engine's fields of an effect by name (`EffectFields`), as the Data panel shows them; `effects`, `onEnd` and
  * `otherwise` are lists of effects. Those of a few values (a missile's `arc`) are a field for each, null for one that