@v12-engine/engine 0.1.0 → 0.4.0

package/dist/ai/plans/plans.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plans.js","names":[],"sources":["../../../src/ai/plans/plans.ts"],"sourcesContent":["import type { Brain } from '#engine/ai/brain'\nimport type { AiArea } from '#engine/ai/area'\nimport { BuildPlan, type BuildPlanMemory, type BuildPlanOptions, type BuildPlanReport, type Want } from './build'\nimport { ProductionPlan, type ProductionPlanMemory, type ProductionPlanOptions, type ProductionPlanReport } from './production'\nimport type { PurseReport } from './purse'\n\n/*\n * The plans of a brain (AI plan, B3), under one name (`ai.plans`): the build plan (what to build, and how to get\n * there) and the production plan (what to train and research), and the game's build order over both (`order`: what\n * to have first, each item waiting for the one before, the computer's own wants held back meanwhile). They are the\n * brain's, as its goals are, so that every module adds to the same ones; the modules `build()` and `production()`\n * run each in its place among a brain's modules, and the melee player runs them in its own. What they remember is\n * kept together in the brain's memory (`BrainMemory.plans`)\n */\n\n/**\n * One item of a build order: a type to have (one of it), or a type and how many. Counts of a type add up along the order\n *\n * @beta\n */\nexport type BuildOrderItem = string | { type: string; count?: number }\n\n/**\n * How a brain plans (`BrainDef.plans`): the build plan's options, the production plan's, the build order\n *\n * @beta\n */\nexport interface PlansOptions {\n\t/** Options of the build plan */\n\tbuild?: BuildPlanOptions\n\t/** Options of the production plan */\n\tproduction?: ProductionPlanOptions\n\t/**\n\t * What to have first, in order (`BuildOrderItem`): each item waits for the one before, and nothing else the\n\t * computer would make of itself is made meanwhile (`following`); what it works out for itself once done. The\n\t * seat's `AiOptions.buildOrder`\n\t */\n\torder?: BuildOrderItem[]\n}\n\n/**\n * What the plans remember between thinks, for a save\n *\n * @beta\n */\nexport interface PlansMemory {\n\t/** The version of the memory's format: 1 so far */\n\tv: 1\n\t/** The build plan's memory */\n\tbuild?: BuildPlanMemory\n\t/** The production plan's memory */\n\tproduction?: ProductionPlanMemory\n}\n\n/**\n * The plans as the report shows them: the purse, and each plan's part\n *\n * @beta\n */\nexport interface PlansReport {\n\t/** The purse: what is free, promised and held */\n\tpurse: PurseReport\n\t/** The build plan's wants and which one saves up */\n\tbuild: BuildPlanReport\n\t/** The production plan's composition and what it trained */\n\tproduction: ProductionPlanReport\n\t/** The build order's next item, while it is being followed */\n\torder?: { type: string; count: number; item: number }\n}\n\n/**\n * A brain's plans (`ai.plans`): `build` for what is to be built, `production` for what is to be trained and\n * researched, the game's build `order` over both. `want` is the one door: a want of a building goes to the build\n * plan; one of a unit goes to the build plan for its buildings, and the production plan trains it\n *\n * @beta\n */\nexport class Plans implements AiArea {\n\t/** Its id among the brain's areas: what its memory and its report are kept under */\n\treadonly id = 'plans'\n\t/** What the log says where a save's memory of it is of a shape it does not read */\n\treadonly afresh = 'the save remembers what the computer player planned in a shape this brain does not read: it plans afresh'\n\n\t/** What to build, and the steps to it */\n\treadonly build: BuildPlan\n\t/** What to train and research */\n\treadonly production: ProductionPlan\n\tprivate readonly order: BuildOrderItem[]\n\tprivate followedAt = -1\n\tprivate next: PlansReport['order'] | undefined\n\n\tconstructor(\n\t\t/** The brain they plan for */\n\t\treadonly ai: Brain,\n\t\toptions: PlansOptions = {}\n\t) {\n\t\tthis.build = new BuildPlan(ai, options.build)\n\t\tthis.production = new ProductionPlan(ai, options.production)\n\t\tthis.order = options.order ?? []\n\t}\n\n\t/** Adds a want: what the brain works towards from now (`BuildPlan.want`). Gives back its id */\n\twant(def: Want): string {\n\t\treturn this.build.want(def)\n\t}\n\n\t/**\n\t * Works on the game's build order, once a think: the first item not had (what stands, is on its way or is queued\n\t * counted; counts of a type adding up along the order) is a want before all others (`order`, priority 1000), and\n\t * `following` is true. Called by the build plan as it thinks; a module may call it sooner\n\t */\n\tfollow(): PlansReport['order'] | undefined {\n\t\tconst { ai, build } = this\n\t\tif (this.followedAt === ai.tick) return this.next\n\t\tthis.followedAt = ai.tick\n\t\tlet next: PlansReport['order'] | undefined\n\t\tconst wanted = new Map<string, number>()\n\t\tfor (let i = 0; i < this.order.length && !next; i++) {\n\t\t\tconst item = this.order[i]\n\t\t\tconst { type, count = 1 } = typeof item === 'string' ? { type: item } : item\n\t\t\tconst need = (wanted.get(type) ?? 0) + count\n\t\t\twanted.set(type, need)\n\t\t\tif (build.have(type) + build.onItsWay(type) < need) next = { type, count: need, item: i }\n\t\t}\n\t\tthis.next = next\n\t\tif (next) build.want({ id: 'order', type: next.type, count: next.count, priority: 1000, by: 'the build order' })\n\t\telse build.drop('order')\n\t\treturn next\n\t}\n\n\t/** Whether the game's build order is still being followed: what the computer would make of itself waits */\n\tget following(): boolean {\n\t\treturn this.follow() !== undefined\n\t}\n\n\t/** Takes a want out, by id */\n\tdrop(id: string): boolean {\n\t\treturn this.build.drop(id)\n\t}\n\n\t/** The purse and each plan's part, for the report */\n\treport(): PlansReport {\n\t\treturn {\n\t\t\tpurse: this.ai.purse.inspect(),\n\t\t\tbuild: this.build.report(),\n\t\t\tproduction: this.production.report(),\n\t\t\t...(this.next && { order: { ...this.next } })\n\t\t}\n\t}\n\n\t/** What the plans remember, for a save */\n\t/** Whether it has anything to remember now: one that does not is left out of a save */\n\tremembers(): boolean {\n\t\treturn true\n\t}\n\n\t/** Gives a copy of the plans' memory, for a save of the brain */\n\tsave(): PlansMemory {\n\t\tconst production = this.production.save()\n\t\treturn { v: 1, build: this.build.save(), ...(production && { production }) }\n\t}\n\n\t/** Takes back what `save` gave: whether it was read */\n\trestore(memory: unknown): boolean {\n\t\tconst given = memory as PlansMemory | undefined\n\t\tif (!given || typeof given !== 'object' || given.v !== 1) return false\n\t\tif (given.build !== undefined) this.build.restore(given.build)\n\t\tthis.production.restore(given.production)\n\t\treturn true\n\t}\n}\n\ndeclare module '#engine/ai/area' {\n\tinterface AreaMemories {\n\t\tplans?: PlansMemory\n\t}\n}\n"],"mappings":";;;;;;;;;;AA6EA,IAAa,QAAb,MAAqC;CAgB1B;;CAdV,KAAc;;CAEd,SAAkB;;CAGlB;;CAEA;CACA;CACA,aAAqB;CACrB;CAEA,YAEC,IACA,UAAwB,CAAC,GACxB;EAFQ,KAAA,KAAA;EAGT,KAAK,QAAQ,IAAI,UAAU,IAAI,QAAQ,KAAK;EAC5C,KAAK,aAAa,IAAI,eAAe,IAAI,QAAQ,UAAU;EAC3D,KAAK,QAAQ,QAAQ,SAAS,CAAC;CAChC;;CAGA,KAAK,KAAmB;EACvB,OAAO,KAAK,MAAM,KAAK,GAAG;CAC3B;;;;;;CAOA,SAA2C;EAC1C,MAAM,EAAE,IAAI,UAAU;EACtB,IAAI,KAAK,eAAe,GAAG,MAAM,OAAO,KAAK;EAC7C,KAAK,aAAa,GAAG;EACrB,IAAI;EACJ,MAAM,yBAAS,IAAI,IAAoB;EACvC,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,MAAM,UAAU,CAAC,MAAM,KAAK;GACpD,MAAM,OAAO,KAAK,MAAM;GACxB,MAAM,EAAE,MAAM,QAAQ,MAAM,OAAO,SAAS,WAAW,EAAE,MAAM,KAAK,IAAI;GACxE,MAAM,QAAQ,OAAO,IAAI,IAAI,KAAK,KAAK;GACvC,OAAO,IAAI,MAAM,IAAI;GACrB,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,SAAS,IAAI,IAAI,MAAM,OAAO;IAAE;IAAM,OAAO;IAAM,MAAM;GAAE;EACzF;EACA,KAAK,OAAO;EACZ,IAAI,MAAM,MAAM,KAAK;GAAE,IAAI;GAAS,MAAM,KAAK;GAAM,OAAO,KAAK;GAAO,UAAU;GAAM,IAAI;EAAkB,CAAC;OAC1G,MAAM,KAAK,OAAO;EACvB,OAAO;CACR;;CAGA,IAAI,YAAqB;EACxB,OAAO,KAAK,OAAO,MAAM,KAAA;CAC1B;;CAGA,KAAK,IAAqB;EACzB,OAAO,KAAK,MAAM,KAAK,EAAE;CAC1B;;CAGA,SAAsB;EACrB,OAAO;GACN,OAAO,KAAK,GAAG,MAAM,QAAQ;GAC7B,OAAO,KAAK,MAAM,OAAO;GACzB,YAAY,KAAK,WAAW,OAAO;GACnC,GAAI,KAAK,QAAQ,EAAE,OAAO,EAAE,GAAG,KAAK,KAAK,EAAE;EAC5C;CACD;;;CAIA,YAAqB;EACpB,OAAO;CACR;;CAGA,OAAoB;EACnB,MAAM,aAAa,KAAK,WAAW,KAAK;EACxC,OAAO;GAAE,GAAG;GAAG,OAAO,KAAK,MAAM,KAAK;GAAG,GAAI,cAAc,EAAE,WAAW;EAAG;CAC5E;;CAGA,QAAQ,QAA0B;EACjC,MAAM,QAAQ;EACd,IAAI,CAAC,SAAS,OAAO,UAAU,YAAY,MAAM,MAAM,GAAG,OAAO;EACjE,IAAI,MAAM,UAAU,KAAA,GAAW,KAAK,MAAM,QAAQ,MAAM,KAAK;EAC7D,KAAK,WAAW,QAAQ,MAAM,UAAU;EACxC,OAAO;CACR;AACD"}

