melonjs 17.3.0 → 18.0.0

package/dist/melonjs.mjs/level/tiled/renderer/TMXOrthogonalRenderer.js

@@ -1,155 +0,0 @@
-/*!
- * melonJS Game Engine - v17.3.0
- * http://www.melonjs.org
- * melonjs is licensed under the MIT License.
- * http://www.opensource.org/licenses/mit-license
- * @copyright (C) 2011 - 2024 Olivier Biot (AltByte Pte Ltd)
- */
-import Vector2d from '../../../math/vector2.js';
-import pool from '../../../system/pooling.js';
-import TMXRenderer from './TMXRenderer.js';
-
-/**
- * @classdesc
- * an Orthogonal Map Renderder
- * @augments TMXRenderer
- */
-class TMXOrthogonalRenderer extends TMXRenderer {
-    /**
-     * @param {TMXTileMap} map - the TMX map
-     */
-    constructor(map) {
-        super(
-            map.cols,
-            map.rows,
-            map.tilewidth,
-            map.tileheight
-        );
-    }
-
-    /**
-     * return true if the renderer can render the specified layer
-     * @ignore
-     */
-    canRender(layer) {
-        return (
-            (layer.orientation === "orthogonal") &&
-            super.canRender(layer)
-        );
-    }
-
-    /**
-     * return the tile position corresponding to the specified pixel
-     * @ignore
-     */
-    pixelToTileCoords(x, y, v) {
-        let ret = v || new Vector2d();
-        return ret.set(
-            x / this.tilewidth,
-            y / this.tileheight
-        );
-    }
-
-
-    /**
-     * return the pixel position corresponding of the specified tile
-     * @ignore
-     */
-    tileToPixelCoords(x, y, v) {
-        let ret = v || new Vector2d();
-        return ret.set(
-            x * this.tilewidth,
-            y * this.tileheight
-        );
-    }
-
-    /**
-     * fix the position of Objects to match
-     * the way Tiled places them
-     * @ignore
-     */
-    adjustPosition(obj) {
-        // only adjust position if obj.gid is defined
-        if (typeof(obj.gid) === "number") {
-            // Tiled objects origin point is "bottom-left" in Tiled,
-            // "top-left" in melonJS)
-            obj.y -= obj.height;
-        }
-    }
-
-    /**
-     * draw the tile map
-     * @ignore
-     */
-    drawTile(renderer, x, y, tmxTile) {
-        let tileset = tmxTile.tileset;
-        // draw the tile
-        tileset.drawTile(
-            renderer,
-            tileset.tileoffset.x + x * this.tilewidth,
-            tileset.tileoffset.y + (y + 1) * this.tileheight - tileset.tileheight,
-            tmxTile
-        );
-    }
-
-    /**
-     * draw the tile map
-     * @ignore
-     */
-    drawTileLayer(renderer, layer, rect) {
-        let incX = 1, incY = 1;
-
-        // get top-left and bottom-right tile position
-        let start = this.pixelToTileCoords(
-            Math.max(rect.pos.x - (layer.maxTileSize.width - layer.tilewidth), 0),
-            Math.max(rect.pos.y - (layer.maxTileSize.height - layer.tileheight), 0),
-            pool.pull("Vector2d")
-        ).floorSelf();
-
-        let end = this.pixelToTileCoords(
-            rect.pos.x + rect.width + this.tilewidth,
-            rect.pos.y + rect.height + this.tileheight,
-            pool.pull("Vector2d")
-        ).ceilSelf();
-
-        //ensure we are in the valid tile range
-        end.x = end.x > this.cols ? this.cols : end.x;
-        end.y = end.y > this.rows ? this.rows : end.y;
-
-        switch (layer.renderorder) {
-            case "right-up" :
-                // swapping start.y and end.y
-                end.y = start.y + (start.y = end.y) - end.y;
-                incY = -1;
-                break;
-            case "left-down" :
-                // swapping start.x and end.x
-                end.x = start.x + (start.x = end.x) - end.x;
-                incX = -1;
-                break;
-            case "left-up" :
-                // swapping start.x and end.x
-                end.x = start.x + (start.x = end.x) - end.x;
-                // swapping start.y and end.y
-                end.y = start.y + (start.y = end.y) - end.y;
-                incX = -1;
-                incY = -1;
-                break;
-        }
-
-        // main drawing loop
-        for (let y = start.y; y !== end.y; y += incY) {
-            for (let x = start.x; x !== end.x; x += incX) {
-                let tmxTile = layer.cellAt(x, y, false);
-                if (tmxTile) {
-                    this.drawTile(renderer, x, y, tmxTile);
-                }
-            }
-        }
-
-        pool.push(start);
-        pool.push(end);
-    }
-}
-
-export { TMXOrthogonalRenderer as default };

package/dist/melonjs.mjs/level/tiled/renderer/TMXRenderer.js

