@v12-engine/engine 0.1.0 → 0.4.0

package/dist/abilities/amounts.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Amounts of effects as they land (E2E-PLAN AB3): a number, one per level, or code (`EffectValue`), with the caster's stats
+ * (`scaling`) and the formulas of the target (`byMaxHealth`, `byCurrentHealth`, `byMissingHealth`, `byStacks`,
+ * `byDistance`, `targetScaling`) on top, for each target it reaches
+ */
+import { type EffectValue, type EffectDef } from '#engine/defs';
+import type { Entity } from '#engine/entity';
+import type { EffectContext } from './effects';
+/**
+ * The value of an amount, a time or a size of an effect as it lands (`EffectValue`): at the context's level, or what its
+ * code says for the target (none for what is not for one: a zone's time, an area's size). `fallback` where it says
+ * nothing
+ *
+ * @beta
+ */
+export declare function valueOf(context: EffectContext, value: EffectValue | undefined, target?: Entity, fallback?: number): number;
+/**
+ * How much an effect of `damage`, `heal` or a shield (`buff`) comes to for one target as it lands: its `amount` (a
+ * number, one per level, or code), with what the caster's stats add (`scaling`), times `power` (the caster's heal and
+ * shield power, for those), the share a bouncing missile has left (`EffectContext.share`) and how full it was held
+ * (`EffectContext.held`, by `HoldDef.scale`); then for the target, what
+ * its formulas add: a part of what it lacks (`byMissingHealth`), of its max health (`byMaxHealth`), of its health now
+ * (`byCurrentHealth`), so much for each stack of a buff (`byStacks`), parts of its stats (`targetScaling`); and all of
+ * that times what the distance makes of it (`byDistance`). A game's own effect with an amount calls it too
+ *
+ * @beta
+ */
+export declare function effectAmount(context: EffectContext, effect: EffectDef, target?: Entity, power?: number): number;

package/dist/abilities/amounts.js

@@ -0,0 +1,74 @@
+import { dist } from "../math.js";
+import { at } from "../defs.js";
+import { statsOf } from "../stats.js";
+import { casterFacts, scaled } from "./scaled.js";
+import { effectOrigin } from "./land.js";
+//#region src/abilities/amounts.ts
+/**
+* Amounts of effects as they land (E2E-PLAN AB3): a number, one per level, or code (`EffectValue`), with the caster's stats
+* (`scaling`) and the formulas of the target (`byMaxHealth`, `byCurrentHealth`, `byMissingHealth`, `byStacks`,
+* `byDistance`, `targetScaling`) on top, for each target it reaches
+*/
+/**
+* The value of an amount, a time or a size of an effect as it lands (`EffectValue`): at the context's level, or what its
+* code says for the target (none for what is not for one: a zone's time, an area's size). `fallback` where it says
+* nothing
+*
+* @beta
+*/
+function valueOf(context, value, target, fallback = 0) {
+	if (typeof value !== "function") return at(value, context.level, fallback);
+	return value({
+		level: context.level,
+		caster: casterFacts(context.world, context.caster),
+		effect: context
+	}, target);
+}
+/** How many of a buff an entity carries: its stacks, one for a buff that does not count them, none for none */
+function stacksOf(entity, buff) {
+	const instance = entity.buffs.find((carried) => carried.id === buff);
+	return instance ? instance.stacks ?? 1 : 0;
+}
+/**
+* How much an effect of `damage`, `heal` or a shield (`buff`) comes to for one target as it lands: its `amount` (a
+* number, one per level, or code), with what the caster's stats add (`scaling`), times `power` (the caster's heal and
+* shield power, for those), the share a bouncing missile has left (`EffectContext.share`) and how full it was held
+* (`EffectContext.held`, by `HoldDef.scale`); then for the target, what
+* its formulas add: a part of what it lacks (`byMissingHealth`), of its max health (`byMaxHealth`), of its health now
+* (`byCurrentHealth`), so much for each stack of a buff (`byStacks`), parts of its stats (`targetScaling`); and all of
+* that times what the distance makes of it (`byDistance`). A game's own effect with an amount calls it too
+*
+* @beta
+*/
+function effectAmount(context, effect, target, power = 1) {
+	const { world, caster, level } = context;
+	const fields = effect;
+	const scale = context.held === void 0 ? 1 : 1 + ((context.ability.hold?.scale ?? 1) - 1) * context.held;
+	const share = (context.share ?? 1) * scale;
+	let total = scaled(world, caster, valueOf(context, fields.amount, target), fields.scaling, level) * power * share;
+	if (!target) return total;
+	const add = (ratio, of) => {
+		if (ratio === void 0) return;
+		const part = at(ratio, level) * share * power;
+		if (part) total += part * of();
+	};
+	add(fields.byMissingHealth, () => Math.max(target.maxHealth - target.health, 0));
+	add(fields.byMaxHealth, () => target.maxHealth);
+	add(fields.byCurrentHealth, () => Math.max(target.health, 0));
+	add(fields.byDamage, () => context.damage ?? 0);
+	const { byStacks, targetScaling, byDistance } = fields;
+	if (byStacks) add(byStacks.amount, () => stacksOf(byStacks.of === "caster" ? caster : target, byStacks.buff));
+	if (targetScaling) {
+		const stats = statsOf(world, target);
+		for (const stat in targetScaling) add(targetScaling[stat], () => stats[stat] ?? 0);
+	}
+	if (byDistance) {
+		const far = context.distance ?? dist(effectOrigin(context), target.pos);
+		total *= Math.min(1 + byDistance.per * far, byDistance.most ?? Infinity);
+	}
+	return total;
+}
+//#endregion
+export { effectAmount, valueOf };
+
+//# sourceMappingURL=amounts.js.map

