@v12-engine/engine 0.1.0 → 0.4.0

package/dist/ai/melee/goals.js

@@ -0,0 +1,720 @@
+import { distSq } from "../../math.js";
+import { baseStats } from "../../defs.js";
+import { heroOfState } from "../../hero.js";
+import { defineModule, moduleKey } from "../module.js";
+import { consider, curve, defineGoal } from "../goals.js";
+import { where } from "../geometry.js";
+import { flagOf } from "../profiles.js";
+import { Defence } from "../defence.js";
+import { Team } from "../team.js";
+import { Waves } from "../waves.js";
+//#region src/ai/melee/goals.ts
+/**
+* What finds the melee army's module with its shape (`ai.module(MELEE_ARMY)`)
+*
+* @beta
+*/
+var MELEE_ARMY = moduleKey("melee.army");
+/**
+* The melee brain's army (`MeleeArmy`) of a brain: its waves, numbers and memory, for the tests and the debug tools.
+* Throws for a brain without the `melee.army` module
+*
+* @beta
+*/
+function meleeArmyOf(ai) {
+	const module = ai.module(MELEE_ARMY);
+	if (!module?.army) throw new Error(`The brain "${ai.def.id}" has no melee.army module`);
+	return module.army;
+}
+/** How near a base their army seen counts as there */
+var ARMY_NEAR = 36;
+/** How near a base a guard stands to guard it */
+var GUARDING = 16;
+/** The fewest raiders or harassers a party is sent with */
+var PARTY_LEAST = 2;
+/** Why a wave that razed what it went for and does not go on walks home (its `retreat`'s `why`) */
+var RAZED = "razed";
+/**
+* The melee player's army: its waves of its own and the goals beside them (the file's comment), its numbers from its
+* options (`firstAttack`, `attackEvery`, `waveSize`) and the defence's radius, its memory. Made for a brain by
+* the `army()` module; reached as `ai.module(MELEE_ARMY)?.army` (`meleeArmyOf(ai)`)
+*
+* @beta
+*/
+var MeleeArmy = class {
+	ai;
+	options;
+	/** What the army remembers between thinks: wave size, next times and counts */
+	memory;
+	/** Seconds into the game the first wave is due */
+	firstAttack;
+	/** Seconds between one wave's time and the next */
+	attackEvery;
+	/** How far from a base, in cells, the army defends */
+	defendRadius;
+	constructor(ai, options) {
+		this.ai = ai;
+		this.options = options;
+		this.firstAttack = options.firstAttack ?? 150;
+		this.attackEvery = options.attackEvery ?? 45;
+		this.defendRadius = ai.area(Defence).radius;
+		this.memory = {
+			v: 1,
+			waveSize: options.waveSize ?? 6,
+			nextAttack: this.firstAttack,
+			nextCreeping: options.creep && options.creep.from || 30,
+			attacks: 0
+		};
+	}
+	get time() {
+		return this.ai.time;
+	}
+	/** Its fighters: what is gathering (a ghoul at the trees) is at work, not in the army */
+	armyOf(units) {
+		return units.fighters().where((entity) => entity.own?.order !== "harvest");
+	}
+	/** The fighters no goal holds and with nothing to do: what a wave or a party is made of. Once a think */
+	ready() {
+		return this.ai.cache("melee.ready", () => this.readyOf(this.ai.goals.pool()));
+	}
+	readyOf(units) {
+		return this.armyOf(units).where((unit) => !unit.own?.order);
+	}
+	/** Their army as last seen within so many seconds, summed by type: a force to weigh odds against */
+	theirs(seconds) {
+		return this.ai.cache(`melee.theirs.${seconds}`, () => {
+			const theirs = {};
+			for (const army of this.ai.knowledge.enemy.armySeen(seconds)) for (const [type, count] of Object.entries(army.types)) theirs[type] = (theirs[type] ?? 0) + count;
+			return theirs;
+		});
+	}
+	/** The odds of a force of mine against their army as last seen within so many seconds: 1 where none was seen */
+	oddsAgainstTheirs(mine, seconds) {
+		if (!mine.length) return 0;
+		const theirs = this.theirs(seconds);
+		if (!Object.keys(theirs).length) return 1;
+		return this.ai.view.strength.odds(mine, theirs);
+	}
+	/** The odds of a force of mine against what is remembered to reach a place (towers, their army seen near it), by the square law */
+	oddsAt(mine, at) {
+		const { view } = this.ai;
+		const strength = view.strength.sum([...mine]);
+		if (strength <= 0) return 0;
+		const theirs = view.threat.at(at, { remembered: true }).enemy;
+		if (theirs <= 0) return 1;
+		return strength * strength / (strength * strength + theirs * theirs);
+	}
+	/** Whether its team asks it to join an attack together it has not answered, while its waves wait for the team's (`together`) */
+	invited() {
+		const team = this.ai.area(Team);
+		const plan = team.together ? team.plan : void 0;
+		return !!plan && plan.by !== this.ai.playerId && this.ai.tick < plan.at && !plan.declined.includes(this.ai.playerId);
+	}
+	/**
+	* Whether it has no mercy (No Mercy, a flag of its profile): the enemy's army as last seen (the last minute) weak
+	* against what it has ready, at the odds the flag says (0.75 for `true`), and it goes before its time
+	*/
+	merciless() {
+		const flag = flagOf(this.ai, "noMercy");
+		if (!flag) return false;
+		const odds = typeof flag === "number" ? flag : .75;
+		const ready = this.ready();
+		if (!ready.length) return false;
+		return this.oddsAgainstTheirs(ready, 60) >= odds;
+	}
+	/**
+	* Whether the wave is worth sending now: what is ready would not lose outright against their army as last seen
+	* (`goOdds`), or it has waited long enough (`waitAtMost`). Nothing seen of their army: worth it
+	*/
+	worthGoing() {
+		const goOdds = this.options.goOdds ?? .4;
+		if (goOdds === false) return true;
+		if (this.oddsAgainstTheirs(this.ready(), 60) >= goOdds) return true;
+		return this.waitedEnough();
+	}
+	/**
+	* Whether a wave of theirs just died at its gate (so many of their fighters fallen near its bases in the last twenty
+	* seconds): their base is empty of it, and what is ready goes at once
+	*/
+	counterAttack() {
+		if (this.options.counter === false) return false;
+		return this.ai.cache("melee.counter", () => {
+			const { view, knowledge, registry } = this.ai;
+			const bases = view.bases();
+			let fallen = 0;
+			for (const death of knowledge.events.deaths(20)) {
+				if (view.player(death.owner)?.relation !== "enemy" || !registry.units.has(death.type)) continue;
+				const def = registry.unit(death.type);
+				if (def.kind !== "unit" || !def.attacks?.length || def.harvester) continue;
+				if (bases.some((base) => distSq(base.at, death.at) < 900)) fallen++;
+			}
+			return fallen >= (this.options.counterAfter ?? 3);
+		});
+	}
+	/**
+	* Whether their army is away from what a wave would go for (`strike`): at least one sighting of it within `awayFor`
+	* seconds (nothing seen says nothing of where it is), every one far from the target and from every base of mine and
+	* every building of my allies' (an army at my gate is the defence's, at an ally's the team's: not a reason to trade
+	* bases), and what is ready (half a wave at the least) would hold against what is remembered to reach the target
+	* (its towers). Once a think
+	*/
+	armyAway() {
+		const strike = this.options.strike;
+		if (strike === false) return false;
+		return this.ai.cache("melee.strike", () => {
+			const { view, knowledge } = this.ai;
+			if (this.ai.area(Waves).active || this.out("wave")) return false;
+			const ready = this.ready();
+			if (ready.length < Math.max(PARTY_LEAST, Math.ceil(this.memory.waveSize / 2))) return false;
+			const sightings = knowledge.enemy.armySeen(strike?.awayFor ?? 60).filter((army) => view.player(army.owner)?.relation === "enemy");
+			if (!sightings.length) return false;
+			const target = this.targetFor(ready.centre());
+			if (!target) return false;
+			if (sightings.some((army) => distSq(army.at, target) < 5184)) return false;
+			const home = this.defendRadius + ARMY_NEAR;
+			const ours = [...view.bases().map((base) => base.at), ...view.allies.buildings()];
+			if (sightings.some((army) => ours.some((at) => distSq(army.at, at) < home * home))) return false;
+			return this.oddsAt(ready, target) >= (strike?.odds ?? .6);
+		});
+	}
+	/** Whether the wave has waited past its time as long as it will (`waitAtMost`): it goes with what it has then */
+	waitedEnough() {
+		const { waiting } = this.memory;
+		return waiting !== void 0 && this.time - waiting >= (this.options.waitAtMost ?? this.attackEvery * 2);
+	}
+	/**
+	* Whether the wave is ready: as many as it asks for stand idle; or half of them, once it has waited long enough and
+	* they would hold against what is remembered to reach the target (half a wave is not fed to the towers)
+	*/
+	waveReady() {
+		const ready = this.ready();
+		const { waveSize } = this.memory;
+		if (ready.length >= waveSize) return true;
+		if (!(this.waitedEnough() || this.counterAttack() || this.armyAway()) || ready.length < Math.max(PARTY_LEAST, Math.ceil(waveSize / 2))) return false;
+		const goOdds = this.options.goOdds ?? .4;
+		if (goOdds === false) return true;
+		const target = this.targetFor(ready.centre());
+		return !!target && this.oddsAt(ready, target) >= goOdds;
+	}
+	/**
+	* Where a wave goes: of the rival's buildings it knows of (in sight or remembered, not a creep's), the nearest, or
+	* (`target: 'weakest'`) the one the least of their strength is remembered to reach (an expansion before a main with
+	* towers), the nearest among those alike; else a base it was told of
+	*/
+	targetFor(from) {
+		const { view } = this.ai;
+		const known = view.enemies.known().buildings();
+		const bases = this.ai.options.enemyBases ?? [];
+		if (!known.length || !from) return bases.length ? bases[this.memory.attacks % bases.length] : void 0;
+		if ((this.options.target ?? "weakest") === "nearest") {
+			const near = known.nearest(from);
+			return {
+				x: near.x,
+				z: near.z
+			};
+		}
+		let best;
+		for (const building of known) {
+			const threat = view.threat.at(building, { remembered: true }).enemy;
+			const distance = distSq(from, building);
+			const alike = best && Math.abs(threat - best.threat) <= Math.max(threat, best.threat) * .1;
+			if (!best || (alike ? distance < best.distance : threat < best.threat)) best = {
+				at: {
+					x: building.x,
+					z: building.z
+				},
+				threat,
+				distance
+			};
+		}
+		return best.at;
+	}
+	/**
+	* A way of its own for a wave (Random Paths, a flag of its profile): by the brain's numbers, straight, or by a place a
+	* third of the way's length to one side or the other of its middle. None for straight, or without the flag
+	*/
+	wayOf(squad, target) {
+		if (!flagOf(this.ai, "randomPaths")) return void 0;
+		const from = squad.centre();
+		if (!from) return void 0;
+		const side = this.ai.rng.int(-1, 1);
+		if (side === 0) return void 0;
+		const dx = target.x - from.x;
+		const dz = target.z - from.z;
+		const { width, depth } = this.ai.session.terrain;
+		const x = (from.x + target.x) / 2 - dz / 3 * side;
+		const z = (from.z + target.z) / 2 + dx / 3 * side;
+		return {
+			x: Math.min(width - 2, Math.max(2, x)),
+			z: Math.min(depth - 2, Math.max(2, z))
+		};
+	}
+	/**
+	* How the squads it sends out behave: they fall back from a fight away from home at the odds a wave used to (the
+	* profile's `retreatOdds`, or Groups Flee), fight on to the last near home, and a wave is made up from home
+	* (`reinforce`); the seat's say goes over it
+	*/
+	get outward() {
+		return {
+			retreatAt: .3,
+			home: this.defendRadius + 6,
+			reinforce: this.options.reinforce ?? true,
+			...this.ai.squads.defaults
+		};
+	}
+	/** A party's options: as a wave's, but it falls back sooner and nobody comes after it */
+	party(retreatAt) {
+		return {
+			...this.outward,
+			retreatAt,
+			reinforce: false
+		};
+	}
+	/** Sends a wave: its squad to attack the target, the next wave set, said where it says things */
+	launch(squad, target, together) {
+		const { ai, memory } = this;
+		const known = ai.view.enemies.known().buildings();
+		const size = squad.length;
+		const early = this.time < memory.nextAttack;
+		const counter = early && this.counterAttack();
+		const struck = early && !counter && this.armyAway();
+		const via = this.wayOf(squad, target);
+		squad.attack(target, via ? { via } : {});
+		ai.knowledge.own.attackSent(target, size);
+		memory.attacks++;
+		memory.waveSize = Math.min(memory.waveSize + (this.options.waveGrowth ?? 2), this.options.waveMax ?? 24);
+		memory.waiting = void 0;
+		const mistakes = ai.profile.mistakes ?? 0;
+		memory.nextAttack = this.time + this.attackEvery * (mistakes > 0 ? 1 - mistakes * ai.rng.next() : 1);
+		ai.area(Team).say("attacking");
+		ai.decide(`sends wave ${memory.attacks} of ${size} at ${where(target)}${together ? ", together with its team" : known.length ? ", a building of theirs it knows" : ", a base it was told of"}${counter ? ", answering their wave that fell at its gate" : struck ? ", their army away" : ""}; the next is ${memory.waveSize} strong at ${Math.round(memory.nextAttack)} s`, {
+			kind: "army",
+			goal: "attack"
+		});
+	}
+	/**
+	* The squad a goal of its sent out (`wave`, `creep`, `raid`, `harass`, `expand`), while it is on its errand: on its
+	* way, fighting, falling back, or (a wave) done with its target, to go on or to be sent home. None once its task is
+	* over, or before it was sent
+	*/
+	out(name) {
+		const squad = this.ai.squads.named(name);
+		if (!squad) return void 0;
+		if (!squad.idle) return squad;
+		return name === "wave" && squad.done === "cleared" ? squad : void 0;
+	}
+	/**
+	* Whether a wave that razed what it went for goes on: it may, it is still a few, it is strong enough against their
+	* army as last seen and against what is remembered to reach the next target (its towers), and it knows of more of theirs
+	*/
+	mayPressOn(squad) {
+		if (!(this.options.pressOn ?? true) || squad.length < PARTY_LEAST) return false;
+		const odds = this.options.pressOdds ?? .5;
+		if (this.oddsAgainstTheirs(squad.units(), 60) < odds) return false;
+		if (!this.ai.view.enemies.known().buildings().length) return false;
+		const target = this.targetFor(squad.centre());
+		return !!target && this.oddsAt(squad.units(), target) >= odds;
+	}
+	/** The camp its ready units and hero can take near home, when it is time to go creeping */
+	campToTake(ready) {
+		const creep = this.options.creep;
+		if (creep === false) return void 0;
+		if (this.time < this.memory.nextCreeping || this.memory.nextAttack - this.time < 40) return void 0;
+		const party = [...ready];
+		const hero = party.find((unit) => heroOfState(unit));
+		const home = this.ai.view.home();
+		if (!hero || !home || party.length < (creep?.party ?? 3)) return void 0;
+		const strength = party.length * 1.2 + (heroOfState(hero)?.level ?? 1);
+		const reach = creep?.reach ?? 70;
+		const camps = this.ai.view.camps().filter((camp) => !camp.cleared && camp.level <= strength && distSq(camp, home) < reach * reach);
+		let best;
+		let bestDistance = Infinity;
+		for (const camp of camps) {
+			const d = distSq(home, camp);
+			if (d < bestDistance) {
+				bestDistance = d;
+				best = camp;
+			}
+		}
+		return best;
+	}
+	/** Where a raid would go: the base of theirs with the most workers seen lately and no army seen near it, with how many */
+	raidTarget() {
+		return this.ai.cache("melee.raid", () => {
+			const raid = this.options.raid;
+			if (raid === false || this.ai.area(Waves).active) return void 0;
+			const { enemy } = this.ai.knowledge;
+			const workers = enemy.workersSeen(raid?.workersSeenFor ?? 120).filter((worker) => worker.died === void 0);
+			if (!workers.length) return void 0;
+			const armies = enemy.armySeen(raid?.armyAwayFor ?? 45);
+			const home = this.ai.view.home();
+			let best;
+			for (const base of enemy.bases()) {
+				if (base.gone || armies.some((army) => distSq(army.at, base.at) < 1296)) continue;
+				const count = workers.filter((worker) => distSq(worker.at, base.at) < 900).length;
+				if (!count) continue;
+				const distance = home ? distSq(home, base.at) : 0;
+				if (!best || count > best.workers || count === best.workers && distance < best.distance) best = {
+					at: {
+						x: base.at.x,
+						z: base.at.z
+					},
+					workers: count,
+					distance
+				};
+			}
+			return best && {
+				at: best.at,
+				workers: best.workers
+			};
+		});
+	}
+	/** The fastest fighters of some, no heroes among them, up to so many: a party; none where fewer than two */
+	fastest(units, count) {
+		const { registry, view } = this.ai;
+		const speed = (unit) => baseStats(view.def(unit), registry).moveSpeed;
+		const chosen = units.filter((unit) => !heroOfState(unit)).sort((a, b) => speed(b) - speed(a) || a.id - b.id).slice(0, count);
+		return chosen.length >= Math.min(count, PARTY_LEAST) ? chosen : [];
+	}
+	/** The raiders of what may go: the fastest few, where a raid is on and they would not die at the base */
+	raiders(available) {
+		const raid = this.options.raid;
+		if (raid === false) return [];
+		const target = this.raidTarget();
+		if (!target) return [];
+		const chosen = this.fastest(this.readyOf(available), raid?.size ?? 3);
+		return chosen.length && this.oddsAt(chosen, target.at) >= (raid?.odds ?? .6) ? chosen : [];
+	}
+	/** Their main as known: the first base of theirs with a hall, nearest home */
+	theirMain() {
+		return this.ai.cache("melee.theirMain", () => {
+			if (this.ai.area(Waves).active) return void 0;
+			const home = this.ai.view.home();
+			const mains = this.ai.knowledge.enemy.bases().filter((base) => base.hall && !base.gone && !base.expansion);
+			let best;
+			let bestDistance = Infinity;
+			for (const base of mains) {
+				const d = home ? distSq(home, base.at) : 0;
+				if (d < bestDistance) {
+					bestDistance = d;
+					best = base;
+				}
+			}
+			return best;
+		});
+	}
+	/** The party that harasses: the hero and the fastest few, where their army was not seen at their main lately and the party would hold */
+	harassers(available) {
+		const harass = this.options.harass;
+		if (harass === false) return [];
+		const main = this.theirMain();
+		if (!main) return [];
+		if (this.ai.knowledge.enemy.armySeen(60).some((army) => distSq(army.at, main.at) < 1296)) return [];
+		const ready = this.readyOf(available);
+		const heroes = ready.filter((unit) => !!heroOfState(unit));
+		const size = harass?.size ?? 3;
+		const chosen = [...heroes.slice(0, 1), ...this.fastest(ready, Math.max(0, size - Math.min(1, heroes.length)))];
+		if (!chosen.length || !heroes.length && chosen.length < Math.min(size, PARTY_LEAST)) return [];
+		return this.oddsAt(chosen, main.at) >= (harass?.odds ?? .6) ? chosen : [];
+	}
+	/** Whether a base of mine still wants guards: past home, with no finished tower among its buildings */
+	wantsGuards(base) {
+		return !base.buildings.withRole("tower").finished().length;
+	}
+	/** The bases past home that want guards and have none: no fighters of mine standing by them. Once a think */
+	unguarded() {
+		return this.ai.cache("melee.unguarded", () => {
+			if (this.ai.area(Waves).active) return [];
+			const { view } = this.ai;
+			const fighters = this.armyOf(view.mine);
+			return view.bases().slice(1).filter((base) => this.wantsGuards(base) && !fighters.near(base.at, GUARDING).length);
+		});
+	}
+	/** The base the expand squad guards, where it still wants guards */
+	guarded() {
+		const squad = this.ai.squads.named("expand");
+		const at = squad?.current?.kind === "defend" ? squad.current.data.at : void 0;
+		if (!at) return void 0;
+		const base = this.ai.view.bases().find((each) => distSq(each.at, at) < 256);
+		return base && this.wantsGuards(base) ? base : void 0;
+	}
+	/** The guards for the first base wanting them: the fighters nearest it, so many, from what stands idle past a wave */
+	guards(available) {
+		const expand = this.options.expand;
+		if (expand === false) return [];
+		const base = this.unguarded()[0];
+		if (!base) return [];
+		const ready = this.readyOf(available);
+		const guards = expand?.guards ?? 2;
+		if (ready.length < guards + this.memory.waveSize + (expand?.spare ?? 0)) return [];
+		return ready.items.slice().sort((a, b) => distSq(a, base.at) - distSq(b, base.at) || a.id - b.id).slice(0, guards);
+	}
+	/** The goals, for the picker: attack, creep, raid, harass, expand (each unless left out) */
+	goals() {
+		const { options } = this;
+		const goals = [this.attackGoal()];
+		if (options.creep !== false) goals.push(this.creepGoal());
+		if (options.raid !== false) goals.push(this.raidGoal());
+		if (options.harass !== false) goals.push(this.harassGoal());
+		if (options.expand !== false) goals.push(this.expandGoal());
+		return goals;
+	}
+	attackGoal() {
+		return defineGoal({
+			id: "attack",
+			weight: .8,
+			considerations: [
+				consider("its time has come", () => this.ai.area(Waves).active ? -1 : this.out("wave") ? 1 : this.invited() || this.merciless() || this.counterAttack() || this.armyAway() ? 0 : this.time - this.memory.nextAttack, curve.step(0)),
+				consider("the wave is ready", () => this.out("wave") || this.waveReady() ? 1 : this.ready().length / this.memory.waveSize, curve.step(1)),
+				consider("worth going", () => this.out("wave") ? 1 : this.worthGoing() ? 1 : 0, curve.step(1))
+			],
+			claims: { units: (_ai, available) => this.readyOf(available) },
+			run: (_ai, claimed) => this.attack(claimed)
+		});
+	}
+	/** The attack goal's turn: the wave out watched (its fall back, its wait for the team, its next target), or sent */
+	attack(claimed) {
+		const { ai, memory } = this;
+		const team = ai.area(Team);
+		const out = ai.squads.named("wave");
+		if (!claimed.first && out) {
+			if (out.current?.kind === "retreat" && out.current.data.why === RAZED) return;
+			if (out.current?.kind === "retreat") {
+				memory.nextAttack = Math.max(memory.nextAttack, out.current.since / ai.session.tickRate + this.attackEvery);
+				if (memory.saidRetreat !== out.current.since) {
+					memory.saidRetreat = out.current.since;
+					team.say("retreating");
+				}
+				return;
+			}
+			if (out.current?.kind === "defend" && out.current.data.waiting) {
+				const plan = team.plan;
+				if (plan && plan.joined.includes(ai.playerId) && ai.tick < plan.at) return;
+				const target = plan?.target ?? this.targetFor(out.centre());
+				if (target) this.launch(out, target, !!plan);
+				return;
+			}
+			if (out.idle && out.done === "cleared") {
+				const target = this.mayPressOn(out) && this.targetFor(out.centre());
+				if (target) {
+					out.attack(target);
+					ai.knowledge.own.attackSent(target, out.length);
+					ai.decide(`wave ${memory.attacks} of ${out.length} goes on to ${where(target)}: what it went for is razed`, {
+						kind: "army",
+						goal: "attack"
+					});
+				} else {
+					out.retreat(void 0, RAZED);
+					ai.decide(`wave ${memory.attacks} of ${out.length} goes home: what it went for is razed`, {
+						kind: "army",
+						goal: "attack"
+					});
+				}
+			}
+			return;
+		}
+		if (!claimed.first) return;
+		const wave = claimed.units;
+		const target = this.targetFor(wave.centre());
+		if (!target) return;
+		const squad = claimed.squad("wave", wave, this.outward);
+		if (team.together) {
+			if (team.plan && ai.tick < team.plan.at ? team.plan : void 0) team.join();
+			else team.propose(target);
+			squad.defend(wave.centre() ?? target, 12);
+			squad.current.data.waiting = true;
+			const at = (team.plan?.at ?? ai.tick) / ai.session.tickRate;
+			ai.decide(`wave ${memory.attacks + 1} of ${wave.length} waits to attack together at ${Math.round(at)} s`, {
+				kind: "army",
+				goal: "attack"
+			});
+			return;
+		}
+		this.launch(squad, target, false);
+	}
+	creepGoal() {
+		return defineGoal({
+			id: "creep",
+			weight: .5,
+			considerations: [consider("a camp to take", () => this.out("creep") ? 1 : this.campToTake(this.ready()) ? 1 : 0, curve.step(1))],
+			claims: { units: (_ai, available) => this.readyOf(available) },
+			run: (ai, claimed) => {
+				if (!claimed.first) return;
+				const camp = this.campToTake(claimed.units);
+				if (!camp) return;
+				this.memory.nextCreeping = this.time + (this.options.creep && this.options.creep.every || 40);
+				claimed.squad("creep", claimed.units, this.outward).creep(camp);
+				ai.decide(`goes creeping at ${where(camp)} with ${claimed.units.length}`, {
+					kind: "army",
+					goal: "creep"
+				});
+			}
+		});
+	}
+	raidGoal() {
+		const raid = this.options.raid || {};
+		const every = raid.every ?? 60;
+		return defineGoal({
+			id: "raid",
+			weight: .6,
+			commitment: 20,
+			cooldown: every,
+			considerations: [
+				consider("their workers seen where their army is not", () => this.out("raid") ? 1 : this.raidTarget()?.workers ?? 0, curve.step(1)),
+				consider("seconds since the last raid", () => this.out("raid") || this.memory.raided === void 0 ? every : (this.ai.tick - this.memory.raided) / this.ai.session.tickRate, curve.step(every)),
+				consider("raiders to spare", () => this.out("raid") ? 1 : this.raiders(this.ai.goals.pool()).length, curve.step(1))
+			],
+			claims: { units: (_ai, available) => this.raiders(available) },
+			run: (ai, claimed) => {
+				if (!claimed.first) return;
+				const target = this.raidTarget();
+				if (!target) return;
+				this.memory.raided = ai.tick;
+				claimed.squad("raid", claimed.units, this.party(raid.retreatAt ?? .5)).harass(target.at);
+				ai.decide(`raids their workers at ${where(target.at)} with ${claimed.units.length}: ${target.workers} seen there, their army elsewhere`, {
+					kind: "army",
+					goal: "raid"
+				});
+			}
+		});
+	}
+	harassGoal() {
+		const harass = this.options.harass || {};
+		const every = harass.every ?? 90;
+		return defineGoal({
+			id: "harass",
+			weight: .5,
+			commitment: 30,
+			cooldown: every,
+			considerations: [
+				consider("before the first wave", () => this.out("harass") ? 1 : this.memory.attacks === 0 && this.time < this.memory.nextAttack ? 1 : 0, curve.step(1)),
+				consider("their main known", () => this.out("harass") ? 1 : this.theirMain() ? 1 : 0, curve.step(1)),
+				consider("seconds since the last", () => this.out("harass") || this.memory.harassed === void 0 ? every : (this.ai.tick - this.memory.harassed) / this.ai.session.tickRate, curve.step(every)),
+				consider("a party to send", () => this.out("harass") ? 1 : this.harassers(this.ai.goals.pool()).length, curve.step(1))
+			],
+			claims: { units: (_ai, available) => this.harassers(available) },
+			run: (ai, claimed) => {
+				if (!claimed.first) return;
+				const main = this.theirMain();
+				if (!main) return;
+				this.memory.harassed = ai.tick;
+				claimed.squad("harass", claimed.units, this.party(harass.retreatAt ?? .5)).harass(main.at);
+				ai.decide(`harasses their main at ${where(main.at)} with ${claimed.units.length} before its first wave`, {
+					kind: "army",
+					goal: "harass"
+				});
+			}
+		});
+	}
+	expandGoal() {
+		return defineGoal({
+			id: "expand",
+			weight: .7,
+			commitment: 30,
+			considerations: [consider("a new base to hold", () => this.guarded() ? 1 : this.unguarded().length, curve.step(1)), consider("guards to spare", () => this.guarded() ? 1 : this.guards(this.ai.goals.pool()).length, curve.step(1))],
+			claims: { units: (_ai, available) => this.guards(available) },
+			run: (ai, claimed) => {
+				if (!claimed.first) return;
+				const base = this.unguarded()[0];
+				if (!base) return;
+				claimed.squad("expand", claimed.units, {
+					...this.outward,
+					reinforce: false
+				}).defend(base.at, GUARDING);
+				ai.decide(`leaves ${claimed.units.length} to guard its base at ${where(base.at)}: no tower there yet`, {
+					kind: "army",
+					goal: "expand"
+				});
+			}
+		});
+	}
+	/** Once a think, before the picker: whether the wave began waiting past its time, short of its size or outmatched */
+	think() {
+		const { memory } = this;
+		if (this.ai.area(Waves).active || this.out("wave")) return;
+		if (this.time < memory.nextAttack) {
+			memory.waiting = void 0;
+			return;
+		}
+		if (memory.waiting !== void 0) return;
+		const ready = this.ready().length;
+		const short = ready < memory.waveSize;
+		if (!short && this.worthGoing()) return;
+		memory.waiting = this.time;
+		this.ai.decide(`wave ${memory.attacks + 1} waits: ${short ? `${ready} of ${memory.waveSize} ready` : `outmatched by their army as last seen (odds ${this.oddsAgainstTheirs(this.ready(), 60).toFixed(2)})`}`, {
+			kind: "army",
+			goal: "attack"
+		});
+	}
+	/** What it remembers, for a save: a copy */
+	save() {
+		return { ...this.memory };
+	}
+	/** Takes back what `save` gave */
+	restore(data) {
+		const given = data ?? {};
+		const { memory } = this;
+		memory.waveSize = given.waveSize ?? memory.waveSize;
+		memory.nextAttack = given.nextAttack ?? memory.nextAttack;
+		memory.nextCreeping = given.nextCreeping ?? memory.nextCreeping;
+		memory.attacks = given.attacks ?? memory.attacks;
+		for (const key of [
+			"saidRetreat",
+			"waiting",
+			"raided",
+			"harassed"
+		]) if (given[key] !== void 0) memory[key] = given[key];
+		else delete memory[key];
+	}
+	/** What it is thinking, for the debug tools: how hard it plays, its next wave, its roles */
+	inspect() {
+		const { ai, memory } = this;
+		const { view } = ai;
+		const first = (role) => view.typesOf(role)[0]?.id;
+		return {
+			difficulty: ai.profile.difficulty ?? "normal",
+			personality: ai.profile.personality ?? "balanced",
+			nextAttack: Math.max(0, Math.round(memory.nextAttack - this.time)),
+			waveSize: memory.waveSize,
+			attacks: memory.attacks,
+			...memory.waiting !== void 0 && { waiting: Math.round(this.time - memory.waiting) },
+			roles: {
+				worker: first("worker"),
+				hall: first("hall"),
+				farm: [...view.typesOf("supply")].sort((a, b) => (a.cost?.[ai.purse.money] ?? 0) - (b.cost?.[ai.purse.money] ?? 0))[0]?.id,
+				barracks: view.typesOf("barracks").map((def) => def.id),
+				altars: view.typesOf("altar").map((def) => def.id)
+			}
+		};
+	}
+};
+/**
+* The melee brain's army module: the goals of the army put on the picker (attack, creep, raid, harass, expand), the
+* wave's wait counted. Before the picker (`goals`), after the building and the production, as the old turn had it. With how the army goes where the seat says nothing (`MeleeArmyOptions`)
+*
+* @beta
+*/
+var army = (options = {}) => defineModule({
+	id: "melee.army",
+	make: (ai) => {
+		const army = new MeleeArmy(ai, {
+			...options,
+			...ai.settings.army
+		});
+		ai.goals.add(...army.goals());
+		return {
+			id: "melee.army",
+			version: 1,
+			phase: "decide",
+			army,
+			think: () => army.think(),
+			save: () => army.save(),
+			restore: (data) => army.restore(data),
+			inspect: () => army.inspect()
+		};
+	}
+});
+//#endregion
+export { MELEE_ARMY, MeleeArmy, army, meleeArmyOf };
+
+//# sourceMappingURL=goals.js.map