@v12-engine/engine 0.0.0-stage → 0.1.1

package/dist/ai/plans/build.d.ts

@@ -0,0 +1,280 @@
+import { type Cost, type UnitTypeDef } from '#engine/defs';
+import { type Vec2 } from '#engine/math';
+import type { EntityState } from '#engine/session/protocol';
+import { type Brain } from '#engine/ai/brain';
+import { type AiModuleDef } from '#engine/ai/module';
+import { type AiCondition, type AiConditionData } from '#engine/ai/rules';
+import { type PlacementName, type PlacementStrategy, type PlacementTable, type SiteRequest } from './placement';
+import { type TechPath, type TechStep } from './tech';
+/**
+ * Something a computer player wants built or trained, as plain data (a map's file, a rule's action, a seat's
+ * options): a type, how many, under what condition, where, how important. `WantData` is what a save keeps; `Want`
+ * is the same with the function forms
+ *
+ * @beta
+ */
+export interface WantData {
+    /** Its name: what the memory, the report and `drop` know it by. Made up when left out */
+    id?: string;
+    /** The unit type wanted: a building, or a unit (whose buildings the plan puts up; the production plan trains it) */
+    type: string;
+    /** How many of it to have, those on their way counted: 1 when left out */
+    count?: number;
+    /** Only while this holds (`AiConditionData`, as a rule's): a tower after the first attack, a second hall past five minutes */
+    when?: AiConditionData;
+    /** Where: a point, or the name of an entity the map or rules named. Home when left out */
+    near?: Vec2 | string;
+    /** How far from there at the most: 22 when left out */
+    within?: number;
+    /** How its spot is chosen (`PlacementName`): what the type declares, the brain's table, or the role's default when left out */
+    placement?: PlacementName;
+    /** Wants are taken most important first, and the most important one that cannot be paid for saves up: 0 when left out */
+    priority?: number;
+    /** Money to have left over after paying for it: a luxury that waits for gold to spare. 0 when left out */
+    spare?: number;
+    /**
+     * Whether the want stands: kept once met, and short again when what it made is lost, so that it is built anew.
+     * Wants of a brain's or a seat's options stand; one added as the game goes is dropped once met, unless it says so
+     */
+    keep?: boolean;
+    /** For a standing want: whether a building lost is built again (the plan's `rebuild` when left out) */
+    rebuild?: boolean;
+    /** Seconds without a spot for it before a want that does not stand is given up: the plan's `siteTimeout` when left out */
+    siteTimeout?: number;
+    /** Who wants it, for the report: `order`, `production`, `economy`, a goal's or a rule's id */
+    by?: string;
+}
+/**
+ * A want with the function forms: how many as a function of the brain, a condition as code, a place found each think,
+ * a placement strategy of the game's own (`ai.plans.want`, `BuildPlanOptions.wants`)
+ *
+ * @beta
+ */
+export interface Want extends Omit<WantData, 'count' | 'when' | 'near' | 'placement'> {
+    count?: number | ((ai: Brain) => number);
+    when?: AiCondition;
+    near?: Vec2 | string | ((ai: Brain) => Vec2 | undefined);
+    placement?: PlacementName | PlacementStrategy;
+}
+/**
+ * How the build plan goes about it (`BrainDef.plans.build`, the `build()` module; the data of it in `AiOptions`)
+ *
+ * @beta
+ */
+export interface BuildPlanOptions {
+    /** Standing wants: what the brain always has, built anew when lost */
+    wants?: Want[];
+    /** How each type's spot is chosen, by type id or by role: a name or a function. What a type declares (`UnitTypeDef.ai.placement`) goes over it */
+    placement?: PlacementTable;
+    /** Whether a building lost is built again, for standing wants that do not say: yes when left out */
+    rebuild?: boolean;
+    /** Whether a worker is sent to mend a damaged building when no enemy reaches it: yes when left out */
+    repair?: boolean;
+    /** Seconds without a spot before a want that does not stand is given up: 60 when left out */
+    siteTimeout?: number;
+    /** How far from home a building goes at the most, where a want does not say: 22 when left out */
+    within?: number;
+}
+/** What the plan remembers of a want between thinks */
+interface WantMemory {
+    /** The tick it was added at */
+    since: number;
+    /** Its place among the wants: among equals in priority, the first added goes first. Kept, so a loaded game ranks alike */
+    order: number;
+    /** How many of its type the plan started for it */
+    made: number;
+    /** A standing want met once and not to be built anew */
+    satisfied?: true;
+    /** The tick since which no spot was found for it */
+    noSite?: number;
+    /** The worker sent to look at the ground where it goes */
+    settler?: number;
+}
+/**
+ * What the build plan remembers between thinks, for a save: each want's memory, and the wants added as the game went
+ * that are plain data (a rule's), to have them again
+ *
+ * @beta
+ */
+export interface BuildPlanMemory {
+    v: 1;
+    wants: {
+        id: string;
+        memory: WantMemory;
+        data?: WantData;
+    }[];
+    /** The order the next want added gets: kept, so that a loaded game ranks the wants it adds as the game saved did */
+    added?: number;
+    /** The want saving up as of the last think (`savingFor`): what a loaded game reads until it thinks again */
+    saving?: string;
+}
+/**
+ * One want as the report shows it: what it is, how far along, what it waits for (`status`), the steps to it, what it
+ * holds in the purse
+ *
+ * @beta
+ */
+export interface WantReport {
+    id: string;
+    type: string;
+    count: number;
+    have: number;
+    onItsWay: number;
+    priority: number;
+    by?: string;
+    keep?: true;
+    status: string;
+    steps: string[];
+    holds?: Cost;
+}
+/**
+ * The build plan as the report shows it: its wants, and which one saves up
+ *
+ * @beta
+ */
+export interface BuildPlanReport {
+    wants: WantReport[];
+    saving?: string;
+}
+/**
+ * The brain's build plan (`ai.plans.build`): its wants, the steps to each, the spots, the builders, the purse. Add a
+ * want with `want`, read where each stands with `report`, and let `think` act on them once a think
+ *
+ * @beta
+ */
+export declare class BuildPlan {
+    /** The brain it plans for */
+    readonly ai: Brain;
+    private options;
+    private readonly wants;
+    /** Memory of wants a save remembers that no module has asked for yet: given to them as they come */
+    private pending;
+    private added;
+    private thoughtAt;
+    private paths;
+    /** What is on its way, by type, worked out once a think: asked for every want and every step */
+    private onWay;
+    /** The builders sent this think: not sent twice */
+    private sent;
+    /** The want saving up this think, if one is */
+    private saving;
+    private warned;
+    constructor(
+    /** The brain it plans for */
+    ai: Brain, options?: BuildPlanOptions);
+    /** Takes options in, over what it had: the standing wants added, the table of placements merged, the flags replaced */
+    configure(options: BuildPlanOptions): void;
+    /** The plan's options as they stand */
+    get settings(): Readonly<BuildPlanOptions>;
+    /**
+     * Adds a want, or replaces one of the same id (its memory kept): what the plan works towards from now. Gives back
+     * its id. A want with no `keep` is dropped once met
+     */
+    want(def: Want): string;
+    /** Takes a want out, and what a save remembered of it: whether there was one */
+    drop(id: string): boolean;
+    /** A want by id */
+    get(id: string): Want | undefined;
+    /** The wants, in the order added */
+    list(): Want[];
+    /** Where a want stands, in words, as of the last think: `building a barracks at (40, 60)`, `saving for a town hall` */
+    status(id: string): string | undefined;
+    /** The want saving up, as of the last think: the most important one it could not pay for */
+    get savingFor(): string | undefined;
+    /** How many of a type the player has, those under construction and those that count as it included */
+    have(type: string): number;
+    /** How many of a type are on their way beyond those that stand: builders sent to build one, buildings turning into one, units queued */
+    onItsWay(type: string): number;
+    /** Whether a type is had or on its way: standing (finished or not), or a builder or a morph on the way to it */
+    private had;
+    /** The steps to being able to make a type (`techPath`), worked out once a think */
+    path(type: string): TechPath;
+    /** The first step towards a type not had yet, the type's own last: none when nothing is to be done, or the path is blocked */
+    next(type: string): TechStep | undefined;
+    /**
+     * The think, once a think: every want measured against what stands and is on its way (met ones dropped, or kept
+     * standing), those whose condition holds taken most important first, each advanced by the first step it can take:
+     * built, turned into, or saved for. Then the mending, where the plan is to
+     */
+    think(): void;
+    /** One want, one think: the steps to it, and the first one it can take */
+    private advance;
+    /** Takes a step for a want, where it can: what came of it, in words, for the status */
+    private act;
+    /**
+     * Pays for a step out of the purse, with the want's `spare` left over, as important as the want is (what less
+     * important wants and modules hold is its to spend); where it cannot, the most important want that could not pay
+     * holds the money (one at a time), and what is less important waits
+     */
+    private pay;
+    /** Whether a want can pay for a step now (nothing spent); where it cannot, it may hold the money (`pay`) */
+    private canPay;
+    /** A step not paid for, in words: the want holds the money (saving), waits for money to spare (a luxury), or waits for the money */
+    private short;
+    /** No spot found this think: for a want that does not stand, given up after `siteTimeout` seconds, and said */
+    private noSite;
+    /** Where a want says it goes, as a point: a point, a named entity it knows of, or what its function gives. Nothing for home */
+    private placeOf;
+    /** A spot for a type: where the want says, no further than it says, by its strategy; near home for a step on the way */
+    private siteFor;
+    /**
+     * A spot for a type near a place, by a strategy: the one given, else what the type declares (`UnitTypeDef.ai.placement`),
+     * the plan's table by type then by role, the role's default, the rings around the place. What is built on a
+     * deposit goes on one whatever the name
+     */
+    site(type: UnitTypeDef, request: Omit<SiteRequest, 'ordinal'> & {
+        ordinal?: number;
+    }, placement?: PlacementName | PlacementStrategy): Vec2 | undefined;
+    private strategyFor;
+    /** The workers sent to look at the ground somewhere, by any want: not builders while they go */
+    private settlers;
+    /**
+     * Who builds a type at a spot: of the player's units that build it, those not hidden, not building, not sent this
+     * think, not off to look at ground and not in a squad or held by a rule; idle first, then whoever carries the least,
+     * then the nearest
+     */
+    builderFor(type: UnitTypeDef, site: Vec2): EntityState | undefined;
+    /** Where a settler stands to see a place: on its near side, towards home, so that it sees where the building would stand and not the mine alone */
+    private settlePoint;
+    /**
+     * A worker sent to where a want goes, to see the ground: one at a time for the want, sent again if it was taken off
+     * it. To the near side of the place, towards home (`settlePoint`)
+     */
+    private sendSettler;
+    /**
+     * Builds a type now, outside any want: a spot near a place (home when left out), a builder, the purse. What a
+     * module does for a one-off (the melee player's building on a mine). Whether it was sent
+     */
+    build(type: UnitTypeDef | string, options?: {
+        near?: Vec2;
+        within?: number;
+        placement?: PlacementName | PlacementStrategy;
+        spare?: number;
+        by?: string;
+    }): boolean;
+    /**
+     * Mends: a worker sent to a damaged building of the player's that no enemy strength reaches, one a think, when
+     * the purse has what the mending will cost (`GameRules.economy.repairCost` of what is missing). Not one being mended already
+     */
+    private mend;
+    /** The wants in the order they were added: what the report and a save list them in, the same in a loaded game */
+    private ordered;
+    /** Every want as the last think left it, in the order added, the one saving up named */
+    report(): BuildPlanReport;
+    /**
+     * What it remembers, for a save: each standing want's memory (its code gives the want again), and the wants added
+     * as the game went that are plain data, whole. A want that does not stand and has code in it is not kept: the
+     * game loaded from the save would not know when the game saved from would have dropped it
+     */
+    save(): BuildPlanMemory;
+    /** Takes back what `save` gave: whether it was read. The data wants are had again; memory waits for the wants code adds */
+    restore(memory: unknown): boolean;
+}
+/**
+ * The build module: runs the brain's build plan (`ai.plans.build.think()`) in its place among a brain's modules, after
+ * what adds wants (rules, goals) and before what gives idle workers something else to do. With options for the plan
+ *
+ * @beta
+ */
+export declare const build: (options?: BuildPlanOptions) => AiModuleDef;
+export {};

