@v12-engine/engine 0.1.1 → 0.4.0

package/dist/ai/micro.js

@@ -0,0 +1,1316 @@
+import { distSq } from "../math.js";
+import { anyEffect, at, baseStats, declaredAt, lowerChain, supplyOf } from "../defs.js";
+import { snapshotOf } from "../components.js";
+import { inventorySlots } from "../inventory.js";
+import { heroOfState } from "../hero.js";
+import { farthestReach } from "../attacks.js";
+import { AIM_KINDS } from "../targeting.js";
+import { shopStock } from "../items.js";
+import { defineModule } from "./module.js";
+import "./reach.js";
+import { UnitSet } from "./view.js";
+import { evaluate } from "./rules.js";
+import { an, pair, point, where } from "./geometry.js";
+import { orderKey } from "./checks.js";
+import { defineTask } from "./task.js";
+//#region src/ai/micro.ts
+/** Seconds a squad keeps hitting the one it was told to, before it is chosen again */
+var FOCUS_EVERY = 4;
+/** Seconds between two steps back of one unit: what keeps a kiting unit from stuttering */
+var KITE_EVERY = 3;
+/** How near a melee foe comes, past its own reach, before a ranged unit steps back */
+var KITE_CLOSE = 3;
+/** How much faster than the foe a unit is to step back from it: as fast is not enough, the foe is on it again as it stops */
+var KITE_FASTER = 1.05;
+/** How far from the middle of its squad a kiting unit may step, past the squad's spread */
+var KITE_LEASH = 1;
+/** The odds under which a unit does not bother kiting: its squad falls back, or fights on to the last */
+var KITE_ODDS = .3;
+/** Seconds between two orders of a siege unit */
+var SIEGE_EVERY = 4;
+/** How near a siege unit a foe is for the unit to be threatened: it shoots what threatens it, not buildings */
+var SIEGE_THREATENED = 6;
+/** How far behind the squad's middle a siege unit ahead of it is sent */
+var SIEGE_BEHIND = 3;
+/** Seconds a fled unit with nothing to heal it waits in safety before it is back */
+var FLEE_SAFE = 8;
+/**
+* Seconds of its own healing a fled unit is worth waiting for: one that would take longer to be back at `returnAt` (a
+* trickle of regeneration) is as one nothing heals, and comes back once safe, rather than sitting out the game
+*/
+var HEAL_WAIT = 60;
+/** How far a unit with nowhere safe to go runs from the fight */
+var FLEE_AWAY = 20;
+/** Seconds before a fleeing unit standing idle short of its destination is sent again */
+var FLEE_RESEND = 3;
+/** How far a shop may be for a hero to walk to it: not across the map */
+var SHOP_REACH = 60;
+/** How near a shop a hero is at it: the engine's shop range (6), a little in */
+var AT_SHOP = 5;
+/** How important an item is to the purse: under a hero (35), over what can wait */
+var SHOPPING_PRIORITY = 20;
+/** How important a mercenary is to the purse: under an item, over the soldiers trained (0) */
+var HIRING_PRIORITY = 10;
+/** Money to have left over before hiring of itself (the kit's choice): a mercenary is bought with what would lie idle */
+var HIRING_SPARE = 150;
+/** Mercenaries it keeps at the most, of the kit's choice */
+var HIRING_MOST = 4;
+/** The share of its health under which a unit drinks what heals, and of its mana under which it drinks what restores */
+var DRINK_HEALTH = .45;
+var DRINK_MANA = .25;
+/** The squad the micro module keeps the units that fled in */
+var FLEEING = "fleeing";
+/** Whose the fleeing squad is */
+var OWNER = "micro";
+/** The kit's rules of who is worth hitting first: casters, healers, heroes, siege; everyone else is worth 1 */
+var DEFAULT_TARGETS = [
+	{
+		match: "caster",
+		weight: 2
+	},
+	{
+		match: "healer",
+		weight: 2
+	},
+	{
+		match: "hero",
+		weight: 1.5
+	},
+	{
+		match: "siege",
+		weight: 1
+	}
+];
+var percent = (share) => `${Math.round(share * 100)}%`;
+/**
+* A brain's micro (`ai.micro`): how its squads fight once in a fight, run by the `micro()` module each think after the
+* squads (`think`), and asked by whoever wants its judgement (`target`, `priority`, `nextHero`, `nextSkill`). Kept in
+* the brain's memory (`BrainMemory.micro`)
+*
+* @internal
+*/
+var Micro = class Micro {
+	ai;
+	/** What finds it on a brain (`ai.area(Micro)`): made the first time a module asks for it */
+	static id = "micro";
+	/** Makes the micro of a brain; what `ai.area(Micro)` calls the first time a module asks for it */
+	static make(ai) {
+		return new Micro(ai);
+	}
+	/** Its id among the brain's areas: what its memory and its report are kept under */
+	id = "micro";
+	/** What the log says where a save's memory of it is of a shape it does not read */
+	afresh = "the save remembers how the computer player was fighting in a shape this brain does not read: it fights afresh";
+	/** What the module was made with, under the brain's settings */
+	configured = {};
+	/** Whether a `micro()` module is in the brain: without one, nothing here runs by itself, and the squads fight as units do */
+	enabled = false;
+	memory = {
+		v: 1,
+		focus: {},
+		kited: {},
+		fled: {},
+		siege: {},
+		shopping: {},
+		rolled: {}
+	};
+	fights = [];
+	cast = 0;
+	/** Thinks its fights were left alone, a slip of its profile's `mistakes` */
+	slipped = 0;
+	thoughtAt = {};
+	constructor(ai) {
+		this.ai = ai;
+		ai.squads.define(FLEE);
+	}
+	/** Puts the `micro()` module's options under the brain's settings: what the module is made with */
+	configure(options) {
+		this.configured = options;
+		this.enabled = true;
+	}
+	/** How it fights: the module's options, the brain's settings over them (`ai.settings.micro`: when units and heroes flee, the flags) */
+	get options() {
+		return this.ai.cache("micro.options", () => ({
+			...this.configured,
+			...this.ai.settings.micro
+		}));
+	}
+	/** Whether the module fights for a squad: one on a task that fights (`TaskDef.fighting`), not told to be left alone (`SquadOptions.micro`) */
+	manages(squad) {
+		const state = squad.current;
+		return this.enabled && squad.options.micro !== false && !!state && state.done === void 0 && this.ai.squads.taskDef(state.kind)?.fighting !== false;
+	}
+	/**
+	* The whole think: the fights (focus fire, kiting, siege, fleeing), those that fled coming back, the spells, the
+	* items, the heroes' skills. Each part once a think: a part the melee player's steps asked for already is not done again
+	*/
+	think() {
+		const mistakes = this.ai.profile.mistakes ?? 0;
+		if (!this.fighting && mistakes > 0 && this.ai.rng.next() < mistakes) {
+			this.slipped++;
+			this.done("fights");
+		}
+		if (!this.fight()) return;
+		this.spells();
+		this.items();
+		this.heroes();
+	}
+	/**
+	* The fights: each squad in one looked at, its units told whom to hit, stepped back, sent to shoot buildings, sent to
+	* safety; and the fled coming back. The squads are looked at as many a tick as the budget has room for (F2,
+	* `ai.budget`): false where it stopped for the tick with squads to go, to go on at the next over the same picture
+	*/
+	fight() {
+		const { ai } = this;
+		const { view } = ai;
+		if (!this.fighting) {
+			if (!this.begin("fights")) return true;
+			this.prune();
+			this.fights = [];
+			const focused = this.memory.focus;
+			for (const name in focused) {
+				const squad = ai.squads.named(name);
+				if (!squad || !this.manages(squad)) delete focused[name];
+			}
+			this.fighting = {
+				squads: view.hostile.alive().length ? [...ai.squads.all()].filter((squad) => this.manages(squad)) : [],
+				at: 0
+			};
+		}
+		const hostile = view.hostile.alive();
+		const { squads } = this.fighting;
+		for (; this.fighting.at < squads.length; this.fighting.at++) {
+			const looked = this.fightOf(squads[this.fighting.at], hostile);
+			if (!ai.budget.spent(looked || 1) && this.fighting.at + 1 < squads.length) {
+				this.fighting.at++;
+				ai.budget.later();
+				return false;
+			}
+		}
+		this.fighting = void 0;
+		this.injured();
+		this.back();
+		return true;
+	}
+	/** One squad's fight, if it is in one: its units told whom to hit, stepped back, sent at buildings, sent to safety. Gives how many units were looked at */
+	fightOf(squad, hostile) {
+		const { view } = this.ai;
+		const focused = this.memory.focus;
+		const units = squad.units();
+		const middle = units.centre();
+		if (!middle) return 0;
+		const foes = hostile.near(middle, 14).where((entity, def) => !entity.asleep && (def.kind === "unit" || !!def.attacks?.length));
+		if (!foes.length) {
+			delete focused[squad.name];
+			return units.length;
+		}
+		const fight = {
+			squad,
+			units,
+			middle,
+			foes,
+			odds: view.strength.odds(units, foes),
+			kiting: [],
+			siege: []
+		};
+		this.fights.push(fight);
+		this.flee(fight);
+		fight.units = squad.units();
+		if (!fight.units.length) return units.length;
+		this.siegeOf(fight);
+		this.kite(fight);
+		this.focus(fight);
+		return units.length;
+	}
+	/** The squads still to be looked at for a fight this think, where a pass stopped for the tick's budget, and the next of them */
+	fighting;
+	/**
+	* How much a foe is worth hitting: what its type declares (`UnitTypeDef.ai.priority`, 1 when it says nothing) times
+	* one and the weights of the rules that pick it out (`targets`, the kit's when none are given)
+	*/
+	priority(foe) {
+		const { view } = this.ai;
+		const def = view.def(foe);
+		let worth = 1;
+		const rules = Array.isArray(this.options.targets) ? this.options.targets : DEFAULT_TARGETS;
+		for (const rule of rules) {
+			if (rule.match === "hero" && this.options.targetHeroes === false && !Array.isArray(this.options.targets)) continue;
+			if (!this.matches(rule.match, foe, def)) continue;
+			if (rule.when !== void 0 && !evaluate(rule.when, this.ai)) continue;
+			worth += rule.weight ?? 1;
+		}
+		return (def.ai?.priority ?? 1) * worth;
+	}
+	/** Whether a rule's word picks a foe out: `building`, a role, a tag, a type */
+	matches(match, foe, def) {
+		if (match === "building") return def.kind === "building";
+		const { roles } = this.ai.view;
+		return foe.type === match || roles.has(foe.type, match) || roles.hasTag(foe.type, match);
+	}
+	/**
+	* Whom a squad in a fight hits: the foe worth most (`priority`), the weakest among those alike (what falls soonest
+	* deals no more damage), the nearest among those alike too; or what the game's picker says (`targets` as a function)
+	*/
+	target(squad, foes) {
+		if (typeof this.options.targets === "function") return this.options.targets(this.ai, squad, foes);
+		const prey = this.preyOf(squad, foes);
+		if (prey) return prey;
+		const middle = squad.centre();
+		if (!middle || !foes.length) return void 0;
+		let best;
+		let most = -Infinity;
+		for (const foe of foes) {
+			const stats = this.ai.view.strength.statsOf(foe);
+			const health = Math.max(0, Math.min(1, foe.health / Math.max(1, foe.maxHealth ?? stats.health)));
+			const near = 1 - .2 * Math.min(1, Math.sqrt(distSq(foe, middle)) / 14);
+			const score = this.priority(foe) * (2 - health) * near;
+			if (score > most) {
+				most = score;
+				best = foe;
+			}
+		}
+		return best;
+	}
+	/**
+	* What the squad's task wants hit first, where it is among the foes: a harass's worker (`TaskState.memory.prey`). The
+	* task names it and the micro module, fighting for the squad, sends the order: one of them, not both, or the units are
+	* told the same twice
+	*/
+	preyOf(squad, foes) {
+		const prey = squad.current?.memory.prey;
+		return typeof prey === "number" ? foes.find((foe) => foe.id === prey) : void 0;
+	}
+	/**
+	* All of a squad on one rival: chosen again once it fell or every `focusEvery` seconds, the units within reach of it
+	* told to attack it, and then, queued, to go on with the squad's errand. The healers are left to their spells, the
+	* siege to its buildings, what stepped back this think to its step
+	*/
+	focus(fight) {
+		const { ai } = this;
+		const { squad, foes, units } = fight;
+		const every = (this.options.focusEvery ?? FOCUS_EVERY) * ai.session.tickRate;
+		const kept = this.memory.focus[squad.name];
+		const current = kept && foes.find((foe) => foe.id === kept.target);
+		const prey = this.preyOf(squad, foes);
+		if (current && ai.tick - kept.since < every && (!prey || prey.id === current.id)) {
+			fight.target = current;
+			return;
+		}
+		const target = this.target(squad, foes);
+		if (!target) {
+			delete this.memory.focus[squad.name];
+			return;
+		}
+		this.memory.focus[squad.name] = {
+			target: target.id,
+			since: ai.tick
+		};
+		fight.target = target;
+		const again = kept?.target === target.id;
+		if (squad.current?.kind === "defend") squad.current.memory.foe = target.id;
+		const { roles } = ai.view;
+		const reach = 196;
+		const told = orderKey({
+			type: "attack",
+			entities: [],
+			point: point(target),
+			target: target.id
+		});
+		const toldAlready = (unit) => {
+			const sent = ai.sentTo(unit.id);
+			return !!sent && sent.key === told && (unit.own?.order === "attack" || sent.tick >= ai.snapshot.tick);
+		};
+		const hitters = units.filter((unit) => distSq(unit, target) < reach && !unit.own?.hidden && !roles.has(unit.type, "healer") && !fight.kiting.includes(unit.id) && !fight.siege.includes(unit.id) && !(again && (unit.own?.order === "attack" || unit.own?.order === "cast")) && !toldAlready(unit));
+		if (!hitters.length) return;
+		const entities = hitters.map((unit) => unit.id);
+		ai.send({
+			type: "attack",
+			entities,
+			point: point(target),
+			target: target.id
+		});
+		const on = ai.squads.whereOf(squad) ?? fight.middle;
+		ai.send({
+			type: "attack",
+			entities,
+			point: point(on),
+			queue: true
+		});
+	}
+	/**
+	* The ranged units of a squad closed on by melee they can outrun step back as far as their reach, within the squad's
+	* spread, then go on with the fight: no more than once every few seconds each, and not when the squad is losing (it
+	* falls back, or fights to the last)
+	*/
+	kite(fight) {
+		if ((this.options.kite ?? "ranged") === false || fight.odds < KITE_ODDS) return;
+		const { ai } = this;
+		const { view } = ai;
+		const { roles } = view;
+		const every = KITE_EVERY * ai.session.tickRate;
+		const melee = fight.foes.where((_, def) => def.kind === "unit" && !!def.attacks?.length && !def.attacks.some((attack) => attack.projectileSpeed));
+		if (!melee.length) return;
+		const spread = fight.squad.spread() + KITE_LEASH;
+		const { width, depth } = ai.session.terrain;
+		const on = ai.squads.whereOf(fight.squad) ?? fight.middle;
+		for (const unit of fight.units) {
+			if (!roles.hasTag(unit.type, "ranged") || unit.own?.hidden) continue;
+			const last = this.memory.kited[unit.id];
+			if (last !== void 0 && ai.tick - last < every) continue;
+			let closest;
+			let closestAt = Infinity;
+			for (const foe of melee) {
+				const d = distSq(unit, foe);
+				if (d < closestAt) {
+					closestAt = d;
+					closest = foe;
+				}
+			}
+			if (!closest) continue;
+			const theirs = view.strength.statsOf(closest);
+			const close = farthestReach(view.def(closest), theirs) + KITE_CLOSE;
+			if (closestAt > close * close) continue;
+			const mine = view.strength.statsOf(unit);
+			if (mine.moveSpeed < theirs.moveSpeed * KITE_FASTER) continue;
+			const range = farthestReach(view.def(unit), mine);
+			const step = Math.max(2, range - 1);
+			const dx = unit.x - closest.x;
+			const dz = unit.z - closest.z;
+			const length = Math.sqrt(dx * dx + dz * dz) || 1;
+			let to = {
+				x: unit.x + dx / length * step,
+				z: unit.z + dz / length * step
+			};
+			const fromMiddle = Math.sqrt(distSq(to, fight.middle));
+			if (fromMiddle > spread) to = {
+				x: fight.middle.x + (to.x - fight.middle.x) / fromMiddle * spread,
+				z: fight.middle.z + (to.z - fight.middle.z) / fromMiddle * spread
+			};
+			to = {
+				x: Math.min(width - 1, Math.max(1, to.x)),
+				z: Math.min(depth - 1, Math.max(1, to.z))
+			};
+			if (distSq(to, unit) < 2.25) continue;
+			this.memory.kited[unit.id] = ai.tick;
+			fight.kiting.push(unit.id);
+			ai.send({
+				type: "order",
+				entities: [unit.id],
+				order: {
+					type: "move",
+					point: to
+				}
+			});
+			ai.send({
+				type: "attack",
+				entities: [unit.id],
+				point: point(on),
+				queue: true
+			});
+		}
+	}
+	/**
+	* The siege units of a squad shoot buildings when there are any in their reach and no foe is upon them, and one
+	* that got ahead of the squad's middle is sent behind it: artillery is for walls, and dies to whatever reaches it
+	*/
+	siegeOf(fight) {
+		if (this.options.smartArtillery === false) return;
+		const { ai } = this;
+		const { view } = ai;
+		const siege = fight.units.withRole("siege");
+		if (!siege.length) return;
+		const every = SIEGE_EVERY * ai.session.tickRate;
+		const threats = fight.foes.units();
+		const buildings = view.hostile.alive().buildings();
+		const on = ai.squads.whereOf(fight.squad) ?? fight.middle;
+		for (const unit of siege) {
+			if (unit.own?.hidden) continue;
+			const kept = this.memory.siege[unit.id];
+			if (threats.near(unit, SIEGE_THREATENED).length > 0) {
+				delete this.memory.siege[unit.id];
+				continue;
+			}
+			const range = farthestReach(view.def(unit), view.strength.statsOf(unit)) + 2;
+			const near = buildings.near(unit, range).visible();
+			const current = kept && near.find((building) => building.id === kept.target);
+			if (near.length && (!current || ai.tick - kept.since >= every)) {
+				const target = near.filter((building) => !!view.def(building).attacks?.length).sort((a, b) => distSq(a, unit) - distSq(b, unit))[0] ?? near.nearest(unit);
+				if (!current || current.id !== target.id) {
+					this.memory.siege[unit.id] = {
+						target: target.id,
+						since: ai.tick
+					};
+					ai.send({
+						type: "attack",
+						entities: [unit.id],
+						point: point(target),
+						target: target.id
+					});
+					ai.send({
+						type: "attack",
+						entities: [unit.id],
+						point: point(on),
+						queue: true
+					});
+					ai.decide(`${unit.type} ${unit.id} turns to the ${target.type} at ${where(target)}`, { kind: "micro" });
+				} else this.memory.siege[unit.id].since = ai.tick;
+				fight.siege.push(unit.id);
+				continue;
+			}
+			if (current) fight.siege.push(unit.id);
+			const foe = threats.nearest(unit);
+			if (!foe) continue;
+			if (Math.sqrt(distSq(fight.middle, foe)) - Math.sqrt(distSq(unit, foe)) <= 2 || kept && ai.tick - kept.since < every) continue;
+			const dx = fight.middle.x - foe.x;
+			const dz = fight.middle.z - foe.z;
+			const length = Math.sqrt(dx * dx + dz * dz) || 1;
+			const to = {
+				x: fight.middle.x + dx / length * SIEGE_BEHIND,
+				z: fight.middle.z + dz / length * SIEGE_BEHIND
+			};
+			this.memory.siege[unit.id] = {
+				target: 0,
+				since: ai.tick
+			};
+			fight.siege.push(unit.id);
+			ai.send({
+				type: "order",
+				entities: [unit.id],
+				order: {
+					type: "move",
+					point: to
+				}
+			});
+			ai.send({
+				type: "attack",
+				entities: [unit.id],
+				point: point(on),
+				queue: true
+			});
+		}
+	}
+	/** The share of its health under which a unit leaves a fight: heroes and units each their own; none for one that never does */
+	fleeAt(unit) {
+		const at = this.ai.view.hasRole(unit, "hero") ? this.options.heroesFlee ?? .35 : this.options.unitsFlee ?? .25;
+		return at === false || !(at > 0) ? void 0 : at;
+	}
+	/** How much of its health a unit has, 0 to 1 */
+	healthOf(unit) {
+		const stats = this.ai.view.strength.statsOf(unit);
+		return Math.max(0, Math.min(1, unit.health / Math.max(1, unit.maxHealth ?? stats.health)));
+	}
+	/** The units of a squad in a fight about to die leave it for safety */
+	flee(fight) {
+		for (const unit of fight.units) {
+			const at = this.fleeAt(unit);
+			if (at === void 0 || unit.own?.hidden) continue;
+			if (this.healthOf(unit) >= at) continue;
+			if (!fight.foes.some((foe) => distSq(unit, foe) <= 64)) continue;
+			this.sendToSafety(unit, fight.squad, "hurt");
+		}
+	}
+	/** With `removeInjuries`, the hurt units with something to heal them go home between fights */
+	injured() {
+		if (!this.options.removeInjuries) return;
+		const { ai } = this;
+		const { view } = ai;
+		const back = this.options.returnAt ?? .8;
+		const hostile = view.hostile.alive();
+		for (const squad of ai.squads.all()) {
+			if (!this.manages(squad) || this.fights.some((fight) => fight.squad === squad)) continue;
+			for (const unit of squad.units()) {
+				if (unit.own?.hidden || this.healthOf(unit) >= back) continue;
+				if (view.strength.statsOf(unit).healthRegen <= 0) continue;
+				if (hostile.near(unit, 14).length) continue;
+				this.sendToSafety(unit, squad, "injured");
+			}
+		}
+	}
+	/**
+	* Where a unit is safe: the nearest of its own finished buildings that no enemy strength reaches, else any of them,
+	* else home, else away from the foes
+	*/
+	safety(unit, foes) {
+		const { view } = this.ai;
+		const buildings = view.mine.buildings().finished();
+		let best;
+		let bestAt = Infinity;
+		let safe = false;
+		for (const building of buildings) {
+			const quiet = view.threat.at(building).enemy === 0;
+			if (safe && !quiet) continue;
+			const d = distSq(unit, building);
+			if (quiet && !safe || d < bestAt) {
+				best = building;
+				bestAt = d;
+				safe = quiet;
+			}
+		}
+		if (best) return point(best);
+		const home = view.home();
+		if (home) return point(home);
+		const foe = foes.nearest(unit);
+		const dx = foe ? unit.x - foe.x : 1;
+		const dz = foe ? unit.z - foe.z : 0;
+		const length = Math.sqrt(dx * dx + dz * dz) || 1;
+		const { width, depth } = this.ai.session.terrain;
+		return {
+			x: Math.min(width - 1, Math.max(1, unit.x + dx / length * FLEE_AWAY)),
+			z: Math.min(depth - 1, Math.max(1, unit.z + dz / length * FLEE_AWAY))
+		};
+	}
+	/** Takes a unit out of its squad into the `fleeing` squad and sends it to safety; the squad's task goes on without it */
+	sendToSafety(unit, from, why) {
+		const { ai } = this;
+		const to = this.safety(unit, ai.view.hostile.alive());
+		const fleeing = ai.squads.named(FLEEING) ?? ai.squads.make(FLEEING, [], {
+			owner: OWNER,
+			retreatAt: false,
+			regroupWhen: false,
+			micro: false
+		});
+		if (!fleeing.current) fleeing.task(FLEE.id);
+		fleeing.add([unit.id], why === "hurt" ? "fled" : "sent to heal");
+		if (!fleeing.data.units.includes(unit.id)) return;
+		this.memory.fled[unit.id] = {
+			squad: from.name,
+			since: ai.tick,
+			to,
+			why
+		};
+		const state = fleeing.current;
+		if (state.phase === "starting") {
+			state.phase = "fleeing";
+			state.phaseSince = ai.tick;
+		}
+		state.memory.to ??= {};
+		state.memory.to[unit.id] = to;
+		ai.send({
+			type: "order",
+			entities: [unit.id],
+			order: {
+				type: "move",
+				point: to
+			}
+		});
+		ai.decide(why === "hurt" ? `${unit.type} ${unit.id} flees at ${percent(this.healthOf(unit))} to ${where(to)}` : `${unit.type} ${unit.id} goes to heal at ${where(to)}: ${percent(this.healthOf(unit))}`, { kind: "micro" });
+	}
+	/**
+	* Those that fled come back: at `returnAt` of their health, or, with nothing to heal them (or healing too slowly to
+	* wait for: `HEAL_WAIT`) and `ignoreInjured` not set, once safe for a while, to the pool at home. Back to the squad they left when it is still there, sent to it; else to the pool
+	*/
+	back() {
+		const { ai } = this;
+		const { view } = ai;
+		const fleeing = ai.squads.named(FLEEING);
+		if (!fleeing) {
+			this.memory.fled = {};
+			return;
+		}
+		const back = this.options.returnAt ?? .8;
+		const hostile = view.hostile.alive();
+		const state = fleeing.current;
+		for (const unit of fleeing.units()) {
+			const fled = this.memory.fled[unit.id];
+			const health = this.healthOf(unit);
+			const healed = health >= back;
+			const stats = view.strength.statsOf(unit);
+			const slow = stats.healthRegen <= 0 || (back - health) * stats.health / stats.healthRegen > HEAL_WAIT;
+			let safe = false;
+			if (!healed && !this.options.ignoreInjured && slow) {
+				const since = fled?.since ?? fleeing.current?.since ?? ai.tick;
+				safe = ai.tick - since >= FLEE_SAFE * ai.session.tickRate && !hostile.near(unit, 14).length;
+			}
+			if (!healed && !safe) continue;
+			fleeing.remove([unit.id], "back");
+			if (state) delete state.memory.to?.[unit.id];
+			delete this.memory.fled[unit.id];
+			const squad = healed && fled?.squad ? ai.squads.named(fled.squad) : void 0;
+			if (squad && squad.alive && !squad.idle) {
+				squad.add([unit.id], "back from fleeing");
+				const join = squad.centre() ?? ai.squads.whereOf(squad);
+				if (squad.data.units.includes(unit.id) && join) ai.send({
+					type: "attack",
+					entities: [unit.id],
+					point: point(join)
+				});
+				ai.decide(`${unit.type} ${unit.id} back with ${squad.name} at ${percent(health)}`, { kind: "micro" });
+			} else ai.decide(`${unit.type} ${unit.id} back at ${percent(health)}`, { kind: "micro" });
+		}
+		if (!fleeing.data.units.length) fleeing.disband("no one fleeing");
+	}
+	/**
+	* Has units use the abilities that have to be aimed, where there is a fight near them: the brain's say first
+	* (`spells`), then the ability's own (`AbilityDef.ai`), then what the kit works out from the effects (`aim`). The
+	* ones on autocast look after themselves
+	*/
+	spells() {
+		if (!this.begin("spells")) return;
+		this.cast = 0;
+		if (this.options.spells === false) return;
+		const { ai } = this;
+		const { view } = ai;
+		const { registry } = view;
+		const enemies = view.hostile.units().alive();
+		if (!enemies.length) return;
+		const friends = view.all.visible().units().where((entity, def) => !view.isHostile(entity) && !!def.attacks?.length);
+		for (const caster of view.mine) {
+			if (!caster.own?.abilities?.length || caster.own.hidden || caster.own.order === "cast") continue;
+			if (!enemies.near(caster, 12).length) continue;
+			for (const state of caster.own.abilities) {
+				const ability = registry.ability(state.id);
+				if (state.level < 1 || state.cooldown > 0 || state.charges === 0 || ability.target === "passive" || state.autocast) continue;
+				const rate = healthRate(registry, caster);
+				const cost = at(ability.manaCost, state.level);
+				if (rate > 0 ? cost * rate >= caster.health : cost > (caster.mana ?? 0)) continue;
+				const attacks = ability.attackRange ? view.strength.statsOf(caster).attackRange : 0;
+				const foes = enemies.near(caster, at(ability.range, state.level) + attacks + 4).items;
+				const near = friends.near(caster, 12).items;
+				const aim = this.aim(caster, ability, state.level, foes, near);
+				if (!aim) continue;
+				ai.send({
+					type: "cast",
+					entities: [caster.id],
+					ability: ability.id,
+					point: point(aim.point),
+					target: aim.target,
+					...aim.to && { to: point(aim.to) }
+				});
+				this.cast++;
+				break;
+			}
+		}
+	}
+	/**
+	* Where to use an ability, or nothing when there is nothing worth it: the brain's `spells`, the ability's `ai`, then
+	* from its effects (a heal on the friend hurt most, something harmful on the nearest, an area where it catches most)
+	*/
+	aim(caster, ability, level, enemies, friends) {
+		const { ai } = this;
+		const { view } = ai;
+		const { registry } = view;
+		const own = this.options.spells && this.options.spells[ability.id];
+		if (own) {
+			const decided = own(ai, caster, enemies, friends, level);
+			if (decided !== void 0) return decided ?? void 0;
+		}
+		if (ability.ai) {
+			const decided = ability.ai({
+				snapshot: ai.snapshot,
+				registry,
+				playerId: ai.playerId,
+				enemies: [...enemies],
+				friends: [...friends]
+			}, caster, level);
+			if (decided !== void 0) return decided ?? void 0;
+		}
+		if (!AIM_KINDS.includes(ability.target)) return void 0;
+		const harmful = (id) => !!id && !!registry.buff(id).harmful;
+		const now = lowerChain(ability.effects);
+		const hurts = now.flatMap((effect) => [effect, ...anyEffect(effect).effects ?? []]).some((effect) => effect.type === "damage" || effect.type === "buff" && harmful(effect.buff));
+		const layers = ability.targets?.layers ?? now.find((effect) => effect.layers)?.layers;
+		if (layers) enemies = enemies.filter((enemy) => layers.includes(view.def(enemy).flying ? "air" : "ground"));
+		const heals = now.find((effect) => effect.type === "heal");
+		const area = now.reduce((max, effect) => Math.max(max, declaredAt(effect.radius, level)), 0);
+		const maxHp = (entity) => entity.maxHealth ?? baseStats(view.def(entity), registry).health;
+		const nearest = (candidates) => {
+			let best;
+			let bestAt = Infinity;
+			for (const candidate of candidates) {
+				const d = distSq(caster, candidate);
+				if (d < bestAt) {
+					bestAt = d;
+					best = candidate;
+				}
+			}
+			return best;
+		};
+		if (ability.target === "unit") {
+			if (heals) {
+				const need = declaredAt(heals.amount, level) * .6;
+				const hurt = friends.filter((friend) => friend.id !== caster.id && maxHp(friend) - friend.health >= need).sort((a, b) => a.health / maxHp(a) - b.health / maxHp(b))[0];
+				return hurt && {
+					point: hurt,
+					target: hurt.id
+				};
+			}
+			if (hurts) {
+				const target = nearest(enemies);
+				return target && {
+					point: target,
+					target: target.id
+				};
+			}
+			const buff = now.find((effect) => effect.type === "buff")?.buff;
+			const target = friends.find((friend) => !friend.buffs?.includes(buff ?? ""));
+			return target && {
+				point: target,
+				target: target.id
+			};
+		}
+		if (ability.target === "vector") {
+			const target = nearest(enemies);
+			const reach = at(ability.range, level);
+			if (!target || distSq(caster, target) > reach * reach) return void 0;
+			const gap = Math.sqrt(distSq(caster, target)) || 1;
+			const on = {
+				x: target.x + (target.x - caster.x) / gap,
+				z: target.z + (target.z - caster.z) / gap
+			};
+			return {
+				point: {
+					x: target.x,
+					z: target.z
+				},
+				to: on
+			};
+		}
+		if (ability.target === "direction") {
+			const missile = now.find((effect) => effect.type === "missile");
+			const reach = at(missile?.distance, level, 10);
+			const target = nearest(enemies);
+			return target && distSq(caster, target) <= reach * reach ? { point: {
+				x: target.x,
+				z: target.z
+			} } : void 0;
+		}
+		if (hurts) {
+			const centres = ability.target === "none" ? [caster] : enemies;
+			const reach = area || 3;
+			const need = ability.ultimate || ability.requiresLevel ? 4 : 2;
+			let best;
+			let most = need - 1;
+			for (const centre of centres) {
+				const caught = enemies.filter((enemy) => distSq(centre, enemy) <= reach * reach).length;
+				if (caught > most) {
+					most = caught;
+					best = centre;
+				}
+			}
+			return best && { point: {
+				x: best.x,
+				z: best.z
+			} };
+		}
+		return enemies.some((enemy) => distSq(caster, enemy) < 64) ? { point: caster } : void 0;
+	}
+	/** Has units drink their potions when they need them, pick up what lies around, and heroes shop for what their list says */
+	items() {
+		if (!this.begin("items")) return;
+		const { ai } = this;
+		const { view } = ai;
+		const { registry } = view;
+		const potions = this.options.potions !== false;
+		const takeItems = this.options.takeItems !== false;
+		const hostile = view.hostile.alive();
+		for (const hero of view.mine) {
+			const inventory = hero.own && snapshotOf(hero, inventorySlots)?.slots;
+			if (!inventory || hero.own?.hidden) continue;
+			const stats = view.strength.statsOf(hero);
+			const maxHp = hero.maxHealth ?? stats.health;
+			const maxMana = hero.maxMana ?? stats.mana;
+			if (potions) {
+				let drank = false;
+				for (const slot of inventory) {
+					const ability = slot && registry.item(slot.item).ability;
+					if (!slot || !ability || slot.cooldown > 0 || slot.uses === 0) continue;
+					const effects = registry.ability(ability).effects;
+					const heals = effects.some((effect) => effect.type === "heal");
+					const restores = effects.some((effect) => effect.type === "mana");
+					if (heals && hero.health < maxHp * DRINK_HEALTH || restores && maxMana > 0 && (hero.mana ?? 0) < maxMana * DRINK_MANA) {
+						ai.send({
+							type: "order",
+							entities: [hero.id],
+							order: {
+								type: "cast",
+								item: slot.id
+							}
+						});
+						drank = true;
+						break;
+					}
+				}
+				if (drank) continue;
+			}
+			if (hero.own?.order) continue;
+			if (takeItems && inventory.includes(null)) {
+				let lying;
+				let lyingAt = 100;
+				for (const item of view.items) {
+					const d = distSq(item, hero);
+					if (d < lyingAt) {
+						lyingAt = d;
+						lying = item;
+					}
+				}
+				if (lying) {
+					ai.send({
+						type: "order",
+						entities: [hero.id],
+						order: {
+							type: "pickUp",
+							item: lying.id
+						}
+					});
+					continue;
+				}
+			}
+		}
+		this.shop(hostile);
+		this.hire(hostile);
+	}
+	/** What a hero shops for: its plan's list, the brain's, or the kit's (the cheapest item whose ability heals, when it carries none) */
+	wanted(hero) {
+		const { ai } = this;
+		const { registry } = ai.view;
+		const list = this.planOf(hero.type)?.items ?? this.options.shopping;
+		if (list === false) return void 0;
+		if (typeof list === "function") return list(ai, hero);
+		const slots = snapshotOf(hero, inventorySlots)?.slots ?? [];
+		const carried = (item) => slots.filter((slot) => slot?.item === item).length;
+		if (Array.isArray(list)) {
+			for (const line of list) {
+				if (!registry.items.has(line.item)) continue;
+				if (carried(line.item) >= (line.count ?? 1)) continue;
+				if (line.when !== void 0 && !evaluate(line.when, ai)) continue;
+				return line.item;
+			}
+			return;
+		}
+		const money = ai.purse.money;
+		const heals = (def) => !!def.ability && registry.abilities.has(def.ability) && registry.ability(def.ability).effects.some((effect) => effect.type === "heal");
+		if (slots.some((slot) => slot && heals(registry.item(slot.item)))) return void 0;
+		return registry.items.all().filter((def) => heals(def) && (def.cost[money] ?? 0) > 0).sort((a, b) => (a.cost[money] ?? 0) - (b.cost[money] ?? 0))[0]?.id;
+	}
+	/**
+	* Heroes with nothing to do walk to a shop in reach for what they want and buy it there: the money held in the purse
+	* on the way, paid as the `buy` is sent. Not in a fight, not on an errand
+	*/
+	shop(hostile) {
+		if (this.options.buyItems === false) return;
+		const { ai } = this;
+		const { view } = ai;
+		const { registry } = view;
+		const selling = ai.cache("micro.selling", () => new Set(registry.units.all().flatMap((def) => def.sells?.length ? [def.id] : [])));
+		const shops = new UnitSet(view, view.all.known().filter((entity) => selling.has(entity.type) && !!snapshotOf(entity, shopStock) && !view.isHostile(entity)));
+		if (!shops.length) {
+			this.memory.shopping = {};
+			return;
+		}
+		const going = this.memory.shopping;
+		for (const hero of view.mine.heroes()) {
+			const own = hero.own;
+			const slots = own && snapshotOf(hero, inventorySlots)?.slots;
+			if (!own || !slots || own.hidden) continue;
+			const squad = ai.squads.squadOf(hero);
+			const busy = squad && !squad.idle || hostile.near(hero, 14).length > 0;
+			let errand = going[hero.id];
+			if (errand && (busy || !slots.includes(null))) {
+				delete going[hero.id];
+				errand = void 0;
+			}
+			if (busy) continue;
+			if (!errand) {
+				if (own.order || !slots.includes(null)) continue;
+				const item = this.wanted(hero);
+				if (!item || !registry.items.has(item)) continue;
+				const def = registry.item(item);
+				if (!ai.purse.affords(def.cost, 0, SHOPPING_PRIORITY)) continue;
+				const shop = shops.where((entity) => !!snapshotOf(entity, shopStock).find((stock) => stock.item === item && (stock.count === void 0 || stock.count > 0))).near(hero, SHOP_REACH).nearest(hero);
+				if (!shop) continue;
+				errand = going[hero.id] = {
+					shop: shop.id,
+					item,
+					since: ai.tick
+				};
+				ai.send({
+					type: "order",
+					entities: [hero.id],
+					order: {
+						type: "move",
+						point: point(shop)
+					}
+				});
+				ai.decide(`${hero.type} ${hero.id} goes to the ${shop.type} at ${where(shop)} for ${an(def.name || item)}`, { kind: "micro" });
+			}
+			const shop = view.byId(errand.shop);
+			const def = registry.item(errand.item);
+			if (!shop || !snapshotOf(shop, shopStock)?.some((stock) => stock.item === errand.item && (stock.count === void 0 || stock.count > 0))) {
+				delete going[hero.id];
+				continue;
+			}
+			const reach = AT_SHOP + view.def(shop).radius;
+			if (distSq(hero, shop) <= reach * reach) {
+				delete going[hero.id];
+				if (!ai.purse.spend(def.cost, SHOPPING_PRIORITY)) continue;
+				ai.send({
+					type: "buy",
+					shop: shop.id,
+					item: errand.item,
+					hero: hero.id
+				});
+				ai.decide(`${hero.type} ${hero.id} buys ${an(def.name || errand.item)} at the ${shop.type}`, { kind: "micro" });
+				continue;
+			}
+			ai.purse.reserve(`micro.shopping:${hero.id}`, def.cost, SHOPPING_PRIORITY);
+			if (!own.order && ai.tick - errand.since >= FLEE_RESEND * ai.session.tickRate) {
+				errand.since = ai.tick;
+				ai.send({
+					type: "order",
+					entities: [hero.id],
+					order: {
+						type: "move",
+						point: point(shop)
+					}
+				});
+			}
+		}
+	}
+	/** What it would hire at a place now, of what the place offers: its list's next, the function's, or the kit's (the strongest soldier for its price) */
+	toHire(offered) {
+		const { ai } = this;
+		const { view } = ai;
+		const { hiring } = this.options;
+		if (hiring === false || !offered.length) return void 0;
+		if (typeof hiring === "function") {
+			const id = hiring(ai, offered);
+			return id === void 0 ? void 0 : offered.find((def) => def.id === id);
+		}
+		if (Array.isArray(hiring)) {
+			for (const line of hiring) {
+				const def = offered.find((each) => each.id === line.unit);
+				if (!def) continue;
+				if (view.mine.ofType(def.id).length >= (line.count ?? 1)) continue;
+				if (line.when !== void 0 && !evaluate(line.when, ai)) continue;
+				return def;
+			}
+			return;
+		}
+		const money = ai.purse.money;
+		const soldiers = offered.filter((def) => !def.hero && view.hasRole(def.id, "soldier"));
+		if (view.mine.where((entity) => soldiers.some((def) => def.id === entity.type)).length >= HIRING_MOST) return void 0;
+		const worth = (def) => view.strength.of(def) / Math.max(1, def.cost?.[money] ?? 0);
+		const best = [...soldiers].sort((a, b) => worth(b) - worth(a))[0];
+		return best && ai.purse.affords(best.cost ?? {}, HIRING_SPARE, HIRING_PRIORITY) ? best : void 0;
+	}
+	/**
+	* Mercenaries: with supply free, a hero with nothing to do (or else an idle fighter of no squad's) walks to a place
+	* that hires in reach for what `toHire` says, the money held in the purse on the way and paid as the `hire` is sent.
+	* Not in a fight, not on an errand
+	*/
+	hire(hostile) {
+		if (this.options.hireUnits === false || this.options.hiring === false) return;
+		const { ai } = this;
+		const { view } = ai;
+		const { registry } = view;
+		const hiring = ai.cache("micro.hiring", () => new Set(registry.units.all().flatMap((def) => def.hires?.length ? [def.id] : [])));
+		if (!hiring.size) return;
+		const places = new UnitSet(view, view.all.known().filter((entity) => hiring.has(entity.type) && entity.health > 0 && !view.isHostile(entity)));
+		const going = this.memory.hiring ??= {};
+		if (!places.length) {
+			this.memory.hiring = {};
+			return;
+		}
+		const offeredAt = (place) => (view.def(place).hires ?? []).filter((id) => registry.units.has(id)).map((id) => registry.unit(id));
+		const { me } = view;
+		const busy = (unit) => {
+			const squad = ai.squads.squadOf(unit);
+			return squad && !squad.idle || hostile.near(unit, 14).length > 0;
+		};
+		for (const [id, errand] of Object.entries(going)) {
+			const unit = view.byId(Number(id));
+			const place = view.byId(errand.place);
+			if (!unit || !place || unit.health <= 0 || busy(unit) || !(view.def(place).hires ?? []).includes(errand.unit)) {
+				delete going[id];
+				continue;
+			}
+			const def = registry.unit(errand.unit);
+			const reach = AT_SHOP + view.def(place).radius;
+			if (distSq(unit, place) <= reach * reach) {
+				delete going[id];
+				const supply = supplyOf(def);
+				if (supply > 0 && me.supplyUsed + supply > me.supplyCap || !ai.purse.spend(def.cost ?? {}, HIRING_PRIORITY)) continue;
+				me.supplyUsed += supply;
+				ai.send({
+					type: "hire",
+					shop: place.id,
+					unit: errand.unit
+				});
+				ai.decide(`hires ${an(def.name || errand.unit)} at the ${place.type}`, { kind: "micro" });
+				continue;
+			}
+			ai.purse.reserve(`micro.hiring:${id}`, def.cost ?? {}, HIRING_PRIORITY);
+			if (!unit.own?.order && ai.tick - errand.since >= FLEE_RESEND * ai.session.tickRate) {
+				errand.since = ai.tick;
+				ai.send({
+					type: "order",
+					entities: [unit.id],
+					order: {
+						type: "move",
+						point: point(place)
+					}
+				});
+			}
+		}
+		if (Object.keys(going).length) return;
+		const idle = (unit) => !!unit.own && !unit.own.hidden && !unit.own.order && !busy(unit);
+		const runners = [...view.mine.heroes().where(idle), ...view.mine.fighters().where((unit, def) => !def.hero && idle(unit) && !ai.squads.squadOf(unit))];
+		for (const runner of runners) {
+			const place = places.near(runner, SHOP_REACH).nearest(runner);
+			if (!place) continue;
+			const def = this.toHire(offeredAt(place));
+			if (!def) return;
+			const supply = supplyOf(def);
+			if (supply > 0 && me.supplyUsed + supply > me.supplyCap) return;
+			if (!ai.purse.affords(def.cost ?? {}, 0, HIRING_PRIORITY)) return;
+			going[runner.id] = {
+				place: place.id,
+				unit: def.id,
+				since: ai.tick
+			};
+			ai.send({
+				type: "order",
+				entities: [runner.id],
+				order: {
+					type: "move",
+					point: point(place)
+				}
+			});
+			ai.decide(`${runner.type} ${runner.id} goes to the ${place.type} at ${where(place)} to hire ${an(def.name || def.id)}`, { kind: "micro" });
+			return;
+		}
+	}
+	/** The plan for a hero type, where the brain's `heroes` is a list */
+	planOf(type) {
+		return Array.isArray(this.options.heroes) ? this.options.heroes.find((plan) => plan.type === type) : void 0;
+	}
+	/**
+	* Which hero to make next of those that could be made (at an altar, of the player's race, not had): the first of the
+	* brain's `heroes` that could be and whose chance came up, or what its function says; else the first candidate
+	*/
+	nextHero(candidates, had) {
+		const free = candidates.filter((def) => !had.includes(def.id));
+		if (!free.length) return void 0;
+		const { heroes } = this.options;
+		if (typeof heroes === "function") {
+			const picked = heroes(this.ai, free);
+			if (picked === void 0) return void 0;
+			return typeof picked === "string" ? free.find((def) => def.id === picked) : picked;
+		}
+		if (Array.isArray(heroes)) {
+			for (let i = 0; i < heroes.length; i++) {
+				const plan = heroes[i];
+				const def = free.find((each) => each.id === plan.type);
+				if (!def) continue;
+				const chance = plan.chance ?? 1;
+				if (chance < 1) {
+					this.memory.rolled[i] ??= this.ai.rng.next() < chance;
+					if (!this.memory.rolled[i]) continue;
+				}
+				return def;
+			}
+			return;
+		}
+		return free[0];
+	}
+	/**
+	* Which skill a hero learns next of those it may: its plan's order (the next line not yet learned to that level),
+	* else the ultimate as soon as it can be had, else whatever is furthest behind
+	*/
+	nextSkill(hero, learnable, now = true) {
+		if (!learnable.length) return void 0;
+		const plan = this.planOf(hero.type);
+		if (typeof plan?.skills === "function") return plan.skills(this.ai, hero, learnable);
+		if (Array.isArray(plan?.skills)) {
+			const counted = {};
+			for (const id of plan.skills) {
+				counted[id] = (counted[id] ?? 0) + 1;
+				const skill = learnable.find((each) => each.id === id);
+				if (!skill || skill.level >= counted[id]) continue;
+				return skill.available || !now ? id : void 0;
+			}
+		}
+		return (now ? learnable.filter((skill) => skill.available) : [...learnable]).sort((a, b) => a.maxLevel - b.maxLevel || a.level - b.level)[0]?.id;
+	}
+	/** Has heroes put the points they have into their skills, in the order their plan says */
+	heroes() {
+		if (!this.begin("heroes")) return;
+		const { ai } = this;
+		for (const hero of ai.view.mine.heroes()) {
+			const info = heroOfState(hero);
+			if (!info?.points || !info.learnable || hero.own?.hidden) continue;
+			const next = this.nextSkill(hero, info.learnable);
+			if (!next) continue;
+			ai.send({
+				type: "learn",
+				entity: hero.id,
+				ability: next
+			});
+			ai.decide(`${hero.type} ${hero.id} learns ${next}`, { kind: "micro" });
+		}
+	}
+	/** Whether a part of the think is still to be done this think: it is, once, for whoever asks first */
+	begin(part) {
+		if (this.thoughtAt[part] === this.ai.tick) return false;
+		this.thoughtAt[part] = this.ai.tick;
+		return true;
+	}
+	/** Marks a part of the think done: one a brain's own turn did itself, or left to the units (a slip) */
+	done(part) {
+		this.thoughtAt[part] = this.ai.tick;
+	}
+	/** Drops what is remembered of units that are gone */
+	prune() {
+		const { view } = this.ai;
+		const gone = (id) => !view.mine.has(Number(id));
+		for (const id in this.memory.kited) if (gone(id)) delete this.memory.kited[id];
+		for (const id in this.memory.siege) if (gone(id)) delete this.memory.siege[id];
+		for (const id in this.memory.fled) if (gone(id)) delete this.memory.fled[id];
+		for (const id in this.memory.shopping) if (gone(id)) delete this.memory.shopping[id];
+	}
+	/** The fights and the rest, as the report shows them */
+	report() {
+		const { ai } = this;
+		const { view } = ai;
+		const fleeing = ai.squads.named(FLEEING);
+		const fled = this.memory.fled;
+		return {
+			fights: this.fights.map((fight) => {
+				const kept = this.memory.focus[fight.squad.name];
+				return {
+					squad: fight.squad.name,
+					foes: fight.foes.length,
+					odds: Math.round(fight.odds * 100) / 100,
+					...fight.target && kept && { target: {
+						id: fight.target.id,
+						type: fight.target.type,
+						since: kept.since
+					} },
+					kiting: [...fight.kiting],
+					siege: [...fight.siege]
+				};
+			}),
+			fleeing: (fleeing?.units().items ?? []).map((unit) => ({
+				unit: unit.id,
+				type: unit.type,
+				health: Math.round(this.healthOf(unit) * 100) / 100,
+				to: pair(fled[unit.id]?.to ?? unit),
+				since: fled[unit.id]?.since ?? 0,
+				why: fled[unit.id]?.why ?? "hurt"
+			})),
+			heroes: view.mine.heroes().map((hero) => {
+				const info = heroOfState(hero);
+				const next = info?.learnable ? this.nextSkill(hero, info.learnable, false) : void 0;
+				return {
+					id: hero.id,
+					type: hero.type,
+					level: info?.level ?? 1,
+					...next && { next }
+				};
+			}),
+			shopping: Object.entries(this.memory.shopping).map(([hero, errand]) => ({
+				hero: Number(hero),
+				...errand
+			})),
+			hiring: Object.entries(this.memory.hiring ?? {}).map(([by, errand]) => ({
+				by: Number(by),
+				...errand
+			})),
+			cast: this.cast,
+			...this.slipped && { slipped: this.slipped }
+		};
+	}
+	/** 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 this.enabled;
+	}
+	/** Its part of the brain's report */
+	reportTo(report) {
+		report.micro = this.report();
+	}
+	/** Gives a copy of the micro'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,
+			focus: { ...given.focus ?? {} },
+			kited: { ...given.kited ?? {} },
+			fled: structuredClone(given.fled ?? {}),
+			siege: { ...given.siege ?? {} },
+			shopping: structuredClone(given.shopping ?? {}),
+			...given.hiring && { hiring: structuredClone(given.hiring) },
+			rolled: { ...given.rolled ?? {} }
+		};
+		return true;
+	}
+};
+/**
+* The task of the `fleeing` squad: each of its units on its way to its own safety (`state.memory.to`, by unit id), those
+* that stopped short sent again; never over by itself: the micro module takes the units out as they heal
+*/
+var FLEE = defineTask({
+	id: "flee",
+	fighting: false,
+	start(ai, squad, state) {
+		state.phase = "fleeing";
+		state.phaseSince = ai.tick;
+		const to = state.memory.to ?? {};
+		for (const id of squad.data.units) if (to[id]) squad.order({
+			type: "move",
+			point: to[id]
+		}, [id]);
+	},
+	think(_ai, squad, state) {
+		if (!squad.mayResend()) return;
+		const to = state.memory.to ?? {};
+		for (const unit of squad.idleUnits()) {
+			const there = to[unit.id];
+			if (there && distSq(unit, there) > 16) squad.order({
+				type: "move",
+				point: there
+			}, [unit.id]);
+		}
+	},
+	handles: [
+		"retreat",
+		"regroup",
+		"reinforce"
+	]
+});
+/**
+* The micro module: the fights of the brain's squads each think, after the squads sent and watched their tasks
+* (`ai.micro.think`): focus fire, kiting, siege, fleeing and coming back, spells, items, the heroes' skills. With how it
+* fights where the brain's definition and the seat's options say nothing (`MicroOptions`)
+*
+* @beta
+*/
+var micro = (options = {}) => defineModule({
+	id: "micro",
+	make: (ai) => {
+		ai.area(Micro).configure(options);
+		return {
+			id: "micro",
+			phase: "fight",
+			think: () => ai.area(Micro).think()
+		};
+	}
+});
+/** What a unit pays in health for each point of mana, by the buffs it carries (`BuffDef.paysWithHealth`): 0 for mana */
+function healthRate(registry, unit) {
+	let rate = 0;
+	for (const buff of unit.buffs ?? []) {
+		const pays = registry.buffs.has(buff) ? registry.buff(buff).paysWithHealth : void 0;
+		if (pays) rate = Math.max(rate, pays === true ? 1 : pays);
+	}
+	return rate;
+}
+//#endregion
+export { Micro, micro };
+
+//# sourceMappingURL=micro.js.map