@v12-engine/engine 0.0.0-stage → 0.1.0

package/dist/stances.d.ts

@@ -0,0 +1,76 @@
+import type { GamePack } from './packs/pack';
+import { type Entity } from './entity';
+/**
+ * A stance: how a unit without orders takes to the enemies around it
+ *
+ * @beta
+ */
+export interface StanceDef {
+    id: string;
+    name: string;
+    description?: string;
+    /** The key on the command card, for the HUD's buttons (`stanceButtons` of the client) */
+    hotkey?: string;
+    /** What it attacks of its own accord: anything in its acquisition range, only what its attack reaches, or nothing */
+    acquire: 'any' | 'near' | 'none';
+    /** Whether it chases what it fights past the reach of its attack */
+    pursue: boolean;
+    /** Whether it fights back whoever hits it, for a stance that acquires nothing */
+    fireBack: boolean;
+    /** Where it goes once a fight is over: back where it stood, or nowhere */
+    returnTo: 'post' | 'none';
+}
+/**
+ * The four stances every RTS has: aggressive (the engine's own way, when no stance is set), defensive, hold fire and no
+ * attack. A game gives `withStances` its own list in their place, or adds to these
+ *
+ * @beta
+ */
+export declare const STANCES: readonly StanceDef[];
+/**
+ * The stance of a unit that was given none: the engine's own way
+ *
+ * @beta
+ */
+export declare const DEFAULT_STANCE = "aggressive";
+/**
+ * The stance a unit is in, by its id; absent for one in the default stance. Told to its owner, so that the HUD shows it
+ *
+ * @beta
+ */
+export declare const stance: import("./components").Component<string, string>;
+/**
+ * The stance of a unit, as a definition: the one its component names, else the default (the first of `stances` with
+ * the default's id, else the first of them)
+ *
+ * @beta
+ */
+export declare function stanceOf(entity: Entity, stances?: readonly StanceDef[]): StanceDef;
+/**
+ * Puts units of the player's in a stance (`{ entities, stance }`). Units of another's, and ids of nothing, are left
+ * out. A stance the game has not got is kept as a word and behaves as the default: the hooks know the game's list
+ *
+ * @beta
+ */
+export declare const stanceCommand: import("#engine/commands").DefinedCommand<"stance", {
+    entities: import("./fields").Check<number[]>;
+    stance: import("./fields").Check<string>;
+}>;
+/**
+ * What a game turns stances on with (`withStances`)
+ *
+ * @beta
+ */
+export interface StancesOptions {
+    /** The stances of this game, in the order the HUD shows them: the usual four (`STANCES`) when left out */
+    stances?: readonly StanceDef[];
+}
+/**
+ * A game whose units have stances: the component, the command, and the engine's acquisition read through hooks. In
+ * the default stance nothing changes. Defensive units fire at what their attack reaches and let go of what steps out
+ * of it, returning to where they stood (the engine's own way home); hold fire fires back at the last to hit it; no
+ * attack leaves everyone alone. A unit given an attack order fights whatever its stance
+ *
+ * @beta
+ */
+export declare function withStances(options?: StancesOptions): GamePack;

package/dist/start.d.ts

