@v12-engine/engine 0.1.0 → 0.4.0

package/dist/abilities/triggers.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Triggers and what uses a buff up (E2E-PLAN AB7): what the passives of a unit (its abilities', its items' and the buffs
+ * it carries: `BuffDef.passive`) set off when its attacks land (`onHit`, every `every`th, using up `consumes`), it is
+ * hurt (`onDamaged`), its abilities hit (`onAbilityHit`), it casts (`onCast`), it kills (`onKill`), its health falls low
+ * (`onLowHealth`), each once in its `cooldown`; what takes a buff off (`removeBuff`, `BuffDef.breaksOn`), and what a buff
+ * does at its most stacks (`onMaxStacks`) and where its carrier dies (`onCarrierDeath`)
+ */
+import { type AbilityDef, type AnyEffect, type BuffBreak } from '#engine/defs';
+import type { BuffInstance, Entity } from '#engine/entity';
+import type { World } from '#engine/world';
+import type { AfterDamage } from '#engine/hooks';
+/**
+ * The kinds of trigger a passive has (`EffectTypes`): what sets each off is said by its type
+ *
+ * @beta
+ */
+export type TriggerType = 'onHit' | 'onKill' | 'onCast' | 'onDamaged' | 'onAbilityHit' | 'onLowHealth' | 'onFatal';
+/**
+ * Takes stacks of a buff off an entity: `count` of the first of it, the buff once none is left; all of it, every one of
+ * it there is, when `count` is left out. What `removeBuff` does, and an attack that `consumes` its buff
+ *
+ * @beta
+ */
+export declare function removeStacks(world: World, entity: Entity, buff: string, count?: number): void;
+/**
+ * One of what an attack of a unit sets off (an `onHit` of its abilities, items or buffs), as the rule of slots sees it
+ * (`RuleSettings.combat.attackModifiers`): where it comes from, its slot and priority
+ *
+ * @beta
+ */
+export interface AttackModifier {
+    /** The `onHit` effect */
+    readonly effect: Readonly<AnyEffect>;
+    /** Where it comes from: an ability the unit learned, an item it carries, a buff on it */
+    readonly from: 'ability' | 'item' | 'buff';
+    /** The ability it goes by: the learned one, the item's passive, the ability that put the buff on (or the buff, as one) */
+    readonly ability: AbilityDef;
+    /** The level it goes off at */
+    readonly level: number;
+    /** Its slot (`EffectFields.slot`): none for one that always adds up */
+    readonly slot?: string;
+    /** Its priority among those of its slot (`EffectFields.priority`): 0 when it says none */
+    readonly priority: number;
+}
+/**
+ * The engine's rule of attack modifiers (`RuleSettings.combat.attackModifiers`): of those that share a slot, only the
+ * one of the highest priority (the first among equals: abilities, then items, then buffs); those of different slots,
+ * and those of none, all of them. In the order they came
+ *
+ * @beta
+ */
+export declare function bySlot(_world: World, _attacker: Entity, _target: Entity, modifiers: readonly AttackModifier[]): readonly AttackModifier[];
+/**
+ * An attack of `attacker` landed on `target` (dead of it or not): its `onHit` triggers are asked. Of those that can go
+ * off (while their buff, not cooling), the game's rule of slots picks (`RuleSettings.combat.attackModifiers`: one a
+ * slot, by priority); each of those counts the attack towards its `every`, those due do what they do to a target
+ * still alive, and use up a stack of their `whileBuff` (`consumes`) either way. One a slot passed over counts nothing
+ */
+export declare function attackLanded(world: World, attacker: Entity, target: Entity, damage: number): void;
+/**
+ * How many of a unit's attacks are counted towards an `onHit` that goes off every so many (`EffectFields.every`): the one
+ * of an ability's passive at `place` in its list, of an item's (`item: true`) or of a buff's (`buff: true`). 0 when none
+ * are: for a screen to show, a test to check
+ *
+ * @beta
+ */
+export declare function attacksCounted(entity: Entity, id: string, place?: number, from?: 'ability' | 'item' | 'buff'): number;
+/** What a unit's casting sets off (`onCast`): for a hero, only one of the abilities it learns */
+export declare function castTriggers(world: World, caster: Entity, cast: AbilityDef): void;
+/** What killing someone sets off (`onKill`); `attack`, whether one of its attacks did */
+export declare function killTriggers(world: World, killer: Entity, victim: Entity, attack: boolean, carried?: readonly BuffInstance[]): void;
+/**
+ * What damage sets off besides an attack's own triggers: the target's `onDamaged` (not for what a trigger's effects did)
+ * and `onLowHealth`, the source's `onAbilityHit`, and the buffs it breaks (`breaksOn`): the target's that break on damage,
+ * the attacker's that break on its attack
+ */
+export declare function damageTriggers(world: World, event: AfterDamage): void;
+/**
+ * Takes off what a unit carries that breaks on what it just did or had done to it (`BuffDef.breaksOn`); `ability`, for
+ * a cast, the ability whose buffs stay (what it put on itself)
+ *
+ * @beta
+ */
+export declare function breakBuffs(world: World, entity: Entity, by: BuffBreak, ability?: string): void;
+/** What the buffs of one dying do where it dies (`onCarrierDeath`), while it still stands there */
+export declare function carrierDied(world: World, entity: Entity): void;
+/** A stack was added to a buff: what it does at its most (`onMaxStacks`), as it gets there */
+export declare function stacked(world: World, carrier: Entity, instance: BuffInstance, before: number): void;
+/**
+ * A unit about to die of a blow or a kill (`onFatal`): the first of its `onFatal` triggers not cooling down (and whose
+ * `chance` draws yes) keeps it alive, with `health` of its max (all of it when left out), and does its effects in its
+ * name, its cooldown started. True when one did: it does not die
+ */
+export declare function cheatDeath(world: World, entity: Entity): boolean;
+/** Every trigger type, for the rules' check and the Data panel */
+export declare const TRIGGER_TYPES: readonly TriggerType[];
+/** Every way a buff breaks (`BuffBreak`), for the rules' check */
+export declare const BUFF_BREAKS: readonly BuffBreak[];

package/dist/abilities/triggers.js

