melonjs 14.0.2 → 14.1.0

package/dist/melonjs.mjs/entity/entity.js

@@ -0,0 +1,248 @@
+/*!
+ * melonJS Game Engine - v14.1.0
+ * 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 pool from '../system/pooling.js';
+import Renderable from '../renderable/renderable.js';
+import Sprite from '../renderable/sprite.js';
+import Body from '../physics/body.js';
+
+/**
+ * @classdesc
+ * a Generic Object Entity
+ * @augments Renderable
+ * @see Renderable
+ */
+class Entity extends Renderable {
+    /**
+     * @param {number} x - the x coordinates of the entity object
+     * @param {number} y - the y coordinates of the entity object
+     * @param {object} settings - Entity properties, to be defined through Tiled or when calling the entity constructor
+     * <img src="images/object_properties.png"/>
+     * @param {number} settings.width - the physical width the entity takes up in game
+     * @param {number} settings.height - the physical height the entity takes up in game
+     * @param {string} [settings.name] - object entity name
+     * @param {string} [settings.id] - object unique IDs
+     * @param {Image|string} [settings.image] - resource name of a spritesheet to use for the entity renderable component
+     * @param {Vector2d} [settings.anchorPoint=0.0] - Entity anchor point
+     * @param {number} [settings.framewidth=settings.width] - width of a single frame in the given spritesheet
+     * @param {number} [settings.frameheight=settings.width] - height of a single frame in the given spritesheet
+     * @param {string} [settings.type] - object type
+     * @param {number} [settings.collisionMask] - Mask collision detection for this object
+     * @param {Rect[]|Polygon[]|Line[]|Ellipse[]} [settings.shapes] - the initial list of collision shapes (usually populated through Tiled)
+     */
+    constructor(x, y, settings) {
+
+        // ensure mandatory properties are defined
+        if ((typeof settings.width !== "number") || (typeof settings.height !== "number")) {
+            throw new Error("height and width properties are mandatory when passing settings parameters to an object entity");
+        }
+
+        // call the super constructor
+        super(x, y, settings.width, settings.height);
+
+        /**
+         * The array of renderable children of this entity.
+         * @ignore
+         */
+        this.children = [];
+
+        if (settings.image) {
+            // set the frame size to the given entity size, if not defined in settings
+            settings.framewidth = settings.framewidth || settings.width;
+            settings.frameheight = settings.frameheight || settings.height;
+            this.renderable = new Sprite(0, 0, settings);
+        }
+
+        // Update anchorPoint
+        if (settings.anchorPoint) {
+            this.anchorPoint.set(settings.anchorPoint.x, settings.anchorPoint.y);
+        } else {
+            // for backward compatibility
+            this.anchorPoint.set(0, 0);
+        }
+
+        // set the sprite name if specified
+        if (typeof (settings.name) === "string") {
+            this.name = settings.name;
+        }
+
+        /**
+         * object type (as defined in Tiled)
+         * @public
+         * @type {string}
+         * @name type
+         * @memberof Entity
+         */
+        this.type = settings.type || "";
+
+        /**
+         * object unique ID (as defined in Tiled)
+         * @public
+         * @type {number}
+         * @name id
+         * @memberof Entity
+         */
+        this.id = settings.id || "";
+
+        /**
+         * dead/living state of the entity<br>
+         * default value : true
+         * @public
+         * @type {boolean}
+         * @name alive
+         * @memberof Entity
+         */
+        this.alive = true;
+
+        /**
+         * the entity body object
+         * @public
+         * @member {Body}
+         * @name body
+         * @memberof Entity
+         */
+        // initialize the default body
+        if (typeof settings.shapes === "undefined") {
+            settings.shapes = pool.pull("Polygon", 0, 0, [
+                pool.pull("Vector2d", 0,          0),
+                pool.pull("Vector2d", this.width, 0),
+                pool.pull("Vector2d", this.width, this.height),
+                pool.pull("Vector2d", 0,          this.height)
+            ]);
+        }
+        this.body = new Body(this, settings.shapes, this.onBodyUpdate.bind(this));
+
+        // resize the entity if required
+        if (this.width === 0 && this.height === 0) {
+            this.resize(this.body.getBounds().width, this.body.getBounds().height);
+        }
+
+        // set the  collision mask and type (if defined)
+        this.body.setCollisionMask(settings.collisionMask);
+        this.body.setCollisionType(settings.collisionType);
+
+        // disable for entities
+        this.autoTransform = false;
+    }
+
+
+    /**
+     * The entity renderable component (can be any objects deriving from me.Renderable, like me.Sprite for example)
+     * @public
+     * @type {Renderable}
+     * @name renderable
+     * @memberof Entity
+     */
+
+    get renderable() {
+        return this.children[0];
+    }
+
+    set renderable(value) {
+        if (value instanceof Renderable) {
+            this.children[0] = value;
+            this.children[0].ancestor = this;
+        } else {
+            throw new Error(value + "should extend me.Renderable");
+        }
+    }
+
+    /** @ignore */
+    update(dt) {
+        if (this.renderable) {
+            this.isDirty |= this.renderable.update(dt);
+        }
+        return super.update(dt);
+    }
+
+    /**
+     * update the bounds position when the body is modified
+     * @ignore
+     * @name onBodyUpdate
+     * @memberof Entity
+     * @param {Body} body - the body whose bounds to update
+     */
+    onBodyUpdate(body) {
+        // update the entity bounds to include the body bounds
+        this.getBounds().addBounds(body.getBounds(), true);
+        // update the bounds pos
+        this.updateBoundsPos(this.pos.x, this.pos.y);
+    }
+
+    preDraw(renderer) {
+        renderer.save();
+
+        // translate to the entity position
+        renderer.translate(
+            this.pos.x + this.body.getBounds().x,
+            this.pos.y + this.body.getBounds().y
+        );
+
+        if (this.renderable instanceof Renderable) {
+            // draw the child renderable's anchorPoint at the entity's
+            // anchor point.  the entity's anchor point is a scale from
+            // body position to body width/height
+            renderer.translate(
+                this.anchorPoint.x * this.body.getBounds().width,
+                this.anchorPoint.y * this.body.getBounds().height
+            );
+        }
+    }
+
+    /**
+     * draw this entity (automatically called by melonJS)
+     * @name draw
+     * @memberof Entity
+     * @protected
+     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer instance
+     * @param {Camera2d} [viewport] - the viewport to (re)draw
+     */
+    draw(renderer, viewport) {
+        var renderable = this.renderable;
+        if (renderable instanceof Renderable) {
+            // predraw (apply transforms)
+            renderable.preDraw(renderer);
+
+            // draw the object
+            renderable.draw(renderer, viewport);
+
+            // postdraw (clean-up);
+            renderable.postDraw(renderer);
+        }
+    }
+
+    /**
+     * Destroy function<br>
+     * @ignore
+     */
+    destroy() {
+        // free some property objects
+        if (this.renderable) {
+            this.renderable.destroy.apply(this.renderable, arguments);
+            this.children.splice(0, 1);
+        }
+
+        // call the parent destroy method
+        super.destroy(arguments);
+    }
+
+    /**
+     * onDeactivateEvent Notification function<br>
+     * Called by engine before deleting the object
+     * @name onDeactivateEvent
+     * @memberof Entity
+     */
+    onDeactivateEvent() {
+        if (this.renderable && this.renderable.onDeactivateEvent) {
+            this.renderable.onDeactivateEvent();
+        }
+    }
+
+}
+var Entity$1 = Entity;
+
+export { Entity$1 as default };

