@v12-engine/engine 0.1.1 → 0.4.0

package/dist/targeting.js

@@ -0,0 +1,49 @@
+//#region src/targeting.ts
+/**
+* Every `AimKind`, in the order the aims are listed in tools
+*
+* @beta
+*/
+var AIM_KINDS = [
+	"none",
+	"unit",
+	"point",
+	"direction",
+	"vector",
+	"passive"
+];
+/**
+* A way of aiming of a game's own: `defineTargeting({ id: 'wall', like: 'point', check, indicator })`, listed in
+* `Rules.targetings` and named by an ability's `target`. Its name is said by declaring it in `AbilityTargetings`
+* (`declare module '@v12-engine/engine' { interface AbilityTargetings { wall: true } }`), so that an ability's
+* `target: 'wall'` is typed
+*
+* @beta
+*/
+function defineTargeting(def) {
+	if (AIM_KINDS.includes(def.id)) throw new Error(`"${def.id}" is a way of aiming of the engine's: a game's own needs a name of its own`);
+	return def;
+}
+/**
+* How an ability is aimed, as the engine's way it is or is like (`AimKind`): its `target` itself for the engine's, the
+* `like` of a game's own (`Rules.targetings`). `none` for a name nothing defines
+*
+* @beta
+*/
+function aimKind(registry, ability) {
+	const { target } = ability;
+	if (AIM_KINDS.includes(target)) return target;
+	return registry.targetings.has(target) ? registry.targetings.get(target).like : "none";
+}
+/**
+* A game's own way of aiming an ability (`Rules.targetings`), where its `target` names one
+*
+* @beta
+*/
+function targetingOf(registry, ability) {
+	return registry.targetings.has(ability.target) ? registry.targetings.get(ability.target) : void 0;
+}
+//#endregion
+export { AIM_KINDS, aimKind, defineTargeting, targetingOf };
+
+//# sourceMappingURL=targeting.js.map

package/dist/targeting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"targeting.js","names":[],"sources":["../src/targeting.ts"],"sourcesContent":["/**\n * How an ability is aimed (E2E-PLAN AB4): the engine's ways (`AbilityDef.target`: nothing, a unit, a point, a direction,\n * two points, passive) and a game's own (`defineTargeting`, listed in `Rules.targetings`): how the order checks and\n * aims it, and what the screen's indicator draws while the player aims it\n */\nimport type { AbilityDef, AimShape } from './defs'\nimport type { Entity } from './entity'\nimport type { Vec2 } from './math'\nimport type { MessageRef } from './messages'\nimport type { World } from './world'\n\n/**\n * The engine's ways of aiming an ability, what every way of a game's own is like (`Targeting.like`): at once\n * (`none`), at a unit, at a point (walked into range of), towards a point (from where the caster stands), along two\n * points (`vector`: where it starts, in range, and the way it goes from there), or not cast at all (`passive`)\n *\n * @beta\n */\nexport type AimKind = 'none' | 'unit' | 'point' | 'direction' | 'vector' | 'passive'\n\n/**\n * Every `AimKind`, in the order the aims are listed in tools\n *\n * @beta\n */\nexport const AIM_KINDS: readonly AimKind[] = ['none', 'unit', 'point', 'direction', 'vector', 'passive']\n\n/**\n * How an ability was aimed, as its order carries it: the unit, the point, and for two points (`vector`) where it goes\n * from the point (`to`)\n *\n * @beta\n */\nexport interface CastAim {\n\t/** The ability's level */\n\tlevel: number\n\t/** The unit the ability was aimed at, for a unit-aimed ability */\n\ttarget?: Entity\n\t/** The ground point it was aimed at, or the first point of a two-point ability */\n\tpoint?: Vec2\n\t/** For two points: the second, the way it goes from `point` */\n\tto?: Vec2\n}\n\n/**\n * Where an ability's effects go, from how it was aimed (`Targeting.aim`): their point, the unit they are for, and what\n * they go off from when not the caster (`EffectContext.origin`)\n *\n * @beta\n */\nexport interface CastAimed {\n\t/** Where the effects go, in world coordinates */\n\tpoint?: Vec2\n\t/** The unit the effects are for */\n\ttarget?: Entity\n\t/** What the effects go off from when it is not the caster: an entity or a point */\n\torigin?: Entity | Vec2\n}\n\n/**\n * A piece of what an indicator draws (`Targeting.indicator`): a shape (`AimShape`) at a place on the ground, turned\n * to `heading` (radians, 0 the way of +z) for one that points somewhere (a line, a cone, an arc)\n *\n * @beta\n */\nexport type AimPiece = AimShape & { at: Vec2; heading?: number }\n\n/**\n * What the screen knows as the player aims (`Targeting.indicator`): the ability and its level, where the caster\n * stands, where the pointer is on the ground, and for two points the first one, once it is given\n *\n * @beta\n */\nexport interface AimView {\n\t/** The ability being aimed */\n\tability: AbilityDef\n\t/** The level of the ability being aimed */\n\tlevel: number\n\t/** Where the caster stands, in world coordinates */\n\tfrom: Vec2\n\t/** Where the pointer is on the ground, when it is over the ground */\n\tpointer?: Vec2\n\t/** The first point of a two-point ability once it is given */\n\tstart?: Vec2\n}\n\n/**\n * A way of aiming of a game's own, for `AbilityDef.target` (`defineTargeting`): the engine's way it is like (what the\n * player gives, what the order walks to), and on top of that what may be aimed at (`check`), where the effects go\n * from what was aimed (`aim`), and what the screen draws while it is aimed (`indicator`)\n *\n * @beta\n */\nexport interface Targeting {\n\t/** What `AbilityDef.target` says for it */\n\treadonly id: string\n\t/** The engine's way it is like: what the player gives (a unit, a point, two points, nothing) and what the order walks to */\n\treadonly like: Exclude<AimKind, 'passive'>\n\t/**\n\t * Why it cannot be aimed so, or nothing where it can: asked as the order takes it and again as it goes off (the\n\t * player is told the reason). A wall only on open ground, a point only beside an ally\n\t */\n\tcheck?(world: World, caster: Entity, ability: AbilityDef, aim: CastAim): MessageRef | undefined\n\t/**\n\t * Where the effects go, from how it was aimed: over what the engine makes of it (its `point`, `target`, and for two\n\t * points the first as the `origin` and the second as the `point`)\n\t */\n\taim?(world: World, caster: Entity, ability: AbilityDef, aim: CastAim): CastAimed | undefined\n\t/**\n\t * What the screen draws on the ground while the player aims it, in place of the engine's (`aimOf`): pieces of the\n\t * shapes there are, each at a place, turned as it says. Code of the game's own, run on the screen: no world\n\t */\n\tindicator?(view: AimView): readonly AimPiece[] | undefined\n}\n\n/**\n * A way of aiming of a game's own: `defineTargeting({ id: 'wall', like: 'point', check, indicator })`, listed in\n * `Rules.targetings` and named by an ability's `target`. Its name is said by declaring it in `AbilityTargetings`\n * (`declare module '@v12-engine/engine' { interface AbilityTargetings { wall: true } }`), so that an ability's\n * `target: 'wall'` is typed\n *\n * @beta\n */\nexport function defineTargeting(def: Targeting): Targeting {\n\tif ((AIM_KINDS as readonly string[]).includes(def.id))\n\t\tthrow new Error(`\"${def.id}\" is a way of aiming of the engine's: a game's own needs a name of its own`)\n\treturn def\n}\n\n/**\n * How an ability is aimed, as the engine's way it is or is like (`AimKind`): its `target` itself for the engine's, the\n * `like` of a game's own (`Rules.targetings`). `none` for a name nothing defines\n *\n * @beta\n */\nexport function aimKind(registry: { readonly targetings: { has(id: string): boolean; get(id: string): Targeting } }, ability: AbilityDef): AimKind {\n\tconst { target } = ability\n\tif ((AIM_KINDS as readonly string[]).includes(target)) return target as AimKind\n\treturn registry.targetings.has(target) ? registry.targetings.get(target).like : 'none'\n}\n\n/**\n * A game's own way of aiming an ability (`Rules.targetings`), where its `target` names one\n *\n * @beta\n */\nexport function targetingOf(\n\tregistry: { readonly targetings: { has(id: string): boolean; get(id: string): Targeting } },\n\tability: AbilityDef\n): Targeting | undefined {\n\treturn registry.targetings.has(ability.target) ? registry.targetings.get(ability.target) : undefined\n}\n"],"mappings":";;;;;;AAyBA,IAAa,YAAgC;CAAC;CAAQ;CAAQ;CAAS;CAAa;CAAU;AAAS;;;;;;;;;AAkGvG,SAAgB,gBAAgB,KAA2B;CAC1D,IAAK,UAAgC,SAAS,IAAI,EAAE,GACnD,MAAM,IAAI,MAAM,IAAI,IAAI,GAAG,2EAA2E;CACvG,OAAO;AACR;;;;;;;AAQA,SAAgB,QAAQ,UAA6F,SAA8B;CAClJ,MAAM,EAAE,WAAW;CACnB,IAAK,UAAgC,SAAS,MAAM,GAAG,OAAO;CAC9D,OAAO,SAAS,WAAW,IAAI,MAAM,IAAI,SAAS,WAAW,IAAI,MAAM,CAAC,CAAC,OAAO;AACjF;;;;;;AAOA,SAAgB,YACf,UACA,SACwB;CACxB,OAAO,SAAS,WAAW,IAAI,QAAQ,MAAM,IAAI,SAAS,WAAW,IAAI,QAAQ,MAAM,IAAI,KAAA;AAC5F"}