@@ -0,0 +1,71 @@
+import type { PlayerId } from './entity';
+import { type Vec2 } from './math';
+import type { World } from './world';
+/**
+ * A start in code: puts down a base at the start location, whatever it likes
+ *
+ * @beta
+ */
+export interface StartCode {
+    /** Puts down a base at the start location. Only for players the map places nothing for */
+    spawn(world: World, player: PlayerId, at: Vec2): void;
+}
+/**
+ * A start as data: a hall at the start location and workers on the side of the closest gold mine, as in a classic melee
+ * game (`startingBase` puts it down). Every id is a unit type of the game's (`checkRaces` says where one is not)
+ *
+ * @beta
+ */
+export interface StartData {
+    /** The unit type put down at the start location: a town hall */
+    hall: string;
+    /** The workers put down beside it, facing the closest gold mine */
+    workers: {
+        type: string;
+        count: number;
+    };
+    /** What else is put down with the workers, in the same row after them: a race's first fighter */
+    units?: {
+        type: string;
+        count: number;
+    }[];
+    /**
+     * What the race builds on the closest gold mine to gather it, put down there already standing (the undead's cursed
+     * mine). With it, the closest mine is found at any distance; without, the workers face a mine within 20 cells
+     */
+    onMine?: string;
+    /** How far from the hall the workers stand: 5 cells when left out */
+    distance?: number;
+    /** The angle between two workers in the row, in radians: 0.35 when left out */
+    spread?: number;
+}
+/**
+ * What each player gets at the beginning of a game on a map, for players the map places nothing for: as data
+ * (`StartData`: a hall, workers and what else by unit type, editable in the Data panel) or as code (`StartCode`). What
+ * they start with of each resource is in its `ResourceDef`
+ *
+ * @beta
+ */
+export type StartDef = StartCode | StartData;
+/** Whether a start is the data form */
+export declare const isStartData: (start: StartDef) => start is StartData;
+/**
+ * Puts down what a start as data says (`StartData`): the hall at the point, what the race builds on the closest gold
+ * mine (`onMine`) on it, and the workers and the other units in a row on the side of the hall that faces the mine,
+ * facing it. With no mine in reach, the row faces north. A classic melee start; a race's `start` as data does this
+ *
+ * @beta
+ */
+export declare function startingBase(world: World, player: PlayerId, at: Vec2, start: StartData): void;
+/**
+ * Puts down a player's start at a point, whichever form it is in: the code's `spawn`, or the base the data describes
+ * (`startingBase`). Nothing for no start
+ *
+ * @beta
+ */
+export declare function spawnStart(world: World, start: StartDef | undefined, player: PlayerId, at: Vec2): void;
+/** The unit type ids a start as data names, each with where it is said (`start.hall`, `start.units[1].type`); none for code */
+export declare function startIds(start: StartDef | undefined): {
+    where: string;
+    id: string;
+}[];

package/dist/stats.d.ts

