@v12-engine/engine 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,3 @@
+import type { MapRule } from '../rule';
+/** How many players the map has, against what the game allows */
+export declare const playerRules: MapRule;

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

@@ -0,0 +1,3 @@
+import type { MapRule } from '../rule';
+/** The races of the map, its players and what is placed for them */
+export declare const raceRules: MapRule;

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

@@ -0,0 +1,3 @@
+import type { MapRule } from '../rule';
+/** Random groups and item tables: something to draw from, and by names there are */
+export declare const randomRules: MapRule;

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

@@ -0,0 +1,3 @@
+import type { MapRule } from '../rule';
+/** Regions on the map */
+export declare const regionRules: MapRule;

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

@@ -0,0 +1,3 @@
+import type { MapRule } from '../rule';
+/** A field that names a region, a point or a path the map has not (any more) */
+export declare const targetRules: MapRule;

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

@@ -0,0 +1,3 @@
+import type { MapRule } from '../rule';
+/** Who can walk to whom: starts cut off from each other, mines nobody can walk to */
+export declare const walkingRules: MapRule;

package/dist/mapCheck.d.ts

@@ -0,0 +1,23 @@
+import { type GameMap } from './map';
+import type { MapProblem } from './mapFields';
+import type { Registry } from './registry';
+import type { MapRule } from './mapCheck/rule';
+export { mapCells } from './mapCheck/cells';
+export type { MapCheckContext, MapRule } from './mapCheck/rule';
+/**
+ * The engine's checks of a map, in the order they run: players, what is placed, random groups, names, regions, paths,
+ * walking, races, the fields that name things
+ *
+ * @beta
+ */
+export declare const MAP_RULES: readonly MapRule[];
+/**
+ * What is wrong with a map, before it is played: what the game does not have, names used twice or named and not
+ * there, what stands off the map or in deep water, starts that cannot reach each other on foot, mines nobody can walk
+ * to, regions outside the map (`MAP_RULES`); then the checks given (`more`: the client's of what the map looks like,
+ * a game view's own, as the editor runs them); then the game's own (`MapEditorDef.check`). Errors keep it from being
+ * played; the rest are warnings. Runs without the editor, for a test that goes over every map of a project
+ *
+ * @beta
+ */
+export declare function checkMap(map: GameMap, registry: Registry, more?: readonly MapRule[]): MapProblem[];

package/dist/mapFields.d.ts

