@v12-engine/engine 0.0.0-stage → 0.1.0

package/dist/map/types.d.ts

@@ -0,0 +1,613 @@
+import type { GameData } from '../gameData';
+import type { AreaShape } from '../areas';
+import type { PlayerId } from '../entity';
+import type { GeneratedWith } from '../generate';
+import type { Vec2 } from '../math';
+import type { MapDoodadLight, MapEnvironment } from './look';
+/**
+ * A map: the ground and what stands on it when the game begins, as data. The editor makes them, scenes play them.
+ *
+ * The ground is kept in layers that are edited apart and put together into a `Terrain`: the height of the land,
+ * cliff levels, ramps between levels, water and paint. The layers are what a map file stores, the terrain is
+ * derived from them whenever one changes.
+ *
+ * @beta
+ */
+export interface GameMap {
+    name: string;
+    description: string;
+    /**
+     * The game the map was made for, by the id of its module (`GameModule.id`): a world is not made from it for
+     * another. For any game when left out, like the maps made before maps said
+     */
+    game?: string;
+    width: number;
+    depth: number;
+    /** How much higher a level stands than the one below */
+    cliffHeight: number;
+    /** Height of the land per vertex, row by row, before cliffs and water */
+    ground: Float32Array;
+    /** Cliff level per cell */
+    levels: Uint8Array;
+    /** 1 where a cell is part of a ramp: the levels around it are joined by a slope instead of a cliff */
+    ramps: Uint8Array;
+    /** `WATER_*` per cell */
+    water: Uint8Array;
+    /** Paint per cell: 0 for none, otherwise 1 and up into `tileset` */
+    tiles: Uint8Array;
+    /**
+     * The game's own layers of cells (`CellLayerDef`), by id: where the bushes are. A value per cell, row by row. Left
+     * out, or a layer left out, for none
+     */
+    cells?: Record<string, Uint8Array>;
+    /**
+     * What is kept off each cell by hand, as the editor's pathing brush paints it: `BLOCKS_BUILD` (no building there),
+     * `BLOCKS_WALK` (nothing walks or builds there), 0 for nothing. With what doodads keep off, into `Terrain.blocked`:
+     * no-build zones, invisible walls. Left out for none. While the game runs, a game blocks the way with obstacles
+     * (`world.nav.addObstacle`) and keeps buildings off with the `canPlace` hook
+     */
+    pathing?: Uint8Array;
+    /**
+     * The tiles the paint of `tiles` is, by name: index 1 is the first. The game's own list, as the map is opened with
+     * a game (`adoptTileset`); names the game does not have come after it, kept for the file
+     */
+    tileset: string[];
+    /** The players who can take part. Neutral and the creeps are always there on top of these */
+    players: MapPlayer[];
+    objects: MapObject[];
+    camps: MapCamp[];
+    /** Parts of the map the rules watch by name: who walks in and out (see `MapRegion`) */
+    regions: MapRegion[];
+    /** Spots the rules know by name: where a wave comes in, where a hero waits (see `MapPoint`) */
+    points: MapPoint[];
+    /** Lines the rules know by name: a road, a patrol route (see `MapPath`) */
+    paths: MapPath[];
+    /** Scenery, which the rules do not know of but where it blocks (see `MapDoodad`) */
+    doodads: MapDoodad[];
+    /** Views of the map saved under names (see `MapCamera`) */
+    cameras: MapCamera[];
+    /** Groups what is placed can be drawn from when the game starts, and tables of what drops (see `MapRandomGroup`) */
+    randomGroups?: MapRandomGroup[];
+    itemTables?: MapItemTable[];
+    /**
+     * The map's own definitions (campaign plan RC8), a `data.json` as the game's has it (`GameData`): laid over the
+     * game's data as a world is made from the map, before its rules are checked. A footman of 200 health on this map
+     * alone. Its rules hash has them, so a save of it is not one of another map with other definitions
+     */
+    definitions?: GameData;
+    /** Its teams, named, and what their players share (see `MapForce`). Teams by number only when left out */
+    forces?: MapForce[];
+    /** The races a lobby offers its players who have none fixed (`MapPlayer.race`), by id. All of the game's when left out */
+    races?: string[];
+    /** Who made it */
+    author?: string;
+    /** The map's checks it does not want, by their rules' ids (`MapProblem.rule`): a desert map with no path to its mines */
+    silence?: string[];
+    /** Who it is for, as lists show it: "2 players", "2 v 2" */
+    meantFor?: string;
+    /**
+     * Whether the whole map starts explored for everyone, the fog over it all the same: its ground, and what stands on it
+     * and belongs to no player (trees, mines, neutral buildings), seen from the first moment. Yes or no over the game's
+     * (`FogRules.startExplored`); the game's when left out
+     */
+    explored?: boolean;
+    /** What the loading screen says while it loads */
+    loading?: string;
+    /** A picture of it, for lists of maps: a small PNG as a data URL, made from its ground in the editor */
+    preview?: string;
+    /** What the map looks like beyond its ground: its water, light, sky (see `MapEnvironment`) */
+    environment?: MapEnvironment;
+    /** The hour the game starts at, and whether it moves (see `MapDay`) */
+    day?: MapDay;
+    /** How it was made, where a generator made it (`generateMap`): the seed and the options, for the same again or another */
+    generated?: GeneratedWith;
+    /**
+     * The part of the map play happens in, in cells, when it is not all of it: nothing on foot goes outside it, nothing
+     * is built there, the camera keeps to it, and the screen darkens what is beyond. Scenery around the edge
+     */
+    bounds?: CellRect;
+    /**
+     * What the game keeps with the map, for its rules to read: a difficulty, the waves of this level. Plain data,
+     * as in a save. The engine never looks inside
+     */
+    data: Record<string, unknown>;
+    /**
+     * What the map's editor keeps with it of its own (what is hidden or locked, its groups, its views, the instances of
+     * prefabs): saved with the map as plain data, read by no game, world or rule, and taken away for play
+     * (`withoutEditor`). The engine never looks inside: the editor says what it holds
+     */
+    editor?: Record<string, unknown>;
+    /**
+     * What the file held that this reader does not know, as it was: written back when the map is saved, so that a map
+     * from a newer editor loses nothing by passing through an older one
+     */
+    extra?: Record<string, unknown>;
+}
+/** @beta */
+export interface MapPlayer {
+    id: PlayerId;
+    name: string;
+    team: number;
+    color: [number, number, number];
+    /** Where their base goes, for a game that gives everyone a start */
+    start?: Vec2;
+    /** Where their view starts, by the name of a camera of the map (`MapCamera`). Over their start when it has one */
+    camera?: string;
+    /**
+     * Who plays them: a person, the computer, or nobody (an open slot left empty). The game's to say when left out: the
+     * game reads it (`world.map.player(id)`), the engine does nothing with it
+     */
+    controller?: 'person' | 'computer' | 'nobody';
+    /** What they start with, by resource id, over what the game gives everyone */
+    resources?: Record<string, number>;
+    /**
+     * The race they play, fixed by the map (a campaign's), of the game's races (`GameModule.races`), or `random`: not
+     * chosen in a lobby. Left to the lobby, or the game's first, when left out
+     */
+    race?: string;
+    /** What the game's own fields for players were set to (`defineMapField` with `for: 'player'`) */
+    data?: Record<string, unknown>;
+}
+/**
+ * A team of a map, with a name, and what its players share: for the game to read (`world.map.forces`)
+ *
+ * @beta
+ */
+export interface MapForce {
+    /** The team, as its players have it (`MapPlayer.team`) */
+    team: number;
+    name: string;
+    /** Its players see what each other sees. Teams always do in this engine: kept for the game to read */
+    sharedVision?: boolean;
+    /** Its players can give orders to each other's units: for the game to read */
+    sharedControl?: boolean;
+}
+/**
+ * A view of the map saved under a name: what the camera looks at, from how far, which way and how steeply. For
+ * cinematics (`cut.camera('gate')`), a player's first view, and code (`client.lookFrom('gate')`). The screen's
+ *
+ * @beta
+ */
+export interface MapCamera {
+    /** The editor's, see `MapRegion.id` */
+    id: number;
+    name: string;
+    x: number;
+    z: number;
+    distance: number;
+    /** Radians around the vertical axis, 0 looking north, and between the view and the ground */
+    yaw: number;
+    pitch: number;
+}
+/**
+ * Something that stands on the map when the game begins: a unit, a building, a tree, a mine
+ *
+ * @beta
+ */
+export interface MapObject {
+    id: number;
+    type: string;
+    owner: PlayerId;
+    x: number;
+    z: number;
+    facing: number;
+    /** How big it is drawn */
+    scale: number;
+    /** Which of the models of its type it is drawn with, for things that come in kinds like trees. Left out: one picked for it */
+    look?: string;
+    /**
+     * The random group it is drawn from when the game starts (`MapRandomGroup`, by name): `type` is what the editor
+     * shows until then
+     */
+    random?: string;
+    /** The item table it drops from when it dies (`MapItemTable`, by name) */
+    drops?: string;
+    /**
+     * A name of its own, for the rules to find it by (`world.named('gate')`). No two things on a map have the same,
+     * whatever they are
+     */
+    name?: string;
+    /** The health it starts with, as a part of what it can have: 0.5 is half. All of it when left out */
+    health?: number;
+    /** The mana it starts with, as a part of what it can have. What its type starts with when left out */
+    mana?: number;
+    /** For a hero: the level it starts at */
+    level?: number;
+    /** For a hero: what it has learned already, as the level of each ability by id. As far as its level lets it */
+    abilities?: Record<string, number>;
+    /** The items it carries, by the id of each, as far as it has room */
+    items?: string[];
+    /** For a resource: how much there is of it. What its type holds when left out */
+    amount?: number;
+    /** For a building: it starts as a site that is still to be built */
+    underConstruction?: boolean;
+    /** Seconds until it is gone, for what is not there to stay */
+    lifetime?: number;
+    /**
+     * What it is doing as the game begins, its own orders and no player's, one after the other (campaign plan MS2): a
+     * guard walking a patrol route, a caravan on its road. Nothing but what a unit does by itself when left out
+     */
+    orders?: MapObjectOrder[];
+    /**
+     * What the game's own fields were set to, by the id of each (see `defineMapField`). The engine does not look
+     * inside: the `mapObject` hook hands it to the game
+     */
+    data?: Record<string, unknown>;
+}
+/**
+ * An order a unit of the map is given as the game begins (`MapObject.orders`): to go somewhere (`move`), to walk to
+ * and fro fighting what it meets (`patrol`), to stand somewhere and fight what comes near, coming back after
+ * (`guard`), to stand its ground (`hold`); to a point, or along a path of the map by its name, bend after bend (a
+ * patrol along one walks it back and forth)
+ *
+ * @beta
+ */
+export interface MapObjectOrder {
+    kind: 'move' | 'patrol' | 'guard' | 'hold';
+    path?: string;
+    point?: Vec2;
+}
+/**
+ * A named part of the map, which becomes an area of the world made from it (`AreaDef`): the rules hear who walks in
+ * and out (`enteredArea`, `leftArea`) and ask who is in it (`world.areas`), by its name
+ *
+ * @beta
+ */
+export interface MapRegion {
+    /** The editor's, to tell regions apart while one is renamed. The world knows it by its name */
+    id: number;
+    /** What the rules know it by. No two things on a map have the same, whatever they are */
+    name: string;
+    shape: AreaShape;
+    /** What it is drawn in, in the editor, to tell it from the others. The editor picks one when left out */
+    color?: [number, number, number];
+    /** What the game's own fields for regions were set to, see `MapObject.data`: the `mapRegion` hook hands it to the game */
+    data?: Record<string, unknown>;
+    /**
+     * A cinematic the region plays (ED4): for everyone, once, the first time a unit of a player walks in, unless the game
+     * plays it its own way (`play: 'code'`: the region says which, `world.map.regions`, and the game's rules play it)
+     */
+    cinematic?: MapRegionCinematic;
+}
+/**
+ * The cinematic a region of the map plays (`MapRegion.cinematic`): which, by its id (`GameView.cinematics.defs`), and who
+ * plays it: the engine, as a unit of a player first walks in (`'enter'`, when left out), or the game's own code
+ * (`'code'`)
+ *
+ * @beta
+ */
+export interface MapRegionCinematic {
+    /** The cinematic, by its id: the game's (`GameView.cinematics.defs`) */
+    id: string;
+    /** Who plays it: the engine as a unit of a player first walks in (`'enter'`, when left out), or the game's code */
+    play?: 'enter' | 'code';
+}
+/**
+ * A named spot of the map, facing a way: `world.map.point('spawn')`
+ *
+ * @beta
+ */
+export interface MapPoint {
+    /** The editor's, see `MapRegion.id` */
+    id: number;
+    /** What the rules know it by. No two things on a map have the same, whatever they are */
+    name: string;
+    x: number;
+    z: number;
+    /** Radians, the way entities face: 0 is along +z */
+    facing: number;
+    /** What it is drawn in, in the editor */
+    color?: [number, number, number];
+}
+/**
+ * Scenery: a model on the map that is no entity of the rules, with no health, owner or place in a snapshot. A rock, a
+ * fence, a ruined arch, free to lean, float and stretch. What it keeps off the cells under it (`blocks`) the terrain
+ * has, for the paths of units and for building
+ *
+ * @beta
+ */
+export interface MapDoodad {
+    /** The editor's, see `MapRegion.id` */
+    id: number;
+    /** The model, by its path in `models/`: the map's own, the game's, or a shared one */
+    model: string;
+    x: number;
+    z: number;
+    /** How high above the ground under it */
+    y?: number;
+    /** Radians: which way it faces, the way entities do (0 is along +z), then how far it leans forward and to the side */
+    yaw: number;
+    pitch?: number;
+    roll?: number;
+    /** How much bigger or smaller it is drawn than it was made, across, up and deep */
+    scale: [number, number, number];
+    /** A colour it is drawn in, over its own */
+    tint?: [number, number, number];
+    /** What code knows it by (`client.doodads.named`). Doodads are the screen's: the rules never see them */
+    name?: string;
+    /** What it keeps off the cells within `radius` of its middle: building there, or walking and building. Nothing when left out */
+    blocks?: 'build' | 'walk';
+    /**
+     * A bridge: walked on, over deep water too, at its height (`y`) above the water. Nothing is built on it. Within
+     * `radius` of its middle
+     */
+    bridge?: boolean;
+    /**
+     * A gate: it keeps walking off the cells within `radius` while it is shut, and the rules open and shut it by its
+     * name while the game runs (`setGate`). Shut when the game starts, unless `open`
+     */
+    gate?: boolean;
+    open?: boolean;
+    /** How far around its middle it blocks, in cells */
+    radius?: number;
+    /**
+     * A clip of its model it plays over and over (a windmill's sails, a flag, a chest held open), by its name: none when
+     * left out, or as the game says of its model (`SceneryDef.animation`). It is drawn on its own while it plays
+     */
+    animation?: string;
+    /**
+     * Merged with the scenery near it, to be drawn in one go (`DoodadView`): yes when left out, as far as its model can be.
+     * No keeps it a copy of its model's mesh: for a game's code that reaches for it
+     */
+    batch?: boolean;
+    /**
+     * This one's lights otherwise than its model's (`GameView.ground.scenery`): put out (`on: false`), another colour, brighter,
+     * further. Laid over every light its model gives
+     */
+    light?: MapDoodadLight;
+    /**
+     * How this one is drawn by distance, over its model's (`MapDetail`): pinned to a level by its index (`level`: 0 always at
+     * full), or levels of its own. As its model when left out
+     */
+    detail?: MapDoodadDetail;
+}
+/**
+ * One way a thing is drawn, and when, as a map says it (`MapDetail.models`, `MapDoodad.detail`): the client's
+ * `DetailLevel` without what only code can say. A level applies when any of its conditions holds; of a thing's levels the
+ * last that applies is drawn, the first being its full self
+ *
+ * @beta
+ */
+export interface MapDetailLevel {
+    /** What is drawn: a picture of the model (`impostor`), or nothing (`none`). The model, or `model`, when left out */
+    draw?: 'impostor' | 'none';
+    /** Another model, by its path in `models/`, in place of the thing's own */
+    model?: string;
+    /** Or a lighter version of the full model made from it: this part of its triangles (0.25) */
+    ratio?: number;
+    /** From this far from the camera, in cells */
+    from?: number;
+    /** Or: once the thing is at most this tall on the screen, in pixels */
+    under?: number;
+    /** Or: while the camera is over a region of the map, by its name; or not over it (`!name`) */
+    region?: string;
+    /**
+     * How its file is loaded: with the model (`eager`), once something comes near wanting it (`lazy`, when left out: within
+     * half again its distance), by code alone (`never`), or as the camera comes over a region of the map, by its name
+     */
+    load?: 'eager' | 'lazy' | 'never' | {
+        region: string;
+    };
+    /**
+     * The level its shadow is drawn at, by index: a lighter one is cheaper, and nobody sees a leaf's shadow. One of nothing
+     * casts none. As the shadows' bias says when left out (`MapDetail.shadowBias`), else the level it is drawn at
+     */
+    shadow?: number;
+}
+/**
+ * How one doodad is drawn by distance (`MapDoodad.detail`)
+ *
+ * @beta
+ */
+export interface MapDoodadDetail {
+    /** Always at this level, by its index: 0 at full */
+    level?: number;
+    /** Its own levels, over its model's */
+    levels?: MapDetailLevel[];
+}
+/**
+ * How much detail things are drawn with by their distance on a map (`MapEnvironment.detail`), over the game's
+ * (`GameView.scene.detail`): a forest map drawn lighter. The screen's: the rules never see it
+ *
+ * @beta
+ */
+export interface MapDetail {
+    /** Every distance a level starts from, times this: under 1 lighter sooner, over 1 later. The game's when left out */
+    scale?: number;
+    /** Past this far from the camera, in cells, no scenery, tree or mine is drawn at all, nor casts a shadow. None when left out */
+    cull?: number;
+    /**
+     * How many levels coarser than it is drawn at a thing casts its shadow, where its level does not say (`shadow`): 1
+     * draws a tree's shadow at its next lighter level. The game's when left out
+     */
+    shadowBias?: number;
+    /** The levels of every model that has none said of it, over the game's (`GameView.scene.detail.levels`) */
+    levels?: MapDetailLevel[];
+    /** A model's levels, by its path in `models/`, over its own and the game's */
+    models?: Record<string, MapDetailLevel[]>;
+}
+/**
+ * A group a placed thing is drawn from when the game starts (random groups, as classic map editors have them): one of these types by
+ * weight, or any creep of a level ("a level 3 creep")
+ *
+ * @beta
+ */
+export interface MapRandomGroup {
+    name: string;
+    /** One of these, more likely by its weight */
+    choices?: {
+        type: string;
+        weight: number;
+    }[];
+    /** Or any unit type with a bounty, of this level */
+    level?: number;
+}
+/**
+ * What something drops when it dies (item tables, as classic map editors have them): one item by weight, or none
+ *
+ * @beta
+ */
+export interface MapItemTable {
+    name: string;
+    items: MapItemTableEntry[];
+    /** How likely it is to drop anything, 0..1. Always when left out */
+    chance?: number;
+}
+/**
+ * A line of an item table (`MapItemTable.items`): an item by id, or any item of a level, a class, or both (campaign
+ * plan GP3: `{ level: 3, weight: 2 }`), its weight shared among those of the game that match
+ *
+ * @beta
+ */
+export interface MapItemTableEntry {
+    item?: string;
+    level?: number;
+    class?: string;
+    weight: number;
+}
+/**
+ * What a doodad keeps off a cell, in `Terrain.blocked`: building, walking too, or building on a bridge one walks on
+ *
+ * @beta
+ */
+export declare const BLOCKS_BUILD = 1;
+/** @beta */
+export declare const BLOCKS_WALK = 2;
+/**
+ * A named line of the map, through points in order, with a width: `world.map.path('road')` (see `Path`)
+ *
+ * @beta
+ */
+export interface MapPath {
+    /** The editor's, see `MapRegion.id` */
+    id: number;
+    /** What the rules know it by. No two things on a map have the same, whatever they are */
+    name: string;
+    points: Vec2[];
+    /** How wide it is, in cells: what it paints and keeps clear, and what `Path.contains` says is on it */
+    width: number;
+    /** A tile of the game's, by id, that the ground under it is painted with, over the map's own paint */
+    paint?: string;
+    /** Nothing may be built on it: a road the invaders need to get through */
+    keepClear?: boolean;
+    /** What it is drawn in, in the editor */
+    color?: [number, number, number];
+    /**
+     * A road's or a river's bed under it, carved in the ground and painted each time the terrain is worked out (the
+     * map's own heights stay as they are, so the bed follows the path wherever its points go): `PathProfile`
+     */
+    profile?: PathProfile;
+}
+/**
+ * The bed a path carves, as a road or a river: its middle as smooth along it as a road is (the land along it averaged
+ * over four cells each way), lowered by `depth`, level across `width`, eased into the land over `banks` cells each
+ * side; painted with `ground`, and with water in it for a river
+ *
+ * @beta
+ */
+export interface PathProfile {
+    /** How wide the bed is, in cells: the path's own width when left out */
+    width?: number;
+    /** How far below the land along it the bed is (0, a road; a river's bed with its water), in the heights' units */
+    depth?: number;
+    /** A tile of the game's the bed is painted with, by id (over the path's `paint`) */
+    ground?: string;
+    /** Over how many cells each side the bed is eased into the land: 2 when left out */
+    banks?: number;
+    /** Water in the bed: deep where `depth` is 1 or more, else shallow (a river, a ford) */
+    water?: boolean;
+}
+/**
+ * The time of day of a map, in a game with days (`GameModule.day`). The rules': what is done at night is done by it
+ *
+ * @beta
+ */
+export interface MapDay {
+    /** The hour the game starts at. The game's when left out */
+    start?: number;
+    /** The hour stays where it starts: always night, always noon */
+    still?: boolean;
+}
+/**
+ * Creeps that guard a spot
+ *
+ * @beta
+ */
+export interface MapCamp {
+    id: number;
+    x: number;
+    z: number;
+    /** Unit types, the first one stands in the middle */
+    units: string[];
+    /** A name of its own, for the rules to find it by (`campNamed(world, 'ogres')`), see `MapObject.name` */
+    name?: string;
+    /** What the game's own fields for camps were set to, see `MapObject.data`: the `mapCamp` hook hands it to the game */
+    data?: Record<string, unknown>;
+    /** Seconds after it is cleared that it comes back (see `Camp.respawn`). The game's rule when left out */
+    respawn?: number;
+}
+/**
+ * Owner of trees, mines and whatever belongs to nobody
+ *
+ * @beta
+ */
+export declare const MAP_NEUTRAL: PlayerId;
+/**
+ * Owner of the creeps
+ *
+ * @beta
+ */
+export declare const MAP_CREEPS: PlayerId;
+/**
+ * Players a map may have at most, whatever the game: each could be a team of its own, and the fog of war keeps 32
+ * teams apart (`MAX_FOG_TEAMS`). How many a game allows is its own (`GameModule.maxPlayers`, 8 when it says nothing)
+ *
+ * @beta
+ */
+export declare const MAX_MAP_PLAYERS = 32;
+/**
+ * Highest cliff level
+ *
+ * @beta
+ */
+export declare const MAX_LEVEL = 4;
+/** @beta */
+export declare const PLAYER_COLORS: [number, number, number][];
+/** @beta */
+export declare const playerSlot: (id: number) => MapPlayer;
+/** @beta */
+export interface NewMapOptions {
+    name?: string;
+    width: number;
+    depth: number;
+    /** Height of the land everywhere */
+    height?: number;
+    players?: number;
+    /** The game it is for, see `GameMap.game` */
+    game?: string;
+    /** The tiles it can be painted with, by name: the game's (`registry.tiles`). None when left out */
+    tileset?: string[];
+}
+/**
+ * Flat grass, two players and nothing on it
+ *
+ * @beta
+ */
+export declare function createMap(options: NewMapOptions): GameMap;
+/**
+ * A rectangle of a map, in cells
+ *
+ * @beta
+ */
+export interface CellRect {
+    x: number;
+    z: number;
+    width: number;
+    depth: number;
+}
+/**
+ * The largest, the same for the editor and a map file. 512 until a game needs more (S37 is what makes more cost little)
+ *
+ * @beta
+ */
+export declare const MAX_MAP_SIZE = 512;