@@ -0,0 +1,122 @@
+import { type DamageType, type StatChange, type StatKey, type Stats } from './defs';
+import type { Entity } from './entity';
+import type { World } from './world';
+/**
+ * What adds up a unit's stats in the sum: what a stat source is handed (`StatPart.add`)
+ *
+ * @beta
+ */
+export interface StatSum {
+    /** Adds a change to the stats, `times` over (1 when left out) */
+    add(change: StatChange, times?: number): void;
+    /** What a stat comes to so far: all that was added to it, by the parts it was made bigger or smaller by */
+    get(stat: StatKey): number;
+}
+/**
+ * A part of the stats a pack adds (`GamePack.stats`): a hero's growth by its level, in the heroes pack. `stamp` is a
+ * number that changes whenever what it adds does, and is 0 when it adds nothing: the stats are added up again when it
+ * changes, however it changed (a game that sets a hero's level itself says nothing, and need not)
+ *
+ * @beta
+ */
+export interface StatPart {
+    readonly id: string;
+    stamp(entity: Entity): number;
+    add(world: World, entity: Entity, sum: StatSum): void;
+    /**
+     * What it makes of the stats once everything else is added (research, the packs' parts, items, buffs, the `stats`
+     * hook), read with `sum.get`: a hero's strength into health, in the attributes pack (`withAttributes`)
+     */
+    derive?(world: World, entity: Entity, sum: StatSum): void;
+}
+/**
+ * Says the stats of an entity, or of every entity when none is said, are to be added up again the next time they are
+ * asked for: what a `stats` hook or a buff's `change` reads changed (an ally came near, a flag of the game's). What
+ * the engine knows about (buffs, items, levels, research, the time of day) it notices by itself
+ *
+ * @beta
+ */
+export declare function invalidateStats(world: World, entity?: Entity): void;
+/**
+ * The stats of an entity the last time they were worked out, and everything they were worked out from.
+ *
+ * Stats are asked for all the time: on every hit (for both sides), every target search, every fog update.
+ * Adding them up means going through the owner's research, what the unit carries and every buff on it,
+ * and allocates. Checking whether any of that changed is a handful of comparisons and allocates nothing,
+ * so `statsOf` does that first and only adds up again when something did.
+ *
+ * The inputs are compared, rather than the cache being thrown away wherever they change, so that nothing
+ * can change a buff or an item and forget to say so: game modules and mods change them directly.
+ *
+ * Not game state: it can be dropped at any time (and is never saved or sent), it is rebuilt on the next ask.
+ */
+export interface StatsCache {
+    stats: Readonly<Stats>;
+    /** `changedStats` of `stats`, once someone asked. The same object for as long as the stats stay the same */
+    changed?: Partial<Stats>;
+    changedFor?: Readonly<Stats>;
+    def: Entity['def'];
+    night: boolean;
+    owner: number;
+    /** What each of the packs' stat sources stamped it with (`StatPart.stamp`), in their order */
+    stamps: number[];
+    upgradesVersion: number;
+    /** `World.statsVersion` when it was worked out: `invalidateStats` for every entity moves it on */
+    statsVersion: number;
+    /** Ids of what it carries, in slot order, empty slots left out */
+    items: string[];
+    /** Id, level and stacks of every buff, in order */
+    buffIds: string[];
+    buffLevels: number[];
+    buffStacks: number[];
+}
+/**
+ * The stats of an entity as they are right now: what its type starts with at this time of day, and on top of that
+ * its levels, the research of its owner, what it carries and the buffs on it.
+ *
+ * The result is shared and must not be changed. It stays the same object for as long as the stats stay the same.
+ *
+ * @beta
+ */
+export declare function statsOf(world: World, entity: Entity): Readonly<Stats>;
+/**
+ * Brings the most health and mana an entity can have in line with its stats.
+ * What is gained is added to what it has, what is lost is only taken when it has more than it can hold.
+ *
+ * @beta
+ */
+export declare function refreshVitals(world: World, entity: Entity): void;
+/**
+ * What is left of damage once the armor or the magic resist of the target had its say, as a part of it: 100 of it
+ * halve what arrives, and below 0 it adds. The engine's formula: the game's is `world.rules.combat.mitigation`, which
+ * is this unless the game says (penetration: `withMobaStats`)
+ *
+ * @beta
+ */
+export declare function mitigation(type: DamageType, target: Readonly<Stats>): number;
+/**
+ * How long an attack of the entity takes: from the start of the swing to the hit, and from one swing to the next. Of
+ * its first attack, or the one at that place (`UnitTypeDef.attacks`), by the speed stat it reads (`AttackDef.stats`)
+ *
+ * @beta
+ */
+export declare function attackTiming(world: World, entity: Entity, weapon?: number): {
+    swing: number;
+    period: number;
+};
+/**
+ * Seconds an ability of the entity takes to be ready again
+ *
+ * @beta
+ */
+export declare function cooldownOf(world: World, entity: Entity, seconds: number): number;
+/**
+ * How long an attack takes, from the start of the swing to the hit, and from one swing to the next, for a unit
+ * whose type attacks `base` times a second and that now attacks `speed` times. Undefined for what does not attack
+ *
+ * @beta
+ */
+export declare function swingTiming(damagePoint: number, base: number, speed: number): {
+    swing: number;
+    period: number;
+} | undefined;

package/dist/summons.d.ts