@@ -1,113 +0,0 @@
-/*!
- * melonJS Game Engine - v17.3.0
- * http://www.melonjs.org
- * melonjs is licensed under the MIT License.
- * http://www.opensource.org/licenses/mit-license
- * @copyright (C) 2011 - 2024 Olivier Biot (AltByte Pte Ltd)
- */
-import pool from '../../../system/pooling.js';
-import TMXLayer from '../TMXLayer.js';
-import Bounds from '../../../physics/bounds.js';
-
-/* eslint-disable no-unused-vars */
-
-
-/**
- * @classdesc
- * The map renderer base class
- */
-class TMXRenderer {
-    /**
-     * @param {number} cols - width of the tilemap in tiles
-     * @param {number} rows - height of the tilemap in tiles
-     * @param {number} tilewidth - width of each tile in pixels
-     * @param {number} tileheight - height of each tile in pixels
-     */
-    constructor(cols, rows, tilewidth, tileheight) {
-        this.cols = cols;
-        this.rows = rows;
-        this.tilewidth = tilewidth;
-        this.tileheight = tileheight;
-        this.bounds = new Bounds();
-    }
-
-    /**
-     * return true if the renderer can render the specified map or layer
-     * @param {TMXTileMap|TMXLayer} component - TMX Map or Layer
-     * @returns {boolean}
-     */
-    canRender(component) {
-        return (
-            /*
-            // layers can have different size within
-            // the same maps, so commenting these two lines
-            (this.cols === component.cols) &&
-            (this.rows === component.rows) &&
-            */
-            (this.tilewidth === component.tilewidth) &&
-            (this.tileheight === component.tileheight)
-        );
-    }
-
-    /**
-     * return the bounding rect for this map renderer
-     * @param {TMXLayer} [layer] - calculate the bounding rect for a specific layer (will return a new bounds object)
-     * @returns {Bounds}
-     */
-    getBounds(layer) {
-        let bounds = layer instanceof TMXLayer ? pool.pull("Bounds") : this.bounds;
-        bounds.setMinMax(
-            0, 0,
-            this.cols * this.tilewidth,
-            this.rows * this.tileheight
-        );
-        return bounds;
-    }
-
-    /**
-     * return the tile position corresponding to the specified pixel
-     * @param {number} x - X coordinate
-     * @param {number} y - Y coordinate
-     * @param {Vector2d} [v] - an optional vector object where to put the return values
-     * @returns {Vector2d}
-     */
-    pixelToTileCoords(x, y, v) {
-        return v;
-    }
-
-    /**
-     * return the pixel position corresponding of the specified tile
-     * @param {number} col - tile horizontal position
-     * @param {number} row - tile vertical position
-     * @param {Vector2d} [v] - an optional vector object where to put the return values
-     * @returns {Vector2d}
-     */
-    tileToPixelCoords(col, row, v) {
-        return v;
-    }
-
-    /**
-     * draw the given tile at the specified layer
-     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer object
-     * @param {number} x - X coordinate where to draw the tile
-     * @param {number} y - Y coordinate where to draw the tile
-     * @param {Tile} tile - the tile object to draw
-     */
-    drawTile(renderer, x, y, tile) {
-    }
-
-    /**
-     * draw the given TMX Layer for the given area
-     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer object
-     * @param {TMXLayer} layer - a TMX Layer object
-     * @param {Rect} rect - the area of the layer to draw
-     */
-    drawTileLayer(renderer, layer, rect) {
-    }
-
-}
-
-
-/* eslint-enable no-unused-vars */
-
-export { TMXRenderer as default };

package/dist/melonjs.mjs/level/tiled/renderer/TMXStaggeredRenderer.js

