@genex-ai/multiplayer 0.17.1 → 0.17.8

package/dist/level-build-CbRqrYJq.d.ts

@@ -0,0 +1,140 @@
+/** Why a level was refused. A refusal says this code and names what to change. */
+declare const LevelRefusalCode: {
+    /** Not a glb or a glTF, or not a file that can be read. */
+    readonly NotGltf: "not_gltf";
+    /** A glb's chunks do not add up. */
+    readonly BadContainer: "bad_container";
+    /** glTF 1 or a version this reader does not take. */
+    readonly BadVersion: "bad_version";
+    /** An index that names nothing: a scene, a node, a mesh, an accessor, a buffer. */
+    readonly BadReference: "bad_reference";
+    /** An accessor or a view that does not fit what it reads or is not what it must be. */
+    readonly BadAccessor: "bad_accessor";
+    /** A triangle's index past its vertices. */
+    readonly BadIndex: "bad_index";
+    /** A transform or a field of the wrong shape. */
+    readonly BadValue: "bad_value";
+    /** NaN, an infinity, or a coordinate past the format's range. */
+    readonly NotFinite: "not_finite";
+    /** A cycle, or a node with two parents. */
+    readonly NodeCycle: "node_cycle";
+    /** Past a stated limit (LEVEL_LIMITS). */
+    readonly TooLarge: "too_large";
+    /** Draco or meshopt on something that collides. */
+    readonly Compressed: "compressed";
+    /** A required extension this reader cannot honour. */
+    readonly UnknownExtension: "unknown_extension";
+    /** A buffer URI that leaves the input's folder, names the network, or is not a plain file. */
+    readonly UriRefused: "uri_refused";
+    /** A skinned mesh that collides. */
+    readonly Skinned: "skinned";
+    /** A mesh posed by morph targets that collides. */
+    readonly Morphed: "morphed";
+    /** A kind of three.js object the helper cannot read. */
+    readonly Unsupported: "unsupported";
+    /** A mesh with no triangle left of any area. */
+    readonly Degenerate: "degenerate";
+    /** More triangles on one edge than any surface has. */
+    readonly NonManifold: "non_manifold";
+    /** No spawn: a fit starts from where a hull can stand. */
+    readonly NoSpawn: "no_spawn";
+    /** Nothing collides. */
+    readonly NoSurface: "no_surface";
+    /** A mark that is not one. */
+    readonly BadMark: "bad_mark";
+};
+type LevelRefusalCode = (typeof LevelRefusalCode)[keyof typeof LevelRefusalCode];
+/** A level refused by name: `code` says why, the message names the node or field and what to do. */
+declare class LevelRefusal extends Error {
+    readonly code: LevelRefusalCode;
+    constructor(code: LevelRefusalCode, message: string);
+}
+/** What this path takes. Each is refused before anything is decoded or allocated for it. */
+declare const LEVEL_LIMITS: {
+    /** One glb, or one external buffer, and all buffers together. */
+    readonly maxFileBytes: number;
+    /** Triangles in the level, instances counted. A fit reads a scene of this size; art past it needs a proxy. */
+    readonly maxTriangles: 8000000;
+    /** Vertices one accessor may read. */
+    readonly maxVertices: 24000000;
+    readonly maxNodes: 1000000;
+    readonly maxDepth: 1024;
+    /** Points a `hull` holds, as the scene format says. */
+    readonly maxHullPoints: 4096;
+    /** No surface puts more triangles on one edge: past this it is junk, or an attack on what reads it. */
+    readonly maxTrianglesOnEdge: 64;
+};
+/** What a surface answers, as a creator marks it. `both` is the default; `none` is only drawn. */
+declare const LevelCollide: {
+    readonly Both: "both";
+    readonly Move: "move";
+    readonly Shot: "shot";
+    readonly None: "none";
+};
+type LevelCollide = (typeof LevelCollide)[keyof typeof LevelCollide];
+/** How a mesh becomes surfaces. Unmarked, a closed axis-aligned cube becomes an exact box and the rest stays triangles. */
+declare const LevelShape: {
+    readonly Mesh: "mesh";
+    readonly Box: "box";
+    readonly Hull: "hull";
+};
+type LevelShape = (typeof LevelShape)[keyof typeof LevelShape];
+/** A node's own mark, from its name and its `extras.genex` (`userData.genex` in three.js). */
+interface LevelMark {
+    readonly collide?: LevelCollide;
+    readonly shape?: LevelShape;
+    readonly movable?: boolean;
+    readonly prop?: boolean;
+    readonly spawn?: boolean;
+    readonly tags?: readonly string[];
+}
+/** A node's own mark: what its name spells, then its `extras.genex`, which wins. Refuses a mark that is not one. */
+declare function levelMarkOf(name: string, genex: unknown, where?: string, allowSettings?: boolean): LevelMark;
+interface LevelHull {
+    readonly radius: number;
+    readonly height: number;
+    readonly crouchHeight: number;
+    readonly step: number;
+    readonly jump: number;
+    readonly leap: number;
+}
+/** The scene as JSON holds it, base64 for the big arrays: `parseWorldScene` takes exactly this. */
+interface RawWorldScene {
+    readonly format: 'genex-world-scene';
+    readonly version: 1;
+    readonly unitsPerMeter: number;
+    readonly source: Readonly<Record<string, string>>;
+    readonly hull?: LevelHull;
+    readonly actors: readonly RawActor[];
+    readonly spawns: readonly {
+        readonly at: readonly number[];
+        readonly name?: string;
+        readonly tags?: readonly string[];
+    }[];
+}
+interface RawActor {
+    readonly name: string;
+    readonly tags?: readonly string[];
+    readonly surfaces: readonly RawSurface[];
+}
+type RawSurface = {
+    readonly kind: string;
+} & Readonly<Record<string, unknown>>;
+interface LevelStats {
+    readonly actors: number;
+    readonly boxes: number;
+    readonly hulls: number;
+    readonly meshes: number;
+    readonly triangles: number;
+    readonly spawns: number;
+}
+interface LevelScene {
+    readonly scene: RawWorldScene;
+    /** What was kept or dropped that a creator may want to look at. Never in the scene's bytes. */
+    readonly notes: readonly string[];
+    readonly stats: LevelStats;
+    /** The scene's bytes, as text: one file, the same on every OS. */
+    readonly json: string;
+}
+
+export { type LevelScene as L, type RawWorldScene as R, type LevelHull as a, LEVEL_LIMITS as b, LevelCollide as c, type LevelMark as d, LevelRefusal as e, LevelRefusalCode as f, LevelShape as g, levelMarkOf as l };