@v12-engine/engine 0.1.1 → 0.4.0

package/dist/cinematics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cinematics.js","names":["cinematicCueEvent","cinematicCuedEvent","cinematicEndedEvent","cinematicChoiceEvent"],"sources":["../src/cinematics.ts"],"sourcesContent":["import {\n\tcinematicChoice as cinematicChoiceEvent,\n\tcinematicCue as cinematicCueEvent,\n\tcinematicCued as cinematicCuedEvent,\n\tcinematicEnded as cinematicEndedEvent,\n\tenteredArea\n} from '#engine/engineEvents'\nimport { defineComponent } from './components'\nimport { defineListener } from './events'\nimport type { Audience } from './dialog'\nimport type { PlayerId } from './entity'\nimport { plain } from './plain'\nimport { type Step, waitUntil } from './sequences'\nimport type { World } from './world'\nimport { replicateEvent } from './replication'\n\n/**\n * Cinematics are the screen's: the camera, the HUD making way, the player's hands off. What they are is in a game's\n * view, by id (`GameView.cinematics.defs`). The rules say when one plays, so that it comes at the moment of the game it is\n * about (the start of the mission, a boss coming, the last wave beaten), the same moment for everyone, and a save\n * knows it was played: `playCinematic` now, or `cinematic` as a step of a sequence.\n *\n * The rules and the screen talk both ways. The rules cue a cinematic playing (`cueCinematic`: the gate is open, go on)\n * and a script or the data waits for the cue (`cut.untilCue`, a hook `cue:<name>`). The screen tells the rules when one\n * they played is over, and how (the `cinematic` command, as the player who saw it): the engine says so as\n * `cinematicEnded`, which a sequence waits for (`waitFor(cinematicEndedEvent)`, or `cinematic(id, { wait: 'ended' })`).\n * Being a command, it is in a replay, so what a story does after a cinematic is the same on every screen and every\n * time; the screen's cinematic is not in a replay, as screens are not\n */\n\n/**\n * A cinematic the rules play, as the engine's `cinematic` event carries it to the screens\n *\n * @beta\n */\nexport interface CinematicCue {\n\t/** Which of the view's cinematics */\n\tid: string\n\t/** Who sees it. Everyone when left out */\n\tto?: PlayerId[]\n\t/**\n\t * The game waits while it plays. Only where the simulation runs on the player's machine (single player): a screen\n\t * whose game runs elsewhere plays it with the game going on, as a server does not stop for one player\n\t */\n\thold: boolean\n\t/** The player may skip it */\n\tskippable: boolean\n\t/** What the rules hand the cinematic: the road of this map to fly down. Plain data, as it goes to every screen */\n\tparams?: Record<string, unknown>\n}\n\n/**\n * How a cinematic the rules played ended on a player's screen: played to its end, skipped, stopped (the game left, code\n * stopped it), made way for another, or never played (one already playing would not make way)\n *\n * @beta\n */\nexport type CinematicOutcome = 'ended' | 'skipped' | 'stopped' | 'replaced' | 'ignored'\n\n/** The outcomes a screen may report, for the command's check */\nexport const CINEMATIC_OUTCOMES = ['ended', 'skipped', 'stopped', 'replaced', 'ignored'] as const\n\n/**\n * A cue the rules send to the cinematic playing on some screens (`cueCinematic`), as the engine's `cinematicCued` event\n * carries it\n *\n * @beta\n */\nexport interface CinematicCueSent {\n\t/** Its name, as the cinematic waits for it (`cut.untilCue('gate')`, a hook `cue:gate`) */\n\tcue: string\n\t/** Who it goes to. Everyone when left out */\n\tto?: PlayerId[]\n\t/** What it carries to the cinematic. Plain data */\n\tparams?: Record<string, unknown>\n}\n\n/**\n * A cinematic the rules played is over on a player's screen (the engine's `cinematicEnded` event), as that player's\n * screen said with the `cinematic` command\n *\n * @beta\n */\nexport interface CinematicEnded {\n\t/** Whose screen it ended on */\n\tplayer: PlayerId\n\t/** Which of the view's cinematics */\n\tcinematic: string\n\t/** How it ended there */\n\toutcome: CinematicOutcome\n}\n\n/**\n * How a cinematic is played when a rule calls for it: who sees it, whether the game waits and whether it can be skipped\n *\n * @beta\n */\nexport interface CinematicOptions {\n\t/** Who sees it: a player, some, or everyone. Everyone when left out */\n\tto?: Audience\n\t/** The game waits while it plays, in single player. False when left out */\n\thold?: boolean\n\t/** The player may skip it. True when left out */\n\tskippable?: boolean\n\t/**\n\t * What the cinematic is handed (`Cinematic` is given it): what the rules know and the screen does not, like the\n\t * road of the map being played. Plain data\n\t */\n\tparams?: Record<string, unknown>\n}\n\n/**\n * Plays one of the view's cinematics on the screens of the players it is for, now\n *\n * @beta\n */\nexport function playCinematic(world: World, id: string, options: CinematicOptions = {}): void {\n\tconst { to = 'everyone', hold = false, skippable = true, params } = options\n\tworld.events.emit(cinematicCueEvent, {\n\t\tid,\n\t\tto: audience(to),\n\t\thold,\n\t\tskippable,\n\t\t...(params && { params: plain(params, `params of the cinematic \"${id}\"`, 'Cinematic') as Record<string, unknown> })\n\t})\n}\n\n/** Who a cue or a cinematic goes to, as a list: everyone's is left out */\nconst audience = (to: Audience): PlayerId[] | undefined => (to === 'everyone' ? undefined : Array.isArray(to) ? to : [to])\n\n/**\n * Cues the cinematic playing on the screens of the players it is for (everyone when left out): one waiting for it\n * (`cut.untilCue(name)`) goes on, and the view's hooks of it (`cue:<name>`) run. Nothing happens where none plays, or\n * the one playing does not listen for it. `params` is plain data the cue carries\n *\n * @beta\n */\nexport function cueCinematic(world: World, cue: string, options: { to?: Audience; params?: Record<string, unknown> } = {}): void {\n\tconst { to = 'everyone', params } = options\n\tworld.events.emit(cinematicCuedEvent, {\n\t\tcue,\n\t\tto: audience(to),\n\t\t...(params && { params: plain(params, `params of the cue \"${cue}\"`, 'Cinematic') as Record<string, unknown> })\n\t})\n}\n\n/**\n * A step of a sequence that cues the cinematic playing (see `cueCinematic`): `[wait(4), cinematicCue('gateOpen')]`\n *\n * @beta\n */\nexport const cinematicCue =\n\t<D = undefined>(cue: string, options?: { to?: Audience; params?: Record<string, unknown> }): Step<D> =>\n\t(world) =>\n\t\tcueCinematic(world, cue, options)\n\n/**\n * What a sequence waits for after a cinematic it played: its end for the player it was for (`ended`), the first of the\n * players' ends (`any`), or every player's (`all`). `ended` for a cinematic of several players is `all`\n *\n * @beta\n */\nexport type CinematicWait = 'ended' | 'any' | 'all'\n\n/** The sequences waiting for a cinematic to end on players' screens: in the world, so that a save keeps the count */\nexport const waits = defineComponent<{ list: { run: number; cinematic: string; waiting: PlayerId[]; any: boolean }[] }>({ id: 'core.cinematicWaits', default: () => ({ list: [] }) })\n\n/**\n * A player's screen says a cinematic the rules played is over (the `cinematic` command): the engine says so to the rules\n * (`cinematicEnded`), and a sequence that waits for it counts it\n */\nexport function cinematicEnded(world: World, player: PlayerId, cinematic: string, outcome: CinematicOutcome): void {\n\tif (world.states.has(waits)) {\n\t\tfor (const entry of world.state(waits).list) {\n\t\t\tif (entry.cinematic !== cinematic || !entry.waiting.includes(player)) continue\n\t\t\tentry.waiting = entry.any ? [] : entry.waiting.filter((other) => other !== player)\n\t\t}\n\t}\n\tworld.events.emit(cinematicEndedEvent, { player, cinematic, outcome })\n}\n\n/**\n * A player picked an answer of a choice of a cinematic on their screen (the engine's `cinematicChoice` event), as their\n * screen said with the `cinematicChoice` command: the rules branch on it (`waitFor(cinematicChoiceEvent, ...)`), so that\n * the story's branch is the same on every screen and in a replay\n *\n * @beta\n */\nexport interface CinematicChoice {\n\t/** Whose screen it was picked on */\n\tplayer: PlayerId\n\t/** Which of the view's cinematics */\n\tcinematic: string\n\t/** The choice's name in the cinematic (`choice` when it gave none), and the answer's id */\n\tquestion: string\n\t/** The id of the answer picked */\n\tchoice: string\n\t/** Whether nobody picked and the time ran out on its default */\n\ttimedOut: boolean\n}\n\n/** A player's pick of a choice of a cinematic, as their screen said: heard by the rules as `cinematicChoice` */\nexport function cinematicChose(world: World, choice: CinematicChoice): void {\n\tworld.events.emit(cinematicChoiceEvent, choice)\n}\n\n/**\n * The players a cinematic goes to that have a screen to say it ended: the ones of `to` (everyone's when left out) the\n * computer does not play, and not the neutral ones\n */\nfunction screensOf(world: World, to: PlayerId[] | undefined): PlayerId[] {\n\tconst computers = new Set(world.computers.list())\n\tconst out: PlayerId[] = []\n\tfor (const player of world.players.values()) {\n\t\tif (player.neutral || computers.has(player.id) || (to && !to.includes(player.id))) continue\n\t\tout.push(player.id)\n\t}\n\treturn out\n}\n\n/**\n * A step of a sequence that plays one of the view's cinematics: `defineSequence({ id: 'td.start', steps: [cinematic('td.intro', {\n * hold: true }), ...talk(...)] })`. It does not wait for it (with `hold`, the game, and the sequence with it, waits),\n * unless told to: `wait: 'ended'` goes on once the player it was for has seen it end (or skipped it), `any` once one\n * of the players it went to has, `all` once every one of them has. Only players with a screen are waited for (not the\n * computer's); one who left a game of several never says, so a sequence for many waits for `any` where that matters.\n * With a wait it is two steps, which `defineSequence` takes as they are\n *\n * @public\n */\nexport function cinematic<D = undefined>(id: string, options?: CinematicOptions & { wait?: undefined }): Step<D>\n/**\n * With `wait`: the cinematic played, then a wait for its end (see the other form), as two steps\n *\n * @public\n */\nexport function cinematic<D = undefined>(id: string, options: CinematicOptions & { wait: CinematicWait }): Step<D>[]\nexport function cinematic<D = undefined>(id: string, options: CinematicOptions & { wait?: CinematicWait } = {}): Step<D> | Step<D>[] {\n\tconst { wait, ...rest } = options\n\tconst play: Step<D> = (world) => playCinematic(world, id, rest)\n\tif (!wait) return play\n\tconst begin: Step<D> = (world, _data, run) => {\n\t\tconst state = world.state(waits)\n\t\t// what a sequence stopped before its cinematic ended left behind goes\n\t\tstate.list = state.list.filter((entry) => entry.run !== run && world.sequences.running(entry.run))\n\t\tstate.list.push({ run, cinematic: id, waiting: screensOf(world, audience(rest.to ?? 'everyone')), any: wait === 'any' })\n\t\tplayCinematic(world, id, rest)\n\t}\n\tconst over = waitUntil<D>((world, _data, run) => {\n\t\tconst state = world.state(waits)\n\t\tconst entry = state.list.find((candidate) => candidate.run === run)\n\t\tif (entry && entry.waiting.length > 0) return false\n\t\tstate.list = state.list.filter((candidate) => candidate !== entry)\n\t\treturn true\n\t})\n\treturn [begin, over]\n}\n\n/** A cinematic played, to whom it is for: everyone when it names nobody */\nexport const toldCinematic = replicateEvent(cinematicCueEvent, 'cinematic', ({ id, to, hold, skippable, params }, view) =>\n\t!to || to.includes(view.player) ? { type: 'cinematic', cinematic: id, hold, skippable, ...(params && { params }) } : undefined\n)\n\n/** A cue of the rules to a cinematic playing, to whom it is for */\nexport const toldCinematicCue = replicateEvent(cinematicCuedEvent, 'cinematicCue', ({ cue, to, params }, view) =>\n\t!to || to.includes(view.player) ? { type: 'cinematicCue', cue, ...(params && { params }) } : undefined\n)\n\n/**\n * The regions whose cinematic has played (`MapRegion.cinematic`), by name: kept in the world, so that a save knows\n *\n * @internal\n */\nexport const regionCinematicsPlayed = defineComponent<Record<string, true>>({ id: 'core.regionCinematics', default: () => ({}) })\n\n/**\n * A region of the map with a cinematic (`MapRegion.cinematic`, ED4) plays it for everyone, once, the first time a unit\n * of a player (not the neutral, nor a building) walks in, unless the game plays it its own way (`play: 'code'`)\n *\n * @beta\n */\nexport const regionCinematic = defineListener({\n\tid: 'core.regionCinematic',\n\tevent: enteredArea,\n\trun(world, { area, entity }) {\n\t\tconst region = world.map.regions.find((each) => each.name === area)\n\t\tconst cinematic = region?.cinematic\n\t\tif (!cinematic || cinematic.play === 'code' || world.player(entity.owner).neutral) return\n\t\tconst played = world.state(regionCinematicsPlayed)\n\t\tif (played[area]) return\n\t\tworld.setState(regionCinematicsPlayed, { ...played, [area]: true })\n\t\tplayCinematic(world, cinematic.id)\n\t}\n})\n"],"mappings":"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"}

package/dist/clock.d.ts

@@ -1,6 +1,6 @@
 import type { World } from './world';
 /**
- * The time of day of a world: what its day (`GameModule.day`) and the time played make of it, turned forward or stopped
+ * The time of day of a world: what its day (`Rules.day`) and the time played make of it, turned forward or stopped
  * by a map or a script. Kept in a save (`WorldInternals.clockShift`, `stillHour`)
  *
  * @beta
@@ -29,4 +29,4 @@ export declare class Clock {
     get night(): boolean;
 }
 /** The hour of the day, in a game with one (`Snapshot.hour`) */
-export declare const hourPart: import("./replication").SnapshotPart<keyof import(".").Snapshot>;
+export declare const hourPart: import("./replication").SnapshotField<keyof import(".").Snapshot>;

package/dist/clock.js

@@ -0,0 +1,78 @@
+import { hourOf, isNight } from "./defs.js";
+import { snapshotField } from "./replication.js";
+//#region src/clock.ts
+/**
+* The time of day of a world (`world.clock`): the hour, whether it is night, turned forward to an hour or stopped at one.
+* The world's clock of ticks is the world's (`world.time`); this is the day's, which a map and a script move
+*/
+/**
+* The time of day of a world: what its day (`Rules.day`) and the time played make of it, turned forward or stopped
+* by a map or a script. Kept in a save (`WorldInternals.clockShift`, `stillHour`)
+*
+* @beta
+*/
+var Clock = class {
+	world;
+	/** Seconds the time of day is ahead of the time played */
+	shift = 0;
+	/** The hour, when the clock does not move (`stop`) */
+	still = void 0;
+	/** Whether it was night, and when that was worked out: asked many times a tick, worked out once */
+	seen = {
+		day: void 0,
+		time: NaN,
+		shift: 0,
+		still: void 0,
+		night: false
+	};
+	constructor(world) {
+		this.world = world;
+	}
+	/** Hour of the day, 0..24. Noon in a game without days */
+	get hour() {
+		if (this.still !== void 0 && this.world.registry.day) return this.still;
+		return hourOf(this.world.registry.day, this.world.time + this.shift);
+	}
+	/** Turns the clock forward to an hour, for a map that wants to start at night or a debug tool */
+	setHour(hour) {
+		const { day } = this.world.registry;
+		if (this.still !== void 0) this.still = hour;
+		else if (day) this.shift += ((hour - this.hour) % 24 + 24) % 24 / 24 * day.length;
+	}
+	/** Stops the clock at the hour it is, for a map that is always night; `false` lets it go on from there */
+	stop(still = true) {
+		const { day } = this.world.registry;
+		if (still) this.still ??= this.hour;
+		else if (this.still !== void 0) {
+			const hour = this.still;
+			this.still = void 0;
+			if (day) this.setHour(hour);
+		}
+	}
+	/** Whether the clock stands still (`stop`) */
+	get stopped() {
+		return this.still !== void 0;
+	}
+	/**
+	* Whether the sun is down. Asked for every unit's sight and stats, many times a tick: kept for the moment it was
+	* worked out at (the day, the time, the clock's shift, an hour that stands still), so it is worked out once a tick
+	*/
+	get night() {
+		const { seen } = this;
+		const { day } = this.world.registry;
+		const { time } = this.world;
+		if (seen.time === time && seen.shift === this.shift && seen.still === this.still && seen.day === day) return seen.night;
+		seen.day = day;
+		seen.time = time;
+		seen.shift = this.shift;
+		seen.still = this.still;
+		seen.night = isNight(day, this.hour);
+		return seen.night;
+	}
+};
+/** The hour of the day, in a game with one (`Snapshot.hour`) */
+var hourPart = snapshotField("hour", ({ world }) => world.registry.day ? world.hour : void 0, true);
+//#endregion
+export { Clock, hourPart };
+
+//# sourceMappingURL=clock.js.map

package/dist/clock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.js","names":[],"sources":["../src/clock.ts"],"sourcesContent":["/**\n * The time of day of a world (`world.clock`): the hour, whether it is night, turned forward to an hour or stopped at one.\n * The world's clock of ticks is the world's (`world.time`); this is the day's, which a map and a script move\n */\nimport { hourOf, isNight } from './defs'\nimport type { World } from './world'\nimport { snapshotField } from './replication'\n\n/**\n * The time of day of a world: what its day (`Rules.day`) and the time played make of it, turned forward or stopped\n * by a map or a script. Kept in a save (`WorldInternals.clockShift`, `stillHour`)\n *\n * @beta\n */\nexport class Clock {\n\t/** Seconds the time of day is ahead of the time played */\n\tshift = 0\n\t/** The hour, when the clock does not move (`stop`) */\n\tstill: number | undefined = undefined\n\t/** Whether it was night, and when that was worked out: asked many times a tick, worked out once */\n\tprivate readonly seen: { day: unknown; time: number; shift: number; still: number | undefined; night: boolean } = {\n\t\tday: undefined,\n\t\ttime: Number.NaN,\n\t\tshift: 0,\n\t\tstill: undefined,\n\t\tnight: false\n\t}\n\n\tconstructor(private readonly world: World) {}\n\n\t/** Hour of the day, 0..24. Noon in a game without days */\n\tget hour(): number {\n\t\tif (this.still !== undefined && this.world.registry.day) return this.still\n\t\treturn hourOf(this.world.registry.day, this.world.time + this.shift)\n\t}\n\n\t/** Turns the clock forward to an hour, for a map that wants to start at night or a debug tool */\n\tsetHour(hour: number): void {\n\t\tconst { day } = this.world.registry\n\t\tif (this.still !== undefined) this.still = hour\n\t\telse if (day) this.shift += (((((hour - this.hour) % 24) + 24) % 24) / 24) * day.length\n\t}\n\n\t/** Stops the clock at the hour it is, for a map that is always night; `false` lets it go on from there */\n\tstop(still = true): void {\n\t\tconst { day } = this.world.registry\n\t\tif (still) this.still ??= this.hour\n\t\telse if (this.still !== undefined) {\n\t\t\tconst hour = this.still\n\t\t\tthis.still = undefined\n\t\t\tif (day) this.setHour(hour)\n\t\t}\n\t}\n\n\t/** Whether the clock stands still (`stop`) */\n\tget stopped(): boolean {\n\t\treturn this.still !== undefined\n\t}\n\n\t/**\n\t * Whether the sun is down. Asked for every unit's sight and stats, many times a tick: kept for the moment it was\n\t * worked out at (the day, the time, the clock's shift, an hour that stands still), so it is worked out once a tick\n\t */\n\tget night(): boolean {\n\t\tconst { seen } = this\n\t\tconst { day } = this.world.registry\n\t\tconst { time } = this.world\n\t\tif (seen.time === time && seen.shift === this.shift && seen.still === this.still && seen.day === day) return seen.night\n\t\tseen.day = day\n\t\tseen.time = time\n\t\tseen.shift = this.shift\n\t\tseen.still = this.still\n\t\tseen.night = isNight(day, this.hour)\n\t\treturn seen.night\n\t}\n}\n\n/** The hour of the day, in a game with one (`Snapshot.hour`) */\nexport const hourPart = snapshotField('hour', ({ world }) => (world.registry.day ? world.hour : undefined), true)\n"],"mappings":";;;;;;;;;;;;;AAcA,IAAa,QAAb,MAAmB;CAcW;;CAZ7B,QAAQ;;CAER,QAA4B,KAAA;;CAE5B,OAAkH;EACjH,KAAK,KAAA;EACL,MAAM;EACN,OAAO;EACP,OAAO,KAAA;EACP,OAAO;CACR;CAEA,YAAY,OAA+B;EAAd,KAAA,QAAA;CAAe;;CAG5C,IAAI,OAAe;EAClB,IAAI,KAAK,UAAU,KAAA,KAAa,KAAK,MAAM,SAAS,KAAK,OAAO,KAAK;EACrE,OAAO,OAAO,KAAK,MAAM,SAAS,KAAK,KAAK,MAAM,OAAO,KAAK,KAAK;CACpE;;CAGA,QAAQ,MAAoB;EAC3B,MAAM,EAAE,QAAQ,KAAK,MAAM;EAC3B,IAAI,KAAK,UAAU,KAAA,GAAW,KAAK,QAAQ;OACtC,IAAI,KAAK,KAAK,WAAc,OAAO,KAAK,QAAQ,KAAM,MAAM,KAAM,KAAM,IAAI;CAClF;;CAGA,KAAK,QAAQ,MAAY;EACxB,MAAM,EAAE,QAAQ,KAAK,MAAM;EAC3B,IAAI,OAAO,KAAK,UAAU,KAAK;OAC1B,IAAI,KAAK,UAAU,KAAA,GAAW;GAClC,MAAM,OAAO,KAAK;GAClB,KAAK,QAAQ,KAAA;GACb,IAAI,KAAK,KAAK,QAAQ,IAAI;EAC3B;CACD;;CAGA,IAAI,UAAmB;EACtB,OAAO,KAAK,UAAU,KAAA;CACvB;;;;;CAMA,IAAI,QAAiB;EACpB,MAAM,EAAE,SAAS;EACjB,MAAM,EAAE,QAAQ,KAAK,MAAM;EAC3B,MAAM,EAAE,SAAS,KAAK;EACtB,IAAI,KAAK,SAAS,QAAQ,KAAK,UAAU,KAAK,SAAS,KAAK,UAAU,KAAK,SAAS,KAAK,QAAQ,KAAK,OAAO,KAAK;EAClH,KAAK,MAAM;EACX,KAAK,OAAO;EACZ,KAAK,QAAQ,KAAK;EAClB,KAAK,QAAQ,KAAK;EAClB,KAAK,QAAQ,QAAQ,KAAK,KAAK,IAAI;EACnC,OAAO,KAAK;CACb;AACD;;AAGA,IAAa,WAAW,cAAc,SAAS,EAAE,YAAa,MAAM,SAAS,MAAM,MAAM,OAAO,KAAA,GAAY,IAAI"}

package/dist/commands.d.ts

@@ -8,11 +8,12 @@ import type { World } from './world';
  *
  * A command type is a `CommandDef`: the fields it carries, and what it does. What arrives is checked against the
  * fields before anything happens, because on a server it is whatever anyone sends. The engine's own commands are
- * defined the same way as a game module's (`GameModule.commands`).
+ * defined the same way as a game module's (`Rules.commands`).
  *
  * @beta
  */
 export interface CommandDef<F extends Fields = Fields> {
+    /** The command's name, which a sent command carries as its `type` */
     type: string;
     /** What it carries, besides its type and the player who sent it. See `fields.ts` for the checkers */
     fields: F;
@@ -53,7 +54,7 @@ export type DefinedCommand<T extends string, F extends Fields> = CommandDef<F> &
  * session.send(sellTower.make({ tower: 12 }))
  * ```
  *
- * @beta
+ * @public
  */
 export declare function defineCommand<const T extends string, F extends Fields>(type: T, fields: F, execute: (world: World, player: PlayerId, command: Checked<F>) => void, options?: {
     outsideTick?: boolean;
@@ -63,9 +64,19 @@ type CommandOf<D> = D extends DefinedCommand<infer T, infer F> ? {
     type: T;
     player: PlayerId;
 } & Checked<F> : never;
+/**
+ * Turns the player's missiles of an ability that are steered (`EffectFields.steer`) towards a point, as they fly
+ * (`steerMissile`): what the screen sends while one is in the air, for where the pointer is
+ *
+ * @beta
+ */
+export declare const steerCommand: DefinedCommand<"steer", {
+    ability: import("./fields").Check<string>;
+    point: import("./fields").Check<Vec2>;
+}>;
 /**
  * Stops what units are doing, as the classic Stop does: a plain interrupt. They fight what comes near again at once; a
- * unit that is to stand down and take no fights is put in a stance (`stanceCommand`, `withStances`)
+ * unit that is to stand down and take no fights is put in a stance (`stanceCommand`, `stancesPack`)
  *
  * @beta
  */
@@ -104,7 +115,22 @@ export declare const shareCommand: DefinedCommand<"share", {
  *
  * @beta
  */
-export declare const coreCommands: readonly [DefinedCommand<"order", {
+export declare const coreCommands: readonly [DefinedCommand<"camera", {
+    pan: import("./fields").Check<Checked<{
+        x: import("./fields").Check<number>;
+        z: import("./fields").Check<number>;
+        seconds: import("./fields").Check<number | undefined>;
+        ease: import("./fields").Check<string | undefined>;
+    }> | undefined>;
+    lock: import("./fields").Check<import("./cameraOrders").CameraRect | null | undefined>;
+    bounds: import("./fields").Check<import("./cameraOrders").CameraRect | null | undefined>;
+    shake: import("./fields").Check<Checked<{
+        strength: import("./fields").Check<number>;
+        x: import("./fields").Check<number | undefined>;
+        z: import("./fields").Check<number | undefined>;
+    }> | undefined>;
+    seat: import("./fields").Check<number | undefined>;
+}>, DefinedCommand<"order", {
     entities: import("./fields").Check<number[]>;
     order: import("./fields").Check<Checked<{
         type: import("./fields").Check<string>;
@@ -126,6 +152,7 @@ export declare const coreCommands: readonly [DefinedCommand<"order", {
     target: import("./fields").Check<number | undefined>;
     queue: import("./fields").Check<boolean | undefined>;
     formation: import("./fields").Check<string | undefined>;
+    facing: import("./fields").Check<number | undefined>;
 }>, DefinedCommand<"attack", {
     entities: import("./fields").Check<number[]>;
     point: import("./fields").Check<Vec2>;
@@ -136,8 +163,12 @@ export declare const coreCommands: readonly [DefinedCommand<"order", {
     entities: import("./fields").Check<number[]>;
     ability: import("./fields").Check<string>;
     point: import("./fields").Check<Vec2 | undefined>;
+    to: import("./fields").Check<Vec2 | undefined>;
     target: import("./fields").Check<number | undefined>;
     queue: import("./fields").Check<boolean | undefined>;
+}>, DefinedCommand<"steer", {
+    ability: import("./fields").Check<string>;
+    point: import("./fields").Check<Vec2>;
 }>, DefinedCommand<"autocast", {
     entities: import("./fields").Check<number[]>;
     ability: import("./fields").Check<string>;
@@ -205,6 +236,7 @@ export declare const coreCommands: readonly [DefinedCommand<"order", {
  * @beta
  */
 export interface Commands {
+    /** The engine's commands, as a union of their types; a game or pack adds its own by merging into `Commands` */
     core: (typeof coreCommands)[number];
 }
 /**