@v12-engine/engine 0.1.0 → 0.4.0

package/dist/abilities/buffs.js

@@ -0,0 +1,443 @@
+import { at } from "../defs.js";
+import { buffApplied, buffRemoved } from "../engineEvents.js";
+import { replicateEvent } from "../replication.js";
+import { scaled } from "./scaled.js";
+import { buffEffects } from "./land.js";
+//#region src/abilities/buffs.ts
+/**
+* Auras keep their buff alive by renewing it. It wears off this long after leaving the aura
+*
+* @beta
+*/
+var AURA_LINGER = .75;
+/**
+* The flags of buffs that the questions below ask about, one bit each (`buffFlags`). A bit says that a buff on the
+* entity declares the flag, as it is or as a function: maybe, ask the buffs. No bit, and none of them holds it
+*
+* @internal
+*/
+var BuffFlag = {
+	stun: 1,
+	root: 2,
+	disarm: 4,
+	invulnerable: 8,
+	untargetable: 16,
+	phasing: 32,
+	invisible: 64,
+	grounds: 128,
+	unstoppable: 256,
+	spellImmune: 512,
+	control: 1024,
+	grounded: 2048,
+	silence: 4096
+};
+/** The flags a buff declares, whatever it makes of them for its carrier */
+function flagsOf(def) {
+	return (def.stun || def.airborne || def.suppress ? BuffFlag.stun : 0) | (def.root ? BuffFlag.root : 0) | (def.disarm ? BuffFlag.disarm : 0) | (def.invulnerable ? BuffFlag.invulnerable : 0) | (def.untargetable ? BuffFlag.untargetable : 0) | (def.phasing ? BuffFlag.phasing : 0) | (def.invisible ? BuffFlag.invisible : 0) | (def.grounds ? BuffFlag.grounds : 0) | (def.unstoppable ? BuffFlag.unstoppable : 0) | (def.spellImmune ? BuffFlag.spellImmune : 0) | (def.control ? BuffFlag.control : 0) | (def.grounded ? BuffFlag.grounded : 0) | (def.silence ? BuffFlag.silence : 0);
+}
+/**
+* The flags the buffs on an entity declare (`BuffFlag`), all of them together. Whether a unit is stunned, rooted or
+* invisible is asked of every unit several times a tick, and almost always none of its buffs says anything of it: one
+* bit answers that, and only a unit whose buffs do declare it goes through them. Worked out again after its buffs
+* changed (the entity's writes of them put it back) or the buff definitions did (`world.redefine`, a hot reload)
+*
+* @internal
+*/
+function buffFlags(world, entity) {
+	const version = world.registry.buffs.version;
+	if (entity.buffFlags >= 0 && entity.buffFlagsOf === version) return entity.buffFlags;
+	let flags = 0;
+	for (const instance of entity.buffs) flags |= flagsOf(world.registry.buff(instance.id));
+	entity.buffFlags = flags;
+	entity.buffFlagsOf = version;
+	return flags;
+}
+/** Whether a buff on an entity declares a flag (`BuffFlag`): where none does, none holds it, and the buffs need no asking */
+var declares = (world, entity, flag) => entity.buffs.length > 0 && (buffFlags(world, entity) & flag) !== 0;
+/**
+* Whether `entity` has a buff with the id `buff` on it now
+*
+* @beta
+*/
+function hasBuff(entity, buff) {
+	return entity.buffs.some((instance) => instance.id === buff);
+}
+/**
+* Puts a buff on an entity. Buffs do not stack with themselves: a second one of the
+* same kind renews the first when it lasts longer.
+*
+* @public
+*/
+function applyBuff(world, target, buff, duration, source, level = 1, ability) {
+	if (!target.alive) return;
+	const def = world.registry.buff(buff);
+	if (def.harmful && target.buffs.length && holdsUp(def) && isUnstoppable(world, target)) return;
+	let remaining = duration ?? def.duration ?? Infinity;
+	if (world.hooks.has("beforeBuff")) {
+		const before = world.hooks.run("beforeBuff", {
+			target,
+			buff: def,
+			source,
+			level,
+			duration: remaining,
+			cancelled: false
+		});
+		if (before.cancelled) return;
+		level = before.level;
+		remaining = before.duration;
+	}
+	const shield = def.shield === void 0 ? void 0 : fullShield(world, def, source ?? target, level);
+	const from = source?.id ?? 0;
+	const policy = def.stacking ?? "strongest";
+	const existing = policy === "independent" ? void 0 : target.buffs.find((instance) => instance.id === buff && (policy !== "perSource" || instance.source === from));
+	if (existing) {
+		const decision = typeof policy === "function" ? policy(existing, {
+			level,
+			duration: remaining,
+			source: from
+		}) : policy === "refresh" ? "replace" : level > existing.level ? "replace" : level === existing.level && remaining > existing.remaining ? "renew" : "keep";
+		if (decision === "keep") return;
+		const previousLevel = existing.level;
+		if (existing.kept) delete existing.kept;
+		if (decision === "replace") {
+			Object.assign(existing, {
+				level,
+				remaining,
+				source: from
+			});
+			if (shield !== void 0) existing.shield = shield;
+			if (ability !== void 0) existing.ability = ability;
+		} else if (decision === "renew") {
+			existing.remaining = remaining;
+			if (shield !== void 0) existing.shield = Math.max(existing.shield ?? 0, shield);
+		}
+		if (decision !== "add") {
+			world.events.emit(buffApplied, {
+				target,
+				buff,
+				level: existing.level,
+				source,
+				renewed: true,
+				previousLevel
+			});
+			return;
+		}
+	}
+	world.wake(target);
+	const instance = {
+		id: buff,
+		level,
+		remaining,
+		elapsed: 0,
+		source: from,
+		shield,
+		ability
+	};
+	target.addBuff(instance);
+	world.events.emit(buffApplied, {
+		target,
+		buff,
+		level,
+		source,
+		renewed: false
+	});
+	if (typeof def.onApply === "function") def.onApply(world, target, instance);
+	else if (def.onApply) buffEffects(world, target, instance, def.onApply);
+}
+/** What the shield of a buff holds when it is new */
+function fullShield(world, def, source, level) {
+	return scaled(world, source, at(def.shield, level), def.shieldScaling, level) * world.settings.combat.healPower(world, source);
+}
+/**
+* Takes a buff off, before its time is up: the one of it `source` put on, for buffs each source has their own of, or
+* the first. The `buffEnd` hook hears of it, and the buff's `onRemove`
+*
+* @beta
+*/
+function removeBuff(world, entity, buff, source) {
+	const index = entity.buffs.findIndex((instance) => instance.id === buff && (!source || instance.source === source.id));
+	if (index < 0) return;
+	const instance = entity.dropBuff(index);
+	world.registry.buff(instance.id).onRemove?.(world, entity, instance, false);
+	world.hooks.run("buffEnd", {
+		entity,
+		buff: instance,
+		expired: false
+	});
+	world.events.emit(buffRemoved, {
+		entity,
+		buff: instance.id,
+		expired: false
+	});
+}
+/**
+* Whether nothing of an ability happens to an entity: it carries a buff that keeps it out of the way of
+* that kind of thing, like someone up in the air when the ground shakes
+*/
+/** Whether a flag of a buff holds for its carrier now: as it is declared, or as its function says */
+var holds = (world, carrier, instance, flag) => typeof flag === "function" ? flag(world, carrier, instance) : !!flag;
+/** Whether an ability gets through a unit's immunity to spells: always, never, or as its function says for the unit */
+var pierces = (world, ability, target) => typeof ability.piercesImmunity === "function" ? ability.piercesImmunity(world, target) : !!ability.piercesImmunity;
+/** Whether a buff a unit carries keeps it from attacking now (`BuffDef.disarm`) */
+var isDisarmed = (world, entity) => declares(world, entity, BuffFlag.disarm) && entity.buffs.some((instance) => {
+	const def = world.registry.buff(instance.id);
+	return holds(world, entity, instance, def.disarm) && !shrugged(world, entity, def);
+});
+/**
+* Whether a unit takes no damage and no enemy's ability may be cast on it: by its type (`UnitTypeDef.invulnerable`) or
+* a buff it carries (`BuffDef.invulnerable`), as declared or as code decides
+*
+* @beta
+*/
+function isInvulnerable(world, entity) {
+	if (entity.def.invulnerable) return true;
+	if (!declares(world, entity, BuffFlag.invulnerable)) return false;
+	return entity.buffs.some((instance) => holds(world, entity, instance, world.registry.buff(instance.id).invulnerable));
+}
+/**
+* Whether a unit is out of everyone else's reach: a buff it carries says so (`BuffDef.untargetable`), as declared or as
+* code decides
+*
+* @beta
+*/
+function isUntargetable(world, entity) {
+	if (!declares(world, entity, BuffFlag.untargetable)) return false;
+	return entity.buffs.some((instance) => holds(world, entity, instance, world.registry.buff(instance.id).untargetable));
+}
+/**
+* The least health damage leaves a unit with, by the buffs it carries (`BuffDef.minHealth`): the highest of them, 0
+* where none says
+*
+* @beta
+*/
+function healthFloor(world, entity) {
+	let floor = 0;
+	for (const instance of entity.buffs) {
+		const least = world.registry.buff(instance.id).minHealth;
+		if (least === void 0) continue;
+		floor = Math.max(floor, typeof least === "function" ? least(world, entity, instance) : at(least, instance.level));
+	}
+	return floor;
+}
+/**
+* Whether a unit is immune to spells: by its type, or a buff it carries (an avatar), as declared or as code decides
+*
+* @beta
+*/
+function isSpellImmune(world, entity) {
+	const own = entity.def.spellImmune;
+	if (typeof own === "function" ? own(world, entity) : own) return true;
+	if (!declares(world, entity, BuffFlag.spellImmune)) return false;
+	return entity.buffs.some((instance) => holds(world, entity, instance, world.registry.buff(instance.id).spellImmune));
+}
+/**
+* Whether `ability` does nothing to `entity`: it is spell immune and the ability does not pierce that, or a buff on it avoids one of the ability's tags
+*
+* @beta
+*/
+function avoids(world, entity, ability) {
+	if (!pierces(world, ability, entity) && isSpellImmune(world, entity)) return true;
+	const { tags } = ability;
+	if (!tags?.length || !entity.buffs.length) return false;
+	return entity.buffs.some((instance) => world.registry.buff(instance.id).avoids?.some((tag) => tags.includes(tag)));
+}
+/** Whether a buff keeps a unit from doing what it wants: stuns and slows. Tenacity cuts those short, but not a suppression */
+function isCrowdControl(def) {
+	if (!def.harmful || def.suppress) return false;
+	if (def.stun || def.airborne || def.grounds || def.root || def.silence || def.control || def.grounded) return true;
+	const slower = (value) => value !== void 0 && at(value, 1) < 0;
+	return slower(def.percent?.moveSpeed) || slower(def.percent?.attackSpeed);
+}
+/**
+* Whether a buff holds a unit up in any way (`unstoppable` is proof against these): stuns, roots, silences, disarms,
+* controls, suppressions and grounds. Not a slow
+*
+* @beta
+*/
+var holdsUp = (def) => !!(def.stun || def.airborne || def.root || def.silence || def.disarm || def.control || def.suppress || def.grounded);
+/**
+* Nothing that holds a unit up does anything to it now: it carries a buff that is `unstoppable`
+*
+* @beta
+*/
+var isUnstoppable = (world, entity) => declares(world, entity, BuffFlag.unstoppable);
+/** Whether what a harmful buff does is lost on its carrier now, which is unstoppable */
+var shrugged = (world, entity, def) => !!def.harmful && isUnstoppable(world, entity);
+/**
+* Whether `entity` is stunned now: a buff on it stuns it, or has it airborne
+*
+* @beta
+*/
+var isStunned = (world, entity) => declares(world, entity, BuffFlag.stun) && entity.buffs.some((instance) => {
+	const def = world.registry.buff(instance.id);
+	return (def.airborne || def.suppress || holds(world, entity, instance, def.stun)) && !shrugged(world, entity, def);
+});
+/**
+* Held to the spot: it can do everything but walk
+*
+* @beta
+*/
+var isRooted = (world, entity) => declares(world, entity, BuffFlag.root) && entity.buffs.some((instance) => {
+	const def = world.registry.buff(instance.id);
+	return holds(world, entity, instance, def.root) && !shrugged(world, entity, def);
+});
+/**
+* The buff that takes a unit's orders now (`BuffDef.control`): the last it carries of them, unless it is unstoppable
+*
+* @beta
+*/
+function controlOf(world, entity) {
+	if (!declares(world, entity, BuffFlag.control)) return void 0;
+	for (let i = entity.buffs.length - 1; i >= 0; i--) {
+		const def = world.registry.buff(entity.buffs[i].id);
+		if (def.control && !shrugged(world, entity, def)) return entity.buffs[i];
+	}
+}
+/**
+* Whether a unit walks through other units now, and they through it: a buff it carries says so (`BuffDef.phasing`), as
+* declared or as code decides
+*
+* @beta
+*/
+var isPhasing = (world, entity) => declares(world, entity, BuffFlag.phasing) && entity.buffs.some((instance) => holds(world, entity, instance, world.registry.buff(instance.id).phasing));
+/**
+* The buffs a unit carries that have a tag (`BuffDef.tags`): a `fire` on it, the `anti-heal` it is under
+*
+* @beta
+*/
+function buffsTagged(world, entity, tag) {
+	return entity.buffs.filter((instance) => world.registry.buff(instance.id).tags?.includes(tag));
+}
+/**
+* What a unit pays its abilities' mana costs with in health, for each point of mana, by the buffs it carries
+* (`BuffDef.paysWithHealth`): the highest of them; 0 where it pays with mana
+*
+* @beta
+*/
+function healthPerMana(world, entity) {
+	let rate = 0;
+	for (const instance of entity.buffs) {
+		const pays = world.registry.buff(instance.id).paysWithHealth;
+		if (pays) rate = Math.max(rate, pays === true ? 1 : pays);
+	}
+	return rate;
+}
+/**
+* Whether a buff takes a unit's orders now (`BuffDef.control`): it refuses any new
+*
+* @beta
+*/
+var isControlled = (world, entity) => controlOf(world, entity) !== void 0;
+/**
+* Whether a unit cannot rush or jump of its own now (`BuffDef.grounded`)
+*
+* @beta
+*/
+var isGrounded = (world, entity) => declares(world, entity, BuffFlag.grounded) && entity.buffs.some((instance) => {
+	const def = world.registry.buff(instance.id);
+	return def.grounded && !shrugged(world, entity, def);
+});
+/**
+* Whether a `cleanse` takes a buff off: harmful, and holding its carrier up (`holdsUp`) or slowing it, but neither a
+* suppression nor being thrown up
+*
+* @beta
+*/
+var isCleansable = (def) => !!def.harmful && !def.suppress && !def.airborne && (holdsUp(def) || isCrowdControl(def));
+/**
+* Kept from using its abilities: from this one, when it says which (a silence of fire spells only). Without an
+* ability, whether anything keeps it from using some
+*
+* @beta
+*/
+var isSilenced = (world, entity, ability) => declares(world, entity, BuffFlag.silence) && entity.buffs.some((instance) => {
+	const def = world.registry.buff(instance.id);
+	return silences(def.silence, ability) && !shrugged(world, entity, def);
+});
+/**
+* Whether a buff's `silence` keeps its carrier from an ability, or from any when none is said. For both ends
+*
+* @beta
+*/
+var silences = (silence, ability) => typeof silence === "function" ? ability ? silence(ability) : true : !!silence;
+/**
+* Where an entity is right now. What flies is in the air, unless something holds it down
+*
+* @beta
+*/
+function layerOf(world, entity) {
+	if (!entity.flying) return "ground";
+	return declares(world, entity, BuffFlag.grounds) ? "ground" : "air";
+}
+/** The part of the healed one's max health an overheal's shield holds at the most, where its buff does not say */
+var OVERHEAL_MOST = 1 / 3;
+/**
+* Healing past full health, `over` of it, becomes a shield on whoever was healed, where the healer carries a buff that
+* says so of what it gives (`BuffDef.overheal`, `of: 'given'`) or the healed one of what it gets (`of: 'taken'`): its
+* buff put on the healed one, its shield what spilled over (by `part`), up to `most` of its max health. What
+* `World.heal` does with what it could not give
+*
+* @beta
+*/
+function overheal(world, target, source, over) {
+	if (over <= 0 || !target.alive) return;
+	const shields = (carrier, of) => {
+		for (const instance of carrier.buffs.slice()) {
+			const rule = world.registry.buff(instance.id).overheal;
+			if (!rule || (rule.of ?? "given") !== of) continue;
+			const amount = over * at(rule.part ?? 1, instance.level);
+			if (amount <= 0) continue;
+			applyBuff(world, target, rule.buff, void 0, source ?? carrier, instance.level);
+			let shield;
+			for (const each of target.buffs) if (each.id === rule.buff) shield = each;
+			if (shield) shield.shield = Math.min((shield.shield ?? 0) + amount, Math.max((rule.most ?? OVERHEAL_MOST) * target.maxHealth, shield.shield ?? 0));
+		}
+	};
+	if (source?.buffs.length) shields(source, "given");
+	if (target.buffs.length) shields(target, "taken");
+}
+/**
+* What is left of the shields on an entity
+*
+* @beta
+*/
+function shieldOf(entity) {
+	let total = 0;
+	for (const instance of entity.buffs) total += instance.shield ?? 0;
+	return total;
+}
+/** Lets the shields of an entity take damage. Returns what they could not hold */
+function absorb(entity, amount) {
+	let left = amount;
+	for (const instance of entity.buffs) {
+		if (!instance.shield || left <= 0) continue;
+		const taken = Math.min(instance.shield, left);
+		instance.shield -= taken;
+		left -= taken;
+	}
+	return left;
+}
+/**
+* A buff put on, to those who see who has it. Put on again, only where its level changed: an aura renews its buff
+* every round, and what is left of it is the snapshot's (`EntityState.buffTimes`)
+*/
+var toldBuffOn = replicateEvent(buffApplied, "buff", ({ target, buff, level, source, renewed, previousLevel }, view) => view.knows(target) && !(renewed && previousLevel === level) ? {
+	type: "buff",
+	id: target.id,
+	buff,
+	on: true,
+	level,
+	renewed,
+	source: source && view.knows(source) ? source.id : void 0
+} : void 0);
+/** A buff gone, to those who see who had it */
+var toldBuffOff = replicateEvent(buffRemoved, "buff", ({ entity, buff }, view) => view.knows(entity) ? {
+	type: "buff",
+	id: entity.id,
+	buff,
+	on: false
+} : void 0);
+//#endregion
+export { AURA_LINGER, BuffFlag, absorb, applyBuff, avoids, buffFlags, buffsTagged, controlOf, fullShield, hasBuff, healthFloor, healthPerMana, holdsUp, isCleansable, isControlled, isCrowdControl, isDisarmed, isGrounded, isInvulnerable, isPhasing, isRooted, isSilenced, isSpellImmune, isStunned, isUnstoppable, isUntargetable, layerOf, overheal, pierces, removeBuff, shieldOf, silences, toldBuffOff, toldBuffOn };
+
+//# sourceMappingURL=buffs.js.map

