@v12-engine/engine 0.0.0-stage → 0.1.0

package/dist/ai/knowledge.d.ts

@@ -0,0 +1,418 @@
+import type { ResourceKind } from '#engine/defs';
+import type { AiArea } from './area';
+import type { PlayerId } from '#engine/entity';
+import { type Vec2 } from '#engine/math';
+import type { CampInfo, EntityState, MineInfo } from '#engine/session/protocol';
+import type { AiView } from './view';
+/**
+ * How a brain's knowledge remembers (`BrainDef.knowledge`): how long, how much, what counts as the army. Every field
+ * has its default; numbers are seconds where they say so
+ *
+ * @beta
+ */
+export interface KnowledgeOptions {
+    /** Seconds a sighting of the enemy's army, or of a worker, is kept: 180 */
+    armyFor?: number;
+    /** Seconds a structure seen gone is still remembered as gone, and an event, a loss or an attack sent is kept: 300 */
+    keepFor?: number;
+    /** How near two groups of enemy fighters are to be one sighting, and a newer sighting to replace an older: 16 */
+    mergeRadius?: number;
+    /** Seconds between samples of what was gathered, for `own.income`: 5 */
+    historyEvery?: number;
+    /** At most so many of each: sightings 12, workers 40, heroes 16, structures 400, losses 64, events 48, attacks 20, samples 36 */
+    limits?: Partial<Record<'sightings' | 'workers' | 'heroes' | 'structures' | 'lost' | 'events' | 'attacks' | 'history', number>>;
+    /** What of the enemy's units in sight counts as their army: their soldiers and heroes (`UnitSet.fighters`) when left out */
+    army?: (entity: EntityState, view: AiView) => boolean;
+}
+/**
+ * An enemy structure as remembered: where, what, whose, and when it was first and last in sight (ticks). `gone` is the
+ * tick it was known to be gone: seen destroyed, or its spot seen empty
+ *
+ * @beta
+ */
+export interface StructureSeen {
+    id: number;
+    type: string;
+    owner: PlayerId;
+    at: Vec2;
+    first: number;
+    last: number;
+    gone?: number;
+}
+/**
+ * A group of the enemy's fighters, seen together (`enemy.armySeen`): where its middle was, the tick, how many, of
+ * what types, with how much health and strength, whose (the owner of most of them)
+ *
+ * @beta
+ */
+export interface ArmySighting {
+    at: Vec2;
+    tick: number;
+    owner: PlayerId;
+    count: number;
+    /** Their health together, as seen */
+    health: number;
+    /** Their strength together, as seen (`Strength.of`, with the health each had left) */
+    strength: number;
+    types: Record<string, number>;
+    heroes: number;
+}
+/**
+ * An enemy unit as last seen (`enemy.workersSeen`, `enemy.heroesSeen`): `level` for a hero, `died` the tick it was
+ * seen to die (a hero may come back)
+ *
+ * @beta
+ */
+export interface UnitSeen {
+    id: number;
+    type: string;
+    owner: PlayerId;
+    at: Vec2;
+    tick: number;
+    level?: number;
+    died?: number;
+}
+/**
+ * A unit type of the enemy's as seen (`enemy.typesSeen`): first and last tick, and the most seen at once
+ *
+ * @beta
+ */
+export interface TypeSeen {
+    first: number;
+    last: number;
+    most: number;
+}
+/**
+ * An enemy's base, as its structures remembered cluster (`enemy.bases`): around what takes deposits (a hall), or
+ * around any structure where none does. `gone` when every structure of it is known gone; `expansion` for every base of
+ * an owner but the first seen of theirs
+ *
+ * @beta
+ */
+export interface EnemyBase {
+    owner: PlayerId;
+    at: Vec2;
+    /** When the first of it was seen */
+    first: number;
+    /** When any of it was last in sight */
+    last: number;
+    structures: StructureSeen[];
+    /** Whether it is around what takes deposits: a hall, not a lone tower */
+    hall: boolean;
+    gone: boolean;
+    expansion: boolean;
+}
+/**
+ * Something of one's own that died (`own.lost`): what, where, when, to what type of killer where it was seen
+ *
+ * @beta
+ */
+export interface Loss {
+    id: number;
+    type: string;
+    at: Vec2;
+    tick: number;
+    by?: string;
+}
+/**
+ * An attack a module sent (`own.attackSent`): when, where to, with how many
+ *
+ * @beta
+ */
+export interface AttackSent {
+    tick: number;
+    at: Vec2;
+    count: number;
+}
+/**
+ * A ping heard (`events.pings`): who marked where, of what kind
+ *
+ * @beta
+ */
+export interface PingHeard {
+    tick: number;
+    player: PlayerId;
+    at: Vec2;
+    kind: string;
+}
+/**
+ * Damage seen done to one's own or an ally's entity in a think (`events.damage`): added up over the think, one line
+ * an entity
+ *
+ * @beta
+ */
+export interface DamageSeen {
+    tick: number;
+    id: number;
+    type: string;
+    owner: PlayerId;
+    at: Vec2;
+    amount: number;
+    by?: string;
+}
+/**
+ * A death seen (`events.deaths`): of anyone known to the seat in the think before
+ *
+ * @beta
+ */
+export interface DeathSeen {
+    tick: number;
+    id: number;
+    type: string;
+    owner: PlayerId;
+    at: Vec2;
+    by?: string;
+}
+/**
+ * What a brain's knowledge is, as plain data: what a save keeps (`Brain.save`, under `knowledge`), what a game's module
+ * may read or add to through `Knowledge`
+ *
+ * @beta
+ */
+export interface KnowledgeMemory {
+    v: 1;
+    /** The tick it was last brought up to date */
+    tick: number;
+    structures: StructureSeen[];
+    /** Newest first */
+    army: ArmySighting[];
+    workers: UnitSeen[];
+    heroes: UnitSeen[];
+    types: Record<string, TypeSeen>;
+    /** The tick each cell of the map was last in sight, row by row (-1: never); `cols` cells a row */
+    looked: {
+        cols: number;
+        rows: number;
+        ticks: number[];
+    };
+    lost: Loss[];
+    attacks: AttackSent[];
+    /** What was gathered of each resource since the game began, as far as rises in what the player has tell */
+    gathered: Record<ResourceKind, number>;
+    /** What the player had at the last update, to see the next rise against */
+    had?: Record<ResourceKind, number>;
+    /** Samples of `gathered`, oldest first */
+    history: {
+        tick: number;
+        gathered: Record<ResourceKind, number>;
+    }[];
+    pings: PingHeard[];
+    damage: DamageSeen[];
+    deaths: DeathSeen[];
+}
+declare const LIMITS: {
+    sightings: number;
+    workers: number;
+    heroes: number;
+    structures: number;
+    lost: number;
+    events: number;
+    attacks: number;
+    history: number;
+};
+/**
+ * What a computer player remembers of the enemy, the map and itself, with when (`Brain.knowledge`). Brought up to date
+ * once a think from the view; asked through its parts: `enemy` (structures, bases, army seen, workers, heroes, tech),
+ * `map` (when a place was last looked at), `own` (losses, attacks sent, income), `events` (pings, damage, deaths heard).
+ * Plain data underneath (`data`), saved with the brain
+ *
+ * @beta
+ */
+export declare class Knowledge implements AiArea {
+    /** Whether a save keeps it: not for a brain that remembers nothing between thinks (`BrainDef.knowledge: false`) */
+    private readonly kept;
+    /** Its id among the brain's areas: what its memory and its report are kept under */
+    readonly id = "knowledge";
+    /** What the log says where a save's memory of it is of a shape it does not read */
+    readonly afresh = "the save remembers what the computer player knew in a shape this brain does not read: it starts afresh";
+    /** What it remembers, as plain data. Replaced as a whole by `restore` */
+    data: KnowledgeMemory;
+    /** The enemy: structures, bases, army, workers, heroes, tech */
+    readonly enemy: EnemyKnowledge;
+    /** The map: when each place was last in sight */
+    readonly map: MapKnowledge;
+    /** One's own: losses, attacks sent, income */
+    readonly own: OwnKnowledge;
+    /** What was heard: pings, damage to friends, deaths */
+    readonly events: HeardEvents;
+    /** Where in the fog each cell of the map is read: found again when the fog or the map is of another size */
+    private sample;
+    readonly options: Required<Omit<KnowledgeOptions, 'army' | 'limits'>> & Pick<KnowledgeOptions, 'army'> & {
+        limits: typeof LIMITS;
+    };
+    constructor(options?: KnowledgeOptions, 
+    /** The map's size, where known before the first update: what is looked at can be told before it (an older save) */
+    size?: {
+        width: number;
+        depth: number;
+    }, 
+    /** Whether a save keeps it: not for a brain that remembers nothing between thinks (`BrainDef.knowledge: false`) */
+    kept?: boolean);
+    /** Makes what is remembered of the map the size of a map of this many units: forgotten where it was another size */
+    private size;
+    /** The tick it was last brought up to date */
+    get tick(): number;
+    /**
+     * Brings it up to date from a think's view. `before` is the view of the think before: what the dead of this think
+     * were (a death says only an id). What the brain calls as each think begins, after the view is made
+     */
+    update(view: AiView, before?: AiView): void;
+    /** Brings what was last looked at up to date from the seat's fog: what is in sight now, by cell (1 for in sight) */
+    /**
+     * Reads the think's picture through this view without remembering anything of it: for a think a game loaded from a
+     * save goes on with (`BrainMemory.thinking`), whose picture the saved game remembered already, so that what is restored
+     * is as it was after that; only what is asked of the map now needs the view it is asked through
+     */
+    resume(view: AiView): void;
+    private lookAround;
+    /**
+     * The enemy's fighters in sight, grouped by nearness into sightings. A newer sighting replaces the older ones near
+     * it (the army moved); an older one whose place is in sight with no sighting near is dropped (no one is there now)
+     */
+    private seeArmy;
+    /**
+     * The enemy's workers and heroes in sight, by id, where they were. A worker whose place is in sight and who is not
+     * there is forgotten; a hero is kept where last seen (there are few, and where they went matters)
+     */
+    private seeUnits;
+    /** What the think's events say: deaths (one's own among them, as losses), pings, damage to one's own and allies' */
+    private hear;
+    /** What was gathered: every rise in what the player has, added up; sampled every `historyEvery` seconds */
+    private count;
+    /** Forgets what is older than so many seconds: sightings, workers, losses, attacks, what was heard, structures long gone */
+    forget(olderThan: number): void;
+    private forgetOlder;
+    /** What it remembers, as plain data for a save: a copy */
+    /** Whether it has anything to remember now: one that does not is left out of a save */
+    remembers(): boolean;
+    save(): KnowledgeMemory;
+    /** Takes back what `save` gave. Memory of another shape is dropped: it starts afresh */
+    restore(memory: unknown): boolean;
+    /** What it knows, in short, for the debug tools: bases, the army seen with its age, the tech seen */
+    inspect(): Record<string, unknown>;
+}
+/**
+ * What a computer player remembers of its enemies (`knowledge.enemy`): their structures and bases, their army as last
+ * seen, their workers and heroes, the types and tech seen. Creeps are no one's enemy here
+ *
+ * @beta
+ */
+export declare class EnemyKnowledge {
+    private readonly knowledge;
+    private basesFound;
+    private trainedBy;
+    constructor(knowledge: Knowledge);
+    /** Their structures remembered and not known gone (`gone: true` for those too), of one owner where given */
+    structures(options?: {
+        owner?: PlayerId;
+        gone?: boolean;
+    }): StructureSeen[];
+    /**
+     * Their bases: the structures remembered, gone ones too, clustered by owner around what takes deposits (a hall), or
+     * around any structure where none does. The first seen of each owner's first; `gone` where all of it is known gone
+     */
+    bases(owner?: PlayerId): EnemyBase[];
+    private cluster;
+    /** Their bases beyond the first of each owner's, with a hall: where they expanded to, as far as seen */
+    expansionsSeen(): EnemyBase[];
+    /** Their army as last seen, in groups, newest first; only those seen within so many seconds where given */
+    armySeen(withinSeconds?: number): ArmySighting[];
+    /** Their workers as last seen, newest first; only those seen within so many seconds where given */
+    workersSeen(withinSeconds?: number): UnitSeen[];
+    /** Their heroes as last seen, newest first: type, level, where, and `died` when seen to die */
+    heroesSeen(): UnitSeen[];
+    /** The unit and structure types of theirs seen, with when and the most seen at once */
+    typesSeen(): Readonly<Record<string, TypeSeen>>;
+    /** The most of a type of theirs seen at once: 0 for one never seen */
+    mostSeen(type: string): number;
+    /**
+     * What they have, as far as what was seen tells: the types seen; what those require, named as `UnitTypeDef.requires`
+     * names them; and the building that trains a type, where only one does (a gryphon means an aviary, and what an aviary
+     * requires). Sorted, for the same answer every time
+     */
+    techSeen(): string[];
+    /** The building types that train a unit type, found once for the game's definitions */
+    private trainersOf;
+    /** Takes in what a type seen was, where the game or an older save tells: as if seen, `count` at once, at a tick */
+    sawType(type: string, count: number, tick?: number): void;
+}
+/**
+ * What a computer player remembers of the map (`knowledge.map`): when each place was last in sight. The cells are of
+ * the view's grid (8 units)
+ *
+ * @beta
+ */
+export declare class MapKnowledge {
+    private readonly knowledge;
+    constructor(knowledge: Knowledge);
+    /** The tick a place was last in sight of the seat's team: none for a place never seen */
+    lastLooked(point: Vec2): number | undefined;
+    /** Seconds since a place was last in sight: `Infinity` for one never seen */
+    sinceLooked(point: Vec2): number;
+    /** Whether a place is in sight now, as of the last update */
+    inSight(point: Vec2): boolean;
+    /** Whether the seat's team has explored a place: seen it once, as the fog says */
+    explored(point: Vec2): boolean;
+    /** Takes in that a place was looked at, at a tick: where the game or an older save tells */
+    look(point: Vec2, tick?: number): void;
+    /**
+     * The map's mines (`view.mines`), each with when its place was last looked at and whose base is by it, as far as
+     * known: where to expand, where to look for theirs
+     */
+    mines(): (MineInfo & {
+        looked?: number;
+        taken?: PlayerId;
+    })[];
+    /** The map's creep camps, as the seat knows them (`view.camps`) */
+    camps(): readonly CampInfo[];
+}
+/**
+ * What a computer player remembers of itself (`knowledge.own`): what it lost, the attacks it sent, what it gathered
+ *
+ * @beta
+ */
+export declare class OwnKnowledge {
+    private readonly knowledge;
+    constructor(knowledge: Knowledge);
+    /** What of its own died, oldest first; only within so many seconds where given */
+    lost(withinSeconds?: number): Loss[];
+    /** What of its own died within a distance of a place: "we are being raided here" */
+    lostNear(point: Vec2, radius: number, withinSeconds?: number): Loss[];
+    /** Notes an attack sent, for whoever asks later (`attacks`): what a module that sends an army calls */
+    attackSent(point: Vec2, count: number): void;
+    /** The attacks sent, oldest first; only within so many seconds where given */
+    attacks(withinSeconds?: number): AttackSent[];
+    /**
+     * What it gathers of a resource a minute, over the last so many seconds (60): from the rises in what it has, so it
+     * is at least this (what was gathered and spent between two thinks does not show). Bounty counts as gathered
+     */
+    income(kind: ResourceKind, seconds?: number): number;
+    /** The income of every resource gathered so far, a minute (`income`) */
+    incomes(seconds?: number): Record<ResourceKind, number>;
+    /** What was gathered of each resource since the game began, as far as the rises tell */
+    get gathered(): Readonly<Record<ResourceKind, number>>;
+    /** The samples of what was gathered, oldest first */
+    get history(): KnowledgeMemory['history'];
+}
+/**
+ * What a computer player heard (`knowledge.events`): pings, damage to its own and its allies', deaths, each with its
+ * tick, the oldest first
+ *
+ * @beta
+ */
+export declare class HeardEvents {
+    private readonly knowledge;
+    constructor(knowledge: Knowledge);
+    /** Pings heard; only within so many seconds where given */
+    pings(withinSeconds?: number): PingHeard[];
+    /** Damage seen done to its own and its allies' entities, a line an entity a think; only within so many seconds where given */
+    damage(withinSeconds?: number): DamageSeen[];
+    /** Deaths seen, anyone's; only within so many seconds where given */
+    deaths(withinSeconds?: number): DeathSeen[];
+}
+declare module './area' {
+    interface AreaMemories {
+        knowledge?: KnowledgeMemory;
+    }
+}
+export {};

