@v12-engine/engine 0.0.0-stage → 0.1.1

package/dist/generate.d.ts

@@ -0,0 +1,403 @@
+import { Rng } from './rng';
+import { type GameMap, type MapCamp, type MapDoodad, type MapObject, type MapPlayer, type MapRegion } from './map';
+import type { MapProblem } from './mapFields';
+import type { Vec2 } from './math';
+import type { AreaShape } from './areas';
+import type { PlayerId } from './entity';
+import type { Registry } from './registry';
+/**
+ * How a map is mirrored, so that it is fair: not at all, across x, across z, both ways, a half turn about the middle,
+ * or quarter turns (a square map, its sides even). As the editor's symmetry says it
+ *
+ * @beta
+ */
+export type MapSymmetry = 'none' | 'x' | 'z' | 'both' | 'half' | 'quarter';
+/**
+ * What a map is made with (`generateMap`): the seed, the size, the players, the symmetry, and the game's own
+ * parameters (`MapGenerator.params`), each at its default where not said
+ *
+ * @beta
+ */
+export interface GeneratorOptions {
+    seed: number;
+    width: number;
+    depth: number;
+    players: number;
+    symmetry?: MapSymmetry;
+    /** The map's name: "Generated <seed>" when left out */
+    name?: string;
+    /** The game's own parameters, by id, as the dialog's sliders and switches set them */
+    params?: Record<string, number | string | boolean>;
+}
+/**
+ * A parameter of a generator (`MapGenerator.params`): a slider, a switch or a choice in the editor's dialog and the
+ * page's form, and a value in code (`GeneratorOptions.params`)
+ *
+ * @beta
+ */
+export interface GeneratorParamDef {
+    id: string;
+    name: string;
+    description?: string;
+    /** A number on a slider (the default), a switch, or one of `choices` */
+    kind?: 'number' | 'boolean' | 'choice';
+    default: number | string | boolean;
+    min?: number;
+    max?: number;
+    step?: number;
+    choices?: {
+        value: string;
+        label: string;
+    }[];
+}
+/**
+ * What was put down by a pass, for the passes after to avoid or use (`GeneratorContext.placed`)
+ *
+ * @beta
+ */
+export interface GeneratorMark {
+    kind: string;
+    x: number;
+    z: number;
+    radius: number;
+}
+/**
+ * What a pass works with (`GeneratorPass.run`): the map as the passes before left it, the seed's numbers, noise that
+ * repeats across the map, the symmetry, and what to put down with
+ *
+ * @beta
+ */
+export interface GeneratorContext {
+    map: GameMap;
+    /** The seed's numbers: every draw of a pass is one of these, so the same seed makes the same map */
+    rng: Rng;
+    options: GeneratorOptions;
+    registry: Registry;
+    /** A parameter as it is: what the options say, or its default (`MapGenerator.params`), or `fallback` where neither says */
+    param<T extends number | string | boolean>(id: string, fallback: T): T;
+    /**
+     * A place, and the places the symmetry mirrors or turns it to (the first is the place itself): what is put down at
+     * one is put down at the others, so the map is fair
+     */
+    symmetric(x: number, z: number): Vec2[];
+    /** Whether a cell is the first of its mirrored set: what is done once a set is done at this one, and mirrored from it */
+    canonical(cx: number, cz: number): boolean;
+    /**
+     * What `draw` makes, made once for a place and the places the symmetry mirrors it to: the first call of a set draws
+     * (and spends the seed's numbers), the calls for its mirrors get the same. For a choice put down at every mirror
+     * (a camp's creeps), so the map stays fair
+     */
+    once<T>(x: number, z: number, draw: () => T): T;
+    /**
+     * Noise that repeats across the map, by a name (the same name is the same noise), 0..1 at a point of the map in
+     * cells; `cells` are the sizes of its features, coarsest first (`[32, 16, 8]` for hills). Mirrored as the map is
+     */
+    noise(name: string, cells?: readonly number[]): (x: number, z: number) => number;
+    /** What the passes before put down, by kind */
+    placed: GeneratorMark[];
+    /** Puts a mark down for the passes after: nothing on the map, only in `placed` */
+    mark(kind: string, x: number, z: number, radius: number): void;
+    /** Whether nothing marked is within `radius` of a place (of `kinds` alone, when said) */
+    free(x: number, z: number, radius: number, kinds?: readonly string[]): boolean;
+    /** The level of the ground at a point: its cell's cliff level */
+    levelAt(x: number, z: number): number;
+    /** Whether a point is on the map and on ground something walks: no deep water, not off the map */
+    walkable(x: number, z: number): boolean;
+    /** Scenery put down, with an id of its own: the model by its path in `models/`, as big as it says, turned as it says */
+    addDoodad(doodad: Omit<MapDoodad, 'id' | 'scale' | 'yaw'> & {
+        scale?: number | [number, number, number];
+        yaw?: number;
+    }): MapDoodad;
+    /** A unit or a building of a type put down, with an id of its own, for a player (`MAP_NEUTRAL`, `MAP_CREEPS`, or one of the map's) */
+    addObject(type: string, owner: PlayerId, x: number, z: number, more?: Partial<Omit<MapObject, 'id' | 'type' | 'owner' | 'x' | 'z'>>): MapObject;
+    /** Creeps that guard a spot, with an id of their own */
+    addCamp(x: number, z: number, units: string[], more?: Partial<Omit<MapCamp, 'id' | 'x' | 'z' | 'units'>>): MapCamp;
+    /** A region the rules watch by name, with an id of its own */
+    addRegion(name: string, shape: AreaShape, more?: Partial<Omit<MapRegion, 'id' | 'name' | 'shape'>>): MapRegion;
+}
+/**
+ * A pass of a generator: one thing done to the map, in its turn (`MapGenerator.passes`)
+ *
+ * @beta
+ */
+export interface GeneratorPass {
+    id: string;
+    name: string;
+    run(ctx: GeneratorContext): void;
+}
+/**
+ * A game's generator (`GameModule.generator`): its parameters, as the dialog and the page show them, and its passes
+ * in order. `generateMap` runs it
+ *
+ * @beta
+ */
+export interface MapGenerator {
+    params: GeneratorParamDef[];
+    passes: GeneratorPass[];
+    /**
+     * How many seeds are tried where the map comes out with a problem that keeps it from being played (an error, a start
+     * cut off from the others or blocked): 4 when left out
+     */
+    tries?: number;
+}
+/**
+ * How a map was made, kept with it (`GameMap.generated`): the same again from the same
+ *
+ * @beta
+ */
+export interface GeneratedWith {
+    seed: number;
+    options: GeneratorOptions;
+}
+/**
+ * The map a generator makes of options: its passes run in order on a map of the size and players asked, with the
+ * game's tiles; then checked (`checkMap`). A map with a problem that keeps it from being played (a start cut off from
+ * the others, or where nothing walks) is thrown away and the next seed tried, `tries` times; the last is given with
+ * its problems. The map says how it was made (`GameMap.generated`)
+ *
+ * @beta
+ */
+export declare function generateMap(generator: MapGenerator, options: GeneratorOptions, registry: Registry): {
+    map: GameMap;
+    problems: MapProblem[];
+    seed: number;
+};
+/**
+ * The places a point is mirrored or turned to, the point first (as the editor's `mirrors`)
+ *
+ * @beta
+ */
+export declare function symmetricPlaces(symmetry: MapSymmetry, width: number, depth: number, x: number, z: number): Vec2[];
+/**
+ * What `terrainPass` takes: the parameters of the generator it reads where they are not given here
+ *
+ * @beta
+ */
+export interface TerrainPassOptions {
+    /** How many cliff levels the ground rises through, 1 (flat) to 4: the parameter `levels`, or 2 */
+    levels?: number;
+    /** How much of the map is under water, 0..1: the parameter `water`, or 0.15 */
+    water?: number;
+    /** How much the ground rolls within a level, 0..1: the parameter `roughness`, or 0.4 */
+    roughness?: number;
+    /** How many cells a hill is across, about: the parameter `hills`, or 24 */
+    hills?: number;
+    /** Whether ramps are cut so that every part of the ground can be walked to: yes when left out */
+    ramps?: boolean;
+    /** How wide a ramp is, in cells: 3 when left out */
+    rampWidth?: number;
+    /**
+     * The lie of the land, where it is not the noise's alone: the ground's value at a point (high is high), made from the
+     * point, the plateau noise there (0..1) and the map; the levels and the water are cut from the values as ever (the
+     * lowest share water). A bay (`basinShape`: the corners high, a sea in the middle, an island in it), a valley, a
+     * ridge: a shape of the game's own
+     */
+    shape?: (x: number, z: number, noise: number, map: GameMap) => number;
+}
+/**
+ * What `basinShape` takes
+ *
+ * @beta
+ */
+export interface BasinShapeOptions {
+    /** How big the island in the middle is, 0..1 of the way to the corners: 0.14 when left out, 0 for no island */
+    island?: number;
+    /** How much the noise moves the shore and the island about, 0..1: 0.25 when left out */
+    roughness?: number;
+    /**
+     * How high the island rises, in the shape's values (the corners are at 1, the middle of the sea at 0): 0.4 when
+     * left out, which with `water` at 0.2 and three levels lands it on the lowest dry level, the beach's, so that fords
+     * of shallow water reach it with no cliff between
+     */
+    height?: number;
+}
+/**
+ * The lie of a bay, for `terrainPass`'s `shape`: the corners high, the ground falling to a sea in the middle, an
+ * island in it. With `water` at 0.25–0.35 the sea takes the middle and the shore runs round it; the starts in the
+ * corners (`startsPass` with a spread of 0.4), the way between them along the shore
+ *
+ * @beta
+ */
+export declare function basinShape(options?: BasinShapeOptions): NonNullable<TerrainPassOptions['shape']>;
+/**
+ * The ground: a height field of noise, mirrored as the map is, quantised into cliff levels with the ground rolling
+ * within each, water in the low ground, and ramps cut between the levels so that every part can be walked to
+ *
+ * @beta
+ */
+export declare function terrainPass(options?: TerrainPassOptions): GeneratorPass;
+/**
+ * What `tilesPass` takes: how a cell is painted, from what the ground is there
+ *
+ * @beta
+ */
+export interface TilesPassOptions {
+    /**
+     * The tile a cell is painted with, by id, or nothing for none (the ground's own colours): from its level, the slope
+     * there (radians), how wet it is (a noise, 0..1) and whether it is by the water. The engine's own rule when left
+     * out: `sand` by the water, `rock` on steep ground (the cliffs), `snow` on the top of four levels or more, `dirt`
+     * where it is dry, each where the game has such a tile
+     */
+    by?: (cell: {
+        x: number;
+        z: number;
+        level: number;
+        slope: number;
+        moisture: number;
+        shore: boolean;
+    }, tiles: readonly string[]) => string | undefined;
+}
+/**
+ * The paint: each cell a tile by what the ground is there, through the game's tiles by name
+ *
+ * @beta
+ */
+export declare function tilesPass(options?: TilesPassOptions): GeneratorPass;
+/**
+ * What `startsPass` takes
+ *
+ * @beta
+ */
+export interface StartsPassOptions {
+    /** How many cells around a start are flattened and dried: 6 when left out */
+    clearing?: number;
+    /** How far from the map's middle the starts stand, 0..0.5 of its size: 0.36 when left out */
+    spread?: number;
+    /** What a game puts at a start: its town hall and workers. Nothing when left out */
+    from?: (player: MapPlayer, at: Vec2, ctx: GeneratorContext) => void;
+}
+/**
+ * The starts: as far apart as the symmetry allows (mirrored from one, or around the middle), each on flat, dry ground
+ * (a clearing made for it), the player's `start` set, and what the game puts there
+ *
+ * @beta
+ */
+export declare function startsPass(options?: StartsPassOptions): GeneratorPass;
+/**
+ * The nearest place to one that is not in the water, at a cell's middle: for a pass of a game's own that puts something
+ * down where the ground may be wet
+ *
+ * @beta
+ */
+export declare const nearestDryGround: (ctx: GeneratorContext, at: Vec2, reach: number) => Vec2;
+/**
+ * The ground around a place made flat and dry: one level (the one there, or `level`), no water, no ramps, the ground at
+ * one height eased into what is around; mirrored as the map is, unless `alone`. What a start's clearing and a mine's
+ * are made with, for a pass of a game's own
+ *
+ * @beta
+ */
+export declare const clearGround: (ctx: GeneratorContext, at: Vec2, radius: number, alone?: boolean, level?: number) => void;
+/**
+ * What `scatterPass` takes: how much of what, where
+ *
+ * @beta
+ */
+export interface ScatterPassOptions {
+    /** What the things are, for the passes after (`placed`): `trees`, `rocks` */
+    kind: string;
+    /** Puts one down at a place: a doodad, a unit, a camp, a region */
+    what: (ctx: GeneratorContext, at: Vec2) => void;
+    /** How much of the map they cover, 0..1: the parameter `<kind>` where the generator has one, or 0.12 */
+    density?: number;
+    /** How far apart they are at least, in cells: 1.5 when left out */
+    spacing?: number;
+    /** How big each is, for what comes after to keep off: half the spacing when left out */
+    radius?: number;
+    /** How far from a start they keep, in cells: 10 when left out */
+    avoid?: number;
+    /** What else they keep off, by kind (`placed`), with how far: the starts always */
+    avoidKinds?: Record<string, number>;
+    /** Where they may go: a cell's level, slope, water and the noise of the kind (0..1, patches). On any dry ground when left out */
+    where?: (cell: {
+        x: number;
+        z: number;
+        level: number;
+        slope: number;
+        noise: number;
+        shore: boolean;
+    }) => boolean;
+    /** In patches of a noise (how much the noise decides, 0 even, 1 all in patches): 0.6 when left out */
+    patches?: number;
+}
+/**
+ * Things scattered over the map: as many as the density says, in patches of a noise, at least `spacing` apart, off
+ * the starts and what else they avoid, where they may go; each put down by `what`, mirrored as the map is. Trees now;
+ * rocks, houses, ruins and the rest the same way, with another `what`
+ *
+ * @beta
+ */
+export declare function scatterPass(options: ScatterPassOptions): GeneratorPass;
+/**
+ * What `resourcesPass` takes: where the game's mines go, and what the game puts there
+ *
+ * @beta
+ */
+export interface ResourcesPassOptions {
+    /** How far from each start its own stands, in cells: 8 when left out; `false` for none at the starts (a game puts those down itself) */
+    main?: number | false;
+    /** How many more there are besides the starts', spread over the map and mirrored: 2 when left out */
+    extra?: number;
+    /** How far apart the extra ones keep from each other and from the starts, in cells: 20 when left out */
+    spacing?: number;
+    /**
+     * How many cells around each are made flat and dry for it, as a start's clearing is: 3 when left out, enough for a
+     * mine of 4 by 4; 0 for none
+     */
+    clearing?: number;
+    /** Puts the resource down: the game's mine, a camp guarding it. Told the start it is for, where it is one's */
+    from: (ctx: GeneratorContext, at: Vec2, start?: MapPlayer) => void;
+}
+/**
+ * Resources: one near each start (towards the map's middle, as far as `main` says), and more spread over the map,
+ * mirrored as the map is, each put down by the game
+ *
+ * @beta
+ */
+export declare function resourcesPass(options: ResourcesPassOptions): GeneratorPass;
+/**
+ * What `roadsPass` takes
+ *
+ * @beta
+ */
+export interface RoadsPassOptions {
+    /** The tile the road is painted with, by id */
+    tile: string;
+    /** How wide, in cells: 2 when left out */
+    width?: number;
+    /** Between what: every two starts when left out, or places of the map's own */
+    between?: Vec2[];
+}
+/**
+ * Roads between the starts (or places given), the way something on foot would go (over the level map, by ramps, around
+ * water; the gentlest ground preferred), painted with a tile
+ *
+ * @beta
+ */
+export declare function roadsPass(options: RoadsPassOptions): GeneratorPass;
+/**
+ * What the engine's preset takes from a game: what its scenery is
+ *
+ * @beta
+ */
+export interface PresetGeneratorOptions {
+    /** The models of trees, by their paths in `models/`: one picked for each. No trees when left out */
+    trees?: string[];
+    /** How big a tree is drawn, and how much that varies: 1, by a fifth, when left out */
+    treeScale?: {
+        scale?: number;
+        vary?: number;
+    };
+    /** The models of rocks, the same way. None when left out */
+    rocks?: string[];
+    /** What a game puts at a start (`startsPass`): its hall and workers */
+    start?: StartsPassOptions['from'];
+}
+/**
+ * A generator to take whole: hills and water, the paint, the starts, trees in patches and rocks about, with the
+ * parameters `levels`, `water`, `roughness`, `hills`, `trees` and `rocks`; what the trees and rocks are is the game's
+ * to say
+ *
+ * @beta
+ */
+export declare function presetGenerator(options?: PresetGeneratorOptions): MapGenerator;