package/dist/abilities/amounts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"amounts.js","names":[],"sources":["../../src/abilities/amounts.ts"],"sourcesContent":["/**\n * Amounts of effects as they land (E2E-PLAN AB3): a number, one per level, or code (`EffectValue`), with the caster's stats\n * (`scaling`) and the formulas of the target (`byMaxHealth`, `byCurrentHealth`, `byMissingHealth`, `byStacks`,\n * `byDistance`, `targetScaling`) on top, for each target it reaches\n */\nimport { type EffectValue, type AnyEffect, at, type EffectDef, type Scaled } from '#engine/defs'\nimport type { Entity } from '#engine/entity'\nimport { dist } from '#engine/math'\nimport { statsOf } from '#engine/stats'\nimport type { EffectContext } from './effects'\nimport { effectOrigin } from './land'\nimport { casterFacts, scaled } from './scaled'\n\n/**\n * The value of an amount, a time or a size of an effect as it lands (`EffectValue`): at the context's level, or what its\n * code says for the target (none for what is not for one: a zone's time, an area's size). `fallback` where it says\n * nothing\n *\n * @beta\n */\nexport function valueOf(context: EffectContext, value: EffectValue | undefined, target?: Entity, fallback = 0): number {\n\tif (typeof value !== 'function') return at(value, context.level, fallback)\n\treturn value({ level: context.level, caster: casterFacts(context.world, context.caster), effect: context }, target)\n}\n\n/** How many of a buff an entity carries: its stacks, one for a buff that does not count them, none for none */\nfunction stacksOf(entity: Entity, buff: string): number {\n\tconst instance = entity.buffs.find((carried) => carried.id === buff)\n\treturn instance ? (instance.stacks ?? 1) : 0\n}\n\n/**\n * How much an effect of `damage`, `heal` or a shield (`buff`) comes to for one target as it lands: its `amount` (a\n * number, one per level, or code), with what the caster's stats add (`scaling`), times `power` (the caster's heal and\n * shield power, for those), the share a bouncing missile has left (`EffectContext.share`) and how full it was held\n * (`EffectContext.held`, by `HoldDef.scale`); then for the target, what\n * its formulas add: a part of what it lacks (`byMissingHealth`), of its max health (`byMaxHealth`), of its health now\n * (`byCurrentHealth`), so much for each stack of a buff (`byStacks`), parts of its stats (`targetScaling`); and all of\n * that times what the distance makes of it (`byDistance`). A game's own effect with an amount calls it too\n *\n * @beta\n */\nexport function effectAmount(context: EffectContext, effect: EffectDef, target?: Entity, power = 1): number {\n\tconst { world, caster, level } = context\n\tconst fields = effect as AnyEffect\n\t// held and let go (AB15): grown as full as it was, up to what `scale` says\n\tconst scale = context.held === undefined ? 1 : 1 + ((context.ability.hold?.scale ?? 1) - 1) * context.held\n\tconst share = (context.share ?? 1) * scale\n\tlet total = scaled(world, caster, valueOf(context, fields.amount, target), fields.scaling, level) * power * share\n\tif (!target) return total\n\t// so much of what the target is, for each part a formula says\n\tconst add = (ratio: Scaled | undefined, of: () => number) => {\n\t\tif (ratio === undefined) return\n\t\tconst part = at(ratio, level) * share * power\n\t\tif (part) total += part * of()\n\t}\n\tadd(fields.byMissingHealth, () => Math.max(target.maxHealth - target.health, 0))\n\tadd(fields.byMaxHealth, () => target.maxHealth)\n\tadd(fields.byCurrentHealth, () => Math.max(target.health, 0))\n\tadd(fields.byDamage, () => context.damage ?? 0)\n\tconst { byStacks, targetScaling, byDistance } = fields\n\tif (byStacks) add(byStacks.amount, () => stacksOf(byStacks.of === 'caster' ? caster : target, byStacks.buff))\n\tif (targetScaling) {\n\t\tconst stats = statsOf(world, target) as unknown as Record<string, number>\n\t\tfor (const stat in targetScaling) add(targetScaling[stat], () => stats[stat] ?? 0)\n\t}\n\tif (byDistance) {\n\t\tconst far = context.distance ?? dist(effectOrigin(context), target.pos)\n\t\ttotal *= Math.min(1 + byDistance.per * far, byDistance.most ?? Infinity)\n\t}\n\treturn total\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAoBA,SAAgB,QAAQ,SAAwB,OAAgC,QAAiB,WAAW,GAAW;CACtH,IAAI,OAAO,UAAU,YAAY,OAAO,GAAG,OAAO,QAAQ,OAAO,QAAQ;CACzE,OAAO,MAAM;EAAE,OAAO,QAAQ;EAAO,QAAQ,YAAY,QAAQ,OAAO,QAAQ,MAAM;EAAG,QAAQ;CAAQ,GAAG,MAAM;AACnH;;AAGA,SAAS,SAAS,QAAgB,MAAsB;CACvD,MAAM,WAAW,OAAO,MAAM,MAAM,YAAY,QAAQ,OAAO,IAAI;CACnE,OAAO,WAAY,SAAS,UAAU,IAAK;AAC5C;;;;;;;;;;;;AAaA,SAAgB,aAAa,SAAwB,QAAmB,QAAiB,QAAQ,GAAW;CAC3G,MAAM,EAAE,OAAO,QAAQ,UAAU;CACjC,MAAM,SAAS;CAEf,MAAM,QAAQ,QAAQ,SAAS,KAAA,IAAY,IAAI,MAAM,QAAQ,QAAQ,MAAM,SAAS,KAAK,KAAK,QAAQ;CACtG,MAAM,SAAS,QAAQ,SAAS,KAAK;CACrC,IAAI,QAAQ,OAAO,OAAO,QAAQ,QAAQ,SAAS,OAAO,QAAQ,MAAM,GAAG,OAAO,SAAS,KAAK,IAAI,QAAQ;CAC5G,IAAI,CAAC,QAAQ,OAAO;CAEpB,MAAM,OAAO,OAA2B,OAAqB;EAC5D,IAAI,UAAU,KAAA,GAAW;EACzB,MAAM,OAAO,GAAG,OAAO,KAAK,IAAI,QAAQ;EACxC,IAAI,MAAM,SAAS,OAAO,GAAG;CAC9B;CACA,IAAI,OAAO,uBAAuB,KAAK,IAAI,OAAO,YAAY,OAAO,QAAQ,CAAC,CAAC;CAC/E,IAAI,OAAO,mBAAmB,OAAO,SAAS;CAC9C,IAAI,OAAO,uBAAuB,KAAK,IAAI,OAAO,QAAQ,CAAC,CAAC;CAC5D,IAAI,OAAO,gBAAgB,QAAQ,UAAU,CAAC;CAC9C,MAAM,EAAE,UAAU,eAAe,eAAe;CAChD,IAAI,UAAU,IAAI,SAAS,cAAc,SAAS,SAAS,OAAO,WAAW,SAAS,QAAQ,SAAS,IAAI,CAAC;CAC5G,IAAI,eAAe;EAClB,MAAM,QAAQ,QAAQ,OAAO,MAAM;EACnC,KAAK,MAAM,QAAQ,eAAe,IAAI,cAAc,aAAa,MAAM,SAAS,CAAC;CAClF;CACA,IAAI,YAAY;EACf,MAAM,MAAM,QAAQ,YAAY,KAAK,aAAa,OAAO,GAAG,OAAO,GAAG;EACtE,SAAS,KAAK,IAAI,IAAI,WAAW,MAAM,KAAK,WAAW,QAAQ,QAAQ;CACxE;CACA,OAAO;AACR"}

