melonjs 20.2.0 → 20.4.0

package/build/level/level.d.ts

@@ -1,8 +1,6 @@
 export namespace level {
     /**
      * add a level into the game manager (usually called by the preloader)
-     * @name add
-     * @memberof level
      * @public
      * @param {string} format - level format ("tmx" for Tiled maps, "gltf" / "glb" for 3D scenes)
      * @param {string} levelId - the level id (or name)
@@ -11,76 +9,58 @@ export namespace level {
      */
     function add(format: string, levelId: string, callback?: Function): boolean;
     /**
-     * load a level into the game manager<br>
+     * load a level into the game manager, and return a promise that settles once
+     * it is actually in the world<br>
      * (will also create all level defined entities, etc..)
-     * @name load
-     * @memberof level
-     * @public
+     *
+     * `options.onLoaded` still fires, so the two forms mix freely. An unknown
+     * `levelId` throws SYNCHRONOUSLY rather than rejecting — that is a typo, not
+     * a load failure, and it should not need `await` to surface.
+     * @overload
      * @param {string} levelId - level id
-     * @param {object} [options] - additional optional parameters
-     * @param {Container} [options.container=game.world] - container in which to load the specified level
-     * @param {Function} [options.onLoaded=game.onLevelLoaded] - callback for when the level is fully loaded
-     * @param {boolean} [options.flatten=game.mergeGroup] - (TMX only) if true, flatten all objects into the given container
-     * @param {boolean} [options.setViewportBounds=true] - (TMX only) if true, set the viewport bounds to the map size
-     * @param {number} [options.scale=1] - (glTF/GLB only) pixels per glTF unit applied to the whole scene
-     * @param {boolean} [options.rightHanded=true] - (glTF/GLB only) convert the right-handed (Y-up) source to the engine's Y-down via a rotation rather than a mirror
-     * @param {boolean} [options.lights=true] - (glTF/GLB only) add the scene's authored `KHR_lights_punctual` lights (plus a soft ambient fill) as {@link Light3d} world children; each carries its authored name for `getChildByName` lookups
-     * @param {number} [options.lightIntensityScale] - (glTF/GLB only) multiply each light's authored physical intensity (lux/candela) by this factor instead of normalizing it to 1 — see {@link GLTFScene#addTo}
-     * @param {boolean} [options.castGroundShadow] - (glTF/GLB only) give this scene's meshes a ground shadow ({@link Mesh#castGroundShadow}). Overrides the application's `castGroundShadow` setting for this scene, in both directions; omit it to inherit. As a scene-wide opt-in it skips nodes with no vertical extent — a scene's ground plane is exactly that, and shadowing it with itself smears a blob across the whole floor
-     * @param {number} [options.shadowGroundY] - (glTF/GLB only) world Y of the floor those shadows land on ({@link Mesh#shadowGroundY}); omit it and each blob sits at its own object's base at full strength, which is right for a scene whose props already rest on the ground
-     * @returns {boolean} true if the level was successfully loaded
+     * @param {LevelLoadOptions & { async: true }} options - load options, with `async` set
+     * @returns {Promise<boolean>} resolves `true` once the level is in the world
      * @example
-     * // the game assets to be be preloaded
-     * // TMX maps
-     * let resources = [
-     *     {name: "a4_level1",   type: "tmx",   src: "data/level/a4_level1.tmx"},
-     *     {name: "a4_level2",   type: "tmx",   src: "data/level/a4_level2.tmx"},
-     *     {name: "a4_level3",   type: "tmx",   src: "data/level/a4_level3.tmx"},
-     *     // ...
-     * ];
+     * await me.loader.preload(game.assets);
+     * await me.level.load("a4_level1", { async: true });
+     * // the world is populated here
+     * @category Level
+     */
+    function load(levelId: string, options: LevelLoadOptions & {
+        async: true;
+    }): Promise<boolean>;
+    /**
+     * load a level into the game manager<br>
+     * (will also create all level defined entities, etc..)
      *
-     * // ...
+     * While the game loop is running the load is DEFERRED to a timer, so this
+     * returns before anything is in the world. Sequence follow-up work from
+     * `options.onLoaded`, from an `event.LEVEL_LOADED` listener, or by passing
+     * `async: true` and awaiting the promise that overload returns.
      *
-     * // load a level into the game world
+     * Note that `await me.level.load(id)` without `async: true` does not await
+     * the load: the call returns a boolean, and `await true` resolves at once.
+     * @overload
+     * @param {string} levelId - level id
+     * @param {LevelLoadOptions & { async?: false }} [options] - additional optional parameters
+     * @returns {boolean} `true`
+     * @example
+     * // load a level
      * me.level.load("a4_level1");
-     * ...
-     * ...
-     * // load a level into a specific container
-     * let levelContainer = new me.Container();
-     * me.level.load("a4_level2", {container:levelContainer});
-     * // add a simple transformation
-     * levelContainer.translate(levelContainer.width / 2, levelContainer.height / 2 );
-     * levelContainer.rotate(0.05);
-     * levelContainer.translate(-levelContainer.width / 2, -levelContainer.height / 2 );
-     * // add it to the game world
-     * app.world.addChild(levelContainer);
      *
-     * // load a glTF/GLB scene (preloaded with type "glb") under a Camera3d:
-     * // 50 pixels per glTF unit, authored lux/candela intensities kept at
-     * // a 1/1000 scale instead of being normalized to 1
+     * // load into a specific container
+     * me.level.load("a4_level2", { container: levelContainer });
+     *
+     * // a glTF/GLB scene (preloaded with type "glb") under a Camera3d:
+     * // 50 pixels per glTF unit, authored intensities kept at a 1/1000 scale
      * me.level.load("diorama", { scale: 50, lightIntensityScale: 0.001 });
-     * // …and give every prop in it a ground shadow landing on the floor at y = 0
-     * // (the scene's own ground plane is skipped — it has no height to cast)
-     * me.level.load("diorama", { scale: 50, castGroundShadow: true, shadowGroundY: 0 });
-     * // the authored lights are world children — grab the sun for a day/night cycle
-     * const sun = app.world.getChildByName("Sun")[0];
-     */
-    function load(levelId: string, options?: {
-        container?: any;
-        onLoaded?: Function | undefined;
-        flatten?: boolean | undefined;
-        setViewportBounds?: boolean | undefined;
-        scale?: number | undefined;
-        rightHanded?: boolean | undefined;
-        lights?: boolean | undefined;
-        lightIntensityScale?: number | undefined;
-        castGroundShadow?: boolean | undefined;
-        shadowGroundY?: number | undefined;
-    }): boolean;
+     * @category Level
+     */
+    function load(levelId: string, options?: (LevelLoadOptions & {
+        async?: false;
+    }) | undefined): boolean;
     /**
      * return the current level id<br>
-     * @name getCurrentLevelId
-     * @memberof level
      * @public
      * @returns {string}
      */
@@ -89,69 +69,171 @@ export namespace level {
      * return the current level definition.
      * for a reference to the live instantiated level,
      * rather use the container in which it was loaded (e.g. app.world)
-     * @name getCurrentLevel
-     * @memberof level
      * @public
      * @returns {TMXTileMap|GLTFScene} the current level object (a TMXTileMap for Tiled maps, a GLTFScene for glTF/GLB scenes)
      */
     function getCurrentLevel(): TMXTileMap | GLTFScene;
     /**
-     * reload the current level
-     * @name reload
-     * @memberof level
-     * @public
-     * @param {object} [options] - additional optional parameters
-     * @param {Container} [options.container=game.world] - container in which to load the specified level
-     * @param {Function} [options.onLoaded=game.onLevelLoaded] - callback for when the level is fully loaded
-     * @param {boolean} [options.flatten=game.mergeGroup] - if true, flatten all objects into the given container
-     * @returns {object} the current level
-     */
-    function reload(options?: {
-        container?: any;
-        onLoaded?: Function | undefined;
-        flatten?: boolean | undefined;
-    }): object;
-    /**
-     * load the next level
-     * @name next
-     * @memberof level
-     * @public
-     * @param {object} [options] - additional optional parameters
-     * @param {Container} [options.container=game.world] - container in which to load the specified level
-     * @param {Function} [options.onLoaded=game.onLevelLoaded] - callback for when the level is fully loaded
-     * @param {boolean} [options.flatten=game.mergeGroup] - if true, flatten all objects into the given container
-     * @returns {boolean} true if the next level was successfully loaded
-     */
-    function next(options?: {
-        container?: any;
-        onLoaded?: Function | undefined;
-        flatten?: boolean | undefined;
-    }): boolean;
-    /**
-     * load the previous level<br>
-     * @name previous
-     * @memberof level
-     * @public
-     * @param {object} [options] - additional optional parameters
-     * @param {Container} [options.container=game.world] - container in which to load the specified level
-     * @param {Function} [options.onLoaded=game.onLevelLoaded] - callback for when the level is fully loaded
-     * @param {boolean} [options.flatten=game.mergeGroup] - if true, flatten all objects into the given container
-     * @returns {boolean} true if the previous level was successfully loaded
-     */
-    function previous(options?: {
-        container?: any;
-        onLoaded?: Function | undefined;
-        flatten?: boolean | undefined;
-    }): boolean;
+     * reload the current level, and return a promise that settles once the level is in the world.
+     *
+     * @overload
+     * @param {LevelLoadOptions & { async: true }} options - load options, with `async` set
+     * @returns {Promise<boolean>} resolves `true` once the level is back in the world
+     * @example
+     * await me.level.reload({ async: true });
+     * @category Level
+     */
+    function reload(options: LevelLoadOptions & {
+        async: true;
+    }): Promise<boolean>;
+    /**
+     * reload the current level.
+     *
+     * While the game loop is running the load is deferred to a timer, so this
+     * returns before anything is in the world — see {@link level.load}.
+     * @overload
+     * @param {LevelLoadOptions & { async?: false }} [options] - additional optional parameters
+     * @returns {boolean} `true`
+     * @category Level
+     */
+    function reload(options?: (LevelLoadOptions & {
+        async?: false;
+    }) | undefined): boolean;
+    /**
+     * load the next level, and return a promise that settles once the level is in the world.
+     *
+     * With no level to go to this reports `false` WITHOUT loading anything, and
+     * the promise form resolves `false` rather than rejecting: running out of
+     * levels is an ordinary outcome, not an error.
+     *
+     * @overload
+     * @param {LevelLoadOptions & { async: true }} options - load options, with `async` set
+     * @returns {Promise<boolean>} resolves `true`, or `false` if there is no next level
+     * @example
+     * await me.level.next({ async: true });
+     * @category Level
+     */
+    function next(options: LevelLoadOptions & {
+        async: true;
+    }): Promise<boolean>;
+    /**
+     * load the next level.
+     *
+     * With no level to go to this reports `false` WITHOUT loading anything, and
+     * the promise form resolves `false` rather than rejecting: running out of
+     * levels is an ordinary outcome, not an error.
+     *
+     * While the game loop is running the load is deferred to a timer, so this
+     * returns before anything is in the world — see {@link level.load}.
+     * @overload
+     * @param {LevelLoadOptions & { async?: false }} [options] - additional optional parameters
+     * @returns {boolean} `true` if the next level was loaded, `false` if there is none
+     * @category Level
+     */
+    function next(options?: (LevelLoadOptions & {
+        async?: false;
+    }) | undefined): boolean;
+    /**
+     * load the previous level, and return a promise that settles once the level is in the world.
+     *
+     * With no level to go to this reports `false` WITHOUT loading anything, and
+     * the promise form resolves `false` rather than rejecting: running out of
+     * levels is an ordinary outcome, not an error.
+     *
+     * @overload
+     * @param {LevelLoadOptions & { async: true }} options - load options, with `async` set
+     * @returns {Promise<boolean>} resolves `true`, or `false` if there is no previous level
+     * @example
+     * await me.level.previous({ async: true });
+     * @category Level
+     */
+    function previous(options: LevelLoadOptions & {
+        async: true;
+    }): Promise<boolean>;
+    /**
+     * load the previous level.
+     *
+     * With no level to go to this reports `false` WITHOUT loading anything, and
+     * the promise form resolves `false` rather than rejecting: running out of
+     * levels is an ordinary outcome, not an error.
+     *
+     * While the game loop is running the load is deferred to a timer, so this
+     * returns before anything is in the world — see {@link level.load}.
+     * @overload
+     * @param {LevelLoadOptions & { async?: false }} [options] - additional optional parameters
+     * @returns {boolean} `true` if the previous level was loaded, `false` if there is none
+     * @category Level
+     */
+    function previous(options?: (LevelLoadOptions & {
+        async?: false;
+    }) | undefined): boolean;
     /**
      * return the amount of level preloaded
-     * @name levelCount
-     * @memberof level
      * @public
      * @returns {number} the amount of level preloaded
      */
     function levelCount(): number;
 }
+/**
+ * Options accepted by every level-loading call.
+ *
+ * `async` is the switch that decides what the call HANDS BACK: leave it out and
+ * you get the boolean these calls have always returned, set it and you get a
+ * promise that settles once the level is actually in the world. Everything else
+ * behaves identically either way, `onLoaded` included.
+ *
+ * Awaiting a call WITHOUT `async: true` is not an error, but it is not a wait
+ * either: the call hands back a boolean, and `await true` resolves immediately.
+ * While the loop is running the load is deferred onto a timer, so it has NOT
+ * happened by the time such an `await` resumes. Pass the flag when you mean to
+ * await.
+ */
+export type LevelLoadOptions = {
+    /**
+     * - container in which to load the specified level
+     */
+    container?: Container;
+    /**
+     * - callback for when the level is fully loaded, called in both forms
+     */
+    onLoaded?: Function;
+    /**
+     * - return a promise that settles once the level is in the world, instead of a boolean
+     */
+    async?: boolean;
+    /**
+     * - (TMX only) if true, flatten all objects into the given container
+     */
+    flatten?: boolean;
+    /**
+     * - (TMX only) if true, set the viewport bounds to the map size
+     */
+    setViewportBounds?: boolean;
+    /**
+     * - (glTF/GLB only) pixels per glTF unit applied to the whole scene
+     */
+    scale?: number;
+    /**
+     * - (glTF/GLB only) convert the right-handed (Y-up) source to the engine's Y-down via a rotation rather than a mirror
+     */
+    rightHanded?: boolean;
+    /**
+     * - (glTF/GLB only) add the scene's authored `KHR_lights_punctual` lights (plus a soft ambient fill) as {@link Light3d} world children
+     */
+    lights?: boolean;
+    /**
+     * - (glTF/GLB only) multiply each light's authored physical intensity by this factor instead of normalizing it to 1
+     */
+    lightIntensityScale?: number;
+    /**
+     * - (glTF/GLB only) give every mesh in the scene a ground shadow; omit to inherit the application's `castGroundShadow` setting (on by default)
+     */
+    castGroundShadow?: boolean;
+    /**
+     * - (glTF/GLB only) world Y the ground shadows land on
+     */
+    shadowGroundY?: number;
+};
 import TMXTileMap from "./tiled/TMXTileMap.js";
 import GLTFScene from "./gltf/GLTFScene.js";
 //# sourceMappingURL=level.d.ts.map

package/build/level/level.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"level.d.ts","sourceRoot":"","sources":["../../src/level/level.js"],"names":[],"mappings":";IA4FC;;;;;;;;;OASG;IACH,qBALW,MAAM,WACN,MAAM,wBAEJ,OAAO,CAkCnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsDG;IACH,uBAjDW,MAAM,YAEd;QAA4B,SAAS;QACV,QAAQ;QACT,OAAO;QACP,iBAAiB;QAClB,KAAK;QACJ,WAAW;QACX,MAAM;QACP,mBAAmB;QAClB,gBAAgB;QACjB,aAAa;KACtC,GAAU,OAAO,CAoEnB;IAED;;;;;;OAMG;IACH,8BAFa,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,4BAFa,UAAU,GAAC,SAAS,CAIhC;IAED;;;;;;;;;;OAUG;IACH,0BALG;QAA4B,SAAS;QACV,QAAQ;QACT,OAAO;KACjC,GAAU,MAAM,CAMlB;IAED;;;;;;;;;;OAUG;IACH,wBALG;QAA4B,SAAS;QACV,QAAQ;QACT,OAAO;KACjC,GAAU,OAAO,CASnB;IAED;;;;;;;;;;OAUG;IACH,4BALG;QAA4B,SAAS;QACV,QAAQ;QACT,OAAO;KACjC,GAAU,OAAO,CASnB;IAED;;;;;;OAMG;IACH,uBAFa,MAAM,CAIlB;;uBApTqB,uBAAuB;sBADxB,qBAAqB"}
+{"version":3,"file":"level.d.ts","sourceRoot":"","sources":["../../src/level/level.js"],"names":[],"mappings":";IAsIC;;;;;;;OAOG;IACH,qBALW,MAAM,WACN,MAAM,wBAEJ,OAAO,CAkCnB;;;;;;;;;;;;;;;;;;;IAUE,uBACQ,MAAM,WACN,gBAAgB,GAAG;QAAE,KAAK,EAAE,IAAI,CAAA;KAAE,GAChC,OAAO,CAAC,OAAO,CAAC,CAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiBA,uBACQ,MAAM;gBACuB,KAAK;qBAChC,OAAO,CACjB;IA4FH;;;;OAIG;IACH,8BAFa,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,4BAFa,UAAU,GAAC,SAAS,CAIhC;;;;;;;;;;;IAKE,yBACQ,gBAAgB,GAAG;QAAE,KAAK,EAAE,IAAI,CAAA;KAAE,GAChC,OAAO,CAAC,OAAO,CAAC,CAC1B;;;;;;;;;;;IASA;gBACqC,KAAK;qBAChC,OAAO,CACjB;;;;;;;;;;;;;;;IAoBA,uBACQ,gBAAgB,GAAG;QAAE,KAAK,EAAE,IAAI,CAAA;KAAE,GAChC,OAAO,CAAC,OAAO,CAAC,CAC1B;;;;;;;;;;;;;;;IAaA;gBACqC,KAAK;qBAChC,OAAO,CACjB;;;;;;;;;;;;;;;IAsBA,2BACQ,gBAAgB,GAAG;QAAE,KAAK,EAAE,IAAI,CAAA;KAAE,GAChC,OAAO,CAAC,OAAO,CAAC,CAC1B;;;;;;;;;;;;;;;IAaA;gBACqC,KAAK;qBAChC,OAAO,CACjB;IAeH;;;;OAIG;IACH,uBAFa,MAAM,CAIlB;;;;;;;;;;;;;;;;;;;;gBAtUY,SAAS;;;;;;;;YAET,OAAO;;;;cACP,OAAO;;;;wBACP,OAAO;;;;YACP,MAAM;;;;kBACN,OAAO;;;;aACP,OAAO;;;;0BACP,MAAM;;;;uBACN,OAAO;;;;oBACP,MAAM;;uBAtHG,uBAAuB;sBADxB,qBAAqB"}

