melonjs 17.3.0 → 18.0.0

package/dist/melonjs.mjs/const.js

@@ -1,32 +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)
- */
-/**
- * constant to select the HTML5 Canvas renderer
- * @type {number}
- * @static
- * @see Application
- */
-const CANVAS = 0;
-
-/**
- * constant to select select the WebGL renderer
- * @type {number}
- * @static
- * @see Application
- */
-const WEBGL = 1;
-
-/**
- * constant to auto-select the renderer (Attempt WebGL first, with fallback to Canvas)
- * @static
- * @type {number}
- * @see Application
- */
-const AUTO = 2;
-
-export { AUTO, CANVAS, WEBGL };

package/dist/melonjs.mjs/geometries/ellipse.js

@@ -1,245 +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';
-
-/**
- * @classdesc
- * an ellipse Object
- */
-class Ellipse {
-    /**
-     * @param {number} x - the center x coordinate of the ellipse
-     * @param {number} y - the center y coordinate of the ellipse
-     * @param {number} w - width (diameter) of the ellipse
-     * @param {number} h - height (diameter) of the ellipse
-     */
-    constructor(x, y, w, h) {
-        /**
-         * the center coordinates of the ellipse
-         * @public
-         * @type {Vector2d}
-         */
-        this.pos = pool.pull("Vector2d");
-
-        /**
-         * The bounding rectangle for this shape
-         * @private
-         */
-        this._bounds = undefined;
-
-        /**
-         * Maximum radius of the ellipse
-         * @public
-         * @type {number}
-         */
-        this.radius = NaN;
-
-        /**
-         * Pre-scaled radius vector for ellipse
-         * @public
-         * @type {Vector2d}
-         */
-        this.radiusV = pool.pull("Vector2d");
-
-        /**
-         * Radius squared, for pythagorean theorom
-         * @public
-         * @type {Vector2d}
-         */
-        this.radiusSq = pool.pull("Vector2d");
-
-        /**
-         * x/y scaling ratio for ellipse
-         * @public
-         * @type {Vector2d}
-         */
-        this.ratio = pool.pull("Vector2d");
-
-        /**
-         * the shape type (used internally)
-         * @type {string}
-         * @default "Ellipse"
-         */
-        this.type = "Ellipse";
-        this.setShape(x, y, w, h);
-    }
-
-    /** @ignore */
-    onResetEvent(x, y, w, h) {
-        this.setShape(x, y, w, h);
-    }
-
-    /**
-     * set new value to the Ellipse shape
-     * @param {number} x - the center x coordinate of the ellipse
-     * @param {number} y - the center y coordinate of the ellipse
-     * @param {number} w - width (diameter) of the ellipse
-     * @param {number} h - height (diameter) of the ellipse
-     * @returns {Ellipse} this instance for objecf chaining
-     */
-    setShape(x, y, w, h) {
-        const hW = w / 2;
-        const hH = h / 2;
-        const radius = Math.max(hW, hH);
-        const r = radius * radius;
-
-        this.pos.set(x, y);
-        this.radius = radius;
-        this.ratio.set(hW / radius, hH / radius);
-        this.radiusV.set(radius, radius).scaleV(this.ratio);
-        this.radiusSq.set(r, r).scaleV(this.ratio);
-
-        let bounds = this.getBounds();
-        // update the corresponding bounds
-        bounds.setMinMax(x, y, x + w, x + h);
-        // elipse position is the center of the cirble, bounds position are top left
-        bounds.translate(-this.radiusV.x, -this.radiusV.y);
-
-        return this;
-    }
-
-    /**
-     * Rotate this Ellipse (counter-clockwise) by the specified angle (in radians).
-     * @param {number} angle - The angle to rotate (in radians)
-     * @param {Vector2d|ObservableVector2d} [v] - an optional point to rotate around
-     * @returns {Ellipse} Reference to this object for method chaining
-     */
-    rotate(angle, v) {
-        let bounds = this.getBounds();
-        // TODO : only works for circle
-        this.pos.rotate(angle, v);
-        bounds.shift(this.pos);
-        bounds.translate(-this.radiusV.x, -this.radiusV.y);
-        return this;
-    }
-
-    /**
-     * Scale this Ellipse by the specified scalar.
-     * @param {number} x - the scale factor along the x-axis
-     * @param {number} [y=x] - the scale factor along the y-axis
-     * @returns {Ellipse} Reference to this object for method chaining
-     */
-    scale(x, y = x) {
-        return this.setShape(
-            this.pos.x,
-            this.pos.y,
-            this.radiusV.x * 2 * x,
-            this.radiusV.y * 2 * y
-        );
-    }
-
-    /**
-     * Scale this Ellipse by the specified vector.
-     * @param {Vector2d} v
-     * @returns {Ellipse} Reference to this object for method chaining
-     */
-    scaleV(v) {
-        return this.scale(v.x, v.y);
-    }
-
-    /**
-     * apply the given transformation matrix to this ellipse
-     * @param {Matrix2d} matrix - the transformation matrix
-     * @returns {Polygon} Reference to this object for method chaining
-     */
-    transform(matrix) { // eslint-disable-line no-unused-vars
-        // TODO
-        return this;
-    }
-
-    /**
-     * translate the circle/ellipse by the specified offset
-     * @param {number|Vector2d} x -  x coordinate or a vector point to translate by
-     * @param {number} [y] - y offset
-     * @returns {Ellipse} this ellipse
-     * @example
-     * ellipse.translate(10, 10);
-     * // or
-     * ellipse.translate(myVector2d);
-     */
-    translate() {
-        let _x, _y;
-
-        if (arguments.length === 2) {
-            // x, y
-            _x = arguments[0];
-            _y = arguments[1];
-        } else {
-            // vector
-            _x = arguments[0].x;
-            _y = arguments[0].y;
-        }
-
-        this.pos.x += _x;
-        this.pos.y += _y;
-        this.getBounds().translate(_x, _y);
-
-        return this;
-    }
-
-    /**
-     * check if this circle/ellipse contains the specified point
-     * @param {number|Vector2d} x -  x coordinate or a vector point to check
-     * @param {number} [y] -  y coordinate
-     * @returns {boolean} true if contains
-     * @example
-     * if (circle.contains(10, 10)) {
-     *   // do something
-     * }
-     * // or
-     * if (circle.contains(myVector2d)) {
-     *  // do something
-     * }
-     */
-    contains(...args) {
-        let _x, _y;
-
-        if (args.length === 2) {
-            // x, y
-            [_x, _y] = args;
-        } else {
-            // vector
-            [_x, _y] = [args[0].x, args[0].y];
-        }
-
-        // Make position relative to object center point.
-        _x -= this.pos.x;
-        _y -= this.pos.y;
-        // Pythagorean theorem.
-        return (
-            ((_x * _x) / this.radiusSq.x) +
-            ((_y * _y) / this.radiusSq.y)
-        ) <= 1.0;
-    }
-
-    /**
-     * returns the bounding box for this shape, the smallest Rectangle object completely containing this shape.
-     * @returns {Bounds} this shape bounding box Rectangle object
-     */
-    getBounds() {
-        if (typeof this._bounds === "undefined") {
-            this._bounds = pool.pull("Bounds");
-        }
-        return this._bounds;
-    }
-
-    /**
-     * clone this Ellipse
-     * @returns {Ellipse} new Ellipse
-     */
-    clone() {
-        return new Ellipse(
-            this.pos.x,
-            this.pos.y,
-            this.radiusV.x * 2,
-            this.radiusV.y * 2
-        );
-    }
-}
-
-export { Ellipse as default };