package/dist/tech.d.ts

@@ -1,4 +1,4 @@
-import { type Entity, type PlayerId } from './entity';
+import { type AbilityState, type Entity, type PlayerId } from './entity';
 import type { World } from './world';
 import { type Message } from './messages';
 /**
@@ -33,17 +33,34 @@ export declare function unlockRefusal(world: World, player: PlayerId, kind: 'uni
  * @beta
  */
 export declare function unlocked(world: World, player: PlayerId, kind: 'unit' | 'upgrade', id: string, requires: string[] | undefined, level?: number): boolean;
+/**
+ * How `morph` goes about it where a building's upgrade does not: what a form needs (`takeForm`)
+ *
+ * @beta
+ */
+export interface MorphOptions {
+    /**
+     * What it was told goes on in the new type (what it was doing starts over from where it stands), where an upgrade
+     * drops it all
+     */
+    keepOrders?: boolean;
+    /** Its health and mana are the same parts of the most it can have in the new type, where an upgrade keeps what was lost */
+    share?: boolean;
+    /** What it can cast in the new type, all of it, in place of what the type's abilities and what it learned make */
+    abilities?: AbilityState[];
+}
 /**
  * Turns an entity into another type, where it stands: a building upgraded, a unit transformed (a druid into a bear, a
  * siege tank set up). Everything of the type is the new one's: stats, how it moves (and on the ground or in the air),
  * whether it fights, gathers or carries, its abilities (those of the old type it keeps are kept as they were, at their
  * levels and cooldowns), and what it makes. What it went through stays: health lost, mana, buffs, experience, items.
  * The parts of the game it had none of are given it as `spawn` gives them (`Component.onSpawn`), and the `morphed` hook
- * runs: what a pack gives it of its own for its new type (the heroes pack: a hero's level, a shop's wares)
+ * runs: what a pack gives it of its own for its new type (the heroes pack: a hero's level, a shop's wares). `options`
+ * keep its orders and the shares of its health and mana, and say its abilities: what a hero's form takes (`takeForm`)
  *
  * @beta
  */
