melonjs 14.0.2 → 14.1.1

package/dist/melonjs.mjs/level/tiled/TMXTileset.js

@@ -0,0 +1,309 @@
+/*!
+ * melonJS Game Engine - v14.1.1
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import Vector2d from '../../math/vector2.js';
+import { renderer } from '../../video/video.js';
+import { getExtension, getBasename } from '../../utils/file.js';
+import timer from '../../system/timer.js';
+import loader from '../../loader/loader.js';
+
+/**
+ * @classdesc
+ * a TMX Tile Set Object
+ */
+ class TMXTileset {
+    /**
+     *  @param {object} tileset - tileset data in JSON format ({@link http://docs.mapeditor.org/en/stable/reference/tmx-map-format/#tileset})
+     */
+    constructor(tileset) {
+        var i = 0;
+        // first gid
+
+        // tile properties (collidable, etc..)
+        this.TileProperties = [];
+
+        // hold reference to each tile image
+        this.imageCollection = [];
+
+        this.firstgid = this.lastgid = +tileset.firstgid;
+
+        // check if an external tileset is defined
+        if (typeof(tileset.source) !== "undefined") {
+            var src = tileset.source;
+            var ext = getExtension(src);
+            if (ext === "tsx" || ext === "json") {
+                // load the external tileset (TSX/JSON)
+                tileset = loader.getTMX(getBasename(src));
+                if (!tileset) {
+                    throw new Error(src + " external TSX/JSON tileset not found");
+                }
+            }
+        }
+
+        this.name = tileset.name;
+        this.tilewidth = +tileset.tilewidth;
+        this.tileheight = +tileset.tileheight;
+        this.spacing = +tileset.spacing || 0;
+        this.margin = +tileset.margin || 0;
+
+        // set tile offset properties (if any)
+        this.tileoffset = new Vector2d();
+
+        /**
+         * Tileset contains animated tiles
+         * @public
+         * @type {boolean}
+         * @name TMXTileset#isAnimated
+         */
+        this.isAnimated = false;
+
+        /**
+         * true if the tileset is a "Collection of Image" Tileset
+         * @public
+         * @type {boolean}
+         * @name TMXTileset#isCollection
+         */
+        this.isCollection = false;
+
+        /**
+         * the tileset class
+         * @public
+         * @type {boolean}
+         * @name TMXTileset#class
+         */
+        this.class = tileset.class;
+
+        /**
+         * Tileset animations
+         * @private
+         */
+        this.animations = new Map();
+
+        /**
+         * Remember the last update timestamp to prevent too many animation updates
+         * @private
+         */
+        this._lastUpdate = 0;
+
+        var tiles = tileset.tiles;
+        for (i in tiles) {
+            if (tiles.hasOwnProperty(i)) {
+                if ("animation" in tiles[i]) {
+                    this.isAnimated = true;
+                    this.animations.set(tiles[+i].animation[0].tileid, {
+                        dt      : 0,
+                        idx     : 0,
+                        frames  : tiles[+i].animation,
+                        cur     : tiles[+i].animation[0]
+                    });
+                }
+                // set tile properties, if any
+                if ("properties" in tiles[i]) {
+                    if (Array.isArray(tiles[i].properties)) { // JSON (new format)
+                        var tileProperty = {};
+                        for (var j in tiles[i].properties) {
+                            tileProperty[tiles[i].properties[j].name] = tiles[i].properties[j].value;
+                        }
+                        this.setTileProperty(+tiles[i].id + this.firstgid, tileProperty);
+                    } else { // XML format
+                        this.setTileProperty(+i + this.firstgid, tiles[i].properties);
+                    }
+                }
+                if ("image" in tiles[i]) {
+                    var image = loader.getImage(tiles[i].image);
+                    if (!image) {
+                        throw new Error("melonJS: '" + tiles[i].image + "' file for tile '" + (+i + this.firstgid) + "' not found!");
+                    }
+                    this.imageCollection[+i + this.firstgid] = image;
+                }
+            }
+        }
+
+        this.isCollection = this.imageCollection.length > 0;
+
+        var offset = tileset.tileoffset;
+        if (offset) {
+            this.tileoffset.x = +offset.x;
+            this.tileoffset.y = +offset.y;
+        }
+
+        // set tile properties, if any (JSON old format)
+        var tileInfo = tileset.tileproperties;
+        if (tileInfo) {
+            for (i in tileInfo) {
+                if (tileInfo.hasOwnProperty(i)) {
+                    this.setTileProperty(+i + this.firstgid, tileInfo[i]);
+                }
+            }
+        }
+
+        // if not a tile image collection
+        if (this.isCollection === false) {
+
+            // get the global tileset texture
+            this.image = loader.getImage(tileset.image);
+
+            if (!this.image) {
+                throw new Error("melonJS: '" + tileset.image + "' file for tileset '" + this.name + "' not found!");
+            }
+
+            // create a texture atlas for the given tileset
+            this.texture = renderer.cache.get(this.image, {
+                framewidth : this.tilewidth,
+                frameheight : this.tileheight,
+                margin : this.margin,
+                spacing : this.spacing
+            });
+            this.atlas = this.texture.getAtlas();
+
+            // calculate the number of tiles per horizontal line
+            var hTileCount = +tileset.columns || Math.round(this.image.width / (this.tilewidth + this.spacing));
+            var vTileCount = Math.round(this.image.height / (this.tileheight + this.spacing));
+            if (tileset.tilecount % hTileCount > 0) {
+                ++vTileCount;
+            }
+            // compute the last gid value in the tileset
+            this.lastgid = this.firstgid + (((hTileCount * vTileCount) - 1) || 0);
+            if (tileset.tilecount && this.lastgid - this.firstgid + 1 !== +tileset.tilecount) {
+                console.warn(
+                    "Computed tilecount (" + (this.lastgid - this.firstgid + 1) +
+                    ") does not match expected tilecount (" + tileset.tilecount + ")"
+                );
+            }
+        }
+    }
+
+    /**
+     * return the tile image from a "Collection of Image" tileset
+     * @name TMXTileset#getTileImage
+     * @public
+     * @param {number} gid
+     * @returns {Image} corresponding image or undefined
+     */
+    getTileImage(gid) {
+        return this.imageCollection[gid];
+    }
+
+
+    /**
+     * set the tile properties
+     * @ignore
+     */
+    setTileProperty(gid, prop) {
+        // set the given tile id
+        this.TileProperties[gid] = prop;
+    }
+
+    /**
+     * return true if the gid belongs to the tileset
+     * @name TMXTileset#contains
+     * @public
+     * @param {number} gid
+     * @returns {boolean}
+     */
+    contains(gid) {
+        return gid >= this.firstgid && gid <= this.lastgid;
+    }
+
+    /**
+     * Get the view (local) tile ID from a GID, with animations applied
+     * @name TMXTileset#getViewTileId
+     * @public
+     * @param {number} gid - Global tile ID
+     * @returns {number} View tile ID
+     */
+    getViewTileId(gid) {
+        var localId = gid - this.firstgid;
+
+        if (this.animations.has(localId)) {
+            // return the current corresponding tile id if animated
+            return this.animations.get(localId).cur.tileid;
+        }
+
+        return localId;
+    }
+
+    /**
+     * return the properties of the specified tile
+     * @name TMXTileset#getTileProperties
+     * @public
+     * @param {number} tileId
+     * @returns {object}
+     */
+    getTileProperties(tileId) {
+        return this.TileProperties[tileId];
+    }
+
+    // update tile animations
+    update(dt) {
+        var duration = 0,
+            now = timer.getTime(),
+            result = false;
+
+        if (this._lastUpdate !== now) {
+            this._lastUpdate = now;
+
+            this.animations.forEach((anim) => {
+                anim.dt += dt;
+                duration = anim.cur.duration;
+                while (anim.dt >= duration) {
+                    anim.dt -= duration;
+                    anim.idx = (anim.idx + 1) % anim.frames.length;
+                    anim.cur = anim.frames[anim.idx];
+                    duration = anim.cur.duration;
+                    result = true;
+                }
+            });
+        }
+
+        return result;
+    }
+
+    // draw the x,y tile
+    drawTile(renderer, dx, dy, tmxTile) {
+
+        // check if any transformation is required
+        if (tmxTile.flipped) {
+            renderer.save();
+            // apply the tile current transform
+            renderer.translate(dx, dy);
+            renderer.transform(tmxTile.currentTransform);
+            // reset both values as managed through transform();
+            dx = dy = 0;
+        }
+
+        // check if the tile has an associated image
+        if (this.isCollection === true) {
+            // draw the tile
+            renderer.drawImage(
+                this.imageCollection[tmxTile.tileId],
+                0, 0,
+                tmxTile.width, tmxTile.height,
+                dx, dy,
+                tmxTile.width, tmxTile.height
+            );
+        } else {
+            // use the tileset texture
+            var offset = this.atlas[this.getViewTileId(tmxTile.tileId)].offset;
+            // draw the tile
+            renderer.drawImage(
+                this.image,
+                offset.x, offset.y,
+                this.tilewidth, this.tileheight,
+                dx, dy,
+                this.tilewidth + renderer.uvOffset, this.tileheight + renderer.uvOffset
+            );
+        }
+
+        if (tmxTile.flipped) {
+            // restore the context to the previous state
+            renderer.restore();
+        }
+    }
+}
+
+export { TMXTileset as default };

