@v12-engine/engine 0.1.1 → 0.4.0

package/dist/engineEvents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineEvents.js","names":[],"sources":["../src/engineEvents.ts"],"sourcesContent":["/**\n * The engine's events (design review E7): a key each, as a game's own are (`defineEvent`), emitted on `world.events`\n * and listened to with `defineListener` the same way. What each says is its payload, typed by the key; its id is its\n * name, as the debug tools' event log shows it\n */\nimport { engineEvent } from './events'\nimport type { WorldEvents } from './world'\n\n/**\n * Something was made in the world: a unit trained or spawned, a building put down, a tree of the map\n *\n * @beta\n */\nexport const entitySpawned = engineEvent<WorldEvents['entitySpawned']>('entitySpawned')\n\n/**\n * Something left the world for good: a corpse gone, a building taken down, a unit removed by the rules\n *\n * @beta\n */\nexport const entityRemoved = engineEvent<WorldEvents['entityRemoved']>('entityRemoved')\n\n/**\n * Something died: what killed it, and how. `cause`: the blow, for what died of damage. `how`: what the rules made\n * of the death in the `death` hook, for the screen to show (`'exploded'`, `'burned'`)\n *\n * @public\n */\nexport const entityDied = engineEvent<WorldEvents['entityDied']>('entityDied')\n\n/**\n * A buff was put on, or put on again (`renewed`, with the level it had before: `previousLevel`)\n *\n * @beta\n */\nexport const buffApplied = engineEvent<WorldEvents['buffApplied']>('buffApplied')\n\n/**\n * A buff came off: it ran out (`expired`), or was taken off. Not for the buffs of something that dies\n *\n * @beta\n */\nexport const buffRemoved = engineEvent<WorldEvents['buffRemoved']>('buffRemoved')\n\n/**\n * Something took damage: who dealt it, how much, of which type, whether a critical strike, and by an attack or an ability\n *\n * @beta\n */\nexport const damaged = engineEvent<WorldEvents['damaged']>('damaged')\n\n/**\n * An attack went wide. Where it would have landed, and whom it was for\n *\n * @beta\n */\nexport const missed = engineEvent<WorldEvents['missed']>('missed')\n\n/**\n * Something was given health back, and by whom\n *\n * @beta\n */\nexport const healed = engineEvent<WorldEvents['healed']>('healed')\n\n/**\n * A unit began an attack: its swing, at its target where it has one\n *\n * @beta\n */\nexport const attackStarted = engineEvent<WorldEvents['attackStarted']>('attackStarted')\n\n/**\n * A unit's swing was called off before its blow landed (moved away, told something else, its target gone, stunned):\n * told to the players as `attackCancelled`, for the screen to cut the attack to the walk\n *\n * @beta\n */\nexport const swingCancelled = engineEvent<WorldEvents['swingCancelled']>('swingCancelled')\n\n/**\n * An attack's projectile set off\n *\n * @beta\n */\nexport const projectileSpawned = engineEvent<WorldEvents['projectileSpawned']>('projectileSpawned')\n\n/**\n * An attack's projectile landed or was taken away\n *\n * @beta\n */\nexport const projectileRemoved = engineEvent<WorldEvents['projectileRemoved']>('projectileRemoved')\n\n/**\n * An attack that hits an area came down\n *\n * @beta\n */\nexport const impact = engineEvent<WorldEvents['impact']>('impact')\n\n/**\n * A building's site was put down: what it will be, while it goes up\n *\n * @beta\n */\nexport const constructionStarted = engineEvent<WorldEvents['constructionStarted']>('constructionStarted')\n\n/**\n * A building went up whole and works\n *\n * @beta\n */\nexport const constructionFinished = engineEvent<WorldEvents['constructionFinished']>('constructionFinished')\n\n/**\n * A construction was called off by its owner: it dies next, with the reason `cancelled`\n *\n * @beta\n */\nexport const constructionCancelled = engineEvent<WorldEvents['constructionCancelled']>('constructionCancelled')\n\n/**\n * A building started to turn into another type (`UnitTypeDef.upgradesTo`), over `time` seconds\n *\n * @beta\n */\nexport const morphStarted = engineEvent<WorldEvents['morphStarted']>('morphStarted')\n\n/**\n * That was called off, or the building died before it was done\n *\n * @beta\n */\nexport const morphCancelled = engineEvent<WorldEvents['morphCancelled']>('morphCancelled')\n\n/**\n * A building trained a unit: the building, and the unit made\n *\n * @beta\n */\nexport const unitTrained = engineEvent<WorldEvents['unitTrained']>('unitTrained')\n\n/**\n * An entity became another type: `from`, what it was\n *\n * @beta\n */\nexport const entityMorphed = engineEvent<WorldEvents['entityMorphed']>('entityMorphed')\n\n/**\n * A hero in a form turned back into what it was (`leaveForm`): the form it was in, and what turned it back (its\n * ability cast again, its time, its death; none when it took another form or code did it)\n *\n * @beta\n */\nexport const morphedBack = engineEvent<WorldEvents['morphedBack']>('morphedBack')\n\n/**\n * A player lost: their units and buildings are gone, or the rules said so\n *\n * @beta\n */\nexport const playerDefeated = engineEvent<WorldEvents['playerDefeated']>('playerDefeated')\n\n/**\n * A player gave up (see `surrender`): `playerDefeated` follows\n *\n * @beta\n */\nexport const playerSurrendered = engineEvent<WorldEvents['playerSurrendered']>('playerSurrendered')\n\n/**\n * A player asked for a pause, and the rules let them (see `askPause`): whoever runs the world pauses it, for `seconds` at most\n *\n * @beta\n */\nexport const pauseAsked = engineEvent<WorldEvents['pauseAsked']>('pauseAsked')\n\n/**\n * The game ended, with the winning team (`0` for none)\n *\n * @beta\n */\nexport const gameOver = engineEvent<WorldEvents['gameOver']>('gameOver')\n\n/**\n * The game ended on an error in its rules (`world.failure`): it is not stepped again\n *\n * @beta\n */\nexport const worldFailed = engineEvent<WorldEvents['worldFailed']>('worldFailed')\n\n/**\n * A unit got into a transport (`UnitTypeDef.transport`), or out of one\n *\n * @beta\n */\nexport const boarded = engineEvent<WorldEvents['boarded']>('boarded')\n\n/**\n * A unit was hired at a place that hires (`UnitTypeDef.hires`)\n *\n * @beta\n */\nexport const unitHired = engineEvent<WorldEvents['unitHired']>('unitHired')\n\n/**\n * A passenger left its transport\n *\n * @beta\n */\nexport const unloaded = engineEvent<WorldEvents['unloaded']>('unloaded')\n\n/**\n * A hero went up a level\n *\n * @beta\n */\nexport const heroLevelUp = engineEvent<WorldEvents['heroLevelUp']>('heroLevelUp')\n\n/**\n * A hero earned experience (`grantXp`): how much, after `beforeXp`, and the level it is at after it\n *\n * @beta\n */\nexport const xpGained = engineEvent<WorldEvents['xpGained']>('xpGained')\n\n/**\n * A unit's mana changed by something it did or was given: spent on a cast (`amount` below 0, `ability` the one cast)\n * or given by an effect (above 0). Not its regeneration, which would be every tick\n *\n * @beta\n */\nexport const manaChanged = engineEvent<WorldEvents['manaChanged']>('manaChanged')\n\n/**\n * A pool of a game's own on a unit (rage, energy, charges) changed: emitted by the game's rules\n * (`world.events.emit('resourceChanged', …)`), heard by the screens of the unit's owner and allies (`resource`)\n *\n * @beta\n */\nexport const resourceChanged = engineEvent<WorldEvents['resourceChanged']>('resourceChanged')\n\n/**\n * A hero came back to life (at an altar, or by the rules)\n *\n * @beta\n */\nexport const heroRevived = engineEvent<WorldEvents['heroRevived']>('heroRevived')\n\n/**\n * A unit began casting an ability, at a point where it has one. `duration`: seconds of the wind-up\n *\n * @beta\n */\nexport const castStarted = engineEvent<WorldEvents['castStarted']>('castStarted')\n\n/**\n * A wind-up called off before it went off (`castStarted` with no cast after it): stunned, killed, ordered elsewhere\n *\n * @beta\n */\nexport const castCancelled = engineEvent<WorldEvents['castCancelled']>('castCancelled')\n\n/**\n * A channelled ability started to be kept up, or ended: done, or `interrupted`\n *\n * @beta\n */\nexport const channelStarted = engineEvent<WorldEvents['channelStarted']>('channelStarted')\n\n/**\n * A channelled ability stopped: run to its end, or broken off (`interrupted`)\n *\n * @beta\n */\nexport const channelEnded = engineEvent<WorldEvents['channelEnded']>('channelEnded')\n\n/**\n * An ability's missile set off\n *\n * @beta\n */\nexport const missileSpawned = engineEvent<WorldEvents['missileSpawned']>('missileSpawned')\n\n/**\n * An ability's missile reached what it was sent at\n *\n * @beta\n */\nexport const missileHit = engineEvent<WorldEvents['missileHit']>('missileHit')\n\n/**\n * An ability's missile is gone: it hit, or ran out\n *\n * @beta\n */\nexport const missileRemoved = engineEvent<WorldEvents['missileRemoved']>('missileRemoved')\n\n/**\n * An ability went off: who cast it, at what level, at whom or where\n *\n * @beta\n */\nexport const abilityCast = engineEvent<WorldEvents['abilityCast']>('abilityCast')\n\n/**\n * What an ability set off arrived: a missile hit, a rush ended, the time was up\n *\n * @beta\n */\nexport const abilityImpact = engineEvent<WorldEvents['abilityImpact']>('abilityImpact')\n\n/**\n * A building finished researching an upgrade: which, and its level now\n *\n * @beta\n */\nexport const researchFinished = engineEvent<WorldEvents['researchFinished']>('researchFinished')\n\n/**\n * An item was put on the ground\n *\n * @beta\n */\nexport const itemDropped = engineEvent<WorldEvents['itemDropped']>('itemDropped')\n\n/**\n * An item was picked up from the ground\n *\n * @beta\n */\nexport const itemPicked = engineEvent<WorldEvents['itemPicked']>('itemPicked')\n\n/**\n * A hero took a purchase back at a shop (`undoBuy`)\n *\n * @beta\n */\nexport const itemUndone = engineEvent<WorldEvents['itemUndone']>('itemUndone')\n\n/**\n * Every creep of a camp is gone. It comes back after a while, when it says so (see `Camp.respawn`)\n *\n * @beta\n */\nexport const campCleared = engineEvent<WorldEvents['campCleared']>('campCleared')\n\n/**\n * A camp cleared came back, its creeps where they stood (see `respawnCamp`)\n *\n * @beta\n */\nexport const campReturned = engineEvent<WorldEvents['campReturned']>('campReturned')\n\n/**\n * A player marked a spot for their allies, or for everyone (see `ping`)\n *\n * @beta\n */\nexport const pinged = engineEvent<WorldEvents['pinged']>('pinged')\n\n/**\n * A player gave an ally resources (see `give`): how much went, and how much came after the tax\n *\n * @beta\n */\nexport const traded = engineEvent<WorldEvents['traded']>('traded')\n\n/**\n * A player traded one resource for another at a rate (see `exchange`): how much of what went, and how much of what came\n *\n * @beta\n */\nexport const exchanged = engineEvent<WorldEvents['exchanged']>('exchanged')\n\n/**\n * A player said a line (see `chat`): to their side, or to everyone\n *\n * @beta\n */\nexport const chatted = engineEvent<WorldEvents['chatted']>('chatted')\n\n/**\n * What a unit carries changed: an item given, taken, bought, sold, used up, or a hero carried in with theirs\n *\n * @beta\n */\nexport const inventoryChanged = engineEvent<WorldEvents['inventoryChanged']>('inventoryChanged')\n\n/**\n * A player was paid for a kill: the unit killed, who was paid, how much\n *\n * @beta\n */\nexport const bounty = engineEvent<WorldEvents['bounty']>('bounty')\n\n/**\n * A worker struck what it is mending\n *\n * @beta\n */\nexport const worked = engineEvent<WorldEvents['worked']>('worked')\n\n/**\n * A worker struck the tree it is working on\n *\n * @beta\n */\nexport const chopped = engineEvent<WorldEvents['chopped']>('chopped')\n\n/**\n * A worker handed in what it carried: `amount` as it went into the purse, `upkeep` what upkeep took of it at the door\n *\n * @beta\n */\nexport const resourcesDeposited = engineEvent<WorldEvents['resourcesDeposited']>('resourcesDeposited')\n\n/**\n * A player paid for something (`spend`), or was given back what they paid (`refund`, `giveBack`): `on` what (`unit`,\n * `upgrade`, `structure`, `item`, `hire`, `repair`... or a game's own word), and its id\n *\n * @beta\n */\nexport const resourcesSpent = engineEvent<WorldEvents['resourcesSpent']>('resourcesSpent')\n\n/**\n * A command, or a part of one, that a player's own client never sends: not what it says it is (an unknown type, a\n * field missing or of the wrong kind), or naming another player's unit, or a unit there never was. What a race makes\n * (an order to a unit that has just died) is not one. A server counts these against whoever sent them (`onCheat`);\n * a game's own commands may emit it too\n */\n/**\n * A command turned away (`RejectedKind`: why, for what counts them, as a server's cheat counter does), with the\n * reason in words for the log\n *\n * @beta\n */\nexport const commandRejected = engineEvent<WorldEvents['commandRejected']>('commandRejected')\n\n/**\n * A command that came with a number of its sender's (`seq`) was carried out: refused with the first error the player was told, or not\n *\n * @beta\n */\nexport const commandHandled = engineEvent<WorldEvents['commandHandled']>('commandHandled')\n\n/**\n * Feedback for a player, like \"Not enough gold\": what the client finds the words for\n *\n * @beta\n */\nexport const messageSent = engineEvent<WorldEvents['messageSent']>('messageSent')\n\n/**\n * A unit walked into an area of the game (`Rules.areas`)\n *\n * @public\n */\nexport const enteredArea = engineEvent<WorldEvents['enteredArea']>('enteredArea')\n\n/**\n * A unit walked out of one. What dies in an area is not said to leave it\n *\n * @beta\n */\nexport const leftArea = engineEvent<WorldEvents['leftArea']>('leftArea')\n\n/**\n * An objective of a player was given (`was` undefined), got further along, was done or failed\n *\n * @beta\n */\nexport const objectiveChanged = engineEvent<WorldEvents['objectiveChanged']>('objectiveChanged')\n\n/**\n * Someone said a line, to some players or everyone (see `world.dialog`)\n *\n * @beta\n */\nexport const lineSaid = engineEvent<WorldEvents['lineSaid']>('lineSaid')\n\n/**\n * A line was skipped by whom it was said to: it ends early for them\n *\n * @beta\n */\nexport const lineEnded = engineEvent<WorldEvents['lineEnded']>('lineEnded')\n\n/**\n * A player went over to another team (`setTeam`)\n *\n * @beta\n */\nexport const teamChanged = engineEvent<WorldEvents['teamChanged']>('teamChanged')\n\n/**\n * The rules marked a moment to start again from, like the start of a wave: a session keeps a save of it\n *\n * @beta\n */\nexport const checkpoint = engineEvent<WorldEvents['checkpoint']>('checkpoint')\n\n/**\n * The rules play one of the view's cinematics on the screens of some players, or everyone's (see `playCinematic`)\n *\n * @beta\n */\nexport const cinematicCue = engineEvent<WorldEvents['cinematicCue']>('cinematicCue')\n\n/**\n * The rules cue the cinematic playing on some screens, or everyone's (see `cueCinematic`)\n *\n * @beta\n */\nexport const cinematicCued = engineEvent<WorldEvents['cinematicCued']>('cinematicCued')\n\n/**\n * The rules pan or shake one player's camera (see `cameraFor`)\n *\n * @beta\n */\nexport const cameraOrdered = engineEvent<WorldEvents['cameraOrdered']>('cameraOrdered')\n\n/**\n * A cinematic the rules played is over on a player's screen, as their screen said (see `cinematic`'s `wait`)\n *\n * @beta\n */\nexport const cinematicEnded = engineEvent<WorldEvents['cinematicEnded']>('cinematicEnded')\n\n/**\n * A player picked an answer of a cinematic's choice, as their screen said (see `cinematicChose`)\n *\n * @beta\n */\nexport const cinematicChoice = engineEvent<WorldEvents['cinematicChoice']>('cinematicChoice')\n\n/**\n * The rules play one of the view's effects at a place or on an entity, for everyone who sees it (see `world.fx`)\n *\n * @beta\n */\nexport const fxStarted = engineEvent<WorldEvents['fxStarted']>('fxStarted')\n\n/**\n * The rules stop an effect they played (see `world.stopFx`)\n *\n * @beta\n */\nexport const fxStopped = engineEvent<WorldEvents['fxStopped']>('fxStopped')\n\n/**\n * One hidden in a layer of cells moved in it, or stepped into it (`ConcealmentOptions.rustle`): told to the teams\n * it names that do not see it (all of them, where none are named), where they see the ground, as a shake of what the\n * layer draws there\n *\n * @beta\n */\nexport const rustled = engineEvent<WorldEvents['rustled']>('rustled')\n\n/**\n * A gust of wind blew at a place (`gust`, `WindGust`): where, and the gust. Told to the players who see the place, as\n * a `gust` message, for their screens to bend the grass and bushes there. Nothing of the world changes by it\n *\n * @beta\n */\nexport const gusted = engineEvent<WorldEvents['gusted']>('gusted')\n\n/**\n * Cells of a layer (`Terrain.cells`) were set to a value (`setCells`): told to the players who see them, the others as\n * they come into sight (`cellsSeen`)\n *\n * @beta\n */\nexport const cellsChanged = engineEvent<WorldEvents['cellsChanged']>('cellsChanged')\n\n/**\n * A part of the ground was reshaped (`World.reshapeGround`): told to every player\n *\n * @beta\n */\nexport const groundReshaped = engineEvent<WorldEvents['groundReshaped']>('groundReshaped')\n\n/**\n * Cells of a layer that changed out of a team's sight came into it (`TeamMemory.cells`): told to that team's players\n *\n * @beta\n */\nexport const cellsSeen = engineEvent<WorldEvents['cellsSeen']>('cellsSeen')\n\n/** What the map looks like beyond its ground changed (`setEnvironment`): as it is now, told to every player */\n/** `over`: the seconds the screens ease into it over, where the rules said\n *\n * @beta\n */\nexport const environmentChanged = engineEvent<WorldEvents['environmentChanged']>('environmentChanged')\n"],"mappings":"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"}

