@v12-engine/engine 0.1.0 → 0.4.0

package/dist/hero.d.ts

@@ -1,24 +1,25 @@
+import { type CallingDef } from './callings';
 import type { Cost } from './defs';
-import { type Entity, type PlayerId } from './entity';
+import { type Entity, type EntityId, type PlayerId } from './entity';
 import type { Vec2 } from './math';
 import type { World } from './world';
 import type { EntityState, LearnableInfo, XpInfo } from './session/protocol';
 import type { GamePack } from './packs/pack';
 import type { HeroSummary } from './session/protocol';
 /**
- * The id of the heroes pack (`withHeroes`): `hasPack(game, HEROES)`
+ * The id of the heroes pack (`heroesPack`): `hasPack(game, HEROES)`
  *
  * @beta
  */
 export declare const HEROES = "core.heroes";
 /**
- * The numbers and formulas of heroes, the heroes pack's (`withHeroes(rules)`): how many heroes a player may
+ * The numbers and formulas of heroes, the heroes pack's (`heroesPack(rules)`): how many heroes a player may
  * have, how much experience a level takes, what bringing one back costs. The classic RTS numbers for
  * those left out
  *
  * @beta
  */
-export interface HeroRules {
+export interface HeroSettings {
     /** Heroes a player can have at once, fallen ones and ones being trained included */
     maxHeroes: number;
     /** The level heroes stop at, unless their type says otherwise (`HeroDef.maxLevel`) */
@@ -36,15 +37,62 @@ export interface HeroRules {
     };
     /** Ability points a hero gets for reaching a level. One, when left out */
     pointsForLevel(level: number): number;
+    /** Seconds a fallen hero is remembered as it fell (`fallenHeroes`): 8 when left out */
+    fallenFor: number;
+    /**
+     * Seconds within which a hero that hurt a hero, or healed, shielded or buffed the hero that killed it, assists the
+     * kill (`heroAssists`): it shares the kill's experience wherever it is, and is paid `assistGold`. 10 when left out;
+     * 0 for no assists
+     */
+    assistTime: number;
+    /**
+     * Which heroes assist a hero's kill, of those the engine found (`foundAssists`: who hurt it and who helped its
+     * killer within `assistTime`): all of them when left out. A game's own rule (only those near, only damage)
+     */
+    assists(world: World, victim: Entity, killer: Entity | undefined, found: readonly Entity[]): readonly Entity[];
+    /**
+     * Gold the player of each hero that assists a hero's kill is paid. Half of what the kill is worth (its bounty's
+     * middle, or 100 and 25 a level of the victim's: `heroKillWorth`), shared out among them, when left out
+     */
+    assistGold(world: World, victim: Entity, killer: Entity | undefined, assists: readonly Entity[]): number;
+    /**
+     * Gold a hero's death pays its killer's player on top of the kill, for the kills it made in a row without dying
+     * (`streak`): the shutdown that ends a streak. None under 3, then 100, and 50 more for each kill past it, 500 at
+     * most, when left out
+     */
+    shutdownGold(world: World, victim: Entity, streak: number): number;
+    /**
+     * What buying a fallen hero back costs its player (`buyBack`): 100 and 40 a level of its, in the game's money, when
+     * left out. Nothing for a hero that cannot be bought back: a game without buyback says `() => undefined`
+     */
+    buybackCost(world: World, hero: Entity): Cost | undefined;
+    /** Seconds a hero bought back waits before it may be again: 120 when left out */
+    buybackCooldown: number;
+    /**
+     * The callings a hero may have (`HeroDef.callings`): the engine's when left out (`defaultCallings`), or a game's
+     * own, some of them, renamed or added to: `heroesPack({ callings: [...] })`
+     *
+     * @beta
+     */
+    callings: readonly CallingDef[];
 }
 /**
- * The heroes pack, as `withHeroes` makes it: its rules beside its parts
+ * What the kill of a hero is worth in the game's money, as the engine's rules have it (what assists share,
+ * `HeroSettings.assistGold`): the middle of its bounty (`UnitTypeDef.bounty`), or 100 and 25 a level
+ *
+ * @beta
+ */
+export declare function heroKillWorth(victim: Entity): number;
+/**
+ * The heroes pack, as `heroesPack` makes it: its rules beside its parts
  *
  * @beta
  */
 export interface HeroesPack extends GamePack {
-    /** What the game says of heroes, over the engine's (`defaultHeroRules`): what the pack was made with (`GameRules.heroes`) */
-    options: Partial<HeroRules>;
+    /** What the game says of heroes, over the engine's (`defaultHeroSettings`): what the pack was made with (`RuleSettings.heroes`) */
+    options: Partial<HeroSettings>;
+    /** The callings its heroes may have: the game's (`heroesPack({ callings })`) or the engine's (`defaultCallings`) @beta */
+    callings: readonly CallingDef[];
 }
 /**
  * What a hero has earned: its level, its experience, the points it has to put into abilities (`heroState`)
@@ -52,6 +100,7 @@ export interface HeroesPack extends GamePack {
  * @beta
  */
 export interface HeroState {
+    /** The hero's level */
     level: number;
     /** Experience in total */
     xp: number;
@@ -60,12 +109,13 @@ export interface HeroState {
 }
 /**
  * What a player is told of a hero (`heroState`): its level, to everyone who sees it; its experience to its side, and to
- * everyone where the rules share it (`GameRules.hud.shareXp`); the points it has to spend and what it can learn, to its
+ * everyone where the rules share it (`RuleSettings.hud.shareXp`); the points it has to spend and what it can learn, to its
  * side
  *
  * @beta
  */
 export interface HeroSent {
+    /** The hero's level, which everyone who sees the hero is told */
     level: number;
     /** Its experience: its side's, and everyone's where the rules share it */
     xp?: XpInfo;
@@ -85,7 +135,7 @@ export declare const heroState: import("./components").Component<HeroState, Hero
 /**
  * What a hero has earned: none for what is no hero (`heroState`)
  *
- * @beta
+ * @public
  */
 export declare const heroOf: (entity: Entity) => HeroState | undefined;
 /**
@@ -107,6 +157,20 @@ export declare const maxLevelOf: (world: World, entity: Entity) => number;
  * @beta
  */
 export declare function grantXp(world: World, entity: Entity, amount: number, from?: Entity): void;
+/**
+ * The level of a hero's innate (`HeroDef.innate`) at a level of the hero: one for each of `innateLevels` it reached,
+ * or the hero's own level where it says none; never past the ability's `maxLevel` where it says one. 0 before the first
+ *
+ * @beta
+ */
+export declare function innateLevel(world: World, entity: Entity, heroLevel?: number): number;
+/**
+ * Gives a hero its innate (`HeroDef.innate`) where it has it not, at the level its own level says (`innateLevel`): as it
+ * is made, as it gains a level, as it takes another form. It costs no point, and is none of those it learns
+ *
+ * @beta
+ */
+export declare function keepInnate(world: World, entity: Entity): void;
 /**
  * Puts a hero at a level as if it had got there: the points to spend, the stats that grew, the experience of that
  * level. No message, no event and no `beforeXp`: for a hero that starts a map at that level, not one that earns it.
@@ -133,7 +197,11 @@ export declare function levelNeeded(world: World, hero: Entity, ability: string)
  * @beta
  */
 export declare function canLearn(world: World, hero: Entity, ability: string): boolean;
-/** @beta */
+/**
+ * Teaches the hero one level of an ability and spends a point on it; returns false when `canLearn` says it cannot
+ *
+ * @public
+ */
 export declare function learn(world: World, hero: Entity, ability: string): boolean;
 /**
  * Heroes a player has, fallen ones included
@@ -175,3 +243,51 @@ export declare const toldXp: import("./replication").ReplicatedEvent;
  * @beta
  */
 export declare function heroSummaries(world: World, player: PlayerId): HeroSummary[];
+/**
+ * A hero shared a kill as an assist (`heroAssists`): who, of whom, who killed it, and the gold its player was paid for it
+ *
+ * @beta
+ */
+export declare const heroAssisted: import("./events").EventKey<{
+    hero: EntityId;
+    type: string;
+    player: PlayerId;
+    victim: EntityId;
+    killer?: EntityId;
+    gold: number;
+}>;
+/**
+ * A hero killed another and is on a streak of this many since it last died
+ *
+ * @beta
+ */
+export declare const killStreak: import("./events").EventKey<{
+    hero: EntityId;
+    type: string;
+    player: PlayerId;
+    streak: number;
+}>;
+/**
+ * A hero on a streak fell (`HeroSettings.shutdownGold`): whose streak of how many, and the gold its killer's player was
+ * paid on top of the kill for ending it
+ *
+ * @beta
+ */
+export declare const heroShutdown: import("./events").EventKey<{
+    hero: EntityId;
+    streak: number;
+    killer?: EntityId;
+    player?: PlayerId;
+    gold: number;
+}>;
+/**
+ * A fallen hero was bought back (`buyBack`): who, for whom, at what cost
+ *
+ * @beta
+ */
+export declare const boughtBack: import("./events").EventKey<{
+    hero: EntityId;
+    type: string;
+    player: PlayerId;
+    cost: Cost;
+}>;

package/dist/hero.js

@@ -0,0 +1,432 @@
+import { defineComponent, snapshotOf } from "./components.js";
+import { refreshVitals, statsOf } from "./stats.js";
+import { defineEngineEvent } from "./events.js";
+import { heroLevelUp, heroRevived, xpGained } from "./engineEvents.js";
+import { replicateEvent } from "./replication.js";
+import { defaultCallings } from "./callings.js";
+import { fighting, moving } from "./entity.js";
+import { currencyOf } from "./player.js";
+import { engineMessage } from "./messages.js";
+import { readyAgain } from "./abilities/charges.js";
+import { agentParamsOf } from "./navigation/agentParams.js";
+import { productionOf } from "./systems/productionQueue.js";
+import { learnedInForm, learnsOf } from "./formState.js";
+//#region src/hero.ts
+/**
+* The id of the heroes pack (`heroesPack`): `hasPack(game, HEROES)`
+*
+* @beta
+*/
+var HEROES = "core.heroes";
+/**
+* What the kill of a hero is worth in the game's money, as the engine's rules have it (what assists share,
+* `HeroSettings.assistGold`): the middle of its bounty (`UnitTypeDef.bounty`), or 100 and 25 a level
+*
+* @beta
+*/
+function heroKillWorth(victim) {
+	const bounty = victim.def.bounty;
+	if (bounty) return (bounty[0] + bounty[1]) / 2;
+	return 100 + 25 * (heroOf(victim)?.level ?? 1);
+}
+/**
+* The heroes pack's rules where a game says nothing: the classic RTS numbers
+*
+* @internal
+*/
+var defaultHeroSettings = Object.freeze({
+	maxHeroes: 3,
+	maxHeroLevel: 10,
+	xpRange: 20,
+	xpForLevel: (level) => 50 * (level - 1) * (level + 2),
+	killXp(world, dead) {
+		const hero = heroOf(dead);
+		if (hero) return 100 * hero.level;
+		if (!dead.isUnit) return 0;
+		return Math.max(Math.round(currencyOf(world.registry, dead.def.cost) / 4), 10);
+	},
+	revive(world, hero) {
+		const level = heroOf(hero)?.level ?? 1;
+		const { currency } = world.registry;
+		const paid = currencyOf(world.registry, hero.def.cost);
+		return {
+			cost: currency ? { [currency]: Math.min(Math.round(paid * (.4 + .1 * level)), 700) } : {},
+			time: Math.min((hero.def.buildTime ?? 30) * .5 + 4 * level, 110)
+		};
+	},
+	pointsForLevel: () => 1,
+	fallenFor: 8,
+	assistTime: 10,
+	assists: (_world, _victim, _killer, found) => found,
+	assistGold: (_world, victim, _killer, assists) => assists.length ? Math.round(heroKillWorth(victim) / 2 / assists.length) : 0,
+	shutdownGold: (_world, _victim, streak) => streak < 3 ? 0 : Math.min(100 + 50 * (streak - 3), 500),
+	buybackCost(world, hero) {
+		const { currency } = world.registry;
+		return currency ? { [currency]: 100 + 40 * (heroOf(hero)?.level ?? 1) } : void 0;
+	},
+	buybackCooldown: 120,
+	callings: Object.freeze(defaultCallings())
+});
+/** A hero's experience: what it has, what its level took and what the next takes */
+function xpOf(world, entity, hero) {
+	return {
+		xp: Math.floor(hero.xp),
+		levelXp: world.settings.heroes.xpForLevel(hero.level),
+		nextXp: world.settings.heroes.xpForLevel(Math.min(hero.level + 1, maxLevelOf(world, entity)))
+	};
+}
+var sameXp = (a, b) => a === b || !!a && !!b && a.xp === b.xp && a.levelXp === b.levelXp && a.nextXp === b.nextXp;
+/**
+* A hero: what it has earned (`HeroState`). Set as a unit of a type that says it is one (`UnitTypeDef.hero`) is made,
+* filed by owner (`world.index.with(heroState, player)`, `heroesOf`). What is a hero is what has it: a fallen hero stays
+* in the world's entities, out of the world, to be brought back
+*
+* @beta
+*/
+var heroState = defineComponent({
+	id: "core.hero",
+	replicate: "everyone",
+	index: "owner",
+	snapshot(hero, entity, { world, ally }) {
+		const sent = { level: hero.level };
+		if (!entity.def.hero) return sent;
+		const shareXp = world.settings.hud.shareXp;
+		const shared = shareXp !== void 0 && (typeof shareXp === "function" ? shareXp(world, entity) : shareXp);
+		if (ally || shared) sent.xp = xpOf(world, entity, hero);
+		if (!ally) return sent;
+		sent.points = hero.points;
+		sent.learnable = learnsOf(entity).map((id) => ({
+			id,
+			level: entity.abilities.find((ability) => ability.id === id)?.level ?? 0,
+			maxLevel: world.registry.ability(id).maxLevel ?? 3,
+			needs: levelNeeded(world, entity, id),
+			available: canLearn(world, entity, id)
+		}));
+		return sent;
+	},
+	same: (a, b) => a.level === b.level && sameXp(a.xp, b.xp) && a.points === b.points && (a.learnable === b.learnable || !!a.learnable && !!b.learnable && a.learnable.length === b.learnable.length && a.learnable.every((info, i) => {
+		const other = b.learnable[i];
+		return info.id === other.id && info.level === other.level && info.maxLevel === other.maxLevel && info.needs === other.needs && info.available === other.available;
+	}))
+});
+/**
+* What a hero has earned: none for what is no hero (`heroState`)
+*
+* @public
+*/
+var heroOf = (entity) => entity.get(heroState);
+/**
+* What a player was told of a hero in their snapshot (`heroState`): its level to everyone, its experience, points and
+* what it can learn to its side. None for what is no hero
+*
+* @beta
+*/
+var heroOfState = (state) => snapshotOf(state, heroState);
+/**
+* The level a hero stops at
+*
+* @beta
+*/
+var maxLevelOf = (world, entity) => entity.def.hero?.maxLevel ?? world.settings.heroes.maxHeroLevel;
+/**
+* Gives a hero experience: `from` what was killed, when that is where it comes from. The `beforeXp` hook has its say
+*
+* @beta
+*/
+function grantXp(world, entity, amount, from) {
+	const hero = heroOf(entity);
+	const max = maxLevelOf(world, entity);
+	const { xpForLevel, pointsForLevel } = world.settings.heroes;
+	if (!hero || !entity.alive || hero.level >= max) return;
+	if (world.hooks.has("beforeXp")) amount = world.hooks.run("beforeXp", {
+		hero: entity,
+		from,
+		amount
+	}).amount;
+	if (amount <= 0) return;
+	hero.xp += amount;
+	while (hero.level < max && hero.xp >= xpForLevel(hero.level + 1)) {
+		hero.level++;
+		hero.points += pointsForLevel(hero.level);
+		refreshVitals(world, entity);
+		keepInnate(world, entity);
+		world.events.emit(heroLevelUp, {
+			hero: entity,
+			level: hero.level
+		});
+		world.message(entity.owner, engineMessage("heroLevel", {
+			unit: entity.def.id,
+			level: hero.level
+		}), "info");
+	}
+	if (hero.level >= max) hero.xp = xpForLevel(max);
+	world.events.emit(xpGained, {
+		hero: entity,
+		amount,
+		level: hero.level,
+		from
+	});
+}
+/**
+* The level of a hero's innate (`HeroDef.innate`) at a level of the hero: one for each of `innateLevels` it reached,
+* or the hero's own level where it says none; never past the ability's `maxLevel` where it says one. 0 before the first
+*
+* @beta
+*/
+function innateLevel(world, entity, heroLevel = heroOf(entity)?.level ?? 1) {
+	const def = entity.def.hero;
+	if (!def?.innate) return 0;
+	const own = def.innateLevels ? def.innateLevels.filter((at) => heroLevel >= at).length : heroLevel;
+	return Math.max(Math.min(own, world.registry.ability(def.innate).maxLevel ?? Infinity), 0);
+}
+/**
+* Gives a hero its innate (`HeroDef.innate`) where it has it not, at the level its own level says (`innateLevel`): as it
+* is made, as it gains a level, as it takes another form. It costs no point, and is none of those it learns
+*
+* @beta
+*/
+function keepInnate(world, entity) {
+	const id = entity.def.hero?.innate;
+	if (!id || !entity.has(heroState)) return;
+	const level = innateLevel(world, entity);
+	const state = entity.abilities.find((each) => each.id === id);
+	if (!state) entity.addAbility({
+		id: world.registry.ability(id).id,
+		level,
+		cooldown: 0,
+		autocast: world.registry.ability(id).autocast ?? false
+	});
+	else if (state.level !== level) state.level = level;
+}
+/**
+* Puts a hero at a level as if it had got there: the points to spend, the stats that grew, the experience of that
+* level. No message, no event and no `beforeXp`: for a hero that starts a map at that level, not one that earns it.
+* Never down
+*
+* @beta
+*/
+function setHeroLevel(world, entity, level) {
+	const hero = heroOf(entity);
+	if (!hero) return;
+	const to = Math.min(Math.floor(level), maxLevelOf(world, entity));
+	if (to <= hero.level) return;
+	while (hero.level < to) {
+		hero.level++;
+		hero.points += world.settings.heroes.pointsForLevel(hero.level);
+	}
+	hero.xp = world.settings.heroes.xpForLevel(to);
+	refreshVitals(world, entity);
+	keepInnate(world, entity);
+}
+/**
+* Experience a kill is worth
+*
+* @beta
+*/
+function xpWorth(world, entity) {
+	return entity.def.xp ?? world.settings.heroes.killXp(world, entity);
+}
+/**
+* Hero level needed to put the next point into an ability
+*
+* @beta
+*/
+function levelNeeded(world, hero, ability) {
+	const def = world.registry.ability(ability);
+	const state = hero.abilities.find((a) => a.id === ability);
+	return (def.requiresLevel ?? (def.ultimate ? 6 : 1)) + (def.levelStep ?? 2) * (state?.level ?? 0);
+}
+/**
+* Whether a hero may put a point into an ability now: by points, levels and its learning, and the `canLearn` hook
+*
+* @beta
+*/
+function canLearn(world, hero, ability) {
+	const state = heroOf(hero);
+	if (!state || !hero.alive || state.points <= 0) return false;
+	if (!hero.def.hero || !learnsOf(hero).includes(ability) || !world.registry.abilities.has(ability)) return false;
+	const learned = hero.abilities.find((a) => a.id === ability);
+	if (!learned || learned.level >= (world.registry.ability(ability).maxLevel ?? 3)) return false;
+	const allowed = state.level >= levelNeeded(world, hero, ability);
+	return world.hooks.has("canLearn") ? !world.hooks.run("canLearn", {
+		hero,
+		ability,
+		cancelled: !allowed
+	}).cancelled : allowed;
+}
+/**
+* Teaches the hero one level of an ability and spends a point on it; returns false when `canLearn` says it cannot
+*
+* @public
+*/
+function learn(world, hero, ability) {
+	if (!canLearn(world, hero, ability)) return false;
+	const state = hero.abilities.find((a) => a.id === ability);
+	state.level++;
+	heroOf(hero).points--;
+	if (state.level === 1) state.autocast = world.registry.ability(ability).autocast ?? false;
+	learnedInForm(hero, ability);
+	return true;
+}
+/**
+* Heroes a player has, fallen ones included
+*
+* @beta
+*/
+function heroesOf(world, player) {
+	return [...world.index.with(heroState, player)];
+}
+/**
+* What it costs to bring a hero back, in the game's money, and how long it takes
+*
+* @beta
+*/
+function reviveCost(world, hero) {
+	return world.settings.heroes.revive(world, hero);
+}
+/**
+* Puts a fallen hero back into the world
+*
+* @beta
+*/
+function reviveHero(world, hero, at) {
+	if (hero.alive || !hero.has(heroState)) return;
+	const point = (hero.flying ? world.air : world.nav).closestPoint(at, 8) ?? at;
+	hero.setAlive(true);
+	hero.setInside(false);
+	hero.reviving = false;
+	hero.health = hero.maxHealth;
+	hero.mana = hero.maxMana;
+	hero.clearBuffs();
+	hero.keepOrders();
+	for (const ability of hero.abilities) readyAgain(ability);
+	hero.moveTo(point.x, point.z);
+	hero.prevPos.x = point.x;
+	hero.prevPos.z = point.z;
+	const m = hero.get(moving);
+	if (m) {
+		m.status = "idle";
+		m.anchored = false;
+		m.ghost = false;
+		delete m.phased;
+		m.finalFacing = null;
+		m.speed = statsOf(world, hero).moveSpeed;
+		world.nav.addAgent(hero.id, point, agentParamsOf(hero, m.speed));
+	}
+	if (hero.get(fighting)) Object.assign(hero.get(fighting), {
+		cooldown: 0,
+		swing: 0,
+		swingTarget: 0,
+		autoTarget: 0,
+		lastAttacker: 0,
+		guard: null,
+		passive: false
+	});
+	world.events.emit(heroRevived, hero);
+}
+/**
+* A fallen hero waiting to come back: when it fell, and how long it waits, in seconds of the game
+*
+* @internal
+*/
+var respawning = defineComponent({ id: "core.respawning" });
+/**
+* How long until a fallen hero comes back by itself, in seconds: none for one that is not waiting
+*
+* @beta
+*/
+function respawnIn(world, hero) {
+	const waiting = hero.get(respawning);
+	return waiting && !hero.alive ? Math.max(0, waiting.since + waiting.wait - world.time) : void 0;
+}
+/** A hero back, to those who see it */
+var toldRevived = replicateEvent(heroRevived, "revived", (hero, view) => view.knows(hero) ? {
+	type: "revived",
+	id: hero.id
+} : void 0);
+/** A hero's new level, to those who see it */
+var toldLevelUp = replicateEvent(heroLevelUp, "levelUp", ({ hero, level }, view) => view.knows(hero) ? {
+	type: "levelUp",
+	id: hero.id,
+	level
+} : void 0);
+/** Experience gained: its side's alone, an enemy sees a bar move, not why */
+var toldXp = replicateEvent(xpGained, "xp", ({ hero, amount, level }, view) => view.isAlly(hero.owner) ? {
+	type: "xp",
+	id: hero.id,
+	amount,
+	level
+} : void 0);
+/**
+* A player's heroes, as their portraits show them (`PlayerState.own.heroes`): their level, health and mana, and how far
+* a fallen one is through being brought back, at an altar or by itself
+*
+* @beta
+*/
+function heroSummaries(world, player) {
+	const reviving = /* @__PURE__ */ new Map();
+	for (const entity of world.index.ownedBy(player)) {
+		const production = productionOf(entity);
+		if (!production) continue;
+		for (const item of production.queue) if (item.kind === "revive") reviving.set(Number(item.id), item.progress / item.duration);
+	}
+	return heroesOf(world, player).map((entity) => ({
+		id: entity.id,
+		type: entity.def.id,
+		level: heroOf(entity).level,
+		alive: entity.alive,
+		health: entity.alive ? entity.health / entity.maxHealth : 0,
+		mana: entity.alive && entity.maxMana > 0 ? entity.mana / entity.maxMana : 0,
+		points: heroOf(entity).points,
+		reviving: reviving.get(entity.id) ?? respawnProgress(world, entity),
+		...respawnIn(world, entity) !== void 0 && { respawnIn: respawnIn(world, entity) },
+		reviveCost: entity.alive ? void 0 : reviveCost(world, entity).cost
+	}));
+}
+/** How far a fallen hero is through its wait to come back by itself, 0..1: none for one that is not waiting */
+function respawnProgress(world, hero) {
+	const waiting = hero.get(respawning);
+	if (!waiting || hero.alive) return void 0;
+	return waiting.wait > 0 ? Math.min(1, (world.time - waiting.since) / waiting.wait) : 1;
+}
+/**
+* A hero shared a kill as an assist (`heroAssists`): who, of whom, who killed it, and the gold its player was paid for it
+*
+* @beta
+*/
+var heroAssisted = defineEngineEvent({
+	id: "core.heroAssisted",
+	replicate: "everyone"
+});
+/**
+* A hero killed another and is on a streak of this many since it last died
+*
+* @beta
+*/
+var killStreak = defineEngineEvent({
+	id: "core.killStreak",
+	replicate: "everyone"
+});
+/**
+* A hero on a streak fell (`HeroSettings.shutdownGold`): whose streak of how many, and the gold its killer's player was
+* paid on top of the kill for ending it
+*
+* @beta
+*/
+var heroShutdown = defineEngineEvent({
+	id: "core.shutdown",
+	replicate: "everyone"
+});
+/**
+* A fallen hero was bought back (`buyBack`): who, for whom, at what cost
+*
+* @beta
+*/
+var boughtBack = defineEngineEvent({
+	id: "core.boughtBack",
+	replicate: "everyone"
+});
+//#endregion
+export { HEROES, boughtBack, canLearn, defaultHeroSettings, grantXp, heroAssisted, heroKillWorth, heroOf, heroOfState, heroShutdown, heroState, heroSummaries, heroesOf, innateLevel, keepInnate, killStreak, learn, levelNeeded, maxLevelOf, respawnIn, respawning, reviveCost, reviveHero, setHeroLevel, toldLevelUp, toldRevived, toldXp, xpWorth };
+
+//# sourceMappingURL=hero.js.map