package/build/level/tiled/TMXGroup.d.ts

@@ -1,66 +1,2 @@
-/**
- * object group definition as defined in Tiled.
- * (group definition is translated into the virtual `app.world` using `me.Container`)
- * @ignore
- */
-export default class TMXGroup {
-    constructor(map: any, data: any, z: any);
-    /**
-     * group name
-     * @type {string}
-     */
-    name: string;
-    /**
-     * group width
-     * @type {number}
-     */
-    width: number;
-    /**
-     * group height
-     * @type {number}
-     */
-    height: number;
-    /**
-     * tint color
-     * @type {string}
-     */
-    tintcolor: string;
-    /**
-     * the group class
-     * @type {string}
-     */
-    class: string;
-    /**
-     * group z order
-     * @type {number}
-     */
-    z: number;
-    /**
-     * group objects list definition
-     * @see {@link TMXObject}
-     * @type {object[]}
-     */
-    objects: object[];
-    opacity: number;
-    /**
-     * group blend mode (Tiled 1.12+)
-     * @type {string}
-     */
-    blendMode: string;
-    /**
-     * reset function
-     * @ignore
-     */
-    destroy(): void;
-    /**
-     * return the object count
-     * @ignore
-     */
-    getObjectCount(): number;
-    /**
-     * returns the object at the specified index
-     * @ignore
-     */
-    getObjectByIndex(idx: any): object;
-}
+
 //# sourceMappingURL=TMXGroup.d.ts.map