package/dist/abilities/buffs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffs.js","names":[],"sources":["../../src/abilities/buffs.ts"],"sourcesContent":["import { buffApplied, buffRemoved } from '#engine/engineEvents'\nimport { type AbilityDef, at, type BuffCheck, type BuffDef, type Layer, type Scaled } from '#engine/defs'\nimport type { BuffInstance, Entity } from '#engine/entity'\nimport { buffEffects } from './land'\nimport { scaled } from './scaled'\nimport type { World } from '#engine/world'\nimport { replicateEvent } from '../replication'\n\n/**\n * Auras keep their buff alive by renewing it. It wears off this long after leaving the aura\n *\n * @beta\n */\nexport const AURA_LINGER = 0.75\n\n/**\n * The flags of buffs that the questions below ask about, one bit each (`buffFlags`). A bit says that a buff on the\n * entity declares the flag, as it is or as a function: maybe, ask the buffs. No bit, and none of them holds it\n *\n * @internal\n */\nexport const BuffFlag = {\n\tstun: 1 << 0,\n\troot: 1 << 1,\n\tdisarm: 1 << 2,\n\tinvulnerable: 1 << 3,\n\tuntargetable: 1 << 4,\n\tphasing: 1 << 5,\n\tinvisible: 1 << 6,\n\tgrounds: 1 << 7,\n\tunstoppable: 1 << 8,\n\tspellImmune: 1 << 9,\n\tcontrol: 1 << 10,\n\tgrounded: 1 << 11,\n\tsilence: 1 << 12\n} as const\n\n/** The flags a buff declares, whatever it makes of them for its carrier */\nfunction flagsOf(def: BuffDef): number {\n\treturn (\n\t\t(def.stun || def.airborne || def.suppress ? BuffFlag.stun : 0) |\n\t\t(def.root ? BuffFlag.root : 0) |\n\t\t(def.disarm ? BuffFlag.disarm : 0) |\n\t\t(def.invulnerable ? BuffFlag.invulnerable : 0) |\n\t\t(def.untargetable ? BuffFlag.untargetable : 0) |\n\t\t(def.phasing ? BuffFlag.phasing : 0) |\n\t\t(def.invisible ? BuffFlag.invisible : 0) |\n\t\t(def.grounds ? BuffFlag.grounds : 0) |\n\t\t(def.unstoppable ? BuffFlag.unstoppable : 0) |\n\t\t(def.spellImmune ? BuffFlag.spellImmune : 0) |\n\t\t(def.control ? BuffFlag.control : 0) |\n\t\t(def.grounded ? BuffFlag.grounded : 0) |\n\t\t(def.silence ? BuffFlag.silence : 0)\n\t)\n}\n\n/**\n * The flags the buffs on an entity declare (`BuffFlag`), all of them together. Whether a unit is stunned, rooted or\n * invisible is asked of every unit several times a tick, and almost always none of its buffs says anything of it: one\n * bit answers that, and only a unit whose buffs do declare it goes through them. Worked out again after its buffs\n * changed (the entity's writes of them put it back) or the buff definitions did (`world.redefine`, a hot reload)\n *\n * @internal\n */\nexport function buffFlags(world: World, entity: Entity): number {\n\tconst version = world.registry.buffs.version\n\tif (entity.buffFlags >= 0 && entity.buffFlagsOf === version) return entity.buffFlags\n\tlet flags = 0\n\tfor (const instance of entity.buffs) flags |= flagsOf(world.registry.buff(instance.id))\n\tentity.buffFlags = flags\n\tentity.buffFlagsOf = version\n\treturn flags\n}\n\n/** Whether a buff on an entity declares a flag (`BuffFlag`): where none does, none holds it, and the buffs need no asking */\nconst declares = (world: World, entity: Entity, flag: number): boolean => entity.buffs.length > 0 && (buffFlags(world, entity) & flag) !== 0\n\n/**\n * Whether `entity` has a buff with the id `buff` on it now\n *\n * @beta\n */\nexport function hasBuff(entity: Entity, buff: string): boolean {\n\treturn entity.buffs.some((instance) => instance.id === buff)\n}\n\n/**\n * Puts a buff on an entity. Buffs do not stack with themselves: a second one of the\n * same kind renews the first when it lasts longer.\n *\n * @public\n */\nexport function applyBuff(world: World, target: Entity, buff: string, duration?: number, source?: Entity, level = 1, ability?: string): void {\n\tif (!target.alive) return\n\tconst def = world.registry.buff(buff)\n\t// what holds a unit up does not take on one that nothing holds up (`unstoppable`)\n\tif (def.harmful && target.buffs.length && holdsUp(def) && isUnstoppable(world, target)) return\n\tlet remaining = duration ?? def.duration ?? Infinity\n\tif (world.hooks.has('beforeBuff')) {\n\t\tconst before = world.hooks.run('beforeBuff', { target, buff: def, source, level, duration: remaining, cancelled: false })\n\t\tif (before.cancelled) return\n\t\tlevel = before.level\n\t\tremaining = before.duration\n\t}\n\tconst shield = def.shield === undefined ? undefined : fullShield(world, def, source ?? target, level)\n\tconst from = source?.id ?? 0\n\tconst policy = def.stacking ?? 'strongest'\n\t// the one of it there is already, that this one is about: none for those that are each of their own\n\tconst existing =\n\t\tpolicy === 'independent'\n\t\t\t? undefined\n\t\t\t: target.buffs.find((instance) => instance.id === buff && (policy !== 'perSource' || instance.source === from))\n\tif (existing) {\n\t\tconst decision =\n\t\t\ttypeof policy === 'function'\n\t\t\t\t? policy(existing, { level, duration: remaining, source: from })\n\t\t\t\t: policy === 'refresh'\n\t\t\t\t\t? 'replace'\n\t\t\t\t\t: // the stronger one wins, the longer one among equals\n\t\t\t\t\t\tlevel > existing.level\n\t\t\t\t\t\t? 'replace'\n\t\t\t\t\t\t: level === existing.level && remaining > existing.remaining\n\t\t\t\t\t\t\t? 'renew'\n\t\t\t\t\t\t\t: 'keep'\n\t\tif (decision === 'keep') return\n\t\tconst previousLevel = existing.level\n\t\t// put on again for a time of its own: an aura that keeps it up says so again after (`keptUp`)\n\t\tif (existing.kept) delete existing.kept\n\t\tif (decision === 'replace') {\n\t\t\t// only what the renewer brings: an aura renewing a cast buff keeps its `ability` (its `onEnd`)\n\t\t\tObject.assign(existing, { level, remaining, source: from })\n\t\t\tif (shield !== undefined) existing.shield = shield\n\t\t\tif (ability !== undefined) existing.ability = ability\n\t\t} else if (decision === 'renew') {\n\t\t\texisting.remaining = remaining\n\t\t\t// a shield that is put on again is as good as new\n\t\t\tif (shield !== undefined) existing.shield = Math.max(existing.shield ?? 0, shield)\n\t\t}\n\t\tif (decision !== 'add') {\n\t\t\tworld.events.emit(buffApplied, { target, buff, level: existing.level, source, renewed: true, previousLevel })\n\t\t\treturn\n\t\t}\n\t}\n\t// a buff runs out tick by tick, which scenery does not get\n\tworld.wake(target)\n\tconst instance: BuffInstance = { id: buff, level, remaining, elapsed: 0, source: from, shield, ability }\n\ttarget.addBuff(instance)\n\tworld.events.emit(buffApplied, { target, buff, level, source, renewed: false })\n\tif (typeof def.onApply === 'function') def.onApply(world, target, instance)\n\telse if (def.onApply) buffEffects(world, target, instance, def.onApply)\n}\n\n/** What the shield of a buff holds when it is new */\nexport function fullShield(world: World, def: BuffDef, source: Entity, level: number): number {\n\treturn scaled(world, source, at(def.shield, level), def.shieldScaling, level) * world.settings.combat.healPower(world, source)\n}\n\n/**\n * Takes a buff off, before its time is up: the one of it `source` put on, for buffs each source has their own of, or\n * the first. The `buffEnd` hook hears of it, and the buff's `onRemove`\n *\n * @beta\n */\nexport function removeBuff(world: World, entity: Entity, buff: string, source?: Entity): void {\n\tconst index = entity.buffs.findIndex((instance) => instance.id === buff && (!source || instance.source === source.id))\n\tif (index < 0) return\n\tconst instance = entity.dropBuff(index)!\n\tworld.registry.buff(instance.id).onRemove?.(world, entity, instance, false)\n\tworld.hooks.run('buffEnd', { entity, buff: instance, expired: false })\n\tworld.events.emit(buffRemoved, { entity, buff: instance.id, expired: false })\n}\n\n/**\n * Whether nothing of an ability happens to an entity: it carries a buff that keeps it out of the way of\n * that kind of thing, like someone up in the air when the ground shakes\n */\n/** Whether a flag of a buff holds for its carrier now: as it is declared, or as its function says */\nconst holds = (world: World, carrier: Entity, instance: BuffInstance, flag: boolean | BuffCheck | undefined) =>\n\ttypeof flag === 'function' ? flag(world, carrier, instance) : !!flag\n\n/** Whether an ability gets through a unit's immunity to spells: always, never, or as its function says for the unit */\nexport const pierces = (world: World, ability: AbilityDef, target: Entity): boolean =>\n\ttypeof ability.piercesImmunity === 'function' ? ability.piercesImmunity(world, target) : !!ability.piercesImmunity\n\n/** Whether a buff a unit carries keeps it from attacking now (`BuffDef.disarm`) */\nexport const isDisarmed = (world: World, entity: Entity): boolean =>\n\tdeclares(world, entity, BuffFlag.disarm) &&\n\tentity.buffs.some((instance) => {\n\t\tconst def = world.registry.buff(instance.id)\n\t\treturn holds(world, entity, instance, def.disarm) && !shrugged(world, entity, def)\n\t})\n\n/**\n * Whether a unit takes no damage and no enemy's ability may be cast on it: by its type (`UnitTypeDef.invulnerable`) or\n * a buff it carries (`BuffDef.invulnerable`), as declared or as code decides\n *\n * @beta\n */\nexport function isInvulnerable(world: World, entity: Entity): boolean {\n\tif (entity.def.invulnerable) return true\n\tif (!declares(world, entity, BuffFlag.invulnerable)) return false\n\treturn entity.buffs.some((instance) => holds(world, entity, instance, world.registry.buff(instance.id).invulnerable))\n}\n\n/**\n * Whether a unit is out of everyone else's reach: a buff it carries says so (`BuffDef.untargetable`), as declared or as\n * code decides\n *\n * @beta\n */\nexport function isUntargetable(world: World, entity: Entity): boolean {\n\tif (!declares(world, entity, BuffFlag.untargetable)) return false\n\treturn entity.buffs.some((instance) => holds(world, entity, instance, world.registry.buff(instance.id).untargetable))\n}\n\n/**\n * The least health damage leaves a unit with, by the buffs it carries (`BuffDef.minHealth`): the highest of them, 0\n * where none says\n *\n * @beta\n */\nexport function healthFloor(world: World, entity: Entity): number {\n\tlet floor = 0\n\tfor (const instance of entity.buffs) {\n\t\tconst least = world.registry.buff(instance.id).minHealth\n\t\tif (least === undefined) continue\n\t\tfloor = Math.max(floor, typeof least === 'function' ? least(world, entity, instance) : at(least, instance.level))\n\t}\n\treturn floor\n}\n\n/**\n * Whether a unit is immune to spells: by its type, or a buff it carries (an avatar), as declared or as code decides\n *\n * @beta\n */\nexport function isSpellImmune(world: World, entity: Entity): boolean {\n\tconst own = entity.def.spellImmune\n\tif (typeof own === 'function' ? own(world, entity) : own) return true\n\tif (!declares(world, entity, BuffFlag.spellImmune)) return false\n\treturn entity.buffs.some((instance) => holds(world, entity, instance, world.registry.buff(instance.id).spellImmune))\n}\n\n/**\n * Whether `ability` does nothing to `entity`: it is spell immune and the ability does not pierce that, or a buff on it avoids one of the ability's tags\n *\n * @beta\n */\nexport function avoids(world: World, entity: Entity, ability: AbilityDef): boolean {\n\t// immune to spells: nothing of one happens to it, unless it gets through\n\tif (!pierces(world, ability, entity) && isSpellImmune(world, entity)) return true\n\tconst { tags } = ability\n\tif (!tags?.length || !entity.buffs.length) return false\n\treturn entity.buffs.some((instance) => world.registry.buff(instance.id).avoids?.some((tag) => tags.includes(tag)))\n}\n\n/** Whether a buff keeps a unit from doing what it wants: stuns and slows. Tenacity cuts those short, but not a suppression */\nexport function isCrowdControl(def: BuffDef): boolean {\n\tif (!def.harmful || def.suppress) return false\n\tif (def.stun || def.airborne || def.grounds || def.root || def.silence || def.control || def.grounded) return true\n\tconst slower = (value: Scaled | undefined) => value !== undefined && at(value, 1) < 0\n\treturn slower(def.percent?.moveSpeed) || slower(def.percent?.attackSpeed)\n}\n\n/**\n * Whether a buff holds a unit up in any way (`unstoppable` is proof against these): stuns, roots, silences, disarms,\n * controls, suppressions and grounds. Not a slow\n *\n * @beta\n */\nexport const holdsUp = (def: BuffDef): boolean =>\n\t!!(def.stun || def.airborne || def.root || def.silence || def.disarm || def.control || def.suppress || def.grounded)\n\n/**\n * Nothing that holds a unit up does anything to it now: it carries a buff that is `unstoppable`\n *\n * @beta\n */\nexport const isUnstoppable = (world: World, entity: Entity): boolean =>\n\t// declared as it is, never a function: a buff that declares it holds it\n\tdeclares(world, entity, BuffFlag.unstoppable)\n\n/** Whether what a harmful buff does is lost on its carrier now, which is unstoppable */\nconst shrugged = (world: World, entity: Entity, def: BuffDef) => !!def.harmful && isUnstoppable(world, entity)\n\n/**\n * Whether `entity` is stunned now: a buff on it stuns it, or has it airborne\n *\n * @beta\n */\nexport const isStunned = (world: World, entity: Entity) =>\n\tdeclares(world, entity, BuffFlag.stun) &&\n\tentity.buffs.some((instance) => {\n\t\tconst def = world.registry.buff(instance.id)\n\t\treturn (def.airborne || def.suppress || holds(world, entity, instance, def.stun)) && !shrugged(world, entity, def)\n\t})\n\n/**\n * Held to the spot: it can do everything but walk\n *\n * @beta\n */\nexport const isRooted = (world: World, entity: Entity) =>\n\tdeclares(world, entity, BuffFlag.root) &&\n\tentity.buffs.some((instance) => {\n\t\tconst def = world.registry.buff(instance.id)\n\t\treturn holds(world, entity, instance, def.root) && !shrugged(world, entity, def)\n\t})\n\n/**\n * The buff that takes a unit's orders now (`BuffDef.control`): the last it carries of them, unless it is unstoppable\n *\n * @beta\n */\nexport function controlOf(world: World, entity: Entity): BuffInstance | undefined {\n\tif (!declares(world, entity, BuffFlag.control)) return undefined\n\tfor (let i = entity.buffs.length - 1; i >= 0; i--) {\n\t\tconst def = world.registry.buff(entity.buffs[i].id)\n\t\tif (def.control && !shrugged(world, entity, def)) return entity.buffs[i]\n\t}\n\treturn undefined\n}\n\n/**\n * Whether a unit walks through other units now, and they through it: a buff it carries says so (`BuffDef.phasing`), as\n * declared or as code decides\n *\n * @beta\n */\nexport const isPhasing = (world: World, entity: Entity): boolean =>\n\tdeclares(world, entity, BuffFlag.phasing) &&\n\tentity.buffs.some((instance) => holds(world, entity, instance, world.registry.buff(instance.id).phasing))\n\n/**\n * The buffs a unit carries that have a tag (`BuffDef.tags`): a `fire` on it, the `anti-heal` it is under\n *\n * @beta\n */\nexport function buffsTagged(world: World, entity: Entity, tag: string): BuffInstance[] {\n\treturn entity.buffs.filter((instance) => world.registry.buff(instance.id).tags?.includes(tag))\n}\n\n/**\n * What a unit pays its abilities' mana costs with in health, for each point of mana, by the buffs it carries\n * (`BuffDef.paysWithHealth`): the highest of them; 0 where it pays with mana\n *\n * @beta\n */\nexport function healthPerMana(world: World, entity: Entity): number {\n\tlet rate = 0\n\tfor (const instance of entity.buffs) {\n\t\tconst pays = world.registry.buff(instance.id).paysWithHealth\n\t\tif (pays) rate = Math.max(rate, pays === true ? 1 : pays)\n\t}\n\treturn rate\n}\n\n/**\n * Whether a buff takes a unit's orders now (`BuffDef.control`): it refuses any new\n *\n * @beta\n */\nexport const isControlled = (world: World, entity: Entity): boolean => controlOf(world, entity) !== undefined\n\n/**\n * Whether a unit cannot rush or jump of its own now (`BuffDef.grounded`)\n *\n * @beta\n */\nexport const isGrounded = (world: World, entity: Entity): boolean =>\n\tdeclares(world, entity, BuffFlag.grounded) &&\n\tentity.buffs.some((instance) => {\n\t\tconst def = world.registry.buff(instance.id)\n\t\treturn def.grounded && !shrugged(world, entity, def)\n\t})\n\n/**\n * Whether a `cleanse` takes a buff off: harmful, and holding its carrier up (`holdsUp`) or slowing it, but neither a\n * suppression nor being thrown up\n *\n * @beta\n */\nexport const isCleansable = (def: BuffDef): boolean => !!def.harmful && !def.suppress && !def.airborne && (holdsUp(def) || isCrowdControl(def))\n\n/**\n * Kept from using its abilities: from this one, when it says which (a silence of fire spells only). Without an\n * ability, whether anything keeps it from using some\n *\n * @beta\n */\nexport const isSilenced = (world: World, entity: Entity, ability?: AbilityDef) =>\n\tdeclares(world, entity, BuffFlag.silence) &&\n\tentity.buffs.some((instance) => {\n\t\tconst def = world.registry.buff(instance.id)\n\t\treturn silences(def.silence, ability) && !shrugged(world, entity, def)\n\t})\n\n/**\n * Whether a buff's `silence` keeps its carrier from an ability, or from any when none is said. For both ends\n *\n * @beta\n */\nexport const silences = (silence: BuffDef['silence'], ability?: AbilityDef): boolean =>\n\ttypeof silence === 'function' ? (ability ? silence(ability) : true) : !!silence\n\n/**\n * Where an entity is right now. What flies is in the air, unless something holds it down\n *\n * @beta\n */\nexport function layerOf(world: World, entity: Entity): Layer {\n\tif (!entity.flying) return 'ground'\n\t// `grounds` is declared as it is, never a function: a buff that declares it holds it\n\treturn declares(world, entity, BuffFlag.grounds) ? 'ground' : 'air'\n}\n\n/** The part of the healed one's max health an overheal's shield holds at the most, where its buff does not say */\nconst OVERHEAL_MOST = 1 / 3\n\n/**\n * Healing past full health, `over` of it, becomes a shield on whoever was healed, where the healer carries a buff that\n * says so of what it gives (`BuffDef.overheal`, `of: 'given'`) or the healed one of what it gets (`of: 'taken'`): its\n * buff put on the healed one, its shield what spilled over (by `part`), up to `most` of its max health. What\n * `World.heal` does with what it could not give\n *\n * @beta\n */\nexport function overheal(world: World, target: Entity, source: Entity | undefined, over: number): void {\n\tif (over <= 0 || !target.alive) return\n\tconst shields = (carrier: Entity, of: 'given' | 'taken') => {\n\t\tfor (const instance of carrier.buffs.slice()) {\n\t\t\tconst rule = world.registry.buff(instance.id).overheal\n\t\t\tif (!rule || (rule.of ?? 'given') !== of) continue\n\t\t\tconst amount = over * at(rule.part ?? 1, instance.level)\n\t\t\tif (amount <= 0) continue\n\t\t\tapplyBuff(world, target, rule.buff, undefined, source ?? carrier, instance.level)\n\t\t\t// the one it put on, or renewed: the last of it there is\n\t\t\tlet shield: BuffInstance | undefined\n\t\t\tfor (const each of target.buffs) if (each.id === rule.buff) shield = each\n\t\t\tif (shield)\n\t\t\t\tshield.shield = Math.min((shield.shield ?? 0) + amount, Math.max((rule.most ?? OVERHEAL_MOST) * target.maxHealth, shield.shield ?? 0))\n\t\t}\n\t}\n\tif (source?.buffs.length) shields(source, 'given')\n\tif (target.buffs.length) shields(target, 'taken')\n}\n\n/**\n * What is left of the shields on an entity\n *\n * @beta\n */\nexport function shieldOf(entity: Entity): number {\n\tlet total = 0\n\tfor (const instance of entity.buffs) total += instance.shield ?? 0\n\treturn total\n}\n\n/** Lets the shields of an entity take damage. Returns what they could not hold */\nexport function absorb(entity: Entity, amount: number): number {\n\tlet left = amount\n\tfor (const instance of entity.buffs) {\n\t\tif (!instance.shield || left <= 0) continue\n\t\tconst taken = Math.min(instance.shield, left)\n\t\tinstance.shield -= taken\n\t\tleft -= taken\n\t}\n\treturn left\n}\n\n/**\n * A buff put on, to those who see who has it. Put on again, only where its level changed: an aura renews its buff\n * every round, and what is left of it is the snapshot's (`EntityState.buffTimes`)\n */\nexport const toldBuffOn = replicateEvent(buffApplied, 'buff', ({ target, buff, level, source, renewed, previousLevel }, view) =>\n\tview.knows(target) && !(renewed && previousLevel === level)\n\t\t? { type: 'buff', id: target.id, buff, on: true, level, renewed, source: source && view.knows(source) ? source.id : undefined }\n\t\t: undefined\n)\n\n/** A buff gone, to those who see who had it */\nexport const toldBuffOff = replicateEvent(buffRemoved, 'buff', ({ entity, buff }, view) =>\n\tview.knows(entity) ? { type: 'buff', id: entity.id, buff, on: false } : undefined\n)\n"],"mappings":"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"}

package/dist/abilities/castTold.d.ts

@@ -4,6 +4,8 @@
  */
 /** A spell being wound up, to those who see the caster: where it aims, and for how long */
 export declare const toldWindup: import("..").ReplicatedEvent;
+/** A wind-up called off, to those who see the caster: its shape on the ground goes (B46) */
+export declare const toldCastCancelled: import("..").ReplicatedEvent;
 /** A channel begun, to those who see the caster */
 export declare const toldChannelStarted: import("..").ReplicatedEvent;
 /** A channel over, to those who see the caster */

package/dist/abilities/castTold.js

@@ -0,0 +1,66 @@
+import { aimOf } from "../defs.js";
+import { abilityCast, castCancelled, castStarted, channelEnded, channelStarted } from "../engineEvents.js";
+import { replicateEvent } from "../replication.js";
+//#region src/abilities/castTold.ts
+/**
+* What players are told of casting (the cast order's events): the wind-up, a channel's start and end, the cast. Beside
+* the abilities, whose order emits them
+*/
+/** A spell being wound up, to those who see the caster: where it aims, and for how long */
+var toldWindup = replicateEvent(castStarted, "windup", ({ caster, ability, point, duration }, view) => {
+	if (!duration || !view.knows(caster)) return void 0;
+	const aim = point ?? caster.pos;
+	const level = caster.abilities.find((state) => state.id === ability.id)?.level || 1;
+	return {
+		type: "windup",
+		id: caster.id,
+		ability: ability.id,
+		level,
+		x: aim.x,
+		z: aim.z,
+		duration
+	};
+});
+/** A wind-up called off, to those who see the caster: its shape on the ground goes (B46) */
+var toldCastCancelled = replicateEvent(castCancelled, "castCancelled", ({ caster, ability }, view) => view.knows(caster) ? {
+	type: "castCancelled",
+	id: caster.id,
+	ability: ability?.id
+} : void 0);
+/** A channel begun, to those who see the caster */
+var toldChannelStarted = replicateEvent(channelStarted, "channel", ({ caster, ability, duration }, view) => view.knows(caster) ? {
+	type: "channel",
+	id: caster.id,
+	ability: ability.id,
+	on: true,
+	duration
+} : void 0);
+/** A channel over, to those who see the caster */
+var toldChannelEnded = replicateEvent(channelEnded, "channel", ({ caster, ability, interrupted }, view) => view.knows(caster) ? {
+	type: "channel",
+	id: caster.id,
+	ability: ability.id,
+	on: false,
+	interrupted
+} : void 0);
+/** A cast, to those who see the caster or where it lands */
+var toldCast = replicateEvent(abilityCast, "cast", ({ caster, ability, level, target, point, charged }, view) => {
+	if (!view.knows(caster) && !view.sees(point.x, point.z)) return void 0;
+	const aim = aimOf(ability, level);
+	const radius = aim?.shape === "circle" ? aim.radius : 0;
+	return {
+		type: "cast",
+		id: view.knows(caster) ? caster.id : void 0,
+		ability: ability.id,
+		level,
+		x: point.x,
+		z: point.z,
+		target: target && view.knows(target) ? target.id : void 0,
+		radius: radius || void 0,
+		charged
+	};
+});
+//#endregion
+export { toldCast, toldCastCancelled, toldChannelEnded, toldChannelStarted, toldWindup };
+
+//# sourceMappingURL=castTold.js.map

package/dist/abilities/castTold.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"castTold.js","names":[],"sources":["../../src/abilities/castTold.ts"],"sourcesContent":["import { abilityCast, castCancelled, castStarted, channelEnded, channelStarted } from '#engine/engineEvents'\nimport { replicateEvent } from '../replication'\nimport { aimOf } from '../defs'\n\n/**\n * What players are told of casting (the cast order's events): the wind-up, a channel's start and end, the cast. Beside\n * the abilities, whose order emits them\n */\n\n/** A spell being wound up, to those who see the caster: where it aims, and for how long */\nexport const toldWindup = replicateEvent(castStarted, 'windup', ({ caster, ability, point, duration }, view) => {\n\tif (!duration || !view.knows(caster)) return undefined\n\tconst aim = point ?? caster.pos\n\t// what an item gives is at its first level\n\tconst level = caster.abilities.find((state) => state.id === ability.id)?.level || 1\n\treturn { type: 'windup', id: caster.id, ability: ability.id, level, x: aim.x, z: aim.z, duration }\n})\n\n/** A wind-up called off, to those who see the caster: its shape on the ground goes (B46) */\nexport const toldCastCancelled = replicateEvent(castCancelled, 'castCancelled', ({ caster, ability }, view) =>\n\tview.knows(caster) ? { type: 'castCancelled', id: caster.id, ability: ability?.id } : undefined\n)\n\n/** A channel begun, to those who see the caster */\nexport const toldChannelStarted = replicateEvent(channelStarted, 'channel', ({ caster, ability, duration }, view) =>\n\tview.knows(caster) ? { type: 'channel', id: caster.id, ability: ability.id, on: true, duration } : undefined\n)\n\n/** A channel over, to those who see the caster */\nexport const toldChannelEnded = replicateEvent(channelEnded, 'channel', ({ caster, ability, interrupted }, view) =>\n\tview.knows(caster) ? { type: 'channel', id: caster.id, ability: ability.id, on: false, interrupted } : undefined\n)\n\n/** A cast, to those who see the caster or where it lands */\nexport const toldCast = replicateEvent(abilityCast, 'cast', ({ caster, ability, level, target, point, charged }, view) => {\n\tif (!view.knows(caster) && !view.sees(point.x, point.z)) return undefined\n\tconst aim = aimOf(ability, level)\n\tconst radius = aim?.shape === 'circle' ? aim.radius : 0\n\treturn {\n\t\ttype: 'cast',\n\t\tid: view.knows(caster) ? caster.id : undefined,\n\t\tability: ability.id,\n\t\tlevel,\n\t\tx: point.x,\n\t\tz: point.z,\n\t\ttarget: target && view.knows(target) ? target.id : undefined,\n\t\tradius: radius || undefined,\n\t\tcharged\n\t}\n})\n"],"mappings":";;;;;;;;;AAUA,IAAa,aAAa,eAAe,aAAa,WAAW,EAAE,QAAQ,SAAS,OAAO,YAAY,SAAS;CAC/G,IAAI,CAAC,YAAY,CAAC,KAAK,MAAM,MAAM,GAAG,OAAO,KAAA;CAC7C,MAAM,MAAM,SAAS,OAAO;CAE5B,MAAM,QAAQ,OAAO,UAAU,MAAM,UAAU,MAAM,OAAO,QAAQ,EAAE,CAAC,EAAE,SAAS;CAClF,OAAO;EAAE,MAAM;EAAU,IAAI,OAAO;EAAI,SAAS,QAAQ;EAAI;EAAO,GAAG,IAAI;EAAG,GAAG,IAAI;EAAG;CAAS;AAClG,CAAC;;AAGD,IAAa,oBAAoB,eAAe,eAAe,kBAAkB,EAAE,QAAQ,WAAW,SACrG,KAAK,MAAM,MAAM,IAAI;CAAE,MAAM;CAAiB,IAAI,OAAO;CAAI,SAAS,SAAS;AAAG,IAAI,KAAA,CACvF;;AAGA,IAAa,qBAAqB,eAAe,gBAAgB,YAAY,EAAE,QAAQ,SAAS,YAAY,SAC3G,KAAK,MAAM,MAAM,IAAI;CAAE,MAAM;CAAW,IAAI,OAAO;CAAI,SAAS,QAAQ;CAAI,IAAI;CAAM;AAAS,IAAI,KAAA,CACpG;;AAGA,IAAa,mBAAmB,eAAe,cAAc,YAAY,EAAE,QAAQ,SAAS,eAAe,SAC1G,KAAK,MAAM,MAAM,IAAI;CAAE,MAAM;CAAW,IAAI,OAAO;CAAI,SAAS,QAAQ;CAAI,IAAI;CAAO;AAAY,IAAI,KAAA,CACxG;;AAGA,IAAa,WAAW,eAAe,aAAa,SAAS,EAAE,QAAQ,SAAS,OAAO,QAAQ,OAAO,WAAW,SAAS;CACzH,IAAI,CAAC,KAAK,MAAM,MAAM,KAAK,CAAC,KAAK,KAAK,MAAM,GAAG,MAAM,CAAC,GAAG,OAAO,KAAA;CAChE,MAAM,MAAM,MAAM,SAAS,KAAK;CAChC,MAAM,SAAS,KAAK,UAAU,WAAW,IAAI,SAAS;CACtD,OAAO;EACN,MAAM;EACN,IAAI,KAAK,MAAM,MAAM,IAAI,OAAO,KAAK,KAAA;EACrC,SAAS,QAAQ;EACjB;EACA,GAAG,MAAM;EACT,GAAG,MAAM;EACT,QAAQ,UAAU,KAAK,MAAM,MAAM,IAAI,OAAO,KAAK,KAAA;EACnD,QAAQ,UAAU,KAAA;EAClB;CACD;AACD,CAAC"}

package/dist/abilities/chance.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 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
+ */
+import { type EffectValue, type UnitCondition, type UnitConditionCheck } from '#engine/defs';
+import type { Entity, PlayerId } from '#engine/entity';
+import type { World } from '#engine/world';
+import type { EffectContext } from './effects';
+/**
+ * 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
+ */
+export declare function byChance(context: EffectContext, chance: EffectValue | undefined, target?: Entity): boolean;
+/**
+ * Whether the type of a unit has one of the tags (`UnitTypeDef.tags`)
+ *
+ * @beta
+ */
+export declare function hasTag(entity: Entity, tags: readonly string[]): boolean;
+/**
+ * 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
+ */
+export declare function conditionHolds(context: EffectContext, condition: UnitCondition | UnitConditionCheck | undefined, unit: Entity | undefined): boolean;
+/**
+ * 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
+ */
+export declare function unitMatches(world: World, condition: UnitCondition, unit: Entity, of?: PlayerId): boolean;