@v12-engine/engine 0.1.0 → 0.4.0

package/dist/unitResources.js

@@ -0,0 +1,266 @@
+import { hypot } from "./exactMath.js";
+import { at } from "./defs.js";
+import { defineComponent } from "./components.js";
+import { engineMessage } from "./messages.js";
+import { scaled } from "./abilities/scaled.js";
+import { applyBuff, hasBuff, removeBuff } from "./abilities/buffs.js";
+import { defineHook } from "./hooks.js";
+import { valueOf } from "./abilities/amounts.js";
+import { defineEffect, effectTargets } from "./abilities/effects.js";
+//#region src/unitResources.ts
+/**
+* The resources pack's id
+*
+* @beta
+*/
+var RESOURCES = "core.resources";
+/**
+* What a unit holds of its pools (`UnitPools`): on every unit whose type has `pools`, from the moment it is made. Its
+* players are told how much of each it holds (`values`, whole numbers), as they are of its mana
+*
+* @beta
+*/
+var pools = /* @__PURE__ */ defineComponent({
+	id: "core.pools",
+	index: true,
+	replicate: "everyone",
+	onSpawn: (entity) => {
+		const defs = entity.def.pools;
+		if (!defs) return;
+		const values = {};
+		for (const id in defs) values[id] = Math.min(Math.max(defs[id].start ?? defs[id].max, 0), defs[id].max);
+		entity.set(pools, { values });
+	},
+	snapshot: (value) => {
+		const sent = {};
+		for (const id in value.values) sent[id] = Math.floor(value.values[id]);
+		return sent;
+	},
+	same: (a, b) => {
+		for (const id in a) if (a[id] !== b[id]) return false;
+		for (const id in b) if (!(id in a)) return false;
+		return true;
+	}
+});
+/**
+* How much a unit holds of one of its pools (`UnitTypeDef.pools`): 0 where it has none
+*
+* @beta
+*/
+var poolOf = (entity, pool) => entity.get(pools)?.values[pool] ?? 0;
+/** The threshold of a pool whose buff holds it still while it lasts, where it is on now */
+function heldStill(entity, def) {
+	for (const threshold of def.thresholds ?? []) if (threshold.empties && !threshold.kept && hasBuff(entity, threshold.buff)) return true;
+	return false;
+}
+/** Sets a pool to a value, as its bounds and thresholds go */
+function setPool(world, entity, state, pool, def, value) {
+	const before = state.values[pool] ?? 0;
+	const after = Math.min(Math.max(value, 0), def.max);
+	state.values[pool] = after;
+	for (const threshold of def.thresholds ?? []) {
+		if (!world.registry.buffs.has(threshold.buff)) continue;
+		if (threshold.kept) {
+			const on = hasBuff(entity, threshold.buff);
+			if (after >= threshold.at && !on) applyBuff(world, entity, threshold.buff, void 0, entity);
+			else if (after < threshold.at && on) removeBuff(world, entity, threshold.buff, entity);
+		} else if (before < threshold.at && after >= threshold.at) applyBuff(world, entity, threshold.buff, void 0, entity);
+	}
+}
+/**
+* Fills a pool of a unit by `amount` (empties it, under 0), as far as its bounds go, its thresholds' buffs put on and
+* taken off, the time it decays after started over: what the `gain` effect does, and an ability's `cost` and `gain`.
+* Nothing while a threshold's buff that `empties` it holds it still. How much it changed
+*
+* @beta
+*/
+function changePool(world, entity, pool, amount) {
+	const state = entity.get(pools);
+	const def = entity.def.pools?.[pool];
+	if (!state || !def || !entity.alive || heldStill(entity, def)) return 0;
+	const before = state.values[pool] ?? 0;
+	setPool(world, entity, state, pool, def, before + amount);
+	if (state.quiet) delete state.quiet[pool];
+	return state.values[pool] - before;
+}
+/** The factor an ability's costs are grown by, by the stacks of its `costGrowth` buff on the caster */
+function growthOf(caster, ability) {
+	const growth = ability.costGrowth;
+	if (!growth) return 1;
+	const instance = caster.buffs.find((buff) => buff.id === growth.buff);
+	return instance ? 1 + growth.per * (instance.stacks ?? 1) : 1;
+}
+/**
+* What an ability costs a caster of its pools now (`AbilityDef.cost`, grown by `costGrowth`), by pool: none for an ability
+* that costs nothing of them
+*
+* @beta
+*/
+function poolCosts(caster, ability, level) {
+	if (!ability.cost) return void 0;
+	const grown = growthOf(caster, ability);
+	const costs = {};
+	for (const pool in ability.cost) costs[pool] = at(ability.cost[pool], level) * grown;
+	return costs;
+}
+/** The pool a caster has too little of for a cost, where there is one: its name */
+function shortOf(caster, costs) {
+	for (const pool in costs) if (costs[pool] > 0 && poolOf(caster, pool) < costs[pool]) return caster.def.pools?.[pool]?.name ?? pool;
+}
+/** Fills or empties a pool of what it reaches */
+var gainEffect = /* @__PURE__ */ defineEffect({
+	type: "gain",
+	run: (context, effect) => {
+		const { world, caster, level } = context;
+		for (const entity of effectTargets(context, effect, "allies")) {
+			const amount = scaled(world, caster, valueOf(context, effect.amount, entity), effect.scaling, level) * (context.share ?? 1);
+			changePool(world, entity, effect.pool, amount);
+		}
+	},
+	fields: [
+		{
+			path: "pool",
+			kind: "text",
+			hint: "Which of the pools of what it reaches it fills (energy, fury, heat…): it empties it with an amount under 0"
+		},
+		"amount",
+		"scaling"
+	]
+});
+/** Pools filling and emptying by themselves: back each second, decaying, filled by walking, reloaded */
+function tickPools(world, entity, state, dt) {
+	const defs = entity.def.pools;
+	const walked = state.at ? hypot(entity.pos.x - state.at.x, entity.pos.z - state.at.z) : 0;
+	state.at = {
+		x: entity.pos.x,
+		z: entity.pos.z
+	};
+	if (!entity.alive) return;
+	for (const pool in defs) {
+		const def = defs[pool];
+		const now = state.values[pool] ?? 0;
+		if (heldStill(entity, def)) continue;
+		if (def.thresholds?.find((threshold) => threshold.empties && !threshold.kept && now >= threshold.at && !hasBuff(entity, threshold.buff))) {
+			setPool(world, entity, state, pool, def, 0);
+			continue;
+		}
+		const quiet = state.quiet ??= {};
+		quiet[pool] = (quiet[pool] ?? 0) + dt;
+		let next = now + (def.regen ?? 0) * dt + (def.moving ?? 0) * walked;
+		if (def.decay && quiet[pool] >= (def.idle ?? 0)) next -= def.decay * dt;
+		if (def.reload !== void 0) {
+			const empty = state.empty ??= {};
+			if (now <= 0) {
+				empty[pool] = (empty[pool] ?? 0) + dt;
+				if (empty[pool] >= def.reload) {
+					next = def.max;
+					delete empty[pool];
+				}
+			} else delete empty[pool];
+		}
+		if (next !== now) setPool(world, entity, state, pool, def, next);
+	}
+}
+/** Whether a carrier has what a buff takes of it for a while (`BuffDef.drain`) */
+function canPay(entity, drain, seconds) {
+	for (const pool in drain) if ((pool === "mana" ? entity.mana : poolOf(entity, pool)) < drain[pool] * seconds) return false;
+	return true;
+}
+/** What buffs take of their carriers each second, the buff taken off where there is not enough for the next second */
+function drainBuffs(world, dt) {
+	for (const entity of world.units.values()) {
+		if (!entity.alive || !entity.buffs.length) continue;
+		for (const buff of [...entity.buffs]) {
+			const drain = world.registry.buffs.find(buff.id)?.drain;
+			if (!drain) continue;
+			if (!canPay(entity, drain, 1)) {
+				removeBuff(world, entity, buff.id);
+				continue;
+			}
+			for (const pool in drain) if (pool === "mana") entity.mana = Math.max(entity.mana - drain[pool] * dt, 0);
+			else changePool(world, entity, pool, -drain[pool] * dt);
+		}
+	}
+}
+/** Pools by themselves, and what buffs drain: after the abilities have gone off this tick */
+var poolsSystem = {
+	name: "pools",
+	phase: "decide",
+	after: ["abilities"],
+	update(world, dt) {
+		for (const entity of [...world.index.with(pools)]) {
+			const state = entity.get(pools);
+			if (state && entity.def.pools) tickPools(world, entity, state, dt);
+		}
+		drainBuffs(world, dt);
+	}
+};
+/**
+* Unit resources: what a game with it (`Rules.packs`) gets for pools beside mana. A unit type's `pools` (`PoolDef`: energy
+* back each second, fury that decays when unused, heat that overheats at a threshold, flow filled by walking, ammo that
+* reloads), an ability's `cost` of them (not ready with less, paid as it goes off) and `gain` (given as it goes off), costs
+* that grow by a buff's stacks (`costGrowth`, mana too), an attack's cost (`attackCost`: no attack with less), buffs
+* that drain a pool or mana each second while they last (`BuffDef.drain`), and the `gain` effect. `changePool`, `poolOf`
+* and `poolCosts` in code
+*
+* @beta
+*/
+function resourcesPack() {
+	const ready = defineHook({
+		hook: "canCast",
+		id: "resources",
+		run(world, event) {
+			const { caster, ability, level, item } = event;
+			if (event.cancelled || item || world.cheats.noManaCosts) return;
+			const short = shortOf(caster, poolCosts(caster, ability, level));
+			if (short !== void 0) return event.cancel(engineMessage("notEnough", { resource: short }));
+			if (ability.costGrowth && ability.manaCost !== void 0 && at(ability.manaCost, level) * growthOf(caster, ability) > caster.mana) event.cancel(engineMessage("notEnoughMana"));
+		}
+	});
+	const grown = defineHook({
+		hook: "beforeCast",
+		id: "resources",
+		run(_world, event) {
+			if (!event.item && event.ability.costGrowth) event.manaCost *= growthOf(event.caster, event.ability);
+		}
+	});
+	const paid = defineHook({
+		hook: "afterCast",
+		id: "resources",
+		run(world, event) {
+			const { caster, ability, level, item } = event;
+			if (item) return;
+			if (!world.cheats.noManaCosts) {
+				const costs = poolCosts(caster, ability, level);
+				for (const pool in costs) changePool(world, caster, pool, -costs[pool]);
+			}
+			for (const pool in ability.gain) changePool(world, caster, pool, at(ability.gain[pool], level));
+		}
+	});
+	const shot = defineHook({
+		hook: "beforeAttack",
+		id: "resources",
+		run(world, event) {
+			const cost = event.attacker.def.attackCost;
+			if (!cost || event.cancelled) return;
+			for (const pool in cost) if (poolOf(event.attacker, pool) < cost[pool]) return event.cancel();
+			for (const pool in cost) changePool(world, event.attacker, pool, -cost[pool]);
+		}
+	});
+	return {
+		id: RESOURCES,
+		components: [pools],
+		effects: [gainEffect],
+		systems: [poolsSystem],
+		hooks: [
+			ready,
+			grown,
+			paid,
+			shot
+		]
+	};
+}
+//#endregion
+export { RESOURCES, changePool, poolCosts, poolOf, pools, resourcesPack };
+
+//# sourceMappingURL=unitResources.js.map

