@v12-engine/engine 0.0.0-stage → 0.1.0

package/dist/map/images.d.ts

@@ -0,0 +1,18 @@
+import type { GameMap } from './types';
+/**
+ * Heights from the pixels of a picture (RGBA, as a canvas gives them): dark is `low`, light is `high`, the picture
+ * stretched over the corners of the map's ground. A heightmap made elsewhere, read into a map
+ *
+ * @beta
+ */
+export declare function heightsFromPixels(pixels: ArrayLike<number>, imageWidth: number, imageHeight: number, map: Pick<GameMap, 'width' | 'depth'>, low: number, high: number): Float32Array;
+/**
+ * The heights of a terrain as the pixels of a picture (RGBA), a pixel a corner: the lowest black, the highest white
+ *
+ * @beta
+ */
+export declare function heightsToPixels(heights: Float32Array, width: number, depth: number): {
+    pixels: Uint8ClampedArray;
+    low: number;
+    high: number;
+};

package/dist/map/look.d.ts

@@ -0,0 +1,47 @@
+/**
+ * What a map looks like beyond its ground (design review E8c): the engine carries it (in the map, its file, a save,
+ * what players are told as it changes: `world.setEnvironment`) and reads none of it but the map's own tiles, which are
+ * paint like the game's. An open interface: the client adds what it draws by (its water, light, sky, fog, weather,
+ * lights and the rest), as a game adds its commands (`Commands`)
+ *
+ * @beta
+ */
+export interface MapEnvironment {
+    /** Ground of the map's own to paint with, past the game's tiles (see `MapTile`): the rules' paint, by id */
+    tiles?: MapTile[];
+}
+/**
+ * A ground of a map's own, to paint with as a game's tiles are (`MapEnvironment.tiles`): to the rules, paint by its id.
+ * An open interface: the client adds its look (its picture, colour, pattern)
+ *
+ * @beta
+ */
+export interface MapTile {
+    /** Its id in the map's paint (`GameMap.tileset`): none of the game's tiles' */
+    id: string;
+    /** What the editor's palette calls it */
+    name: string;
+}
+/**
+ * The ids of a map's own tiles (`MapEnvironment.tiles`)
+ *
+ * @beta
+ */
+export declare const mapTileIds: (environment: MapEnvironment | undefined) => string[];
+/**
+ * The tiles a world from a map is painted with: the game's, then the map's own that are none of them, as many as a map
+ * can hold. The order a played ground's paint is in, and its looks
+ *
+ * @beta
+ */
+export declare function playTileset(gameTiles: readonly string[], environment: MapEnvironment | undefined): string[];
+/** The map's light, fog and sky changed (`world.setEnvironment`): to everyone */
+export declare const toldEnvironment: import("..").ReplicatedEvent;
+/**
+ * The light a doodad carries (`MapDoodad.light`), over the one its kind of doodad gives: an open interface the client
+ * fills in with what a light of the map is (`MapLightSource`, less where it stands and its name)
+ *
+ * @beta
+ */
+export interface MapDoodadLight {
+}

package/dist/map/pathProfile.d.ts

@@ -0,0 +1,13 @@
+import type { MapPath } from './types';
+/**
+ * How far along a path its land is averaged each way, in cells: what makes a road as smooth along it as a road is
+ *
+ * @beta
+ */
+export declare const PROFILE_SMOOTH = 4;
+/**
+ * How far a path's profile reaches from its line, in cells: half its bed and its banks
+ *
+ * @beta
+ */
+export declare function profileReach(path: Pick<MapPath, 'width' | 'profile'>): number;

package/dist/map/resize.d.ts