package/dist/generateWorker.d.ts

@@ -0,0 +1,39 @@
+import { type GeneratorOptions } from './generate';
+import { type GameModule } from './game';
+import type { GameMap } from './map';
+import type { MapProblem } from './mapFields';
+import type { NavigationPort, NavigationWorkerLike } from './navigation/builds';
+/**
+ * A map a generator made (`generateMap`): the map, what is wrong with it, and the seed it came out of
+ *
+ * @beta
+ */
+export interface GeneratedMap {
+    map: GameMap;
+    problems: MapProblem[];
+    seed: number;
+}
+/**
+ * Makes a map of options somewhere else than this thread (`mapGeneratorWorker`): a menu's preview of a random map that
+ * does not stop the page while it is made
+ *
+ * @beta
+ */
+export type MapGenerating = (options: GeneratorOptions) => Promise<GeneratedMap>;
+/**
+ * What a worker's file of a game's maps does: it makes, with the game's generator (`GameModule.generator`) and its
+ * registry, the map of each set of options it is sent, and sends it back. A worker's file of two lines, the game's rules
+ * imported and this called with them; `port` is where it hears, as for `serveNavigationBuilds`: the worker's own scope
+ * when left out
+ *
+ * @beta
+ */
+export declare function serveMapGenerator(rules: GameModule, port?: NavigationPort): void;
+/**
+ * Maps made in a worker whose file serves them (`serveMapGenerator`): the page makes the worker as its bundler wants it,
+ * `mapGeneratorWorker(() => new Worker(new URL('./generate.worker.ts', import.meta.url), { type: 'module' }))`. Given
+ * as a function, the worker is made at the first map asked for: a menu that is never opened fetches none of it
+ *
+ * @beta
+ */
+export declare function mapGeneratorWorker(given: NavigationWorkerLike | (() => NavigationWorkerLike)): MapGenerating;