package/dist/unitResources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unitResources.js","names":[],"sources":["../src/unitResources.ts"],"sourcesContent":["import { valueOf } from './abilities/amounts'\nimport { applyBuff, hasBuff, removeBuff } from './abilities/buffs'\nimport { defineEffect, effectTargets } from './abilities/effects'\nimport { scaled } from './abilities/scaled'\nimport { defineComponent } from './components'\nimport { type AbilityDef, at, type PoolDef } from './defs'\nimport type { Entity } from './entity'\nimport { hypot } from './exactMath'\nimport { defineHook } from './hooks'\nimport type { Vec2 } from './math'\nimport { engineMessage } from './messages'\nimport type { GamePack } from './packs/pack'\nimport type { System } from './registry'\nimport type { World } from './world'\n\n/*\n * Unit resources, an opt-in pack (E2E-PLAN AB14): pools a unit has beside mana (energy, fury, heat, flow, ammo), what\n * abilities and attacks cost of them and give, how they fill and empty by themselves, and buffs at thresholds. A game\n * without it pays nothing for these\n */\n\n/**\n * The resources pack's id\n *\n * @beta\n */\nexport const RESOURCES = 'core.resources'\n\n/**\n * What a unit holds of its pools (`UnitTypeDef.pools`): how much of each (`values`), the seconds since each was last\n * spent or given (`quiet`, for its `decay`), the seconds each has been empty (`empty`, for its `reload`) and where the\n * unit stood a tick ago (`at`, for what fills by walking)\n *\n * @beta\n */\nexport interface UnitPools {\n\t/** How much it holds of each, by pool */\n\tvalues: Record<string, number>\n\t/** Seconds since each was last spent or given, by pool */\n\tquiet?: Record<string, number>\n\t/** Seconds each has been empty, for one that reloads */\n\tempty?: Record<string, number>\n\t/** Where it stood a tick ago, for a pool that fills by walking */\n\tat?: Vec2\n}\n\n/**\n * What a unit holds of its pools (`UnitPools`): on every unit whose type has `pools`, from the moment it is made. Its\n * players are told how much of each it holds (`values`, whole numbers), as they are of its mana\n *\n * @beta\n */\nexport const pools = /* @__PURE__ */ defineComponent<UnitPools, Record<string, number>>({\n\tid: 'core.pools',\n\tindex: true,\n\treplicate: 'everyone',\n\tonSpawn: (entity) => {\n\t\tconst defs = entity.def.pools\n\t\tif (!defs) return\n\t\tconst values: Record<string, number> = {}\n\t\tfor (const id in defs) values[id] = Math.min(Math.max(defs[id].start ?? defs[id].max, 0), defs[id].max)\n\t\tentity.set(pools, { values })\n\t},\n\tsnapshot: (value) => {\n\t\tconst sent: Record<string, number> = {}\n\t\tfor (const id in value.values) sent[id] = Math.floor(value.values[id])\n\t\treturn sent\n\t},\n\tsame: (a, b) => {\n\t\tfor (const id in a) if (a[id] !== b[id]) return false\n\t\tfor (const id in b) if (!(id in a)) return false\n\t\treturn true\n\t}\n})\n\n/**\n * How much a unit holds of one of its pools (`UnitTypeDef.pools`): 0 where it has none\n *\n * @beta\n */\nexport const poolOf = (entity: Entity, pool: string): number => entity.get(pools)?.values[pool] ?? 0\n\n/** The threshold of a pool whose buff holds it still while it lasts, where it is on now */\nfunction heldStill(entity: Entity, def: PoolDef): boolean {\n\tfor (const threshold of def.thresholds ?? []) if (threshold.empties && !threshold.kept && hasBuff(entity, threshold.buff)) return true\n\treturn false\n}\n\n/** Sets a pool to a value, as its bounds and thresholds go */\nfunction setPool(world: World, entity: Entity, state: UnitPools, pool: string, def: PoolDef, value: number): void {\n\tconst before = state.values[pool] ?? 0\n\tconst after = Math.min(Math.max(value, 0), def.max)\n\tstate.values[pool] = after\n\tfor (const threshold of def.thresholds ?? []) {\n\t\tif (!world.registry.buffs.has(threshold.buff)) continue\n\t\tif (threshold.kept) {\n\t\t\tconst on = hasBuff(entity, threshold.buff)\n\t\t\tif (after >= threshold.at && !on) applyBuff(world, entity, threshold.buff, undefined, entity)\n\t\t\telse if (after < threshold.at && on) removeBuff(world, entity, threshold.buff, entity)\n\t\t} else if (before < threshold.at && after >= threshold.at) applyBuff(world, entity, threshold.buff, undefined, entity)\n\t}\n}\n\n/**\n * Fills a pool of a unit by `amount` (empties it, under 0), as far as its bounds go, its thresholds' buffs put on and\n * taken off, the time it decays after started over: what the `gain` effect does, and an ability's `cost` and `gain`.\n * Nothing while a threshold's buff that `empties` it holds it still. How much it changed\n *\n * @beta\n */\nexport function changePool(world: World, entity: Entity, pool: string, amount: number): number {\n\tconst state = entity.get(pools)\n\tconst def = entity.def.pools?.[pool]\n\tif (!state || !def || !entity.alive || heldStill(entity, def)) return 0\n\tconst before = state.values[pool] ?? 0\n\tsetPool(world, entity, state, pool, def, before + amount)\n\tif (state.quiet) delete state.quiet[pool]\n\treturn state.values[pool] - before\n}\n\n/** The factor an ability's costs are grown by, by the stacks of its `costGrowth` buff on the caster */\nfunction growthOf(caster: Entity, ability: AbilityDef): number {\n\tconst growth = ability.costGrowth\n\tif (!growth) return 1\n\tconst instance = caster.buffs.find((buff) => buff.id === growth.buff)\n\treturn instance ? 1 + growth.per * (instance.stacks ?? 1) : 1\n}\n\n/**\n * What an ability costs a caster of its pools now (`AbilityDef.cost`, grown by `costGrowth`), by pool: none for an ability\n * that costs nothing of them\n *\n * @beta\n */\nexport function poolCosts(caster: Entity, ability: AbilityDef, level: number): Record<string, number> | undefined {\n\tif (!ability.cost) return undefined\n\tconst grown = growthOf(caster, ability)\n\tconst costs: Record<string, number> = {}\n\tfor (const pool in ability.cost) costs[pool] = at(ability.cost[pool], level) * grown\n\treturn costs\n}\n\n/** The pool a caster has too little of for a cost, where there is one: its name */\nfunction shortOf(caster: Entity, costs: Record<string, number> | undefined): string | undefined {\n\tfor (const pool in costs) if (costs[pool] > 0 && poolOf(caster, pool) < costs[pool]) return caster.def.pools?.[pool]?.name ?? pool\n\treturn undefined\n}\n\n/** Fills or empties a pool of what it reaches */\nconst gainEffect = /* @__PURE__ */ defineEffect({\n\ttype: 'gain',\n\trun: (context, effect) => {\n\t\tconst { world, caster, level } = context\n\t\tfor (const entity of effectTargets(context, effect, 'allies')) {\n\t\t\tconst amount = scaled(world, caster, valueOf(context, effect.amount, entity), effect.scaling, level) * (context.share ?? 1)\n\t\t\tchangePool(world, entity, effect.pool, amount)\n\t\t}\n\t},\n\tfields: [{ path: 'pool', kind: 'text', hint: 'Which of the pools of what it reaches it fills (energy, fury, heat…): it empties it with an amount under 0' }, 'amount', 'scaling']\n})\n\n/** Pools filling and emptying by themselves: back each second, decaying, filled by walking, reloaded */\nfunction tickPools(world: World, entity: Entity, state: UnitPools, dt: number): void {\n\tconst defs = entity.def.pools!\n\tconst walked = state.at ? hypot(entity.pos.x - state.at.x, entity.pos.z - state.at.z) : 0\n\tstate.at = { x: entity.pos.x, z: entity.pos.z }\n\tif (!entity.alive) return\n\tfor (const pool in defs) {\n\t\tconst def = defs[pool]\n\t\tconst now = state.values[pool] ?? 0\n\t\tif (heldStill(entity, def)) continue\n\t\t// what held it still has ended: empty, as an overheat leaves it\n\t\tconst over = def.thresholds?.find((threshold) => threshold.empties && !threshold.kept && now >= threshold.at && !hasBuff(entity, threshold.buff))\n\t\tif (over) {\n\t\t\tsetPool(world, entity, state, pool, def, 0)\n\t\t\tcontinue\n\t\t}\n\t\tconst quiet = (state.quiet ??= {})\n\t\tquiet[pool] = (quiet[pool] ?? 0) + dt\n\t\tlet next = now + (def.regen ?? 0) * dt + (def.moving ?? 0) * walked\n\t\tif (def.decay && quiet[pool] >= (def.idle ?? 0)) next -= def.decay * dt\n\t\tif (def.reload !== undefined) {\n\t\t\tconst empty = (state.empty ??= {})\n\t\t\tif (now <= 0) {\n\t\t\t\tempty[pool] = (empty[pool] ?? 0) + dt\n\t\t\t\tif (empty[pool] >= def.reload) {\n\t\t\t\t\tnext = def.max\n\t\t\t\t\tdelete empty[pool]\n\t\t\t\t}\n\t\t\t} else delete empty[pool]\n\t\t}\n\t\tif (next !== now) setPool(world, entity, state, pool, def, next)\n\t}\n}\n\n/** Whether a carrier has what a buff takes of it for a while (`BuffDef.drain`) */\nfunction canPay(entity: Entity, drain: Record<string, number>, seconds: number): boolean {\n\tfor (const pool in drain) if ((pool === 'mana' ? entity.mana : poolOf(entity, pool)) < drain[pool] * seconds) return false\n\treturn true\n}\n\n/** What buffs take of their carriers each second, the buff taken off where there is not enough for the next second */\nfunction drainBuffs(world: World, dt: number): void {\n\tfor (const entity of world.units.values()) {\n\t\tif (!entity.alive || !entity.buffs.length) continue\n\t\tfor (const buff of [...entity.buffs]) {\n\t\t\tconst drain = world.registry.buffs.find(buff.id)?.drain\n\t\t\tif (!drain) continue\n\t\t\tif (!canPay(entity, drain, 1)) {\n\t\t\t\tremoveBuff(world, entity, buff.id)\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tfor (const pool in drain) {\n\t\t\t\tif (pool === 'mana') entity.mana = Math.max(entity.mana - drain[pool] * dt, 0)\n\t\t\t\telse changePool(world, entity, pool, -drain[pool] * dt)\n\t\t\t}\n\t\t}\n\t}\n}\n\n/** Pools by themselves, and what buffs drain: after the abilities have gone off this tick */\nconst poolsSystem: System = {\n\tname: 'pools',\n\tphase: 'decide',\n\tafter: ['abilities'],\n\tupdate(world, dt) {\n\t\tfor (const entity of [...world.index.with(pools)]) {\n\t\t\tconst state = entity.get(pools)\n\t\t\tif (state && entity.def.pools) tickPools(world, entity, state, dt)\n\t\t}\n\t\tdrainBuffs(world, dt)\n\t}\n}\n\n/**\n * Unit resources: what a game with it (`Rules.packs`) gets for pools beside mana. A unit type's `pools` (`PoolDef`: energy\n * back each second, fury that decays when unused, heat that overheats at a threshold, flow filled by walking, ammo that\n * reloads), an ability's `cost` of them (not ready with less, paid as it goes off) and `gain` (given as it goes off), costs\n * that grow by a buff's stacks (`costGrowth`, mana too), an attack's cost (`attackCost`: no attack with less), buffs\n * that drain a pool or mana each second while they last (`BuffDef.drain`), and the `gain` effect. `changePool`, `poolOf`\n * and `poolCosts` in code\n *\n * @beta\n */\nexport function resourcesPack(): GamePack {\n\tconst ready = defineHook({\n\t\thook: 'canCast',\n\t\tid: 'resources',\n\t\trun(world, event) {\n\t\t\tconst { caster, ability, level, item } = event\n\t\t\tif (event.cancelled || item || world.cheats.noManaCosts) return\n\t\t\tconst short = shortOf(caster, poolCosts(caster, ability, level))\n\t\t\tif (short !== undefined) return event.cancel(engineMessage('notEnough', { resource: short }))\n\t\t\t// mana grown by stacks: the screen's own check had the cost as it is declared\n\t\t\tif (ability.costGrowth && ability.manaCost !== undefined && at(ability.manaCost, level) * growthOf(caster, ability) > caster.mana)\n\t\t\t\tevent.cancel(engineMessage('notEnoughMana'))\n\t\t}\n\t})\n\tconst grown = defineHook({\n\t\thook: 'beforeCast',\n\t\tid: 'resources',\n\t\trun(_world, event) {\n\t\t\tif (!event.item && event.ability.costGrowth) event.manaCost *= growthOf(event.caster, event.ability)\n\t\t}\n\t})\n\tconst paid = defineHook({\n\t\thook: 'afterCast',\n\t\tid: 'resources',\n\t\trun(world, event) {\n\t\t\tconst { caster, ability, level, item } = event\n\t\t\tif (item) return\n\t\t\tif (!world.cheats.noManaCosts) {\n\t\t\t\tconst costs = poolCosts(caster, ability, level)\n\t\t\t\tfor (const pool in costs) changePool(world, caster, pool, -costs[pool])\n\t\t\t}\n\t\t\tfor (const pool in ability.gain) changePool(world, caster, pool, at(ability.gain[pool], level))\n\t\t}\n\t})\n\tconst shot = defineHook({\n\t\thook: 'beforeAttack',\n\t\tid: 'resources',\n\t\trun(world, event) {\n\t\t\tconst cost = event.attacker.def.attackCost\n\t\t\tif (!cost || event.cancelled) return\n\t\t\tfor (const pool in cost) if (poolOf(event.attacker, pool) < cost[pool]) return event.cancel()\n\t\t\tfor (const pool in cost) changePool(world, event.attacker, pool, -cost[pool])\n\t\t}\n\t})\n\treturn {\n\t\tid: RESOURCES,\n\t\tcomponents: [pools],\n\t\teffects: [gainEffect],\n\t\tsystems: [poolsSystem],\n\t\thooks: [ready, grown, paid, shot]\n\t}\n}\n"],"mappings":"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"}

package/dist/upkeep.d.ts

@@ -1,9 +1,14 @@
 import type { PlayerId } from './entity';
 import type { World } from './world';
-/** @beta */
+/**
+ * The upkeep a player is at: its tier, its name and the share of income that reaches them
+ *
+ * @beta
+ */
 export interface Upkeep {
     /** 0 without upkeep, then counting up with the tiers of the game */
     tier: number;
+    /** The name of the upkeep tier, shown to the player */
     name: string;
     /** Part of the gold a worker brings in that reaches the player */
     income: number;

package/dist/upkeep.js

@@ -0,0 +1,26 @@
+//#region src/upkeep.ts
+/**
+* What a player's army costs them, by how much supply they use
+*
+* @beta
+*/
+function upkeepOf(world, player) {
+	const { supplyUsed } = world.player(player);
+	let upkeep = {
+		tier: 0,
+		name: "No upkeep",
+		income: 1
+	};
+	world.registry.upkeep.forEach((tier, index) => {
+		if (supplyUsed > tier.above) upkeep = {
+			tier: index + 1,
+			name: tier.name,
+			income: tier.income
+		};
+	});
+	return upkeep;
+}
+//#endregion
+export { upkeepOf };
+
+//# sourceMappingURL=upkeep.js.map

package/dist/upkeep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upkeep.js","names":[],"sources":["../src/upkeep.ts"],"sourcesContent":["import type { PlayerId } from './entity'\nimport type { World } from './world'\n\n/**\n * The upkeep a player is at: its tier, its name and the share of income that reaches them\n *\n * @beta\n */\nexport interface Upkeep {\n\t/** 0 without upkeep, then counting up with the tiers of the game */\n\ttier: number\n\t/** The name of the upkeep tier, shown to the player */\n\tname: string\n\t/** Part of the gold a worker brings in that reaches the player */\n\tincome: number\n}\n\n/**\n * What a player's army costs them, by how much supply they use\n *\n * @beta\n */\nexport function upkeepOf(world: World, player: PlayerId): Upkeep {\n\tconst { supplyUsed } = world.player(player)\n\tlet upkeep: Upkeep = { tier: 0, name: 'No upkeep', income: 1 }\n\tworld.registry.upkeep.forEach((tier, index) => {\n\t\tif (supplyUsed > tier.above) upkeep = { tier: index + 1, name: tier.name, income: tier.income }\n\t})\n\treturn upkeep\n}\n"],"mappings":";;;;;;AAsBA,SAAgB,SAAS,OAAc,QAA0B;CAChE,MAAM,EAAE,eAAe,MAAM,OAAO,MAAM;CAC1C,IAAI,SAAiB;EAAE,MAAM;EAAG,MAAM;EAAa,QAAQ;CAAE;CAC7D,MAAM,SAAS,OAAO,SAAS,MAAM,UAAU;EAC9C,IAAI,aAAa,KAAK,OAAO,SAAS;GAAE,MAAM,QAAQ;GAAG,MAAM,KAAK;GAAM,QAAQ,KAAK;EAAO;CAC/F,CAAC;CACD,OAAO;AACR"}

package/dist/veterancy.d.ts

@@ -9,8 +9,11 @@ import type { World } from './world';
  * @beta
  */
 export interface VeterancyRank {
+    /** The rank's name */
     name: string;
+    /** The experience a unit starts the rank at */
     xp: number;
+    /** What the rank adds to the unit's stats, in place of the rank before's */
     stats?: StatChange;
 }
 /**
@@ -19,7 +22,9 @@ export interface VeterancyRank {
  * @beta
  */
 export interface VeterancyState {
+    /** Experience the unit has gained */
     xp: number;
+    /** Index of the rank reached, 0 for none yet */
     rank: number;
 }
 /**
@@ -29,7 +34,7 @@ export interface VeterancyState {
  */
 export declare const VETERANCY_RANKS: readonly VeterancyRank[];
 /**
- * What veterancy is made of (`withVeterancy`)
+ * What veterancy is made of (`veterancyPack`)
  *
  * @beta
  */
@@ -66,7 +71,7 @@ export declare function rankOf(entity: Entity, ranks?: readonly VeterancyRank[])
 /**
  * Gives a unit experience, as a kill does: its rank goes up where it reaches the next ones' thresholds, its stats
  * with it, and `rankedUp` is told for each. Gives back the rank it is at. For a game's own rules (a unit that trains
- * at a camp), and what `withVeterancy` does on a kill
+ * at a camp), and what `veterancyPack` does on a kill
  *
  * @beta
  */
@@ -77,4 +82,4 @@ export declare function grantVeterancy(world: World, entity: Entity, xp: number,
  *
  * @beta
  */
-export declare function withVeterancy(options?: VeterancyOptions): GamePack;
+export declare function veterancyPack(options?: VeterancyOptions): GamePack;

package/dist/veterancy.js

@@ -0,0 +1,131 @@
+import { defineComponent } from "./components.js";
+import { invalidateStats } from "./stats.js";
+import { defineEngineEvent } from "./events.js";
+import { heroState, xpWorth } from "./hero.js";
+import { defineHook } from "./hooks.js";
+//#region src/veterancy.ts
+/**
+* Ranks as many games have them: three, at 50, 150 and 300 experience, 10%, 20% and 30% more damage and health
+*
+* @beta
+*/
+var VETERANCY_RANKS = [
+	{
+		name: "Veteran",
+		xp: 50,
+		stats: { percent: {
+			attackDamage: .1,
+			health: .1
+		} }
+	},
+	{
+		name: "Elite",
+		xp: 150,
+		stats: { percent: {
+			attackDamage: .2,
+			health: .2
+		} }
+	},
+	{
+		name: "Heroic",
+		xp: 300,
+		stats: { percent: {
+			attackDamage: .3,
+			health: .3
+		} }
+	}
+];
+/**
+* What a unit has of veterancy, told to everyone (a rank shows on its plate): none for one that has earned nothing
+*
+* @beta
+*/
+var veterancy = defineComponent({
+	id: "core.veterancy",
+	replicate: "everyone"
+});
+/**
+* A unit reached a rank: told to everyone, for a sound or a word on the screen
+*
+* @beta
+*/
+var rankedUp = defineEngineEvent({
+	id: "core.rankedUp",
+	replicate: "everyone"
+});
+/**
+* The rank a unit has reached, as a definition, or none: of the game's ranks (`VeterancyOptions.ranks`)
+*
+* @beta
+*/
+function rankOf(entity, ranks = VETERANCY_RANKS) {
+	const rank = entity.get(veterancy)?.rank ?? 0;
+	return rank > 0 ? ranks[rank - 1] : void 0;
+}
+/**
+* Gives a unit experience, as a kill does: its rank goes up where it reaches the next ones' thresholds, its stats
+* with it, and `rankedUp` is told for each. Gives back the rank it is at. For a game's own rules (a unit that trains
+* at a camp), and what `veterancyPack` does on a kill
+*
+* @beta
+*/
+function grantVeterancy(world, entity, xp, ranks = VETERANCY_RANKS) {
+	const now = entity.get(veterancy) ?? {
+		xp: 0,
+		rank: 0
+	};
+	const next = {
+		xp: now.xp + Math.max(0, xp),
+		rank: now.rank
+	};
+	while (next.rank < ranks.length && next.xp >= ranks[next.rank].xp) {
+		next.rank++;
+		world.events.emit(rankedUp, {
+			entity: entity.id,
+			rank: next.rank,
+			name: ranks[next.rank - 1].name
+		});
+	}
+	entity.set(veterancy, next);
+	if (next.rank !== now.rank) invalidateStats(world, entity);
+	return next.rank;
+}
+/**
+* Veterancy for a game's units (`VeterancyOptions`): the killer of an enemy earns what it was worth, ranks come at
+* their thresholds, each rank's stats are added (the `stats` hook). The game is the same otherwise
+*
+* @beta
+*/
+function veterancyPack(options = {}) {
+	const ranks = options.ranks ?? VETERANCY_RANKS;
+	const earns = options.earns ?? ((_world, entity) => !entity.has(heroState) && !entity.isStructure && entity.alive);
+	const deathHook = defineHook({
+		hook: "death",
+		id: "core.veterancy.death",
+		run(world, event) {
+			const { entity: dead, killer } = event;
+			if (!killer || !world.areEnemies(killer.owner, dead.owner) || !earns(world, killer)) return;
+			const worth = options.worth ? options.worth(world, dead, killer) : xpWorth(world, dead);
+			if (worth > 0) grantVeterancy(world, killer, worth, ranks);
+		}
+	});
+	const statsHook = defineHook({
+		hook: "stats",
+		id: "core.veterancy.stats",
+		run(_world, event) {
+			const rank = rankOf(event.entity, ranks);
+			if (rank?.stats) event.add(rank.stats);
+		}
+	});
+	return {
+		id: "veterancy",
+		options,
+		components: [veterancy],
+		events: [rankedUp],
+		hooks: [deathHook, statsHook]
+	};
+}
+//#endregion
+export { VETERANCY_RANKS, grantVeterancy, rankOf, rankedUp, veterancy, veterancyPack };
+
+//# sourceMappingURL=veterancy.js.map

package/dist/veterancy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"veterancy.js","names":[],"sources":["../src/veterancy.ts"],"sourcesContent":["import { defineComponent } from './components'\nimport type { GamePack } from './packs/pack'\nimport type { StatChange } from './defs'\nimport type { Entity } from './entity'\nimport { defineEngineEvent } from './events'\nimport { heroState, xpWorth } from './hero'\nimport { defineHook } from './hooks'\nimport { invalidateStats } from './stats'\nimport type { World } from './world'\n\n/*\n * Veterancy, an opt-in pack (master plan OH1): units that are not heroes earn experience from what they kill, reach\n * ranks at thresholds, and each rank adds to their stats. A game turns it on with the pack `veterancyPack(options)` in its `packs`; what\n * a unit has is a component (`veterancy`), saved and told to everyone, and a rank reached is an event (`rankedUp`) for\n * the screen. What it looks like (a chevron on the plate) is the game's: the client reads the component\n */\n\n/**\n * A rank of veterancy: the experience it starts at, its name, and what it adds to a unit's stats (in place of the rank\n * before's: each says all a unit of that rank has)\n *\n * @beta\n */\nexport interface VeterancyRank {\n\t/** The rank's name */\n\tname: string\n\t/** The experience a unit starts the rank at */\n\txp: number\n\t/** What the rank adds to the unit's stats, in place of the rank before's */\n\tstats?: StatChange\n}\n\n/**\n * What a unit has of veterancy: its experience and the rank it reached (0 for none yet)\n *\n * @beta\n */\nexport interface VeterancyState {\n\t/** Experience the unit has gained */\n\txp: number\n\t/** Index of the rank reached, 0 for none yet */\n\trank: number\n}\n\n/**\n * Ranks as many games have them: three, at 50, 150 and 300 experience, 10%, 20% and 30% more damage and health\n *\n * @beta\n */\nexport const VETERANCY_RANKS: readonly VeterancyRank[] = [\n\t{ name: 'Veteran', xp: 50, stats: { percent: { attackDamage: 0.1, health: 0.1 } } },\n\t{ name: 'Elite', xp: 150, stats: { percent: { attackDamage: 0.2, health: 0.2 } } },\n\t{ name: 'Heroic', xp: 300, stats: { percent: { attackDamage: 0.3, health: 0.3 } } }\n]\n\n/**\n * What veterancy is made of (`veterancyPack`)\n *\n * @beta\n */\nexport interface VeterancyOptions {\n\t/** The ranks, from the lowest: `VETERANCY_RANKS` when left out */\n\tranks?: readonly VeterancyRank[]\n\t/** Who earns it: units of a player's that are not heroes and not structures, when left out */\n\tearns?: (world: World, entity: Entity) => boolean\n\t/** What a kill is worth to the killer: what it is worth to heroes (`xpWorth`), when left out. 0 for nothing */\n\tworth?: (world: World, dead: Entity, killer: Entity) => number\n}\n\n/**\n * What a unit has of veterancy, told to everyone (a rank shows on its plate): none for one that has earned nothing\n *\n * @beta\n */\nexport const veterancy = defineComponent<VeterancyState>({ id: 'core.veterancy', replicate: 'everyone' })\n\n/**\n * A unit reached a rank: told to everyone, for a sound or a word on the screen\n *\n * @beta\n */\nexport const rankedUp = defineEngineEvent<{ entity: number; rank: number; name: string }>({ id: 'core.rankedUp', replicate: 'everyone' })\n\n/**\n * The rank a unit has reached, as a definition, or none: of the game's ranks (`VeterancyOptions.ranks`)\n *\n * @beta\n */\nexport function rankOf(entity: Entity, ranks: readonly VeterancyRank[] = VETERANCY_RANKS): VeterancyRank | undefined {\n\tconst rank = entity.get(veterancy)?.rank ?? 0\n\treturn rank > 0 ? ranks[rank - 1] : undefined\n}\n\n/**\n * Gives a unit experience, as a kill does: its rank goes up where it reaches the next ones' thresholds, its stats\n * with it, and `rankedUp` is told for each. Gives back the rank it is at. For a game's own rules (a unit that trains\n * at a camp), and what `veterancyPack` does on a kill\n *\n * @beta\n */\nexport function grantVeterancy(world: World, entity: Entity, xp: number, ranks: readonly VeterancyRank[] = VETERANCY_RANKS): number {\n\tconst now = entity.get(veterancy) ?? { xp: 0, rank: 0 }\n\tconst next: VeterancyState = { xp: now.xp + Math.max(0, xp), rank: now.rank }\n\twhile (next.rank < ranks.length && next.xp >= ranks[next.rank].xp) {\n\t\tnext.rank++\n\t\tworld.events.emit(rankedUp, { entity: entity.id, rank: next.rank, name: ranks[next.rank - 1].name })\n\t}\n\tentity.set(veterancy, next)\n\tif (next.rank !== now.rank) invalidateStats(world, entity)\n\treturn next.rank\n}\n\n/**\n * Veterancy for a game's units (`VeterancyOptions`): the killer of an enemy earns what it was worth, ranks come at\n * their thresholds, each rank's stats are added (the `stats` hook). The game is the same otherwise\n *\n * @beta\n */\nexport function veterancyPack(options: VeterancyOptions = {}): GamePack {\n\tconst ranks = options.ranks ?? VETERANCY_RANKS\n\tconst earns = options.earns ?? ((_world: World, entity: Entity) => !entity.has(heroState) && !entity.isStructure && entity.alive)\n\tconst deathHook = defineHook({\n\t\thook: 'death',\n\t\tid: 'core.veterancy.death',\n\t\trun(world, event) {\n\t\t\tconst { entity: dead, killer } = event\n\t\t\tif (!killer || !world.areEnemies(killer.owner, dead.owner) || !earns(world, killer)) return\n\t\t\tconst worth = options.worth ? options.worth(world, dead, killer) : xpWorth(world, dead)\n\t\t\tif (worth > 0) grantVeterancy(world, killer, worth, ranks)\n\t\t}\n\t})\n\tconst statsHook = defineHook({\n\t\thook: 'stats',\n\t\tid: 'core.veterancy.stats',\n\t\trun(_world, event) {\n\t\t\tconst rank = rankOf(event.entity, ranks)\n\t\t\tif (rank?.stats) event.add(rank.stats)\n\t\t}\n\t})\n\treturn {\n\t\tid: 'veterancy',\n\t\toptions,\n\t\tcomponents: [veterancy],\n\t\tevents: [rankedUp],\n\t\thooks: [deathHook, statsHook]\n\t}\n}\n"],"mappings":";;;;;;;;;;;AAiDA,IAAa,kBAA4C;CACxD;EAAE,MAAM;EAAW,IAAI;EAAI,OAAO,EAAE,SAAS;GAAE,cAAc;GAAK,QAAQ;EAAI,EAAE;CAAE;CAClF;EAAE,MAAM;EAAS,IAAI;EAAK,OAAO,EAAE,SAAS;GAAE,cAAc;GAAK,QAAQ;EAAI,EAAE;CAAE;CACjF;EAAE,MAAM;EAAU,IAAI;EAAK,OAAO,EAAE,SAAS;GAAE,cAAc;GAAK,QAAQ;EAAI,EAAE;CAAE;AACnF;;;;;;AAqBA,IAAa,YAAY,gBAAgC;CAAE,IAAI;CAAkB,WAAW;AAAW,CAAC;;;;;;AAOxG,IAAa,WAAW,kBAAkE;CAAE,IAAI;CAAiB,WAAW;AAAW,CAAC;;;;;;AAOxI,SAAgB,OAAO,QAAgB,QAAkC,iBAA4C;CACpH,MAAM,OAAO,OAAO,IAAI,SAAS,CAAC,EAAE,QAAQ;CAC5C,OAAO,OAAO,IAAI,MAAM,OAAO,KAAK,KAAA;AACrC;;;;;;;;AASA,SAAgB,eAAe,OAAc,QAAgB,IAAY,QAAkC,iBAAyB;CACnI,MAAM,MAAM,OAAO,IAAI,SAAS,KAAK;EAAE,IAAI;EAAG,MAAM;CAAE;CACtD,MAAM,OAAuB;EAAE,IAAI,IAAI,KAAK,KAAK,IAAI,GAAG,EAAE;EAAG,MAAM,IAAI;CAAK;CAC5E,OAAO,KAAK,OAAO,MAAM,UAAU,KAAK,MAAM,MAAM,KAAK,KAAK,CAAC,IAAI;EAClE,KAAK;EACL,MAAM,OAAO,KAAK,UAAU;GAAE,QAAQ,OAAO;GAAI,MAAM,KAAK;GAAM,MAAM,MAAM,KAAK,OAAO,EAAE,CAAC;EAAK,CAAC;CACpG;CACA,OAAO,IAAI,WAAW,IAAI;CAC1B,IAAI,KAAK,SAAS,IAAI,MAAM,gBAAgB,OAAO,MAAM;CACzD,OAAO,KAAK;AACb;;;;;;;AAQA,SAAgB,cAAc,UAA4B,CAAC,GAAa;CACvE,MAAM,QAAQ,QAAQ,SAAS;CAC/B,MAAM,QAAQ,QAAQ,WAAW,QAAe,WAAmB,CAAC,OAAO,IAAI,SAAS,KAAK,CAAC,OAAO,eAAe,OAAO;CAC3H,MAAM,YAAY,WAAW;EAC5B,MAAM;EACN,IAAI;EACJ,IAAI,OAAO,OAAO;GACjB,MAAM,EAAE,QAAQ,MAAM,WAAW;GACjC,IAAI,CAAC,UAAU,CAAC,MAAM,WAAW,OAAO,OAAO,KAAK,KAAK,KAAK,CAAC,MAAM,OAAO,MAAM,GAAG;GACrF,MAAM,QAAQ,QAAQ,QAAQ,QAAQ,MAAM,OAAO,MAAM,MAAM,IAAI,QAAQ,OAAO,IAAI;GACtF,IAAI,QAAQ,GAAG,eAAe,OAAO,QAAQ,OAAO,KAAK;EAC1D;CACD,CAAC;CACD,MAAM,YAAY,WAAW;EAC5B,MAAM;EACN,IAAI;EACJ,IAAI,QAAQ,OAAO;GAClB,MAAM,OAAO,OAAO,MAAM,QAAQ,KAAK;GACvC,IAAI,MAAM,OAAO,MAAM,IAAI,KAAK,KAAK;EACtC;CACD,CAAC;CACD,OAAO;EACN,IAAI;EACJ;EACA,YAAY,CAAC,SAAS;EACtB,QAAQ,CAAC,QAAQ;EACjB,OAAO,CAAC,WAAW,SAAS;CAC7B;AACD"}

package/dist/vision.d.ts

@@ -0,0 +1,36 @@
+import { type Entity } from './entity';
+import type { GamePack } from './packs/pack';
+import type { World } from './world';
+/**
+ * The vision pack's id
+ *
+ * @beta
+ */
+export declare const VISION = "core.vision";
+/**
+ * Lets a team see a unit wherever it is for so many seconds (the longer of these and what it had): in the fog (lit where
+ * it stands), in a bush, invisible or camouflaged. What the `revealUnit` effect does, for a game's own code. Works in any
+ * game: the engine's fog and sight read it
+ *
+ * @beta
+ */
+export declare function revealUnit(world: World, entity: Entity, team: number, seconds: number): void;
+/**
+ * How near its enemies have to come to see a camouflaged unit (`BuffDef.camouflage`): the most of what its buffs say, or
+ * undefined where it is not camouflaged
+ *
+ * @beta
+ */
+export declare function camouflageOf(world: World, entity: Entity): number | undefined;
+/**
+ * Vision: what a game with it (`Rules.packs`) gets for what is seen. A buff that reveals its carrier to the team of
+ * whoever put it on (`BuffDef.revealed`), the `revealUnit` effect (the caster's team sees each it reaches for its
+ * `duration`; `revealUnit` in code), camouflage (`BuffDef.camouflage`: enemies see the carrier only from that near) and
+ * true sight (`UnitTypeDef.trueSight`, `BuffDef.trueSight`: the invisible and camouflaged enemies that near are found).
+ * Everything that asks what a team sees goes by it (`world.isVisibleTo`: what units pick, the commands a player may give,
+ * the computer players, each player's snapshot), and the fog is lit where a revealed or found unit stands, as for what a
+ * `detect` found. Nothing of its own is saved: what is revealed is the `detection` component
+ *
+ * @beta
+ */
+export declare function visionPack(): GamePack;