package/dist/melonjs.mjs/game.js

@@ -0,0 +1,29 @@
+/*!
+ * melonJS Game Engine - v14.1.0
+ * 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 { on, BOOT } from './system/event.js';
+import Application from './application/application.js';
+
+/**
+ * game is a default instance of a melonJS Application and represents your current game,
+ * it contains all the objects, tilemap layers, current viewport, collision map, etc...<br>
+ * @namespace game
+ * @see Application
+ */
+
+// create a default melonJS application instance
+let game = new Application();
+
+ // initialize the game manager on system boot
+on(BOOT, () => {
+    // initialize the default game instance
+    game.init();
+});
+
+var game$1 = game;
+
+export { game$1 as default };

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

@@ -0,0 +1,275 @@
+/*!
+ * melonJS Game Engine - v14.1.0
+ * 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 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}
+         * @name pos
+         * @memberof Ellipse
+         */
+        this.pos = pool.pull("Vector2d");
+
+        /**
+         * The bounding rectangle for this shape
+         * @private
+         */
+        this._bounds = undefined;
+
+        /**
+         * Maximum radius of the ellipse
+         * @public
+         * @type {number}
+         * @name radius
+         * @memberof Ellipse
+         */
+        this.radius = NaN;
+
+        /**
+         * Pre-scaled radius vector for ellipse
+         * @public
+         * @type {Vector2d}
+         * @name radiusV
+         * @memberof Ellipse
+         */
+        this.radiusV = pool.pull("Vector2d");
+
+        /**
+         * Radius squared, for pythagorean theorom
+         * @public
+         * @type {Vector2d}
+         * @name radiusSq
+         * @memberof Ellipse
+         */
+        this.radiusSq = pool.pull("Vector2d");
+
+        /**
+         * x/y scaling ratio for ellipse
+         * @public
+         * @type {Vector2d}
+         * @name ratio
+         * @memberof Ellipse
+         */
+        this.ratio = pool.pull("Vector2d");
+
+        // the shape type
+        this.shapeType = "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
+     * @name setShape
+     * @memberof 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
+     * @returns {Ellipse} this instance for objecf chaining
+     */
+    setShape(x, y, w, h) {
+        var hW = w / 2;
+        var hH = h / 2;
+
+        this.pos.set(x, y);
+        this.radius = Math.max(hW, hH);
+        this.ratio.set(hW / this.radius, hH / this.radius);
+        this.radiusV.set(this.radius, this.radius).scaleV(this.ratio);
+        var r = this.radius * this.radius;
+        this.radiusSq.set(r, r).scaleV(this.ratio);
+
+        // update the corresponding bounds
+        this.getBounds().setMinMax(x, y, x + w, x + h);
+        // elipse position is the center of the cirble, bounds position are top left
+        this.getBounds().translate(-this.radiusV.x, -this.radiusV.y);
+
+        return this;
+    }
+
+    /**
+     * Rotate this Ellipse (counter-clockwise) by the specified angle (in radians).
+     * @name rotate
+     * @memberof Ellipse
+     * @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) {
+        // TODO : only works for circle
+        this.pos.rotate(angle, v);
+        this.getBounds().shift(this.pos);
+        this.getBounds().translate(-this.radiusV.x, -this.radiusV.y);
+        return this;
+    }
+
+    /**
+     * Scale this Ellipse by the specified scalar.
+     * @name scale
+     * @memberof Ellipse
+     * @param {number} x
+     * @param {number} [y=x]
+     * @returns {Ellipse} Reference to this object for method chaining
+     */
+    scale(x, y) {
+        y = typeof (y) !== "undefined" ? 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.
+     * @name scale
+     * @memberof Ellipse
+     * @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
+     * @name transform
+     * @memberof 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
+     * @name translate
+     * @memberof Ellipse
+     * @method
+     * @param {number} x - x offset
+     * @param {number} y - y offset
+     * @returns {Ellipse} this ellipse
+     */
+    /**
+     * translate the circle/ellipse by the specified vector
+     * @name translate
+     * @memberof Ellipse
+     * @param {Vector2d} v - vector offset
+     * @returns {Ellipse} this ellipse
+     */
+    translate() {
+        var _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
+     * @name contains
+     * @method
+     * @memberof Ellipse
+     * @param {Vector2d} point
+     * @returns {boolean} true if contains
+     */
+
+    /**
+     * check if this circle/ellipse contains the specified point
+     * @name contains
+     * @memberof Ellipse
+     * @param  {number} x -  x coordinate
+     * @param  {number} y -  y coordinate
+     * @returns {boolean} true if contains
+     */
+    contains() {
+        var _x, _y;
+
+        if (arguments.length === 2) {
+          // x, y
+          _x = arguments[0];
+          _y = arguments[1];
+        } else {
+          // vector
+          _x = arguments[0].x;
+          _y = arguments[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.
+     * @name getBounds
+     * @memberof Ellipse
+     * @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
+     * @name clone
+     * @memberof Ellipse
+     * @returns {Ellipse} new Ellipse
+     */
+    clone() {
+        return new Ellipse(
+            this.pos.x,
+            this.pos.y,
+            this.radiusV.x * 2,
+            this.radiusV.y * 2
+        );
+    }
+}
+var Ellipse$1 = Ellipse;
+
+export { Ellipse$1 as default };

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

@@ -0,0 +1,116 @@
+/*!
+ * melonJS Game Engine - v14.1.0
+ * 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 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
+     * @name contains
+     * @memberof Line
+     * @method
+     * @param {Vector2d} point
+     * @returns {boolean} true if contains
+     */
+
+    /**
+     * Returns true if the Line contains the given point
+     * @name contains
+     * @memberof Line
+     * @param  {number} x -  x coordinate
+     * @param  {number} y -  y coordinate
+     * @returns {boolean} true if contains
+     */
+    contains() {
+        var _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
+        var start = this.points[0]; // Ax/Ay
+        var 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.
+     * @name recalc
+     * @memberof Line
+     * @returns {Line} this instance for objecf chaining
+     */
+    recalc() {
+        var edges = this.edges;
+        var normals = this.normals;
+        var indices = this.indices;
+
+        // Copy the original points array and apply the offset/angle
+        var 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
+     * @name clone
+     * @memberof Line
+     * @returns {Line} new Line
+     */
+    clone() {
+        var copy = [];
+        this.points.forEach((point) => {
+            copy.push(point.clone());
+        });
+        return new Line(this.pos.x, this.pos.y, copy);
+    }
+
+}
+var Line$1 = Line;
+
+export { Line$1 as default };