package/dist/grid.d.ts

@@ -0,0 +1,53 @@
+import type { Terrain } from './terrain';
+/**
+ * Min cell of a footprint centered as close as possible to the given point
+ *
+ * @beta
+ */
+export declare const footprintCell: (x: number, z: number, w: number, d: number) => {
+    x: number;
+    z: number;
+};
+export interface GridOptions {
+    /** Steepest slope (radians) that can be built on */
+    maxBuildSlope?: number;
+}
+/**
+ * Placement grid. One cell per world unit, tracking where structures stand and
+ * where the ground is flat enough to build.
+ *
+ * @beta
+ */
+export declare class BuildGrid {
+    private readonly terrain;
+    readonly width: number;
+    readonly depth: number;
+    /** Id of the structure occupying each cell, 0 when free */
+    private readonly occupant;
+    private readonly buildable;
+    /** The steepest a cell is built on */
+    private readonly maxBuildSlope;
+    constructor(terrain: Terrain, options?: GridOptions);
+    /**
+     * Works out again where can be built, in a rectangle of cells and the ring about it (a slope is of the vertices about a
+     * cell): after the ground was reshaped there (`World.reshapeGround`). What stands there stays where it is
+     */
+    groundChanged(rect: {
+        x: number;
+        z: number;
+        width: number;
+        depth: number;
+    }): void;
+    inBounds(x: number, z: number): boolean;
+    occupantAt(x: number, z: number): number;
+    isBuildable(x: number, z: number): boolean;
+    isFree(x: number, z: number): boolean;
+    /** Min cell of a footprint centered as close as possible to the given point */
+    cellFor(x: number, z: number, w: number, d: number): {
+        x: number;
+        z: number;
+    };
+    canPlace(cellX: number, cellZ: number, w: number, d: number): boolean;
+    occupy(cellX: number, cellZ: number, w: number, d: number, id: number): void;
+    release(cellX: number, cellZ: number, w: number, d: number, id: number): void;
+}