package/build/level/tiled/TMXGroup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TMXGroup.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXGroup.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH;IACC,yCAsFC;IArFA;;;OAGG;IACH,MAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,OAFU,MAAM,CAEY;IAE5B;;;OAGG;IACH,QAFU,MAAM,CAEc;IAE9B;;;OAGG;IACH,WAFU,MAAM,CAEe;IAE/B;;;OAGG;IACH,OAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,GAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,SAFU,MAAM,EAAE,CAED;IAGjB,gBAA2E;IAE3E;;;OAGG;IACH,WAFU,MAAM,CAE0B;IAqC3C;;;OAGG;IACH,gBAGC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,mCAEC;CACD"}
+{"version":3,"file":"TMXGroup.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXGroup.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH;IACC,yCAsFC;IArFA;;;OAGG;IACH,MAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,OAFU,MAAM,CAEY;IAE5B;;;OAGG;IACH,QAFU,MAAM,CAEc;IAE9B;;;OAGG;IACH,WAFU,MAAM,CAEe;IAE/B;;;OAGG;IACH,OAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,GAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,SAFU,MAAM,EAAE,CAED;IAGjB,gBAA2E;IAE3E;;;OAGG;IACH,WAFU,MAAM,CAE0B;IAqC3C;;;;OAIG;IACH,gBAGC;IAED;;;;OAIG;IACH,yBAEC;IAED;;;;OAIG;IACH,mCAEC;CACD"}

