@v12-engine/engine 0.1.1 → 0.4.0

package/dist/packs/heroes/loop.d.ts

@@ -0,0 +1,95 @@
+import type { Entity } from '#engine/entity';
+import { type Message } from '#engine/messages';
+import type { World } from '#engine/world';
+/**
+ * Who of the heroes did a hero harm or good a moment ago, by id, and when (the game's time): `hurt` by its enemies,
+ * `helped` by its allies (a heal, a shield, a buff). What its assists are found from (`heroAssists`). Saved with it
+ *
+ * @beta
+ */
+export interface AssistLog {
+    /** The enemy heroes that hurt it, by id, and the last time each did */
+    hurt: Record<string, number>;
+    /** The allied heroes that healed, shielded or buffed it, by id, and the last time each did */
+    helped: Record<string, number>;
+}
+/**
+ * What a hero's harm and help a moment ago was (`AssistLog`), on the hero, while assists count (`HeroSettings.assistTime`)
+ *
+ * @beta
+ */
+export declare const assistLog: import("#engine/components").Component<AssistLog, AssistLog>;
+/**
+ * A hero's kills, deaths and assists, and its kills since it last died (`streak`): its tally, sent to everyone who
+ * sees it, for a scoreboard
+ *
+ * @beta
+ */
+export interface HeroTally {
+    /** Heroes it killed */
+    kills: number;
+    /** Times it fell */
+    deaths: number;
+    /** Heroes' kills it assisted (`heroAssists`) */
+    assists: number;
+    /** Heroes it killed since it last died */
+    streak: number;
+    /** The game's time it may buy itself back again (`buyBack`): none until it has */
+    buybackAt?: number;
+}
+/**
+ * A hero's tally (`HeroTally`): kills, deaths, assists, its streak and when it may buy itself back
+ *
+ * @beta
+ */
+export declare const heroTally: import("#engine/components").Component<HeroTally, HeroTally>;
+/**
+ * The hero behind what did something: itself, or the hero whose summon it is (`summoned.by`). None for what no hero
+ * is behind (a tower, a creep)
+ *
+ * @beta
+ */
+export declare function heroBehind(world: World, entity: Entity | undefined): Entity | undefined;
+/**
+ * The heroes who assisted the kill of `victim` by `killer` as the engine counts them: the enemies of the victim that
+ * hurt it within the last `HeroSettings.assistTime` seconds, and the allies of the killer's hero that healed, shielded
+ * or buffed it within as long; neither the killer nor its hero, nor what is no hero (an illusion). By id, the same on
+ * every machine. What `HeroSettings.assists` is given to keep or change
+ *
+ * @beta
+ */
+export declare function foundAssists(world: World, victim: Entity, killer: Entity | undefined): Entity[];
+/**
+ * The heroes who assist the kill of `victim` by `killer`: those the engine found (`foundAssists`), as the game's rule
+ * keeps them (`HeroSettings.assists`). None for a victim that is no hero, nor in a game without the heroes pack
+ *
+ * @beta
+ */
+export declare function heroAssists(world: World, victim: Entity, killer: Entity | undefined): Entity[];
+/**
+ * A hero fell to `killer`, with these assisting: their records, the streaks (the killer's hero one more, the victim's
+ * ended, its killer paid the shutdown for it), and the assists' gold. The pack's `death` hook, after the experience
+ *
+ * @beta
+ */
+export declare function settleHeroKill(world: World, victim: Entity, killer: Entity | undefined, assists: readonly Entity[]): void;
+/**
+ * What a hero's harm and help is noted from, while assists count: a hero hurt by an enemy hero (or its summon), healed
+ * by an ally's, given a buff (a shield among them) by an ally's that is no harm
+ */
+export declare const assistListeners: import("#engine/events").ListenerDef[];
+/**
+ * Why a fallen hero cannot be bought back now, or undefined when it can: a living one, one being revived at an altar,
+ * one the game has no buyback for, one waiting out its last, one whose player is short of its price
+ *
+ * @beta
+ */
+export declare function buybackRefusal(world: World, hero: Entity): Message | undefined;
+/**
+ * Buys a fallen hero back (`HeroSettings.buybackCost`): its player pays, it is back at once at its side's home (where it
+ * fell when there is none), its wait to come back by itself over, and it may not again for `buybackCooldown`
+ * seconds. False, and the player told why, where it cannot (`buybackRefusal`)
+ *
+ * @beta
+ */
+export declare function buyBack(world: World, hero: Entity): boolean;

package/dist/packs/heroes/loop.js