@@ -0,0 +1,351 @@
+import { at, passiveEffects } from "../defs.js";
+import { defineComponent } from "../components.js";
+import { carriedPassives } from "../inventory.js";
+import { learnsOf } from "../formState.js";
+import { heroState } from "../hero.js";
+import { byChance } from "./chance.js";
+import { buffEffects, run } from "./land.js";
+import { removeBuff } from "./buffs.js";
+//#region src/abilities/triggers.ts
+/**
+* Triggers and what uses a buff up (E2E-PLAN AB7): what the passives of a unit (its abilities', its items' and the buffs
+* it carries: `BuffDef.passive`) set off when its attacks land (`onHit`, every `every`th, using up `consumes`), it is
+* hurt (`onDamaged`), its abilities hit (`onAbilityHit`), it casts (`onCast`), it kills (`onKill`), its health falls low
+* (`onLowHealth`), each once in its `cooldown`; what takes a buff off (`removeBuff`, `BuffDef.breaksOn`), and what a buff
+* does at its most stacks (`onMaxStacks`) and where its carrier dies (`onCarrierDeath`)
+*/
+/**
+* What the triggers of a unit keep on it, by trigger (`<where>:<id>:<place>`): `n:` its attacks counted towards `every`,
+* `t:` the time it may go off again (an item's and a buff's `cooldown`; an ability's is its own). Saved with the unit
+*
+* @internal
+*/
+var triggerState = defineComponent({ id: "core.triggers" });
+/** The places of a list's triggers of each type, worked out once a list */
+var placesByList = /* @__PURE__ */ new WeakMap();
+function places(list, type) {
+	let found = placesByList.get(list);
+	if (!found) {
+		found = {};
+		list.forEach((effect, index) => (found[effect.type] ??= []).push(index));
+		placesByList.set(list, found);
+	}
+	return found[type];
+}
+/** The ability a buff's trigger goes by: the one that put the buff on, or the buff itself */
+function abilityOfBuff(world, instance, def) {
+	return instance.ability && world.registry.abilities.has(instance.ability) ? world.registry.ability(instance.ability) : {
+		id: instance.id,
+		name: def.name,
+		target: "passive",
+		effects: []
+	};
+}
+/**
+* The triggers of a type a unit has now: those of its abilities (learned), of what it carries (an item's `passive`),
+* and of the buffs on it (`BuffDef.passive`), in that order. A list of its own, so that what they do (a buff used up)
+* changes nothing being walked
+*/
+function triggersOf(world, entity, type, abilitiesOnly = false) {
+	const out = [];
+	for (const state of entity.abilities) {
+		if (state.level < 1) continue;
+		const ability = world.registry.ability(state.id);
+		const list = passiveEffects(ability);
+		for (const index of places(list, type) ?? []) out.push({
+			effect: list[index],
+			ability,
+			level: state.level,
+			key: `a:${ability.id}:${index}`,
+			state
+		});
+	}
+	if (abilitiesOnly) return out;
+	for (const passive of carriedPassives(world, entity)) {
+		const ability = world.registry.ability(passive);
+		const list = passiveEffects(ability);
+		for (const index of places(list, type) ?? []) out.push({
+			effect: list[index],
+			ability,
+			level: 1,
+			key: `i:${ability.id}:${index}`
+		});
+	}
+	for (const instance of entity.buffs) {
+		const def = world.registry.buff(instance.id);
+		if (!def.passive) continue;
+		for (const index of places(def.passive, type) ?? []) out.push({
+			effect: def.passive[index],
+			ability: abilityOfBuff(world, instance, def),
+			level: instance.level,
+			key: `b:${instance.id}:${index}`,
+			buff: instance
+		});
+	}
+	return out;
+}
+/** Whether a trigger is waiting out its `cooldown` */
+function cooling(world, entity, trigger) {
+	if (trigger.effect.cooldown === void 0) return false;
+	if (trigger.state) return trigger.state.cooldown > 0;
+	return (entity.get(triggerState)?.[`t:${trigger.key}`] ?? -Infinity) > world.time;
+}
+/** A trigger went off: its `cooldown` starts */
+function cool(world, entity, trigger) {
+	const seconds = at(trigger.effect.cooldown, trigger.level, 0);
+	if (trigger.effect.cooldown === void 0 || seconds <= 0) return;
+	if (trigger.state) {
+		trigger.state.cooldown = seconds;
+		return;
+	}
+	keep(entity)[`t:${trigger.key}`] = world.time + seconds;
+}
+function keep(entity) {
+	let kept = entity.get(triggerState);
+	if (!kept) entity.set(triggerState, kept = {});
+	return kept;
+}
+/** How deep in the effects of triggers the world is: what they do sets off no `onDamaged`, `onAbilityHit` (no echo) */
+var triggering = 0;
+/**
+* Runs a trigger's effects, its cooldown started; what they do sets off no other trigger of damage. One that goes off by
+* `chance` does nothing, its cooldown not started, when the draw says no
+*/
+function fire(world, carrier, trigger, target, damage, first) {
+	const where = target ?? carrier;
+	const context = {
+		world,
+		caster: carrier,
+		ability: trigger.ability,
+		level: trigger.level,
+		target,
+		point: {
+			x: where.pos.x,
+			z: where.pos.z
+		},
+		...damage !== void 0 && { damage }
+	};
+	if (trigger.effect.chance !== void 0 && !byChance(context, trigger.effect.chance, target)) return false;
+	cool(world, carrier, trigger);
+	first?.();
+	triggering++;
+	try {
+		run(context, trigger.effect.effects);
+	} finally {
+		triggering--;
+	}
+	return true;
+}
+/**
+* Takes stacks of a buff off an entity: `count` of the first of it, the buff once none is left; all of it, every one of
+* it there is, when `count` is left out. What `removeBuff` does, and an attack that `consumes` its buff
+*
+* @beta
+*/
+function removeStacks(world, entity, buff, count) {
+	if (count === void 0) {
+		while (entity.buffs.some((instance) => instance.id === buff)) removeOne(world, entity, buff);
+		return;
+	}
+	const instance = entity.buffs.find((carried) => carried.id === buff);
+	if (!instance) return;
+	if ((instance.stacks ?? 0) > count) instance.stacks -= count;
+	else removeOne(world, entity, buff);
+}
+/** Taking one buff off as `removeBuff` does, its hooks told */
+var removeOne = (world, entity, buff) => removeBuff(world, entity, buff);
+/**
+* The engine's rule of attack modifiers (`RuleSettings.combat.attackModifiers`): of those that share a slot, only the
+* one of the highest priority (the first among equals: abilities, then items, then buffs); those of different slots,
+* and those of none, all of them. In the order they came
+*
+* @beta
+*/
+function bySlot(_world, _attacker, _target, modifiers) {
+	if (!modifiers.some((modifier) => modifier.slot !== void 0)) return modifiers;
+	const best = /* @__PURE__ */ new Map();
+	for (const modifier of modifiers) {
+		if (modifier.slot === void 0) continue;
+		const held = best.get(modifier.slot);
+		if (!held || modifier.priority > held.priority) best.set(modifier.slot, modifier);
+	}
+	return modifiers.filter((modifier) => modifier.slot === void 0 || best.get(modifier.slot) === modifier);
+}
+var FROM = {
+	a: "ability",
+	i: "item",
+	b: "buff"
+};
+/**
+* Of the `onHit` triggers that can go off (their buff there, not cooling), those the game's rule of slots lets
+* (`RuleSettings.combat.attackModifiers`): all of them where none has a slot and the rule is the engine's
+*/
+function modifiersOf(world, attacker, target, ready) {
+	const rule = world.settings.combat.attackModifiers;
+	if (!ready.length || rule === bySlot && !ready.some((trigger) => trigger.effect.slot !== void 0)) return ready;
+	const byModifier = /* @__PURE__ */ new Map();
+	return rule(world, attacker, target, ready.map((trigger) => {
+		const { effect } = trigger;
+		const modifier = {
+			effect,
+			from: FROM[trigger.key[0]],
+			ability: trigger.ability,
+			level: trigger.level,
+			...effect.slot !== void 0 && { slot: effect.slot },
+			priority: effect.priority ?? 0
+		};
+		byModifier.set(modifier, trigger);
+		return modifier;
+	})).flatMap((modifier) => byModifier.get(modifier) ?? []);
+}
+/**
+* An attack of `attacker` landed on `target` (dead of it or not): its `onHit` triggers are asked. Of those that can go
+* off (while their buff, not cooling), the game's rule of slots picks (`RuleSettings.combat.attackModifiers`: one a
+* slot, by priority); each of those counts the attack towards its `every`, those due do what they do to a target
+* still alive, and use up a stack of their `whileBuff` (`consumes`) either way. One a slot passed over counts nothing
+*/
+function attackLanded(world, attacker, target, damage) {
+	const ready = triggersOf(world, attacker, "onHit").filter((trigger) => !(trigger.effect.whileBuff && !attacker.buffs.some((instance) => instance.id === trigger.effect.whileBuff)) && !cooling(world, attacker, trigger));
+	for (const trigger of modifiersOf(world, attacker, target, ready)) {
+		const { effect } = trigger;
+		if (effect.every !== void 0 && effect.every > 1) {
+			const kept = keep(attacker);
+			const count = (kept[`n:${trigger.key}`] ?? 0) + 1;
+			if (count < effect.every) {
+				kept[`n:${trigger.key}`] = count;
+				continue;
+			}
+			delete kept[`n:${trigger.key}`];
+		}
+		if (target.alive) fire(world, attacker, trigger, target, damage);
+		else cool(world, attacker, trigger);
+		if (effect.consumes && effect.whileBuff && attacker.alive) removeStacks(world, attacker, effect.whileBuff, 1);
+	}
+}
+/**
+* How many of a unit's attacks are counted towards an `onHit` that goes off every so many (`EffectFields.every`): the one
+* of an ability's passive at `place` in its list, of an item's (`item: true`) or of a buff's (`buff: true`). 0 when none
+* are: for a screen to show, a test to check
+*
+* @beta
+*/
+function attacksCounted(entity, id, place = 0, from = "ability") {
+	return entity.get(triggerState)?.[`n:${from[0]}:${id}:${place}`] ?? 0;
+}
+/** What a unit's casting sets off (`onCast`): for a hero, only one of the abilities it learns */
+function castTriggers(world, caster, cast) {
+	if (caster.def.hero && !learnsOf(caster).includes(cast.id)) return;
+	for (const trigger of triggersOf(world, caster, "onCast")) {
+		if (cooling(world, caster, trigger)) continue;
+		fire(world, caster, trigger, void 0);
+	}
+}
+/** What killing someone sets off (`onKill`); `attack`, whether one of its attacks did */
+function killTriggers(world, killer, victim, attack, carried) {
+	for (const trigger of triggersOf(world, killer, "onKill")) {
+		const { effect } = trigger;
+		if (effect.attack && !attack || effect.only === "heroes" && !victim.has(heroState)) continue;
+		if (effect.whileBuff && !killer.buffs.some((instance) => instance.id === effect.whileBuff)) continue;
+		if (cooling(world, killer, trigger)) continue;
+		if (!carried?.length) {
+			fire(world, killer, trigger, victim);
+			continue;
+		}
+		const buffs = victim.buffs;
+		buffs.unshift(...carried);
+		victim.buffsChanged();
+		try {
+			fire(world, killer, trigger, victim);
+		} finally {
+			for (let i = buffs.length - 1; i >= 0; i--) if (carried.includes(buffs[i])) buffs.splice(i, 1);
+			victim.buffsChanged();
+		}
+	}
+}
+/** Whether an attack is made from up close: one with no missile (`AttackDef.projectileSpeed`) */
+var melee = (entity) => !entity.def.attacks?.[0]?.projectileSpeed;
+/**
+* What damage sets off besides an attack's own triggers: the target's `onDamaged` (not for what a trigger's effects did)
+* and `onLowHealth`, the source's `onAbilityHit`, and the buffs it breaks (`breaksOn`): the target's that break on damage,
+* the attacker's that break on its attack
+*/
+function damageTriggers(world, event) {
+	const { target, source, dealt, attack, ability } = event;
+	if (!triggering && target.alive && source && source !== target) for (const trigger of triggersOf(world, target, "onDamaged")) {
+		const { effect } = trigger;
+		if ((effect.attack || effect.melee) && !attack) continue;
+		if (effect.melee && !melee(source)) continue;
+		if (cooling(world, target, trigger) || !source.alive) continue;
+		fire(world, target, trigger, source, dealt);
+	}
+	if (!triggering && source?.alive && !attack && ability !== void 0 && world.areEnemies(source.owner, target.owner)) {
+		for (const trigger of triggersOf(world, source, "onAbilityHit")) if (!cooling(world, source, trigger)) fire(world, source, trigger, target, dealt);
+	}
+	if (target.alive && dealt > 0) for (const trigger of triggersOf(world, target, "onLowHealth")) {
+		const line = (trigger.effect.below ?? 0) * target.maxHealth;
+		if (target.health >= line || target.health + dealt < line || cooling(world, target, trigger)) continue;
+		fire(world, target, trigger, void 0);
+	}
+	if (dealt > 0 && target.alive && target.buffs.length) breakBuffs(world, target, "damage");
+	if (attack && source?.alive && source.buffs.length) breakBuffs(world, source, "attack");
+}
+/**
+* Takes off what a unit carries that breaks on what it just did or had done to it (`BuffDef.breaksOn`); `ability`, for
+* a cast, the ability whose buffs stay (what it put on itself)
+*
+* @beta
+*/
+function breakBuffs(world, entity, by, ability) {
+	for (let i = entity.buffs.length - 1; i >= 0; i--) {
+		const instance = entity.buffs[i];
+		if (!instance || ability !== void 0 && instance.ability === ability) continue;
+		if (world.registry.buff(instance.id).breaksOn?.includes(by)) removeOne(world, entity, instance.id);
+	}
+}
+/** What the buffs of one dying do where it dies (`onCarrierDeath`), while it still stands there */
+function carrierDied(world, entity) {
+	for (const instance of [...entity.buffs]) {
+		const def = world.registry.buff(instance.id);
+		if (def.onCarrierDeath) buffEffects(world, entity, instance, def.onCarrierDeath);
+	}
+}
+/** A stack was added to a buff: what it does at its most (`onMaxStacks`), as it gets there */
+function stacked(world, carrier, instance, before) {
+	const def = world.registry.buff(instance.id);
+	if (!def.onMaxStacks || def.maxStacks === void 0) return;
+	if (before < def.maxStacks && (instance.stacks ?? 0) >= def.maxStacks) buffEffects(world, carrier, instance, def.onMaxStacks);
+}
+/**
+* A unit about to die of a blow or a kill (`onFatal`): the first of its `onFatal` triggers not cooling down (and whose
+* `chance` draws yes) keeps it alive, with `health` of its max (all of it when left out), and does its effects in its
+* name, its cooldown started. True when one did: it does not die
+*/
+function cheatDeath(world, entity) {
+	if (!entity.isUnit) return false;
+	for (const trigger of triggersOf(world, entity, "onFatal")) {
+		if (cooling(world, entity, trigger)) continue;
+		const share = trigger.effect.health ?? 1;
+		if (fire(world, entity, trigger, void 0, void 0, () => entity.health = Math.max(Math.min(share, 1) * entity.maxHealth, 1))) return true;
+	}
+	return false;
+}
+/** Every trigger type, for the rules' check and the Data panel */
+var TRIGGER_TYPES = [
+	"onHit",
+	"onKill",
+	"onCast",
+	"onDamaged",
+	"onAbilityHit",
+	"onLowHealth",
+	"onFatal"
+];
+/** Every way a buff breaks (`BuffBreak`), for the rules' check */
+var BUFF_BREAKS = [
+	"damage",
+	"attack",
+	"cast"
+];
+//#endregion
+export { BUFF_BREAKS, TRIGGER_TYPES, attackLanded, attacksCounted, breakBuffs, bySlot, carrierDied, castTriggers, cheatDeath, damageTriggers, killTriggers, removeStacks, stacked, triggerState };
+
+//# sourceMappingURL=triggers.js.map