@@ -0,0 +1,54 @@
+import type { AreaShape } from '../areas';
+import { type Vec2 } from '../math';
+import { type GameMap } from './types';
+/**
+ * How many cells a map gains on each side, or loses where it is less than 0 (see `resizeMap`)
+ *
+ * @beta
+ */
+export interface MapSides {
+    /** Towards x 0, and towards x of the width */
+    left: number;
+    right: number;
+    /** Towards z 0, and towards z of the depth */
+    top: number;
+    bottom: number;
+}
+/**
+ * How a map is being grown or cut (`resizeMap`), for what moves along with it: where a place goes, whether it is
+ * still on the map, and a shape moved and cut to the map
+ *
+ * @beta
+ */
+export interface MapResize {
+    readonly sides: MapSides;
+    /** The new size, in cells */
+    readonly width: number;
+    readonly depth: number;
+    /** A place where it is on the grown map (the old place, moved by the cells gained on the left and the top) */
+    moved<P extends Vec2>(place: P): P;
+    /** Whether a place is on the grown map */
+    on(place: Vec2): boolean;
+    /** A place kept on the grown map: at its edge where it is past it */
+    inside<P extends Vec2>(place: P): P;
+    /** A shape moved: a circle while its middle is on the map, what is left of a rectangle on it; none when it is gone */
+    shape<S extends AreaShape>(shape: S): S | undefined;
+}
+/**
+ * What moves along with a map grown or cut, of what others than the engine keep with it (`resizeMap`): the client's
+ * looks under `map.environment` (`mapLooksResizer` of `@v12-engine/client`), the editor's own. Changes the copy it is
+ * given, as `resizeMap` hands it on
+ *
+ * @beta
+ */
+export type MapResizer = (map: GameMap, resize: MapResize) => void;
+/**
+ * A map grown or cut on any side: the ground, cliffs, water and paint go on as they were at the old edge where it
+ * grows; everything on it moves along, and what is no longer on the map is gone. The map itself is left as it was.
+ * What the engine keeps moves (objects, camps, regions, points, paths, doodads, cameras, the players' starts, the bounds,
+ * the game's own kinds' things in `data`); what others keep moves with the `resizers` given (the client's looks:
+ * `mapLooksResizer`)
+ *
+ * @beta
+ */
+export declare function resizeMap(map: GameMap, sides: MapSides, resizers?: readonly MapResizer[]): GameMap;

package/dist/map/schema.d.ts

@@ -0,0 +1,10 @@
+/** The fields as specs, for what walks them */
+export declare const MAP_FIELD_SPECS: readonly MapFieldSpec[];
+/** What a reader of this format knows in a file: `format` and every field. The rest is carried along (`GameMap.extra`) */
+export declare const KNOWN: ReadonlySet<string>;
+/** The fields of a kind */
+export declare const fieldsOf: (...kinds: MapFieldKind[]) => readonly MapFieldSpec[];
+/** The lists of things with ids: merged thing by thing (`mergeMaps`), an entry to a line (`mapText`) */
+export declare const BY_ID: readonly string[];
+/** The layers of the ground every map has: merged cell by cell (`mergeMaps`), a row to a line (`mapText`) */
+export declare const LAYERS: readonly ('ground' | 'levels' | 'ramps' | 'water' | 'tiles')[];

package/dist/map/terrain.d.ts

@@ -0,0 +1,32 @@
+import { Terrain } from '../terrain';
+import { type CellRect, type GameMap } from './types';
+/**
+ * The terrain a map describes
+ *
+ * @beta
+ */
+export declare function mapTerrain(map: GameMap): Terrain;
+/**
+ * What the doodads of a map keep off its cells, and what is kept off them by hand (`GameMap.pathing`), into the
+ * terrain (`Terrain.blocked`): the most any of them keeps off. With `area` (cells), there alone: what the layers changed
+ * there (a brush's step), the doodads elsewhere as they were; the whole map where a doodad itself changed
+ *
+ * @beta
+ */
+export declare function blockByDoodads(map: Pick<GameMap, 'doodads' | 'width' | 'depth' | 'pathing'>, terrain: Terrain, area?: CellRect): void;
+/**
+ * Brings a terrain of the same size in line with the layers of a map, in place, for editing. With `area`, only what
+ * a change to those cells can have changed: the cells and the corners of cells within reach of it. Returns the cells
+ * whose terrain was worked out again, for whoever draws it to draw again: their corners are the vertices that changed
+ *
+ * @beta
+ */
+export declare function updateMapTerrain(map: GameMap, terrain: Terrain, area?: CellRect): CellRect;
+/**
+ * Brings the paint of a map in line with a game's tiles, in place: afterwards index 1 is the game's first tile, and
+ * so on. What was painted with a tile the game does not have keeps it, under an index after the game's: the map
+ * loses nothing, and the file has it still. Returns the names of those, which no world is given
+ *
+ * @beta
+ */
+export declare function adoptTileset(map: GameMap, tiles: readonly string[]): string[];