@@ -0,0 +1,250 @@
+import { defineComponent } from "../../components.js";
+import { defineListener } from "../../events.js";
+import { bounty, buffApplied, damaged, healed } from "../../engineEvents.js";
+import { earn, shortOf, spend } from "../../player.js";
+import { engineMessage } from "../../messages.js";
+import { boughtBack, heroAssisted, heroShutdown, heroState, killStreak, respawning, reviveHero } from "../../hero.js";
+import { summoned } from "../../summoned.js";
+import { worthless } from "../../summons.js";
+import { homeOf } from "../../home.js";
+//#region src/packs/heroes/loop.ts
+/**
+* The hero loop of the heroes pack (items-and-spells plan, phase 4): assists, kill streaks and the shutdown that ends
+* one, and buyback. Who hurt a hero, or helped the hero that killed it (a heal, a shield, a buff), within the last
+* `HeroSettings.assistTime` seconds shares its kill's experience and is paid for it; a hero's kills in a row without
+* dying make its death worth more to whoever ends it; a fallen hero comes back at once, for gold that grows with its
+* level, then waits a while to do it again. Each a setting of the pack with the game's own rule in its place
+*/
+/**
+* What a hero's harm and help a moment ago was (`AssistLog`), on the hero, while assists count (`HeroSettings.assistTime`)
+*
+* @beta
+*/
+var assistLog = defineComponent({ id: "heroes.assists" });
+/**
+* A hero's tally (`HeroTally`): kills, deaths, assists, its streak and when it may buy itself back
+*
+* @beta
+*/
+var heroTally = defineComponent({
+	id: "heroes.tally",
+	replicate: "everyone",
+	same: (a, b) => a.kills === b.kills && a.deaths === b.deaths && a.assists === b.assists && a.streak === b.streak && a.buybackAt === b.buybackAt
+});
+/** The tally of a hero, made as it is first asked for */
+function tallyOf(hero) {
+	let record = hero.get(heroTally);
+	if (!record) hero.set(heroTally, record = {
+		kills: 0,
+		deaths: 0,
+		assists: 0,
+		streak: 0
+	});
+	return record;
+}
+/**
+* The hero behind what did something: itself, or the hero whose summon it is (`summoned.by`). None for what no hero
+* is behind (a tower, a creep)
+*
+* @beta
+*/
+function heroBehind(world, entity) {
+	if (!entity) return void 0;
+	if (entity.has(heroState)) return worthless(entity) ? void 0 : entity;
+	const master = world.get(entity.get(summoned)?.by);
+	return master?.has(heroState) && !worthless(master) ? master : void 0;
+}
+/** Writes down that `by` did `hero` harm or good now, and forgets what is past counting */
+function note(world, hero, kind, by) {
+	const window = world.settings.heroes.assistTime;
+	if (!(window > 0) || by === hero) return;
+	let log = hero.get(assistLog);
+	if (!log) hero.set(assistLog, log = {
+		hurt: {},
+		helped: {}
+	});
+	const list = log[kind];
+	for (const id in list) if (list[id] < world.time - window) delete list[id];
+	list[by.id] = world.time;
+}
+/**
+* The heroes who assisted the kill of `victim` by `killer` as the engine counts them: the enemies of the victim that
+* hurt it within the last `HeroSettings.assistTime` seconds, and the allies of the killer's hero that healed, shielded
+* or buffed it within as long; neither the killer nor its hero, nor what is no hero (an illusion). By id, the same on
+* every machine. What `HeroSettings.assists` is given to keep or change
+*
+* @beta
+*/
+function foundAssists(world, victim, killer) {
+	const window = world.settings.heroes.assistTime;
+	if (!(window > 0)) return [];
+	const since = world.time - window;
+	const killerHero = heroBehind(world, killer);
+	const ids = /* @__PURE__ */ new Set();
+	const hurt = victim.get(assistLog)?.hurt;
+	for (const id in hurt) if (hurt[id] >= since) ids.add(Number(id));
+	const helped = killerHero?.get(assistLog)?.helped;
+	for (const id in helped) if (helped[id] >= since) ids.add(Number(id));
+	const found = [];
+	for (const id of [...ids].sort((a, b) => a - b)) {
+		const hero = world.entities.get(id);
+		if (!hero || hero === killer || hero === killerHero || hero === victim || !hero.has(heroState) || worthless(hero)) continue;
+		if (!world.areEnemies(hero.owner, victim.owner)) continue;
+		found.push(hero);
+	}
+	return found;
+}
+/**
+* The heroes who assist the kill of `victim` by `killer`: those the engine found (`foundAssists`), as the game's rule
+* keeps them (`HeroSettings.assists`). None for a victim that is no hero, nor in a game without the heroes pack
+*
+* @beta
+*/
+function heroAssists(world, victim, killer) {
+	if (!victim.has(heroState) || worthless(victim) || !(world.settings.heroes.assistTime > 0)) return [];
+	return [...world.settings.heroes.assists(world, victim, killer, foundAssists(world, victim, killer))];
+}
+/** Pays a player gold for a kill, told as a bounty is (the score counts it as one) */
+function pay(world, player, victim, amount) {
+	const { currency } = world.registry;
+	const gold = Math.round(amount);
+	if (!currency || !(gold > 0)) return 0;
+	earn(world.player(player).resources, currency, gold);
+	world.events.emit(bounty, {
+		entity: victim,
+		player,
+		amount: gold
+	});
+	return gold;
+}
+/**
+* A hero fell to `killer`, with these assisting: their records, the streaks (the killer's hero one more, the victim's
+* ended, its killer paid the shutdown for it), and the assists' gold. The pack's `death` hook, after the experience
+*
+* @beta
+*/
+function settleHeroKill(world, victim, killer, assists) {
+	const settings = world.settings.heroes;
+	const own = tallyOf(victim);
+	const streak = own.streak;
+	own.deaths++;
+	own.streak = 0;
+	victim.remove(assistLog);
+	const enemy = killer && world.areEnemies(killer.owner, victim.owner) ? killer : void 0;
+	const killerHero = heroBehind(world, enemy);
+	if (killerHero) {
+		const record = tallyOf(killerHero);
+		record.kills++;
+		record.streak++;
+		world.events.emit(killStreak, {
+			hero: killerHero.id,
+			type: killerHero.def.id,
+			player: killerHero.owner,
+			streak: record.streak
+		});
+	}
+	const worth = streak > 0 ? settings.shutdownGold(world, victim, streak) : 0;
+	if (worth > 0) {
+		const gold = enemy ? pay(world, enemy.owner, victim, worth) : 0;
+		world.events.emit(heroShutdown, {
+			hero: victim.id,
+			streak,
+			...enemy && {
+				killer: enemy.id,
+				player: enemy.owner
+			},
+			gold
+		});
+	}
+	const each = assists.length ? settings.assistGold(world, victim, killer, assists) : 0;
+	for (const hero of assists) {
+		tallyOf(hero).assists++;
+		const gold = pay(world, hero.owner, victim, each);
+		world.events.emit(heroAssisted, {
+			hero: hero.id,
+			type: hero.def.id,
+			player: hero.owner,
+			victim: victim.id,
+			...killer && { killer: killer.id },
+			gold
+		});
+	}
+}
+/**
+* What a hero's harm and help is noted from, while assists count: a hero hurt by an enemy hero (or its summon), healed
+* by an ally's, given a buff (a shield among them) by an ally's that is no harm
+*/
+var assistListeners = [
+	defineListener({
+		id: "heroes.assists.hurt",
+		event: damaged,
+		run(world, { target, source, amount }) {
+			if (amount <= 0 || !target.has(heroState) || !source) return;
+			const by = heroBehind(world, source);
+			if (by && world.areEnemies(by.owner, target.owner)) note(world, target, "hurt", by);
+		}
+	}),
+	defineListener({
+		id: "heroes.assists.healed",
+		event: healed,
+		run(world, { target, source, amount }) {
+			if (amount <= 0 || !target.has(heroState) || !source) return;
+			const by = heroBehind(world, source);
+			if (by && world.areAllies(by.owner, target.owner)) note(world, target, "helped", by);
+		}
+	}),
+	defineListener({
+		id: "heroes.assists.buffed",
+		event: buffApplied,
+		run(world, { target, source, buff }) {
+			if (!target.has(heroState) || !source || world.registry.buff(buff).harmful) return;
+			const by = heroBehind(world, source);
+			if (by && world.areAllies(by.owner, target.owner)) note(world, target, "helped", by);
+		}
+	})
+];
+/**
+* Why a fallen hero cannot be bought back now, or undefined when it can: a living one, one being revived at an altar,
+* one the game has no buyback for, one waiting out its last, one whose player is short of its price
+*
+* @beta
+*/
+function buybackRefusal(world, hero) {
+	if (hero.alive || !hero.has(heroState) || hero.reviving) return engineMessage("cannotDoThat");
+	const cost = world.settings.heroes.buybackCost(world, hero);
+	if (!cost) return engineMessage("noBuyback");
+	const at = hero.get(heroTally)?.buybackAt;
+	if (at !== void 0 && at > world.time) return engineMessage("buybackNotReady", { seconds: Math.ceil(at - world.time) });
+	const short = shortOf(world.player(hero.owner).resources, cost);
+	if (short) return engineMessage("notEnough", { resource: short });
+}
+/**
+* Buys a fallen hero back (`HeroSettings.buybackCost`): its player pays, it is back at once at its side's home (where it
+* fell when there is none), its wait to come back by itself over, and it may not again for `buybackCooldown`
+* seconds. False, and the player told why, where it cannot (`buybackRefusal`)
+*
+* @beta
+*/
+function buyBack(world, hero) {
+	const refusal = buybackRefusal(world, hero);
+	if (refusal) {
+		world.message(hero.owner, refusal);
+		return false;
+	}
+	const cost = world.settings.heroes.buybackCost(world, hero);
+	spend(world, hero.owner, cost, "buyback", hero.def.id);
+	tallyOf(hero).buybackAt = world.time + world.settings.heroes.buybackCooldown;
+	hero.remove(respawning);
+	reviveHero(world, hero, homeOf(world, hero.owner, hero.pos) ?? hero.pos);
+	world.events.emit(boughtBack, {
+		hero: hero.id,
+		type: hero.def.id,
+		player: hero.owner,
+		cost
+	});
+	return true;
+}
+//#endregion
+export { assistListeners, assistLog, buyBack, buybackRefusal, foundAssists, heroAssists, heroBehind, heroTally, settleHeroKill };
+
+//# sourceMappingURL=loop.js.map