package/dist/ground.d.ts

@@ -0,0 +1,127 @@
+import { type TerrainSave } from './terrainSave';
+import { Terrain } from './terrain';
+/**
+ * The ground of a save or a welcome: all of it, or the map it started as and what changed of it
+ *
+ * @beta
+ */
+export type SavedGround = TerrainSave | GroundChanges;
+/**
+ * The ground as a map the game has, and the cells of it that changed: in a save and in a welcome
+ *
+ * @beta
+ */
+export interface GroundChanges {
+    /** The map it started as, by its name (`GameMap.name`) and a hash of the ground it makes (`groundHash`) */
+    map: string;
+    hash: string;
+    width: number;
+    depth: number;
+    /** For each layer that changed: which cells (packed as 32-bit numbers), and what each holds now */
+    changes: Partial<Record<GroundLayer, {
+        count: number;
+        at: string;
+        to: string;
+    }>>;
+    /** The same for the game's layers of cells (`Terrain.cells`), by id */
+    cells?: Record<string, {
+        count: number;
+        at: string;
+        to: string;
+    }>;
+    /** The part of the map play happens in, as it is now */
+    bounds?: {
+        x: number;
+        z: number;
+        width: number;
+        depth: number;
+    };
+}
+declare const LAYERS: readonly ['heights', 'levels', 'water', 'waterHeights', 'tiles', 'blocked'];
+/** @beta */
+export type GroundLayer = (typeof LAYERS)[number];
+/**
+ * Whether a save's ground is the changes of a map, not the whole of it
+ *
+ * @beta
+ */
+export declare const isGroundChanges: (ground: SavedGround) => ground is GroundChanges;
+/**
+ * A hash of a ground, every layer of it and its size: two grounds of the same hash are the same ground
+ *
+ * @beta
+ */
+export declare function groundHash(terrain: Terrain): string;
+/**
+ * The ground a world started on, from a map: kept with the world (`World.ground`), not in its save
+ *
+ * @beta
+ */
+export interface GroundBase {
+    map: string;
+    /** A hash of the ground (`groundHash`): worked out the first time it is asked for */
+    readonly hash: string;
+    terrain: Terrain;
+}
+/**
+ * A part of the ground as it is, to put in another of the same size (`applyTerrainPatch`): a rectangle of cells and
+ * every layer of it, the vertices at its corners included. What the editor's Play here sends of the map's ground as it
+ * is edited (`debug.ground`, EQ10), and what a session is told of it (`ground`)
+ *
+ * @beta
+ */
+export interface TerrainPatch {
+    /** The first cell, and how many across and down */
+    x: number;
+    z: number;
+    width: number;
+    depth: number;
+    /** Per vertex, row by row: `(width + 1) * (depth + 1)` of them */
+    heights: number[];
+    waterHeights: number[];
+    /** Per cell, row by row: `width * depth` of them */
+    levels: number[];
+    water: number[];
+    tiles: number[];
+    blocked: number[];
+    /** The game's layers of cells (`Terrain.cells`), by id, per cell: those in either ground */
+    cells?: Record<string, number[]>;
+}
+/**
+ * The cells of two grounds of one size that are not the same, as the smallest rectangle around them; none where they
+ * are the same. Every layer, the game's layers of cells too. Two of other sizes: all of `after`
+ *
+ * @beta
+ */
+export declare function groundDifference(before: Terrain, after: Terrain): {
+    x: number;
+    z: number;
+    width: number;
+    depth: number;
+} | undefined;
+/**
+ * A rectangle of cells of a ground as it is (`TerrainPatch`): to be put in another
+ *
+ * @beta
+ */
+export declare function terrainPatch(terrain: Terrain, rect: {
+    x: number;
+    z: number;
+    width: number;
+    depth: number;
+}): TerrainPatch;
+/**
+ * What is wrong with a patch for a ground (`TerrainPatch`): out of it, or of layers of other lengths. Nothing when it fits
+ *
+ * @beta
+ */
+export declare function terrainPatchProblem(terrain: Terrain, patch: TerrainPatch): string | undefined;
+/**
+ * Puts a patch (`TerrainPatch`) in a ground, in place: its heights, water, paint and levels, and the game's layers of
+ * cells (a layer the patch has that the ground has not is made). Nothing else: what the rules make of the ground is
+ * `World.reshapeGround`'s. Throws where it does not fit (`terrainPatchProblem`)
+ *
+ * @beta
+ */
+export declare function applyTerrainPatch(terrain: Terrain, patch: TerrainPatch): void;
+export {};

package/dist/groundSpeed.d.ts

@@ -0,0 +1,22 @@
+import type { Entity } from './entity';
+import type { Registry } from './registry';
+import type { Terrain } from './terrain';
+import type { World } from './world';
+/**
+ * How fast one on foot goes over a cell of the map, as a multiplier: the tile's `speed` times the `speed` of every
+ * layer of cells that is not 0 there; 1 where nothing says. Off the map, 1
+ *
+ * @beta
+ */
+export declare function groundSpeedOfCell(world: World, x: number, z: number): number;
+/** `groundSpeedOfCell` of a game's ground before there is a world of it: what its navigation is cut with */
+export declare function groundSpeedOn(registry: Registry, terrain: Terrain, x: number, z: number): number;
+/**
+ * How fast a unit goes where it stands, as a multiplier of its speed: the ground's for one on foot
+ * (`groundSpeedOfCell`), 1 for what flies or sails
+ *
+ * @beta
+ */
+export declare function groundSpeedAt(world: World, entity: Entity): number;
+/** Whether any of a game's ground slows or speeds one on foot: a tile, or a layer of cells, with a speed of its own */
+export declare function hasGroundSpeeds(registry: Registry): boolean;