@@ -0,0 +1,63 @@
+import type { Entity, PlayerId } from './entity';
+import type { Vec2 } from './math';
+import type { World } from './world';
+/**
+ * What is left of a unit that died, for a while (see `corpses`)
+ *
+ * @beta
+ */
+export interface Corpse {
+    /** The id the unit had: the screen keeps its body lying for as long as the corpse is there */
+    id: number;
+    type: string;
+    owner: PlayerId;
+    x: number;
+    z: number;
+    /** When it is gone, in seconds of the game */
+    until: number;
+}
+/**
+ * The corpses of a world. Saved with it
+ *
+ * @beta
+ */
+export declare const corpses: import("./components").Component<Corpse[], Corpse[]>;
+/**
+ * On a unit a spell brought: who brought it. Dispelling hurts what carries it
+ *
+ * @beta
+ */
+export declare const summoned: import("./components").Component<{
+    by: number;
+}, {
+    by: number;
+}>;
+/**
+ * On an illusion: whose copy it is, the part of its damage it deals, and how much more it takes. Told to its side
+ * only: to everyone else it is the real one
+ *
+ * @beta
+ */
+export declare const illusion: import("./components").Component<{
+    of: number;
+    dealt: number;
+    taken: number;
+}, {
+    of: number;
+    dealt: number;
+    taken: number;
+}>;
+/**
+ * Takes up to `most` corpses nearest a point, within `radius`, out of the world, and gives them
+ *
+ * @beta
+ */
+export declare function takeCorpses(world: World, point: Vec2, radius: number, most: number): Corpse[];
+/**
+ * Whether killing an entity gains its killer nothing: an illusion
+ *
+ * @beta
+ */
+export declare const worthless: (entity: Entity) => boolean;
+/** The corpses where the player sees (`Snapshot.corpses`): none to a computer, and left out where there are none */
+export declare const corpsesPart: import("./replication").SnapshotPart<keyof import(".").Snapshot>;

package/dist/systems/abilities.d.ts

@@ -0,0 +1,3 @@
+import type { System } from '#engine/registry';
+/** Everything about abilities that happens on its own: regeneration, cooldowns, buffs running out, auras, autocast */
+export declare const abilitySystem: System;

package/dist/systems/combat.d.ts

@@ -0,0 +1,71 @@
+import { type Entity } from '#engine/entity';
+import { type Vec2 } from '#engine/math';
+import type { System } from '#engine/registry';
+import type { World } from '#engine/world';
+export type EngageResult = 'invalid' | 'attacking' | 'chasing' | 'outOfRange';
+/**
+ * Whether an attacker may attack a target: its attack reaches it, it is an enemy, and the `canAttack` hook agrees.
+ * `ordered`: a player told it to (an attack order), which a game may let it do to its own side (`CanAttack.ordered`)
+ *
+ * @beta
+ */
+export declare function canAttack(world: World, attacker: Entity, target: Entity, ordered?: boolean): boolean;
+/**
+ * Whether one of an attacker's attacks can hit a target where it is, whoever's it is: the ground, the air, the kinds it
+ * names (`pickAttack`). For a `canAttack` handler that lets a unit attack what is not an enemy
+ *
+ * @beta
+ */
+export declare function attackReaches(world: World, attacker: Entity, target: Entity): boolean;
+export declare function canSee(world: World, viewer: Entity, target: Entity): boolean;
+/**
+ * Whether the target stands on higher ground than the attacker. Nothing is uphill from the air
+ *
+ * @beta
+ */
+export declare function shootsUphill(world: World, attacker: Entity, target: Entity): boolean;
+/**
+ * What a search for a target found: the best, and whether it passed over one it would have taken but for leaving it
+ * alone for now (`shun`): what asking again with `shunned` would have found something for, without looking again
+ */
+export interface TargetFound {
+    target: Entity | undefined;
+    passedOver: boolean;
+}
+/**
+ * Best enemy within `range` of the entity (its acquisition range by default), as the `targetScore` hook sees it. Those
+ * it leaves alone for now (`shun`) are not, unless `shunned` says to count them too: to know whether a fight is still on
+ */
+export declare const acquireTarget: (world: World, entity: Entity, range?: number, shunned?: boolean) => Entity | undefined;
+/**
+ * Best enemy it can hit from where it stands: within the range of the attack it would use against each (`pickAttack`),
+ * and `slack` more. For one that holds its ground
+ *
+ * @beta
+ */
+export declare function acquireInRange(world: World, entity: Entity, slack?: number): Entity | undefined;
+/**
+ * `acquireTarget`, and whether it passed over a target it leaves alone for now (`TargetFound`). What it gives back is
+ * the search's own, used again by the next search: read it at once
+ */
+export declare function searchTarget(world: World, entity: Entity, range?: number, shunned?: boolean, inRange?: number): Readonly<TargetFound>;
+export declare function cancelSwing(entity: Entity): void;
+export type BombardResult = 'attacking' | 'outOfRange';
+/** One tick of attacking a spot on the ground, for attacks that can. Getting into range is up to the caller */
+export declare function bombard(world: World, entity: Entity, point: Vec2, dt: number): BombardResult;
+/**
+ * Drives one tick of fighting a target: close the distance, turn, swing, hit.
+ * Every order that fights (attack, attack-move, hold, idle auto-attack) goes through here.
+ */
+export declare function engage(world: World, entity: Entity, target: Entity | undefined, dt: number, chase: boolean, ordered?: boolean): EngageResult;
+/**
+ * One tick of an attack that fires as the unit walks (`AttackDef.onTheMove`): what it shot at last tick while it can
+ * still be hit from where the unit is, else the best in range (looked for every fourth tick), swung at without a stop
+ * or a turn. Gives back what it is shooting at, none for nothing
+ *
+ * @beta
+ */
+export declare function fireOnTheMove(world: World, entity: Entity, current: number | undefined, dt: number): number | undefined;
+/** Stops fighting: aborts the swing and lets the unit be pushed around again. */
+export declare function disengage(world: World, entity: Entity): void;
+export declare const combatSystem: System;