package/dist/melonjs.mjs/geometries/line.js

@@ -1,108 +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 Polygon from './poly.js';
-
-/**
- * @classdesc
- * a line segment Object
- * @augments Polygon
- * @param {number} x - origin point of the Line
- * @param {number} y - origin point of the Line
- * @param {Vector2d[]} points - array of vectors defining the Line
- */
-
-class Line extends Polygon {
-
-    /**
-     * Returns true if the Line contains the given point
-     * @param {number|Vector2d} x -  x coordinate or a vector point to check
-     * @param {number} [y] -  y coordinate
-     * @returns {boolean} true if contains
-     * @example
-     * if (line.contains(10, 10)) {
-     *   // do something
-     * }
-     * // or
-     * if (line.contains(myVector2d)) {
-     *   // do something
-     * }
-     */
-    contains() {
-        let _x, _y;
-
-        if (arguments.length === 2) {
-            // x, y
-            _x = arguments[0];
-            _y = arguments[1];
-        } else {
-            // vector
-            _x = arguments[0].x;
-            _y = arguments[0].y;
-        }
-
-        // translate the given coordinates,
-        // rather than creating temp translated vectors
-        _x -= this.pos.x; // Cx
-        _y -= this.pos.y; // Cy
-        let start = this.points[0]; // Ax/Ay
-        let end = this.points[1]; // Bx/By
-
-        //(Cy - Ay) * (Bx - Ax) = (By - Ay) * (Cx - Ax)
-        return (_y - start.y) * (end.x - start.x) === (end.y - start.y) * (_x - start.x);
-    }
-
-    /**
-     * Computes the calculated collision edges and normals.
-     * This **must** be called if the `points` array, `angle`, or `offset` is modified manually.
-     * @returns {Line} this instance for objecf chaining
-     */
-    recalc() {
-        let edges = this.edges;
-        let normals = this.normals;
-        let indices = this.indices;
-
-        // Copy the original points array and apply the offset/angle
-        let points = this.points;
-
-        if (points.length !== 2) {
-            throw new Error("Requires exactly 2 points");
-        }
-
-        // Calculate the edges/normals
-        if (edges[0] === undefined) {
-            edges[0] = pool.pull("Vector2d");
-        }
-        edges[0].copy(points[1]).sub(points[0]);
-        if (normals[0] === undefined) {
-            normals[0] = pool.pull("Vector2d");
-        }
-        normals[0].copy(edges[0]).perp().normalize();
-
-        // do not do anything here, indices will be computed by
-        // toIndices if array is empty upon function call
-        indices.length = 0;
-
-        return this;
-    }
-
-    /**
-     * clone this line segment
-     * @returns {Line} new Line
-     */
-    clone() {
-        let copy = [];
-        this.points.forEach((point) => {
-            copy.push(point.clone());
-        });
-        return new Line(this.pos.x, this.pos.y, copy);
-    }
-
-}
-
-export { Line as default };