package/dist/map.d.ts

@@ -0,0 +1,7 @@
+export * from './map/types';
+export * from './map/look';
+export * from './map/terrain';
+export { PROFILE_SMOOTH, profileReach } from './map/pathProfile';
+export * from './map/resize';
+export * from './map/images';
+export * from './map/file';

package/dist/mapCheck/cells.d.ts

@@ -0,0 +1,19 @@
+import { type GameMap } from '../map';
+import type { Vec2 } from '../math';
+import type { Registry } from '../registry';
+import { type Terrain } from '../terrain';
+/**
+ * Which cells of a map something on foot can stand on (1) and which have a building or a mine on them (`built`): for
+ * the checks, and for what the editor shows of where one can walk and build. `steep` counts slopes too steep to walk
+ *
+ * @beta
+ */
+export declare function mapCells(map: GameMap, registry: Registry, terrain?: Terrain, steep?: boolean): {
+    open: Uint8Array;
+    built: Uint8Array;
+};
+/** Cells something on foot can stand on, and which of them it can get to from which: a number per cell, 0 for none */
+export declare function walkingAreas(map: GameMap, registry: Registry): {
+    area: Int32Array;
+    at: (point: Vec2) => number;
+};

package/dist/mapCheck/rule.d.ts

@@ -0,0 +1,30 @@
+import type { GameMap } from '../map';
+import type { MapProblem } from '../mapFields';
+import type { Vec2 } from '../math';
+import type { Registry } from '../registry';
+import type { Terrain } from '../terrain';
+/**
+ * What a check of a map is handed besides the map and the game: the terrain the map makes (made once, as the first
+ * check asks), and whether a point is on the map
+ *
+ * @beta
+ */
+export interface MapCheckContext {
+    /** The terrain the map makes */
+    readonly terrain: Terrain;
+    /** Whether a point is on the map: within its width and depth, edges included */
+    onMap(point: Vec2): boolean;
+}
+/**
+ * A check of a map (`checkMap`): what it says is wrong (`say`), each problem with the rule it breaks (`MapProblem.rule`),
+ * which a map or a game silences. `id` names the check: the engine's by what they look at (`objects`, `walking`), a
+ * game's its own
+ *
+ * @beta
+ */
+export interface MapRule {
+    /** What names the check (`objects`, `walking`, a game's own): each problem it says names the rule it breaks */
+    id: string;
+    /** Says what is wrong with the map (`say`, a problem at a time), the game's registry and the context to go by */
+    check(map: GameMap, registry: Registry, say: (problem: MapProblem) => void, context: MapCheckContext): void;
+}

package/dist/mapCheck/rules/names.d.ts

@@ -0,0 +1,3 @@
+import type { MapRule } from '../rule';
+/** One thing a name, and the cameras players start looking from */
+export declare const nameRules: MapRule;

package/dist/mapCheck/rules/objects.d.ts

@@ -0,0 +1,3 @@
+import type { MapRule } from '../rule';
+/** What is placed and the camps: of types the game has, on the map, out of deep water */
+export declare const objectRules: MapRule;

package/dist/mapCheck/rules/paths.d.ts

@@ -0,0 +1,3 @@
+import type { MapRule } from '../rule';
+/** Paths on the map: on it, and what they paint and carve there to be had */
+export declare const pathRules: MapRule;