package/dist/systems/combatTold.d.ts

@@ -0,0 +1,14 @@
+/**
+ * What players are told of fights (the combat system's events): a swing, a shot landing, a miss, a blast. Beside the
+ * combat system, which emits them
+ */
+/** A swing, to those who see the attacker */
+export declare const toldAttack: import("..").ReplicatedEvent;
+/** A shot landing: to its side, and to those who see where */
+export declare const toldShot: import("..").ReplicatedEvent;
+/** A miss, to those who see who missed or who was missed */
+export declare const toldMiss: import("..").ReplicatedEvent;
+/** A blast: to its side, and to those who see where */
+export declare const toldImpact: import("..").ReplicatedEvent;
+/** The projectiles in flight the player is told of: their side's, and those where they see (`Snapshot.projectiles`); none to a computer */
+export declare const projectilesPart: import("..").SnapshotPart<keyof import("..").Snapshot>;

package/dist/systems/construction.d.ts

@@ -0,0 +1,34 @@
+import type { ConstructionState, Entity } from '#engine/entity';
+import type { EntityState } from '#engine/session/protocol';
+import type { System } from '#engine/registry';
+/** Whether two parts done of a whole say the same to a screen: to a hundredth, what a bar shows and the wire sends */
+export declare const sameHundredth: (a: number, b: number) => boolean;
+/**
+ * A structure being built: how far it is, how long it takes, who works on it (`UnitTypeDef.construction`). Set as a
+ * site is put down (`SpawnOptions.underConstruction`), taken off once it stands; a structure's only (a unit given it is
+ * not seen as one). Everyone who sees it is told how far it is (0..1)
+ *
+ * @beta
+ */
+export declare const constructionSite: import("#engine/components").Component<ConstructionState, number>;
+/**
+ * What a structure being built has done and needs: none once it stands, or for what was put down whole (`constructionSite`)
+ *
+ * @beta
+ */
+export declare const underConstruction: (entity: Entity) => ConstructionState | undefined;
+/**
+ * How far a structure in a snapshot is built, 0..1: undefined for one that stands (a screen's, a computer player's view)
+ *
+ * @beta
+ */
+export declare const builtSoFar: (state: EntityState) => number | undefined;
+export declare const constructionSystem: System;
+/** A structure begun, to those who see it: with how long it takes */
+export declare const toldConstructionStarted: import("..").ReplicatedEvent;
+/** A structure finished, to those who see it */
+export declare const toldBuilt: import("..").ReplicatedEvent;
+/** A structure called off while being built, to those who see it */
+export declare const toldConstructionCancelled: import("..").ReplicatedEvent;
+/** A blow of a builder's hammer, to those who see the builder */
+export declare const toldWork: import("..").ReplicatedEvent;

