@v12-engine/engine 0.1.0 → 0.4.0

package/dist/ai/missionRules.js

@@ -0,0 +1,26 @@
+import { missionRulesPack } from "../missionRules.js";
+import { ruleWatcher } from "./computer.js";
+//#region src/ai/missionRules.ts
+/**
+* Mission rules as data (campaign plan MS1): the rules a map keeps (`MissionRule`, under `GameMap.data.rules`, written
+* in the editor's Rules panel) run as the game plays, `rules` of the game's own code beside them. Each `when` a
+* condition of the computer players' language holds (`docs/ai/scripting.md`), asked as a player, `do`es its actions
+* (`MissionActionData`: an objective of the map's given, done or failed, a line said, a cinematic played, a prefab
+* spawned, a computer told, a relation set, a timer started, win, lose). Checked once a second; what the rules
+* remember is in the world's state, so a save mid-mission has it. The code reaches the rules with `tellRules` and hears
+* them fire as `ruleFired`; the map's checks say what is wrong with them (`checkMissionRules`). Of `@v12-engine/engine/ai`, as
+* a condition is asked of a watcher seated as the computer players are (`ruleWatcher`); the map objectives pack
+* (`mapObjectives`) goes with it, for the objectives a rule gives
+*
+* @beta
+*/
+function missionRules(options = {}) {
+	return missionRulesPack({
+		...options,
+		watch: ruleWatcher
+	});
+}
+//#endregion
+export { missionRules };
+
+//# sourceMappingURL=missionRules.js.map

package/dist/ai/missionRules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"missionRules.js","names":[],"sources":["../../src/ai/missionRules.ts"],"sourcesContent":["import { type MissionRule, missionRulesPack } from '#engine/missionRules'\nimport type { GamePack } from '#engine/packs/pack'\nimport { ruleWatcher } from './computer'\n\n/**\n * Mission rules as data (campaign plan MS1): the rules a map keeps (`MissionRule`, under `GameMap.data.rules`, written\n * in the editor's Rules panel) run as the game plays, `rules` of the game's own code beside them. Each `when` a\n * condition of the computer players' language holds (`docs/ai/scripting.md`), asked as a player, `do`es its actions\n * (`MissionActionData`: an objective of the map's given, done or failed, a line said, a cinematic played, a prefab\n * spawned, a computer told, a relation set, a timer started, win, lose). Checked once a second; what the rules\n * remember is in the world's state, so a save mid-mission has it. The code reaches the rules with `tellRules` and hears\n * them fire as `ruleFired`; the map's checks say what is wrong with them (`checkMissionRules`). Of `@v12-engine/engine/ai`, as\n * a condition is asked of a watcher seated as the computer players are (`ruleWatcher`); the map objectives pack\n * (`mapObjectives`) goes with it, for the objectives a rule gives\n *\n * @beta\n */\nexport function missionRules(options: { rules?: MissionRule[] } = {}): GamePack {\n\treturn missionRulesPack({ ...options, watch: ruleWatcher })\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAiBA,SAAgB,aAAa,UAAqC,CAAC,GAAa;CAC/E,OAAO,iBAAiB;EAAE,GAAG;EAAS,OAAO;CAAY,CAAC;AAC3D"}

package/dist/ai/module.d.ts