package/dist/ai/plans/placement.d.ts

@@ -0,0 +1,82 @@
+import { type UnitTypeDef } from '#engine/defs';
+import { type Vec2 } from '#engine/math';
+import type { Brain } from '#engine/ai/brain';
+/**
+ * Where a type is wanted: near a place, no further than `within`, and which of its kind this is (`ordinal`, so that
+ * two farms do not try the same corner first)
+ *
+ * @beta
+ */
+export interface SiteRequest {
+    near: Vec2;
+    within: number;
+    ordinal: number;
+}
+/**
+ * A way of finding a spot for a building: the kit's by name, or a function of the game's own. Nothing (`undefined`)
+ * when there is no spot it likes
+ *
+ * @beta
+ */
+export type PlacementStrategy = (ai: Brain, type: UnitTypeDef, site: SiteRequest) => Vec2 | undefined;
+/**
+ * The kit's placement strategies, by name: `nearHome` (rings around the place, keeping the way to the mine clear),
+ * `byResource` (on the nearest deposit it is built on: a mine), `atEdge` (at the edge of the base towards the enemy,
+ * for a tower), `behind` (away from the enemy, for supply), `cluster` (beside another of its type, barracks by
+ * barracks; `cluster:<type>` beside another type), `onLayer:<layer>` (where the whole footprint is on a layer of cells
+ * the game paints: `onLayer:blight` for a race that builds on blight)
+ *
+ * @beta
+ */
+export type PlacementName = 'nearHome' | 'byResource' | 'atEdge' | 'behind' | 'cluster' | `cluster:${string}` | `onLayer:${string}`;
+/**
+ * Which strategy a type goes by (`AiOptions.placement`, `BuildPlanOptions.placement`): by type id or by role, a name
+ * or a function
+ *
+ * @beta
+ */
+export type PlacementTable = Record<string, PlacementName | PlacementStrategy>;
+/**
+ * The rings around a place, walked out from `from` to `within` (then in from `from` to the nearest ring where `inward`),
+ * each at so many angles; the first point that stands clear and that `accept` likes. Deterministic, but not the same
+ * corner for every building: the angles start where `ordinal` says
+ *
+ * @beta
+ */
+export declare function rings(ai: Brain, type: UnitTypeDef, centre: Vec2, options: {
+    from?: number;
+    within: number;
+    ordinal?: number;
+    inward?: boolean;
+    accept?: (point: Vec2) => boolean;
+}): Vec2 | undefined;
+/**
+ * Which way the enemy is from a place, as a unit vector: towards the nearest of their bases it knows of, else the
+ * nearest base the seat was told of (`AiOptions.enemyBases`), else towards the strongest enemy reaching its own
+ * (`threat.hot`). Nothing where it has no idea
+ *
+ * @beta
+ */
+export declare function enemyDirection(ai: Brain, from: Vec2): Vec2 | undefined;
+/** Beside another of a type (its own when none is named): barracks by barracks. Rings around home where there is none yet */
+declare const cluster: (type?: string) => PlacementStrategy;
+/**
+ * On a layer of cells, the whole footprint (`onLayer:<layer>`): the rings around the place, the way to the mine kept
+ * clear, then the layer's painted cells nearest the place where the rings find none (a scan of the layer, only then).
+ * Nothing where the layer is painted nowhere near
+ */
+declare const onLayer: (layer: string) => PlacementStrategy;
+/**
+ * The kit's placement strategies, by name (`PlacementName`), for a game that wants to call or wrap one
+ *
+ * @beta
+ */
+export declare const placements: {
+    readonly nearHome: PlacementStrategy;
+    readonly byResource: PlacementStrategy;
+    readonly atEdge: PlacementStrategy;
+    readonly behind: PlacementStrategy;
+    readonly cluster: typeof cluster;
+    readonly onLayer: typeof onLayer;
+};
+export {};