package/dist/systems/economy.d.ts

@@ -0,0 +1,21 @@
+import type { System } from '#engine/registry';
+import type { SessionView } from '../replication';
+import type { MineInfo } from '../session/protocol';
+/**
+ * Keeps every player's supply in sync with what they own and have queued: what their units take (`GameRules.supply.of`,
+ * those in a queue too) against what their finished buildings provide, changed by the game's `supplyCap` hook and held
+ * under the game's most. The same for each of the game's other pools (`GameRules.supply.pools`), from the types' `supplies`
+ * and `suppliesProvided`
+ */
+export declare const supplySystem: System;
+/** A tree chopped, to those who see the worker and the tree */
+export declare const toldChop: import("..").ReplicatedEvent;
+/** What an entity carries or holds of a resource changed: its side's alone */
+export declare const toldResource: import("..").ReplicatedEvent;
+/**
+ * Where the game's money is mined, as the map shows it, seen or not (`GameSession.mines`). Worked out once a tick: a
+ * walk of every entity, which twelve computers would each take a think. The same list every time within a tick, to read
+ *
+ * @beta
+ */
+export declare function minesFor(view: SessionView): readonly MineInfo[];

package/dist/systems/fog.d.ts

@@ -0,0 +1,19 @@
+import type { Entity } from '#engine/entity';
+import type { System } from '#engine/registry';
+/**
+ * Lets a team see the entity for a while, for having attacked it: from the dark, from high ground, from anywhere
+ *
+ * @beta
+ */
+export declare function expose(entity: Entity, team: number): void;
+/**
+ * Works out what every team sees, every few ticks: clears the `visible` grids and lights a circle around
+ * everything that looks around (units and buildings by their sight, reveal spells, scouting missiles,
+ * invisible units that were found, attackers that gave themselves away).
+ */
+export declare const fogSystem: System;
+/**
+ * What the player is told of the spots revealed (`Snapshot.reveals`): their team's own, and another's only where they see:
+ * where an enemy's spell looks is the enemy's to know. A quiet one shows what it shows, and is nothing to draw; none to a computer
+ */
+export declare const revealsPart: import("..").SnapshotPart<keyof import("..").Snapshot>;

package/dist/systems/life.d.ts

@@ -0,0 +1,3 @@
+import type { System } from '#engine/registry';
+/** Counts down what only lasts a while: things that are gone after some time, invisibility setting in, being found, spots that are revealed */
+export declare const lifeSystem: System;

package/dist/systems/movement.d.ts