@@ -87,6 +87,7 @@ export type AiPhase = (typeof AI_PHASES)[number];
  * @beta
  */
 export interface ModuleKey<M extends AiModule> {
+    /** The id the module is found by: a module of that id is the one this key finds */
     readonly id: string;
     /** The shape the module has: never set, for the type alone */
     readonly shape?: M;
@@ -111,6 +112,9 @@ export type AiModuleDef = AiModule | (((ai: Brain) => AiModule) & {
  * A module made for each brain by a function of it, with its id known before it is made: what a brain's `without`
  * leaves out by name (`meleeBrain.with({ without: ['scouting'] })`). The kit's modules are all defined so
  *
- * @beta
+ * @public
  */
-export declare function defineModule(id: string, make: (ai: Brain) => AiModule): AiModuleDef;
+export declare function defineModule(def: {
+    id: string;
+    make: (ai: Brain) => AiModule;
+}): AiModuleDef;

package/dist/ai/module.js

@@ -0,0 +1,37 @@
+//#region src/ai/module.ts
+/**
+* The phases of a think, in the order they run (`AiModule.phase`): `hear` what it was told and its rules, `sense`
+* what threatens it and its team, `plan` its economy, buildings and training, `decide` what its own goals are, `act`
+* the picker, the squads and the waves, `fight` the micro
+*
+* @beta
+*/
+var AI_PHASES = [
+	"hear",
+	"sense",
+	"plan",
+	"decide",
+	"act",
+	"fight"
+];
+/**
+* A key to a module of a game's own (`ai.module(key)` gives it with its shape)
+*
+* @beta
+*/
+function moduleKey(id) {
+	return { id };
+}
+/**
+* A module made for each brain by a function of it, with its id known before it is made: what a brain's `without`
+* leaves out by name (`meleeBrain.with({ without: ['scouting'] })`). The kit's modules are all defined so
+*
+* @public
+*/
+function defineModule(def) {
+	return Object.assign(def.make, { id: def.id });
+}
+//#endregion
+export { AI_PHASES, defineModule, moduleKey };
+
+//# sourceMappingURL=module.js.map

package/dist/ai/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","names":[],"sources":["../../src/ai/module.ts"],"sourcesContent":["/**\n * A module of a brain (`AiModule`): one part of a think, made for each brain (`defineModule`). Apart from the brain\n * (`brain.ts`), which is made of them, so that a module and an area of the kit import this and the brain's type only,\n * and the brain imports no module back\n */\nimport type { Brain } from './brain'\nimport type { AiReport } from './report'\n\n/**\n * One named part of a computer player's think (`defineBrain`'s `modules`). Modules run in their order each think, over\n * the same picture of the game, each reading it through the brain it is handed (`ai.snapshot`, later `ai.view`) and\n * acting through `ai.send`. A module is made for each brain (`AiModuleDef`: a function of the brain), so that what it\n * keeps in itself is one seat's. What it remembers between thinks goes through `save` and `restore`, as plain data\n *\n * @beta\n */\nexport interface AiModule {\n\t/** Unique in a brain: what its memory is kept under, what the timing and the debug tools name it by */\n\tid: string\n\t/**\n\t * The version of what it remembers (`save`): 1 when left out. Raised when the shape of it changes; a load that finds\n\t * memory of another version gives it to `migrate`, or starts the module afresh where there is none\n\t */\n\tversion?: number\n\t/** Runs once in so many thinks, for work that does not need doing every think. Every think when left out */\n\teveryThinks?: number\n\t/** With `everyThinks`, the think in each round it runs at: modules with the same `every` and other offsets spread the work */\n\toffset?: number\n\t/**\n\t * When in a think it runs (`AiPhase`): the brain runs its modules phase by phase, as listed within each. Left out,\n\t * in the phase of the module listed before it (the first phase for the first)\n\t */\n\tphase?: AiPhase\n\t/**\n\t * Ids of modules of the brain this one runs ahead of, for what one phase needs within itself. Ids of modules the\n\t * brain does not have are passed over\n\t */\n\tbefore?: string[]\n\t/** Ids of modules of the brain this one runs after, within its phase */\n\tafter?: string[]\n\t/**\n\t * Ids this module's memory was kept under before it was called what it is: a save made then gives it back under\n\t * the old id, and it is read as this module's (through `migrate` where the version differs too)\n\t */\n\twasCalled?: string[]\n\t/** Its part of the think */\n\tthink(ai: Brain): void\n\t/** What it remembers between thinks, as plain data for a save. Nothing (`undefined`) for a module that remembers nothing */\n\tsave?(): unknown\n\t/** Takes back what `save` gave, in a game loaded from a save */\n\trestore?(data: unknown): void\n\t/**\n\t * Brings what an earlier version of the module saved (`from`: its version) up to what this one takes. Nothing\n\t * (`undefined`) says it cannot be brought up, and the module starts afresh; so does a module without `migrate`\n\t */\n\tmigrate?(data: unknown, from: number): unknown\n\t/**\n\t * What it is thinking, as plain data, for the debug tools: what the report has no part for, kept under the module's\n\t * id in its `sections` (`Brain.report`)\n\t */\n\tinspect?(): unknown\n\t/**\n\t * Writes its part of the report (`Brain.report`), where the report has a part for it: a kit's module fills the part\n\t * it names (its squads, its plans). Plain data only\n\t */\n\treport?(report: AiReport): void\n\t/** Lets go of what it holds outside the brain when the computer is unseated */\n\tdispose?(): void\n}\n\n/**\n * The phases of a think, in the order they run (`AiModule.phase`): `hear` what it was told and its rules, `sense`\n * what threatens it and its team, `plan` its economy, buildings and training, `decide` what its own goals are, `act`\n * the picker, the squads and the waves, `fight` the micro\n *\n * @beta\n */\nexport const AI_PHASES = ['hear', 'sense', 'plan', 'decide', 'act', 'fight'] as const\n\n/**\n * A phase of a think (`AI_PHASES`)\n *\n * @beta\n */\nexport type AiPhase = (typeof AI_PHASES)[number]\n\n/**\n * What finds a module of a brain with its shape (`ai.module(key)`): its id, typed. The kit's are `MELEE_ARMY` and\n * `LANES`; a game makes its own with `moduleKey`\n *\n * @beta\n */\nexport interface ModuleKey<M extends AiModule> {\n\t/** The id the module is found by: a module of that id is the one this key finds */\n\treadonly id: string\n\t/** The shape the module has: never set, for the type alone */\n\treadonly shape?: M\n}\n\n/**\n * A key to a module of a game's own (`ai.module(key)` gives it with its shape)\n *\n * @beta\n */\nexport function moduleKey<M extends AiModule>(id: string): ModuleKey<M> {\n\treturn { id }\n}\n\n/**\n * A module of a brain: made for each brain by a function of it, so that two brains never share one; or one as it is,\n * for a module that keeps nothing. A function made with `defineModule` carries the module's id before it is made,\n * which is how `BrainDef.without` names it\n *\n * @beta\n */\nexport type AiModuleDef = AiModule | (((ai: Brain) => AiModule) & { id?: string })\n\n/**\n * A module made for each brain by a function of it, with its id known before it is made: what a brain's `without`\n * leaves out by name (`meleeBrain.with({ without: ['scouting'] })`). The kit's modules are all defined so\n *\n * @public\n */\nexport function defineModule(def: { id: string; make: (ai: Brain) => AiModule }): AiModuleDef {\n\treturn Object.assign(def.make, { id: def.id })\n}\n"],"mappings":";;;;;;;;AA6EA,IAAa,YAAY;CAAC;CAAQ;CAAS;CAAQ;CAAU;CAAO;AAAO;;;;;;AA2B3E,SAAgB,UAA8B,IAA0B;CACvE,OAAO,EAAE,GAAG;AACb;;;;;;;AAiBA,SAAgB,aAAa,KAAiE;CAC7F,OAAO,OAAO,OAAO,IAAI,MAAM,EAAE,IAAI,IAAI,GAAG,CAAC;AAC9C"}

package/dist/ai/options.d.ts

@@ -27,18 +27,18 @@ export interface AiOptions {
     /**
      * Goals of the game's own, picked with the engine's each turn (`ai.goals`): a goal that scores itself from
      * considerations and claims units (`defineGoal`). A raid on workers, holding a hill, escorting a caravan. Code: not kept
-     * in a save; a brain's own goals are (`meleeBrain.with({ goals })`, `GameModule.brains`)
+     * in a save; a brain's own goals are (`meleeBrain.with({ goals })`, `Rules.brains`)
      */
     goals?: GoalDef[];
     /**
-     * How hard it plays (`easy`, `normal`, `hard`, `insane`, or a game's own: `GameModule.ai.difficulties`): how often it thinks, when it first attacks
+     * How hard it plays (`easy`, `normal`, `hard`, `insane`, or a game's own: `Rules.ai.difficulties`): how often it thinks, when it first attacks
      * and how many it sends, how far it comes to defend, how many workers it keeps, how many commands a think, how often
      * it slips, whether it sees through the fog (`insane`). A layer of the profile (`AiProfile`): the personality's, the
      * map's and the seat's settings go over it. `normal` when left out
      */
     difficulty?: string;
     /**
-     * How it likes to play (`balanced`, `rusher`, `turtle`, `expander`, `harasser`, or a game's own: `GameModule.ai.personalities`):
+     * How it likes to play (`balanced`, `rusher`, `turtle`, `expander`, `harasser`, or a game's own: `Rules.ai.personalities`):
      * the weights of its goals, when it attacks and expands, its towers. Over the difficulty. `balanced` when left out
      */
     personality?: string;

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

@@ -51,9 +51,13 @@ export interface WantData {
  * @beta
  */
 export interface Want extends Omit<WantData, 'count' | 'when' | 'near' | 'placement'> {
+    /** How many of the type the want asks for, or a function of the brain that gives it; 1 when left out */
     count?: number | ((ai: Brain) => number);
+    /** A condition the want holds only while true; when it is false the want is not pursued */
     when?: AiCondition;
+    /** Where to build: a point, the name of an entity or region the map gave, or a function of the brain that finds one each think */
     near?: Vec2 | string | ((ai: Brain) => Vec2 | undefined);
+    /** How the spot is chosen: a strategy by name or a function; the build plan's table or the type's own when left out */
     placement?: PlacementName | PlacementStrategy;
 }
 /**
@@ -97,7 +101,9 @@ interface WantMemory {
  * @beta
  */
 export interface BuildPlanMemory {
+    /** The version of the memory's format: 1 so far */
     v: 1;
+    /** Each want by id with its memory, and its data where the want is plain data (a rule's) */
     wants: {
         id: string;
         memory: WantMemory;
@@ -115,16 +121,27 @@ export interface BuildPlanMemory {
  * @beta
  */
 export interface WantReport {
+    /** The want's id, which the plan knows it by */
     id: string;
+    /** The id of the unit type the want is for */
     type: string;
+    /** How many of the type it asks for */
     count: number;
+    /** How many of the type the player has now */
     have: number;
+    /** How many a worker is on its way to build or the queue is making */
     onItsWay: number;
+    /** How important the want is; a higher one is served first and holds its money in the purse first */
     priority: number;
+    /** Who wants it: `order`, `production`, `economy`, a goal's or a rule's id */
     by?: string;
+    /** Whether it is a standing want, built anew when lost */
     keep?: true;
+    /** What it waits for or how far it is, in words */
     status: string;
+    /** The steps to the type that are still to take, in words */
     steps: string[];
+    /** What the want holds in the purse */
     holds?: Cost;
 }
 /**
@@ -133,7 +150,9 @@ export interface WantReport {
  * @beta
  */
 export interface BuildPlanReport {
+    /** Every want of the plan */
     wants: WantReport[];
+    /** The id of the want that saves up money now, if one does */
     saving?: string;
 }
 /**
@@ -254,7 +273,7 @@ export declare class BuildPlan {
     }): 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
+     * the purse has what the mending will cost (`RuleSettings.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 */