@@ -0,0 +1,364 @@
+import { type UnitTypeDef } from './defs';
+import type { GameMap, MapPlayer } from './map';
+import type { GameMeasure } from './mapMeasure';
+import type { Vec2 } from './math';
+import type { Registry } from './registry';
+/**
+ * A thing on a map, by its kind and id: what a problem is about, which the editor selects. `thing` is one of a kind of
+ * the game's own (`MapThing`), with the kind's name
+ *
+ * @beta
+ */
+export type MapTarget = {
+    object: number;
+} | {
+    camp: number;
+} | {
+    region: number;
+} | {
+    point: number;
+} | {
+    path: number;
+} | {
+    doodad: number;
+} | {
+    light: number;
+} | {
+    effect: number;
+} | {
+    decal: number;
+} | {
+    sound: number;
+} | {
+    mistArea: number;
+} | {
+    weatherArea: number;
+} | {
+    cloudPatch: number;
+} | {
+    player: number;
+} | {
+    thing: number;
+    kind: string;
+};
+/**
+ * A thing of a kind of a game's own on a map: something the game's editor puts down for its rules to read (a spawner,
+ * a waypoint, ground kept clear), where the engine's own kinds (objects, camps, regions, points, paths, doodads) do
+ * not say it. Kept with the map under the kind's name (`GameMap.data[kind]`, a list of them), which the engine never
+ * looks inside: the rules read them (`world.map.things(kind)`, `mapThings`)
+ *
+ * @beta
+ */
+export interface MapThing {
+    /** Its own among the things of its kind */
+    id: number;
+    x: number;
+    z: number;
+    /** The way it faces, in radians. 0 when left out */
+    facing?: number;
+    /** A name of its own, to find it by: no two things of a map have the same, whatever they are */
+    name?: string;
+    /** The game's own fields of it, by their ids: what was set, without what is at its default */
+    data?: Record<string, unknown>;
+}
+/**
+ * The things of a kind of a game's own on a map (`MapThing`), as the map keeps them: none for a kind it has nothing
+ * of. What is kept under that name and is no thing (no id, no place) is left out, so that a file changed by hand breaks
+ * no rule that reads it
+ *
+ * @beta
+ */
+export declare function mapThings(map: {
+    data: Record<string, unknown>;
+}, kind: string): MapThing[];
+/**
+ * Something wrong with a map, as a game sees it: said before the map is played
+ *
+ * @beta
+ */
+export interface MapProblem {
+    message: string;
+    /** It cannot be played like this. A warning when left out: it can, but probably should not */
+    error?: boolean;
+    /** Where on the map it is, for the editor to show */
+    at?: Vec2;
+    /**
+     * The rule it breaks, by id (`off-map`, `deep-water`…, or a game's own): what silences it, for a map
+     * (`GameMap.silence`) or a game (`MapEditorDef.silence`). A game's own check that says none is `game`
+     */
+    rule?: string;
+    /** What it is about: a click on it in the editor selects it */
+    about?: MapTarget;
+    /**
+     * Where it is shown when it is about something of a panel's rather than the map's (a clip of a cinematic): a click on
+     * it opens that panel at that entry (`editor.panels.reveal(panel, entry)`, as the search of everything does)
+     */
+    reveal?: {
+        panel: string;
+        entry: string;
+    };
+}
+/**
+ * What a game brings to the map editor, beyond its units: the fields of its own, what can be scattered, its players,
+ * and what it takes for a map to be one of its maps. Each that is decided from something can be given as a function
+ *
+ * @beta
+ */
+export interface MapEditorDef {
+    /** Fields of the game's own on what is placed on a map, shown in the inspector (see `defineMapField`) */
+    fields?: MapFieldDef[];
+    /**
+     * Unit types the scatter brush puts down many of at once, like a forest. Resources one cell big when left out:
+     * trees. What is scattered belongs to nobody
+     */
+    scatter?: string[] | ((registry: Registry) => string[]);
+    /** Whether the game has creep camps to place. It does when it has a unit type with a bounty, when left out */
+    camps?: boolean;
+    /**
+     * The players of every map of the game, when the game decides who they are, as a tower defense does: the editor
+     * shows those and only lets their starts be set. Open slots to add and take away when left out
+     */
+    players?: MapPlayer[] | ((map: GameMap) => MapPlayer[]);
+    /** A line under the players, saying what the game makes of them: who is the player, who gets a base */
+    playersNote?: string;
+    /**
+     * What is wrong with a map as a map of this game: no start for anyone, no way through. Errors keep it from being
+     * played from the editor; warnings are said
+     */
+    check?: (map: GameMap, registry: Registry) => MapProblem[];
+    /** The editor's checks the game does not want, by their rules' ids (`MapProblem.rule`), for every map of it */
+    silence?: string[];
+    /** What the game measures of a map of its own, for the editor's report (`measureMap`): the length of the road */
+    measure?: (map: GameMap, registry: Registry) => GameMeasure[];
+    /**
+     * The palette's groups of unit types, each saying whose what is put down from it is and whether it makes camps.
+     * Units, heroes, buildings, resources (nobody's) and creeps (the creeps', making camps) when left out
+     */
+    palette?: (registry: Registry) => MapPaletteGroup[];
+    /**
+     * What the erase brush can be set to take, besides everything and camps. Units, buildings, resources and trees (a
+     * resource one cell big) when left out
+     */
+    erase?: MapEraseKind[];
+    /**
+     * What the starts must be able to walk to, which the checks look for (`unreachable`): a resource two cells big or
+     * more when left out, a gold mine and not a tree
+     */
+    reach?: (def: UnitTypeDef) => boolean;
+    /** The lowest and the highest the ground is raised to. -4 to 16 when left out */
+    heights?: readonly [number, number];
+    /**
+     * Where else the game names a thing of a map (a unit type in its waves, a region in a mission's goals): what the
+     * editor lists under Used by and selects with Find references, beyond what it finds on the map itself (placed
+     * objects, camps, random groups, the game's fields, prefabs, cinematics). Given the thing asked about and the map
+     *
+     * @beta
+     */
+    references?: (ref: MapRef, map: GameMap, registry: Registry) => MapRefUse[];
+}
+/**
+ * Something of a game or a map that others name: a unit type, a doodad's model, a prefab, a region, a point or a path
+ * (by name), a thing named on the map, a cinematic, a file of the game's
+ *
+ * @beta
+ */
+export type MapRef = {
+    type: string;
+} | {
+    model: string;
+} | {
+    prefab: string;
+} | {
+    region: string;
+} | {
+    point: string;
+} | {
+    path: string;
+} | {
+    name: string;
+} | {
+    cinematic: string;
+} | {
+    asset: string;
+};
+/**
+ * What on the map a use is: what a click on it selects
+ *
+ * @beta
+ */
+export type MapRefTarget = {
+    object: number;
+} | {
+    camp: number;
+} | {
+    region: number;
+} | {
+    point: number;
+} | {
+    path: number;
+} | {
+    doodad: number;
+} | {
+    light: number;
+} | {
+    effect: number;
+} | {
+    decal: number;
+} | {
+    sound: number;
+} | {
+    mistArea: number;
+} | {
+    weatherArea: number;
+} | {
+    cloudPatch: number;
+} | {
+    thing: number;
+    kind: string;
+};
+/**
+ * One place a thing is named: what names it, where, and what on the map that is
+ *
+ * @beta
+ */
+export interface MapRefUse {
+    /** What names it: `placed`, `camp`, `random group`, `field Spawns`, `prefab`, `cinematic`, or the game's own word */
+    what: string;
+    /** Where: the map's name, a group's, a prefab's, a cinematic's id, a wave's */
+    where: string;
+    target?: MapRefTarget;
+}
+/**
+ * A group of the palette (`MapEditorDef.palette`)
+ *
+ * @beta
+ */
+export interface MapPaletteGroup {
+    name: string;
+    types: UnitTypeDef[];
+    /**
+     * Whose what is put down from it is, by player id (`MAP_CREEPS`, `MAP_NEUTRAL`): the player picked above it when
+     * left out, and nobody for a resource
+     */
+    owner?: number;
+    /** Its units are what camps are made of: the camp tool picks from them */
+    camps?: boolean;
+}
+/**
+ * A kind of thing the erase brush can be set to take (`MapEditorDef.erase`)
+ *
+ * @beta
+ */
+export interface MapEraseKind {
+    id: string;
+    /** What the brush's choice calls it */
+    name: string;
+    takes: (def: UnitTypeDef) => boolean;
+}
+/**
+ * The heights the ground goes from and to when a game does not say
+ *
+ * @beta
+ */
+export declare const DEFAULT_HEIGHTS: readonly [number, number];
+/** What a field of a game's own holds, and so how the editor lets it be set */
+/**
+ * What a field holds: a number, words, yes or no, one of a few, a unit type, a player; a region, a point or a path of
+ * the map (kept by id, so that a rename does not lose it; handed to the game by name); a colour (`[r, g, b]`, 0 to 1);
+ * a list of words; a vector on the ground (`{ x, z }`)
+ *
+ * @beta
+ */
+export type MapFieldKind = 'number' | 'text' | 'toggle' | 'choice' | 'unit' | 'player' | 'region' | 'point' | 'path' | 'color' | 'list' | 'vector';
+/** The kinds of field that name a thing of the map, by its id */
+export declare const TARGET_FIELDS: readonly ['region', 'point', 'path'];
+/**
+ * A field of a game's own on what is placed on a map: the wave a spawner sends, whether a gate starts open, what a
+ * guard does. The editor shows it in the inspector for what it is a field of, and keeps what it was set to with the
+ * object (`MapObject.data`). The engine does nothing with it: the `mapObject` hook hands it to the game as the world
+ * is made, which is where the game says what it means. Given in `GameModule.editor.fields`
+ *
+ * @beta
+ */
+export interface MapFieldDef {
+    /** The key it is kept under. Shared by the fields of every mod on the game: give a mod's a prefix */
+    id: string;
+    /** What the inspector calls it */
+    name: string;
+    /** A line more, shown when the pointer rests on it */
+    hint?: string;
+    /**
+     * The fields it is laid out beside in the inspector, by a name they share (`'Position'`): the consecutive fields of
+     * one group two a line, under its name. Alone when left out
+     */
+    group?: string;
+    kind: MapFieldKind;
+    /**
+     * What it is a field of: objects of these unit types, or of the types a function says yes to (every hero, every
+     * building that trains something); or camps, or regions; or the map itself (kept in `GameMap.data`, read as
+     * `world.map.data`), or its players (`MapPlayer.data`, read as `world.map.player(id).data`)
+     */
+    for: string[] | ((def: UnitTypeDef) => boolean) | 'camp' | 'region' | 'map' | 'player';
+    /** What it is when nothing was set. The game is given this then, and the file does not hold it */
+    default?: unknown;
+    /** For a number: the least and the most it can be, and what the arrows step by */
+    min?: number;
+    max?: number;
+    step?: number;
+    /** For a choice: what there is to choose from, as data or worked out from the game */
+    options?: readonly MapFieldOption[] | ((registry: Registry) => readonly MapFieldOption[]);
+}
+/**
+ * One of the things a choice field can be: the value kept, and what the inspector calls it when that is not the value
+ *
+ * @beta
+ */
+export type MapFieldOption = string | {
+    value: string;
+    label: string;
+};
+/**
+ * Typed help for writing a field
+ *
+ * @beta
+ */
+export declare const defineMapField: (def: MapFieldDef) => MapFieldDef;
+/**
+ * The game's fields for a placed object, by the type it is of. None for a type the game does not have
+ *
+ * @beta
+ */
+export declare function objectFields(registry: Registry, type: string): MapFieldDef[];
+/**
+ * The game's fields for a camp
+ *
+ * @beta
+ */
+export declare const campFields: (registry: Registry) => MapFieldDef[];
+/**
+ * The game's fields for a region
+ *
+ * @beta
+ */
+export declare const regionFields: (registry: Registry) => MapFieldDef[];
+/**
+ * The fields of the map itself, and of its players
+ *
+ * @beta
+ */
+export declare const mapFields: (registry: Registry) => MapFieldDef[];
+/** @beta */
+export declare const playerFields: (registry: Registry) => MapFieldDef[];
+/**
+ * What a choice field can be set to, as values with what each is called
+ *
+ * @beta
+ */
+export declare function fieldOptions(registry: Registry, field: MapFieldDef): {
+    value: string;
+    label: string;
+}[];
+/** What the fields of something placed are, with what was not set at its default: what the game is handed */
+export declare function fieldValues(fields: readonly MapFieldDef[], data: Record<string, unknown> | undefined, map?: GameMap): Record<string, unknown>;
+/** The name of a region, a point or a path of a map by its id: undefined for one the map has not (any more) */
+export declare function targetName(map: GameMap, kind: (typeof TARGET_FIELDS)[number], id: number): string | undefined;