package/build/level/tiled/TMXLayer.d.ts

@@ -75,19 +75,6 @@ export default class TMXLayer extends Renderable {
      * @type {Uint16Array}
      */
     layerData: Uint16Array;
-    /**
-     * Lazy view cache of Tile objects, indexed by `y * cols + x` (row-major).
-     * Allocated lazily on the first `cellAt` / `getTile` call — the renderer
-     * hot path reads `layerData` directly and never touches this cache, so
-     * for games that never call `getTile`/`cellAt` from user code, this
-     * stays `null` for the layer's lifetime. Invalidated entry-by-entry by
-     * `setTile` and `clearTile`. The raw bytes in `layerData` are the source
-     * of truth; this exists only to preserve stable Tile identity across
-     * repeated user-facing reads.
-     * @type {Array<Tile|null>|null}
-     * @ignore
-     */
-    cachedTile: Array<Tile | null> | null;
     /**
      * Monotonically-increasing counter bumped by `setTile` and `clearTile`.
      * Renderers can compare against a stashed value to detect mutations and
@@ -114,26 +101,6 @@ export default class TMXLayer extends Renderable {
     onActivateEvent(): void;
     canvasRenderer: CanvasRenderer | undefined;
     preRender: boolean | undefined;
-    /**
-     * Resolve `this.renderMode` to one of "shader" / "prerender" / "perTile"
-     * based on eligibility checks and user/world hints. Emits a single
-     * `console.warn` at activation when a forced mode is ineligible, or
-     * when an auto-eligible mode falls back due to a layer feature the GPU
-     * path doesn't support (orientation, collection-of-image tileset, etc.).
-     * @ignore
-     */
-    _resolveRenderMode(): void;
-    /**
-     * Check whether this layer is eligible for the WebGL2 shader path.
-     * @param {object} renderer
-     * @param {boolean} gpuAllowed - whether `gpuTilemap` is enabled at the world level
-     * @returns {{ok: boolean, reason?: string}}
-     * @ignore
-     */
-    _checkShaderEligibility(renderer: object, gpuAllowed: boolean): {
-        ok: boolean;
-        reason?: string;
-    };
     onDeactivateEvent(): void;
     /**
      * Set the TMX renderer for this layer object
@@ -177,7 +144,6 @@ export default class TMXLayer extends Renderable {
      * @returns {Tile} the tile object
      */
     setTile(tile: Tile, x: number, y: number): Tile;
-    _truncationWarned: boolean | undefined;
     /**
      * return a new the Tile object corresponding to the given tile id
      * @param {number} tileId - tileId
@@ -208,16 +174,6 @@ export default class TMXLayer extends Renderable {
      * });
      */
     clearTile(x: number, y: number): void;
-    /**
-     * update animations in a tileset layer
-     * @ignore
-     */
-    update(dt: any): boolean;
-    /**
-     * draw a tileset layer
-     * @ignore
-     */
-    draw(renderer: any, rect: any): void;
 }
 import Renderable from "../../renderable/renderable.js";
 import Tile from "./TMXTile.js";