package/dist/abilities/triggers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"triggers.js","names":[],"sources":["../../src/abilities/triggers.ts"],"sourcesContent":["/**\n * Triggers and what uses a buff up (E2E-PLAN AB7): what the passives of a unit (its abilities', its items' and the buffs\n * it carries: `BuffDef.passive`) set off when its attacks land (`onHit`, every `every`th, using up `consumes`), it is\n * hurt (`onDamaged`), its abilities hit (`onAbilityHit`), it casts (`onCast`), it kills (`onKill`), its health falls low\n * (`onLowHealth`), each once in its `cooldown`; what takes a buff off (`removeBuff`, `BuffDef.breaksOn`), and what a buff\n * does at its most stacks (`onMaxStacks`) and where its carrier dies (`onCarrierDeath`)\n */\nimport { type AbilityDef, type AnyEffect, at, type BuffBreak, type BuffDef, type EffectDef, passiveEffects } from '#engine/defs'\nimport { defineComponent } from '#engine/components'\nimport type { AbilityState, BuffInstance, Entity } from '#engine/entity'\nimport { heroState } from '#engine/hero'\nimport { learnsOf } from '#engine/formState'\nimport { carriedPassives } from '#engine/inventory'\nimport type { World } from '#engine/world'\nimport type { AfterDamage } from '#engine/hooks'\nimport { buffEffects, run } from './land'\nimport { removeBuff } from './buffs'\nimport { byChance } from './chance'\n\n/**\n * The kinds of trigger a passive has (`EffectTypes`): what sets each off is said by its type\n *\n * @beta\n */\nexport type TriggerType = 'onHit' | 'onKill' | 'onCast' | 'onDamaged' | 'onAbilityHit' | 'onLowHealth' | 'onFatal'\n\n/**\n * What the triggers of a unit keep on it, by trigger (`<where>:<id>:<place>`): `n:` its attacks counted towards `every`,\n * `t:` the time it may go off again (an item's and a buff's `cooldown`; an ability's is its own). Saved with the unit\n *\n * @internal\n */\nexport const triggerState = defineComponent<Record<string, number>>({ id: 'core.triggers' })\n\n/** One trigger of a unit, about to be asked: the effect, whose it is, at what level, and where its count and time are kept */\ninterface Trigger {\n\teffect: AnyEffect\n\tability: AbilityDef\n\tlevel: number\n\tkey: string\n\t/** The ability's own state, for one of an ability: its cooldown is the trigger's */\n\tstate?: AbilityState\n\t/** The buff it comes from, for one of a buff's */\n\tbuff?: BuffInstance\n}\n\n/** The places of a list's triggers of each type, worked out once a list */\nconst placesByList = new WeakMap<readonly EffectDef[], Partial<Record<string, number[]>>>()\n\nfunction places(list: readonly EffectDef[], type: TriggerType): number[] | undefined {\n\tlet found = placesByList.get(list)\n\tif (!found) {\n\t\tfound = {}\n\t\tlist.forEach((effect, index) => (found![effect.type] ??= []).push(index))\n\t\tplacesByList.set(list, found)\n\t}\n\treturn found[type]\n}\n\n/** The ability a buff's trigger goes by: the one that put the buff on, or the buff itself */\nfunction abilityOfBuff(world: World, instance: BuffInstance, def: BuffDef): AbilityDef {\n\treturn instance.ability && world.registry.abilities.has(instance.ability)\n\t\t? world.registry.ability(instance.ability)\n\t\t: ({ id: instance.id, name: def.name, target: 'passive', effects: [] } as AbilityDef)\n}\n\n/**\n * The triggers of a type a unit has now: those of its abilities (learned), of what it carries (an item's `passive`),\n * and of the buffs on it (`BuffDef.passive`), in that order. A list of its own, so that what they do (a buff used up)\n * changes nothing being walked\n */\nfunction triggersOf(world: World, entity: Entity, type: TriggerType, abilitiesOnly = false): Trigger[] {\n\tconst out: Trigger[] = []\n\tfor (const state of entity.abilities) {\n\t\tif (state.level < 1) continue\n\t\tconst ability = world.registry.ability(state.id)\n\t\tconst list = passiveEffects(ability)\n\t\tfor (const index of places(list, type) ?? []) out.push({ effect: list[index] as AnyEffect, ability, level: state.level, key: `a:${ability.id}:${index}`, state })\n\t}\n\tif (abilitiesOnly) return out\n\tfor (const passive of carriedPassives(world, entity)) {\n\t\tconst ability = world.registry.ability(passive)\n\t\tconst list = passiveEffects(ability)\n\t\tfor (const index of places(list, type) ?? []) out.push({ effect: list[index] as AnyEffect, ability, level: 1, key: `i:${ability.id}:${index}` })\n\t}\n\tfor (const instance of entity.buffs) {\n\t\tconst def = world.registry.buff(instance.id)\n\t\tif (!def.passive) continue\n\t\tfor (const index of places(def.passive, type) ?? [])\n\t\t\tout.push({ effect: def.passive[index] as AnyEffect, ability: abilityOfBuff(world, instance, def), level: instance.level, key: `b:${instance.id}:${index}`, buff: instance })\n\t}\n\treturn out\n}\n\n/** Whether a trigger is waiting out its `cooldown` */\nfunction cooling(world: World, entity: Entity, trigger: Trigger): boolean {\n\tif (trigger.effect.cooldown === undefined) return false\n\tif (trigger.state) return trigger.state.cooldown > 0\n\treturn (entity.get(triggerState)?.[`t:${trigger.key}`] ?? -Infinity) > world.time\n}\n\n/** A trigger went off: its `cooldown` starts */\nfunction cool(world: World, entity: Entity, trigger: Trigger): void {\n\tconst seconds = at(trigger.effect.cooldown, trigger.level, 0)\n\tif (trigger.effect.cooldown === undefined || seconds <= 0) return\n\tif (trigger.state) {\n\t\ttrigger.state.cooldown = seconds\n\t\treturn\n\t}\n\tkeep(entity)[`t:${trigger.key}`] = world.time + seconds\n}\n\nfunction keep(entity: Entity): Record<string, number> {\n\tlet kept = entity.get(triggerState)\n\tif (!kept) entity.set(triggerState, (kept = {}))\n\treturn kept\n}\n\n/** How deep in the effects of triggers the world is: what they do sets off no `onDamaged`, `onAbilityHit` (no echo) */\nlet triggering = 0\n\n/**\n * Runs a trigger's effects, its cooldown started; what they do sets off no other trigger of damage. One that goes off by\n * `chance` does nothing, its cooldown not started, when the draw says no\n */\nfunction fire(world: World, carrier: Entity, trigger: Trigger, target: Entity | undefined, damage?: number, first?: () => void): boolean {\n\tconst where = target ?? carrier\n\tconst context = { world, caster: carrier, ability: trigger.ability, level: trigger.level, target, point: { x: where.pos.x, z: where.pos.z }, ...(damage !== undefined && { damage }) }\n\tif (trigger.effect.chance !== undefined && !byChance(context, trigger.effect.chance, target)) return false\n\tcool(world, carrier, trigger)\n\tfirst?.()\n\ttriggering++\n\ttry {\n\t\trun(context, trigger.effect.effects)\n\t} finally {\n\t\ttriggering--\n\t}\n\treturn true\n}\n\n/**\n * Takes stacks of a buff off an entity: `count` of the first of it, the buff once none is left; all of it, every one of\n * it there is, when `count` is left out. What `removeBuff` does, and an attack that `consumes` its buff\n *\n * @beta\n */\nexport function removeStacks(world: World, entity: Entity, buff: string, count?: number): void {\n\tif (count === undefined) {\n\t\twhile (entity.buffs.some((instance) => instance.id === buff)) removeOne(world, entity, buff)\n\t\treturn\n\t}\n\tconst instance = entity.buffs.find((carried) => carried.id === buff)\n\tif (!instance) return\n\tif ((instance.stacks ?? 0) > count) instance.stacks! -= count\n\telse removeOne(world, entity, buff)\n}\n\n/** Taking one buff off as `removeBuff` does, its hooks told */\nconst removeOne = (world: World, entity: Entity, buff: string) => removeBuff(world, entity, buff)\n\n/**\n * One of what an attack of a unit sets off (an `onHit` of its abilities, items or buffs), as the rule of slots sees it\n * (`RuleSettings.combat.attackModifiers`): where it comes from, its slot and priority\n *\n * @beta\n */\nexport interface AttackModifier {\n\t/** The `onHit` effect */\n\treadonly effect: Readonly<AnyEffect>\n\t/** Where it comes from: an ability the unit learned, an item it carries, a buff on it */\n\treadonly from: 'ability' | 'item' | 'buff'\n\t/** The ability it goes by: the learned one, the item's passive, the ability that put the buff on (or the buff, as one) */\n\treadonly ability: AbilityDef\n\t/** The level it goes off at */\n\treadonly level: number\n\t/** Its slot (`EffectFields.slot`): none for one that always adds up */\n\treadonly slot?: string\n\t/** Its priority among those of its slot (`EffectFields.priority`): 0 when it says none */\n\treadonly priority: number\n}\n\n/**\n * The engine's rule of attack modifiers (`RuleSettings.combat.attackModifiers`): of those that share a slot, only the\n * one of the highest priority (the first among equals: abilities, then items, then buffs); those of different slots,\n * and those of none, all of them. In the order they came\n *\n * @beta\n */\nexport function bySlot(_world: World, _attacker: Entity, _target: Entity, modifiers: readonly AttackModifier[]): readonly AttackModifier[] {\n\tif (!modifiers.some((modifier) => modifier.slot !== undefined)) return modifiers\n\tconst best = new Map<string, AttackModifier>()\n\tfor (const modifier of modifiers) {\n\t\tif (modifier.slot === undefined) continue\n\t\tconst held = best.get(modifier.slot)\n\t\tif (!held || modifier.priority > held.priority) best.set(modifier.slot, modifier)\n\t}\n\treturn modifiers.filter((modifier) => modifier.slot === undefined || best.get(modifier.slot) === modifier)\n}\n\nconst FROM: Record<string, AttackModifier['from']> = { a: 'ability', i: 'item', b: 'buff' }\n\n/**\n * Of the `onHit` triggers that can go off (their buff there, not cooling), those the game's rule of slots lets\n * (`RuleSettings.combat.attackModifiers`): all of them where none has a slot and the rule is the engine's\n */\nfunction modifiersOf(world: World, attacker: Entity, target: Entity, ready: Trigger[]): Trigger[] {\n\tconst rule = world.settings.combat.attackModifiers\n\tif (!ready.length || (rule === bySlot && !ready.some((trigger) => trigger.effect.slot !== undefined))) return ready\n\tconst byModifier = new Map<AttackModifier, Trigger>()\n\tconst modifiers = ready.map((trigger) => {\n\t\tconst { effect } = trigger\n\t\tconst modifier: AttackModifier = {\n\t\t\teffect,\n\t\t\tfrom: FROM[trigger.key[0]],\n\t\t\tability: trigger.ability,\n\t\t\tlevel: trigger.level,\n\t\t\t...(effect.slot !== undefined && { slot: effect.slot }),\n\t\t\tpriority: effect.priority ?? 0\n\t\t}\n\t\tbyModifier.set(modifier, trigger)\n\t\treturn modifier\n\t})\n\treturn rule(world, attacker, target, modifiers).flatMap((modifier) => byModifier.get(modifier) ?? [])\n}\n\n/**\n * An attack of `attacker` landed on `target` (dead of it or not): its `onHit` triggers are asked. Of those that can go\n * off (while their buff, not cooling), the game's rule of slots picks (`RuleSettings.combat.attackModifiers`: one a\n * slot, by priority); each of those counts the attack towards its `every`, those due do what they do to a target\n * still alive, and use up a stack of their `whileBuff` (`consumes`) either way. One a slot passed over counts nothing\n */\nexport function attackLanded(world: World, attacker: Entity, target: Entity, damage: number): void {\n\tconst ready = triggersOf(world, attacker, 'onHit').filter(\n\t\t(trigger) => !(trigger.effect.whileBuff && !attacker.buffs.some((instance) => instance.id === trigger.effect.whileBuff)) && !cooling(world, attacker, trigger)\n\t)\n\tfor (const trigger of modifiersOf(world, attacker, target, ready)) {\n\t\tconst { effect } = trigger\n\t\tif (effect.every !== undefined && effect.every > 1) {\n\t\t\tconst kept = keep(attacker)\n\t\t\tconst count = (kept[`n:${trigger.key}`] ?? 0) + 1\n\t\t\tif (count < effect.every) {\n\t\t\t\tkept[`n:${trigger.key}`] = count\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tdelete kept[`n:${trigger.key}`]\n\t\t}\n\t\tif (target.alive) fire(world, attacker, trigger, target, damage)\n\t\telse cool(world, attacker, trigger)\n\t\tif (effect.consumes && effect.whileBuff && attacker.alive) removeStacks(world, attacker, effect.whileBuff, 1)\n\t}\n}\n\n/**\n * How many of a unit's attacks are counted towards an `onHit` that goes off every so many (`EffectFields.every`): the one\n * of an ability's passive at `place` in its list, of an item's (`item: true`) or of a buff's (`buff: true`). 0 when none\n * are: for a screen to show, a test to check\n *\n * @beta\n */\nexport function attacksCounted(entity: Entity, id: string, place = 0, from: 'ability' | 'item' | 'buff' = 'ability'): number {\n\treturn entity.get(triggerState)?.[`n:${from[0]}:${id}:${place}`] ?? 0\n}\n\n/** What a unit's casting sets off (`onCast`): for a hero, only one of the abilities it learns */\nexport function castTriggers(world: World, caster: Entity, cast: AbilityDef): void {\n\tif (caster.def.hero && !learnsOf(caster).includes(cast.id)) return\n\tfor (const trigger of triggersOf(world, caster, 'onCast')) {\n\t\tif (cooling(world, caster, trigger)) continue\n\t\tfire(world, caster, trigger, undefined)\n\t}\n}\n\n/** What killing someone sets off (`onKill`); `attack`, whether one of its attacks did */\nexport function killTriggers(world: World, killer: Entity, victim: Entity, attack: boolean, carried?: readonly BuffInstance[]): void {\n\tfor (const trigger of triggersOf(world, killer, 'onKill')) {\n\t\tconst { effect } = trigger\n\t\tif ((effect.attack && !attack) || (effect.only === 'heroes' && !victim.has(heroState))) continue\n\t\tif (effect.whileBuff && !killer.buffs.some((instance) => instance.id === effect.whileBuff)) continue\n\t\tif (cooling(world, killer, trigger)) continue\n\t\tif (!carried?.length) {\n\t\t\tfire(world, killer, trigger, victim)\n\t\t\tcontinue\n\t\t}\n\t\t// the one killed carries what it did as it fell while the effects ask it (Kindred's mark, B44), and not after\n\t\tconst buffs = victim.buffs as BuffInstance[]\n\t\tbuffs.unshift(...carried)\n\t\tvictim.buffsChanged()\n\t\ttry {\n\t\t\tfire(world, killer, trigger, victim)\n\t\t} finally {\n\t\t\tfor (let i = buffs.length - 1; i >= 0; i--) if (carried.includes(buffs[i])) buffs.splice(i, 1)\n\t\t\tvictim.buffsChanged()\n\t\t}\n\t}\n}\n\n/** Whether an attack is made from up close: one with no missile (`AttackDef.projectileSpeed`) */\nconst melee = (entity: Entity) => !entity.def.attacks?.[0]?.projectileSpeed\n\n/**\n * What damage sets off besides an attack's own triggers: the target's `onDamaged` (not for what a trigger's effects did)\n * and `onLowHealth`, the source's `onAbilityHit`, and the buffs it breaks (`breaksOn`): the target's that break on damage,\n * the attacker's that break on its attack\n */\nexport function damageTriggers(world: World, event: AfterDamage): void {\n\tconst { target, source, dealt, attack, ability } = event\n\tif (!triggering && target.alive && source && source !== target) {\n\t\tfor (const trigger of triggersOf(world, target, 'onDamaged')) {\n\t\t\tconst { effect } = trigger\n\t\t\tif ((effect.attack || effect.melee) && !attack) continue\n\t\t\tif (effect.melee && !melee(source)) continue\n\t\t\tif (cooling(world, target, trigger) || !source.alive) continue\n\t\t\tfire(world, target, trigger, source, dealt)\n\t\t}\n\t}\n\tif (!triggering && source?.alive && !attack && ability !== undefined && world.areEnemies(source.owner, target.owner))\n\t\tfor (const trigger of triggersOf(world, source, 'onAbilityHit')) if (!cooling(world, source, trigger)) fire(world, source, trigger, target, dealt)\n\tif (target.alive && dealt > 0)\n\t\tfor (const trigger of triggersOf(world, target, 'onLowHealth')) {\n\t\t\tconst line = (trigger.effect.below ?? 0) * target.maxHealth\n\t\t\tif (target.health >= line || target.health + dealt < line || cooling(world, target, trigger)) continue\n\t\t\tfire(world, target, trigger, undefined)\n\t\t}\n\tif (dealt > 0 && target.alive && target.buffs.length) breakBuffs(world, target, 'damage')\n\tif (attack && source?.alive && source.buffs.length) breakBuffs(world, source, 'attack')\n}\n\n/**\n * Takes off what a unit carries that breaks on what it just did or had done to it (`BuffDef.breaksOn`); `ability`, for\n * a cast, the ability whose buffs stay (what it put on itself)\n *\n * @beta\n */\nexport function breakBuffs(world: World, entity: Entity, by: BuffBreak, ability?: string): void {\n\tfor (let i = entity.buffs.length - 1; i >= 0; i--) {\n\t\tconst instance = entity.buffs[i]\n\t\tif (!instance || (ability !== undefined && instance.ability === ability)) continue\n\t\tif (world.registry.buff(instance.id).breaksOn?.includes(by)) removeOne(world, entity, instance.id)\n\t}\n}\n\n/** What the buffs of one dying do where it dies (`onCarrierDeath`), while it still stands there */\nexport function carrierDied(world: World, entity: Entity): void {\n\tfor (const instance of [...entity.buffs]) {\n\t\tconst def = world.registry.buff(instance.id)\n\t\tif (def.onCarrierDeath) buffEffects(world, entity, instance, def.onCarrierDeath)\n\t}\n}\n\n/** A stack was added to a buff: what it does at its most (`onMaxStacks`), as it gets there */\nexport function stacked(world: World, carrier: Entity, instance: BuffInstance, before: number): void {\n\tconst def = world.registry.buff(instance.id)\n\tif (!def.onMaxStacks || def.maxStacks === undefined) return\n\tif (before < def.maxStacks && (instance.stacks ?? 0) >= def.maxStacks) buffEffects(world, carrier, instance, def.onMaxStacks)\n}\n\n/**\n * A unit about to die of a blow or a kill (`onFatal`): the first of its `onFatal` triggers not cooling down (and whose\n * `chance` draws yes) keeps it alive, with `health` of its max (all of it when left out), and does its effects in its\n * name, its cooldown started. True when one did: it does not die\n */\nexport function cheatDeath(world: World, entity: Entity): boolean {\n\tif (!entity.isUnit) return false\n\tfor (const trigger of triggersOf(world, entity, 'onFatal')) {\n\t\tif (cooling(world, entity, trigger)) continue\n\t\tconst share = trigger.effect.health ?? 1\n\t\tif (fire(world, entity, trigger, undefined, undefined, () => (entity.health = Math.max(Math.min(share, 1) * entity.maxHealth, 1)))) return true\n\t}\n\treturn false\n}\n\n/** Every trigger type, for the rules' check and the Data panel */\nexport const TRIGGER_TYPES: readonly TriggerType[] = ['onHit', 'onKill', 'onCast', 'onDamaged', 'onAbilityHit', 'onLowHealth', 'onFatal']\n\n/** Every way a buff breaks (`BuffBreak`), for the rules' check */\nexport const BUFF_BREAKS: readonly BuffBreak[] = ['damage', 'attack', 'cast']\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAa,eAAe,gBAAwC,EAAE,IAAI,gBAAgB,CAAC;;AAe3F,IAAM,+BAAe,IAAI,QAAiE;AAE1F,SAAS,OAAO,MAA4B,MAAyC;CACpF,IAAI,QAAQ,aAAa,IAAI,IAAI;CACjC,IAAI,CAAC,OAAO;EACX,QAAQ,CAAC;EACT,KAAK,SAAS,QAAQ,WAAW,MAAO,OAAO,UAAU,CAAC,EAAA,CAAG,KAAK,KAAK,CAAC;EACxE,aAAa,IAAI,MAAM,KAAK;CAC7B;CACA,OAAO,MAAM;AACd;;AAGA,SAAS,cAAc,OAAc,UAAwB,KAA0B;CACtF,OAAO,SAAS,WAAW,MAAM,SAAS,UAAU,IAAI,SAAS,OAAO,IACrE,MAAM,SAAS,QAAQ,SAAS,OAAO,IACtC;EAAE,IAAI,SAAS;EAAI,MAAM,IAAI;EAAM,QAAQ;EAAW,SAAS,CAAC;CAAE;AACvE;;;;;;AAOA,SAAS,WAAW,OAAc,QAAgB,MAAmB,gBAAgB,OAAkB;CACtG,MAAM,MAAiB,CAAC;CACxB,KAAK,MAAM,SAAS,OAAO,WAAW;EACrC,IAAI,MAAM,QAAQ,GAAG;EACrB,MAAM,UAAU,MAAM,SAAS,QAAQ,MAAM,EAAE;EAC/C,MAAM,OAAO,eAAe,OAAO;EACnC,KAAK,MAAM,SAAS,OAAO,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK;GAAE,QAAQ,KAAK;GAAqB;GAAS,OAAO,MAAM;GAAO,KAAK,KAAK,QAAQ,GAAG,GAAG;GAAS;EAAM,CAAC;CACjK;CACA,IAAI,eAAe,OAAO;CAC1B,KAAK,MAAM,WAAW,gBAAgB,OAAO,MAAM,GAAG;EACrD,MAAM,UAAU,MAAM,SAAS,QAAQ,OAAO;EAC9C,MAAM,OAAO,eAAe,OAAO;EACnC,KAAK,MAAM,SAAS,OAAO,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK;GAAE,QAAQ,KAAK;GAAqB;GAAS,OAAO;GAAG,KAAK,KAAK,QAAQ,GAAG,GAAG;EAAQ,CAAC;CAChJ;CACA,KAAK,MAAM,YAAY,OAAO,OAAO;EACpC,MAAM,MAAM,MAAM,SAAS,KAAK,SAAS,EAAE;EAC3C,IAAI,CAAC,IAAI,SAAS;EAClB,KAAK,MAAM,SAAS,OAAO,IAAI,SAAS,IAAI,KAAK,CAAC,GACjD,IAAI,KAAK;GAAE,QAAQ,IAAI,QAAQ;GAAqB,SAAS,cAAc,OAAO,UAAU,GAAG;GAAG,OAAO,SAAS;GAAO,KAAK,KAAK,SAAS,GAAG,GAAG;GAAS,MAAM;EAAS,CAAC;CAC7K;CACA,OAAO;AACR;;AAGA,SAAS,QAAQ,OAAc,QAAgB,SAA2B;CACzE,IAAI,QAAQ,OAAO,aAAa,KAAA,GAAW,OAAO;CAClD,IAAI,QAAQ,OAAO,OAAO,QAAQ,MAAM,WAAW;CACnD,QAAQ,OAAO,IAAI,YAAY,CAAC,GAAG,KAAK,QAAQ,UAAU,aAAa,MAAM;AAC9E;;AAGA,SAAS,KAAK,OAAc,QAAgB,SAAwB;CACnE,MAAM,UAAU,GAAG,QAAQ,OAAO,UAAU,QAAQ,OAAO,CAAC;CAC5D,IAAI,QAAQ,OAAO,aAAa,KAAA,KAAa,WAAW,GAAG;CAC3D,IAAI,QAAQ,OAAO;EAClB,QAAQ,MAAM,WAAW;EACzB;CACD;CACA,KAAK,MAAM,CAAC,CAAC,KAAK,QAAQ,SAAS,MAAM,OAAO;AACjD;AAEA,SAAS,KAAK,QAAwC;CACrD,IAAI,OAAO,OAAO,IAAI,YAAY;CAClC,IAAI,CAAC,MAAM,OAAO,IAAI,cAAe,OAAO,CAAC,CAAE;CAC/C,OAAO;AACR;;AAGA,IAAI,aAAa;;;;;AAMjB,SAAS,KAAK,OAAc,SAAiB,SAAkB,QAA4B,QAAiB,OAA6B;CACxI,MAAM,QAAQ,UAAU;CACxB,MAAM,UAAU;EAAE;EAAO,QAAQ;EAAS,SAAS,QAAQ;EAAS,OAAO,QAAQ;EAAO;EAAQ,OAAO;GAAE,GAAG,MAAM,IAAI;GAAG,GAAG,MAAM,IAAI;EAAE;EAAG,GAAI,WAAW,KAAA,KAAa,EAAE,OAAO;CAAG;CACrL,IAAI,QAAQ,OAAO,WAAW,KAAA,KAAa,CAAC,SAAS,SAAS,QAAQ,OAAO,QAAQ,MAAM,GAAG,OAAO;CACrG,KAAK,OAAO,SAAS,OAAO;CAC5B,QAAQ;CACR;CACA,IAAI;EACH,IAAI,SAAS,QAAQ,OAAO,OAAO;CACpC,UAAU;EACT;CACD;CACA,OAAO;AACR;;;;;;;AAQA,SAAgB,aAAa,OAAc,QAAgB,MAAc,OAAsB;CAC9F,IAAI,UAAU,KAAA,GAAW;EACxB,OAAO,OAAO,MAAM,MAAM,aAAa,SAAS,OAAO,IAAI,GAAG,UAAU,OAAO,QAAQ,IAAI;EAC3F;CACD;CACA,MAAM,WAAW,OAAO,MAAM,MAAM,YAAY,QAAQ,OAAO,IAAI;CACnE,IAAI,CAAC,UAAU;CACf,KAAK,SAAS,UAAU,KAAK,OAAO,SAAS,UAAW;MACnD,UAAU,OAAO,QAAQ,IAAI;AACnC;;AAGA,IAAM,aAAa,OAAc,QAAgB,SAAiB,WAAW,OAAO,QAAQ,IAAI;;;;;;;;AA8BhG,SAAgB,OAAO,QAAe,WAAmB,SAAiB,WAAiE;CAC1I,IAAI,CAAC,UAAU,MAAM,aAAa,SAAS,SAAS,KAAA,CAAS,GAAG,OAAO;CACvE,MAAM,uBAAO,IAAI,IAA4B;CAC7C,KAAK,MAAM,YAAY,WAAW;EACjC,IAAI,SAAS,SAAS,KAAA,GAAW;EACjC,MAAM,OAAO,KAAK,IAAI,SAAS,IAAI;EACnC,IAAI,CAAC,QAAQ,SAAS,WAAW,KAAK,UAAU,KAAK,IAAI,SAAS,MAAM,QAAQ;CACjF;CACA,OAAO,UAAU,QAAQ,aAAa,SAAS,SAAS,KAAA,KAAa,KAAK,IAAI,SAAS,IAAI,MAAM,QAAQ;AAC1G;AAEA,IAAM,OAA+C;CAAE,GAAG;CAAW,GAAG;CAAQ,GAAG;AAAO;;;;;AAM1F,SAAS,YAAY,OAAc,UAAkB,QAAgB,OAA6B;CACjG,MAAM,OAAO,MAAM,SAAS,OAAO;CACnC,IAAI,CAAC,MAAM,UAAW,SAAS,UAAU,CAAC,MAAM,MAAM,YAAY,QAAQ,OAAO,SAAS,KAAA,CAAS,GAAI,OAAO;CAC9G,MAAM,6BAAa,IAAI,IAA6B;CAcpD,OAAO,KAAK,OAAO,UAAU,QAbX,MAAM,KAAK,YAAY;EACxC,MAAM,EAAE,WAAW;EACnB,MAAM,WAA2B;GAChC;GACA,MAAM,KAAK,QAAQ,IAAI;GACvB,SAAS,QAAQ;GACjB,OAAO,QAAQ;GACf,GAAI,OAAO,SAAS,KAAA,KAAa,EAAE,MAAM,OAAO,KAAK;GACrD,UAAU,OAAO,YAAY;EAC9B;EACA,WAAW,IAAI,UAAU,OAAO;EAChC,OAAO;CACR,CACqC,CAAS,CAAC,CAAC,SAAS,aAAa,WAAW,IAAI,QAAQ,KAAK,CAAC,CAAC;AACrG;;;;;;;AAQA,SAAgB,aAAa,OAAc,UAAkB,QAAgB,QAAsB;CAClG,MAAM,QAAQ,WAAW,OAAO,UAAU,OAAO,CAAC,CAAC,QACjD,YAAY,EAAE,QAAQ,OAAO,aAAa,CAAC,SAAS,MAAM,MAAM,aAAa,SAAS,OAAO,QAAQ,OAAO,SAAS,MAAM,CAAC,QAAQ,OAAO,UAAU,OAAO,CAC9J;CACA,KAAK,MAAM,WAAW,YAAY,OAAO,UAAU,QAAQ,KAAK,GAAG;EAClE,MAAM,EAAE,WAAW;EACnB,IAAI,OAAO,UAAU,KAAA,KAAa,OAAO,QAAQ,GAAG;GACnD,MAAM,OAAO,KAAK,QAAQ;GAC1B,MAAM,SAAS,KAAK,KAAK,QAAQ,UAAU,KAAK;GAChD,IAAI,QAAQ,OAAO,OAAO;IACzB,KAAK,KAAK,QAAQ,SAAS;IAC3B;GACD;GACA,OAAO,KAAK,KAAK,QAAQ;EAC1B;EACA,IAAI,OAAO,OAAO,KAAK,OAAO,UAAU,SAAS,QAAQ,MAAM;OAC1D,KAAK,OAAO,UAAU,OAAO;EAClC,IAAI,OAAO,YAAY,OAAO,aAAa,SAAS,OAAO,aAAa,OAAO,UAAU,OAAO,WAAW,CAAC;CAC7G;AACD;;;;;;;;AASA,SAAgB,eAAe,QAAgB,IAAY,QAAQ,GAAG,OAAoC,WAAmB;CAC5H,OAAO,OAAO,IAAI,YAAY,CAAC,GAAG,KAAK,KAAK,GAAG,GAAG,GAAG,GAAG,YAAY;AACrE;;AAGA,SAAgB,aAAa,OAAc,QAAgB,MAAwB;CAClF,IAAI,OAAO,IAAI,QAAQ,CAAC,SAAS,MAAM,CAAC,CAAC,SAAS,KAAK,EAAE,GAAG;CAC5D,KAAK,MAAM,WAAW,WAAW,OAAO,QAAQ,QAAQ,GAAG;EAC1D,IAAI,QAAQ,OAAO,QAAQ,OAAO,GAAG;EACrC,KAAK,OAAO,QAAQ,SAAS,KAAA,CAAS;CACvC;AACD;;AAGA,SAAgB,aAAa,OAAc,QAAgB,QAAgB,QAAiB,SAAyC;CACpI,KAAK,MAAM,WAAW,WAAW,OAAO,QAAQ,QAAQ,GAAG;EAC1D,MAAM,EAAE,WAAW;EACnB,IAAK,OAAO,UAAU,CAAC,UAAY,OAAO,SAAS,YAAY,CAAC,OAAO,IAAI,SAAS,GAAI;EACxF,IAAI,OAAO,aAAa,CAAC,OAAO,MAAM,MAAM,aAAa,SAAS,OAAO,OAAO,SAAS,GAAG;EAC5F,IAAI,QAAQ,OAAO,QAAQ,OAAO,GAAG;EACrC,IAAI,CAAC,SAAS,QAAQ;GACrB,KAAK,OAAO,QAAQ,SAAS,MAAM;GACnC;EACD;EAEA,MAAM,QAAQ,OAAO;EACrB,MAAM,QAAQ,GAAG,OAAO;EACxB,OAAO,aAAa;EACpB,IAAI;GACH,KAAK,OAAO,QAAQ,SAAS,MAAM;EACpC,UAAU;GACT,KAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK,IAAI,QAAQ,SAAS,MAAM,EAAE,GAAG,MAAM,OAAO,GAAG,CAAC;GAC7F,OAAO,aAAa;EACrB;CACD;AACD;;AAGA,IAAM,SAAS,WAAmB,CAAC,OAAO,IAAI,UAAU,EAAE,EAAE;;;;;;AAO5D,SAAgB,eAAe,OAAc,OAA0B;CACtE,MAAM,EAAE,QAAQ,QAAQ,OAAO,QAAQ,YAAY;CACnD,IAAI,CAAC,cAAc,OAAO,SAAS,UAAU,WAAW,QACvD,KAAK,MAAM,WAAW,WAAW,OAAO,QAAQ,WAAW,GAAG;EAC7D,MAAM,EAAE,WAAW;EACnB,KAAK,OAAO,UAAU,OAAO,UAAU,CAAC,QAAQ;EAChD,IAAI,OAAO,SAAS,CAAC,MAAM,MAAM,GAAG;EACpC,IAAI,QAAQ,OAAO,QAAQ,OAAO,KAAK,CAAC,OAAO,OAAO;EACtD,KAAK,OAAO,QAAQ,SAAS,QAAQ,KAAK;CAC3C;CAED,IAAI,CAAC,cAAc,QAAQ,SAAS,CAAC,UAAU,YAAY,KAAA,KAAa,MAAM,WAAW,OAAO,OAAO,OAAO,KAAK,GAC7G;OAAA,MAAM,WAAW,WAAW,OAAO,QAAQ,cAAc,GAAG,IAAI,CAAC,QAAQ,OAAO,QAAQ,OAAO,GAAG,KAAK,OAAO,QAAQ,SAAS,QAAQ,KAAK;CAAA;CAClJ,IAAI,OAAO,SAAS,QAAQ,GAC3B,KAAK,MAAM,WAAW,WAAW,OAAO,QAAQ,aAAa,GAAG;EAC/D,MAAM,QAAQ,QAAQ,OAAO,SAAS,KAAK,OAAO;EAClD,IAAI,OAAO,UAAU,QAAQ,OAAO,SAAS,QAAQ,QAAQ,QAAQ,OAAO,QAAQ,OAAO,GAAG;EAC9F,KAAK,OAAO,QAAQ,SAAS,KAAA,CAAS;CACvC;CACD,IAAI,QAAQ,KAAK,OAAO,SAAS,OAAO,MAAM,QAAQ,WAAW,OAAO,QAAQ,QAAQ;CACxF,IAAI,UAAU,QAAQ,SAAS,OAAO,MAAM,QAAQ,WAAW,OAAO,QAAQ,QAAQ;AACvF;;;;;;;AAQA,SAAgB,WAAW,OAAc,QAAgB,IAAe,SAAwB;CAC/F,KAAK,IAAI,IAAI,OAAO,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK;EAClD,MAAM,WAAW,OAAO,MAAM;EAC9B,IAAI,CAAC,YAAa,YAAY,KAAA,KAAa,SAAS,YAAY,SAAU;EAC1E,IAAI,MAAM,SAAS,KAAK,SAAS,EAAE,CAAC,CAAC,UAAU,SAAS,EAAE,GAAG,UAAU,OAAO,QAAQ,SAAS,EAAE;CAClG;AACD;;AAGA,SAAgB,YAAY,OAAc,QAAsB;CAC/D,KAAK,MAAM,YAAY,CAAC,GAAG,OAAO,KAAK,GAAG;EACzC,MAAM,MAAM,MAAM,SAAS,KAAK,SAAS,EAAE;EAC3C,IAAI,IAAI,gBAAgB,YAAY,OAAO,QAAQ,UAAU,IAAI,cAAc;CAChF;AACD;;AAGA,SAAgB,QAAQ,OAAc,SAAiB,UAAwB,QAAsB;CACpG,MAAM,MAAM,MAAM,SAAS,KAAK,SAAS,EAAE;CAC3C,IAAI,CAAC,IAAI,eAAe,IAAI,cAAc,KAAA,GAAW;CACrD,IAAI,SAAS,IAAI,cAAc,SAAS,UAAU,MAAM,IAAI,WAAW,YAAY,OAAO,SAAS,UAAU,IAAI,WAAW;AAC7H;;;;;;AAOA,SAAgB,WAAW,OAAc,QAAyB;CACjE,IAAI,CAAC,OAAO,QAAQ,OAAO;CAC3B,KAAK,MAAM,WAAW,WAAW,OAAO,QAAQ,SAAS,GAAG;EAC3D,IAAI,QAAQ,OAAO,QAAQ,OAAO,GAAG;EACrC,MAAM,QAAQ,QAAQ,OAAO,UAAU;EACvC,IAAI,KAAK,OAAO,QAAQ,SAAS,KAAA,GAAW,KAAA,SAAkB,OAAO,SAAS,KAAK,IAAI,KAAK,IAAI,OAAO,CAAC,IAAI,OAAO,WAAW,CAAC,CAAE,GAAG,OAAO;CAC5I;CACA,OAAO;AACR;;AAGA,IAAa,gBAAwC;CAAC;CAAS;CAAU;CAAU;CAAa;CAAgB;CAAe;AAAS;;AAGxI,IAAa,cAAoC;CAAC;CAAU;CAAU;AAAM"}

