@v12-engine/engine 0.1.1 → 0.4.0

package/dist/ai/lanes.js

@@ -0,0 +1,715 @@
+import { exp } from "../exactMath.js";
+import { distSq } from "../math.js";
+import { heroOfState } from "../hero.js";
+import { farthestReach } from "../attacks.js";
+import { defineModule, moduleKey } from "./module.js";
+import "./reach.js";
+import { consider, curve, defineGoal, goals } from "./goals.js";
+import { rules, words } from "./rules.js";
+import { point, where } from "./geometry.js";
+import { defineTask } from "./task.js";
+import { squads } from "./squads.js";
+import { Team, team } from "./team.js";
+import { defineBrain } from "./define.js";
+import { micro } from "./micro.js";
+//#region src/ai/lanes.ts
+/** How far from a lane's line a unit is on it */
+var ON_LANE = 7;
+/** How far from a lane's line a tower is by it */
+var BY_LANE = 9;
+/** How near an ally's hero one of theirs is for the two to be in a fight */
+var FIGHTING = 10;
+/** How far behind where it stands a hero falls back to, where none of its side's towers is nearer */
+var FALL_BACK = 14;
+/** Seconds between two recalls of a hero: one that was hurt in the channel walks */
+var RECALL_AGAIN = 10;
+/**
+* Where a place is along a line of points, and how far off it: `along` in cells from the first point, `off` from the
+* line's nearest point. What every question of a lane comes to
+*/
+function measure(points, at) {
+	let best = Infinity;
+	let along = 0;
+	let walked = 0;
+	for (let i = 1; i < points.length; i++) {
+		const a = points[i - 1];
+		const dx = points[i].x - a.x;
+		const dz = points[i].z - a.z;
+		const lengthSq = dx * dx + dz * dz;
+		const length = Math.sqrt(lengthSq);
+		const t = lengthSq > 0 ? Math.min(Math.max(((at.x - a.x) * dx + (at.z - a.z) * dz) / lengthSq, 0), 1) : 0;
+		const ox = at.x - (a.x + dx * t);
+		const oz = at.z - (a.z + dz * t);
+		const off = ox * ox + oz * oz;
+		if (off < best) {
+			best = off;
+			along = walked + length * t;
+		}
+		walked += length;
+	}
+	return {
+		along,
+		off: Math.sqrt(best)
+	};
+}
+/** The length of a line of points */
+function lengthOf(points) {
+	let length = 0;
+	for (let i = 1; i < points.length; i++) length += Math.sqrt(distSq(points[i - 1], points[i]));
+	return length;
+}
+/** The point so far along a line of points from its first */
+function pointAlong(points, along) {
+	let left = Math.max(0, along);
+	for (let i = 1; i < points.length; i++) {
+		const a = points[i - 1];
+		const length = Math.sqrt(distSq(a, points[i]));
+		if (left <= length && length > 0) {
+			const t = left / length;
+			return {
+				x: a.x + (points[i].x - a.x) * t,
+				z: a.z + (points[i].z - a.z) * t
+			};
+		}
+		left -= length;
+	}
+	return point(points[points.length - 1]);
+}
+/**
+* Where a place is on a side's lane: how far along from the side's end, how far off the line
+*
+* @beta
+*/
+function onLane(lane, at) {
+	const measured = measure(lane.points, at);
+	return {
+		along: lane.from === 0 ? measured.along : lane.length - measured.along,
+		off: measured.off
+	};
+}
+/**
+* The point so far along a side's lane from its end
+*
+* @beta
+*/
+function laneAt(lane, along) {
+	const clamped = Math.min(Math.max(along, 0), lane.length);
+	return pointAlong(lane.points, lane.from === 0 ? clamped : lane.length - clamped);
+}
+/** A unit's share of its health */
+function health(ai, unit) {
+	const max = unit.maxHealth ?? ai.view.strength.statsOf(unit).health;
+	return max > 0 ? unit.health / max : 1;
+}
+/** How far a tower reaches: its attack's range and its size, a cell more */
+function reachOf(ai, tower) {
+	return farthestReach(ai.view.def(tower), ai.view.strength.statsOf(tower)) + ai.view.def(tower).radius + 1;
+}
+/** Their towers, as remembered: buildings of theirs that attack */
+var theirTowers = (ai) => ai.cache("lanes.theirTowers", () => ai.view.enemies.known().buildings().alive().where((_entity, def) => !!def.attacks?.length));
+/** Whether a place is in reach of one of their towers with no minion of its side in that tower's reach to take the shots */
+function exposed(ai, at, pad = 0) {
+	for (const tower of theirTowers(ai)) {
+		const reach = reachOf(ai, tower) + pad;
+		if (distSq(tower, at) > reach * reach) continue;
+		if (!ai.view.all.units().alive().near(tower, reachOf(ai, tower)).where((unit) => ai.view.isFriendly(unit) && !heroOfState(unit) && !ai.view.def(unit).hero).length) return true;
+	}
+	return false;
+}
+/**
+* Whom a hero of a lanes brain hits (micro's `targets`, the file's comment): the minion its next hit kills, one of their
+* heroes not under their tower, a building (a tower its side's minions take the shots of), the weakest of the rest; never
+* what stands where their tower would turn on it
+*
+* @beta
+*/
+var lanesTargets = (options = {}) => (ai, squad, foes) => {
+	const { view } = ai;
+	const hitters = squad.units();
+	const middle = hitters.centre();
+	if (!middle) return void 0;
+	const safe = foes.where((foe, def) => {
+		if (def.kind === "building") return def.attacks?.length ? !exposed(ai, foe, -reachOf(ai, foe)) : !exposed(ai, foe);
+		if (def.hero || heroOfState(foe)) return !theirTowers(ai).some((tower) => {
+			const reach = reachOf(ai, tower) + 2;
+			return distSq(tower, foe) <= reach * reach;
+		});
+		return !exposed(ai, foe);
+	});
+	if (!safe.length) return void 0;
+	const nearest = (set) => set.reduce((best, each) => !best || distSq(each, middle) < distSq(best, middle) ? each : best, void 0);
+	if (options.lastHits !== false) {
+		const blow = Math.max(0, ...hitters.map((unit) => view.strength.statsOf(unit).attackDamage));
+		const last = nearest(safe.where((foe, def) => def.kind === "unit" && !def.hero && !heroOfState(foe) && foe.health <= blow).items);
+		if (last) return last;
+	}
+	const heroes = safe.where((foe, def) => !!def.hero || !!heroOfState(foe));
+	if (heroes.length) return heroes.items.reduce((best, each) => health(ai, each) < health(ai, best) ? each : best);
+	const buildings = safe.buildings();
+	if (buildings.length) return nearest(buildings.items);
+	return safe.items.reduce((best, each) => each.health < best.health || each.health === best.health && distSq(each, middle) < distSq(best, middle) ? each : best);
+};
+/**
+* The lanes of a lanes brain, read as its side sees them, and what its heroes do on them (`ai.module('lanes')`'s
+* `play`): the module's goals read it
+*
+* @beta
+*/
+var LanesPlay = class {
+	ai;
+	options;
+	/** What the play keeps between thinks, as `LanesPlayMemory`: the heroes resting and when each was sent home */
+	memory = {
+		v: 1,
+		resting: {},
+		recalled: {},
+		sent: {}
+	};
+	sides;
+	constructor(ai, options) {
+		this.ai = ai;
+		this.options = options;
+	}
+	/** The lanes as its side reads them: each measured from the end its side's spawner stands at. None it has no end of */
+	lanes() {
+		if (this.sides) return this.sides;
+		const { view } = this.ai;
+		const only = this.options.lanes;
+		const ours = (end) => !!end && (end.player === view.playerId || view.player(end.player)?.relation === "ally");
+		const found = [];
+		for (const lane of view.lanes()) {
+			if (only && !only.includes(lane.path)) continue;
+			const from = ours(lane.ends[0]) ? 0 : ours(lane.ends[1]) ? 1 : void 0;
+			if (from === void 0) continue;
+			found.push({
+				path: lane.path,
+				points: lane.points,
+				from,
+				length: lengthOf(lane.points)
+			});
+		}
+		if (view.players.length) this.sides = found;
+		return found;
+	}
+	/** A lane of its side's, by its path's name */
+	lane(path) {
+		return this.lanes().find((lane) => lane.path === path);
+	}
+	/** The units it commands: its heroes, or what `units` says. Alive */
+	commanded(units = this.ai.view.mine) {
+		const { units: commands } = this.options;
+		const alive = units.units().alive();
+		return commands ? alive.where((unit) => commands(this.ai, unit)) : alive.heroes();
+	}
+	/**
+	* Where its heroes rest: `home`, else its side's building nearest the middle of its side's ends of the lanes (a core),
+	* else that middle, else its first building
+	*/
+	home() {
+		const { home } = this.options;
+		if (home) return typeof home === "function" ? home(this.ai) : point(home);
+		const ends = this.lanes().map((lane) => laneAt(lane, 0));
+		if (ends.length) {
+			const middle = {
+				x: ends.reduce((sum, end) => sum + end.x, 0) / ends.length,
+				z: ends.reduce((sum, end) => sum + end.z, 0) / ends.length
+			};
+			const { view } = this.ai;
+			const building = view.all.buildings().alive().where((entity) => view.isFriendly(entity)).near(middle, 16).nearest(middle);
+			return building ? point(building) : middle;
+		}
+		const first = this.ai.view.home();
+		return first && point(first);
+	}
+	/** Each lane as it stands this think: fronts, minions, heroes, towers. Once a think */
+	states() {
+		return this.ai.cache("lanes.states", () => this.lanes().map((lane) => this.stateOf(lane)));
+	}
+	/** One lane as it stands this think */
+	state(path) {
+		return this.states().find((state) => state.lane.path === path);
+	}
+	stateOf(lane) {
+		const { ai } = this;
+		const { view } = ai;
+		const state = {
+			lane,
+			ours: [],
+			theirs: [],
+			allies: [],
+			enemies: [],
+			ourTowers: [],
+			theirTowers: []
+		};
+		for (const unit of view.all.units().alive()) {
+			const friendly = view.isFriendly(unit);
+			if (!friendly && !(view.isHostile(unit) && !view.isCreep(unit))) continue;
+			const { along, off } = onLane(lane, unit);
+			if (off > ON_LANE) continue;
+			if (!!view.def(unit).hero || !!heroOfState(unit)) {
+				if (!friendly) state.enemies.push(unit);
+				else if (unit.owner !== view.playerId) state.allies.push(unit);
+				continue;
+			}
+			if (friendly) {
+				state.ours.push(unit);
+				if (state.front === void 0 || along > state.front) state.front = along;
+			} else {
+				state.theirs.push(unit);
+				if (state.theirFront === void 0 || along < state.theirFront) state.theirFront = along;
+			}
+		}
+		const towers = view.all.known().buildings().alive().where((_entity, def) => !!def.attacks?.length);
+		for (const tower of towers) {
+			const { along, off } = onLane(lane, tower);
+			if (off > BY_LANE) continue;
+			if (view.isFriendly(tower)) state.ourTowers.push({
+				tower,
+				at: along
+			});
+			else if (view.isHostile(tower) && !view.isCreep(tower)) state.theirTowers.push({
+				tower,
+				at: along
+			});
+		}
+		return state;
+	}
+	/**
+	* Where a hero walks on a lane now: a little behind its side's front; with no wave there, by its side's furthest tower
+	* on it (or a little out of its end); never into reach of a tower of theirs that no minion of its side is in reach of
+	*/
+	spot(path) {
+		const state = this.state(path);
+		if (!state) return void 0;
+		const { lane } = state;
+		const behind = this.options.behind ?? 3;
+		let along;
+		if (state.front !== void 0) along = state.front - behind;
+		else along = Math.max(6, ...state.ourTowers.map((each) => each.at - 2));
+		for (const { tower, at } of state.theirTowers) {
+			const reach = reachOf(this.ai, tower);
+			if (!state.ours.some((unit) => distSq(unit, tower) <= reach * reach) && along > at - reach - 1) along = at - reach - 1;
+		}
+		return laneAt(lane, Math.max(0, along));
+	}
+	/**
+	* What is at stake on a lane, 0..1: how far along its side's wave is (a tower of theirs to take, their core), or how
+	* near its side's end theirs is (its own towers under attack), whichever is more
+	*/
+	stake(path) {
+		const state = this.state(path);
+		if (!state) return 0;
+		const { length } = state.lane;
+		const ours = state.front === void 0 ? 0 : state.front / length;
+		const theirs = state.theirFront === void 0 ? 0 : 1 - state.theirFront / length;
+		return Math.min(1, Math.max(ours, theirs));
+	}
+	/** Where a hero outmatched on a lane falls back to: its side's nearest tower behind it, or so far back along it */
+	fallBack(path, from) {
+		const state = this.state(path);
+		if (!state) return void 0;
+		const { along } = onLane(state.lane, from);
+		const behind = state.ourTowers.filter((each) => each.at < along - 2).sort((a, b) => b.at - a.at)[0];
+		return behind ? laneAt(state.lane, behind.at - 2) : laneAt(state.lane, along - FALL_BACK);
+	}
+	/** The odds of its side against theirs where a unit stands (`Strength.odds`): their towers that reach there count */
+	oddsAt(at, reach = 9) {
+		const { view } = this.ai;
+		const near = view.all.units().alive().near(at, reach);
+		const ours = near.where((unit) => view.isFriendly(unit));
+		const theirs = [...near.where((unit) => view.isHostile(unit)).items];
+		for (const tower of theirTowers(this.ai)) {
+			const towerReach = reachOf(this.ai, tower);
+			if (distSq(tower, at) <= towerReach * towerReach) theirs.push(tower);
+		}
+		return theirs.length ? view.strength.odds(ours, theirs) : 1;
+	}
+	/** The heroes resting, alive */
+	resting() {
+		return this.commanded().where((hero) => this.memory.resting[hero.id] !== void 0).items;
+	}
+	/** Heroes turned for home, those back out: what the `lanes.back` goal reads. Each think, before the goals */
+	think() {
+		const { ai } = this;
+		const { memory } = this;
+		const backAt = this.options.backAt ?? .35;
+		const returnAt = this.options.returnAt ?? .85;
+		const restFor = (this.options.restFor ?? 40) * ai.session.tickRate;
+		const heroes = this.commanded();
+		for (const id in memory.resting) if (!heroes.has(Number(id))) delete memory.resting[id];
+		for (const id in memory.recalled) if (!heroes.has(Number(id))) delete memory.recalled[id];
+		for (const id in memory.sent) if (memory.resting[id] === void 0) delete memory.sent[id];
+		for (const hero of heroes) {
+			const share = health(ai, hero);
+			const since = memory.resting[hero.id];
+			if (since === void 0) {
+				if (share < backAt) {
+					memory.resting[hero.id] = ai.tick;
+					ai.decide(`${hero.type} ${hero.id} goes home to rest at ${Math.round(share * 100)}%`, { kind: "lanes" });
+				}
+			} else if (share >= returnAt || ai.tick - since >= restFor) {
+				delete memory.resting[hero.id];
+				ai.decide(`${hero.type} ${hero.id} rested, back out at ${Math.round(share * 100)}%`, { kind: "lanes" });
+			}
+		}
+	}
+	/**
+	* Sends a resting hero home: by an ability that takes it there (one whose effects, at its end, teleport home), where
+	* it has one ready and nothing hostile is near; else on foot. Nothing while it channels, or once home
+	*/
+	sendHome(hero) {
+		const { ai } = this;
+		const home = this.home();
+		if (!home || !hero.own || hero.own.hidden) return;
+		if (distSq(hero, home) <= 64 || hero.own.order === "cast") return;
+		const recalled = this.memory.recalled[hero.id];
+		const safe = !ai.view.hostile.alive().near(hero, 12).length;
+		if (this.options.recall !== false && safe && (recalled === void 0 || ai.tick - recalled >= RECALL_AGAIN * ai.session.tickRate)) {
+			const ability = hero.own.abilities?.find((state) => {
+				if (state.level < 1 || state.cooldown > 0 || state.charges === 0) return false;
+				const def = ai.registry.ability(state.id);
+				return [...def.effects, ...def.channel?.finished ?? []].some((effect) => effect.type === "teleport" && effect.to === "home");
+			});
+			if (ability) {
+				this.memory.recalled[hero.id] = ai.tick;
+				ai.send({
+					type: "cast",
+					entities: [hero.id],
+					ability: ability.id
+				});
+				ai.decide(`${hero.type} ${hero.id} recalls home`, { kind: "lanes" });
+				return;
+			}
+		}
+		if (hero.own.order === "move") return;
+		const sent = this.memory.sent[hero.id];
+		if (sent !== void 0 && ai.tick - sent < 3 * ai.session.tickRate) return;
+		this.memory.sent[hero.id] = ai.tick;
+		ai.send({
+			type: "order",
+			entities: [hero.id],
+			order: {
+				type: "move",
+				point: home
+			}
+		});
+	}
+	/** An ally's hero in a fight one of its heroes could go to: the most hurt, near enough; or a person's call for help */
+	call(from) {
+		const help = this.options.help;
+		if (help === false) return void 0;
+		const { ai } = this;
+		const { view } = ai;
+		const reach = help?.reach ?? 30;
+		const theirHeroes = view.enemies.units().alive().where((unit, def) => !!def.hero || !!heroOfState(unit));
+		let best;
+		for (const ally of view.allies.units().alive().heroes()) {
+			if (distSq(ally, from) > reach * reach || !theirHeroes.near(ally, FIGHTING).length) continue;
+			if (!best || health(ai, ally) < health(ai, best)) best = ally;
+		}
+		if (best) return point(best);
+		const ping = ai.area(Team).enabled ? ai.area(Team).requests("help").find((request) => request.by === "ping" && distSq(request.at, from) <= reach * reach) : void 0;
+		return ping && point(ping.at);
+	}
+	/** The ally's hero nearest a place: what a hero helping goes with */
+	allyAt(at) {
+		return this.ai.view.allies.units().alive().heroes().near(at, 2).first();
+	}
+	/** The nearest camp it may take from a place: not cleared, in reach, its creeps (as seen) beatable */
+	camp(hero) {
+		const camps = this.options.camps;
+		if (camps === false) return void 0;
+		const { ai } = this;
+		const { view } = ai;
+		const reach = camps?.reach ?? 50;
+		const odds = camps?.odds ?? .6;
+		let best;
+		for (const camp of view.camps()) {
+			if (camp.cleared) continue;
+			const d = distSq(camp, hero);
+			if (d > reach * reach || best && d >= best.d) continue;
+			const creeps = view.creeps.alive().near(camp, 8);
+			if (creeps.length ? view.strength.odds([hero], creeps) >= odds : camp.level <= 2 + 2 * (heroOfState(hero)?.level ?? 1)) best = {
+				at: {
+					x: camp.x,
+					z: camp.z
+				},
+				d
+			};
+		}
+		return best?.at;
+	}
+};
+/** The kit's lane task: a hero walks a lane behind its side's wave (`LanesPlay.spot`), falling back once outmatched */
+var PUSH = defineTask({
+	id: "lanes.push",
+	start(ai, squad, state) {
+		state.phase = "going";
+		state.phaseSince = ai.tick;
+		pushOn(ai, squad, state, true);
+	},
+	think(ai, squad, state) {
+		pushOn(ai, squad, state, false);
+	},
+	where: (ai, _squad, state) => playOf(ai)?.spot(state.data.lane),
+	handles: [
+		"retreat",
+		"regroup",
+		"reinforce"
+	],
+	standing: true
+});
+/** The lanes module's play, where the brain has one */
+var playOf = (ai) => ai.module(LANES)?.play;
+/** A hero on its lane: to its spot, fighting on the way; back along it when outmatched */
+function pushOn(ai, squad, state, first) {
+	const play = playOf(ai);
+	const path = state.data.lane;
+	const lane = play?.state(path);
+	const middle = squad.centre();
+	if (!play || !lane || !middle) {
+		squad.finish("lost");
+		return;
+	}
+	const fighting = ai.view.hostile.alive().near(middle, 9).length > 0;
+	if (fighting && play.oddsAt(middle) < (play.options.backOdds ?? .3)) {
+		const to = play.fallBack(path, middle);
+		if (to) {
+			ai.decide(`squad ${squad.name} falls back along ${path} to ${where(to)}: outmatched (odds ${play.oddsAt(middle).toFixed(2)})`, { kind: "lanes" });
+			squad.retreat(to, "outmatched on its lane");
+			return;
+		}
+	}
+	const spot = play.spot(path);
+	const phase = lane.front !== void 0 ? "pushing" : "waiting";
+	if (state.phase !== phase) {
+		state.phase = phase;
+		state.phaseSince = ai.tick;
+	}
+	const idle = squad.idleUnits();
+	if (fighting && !idle.length) return;
+	const sentTo = state.memory.at;
+	const moved = !sentTo || distSq(sentTo, spot) > 16;
+	const away = squad.units().some((unit) => distSq(unit, spot) > 16);
+	if (!first && !(away && (moved || idle.length && squad.mayResend()))) return;
+	state.memory.at = point(spot);
+	squad.fight(spot);
+}
+/**
+* What finds a lanes brain's module with its shape (`ai.module(LANES)`)
+*
+* @beta
+*/
+var LANES = moduleKey("lanes");
+/** The goals of a lanes brain over its play (the file's comment) */
+function laneGoals(ai, play) {
+	/** Its heroes free to go: alive, not resting */
+	const free = (available) => play.commanded(available).where((hero) => play.memory.resting[hero.id] === void 0);
+	const nearestTo = (set, at) => at ? set.nearest(at) : set.first();
+	const push = (ai.session.can.computer?.lanes() ?? []).map((lane) => lane.path).filter((path) => !play.options.lanes || play.options.lanes.includes(path)).map((path) => {
+		const id = `lanes.push:${path}`;
+		return defineGoal({
+			id,
+			weight: 1,
+			commitment: 30,
+			considerations: [
+				consider("a lane of its side", () => play.lane(path) ? 1 : 0, curve.step(1)),
+				consider("a hero free", () => free(ai.view.mine).length, curve.step(1)),
+				consider("its wave on it", () => ai.view.strength.sum(play.state(path)?.ours ?? []), curve.custom((x) => .3 + .7 * (1 - exp(-x / 60)))),
+				consider("what is at stake", () => play.stake(path), curve.custom((x) => .4 + .6 * x)),
+				consider("the odds at its front", () => {
+					const spot = play.spot(path);
+					return spot ? play.oddsAt(spot, 14) : 0;
+				}, curve.custom((odds) => .2 + odds)),
+				consider("allies already on it", () => play.state(path)?.allies.length ?? 0, curve.inverse(2)),
+				consider("how far its hero is", () => {
+					const spot = play.spot(path);
+					const hero = nearestTo(free(ai.view.mine), spot);
+					return hero && spot ? Math.sqrt(distSq(hero, spot)) : 0;
+				}, curve.inverse(60))
+			],
+			claims: { units: (_ai, available) => {
+				const hero = nearestTo(free(available), play.spot(path));
+				return hero ? [hero] : [];
+			} },
+			run: (_ai, claimed) => {
+				const squad = claimed.squad(id, claimed.units, { retreatAt: false });
+				if (squad.idle) squad.task(PUSH, { lane: path });
+			}
+		});
+	});
+	const back = defineGoal({
+		id: "lanes.back",
+		weight: 10,
+		urgent: true,
+		commitment: 0,
+		considerations: [consider("a hero to rest", () => play.resting().length, curve.step(1))],
+		claims: { units: () => play.resting() },
+		run: (ai, claimed) => {
+			const hold = ai.goals.held("lanes.back");
+			const resting = play.resting();
+			const fresh = resting.filter((hero) => !hold?.units.includes(hero.id)).map((hero) => hero.id);
+			if (fresh.length) {
+				ai.goals.take(fresh, "urgent");
+				ai.goals.give("lanes.back", fresh);
+			}
+			const rested = claimed.units.where((hero) => play.memory.resting[hero.id] === void 0).ids();
+			if (rested.size) ai.goals.drop("lanes.back", rested);
+			for (const hero of resting) play.sendHome(hero);
+		}
+	});
+	const help = defineGoal({
+		id: "lanes.help",
+		weight: 1.3,
+		commitment: 6,
+		considerations: [consider("an ally in a fight near", () => {
+			const hero = free(ai.view.mine).first();
+			return hero && play.call(hero) ? 1 : 0;
+		}, curve.step(1)), consider("the odds there with it", () => {
+			const hero = free(ai.view.mine).first();
+			const at = hero && play.call(hero);
+			if (!hero || !at) return 0;
+			const near = ai.view.all.units().alive().near(at, 12);
+			const theirs = near.where((unit) => ai.view.isHostile(unit));
+			return theirs.length ? ai.view.strength.odds([...near.where((unit) => ai.view.isFriendly(unit)).items, hero], theirs) : 1;
+		}, curve.custom((odds) => odds >= ((play.options.help || {}).odds ?? .4) ? odds : 0))],
+		claims: { units: (_ai, available) => {
+			const heroes = free(available);
+			const hero = heroes.first();
+			const at = hero && play.call(hero);
+			const chosen = at && heroes.nearest(at);
+			return chosen ? [chosen] : [];
+		} },
+		run: (ai, claimed) => {
+			const hero = claimed.units.first();
+			const at = hero && play.call(hero);
+			if (!hero || !at) return;
+			const ally = play.allyAt(at);
+			const squad = claimed.squad("lanes.help", claimed.units, { retreatAt: false });
+			if (claimed.first) ai.decide(`${hero.type} ${hero.id} goes to help at ${where(at)}`, { kind: "lanes" });
+			if (squad.idle || ally && squad.current?.kind !== "escort") {
+				if (ally) squad.escort(ally.id);
+				else squad.attack(at);
+			}
+		}
+	});
+	const camp = defineGoal({
+		id: "lanes.camp",
+		weight: .6,
+		commitment: 15,
+		considerations: [consider("no wave to walk with", () => play.states().filter((state) => state.ours.length > 0).length, curve.inverse(.01)), consider("a camp it can take", () => {
+			const hero = free(ai.view.mine).first();
+			return hero && play.camp(hero) ? 1 : 0;
+		}, curve.step(1))],
+		claims: { units: (_ai, available) => {
+			const hero = free(available).first();
+			return hero && play.camp(hero) ? [hero] : [];
+		} },
+		run: (_ai, claimed) => {
+			const hero = claimed.units.first();
+			const at = hero && play.camp(hero);
+			const squad = claimed.squad("lanes.camp", claimed.units, { retreatAt: false });
+			if (squad.idle && at) squad.creep(at);
+		}
+	});
+	return [
+		...push,
+		back,
+		...play.options.help === false ? [] : [help],
+		...play.options.camps === false ? [] : [camp]
+	];
+}
+/**
+* The module of a lanes brain: the lanes read for its side, its heroes' rest, and its goals put on the picker (the
+* file's comment). Its options under the brain's settings (`AiSettings.lanes`)
+*
+* @beta
+*/
+var lanesPlay = (options = {}) => defineModule({
+	id: "lanes",
+	make: (ai) => {
+		const play = new LanesPlay(ai, {
+			...options,
+			...ai.settings.lanes
+		});
+		ai.squads.define(PUSH);
+		ai.goals.add(...laneGoals(ai, play));
+		return {
+			id: "lanes",
+			version: 1,
+			phase: "decide",
+			play,
+			think: () => play.think(),
+			save: () => structuredClone(play.memory),
+			restore: (data) => {
+				const kept = data && typeof data === "object" ? data : {};
+				play.memory.resting = { ...kept.resting };
+				play.memory.recalled = { ...kept.recalled };
+				play.memory.sent = { ...kept.sent };
+			},
+			inspect: () => ({
+				lanes: play.states().map((state) => ({
+					lane: state.lane.path,
+					front: state.front === void 0 ? void 0 : Math.round(state.front),
+					theirFront: state.theirFront === void 0 ? void 0 : Math.round(state.theirFront),
+					ours: state.ours.length,
+					theirs: state.theirs.length
+				})),
+				resting: Object.keys(play.memory.resting).map(Number)
+			})
+		};
+	}
+});
+/**
+* The engine's computer player for a game of lanes (`lanesPack`): a brain of its rules, the words, `lanesPlay`, the
+* team, the picker, squads and micro (the file's comment). Heroes walk the lanes with their waves, rest at home when
+* hurt, help an ally's hero, take a camp with no wave to walk with. A variant is `lanesBrain.with({ ... })`; a game's
+* own lanes brain is `lanesBrainOf({ id, lanes, ... })`
+*
+* @beta
+*/
+function lanesBrainOf(def) {
+	const { lanes, modules = [], settings, ...rest } = def;
+	return defineBrain({
+		...rest,
+		settings: {
+			...settings,
+			micro: {
+				heroesFlee: false,
+				unitsFlee: false,
+				focusEvery: 2,
+				targets: lanesTargets(lanes),
+				...settings?.micro
+			},
+			team: {
+				defendUsers: false,
+				askForHelp: false,
+				...settings?.team
+			}
+		},
+		modules: [
+			defineModule({
+				id: "rules",
+				make: (ai) => rules(ai.def.rules ?? [])(ai)
+			}),
+			words(),
+			team(),
+			lanesPlay(lanes),
+			...modules,
+			goals(),
+			squads(),
+			micro()
+		]
+	});
+}
+/**
+* The engine's computer player for a game of lanes, as it is: `lanesBrainOf({ id: 'core.lanes' })`. List it in the
+* game's `Rules.brains` and seat it (`world.computers.seat(player, { brain: lanesBrain })`)
+*
+* @beta
+*/
+var lanesBrain = lanesBrainOf({ id: "core.lanes" });
+//#endregion
+export { LANES, LanesPlay, laneAt, lanesBrain, lanesBrainOf, lanesPlay, lanesTargets, onLane };
+
+//# sourceMappingURL=lanes.js.map