emeraldengine 2.2.1 → 3.0.0

package/dist/types/src/Serializer.d.ts

@@ -0,0 +1,86 @@
+export default Serializer;
+/**
+ * @class Serializer
+ * @description Saves/loads a scene to/from plain JSON. Because components hold
+ * live GL/physics handles that can't be serialized generically, reconstruction
+ * goes through registered factories keyed by a `prefabType`. Each object's
+ * transform, layer, opacity and an optional `serialize()` payload are captured.
+ *
+ * @example
+ * Serializer.register("coin", (data) => makeCoin(data.value));
+ * coin.prefabType = "coin";
+ * coin.serialize = () => ({ value: 5 });
+ *
+ * const json = Serializer.toJSON(scene);          // save
+ * Serializer.fromJSON(json, new Scene());          // load
+ */
+declare class Serializer {
+    /**
+     * @method register
+     * @description Registers a factory that rebuilds an object from its data.
+     * @param {string} type - The prefabType
+     * @param {(data:any, entry:any) => Object} factory - Returns a GameObject
+     */
+    static register(type: string, factory: (data: any, entry: any) => any): void;
+    /**
+     * @method serializeObject
+     * @description Captures a single object's serializable state.
+     */
+    static serializeObject(obj: any): {
+        type: any;
+        name: any;
+        layer: any;
+        opacity: any;
+        screenSpace: boolean;
+        transform: {
+            position: {
+                x: any;
+                y: any;
+                z: any;
+            };
+            rotation: any;
+            scale: {
+                x: any;
+                y: any;
+            };
+        };
+        data: any;
+    };
+    /**
+     * @method serializeScene
+     * @description Returns a plain object describing the scene.
+     */
+    static serializeScene(scene: any): {
+        objects: any;
+    };
+    /**
+     * @method applyState
+     * @description Applies a serialized entry's transform/layer/opacity to an object.
+     */
+    static applyState(obj: any, entry: any): void;
+    /**
+     * @method deserializeObject
+     * @description Rebuilds an object from an entry via its registered factory.
+     * @returns {Object|null}
+     */
+    static deserializeObject(entry: any): any | null;
+    /**
+     * @method deserializeScene
+     * @description Rebuilds objects into the given scene.
+     * @returns {Scene} - The populated scene
+     */
+    static deserializeScene(json: any, scene: any): Scene;
+    /**
+     * @method toJSON
+     * @description Serializes a scene to a JSON string.
+     */
+    static toJSON(scene: any): string;
+    /**
+     * @method fromJSON
+     * @description Loads a scene from a JSON string into the given scene.
+     */
+    static fromJSON(str: any, scene: any): Scene;
+}
+declare namespace Serializer {
+    let factories: Map<any, any>;
+}

package/dist/types/src/Shaders.d.ts