package/dist/abilityChanges.d.ts

@@ -0,0 +1,131 @@
+import type { AbilityState, Entity, PlayerId } from './entity';
+import type { GamePack } from './packs/pack';
+import type { World } from './world';
+/**
+ * The ability changes pack's id
+ *
+ * @beta
+ */
+export declare const ABILITY_CHANGES = "core.abilityChanges";
+/**
+ * An ability a unit was given for a while (`grantAbility`, `swapAbility`, a stolen one): seconds `left`, casts left
+ * (`uses`), and what it took the place of (`replaced`), back as it is gone
+ *
+ * @beta
+ */
+export interface AbilityGrant {
+    /** The ability given */
+    ability: string;
+    /** Seconds until it is gone, where it is for a time */
+    left?: number;
+    /** Casts of it before it is gone, where it is for so many */
+    uses?: number;
+    /** The ability it took the place of, as it was (its cooldown running on meanwhile): back in its place as this goes */
+    replaced?: AbilityState;
+}
+/**
+ * What a unit's owner is told of its abilities given for a while (`AbilityGrant`): which, for how long, how many casts,
+ * and in place of which
+ *
+ * @beta
+ */
+export interface GrantSent {
+    /** The ability given */
+    ability: string;
+    /** Seconds until it is gone */
+    left?: number;
+    /** Casts of it before it is gone */
+    uses?: number;
+    /** The ability it took the place of, by id */
+    replaces?: string;
+}
+/**
+ * A unit's abilities given for a while (`AbilityGrant`), in the order they were given. Told to its owner
+ *
+ * @beta
+ */
+export declare const abilityGrants: import("./components").Component<AbilityGrant[], GrantSent[]>;
+/**
+ * Whose a unit made someone else's for a while (`convert` with a `duration`) was, and for how much longer
+ *
+ * @beta
+ */
+export interface Converted {
+    /** Whose it was, and is again as the time is up */
+    owner: PlayerId;
+    /** Seconds left */
+    left: number;
+}
+/**
+ * Whose a unit made someone else's for a while was (`Converted`)
+ *
+ * @beta
+ */
+export declare const converted: import("./components").Component<Converted, Converted>;
+/**
+ * Options of a change of a unit's abilities (`grantAbility`, `swapAbility`): its level, for how long or how many casts,
+ * where on the card
+ *
+ * @beta
+ */
+export interface GrantOptions {
+    /** The level it is given at: 1, or that of what it takes the place of, when left out */
+    level?: number;
+    /** Seconds until it is gone (and what it took the place of back): for good when left out */
+    until?: number;
+    /** Casts of it before it is gone: for good when left out */
+    uses?: number;
+    /** Where among its abilities (and so on the card) it goes: after the rest when left out */
+    slot?: number;
+}
+/**
+ * Gives a unit an ability it has not (`GrantOptions`: at a level, for a while or so many casts, at a place on its card).
+ * What lasts a while needs the ability changes pack (`abilityChangesPack`) to end; for good, it does not. False where
+ * the ability is none or the unit has it already
+ *
+ * @beta
+ */
+export declare function grantAbility(world: World, entity: Entity, ability: string, options?: GrantOptions): boolean;
+/**
+ * Takes an ability off a unit; what it took the place of, where it was given in place of another for a while, is back
+ * there. False where it had none
+ *
+ * @beta
+ */
+export declare function removeAbility(world: World, entity: Entity, ability: string): boolean;
+/**
+ * Puts an ability in the place of another of a unit's (`from`), at its level (or `options.level`): for good, or for a
+ * while or so many casts (`until`, `uses`: then `from` is back, its cooldown having run on). A stance, an awakened
+ * ability, a weapon of a set. False where it has no `from`, the new one is none or it has it already
+ *
+ * @beta
+ */
+export declare function swapAbility(world: World, entity: Entity, from: string, to: string, options?: Omit<GrantOptions, 'slot'>): boolean;
+/**
+ * Makes an ability of a unit's into one it may become (`AbilityDef.upgrades`), for good: at its level, with its cooldown.
+ * False where it has no such ability or that is not one it may become
+ *
+ * @beta
+ */
+export declare function upgradeAbility(world: World, entity: Entity, from: string, to: string): boolean;
+/**
+ * Makes one of a unit's abilities into one it may become (`upgradeAbility`): Viktor's augment chosen
+ *
+ * @beta
+ */
+export declare const upgradeAbilityCommand: import("#engine/commands").DefinedCommand<"upgradeAbility", {
+    entity: import("./fields").Check<number>;
+    ability: import("./fields").Check<string>;
+    into: import("./fields").Check<string>;
+}>;
+/**
+ * Abilities changed at runtime: what a game with it (`Rules.packs`) gets. The effects `grantAbility` (an ability given,
+ * for a while or so many casts), `swapAbility` (one in the place of another on the card, and back), `stealAbility` (the
+ * target's ultimate in the place of the one cast, for one cast: Hijack) and `convert` (the target the caster's: Charm);
+ * an ability's `upgrades`, one chosen for good (the `upgradeAbility` command); what lasts a while kept in the
+ * `abilityGrants` component, told to the owner (a stolen one shown in the place of what it took). `grantAbility`,
+ * `removeAbility`, `swapAbility` and `upgradeAbility` in code
+ *
+ * @beta
+ */
+export declare function abilityChangesPack(): GamePack;