@v12-engine/engine 0.1.0 → 0.4.0

package/dist/stats.d.ts

@@ -2,7 +2,7 @@ import { type DamageType, type StatChange, type StatKey, type Stats } from './de
 import type { Entity } from './entity';
 import type { World } from './world';
 /**
- * What adds up a unit's stats in the sum: what a stat source is handed (`StatPart.add`)
+ * What adds up a unit's stats in the sum: what a stat source is handed (`StatField.add`)
  *
  * @beta
  */
@@ -19,15 +19,13 @@ export interface StatSum {
  *
  * @beta
  */
-export interface StatPart {
+export interface StatField {
+    /** The stat field's id, unique among the stat fields of a game */
     readonly id: string;
+    /** A number that changes whenever what this field adds to the entity's stats changes, and is 0 when it adds nothing */
     stamp(entity: Entity): number;
+    /** Adds this field's part to the entity's stat sum */
     add(world: World, entity: Entity, sum: StatSum): void;
-    /**
-     * What it makes of the stats once everything else is added (research, the packs' parts, items, buffs, the `stats`
-     * hook), read with `sum.get`: a hero's strength into health, in the attributes pack (`withAttributes`)
-     */
-    derive?(world: World, entity: Entity, sum: StatSum): void;
 }
 /**
  * Says the stats of an entity, or of every entity when none is said, are to be added up again the next time they are
@@ -58,7 +56,7 @@ export interface StatsCache {
     def: Entity['def'];
     night: boolean;
     owner: number;
-    /** What each of the packs' stat sources stamped it with (`StatPart.stamp`), in their order */
+    /** What each of the packs' stat sources stamped it with (`StatField.stamp`), in their order */
     stamps: number[];
     upgradesVersion: number;
     /** `World.statsVersion` when it was worked out: `invalidateStats` for every entity moves it on */
@@ -76,7 +74,7 @@ export interface StatsCache {
  *
  * The result is shared and must not be changed. It stays the same object for as long as the stats stay the same.
  *
- * @beta
+ * @public
  */
 export declare function statsOf(world: World, entity: Entity): Readonly<Stats>;
 /**
@@ -88,21 +86,47 @@ export declare function statsOf(world: World, entity: Entity): Readonly<Stats>;
 export declare function refreshVitals(world: World, entity: Entity): void;
 /**
  * What is left of damage once the armor or the magic resist of the target had its say, as a part of it: 100 of it
- * halve what arrives, and below 0 it adds. The engine's formula: the game's is `world.rules.combat.mitigation`, which
- * is this unless the game says (penetration: `withMobaStats`)
+ * halve what arrives, and below 0 it adds. The engine's formula: the game's is `world.settings.combat.mitigation`, which
+ * is this unless the game says (penetration: `mobaStatsPack`)
  *
  * @beta
  */
 export declare function mitigation(type: DamageType, target: Readonly<Stats>): number;
 /**
- * How long an attack of the entity takes: from the start of the swing to the hit, and from one swing to the next. Of
- * its first attack, or the one at that place (`UnitTypeDef.attacks`), by the speed stat it reads (`AttackDef.stats`)
+ * The stat that makes damage of a type more or less for whoever takes it, on top of `incomingDamage`:
+ * `incomingMagicDamage` for magic. Flat names, not `incomingDamage.magic`: a stat is one number by its id, and the
+ * data's paths (`stats.incomingMagicDamage`) read a dot as a step into an object
+ *
+ * @beta
+ */
+export declare const INCOMING_DAMAGE: Readonly<Record<DamageType, 'incomingPhysicalDamage' | 'incomingMagicDamage' | 'incomingTrueDamage'>>;
+/**
+ * What damage is multiplied by for who deals it and who takes it, once armor or magic resist had their say and before
+ * shields: the source's `outgoingDamage`, and the target's `incomingDamage` with the part of the damage's own type
+ * (`incomingMagicDamage`), each side's parts added up and never below none, so that nothing turns damage into healing.
+ * The engine's formula: the game's is `world.settings.combat.damageScale`
+ *
+ * @beta
+ */
+export declare function damageScale(type: DamageType, target: Readonly<Stats>, source?: Readonly<Stats>): number;
+/**
+ * What healing is multiplied by for who gets it: its `incomingHealing` (-0.4: an anti-heal), never below none, so that
+ * nothing turns healing into harm. The engine's formula: the game's is `world.settings.combat.healingScale`
+ *
+ * @beta
+ */
+export declare function healingScale(target: Readonly<Stats>): number;
+/**
+ * How long an attack of the entity takes: from the start of the swing to the hit (the windup), from one swing to the
+ * next, and how long it is held after the hit (`AttackDef.recovery`). Of its first attack, or the one at that place
+ * (`UnitTypeDef.attacks`), by the speed stat it reads (`AttackDef.stats`)
  *
  * @beta
  */
 export declare function attackTiming(world: World, entity: Entity, weapon?: number): {
     swing: number;
     period: number;
+    recovery: number;
 };
 /**
  * Seconds an ability of the entity takes to be ready again
@@ -111,12 +135,14 @@ export declare function attackTiming(world: World, entity: Entity, weapon?: numb
  */
 export declare function cooldownOf(world: World, entity: Entity, seconds: number): number;
 /**
- * How long an attack takes, from the start of the swing to the hit, and from one swing to the next, for a unit
- * whose type attacks `base` times a second and that now attacks `speed` times. Undefined for what does not attack
+ * How long an attack takes, from the start of the swing to the hit (the windup), from one swing to the next, and how
+ * long the unit is held after the hit (`AttackDef.recovery`, 0 when left out), for a unit whose type attacks `base`
+ * times a second and that now attacks `speed` times. Undefined for what does not attack
  *
  * @beta
  */
-export declare function swingTiming(damagePoint: number, base: number, speed: number): {
+export declare function swingTiming(damagePoint: number, base: number, speed: number, recovery?: number): {
     swing: number;
     period: number;
+    recovery: number;
 } | undefined;

package/dist/stats.js

@@ -0,0 +1,290 @@
+import { clamp } from "./math.js";
+import { at, baseStats } from "./defs.js";
+import { inventorySlots, slotsOf } from "./inventory.js";
+//#region src/stats.ts
+/** Adds up everything that changes the stats of one unit */
+var Sum = class {
+	flat;
+	/** Parts by stat, for the stats something changes by a part */
+	percent = {};
+	/** Slows are kept apart from what makes faster: resistance only weakens the former */
+	slow = 0;
+	constructor(base) {
+		this.flat = { ...base };
+	}
+	add(change, times = 1) {
+		for (const key in change.stats) this.flat[key] += change.stats[key] * times;
+		for (const key in change.percent) this.part(key, change.percent[key] * times);
+	}
+	addScaled(change, level, times = 1) {
+		for (const key in change.stats) this.flat[key] += at(change.stats[key], level) * times;
+		for (const key in change.percent) this.part(key, at(change.percent[key], level) * times);
+	}
+	get(key) {
+		return (this.flat[key] ?? 0) * Math.max(1 + (this.percent[key] ?? 0), 0);
+	}
+	part(key, value) {
+		if (key === "moveSpeed" && value < 0) this.slow += value;
+		else this.percent[key] = (this.percent[key] ?? 0) + value;
+	}
+	/** The stats, kept within what the rules of the game allow, and its own stats within their bounds */
+	result(game) {
+		const { flat, percent } = this;
+		const stats = flat;
+		for (const key in percent) {
+			const part = percent[key];
+			if (part !== 0) stats[key] *= Math.max(1 + part, 0);
+		}
+		game.settings.combat.clampStats(stats, game.settings);
+		const slowed = this.slow === 0 ? 1 : Math.max(1 + game.settings.combat.slowTaken(stats, this.slow), 0);
+		stats.moveSpeed = Math.max(stats.moveSpeed * slowed, 0);
+		for (const { id, min, max } of game.stats) stats[id] = clamp(stats[id], min ?? -Infinity, max ?? Infinity);
+		stats.health = Math.max(Math.round(stats.health), 1);
+		stats.mana = Math.max(Math.round(stats.mana), 0);
+		return stats;
+	}
+};
+/** Whether anything changes the stats a unit started with */
+function changed(world, entity) {
+	if (entity.buffs.length > 0 || entity.has(inventorySlots) || world.hooks.has("stats")) return true;
+	for (const source of world.registry.statFields) if (source.stamp(entity) !== 0) return true;
+	return world.player(entity.owner).upgrades.size > 0;
+}
+/** Adds up the stats of an entity from scratch. Use `statsOf`, which only does this when something changed */
+function computeStats(world, entity, night) {
+	const base = baseStats(entity.def, world.registry, night);
+	if (!changed(world, entity)) return base;
+	const sum = new Sum(base);
+	for (const [id, level] of world.player(entity.owner).upgrades) for (const effect of world.registry.upgrade(id).effects) if (!effect.units || (typeof effect.units === "function" ? effect.units(entity.def) : effect.units.includes(entity.def.id))) sum.add(effect, level);
+	for (const source of world.registry.statFields) source.add(world, entity, sum);
+	const slots = slotsOf(entity);
+	if (slots) for (const instance of slots) {
+		const bonus = instance && world.registry.item(instance.item).bonus;
+		if (bonus) sum.add(bonus);
+	}
+	for (const instance of entity.buffs) {
+		const def = world.registry.buff(instance.id);
+		sum.addScaled(def, instance.level, def.perStack ? instance.stacks ?? 1 : 1);
+		const own = def.change?.(world, entity, instance);
+		if (own) sum.add(own);
+	}
+	if (world.hooks.has("stats")) world.hooks.run("stats", {
+		entity,
+		base,
+		add: (change, times) => sum.add(change, times)
+	});
+	const stats = sum.result(world.registry);
+	if (entity.def.uses) stats.health = entity.def.uses;
+	return stats;
+}
+/**
+* Says the stats of an entity, or of every entity when none is said, are to be added up again the next time they are
+* asked for: what a `stats` hook or a buff's `change` reads changed (an ally came near, a flag of the game's). What
+* the engine knows about (buffs, items, levels, research, the time of day) it notices by itself
+*
+* @beta
+*/
+function invalidateStats(world, entity) {
+	if (entity) entity.statsCache = null;
+	else world.statsVersion++;
+}
+/** Whether the packs' stat sources stamp the entity as they did when its stats were worked out */
+function sameStamps(stamps, world, entity) {
+	const sources = world.registry.statFields;
+	for (let i = 0; i < sources.length; i++) if (sources[i].stamp(entity) !== stamps[i]) return false;
+	return true;
+}
+/** Whether the stats in the cache were worked out from what the entity is right now */
+function stillHolds(cache, world, entity, night) {
+	if (cache.def !== entity.def || cache.night !== night || cache.owner !== entity.owner || !sameStamps(cache.stamps, world, entity) || cache.upgradesVersion !== world.player(entity.owner).upgradesVersion || cache.statsVersion !== world.statsVersion) return false;
+	const { buffs } = entity;
+	if (buffs.length !== cache.buffIds.length) return false;
+	for (let i = 0; i < buffs.length; i++) {
+		const buff = buffs[i];
+		if (buff.id !== cache.buffIds[i] || buff.level !== cache.buffLevels[i] || (buff.stacks ?? 0) !== cache.buffStacks[i]) return false;
+	}
+	const slots = slotsOf(entity);
+	if (!slots) return cache.items.length === 0;
+	let carried = 0;
+	for (let i = 0; i < slots.length; i++) {
+		const item = slots[i];
+		if (!item) continue;
+		if (item.item !== cache.items[carried]) return false;
+		carried++;
+	}
+	return carried === cache.items.length;
+}
+function buildCache(world, entity, night) {
+	const items = [];
+	const slots = slotsOf(entity);
+	if (slots) {
+		for (const item of slots) if (item) items.push(item.item);
+	}
+	return {
+		stats: computeStats(world, entity, night),
+		def: entity.def,
+		night,
+		owner: entity.owner,
+		stamps: world.registry.statFields.map((source) => source.stamp(entity)),
+		upgradesVersion: world.player(entity.owner).upgradesVersion,
+		statsVersion: world.statsVersion,
+		items,
+		buffIds: entity.buffs.map((buff) => buff.id),
+		buffLevels: entity.buffs.map((buff) => buff.level),
+		buffStacks: entity.buffs.map((buff) => buff.stacks ?? 0)
+	};
+}
+/**
+* The stats of an entity as they are right now: what its type starts with at this time of day, and on top of that
+* its levels, the research of its owner, what it carries and the buffs on it.
+*
+* The result is shared and must not be changed. It stays the same object for as long as the stats stay the same.
+*
+* @public
+*/
+function statsOf(world, entity) {
+	const night = world.night;
+	const cache = entity.statsCache;
+	if (cache && stillHolds(cache, world, entity, night)) {
+		if (world.checks.stats) checkCache(world, entity, night, cache.stats);
+		return cache.stats;
+	}
+	entity.statsCache = buildCache(world, entity, night);
+	return entity.statsCache.stats;
+}
+function checkCache(world, entity, night, cached) {
+	const fresh = computeStats(world, entity, night);
+	for (const key in fresh) {
+		const k = key;
+		if (fresh[k] !== cached[k]) throw new Error(`Stale stats cache: ${entity.def.id}#${entity.id} has ${key} ${cached[k]}, should be ${fresh[k]}`);
+	}
+}
+/**
+* The stats that are not what the type of the entity starts with by day, or undefined when all of them are
+*
+* @internal
+*/
+function changedStats(world, entity) {
+	const base = baseStats(entity.def, world.registry);
+	const stats = statsOf(world, entity);
+	if (stats === base) return void 0;
+	const cache = entity.statsCache;
+	if (cache.changedFor === stats) return cache.changed;
+	let result;
+	for (const key in stats) if (stats[key] !== base[key]) (result ??= {})[key] = stats[key];
+	cache.changed = result;
+	cache.changedFor = stats;
+	return result;
+}
+/**
+* Brings the most health and mana an entity can have in line with its stats.
+* What is gained is added to what it has, what is lost is only taken when it has more than it can hold.
+*
+* @beta
+*/
+function refreshVitals(world, entity) {
+	const stats = statsOf(world, entity);
+	if (stats.health !== entity.maxHealth) {
+		entity.health = Math.min(entity.health + Math.max(stats.health - entity.maxHealth, 0), stats.health);
+		entity.maxHealth = stats.health;
+	}
+	if (stats.mana !== entity.maxMana) {
+		entity.mana = Math.min(entity.mana + Math.max(stats.mana - entity.maxMana, 0), stats.mana);
+		entity.maxMana = stats.mana;
+	}
+}
+/**
+* What is left of damage once the armor or the magic resist of the target had its say, as a part of it: 100 of it
+* halve what arrives, and below 0 it adds. The engine's formula: the game's is `world.settings.combat.mitigation`, which
+* is this unless the game says (penetration: `mobaStatsPack`)
+*
+* @beta
+*/
+function mitigation(type, target) {
+	if (type === "true") return 1;
+	return resisted(type === "physical" ? target.armor : target.magicResist);
+}
+/**
+* The stat that makes damage of a type more or less for whoever takes it, on top of `incomingDamage`:
+* `incomingMagicDamage` for magic. Flat names, not `incomingDamage.magic`: a stat is one number by its id, and the
+* data's paths (`stats.incomingMagicDamage`) read a dot as a step into an object
+*
+* @beta
+*/
+var INCOMING_DAMAGE = Object.freeze({
+	physical: "incomingPhysicalDamage",
+	magic: "incomingMagicDamage",
+	true: "incomingTrueDamage"
+});
+/**
+* What damage is multiplied by for who deals it and who takes it, once armor or magic resist had their say and before
+* shields: the source's `outgoingDamage`, and the target's `incomingDamage` with the part of the damage's own type
+* (`incomingMagicDamage`), each side's parts added up and never below none, so that nothing turns damage into healing.
+* The engine's formula: the game's is `world.settings.combat.damageScale`
+*
+* @beta
+*/
+function damageScale(type, target, source) {
+	return Math.max(1 + (target.incomingDamage ?? 0) + (target[INCOMING_DAMAGE[type]] ?? 0), 0) * (source ? Math.max(1 + (source.outgoingDamage ?? 0), 0) : 1);
+}
+/**
+* What healing is multiplied by for who gets it: its `incomingHealing` (-0.4: an anti-heal), never below none, so that
+* nothing turns healing into harm. The engine's formula: the game's is `world.settings.combat.healingScale`
+*
+* @beta
+*/
+function healingScale(target) {
+	return Math.max(1 + (target.incomingHealing ?? 0), 0);
+}
+/**
+* What is left of damage against a resistance: 100 of it halve what arrives, below 0 it adds
+*
+* @internal
+*/
+var resisted = (resist) => resist >= 0 ? 100 / (100 + resist) : 2 - 100 / (100 - resist);
+/**
+* How long an attack of the entity takes: from the start of the swing to the hit (the windup), from one swing to the
+* next, and how long it is held after the hit (`AttackDef.recovery`). Of its first attack, or the one at that place
+* (`UnitTypeDef.attacks`), by the speed stat it reads (`AttackDef.stats`)
+*
+* @beta
+*/
+function attackTiming(world, entity, weapon = 0) {
+	const attack = entity.def.attacks?.[weapon];
+	const speed = attack?.stats?.speed ?? "attackSpeed";
+	const base = baseStats(entity.def, world.registry)[speed] ?? 0;
+	return swingTiming(attack?.damagePoint ?? 0, base, statsOf(world, entity)[speed] ?? 0, attack?.recovery) ?? {
+		swing: 0,
+		period: Infinity,
+		recovery: 0
+	};
+}
+/**
+* Seconds an ability of the entity takes to be ready again
+*
+* @beta
+*/
+function cooldownOf(world, entity, seconds) {
+	return world.settings.combat.cooldown(seconds, statsOf(world, entity));
+}
+/**
+* How long an attack takes, from the start of the swing to the hit (the windup), from one swing to the next, and how
+* long the unit is held after the hit (`AttackDef.recovery`, 0 when left out), for a unit whose type attacks `base`
+* times a second and that now attacks `speed` times. Undefined for what does not attack
+*
+* @beta
+*/
+function swingTiming(damagePoint, base, speed, recovery = 0) {
+	if (!speed || !base) return void 0;
+	const period = 1 / speed;
+	const swing = Math.min(damagePoint * base / speed, period);
+	return {
+		swing,
+		period,
+		recovery: recovery > 0 ? Math.min(recovery * base / speed, period - swing) : 0
+	};
+}
+//#endregion
+export { INCOMING_DAMAGE, attackTiming, changedStats, cooldownOf, damageScale, healingScale, invalidateStats, mitigation, refreshVitals, resisted, statsOf, swingTiming };
+
+//# sourceMappingURL=stats.js.map

package/dist/stats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats.js","names":[],"sources":["../src/stats.ts"],"sourcesContent":["import { inventorySlots, slotsOf } from './inventory'\nimport { at, baseStats, type DamageType, type ScaledStatChange, type StatChange, type StatKey, type Stats } from './defs'\nimport type { Entity } from './entity'\nimport { clamp } from './math'\nimport type { Registry } from './registry'\nimport type { World } from './world'\n\n/** Adds up everything that changes the stats of one unit */\nclass Sum {\n\treadonly flat: Stats\n\t/** Parts by stat, for the stats something changes by a part */\n\treadonly percent: Record<string, number> = {}\n\t/** Slows are kept apart from what makes faster: resistance only weakens the former */\n\tslow = 0\n\n\tconstructor(base: Readonly<Stats>) {\n\t\tthis.flat = { ...base }\n\t}\n\n\tadd(change: StatChange, times = 1): void {\n\t\tfor (const key in change.stats) this.flat[key as StatKey] += change.stats[key as StatKey]! * times\n\t\tfor (const key in change.percent) this.part(key as StatKey, change.percent[key as StatKey]! * times)\n\t}\n\n\taddScaled(change: ScaledStatChange, level: number, times = 1): void {\n\t\tfor (const key in change.stats) this.flat[key as StatKey] += at(change.stats[key as StatKey], level) * times\n\t\tfor (const key in change.percent) this.part(key as StatKey, at(change.percent[key as StatKey], level) * times)\n\t}\n\n\tget(key: StatKey): number {\n\t\treturn (this.flat[key] ?? 0) * Math.max(1 + (this.percent[key] ?? 0), 0)\n\t}\n\n\tprivate part(key: StatKey, value: number): void {\n\t\tif (key === 'moveSpeed' && value < 0) this.slow += value\n\t\telse this.percent[key] = (this.percent[key] ?? 0) + value\n\t}\n\n\t/** The stats, kept within what the rules of the game allow, and its own stats within their bounds */\n\tresult(game: Registry): Stats {\n\t\tconst { flat, percent } = this\n\t\tconst stats = flat\n\t\tfor (const key in percent) {\n\t\t\tconst part = percent[key]\n\t\t\tif (part !== 0) stats[key] *= Math.max(1 + part, 0)\n\t\t}\n\t\tgame.settings.combat.clampStats(stats, game.settings)\n\t\tconst slowed = this.slow === 0 ? 1 : Math.max(1 + game.settings.combat.slowTaken(stats, this.slow), 0)\n\t\tstats.moveSpeed = Math.max(stats.moveSpeed * slowed, 0)\n\t\tfor (const { id, min, max } of game.stats) stats[id] = clamp(stats[id], min ?? -Infinity, max ?? Infinity)\n\t\tstats.health = Math.max(Math.round(stats.health), 1)\n\t\tstats.mana = Math.max(Math.round(stats.mana), 0)\n\t\treturn stats\n\t}\n}\n\n/**\n * What adds up a unit's stats in the sum: what a stat source is handed (`StatField.add`)\n *\n * @beta\n */\nexport interface StatSum {\n\t/** Adds a change to the stats, `times` over (1 when left out) */\n\tadd(change: StatChange, times?: number): void\n\t/** What a stat comes to so far: all that was added to it, by the parts it was made bigger or smaller by */\n\tget(stat: StatKey): number\n}\n\n/**\n * A part of the stats a pack adds (`GamePack.stats`): a hero's growth by its level, in the heroes pack. `stamp` is a\n * number that changes whenever what it adds does, and is 0 when it adds nothing: the stats are added up again when it\n * changes, however it changed (a game that sets a hero's level itself says nothing, and need not)\n *\n * @beta\n */\nexport interface StatField {\n\t/** The stat field's id, unique among the stat fields of a game */\n\treadonly id: string\n\t/** A number that changes whenever what this field adds to the entity's stats changes, and is 0 when it adds nothing */\n\tstamp(entity: Entity): number\n\t/** Adds this field's part to the entity's stat sum */\n\tadd(world: World, entity: Entity, sum: StatSum): void\n}\n\n/** Whether anything changes the stats a unit started with */\nfunction changed(world: World, entity: Entity): boolean {\n\tif (entity.buffs.length > 0 || entity.has(inventorySlots) || world.hooks.has('stats')) return true\n\tfor (const source of world.registry.statFields) if (source.stamp(entity) !== 0) return true\n\treturn world.player(entity.owner).upgrades.size > 0\n}\n\n/** Adds up the stats of an entity from scratch. Use `statsOf`, which only does this when something changed */\nfunction computeStats(world: World, entity: Entity, night: boolean): Readonly<Stats> {\n\tconst base = baseStats(entity.def, world.registry, night)\n\tif (!changed(world, entity)) return base\n\n\tconst sum = new Sum(base)\n\tfor (const [id, level] of world.player(entity.owner).upgrades) {\n\t\tfor (const effect of world.registry.upgrade(id).effects) {\n\t\t\tif (!effect.units || (typeof effect.units === 'function' ? effect.units(entity.def) : effect.units.includes(entity.def.id)))\n\t\t\t\tsum.add(effect, level)\n\t\t}\n\t}\n\t// what the packs add: a hero's growth by its level\n\tfor (const source of world.registry.statFields) source.add(world, entity, sum)\n\tconst slots = slotsOf(entity)\n\tif (slots) {\n\t\tfor (const instance of slots) {\n\t\t\tconst bonus = instance && world.registry.item(instance.item).bonus\n\t\t\tif (bonus) sum.add(bonus)\n\t\t}\n\t}\n\tfor (const instance of entity.buffs) {\n\t\tconst def = world.registry.buff(instance.id)\n\t\tsum.addScaled(def, instance.level, def.perStack ? (instance.stacks ?? 1) : 1)\n\t\tconst own = def.change?.(world, entity, instance)\n\t\tif (own) sum.add(own)\n\t}\n\t// and whatever the game adds in code: \"+2 armor for each ally near\"\n\tif (world.hooks.has('stats')) world.hooks.run('stats', { entity, base, add: (change, times) => sum.add(change, times) })\n\tconst stats = sum.result(world.registry)\n\t// a unit whose health counts hits keeps that many, whatever adds health\n\tif (entity.def.uses) stats.health = entity.def.uses\n\treturn stats\n}\n\n/**\n * Says the stats of an entity, or of every entity when none is said, are to be added up again the next time they are\n * asked for: what a `stats` hook or a buff's `change` reads changed (an ally came near, a flag of the game's). What\n * the engine knows about (buffs, items, levels, research, the time of day) it notices by itself\n *\n * @beta\n */\nexport function invalidateStats(world: World, entity?: Entity): void {\n\tif (entity) entity.statsCache = null\n\telse world.statsVersion++\n}\n\n/**\n * The stats of an entity the last time they were worked out, and everything they were worked out from.\n *\n * Stats are asked for all the time: on every hit (for both sides), every target search, every fog update.\n * Adding them up means going through the owner's research, what the unit carries and every buff on it,\n * and allocates. Checking whether any of that changed is a handful of comparisons and allocates nothing,\n * so `statsOf` does that first and only adds up again when something did.\n *\n * The inputs are compared, rather than the cache being thrown away wherever they change, so that nothing\n * can change a buff or an item and forget to say so: game modules and mods change them directly.\n *\n * Not game state: it can be dropped at any time (and is never saved or sent), it is rebuilt on the next ask.\n */\nexport interface StatsCache {\n\tstats: Readonly<Stats>\n\t/** `changedStats` of `stats`, once someone asked. The same object for as long as the stats stay the same */\n\tchanged?: Partial<Stats>\n\tchangedFor?: Readonly<Stats>\n\n\tdef: Entity['def']\n\tnight: boolean\n\towner: number\n\t/** What each of the packs' stat sources stamped it with (`StatField.stamp`), in their order */\n\tstamps: number[]\n\tupgradesVersion: number\n\t/** `World.statsVersion` when it was worked out: `invalidateStats` for every entity moves it on */\n\tstatsVersion: number\n\t/** Ids of what it carries, in slot order, empty slots left out */\n\titems: string[]\n\t/** Id, level and stacks of every buff, in order */\n\tbuffIds: string[]\n\tbuffLevels: number[]\n\tbuffStacks: number[]\n}\n\n/** Whether the packs' stat sources stamp the entity as they did when its stats were worked out */\nfunction sameStamps(stamps: number[], world: World, entity: Entity): boolean {\n\tconst sources = world.registry.statFields\n\tfor (let i = 0; i < sources.length; i++) if (sources[i].stamp(entity) !== stamps[i]) return false\n\treturn true\n}\n\n/** Whether the stats in the cache were worked out from what the entity is right now */\nfunction stillHolds(cache: StatsCache, world: World, entity: Entity, night: boolean): boolean {\n\tif (\n\t\tcache.def !== entity.def ||\n\t\tcache.night !== night ||\n\t\tcache.owner !== entity.owner ||\n\t\t!sameStamps(cache.stamps, world, entity) ||\n\t\tcache.upgradesVersion !== world.player(entity.owner).upgradesVersion ||\n\t\tcache.statsVersion !== world.statsVersion\n\t) {\n\t\treturn false\n\t}\n\tconst { buffs } = entity\n\tif (buffs.length !== cache.buffIds.length) return false\n\tfor (let i = 0; i < buffs.length; i++) {\n\t\tconst buff = buffs[i]\n\t\tif (buff.id !== cache.buffIds[i] || buff.level !== cache.buffLevels[i] || (buff.stacks ?? 0) !== cache.buffStacks[i]) return false\n\t}\n\t// asked of every unit many times a tick: what carries nothing makes no empty list to go through\n\tconst slots = slotsOf(entity)\n\tif (!slots) return cache.items.length === 0\n\tlet carried = 0\n\tfor (let i = 0; i < slots.length; i++) {\n\t\tconst item = slots[i]\n\t\tif (!item) continue\n\t\tif (item.item !== cache.items[carried]) return false\n\t\tcarried++\n\t}\n\treturn carried === cache.items.length\n}\n\nfunction buildCache(world: World, entity: Entity, night: boolean): StatsCache {\n\tconst items: string[] = []\n\tconst slots = slotsOf(entity)\n\tif (slots) for (const item of slots) if (item) items.push(item.item)\n\treturn {\n\t\tstats: computeStats(world, entity, night),\n\t\tdef: entity.def,\n\t\tnight,\n\t\towner: entity.owner,\n\t\tstamps: world.registry.statFields.map((source) => source.stamp(entity)),\n\t\tupgradesVersion: world.player(entity.owner).upgradesVersion,\n\t\tstatsVersion: world.statsVersion,\n\t\titems,\n\t\tbuffIds: entity.buffs.map((buff) => buff.id),\n\t\tbuffLevels: entity.buffs.map((buff) => buff.level),\n\t\tbuffStacks: entity.buffs.map((buff) => buff.stacks ?? 0)\n\t}\n}\n\n/**\n * The stats of an entity as they are right now: what its type starts with at this time of day, and on top of that\n * its levels, the research of its owner, what it carries and the buffs on it.\n *\n * The result is shared and must not be changed. It stays the same object for as long as the stats stay the same.\n *\n * @public\n */\nexport function statsOf(world: World, entity: Entity): Readonly<Stats> {\n\tconst night = world.night\n\tconst cache = entity.statsCache\n\tif (cache && stillHolds(cache, world, entity, night)) {\n\t\tif (world.checks.stats) checkCache(world, entity, night, cache.stats)\n\t\treturn cache.stats\n\t}\n\tentity.statsCache = buildCache(world, entity, night)\n\treturn entity.statsCache.stats\n}\n\nfunction checkCache(world: World, entity: Entity, night: boolean, cached: Readonly<Stats>): void {\n\tconst fresh = computeStats(world, entity, night)\n\tfor (const key in fresh) {\n\t\tconst k = key as StatKey\n\t\tif (fresh[k] !== cached[k]) {\n\t\t\tthrow new Error(`Stale stats cache: ${entity.def.id}#${entity.id} has ${key} ${cached[k]}, should be ${fresh[k]}`)\n\t\t}\n\t}\n}\n\n/**\n * The stats that are not what the type of the entity starts with by day, or undefined when all of them are\n *\n * @internal\n */\nexport function changedStats(world: World, entity: Entity): Partial<Stats> | undefined {\n\tconst base = baseStats(entity.def, world.registry)\n\tconst stats = statsOf(world, entity)\n\tif (stats === base) return undefined\n\t// the same stats give the same answer, as the same object: whoever keeps it (the client does) can tell nothing changed\n\tconst cache = entity.statsCache!\n\tif (cache.changedFor === stats) return cache.changed\n\tlet result: Partial<Stats> | undefined\n\tfor (const key in stats) {\n\t\tif (stats[key as StatKey] !== base[key as StatKey]) (result ??= {})[key as StatKey] = stats[key as StatKey]\n\t}\n\tcache.changed = result\n\tcache.changedFor = stats\n\treturn result\n}\n\n/**\n * Brings the most health and mana an entity can have in line with its stats.\n * What is gained is added to what it has, what is lost is only taken when it has more than it can hold.\n *\n * @beta\n */\nexport function refreshVitals(world: World, entity: Entity): void {\n\tconst stats = statsOf(world, entity)\n\tif (stats.health !== entity.maxHealth) {\n\t\tentity.health = Math.min(entity.health + Math.max(stats.health - entity.maxHealth, 0), stats.health)\n\t\tentity.maxHealth = stats.health\n\t}\n\tif (stats.mana !== entity.maxMana) {\n\t\tentity.mana = Math.min(entity.mana + Math.max(stats.mana - entity.maxMana, 0), stats.mana)\n\t\tentity.maxMana = stats.mana\n\t}\n}\n\n/**\n * What is left of damage once the armor or the magic resist of the target had its say, as a part of it: 100 of it\n * halve what arrives, and below 0 it adds. The engine's formula: the game's is `world.settings.combat.mitigation`, which\n * is this unless the game says (penetration: `mobaStatsPack`)\n *\n * @beta\n */\nexport function mitigation(type: DamageType, target: Readonly<Stats>): number {\n\tif (type === 'true') return 1\n\treturn resisted(type === 'physical' ? target.armor : target.magicResist)\n}\n\n/**\n * The stat that makes damage of a type more or less for whoever takes it, on top of `incomingDamage`:\n * `incomingMagicDamage` for magic. Flat names, not `incomingDamage.magic`: a stat is one number by its id, and the\n * data's paths (`stats.incomingMagicDamage`) read a dot as a step into an object\n *\n * @beta\n */\nexport const INCOMING_DAMAGE: Readonly<Record<DamageType, 'incomingPhysicalDamage' | 'incomingMagicDamage' | 'incomingTrueDamage'>> = Object.freeze({\n\tphysical: 'incomingPhysicalDamage',\n\tmagic: 'incomingMagicDamage',\n\ttrue: 'incomingTrueDamage'\n})\n\n/**\n * What damage is multiplied by for who deals it and who takes it, once armor or magic resist had their say and before\n * shields: the source's `outgoingDamage`, and the target's `incomingDamage` with the part of the damage's own type\n * (`incomingMagicDamage`), each side's parts added up and never below none, so that nothing turns damage into healing.\n * The engine's formula: the game's is `world.settings.combat.damageScale`\n *\n * @beta\n */\nexport function damageScale(type: DamageType, target: Readonly<Stats>, source?: Readonly<Stats>): number {\n\tconst taken = Math.max(1 + (target.incomingDamage ?? 0) + (target[INCOMING_DAMAGE[type]] ?? 0), 0)\n\tconst dealt = source ? Math.max(1 + (source.outgoingDamage ?? 0), 0) : 1\n\treturn taken * dealt\n}\n\n/**\n * What healing is multiplied by for who gets it: its `incomingHealing` (-0.4: an anti-heal), never below none, so that\n * nothing turns healing into harm. The engine's formula: the game's is `world.settings.combat.healingScale`\n *\n * @beta\n */\nexport function healingScale(target: Readonly<Stats>): number {\n\treturn Math.max(1 + (target.incomingHealing ?? 0), 0)\n}\n\n/**\n * What is left of damage against a resistance: 100 of it halve what arrives, below 0 it adds\n *\n * @internal\n */\nexport const resisted = (resist: number): number => (resist >= 0 ? 100 / (100 + resist) : 2 - 100 / (100 - resist))\n\n/**\n * How long an attack of the entity takes: from the start of the swing to the hit (the windup), from one swing to the\n * next, and how long it is held after the hit (`AttackDef.recovery`). Of its first attack, or the one at that place\n * (`UnitTypeDef.attacks`), by the speed stat it reads (`AttackDef.stats`)\n *\n * @beta\n */\nexport function attackTiming(world: World, entity: Entity, weapon = 0): { swing: number; period: number; recovery: number } {\n\tconst attack = entity.def.attacks?.[weapon]\n\tconst speed = attack?.stats?.speed ?? 'attackSpeed'\n\tconst base = baseStats(entity.def, world.registry)[speed] ?? 0\n\treturn (\n\t\tswingTiming(attack?.damagePoint ?? 0, base, statsOf(world, entity)[speed] ?? 0, attack?.recovery) ?? { swing: 0, period: Infinity, recovery: 0 }\n\t)\n}\n\n/**\n * Seconds an ability of the entity takes to be ready again\n *\n * @beta\n */\nexport function cooldownOf(world: World, entity: Entity, seconds: number): number {\n\treturn world.settings.combat.cooldown(seconds, statsOf(world, entity))\n}\n\n/**\n * How long an attack takes, from the start of the swing to the hit (the windup), from one swing to the next, and how\n * long the unit is held after the hit (`AttackDef.recovery`, 0 when left out), for a unit whose type attacks `base`\n * times a second and that now attacks `speed` times. Undefined for what does not attack\n *\n * @beta\n */\nexport function swingTiming(\n\tdamagePoint: number,\n\tbase: number,\n\tspeed: number,\n\trecovery = 0\n): { swing: number; period: number; recovery: number } | undefined {\n\tif (!speed || !base) return undefined\n\tconst period = 1 / speed\n\t// the swing gets faster with the attack, and so does the recovery, which ends at the next swing at the latest\n\tconst swing = Math.min((damagePoint * base) / speed, period)\n\treturn { swing, period, recovery: recovery > 0 ? Math.min((recovery * base) / speed, period - swing) : 0 }\n}\n"],"mappings":"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"}

package/dist/summoned.d.ts

@@ -0,0 +1,52 @@
+import type { EntityId } from './entity';
+import type { Entity } from './entity';
+import type { World } from './world';
+/**
+ * Whom a summon goes for, besides what it would find itself (`Summoned.aggro`)
+ *
+ * @beta
+ */
+export type SummonAggro = 'nearest' | 'mastersAttacker' | 'none';
+/**
+ * On a unit a spell brought: who brought it (`by`, its master). Dispelling hurts what carries it. A `summon` effect
+ * gives it the rest: whether it walks with its master when it has nothing to do, whom it goes for, and whether it dies
+ * with its master (`diesWithMaster`; a `raiseDead` unit has only `by`, and outlives the one that raised it)
+ *
+ * @beta
+ */
+export interface Summoned {
+    /** The master: who cast the spell */
+    by: EntityId;
+    /** Walks with its master, within 2 cells, when it has no target (an idle summon) */
+    follow?: boolean;
+    /**
+     * Whom it takes up: `nearest` what any idle unit finds; `mastersAttacker` also whoever hits its master, at once and
+     * ahead of what is nearer; `none` leaves it to the game's `targetScore` and orders
+     */
+    aggro?: SummonAggro;
+    /** Dies when its master does */
+    diesWithMaster?: boolean;
+    /** The game's time, in seconds, it was brought at */
+    at?: number;
+    /** The last who hit its master (`aggro: 'mastersAttacker'`), and until when (game seconds) it counts for more */
+    foe?: EntityId;
+    /** Until when (game seconds) the last who hit the master counts for more */
+    foeUntil?: number;
+}
+/**
+ * On a unit a spell brought: see `Summoned`. Filed in the world's index, so that `summonsOf` goes through summons and
+ * nothing else
+ *
+ * @beta
+ */
+export declare const summoned: import("./components").Component<Summoned, Summoned>;
+/**
+ * The living units a spell brought for `master` (the `summon` effect's, and `raiseDead`'s), in the order of their ids
+ *
+ * @beta
+ */
+export declare function summonsOf(world: World, master: Entity | EntityId): Entity[];
+/** How long the master's last attacker counts for more with its summons, in seconds of the game */
+export declare const FOE_MEMORY = 6;
+/** What the master's attacker is worth more to a summon, in `targetScore` points (a unit of threat is worth 1000) */
+export declare const FOE_BONUS = 5000;

package/dist/summoned.js

@@ -0,0 +1,38 @@
+import { defineComponent } from "./components.js";
+//#region src/summoned.ts
+/**
+* On a unit a spell brought: see `Summoned`. Filed in the world's index, so that `summonsOf` goes through summons and
+* nothing else
+*
+* @beta
+*/
+var summoned = defineComponent({
+	id: "core.summoned",
+	replicate: "everyone",
+	index: true,
+	snapshot: ({ by, follow, aggro, diesWithMaster, at }) => ({
+		by,
+		follow,
+		aggro,
+		diesWithMaster,
+		at
+	}),
+	same: (a, b) => a.by === b.by && a.follow === b.follow && a.aggro === b.aggro && a.diesWithMaster === b.diesWithMaster && a.at === b.at
+});
+/**
+* The living units a spell brought for `master` (the `summon` effect's, and `raiseDead`'s), in the order of their ids
+*
+* @beta
+*/
+function summonsOf(world, master) {
+	const id = typeof master === "number" ? master : master.id;
+	const found = [];
+	for (const entity of world.index.with(summoned)) if (entity.alive && entity.get(summoned).by === id) found.push(entity);
+	return found.sort((a, b) => a.id - b.id);
+}
+/** What the master's attacker is worth more to a summon, in `targetScore` points (a unit of threat is worth 1000) */
+var FOE_BONUS = 5e3;
+//#endregion
+export { FOE_BONUS, summoned, summonsOf };
+
+//# sourceMappingURL=summoned.js.map

package/dist/summoned.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"summoned.js","names":[],"sources":["../src/summoned.ts"],"sourcesContent":["import { defineComponent } from './components'\nimport type { EntityId } from './entity'\nimport type { Entity } from './entity'\nimport type { World } from './world'\n\n/**\n * Whom a summon goes for, besides what it would find itself (`Summoned.aggro`)\n *\n * @beta\n */\nexport type SummonAggro = 'nearest' | 'mastersAttacker' | 'none'\n\n/**\n * On a unit a spell brought: who brought it (`by`, its master). Dispelling hurts what carries it. A `summon` effect\n * gives it the rest: whether it walks with its master when it has nothing to do, whom it goes for, and whether it dies\n * with its master (`diesWithMaster`; a `raiseDead` unit has only `by`, and outlives the one that raised it)\n *\n * @beta\n */\nexport interface Summoned {\n\t/** The master: who cast the spell */\n\tby: EntityId\n\t/** Walks with its master, within 2 cells, when it has no target (an idle summon) */\n\tfollow?: boolean\n\t/**\n\t * Whom it takes up: `nearest` what any idle unit finds; `mastersAttacker` also whoever hits its master, at once and\n\t * ahead of what is nearer; `none` leaves it to the game's `targetScore` and orders\n\t */\n\taggro?: SummonAggro\n\t/** Dies when its master does */\n\tdiesWithMaster?: boolean\n\t/** The game's time, in seconds, it was brought at */\n\tat?: number\n\t/** The last who hit its master (`aggro: 'mastersAttacker'`), and until when (game seconds) it counts for more */\n\tfoe?: EntityId\n\t/** Until when (game seconds) the last who hit the master counts for more */\n\tfoeUntil?: number\n}\n\n/**\n * On a unit a spell brought: see `Summoned`. Filed in the world's index, so that `summonsOf` goes through summons and\n * nothing else\n *\n * @beta\n */\nexport const summoned = defineComponent<Summoned>({ id: 'core.summoned', replicate: 'everyone',\n\tindex: true,\n\t// what the screen reads of it; who the master was hit by is the simulation's\n\tsnapshot: ({ by, follow, aggro, diesWithMaster, at }) => ({ by, follow, aggro, diesWithMaster, at }),\n\tsame: (a, b) => a.by === b.by && a.follow === b.follow && a.aggro === b.aggro && a.diesWithMaster === b.diesWithMaster && a.at === b.at })\n\n/**\n * The living units a spell brought for `master` (the `summon` effect's, and `raiseDead`'s), in the order of their ids\n *\n * @beta\n */\nexport function summonsOf(world: World, master: Entity | EntityId): Entity[] {\n\tconst id = typeof master === 'number' ? master : master.id\n\tconst found: Entity[] = []\n\tfor (const entity of world.index.with(summoned)) if (entity.alive && entity.get(summoned)!.by === id) found.push(entity)\n\treturn found.sort((a, b) => a.id - b.id)\n}\n\n/** How long the master's last attacker counts for more with its summons, in seconds of the game */\nexport const FOE_MEMORY = 6\n/** What the master's attacker is worth more to a summon, in `targetScore` points (a unit of threat is worth 1000) */\nexport const FOE_BONUS = 5000\n"],"mappings":";;;;;;;;AA6CA,IAAa,WAAW,gBAA0B;CAAE,IAAI;CAAiB,WAAW;CACnF,OAAO;CAEP,WAAW,EAAE,IAAI,QAAQ,OAAO,gBAAgB,UAAU;EAAE;EAAI;EAAQ;EAAO;EAAgB;CAAG;CAClG,OAAO,GAAG,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,OAAO,EAAE;AAAG,CAAC;;;;;;AAO1I,SAAgB,UAAU,OAAc,QAAqC;CAC5E,MAAM,KAAK,OAAO,WAAW,WAAW,SAAS,OAAO;CACxD,MAAM,QAAkB,CAAC;CACzB,KAAK,MAAM,UAAU,MAAM,MAAM,KAAK,QAAQ,GAAG,IAAI,OAAO,SAAS,OAAO,IAAI,QAAQ,CAAC,CAAE,OAAO,IAAI,MAAM,KAAK,MAAM;CACvH,OAAO,MAAM,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,EAAE;AACxC;;AAKA,IAAa,YAAY"}

package/dist/summons.d.ts

@@ -1,6 +1,8 @@
 import type { Entity, PlayerId } from './entity';
 import type { Vec2 } from './math';
 import type { World } from './world';
+import { summoned } from './summoned';
+export { summoned };
 /**
  * What is left of a unit that died, for a while (see `corpses`)
  *
@@ -9,9 +11,13 @@ import type { World } from './world';
 export interface Corpse {
     /** The id the unit had: the screen keeps its body lying for as long as the corpse is there */
     id: number;
+    /** The unit type the dead unit was */
     type: string;
+    /** The player who owned the dead unit */
     owner: PlayerId;
+    /** Where the corpse lies, east-west */
     x: number;
+    /** Where the corpse lies, north-south */
     z: number;
     /** When it is gone, in seconds of the game */
     until: number;
@@ -22,16 +28,6 @@ export interface Corpse {
  * @beta
  */
 export declare const corpses: import("./components").Component<Corpse[], Corpse[]>;
-/**
- * On a unit a spell brought: who brought it. Dispelling hurts what carries it
- *
- * @beta
- */
-export declare const summoned: import("./components").Component<{
-    by: number;
-}, {
-    by: number;
-}>;
 /**
  * On an illusion: whose copy it is, the part of its damage it deals, and how much more it takes. Told to its side
  * only: to everyone else it is the real one
@@ -48,11 +44,12 @@ export declare const illusion: import("./components").Component<{
     taken: number;
 }>;
 /**
- * Takes up to `most` corpses nearest a point, within `radius`, out of the world, and gives them
+ * Takes up to `most` corpses nearest a point, within `radius`, out of the world, and gives them; `which`, those of them
+ * it may take (the caster's allies', for a resurrection)
  *
  * @beta
  */
-export declare function takeCorpses(world: World, point: Vec2, radius: number, most: number): Corpse[];
+export declare function takeCorpses(world: World, point: Vec2, radius: number, most: number, which?: (corpse: Corpse) => boolean): Corpse[];
 /**
  * Whether killing an entity gains its killer nothing: an illusion
  *
@@ -60,4 +57,4 @@ export declare function takeCorpses(world: World, point: Vec2, radius: number, m
  */
 export declare const worthless: (entity: Entity) => boolean;
 /** The corpses where the player sees (`Snapshot.corpses`): none to a computer, and left out where there are none */
-export declare const corpsesPart: import("./replication").SnapshotPart<keyof import(".").Snapshot>;
+export declare const corpsesPart: import("./replication").SnapshotField<keyof import(".").Snapshot>;