@v12-engine/engine 0.1.1 → 0.4.0

package/dist/ai/plans/build.js

@@ -0,0 +1,608 @@
+import { distSq } from "../../math.js";
+import { baseStats } from "../../defs.js";
+import { snapshotOf } from "../../components.js";
+import { builtSoFar } from "../../systems/construction.js";
+import { queueOf, upgradeOf } from "../../systems/productionQueue.js";
+import { gathering } from "../../orders/harvest.js";
+import { defineModule } from "../module.js";
+import { evaluate } from "../rules.js";
+import { DEFAULT_PLACEMENT, placementNamed } from "./placement.js";
+import { makerOf, techPath, techTrouble } from "./tech.js";
+import { an, where } from "../geometry.js";
+//#region src/ai/plans/build.ts
+/** How far from a mine, towards home, a settler is sent to see where the hall by it would go */
+var SETTLE_FROM = 10;
+var WITHIN = 22;
+var SITE_TIMEOUT = 60;
+/** Under this part of its health a building is mended */
+var MEND_UNDER = .9;
+/** A step in words, for the report: `build lumbermill`, `townhall → keep`, `train peasant` */
+var stepWords = (step) => step.how === "morph" ? `${step.from} → ${step.type}` : `${step.how} ${step.type}`;
+/** Whether a want is plain data all through: what a save can keep */
+var isData = (def) => typeof def.count !== "function" && typeof def.when !== "function" && typeof def.near !== "function" && typeof def.placement !== "function";
+/**
+* The brain's build plan (`ai.plans.build`): its wants, the steps to each, the spots, the builders, the purse. Add a
+* want with `want`, read where each stands with `report`, and let `think` act on them once a think
+*
+* @beta
+*/
+var BuildPlan = class {
+	ai;
+	options = {};
+	wants = /* @__PURE__ */ new Map();
+	/** Memory of wants a save remembers that no module has asked for yet: given to them as they come */
+	pending = {};
+	added = 0;
+	thoughtAt = -1;
+	paths = /* @__PURE__ */ new Map();
+	/** What is on its way, by type, worked out once a think: asked for every want and every step */
+	onWay = /* @__PURE__ */ new Map();
+	/** The builders sent this think: not sent twice */
+	sent = /* @__PURE__ */ new Set();
+	/** The want saving up this think, if one is */
+	saving;
+	warned = /* @__PURE__ */ new Set();
+	constructor(ai, options = {}) {
+		this.ai = ai;
+		this.configure(options);
+	}
+	/** Takes options in, over what it had: the standing wants added, the table of placements merged, the flags replaced */
+	configure(options) {
+		this.options = {
+			...this.options,
+			...options,
+			placement: {
+				...this.options.placement,
+				...options.placement
+			}
+		};
+		for (const def of options.wants ?? []) this.want({
+			...def,
+			keep: true
+		});
+	}
+	/** The plan's options as they stand */
+	get settings() {
+		return this.options;
+	}
+	/**
+	* Adds a want, or replaces one of the same id (its memory kept): what the plan works towards from now. Gives back
+	* its id. A want with no `keep` is dropped once met
+	*/
+	want(def) {
+		if (!def.type) throw new Error("A want needs a type");
+		const id = def.id ?? `${def.type}#${++this.added}`;
+		const live = this.wants.get(id);
+		if (live) {
+			live.def = {
+				...def,
+				id
+			};
+			return id;
+		}
+		const memory = this.pending[id] ?? {
+			since: this.ai.tick,
+			order: this.added,
+			made: 0
+		};
+		delete this.pending[id];
+		this.added = Math.max(this.added, memory.order + 1);
+		this.wants.set(id, {
+			id,
+			def: {
+				...def,
+				id
+			},
+			memory,
+			count: 0,
+			have: 0,
+			onItsWay: 0,
+			status: "new",
+			steps: []
+		});
+		return id;
+	}
+	/** Takes a want out, and what a save remembered of it: whether there was one */
+	drop(id) {
+		const remembered = id in this.pending;
+		delete this.pending[id];
+		return this.wants.delete(id) || remembered;
+	}
+	/** A want by id */
+	get(id) {
+		return this.wants.get(id)?.def;
+	}
+	/** The wants, in the order added */
+	list() {
+		return this.ordered().map((live) => live.def);
+	}
+	/** Where a want stands, in words, as of the last think: `building a barracks at (40, 60)`, `saving for a town hall` */
+	status(id) {
+		return this.wants.get(id)?.status;
+	}
+	/** The want saving up, as of the last think: the most important one it could not pay for */
+	get savingFor() {
+		return this.saving;
+	}
+	/** How many of a type the player has, those under construction and those that count as it included */
+	have(type) {
+		return this.ai.view.mine.ofType(type).length;
+	}
+	/** How many of a type are on their way beyond those that stand: builders sent to build one, buildings turning into one, units queued */
+	onItsWay(type) {
+		const known = this.onWay.get(type);
+		if (known !== void 0) return known;
+		let count = 0;
+		for (const entity of this.ai.view.mine) {
+			const own = entity.own;
+			if (!own) continue;
+			if (own.order === "build" && own.build === type) count++;
+			else if (upgradeOf(entity)?.to === type) count++;
+			for (const item of queueOf(entity)) if ((item.kind === "morph" || item.kind === "unit") && item.id === type) count++;
+		}
+		this.onWay.set(type, count);
+		return count;
+	}
+	/** Whether a type is had or on its way: standing (finished or not), or a builder or a morph on the way to it */
+	had(type) {
+		return this.ai.view.me.tech.includes(type) || this.have(type) > 0 || this.onItsWay(type) > 0;
+	}
+	/** The steps to being able to make a type (`techPath`), worked out once a think */
+	path(type) {
+		let found = this.paths.get(type);
+		if (!found) this.paths.set(type, found = techPath(this.ai.view, type, (step) => this.onItsWay(step) > 0));
+		return found;
+	}
+	/** The first step towards a type not had yet, the type's own last: none when nothing is to be done, or the path is blocked */
+	next(type) {
+		const path = this.path(type);
+		if (techTrouble(path)) return void 0;
+		for (const step of path.steps) if (!this.had(step.type)) return step;
+		const maker = makerOf(this.ai.view, type);
+		return maker && {
+			type,
+			...maker,
+			for: type
+		};
+	}
+	/**
+	* The think, once a think: every want measured against what stands and is on its way (met ones dropped, or kept
+	* standing), those whose condition holds taken most important first, each advanced by the first step it can take:
+	* built, turned into, or saved for. Then the mending, where the plan is to
+	*/
+	think() {
+		const { ai } = this;
+		if (this.thoughtAt === ai.tick) return;
+		this.thoughtAt = ai.tick;
+		this.paths.clear();
+		this.onWay.clear();
+		this.sent.clear();
+		this.saving = void 0;
+		const following = ai.plans.follow() !== void 0;
+		const active = [];
+		for (const [id, live] of this.wants) {
+			const { def } = live;
+			live.steps = [];
+			live.holds = void 0;
+			live.count = typeof def.count === "function" ? def.count(ai) : def.count ?? 1;
+			live.have = this.have(def.type);
+			live.onItsWay = this.onItsWay(def.type);
+			if (live.have + live.onItsWay >= live.count) {
+				live.status = "met";
+				if (!def.keep) {
+					this.wants.delete(id);
+					continue;
+				}
+				if (!(def.rebuild ?? this.options.rebuild ?? true)) live.memory.satisfied = true;
+				continue;
+			}
+			if (live.memory.satisfied) {
+				live.status = "met once, not built anew";
+				continue;
+			}
+			if (def.when && !evaluate(def.when, ai)) {
+				live.status = "waits for its condition";
+				continue;
+			}
+			if (following && id !== "order") {
+				live.status = "waits for the build order";
+				continue;
+			}
+			active.push(live);
+		}
+		active.sort((a, b) => (b.def.priority ?? 0) - (a.def.priority ?? 0) || a.memory.order - b.memory.order);
+		for (const live of active) this.advance(live);
+		if (this.options.repair ?? true) this.mend();
+	}
+	/** One want, one think: the steps to it, and the first one it can take */
+	advance(live) {
+		const { ai } = this;
+		const { def } = live;
+		const path = this.path(def.type);
+		const trouble = techTrouble(path);
+		if (trouble) {
+			live.status = `blocked: ${trouble}`;
+			if (!this.warned.has(def.type)) {
+				this.warned.add(def.type);
+				ai.log.warn("ai", `the build plan cannot get to ${def.type}: ${trouble}`, { want: live.id });
+			}
+			return;
+		}
+		const own = makerOf(ai.view, def.type);
+		const steps = [...path.steps, ...own ? [{
+			type: def.type,
+			...own,
+			for: def.type
+		}] : []];
+		live.steps = steps.map(stepWords);
+		let status;
+		for (const step of steps) {
+			const last = step.type === def.type;
+			if (!last && this.had(step.type)) {
+				if (!ai.view.me.tech.includes(step.type)) status ??= `waits for ${an(step.type)} to finish`;
+				continue;
+			}
+			const outcome = this.act(step, live, last);
+			status ??= outcome;
+		}
+		live.status = status ?? "nothing to do";
+	}
+	/** Takes a step for a want, where it can: what came of it, in words, for the status */
+	act(step, live, last) {
+		const { ai } = this;
+		const { view, registry } = ai;
+		const { def } = live;
+		const type = registry.unit(step.type);
+		switch (step.how) {
+			case "train": return last ? `to be trained` : `needs ${an(step.type)}`;
+			case "morph": {
+				const from = view.mine.where((entity) => entity.type === step.from && builtSoFar(entity) === void 0 && !upgradeOf(entity)?.to && !queueOf(entity).length).first();
+				if (!from) return `waits for ${an(step.from)} with nothing to do, to turn into ${an(step.type)}`;
+				if (!view.has(type.requires)) return `waits for what ${an(step.type)} requires`;
+				if (!this.pay(live, type.cost)) return this.short(live, step.type);
+				ai.send({
+					type: "upgradeBuilding",
+					building: from.id,
+					into: step.type
+				});
+				if (last) live.memory.made++;
+				ai.decide(`turns its ${step.from} into ${an(step.type)}${def.by ? `, for ${def.by}` : ""}`, { kind: "build" });
+				return `turning ${an(step.from)} into ${an(step.type)}`;
+			}
+			case "build": {
+				if (!view.has(type.requires)) return `waits for what ${an(step.type)} requires`;
+				const place = last ? this.placeOf(live) : void 0;
+				if (place && ai.def.knowledge !== false && !ai.knowledge.map.explored(this.settlePoint(place))) {
+					this.sendSettler(live, place);
+					this.canPay(live, type.cost);
+					return `no ground known at ${where(place)}, a worker sent to look`;
+				}
+				if (!this.canPay(live, type.cost)) return this.short(live, step.type);
+				const site = this.siteFor(type, last ? live : void 0);
+				if (!site) {
+					if (last && this.noSite(live)) return `gave up: no spot for ${an(step.type)}`;
+					return `no spot for ${an(step.type)}${last && live.memory.settler ? ", a worker sent to look" : ""}`;
+				}
+				live.memory.noSite = void 0;
+				const builder = this.builderFor(type, site);
+				if (!builder) return `no builder for ${an(step.type)}`;
+				this.ai.purse.spend(type.cost, def.priority ?? 0);
+				this.sent.add(builder.id);
+				ai.send({
+					type: "order",
+					entities: [builder.id],
+					order: {
+						type: "build",
+						unitType: step.type,
+						point: site
+					}
+				});
+				if (last) live.memory.made++;
+				ai.decide(`builds ${an(step.type)} at ${where(site)}${def.by ? `, for ${def.by}` : ""}${last ? "" : `, on the way to ${def.type}`}`, { kind: "build" });
+				return `building ${an(step.type)} at ${where(site)}`;
+			}
+		}
+	}
+	/**
+	* Pays for a step out of the purse, with the want's `spare` left over, as important as the want is (what less
+	* important wants and modules hold is its to spend); where it cannot, the most important want that could not pay
+	* holds the money (one at a time), and what is less important waits
+	*/
+	pay(live, cost) {
+		if (!this.canPay(live, cost)) return false;
+		this.ai.purse.spend(cost, live.def.priority ?? 0);
+		return true;
+	}
+	/** Whether a want can pay for a step now (nothing spent); where it cannot, it may hold the money (`pay`) */
+	canPay(live, cost) {
+		const { purse } = this.ai;
+		const priority = live.def.priority ?? 0;
+		if (purse.affords(cost, live.def.spare ?? 0, priority)) return true;
+		if (this.saving === void 0 && cost && !live.def.spare) {
+			this.saving = live.id;
+			purse.reserve(live.id, cost, priority);
+			live.holds = { ...cost };
+		}
+		return false;
+	}
+	/** A step not paid for, in words: the want holds the money (saving), waits for money to spare (a luxury), or waits for the money */
+	short(live, type) {
+		if (live.holds) return `saving for ${an(type)}`;
+		if (live.def.spare) return `waits for ${live.def.spare} ${this.ai.purse.money} to spare for ${an(type)}`;
+		return `waits for the money for ${an(type)}`;
+	}
+	/** No spot found this think: for a want that does not stand, given up after `siteTimeout` seconds, and said */
+	noSite(live) {
+		const { ai } = this;
+		live.memory.noSite ??= ai.tick;
+		const to = this.placeOf(live);
+		if (to) this.sendSettler(live, to);
+		if (live.def.keep) return false;
+		const limit = (live.def.siteTimeout ?? this.options.siteTimeout ?? SITE_TIMEOUT) * ai.session.tickRate;
+		if (ai.tick - live.memory.noSite < limit) return false;
+		this.wants.delete(live.id);
+		ai.decide(`gives up on ${an(live.def.type)}: no spot for it in ${Math.round(limit / ai.session.tickRate)} s`, { kind: "build" });
+		return true;
+	}
+	/** Where a want says it goes, as a point: a point, a named entity it knows of, or what its function gives. Nothing for home */
+	placeOf(live) {
+		const { near } = live.def;
+		if (near === void 0) return void 0;
+		if (typeof near === "function") return near(this.ai);
+		if (typeof near === "string") {
+			const named = this.ai.view.named(near);
+			return named ? {
+				x: named.x,
+				z: named.z
+			} : void 0;
+		}
+		return near;
+	}
+	/** A spot for a type: where the want says, no further than it says, by its strategy; near home for a step on the way */
+	siteFor(type, live) {
+		const { view } = this.ai;
+		const near = (live && this.placeOf(live)) ?? view.home() ?? view.mine.where((_, def) => !!def.builds?.includes(type.id)).first();
+		if (!near) return void 0;
+		return this.site(type, {
+			near: {
+				x: near.x,
+				z: near.z
+			},
+			within: live?.def.within ?? this.options.within ?? WITHIN
+		}, live?.def.placement);
+	}
+	/**
+	* A spot for a type near a place, by a strategy: the one given, else what the type declares (`UnitTypeDef.ai.placement`),
+	* the plan's table by type then by role, the role's default, the rings around the place. What is built on a
+	* deposit goes on one whatever the name
+	*/
+	site(type, request, placement) {
+		return this.strategyFor(type, placement)(this.ai, type, {
+			...request,
+			ordinal: request.ordinal ?? this.have(type.id) + this.onItsWay(type.id)
+		});
+	}
+	strategyFor(type, placement) {
+		if (typeof placement === "function") return placement;
+		if (type.builtOn !== void 0) return placementNamed("byResource");
+		const table = this.options.placement ?? {};
+		const roles = this.ai.view.roles.of(type.id);
+		const chosen = placement ?? type.ai?.placement ?? table[type.id] ?? roles.map((role) => table[role]).find((each) => each !== void 0) ?? roles.map((role) => DEFAULT_PLACEMENT[role]).find((each) => each !== void 0);
+		if (typeof chosen === "function") return chosen;
+		return placementNamed(chosen ?? "nearHome");
+	}
+	/** The workers sent to look at the ground somewhere, by any want: not builders while they go */
+	settlers() {
+		const ids = /* @__PURE__ */ new Set();
+		for (const live of this.wants.values()) {
+			const settler = this.ai.view.byId(live.memory.settler);
+			if (settler?.own?.order === "move") ids.add(settler.id);
+		}
+		return ids;
+	}
+	/**
+	* Who builds a type at a spot: of the player's units that build it, those not hidden, not building, not sent this
+	* think, not off to look at ground and not in a squad or held by a rule; idle first, then whoever carries the least,
+	* then the nearest
+	*/
+	builderFor(type, site) {
+		const settlers = this.settlers();
+		const builders = this.ai.view.mine.where((entity, def) => !!def.builds?.includes(type.id) && !!entity.own && !entity.own.hidden && entity.own.order !== "build" && entity.own.order !== "repair" && !this.sent.has(entity.id) && !settlers.has(entity.id) && !this.ai.goals.ruled(entity.id) && !this.ai.squads.squadOf(entity)).items.slice();
+		builders.sort((a, b) => Number(!!a.own?.order) - Number(!!b.own?.order) || (snapshotOf(a, gathering)?.carrying ?? 0) - (snapshotOf(b, gathering)?.carrying ?? 0) || distSq(a, site) - distSq(b, site) || a.id - b.id);
+		return builders[0];
+	}
+	/** Where a settler stands to see a place: on its near side, towards home, so that it sees where the building would stand and not the mine alone */
+	settlePoint(to) {
+		const home = this.ai.view.home();
+		const away = home ? Math.sqrt(distSq(home, to)) : 0;
+		return home && away > SETTLE_FROM ? {
+			x: to.x + (home.x - to.x) / away * SETTLE_FROM,
+			z: to.z + (home.z - to.z) / away * SETTLE_FROM
+		} : {
+			x: to.x,
+			z: to.z
+		};
+	}
+	/**
+	* A worker sent to where a want goes, to see the ground: one at a time for the want, sent again if it was taken off
+	* it. To the near side of the place, towards home (`settlePoint`)
+	*/
+	sendSettler(live, to) {
+		const { ai } = this;
+		const { view } = ai;
+		const settling = view.byId(live.memory.settler);
+		if (settling?.owner === ai.playerId && settling.own?.order === "move") return;
+		const type = ai.registry.unit(live.def.type);
+		const settler = view.mine.where((entity, def) => !!def.builds?.includes(type.id) && !!entity.own && !entity.own.hidden && !snapshotOf(entity, gathering)?.carrying).nearest(to);
+		if (!settler) return;
+		live.memory.settler = settler.id;
+		ai.send({
+			type: "order",
+			entities: [settler.id],
+			order: {
+				type: "move",
+				point: this.settlePoint(to)
+			}
+		});
+		ai.decide(`sends a worker to see the ground at ${where(to)}, for ${an(live.def.type)}`, { kind: "build" });
+	}
+	/**
+	* Builds a type now, outside any want: a spot near a place (home when left out), a builder, the purse. What a
+	* module does for a one-off (the melee player's building on a mine). Whether it was sent
+	*/
+	build(type, options = {}) {
+		const { ai } = this;
+		const { view, purse } = ai;
+		const def = typeof type === "string" ? ai.registry.unit(type) : type;
+		if (!view.has(def.requires) || !purse.affords(def.cost, options.spare ?? 0)) return false;
+		const near = options.near ?? view.home() ?? view.mine.where((_, each) => !!each.builds?.includes(def.id)).first();
+		if (!near) return false;
+		const site = this.site(def, {
+			near: {
+				x: near.x,
+				z: near.z
+			},
+			within: options.within ?? this.options.within ?? WITHIN
+		}, options.placement);
+		if (!site) return false;
+		const builder = this.builderFor(def, site);
+		if (!builder || !purse.spend(def.cost)) return false;
+		this.sent.add(builder.id);
+		ai.send({
+			type: "order",
+			entities: [builder.id],
+			order: {
+				type: "build",
+				unitType: def.id,
+				point: site
+			}
+		});
+		ai.decide(`builds ${an(def.id)} at ${where(site)}${options.by ? `, for ${options.by}` : ""}`, { kind: "build" });
+		return true;
+	}
+	/**
+	* Mends: a worker sent to a damaged building of the player's that no enemy strength reaches, one a think, when
+	* the purse has what the mending will cost (`RuleSettings.economy.repairCost` of what is missing). Not one being mended already
+	*/
+	mend() {
+		const { ai } = this;
+		const { view, purse, registry } = ai;
+		const share = registry.settings.economy.repairCost;
+		for (const building of view.mine.buildings().finished()) {
+			const def = view.def(building);
+			const maxHp = building.maxHealth ?? baseStats(def, registry).health;
+			if (!(building.health < maxHp * MEND_UNDER) || !def.cost) continue;
+			if (ai.threat.at(building).enemy > 0) continue;
+			if (view.mine.where((entity, each) => !!each.builds?.length && entity.own?.order === "repair" && distSq(entity, building) < 36).length) continue;
+			const missing = 1 - building.health / maxHp;
+			const price = {};
+			for (const kind in def.cost) price[kind] = Math.ceil(def.cost[kind] * share * missing);
+			if (!purse.affords(price)) continue;
+			const worker = this.builderFor(def, building);
+			if (!worker || !worker.own || worker.own.order === "build") continue;
+			purse.spend(price);
+			this.sent.add(worker.id);
+			ai.send({
+				type: "order",
+				entities: [worker.id],
+				order: {
+					type: "repair",
+					target: building.id
+				}
+			});
+			ai.decide(`mends its ${def.id} at ${where(building)}: ${Math.round(missing * 100)}% gone, nobody near it`, { kind: "build" });
+			return;
+		}
+	}
+	/** The wants in the order they were added: what the report and a save list them in, the same in a loaded game */
+	ordered() {
+		return [...this.wants.values()].sort((a, b) => a.memory.order - b.memory.order);
+	}
+	/** Every want as the last think left it, in the order added, the one saving up named */
+	report() {
+		return {
+			wants: this.ordered().map((live) => ({
+				id: live.id,
+				type: live.def.type,
+				count: live.count,
+				have: live.have,
+				onItsWay: live.onItsWay,
+				priority: live.def.priority ?? 0,
+				...live.def.by !== void 0 && { by: live.def.by },
+				...live.def.keep && { keep: true },
+				status: live.status,
+				steps: [...live.steps],
+				...live.holds && { holds: { ...live.holds } }
+			})),
+			...this.saving !== void 0 && { saving: this.saving }
+		};
+	}
+	/**
+	* What it remembers, for a save: each standing want's memory (its code gives the want again), and the wants added
+	* as the game went that are plain data, whole. A want that does not stand and has code in it is not kept: the
+	* game loaded from the save would not know when the game saved from would have dropped it
+	*/
+	save() {
+		const wants = [];
+		for (const live of this.ordered()) if (live.def.keep) wants.push({
+			id: live.id,
+			memory: { ...live.memory }
+		});
+		else if (isData(live.def)) wants.push({
+			id: live.id,
+			memory: { ...live.memory },
+			data: structuredClone(live.def)
+		});
+		for (const id in this.pending) wants.push({
+			id,
+			memory: { ...this.pending[id] }
+		});
+		wants.sort((a, b) => a.memory.order - b.memory.order);
+		return {
+			v: 1,
+			wants,
+			added: this.added,
+			...this.saving !== void 0 && { saving: this.saving }
+		};
+	}
+	/** Takes back what `save` gave: whether it was read. The data wants are had again; memory waits for the wants code adds */
+	restore(memory) {
+		const given = memory;
+		if (!given || typeof given !== "object" || given.v !== 1 || !Array.isArray(given.wants)) return false;
+		this.pending = {};
+		if (typeof given.added === "number") this.added = Math.max(this.added, given.added);
+		this.saving = typeof given.saving === "string" ? given.saving : void 0;
+		for (const entry of given.wants) {
+			if (!entry || typeof entry.id !== "string") continue;
+			const live = this.wants.get(entry.id);
+			if (live) live.memory = { ...entry.memory };
+			else this.pending[entry.id] = { ...entry.memory };
+			if (entry.data && !live) this.want({
+				...entry.data,
+				id: entry.id
+			});
+		}
+		return true;
+	}
+};
+/**
+* The build module: runs the brain's build plan (`ai.plans.build.think()`) in its place among a brain's modules, after
+* what adds wants (rules, goals) and before what gives idle workers something else to do. With options for the plan
+*
+* @beta
+*/
+var build = (options = {}) => defineModule({
+	id: "build",
+	make: (ai) => {
+		ai.plans.build.configure(options);
+		return {
+			id: "build",
+			phase: "plan",
+			think: () => ai.plans.build.think()
+		};
+	}
+});
+//#endregion
+export { BuildPlan, build };
+
+//# sourceMappingURL=build.js.map