package/dist/abilities/buffs.d.ts

@@ -1,5 +1,5 @@
 import { type AbilityDef, type BuffDef, type Layer } from '#engine/defs';
-import type { Entity } from '#engine/entity';
+import type { BuffInstance, Entity } from '#engine/entity';
 import type { World } from '#engine/world';
 /**
  * Auras keep their buff alive by renewing it. It wears off this long after leaving the aura
@@ -7,13 +7,17 @@ import type { World } from '#engine/world';
  * @beta
  */
 export declare const AURA_LINGER = 0.75;
-/** @beta */
+/**
+ * Whether `entity` has a buff with the id `buff` on it now
+ *
+ * @beta
+ */
 export declare function hasBuff(entity: Entity, buff: string): boolean;
 /**
  * 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.
  *
- * @beta
+ * @public
  */
 export declare function applyBuff(world: World, target: Entity, buff: string, duration?: number, source?: Entity, level?: number, ability?: string): void;
 /** What the shield of a buff holds when it is new */
@@ -29,17 +33,59 @@ export declare function removeBuff(world: World, entity: Entity, buff: string, s
 export declare const pierces: (world: World, ability: AbilityDef, target: Entity) => boolean;
 /** Whether a buff a unit carries keeps it from attacking now (`BuffDef.disarm`) */
 export declare const isDisarmed: (world: World, entity: Entity) => boolean;
+/**
+ * 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
+ */
+export declare function isInvulnerable(world: World, entity: Entity): boolean;
+/**
+ * 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
+ */
+export declare function isUntargetable(world: World, entity: Entity): boolean;
+/**
+ * The least health damage leaves a unit with, by the buffs it carries (`BuffDef.minHealth`): the highest of them, 0
+ * where none says
+ *
+ * @beta
+ */
+export declare function healthFloor(world: World, entity: Entity): number;
 /**
  * Whether a unit is immune to spells: by its type, or a buff it carries (an avatar), as declared or as code decides
  *
  * @beta
  */
 export declare function isSpellImmune(world: World, entity: Entity): boolean;
-/** @beta */
+/**
+ * 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
+ */
 export declare function avoids(world: World, entity: Entity, ability: AbilityDef): boolean;
-/** Whether a buff keeps a unit from doing what it wants: stuns and slows. Tenacity cuts those short */
+/** Whether a buff keeps a unit from doing what it wants: stuns and slows. Tenacity cuts those short, but not a suppression */
 export declare function isCrowdControl(def: BuffDef): boolean;
-/** @beta */
+/**
+ * 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
+ */
+export declare const holdsUp: (def: BuffDef) => boolean;
+/**
+ * Nothing that holds a unit up does anything to it now: it carries a buff that is `unstoppable`
+ *
+ * @beta
+ */
+export declare const isUnstoppable: (world: World, entity: Entity) => boolean;
+/**
+ * Whether `entity` is stunned now: a buff on it stuns it, or has it airborne
+ *
+ * @beta
+ */
 export declare const isStunned: (world: World, entity: Entity) => boolean;
 /**
  * Held to the spot: it can do everything but walk
@@ -47,6 +93,51 @@ export declare const isStunned: (world: World, entity: Entity) => boolean;
  * @beta
  */
 export declare const isRooted: (world: World, entity: Entity) => boolean;
+/**
+ * The buff that takes a unit's orders now (`BuffDef.control`): the last it carries of them, unless it is unstoppable
+ *
+ * @beta
+ */
+export declare function controlOf(world: World, entity: Entity): BuffInstance | undefined;
+/**
+ * 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
+ */
+export declare const isPhasing: (world: World, entity: Entity) => boolean;
+/**
+ * The buffs a unit carries that have a tag (`BuffDef.tags`): a `fire` on it, the `anti-heal` it is under
+ *
+ * @beta
+ */
+export declare function buffsTagged(world: World, entity: Entity, tag: string): BuffInstance[];
+/**
+ * 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
+ */
+export declare function healthPerMana(world: World, entity: Entity): number;
+/**
+ * Whether a buff takes a unit's orders now (`BuffDef.control`): it refuses any new
+ *
+ * @beta
+ */
+export declare const isControlled: (world: World, entity: Entity) => boolean;
+/**
+ * Whether a unit cannot rush or jump of its own now (`BuffDef.grounded`)
+ *
+ * @beta
+ */
+export declare const isGrounded: (world: World, entity: Entity) => boolean;
+/**
+ * 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
+ */
+export declare const isCleansable: (def: BuffDef) => boolean;
 /**
  * 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
@@ -66,6 +157,15 @@ export declare const silences: (silence: BuffDef['silence'], ability?: AbilityDe
  * @beta
  */
 export declare function layerOf(world: World, entity: Entity): Layer;
+/**
+ * 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
+ */
+export declare function overheal(world: World, target: Entity, source: Entity | undefined, over: number): void;
 /**
  * What is left of the shields on an entity
  *