package/dist/ai/lanes.d.ts

@@ -0,0 +1,232 @@
+import { type Vec2 } from '#engine/math';
+import type { EntityState } from '#engine/session/protocol';
+import { type Brain, type BrainDef, type BrainExtension } from './brain';
+import { type AiModule, type AiModuleDef } from './module';
+import { type TargetPicker } from './micro';
+import type { UnitSet } from './view';
+/**
+ * How a lanes brain plays (`lanesPlay(options)`, the seat's `AiOptions.lanes` over it): its heroes' rest, how far it
+ * goes for an ally or a camp, how near its wave it walks. Data, but for `units` and `home` as functions
+ *
+ * @beta
+ */
+export interface LanesPlayOptions {
+    /**
+     * Which of its units it commands: its heroes when left out. The rest (the minions) are the lanes', and walk as they
+     * were sent
+     */
+    units?: (ai: Brain, unit: EntityState) => boolean;
+    /** Where its heroes go to rest: a point, or a function. Its side's building by its side's ends of the lanes when left out (a core) */
+    home?: Vec2 | ((ai: Brain) => Vec2 | undefined);
+    /** Only these lanes, by their path's name: every lane of the map when left out */
+    lanes?: string[];
+    /** The share of its health under which a hero goes home to rest: 0.35 */
+    backAt?: number;
+    /** The share at which a resting hero goes back out: 0.85 */
+    returnAt?: number;
+    /** Seconds a hero rests at home at most, healed or not: 40 */
+    restFor?: number;
+    /** Whether a hero going home uses an ability that takes it there (a recall), where nothing hostile is near: yes when left out */
+    recall?: boolean;
+    /** The odds where a hero stands on its lane under which it falls back along it: 0.3 */
+    backOdds?: number;
+    /** How many cells behind its side's wave a hero walks: 3 */
+    behind?: number;
+    /** An ally's hero in a fight it goes to: within `reach` cells of it (30), where the odds with it are at least `odds` (0.4). `false` never */
+    help?: false | {
+        reach?: number;
+        odds?: number;
+    };
+    /** A camp it takes with no wave to walk with: within `reach` cells (50), where the odds against it are at least `odds` (0.6). `false` never */
+    camps?: false | {
+        reach?: number;
+        odds?: number;
+    };
+    /** Whether a hero hits the minion its next hit kills before anything else (a last hit): yes when left out */
+    lastHits?: boolean;
+}
+/**
+ * What the lanes module remembers between thinks, as a save keeps it: the heroes resting, since when; when each last
+ * used an ability that takes it home
+ *
+ * @beta
+ */
+export interface LanesPlayMemory {
+    v: 1;
+    /** The heroes resting, by id: the tick they turned for home */
+    resting: Record<string, number>;
+    /** When each hero last set off home by its recall, by id */
+    recalled: Record<string, number>;
+    /** When each resting hero was last sent home on foot, by id */
+    sent: Record<string, number>;
+}
+/**
+ * A lane as one side reads it (`LanesPlay.lanes`): the path, measured from that side's end (`from`: the end its own
+ * spawner stands at), its length
+ *
+ * @beta
+ */
+export interface LaneSide {
+    /** The name of its path: what the goal and squad of the lane are named by (`lanes.push:mid`) */
+    path: string;
+    points: readonly Vec2[];
+    /** The end of the lane that is its side's: 0 the first point's, 1 the last's */
+    from: 0 | 1;
+    /** Cells from end to end, along it */
+    length: number;
+}
+/**
+ * A lane as it stands this think, for one side: its waves' fronts (in cells along it from its side's end), who is on
+ * it, the towers by it
+ *
+ * @beta
+ */
+export interface LaneState {
+    lane: LaneSide;
+    /** How far along its side's furthest minion is: none with no minion of its side on the lane */
+    front?: number;
+    /** How far along their nearest minion is: none with none of theirs on it */
+    theirFront?: number;
+    /** Its side's minions on it (the player's own and its allies'), and theirs */
+    ours: EntityState[];
+    theirs: EntityState[];
+    /** The heroes on it: its allies' (the player's own left out), and theirs */
+    allies: EntityState[];
+    enemies: EntityState[];
+    /** The towers by it, its side's and theirs (theirs as remembered), with how far along each stands */
+    ourTowers: {
+        tower: EntityState;
+        at: number;
+    }[];
+    theirTowers: {
+        tower: EntityState;
+        at: number;
+    }[];
+}
+/**
+ * Where a place is on a side's lane: how far along from the side's end, how far off the line
+ *
+ * @beta
+ */
+export declare function onLane(lane: LaneSide, at: Vec2): {
+    along: number;
+    off: number;
+};
+/**
+ * The point so far along a side's lane from its end
+ *
+ * @beta
+ */
+export declare function laneAt(lane: LaneSide, along: number): Vec2;
+/**
+ * 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
+ */
+export declare const lanesTargets: (options?: Pick<LanesPlayOptions, 'lastHits'>) => TargetPicker;
+/**
+ * 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
+ */
+export declare class LanesPlay {
+    /** The brain it plays for */
+    readonly ai: Brain;
+    /** How it plays: the module's, the seat's over it */
+    readonly options: LanesPlayOptions;
+    readonly memory: LanesPlayMemory;
+    private sides;
+    constructor(
+    /** The brain it plays for */
+    ai: Brain, 
+    /** How it plays: the module's, the seat's over it */
+    options: LanesPlayOptions);
+    /** 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(): readonly LaneSide[];
+    /** A lane of its side's, by its path's name */
+    lane(path: string): LaneSide | undefined;
+    /** The units it commands: its heroes, or what `units` says. Alive */
+    commanded(units?: UnitSet): UnitSet;
+    /**
+     * 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(): Vec2 | undefined;
+    /** Each lane as it stands this think: fronts, minions, heroes, towers. Once a think */
+    states(): readonly LaneState[];
+    /** One lane as it stands this think */
+    state(path: string): LaneState | undefined;
+    private stateOf;
+    /**
+     * 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: string): Vec2 | undefined;
+    /**
+     * 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: string): number;
+    /** 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: string, from: Vec2): Vec2 | undefined;
+    /** The odds of its side against theirs where a unit stands (`Strength.odds`): their towers that reach there count */
+    oddsAt(at: Vec2, reach?: number): number;
+    /** The heroes resting, alive */
+    resting(): readonly EntityState[];
+    /** Heroes turned for home, those back out: what the `lanes.back` goal reads. Each think, before the goals */
+    think(): void;
+    /**
+     * 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: EntityState): void;
+    /** 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: Vec2): Vec2 | undefined;
+    /** The ally's hero nearest a place: what a hero helping goes with */
+    allyAt(at: Vec2): EntityState | undefined;
+    /** The nearest camp it may take from a place: not cleared, in reach, its creeps (as seen) beatable */
+    camp(hero: EntityState): Vec2 | undefined;
+}
+/**
+ * The lanes module, with the play it runs (`LanesPlay`): what the tests reach
+ *
+ * @beta
+ */
+export interface LanesModule extends AiModule {
+    play: LanesPlay;
+}
+/**
+ * What finds a lanes brain's module with its shape (`ai.module(LANES)`)
+ *
+ * @beta
+ */
+export declare const LANES: import("./module").ModuleKey<LanesModule>;
+/**
+ * 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
+ */
+export declare const lanesPlay: (options?: LanesPlayOptions) => AiModuleDef;
+/**
+ * The engine's computer player for a game of lanes (`withLanes`): 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
+ */
+export declare function lanesBrainOf(def: BrainExtension & {
+    id: string;
+    lanes?: LanesPlayOptions;
+}): BrainDef;
+/**
+ * The engine's computer player for a game of lanes, as it is: `lanesBrainOf({ id: 'core.lanes' })`. List it in the
+ * game's `GameModule.brains` and seat it (`world.computers.seat(player, { brain: lanesBrain })`)
+ *
+ * @beta
+ */
+export declare const lanesBrain: BrainDef;