package/dist/ai/plans/production.d.ts

@@ -1,4 +1,4 @@
-import type { UnitTypeDef, UpgradeDef } from '#engine/defs';
+import { type UnitTypeDef, type UpgradeDef } from '#engine/defs';
 import type { EntityState } from '#engine/session/protocol';
 import { type Brain } from '#engine/ai/brain';
 import { type AiModuleDef } from '#engine/ai/module';
@@ -40,7 +40,7 @@ export interface ProductionPlanOptions {
     /** How important training and research are to the purse (`Purse`): 0 when left out, under every want that saves */
     priority?: number;
     /**
-     * The tier of the game's upkeep (`GameModule.upkeep`: 0 none, 1 the first) the composition trains no further into:
+     * The tier of the game's upkeep (`Rules.upkeep`: 0 none, 1 the first) the composition trains no further into:
      * a soldier that would take the supply used past it waits, and no supply is wanted past it, unless the money would
      * lie idle (`upkeepSpare`). What is wanted outright (a wave's, a build order's) is trained all the same. `UPKEEP_TIER`
      * (1) when left out; `false` reads no upkeep
@@ -69,11 +69,17 @@ export declare const UPKEEP_SPARE = 600;
  * @beta
  */
 export interface CompositionReport {
+    /** The id of the unit type */
     type: string;
+    /** How much of the army is wanted of the type, 0..1 */
     target: number;
+    /** How many of the type the player has */
     have: number;
+    /** How much of the army it is now, 0..1 */
     share: number;
+    /** How well the type answers their army: 1 is as good as against anyone */
     counter: number;
+    /** How urgent it is to train the type next, from the target, the share and the counter */
     urge: number;
 }
 /**
@@ -83,10 +89,15 @@ export interface CompositionReport {
  * @beta
  */
 export interface ProductionPlanReport {
+    /** The unit types weighed, each with its target, share, counter and urge */
     composition: CompositionReport[];
+    /** The unit types it queued this think */
     trained: string[];
+    /** The upgrades it researched this think */
     researched: string[];
+    /** The unit wants it trains towards */
     wants: string[];
+    /** Why it did not train, or what it does, in words */
     status: string;
 }
 /**
@@ -95,6 +106,7 @@ export interface ProductionPlanReport {
  * @beta
  */
 export interface ProductionPlanMemory {
+    /** The want of supply it set: the supply building's type, how many it needs and the most it asked for */
     supply?: {
         type: string;
         need: number;

package/dist/ai/plans/production.js

@@ -0,0 +1,434 @@
+import { supplyOf } from "../../defs.js";
+import { availableToPlayer } from "../../shared.js";
+import { queueOf } from "../../systems/productionQueue.js";
+import { defineModule } from "../module.js";
+import { an } from "../geometry.js";
+//#region src/ai/plans/production.ts
+/**
+* The tier of upkeep the production plan trains no further into where its options say none (`upkeepTier`)
+*
+* @beta
+*/
+var UPKEEP_TIER = 1;
+/**
+* The money free past which the production plan reads no upkeep: what would lie idle else (`upkeepSpare`)
+*
+* @beta
+*/
+var UPKEEP_SPARE = 600;
+var QUEUE = 2;
+var SUPPLY_MARGIN = 4;
+/** The id of the build plan's want of supply */
+var SUPPLY_WANT = "production.supply";
+var RESEARCH_SPARE = 200;
+/**
+* The brain's production plan (`ai.plans.production`): what it trains and researches, by the wants of units, the
+* composition and the counters, with supply kept ahead. `train` and `research` are the primitives any module uses
+* to queue something through the purse; `think` runs the plan once a think
+*
+* @beta
+*/
+var ProductionPlan = class {
+	ai;
+	options = {};
+	thoughtAt = -1;
+	trained = [];
+	researched = [];
+	status = "new";
+	weighed = [];
+	wantedNow = [];
+	/** What the supply want was last set with (`supplyAhead`): kept in a save, for a loaded game to have it again */
+	supply;
+	constructor(ai, options = {}) {
+		this.ai = ai;
+		this.configure(options);
+	}
+	/** Takes options in, over what it had */
+	configure(options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+	}
+	/** The plan's options as they stand */
+	get settings() {
+		return this.options;
+	}
+	/** Whether the player may make a type or research an upgrade (`key`: `upgrade:<id>`), as its race and the game's `available` hook say */
+	may(def, key) {
+		const { me } = this.ai.view;
+		return availableToPlayer(def, {
+			race: me.race,
+			availability: me.availability
+		}, key);
+	}
+	/** How many of a unit type the player's buildings are training */
+	queued(type) {
+		let count = 0;
+		for (const entity of this.ai.view.mine) for (const item of queueOf(entity)) if (item.kind === "unit" && item.id === type) count++;
+		return count;
+	}
+	/**
+	* Trains a unit at a building, when it fits the supply, the queue has room and the purse allows: whether it was
+	* sent. The supply used is bumped on the view's `me` at once, so that the next call this think does not queue past
+	* the cap before the command lands. What the economy, the hero module and this plan all train through
+	*/
+	train(building, type, priority = this.options.priority ?? 0) {
+		const { ai } = this;
+		const { me } = ai.view;
+		const supply = supplyOf(type);
+		if (supply > 0 && me.supplyUsed + supply > me.supplyCap) return false;
+		if (queueOf(building).length >= (this.options.queue ?? QUEUE)) return false;
+		if (!ai.purse.affords(type.cost, 0, priority)) return false;
+		ai.purse.spend(type.cost, priority);
+		me.supplyUsed += supply;
+		ai.send({
+			type: "train",
+			building: building.id,
+			unitType: type.id
+		});
+		return true;
+	}
+	/**
+	* Researches an upgrade at a building, when it is not researching already, the building's queue has room and the
+	* purse allows with `spare` left over: whether it was sent. `me.researching` is bumped at once
+	*/
+	research(building, upgrade, spare = 0, priority = this.options.priority ?? 0) {
+		const { ai } = this;
+		const { me } = ai.view;
+		if (me.researching.includes(upgrade.id)) return false;
+		if (queueOf(building).length >= (this.options.queue ?? QUEUE)) return false;
+		if (!ai.purse.affords(upgrade.cost, spare, priority)) return false;
+		ai.purse.spend(upgrade.cost, priority);
+		me.researching.push(upgrade.id);
+		ai.send({
+			type: "research",
+			building: building.id,
+			upgrade: upgrade.id
+		});
+		return true;
+	}
+	/** Whether an upgrade can be researched now: a level left, not under way, the player's to make, what the next level requires standing */
+	researchable(upgrade) {
+		const { me } = this.ai.view;
+		const level = me.upgrades[upgrade.id] ?? 0;
+		return level < (upgrade.maxLevel ?? 1) && !me.researching.includes(upgrade.id) && this.may(upgrade, `upgrade:${upgrade.id}`) && this.ai.view.has(upgrade.requires?.[level]);
+	}
+	/** The soldier types the player can train now: at a finished building of its own, their requirements standing */
+	trainable() {
+		const { view, registry } = this.ai;
+		const types = [];
+		for (const building of view.mine.buildings().finished()) for (const id of view.def(building).trains ?? []) {
+			if (!registry.units.has(id)) continue;
+			const def = registry.unit(id);
+			if (types.includes(def) || !view.hasRole(id, "soldier") || !this.may(def, id) || !view.has(def.requires)) continue;
+			types.push(def);
+		}
+		return types;
+	}
+	/** The army's composition wanted, as given: the function asked, the data as it is */
+	composition() {
+		const { composition } = this.options;
+		return typeof composition === "function" ? composition(this.ai) : composition;
+	}
+	/**
+	* The composition as weighed this think, for the types it can train: each type's share wanted (the composition's
+	* for its id, or for a tag or role where no type has that id, split among the types that have it; even when there is no composition), its
+	* share of the soldiers now, how well it answers the enemy's army seen, and its urge: `target × (1 + counters ×
+	* (counter − 1)) − share`. The most urgent is trained first
+	*/
+	weigh() {
+		const { view } = this.ai;
+		const types = this.trainable();
+		if (!types.length) return [];
+		const composition = this.composition();
+		const weights = /* @__PURE__ */ new Map();
+		if (composition) for (const [key, share] of Object.entries(composition)) {
+			const tagged = this.ai.registry.units.has(key) ? types.filter((def) => def.id === key) : types.filter((def) => view.roles.hasTag(def.id, key) || view.roles.has(def.id, key));
+			for (const def of tagged) weights.set(def, (weights.get(def) ?? 0) + share / tagged.length);
+		}
+		let total = 0;
+		for (const def of types) total += composition ? weights.get(def) ?? 0 : 1;
+		const soldiers = view.mine.fighters().where((_, def) => !def.hero);
+		const counters = this.counters(types);
+		const pull = this.options.counters ?? 1;
+		return types.map((def) => {
+			const target = total > 0 ? (composition ? weights.get(def) ?? 0 : 1) / total : 0;
+			const have = soldiers.ofType(def.id).length;
+			const share = soldiers.length ? have / soldiers.length : 0;
+			const counter = counters.get(def.id) ?? 1;
+			return {
+				type: def.id,
+				target,
+				have,
+				share,
+				counter,
+				urge: target * (1 + pull * (counter - 1)) - share
+			};
+		});
+	}
+	/** How well each type answers the most of each enemy unit type seen at once (`Strength.counterFor`): 1 for each where nothing was seen */
+	counters(types) {
+		const { ai } = this;
+		const result = /* @__PURE__ */ new Map();
+		if (ai.def.knowledge === false) return result;
+		const seen = {};
+		for (const [type, { most }] of Object.entries(ai.knowledge.enemy.typesSeen())) if (ai.registry.units.has(type) && ai.registry.unit(type).kind === "unit") seen[type] = most;
+		if (!Object.keys(seen).length) return result;
+		for (const { def, score } of ai.view.strength.counterFor(seen, types)) result.set(def.id, score);
+		return result;
+	}
+	/** The unit wants the build plan holds that are to be trained now (their buildings up), most important first; the order's alone while it is followed */
+	wanted() {
+		const { ai } = this;
+		const build = ai.plans.build;
+		const following = ai.plans.following;
+		return build.list().filter((want) => {
+			if (following && want.id !== "order") return false;
+			if (!ai.registry.units.has(want.type) || ai.registry.unit(want.type).kind !== "unit") return false;
+			const count = typeof want.count === "function" ? want.count(ai) : want.count ?? 1;
+			return build.have(want.type) + this.queued(want.type) < count && build.next(want.type)?.how === "train" && build.next(want.type)?.type === want.type;
+		}).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+	}
+	/** The finished buildings of the player's that train a type, with room in their queue */
+	trainersOf(type) {
+		const { view } = this.ai;
+		return view.mine.buildings().finished().filter((building) => !!view.def(building).trains?.includes(type) && queueOf(building).length < (this.options.queue ?? QUEUE));
+	}
+	/**
+	* The think, once a think: the unit wants first (each at a building that trains it, as many as wanted), then the
+	* composition's most urgent type at every building with room, as the supply, the queue and the purse allow; one
+	* more of what provides supply wanted when the next does not fit; then the research
+	*/
+	think() {
+		const { ai } = this;
+		if (this.thoughtAt === ai.tick) return;
+		this.thoughtAt = ai.tick;
+		this.trained = [];
+		this.researched = [];
+		this.wantedNow = [];
+		this.weighed = [];
+		this.status = "nothing to train";
+		if (this.options.train !== false) {
+			const { me } = ai.view;
+			const priority = this.options.priority ?? 0;
+			let short;
+			let unpaid;
+			let upkept;
+			const upkeep = ai.purse.affords(void 0, this.options.upkeepSpare ?? 600, priority) ? void 0 : this.upkeepLimit();
+			const queue = (type, upTo, composition = false) => {
+				let sent = 0;
+				for (const trainer of this.trainersOf(type.id)) {
+					if (sent >= upTo) break;
+					const supply = supplyOf(type);
+					if (supply > 0 && me.supplyUsed + supply > me.supplyCap) {
+						short ??= type;
+						break;
+					}
+					if (composition && supply > 0 && upkeep !== void 0 && me.supplyUsed + supply > upkeep) {
+						upkept ??= type;
+						break;
+					}
+					if (!ai.purse.affords(type.cost, 0, priority)) {
+						unpaid ??= type;
+						break;
+					}
+					if (!this.train(trainer, type, priority)) break;
+					this.trained.push(type.id);
+					sent++;
+				}
+				return sent;
+			};
+			for (const want of this.wanted()) {
+				this.wantedNow.push(want.id);
+				const count = typeof want.count === "function" ? want.count(ai) : want.count ?? 1;
+				const type = ai.registry.unit(want.type);
+				const sent = queue(type, count - ai.plans.build.have(want.type) - this.queued(want.type));
+				if (sent) ai.decide(`trains ${sent === 1 ? an(type.id) : `${sent} ${type.id}`}: wanted${want.by ? ` by ${want.by}` : ""}`, { kind: "production" });
+			}
+			if (!ai.plans.following) {
+				this.weighed = this.weigh();
+				const ranked = this.weighed.every((entry) => entry.target <= 0) ? [] : [...this.weighed].sort((a, b) => b.urge - a.urge);
+				const pull = this.options.counters ?? 1;
+				for (const entry of ranked) {
+					if (pull > 0 && entry.counter <= 0) continue;
+					if (entry.urge <= 0 && ranked[0].urge > 0) continue;
+					const type = ai.registry.unit(entry.type);
+					const before = unpaid;
+					const sent = queue(type, Infinity, true);
+					if (sent) {
+						ai.decide(`trains ${sent === 1 ? an(type.id) : `${sent} ${type.id}`}: ${entry.counter !== 1 ? `answers their army ${entry.counter.toFixed(2)}, ` : ""}${Math.round(entry.share * 100)}% of the army for ${Math.round(entry.target * 100)}% wanted`, { kind: "production" });
+						break;
+					}
+					if (short || upkept) break;
+					if (unpaid && unpaid !== before) continue;
+				}
+			}
+			if (short) this.status = `${an(short.id)} does not fit the supply`;
+			else if (upkept) this.status = `holds at ${upkeep} supply: ${an(upkept.id)} would take it into upkeep`;
+			else if (unpaid) this.status = `waits for the money for ${an(unpaid.id)}`;
+			else if (this.trained.length) this.status = `trained ${this.trained.join(", ")}`;
+			const next = short ?? (this.weighed.length ? ai.registry.unit([...this.weighed].sort((a, b) => b.urge - a.urge)[0].type) : void 0);
+			if (this.options.supplyAhead !== false) this.supplyAhead(next, upkeep);
+		}
+		this.runResearch();
+	}
+	/**
+	* The supply used the composition trains no further than for upkeep (`upkeepTier`): where the tier after the one it
+	* may be in begins. None in a game without upkeep, past its last tier, or with `upkeepTier: false`
+	*/
+	upkeepLimit() {
+		const tier = this.options.upkeepTier ?? 1;
+		if (tier === false) return void 0;
+		return this.ai.registry.upkeep[tier]?.above;
+	}
+	/**
+	* Supply kept ahead: when the type to train next does not fit (or the free supply is under the margin), one more of
+	* the cheapest building that provides supply is wanted of the build plan, unless the cap is the game's most or one
+	* is on its way already
+	*/
+	supplyAhead(next, upkeep) {
+		const { ai } = this;
+		const { view } = ai;
+		const { me } = view;
+		const margin = this.options.supplyMargin ?? SUPPLY_MARGIN;
+		const need = (next ? supplyOf(next) : 0) + margin;
+		const most = Math.min(ai.registry.settings.supply.max, upkeep ?? Infinity);
+		if (me.supplyCap >= most || me.supplyCap - me.supplyUsed >= need) return;
+		const type = [...view.typesOf("supply")].sort((a, b) => (a.cost?.[ai.purse.money] ?? 0) - (b.cost?.[ai.purse.money] ?? 0))[0];
+		if (!type) return;
+		this.wantSupply(type.id, need, most);
+	}
+	/**
+	* One at a time: what stands finished, and one more. A standing want, with what is needed in its condition: set
+	* again whenever the need changes
+	*/
+	wantSupply(type, need, most) {
+		const { ai } = this;
+		this.supply = {
+			type,
+			need,
+			most
+		};
+		ai.plans.build.want({
+			id: SUPPLY_WANT,
+			type,
+			count: () => ai.view.mine.ofType(type).finished().length + 1,
+			priority: 90,
+			by: "supply",
+			keep: true,
+			when: () => {
+				const now = ai.view.me;
+				return now.supplyCap < most && now.supplyCap - now.supplyUsed < need;
+			}
+		});
+	}
+	/** What it remembers, for a save: what the supply want was set with, while it stands */
+	save() {
+		const { supply } = this;
+		if (!supply || !this.ai.plans.build.get(SUPPLY_WANT)) return void 0;
+		return { supply: {
+			type: supply.type,
+			need: supply.need,
+			...Number.isFinite(supply.most) && { most: supply.most }
+		} };
+	}
+	/**
+	* Takes back what `save` gave, after the build plan's: the supply want is had again at once, before the first think,
+	* as the game saved from has it (the module sets it again only when supply runs short, after the build plan thinks)
+	*/
+	restore(memory) {
+		const supply = memory?.supply;
+		this.supply = void 0;
+		if (!supply || typeof supply.type !== "string" || !this.ai.registry.units.has(supply.type)) return;
+		this.wantSupply(supply.type, supply.need, supply.most ?? Infinity);
+	}
+	/**
+	* The upgrade to research next: the first of the list it can (`research` as a list), what the function gives, or,
+	* left to itself, the one the most of its units benefit from (`UpgradeEffect.units`), ties as the game lists them
+	*/
+	nextResearch() {
+		const { ai } = this;
+		const { view, registry } = ai;
+		const { research } = this.options;
+		if (typeof research === "function") {
+			const id = research(ai);
+			return id !== void 0 && registry.upgrades.has(id) && this.researchable(registry.upgrade(id)) ? registry.upgrade(id) : void 0;
+		}
+		const offered = [];
+		for (const building of view.mine.buildings().finished()) for (const id of view.def(building).researches ?? []) {
+			if (!registry.upgrades.has(id)) continue;
+			const def = registry.upgrade(id);
+			if (!offered.includes(def) && this.researchable(def)) offered.push(def);
+		}
+		if (research) {
+			for (const id of research) {
+				const found = offered.find((def) => def.id === id);
+				if (found) return found;
+			}
+			return;
+		}
+		let best;
+		let most = -1;
+		for (const def of offered) {
+			const benefits = view.mine.units().filter((unit) => def.effects.some((effect) => effectApplies(effect.units, view.def(unit)))).length;
+			if (benefits > most) {
+				most = benefits;
+				best = def;
+			}
+		}
+		return best;
+	}
+	/** Research, with money to spare: the next upgrade at a finished building of the player's that researches it */
+	runResearch() {
+		const { ai } = this;
+		const { view } = ai;
+		const next = this.nextResearch();
+		if (!next) return;
+		const at = view.mine.buildings().finished().find((building) => !!view.def(building).researches?.includes(next.id) && queueOf(building).length < (this.options.queue ?? QUEUE));
+		if (!at) return;
+		if (this.research(at, next, this.options.researchSpare ?? RESEARCH_SPARE)) {
+			this.researched.push(next.id);
+			ai.decide(`researches ${next.id}: money to spare`, { kind: "research" });
+		}
+	}
+	/** The composition as weighed, what was trained and researched this think, the wants trained towards, and the status */
+	report() {
+		return {
+			composition: this.weighed.map((entry) => ({ ...entry })),
+			trained: [...this.trained],
+			researched: [...this.researched],
+			wants: [...this.wantedNow],
+			status: this.status
+		};
+	}
+};
+/** Whether an upgrade's effect applies to a unit type: everything the player owns when it names none */
+function effectApplies(units, def) {
+	if (!units) return true;
+	if (typeof units === "function") return units(def);
+	return units.includes(def.id);
+}
+/**
+* The production module: runs the brain's production plan (`ai.plans.production.think()`) in its place among a
+* brain's modules, after the build plan (which puts up what a want needs) where a brain has both. With options for
+* the plan
+*
+* @beta
+*/
+var production = (options = {}) => defineModule({
+	id: "production",
+	make: (ai) => {
+		ai.plans.production.configure(options);
+		return {
+			id: "production",
+			phase: "plan",
+			after: ["build"],
+			think: () => ai.plans.production.think()
+		};
+	}
+});
+//#endregion
+export { ProductionPlan, UPKEEP_SPARE, UPKEEP_TIER, production };
+
+//# sourceMappingURL=production.js.map

package/dist/ai/plans/production.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"production.js","names":[],"sources":["../../../src/ai/plans/production.ts"],"sourcesContent":["import { supplyOf, type UnitTypeDef, type UpgradeDef } from '#engine/defs'\nimport { queueOf } from '#engine/systems/productionQueue'\nimport type { EntityState } from '#engine/session/protocol'\nimport { availableToPlayer } from '#engine/shared'\nimport { type Brain } from '#engine/ai/brain'\nimport { type AiModule, type AiModuleDef, defineModule } from '#engine/ai/module'\nimport type { Want } from './build'\nimport { an } from '../geometry'\n\n/*\n * The production plan (AI plan, B3): what a computer player trains and researches. The old melee player trained, at\n * each barracks, \"whatever answers their army best, then whatever there is the least of\", and researched \"whatever is\n * first with gold to spare\". The plan keeps a **composition** instead: the army it wants, as shares by unit type or\n * tag (`{ footman: 2, rifleman: 1 }`, `{ ranged: 1, melee: 1 }`), from the brain's definition, the seat's options, the\n * profile (D1) and the waves (D2) as those land; what is trained is what is furthest under its share, with what\n * answers the enemy's army seen (`Strength.counterFor`, A4) pulling the shares about: a type that cannot hit what\n * they field is not trained while they field it. **Wants** of units (`ai.plans.want({ type: 'gryphon', count: 4 })`)\n * come before the composition: the build plan puts their buildings up, this plan trains them. It trains at every\n * building that trains, as the queue length and the purse allow, and keeps **supply ahead**: when what it would train\n * next does not fit, it wants one more of the cheapest building that provides supply. **Research** goes by a ranked\n * list (`research: ['swords', ...]`, or a function giving the next), or, left to itself, by what the army it has uses\n * most, with money to spare. **Upkeep** (`Rules.upkeep`) is read: the composition trains no further into a tier\n * of upkeep than `upkeepTier` says, unless the money would lie idle (`upkeepSpare`), and no supply is wanted past it.\n * Nothing here is of one game: the types come from the roles and the definitions\n */\n\n/**\n * The army a computer player wants, as shares by unit type id or tag (the kit's `ranged`, `melee`, `hitsAir`, a\n * game's own): `{ footman: 2, rifleman: 1 }` is two footmen to a rifleman. A tag's share is split among the types\n * that have it; a type named gets its own beside. Types it cannot train yet are left out until it can\n *\n * @beta\n */\nexport type Composition = Record<string, number>\n\n/**\n * How the production plan goes about it (`BrainDef.plans.production`, the `production()` module; the data of it in\n * `AiOptions.composition` and `research`)\n *\n * @beta\n */\nexport interface ProductionPlanOptions {\n\t/** The army it wants (`Composition`), or a function of the brain giving it. Even shares of every soldier type it can train when left out */\n\tcomposition?: Composition | ((ai: Brain) => Composition)\n\t/**\n\t * How much what answers the enemy's army seen pulls the shares about: 0 not at all, 1 (left out) as much as a\n\t * share; a type that cannot hit what they field is not trained while they field it\n\t */\n\tcounters?: number\n\t/** Whether it trains soldiers at all: yes when left out. Workers and heroes are the economy's and the hero module's */\n\ttrain?: boolean\n\t/** How many may queue at one building: 2 when left out */\n\tqueue?: number\n\t/** Whether to want one more of what provides supply when what it would train next does not fit: yes when left out */\n\tsupplyAhead?: boolean\n\t/** Supply to keep free beyond the next unit's, so that the farm is up before it is needed: 4 when left out */\n\tsupplyMargin?: number\n\t/** Upgrades to research, in order, by id (the first it can is next), or a function of the brain giving the next; what the army it has uses most when left out */\n\tresearch?: string[] | ((ai: Brain) => string | undefined)\n\t/** Money to have left over before researching: 200 when left out (research is a luxury) */\n\tresearchSpare?: number\n\t/** How important training and research are to the purse (`Purse`): 0 when left out, under every want that saves */\n\tpriority?: number\n\t/**\n\t * The tier of the game's upkeep (`Rules.upkeep`: 0 none, 1 the first) the composition trains no further into:\n\t * a soldier that would take the supply used past it waits, and no supply is wanted past it, unless the money would\n\t * lie idle (`upkeepSpare`). What is wanted outright (a wave's, a build order's) is trained all the same. `UPKEEP_TIER`\n\t * (1) when left out; `false` reads no upkeep\n\t */\n\tupkeepTier?: number | false\n\t/** Money free past which upkeep is not read (it would lie idle else): `UPKEEP_SPARE` (600) when left out */\n\tupkeepSpare?: number\n}\n\n/**\n * The tier of upkeep the production plan trains no further into where its options say none (`upkeepTier`)\n *\n * @beta\n */\nexport const UPKEEP_TIER = 1\n\n/**\n * The money free past which the production plan reads no upkeep: what would lie idle else (`upkeepSpare`)\n *\n * @beta\n */\nexport const UPKEEP_SPARE = 600\n\n/**\n * One type as the production plan weighs it, for the report: its share of the army wanted (`target`, 0..1), its share\n * now (`share`), how well it answers their army (`counter`: 1 is as good as against anyone), and what the two come\n * to (`urge`: the most urgent is trained next)\n *\n * @beta\n */\nexport interface CompositionReport {\n\t/** The id of the unit type */\n\ttype: string\n\t/** How much of the army is wanted of the type, 0..1 */\n\ttarget: number\n\t/** How many of the type the player has */\n\thave: number\n\t/** How much of the army it is now, 0..1 */\n\tshare: number\n\t/** How well the type answers their army: 1 is as good as against anyone */\n\tcounter: number\n\t/** How urgent it is to train the type next, from the target, the share and the counter */\n\turge: number\n}\n\n/**\n * The production plan as the report shows it: the composition as weighed, what it trained and researched this\n * think, the unit wants it trains towards, and why it did not train where it did not\n *\n * @beta\n */\nexport interface ProductionPlanReport {\n\t/** The unit types weighed, each with its target, share, counter and urge */\n\tcomposition: CompositionReport[]\n\t/** The unit types it queued this think */\n\ttrained: string[]\n\t/** The upgrades it researched this think */\n\tresearched: string[]\n\t/** The unit wants it trains towards */\n\twants: string[]\n\t/** Why it did not train, or what it does, in words */\n\tstatus: string\n}\n\nconst QUEUE = 2\nconst SUPPLY_MARGIN = 4\n/** The id of the build plan's want of supply */\nconst SUPPLY_WANT = 'production.supply'\nconst RESEARCH_SPARE = 200\n\n/**\n * What the production plan remembers between thinks, for a save: what its want of supply was set with\n *\n * @beta\n */\nexport interface ProductionPlanMemory {\n\t/** The want of supply it set: the supply building's type, how many it needs and the most it asked for */\n\tsupply?: { type: string; need: number; most?: number }\n}\n\n/**\n * The brain's production plan (`ai.plans.production`): what it trains and researches, by the wants of units, the\n * composition and the counters, with supply kept ahead. `train` and `research` are the primitives any module uses\n * to queue something through the purse; `think` runs the plan once a think\n *\n * @beta\n */\nexport class ProductionPlan {\n\tprivate options: ProductionPlanOptions = {}\n\tprivate thoughtAt = -1\n\tprivate trained: string[] = []\n\tprivate researched: string[] = []\n\tprivate status = 'new'\n\tprivate weighed: CompositionReport[] = []\n\tprivate wantedNow: string[] = []\n\t/** What the supply want was last set with (`supplyAhead`): kept in a save, for a loaded game to have it again */\n\tprivate supply: { type: string; need: number; most: number } | undefined\n\n\tconstructor(\n\t\t/** The brain it plans for */\n\t\treadonly ai: Brain,\n\t\toptions: ProductionPlanOptions = {}\n\t) {\n\t\tthis.configure(options)\n\t}\n\n\t/** Takes options in, over what it had */\n\tconfigure(options: ProductionPlanOptions): void {\n\t\tthis.options = { ...this.options, ...options }\n\t}\n\n\t/** The plan's options as they stand */\n\tget settings(): Readonly<ProductionPlanOptions> {\n\t\treturn this.options\n\t}\n\n\t/** Whether the player may make a type or research an upgrade (`key`: `upgrade:<id>`), as its race and the game's `available` hook say */\n\tprivate may(def: { readonly race?: string }, key: string): boolean {\n\t\tconst { me } = this.ai.view\n\t\treturn availableToPlayer(def, { race: me.race, availability: me.availability }, key)\n\t}\n\n\t/** How many of a unit type the player's buildings are training */\n\tqueued(type: string): number {\n\t\tlet count = 0\n\t\tfor (const entity of this.ai.view.mine) for (const item of queueOf(entity)) if (item.kind === 'unit' && item.id === type) count++\n\t\treturn count\n\t}\n\n\t/**\n\t * Trains a unit at a building, when it fits the supply, the queue has room and the purse allows: whether it was\n\t * sent. The supply used is bumped on the view's `me` at once, so that the next call this think does not queue past\n\t * the cap before the command lands. What the economy, the hero module and this plan all train through\n\t */\n\ttrain(building: EntityState, type: UnitTypeDef, priority = this.options.priority ?? 0): boolean {\n\t\tconst { ai } = this\n\t\tconst { me } = ai.view\n\t\tconst supply = supplyOf(type)\n\t\tif (supply > 0 && me.supplyUsed + supply > me.supplyCap) return false\n\t\tif (queueOf(building).length >= (this.options.queue ?? QUEUE)) return false\n\t\tif (!ai.purse.affords(type.cost, 0, priority)) return false\n\t\tai.purse.spend(type.cost, priority)\n\t\tme.supplyUsed += supply\n\t\tai.send({ type: 'train', building: building.id, unitType: type.id })\n\t\treturn true\n\t}\n\n\t/**\n\t * Researches an upgrade at a building, when it is not researching already, the building's queue has room and the\n\t * purse allows with `spare` left over: whether it was sent. `me.researching` is bumped at once\n\t */\n\tresearch(building: EntityState, upgrade: UpgradeDef, spare = 0, priority = this.options.priority ?? 0): boolean {\n\t\tconst { ai } = this\n\t\tconst { me } = ai.view\n\t\tif (me.researching.includes(upgrade.id)) return false\n\t\tif (queueOf(building).length >= (this.options.queue ?? QUEUE)) return false\n\t\tif (!ai.purse.affords(upgrade.cost, spare, priority)) return false\n\t\tai.purse.spend(upgrade.cost, priority)\n\t\tme.researching.push(upgrade.id)\n\t\tai.send({ type: 'research', building: building.id, upgrade: upgrade.id })\n\t\treturn true\n\t}\n\n\t/** Whether an upgrade can be researched now: a level left, not under way, the player's to make, what the next level requires standing */\n\tresearchable(upgrade: UpgradeDef): boolean {\n\t\tconst { me } = this.ai.view\n\t\tconst level = me.upgrades[upgrade.id] ?? 0\n\t\treturn (\n\t\t\tlevel < (upgrade.maxLevel ?? 1) &&\n\t\t\t!me.researching.includes(upgrade.id) &&\n\t\t\tthis.may(upgrade, `upgrade:${upgrade.id}`) &&\n\t\t\tthis.ai.view.has(upgrade.requires?.[level])\n\t\t)\n\t}\n\n\t/** The soldier types the player can train now: at a finished building of its own, their requirements standing */\n\ttrainable(): UnitTypeDef[] {\n\t\tconst { view, registry } = this.ai\n\t\tconst types: UnitTypeDef[] = []\n\t\tfor (const building of view.mine.buildings().finished()) {\n\t\t\tfor (const id of view.def(building).trains ?? []) {\n\t\t\t\tif (!registry.units.has(id)) continue\n\t\t\t\tconst def = registry.unit(id)\n\t\t\t\tif (types.includes(def) || !view.hasRole(id, 'soldier') || !this.may(def, id) || !view.has(def.requires)) continue\n\t\t\t\ttypes.push(def)\n\t\t\t}\n\t\t}\n\t\treturn types\n\t}\n\n\t/** The army's composition wanted, as given: the function asked, the data as it is */\n\tprivate composition(): Composition | undefined {\n\t\tconst { composition } = this.options\n\t\treturn typeof composition === 'function' ? composition(this.ai) : composition\n\t}\n\n\t/**\n\t * The composition as weighed this think, for the types it can train: each type's share wanted (the composition's\n\t * for its id, or for a tag or role where no type has that id, split among the types that have it; even when there is no composition), its\n\t * share of the soldiers now, how well it answers the enemy's army seen, and its urge: `target × (1 + counters ×\n\t * (counter − 1)) − share`. The most urgent is trained first\n\t */\n\tweigh(): CompositionReport[] {\n\t\tconst { view } = this.ai\n\t\tconst types = this.trainable()\n\t\tif (!types.length) return []\n\t\tconst composition = this.composition()\n\t\tconst weights = new Map<UnitTypeDef, number>()\n\t\tif (composition) {\n\t\t\tfor (const [key, share] of Object.entries(composition)) {\n\t\t\t\t// a key is a type's id first (the fixture's `soldier` is a type and a role): a tag or a role only where no type has the id\n\t\t\t\tconst tagged = this.ai.registry.units.has(key)\n\t\t\t\t\t? types.filter((def) => def.id === key)\n\t\t\t\t\t: types.filter((def) => view.roles.hasTag(def.id, key) || view.roles.has(def.id, key))\n\t\t\t\tfor (const def of tagged) weights.set(def, (weights.get(def) ?? 0) + share / tagged.length)\n\t\t\t}\n\t\t}\n\t\tlet total = 0\n\t\tfor (const def of types) total += composition ? (weights.get(def) ?? 0) : 1\n\t\tconst soldiers = view.mine.fighters().where((_, def) => !def.hero)\n\t\tconst counters = this.counters(types)\n\t\tconst pull = this.options.counters ?? 1\n\t\treturn types.map((def) => {\n\t\t\tconst target = total > 0 ? (composition ? (weights.get(def) ?? 0) : 1) / total : 0\n\t\t\tconst have = soldiers.ofType(def.id).length\n\t\t\tconst share = soldiers.length ? have / soldiers.length : 0\n\t\t\tconst counter = counters.get(def.id) ?? 1\n\t\t\treturn { type: def.id, target, have, share, counter, urge: target * (1 + pull * (counter - 1)) - share }\n\t\t})\n\t}\n\n\t/** How well each type answers the most of each enemy unit type seen at once (`Strength.counterFor`): 1 for each where nothing was seen */\n\tprivate counters(types: UnitTypeDef[]): Map<string, number> {\n\t\tconst { ai } = this\n\t\tconst result = new Map<string, number>()\n\t\tif (ai.def.knowledge === false) return result\n\t\tconst seen: Record<string, number> = {}\n\t\tfor (const [type, { most }] of Object.entries(ai.knowledge.enemy.typesSeen()))\n\t\t\tif (ai.registry.units.has(type) && ai.registry.unit(type).kind === 'unit') seen[type] = most\n\t\tif (!Object.keys(seen).length) return result\n\t\tfor (const { def, score } of ai.view.strength.counterFor(seen, types)) result.set(def.id, score)\n\t\treturn result\n\t}\n\n\t/** The unit wants the build plan holds that are to be trained now (their buildings up), most important first; the order's alone while it is followed */\n\twanted(): Want[] {\n\t\tconst { ai } = this\n\t\tconst build = ai.plans.build\n\t\tconst following = ai.plans.following\n\t\treturn build\n\t\t\t.list()\n\t\t\t.filter((want) => {\n\t\t\t\tif (following && want.id !== 'order') return false\n\t\t\t\tif (!ai.registry.units.has(want.type) || ai.registry.unit(want.type).kind !== 'unit') return false\n\t\t\t\tconst count = typeof want.count === 'function' ? want.count(ai) : (want.count ?? 1)\n\t\t\t\treturn (\n\t\t\t\t\tbuild.have(want.type) + this.queued(want.type) < count &&\n\t\t\t\t\tbuild.next(want.type)?.how === 'train' &&\n\t\t\t\t\tbuild.next(want.type)?.type === want.type\n\t\t\t\t)\n\t\t\t})\n\t\t\t.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0))\n\t}\n\n\t/** The finished buildings of the player's that train a type, with room in their queue */\n\tprivate trainersOf(type: string): EntityState[] {\n\t\tconst { view } = this.ai\n\t\treturn view.mine\n\t\t\t.buildings()\n\t\t\t.finished()\n\t\t\t.filter((building) => !!view.def(building).trains?.includes(type) && queueOf(building).length < (this.options.queue ?? QUEUE))\n\t}\n\n\t/**\n\t * The think, once a think: the unit wants first (each at a building that trains it, as many as wanted), then the\n\t * composition's most urgent type at every building with room, as the supply, the queue and the purse allow; one\n\t * more of what provides supply wanted when the next does not fit; then the research\n\t */\n\tthink(): void {\n\t\tconst { ai } = this\n\t\tif (this.thoughtAt === ai.tick) return\n\t\tthis.thoughtAt = ai.tick\n\t\tthis.trained = []\n\t\tthis.researched = []\n\t\tthis.wantedNow = []\n\t\tthis.weighed = []\n\t\tthis.status = 'nothing to train'\n\t\tif (this.options.train !== false) {\n\t\t\tconst { me } = ai.view\n\t\t\tconst priority = this.options.priority ?? 0\n\t\t\tlet short: UnitTypeDef | undefined\n\t\t\tlet unpaid: UnitTypeDef | undefined\n\t\t\tlet upkept: UnitTypeDef | undefined\n\t\t\t// the upkeep it holds at, while the money would not lie idle past it\n\t\t\tconst upkeep = ai.purse.affords(undefined, this.options.upkeepSpare ?? UPKEEP_SPARE, priority) ? undefined : this.upkeepLimit()\n\t\t\tconst queue = (type: UnitTypeDef, upTo: number, composition = false) => {\n\t\t\t\tlet sent = 0\n\t\t\t\tfor (const trainer of this.trainersOf(type.id)) {\n\t\t\t\t\tif (sent >= upTo) break\n\t\t\t\t\tconst supply = supplyOf(type)\n\t\t\t\t\tif (supply > 0 && me.supplyUsed + supply > me.supplyCap) {\n\t\t\t\t\t\tshort ??= type\n\t\t\t\t\t\tbreak\n\t\t\t\t\t}\n\t\t\t\t\t// the composition's soldiers go no further into upkeep than told\n\t\t\t\t\tif (composition && supply > 0 && upkeep !== undefined && me.supplyUsed + supply > upkeep) {\n\t\t\t\t\t\tupkept ??= type\n\t\t\t\t\t\tbreak\n\t\t\t\t\t}\n\t\t\t\t\tif (!ai.purse.affords(type.cost, 0, priority)) {\n\t\t\t\t\t\tunpaid ??= type\n\t\t\t\t\t\tbreak\n\t\t\t\t\t}\n\t\t\t\t\tif (!this.train(trainer, type, priority)) break\n\t\t\t\t\tthis.trained.push(type.id)\n\t\t\t\t\tsent++\n\t\t\t\t}\n\t\t\t\treturn sent\n\t\t\t}\n\t\t\t// what is wanted outright, most important first\n\t\t\tfor (const want of this.wanted()) {\n\t\t\t\tthis.wantedNow.push(want.id!)\n\t\t\t\tconst count = typeof want.count === 'function' ? want.count(ai) : (want.count ?? 1)\n\t\t\t\tconst type = ai.registry.unit(want.type)\n\t\t\t\tconst sent = queue(type, count - ai.plans.build.have(want.type) - this.queued(want.type))\n\t\t\t\tif (sent)\n\t\t\t\t\tai.decide(`trains ${sent === 1 ? an(type.id) : `${sent} ${type.id}`}: wanted${want.by ? ` by ${want.by}` : ''}`, { kind: 'production' })\n\t\t\t}\n\t\t\t// then the army as the composition wants it, the most urgent type at each building with room, while the\n\t\t\t// order is not being followed (what the game says to make first holds back what the computer would make)\n\t\t\tif (!ai.plans.following) {\n\t\t\t\tthis.weighed = this.weigh()\n\t\t\t\t// a composition that wants nothing (`{}`: the waves', D2, whose groups are wanted outright) trains nothing\n\t\t\t\tconst empty = this.weighed.every((entry) => entry.target <= 0)\n\t\t\t\tconst ranked = empty ? [] : [...this.weighed].sort((a, b) => b.urge - a.urge)\n\t\t\t\tconst pull = this.options.counters ?? 1\n\t\t\t\tfor (const entry of ranked) {\n\t\t\t\t\t// what cannot hit what they field is not trained while they field it (where the counters count); what\n\t\t\t\t\t// is over its share waits while something is under its own\n\t\t\t\t\tif (pull > 0 && entry.counter <= 0) continue\n\t\t\t\t\tif (entry.urge <= 0 && ranked[0].urge > 0) continue\n\t\t\t\t\tconst type = ai.registry.unit(entry.type)\n\t\t\t\t\tconst before = unpaid\n\t\t\t\t\tconst sent = queue(type, Infinity, true)\n\t\t\t\t\tif (sent) {\n\t\t\t\t\t\tai.decide(\n\t\t\t\t\t\t\t`trains ${sent === 1 ? an(type.id) : `${sent} ${type.id}`}: ${entry.counter !== 1 ? `answers their army ${entry.counter.toFixed(2)}, ` : ''}${Math.round(entry.share * 100)}% of the army for ${Math.round(entry.target * 100)}% wanted`,\n\t\t\t\t\t\t\t{ kind: 'production' }\n\t\t\t\t\t\t)\n\t\t\t\t\t\t// what was sent changes the shares: the next type is weighed anew next think\n\t\t\t\t\t\tbreak\n\t\t\t\t\t}\n\t\t\t\t\t// nothing fits the supply: nothing else will; one it cannot pay for: the next it can may go, so that\n\t\t\t\t\t// an army is raised while the dearer type waits for its resource\n\t\t\t\t\tif (short || upkept) break\n\t\t\t\t\tif (unpaid && unpaid !== before) continue\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (short) this.status = `${an(short.id)} does not fit the supply`\n\t\t\telse if (upkept) this.status = `holds at ${upkeep} supply: ${an(upkept.id)} would take it into upkeep`\n\t\t\telse if (unpaid) this.status = `waits for the money for ${an(unpaid.id)}`\n\t\t\telse if (this.trained.length) this.status = `trained ${this.trained.join(', ')}`\n\t\t\t// supply ahead of what comes next: what did not fit, else the most urgent\n\t\t\tconst next = short ?? (this.weighed.length ? ai.registry.unit([...this.weighed].sort((a, b) => b.urge - a.urge)[0].type) : undefined)\n\t\t\tif (this.options.supplyAhead !== false) this.supplyAhead(next, upkeep)\n\t\t}\n\t\tthis.runResearch()\n\t}\n\n\t/**\n\t * The supply used the composition trains no further than for upkeep (`upkeepTier`): where the tier after the one it\n\t * may be in begins. None in a game without upkeep, past its last tier, or with `upkeepTier: false`\n\t */\n\tupkeepLimit(): number | undefined {\n\t\tconst tier = this.options.upkeepTier ?? UPKEEP_TIER\n\t\tif (tier === false) return undefined\n\t\treturn this.ai.registry.upkeep[tier]?.above\n\t}\n\n\t/**\n\t * Supply kept ahead: when the type to train next does not fit (or the free supply is under the margin), one more of\n\t * the cheapest building that provides supply is wanted of the build plan, unless the cap is the game's most or one\n\t * is on its way already\n\t */\n\tprivate supplyAhead(next: UnitTypeDef | undefined, upkeep?: number): void {\n\t\tconst { ai } = this\n\t\tconst { view } = ai\n\t\tconst { me } = view\n\t\tconst margin = this.options.supplyMargin ?? SUPPLY_MARGIN\n\t\tconst need = (next ? supplyOf(next) : 0) + margin\n\t\t// no further than the upkeep it holds at: the margin up to it, not past\n\t\tconst most = Math.min(ai.registry.settings.supply.max, upkeep ?? Infinity)\n\t\tif (me.supplyCap >= most || me.supplyCap - me.supplyUsed >= need) return\n\t\tconst types = [...view.typesOf('supply')].sort((a, b) => (a.cost?.[ai.purse.money] ?? 0) - (b.cost?.[ai.purse.money] ?? 0))\n\t\tconst type = types[0]\n\t\tif (!type) return\n\t\tthis.wantSupply(type.id, need, most)\n\t}\n\n\t/**\n\t * One at a time: what stands finished, and one more. A standing want, with what is needed in its condition: set\n\t * again whenever the need changes\n\t */\n\tprivate wantSupply(type: string, need: number, most: number): void {\n\t\tconst { ai } = this\n\t\tthis.supply = { type, need, most }\n\t\tai.plans.build.want({\n\t\t\tid: SUPPLY_WANT,\n\t\t\ttype,\n\t\t\tcount: () => ai.view.mine.ofType(type).finished().length + 1,\n\t\t\tpriority: 90,\n\t\t\tby: 'supply',\n\t\t\tkeep: true,\n\t\t\twhen: () => {\n\t\t\t\tconst now = ai.view.me\n\t\t\t\treturn now.supplyCap < most && now.supplyCap - now.supplyUsed < need\n\t\t\t}\n\t\t})\n\t}\n\n\t/** What it remembers, for a save: what the supply want was set with, while it stands */\n\tsave(): ProductionPlanMemory | undefined {\n\t\tconst { supply } = this\n\t\tif (!supply || !this.ai.plans.build.get(SUPPLY_WANT)) return undefined\n\t\t// no most but the game's (one without one): Infinity, which a save does not hold\n\t\treturn { supply: { type: supply.type, need: supply.need, ...(Number.isFinite(supply.most) && { most: supply.most }) } }\n\t}\n\n\t/**\n\t * Takes back what `save` gave, after the build plan's: the supply want is had again at once, before the first think,\n\t * as the game saved from has it (the module sets it again only when supply runs short, after the build plan thinks)\n\t */\n\trestore(memory: ProductionPlanMemory | undefined): void {\n\t\tconst supply = memory?.supply\n\t\tthis.supply = undefined\n\t\tif (!supply || typeof supply.type !== 'string' || !this.ai.registry.units.has(supply.type)) return\n\t\tthis.wantSupply(supply.type, supply.need, supply.most ?? Infinity)\n\t}\n\n\t/**\n\t * The upgrade to research next: the first of the list it can (`research` as a list), what the function gives, or,\n\t * left to itself, the one the most of its units benefit from (`UpgradeEffect.units`), ties as the game lists them\n\t */\n\tnextResearch(): UpgradeDef | undefined {\n\t\tconst { ai } = this\n\t\tconst { view, registry } = ai\n\t\tconst { research } = this.options\n\t\tif (typeof research === 'function') {\n\t\t\tconst id = research(ai)\n\t\t\treturn id !== undefined && registry.upgrades.has(id) && this.researchable(registry.upgrade(id)) ? registry.upgrade(id) : undefined\n\t\t}\n\t\tconst offered: UpgradeDef[] = []\n\t\tfor (const building of view.mine.buildings().finished()) {\n\t\t\tfor (const id of view.def(building).researches ?? []) {\n\t\t\t\tif (!registry.upgrades.has(id)) continue\n\t\t\t\tconst def = registry.upgrade(id)\n\t\t\t\tif (!offered.includes(def) && this.researchable(def)) offered.push(def)\n\t\t\t}\n\t\t}\n\t\tif (research) {\n\t\t\tfor (const id of research) {\n\t\t\t\tconst found = offered.find((def) => def.id === id)\n\t\t\t\tif (found) return found\n\t\t\t}\n\t\t\treturn undefined\n\t\t}\n\t\tlet best: UpgradeDef | undefined\n\t\tlet most = -1\n\t\tfor (const def of offered) {\n\t\t\tconst benefits = view.mine.units().filter((unit) => def.effects.some((effect) => effectApplies(effect.units, view.def(unit)))).length\n\t\t\tif (benefits > most) {\n\t\t\t\tmost = benefits\n\t\t\t\tbest = def\n\t\t\t}\n\t\t}\n\t\treturn best\n\t}\n\n\t/** Research, with money to spare: the next upgrade at a finished building of the player's that researches it */\n\tprivate runResearch(): void {\n\t\tconst { ai } = this\n\t\tconst { view } = ai\n\t\tconst next = this.nextResearch()\n\t\tif (!next) return\n\t\tconst at = view.mine\n\t\t\t.buildings()\n\t\t\t.finished()\n\t\t\t.find((building) => !!view.def(building).researches?.includes(next.id) && queueOf(building).length < (this.options.queue ?? QUEUE))\n\t\tif (!at) return\n\t\tif (this.research(at, next, this.options.researchSpare ?? RESEARCH_SPARE)) {\n\t\t\tthis.researched.push(next.id)\n\t\t\tai.decide(`researches ${next.id}: money to spare`, { kind: 'research' })\n\t\t}\n\t}\n\n\t/** The composition as weighed, what was trained and researched this think, the wants trained towards, and the status */\n\treport(): ProductionPlanReport {\n\t\treturn {\n\t\t\tcomposition: this.weighed.map((entry) => ({ ...entry })),\n\t\t\ttrained: [...this.trained],\n\t\t\tresearched: [...this.researched],\n\t\t\twants: [...this.wantedNow],\n\t\t\tstatus: this.status\n\t\t}\n\t}\n}\n\n/** Whether an upgrade's effect applies to a unit type: everything the player owns when it names none */\nfunction effectApplies(units: string[] | ((def: UnitTypeDef) => boolean) | undefined, def: UnitTypeDef): boolean {\n\tif (!units) return true\n\tif (typeof units === 'function') return units(def)\n\treturn units.includes(def.id)\n}\n\n/**\n * The production module: runs the brain's production plan (`ai.plans.production.think()`) in its place among a\n * brain's modules, after the build plan (which puts up what a want needs) where a brain has both. With options for\n * the plan\n *\n * @beta\n */\nexport const production = (options: ProductionPlanOptions = {}): AiModuleDef =>\n\tdefineModule({ id: 'production', make: (ai: Brain): AiModule => {\n\t\tai.plans.production.configure(options)\n\t\treturn {\n\t\t\tid: 'production',\n\t\t\tphase: 'plan',\n\t\t\tafter: ['build'],\n\t\t\tthink: () => ai.plans.production.think()\n\t\t}\n\t} })\n"],"mappings":"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"}

package/dist/ai/plans/purse.d.ts

@@ -1,4 +1,4 @@
-import type { Cost, ResourceKind } from '#engine/defs';
+import type { Cost, ResourceId } from '#engine/defs';
 import type { Registry } from '#engine/registry';
 import type { AiView } from '#engine/ai/view';
 /**
@@ -15,7 +15,7 @@ export declare class Purse {
     /** What was paid this think (`spend`), by resource: with `promised`, never more than the picture's resources (`ai/checks.ts`) */
     spent: Cost;
     /** The resource most things cost (`Registry.currency`): what `affords` keeps `spare` of */
-    readonly money: ResourceKind;
+    readonly money: ResourceId;
     private holds;
     constructor(registry: Registry);
     /**
@@ -26,7 +26,7 @@ export declare class Purse {
     /** What someone this important may spend: what is free, and what is held by anyone less important */
     available(priority?: number): Cost;
     /** The resource a cost is short of, out of what someone this important may spend: none when it can be paid */
-    shortOf(cost: Cost | undefined, priority?: number): ResourceKind | undefined;
+    shortOf(cost: Cost | undefined, priority?: number): ResourceId | undefined;
     /**
      * Whether a cost can be paid by someone this important, with `spare` of the money left over after it (a luxury
      * waits for gold to spare): out of what is free, and what is held by anyone less important
@@ -64,8 +64,11 @@ export declare class Purse {
  * @beta
  */
 export interface PurseReport {
+    /** What the player has that nothing holds or has promised */
     free: Cost;
+    /** What builders on their way will pay */
     promised: Cost;
+    /** What is held, by the id of the holder, with its cost and how important the holder is */
     held: Record<string, {
         cost: Cost;
         priority: number;