package/dist/entity.d.ts

@@ -1,11 +1,19 @@
-import { type Cost, type EffectDef, type ResourceKind, type UnitTypeDef } from './defs';
+import { type Cost, type EffectDef, type ResourceId, type UnitTypeDef } from './defs';
 import { type Component } from './components';
 import type { Rect, Vec2 } from './math';
 import type { StatsCache } from './stats';
-import type { OrderParams } from './registry';
-/** @beta */
+import type { OrderInit, OrderParams } from './registry';
+/**
+ * The number an entity has in its world, unique there
+ *
+ * @public
+ */
 export type EntityId = number;
-/** @beta */
+/**
+ * The number of a player in a world
+ *
+ * @public
+ */
 export type PlayerId = number;
 /**
  * An order a unit carries out or has queued. `State` is what its behaviour keeps in it (`OrderBehavior<State>`): empty
@@ -14,18 +22,26 @@ export type PlayerId = number;
  * @beta
  */
 export interface Order<State extends object = Record<string, any>, Init extends object = OrderParams> {
+    /** The order's number, unique in its world */
     id: number;
+    /** The order's type, naming the behaviour that carries it out */
     type: string;
     /** What it was given, as its type takes it (`OrderInits`): plain data, saved with the order */
     init: Init;
     /** Shared by every unit that received the order from the same command */
     groupId: number;
+    /** Whether the order has begun being carried out */
     started: boolean;
     /** Scratch space owned by the order behavior: plain data, saved with the order */
     state: State;
 }