-export declare function morph(world: World, entity: Entity, into: string): void;
+export declare function morph(world: World, entity: Entity, into: string, options?: MorphOptions): void;
 /** What became another, to those who see it */
 export declare const toldMorphed: import("./replication").ReplicatedEvent;
 /**

package/dist/tech.js

@@ -0,0 +1,239 @@
+import { upgradesOf } from "./defs.js";
+import { inventorySlots, slotsOf } from "./inventory.js";
+import { statsOf } from "./stats.js";
+import { entityMorphed } from "./engineEvents.js";
+import { replicateEvent } from "./replication.js";
+import { fighting, moving } from "./entity.js";
+import { engineMessage, toMessage } from "./messages.js";
+import { availableTo } from "./shared.js";
+import { agentParamsOf } from "./navigation/agentParams.js";
+import { productionQueue } from "./systems/productionQueue.js";
+import { refusalOf } from "./hooks.js";
+import { dropOnGround } from "./items.js";
+import { clearOrders, resetStance } from "./orders/queue.js";
+import { gathering } from "./orders/harvest.js";
+import { isAvailable } from "./races.js";
+//#region src/tech.ts
+/**
+* Types of the finished buildings a player has, with what those count as
+*
+* @beta
+*/
+function techOf(world, player) {
+	const tech = /* @__PURE__ */ new Set();
+	for (const entity of world.index.ownedBy(player)) {
+		if (!entity.alive || !entity.isBuilding || !entity.operational) continue;
+		tech.add(entity.def.id);
+		for (const other of entity.def.provides ?? []) tech.add(other);
+	}
+	return tech;
+}
+/**
+* What of a list of requirements a player does not have
+*
+* @beta
+*/
+function missing(world, player, requires, tech = techOf(world, player)) {
+	return (requires ?? []).filter((id) => !tech.has(id));
+}
+/**
+* Checks requirements and tells the player what is missing. True when there is nothing in the way
+*
+* @beta
+*/
+function meets(world, player, requires) {
+	const lacking = missing(world, player, requires);
+	if (lacking.length === 0) return true;
+	world.message(player, engineMessage("requires", { units: lacking }));
+	return false;
+}
+/**
+* Why a player may not make something as far as what it requires goes, or nothing: the finished buildings it
+* requires, and then the `requirement` hook (see `Requirement`). For a unit or structure type, or a level of research
+*
+* @beta
+*/
+function unlockRefusal(world, player, kind, id, requires, level) {
+	const lacking = missing(world, player, requires);
+	const refusal = lacking.length ? engineMessage("requires", { units: lacking }) : void 0;
+	if (!world.hooks.has("requirement")) return refusal;
+	const decided = refusalOf(world.hooks.run("requirement", {
+		player,
+		kind,
+		id,
+		level,
+		missing: lacking,
+		cancelled: !!refusal,
+		reason: refusal
+	}));
+	return decided ? toMessage(decided) : void 0;
+}
+/**
+* Checks that something is the player's to make at all (`isAvailable`: their race, the `available` hook), then what it
+* requires, by `unlockRefusal`, and tells the player what stands in the way. True when nothing does
+*
+* @beta
+*/
+function unlocked(world, player, kind, id, requires, level) {
+	if (!isAvailable(world, player, kind, id)) {
+		world.message(player, engineMessage("cannotDoThat"));
+		return false;
+	}
+	const refusal = unlockRefusal(world, player, kind, id, requires, level);
+	if (refusal) world.message(player, refusal);
+	return !refusal;
+}
+/**
+* Turns an entity into another type, where it stands: a building upgraded, a unit transformed (a druid into a bear, a
+* siege tank set up). Everything of the type is the new one's: stats, how it moves (and on the ground or in the air),
+* whether it fights, gathers or carries, its abilities (those of the old type it keeps are kept as they were, at their
+* levels and cooldowns), and what it makes. What it went through stays: health lost, mana, buffs, experience, items.
+* The parts of the game it had none of are given it as `spawn` gives them (`Component.onSpawn`), and the `morphed` hook
+* runs: what a pack gives it of its own for its new type (the heroes pack: a hero's level, a shop's wares). `options`
+* keep its orders and the shares of its health and mana, and say its abilities: what a hero's form takes (`takeForm`)
+*
+* @beta
+*/
+function morph(world, entity, into, options = {}) {
+	const def = world.registry.unit(into);
+	const old = entity.def;
+	const from = old.id;
+	const hurt = entity.maxHealth - entity.health;
+	const health = entity.maxHealth > 0 ? entity.health / entity.maxHealth : 1;
+	const mana = entity.maxMana > 0 ? entity.mana / entity.maxMana : 1;
+	world.index.remove(entity);
+	entity.retype(def);
+	world.index.add(entity);
+	const stats = statsOf(world, entity);
+	entity.maxHealth = stats.health;
+	if (options.share) {
+		entity.health = health * stats.health;
+		entity.maxMana = stats.mana;
+		entity.mana = mana * stats.mana;
+	} else entity.health = Math.max(stats.health - hurt, 1);
+	if ((def.trains?.length || def.researches?.length || upgradesOf(def).length) && !entity.has(productionQueue)) entity.set(productionQueue, {
+		queue: [],
+		rally: null
+	});
+	if (def.kind === "unit" && old.kind === "unit") transform(world, entity, old, stats.moveSpeed, options);
+	for (const part of world.registry.spawning) if (!entity.has(part)) part.onSpawn(entity, world);
+	if (world.hooks.has("morphed")) world.hooks.run("morphed", {
+		entity,
+		from
+	});
+	world.events.emit(entityMorphed, {
+		entity,
+		from
+	});
+}
+/** What changes of a unit that becomes another unit type, beyond its stats */
+function transform(world, entity, old, speed, options) {
+	const { def } = entity;
+	const m = entity.get(moving);
+	const reshaped = old.flying !== def.flying || old.radius !== def.radius || old.naval !== def.naval;
+	if (m && (reshaped || !speed)) world.nav.removeAgent(entity.id);
+	if (m && speed && reshaped) {
+		world.nav.addAgent(entity.id, entity.pos, agentParamsOf(entity, speed));
+		delete m.phased;
+	}
+	if (!speed) entity.remove(moving);
+	else if (m) {
+		if (!reshaped && m.speed !== speed) world.nav.setSpeed(entity.id, speed);
+		m.speed = speed;
+	}
+	if (def.attacks?.length) {
+		if (!entity.has(fighting)) entity.set(fighting, {
+			cooldown: 0,
+			swing: 0,
+			swingTarget: 0,
+			autoTarget: 0,
+			lastAttacker: 0,
+			guard: null,
+			passive: false
+		});
+	} else entity.remove(fighting);
+	if (!def.harvester) entity.remove(gathering);
+	else if (!entity.has(gathering)) entity.set(gathering, {
+		carrying: 0,
+		kind: null,
+		resource: 0
+	});
+	if (options.abilities) entity.setAbilities(options.abilities);
+	else {
+		const kept = new Map(entity.abilities.map((state) => [state.id, state]));
+		const learned = /* @__PURE__ */ new Set([
+			...old.hero?.learns ?? [],
+			...old.hero?.spells ?? [],
+			...def.hero?.learns ?? [],
+			...def.hero?.spells ?? []
+		]);
+		entity.setAbilities([...(def.abilities ?? []).map((id) => kept.get(id) ?? {
+			id,
+			level: 1,
+			cooldown: 0,
+			autocast: world.registry.ability(id).autocast ?? false
+		}), ...entity.abilities.filter((state) => learned.has(state.id) && !(def.abilities ?? []).includes(state.id))]);
+	}
+	if (def.inventory !== old.inventory) {
+		const items = (slotsOf(entity) ?? []).filter((item) => item !== null);
+		if (def.inventory) entity.set(inventorySlots, Array.from({ length: def.inventory }, (_, i) => items[i] ?? null));
+		else entity.remove(inventorySlots);
+		for (const item of items.slice(def.inventory ?? 0)) dropOnGround(world, item, entity.pos);
+	}
+	if (options.keepOrders) {
+		resetStance(world, entity);
+		const order = entity.orders[0];
+		if (order) order.started = false;
+	} else clearOrders(world, entity);
+}
+/** What became another, to those who see it */
+var toldMorphed = replicateEvent(entityMorphed, "morphed", ({ entity, from }, view) => view.knows(entity) ? {
+	type: "morphed",
+	id: entity.id,
+	from
+} : void 0);
+/**
+* What the `requirement` hook decided for a player, where it is not what the requirements say: what their screen could
+* not work out for itself (`PlayerState.own.unlocks`). Nothing where the hook agrees with them all
+*
+* @beta
+*/
+function decidedUnlocks(world, player) {
+	const tech = techOf(world, player);
+	let decided;
+	const compare = (key, kind, id, requires, level) => {
+		const lacking = missing(world, player, requires, tech);
+		const declared = lacking.length ? "requires" : void 0;
+		const refusal = unlockRefusal(world, player, kind, id, requires, level);
+		if (refusal?.key !== declared || refusal && declared && refusal.params?.units?.toString() !== lacking.toString()) (decided ??= {})[key] = refusal ?? null;
+	};
+	for (const def of world.registry.units.all()) compare(def.id, "unit", def.id, def.requires);
+	for (const def of world.registry.upgrades.all()) {
+		const level = world.player(player).upgrades.get(def.id) ?? 0;
+		if (level < (def.maxLevel ?? 1)) compare(`upgrade:${def.id}`, "upgrade", def.id, def.requires?.[level], level + 1);
+	}
+	return decided;
+}
+/**
+* What the `available` hook decided for a player, where it is not what their race says: what their screen could not
+* work out for itself (`PlayerState.own.availability`). Nothing where the hook agrees
+*
+* @beta
+*/
+function decidedAvailability(world, player) {
+	const race = world.player(player).race;
+	let decided;
+	for (const def of world.registry.units.all()) {
+		const available = isAvailable(world, player, "unit", def.id);
+		if (available !== availableTo(def, race)) (decided ??= {})[def.id] = available;
+	}
+	for (const def of world.registry.upgrades.all()) {
+		const available = isAvailable(world, player, "upgrade", def.id);
+		if (available !== availableTo(def, race)) (decided ??= {})[`upgrade:${def.id}`] = available;
+	}
+	return decided;
+}
+//#endregion
+export { decidedAvailability, decidedUnlocks, meets, missing, morph, techOf, toldMorphed, unlockRefusal, unlocked };
+
+//# sourceMappingURL=tech.js.map