package/dist/ai/plans/plans.d.ts

@@ -0,0 +1,105 @@
+import type { Brain } from '#engine/ai/brain';
+import type { AiArea } from '#engine/ai/area';
+import { BuildPlan, type BuildPlanMemory, type BuildPlanOptions, type BuildPlanReport, type Want } from './build';
+import { ProductionPlan, type ProductionPlanMemory, type ProductionPlanOptions, type ProductionPlanReport } from './production';
+import type { PurseReport } from './purse';
+/**
+ * One item of a build order: a type to have (one of it), or a type and how many. Counts of a type add up along the order
+ *
+ * @beta
+ */
+export type BuildOrderItem = string | {
+    type: string;
+    count?: number;
+};
+/**
+ * How a brain plans (`BrainDef.plans`): the build plan's options, the production plan's, the build order
+ *
+ * @beta
+ */
+export interface PlansOptions {
+    build?: BuildPlanOptions;
+    production?: ProductionPlanOptions;
+    /**
+     * What to have first, in order (`BuildOrderItem`): each item waits for the one before, and nothing else the
+     * computer would make of itself is made meanwhile (`following`); what it works out for itself once done. The
+     * seat's `AiOptions.buildOrder`
+     */
+    order?: BuildOrderItem[];
+}
+/**
+ * What the plans remember between thinks, for a save
+ *
+ * @beta
+ */
+export interface PlansMemory {
+    v: 1;
+    build?: BuildPlanMemory;
+    production?: ProductionPlanMemory;
+}
+/**
+ * The plans as the report shows them: the purse, and each plan's part
+ *
+ * @beta
+ */
+export interface PlansReport {
+    purse: PurseReport;
+    build: BuildPlanReport;
+    production: ProductionPlanReport;
+    /** The build order's next item, while it is being followed */
+    order?: {
+        type: string;
+        count: number;
+        item: number;
+    };
+}
+/**
+ * A brain's plans (`ai.plans`): `build` for what is to be built, `production` for what is to be trained and
+ * researched, the game's build `order` over both. `want` is the one door: a want of a building goes to the build
+ * plan; one of a unit goes to the build plan for its buildings, and the production plan trains it
+ *
+ * @beta
+ */
+export declare class Plans implements AiArea {
+    /** The brain they plan for */
+    readonly ai: Brain;
+    /** Its id among the brain's areas: what its memory and its report are kept under */
+    readonly id = "plans";
+    /** 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 planned in a shape this brain does not read: it plans afresh";
+    /** What to build, and the steps to it */
+    readonly build: BuildPlan;
+    /** What to train and research */
+    readonly production: ProductionPlan;
+    private readonly order;
+    private followedAt;
+    private next;
+    constructor(
+    /** The brain they plan for */
+    ai: Brain, options?: PlansOptions);
+    /** Adds a want: what the brain works towards from now (`BuildPlan.want`). Gives back its id */
+    want(def: Want): string;
+    /**
+     * Works on the game's build order, once a think: the first item not had (what stands, is on its way or is queued
+     * counted; counts of a type adding up along the order) is a want before all others (`order`, priority 1000), and
+     * `following` is true. Called by the build plan as it thinks; a module may call it sooner
+     */
+    follow(): PlansReport['order'] | undefined;
+    /** Whether the game's build order is still being followed: what the computer would make of itself waits */
+    get following(): boolean;
+    /** Takes a want out, by id */
+    drop(id: string): boolean;
+    /** The purse and each plan's part, for the report */
+    report(): PlansReport;
+    /** What the plans remember, for a save */
+    /** Whether it has anything to remember now: one that does not is left out of a save */
+    remembers(): boolean;
+    save(): PlansMemory;
+    /** Takes back what `save` gave: whether it was read */
+    restore(memory: unknown): boolean;
+}
+declare module '#engine/ai/area' {
+    interface AreaMemories {
+        plans?: PlansMemory;
+    }
+}