package/build/level/tiled/TMXLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TMXLayer.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXLayer.js"],"names":[],"mappings":"AAmHA;;;;GAIG;AACH;IACC;;;;;;;;OAQG;IACH,iBARW,MAAM,QACN,MAAM,aACN,MAAM,cACN,MAAM,eACN,MAAM,YACN,eAAe,KACf,MAAM,EA4LhB;IArLA,eAA4C;IAC5C,gBAA+C;IAG/C,oBAA8B;IAE9B;;;;OAIG;IACH,GAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,GAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,UAFU,eAAe,CAED;IAGxB,aAAwE;IAGxE;;;MAGC;IAaD;;;OAGG;IACH,kBAFU,UAAU,EAAE,CAEI;IAE1B;;;OAGG;IACH,YAFU,OAAO,CAEM;IAEvB;;;;;OAKG;IACH,aAHU,MAAM,CAGmC;IAEnD;;;OAGG;IACH,OAFU,MAAM,CAEO;IASvB,UAAqB;IACrB,aAAuB;IACvB,aAAwB;IA8BxB;;;;;;;;;OASG;IACH,WAFU,WAAW,CAEsC;IAE3D;;;;;;;;;;;OAWG;IACH,YAHU,KAAK,CAAC,IAAI,GAAC,IAAI,CAAC,GAAC,IAAI,CAGT;IAEtB;;;;;OAKG;IACH,aAFU,MAAM,CAEI;IAEpB;;;;;;;;;;;;;;OAcG;IACH,YAHU,MAAM,CAGQ;IAwBzB,wBAkCC;IAfC,2CAKE;IAOH,+BAAgD;IAKjD;;;;;;;OAOG;IACH,2BAkEC;IAED;;;;;;OAMG;IACH,kCALW,MAAM,cACN,OAAO,GACL;QAAC,EAAE,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAC,CA+C1C;IAGD,0BAOC;IAED;;;;;;;OAOG;IACH,sBANW,WAAW,QASrB;IAFA,cAAwB;IAIzB;;;OAGG;IACH,eAFa,WAAW,CAIvB;IAED;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;;;OAUG;IACH,WATW,MAAM,KACN,MAAM,GACJ,IAAI,CAoBhB;IAED;;;;;;OAMG;IACH,cALW,IAAI,KACJ,MAAM,KACN,MAAM,GACJ,IAAI,CA4BhB;IAfC,uCAA6B;IAiB/B;;;;;;OAMG;IACH,oBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAQhB;IAED;;;;;;;;;OASG;IACH,UARW,MAAM,KACN,MAAM,gBACN,MAAM,GACJ,IAAI,CA6ChB;IAED;;;;;;;;;OASG;IACH,aARW,MAAM,KACN,MAAM,QA8BhB;IAED;;;OAGG;IACH,yBAQC;IAED;;;OAGG;IACH,qCAIC;CACD;uBAvsBsB,gCAAgC;iBAStC,cAAc;2BARJ,oCAAoC"}
+{"version":3,"file":"TMXLayer.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXLayer.js"],"names":[],"mappings":"AAuHA;;;;GAIG;AACH;IACC;;;;;;;;OAQG;IACH,iBARW,MAAM,QACN,MAAM,aACN,MAAM,cACN,MAAM,eACN,MAAM,YACN,eAAe,KACf,MAAM,EA6LhB;IAtLA,eAA4C;IAC5C,gBAA+C;IAG/C,oBAA8B;IAE9B;;;;OAIG;IACH,GAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,GAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,UAFU,eAAe,CAED;IAGxB,aAAwE;IAGxE;;;MAGC;IAaD;;;OAGG;IACH,kBAFU,UAAU,EAAE,CAEI;IAE1B;;;OAGG;IACH,YAFU,OAAO,CAEM;IAEvB;;;;;OAKG;IACH,aAHU,MAAM,CAGmC;IAEnD;;;OAGG;IACH,OAFU,MAAM,CAEO;IASvB,UAAqB;IACrB,aAAuB;IACvB,aAAwB;IA8BxB;;;;;;;;;OASG;IACH,WAFU,WAAW,CAEsC;IAE3D;;;;;;;;;;;;OAYG;IACH,YAJU,KAAK,CAAC,IAAI,GAAC,IAAI,CAAC,GAAC,IAAI,CAIT;IAEtB;;;;;OAKG;IACH,aAFU,MAAM,CAEI;IAEpB;;;;;;;;;;;;;;OAcG;IACH,YAHU,MAAM,CAGQ;IAwBzB,wBAkCC;IAfC,2CAKE;IAOH,+BAAgD;IAKjD;;;;;;;;OAQG;IACH,2BAkEC;IAED;;;;;;;OAOG;IACH,kCANW,MAAM,cACN,OAAO,GACL;QAAC,EAAE,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAC,CAgD1C;IAGD,0BAOC;IAED;;;;;;;OAOG;IACH,sBANW,WAAW,QASrB;IAFA,cAAwB;IAIzB;;;OAGG;IACH,eAFa,WAAW,CAIvB;IAED;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;;;OAUG;IACH,WATW,MAAM,KACN,MAAM,GACJ,IAAI,CAoBhB;IAED;;;;;;OAMG;IACH,cALW,IAAI,KACJ,MAAM,KACN,MAAM,GACJ,IAAI,CAgChB;IAnBC;;;OAGG;IACH,uCAA6B;IAiB/B;;;;;;OAMG;IACH,oBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAQhB;IAED;;;;;;;;;OASG;IACH,UARW,MAAM,KACN,MAAM,gBACN,MAAM,GACJ,IAAI,CA6ChB;IAED;;;;;;;;;OASG;IACH,aARW,MAAM,KACN,MAAM,QA8BhB;IAED;;;;OAIG;IACH,yBAQC;IAED;;;;OAIG;IACH,qCAIC;CACD;uBAptBsB,gCAAgC;iBAStC,cAAc;2BARJ,oCAAoC"}