@@ -0,0 +1,2 @@
+export const STANDARD_VERTEX_SHADER: "\n  attribute vec4 aVertexPosition;\n  attribute vec2 aTextureCoord;\n  \n  attribute vec4 aInstanceMatrix0;\n  attribute vec4 aInstanceMatrix1;\n  attribute vec4 aInstanceMatrix2;\n  attribute vec4 aInstanceMatrix3;\n  \n  attribute vec2 aInstanceTexCoord0;\n  attribute vec2 aInstanceTexCoord1;\n  attribute vec2 aInstanceTexCoord2;\n  attribute vec2 aInstanceTexCoord3;\n\n  attribute vec4 aInstanceColor;\n\n  uniform mat4 uModelViewMatrix;\n  uniform mat4 uInstancedModelViewMatrix;\n  uniform mat4 uProjectionMatrix;\n  uniform bool useInstances;\n\n  varying highp vec2 vTexCoord;\n  varying vec2 vFragPos;\n  varying vec4 vInstanceColor;\n\n  void main() {\n    mat4 instanceMatrix = mat4(\n      aInstanceMatrix0,\n      aInstanceMatrix1,\n      aInstanceMatrix2,\n      aInstanceMatrix3\n    );\n    \n    if(useInstances) {\n        gl_Position = uProjectionMatrix * uInstancedModelViewMatrix * instanceMatrix * aVertexPosition;\n        vFragPos = (uInstancedModelViewMatrix * instanceMatrix * aVertexPosition).xy;\n        vInstanceColor = aInstanceColor;\n\n        int vertexIndex = int(aVertexPosition.x > 0.0 ? (aVertexPosition.y > 0.0 ? 0 : 2) : (aVertexPosition.y > 0.0 ? 1 : 3));\n        \n        if(vertexIndex == 0) {\n            vTexCoord = aInstanceTexCoord0;\n        } else if(vertexIndex == 1) {\n            vTexCoord = aInstanceTexCoord1;\n        } else if(vertexIndex == 2) {\n            vTexCoord = aInstanceTexCoord2;\n        } else {\n            vTexCoord = aInstanceTexCoord3;\n        }\n    } else {\n        gl_Position = uProjectionMatrix * uModelViewMatrix * aVertexPosition;\n        vFragPos = (uModelViewMatrix * aVertexPosition).xy;\n        vTexCoord = aTextureCoord;\n        vInstanceColor = vec4(1.0);\n    }\n  }\n";
+export const STANDARD_FRAGMENT_SHADER: "\n    #ifdef GL_ES\n    precision highp float;\n    #endif\n    uniform bool useTexture;\n    uniform vec4 uColor;\n    uniform sampler2D uSampler;\n    uniform float uOpacity;\n\n    uniform vec2 uLightPosition[4];\n    uniform vec3 uLightColor[4];\n    uniform float uLightIntensity[4];\n    uniform float uLightRadius[4];\n    uniform int uActiveLights;\n    \n    uniform vec2 uDirLightPosition[4];\n    uniform vec2 uDirLightDirection[4];\n    uniform vec3 uDirLightColor[4];\n    uniform float uDirLightIntensity[4];\n    uniform float uDirLightWidth[4];\n    uniform int uActiveDirLights;\n    \n    uniform vec3 uAmbientLightValues;\n    uniform bool uUseLighting;\n\n    varying vec2 vTexCoord;\n    varying vec2 vFragPos;\n    varying vec4 vInstanceColor;\n\n    void main() {\n        vec4 ambientLight = vec4(uAmbientLightValues.xyz, 1.0);\n\n        vec4 texColor;\n        if (useTexture) {\n            texColor = texture2D(uSampler, vTexCoord);\n            if (texColor.a < 0.01) discard;\n            texColor *= uColor;\n        } else {\n            texColor = uColor;\n        }\n\n        texColor *= vInstanceColor;\n        \n        vec3 lighting = ambientLight.rgb;\n        \n        for(int i = 0; i < 4; i++) {\n            if(i >= uActiveLights) break;\n            \n            float distance = length(uLightPosition[i] - vFragPos);\n            \n            if(distance < uLightRadius[i]) {\n                float attenuation = 1.0 - distance / uLightRadius[i];\n                \n                lighting += uLightColor[i] * attenuation * uLightIntensity[i];\n            }\n        }\n        \n        for(int i = 0; i < 4; i++) {\n            if(i >= uActiveDirLights) break;\n            \n            vec2 lightPos = uDirLightPosition[i];\n            vec2 lightDir = normalize(uDirLightDirection[i]);\n            vec2 toFrag = vFragPos - lightPos;\n            \n            float projection = dot(toFrag, lightDir);\n            if(projection < 0.0) continue;\n            \n            float perpDistance = abs(dot(toFrag, vec2(-lightDir.y, lightDir.x)));\n            \n            if(perpDistance > uDirLightWidth[i] * 0.5) continue;\n            \n            float widthFactor = 1.0 - (perpDistance / (uDirLightWidth[i] * 0.5));\n            \n            float distance = length(toFrag);\n            float maxDistance = 1000.0;\n            float distanceFactor = max(0.0, 1.0 - (distance / maxDistance));\n            \n            lighting += uDirLightColor[i] * uDirLightIntensity[i] * widthFactor * distanceFactor;\n        }\n        \n        vec4 outColor;\n        if (uUseLighting) {\n            outColor = vec4(texColor.rgb * lighting, texColor.a);\n        } else {\n            outColor = texColor;\n        }\n        outColor.a *= clamp(uOpacity, 0.0, 1.0);\n        gl_FragColor = outColor;\n    }\n";