-/** @beta */
+/**
+ * What a unit holds of one of its abilities: its level, cooldown, charges and autocast
+ *
+ * @beta
+ */
 export interface AbilityState {
+    /** The id of the ability this is the state of */
     id: string;
     /** 0 for an ability a hero has not learned yet */
     level: number;
@@ -38,17 +54,55 @@ export interface AbilityState {
     charges?: number;
     /** Seconds until the next use is back, while it holds fewer than it can */
     refill?: number;
+    /** Whether the ability is cast by itself when its conditions are met */
     autocast: boolean;
     /** Where it was last aimed */
     point?: Vec2;
+    /** For one aimed along two points (`vector`): the second, the way it went from `point` */
+    to?: Vec2;
+    /**
+     * The game's own state of the ability on this unit, plain data (numbers, text, lists and plain objects of them):
+     * ammo, a count of what it hit, a mark it left. Saved with the unit and told to its owner's screen with the rest of
+     * the ability (`AbilityInfo.data`), for a button to show. Nothing of the engine's reads it
+     *
+     * @beta
+     */
+    data?: Record<string, unknown>;
+    /**
+     * Its window to be cast again, while it is open (`AbilityDef.recast`): the next cast is a recast
+     *
+     * @beta
+     */
+    recast?: RecastWindow;
+}
+/**
+ * An ability's window to be cast again (`AbilityState.recast`, `AbilityDef.recast`)
+ *
+ * @beta
+ */
+export interface RecastWindow {
+    /** Seconds left of it */
+    left: number;
+    /** Seconds it was open for in all, for a button to show how much is left */
+    total: number;
+    /** Recasts made in it so far */
+    used: number;
+    /** The cooldown that starts as it closes, for one whose cooldown waits for it (`after`) */
+    cooldown?: number;
 }
-/** @beta */
+/**
+ * A buff on a unit: which, from what level, how long is left and who put it there
+ *
+ * @beta
+ */
 export interface BuffInstance {
+    /** The id of the buff */
     id: string;
     /** Level of the ability it came from */
     level: number;
     /** Seconds left. Infinity for buffs that stay */
     remaining: number;
+    /** Seconds the buff has been on */
     elapsed: number;
     /** Entity that put it there */
     source: EntityId;
@@ -72,12 +126,16 @@ export interface BuffInstance {
  * @beta
  */
 export interface ItemInstance {
+    /** The item instance's number, unique in its world */
     id: number;
+    /** The id of the item type */
     item: string;
     /** Uses left, for items that run out */
     charges: number;
     /** Cooldown of the ability the item gives */
     state?: AbilityState;
+    /** Seconds until its next charge comes back, for an item that refills over time (`ItemDef.refill`) while it is short */
+    refill?: number;
     /** State of the game's own about this one item: kills it has seen, what it has stored. Plain data: it is saved */
     data?: Record<string, unknown>;
 }
@@ -87,41 +145,57 @@ export interface ItemInstance {
  * @beta
  */
 export interface StockState {
+    /** The id of the item type for sale */
     item: string;
+    /** How many of it the shop has now */
     count: number;
     /** Seconds until the next one arrives */
     restock: number;
 }
-/** @beta */
+/**
+ * How a unit's move is going: it is not moving, on its way, got there, or could not
+ *
+ * @beta
+ */
 export type MoveStatus = 'idle' | 'moving' | 'arrived' | 'failed';
-/** @beta */
+/**
+ * What a unit keeps of its moving: speed, goal, status and the path's bookkeeping
+ *
+ * @beta
+ */
 export interface MovementState {
+    /** Units per second it goes at now */
     speed: number;
     /** The fastest it goes for now, whatever its speed: a group's slowest, as it moves together (`OrderParams.together`) */
     cap?: number;
+    /** Whether it is idle, on its way, arrived or failed to get there */
     status: MoveStatus;
+    /** Where it is heading, in cells */
     goal: Vec2;
     /** When set the goal follows this entity */
     goalEntity: EntityId;
     /** Arrive once this close to the goal (edge distance for entity goals) */
     range: number;
+    /** The group of units that were sent together; the same as the `groupId` of their order */
     groupId: number;
     /** Last destination handed to the navigation */
     navGoal: Vec2;
+    /** The version of the navigation when the goal was handed to it */
     navVersion: number;
     /** Corner of the path the unit is heading for. Progress is measured towards it, so a long way round is not mistaken for standing still */
     corner: Vec2;
     /** Closest the unit has been to its corner, used to detect that it stopped making progress */
     bestDistance: number;
+    /** Seconds it has made no progress towards its corner */
     stalledTime: number;
     /**
      * Seconds it has gone well under its speed on its way, held up by others (not counting getting going, or slowing
-     * to arrive): what has those in its way asked to step aside (see `GameRules.movement.lookAhead`)
+     * to arrive): what has those in its way asked to step aside (see `RuleSettings.movement.lookAhead`)
      */
     slowTime?: number;
     /**
      * The point it goes round standing units by, on its way to the next corner of its path, when that is not much
-     * longer (`GameRules.movement.goesAround`, the `detour` hook): none while it goes straight
+     * longer (`RuleSettings.movement.goesAround`, the `detour` hook): none while it goes straight
      */
     detour?: Vec2;
     /** Where it heads on from `detour`: the corner of its path it went round the knot towards */
@@ -130,14 +204,46 @@ export interface MovementState {
     aside?: boolean;
     /** Whether it was sent on past `detour`, towards its path, as it neared it */
     detourPast?: boolean;
+    /**
+     * The group of the formation it was last sent in (`OrderInit.formation`, the order's `groupId`): those of one swap
+     * places on the way, and keep the places they get to (`place`)
+     */
+    formation?: number;
+    /**
+     * Its place in its formation, once there. Stepped aside or pushed off it, it walks back once it has stood off it a
+     * while. None once it walks off on a move of its own, or is given another order
+     */
+    place?: Vec2;
+    /** How many times it went back to its place without getting there: it lets it go after a few */
+    backTries?: number;
+    /**
+     * How many times it tried again on this move, held up 3 seconds by others that may yet go (in a crowd, say): sent on
+     * anew, round the whole knot, those in it asked aside. It gives up after 4, or none when what holds it up is the
+     * ground or those holding their ground. Counted again once it gets 2 cells nearer
+     */
+    tries?: number;
+    /** How far it had left to go when it last tried again */
+    triedAt?: number;
+    /**
+     * On a step aside asked by one stepping aside itself: how far down that line it is (2, 3). One that far asks nobody
+     * aside in turn, so that a crowd parts a few deep and no further
+     */
+    asideDepth?: number;
     /** Whether the last move failed by getting stuck on the way (in a crowd, say), not for there being no way there */
     stuck?: boolean;
+    /** Whether the unit holds its ground in a fight, so that others come round it */
     anchored: boolean;
+    /** Whether the navigation lets it through others, as a ghost */
     ghost: boolean;
+    /**
+     * Whether a buff it carries has it walk through others now (`BuffDef.phasing`): a ghost to the navigation as well,
+     * whatever `ghost` says. Seen to every tick by the movement
+     */
+    phased?: boolean;
     /** Direction the unit turns to while it stands still. Null when it may face wherever it ended up */
     finalFacing: number | null;
     /**
-     * The route its side planned to the goal, corner by corner, with what the side knows (`GameModule.paths: 'seen'`):
+     * The route its side planned to the goal, corner by corner, with what the side knows (`Rules.paths: 'seen'`):
      * walked a stretch at a time. None where routes know everything, or there is no route
      */
     route?: Vec2[];
@@ -156,20 +262,31 @@ export interface MovementState {
  * @beta
  */
 export declare const moving: Component<MovementState, MovementState>;
-/** @beta */
+/**
+ * What a unit keeps of its fighting: cooldown, swing, targets and recovery
+ *
+ * @beta
+ */
 export interface CombatState {
     /** Seconds until the next attack may start */
     cooldown: number;
     /** Seconds until the running swing lands. 0 when not swinging */
     swing: number;
+    /** The entity the running swing is aimed at */
     swingTarget: EntityId;
     /**
      * Which of its attacks the running swing, or the last, is of, by place (`UnitTypeDef.attacks`): the first when left
      * out, as for every unit with one. It swings one at a time, and waits out the cooldown of the one that hit
      */
     weapon?: number;
+    /**
+     * Seconds left of the recovery after its last blow (`AttackDef.recovery`), while what it is told waits: none when
+     * it has none
+     */
+    recovery?: number;
     /** Target picked by the unit itself rather than by an order */
     autoTarget: EntityId;
+    /** The entity that last hit it */
     lastAttacker: EntityId;
     /** Where an idle unit returns to after chasing */
     guard: Vec2 | null;
@@ -181,6 +298,8 @@ export interface CombatState {
     slot?: number | null;
     /** Targets it left alone because it could not get at them, and until when, in world time */
     shunned?: [EntityId, number][];
+    /** The tick the allies of whoever it hit were last called to help (`RuleSettings.combat.helpRange`), so that they are asked once in a while, not by every blow. Unset until it hits someone */
+    helpedAt?: number;
 }
 /**
  * How an entity fights (`CombatState`): its cooldown, its swing, what it is engaged with. What attacks has it from its
@@ -189,17 +308,28 @@ export interface CombatState {
  * @beta
  */
 export declare const fighting: Component<CombatState, CombatState>;
-/** @beta */
+/**
+ * What a worker keeps of its gathering: what it carries and where it gathered
+ *
+ * @beta
+ */
 export interface HarvesterState {
+    /** How much of the resource the worker carries */
     carrying: number;
     /** What it is that the worker carries, or last gathered. Null for one that has not gathered anything yet */
-    kind: ResourceKind | null;
+    kind: ResourceId | null;
     /** Last resource this worker gathered from */
     resource: EntityId;
 }
-/** @beta */
+/**
+ * What is left of a deposit and how many are at it
+ *
+ * @beta
+ */
 export interface ResourceState {
+    /** How much of the resource is left in it */
     amount: number;
+    /** How many workers are at it, inside or working on it */
     occupants: number;
     /** The building that stands on it (`UnitTypeDef.builtOn`), by id: none when nothing does */
     under?: EntityId;
@@ -211,18 +341,28 @@ export interface ResourceState {
  * @beta
  */
 export declare const deposit: Component<ResourceState, ResourceState>;
-/** @beta */
+/**
+ * How far a building under construction has got
+ *
+ * @beta
+ */
 export interface ConstructionState {
     /** 0..1 */
     progress: number;
+    /** Seconds a single builder needs to finish it */
     buildTime: number;
     /** Builders that worked on it during the current tick */
     builders: number;
     /** What was paid for it, when that is not what its type costs. A cancelled site gives part of this back */
     paid?: Cost;
 }
-/** @beta */
+/**
+ * One thing a building makes: a unit, an upgrade, a revive or a morph
+ *
+ * @beta
+ */
 export interface ProductionItem {
+    /** What it makes: a unit, an upgrade, a revived hero or a morph into another type */
     kind: 'unit' | 'upgrade' | 'revive' | 'morph';
     /** Unit type, upgrade id, the id of the hero to bring back, or the type the building turns into */
     id: string;
@@ -230,6 +370,7 @@ export interface ProductionItem {
     paid?: Cost;
     /** Seconds of work done */
     progress: number;
+    /** Seconds it takes in all */
     duration: number;
 }
 /**
@@ -246,36 +387,99 @@ export declare const exposure: Component<Map<number, number>, Map<number, number
  * @beta
  */
 export declare const detection: Component<Map<number, number>, Map<number, number>>;
+/**
+ * Whose picture an entity wears: the type it is drawn as, and the owner whose colour it is drawn in. Nothing in the
+ * rules goes by it
+ *
+ * @beta
+ */
+export interface Likeness {
+    /** The unit type whose picture the entity wears */
+    type: string;
+    /** The player whose colour the entity is drawn in */
+    owner: PlayerId;
+}
 /**
  * A rush to a spot: nothing stops it, and what it does happens where it ends
  *
  * @beta
  */
 export interface Dash {
+    /** Where it ends, east-west in cells */
     x: number;
+    /** Where it ends, north-south in cells */
     z: number;
     /** Where it started */
     from: Vec2;
     /** Units per second */
     speed: number;
+    /** The id of the ability that sent it */
     ability: string;
+    /** The level of the ability it was cast at */
     level: number;
+    /**
+     * Which effect of the ability sent it, by its place there (`effectIndex`): what the screen draws it with
+     * (`AbilityLook.effects`). Nothing to the rules
+     *
+     * @beta
+     */
+    effect?: number;
+    /** The effects that happen where it ends */
     effects: EffectDef[];
     /** How high it rises on the way: a leap, over whatever is in between */
     height?: number;
     /** A buff it carries for as long as the rush lasts */
     buff?: string;
+    /**
+     * Dragged by someone (the effect `pull`): `by` whom, in whose name `effects` happen to it as it arrives, and whether
+     * it is dragged after them as they move (`follows`) or to the spot (`x`, `z`). It does nothing of its own meanwhile,
+     * and nothing else moves it
+     *
+     * @beta
+     */
+    pulled?: {
+        by: EntityId;
+        follows: boolean;
+    };
+    /**
+     * The unit it rushes to (a `dash` to a unit, in a game with the moves pack): its landing `effects` happen to it, where
+     * it still is in the world
+     *
+     * @beta
+     */
+    target?: EntityId;
 }
-/** @beta */
+/**
+ * Where the units a building makes go: a point, or an entity they follow
+ *
+ * @beta
+ */
 export interface RallyPoint {
+    /** The place the units go to */
     point: Vec2;
+    /** The entity they follow; 0 for none */
     target: EntityId;
 }
-/** @beta */
+/**
+ * What a building makes: the queue of what it is making, and its rally point
+ *
+ * @beta
+ */
 export interface ProductionState {
+    /** What it makes in turn, the first being worked on */
     queue: ProductionItem[];
+    /** Where the units it makes go, or null for none */
     rally: RallyPoint | null;
 }
+/**
+ * How an order is given (`Entity.order`)
+ *
+ * @public
+ */
+export interface OrderOptions {
+    /** After what it was told before, rather than in its place: Shift held */
+    queue?: boolean;
+}
 /**
  * Anything in the world: a unit, a building, a tree.
  *
@@ -285,13 +489,16 @@ export interface ProductionState {
  * `retype`, `changeOwner`…). The rest, like health, mana or cooldowns, a game
  * module may change as it likes: nothing is worked out from them that would not notice.
  *
- * @beta
+ * @public
  */
 export declare class Entity {
+    /** The entity's number, unique in its world */
     readonly id: EntityId;
     /** Changes when a building is upgraded into another type */
     readonly def: UnitTypeDef;
+    /** The player it belongs to, changed through `World.setOwner` only */
     readonly owner: PlayerId;
+    /** Whether the entity is in the world; false once it died */
     readonly alive: boolean;
     /** Hidden entities are inside something (a gold mine) and do not take part in the world */
     readonly hidden: boolean;
@@ -300,17 +507,27 @@ export declare class Entity {
      * Becomes false for good once something gives it anything to do (`World.wake`)
      */
     readonly scenery: boolean;
+    /** Where it stands in cells (`x`, `z`), changed through the world's functions only */
     readonly pos: Readonly<Vec2>;
+    /** Where it stood at the last tick, for the screen to draw between */
     readonly prevPos: Vec2;
+    /** The way it faces in radians */
     facing: number;
+    /** The way it faced at the last tick, in radians, for the screen to draw between */
     prevFacing: number;
     /** How big it is drawn, for the look of a map. Nothing in the rules goes by it */
     scale: number;
     /** Which of the models of its type it is drawn with, for the look of a map. Nothing in the rules goes by it either */
     look?: string;
+    /**
+     * Drawn as another's type and owner: a soul in the fallen's shape (`SpawnOptions.looksLike`). Its own type and owner
+     * decide everything but the picture
+     */
+    likeness?: Likeness;
     /** Velocity of the last tick */
     readonly velocity: Vec2;
-    hp: number;
+    /** Hit points it has now; it dies at 0 */
+    health: number;
     /** Teams that have seen this entity at least once, one bit per team as `FogOfWar.teamBit` hands them out. Ask `World.hasSeen` */
     seenBy: number;
     /** When it was last hurt, in seconds of the game. Long ago for what never was */
@@ -329,8 +546,11 @@ export declare class Entity {
     readonly orders: readonly Order[];
     /** Invisible to enemies right now, unless they have found it */
     get unseen(): boolean;
-    maxHp: number;
+    /** The most hit points it can have */
+    maxHealth: number;
+    /** Mana it has now */
     mana: number;
+    /** The most mana it can have */
     maxMana: number;
     /** Does nothing by itself until something wakes it, and is drawn sleeping: creeps at night */
     asleep: boolean;
@@ -354,18 +574,36 @@ export declare class Entity {
     spatialStamp: number;
     /** Stats as last worked out, see `statsOf`. Derived from the rest, never saved or sent */
     statsCache: StatsCache | null;
-    /** The index of the world it is in, told when it gets or loses a component. Not game state */
+    /**
+     * The index of the world it is in (`EntityIndex`), told when it gets or loses a component, and the way to its world
+     * (`order`). Not game state
+     */
     index: {
         componentChanged(entity: Entity, id: string, has: boolean): void;
     } | null;
-    constructor(id: EntityId, 
+    constructor(
+    /** The entity's number, unique in its world */
+    id: EntityId, 
     /** Changes when a building is upgraded into another type */
-    def: UnitTypeDef, owner: PlayerId, position: Vec2);
+    def: UnitTypeDef, 
+    /** The player it belongs to, changed through `World.setOwner` only */
+    owner: PlayerId, position: Vec2);
+    /**
+     * Gives it an order, as its owner would: `unit.order('move', point)`, `unit.order('attack', enemy)`,
+     * `unit.order('cast', { ability: 'blink', point })`. What it is aimed at is a point (`point`), an entity (`target`)
+     * or the order's fields (`OrderInits`). It is the `order` command of its owner through its world (`World.issue`):
+     * taken up at the next tick, turned away as a player's would be (an order its type does not take, a target its owner
+     * does not know), and kept by a replay. `queue` puts it after what it was told before. Throws for an entity that is
+     * in no world (taken out of it)
+     */
+    order<Type extends string>(type: Type, aim?: Vec2 | Entity | Omit<OrderInit<Type>, 'type'>, options?: OrderOptions): void;
     /** A component of a game module or a mod, see `defineComponent` */
     get<T>(key: Component<T, unknown>): T | undefined;
+    /** Whether it holds the component */
     has(key: Component<unknown>): boolean;
     /** Gives it the component, or a new value of it. `undefined` takes it away (`remove`) */
     set<T>(key: Component<T, unknown>, value: T): void;
+    /** Takes the component away; nothing happens when it has none */
     remove(key: Component<unknown>): void;
     /** Its components, in the order it was given them: each one's value is `get(component)` */
     heldComponents(): readonly Component<unknown, unknown>[];
@@ -374,17 +612,26 @@ export declare class Entity {
      * by id now and then (a save, the inspector). What does it often goes through `heldComponents`
      */
     get components(): Readonly<Record<string, unknown>>;
+    /** Whether its type is a building */
     get isBuilding(): boolean;
+    /** Whether its type is a unit */
     get isUnit(): boolean;
+    /** Whether its type is a resource */
     get isResource(): boolean;
     /** Up in the air, where the ground and what stands on it are not in the way */
     get flying(): boolean;
+    /** Whether its type is a building or a resource: anything but a unit */
     get isStructure(): boolean;
     /** Completed and able to do its job */
     get operational(): boolean;
+    /** The order it carries out now, the first of its orders; nothing when it has none */
     get currentOrder(): Order | undefined;
-    /** Ground area covered by a structure */
+    /** Ground area covered by a structure: a new rect each time, for who keeps it (an obstacle, a wall's reshape) */
     get rect(): Rect;
+    /** Half of what it covers across (`rect.hw`), with no rect made: what is asked all the time (is a structure in sight) */
+    get halfWidth(): number;
+    /** Half of what it covers from front to back (`rect.hd`), as `halfWidth` */
+    get halfDepth(): number;
 }
 /**
  * Anything with a place and a size: an entity, or what a client knows of one
@@ -392,7 +639,9 @@ export declare class Entity {
  * @beta
  */
 export interface Placed {
+    /** Where it stands in cells */
     pos: Vec2;
+    /** The definition of its type */
     def: UnitTypeDef;
 }
 /**