@@ -0,0 +1,105 @@
+import { type Entity } from '#engine/entity';
+import { type Vec2 } from '#engine/math';
+import type { AgentState } from '#engine/navigation/navigation';
+import type { System } from '#engine/registry';
+import type { World } from '#engine/world';
+/** @beta */
+export interface MoveOptions {
+    /** Arrive once this close to the goal. `ARRIVE_RANGE` when left out */
+    range?: number;
+    groupId?: number;
+    /** Direction to turn to after arriving */
+    facing?: number;
+    /**
+     * A step aside for another (`stepAside`), or any short move that is nobody's business: the unit goes round nobody
+     * and asks nobody to make way on it, so that one step does not set off the next
+     */
+    aside?: boolean;
+}
+/**
+ * Point a unit should walk to in order to reach the target: next to its edge for structures, its spot around it for
+ * one fighting it (see `engagement.ts`)
+ */
+export declare function approachPoint(world: World, entity: Entity, target: Entity): Vec2;
+/** Sends a walking unit on as it was, after something held it (a builder waiting for room): its stretch, or its goal */
+export declare function walkOn(world: World, entity: Entity): void;
+/**
+ * Sends a unit walking to a point, the way around what is in the way. How it goes is in `entity.movement.status`:
+ * `moving` on the way, `arrived` once there, `failed` when there is no way there or it got stuck. An order calls
+ * this once and then watches the status; calling it again with the same goal starts the walk over
+ *
+ * @beta
+ */
+export declare function moveTo(world: World, entity: Entity, goal: Vec2, options?: MoveOptions): void;
+/**
+ * Walks towards an entity until within `range` of its edge. Safe to call every tick.
+ *
+ * @beta
+ */
+export declare function moveToEntity(world: World, entity: Entity, target: Entity, range: number): void;
+/**
+ * Stops a unit where it is. Its status is `idle` after
+ *
+ * @beta
+ */
+export declare function halt(world: World, entity: Entity): void;
+/**
+ * Anchored units stand their ground instead of being pushed around by units walking past.
+ *
+ * @beta
+ */
+export declare function setAnchored(world: World, entity: Entity, anchored: boolean): void;
+/**
+ * Ghosts walk through other units. Classic RTS games do this for workers hauling resources so mining never jams.
+ *
+ * @beta
+ */
+export declare function setGhost(world: World, entity: Entity, ghost: boolean): void;
+/**
+ * Turns a unit a little towards a point, as far as it turns in `dt` seconds. For orders that aim at something
+ *
+ * @beta
+ */
+export declare function faceTowards(entity: Entity, point: Vec2, dt: number): void;
+/**
+ * Whether another unit stands in a mover's way: there, standing still, and on the same crowd, where each steers
+ * round the other and neither walks through. What moves is steered round by the navigation; what is a ghost is walked
+ * through; what flies, sails or is of another size goes its own way. What the mover walks to, or stands where it is
+ * going, is not in its way either: it stops by it, close enough (a follower by the one it follows, a unit sent where
+ * another stands), rather than send it off
+ *
+ * @beta
+ */
+export declare function standsInWay(world: World, mover: Entity, other: Entity): boolean;
+/**
+ * Asks an ally standing in a unit's way to step aside, as the rules allow (`GameRules.movement.makesWay`, the `makeWay` hook).
+ * `direction` is the way the unit is heading, a unit long; `agent` where its path goes, for the step to be off it.
+ * True when it goes
+ *
+ * @beta
+ */
+export declare function stepAside(world: World, mover: Entity, other: Entity, direction: Vec2, agent: AgentState): boolean;
+/**
+ * Asks friendly units that are standing around in front of a unit to step aside.
+ * Avoidance alone cannot get a unit out of a tight group of idle ones: they would have to move, and nothing tells them to.
+ *
+ * @beta
+ */
+export declare function makeWay(world: World, entity: Entity): void;
+/**
+ * Looks ahead of a unit on its way for units standing in it (within `GameRules.movement.lookAhead`): a way round the knot
+ * they make is taken where it is not much longer (`GameRules.movement.goesAround`, the `detour` hook); otherwise those of
+ * them that make way (`GameRules.movement.makesWay`) are asked to step aside before the unit reaches them. The way round is
+ * beside the knot, on the side it sticks out less, at the knot's middle; the unit heads there, and on to its path
+ * from there. The number of units sent to this per tick is spread by their ids (`LOOK_AHEAD_INTERVAL`)
+ *
+ * @beta
+ */
+export declare function lookAhead(world: World, entity: Entity, agent: AgentState): void;
+/**
+ * Over how many ticks the chasers look for new paths after the navigation changed: an eighth of them each tick
+ *
+ * @beta
+ */
+export declare const REPATH_SPREAD = 8;
+export declare const movementSystem: System;

package/dist/systems/orders.d.ts

@@ -0,0 +1,7 @@
+import type { Entity, Order } from '#engine/entity';
+import type { System } from '#engine/registry';
+import type { World } from '#engine/world';
+/** Runs the order at the front of every queue */
+export declare const orderSystem: System;
+/** One tick of an order: started when it has not been, and taken off the queue when it is over */
+export declare function runOrder(world: World, entity: Entity, order: Order, dt: number): void;