package/dist/mapFile.d.ts

@@ -0,0 +1,23 @@
+import { type GameMap } from './map';
+/**
+ * A map as the text of its file, written to be read by a person comparing two versions of it: every part on a line
+ * of its own in a set order, one object to a line in the order of their ids with what each holds in a set order
+ * too, and the layers last. Moving one object changes one line, whatever was done before
+ *
+ * @beta
+ */
+export declare function mapText(map: GameMap): string;
+/**
+ * What a map file is called, without what comes after the first dot: the name of the map in small letters, with a
+ * dash for whatever is not a letter or a number. `The Pass!` is `the-pass`
+ *
+ * @beta
+ */
+export declare function mapFileStem(name: string): string;
+/**
+ * The names of what is on a map as TypeScript, for a game's code to use: `world.named<RoadNames>('gaet')` does not
+ * compile. The editor writes it next to the map (`road.names.ts` for `road.vgmap.json`), anew with every save
+ *
+ * @beta
+ */
+export declare function mapNamesSource(stem: string, map: GameMap): string;

package/dist/mapMeasure.d.ts

@@ -0,0 +1,95 @@
+import type { PlayerId } from './entity';
+import { type GameMap } from './map';
+import type { Vec2 } from './math';
+import type { Registry } from './registry';
+/**
+ * A way on foot over a map: its length, and the points it goes through
+ *
+ * @beta
+ */
+export interface Walk {
+    length: number;
+    points: Vec2[];
+}
+/**
+ * The way on foot between two points of a map, with what the checks count as in the way. Nothing when there is none
+ *
+ * @beta
+ */
+export declare function walkBetween(map: GameMap, registry: Registry, from: Vec2, to: Vec2): Walk | undefined;
+/**
+ * What one player's start has around it
+ *
+ * @beta
+ */
+export interface StartMeasure {
+    player: PlayerId;
+    name: string;
+    /** The way on foot to the nearest mine, and how much it holds. Nothing without a mine they can walk to */
+    mine?: {
+        distance: number;
+        amount: number;
+        at: Vec2;
+    };
+    /** How many cells within `BUILD_REACH` of the start can be built on */
+    buildable: number;
+    /** Trees within `BUILD_REACH` of the start */
+    trees: number;
+}
+/**
+ * A number of a map a game measures of its own (`MapEditorDef.measure`): the length of the road, for a tower defense
+ *
+ * @beta
+ */
+export interface GameMeasure {
+    name: string;
+    value: number | string;
+}
+/**
+ * What a map is like to play on, measured (see `measureMap`)
+ *
+ * @beta
+ */
+export interface MapReport {
+    /** The way on foot between every two starts: how far a rush goes. Nothing for starts cut off from each other */
+    rushes: {
+        from: PlayerId;
+        to: PlayerId;
+        length?: number;
+        points?: Vec2[];
+    }[];
+    /** The narrowest place on the ways between the starts, and how wide it is */
+    narrowest?: {
+        width: number;
+        at: Vec2;
+    };
+    starts: StartMeasure[];
+    /** What each start has that another has more than `FAIR_MARGIN` more of: what is not fair */
+    unfair: string[];
+    game: GameMeasure[];
+}
+/**
+ * How far around a start counts as its ground, for building and trees
+ *
+ * @beta
+ */
+export declare const BUILD_REACH = 16;
+/**
+ * What a map is like to play on: the way on foot between every two starts, the narrowest place on those ways, and for
+ * each start the nearest mine and how much it holds, the ground around it that can be built on, and its trees; side
+ * by side, with what one start has much more of than another said. Then what the game measures of its own
+ *
+ * @beta
+ */
+export declare function measureMap(map: GameMap, registry: Registry): MapReport;
+/**
+ * Seconds a unit type takes over a way on foot, at the speed it starts with
+ *
+ * @beta
+ */
+export declare const walkingTime: (registry: Registry, type: string, length: number) => number | undefined;
+/** The cell of a footprint, for drawing where a mine stands */
+export declare const footprintAt: (registry: Registry, type: string, at: Vec2) => {
+    x: number;
+    z: number;
+};