package/build/level/tiled/TMXObject.d.ts

@@ -1,138 +1,3 @@
-/**
- * a TMX Object defintion, as defined in Tiled
- * (Object definition is translated into the virtual `app.world` using `me.Renderable`)
- * @ignore
- */
-export default class TMXObject {
-    constructor(map: any, settings: any, z: any);
-    /**
-     * point list in JSON format
-     * @type {object[]}
-     */
-    points: object[];
-    /**
-     * object name
-     * @type {string}
-     */
-    name: string;
-    /**
-     * object x position
-     * @type {number}
-     */
-    x: number;
-    /**
-     * object y position
-     * @type {number}
-     */
-    y: number;
-    /**
-     * object z order
-     * @type {number}
-     */
-    z: number;
-    /**
-     * object width
-     * @type {number}
-     */
-    width: number;
-    /**
-     * object height
-     * @type {number}
-     */
-    height: number;
-    /**
-     * object gid value
-     * when defined the object is a tiled object
-     * @type {number}
-     */
-    gid: number;
-    /**
-     * tint color
-     * @type {string}
-     */
-    tintcolor: string;
-    /**
-     * object type
-     * @type {string}
-     * @deprecated since Tiled 1.9
-     * @see {@link https://docs.mapeditor.org/en/stable/reference/tmx-changelog/#tiled-1-9}
-     */
-    type: string;
-    /**
-     * the object class
-     * @type {string}
-     */
-    class: string;
-    /**
-     * object text
-     * @type {object}
-     * @see {@link http://docs.mapeditor.org/en/stable/reference/tmx-map-format/#text}
-     */
-    text: object;
-    /**
-     * The rotation of the object in radians clockwise (defaults to 0)
-     * @type {number}
-     */
-    rotation: number;
-    /**
-     * the object opacity (0-1), defaults to 1 (since Tiled 1.12)
-     * @type {number}
-     */
-    opacity: number;
-    /**
-     * whether the object is visible, defaults to true
-     * @type {boolean}
-     */
-    visible: boolean;
-    /**
-     * object unique identifier per level (Tiled 0.11.x+)
-     * @type {number}
-     */
-    id: number;
-    /**
-     * object orientation (orthogonal or isometric)
-     * @type {string}
-     */
-    orientation: string;
-    /**
-     * the collision shapes defined for this object
-     * @type {object[]}
-     */
-    shapes: object[];
-    /**
-     * the detected shape type
-     * @type {string}
-     */
-    shapeType: string;
-    /** @type {boolean} */
-    isEllipse: boolean;
-    /** @type {boolean} */
-    isCapsule: boolean;
-    /** @type {boolean} */
-    isPoint: boolean;
-    /** @type {boolean} */
-    isPolygon: boolean;
-    /** @type {boolean} */
-    isPolyLine: boolean;
-    /**
-     * set the object image (for Tiled Object)
-     * @ignore
-     */
-    setTile(tilesets: any): void;
-    framewidth: any;
-    frameheight: any;
-    tile: Tile | undefined;
-    /**
-     * parses the TMX shape definition and returns a corresponding array of shape objects
-     * @private
-     * @returns {Polygon[]|Line[]|Ellipse[]|RoundRect[]} an array of shape objects
-     */
-    private parseTMXShapes;
-    /**
-     * getObjectPropertyByName
-     * @ignore
-     */
-    getObjectPropertyByName(name: any): any;
-}
+
 import Tile from "./TMXTile.js";
 //# sourceMappingURL=TMXObject.d.ts.map