package/dist/packs/heroes/loop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loop.js","names":["bountyEvent"],"sources":["../../../src/packs/heroes/loop.ts"],"sourcesContent":["/**\n * The hero loop of the heroes pack (items-and-spells plan, phase 4): assists, kill streaks and the shutdown that ends\n * one, and buyback. Who hurt a hero, or helped the hero that killed it (a heal, a shield, a buff), within the last\n * `HeroSettings.assistTime` seconds shares its kill's experience and is paid for it; a hero's kills in a row without\n * dying make its death worth more to whoever ends it; a fallen hero comes back at once, for gold that grows with its\n * level, then waits a while to do it again. Each a setting of the pack with the game's own rule in its place\n */\nimport { bounty as bountyEvent, buffApplied, damaged, healed } from '#engine/engineEvents'\nimport { defineComponent } from '#engine/components'\nimport type { Entity, PlayerId } from '#engine/entity'\nimport { defineListener } from '#engine/events'\nimport { boughtBack, heroAssisted, heroShutdown, heroState, killStreak, respawning, reviveHero } from '#engine/hero'\nimport { homeOf } from '#engine/home'\nimport { engineMessage, type Message } from '#engine/messages'\nimport { earn, shortOf, spend } from '#engine/player'\nimport { summoned } from '#engine/summoned'\nimport { worthless } from '#engine/summons'\nimport type { World } from '#engine/world'\n\n/**\n * Who of the heroes did a hero harm or good a moment ago, by id, and when (the game's time): `hurt` by its enemies,\n * `helped` by its allies (a heal, a shield, a buff). What its assists are found from (`heroAssists`). Saved with it\n *\n * @beta\n */\nexport interface AssistLog {\n\t/** The enemy heroes that hurt it, by id, and the last time each did */\n\thurt: Record<string, number>\n\t/** The allied heroes that healed, shielded or buffed it, by id, and the last time each did */\n\thelped: Record<string, number>\n}\n\n/**\n * What a hero's harm and help a moment ago was (`AssistLog`), on the hero, while assists count (`HeroSettings.assistTime`)\n *\n * @beta\n */\nexport const assistLog = defineComponent<AssistLog>({ id: 'heroes.assists' })\n\n/**\n * A hero's kills, deaths and assists, and its kills since it last died (`streak`): its tally, sent to everyone who\n * sees it, for a scoreboard\n *\n * @beta\n */\nexport interface HeroTally {\n\t/** Heroes it killed */\n\tkills: number\n\t/** Times it fell */\n\tdeaths: number\n\t/** Heroes' kills it assisted (`heroAssists`) */\n\tassists: number\n\t/** Heroes it killed since it last died */\n\tstreak: number\n\t/** The game's time it may buy itself back again (`buyBack`): none until it has */\n\tbuybackAt?: number\n}\n\n/**\n * A hero's tally (`HeroTally`): kills, deaths, assists, its streak and when it may buy itself back\n *\n * @beta\n */\nexport const heroTally = defineComponent<HeroTally>({\n\tid: 'heroes.tally',\n\treplicate: 'everyone',\n\tsame: (a, b) => a.kills === b.kills && a.deaths === b.deaths && a.assists === b.assists && a.streak === b.streak && a.buybackAt === b.buybackAt\n})\n\n/** The tally of a hero, made as it is first asked for */\nfunction tallyOf(hero: Entity): HeroTally {\n\tlet record = hero.get(heroTally)\n\tif (!record) hero.set(heroTally, (record = { kills: 0, deaths: 0, assists: 0, streak: 0 }))\n\treturn record\n}\n\n/**\n * The hero behind what did something: itself, or the hero whose summon it is (`summoned.by`). None for what no hero\n * is behind (a tower, a creep)\n *\n * @beta\n */\nexport function heroBehind(world: World, entity: Entity | undefined): Entity | undefined {\n\tif (!entity) return undefined\n\tif (entity.has(heroState)) return worthless(entity) ? undefined : entity\n\tconst master = world.get(entity.get(summoned)?.by)\n\treturn master?.has(heroState) && !worthless(master) ? master : undefined\n}\n\n/** Writes down that `by` did `hero` harm or good now, and forgets what is past counting */\nfunction note(world: World, hero: Entity, kind: keyof AssistLog, by: Entity): void {\n\tconst window = world.settings.heroes.assistTime\n\tif (!(window > 0) || by === hero) return\n\tlet log = hero.get(assistLog)\n\tif (!log) hero.set(assistLog, (log = { hurt: {}, helped: {} }))\n\tconst list = log[kind]\n\tfor (const id in list) if (list[id] < world.time - window) delete list[id]\n\tlist[by.id] = world.time\n}\n\n/**\n * The heroes who assisted the kill of `victim` by `killer` as the engine counts them: the enemies of the victim that\n * hurt it within the last `HeroSettings.assistTime` seconds, and the allies of the killer's hero that healed, shielded\n * or buffed it within as long; neither the killer nor its hero, nor what is no hero (an illusion). By id, the same on\n * every machine. What `HeroSettings.assists` is given to keep or change\n *\n * @beta\n */\nexport function foundAssists(world: World, victim: Entity, killer: Entity | undefined): Entity[] {\n\tconst window = world.settings.heroes.assistTime\n\tif (!(window > 0)) return []\n\tconst since = world.time - window\n\tconst killerHero = heroBehind(world, killer)\n\tconst ids = new Set<number>()\n\tconst hurt = victim.get(assistLog)?.hurt\n\tfor (const id in hurt) if (hurt[id] >= since) ids.add(Number(id))\n\tconst helped = killerHero?.get(assistLog)?.helped\n\tfor (const id in helped) if (helped[id] >= since) ids.add(Number(id))\n\tconst found: Entity[] = []\n\tfor (const id of [...ids].sort((a, b) => a - b)) {\n\t\tconst hero = world.entities.get(id)\n\t\tif (!hero || hero === killer || hero === killerHero || hero === victim || !hero.has(heroState) || worthless(hero)) continue\n\t\tif (!world.areEnemies(hero.owner, victim.owner)) continue\n\t\tfound.push(hero)\n\t}\n\treturn found\n}\n\n/**\n * The heroes who assist the kill of `victim` by `killer`: those the engine found (`foundAssists`), as the game's rule\n * keeps them (`HeroSettings.assists`). None for a victim that is no hero, nor in a game without the heroes pack\n *\n * @beta\n */\nexport function heroAssists(world: World, victim: Entity, killer: Entity | undefined): Entity[] {\n\tif (!victim.has(heroState) || worthless(victim) || !(world.settings.heroes.assistTime > 0)) return []\n\treturn [...world.settings.heroes.assists(world, victim, killer, foundAssists(world, victim, killer))]\n}\n\n/** Pays a player gold for a kill, told as a bounty is (the score counts it as one) */\nfunction pay(world: World, player: PlayerId, victim: Entity, amount: number): number {\n\tconst { currency } = world.registry\n\tconst gold = Math.round(amount)\n\tif (!currency || !(gold > 0)) return 0\n\tearn(world.player(player).resources, currency, gold)\n\tworld.events.emit(bountyEvent, { entity: victim, player, amount: gold })\n\treturn gold\n}\n\n/**\n * A hero fell to `killer`, with these assisting: their records, the streaks (the killer's hero one more, the victim's\n * ended, its killer paid the shutdown for it), and the assists' gold. The pack's `death` hook, after the experience\n *\n * @beta\n */\nexport function settleHeroKill(world: World, victim: Entity, killer: Entity | undefined, assists: readonly Entity[]): void {\n\tconst settings = world.settings.heroes\n\tconst own = tallyOf(victim)\n\tconst streak = own.streak\n\town.deaths++\n\town.streak = 0\n\t// the victim's log is of this life\n\tvictim.remove(assistLog)\n\tconst enemy = killer && world.areEnemies(killer.owner, victim.owner) ? killer : undefined\n\tconst killerHero = heroBehind(world, enemy)\n\tif (killerHero) {\n\t\tconst record = tallyOf(killerHero)\n\t\trecord.kills++\n\t\trecord.streak++\n\t\tworld.events.emit(killStreak, { hero: killerHero.id, type: killerHero.def.id, player: killerHero.owner, streak: record.streak })\n\t}\n\t// what ending its streak is worth, to whoever ended it\n\tconst worth = streak > 0 ? settings.shutdownGold(world, victim, streak) : 0\n\tif (worth > 0) {\n\t\tconst gold = enemy ? pay(world, enemy.owner, victim, worth) : 0\n\t\tworld.events.emit(heroShutdown, { hero: victim.id, streak, ...(enemy && { killer: enemy.id, player: enemy.owner }), gold })\n\t}\n\tconst each = assists.length ? settings.assistGold(world, victim, killer, assists) : 0\n\tfor (const hero of assists) {\n\t\ttallyOf(hero).assists++\n\t\tconst gold = pay(world, hero.owner, victim, each)\n\t\tworld.events.emit(heroAssisted, {\n\t\t\thero: hero.id,\n\t\t\ttype: hero.def.id,\n\t\t\tplayer: hero.owner,\n\t\t\tvictim: victim.id,\n\t\t\t...(killer && { killer: killer.id }),\n\t\t\tgold\n\t\t})\n\t}\n}\n\n/**\n * What a hero's harm and help is noted from, while assists count: a hero hurt by an enemy hero (or its summon), healed\n * by an ally's, given a buff (a shield among them) by an ally's that is no harm\n */\nexport const assistListeners = [\n\tdefineListener({\n\t\tid: 'heroes.assists.hurt',\n\t\tevent: damaged,\n\t\trun(world, { target, source, amount }) {\n\t\t\tif (amount <= 0 || !target.has(heroState) || !source) return\n\t\t\tconst by = heroBehind(world, source)\n\t\t\tif (by && world.areEnemies(by.owner, target.owner)) note(world, target, 'hurt', by)\n\t\t}\n\t}),\n\tdefineListener({\n\t\tid: 'heroes.assists.healed',\n\t\tevent: healed,\n\t\trun(world, { target, source, amount }) {\n\t\t\tif (amount <= 0 || !target.has(heroState) || !source) return\n\t\t\tconst by = heroBehind(world, source)\n\t\t\tif (by && world.areAllies(by.owner, target.owner)) note(world, target, 'helped', by)\n\t\t}\n\t}),\n\tdefineListener({\n\t\tid: 'heroes.assists.buffed',\n\t\tevent: buffApplied,\n\t\trun(world, { target, source, buff }) {\n\t\t\tif (!target.has(heroState) || !source || world.registry.buff(buff).harmful) return\n\t\t\tconst by = heroBehind(world, source)\n\t\t\tif (by && world.areAllies(by.owner, target.owner)) note(world, target, 'helped', by)\n\t\t}\n\t})\n]\n\n/**\n * Why a fallen hero cannot be bought back now, or undefined when it can: a living one, one being revived at an altar,\n * one the game has no buyback for, one waiting out its last, one whose player is short of its price\n *\n * @beta\n */\nexport function buybackRefusal(world: World, hero: Entity): Message | undefined {\n\tif (hero.alive || !hero.has(heroState) || hero.reviving) return engineMessage('cannotDoThat')\n\tconst cost = world.settings.heroes.buybackCost(world, hero)\n\tif (!cost) return engineMessage('noBuyback')\n\tconst at = hero.get(heroTally)?.buybackAt\n\tif (at !== undefined && at > world.time) return engineMessage('buybackNotReady', { seconds: Math.ceil(at - world.time) })\n\tconst short = shortOf(world.player(hero.owner).resources, cost)\n\tif (short) return engineMessage('notEnough', { resource: short })\n\treturn undefined\n}\n\n/**\n * Buys a fallen hero back (`HeroSettings.buybackCost`): its player pays, it is back at once at its side's home (where it\n * fell when there is none), its wait to come back by itself over, and it may not again for `buybackCooldown`\n * seconds. False, and the player told why, where it cannot (`buybackRefusal`)\n *\n * @beta\n */\nexport function buyBack(world: World, hero: Entity): boolean {\n\tconst refusal = buybackRefusal(world, hero)\n\tif (refusal) {\n\t\tworld.message(hero.owner, refusal)\n\t\treturn false\n\t}\n\tconst cost = world.settings.heroes.buybackCost(world, hero)!\n\tspend(world, hero.owner, cost, 'buyback', hero.def.id)\n\ttallyOf(hero).buybackAt = world.time + world.settings.heroes.buybackCooldown\n\t// the timer of its coming back by itself comes to nothing (`respawnPack`)\n\thero.remove(respawning)\n\treviveHero(world, hero, homeOf(world, hero.owner, hero.pos) ?? hero.pos)\n\tworld.events.emit(boughtBack, { hero: hero.id, type: hero.def.id, player: hero.owner, cost })\n\treturn true\n}\n"],"mappings":"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"}

package/dist/packs/heroes/making.d.ts

@@ -6,11 +6,14 @@ import type { Entity } from '#engine/entity';
 import type { World } from '#engine/world';
 /**
  * Makes a unit just made a hero, as its type says (`UnitTypeDef.hero`): level 1, a point to spend, the abilities it can
- * learn (none learned) and the spells it starts with, those it has not got already. What `World.spawn` does for a
+ * learn (none learned), the spells it starts with and its innate (`HeroDef.innate`), those it has not got already. What `World.spawn` does for a
  * hero's type, and `morph` for what becomes one
  *
  * @beta
  */
 export declare function makeHero(world: World, entity: Entity): void;
-/** Shares the experience for a kill between the heroes of the killer's side that were around */
-export declare function awardKill(world: World, dead: Entity, killer: Entity | undefined): void;
+/**
+ * Shares the experience for a kill between the heroes of the killer's side that were around, and those that assisted it
+ * wherever they are (`heroAssists`), alive and short of their last level
+ */
+export declare function awardKill(world: World, dead: Entity, killer: Entity | undefined, assists?: readonly Entity[]): void;

package/dist/packs/heroes/making.js

@@ -0,0 +1,55 @@
+import { distSq } from "../../math.js";
+import { grantXp, heroOf, heroState, keepInnate, maxLevelOf, xpWorth } from "../../hero.js";
+//#region src/packs/heroes/making.ts
+/**
+* Makes a unit just made a hero, as its type says (`UnitTypeDef.hero`): level 1, a point to spend, the abilities it can
+* learn (none learned), the spells it starts with and its innate (`HeroDef.innate`), those it has not got already. What `World.spawn` does for a
+* hero's type, and `morph` for what becomes one
+*
+* @beta
+*/
+function makeHero(world, entity) {
+	const def = entity.def.hero;
+	if (!def) return;
+	entity.set(heroState, {
+		level: 1,
+		xp: 0,
+		points: 1
+	});
+	const add = (id, level) => {
+		if (!entity.abilities.some((state) => state.id === id)) entity.addAbility({
+			id: world.registry.ability(id).id,
+			level,
+			cooldown: 0,
+			autocast: false
+		});
+	};
+	for (const id of def.learns) add(id, 0);
+	for (const id of def.spells ?? []) add(id, 1);
+	keepInnate(world, entity);
+}
+/**
+* Shares the experience for a kill between the heroes of the killer's side that were around, and those that assisted it
+* wherever they are (`heroAssists`), alive and short of their last level
+*/
+function awardKill(world, dead, killer, assists = []) {
+	if (!killer || !world.areEnemies(killer.owner, dead.owner)) return;
+	const worth = xpWorth(world, dead);
+	if (worth <= 0) return;
+	const heroes = [];
+	const { xpRange } = world.settings.heroes;
+	const growing = (entity) => entity.alive && heroOf(entity).level < maxLevelOf(world, entity);
+	for (const player of world.players.values()) {
+		if (!world.areAllies(player.id, killer.owner)) continue;
+		for (const entity of world.index.with(heroState, player.id)) {
+			if (!growing(entity)) continue;
+			if (distSq(entity.pos, dead.pos) <= xpRange * xpRange) heroes.push(entity);
+		}
+	}
+	for (const hero of assists) if (growing(hero) && !heroes.includes(hero)) heroes.push(hero);
+	for (const hero of heroes) grantXp(world, hero, worth / heroes.length, dead);
+}
+//#endregion
+export { awardKill, makeHero };
+
+//# sourceMappingURL=making.js.map

package/dist/packs/heroes/making.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"making.js","names":[],"sources":["../../../src/packs/heroes/making.ts"],"sourcesContent":["/**\n * What the heroes pack does as heroes are made and as things die: a hero of a hero's type made one, and the\n * experience of a kill shared out (the pack's `made` and `death` handlers)\n */\nimport type { Entity } from '#engine/entity'\nimport { grantXp, heroOf, heroState, keepInnate, maxLevelOf, xpWorth } from '#engine/hero'\nimport { distSq } from '#engine/math'\nimport type { World } from '#engine/world'\n\n/**\n * Makes a unit just made a hero, as its type says (`UnitTypeDef.hero`): level 1, a point to spend, the abilities it can\n * learn (none learned), the spells it starts with and its innate (`HeroDef.innate`), those it has not got already. What `World.spawn` does for a\n * hero's type, and `morph` for what becomes one\n *\n * @beta\n */\nexport function makeHero(world: World, entity: Entity): void {\n\tconst def = entity.def.hero\n\tif (!def) return\n\tentity.set(heroState, { level: 1, xp: 0, points: 1 })\n\t// what it has already (a unit turned into a hero, `morph`) as it was\n\tconst add = (id: string, level: number) => {\n\t\tif (!entity.abilities.some((state) => state.id === id))\n\t\t\tentity.addAbility({ id: world.registry.ability(id).id, level, cooldown: 0, autocast: false })\n\t}\n\tfor (const id of def.learns) add(id, 0)\n\tfor (const id of def.spells ?? []) add(id, 1)\n\t// its innate, from level 1, for no point\n\tkeepInnate(world, entity)\n}\n\n/**\n * Shares the experience for a kill between the heroes of the killer's side that were around, and those that assisted it\n * wherever they are (`heroAssists`), alive and short of their last level\n */\nexport function awardKill(world: World, dead: Entity, killer: Entity | undefined, assists: readonly Entity[] = []): void {\n\tif (!killer || !world.areEnemies(killer.owner, dead.owner)) return\n\tconst worth = xpWorth(world, dead)\n\tif (worth <= 0) return\n\tconst heroes: Entity[] = []\n\tconst { xpRange } = world.settings.heroes\n\tconst growing = (entity: Entity) => entity.alive && heroOf(entity)!.level < maxLevelOf(world, entity)\n\tfor (const player of world.players.values()) {\n\t\tif (!world.areAllies(player.id, killer.owner)) continue\n\t\tfor (const entity of world.index.with(heroState, player.id)) {\n\t\t\tif (!growing(entity)) continue\n\t\t\tif (distSq(entity.pos, dead.pos) <= xpRange * xpRange) heroes.push(entity)\n\t\t}\n\t}\n\tfor (const hero of assists) if (growing(hero) && !heroes.includes(hero)) heroes.push(hero)\n\tfor (const hero of heroes) grantXp(world, hero, worth / heroes.length, dead)\n}\n"],"mappings":";;;;;;;;;;AAgBA,SAAgB,SAAS,OAAc,QAAsB;CAC5D,MAAM,MAAM,OAAO,IAAI;CACvB,IAAI,CAAC,KAAK;CACV,OAAO,IAAI,WAAW;EAAE,OAAO;EAAG,IAAI;EAAG,QAAQ;CAAE,CAAC;CAEpD,MAAM,OAAO,IAAY,UAAkB;EAC1C,IAAI,CAAC,OAAO,UAAU,MAAM,UAAU,MAAM,OAAO,EAAE,GACpD,OAAO,WAAW;GAAE,IAAI,MAAM,SAAS,QAAQ,EAAE,CAAC,CAAC;GAAI;GAAO,UAAU;GAAG,UAAU;EAAM,CAAC;CAC9F;CACA,KAAK,MAAM,MAAM,IAAI,QAAQ,IAAI,IAAI,CAAC;CACtC,KAAK,MAAM,MAAM,IAAI,UAAU,CAAC,GAAG,IAAI,IAAI,CAAC;CAE5C,WAAW,OAAO,MAAM;AACzB;;;;;AAMA,SAAgB,UAAU,OAAc,MAAc,QAA4B,UAA6B,CAAC,GAAS;CACxH,IAAI,CAAC,UAAU,CAAC,MAAM,WAAW,OAAO,OAAO,KAAK,KAAK,GAAG;CAC5D,MAAM,QAAQ,QAAQ,OAAO,IAAI;CACjC,IAAI,SAAS,GAAG;CAChB,MAAM,SAAmB,CAAC;CAC1B,MAAM,EAAE,YAAY,MAAM,SAAS;CACnC,MAAM,WAAW,WAAmB,OAAO,SAAS,OAAO,MAAM,CAAC,CAAE,QAAQ,WAAW,OAAO,MAAM;CACpG,KAAK,MAAM,UAAU,MAAM,QAAQ,OAAO,GAAG;EAC5C,IAAI,CAAC,MAAM,UAAU,OAAO,IAAI,OAAO,KAAK,GAAG;EAC/C,KAAK,MAAM,UAAU,MAAM,MAAM,KAAK,WAAW,OAAO,EAAE,GAAG;GAC5D,IAAI,CAAC,QAAQ,MAAM,GAAG;GACtB,IAAI,OAAO,OAAO,KAAK,KAAK,GAAG,KAAK,UAAU,SAAS,OAAO,KAAK,MAAM;EAC1E;CACD;CACA,KAAK,MAAM,QAAQ,SAAS,IAAI,QAAQ,IAAI,KAAK,CAAC,OAAO,SAAS,IAAI,GAAG,OAAO,KAAK,IAAI;CACzF,KAAK,MAAM,QAAQ,QAAQ,QAAQ,OAAO,MAAM,QAAQ,OAAO,QAAQ,IAAI;AAC5E"}

