@v12-engine/engine 0.1.0 → 0.4.0

package/dist/ai/economy.js

@@ -0,0 +1,780 @@
+import { distSq } from "../math.js";
+import { baseStats, constructionOf } from "../defs.js";
+import { snapshotOf } from "../components.js";
+import { builtSoFar } from "../systems/construction.js";
+import { gathers } from "../shared.js";
+import { queueOf } from "../systems/productionQueue.js";
+import { gathering } from "../orders/harvest.js";
+import { defineModule } from "./module.js";
+import "./reach.js";
+import { evaluate } from "./rules.js";
+import { pair, point, where } from "./geometry.js";
+//#region src/ai/economy.ts
+/** A point so far from a place on the way to another */
+function towards(from, to, distance) {
+	const length = Math.sqrt(distSq(from, to));
+	if (length <= distance) return {
+		x: to.x,
+		z: to.z
+	};
+	return {
+		x: from.x + (to.x - from.x) / length * distance,
+		z: from.z + (to.z - from.z) / length * distance
+	};
+}
+/** How far from a mine's middle its side is, a mine being 3 or 4 wide: where a route to it goes */
+var MINE_SIDE = 3.5;
+/** How near a base what is at it is */
+var AT_BASE = 20;
+/** How far round the nearest tree the woods go that home gathers from, where none is near home */
+var WOODS = 12;
+/** The odds of the base's fighters near a worker against the foes on it, under which the worker runs */
+var FLEE_UNDER = .5;
+/** Seconds a base a worker fled from stands clear before it goes back */
+var CLEAR_FOR = 5;
+/** How many workers rebalancing moves in a think: a few at a time, so that a base never empties at once */
+var MOVE_AT_ONCE = 3;
+/** Seconds the other resource runs short, with the money piling up, before one more worker goes to it (AI2) */
+var BLOCKED = 15;
+/** What counts as the other resource running short, and as the money piling up: what little a building or a unit costs of it, and enough for most */
+var SHORT_UNDER = 100;
+var PILED = 300;
+/** How many more workers on the other resource at most, for what waits on it */
+var MORE_AT_MOST = 3;
+/** What the economy holds the workers that fled by (`ai.goals.take`): no goal sends them anywhere until they are back */
+var FLED = "economy:fled";
+/**
+* The id of the want for another hall, on the build plan
+*
+* @internal
+*/
+var EXPAND_WANT = "economy.expand";
+/**
+* A brain's economy (`ai.economy`): its workers, base by base, run by the `economy()` module each think (`think`), or
+* by the melee player's turn, and asked by whoever wants to know (`bases`, `freeMine`, `waiting`). Kept in the brain's
+* memory (`BrainMemory.economy`)
+*
+* @internal
+*/
+var Economy = class Economy {
+	ai;
+	/** What finds it on a brain (`ai.area(Economy)`): made the first time a module asks for it */
+	static id = "economy";
+	/** Makes the economy of a brain; what `ai.area(Economy)` calls the first time a module asks for it */
+	static make(ai) {
+		return new Economy(ai);
+	}
+	/** Its id among the brain's areas: what its memory and its report are kept under */
+	id = "economy";
+	/** What the log says where a save's memory of it is of a shape it does not read */
+	afresh = "the save remembers the computer player’s economy in a shape this brain does not read: it starts afresh";
+	/** Whether an `economy()` module is in the brain, or the melee player runs it: without one, nothing here runs by itself */
+	enabled = false;
+	/**
+	* Whether everything else waits for what the money is gathered at (`builtOn`, a cursed mine), with none of it
+	* standing and none on its way: there is no money without it
+	*/
+	waiting = false;
+	memory = {
+		v: 1,
+		fled: {}
+	};
+	moduleOptions = {};
+	thoughtAt = -1;
+	found;
+	trained = 0;
+	constructor(ai) {
+		this.ai = ai;
+	}
+	/** Puts the `economy()` module's options under the brain's settings: what the module is made with */
+	configure(options) {
+		this.moduleOptions = options;
+		this.enabled = true;
+	}
+	/** How it runs the economy: the module's options, the brain's settings over them (`ai.settings.economy`) */
+	get options() {
+		return this.ai.cache("economy.options", () => ({
+			...this.moduleOptions,
+			...this.ai.settings.economy
+		}));
+	}
+	/** How many of a unit type its buildings have queued: on their way, for what is counted as had */
+	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;
+	}
+	/** What a base wants on a resource where nothing caps it: `workersPer`, then `workers` on the money everywhere, `lumberjacks` on the other at home */
+	asked(kind, base, index) {
+		const options = this.options;
+		const asked = (typeof options.workersPer === "function" ? options.workersPer(this.ai, base, index) : options.workersPer ?? {})[kind] ?? (kind === this.money ? options.workers ?? 8 : index === 0 ? options.lumberjacks ?? 3 : 0);
+		return kind === this.material && index === 0 ? asked + (this.memory.material?.more ?? 0) : asked;
+	}
+	/** The game's money: what most things cost (`Registry.currency`), the first resource where it names none */
+	get money() {
+		const { registry } = this.ai;
+		return registry.currency ?? registry.resources[0]?.id ?? "";
+	}
+	/** The other resource workers gather, where the game has one (lumber, in melee) */
+	get material() {
+		return this.ai.registry.resources.find((resource) => resource.id !== this.money)?.id;
+	}
+	/** What gathers: the first worker type the player can make (`worker` role) */
+	get worker() {
+		return this.ai.view.typesOf("worker")[0];
+	}
+	/** What stands on a mine to gather it there (`topper` role: `builtOn` the money), where the game has one */
+	get topper() {
+		return this.ai.view.typesOf("topper")[0];
+	}
+	/**
+	* What gathers the other resource where the worker does not (a ghoul, who fights too): of the gatherers the player
+	* can make, the first that gathers it. The worker where it does
+	*/
+	get lumberjack() {
+		const { worker, material } = this;
+		if (material === void 0 || !worker || gathers(worker, material)) return worker;
+		return this.ai.view.typesOf("gatherer").find((def) => def.kind === "unit" && def !== worker && gathers(def, material));
+	}
+	/** Whether a building takes deposits of a resource (`dropOff`) */
+	takes(def, kind) {
+		return def.dropOff === true || Array.isArray(def.dropOff) && def.dropOff.includes(kind);
+	}
+	/**
+	* Its bases as the economy sees them, once a think: each of the view's bases (home first) with the deposits it
+	* gathers from, what they serve, the workers it wants and those at work there
+	*/
+	bases() {
+		const { ai } = this;
+		if (this.found?.tick === ai.tick) return this.found.bases;
+		const { view } = ai;
+		const { money, material, topper, worker } = this;
+		const saturate = this.options.saturate ?? true;
+		const halls = view.mine.buildings().finished().where((_, def) => this.takes(def, money));
+		const toppers = topper ? view.mine.ofType(topper.id).finished() : void 0;
+		const mines = view.resources.ofResource(money).alive();
+		const reach = 256;
+		const bases = view.bases().map((base, index) => {
+			const deposits = {};
+			const serves = {};
+			const served = mines.filter((each) => toppers ? toppers.some((top) => top.x === each.x && top.z === each.z && base.buildings.has(top.id)) : halls.some((hall) => distSq(hall, each) < reach && base.buildings.has(hall.id)));
+			deposits[money] = served;
+			serves[money] = served.reduce((sum, each) => sum + this.serving(each, base), 0);
+			if (material !== void 0) {
+				let trees = view.resourcesNear(base).ofResource(material).alive().items;
+				if (!trees.length && index === 0) {
+					const nearest = view.resources.ofResource(material).alive().nearest(base.at);
+					if (nearest) trees = view.resourcesNear(nearest, WOODS).ofResource(material).alive().items;
+				}
+				deposits[material] = trees;
+				serves[material] = trees.reduce((sum, each) => sum + (view.def(each).resource?.slots ?? 1), 0);
+			}
+			const wants = {};
+			for (const kind of [money, ...material !== void 0 ? [material] : []]) {
+				if (!worker || !gathers(worker, kind)) continue;
+				const want = this.asked(kind, base, index);
+				wants[kind] = saturate ? Math.min(want, serves[kind] ?? 0) : (serves[kind] ?? 0) > 0 ? want : 0;
+			}
+			return {
+				base,
+				deposits,
+				serves,
+				wants,
+				working: {}
+			};
+		});
+		if (worker) for (const unit of view.mine.ofType(worker.id)) {
+			if (unit.own?.order !== "harvest") continue;
+			const kind = snapshotOf(unit, gathering)?.kind ?? this.kindNear(unit.own.goal ?? unit);
+			const at = unit.own.goal ?? unit;
+			let best;
+			let bestDistance = Infinity;
+			for (const each of bases) {
+				const d = distSq(each.base.at, at);
+				if (d < bestDistance) {
+					bestDistance = d;
+					best = each;
+				}
+			}
+			if (best) (best.working[kind] ??= []).push(unit.id);
+		}
+		this.found = {
+			tick: ai.tick,
+			bases
+		};
+		return bases;
+	}
+	/** The resource of the deposit nearest a place: what a worker walking there will gather. The money where none is near */
+	kindNear(at) {
+		const near = this.ai.view.resources.nearest(at);
+		return near && distSq(near, at) < 36 ? this.ai.view.def(near).resource?.id ?? this.money : this.money;
+	}
+	/**
+	* How many workers one deposit of the money serves at once, as worked by this base (see the file's comment): what
+	* stands on it to gather it says (`gatherers`); one entered serves its slots for every round trip from the hall
+	* nearest it; one worked from beside, its slots
+	*/
+	serving(deposit, base) {
+		const { view, registry } = this.ai;
+		const def = view.def(deposit);
+		const resource = def.resource;
+		const { topper, worker } = this;
+		if (topper?.builtOn === resource?.id && topper) return topper.gatherers ?? 5;
+		if (!resource?.entered || !worker) return resource?.slots ?? 1;
+		const hall = base.buildings.where((_, each) => this.takes(each, resource.id)).nearest(deposit);
+		if (!hall) return resource.slots;
+		const size = (each) => (each.stats ? baseStats(each, registry).radius : 0) || 0;
+		const speed = baseStats(worker, registry).moveSpeed || 0;
+		const gap = Math.max(0, Math.sqrt(distSq(hall, deposit)) - size(view.def(hall)) - size(def));
+		const gather = resource.gatherTime ?? worker.harvester?.gatherTime ?? 1;
+		const walk = speed > 0 ? 2 * gap / speed : 0;
+		return Math.max(1, Math.ceil((resource.slots || 1) * (1 + walk / Math.max(.1, gather))));
+	}
+	/** Whether a unit is busy for someone else: in a squad (on an errand), held by a rule, or fled */
+	busy(unit) {
+		const { ai } = this;
+		return ai.squads.squadOf(unit) !== void 0 || ai.goals.ruled(unit.id) || this.memory.fled[unit.id] !== void 0;
+	}
+	/**
+	* A gold mine near enough home that nobody has a hall by, and nothing of anyone's stands on, and that a worker can
+	* walk to from home: the nearest, for another hall. None where every one is taken, or none is known. A mine on
+	* ground cut off from home (a plateau with no ramp, an island) is left out: the walk to it is asked of the ground
+	* the player knows each time, nearest first, so the answer is the picture's alone
+	*/
+	freeMine() {
+		const { view } = this.ai;
+		const home = view.home();
+		if (!home) return void 0;
+		const money = this.money;
+		const halls = view.all.filter((entity) => view.def(entity).kind === "building" && this.takes(view.def(entity), money));
+		const reach = 256;
+		const most = 4096;
+		const free = [...view.mines()].map((mine) => ({
+			mine,
+			d: distSq(mine, home)
+		})).filter(({ mine, d }) => d < most && !halls.some((hall) => distSq(hall, mine) < reach)).sort((a, b) => a.d - b.d || a.mine.id - b.mine.id);
+		const out = (view.def(home).radius ?? 2) + 1.5;
+		for (const { mine } of free) if (this.walkable(towards(home, mine, out), mine)) return {
+			x: mine.x,
+			z: mine.z
+		};
+	}
+	/** Whether a worker walks from one place to a mine: the route over the ground known to its side (the mine itself is in the way) ends by it */
+	walkable(from, mine) {
+		const route = this.ai.view.findPath(from, towards(mine, from, MINE_SIDE));
+		const end = route?.[route.length - 1];
+		return !!end && distSq(end, mine) <= 36;
+	}
+	/**
+	* The think, once a think: a builder to every building half built that nobody works on, workers off a raid and back,
+	* idle workers to where they are missing, the spare moved where short, the other resource's gatherers, what the
+	* money is gathered at, workers trained, the next hall wanted. A second call in the same think does nothing
+	*/
+	think() {
+		const { ai } = this;
+		if (this.thoughtAt === ai.tick) return;
+		this.thoughtAt = ai.tick;
+		this.trained = 0;
+		this.prune();
+		const options = this.options;
+		this.sites();
+		if (options.workersFlee ?? true) this.flee();
+		this.back();
+		this.blocked();
+		this.assign();
+		this.rebalance();
+		this.toMaterial();
+		this.lumberjacks();
+		this.toppers();
+		if (options.trainWorkers ?? true) this.train();
+		this.expand();
+	}
+	/**
+	* Whether the other resource holds it up (lumber, where gold is the money): under `SHORT_UNDER` of it with `PILED` of
+	* the money or more, what it has as the snapshot says. One more worker on it at home each `BLOCKED` seconds it is so,
+	* at most `MORE_AT_MOST`; one fewer each twice that once it is not
+	*/
+	blocked() {
+		const { ai } = this;
+		const { material } = this;
+		if (material === void 0) return;
+		const tick = ai.tick;
+		const period = BLOCKED * ai.session.tickRate;
+		const kept = this.memory.material;
+		const have = ai.view.me.resources;
+		if ((have[material] ?? 0) < SHORT_UNDER && (have[this.money] ?? 0) >= PILED) {
+			const state = this.memory.material ??= { more: 0 };
+			delete state.easy;
+			state.since ??= tick;
+			if (tick - state.since < period || state.more >= MORE_AT_MOST) return;
+			state.more++;
+			state.since = tick;
+			ai.decide(`puts ${state.more} more on ${material} at home: ${this.money} piles up while ${material} runs short`, { kind: "economy" });
+			return;
+		}
+		if (!kept) return;
+		delete kept.since;
+		if (kept.more <= 0) {
+			delete this.memory.material;
+			return;
+		}
+		kept.easy ??= tick;
+		if (tick - kept.easy < period * 2) return;
+		kept.more--;
+		kept.easy = tick;
+	}
+	/**
+	* Home short on the other resource while more are put on it (`blocked`), and nobody idle to send: a worker of the
+	* money at home, carrying nothing, goes to the trees by home. One a think
+	*/
+	toMaterial() {
+		const { ai } = this;
+		const { view } = ai;
+		const { material, money, worker } = this;
+		if (material === void 0 || !(this.memory.material?.more ?? 0) || !worker || !gathers(worker, material)) return;
+		const home = this.bases()[0];
+		if (!home || (home.wants[material] ?? 0) - (home.working[material]?.length ?? 0) <= 0) return;
+		const tree = nearestOf(home.deposits[material] ?? [], home.base.at);
+		if (!tree) return;
+		const state = this.memory.material;
+		const moved = state.moved ??= {};
+		for (const id in moved) {
+			const unit = view.byId(Number(id));
+			if (!unit || unit.own?.order !== "harvest" || snapshotOf(unit, gathering)?.kind === material || ai.tick - moved[id] >= 60 * ai.session.tickRate) delete moved[id];
+		}
+		if ((home.wants[material] ?? 0) - (home.working[material]?.length ?? 0) - Object.keys(moved).length <= 0) return;
+		const from = (home.working[money] ?? []).map((id) => view.byId(id)).filter((unit) => unit && moved[unit.id] === void 0 && !unit.own?.hidden && !snapshotOf(unit, gathering)?.carrying && !this.busy(unit)).sort((a, b) => distSq(a, tree) - distSq(b, tree) || a.id - b.id)[0];
+		if (!from) return;
+		ai.send({
+			type: "order",
+			entities: [from.id],
+			order: {
+				type: "harvest",
+				target: tree.id
+			}
+		});
+		moved[from.id] = ai.tick;
+		ai.decide(`moves a worker from ${money} to ${material} at home`, { kind: "economy" });
+	}
+	/** Whether it has run at all: by the module, or the melee player's turn */
+	get running() {
+		return this.enabled || this.thoughtAt >= 0;
+	}
+	/** Marks the think's economy done another way (a brain's own turn that ran it itself): `think` does nothing more this think */
+	done() {
+		this.thoughtAt = this.ai.tick;
+	}
+	/** What is remembered of the dead, or of what is no longer its own, let go of */
+	prune() {
+		const { view, goals } = this.ai;
+		for (const id in this.memory.fled) if (!view.mine.has(Number(id))) delete this.memory.fled[id];
+		const held = goals.held(FLED);
+		if (held) {
+			const away = held.units.filter((id) => this.memory.fled[id] === void 0);
+			if (away.length) goals.drop(FLED, away);
+		}
+	}
+	/** Its workers, as of the think */
+	workers() {
+		const { worker } = this;
+		const { view } = this.ai;
+		return worker ? view.mine.ofType(worker.id) : view.mine.where(() => false);
+	}
+	/** A builder to every building of its own going up by builders that nobody works on: the nearest free worker */
+	sites() {
+		const { ai } = this;
+		const { view } = ai;
+		const workers = this.workers();
+		for (const site of view.mine) {
+			if (builtSoFar(site) === void 0 || constructionOf(view.def(site)) !== "builder") continue;
+			const busy = workers.some((worker) => (worker.own?.order === "build" || worker.own?.order === "construct") && distSq(worker, site) < 100);
+			const sent = `construct:${site.id}:`;
+			if (busy || workers.some((worker) => ai.sentTo(worker.id)?.key === sent)) continue;
+			const helper = workers.where((worker) => !worker.own?.hidden && worker.own?.order !== "build" && !this.busy(worker)).nearest(site);
+			if (helper) ai.send({
+				type: "order",
+				entities: [helper.id],
+				order: {
+					type: "construct",
+					target: site.id
+				}
+			});
+		}
+	}
+	/**
+	* Workers a raid is on, at a base its fighters do not hold: off to the nearest base no enemy is at. A worker with no
+	* such base stays at work: there is nowhere better to be
+	*/
+	flee() {
+		const { ai } = this;
+		const { view } = ai;
+		const foes = view.hostile.alive().units().where((entity, def) => !entity.asleep && !!def.attacks?.length);
+		if (!foes.length) return;
+		const bases = view.bases();
+		const safe = bases.filter((base) => !foes.near(base.at, AT_BASE).length);
+		if (!safe.length) return;
+		const fled = [];
+		for (const unit of this.workers()) {
+			if (unit.own?.hidden || this.busy(unit) || unit.own?.order === "build") continue;
+			const on = foes.near(unit, 8);
+			if (!on.length) continue;
+			const guards = view.mine.fighters().near(unit, 16);
+			if (guards.length && view.strength.odds(guards, on) >= FLEE_UNDER) continue;
+			const from = bases.reduce((best, base) => distSq(base.at, unit) < distSq(best.at, unit) ? base : best, bases[0]);
+			const to = safe.filter((base) => base !== from).reduce((best, base) => !best || distSq(base.at, unit) < distSq(best.at, unit) ? base : best, void 0);
+			if (!to) continue;
+			this.memory.fled[unit.id] = {
+				from: point(from.at),
+				to: point(to.at),
+				since: ai.tick
+			};
+			fled.push(unit);
+		}
+		if (!fled.length) return;
+		const byDestination = /* @__PURE__ */ new Map();
+		for (const unit of fled) {
+			const to = this.memory.fled[unit.id].to;
+			const key = `${to.x},${to.z}`;
+			(byDestination.get(key) ?? byDestination.set(key, {
+				to,
+				ids: []
+			}).get(key)).ids.push(unit.id);
+		}
+		ai.goals.take(fled.map((unit) => unit.id), "told", {
+			id: FLED,
+			seconds: Infinity
+		});
+		for (const { to, ids } of byDestination.values()) {
+			ai.send({
+				type: "order",
+				entities: ids,
+				order: {
+					type: "move",
+					point: to
+				}
+			});
+			ai.decide(`${ids.length === 1 ? "1 worker flees" : `${ids.length} workers flee`} a raid to the base at ${where(to)}`, { kind: "economy" });
+		}
+	}
+	/** Those that fled, back to work at their own base once it has stood clear long enough */
+	back() {
+		const { ai } = this;
+		const { view } = ai;
+		const foes = view.hostile.alive().units().where((entity, def) => !entity.asleep && !!def.attacks?.length);
+		const back = [];
+		for (const id in this.memory.fled) {
+			const fled = this.memory.fled[id];
+			if (foes.near(fled.from, AT_BASE).length) {
+				delete fled.clear;
+				continue;
+			}
+			fled.clear ??= ai.tick;
+			if (ai.tick - fled.clear < CLEAR_FOR * ai.session.tickRate) continue;
+			back.push(Number(id));
+			delete this.memory.fled[id];
+		}
+		if (!back.length) return;
+		ai.goals.drop(FLED, back);
+		const bases = this.bases();
+		const byDeposit = /* @__PURE__ */ new Map();
+		for (const id of back) {
+			const unit = view.byId(id);
+			const deposit = bases.flatMap((each) => each.deposits[this.money] ?? []).reduce((best, each) => !best || distSq(each, unit) < distSq(best, unit) ? each : best, void 0);
+			if (deposit) (byDeposit.get(deposit.id) ?? byDeposit.set(deposit.id, []).get(deposit.id)).push(id);
+		}
+		for (const [target, entities] of byDeposit) ai.send({
+			type: "order",
+			entities,
+			order: {
+				type: "harvest",
+				target
+			}
+		});
+		ai.decide(`${back.length === 1 ? "1 worker goes" : `${back.length} workers go`} back to work: the raid is over`, { kind: "economy" });
+	}
+	/**
+	* The idle workers, each to the base and resource where the most are missing (the nearest base among equals); with
+	* nothing missing anywhere, to the money at the nearest base that has some, rather than stand about
+	*/
+	assign() {
+		const { ai } = this;
+		const { view } = ai;
+		const home = view.home();
+		const idle = this.workers().where((unit) => !!unit.own && !unit.own.order && !unit.own.hidden && !this.busy(unit));
+		if (!idle.length || !home) return;
+		const bases = this.bases();
+		const { money } = this;
+		const short = bases.map((each) => {
+			const missing = {};
+			for (const kind in each.wants) missing[kind] = each.wants[kind] - (each.working[kind]?.length ?? 0);
+			return missing;
+		});
+		const orders = /* @__PURE__ */ new Map();
+		for (const unit of idle) {
+			let best;
+			bases.forEach((each, at) => {
+				for (const kind in short[at]) {
+					const missing = short[at][kind];
+					if (missing <= 0 || !each.deposits[kind]?.length) continue;
+					const distance = distSq(each.base.at, unit);
+					if (!best || missing > best.missing || missing === best.missing && distance < best.distance) best = {
+						at,
+						kind,
+						missing,
+						distance
+					};
+				}
+			});
+			let deposit;
+			if (best) {
+				short[best.at][best.kind] -= 1;
+				const base = bases[best.at];
+				deposit = best.kind === money ? nearestOf(base.deposits[money], unit) : nearestOf(base.deposits[best.kind], base.base.at);
+			} else {
+				const served = bases.flatMap((each) => each.deposits[money] ?? []);
+				deposit = served.length ? nearestOf(served, unit) : this.topper ? void 0 : view.resources.ofResource(money).alive().nearest(home);
+			}
+			if (deposit) (orders.get(deposit.id) ?? orders.set(deposit.id, []).get(deposit.id)).push(unit.id);
+		}
+		for (const [target, entities] of orders) ai.send({
+			type: "order",
+			entities,
+			order: {
+				type: "harvest",
+				target
+			}
+		});
+	}
+	/**
+	* A base with more on the money than its deposits serve (or with none left) gives its spare to a base that is short,
+	* a few a think: those not carrying anything, so that nothing gathered is lost on the way
+	*/
+	rebalance() {
+		const { ai } = this;
+		const { view } = ai;
+		const { money } = this;
+		const bases = this.bases();
+		if (bases.length < 2) return;
+		let moved = 0;
+		for (const from of bases) {
+			const working = from.working[money] ?? [];
+			const spare = working.length - (from.wants[money] ?? 0);
+			if (spare <= 0) continue;
+			const to = bases.filter((each) => each !== from && (each.wants[money] ?? 0) - (each.working[money]?.length ?? 0) > 0 && each.deposits[money]?.length).sort((a, b) => distSq(a.base.at, from.base.at) - distSq(b.base.at, from.base.at))[0];
+			if (!to) continue;
+			const missing = (to.wants[money] ?? 0) - (to.working[money]?.length ?? 0);
+			const ids = working.map((id) => view.byId(id)).filter((unit) => !unit.own?.hidden && !snapshotOf(unit, gathering)?.carrying && !this.busy(unit)).slice(0, Math.min(spare, missing, MOVE_AT_ONCE - moved)).map((unit) => unit.id);
+			if (!ids.length) continue;
+			const deposit = nearestOf(to.deposits[money], from.base.at);
+			ai.send({
+				type: "order",
+				entities: ids,
+				order: {
+					type: "harvest",
+					target: deposit.id
+				}
+			});
+			ai.decide(`moves ${ids.length === 1 ? "1 worker" : `${ids.length} workers`} from the base at ${where(from.base.at)} to the one at ${where(to.base.at)}: ${(from.wants[money] ?? 0) === 0 ? "its mine is gone" : "it has more than it serves"}`, { kind: "economy" });
+			moved += ids.length;
+			if (moved >= MOVE_AT_ONCE) return;
+		}
+	}
+	/**
+	* Where the worker does not gather the other resource: so many of what does (`lumberjack`, a ghoul) sent to the trees
+	* by home, those at home first, as many as home wants on it (the seat's `lumberjacks`). They are trained as soldiers are
+	*/
+	lumberjacks() {
+		const { ai } = this;
+		const { view } = ai;
+		const { lumberjack, worker, material } = this;
+		const home = view.home();
+		if (!lumberjack || lumberjack === worker || material === void 0 || !home) return;
+		const homeBase = view.bases()[0];
+		const wanted = homeBase ? this.asked(material, homeBase, 0) : 0;
+		const all = view.mine.ofType(lumberjack.id).where((unit) => !unit.own?.hidden && !this.busy(unit));
+		const chopping = all.filter((unit) => unit.own?.order === "harvest").length;
+		if (chopping >= wanted) return;
+		const tree = view.resources.ofResource(material).nearest(home);
+		if (!tree) return;
+		const free = all.filter((unit) => unit.own?.order !== "harvest" && distSq(unit, home) < 1024);
+		free.sort((a, b) => distSq(a, home) - distSq(b, home));
+		const sent = free.slice(0, wanted - chopping);
+		if (sent.length) ai.send({
+			type: "order",
+			entities: sent.map((unit) => unit.id),
+			order: {
+				type: "harvest",
+				target: tree.id
+			}
+		});
+	}
+	/**
+	* Where mines are gathered from at what stands on them (`topper`): one put up on each mine by a hall of its own that
+	* has none, a mine at a time, through the build plan. With none at all and none on its way, everything else waits
+	* (`waiting`)
+	*/
+	toppers() {
+		const { ai } = this;
+		const { view } = ai;
+		const { topper } = this;
+		this.waiting = false;
+		if (!topper || view.mine.some((entity) => entity.own?.build === topper.id && entity.own.order === "build")) return;
+		const hall = view.typesOf("hall")[0];
+		const halls = hall ? view.mine.ofType(hall.id).finished() : view.mine.where(() => false);
+		for (const at of halls) if (ai.plans.build.build(topper, {
+			near: {
+				x: at.x,
+				z: at.z
+			},
+			by: "economy"
+		})) return;
+		this.waiting = view.mine.ofType(topper.id).length === 0;
+	}
+	/** How many workers the bases want together: what the halls train up to, with `builders` more */
+	wanted() {
+		let sum = 0;
+		for (const each of this.bases()) for (const kind in each.wants) sum += each.wants[kind] ?? 0;
+		return sum;
+	}
+	/** Workers trained at every hall with nothing in its queue, while it has fewer (those queued counted) than its bases want */
+	train() {
+		const { ai } = this;
+		const { view } = ai;
+		const { worker } = this;
+		if (!worker) return;
+		const halls = view.mine.buildings().finished().where((_, def) => (def.trains ?? []).includes(worker.id));
+		let have = this.workers().length + this.queued(worker.id);
+		const want = this.wanted() + (this.options.builders ?? 1);
+		const bases = this.bases();
+		const shortAt = (at) => {
+			const base = bases.find((each) => each.base.buildings.some((building) => building.x === at.x && building.z === at.z));
+			if (!base) return 0;
+			let missing = 0;
+			for (const kind in base.wants) missing += (base.wants[kind] ?? 0) - (base.working[kind]?.length ?? 0);
+			return missing;
+		};
+		const ready = halls.filter((each) => !queueOf(each).length);
+		ready.sort((a, b) => shortAt(b) - shortAt(a));
+		for (const at of ready) {
+			if (have >= want) return;
+			if (!ai.plans.production.train(at, worker)) return;
+			have++;
+			this.trained++;
+		}
+	}
+	/** Another hall by a free mine, as many as it is to have, once the condition holds: a standing want of the build plan */
+	expand() {
+		const { ai } = this;
+		const hall = ai.view.typesOf("hall")[0];
+		const expansions = this.options.expansions ?? 0;
+		if (!hall || expansions <= 0) {
+			ai.plans.build.drop(EXPAND_WANT);
+			return;
+		}
+		const when = this.options.expandWhen ?? DEFAULT_EXPAND_WHEN;
+		ai.plans.build.want({
+			id: EXPAND_WANT,
+			type: hall.id,
+			count: 1 + expansions,
+			priority: 40,
+			keep: true,
+			by: "economy",
+			within: 15,
+			near: () => this.freeMine(),
+			when: (brain) => evaluate(when, brain) && !!this.freeMine()
+		});
+	}
+	/** The economy as the report shows it */
+	report() {
+		const { ai } = this;
+		const { worker } = this;
+		const running = this.running;
+		return {
+			bases: (running ? this.bases() : []).map((each) => {
+				const workers = {};
+				for (const kind of /* @__PURE__ */ new Set([...Object.keys(each.wants), ...Object.keys(each.working)])) workers[kind] = [
+					each.working[kind]?.length ?? 0,
+					each.wants[kind] ?? 0,
+					each.serves[kind] ?? 0
+				];
+				return {
+					at: pair(each.base.at),
+					hall: each.base.centre.id,
+					workers
+				};
+			}),
+			fled: Object.entries(this.memory.fled).map(([unit, fled]) => ({
+				unit: Number(unit),
+				from: pair(fled.from),
+				since: fled.since
+			})),
+			workers: [worker ? this.workers().length + this.queued(worker.id) : 0, running ? this.wanted() + (this.options.builders ?? 1) : 0],
+			...ai.plans.build.get("economy.expand") && { expansion: ai.plans.build.status("economy.expand") ?? "new" }
+		};
+	}
+	/** What it remembers, for a save: a copy */
+	/** Whether it has anything to remember now: one that does not is left out of a save */
+	remembers() {
+		return Object.keys(this.memory.fled).length > 0 || this.memory.material !== void 0;
+	}
+	/** Its part of the brain's report */
+	reportTo(report) {
+		report.economy = {
+			...report.economy,
+			...this.report()
+		};
+	}
+	/** Gives a copy of the economy's memory, for a save of the brain */
+	save() {
+		return structuredClone(this.memory);
+	}
+	/** Takes back what `save` gave: whether it was read */
+	restore(memory) {
+		const given = memory;
+		if (!given || typeof given !== "object" || given.v !== 1) return false;
+		this.memory = {
+			v: 1,
+			fled: structuredClone(given.fled ?? {}),
+			...given.material && typeof given.material.more === "number" && { material: { ...given.material } }
+		};
+		return true;
+	}
+};
+/** When it expands, where nothing says: four minutes in, with a building that trains soldiers */
+var DEFAULT_EXPAND_WHEN = { all: [{ time: { after: 240 } }, { units: { role: "barracks" } }] };
+/** Of some entities, the one nearest a place */
+function nearestOf(entities, to) {
+	let best;
+	let bestDistance = Infinity;
+	for (const each of entities) {
+		const d = distSq(each, to);
+		if (d < bestDistance) {
+			bestDistance = d;
+			best = each;
+		}
+	}
+	return best;
+}
+/**
+* The economy module: the workers base by base each think (`ai.economy.think`): builders to sites, workers off a raid and
+* back, the idle where they are missing, the spare moved, the other resource's gatherers, what the money is gathered at,
+* workers trained, another hall wanted. With how it runs where the brain's definition and the seat's options say nothing
+* (`EconomyOptions`)
+*
+* @beta
+*/
+var economy = (options = {}) => defineModule({
+	id: "economy",
+	make: (ai) => {
+		ai.area(Economy).configure(options);
+		return {
+			id: "economy",
+			phase: "plan",
+			think: () => ai.area(Economy).think()
+		};
+	}
+});
+//#endregion
+export { EXPAND_WANT, Economy, economy };
+
+//# sourceMappingURL=economy.js.map