package/dist/tech.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tech.js","names":[],"sources":["../src/tech.ts"],"sourcesContent":["import { entityMorphed } from '#engine/engineEvents'\nimport { refusalOf } from './hooks'\nimport { type AbilityState, type Entity, type PlayerId, moving, fighting } from './entity'\nimport { productionQueue } from './systems/productionQueue'\nimport { statsOf } from './stats'\nimport { type UnitTypeDef, upgradesOf } from './defs'\nimport { dropOnGround } from './items'\nimport { inventorySlots, slotsOf } from './inventory'\nimport { gathering } from './orders/harvest'\nimport { clearOrders, resetStance } from './orders/queue'\nimport type { World } from './world'\nimport { engineMessage, type Message, toMessage } from './messages'\nimport { isAvailable } from './races'\nimport { replicateEvent } from './replication'\nimport { availableTo } from './shared'\nimport { agentParamsOf } from './navigation/agentParams'\n\n/**\n * Types of the finished buildings a player has, with what those count as\n *\n * @beta\n */\nexport function techOf(world: World, player: PlayerId): Set<string> {\n\tconst tech = new Set<string>()\n\tfor (const entity of world.index.ownedBy(player)) {\n\t\tif (!entity.alive || !entity.isBuilding || !entity.operational) continue\n\t\ttech.add(entity.def.id)\n\t\tfor (const other of entity.def.provides ?? []) tech.add(other)\n\t}\n\treturn tech\n}\n\n/**\n * What of a list of requirements a player does not have\n *\n * @beta\n */\nexport function missing(world: World, player: PlayerId, requires: string[] | undefined, tech = techOf(world, player)): string[] {\n\treturn (requires ?? []).filter((id) => !tech.has(id))\n}\n\n/**\n * Checks requirements and tells the player what is missing. True when there is nothing in the way\n *\n * @beta\n */\nexport function meets(world: World, player: PlayerId, requires: string[] | undefined): boolean {\n\tconst lacking = missing(world, player, requires)\n\tif (lacking.length === 0) return true\n\tworld.message(player, engineMessage('requires', { units: lacking }))\n\treturn false\n}\n\n/**\n * Why a player may not make something as far as what it requires goes, or nothing: the finished buildings it\n * requires, and then the `requirement` hook (see `Requirement`). For a unit or structure type, or a level of research\n *\n * @beta\n */\nexport function unlockRefusal(\n\tworld: World,\n\tplayer: PlayerId,\n\tkind: 'unit' | 'upgrade',\n\tid: string,\n\trequires: string[] | undefined,\n\tlevel?: number\n): Message | undefined {\n\tconst lacking = missing(world, player, requires)\n\tconst refusal = lacking.length ? engineMessage('requires', { units: lacking }) : undefined\n\tif (!world.hooks.has('requirement')) return refusal\n\tconst decided = refusalOf(world.hooks.run('requirement', { player, kind, id, level, missing: lacking, cancelled: !!refusal, reason: refusal }))\n\treturn decided ? toMessage(decided) : undefined\n}\n\n/**\n * Checks that something is the player's to make at all (`isAvailable`: their race, the `available` hook), then what it\n * requires, by `unlockRefusal`, and tells the player what stands in the way. True when nothing does\n *\n * @beta\n */\nexport function unlocked(\n\tworld: World,\n\tplayer: PlayerId,\n\tkind: 'unit' | 'upgrade',\n\tid: string,\n\trequires: string[] | undefined,\n\tlevel?: number\n): boolean {\n\tif (!isAvailable(world, player, kind, id)) {\n\t\tworld.message(player, engineMessage('cannotDoThat'))\n\t\treturn false\n\t}\n\tconst refusal = unlockRefusal(world, player, kind, id, requires, level)\n\tif (refusal) world.message(player, refusal)\n\treturn !refusal\n}\n\n/**\n * How `morph` goes about it where a building's upgrade does not: what a form needs (`takeForm`)\n *\n * @beta\n */\nexport interface MorphOptions {\n\t/**\n\t * What it was told goes on in the new type (what it was doing starts over from where it stands), where an upgrade\n\t * drops it all\n\t */\n\tkeepOrders?: boolean\n\t/** Its health and mana are the same parts of the most it can have in the new type, where an upgrade keeps what was lost */\n\tshare?: boolean\n\t/** What it can cast in the new type, all of it, in place of what the type's abilities and what it learned make */\n\tabilities?: AbilityState[]\n}\n\n/**\n * Turns an entity into another type, where it stands: a building upgraded, a unit transformed (a druid into a bear, a\n * siege tank set up). Everything of the type is the new one's: stats, how it moves (and on the ground or in the air),\n * whether it fights, gathers or carries, its abilities (those of the old type it keeps are kept as they were, at their\n * levels and cooldowns), and what it makes. What it went through stays: health lost, mana, buffs, experience, items.\n * The parts of the game it had none of are given it as `spawn` gives them (`Component.onSpawn`), and the `morphed` hook\n * runs: what a pack gives it of its own for its new type (the heroes pack: a hero's level, a shop's wares). `options`\n * keep its orders and the shares of its health and mana, and say its abilities: what a hero's form takes (`takeForm`)\n *\n * @beta\n */\nexport function morph(world: World, entity: Entity, into: string, options: MorphOptions = {}): void {\n\tconst def = world.registry.unit(into)\n\tconst old = entity.def\n\tconst from = old.id\n\tconst hurt = entity.maxHealth - entity.health\n\tconst health = entity.maxHealth > 0 ? entity.health / entity.maxHealth : 1\n\tconst mana = entity.maxMana > 0 ? entity.mana / entity.maxMana : 1\n\t// filed again: what it turns into may sell things, or not\n\tworld.index.remove(entity)\n\tentity.retype(def)\n\tworld.index.add(entity)\n\tconst stats = statsOf(world, entity)\n\tentity.maxHealth = stats.health\n\tif (options.share) {\n\t\tentity.health = health * stats.health\n\t\tentity.maxMana = stats.mana\n\t\tentity.mana = mana * stats.mana\n\t} else entity.health = Math.max(stats.health - hurt, 1)\n\t// a unit that makes things too: what `spawn` gives a structure only\n\tif ((def.trains?.length || def.researches?.length || upgradesOf(def).length) && !entity.has(productionQueue))\n\t\tentity.set(productionQueue, { queue: [], rally: null })\n\tif (def.kind === 'unit' && old.kind === 'unit') transform(world, entity, old, stats.moveSpeed, options)\n\t// what each part of the game gives one of the new type as it is made, where it has none of it yet: a hold, slots, a\n\t// game's own (`Component.onSpawn`); what it has already (a hold with passengers, its slots) stays as it is\n\tfor (const part of world.registry.spawning) if (!entity.has(part)) part.onSpawn!(entity, world)\n\t// what a pack gives it of its own for its new type: a hero's level, a shop's wares (`heroesPack`)\n\tif (world.hooks.has('morphed')) world.hooks.run('morphed', { entity, from })\n\tworld.events.emit(entityMorphed, { entity, from })\n}\n\n/** What changes of a unit that becomes another unit type, beyond its stats */\nfunction transform(world: World, entity: Entity, old: UnitTypeDef, speed: number, options: MorphOptions): void {\n\tconst { def } = entity\n\t// how it moves: on the ground or in the air, how big it is\n\tconst m = entity.get(moving)\n\tconst reshaped = old.flying !== def.flying || old.radius !== def.radius || old.naval !== def.naval\n\tif (m && (reshaped || !speed)) world.nav.removeAgent(entity.id)\n\tif (m && speed && reshaped) {\n\t\tworld.nav.addAgent(entity.id, entity.pos, agentParamsOf(entity, speed))\n\t\t// a new agent walks through nobody: phasing is seen to again on the next tick (`BuffDef.phasing`)\n\t\tdelete m.phased\n\t}\n\tif (!speed) entity.remove(moving)\n\telse if (m) {\n\t\t// an agent kept is told its new speed too\n\t\tif (!reshaped && m.speed !== speed) world.nav.setSpeed(entity.id, speed)\n\t\tm.speed = speed\n\t}\n\t// whether it fights, and gathers\n\tif (def.attacks?.length) {\n\t\tif (!entity.has(fighting))\n\t\t\tentity.set(fighting, { cooldown: 0, swing: 0, swingTarget: 0, autoTarget: 0, lastAttacker: 0, guard: null, passive: false })\n\t} else entity.remove(fighting)\n\tif (!def.harvester) entity.remove(gathering)\n\telse if (!entity.has(gathering)) entity.set(gathering, { carrying: 0, kind: null, resource: 0 })\n\tif (options.abilities) entity.setAbilities(options.abilities)\n\telse {\n\t\t// its abilities: those of the new type, the ones it had already as they were; what a hero learned stays\n\t\tconst kept = new Map(entity.abilities.map((state) => [state.id, state]))\n\t\tconst learned = new Set([...(old.hero?.learns ?? []), ...(old.hero?.spells ?? []), ...(def.hero?.learns ?? []), ...(def.hero?.spells ?? [])])\n\t\tentity.setAbilities([\n\t\t\t...(def.abilities ?? []).map((id) => kept.get(id) ?? { id, level: 1, cooldown: 0, autocast: world.registry.ability(id).autocast ?? false }),\n\t\t\t...entity.abilities.filter((state) => learned.has(state.id) && !(def.abilities ?? []).includes(state.id))\n\t\t])\n\t}\n\t// what it carries: the slots of the new type, what does not fit left on the ground\n\tif (def.inventory !== old.inventory) {\n\t\tconst items = (slotsOf(entity) ?? []).filter((item) => item !== null)\n\t\tif (def.inventory)\n\t\t\tentity.set(\n\t\t\t\tinventorySlots,\n\t\t\t\tArray.from({ length: def.inventory }, (_, i) => items[i] ?? null)\n\t\t\t)\n\t\telse entity.remove(inventorySlots)\n\t\tfor (const item of items.slice(def.inventory ?? 0)) dropOnGround(world, item, entity.pos)\n\t}\n\tif (options.keepOrders) {\n\t\t// what it was doing starts over from where it stands, as what it is now; what was to come after waits its turn\n\t\tresetStance(world, entity)\n\t\tconst order = entity.orders[0]\n\t\tif (order) order.started = false\n\t}\n\t// what it was doing may not be for what it is now\n\telse clearOrders(world, entity)\n}\n\n/** What became another, to those who see it */\nexport const toldMorphed = replicateEvent(entityMorphed, 'morphed', ({ entity, from }, view) =>\n\tview.knows(entity) ? { type: 'morphed', id: entity.id, from } : undefined\n)\n\n/**\n * What the `requirement` hook decided for a player, where it is not what the requirements say: what their screen could\n * not work out for itself (`PlayerState.own.unlocks`). Nothing where the hook agrees with them all\n *\n * @beta\n */\nexport function decidedUnlocks(world: World, player: PlayerId): Record<string, Message | null> | undefined {\n\tconst tech = techOf(world, player)\n\tlet decided: Record<string, Message | null> | undefined\n\tconst compare = (key: string, kind: 'unit' | 'upgrade', id: string, requires: string[] | undefined, level?: number) => {\n\t\tconst lacking = missing(world, player, requires, tech)\n\t\tconst declared = lacking.length ? 'requires' : undefined\n\t\tconst refusal = unlockRefusal(world, player, kind, id, requires, level)\n\t\tif (refusal?.key !== declared || (refusal && declared && refusal.params?.units?.toString() !== lacking.toString()))\n\t\t\t(decided ??= {})[key] = refusal ?? null\n\t}\n\tfor (const def of world.registry.units.all()) compare(def.id, 'unit', def.id, def.requires)\n\tfor (const def of world.registry.upgrades.all()) {\n\t\tconst level = world.player(player).upgrades.get(def.id) ?? 0\n\t\tif (level < (def.maxLevel ?? 1)) compare(`upgrade:${def.id}`, 'upgrade', def.id, def.requires?.[level], level + 1)\n\t}\n\treturn decided\n}\n\n/**\n * What the `available` hook decided for a player, where it is not what their race says: what their screen could not\n * work out for itself (`PlayerState.own.availability`). Nothing where the hook agrees\n *\n * @beta\n */\nexport function decidedAvailability(world: World, player: PlayerId): Record<string, boolean> | undefined {\n\tconst race = world.player(player).race\n\tlet decided: Record<string, boolean> | undefined\n\tfor (const def of world.registry.units.all()) {\n\t\tconst available = isAvailable(world, player, 'unit', def.id)\n\t\tif (available !== availableTo(def, race)) (decided ??= {})[def.id] = available\n\t}\n\tfor (const def of world.registry.upgrades.all()) {\n\t\tconst available = isAvailable(world, player, 'upgrade', def.id)\n\t\tif (available !== availableTo(def, race)) (decided ??= {})[`upgrade:${def.id}`] = available\n\t}\n\treturn decided\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,OAAO,OAAc,QAA+B;CACnE,MAAM,uBAAO,IAAI,IAAY;CAC7B,KAAK,MAAM,UAAU,MAAM,MAAM,QAAQ,MAAM,GAAG;EACjD,IAAI,CAAC,OAAO,SAAS,CAAC,OAAO,cAAc,CAAC,OAAO,aAAa;EAChE,KAAK,IAAI,OAAO,IAAI,EAAE;EACtB,KAAK,MAAM,SAAS,OAAO,IAAI,YAAY,CAAC,GAAG,KAAK,IAAI,KAAK;CAC9D;CACA,OAAO;AACR;;;;;;AAOA,SAAgB,QAAQ,OAAc,QAAkB,UAAgC,OAAO,OAAO,OAAO,MAAM,GAAa;CAC/H,QAAQ,YAAY,CAAC,EAAA,CAAG,QAAQ,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC;AACrD;;;;;;AAOA,SAAgB,MAAM,OAAc,QAAkB,UAAyC;CAC9F,MAAM,UAAU,QAAQ,OAAO,QAAQ,QAAQ;CAC/C,IAAI,QAAQ,WAAW,GAAG,OAAO;CACjC,MAAM,QAAQ,QAAQ,cAAc,YAAY,EAAE,OAAO,QAAQ,CAAC,CAAC;CACnE,OAAO;AACR;;;;;;;AAQA,SAAgB,cACf,OACA,QACA,MACA,IACA,UACA,OACsB;CACtB,MAAM,UAAU,QAAQ,OAAO,QAAQ,QAAQ;CAC/C,MAAM,UAAU,QAAQ,SAAS,cAAc,YAAY,EAAE,OAAO,QAAQ,CAAC,IAAI,KAAA;CACjF,IAAI,CAAC,MAAM,MAAM,IAAI,aAAa,GAAG,OAAO;CAC5C,MAAM,UAAU,UAAU,MAAM,MAAM,IAAI,eAAe;EAAE;EAAQ;EAAM;EAAI;EAAO,SAAS;EAAS,WAAW,CAAC,CAAC;EAAS,QAAQ;CAAQ,CAAC,CAAC;CAC9I,OAAO,UAAU,UAAU,OAAO,IAAI,KAAA;AACvC;;;;;;;AAQA,SAAgB,SACf,OACA,QACA,MACA,IACA,UACA,OACU;CACV,IAAI,CAAC,YAAY,OAAO,QAAQ,MAAM,EAAE,GAAG;EAC1C,MAAM,QAAQ,QAAQ,cAAc,cAAc,CAAC;EACnD,OAAO;CACR;CACA,MAAM,UAAU,cAAc,OAAO,QAAQ,MAAM,IAAI,UAAU,KAAK;CACtE,IAAI,SAAS,MAAM,QAAQ,QAAQ,OAAO;CAC1C,OAAO,CAAC;AACT;;;;;;;;;;;;AA8BA,SAAgB,MAAM,OAAc,QAAgB,MAAc,UAAwB,CAAC,GAAS;CACnG,MAAM,MAAM,MAAM,SAAS,KAAK,IAAI;CACpC,MAAM,MAAM,OAAO;CACnB,MAAM,OAAO,IAAI;CACjB,MAAM,OAAO,OAAO,YAAY,OAAO;CACvC,MAAM,SAAS,OAAO,YAAY,IAAI,OAAO,SAAS,OAAO,YAAY;CACzE,MAAM,OAAO,OAAO,UAAU,IAAI,OAAO,OAAO,OAAO,UAAU;CAEjE,MAAM,MAAM,OAAO,MAAM;CACzB,OAAO,OAAO,GAAG;CACjB,MAAM,MAAM,IAAI,MAAM;CACtB,MAAM,QAAQ,QAAQ,OAAO,MAAM;CACnC,OAAO,YAAY,MAAM;CACzB,IAAI,QAAQ,OAAO;EAClB,OAAO,SAAS,SAAS,MAAM;EAC/B,OAAO,UAAU,MAAM;EACvB,OAAO,OAAO,OAAO,MAAM;CAC5B,OAAO,OAAO,SAAS,KAAK,IAAI,MAAM,SAAS,MAAM,CAAC;CAEtD,KAAK,IAAI,QAAQ,UAAU,IAAI,YAAY,UAAU,WAAW,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,IAAI,eAAe,GAC1G,OAAO,IAAI,iBAAiB;EAAE,OAAO,CAAC;EAAG,OAAO;CAAK,CAAC;CACvD,IAAI,IAAI,SAAS,UAAU,IAAI,SAAS,QAAQ,UAAU,OAAO,QAAQ,KAAK,MAAM,WAAW,OAAO;CAGtG,KAAK,MAAM,QAAQ,MAAM,SAAS,UAAU,IAAI,CAAC,OAAO,IAAI,IAAI,GAAG,KAAK,QAAS,QAAQ,KAAK;CAE9F,IAAI,MAAM,MAAM,IAAI,SAAS,GAAG,MAAM,MAAM,IAAI,WAAW;EAAE;EAAQ;CAAK,CAAC;CAC3E,MAAM,OAAO,KAAK,eAAe;EAAE;EAAQ;CAAK,CAAC;AAClD;;AAGA,SAAS,UAAU,OAAc,QAAgB,KAAkB,OAAe,SAA6B;CAC9G,MAAM,EAAE,QAAQ;CAEhB,MAAM,IAAI,OAAO,IAAI,MAAM;CAC3B,MAAM,WAAW,IAAI,WAAW,IAAI,UAAU,IAAI,WAAW,IAAI,UAAU,IAAI,UAAU,IAAI;CAC7F,IAAI,MAAM,YAAY,CAAC,QAAQ,MAAM,IAAI,YAAY,OAAO,EAAE;CAC9D,IAAI,KAAK,SAAS,UAAU;EAC3B,MAAM,IAAI,SAAS,OAAO,IAAI,OAAO,KAAK,cAAc,QAAQ,KAAK,CAAC;EAEtE,OAAO,EAAE;CACV;CACA,IAAI,CAAC,OAAO,OAAO,OAAO,MAAM;MAC3B,IAAI,GAAG;EAEX,IAAI,CAAC,YAAY,EAAE,UAAU,OAAO,MAAM,IAAI,SAAS,OAAO,IAAI,KAAK;EACvE,EAAE,QAAQ;CACX;CAEA,IAAI,IAAI,SAAS,QACZ;MAAA,CAAC,OAAO,IAAI,QAAQ,GACvB,OAAO,IAAI,UAAU;GAAE,UAAU;GAAG,OAAO;GAAG,aAAa;GAAG,YAAY;GAAG,cAAc;GAAG,OAAO;GAAM,SAAS;EAAM,CAAC;CAAA,OACtH,OAAO,OAAO,QAAQ;CAC7B,IAAI,CAAC,IAAI,WAAW,OAAO,OAAO,SAAS;MACtC,IAAI,CAAC,OAAO,IAAI,SAAS,GAAG,OAAO,IAAI,WAAW;EAAE,UAAU;EAAG,MAAM;EAAM,UAAU;CAAE,CAAC;CAC/F,IAAI,QAAQ,WAAW,OAAO,aAAa,QAAQ,SAAS;MACvD;EAEJ,MAAM,OAAO,IAAI,IAAI,OAAO,UAAU,KAAK,UAAU,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC;EACvE,MAAM,0BAAU,IAAI,IAAI;GAAC,GAAI,IAAI,MAAM,UAAU,CAAC;GAAI,GAAI,IAAI,MAAM,UAAU,CAAC;GAAI,GAAI,IAAI,MAAM,UAAU,CAAC;GAAI,GAAI,IAAI,MAAM,UAAU,CAAC;EAAE,CAAC;EAC5I,OAAO,aAAa,CACnB,IAAI,IAAI,aAAa,CAAC,EAAA,CAAG,KAAK,OAAO,KAAK,IAAI,EAAE,KAAK;GAAE;GAAI,OAAO;GAAG,UAAU;GAAG,UAAU,MAAM,SAAS,QAAQ,EAAE,CAAC,CAAC,YAAY;EAAM,CAAC,GAC1I,GAAG,OAAO,UAAU,QAAQ,UAAU,QAAQ,IAAI,MAAM,EAAE,KAAK,EAAE,IAAI,aAAa,CAAC,EAAA,CAAG,SAAS,MAAM,EAAE,CAAC,CACzG,CAAC;CACF;CAEA,IAAI,IAAI,cAAc,IAAI,WAAW;EACpC,MAAM,SAAS,QAAQ,MAAM,KAAK,CAAC,EAAA,CAAG,QAAQ,SAAS,SAAS,IAAI;EACpE,IAAI,IAAI,WACP,OAAO,IACN,gBACA,MAAM,KAAK,EAAE,QAAQ,IAAI,UAAU,IAAI,GAAG,MAAM,MAAM,MAAM,IAAI,CACjE;OACI,OAAO,OAAO,cAAc;EACjC,KAAK,MAAM,QAAQ,MAAM,MAAM,IAAI,aAAa,CAAC,GAAG,aAAa,OAAO,MAAM,OAAO,GAAG;CACzF;CACA,IAAI,QAAQ,YAAY;EAEvB,YAAY,OAAO,MAAM;EACzB,MAAM,QAAQ,OAAO,OAAO;EAC5B,IAAI,OAAO,MAAM,UAAU;CAC5B,OAEK,YAAY,OAAO,MAAM;AAC/B;;AAGA,IAAa,cAAc,eAAe,eAAe,YAAY,EAAE,QAAQ,QAAQ,SACtF,KAAK,MAAM,MAAM,IAAI;CAAE,MAAM;CAAW,IAAI,OAAO;CAAI;AAAK,IAAI,KAAA,CACjE;;;;;;;AAQA,SAAgB,eAAe,OAAc,QAA8D;CAC1G,MAAM,OAAO,OAAO,OAAO,MAAM;CACjC,IAAI;CACJ,MAAM,WAAW,KAAa,MAA0B,IAAY,UAAgC,UAAmB;EACtH,MAAM,UAAU,QAAQ,OAAO,QAAQ,UAAU,IAAI;EACrD,MAAM,WAAW,QAAQ,SAAS,aAAa,KAAA;EAC/C,MAAM,UAAU,cAAc,OAAO,QAAQ,MAAM,IAAI,UAAU,KAAK;EACtE,IAAI,SAAS,QAAQ,YAAa,WAAW,YAAY,QAAQ,QAAQ,OAAO,SAAS,MAAM,QAAQ,SAAS,GAC/G,CAAC,YAAY,CAAC,EAAA,CAAG,OAAO,WAAW;CACrC;CACA,KAAK,MAAM,OAAO,MAAM,SAAS,MAAM,IAAI,GAAG,QAAQ,IAAI,IAAI,QAAQ,IAAI,IAAI,IAAI,QAAQ;CAC1F,KAAK,MAAM,OAAO,MAAM,SAAS,SAAS,IAAI,GAAG;EAChD,MAAM,QAAQ,MAAM,OAAO,MAAM,CAAC,CAAC,SAAS,IAAI,IAAI,EAAE,KAAK;EAC3D,IAAI,SAAS,IAAI,YAAY,IAAI,QAAQ,WAAW,IAAI,MAAM,WAAW,IAAI,IAAI,IAAI,WAAW,QAAQ,QAAQ,CAAC;CAClH;CACA,OAAO;AACR;;;;;;;AAQA,SAAgB,oBAAoB,OAAc,QAAuD;CACxG,MAAM,OAAO,MAAM,OAAO,MAAM,CAAC,CAAC;CAClC,IAAI;CACJ,KAAK,MAAM,OAAO,MAAM,SAAS,MAAM,IAAI,GAAG;EAC7C,MAAM,YAAY,YAAY,OAAO,QAAQ,QAAQ,IAAI,EAAE;EAC3D,IAAI,cAAc,YAAY,KAAK,IAAI,GAAG,CAAC,YAAY,CAAC,EAAA,CAAG,IAAI,MAAM;CACtE;CACA,KAAK,MAAM,OAAO,MAAM,SAAS,SAAS,IAAI,GAAG;EAChD,MAAM,YAAY,YAAY,OAAO,QAAQ,WAAW,IAAI,EAAE;EAC9D,IAAI,cAAc,YAAY,KAAK,IAAI,GAAG,CAAC,YAAY,CAAC,EAAA,CAAG,WAAW,IAAI,QAAQ;CACnF;CACA,OAAO;AACR"}

package/dist/techTree.d.ts

@@ -5,9 +5,13 @@ import type { Registry } from './registry';
  * @beta
  */
 export interface TechNode {
+    /** The unit type or upgrade id this node stands for */
     id: string;
+    /** Whether the node is a unit, a building or an upgrade */
     kind: 'unit' | 'building' | 'upgrade';
+    /** The name shown for the node */
     name: string;
+    /** How far the node is from the start of the tree, 0 for what is made from the start */
     tier: number;
     /** The race it is of, where it says */
     race?: string;
@@ -19,8 +23,11 @@ export interface TechNode {
  * @beta
  */
 export interface TechEdge {
+    /** The id of the node that makes `to`, or that `to` requires */
     from: string;
+    /** The id of the node that is made, or that requires `from` */
     to: string;
+    /** How `from` leads to `to`: it trains, builds, hires, researches or upgrades to it, or `to` requires it */
     kind: 'trains' | 'builds' | 'hires' | 'researches' | 'upgradesTo' | 'requires';
 }
 /**

package/dist/techTree.js

@@ -0,0 +1,90 @@
+import { upgradesOf } from "./defs.js";
+//#region src/techTree.ts
+/**
+* The tech tree of a game's rules: its things that are made or make something (scenery and the map's creeps left
+* out), the edges between them, and each one's tier. Tiers go by what makes what from what nothing makes and from the
+* buildings that make the builders, require nothing and are no other's upgrade (a hall; else, where everything is
+* made of something, the buildings that require nothing, are no upgrade and make something),
+* each thing after what it requires; a loop of requirements stops at the number of things
+*
+* @beta
+*/
+function techTree(registry) {
+	const units = registry.units.all();
+	const upgrades = registry.upgrades.all();
+	const edges = [];
+	const known = /* @__PURE__ */ new Set([...units.map((unit) => unit.id), ...upgrades.map((upgrade) => upgrade.id)]);
+	const add = (from, to, kind) => {
+		if (known.has(from) && known.has(to) && from !== to) edges.push({
+			from,
+			to,
+			kind
+		});
+	};
+	for (const unit of units) {
+		for (const id of unit.trains ?? []) add(unit.id, id, "trains");
+		for (const id of unit.builds ?? []) add(unit.id, id, "builds");
+		for (const id of unit.hires ?? []) add(unit.id, id, "hires");
+		for (const id of unit.researches ?? []) add(unit.id, id, "researches");
+		for (const id of upgradesOf(unit)) add(unit.id, id, "upgradesTo");
+		for (const id of unit.requires ?? []) add(id, unit.id, "requires");
+	}
+	for (const upgrade of upgrades) for (const id of upgrade.requires?.[0] ?? []) add(id, upgrade.id, "requires");
+	const inTree = new Set(edges.flatMap((edge) => [edge.from, edge.to]));
+	const makes = edges.filter((edge) => edge.kind !== "requires");
+	const made = new Set(makes.map((edge) => edge.to));
+	const needs = /* @__PURE__ */ new Map();
+	for (const edge of edges) if (edge.kind === "requires") needs.set(edge.to, [...needs.get(edge.to) ?? [], edge.from]);
+	const buildings = new Set(units.filter((unit) => unit.kind !== "unit").map((unit) => unit.id));
+	const upgraded = new Set(edges.filter((edge) => edge.kind === "upgradesTo").map((edge) => edge.to));
+	let start = [...inTree].filter((id) => !made.has(id));
+	const builders = new Set(units.filter((unit) => unit.builds?.length).map((unit) => unit.id));
+	const first = [...inTree].filter((id) => buildings.has(id) && !needs.has(id) && !upgraded.has(id));
+	const halls = first.filter((id) => makes.some((edge) => edge.from === id && builders.has(edge.to)));
+	start = [.../* @__PURE__ */ new Set([...start, ...halls])];
+	if (!start.length) start = first.filter((id) => makes.some((edge) => edge.from === id));
+	if (!start.length) start = [...inTree].filter((id) => !needs.has(id));
+	const tier = new Map(start.map((id) => [id, 0]));
+	for (let queue = [...start]; queue.length;) {
+		const next = [];
+		for (const id of queue) for (const edge of makes) if (edge.from === id && !tier.has(edge.to)) {
+			tier.set(edge.to, tier.get(id) + 1);
+			next.push(edge.to);
+		}
+		queue = next;
+	}
+	for (let pass = 0; pass < inTree.size; pass++) {
+		let moved = false;
+		for (const [id, required] of needs) {
+			const after = Math.max(...required.map((other) => (tier.get(other) ?? 0) + 1));
+			if (after > (tier.get(id) ?? 0)) {
+				tier.set(id, after);
+				moved = true;
+			}
+		}
+		if (!moved) break;
+	}
+	const nodes = [];
+	for (const unit of units) if (inTree.has(unit.id)) nodes.push({
+		id: unit.id,
+		kind: unit.kind === "unit" ? "unit" : "building",
+		name: unit.name,
+		tier: tier.get(unit.id) ?? 0,
+		...unit.race && { race: unit.race }
+	});
+	for (const upgrade of upgrades) if (inTree.has(upgrade.id)) nodes.push({
+		id: upgrade.id,
+		kind: "upgrade",
+		name: upgrade.name,
+		tier: tier.get(upgrade.id) ?? 0,
+		...upgrade.race && { race: upgrade.race }
+	});
+	return {
+		nodes,
+		edges
+	};
+}
+//#endregion
+export { techTree };
+
+//# sourceMappingURL=techTree.js.map

package/dist/techTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"techTree.js","names":[],"sources":["../src/techTree.ts"],"sourcesContent":["import { upgradesOf } from './defs'\nimport type { Registry } from './registry'\n\n/*\n * The tech tree of a game (master plan OH13): what makes what (a building trains a unit, a worker builds a building, a\n * building researches an upgrade, a type upgrades to another) and what needs what (`requires`), each thing on a tier:\n * how far from the start it is. For the editor's drawing of it, and for a game's own (a help screen)\n */\n\n/**\n * A thing of a tech tree: a unit or building type, or an upgrade, on its tier (0: made from the start)\n *\n * @beta\n */\nexport interface TechNode {\n\t/** The unit type or upgrade id this node stands for */\n\tid: string\n\t/** Whether the node is a unit, a building or an upgrade */\n\tkind: 'unit' | 'building' | 'upgrade'\n\t/** The name shown for the node */\n\tname: string\n\t/** How far the node is from the start of the tree, 0 for what is made from the start */\n\ttier: number\n\t/** The race it is of, where it says */\n\trace?: string\n}\n\n/**\n * How one thing of a tech tree leads to another: `from` makes `to` (trains, builds, hires, researches, upgrades to),\n * or `to` requires `from`\n *\n * @beta\n */\nexport interface TechEdge {\n\t/** The id of the node that makes `to`, or that `to` requires */\n\tfrom: string\n\t/** The id of the node that is made, or that requires `from` */\n\tto: string\n\t/** How `from` leads to `to`: it trains, builds, hires, researches or upgrades to it, or `to` requires it */\n\tkind: 'trains' | 'builds' | 'hires' | 'researches' | 'upgradesTo' | 'requires'\n}\n\n/**\n * The tech tree of a game's rules: its things that are made or make something (scenery and the map's creeps left\n * out), the edges between them, and each one's tier. Tiers go by what makes what from what nothing makes and from the\n * buildings that make the builders, require nothing and are no other's upgrade (a hall; else, where everything is\n * made of something, the buildings that require nothing, are no upgrade and make something),\n * each thing after what it requires; a loop of requirements stops at the number of things\n *\n * @beta\n */\nexport function techTree(registry: Pick<Registry, 'units' | 'upgrades'>): { nodes: TechNode[]; edges: TechEdge[] } {\n\tconst units = registry.units.all()\n\tconst upgrades = registry.upgrades.all()\n\tconst edges: TechEdge[] = []\n\tconst known = new Set([...units.map((unit) => unit.id), ...upgrades.map((upgrade) => upgrade.id)])\n\tconst add = (from: string, to: string, kind: TechEdge['kind']) => {\n\t\tif (known.has(from) && known.has(to) && from !== to) edges.push({ from, to, kind })\n\t}\n\tfor (const unit of units) {\n\t\tfor (const id of unit.trains ?? []) add(unit.id, id, 'trains')\n\t\tfor (const id of unit.builds ?? []) add(unit.id, id, 'builds')\n\t\tfor (const id of unit.hires ?? []) add(unit.id, id, 'hires')\n\t\tfor (const id of unit.researches ?? []) add(unit.id, id, 'researches')\n\t\tfor (const id of upgradesOf(unit)) add(unit.id, id, 'upgradesTo')\n\t\tfor (const id of unit.requires ?? []) add(id, unit.id, 'requires')\n\t}\n\tfor (const upgrade of upgrades) for (const id of upgrade.requires?.[0] ?? []) add(id, upgrade.id, 'requires')\n\n\t// what is in the tree: what makes, is made, or requires or is required\n\tconst inTree = new Set(edges.flatMap((edge) => [edge.from, edge.to]))\n\tconst makes = edges.filter((edge) => edge.kind !== 'requires')\n\tconst made = new Set(makes.map((edge) => edge.to))\n\tconst needs = new Map<string, string[]>()\n\tfor (const edge of edges) if (edge.kind === 'requires') needs.set(edge.to, [...(needs.get(edge.to) ?? []), edge.from])\n\t// the start: what nothing makes; where all is made of something (a hall and its workers), the buildings that require\n\t// nothing and are no other's upgrade (a game starts with a hall), else what requires nothing\n\tconst buildings = new Set(units.filter((unit) => unit.kind !== 'unit').map((unit) => unit.id))\n\tconst upgraded = new Set(edges.filter((edge) => edge.kind === 'upgradesTo').map((edge) => edge.to))\n\tlet start = [...inTree].filter((id) => !made.has(id))\n\t// (of those, the ones that make the builders: a town hall, not a barracks)\n\tconst builders = new Set(units.filter((unit) => unit.builds?.length).map((unit) => unit.id))\n\tconst first = [...inTree].filter((id) => buildings.has(id) && !needs.has(id) && !upgraded.has(id))\n\t// and those halls beside what nothing makes, which may be no player's to make at all (a neutral shipyard that hires)\n\tconst halls = first.filter((id) => makes.some((edge) => edge.from === id && builders.has(edge.to)))\n\tstart = [...new Set([...start, ...halls])]\n\tif (!start.length) start = first.filter((id) => makes.some((edge) => edge.from === id))\n\tif (!start.length) start = [...inTree].filter((id) => !needs.has(id))\n\tconst tier = new Map<string, number>(start.map((id) => [id, 0]))\n\t// out along what makes what, nearest first\n\tfor (let queue = [...start]; queue.length;) {\n\t\tconst next: string[] = []\n\t\tfor (const id of queue)\n\t\t\tfor (const edge of makes)\n\t\t\t\tif (edge.from === id && !tier.has(edge.to)) {\n\t\t\t\t\ttier.set(edge.to, tier.get(id)! + 1)\n\t\t\t\t\tnext.push(edge.to)\n\t\t\t\t}\n\t\tqueue = next\n\t}\n\t// then after what each requires, as long as that moves anything, and no more often than there are things\n\tfor (let pass = 0; pass < inTree.size; pass++) {\n\t\tlet moved = false\n\t\tfor (const [id, required] of needs) {\n\t\t\tconst after = Math.max(...required.map((other) => (tier.get(other) ?? 0) + 1))\n\t\t\tif (after > (tier.get(id) ?? 0)) {\n\t\t\t\ttier.set(id, after)\n\t\t\t\tmoved = true\n\t\t\t}\n\t\t}\n\t\tif (!moved) break\n\t}\n\tconst nodes: TechNode[] = []\n\tfor (const unit of units)\n\t\tif (inTree.has(unit.id))\n\t\t\tnodes.push({\n\t\t\t\tid: unit.id,\n\t\t\t\tkind: unit.kind === 'unit' ? 'unit' : 'building',\n\t\t\t\tname: unit.name,\n\t\t\t\ttier: tier.get(unit.id) ?? 0,\n\t\t\t\t...(unit.race && { race: unit.race })\n\t\t\t})\n\tfor (const upgrade of upgrades)\n\t\tif (inTree.has(upgrade.id))\n\t\t\tnodes.push({\n\t\t\t\tid: upgrade.id,\n\t\t\t\tkind: 'upgrade',\n\t\t\t\tname: upgrade.name,\n\t\t\t\ttier: tier.get(upgrade.id) ?? 0,\n\t\t\t\t...(upgrade.race && { race: upgrade.race })\n\t\t\t})\n\treturn { nodes, edges }\n}\n"],"mappings":"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"}