package/dist/types/{Shapes.d.ts → src/Shapes.d.ts}

@@ -1,16 +1,15 @@
-import Drawable from "./Drawable";
 /**
  * @class Square2D
  * @description Represents a square 2D shape
  */
-declare class Square2D extends Drawable {
+export class Square2D extends Drawable {
     constructor();
 }
 /**
  * @class Triangle2D
  * @description Represents a triangle 2D shape
  */
-declare class Triangle2D extends Drawable {
+export class Triangle2D extends Drawable {
     constructor();
 }
 /**
@@ -18,8 +17,7 @@ declare class Triangle2D extends Drawable {
  * @description Represents a circle 2D shape
  * @param {number} segments - The number of segments to use to draw the circle
  */
-declare class Circle2D extends Drawable {
+export class Circle2D extends Drawable {
     constructor(segments?: number);
 }
-export { Square2D, Triangle2D, Circle2D };
-//# sourceMappingURL=Shapes.d.ts.map
+import Drawable from "./Drawable.js";

package/dist/types/src/SpatialGrid.d.ts

@@ -0,0 +1,50 @@
+export default SpatialGrid;
+/**
+ * @class SpatialGrid
+ * @description A uniform spatial hash grid for fast 2D neighbor queries (picking,
+ * proximity, broadphase). Rebuild it each frame (or as objects move) with
+ * clear()/insert(), then query by radius or rectangle.
+ *
+ * @example
+ * const grid = new SpatialGrid(64);
+ * grid.clear();
+ * for (const e of enemies) grid.insert(e, e.transform.position.x, e.transform.position.y);
+ * const near = grid.queryRadius(player.x, player.y, 100);
+ */
+declare class SpatialGrid {
+    /**
+     * @param {number} cellSize - World units per cell
+     */
+    constructor(cellSize?: number);
+    cellSize: number;
+    cells: Map<any, any>;
+    /** @private */
+    private _key;
+    /** @private */
+    private _cell;
+    /**
+     * @method clear
+     * @description Empties the grid.
+     */
+    clear(): void;
+    /**
+     * @method insert
+     * @description Inserts an item at a world position.
+     * @param {*} item - The item to store
+     * @param {number} x - World x
+     * @param {number} y - World y
+     */
+    insert(item: any, x: number, y: number): void;
+    /**
+     * @method queryRect
+     * @description Returns items whose stored position lies within a rectangle.
+     * @returns {Array} - Matching items
+     */
+    queryRect(minX: any, minY: any, maxX: any, maxY: any): any[];
+    /**
+     * @method queryRadius
+     * @description Returns items within a radius of a point.
+     * @returns {Array} - Matching items
+     */
+    queryRadius(x: any, y: any, radius: any): any[];
+}

package/dist/types/src/SpriteBatch.d.ts

@@ -0,0 +1,89 @@
+export default SpriteBatch;
+/**
+ * @class SpriteBatch
+ * @description A dynamic batched sprite renderer. Instead of one draw call per
+ * sprite (as ordinary Drawables incur), it accumulates many sprites that share a
+ * texture into a single interleaved buffer and submits them in one
+ * `drawElements` call. Batches are flushed automatically when the texture
+ * changes or the buffer fills, so for content that shares a texture/atlas this
+ * collapses hundreds of draw calls into a handful.
+ *
+ * It uses its own minimal shader program (position + uv + per-vertex color), so
+ * it is independent of the main render pipeline.
+ *
+ * @example
+ * const batch = new SpriteBatch();
+ * batch.begin(projectionMatrix, viewMatrix); // gl-matrix mat4s
+ * for (const e of entities) {
+ *   batch.draw({ texture: atlasTex, x: e.x, y: e.y, w: 32, h: 32,
+ *                u0: e.u0, v0: e.v0, u1: e.u1, v1: e.v1 });
+ * }
+ * batch.end();
+ */
+declare class SpriteBatch {
+    /**
+     * @method _writeQuad
+     * @description Pure helper that writes one quad's 4 interleaved vertices
+     * (position, uv, color) into `out` at `offset`. Positions are rotated around
+     * the quad center (cx, cy). Exposed (and side-effect free) for testing.
+     * @private
+     */
+    private static _writeQuad;
+    /**
+     * @param {Object} [options] - { maxQuads = 2000 }
+     */
+    constructor(options?: any);
+    gl: WebGLRenderingContext;
+    maxQuads: any;
+    program: any;
+    attribs: {
+        pos: number;
+        uv: number;
+        color: number;
+    };
+    uniforms: {
+        projection: WebGLUniformLocation;
+        view: WebGLUniformLocation;
+        sampler: WebGLUniformLocation;
+    };
+    vertexData: Float32Array<ArrayBuffer>;
+    vertexBuffer: WebGLBuffer;
+    indexBuffer: WebGLBuffer;
+    /** @private */
+    private _quadCount;
+    /** @private */
+    private _currentTexture;
+    /** @private */
+    private _projection;
+    /** @private */
+    private _view;
+    drawCalls: number;
+    /**
+     * @method begin
+     * @description Starts a batch with the given projection and view matrices
+     * (gl-matrix mat4 / Float32Array(16)).
+     */
+    begin(projectionMatrix: any, viewMatrix: any): void;
+    /**
+     * @method draw
+     * @description Queues one sprite. Flushes first if the texture changed or the
+     * batch is full.
+     * @param {Object} sprite - {
+     *   texture, x, y, w, h,
+     *   rotation = 0, originX = 0.5, originY = 0.5,
+     *   u0 = 0, v0 = 0, u1 = 1, v1 = 1,
+     *   r = 1, g = 1, b = 1, a = 1
+     * }
+     */
+    draw(sprite: any): void;
+    /**
+     * @method end
+     * @description Flushes any remaining sprites.
+     */
+    end(): void;
+    /**
+     * @method flush
+     * @description Uploads and draws the currently staged quads.
+     */
+    flush(): void;
+}

package/dist/types/src/StateMachine.d.ts

@@ -0,0 +1,59 @@
+export default StateMachine;
+/**
+ * @class StateMachine
+ * @description A lightweight finite state machine for entity AI, animation
+ * states, game flow, etc. Each state can define `enter`, `update(dt)`, and
+ * `exit` handlers. Drive it from a Behaviour's update().
+ *
+ * @example
+ * const fsm = new StateMachine();
+ * fsm.add("idle", {
+ *   update: (dt, sm) => { if (seesPlayer) sm.set("chase"); },
+ * });
+ * fsm.add("chase", {
+ *   enter: () => playRoarSound(),
+ *   update: (dt, sm) => moveTowardPlayer(dt),
+ * });
+ * fsm.set("idle");
+ * // in update(dt): fsm.update(dt);
+ */
+declare class StateMachine {
+    states: Map<any, any>;
+    current: any;
+    currentName: any;
+    previousName: any;
+    /**
+     * @method add
+     * @description Registers a state.
+     * @param {string} name - State name
+     * @param {{enter?:Function, update?:Function, exit?:Function}} handlers
+     * @returns {StateMachine} - this
+     */
+    add(name: string, handlers: {
+        enter?: Function;
+        update?: Function;
+        exit?: Function;
+    }): StateMachine;
+    /**
+     * @method set
+     * @description Transitions to a state, running exit/enter handlers. Re-entering
+     * the same state is a no-op unless `force` is true.
+     * @param {string} name - Target state name
+     * @param {boolean} [force] - Allow re-entering the current state
+     * @returns {StateMachine} - this
+     */
+    set(name: string, force?: boolean): StateMachine;
+    /**
+     * @method update
+     * @description Runs the current state's update handler.
+     * @param {number} dt - Seconds since the last frame
+     */
+    update(dt: number): void;
+    /**
+     * @method is
+     * @description Whether the given state is current.
+     * @param {string} name
+     * @returns {boolean}
+     */
+    is(name: string): boolean;
+}

package/dist/types/src/Storage.d.ts

@@ -0,0 +1,89 @@
+export default Storage;
+/**
+ * @class Storage
+ * @description Manages the storage of the game
+ */
+declare class Storage {
+    /**
+     * @method writeToLocalStorage
+     * @description Writes to local storage
+     * @param {string} key - The key to write to
+     * @param {any} value - The value to write to
+     */
+    static writeToLocalStorage(key: string, value: any): void;
+    /**
+     * @method readFromLocalStorage
+     * @description Reads from local storage
+     * @param {string} key - The key to read from
+     * @returns {any} - The value read from local storage
+     */
+    static readFromLocalStorage(key: string): any;
+    /**
+     * @method clearLocalStorage
+     * @description Clears local storage
+     */
+    static clearLocalStorage(): void;
+    /**
+     * @method writeToSessionStorage
+     * @description Writes to session storage
+     * @param {string} key - The key to write to
+     * @param {any} value - The value to write to
+     */
+    static writeToSessionStorage(key: string, value: any): void;
+    /**
+     * @method readFromSessionStorage
+     * @description Reads from session storage
+     * @param {string} key - The key to read from
+     * @returns {any} - The value read from session storage
+     */
+    static readFromSessionStorage(key: string): any;
+    /**
+     * @method clearSessionStorage
+     * @description Clears session storage
+     */
+    static clearSessionStorage(): void;
+    /**
+     * @method save
+     * @description Writes a versioned save under `key`. The payload is wrapped in
+     * an envelope `{ v, t, data }` so it can be migrated later, and the previous
+     * value is mirrored to `key + ".bak"` for corruption recovery. Quota and
+     * serialization errors are caught and reported rather than thrown.
+     * @param {string} key - The storage key
+     * @param {any} data - The data to persist (must be JSON-serializable)
+     * @param {Object} [options] - { version = 1, backup = true }
+     * @returns {boolean} - Whether the write succeeded
+     */
+    static save(key: string, data: any, options?: any): boolean;
+    /**
+     * @method _unwrap
+     * @description Parses a stored string into a `{ v, data }` envelope, treating
+     * a plain (pre-versioning) value as version 0. Returns undefined for missing
+     * data and throws for malformed JSON.
+     * @private
+     */
+    private static _unwrap;
+    /**
+     * @method load
+     * @description Reads a versioned save written by `save`. If the primary value
+     * is corrupt it falls back to the `.bak` copy; if that fails too it returns
+     * `fallback`. When the stored version differs from `version` and a `migrate`
+     * function is given, the data is upgraded (and rewritten unless disabled).
+     * @param {string} key - The storage key
+     * @param {Object} [options] - { version = 1, fallback = null, migrate, rewrite = true }
+     * @returns {any} - The (possibly migrated) saved data, or `fallback`
+     */
+    static load(key: string, options?: any): any;
+    /**
+     * @method hasSave
+     * @description Returns whether a save (or its backup) exists for `key`.
+     * @param {string} key - The storage key
+     * @returns {boolean}
+     */
+    static hasSave(key: string): boolean;
+    /**
+     * @method removeSave
+     * @description Deletes a save and its backup.
+     * @param {string} key - The storage key
+     */
+    static removeSave(key: string): void;
+}

package/dist/types/{Texture.d.ts → src/Texture.d.ts}

@@ -1,4 +1,4 @@
-import Drawable from "./Drawable";
+export default Texture;
 /**
  * @class Texture
  * @description Represents a texture component
@@ -13,7 +13,6 @@ import Drawable from "./Drawable";
  * @param {boolean} useLighting - Whether the texture should react to lighting
  */
 declare class Texture extends Drawable {
-    constructor(texturePath?: string, frameWidth?: number, frameHeight?: number, framesPerRow?: number, totalFrames?: number, animationSpeed?: number, autoPlay?: boolean, pixelart?: boolean, useLighting?: boolean);
+    constructor(texturePath?: {}, frameWidth?: number, frameHeight?: number, framesPerRow?: number, totalFrames?: number, animationSpeed?: number, autoPlay?: boolean, pixelart?: boolean, useLighting?: boolean);
 }
-export default Texture;
-//# sourceMappingURL=Texture.d.ts.map
+import Drawable from "./Drawable.js";

package/dist/types/src/TextureAtlas.d.ts

@@ -0,0 +1,55 @@
+export default TextureAtlas;
+/**
+ * @class TextureAtlas
+ * @description Loads a packed sprite atlas (image + frame rectangles) and applies
+ * named frames to Drawables as normalized UV regions. Accepts TexturePacker
+ * JSON (hash or array `frames`) or a plain `{ name: {x,y,w,h} }` map.
+ *
+ * @example
+ * const atlas = await TextureAtlas.load("sheet.png", sheetJson, true);
+ * const sprite = new Texture(atlas.texturePath, 0, 0, 1, 1, 0, false, true);
+ * obj.addComponent(sprite);
+ * atlas.applyTo(sprite, "player_idle_0");
+ */
+declare class TextureAtlas {
+    /**
+     * @method load
+     * @description Loads the atlas image (caching its GL texture) and parses frames.
+     * @param {string} texturePath
+     * @param {Object} atlasJson - Atlas description
+     * @param {boolean} [pixelart] - Filter mode for the cached texture
+     * @returns {Promise<TextureAtlas>}
+     */
+    static load(texturePath: string, atlasJson: any, pixelart?: boolean): Promise<TextureAtlas>;
+    /** @private */
+    private static _parse;
+    constructor(texturePath: any, frames: any, width: any, height: any);
+    texturePath: any;
+    frames: any;
+    width: any;
+    height: any;
+    /**
+     * @method getFrame
+     * @description Returns the pixel rect { x, y, w, h } for a frame name.
+     */
+    getFrame(name: any): any;
+    /**
+     * @method getRegion
+     * @description Returns the normalized UV region for a frame name.
+     * @returns {{left,top,right,bottom}|null}
+     */
+    getRegion(name: any): {
+        left: any;
+        top: any;
+        right: any;
+        bottom: any;
+    } | null;
+    /**
+     * @method applyTo
+     * @description Applies a frame's UV region to a Drawable.
+     * @param {Drawable} drawable
+     * @param {string} name - Frame name
+     * @returns {TextureAtlas} - this
+     */
+    applyTo(drawable: Drawable, name: string): TextureAtlas;
+}

package/dist/types/src/Tilemap.d.ts

@@ -0,0 +1,91 @@
+export default Tilemap;
+/**
+ * @class Tilemap
+ * @description Builds a grid of tiles from a 2D array of frame indices, rendered
+ * as a single instanced draw call. Use -1 (or null) for empty cells. The tiles
+ * live on `tilemap.gameObject`, which you add to the scene.
+ *
+ * @example
+ * const map = new Tilemap("level", "tiles.png", {
+ *   tileSize: 32, frameWidth: 16, frameHeight: 16, framesPerRow: 4, totalFrames: 16,
+ * });
+ * map.setMap([
+ *   [0, 0, 0, 0],
+ *   [1, -1, -1, 1],
+ *   [2, 2, 2, 2],
+ * ]);
+ * scene.add(map.gameObject);
+ */
+declare class Tilemap {
+    /**
+     * @method computeAutoTile
+     * @description Pure helper that converts a 2D solidity grid into a 2D frame
+     * index grid using 4-bit edge bitmasking. For each solid cell the neighbor
+     * mask is built as up|right|down|left (bits 1,2,4,8); empty cells become -1.
+     * Provide `frames` (a length-16 lookup from mask -> frame index) to match your
+     * tilesheet layout; otherwise the mask itself is used as the frame index, and
+     * `base` is added to every solid frame.
+     *
+     * @param {Array<Array<boolean|number>>} grid - Truthy = solid
+     * @param {Object} [options] - { frames, base = 0, edgesSolid = true }
+     * @returns {number[][]} - Frame indices (-1 for empty)
+     */
+    static computeAutoTile(grid: Array<Array<boolean | number>>, options?: any): number[][];
+    /**
+     * @param {string} name - Name for the underlying GameObject
+     * @param {string} texturePath - Path to the tile sheet
+     * @param {Object} [options] - tileSize, frameWidth, frameHeight, framesPerRow, totalFrames, pixelart
+     */
+    constructor(name: string, texturePath: string, options?: any);
+    name: string;
+    tileSize: any;
+    /** @private */
+    private _config;
+    gameObject: GameObject;
+    texture: InstancedTexture;
+    /** @private */
+    private _map;
+    /** @private */
+    private _layout;
+    /** @private */
+    private _colliders;
+    /**
+     * @method setMap
+     * @description Builds (or rebuilds) the tile instances from a 2D array.
+     * @param {number[][]} map - Rows of frame indices (-1/null = empty)
+     * @param {Object} [options] - { originX = 0, originY = 0, flipY = true }
+     * @returns {Tilemap} - this
+     */
+    setMap(map: number[][], options?: any): Tilemap;
+    /**
+     * @method buildColliders
+     * @description Generates static physics colliders from the current map. Solid
+     * cells are merged greedily into horizontal runs, so a row of N tiles becomes
+     * one box collider instead of N — far fewer bodies for the physics engine.
+     * The bodies are tagged so collision callbacks resolve back to `ownerObject`
+     * (defaults to the tilemap's GameObject). Call again after setMap to rebuild.
+     *
+     * @param {Physics} physics - The physics engine
+     * @param {Object} [options] - { isSolid, friction = 0.2, restitution = 0,
+     *   density = 0, ownerObject }
+     * @returns {Tilemap} - this
+     */
+    buildColliders(physics: Physics, options?: any): Tilemap;
+    /**
+     * @method clearColliders
+     * @description Destroys the physics bodies created by buildColliders.
+     * @returns {Tilemap} - this
+     */
+    clearColliders(): Tilemap;
+    /**
+     * @method setAutoTiledMap
+     * @description Convenience: computes frame indices from a solidity grid using
+     * bitmask auto-tiling, then builds the map. See Tilemap.computeAutoTile.
+     * @param {Array<Array<boolean|number>>} solidGrid - Truthy = solid cell
+     * @param {Object} [options] - Auto-tile options + setMap options
+     * @returns {Tilemap} - this
+     */
+    setAutoTiledMap(solidGrid: Array<Array<boolean | number>>, options?: any): Tilemap;
+}
+import GameObject from "./components/GameObject.js";
+import InstancedTexture from "./InstancedTexture.js";

package/dist/types/src/Time.d.ts

@@ -0,0 +1,53 @@
+export default Time;
+/**
+ * @class Time
+ * @description Global time state for the game. `deltaTime` is the (scaled)
+ * seconds since the last frame, `elapsedTime` accumulates total scaled time, and
+ * `timeScale` lets you slow down / speed up / pause the simulation.
+ */
+declare class Time {
+    /**
+     * @method getDeltaTime
+     * @description Returns the (time-scaled) delta time in seconds
+     * @returns {number} - The delta time
+     */
+    static getDeltaTime(): number;
+    /**
+     * @method setDeltaTime
+     * @description Sets the delta time. The stored value is multiplied by
+     * `timeScale`, and `elapsedTime` is advanced by the scaled amount. Called by
+     * `Emerald.drawScene`, but can be called manually for custom loops.
+     * @param {number} deltaTime - The unscaled delta time in seconds
+     */
+    static setDeltaTime(deltaTime: number): void;
+    /**
+     * @method getUnscaledDeltaTime
+     * @description Returns the raw delta time, ignoring timeScale
+     * @returns {number} - The unscaled delta time
+     */
+    static getUnscaledDeltaTime(): number;
+    /**
+     * @method getElapsedTime
+     * @description Returns the total accumulated (scaled) time in seconds
+     * @returns {number} - The elapsed time
+     */
+    static getElapsedTime(): number;
+    /**
+     * @method setTimeScale
+     * @description Sets the time scale (1 = normal, 0 = paused, 2 = double speed)
+     * @param {number} scale - The time scale (clamped to >= 0)
+     */
+    static setTimeScale(scale: number): void;
+    /**
+     * @method getTimeScale
+     * @description Returns the current time scale
+     * @returns {number} - The time scale
+     */
+    static getTimeScale(): number;
+}
+declare namespace Time {
+    let deltaTime: number;
+    let unscaledDeltaTime: number;
+    let elapsedTime: number;
+    let timeScale: number;
+}