@@ -1,107 +0,0 @@
-/*!
- * melonJS Game Engine - v17.3.0
- * http://www.melonjs.org
- * melonjs is licensed under the MIT License.
- * http://www.opensource.org/licenses/mit-license
- * @copyright (C) 2011 - 2024 Olivier Biot (AltByte Pte Ltd)
- */
-import Vector2d from '../../../math/vector2.js';
-import pool from '../../../system/pooling.js';
-import TMXHexagonalRenderer from './TMXHexagonalRenderer.js';
-import { degToRad } from '../../../math/math.js';
-
-/**
- * @classdesc
- * a Staggered Map Renderder
- * @augments TMXHexagonalRenderer
- */
-class TMXStaggeredRenderer extends TMXHexagonalRenderer {
-
-    /**
-     * return true if the renderer can render the specified layer
-     * @ignore
-     */
-    canRender(layer) {
-        return (
-            (layer.orientation === "staggered") &&
-            super.canRender(layer)
-        );
-    }
-
-    /**
-     * return the tile position corresponding to the specified pixel
-     * @ignore
-     */
-    pixelToTileCoords(x, y, v) {
-        let ret = v || new Vector2d();
-
-        let alignedX = x,
-            alignedY = y;
-
-        if (this.staggerX) {
-            alignedX -= this.staggerEven ? this.sideoffsetx : 0;
-        } else {
-            alignedY -= this.staggerEven ? this.sideoffsety : 0;
-        }
-
-        // Start with the coordinates of a grid-aligned tile
-        let referencePoint = pool.pull("Vector2d",
-            Math.floor(alignedX / this.tilewidth),
-            Math.floor(alignedY / this.tileheight)
-        );
-
-        // Adjust the reference point to the correct tile coordinates
-        if (this.staggerX) {
-            referencePoint.x = referencePoint.x * 2;
-            if (this.staggerEven) {
-                ++referencePoint.x;
-            }
-        } else {
-            referencePoint.y = referencePoint.y * 2;
-            if (this.staggerEven) {
-                ++referencePoint.y;
-            }
-        }
-
-        // Relative x and y position on the base square of the grid-aligned tile
-        let rel = pool.pull("Vector2d",
-            alignedX - referencePoint.x * this.tilewidth,
-            alignedY - referencePoint.y * this.tileheight
-        );
-
-        // Check whether the cursor is in any of the corners (neighboring tiles)
-        let y_pos = rel.x * (this.tileheight / this.tilewidth);
-
-        if (this.sideoffsety - y_pos > rel.y) {
-            referencePoint = this.topLeft(referencePoint.x, referencePoint.y, referencePoint);
-        }
-        if (-this.sideoffsety + y_pos > rel.y) {
-            referencePoint = this.topRight(referencePoint.x, referencePoint.y, referencePoint);
-        }
-        if (this.sideoffsety + y_pos < rel.y) {
-            referencePoint = this.bottomLeft(referencePoint.x, referencePoint.y, referencePoint);
-        }
-        if (this.sideoffsety * 3 - y_pos < rel.y) {
-            referencePoint = this.bottomRight(referencePoint.x, referencePoint.y, referencePoint);
-        }
-
-        ret = this.tileToPixelCoords(referencePoint.x, referencePoint.y, ret);
-
-        ret.set(x - ret.x, y - ret.y);
-
-        // Start with the coordinates of a grid-aligned tile
-        ret.set(
-            ret.x - (this.tilewidth / 2),
-            ret.y * (this.tilewidth / this.tileheight)
-        );
-
-        ret.div(this.tilewidth / Math.sqrt(2)).rotate(degToRad(-45)).add(referencePoint);
-
-        pool.push(referencePoint);
-        pool.push(rel);
-
-        return ret;
-    }
-}
-
-export { TMXStaggeredRenderer as default };

package/dist/melonjs.mjs/level/tiled/renderer/autodetect.js

@@ -1,38 +0,0 @@
-/*!
- * melonJS Game Engine - v17.3.0
- * http://www.melonjs.org
- * melonjs is licensed under the MIT License.
- * http://www.opensource.org/licenses/mit-license
- * @copyright (C) 2011 - 2024 Olivier Biot (AltByte Pte Ltd)
- */
-import TMXOrthogonalRenderer from './TMXOrthogonalRenderer.js';
-import TMXIsometricRenderer from './TMXIsometricRenderer.js';
-import TMXHexagonalRenderer from './TMXHexagonalRenderer.js';
-import TMXStaggeredRenderer from './TMXStaggeredRenderer.js';
-
-/**
- * return a compatible renderer object for the given map
- * @param {TMXTileMap} map
- * @ignore
- */
-function getNewTMXRenderer(map) {
-    switch (map.orientation) {
-        case "orthogonal":
-            return new TMXOrthogonalRenderer(map);
-
-        case "isometric":
-            return new TMXIsometricRenderer(map);
-
-        case "hexagonal":
-            return new TMXHexagonalRenderer(map);
-
-        case "staggered":
-            return new TMXStaggeredRenderer(map);
-
-        // if none found, throw an exception
-        default:
-            throw new Error(map.orientation + " type TMX Tile Map not supported!");
-    }
-}
-
-export { getNewTMXRenderer };

package/dist/melonjs.mjs/loader/cache.js

@@ -1,30 +0,0 @@
-/*!
- * melonJS Game Engine - v17.3.0
- * http://www.melonjs.org
- * melonjs is licensed under the MIT License.
- * http://www.opensource.org/licenses/mit-license
- * @copyright (C) 2011 - 2024 Olivier Biot (AltByte Pte Ltd)
- */
-/**
- * where all preloaded content is cached
- */
-
-// contains all the images loaded
-let imgList = {};
-
-// contains all the TMX loaded
-let tmxList = {};
-
-// contains all the binary files loaded
-let binList = {};
-
-// contains all the JSON files
-let jsonList = {};
-
-// contains all the video files
-let videoList = {};
-
-// contains all the font files
-let fontList = {};
-
-export { binList, fontList, imgList, jsonList, tmxList, videoList };