package/dist/ai/plans/production.d.ts

@@ -0,0 +1,210 @@
+import type { UnitTypeDef, UpgradeDef } from '#engine/defs';
+import type { EntityState } from '#engine/session/protocol';
+import { type Brain } from '#engine/ai/brain';
+import { type AiModuleDef } from '#engine/ai/module';
+import type { Want } from './build';
+/**
+ * The army a computer player wants, as shares by unit type id or tag (the kit's `ranged`, `melee`, `hitsAir`, a
+ * game's own): `{ footman: 2, rifleman: 1 }` is two footmen to a rifleman. A tag's share is split among the types
+ * that have it; a type named gets its own beside. Types it cannot train yet are left out until it can
+ *
+ * @beta
+ */
+export type Composition = Record<string, number>;
+/**
+ * How the production plan goes about it (`BrainDef.plans.production`, the `production()` module; the data of it in
+ * `AiOptions.composition` and `research`)
+ *
+ * @beta
+ */
+export interface ProductionPlanOptions {
+    /** The army it wants (`Composition`), or a function of the brain giving it. Even shares of every soldier type it can train when left out */
+    composition?: Composition | ((ai: Brain) => Composition);
+    /**
+     * How much what answers the enemy's army seen pulls the shares about: 0 not at all, 1 (left out) as much as a
+     * share; a type that cannot hit what they field is not trained while they field it
+     */
+    counters?: number;
+    /** Whether it trains soldiers at all: yes when left out. Workers and heroes are the economy's and the hero module's */
+    train?: boolean;
+    /** How many may queue at one building: 2 when left out */
+    queue?: number;
+    /** Whether to want one more of what provides supply when what it would train next does not fit: yes when left out */
+    supplyAhead?: boolean;
+    /** Supply to keep free beyond the next unit's, so that the farm is up before it is needed: 4 when left out */
+    supplyMargin?: number;
+    /** Upgrades to research, in order, by id (the first it can is next), or a function of the brain giving the next; what the army it has uses most when left out */
+    research?: string[] | ((ai: Brain) => string | undefined);
+    /** Money to have left over before researching: 200 when left out (research is a luxury) */
+    researchSpare?: number;
+    /** How important training and research are to the purse (`Purse`): 0 when left out, under every want that saves */
+    priority?: number;
+    /**
+     * The tier of the game's upkeep (`GameModule.upkeep`: 0 none, 1 the first) the composition trains no further into:
+     * a soldier that would take the supply used past it waits, and no supply is wanted past it, unless the money would
+     * lie idle (`upkeepSpare`). What is wanted outright (a wave's, a build order's) is trained all the same. `UPKEEP_TIER`
+     * (1) when left out; `false` reads no upkeep
+     */
+    upkeepTier?: number | false;
+    /** Money free past which upkeep is not read (it would lie idle else): `UPKEEP_SPARE` (600) when left out */
+    upkeepSpare?: number;
+}
+/**
+ * The tier of upkeep the production plan trains no further into where its options say none (`upkeepTier`)
+ *
+ * @beta
+ */
+export declare const UPKEEP_TIER = 1;
+/**
+ * The money free past which the production plan reads no upkeep: what would lie idle else (`upkeepSpare`)
+ *
+ * @beta
+ */
+export declare const UPKEEP_SPARE = 600;
+/**
+ * One type as the production plan weighs it, for the report: its share of the army wanted (`target`, 0..1), its share
+ * now (`share`), how well it answers their army (`counter`: 1 is as good as against anyone), and what the two come
+ * to (`urge`: the most urgent is trained next)
+ *
+ * @beta
+ */
+export interface CompositionReport {
+    type: string;
+    target: number;
+    have: number;
+    share: number;
+    counter: number;
+    urge: number;
+}
+/**
+ * The production plan as the report shows it: the composition as weighed, what it trained and researched this
+ * think, the unit wants it trains towards, and why it did not train where it did not
+ *
+ * @beta
+ */
+export interface ProductionPlanReport {
+    composition: CompositionReport[];
+    trained: string[];
+    researched: string[];
+    wants: string[];
+    status: string;
+}
+/**
+ * What the production plan remembers between thinks, for a save: what its want of supply was set with
+ *
+ * @beta
+ */
+export interface ProductionPlanMemory {
+    supply?: {
+        type: string;
+        need: number;
+        most?: number;
+    };
+}
+/**
+ * The brain's production plan (`ai.plans.production`): what it trains and researches, by the wants of units, the
+ * composition and the counters, with supply kept ahead. `train` and `research` are the primitives any module uses
+ * to queue something through the purse; `think` runs the plan once a think
+ *
+ * @beta
+ */
+export declare class ProductionPlan {
+    /** The brain it plans for */
+    readonly ai: Brain;
+    private options;
+    private thoughtAt;
+    private trained;
+    private researched;
+    private status;
+    private weighed;
+    private wantedNow;
+    /** What the supply want was last set with (`supplyAhead`): kept in a save, for a loaded game to have it again */
+    private supply;
+    constructor(
+    /** The brain it plans for */
+    ai: Brain, options?: ProductionPlanOptions);
+    /** Takes options in, over what it had */
+    configure(options: ProductionPlanOptions): void;
+    /** The plan's options as they stand */
+    get settings(): Readonly<ProductionPlanOptions>;
+    /** Whether the player may make a type or research an upgrade (`key`: `upgrade:<id>`), as its race and the game's `available` hook say */
+    private may;
+    /** How many of a unit type the player's buildings are training */
+    queued(type: string): number;
+    /**
+     * Trains a unit at a building, when it fits the supply, the queue has room and the purse allows: whether it was
+     * sent. The supply used is bumped on the view's `me` at once, so that the next call this think does not queue past
+     * the cap before the command lands. What the economy, the hero module and this plan all train through
+     */
+    train(building: EntityState, type: UnitTypeDef, priority?: number): boolean;
+    /**
+     * Researches an upgrade at a building, when it is not researching already, the building's queue has room and the
+     * purse allows with `spare` left over: whether it was sent. `me.researching` is bumped at once
+     */
+    research(building: EntityState, upgrade: UpgradeDef, spare?: number, priority?: number): boolean;
+    /** Whether an upgrade can be researched now: a level left, not under way, the player's to make, what the next level requires standing */
+    researchable(upgrade: UpgradeDef): boolean;
+    /** The soldier types the player can train now: at a finished building of its own, their requirements standing */
+    trainable(): UnitTypeDef[];
+    /** The army's composition wanted, as given: the function asked, the data as it is */
+    private composition;
+    /**
+     * The composition as weighed this think, for the types it can train: each type's share wanted (the composition's
+     * for its id, or for a tag or role where no type has that id, split among the types that have it; even when there is no composition), its
+     * share of the soldiers now, how well it answers the enemy's army seen, and its urge: `target × (1 + counters ×
+     * (counter − 1)) − share`. The most urgent is trained first
+     */
+    weigh(): CompositionReport[];
+    /** How well each type answers the most of each enemy unit type seen at once (`Strength.counterFor`): 1 for each where nothing was seen */
+    private counters;
+    /** The unit wants the build plan holds that are to be trained now (their buildings up), most important first; the order's alone while it is followed */
+    wanted(): Want[];
+    /** The finished buildings of the player's that train a type, with room in their queue */
+    private trainersOf;
+    /**
+     * The think, once a think: the unit wants first (each at a building that trains it, as many as wanted), then the
+     * composition's most urgent type at every building with room, as the supply, the queue and the purse allow; one
+     * more of what provides supply wanted when the next does not fit; then the research
+     */
+    think(): void;
+    /**
+     * The supply used the composition trains no further than for upkeep (`upkeepTier`): where the tier after the one it
+     * may be in begins. None in a game without upkeep, past its last tier, or with `upkeepTier: false`
+     */
+    upkeepLimit(): number | undefined;
+    /**
+     * Supply kept ahead: when the type to train next does not fit (or the free supply is under the margin), one more of
+     * the cheapest building that provides supply is wanted of the build plan, unless the cap is the game's most or one
+     * is on its way already
+     */
+    private supplyAhead;
+    /**
+     * One at a time: what stands finished, and one more. A standing want, with what is needed in its condition: set
+     * again whenever the need changes
+     */
+    private wantSupply;
+    /** What it remembers, for a save: what the supply want was set with, while it stands */
+    save(): ProductionPlanMemory | undefined;
+    /**
+     * Takes back what `save` gave, after the build plan's: the supply want is had again at once, before the first think,
+     * as the game saved from has it (the module sets it again only when supply runs short, after the build plan thinks)
+     */
+    restore(memory: ProductionPlanMemory | undefined): void;
+    /**
+     * The upgrade to research next: the first of the list it can (`research` as a list), what the function gives, or,
+     * left to itself, the one the most of its units benefit from (`UpgradeEffect.units`), ties as the game lists them
+     */
+    nextResearch(): UpgradeDef | undefined;
+    /** Research, with money to spare: the next upgrade at a finished building of the player's that researches it */
+    private runResearch;
+    /** The composition as weighed, what was trained and researched this think, the wants trained towards, and the status */
+    report(): ProductionPlanReport;
+}
+/**
+ * The production module: runs the brain's production plan (`ai.plans.production.think()`) in its place among a
+ * brain's modules, after the build plan (which puts up what a want needs) where a brain has both. With options for
+ * the plan
+ *
+ * @beta
+ */
+export declare const production: (options?: ProductionPlanOptions) => AiModuleDef;