package/dist/mapMerge.d.ts

@@ -0,0 +1,19 @@
+import { type GameMap } from './map';
+/**
+ * A merge of two versions of a map from the one they came from
+ *
+ * @beta
+ */
+export interface MapMerge {
+    map: GameMap;
+    /** What both sides changed otherwise, in words: ours was kept for each */
+    conflicts: string[];
+}
+/**
+ * Merges two versions of a map from the one they came from: parts and things by their ids (those of its look too: its
+ * lights, effects, decals), the ground cell by cell. Never throws for what both changed: ours is kept there, and said
+ * (`conflicts`). Maps of different sizes are not merged (ours, and said)
+ *
+ * @beta
+ */
+export declare function mergeMaps(base: GameMap, ours: GameMap, theirs: GameMap): MapMerge;

package/dist/mapObjectives.d.ts

@@ -0,0 +1,82 @@
+import type { PlayerId } from './entity';
+import type { GameMap } from './map';
+import type { MapProblem } from './mapFields';
+import type { Message } from './messages';
+import type { ObjectiveDef, ObjectiveState } from './objectives';
+import type { GamePack } from './packs/pack';
+import type { World } from './world';
+/**
+ * The map objectives pack's id
+ *
+ * @beta
+ */
+export declare const MAP_OBJECTIVES = "core.mapObjectives";
+/**
+ * The key of the map's data its objectives are kept under (`GameMap.data.objectives`)
+ *
+ * @beta
+ */
+export declare const MAP_OBJECTIVES_KEY = "objectives";
+/**
+ * An objective a map gives, as it keeps it: an objective (`ObjectiveDef`: its id, its words, whether the mission needs
+ * it, more about it) and when it is given
+ *
+ * @beta
+ */
+export interface MapObjective extends ObjectiveDef {
+    /**
+     * When it is given: as the game starts (`start`), to every player a person plays (`mapObjectivePlayers`), or when
+     * the rules say (`rule`: `giveMapObjective(world, id)`). Anything but `rule` is the start
+     */
+    at: 'start' | 'rule';
+}
+/**
+ * The objectives a map gives (`GameMap.data.objectives`), in the order it gives them: none for a map with none. What is
+ * kept there and is no objective (no id, no words) is left out, so that a file changed by hand breaks no rule that reads
+ * it; the map's checks say so (`mapObjectives`)
+ *
+ * @beta
+ */
+export declare function mapObjectivesOf(map: {
+    readonly data: Readonly<Record<string, unknown>>;
+}): MapObjective[];
+/**
+ * Who is given a map's objective when the rules do not say (`giveMapObjective`): the map's players a person plays, not
+ * those it says the computer plays or nobody does (`MapPlayer.controller`), in the order of their ids
+ *
+ * @beta
+ */
+export declare function mapObjectivePlayers(world: World): PlayerId[];
+/**
+ * Gives players an objective of the map's, by its id (`MapObjective`): those given by a rule (`at: 'rule'`), when the
+ * rules say. To every player a person plays when `players` is left out (`mapObjectivePlayers`); a player who has it
+ * already keeps theirs. Its words' params and its progress go with it, as `world.objectives.add`. Throws for an id the
+ * map does not have: an id in the code that is not on the map is a mistake
+ *
+ * @beta
+ */
+export declare function giveMapObjective(world: World, id: string, options?: {
+    players?: readonly PlayerId[];
+    params?: Message['params'];
+    progress?: {
+        value: number;
+        max: number;
+    };
+}): ObjectiveState[];
+/**
+ * What is wrong with a map's objectives (`GameMap.data.objectives`): one with no id or with another's, one with no
+ * words, a list that is not one. Each a click away in the Objectives panel
+ *
+ * @beta
+ */
+export declare function checkMapObjectives(map: GameMap): MapProblem[];
+/**
+ * Objectives as data on the map (campaign plan EQ3): a map's objectives (`MapObjective`, kept in `GameMap.data.objectives`,
+ * written by the editor's Objectives panel) given at the start to every player a person plays, as the world is made
+ * from the map; those given by a rule wait for the rules (`giveMapObjective(world, id)`). Done and failed as any
+ * objective is (`world.objectives.complete`, `fail`); a game that is won by them has `objectiveVictory` as its
+ * `victory`. The map's checks say what is wrong with them (`checkMapObjectives`)
+ *
+ * @beta
+ */
+export declare function mapObjectives(): GamePack;