package/dist/packs/heroes/respawn.d.ts

@@ -4,7 +4,7 @@ import type { Entity } from '#engine/entity';
 import type { Vec2 } from '#engine/math';
 import type { World } from '#engine/world';
 /**
- * What a game's heroes do once fallen (`withRespawn`)
+ * What a game's heroes do once fallen (`respawnPack`)
  *
  * @beta
  */
@@ -20,11 +20,11 @@ export interface RespawnOptions {
  * A game whose heroes come back by themselves after a while, at their side's home (see `RespawnOptions`): a saved timer
  * each, shown on the HUD as a revive is, and waited for by the computer player in place of reviving at an altar.
  * Revived at an altar in the meantime, it is back then, and the timer comes to nothing. For a game with the heroes pack
- * on (`withHeroes()`): one without it is refused
+ * on (`heroesPack()`): one without it is refused
  *
  * @beta
  */
-export declare function withRespawn(options?: RespawnOptions): GamePack;
+export declare function respawnPack(options?: RespawnOptions): GamePack;
 /**
  * Recall (features-plan F2): a hero stands and channels for a few seconds, then is at its side's home (`homeOf`),
  * however far; hurt in the meantime, or told to do something else, and it stays where it is. An ability to give heroes

package/dist/packs/heroes/respawn.js

@@ -0,0 +1,87 @@
+import { defineListener } from "../../events.js";
+import { entityDied } from "../../engineEvents.js";
+import { HEROES, heroOf, heroState, respawning, reviveHero } from "../../hero.js";
+import { defineTimer } from "../../timers.js";
+import { homeOf } from "../../home.js";
+//#region src/packs/heroes/respawn.ts
+/**
+* A game whose heroes come back by themselves after a while, at their side's home (see `RespawnOptions`): a saved timer
+* each, shown on the HUD as a revive is, and waited for by the computer player in place of reviving at an altar.
+* Revived at an altar in the meantime, it is back then, and the timer comes to nothing. For a game with the heroes pack
+* on (`heroesPack()`): one without it is refused
+*
+* @beta
+*/
+function respawnPack(options = {}) {
+	const time = options.time ?? ((_world, hero) => 4 + 2 * (heroOf(hero)?.level ?? 1));
+	const comeBack = defineTimer({
+		id: "respawn",
+		run: (world, data) => {
+			const hero = world.get(data.hero) ?? [...world.index.with(heroState, data.player)].find((each) => each.id === data.hero);
+			const waiting = hero?.get(respawning);
+			if (!hero || !waiting || data.since !== void 0 && waiting.since !== data.since) return;
+			hero.remove(respawning);
+			if (hero.alive || !hero.has(heroState)) return;
+			const at = options.at?.(world, hero) ?? homeOf(world, hero.owner, hero.pos) ?? hero.pos;
+			reviveHero(world, hero, at);
+		}
+	});
+	const fell = defineListener({
+		id: "respawn.fell",
+		event: entityDied,
+		run(world, { entity }) {
+			if (!entity.has(heroState) || options.heroes && !options.heroes(world, entity)) return;
+			const wait = Math.max(0, time(world, entity));
+			entity.set(respawning, {
+				since: world.time,
+				wait
+			});
+			world.timers.after(wait, comeBack, {
+				hero: entity.id,
+				player: entity.owner,
+				since: world.time
+			});
+		}
+	});
+	return {
+		id: "respawn",
+		options,
+		requires: [HEROES],
+		components: [respawning],
+		timers: [comeBack],
+		listeners: [fell]
+	};
+}
+/**
+* Recall (features-plan F2): a hero stands and channels for a few seconds, then is at its side's home (`homeOf`),
+* however far; hurt in the meantime, or told to do something else, and it stays where it is. An ability to give heroes
+* (`UnitTypeDef.abilities`), made of the engine's parts: a channel (`AbilityDef.channel`) that `breaksOnDamage`, and the
+* `teleport` effect when it is `finished`. Its id, name, how long it takes, its cooldown and key are the game's to say
+*
+* @beta
+*/
+function recallAbility(options = {}) {
+	const duration = options.duration ?? 6;
+	return {
+		id: options.id ?? "recall",
+		name: options.name ?? "Recall",
+		description: `After ${duration} seconds standing still, unhurt, the hero is back home.`,
+		hotkey: options.hotkey ?? "B",
+		target: "none",
+		cooldown: options.cooldown ?? 20,
+		maxLevel: 1,
+		effects: [],
+		channel: {
+			duration,
+			breaksOnDamage: true,
+			finished: [{
+				type: "teleport",
+				to: "home"
+			}]
+		}
+	};
+}
+//#endregion
+export { recallAbility, respawnPack };
+
+//# sourceMappingURL=respawn.js.map

package/dist/packs/heroes/respawn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"respawn.js","names":[],"sources":["../../../src/packs/heroes/respawn.ts"],"sourcesContent":["import { entityDied } from '#engine/engineEvents'\nimport type { AbilityDef } from '#engine/defs'\nimport type { GamePack } from '#engine/packs/pack'\nimport type { Entity, PlayerId } from '#engine/entity'\nimport { HEROES, heroOf, heroState, respawning, reviveHero } from '#engine/hero'\nimport { defineListener } from '#engine/events'\nimport type { Vec2 } from '#engine/math'\nimport { homeOf } from '#engine/home'\nimport { defineTimer } from '#engine/timers'\nimport type { World } from '#engine/world'\n\n/*\n * Heroes that come back by themselves (features-plan F1), as in a MOBA, and the home they come back to and are\n * recalled to (F2)\n */\n\n/**\n * What a game's heroes do once fallen (`respawnPack`)\n *\n * @beta\n */\nexport interface RespawnOptions {\n\t/** Seconds a fallen hero waits to come back: 4 and 2 more a level when left out (6 at level 1, 24 at level 10) */\n\ttime?: (world: World, hero: Entity) => number\n\t/** Where it comes back: its side's home (`homeOf`) when left out, where it fell when there is none */\n\tat?: (world: World, hero: Entity) => Vec2 | undefined\n\t/** Which heroes come back by themselves: all of them when left out */\n\theroes?: (world: World, hero: Entity) => boolean\n}\n\n/**\n * A game whose heroes come back by themselves after a while, at their side's home (see `RespawnOptions`): a saved timer\n * each, shown on the HUD as a revive is, and waited for by the computer player in place of reviving at an altar.\n * Revived at an altar in the meantime, it is back then, and the timer comes to nothing. For a game with the heroes pack\n * on (`heroesPack()`): one without it is refused\n *\n * @beta\n */\nexport function respawnPack(options: RespawnOptions = {}): GamePack {\n\tconst time = options.time ?? ((_world: World, hero: Entity) => 4 + 2 * (heroOf(hero)?.level ?? 1))\n\tconst comeBack = defineTimer<{ hero: number; player: PlayerId; since?: number }>({ id: 'respawn', run: (world, data) => {\n\t\t// a fallen hero waits out of the world: among its player's heroes\n\t\tconst hero = world.get(data.hero) ?? [...world.index.with(heroState, data.player)].find((each) => each.id === data.hero)\n\t\t// the wait of this death, not of one before it the hero came back from at an altar\n\t\tconst waiting = hero?.get(respawning)\n\t\tif (!hero || !waiting || (data.since !== undefined && waiting.since !== data.since)) return\n\t\thero.remove(respawning)\n\t\t// revived at an altar in the meantime: back already\n\t\tif (hero.alive || !hero.has(heroState)) return\n\t\tconst at = options.at?.(world, hero) ?? homeOf(world, hero.owner, hero.pos) ?? hero.pos\n\t\treviveHero(world, hero, at)\n\t} })\n\tconst fell = defineListener({\n\t\tid: 'respawn.fell',\n\t\tevent: entityDied,\n\t\trun(world, { entity }) {\n\t\t\tif (!entity.has(heroState) || (options.heroes && !options.heroes(world, entity))) return\n\t\t\tconst wait = Math.max(0, time(world, entity))\n\t\t\tentity.set(respawning, { since: world.time, wait })\n\t\t\tworld.timers.after(wait, comeBack, { hero: entity.id, player: entity.owner, since: world.time })\n\t\t}\n\t})\n\treturn {\n\t\tid: 'respawn',\n\t\toptions,\n\t\t// heroes are the heroes pack's: a game with this has that on too, or is refused\n\t\trequires: [HEROES],\n\t\tcomponents: [respawning],\n\t\ttimers: [comeBack],\n\t\tlisteners: [fell]\n\t}\n}\n\n/**\n * Recall (features-plan F2): a hero stands and channels for a few seconds, then is at its side's home (`homeOf`),\n * however far; hurt in the meantime, or told to do something else, and it stays where it is. An ability to give heroes\n * (`UnitTypeDef.abilities`), made of the engine's parts: a channel (`AbilityDef.channel`) that `breaksOnDamage`, and the\n * `teleport` effect when it is `finished`. Its id, name, how long it takes, its cooldown and key are the game's to say\n *\n * @beta\n */\nexport function recallAbility(options: { id?: string; name?: string; duration?: number; cooldown?: number; hotkey?: string } = {}): AbilityDef {\n\tconst duration = options.duration ?? 6\n\treturn {\n\t\tid: options.id ?? 'recall',\n\t\tname: options.name ?? 'Recall',\n\t\tdescription: `After ${duration} seconds standing still, unhurt, the hero is back home.`,\n\t\thotkey: options.hotkey ?? 'B',\n\t\ttarget: 'none',\n\t\tcooldown: options.cooldown ?? 20,\n\t\tmaxLevel: 1,\n\t\teffects: [],\n\t\tchannel: { duration, breaksOnDamage: true, finished: [{ type: 'teleport', to: 'home' }] }\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;AAsCA,SAAgB,YAAY,UAA0B,CAAC,GAAa;CACnE,MAAM,OAAO,QAAQ,UAAU,QAAe,SAAiB,IAAI,KAAK,OAAO,IAAI,CAAC,EAAE,SAAS;CAC/F,MAAM,WAAW,YAAgE;EAAE,IAAI;EAAW,MAAM,OAAO,SAAS;GAEvH,MAAM,OAAO,MAAM,IAAI,KAAK,IAAI,KAAK,CAAC,GAAG,MAAM,MAAM,KAAK,WAAW,KAAK,MAAM,CAAC,CAAC,CAAC,MAAM,SAAS,KAAK,OAAO,KAAK,IAAI;GAEvH,MAAM,UAAU,MAAM,IAAI,UAAU;GACpC,IAAI,CAAC,QAAQ,CAAC,WAAY,KAAK,UAAU,KAAA,KAAa,QAAQ,UAAU,KAAK,OAAQ;GACrF,KAAK,OAAO,UAAU;GAEtB,IAAI,KAAK,SAAS,CAAC,KAAK,IAAI,SAAS,GAAG;GACxC,MAAM,KAAK,QAAQ,KAAK,OAAO,IAAI,KAAK,OAAO,OAAO,KAAK,OAAO,KAAK,GAAG,KAAK,KAAK;GACpF,WAAW,OAAO,MAAM,EAAE;EAC3B;CAAE,CAAC;CACH,MAAM,OAAO,eAAe;EAC3B,IAAI;EACJ,OAAO;EACP,IAAI,OAAO,EAAE,UAAU;GACtB,IAAI,CAAC,OAAO,IAAI,SAAS,KAAM,QAAQ,UAAU,CAAC,QAAQ,OAAO,OAAO,MAAM,GAAI;GAClF,MAAM,OAAO,KAAK,IAAI,GAAG,KAAK,OAAO,MAAM,CAAC;GAC5C,OAAO,IAAI,YAAY;IAAE,OAAO,MAAM;IAAM;GAAK,CAAC;GAClD,MAAM,OAAO,MAAM,MAAM,UAAU;IAAE,MAAM,OAAO;IAAI,QAAQ,OAAO;IAAO,OAAO,MAAM;GAAK,CAAC;EAChG;CACD,CAAC;CACD,OAAO;EACN,IAAI;EACJ;EAEA,UAAU,CAAC,MAAM;EACjB,YAAY,CAAC,UAAU;EACvB,QAAQ,CAAC,QAAQ;EACjB,WAAW,CAAC,IAAI;CACjB;AACD;;;;;;;;;AAUA,SAAgB,cAAc,UAAiG,CAAC,GAAe;CAC9I,MAAM,WAAW,QAAQ,YAAY;CACrC,OAAO;EACN,IAAI,QAAQ,MAAM;EAClB,MAAM,QAAQ,QAAQ;EACtB,aAAa,SAAS,SAAS;EAC/B,QAAQ,QAAQ,UAAU;EAC1B,QAAQ;EACR,UAAU,QAAQ,YAAY;EAC9B,UAAU;EACV,SAAS,CAAC;EACV,SAAS;GAAE;GAAU,gBAAgB;GAAM,UAAU,CAAC;IAAE,MAAM;IAAY,IAAI;GAAO,CAAC;EAAE;CACzF;AACD"}

package/dist/packs/heroes/sets.d.ts

@@ -0,0 +1,32 @@
+import type { CallingDef } from '#engine/callings';
+import type { AbilityDef, BuffDef } from '#engine/defs';
+import type { Rules } from '#engine/game';
+/**
+ * The hero spells as a set to choose from: the abilities (`defaultHeroSpells`), with the buffs they use beside them
+ * (`defaultHeroSpellBuffs`). A new one each time it is asked
+ *
+ * @beta
+ */
+export declare function defaultHeroSpellSet(): {
+    id: 'heroSpells';
+    name: string;
+    kind: 'abilities';
+    defs: AbilityDef[];
+    uses: {
+        buffs: BuffDef[];
+    };
+};
+/**
+ * The callings as a set to choose from (`defaultCallings`): what is chosen is laid on the rules as the heroes pack's
+ * (`heroesPack({ callings })`), in place of whatever was laid before; a heroes pack is put in where the game has none.
+ * A new one each time it is asked
+ *
+ * @beta
+ */
+export declare function defaultCallingSet(): {
+    id: 'callings';
+    name: string;
+    kind: 'callings';
+    defs: CallingDef[];
+    lay(rules: Rules, defs: readonly CallingDef[]): Rules;
+};