package/dist/melonjs.mjs/level/tiled/TMXTilesetGroup.js

@@ -0,0 +1,81 @@
+/*!
+ * melonJS Game Engine - v14.1.1
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+// bitmask constants to check for flipped & rotated tiles
+const TMX_CLEAR_BIT_MASK = ~(0x80000000 | 0x40000000 | 0x20000000);
+
+/**
+ * @classdesc
+ * an object containing all tileset
+ */
+ class TMXTilesetGroup {
+
+    constructor() {
+        this.tilesets = [];
+        this.length = 0;
+    }
+
+    /**
+     * add a tileset to the tileset group
+     * @name TMXTilesetGroup#add
+     * @public
+     * @param {TMXTileset} tileset
+     */
+    add(tileset) {
+        this.tilesets.push(tileset);
+        this.length++;
+    }
+
+    /**
+     * return the tileset at the specified index
+     * @name TMXTilesetGroup#getTilesetByIndex
+     * @public
+     * @param {number} i
+     * @returns {TMXTileset} corresponding tileset
+     */
+    getTilesetByIndex(i) {
+        return this.tilesets[i];
+    }
+
+    /**
+     * return the tileset corresponding to the specified id <br>
+     * will throw an exception if no matching tileset is found
+     * @name TMXTilesetGroup#getTilesetByGid
+     * @public
+     * @param {number} gid
+     * @returns {TMXTileset} corresponding tileset
+     */
+    getTilesetByGid(gid) {
+        var invalidRange = -1;
+
+        // clear the gid of all flip/rotation flags
+        gid &= TMX_CLEAR_BIT_MASK;
+
+        // cycle through all tilesets
+        for (var i = 0, len = this.tilesets.length; i < len; i++) {
+            // return the corresponding tileset if matching
+            if (this.tilesets[i].contains(gid)) {
+                return this.tilesets[i];
+            }
+            // typically indicates a layer with no asset loaded (collision?)
+            if (this.tilesets[i].firstgid === this.tilesets[i].lastgid &&
+                gid >= this.tilesets[i].firstgid) {
+                // store the id if the [firstgid .. lastgid] is invalid
+                invalidRange = i;
+            }
+        }
+        // return the tileset with the invalid range
+        if (invalidRange !== -1) {
+            return this.tilesets[invalidRange];
+        }
+        else {
+            throw new Error("no matching tileset found for gid " + gid);
+        }
+    }
+}
+
+export { TMXTilesetGroup as default };