package/dist/mapObjects.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/math.d.ts

@@ -0,0 +1,44 @@
+/**
+ * A point on the ground plane. The simulation is 2D; height always comes from the terrain.
+ *
+ * @beta
+ */
+export interface Vec2 {
+    x: number;
+    z: number;
+}
+/** @beta */
+export declare const vec2: (x?: number, z?: number) => Vec2;
+/** @beta */
+export declare const clamp: (v: number, min: number, max: number) => number;
+/** @beta */
+export declare const lerp: (a: number, b: number, t: number) => number;
+/**
+ * 0 at `from` and before, 1 at `to` and after, eased in and out between: a shader's `smoothstep`
+ *
+ * @beta
+ */
+export declare const smoothstep: (from: number, to: number, x: number) => number;
+/**
+ * A number in 0..1 for two whole numbers, the same each time and in every engine (it is integer arithmetic)
+ *
+ * @beta
+ */
+export declare function hashInts(a: number, b: number): number;
+/** @beta */
+export declare const distSq: (a: Vec2, b: Vec2) => number;
+/** @beta */
+export declare const dist: (a: Vec2, b: Vec2) => number;
+/** @beta */
+export declare const lerpAngle: (a: number, b: number, t: number) => number;
+/**
+ * Axis aligned rectangle on the ground plane, described by its center and half sizes.
+ *
+ * @beta
+ */
+export interface Rect {
+    x: number;
+    z: number;
+    hw: number;
+    hd: number;
+}