package/build/level/tiled/TMXObject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TMXObject.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXObject.js"],"names":[],"mappings":"AAoCA;;;;GAIG;AACH;IACC,6CAmKC;IAlKA;;;OAGG;IACH,QAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,MAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,GAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,GAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,GAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,OAFU,MAAM,CAEiB;IAEjC;;;OAGG;IACH,QAFU,MAAM,CAEmB;IAEnC;;;;OAIG;IACH,KAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,WAFU,MAAM,CAEmB;IAEnC;;;;;OAKG;IACH,MAJU,MAAM,CAIS;IAEzB;;;OAGG;IACH,OAFU,MAAM,CAE4B;IAE5C;;;;OAIG;IACH,MAHU,MAAM,CAGK;IAErB;;;OAGG;IACH,UAFU,MAAM,CAEiC;IAEjD;;;OAGG;IACH,SAFU,MAAM,CAEuB;IAEvC;;;OAGG;IACH,SAFU,OAAO,CAE4B;IAE7C;;;OAGG;IACH,IAFU,MAAM,CAEmB;IAEnC;;;OAGG;IACH,aAFU,MAAM,CAEkB;IAElC;;;OAGG;IACH,QAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,WAFU,MAAM,CAEY;IAa5B,sBAAsB;IACtB,WADW,OAAO,CAC2B;IAC7C,sBAAsB;IACtB,WADW,OAAO,CAC2B;IAC7C,sBAAsB;IACtB,SADW,OAAO,CACuB;IACzC,sBAAsB;IACtB,WADW,OAAO,CAC2B;IAC7C,sBAAsB;IACtB,YADW,OAAO,CAC6B;IA0BhD;;;OAGG;IACH,6BASC;IALc,gBAAmC;IAClC,iBAAqC;IAGpD,uBAAuD;IAGxD;;;;OAIG;IACH,uBAuGC;IAED;;;OAGG;IACH,wCAEC;CACD;iBA5UgB,cAAc"}
+{"version":3,"file":"TMXObject.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXObject.js"],"names":[],"mappings":"AAqCA;;;;;GAKG;AACH;IACC,6CAmKC;IAlKA;;;OAGG;IACH,QAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,MAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,GAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,GAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,GAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,OAFU,MAAM,CAEiB;IAEjC;;;OAGG;IACH,QAFU,MAAM,CAEmB;IAEnC;;;;OAIG;IACH,KAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,WAFU,MAAM,CAEmB;IAEnC;;;;;OAKG;IACH,MAJU,MAAM,CAIS;IAEzB;;;OAGG;IACH,OAFU,MAAM,CAE4B;IAE5C;;;;OAIG;IACH,MAHU,MAAM,CAGK;IAErB;;;OAGG;IACH,UAFU,MAAM,CAEiC;IAEjD;;;OAGG;IACH,SAFU,MAAM,CAEuB;IAEvC;;;OAGG;IACH,SAFU,OAAO,CAE4B;IAE7C;;;OAGG;IACH,IAFU,MAAM,CAEmB;IAEnC;;;OAGG;IACH,aAFU,MAAM,CAEkB;IAElC;;;OAGG;IACH,QAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,WAFU,MAAM,CAEY;IAa5B,sBAAsB;IACtB,WADW,OAAO,CAC2B;IAC7C,sBAAsB;IACtB,WADW,OAAO,CAC2B;IAC7C,sBAAsB;IACtB,SADW,OAAO,CACuB;IACzC,sBAAsB;IACtB,WADW,OAAO,CAC2B;IAC7C,sBAAsB;IACtB,YADW,OAAO,CAC6B;IA0BhD;;;;OAIG;IACH,6BASC;IALc,gBAAmC;IAClC,iBAAqC;IAGpD,uBAAuD;IAGxD;;;;OAIG;IACH,uBAuGC;IAED;;;;OAIG;IACH,wCAEC;CACD;iBAhVgB,cAAc"}