melonjs 9.1.0 → 10.0.1

package/src/physics/body.js

@@ -1,14 +1,13 @@
 import Vector2d from "./../math/vector2.js";
-import ObservableVector2d from "./../math/observable_vector2.js";
 import Rect from "./../shapes/rectangle.js";
 import Ellipse from "./../shapes/ellipse.js";
 import Polygon from "./../shapes/poly.js";
 import Bounds from "./bounds.js";
 import collision from "./collision.js";
-import utils from "./../utils/utils.js";
+import * as arrayUtil from "./../utils/array.js";
 import timer from "./../system/timer.js";
 import { clamp } from "./../math/math.js";
-import game from "./../game.js";
+import { world } from "./../game.js";
 
 
 /**
@@ -89,8 +88,7 @@ class Body {
         this.collisionType = collision.types.ENEMY_OBJECT;
 
         /**
-         * body velocity<br>
-         *
+         * body velocity
          * @public
          * @type me.Vector2d
          * @default <0,0>
@@ -102,22 +100,6 @@ class Body {
         }
         this.vel.set(0, 0);
 
-        /**
-         * body acceleration <br>
-         * Not fully implemented yet.  At this time accel is used to set the MaximumVelocity allowed.
-         * @public
-         * @type me.Vector2d
-         * @default <0,0>
-         * @name accel
-         * @deprecated
-         * @see me.Body.force
-         * @memberOf me.Body
-         */
-        if (typeof this.accel === "undefined") {
-            this.accel = new Vector2d();
-        }
-        this.accel.set(0, 0);
-
         /**
          * body force or acceleration (automatically) applied to the body.
          * when defining a force, user should also define a max velocity
@@ -198,32 +180,18 @@ class Body {
         // cap by default to half the default gravity force
         this.maxVel.set(490, 490);
 
+
         /**
-         * Default gravity value for this body.
-         * To be set to to < 0, 0 > for RPG, shooter, etc...<br>
+         * either this body is a static body or not
+         * @readonly
          * @public
-         * @see me.Body.gravityScale
-         * @type me.Vector2d
-         * @default <0,0.98>
-         * @deprecated since 8.0.0
-         * @name gravity
+         * @type Boolean
+         * @default false
+         * @name isStatic
          * @memberOf me.Body
          */
-        if (typeof this.gravity === "undefined") {
-            var self = this;
-            this.gravity = new ObservableVector2d(0, 0, { onUpdate : function(x, y) {
-                // disable gravity or apply a scale if y gravity is different from 0
-                if (typeof y === "number") {
-                    self.gravityScale = y / game.world.gravity.y;
-                }
-                // deprecation // WARNING:
-                console.log(
-                    "me.Body.gravity is deprecated, " +
-                    "please see me.Body.gravityScale " +
-                    "to modify gravity for a specific body"
-                );
-            }});
-        }
+        this.isStatic = false;
+
 
         /**
          * The degree to which this body is affected by the world gravity
@@ -294,6 +262,19 @@ class Body {
         this.ancestor.isKinematic = false;
     }
 
+    /**
+     * set the body as a static body
+     * static body do not move automatically and do not check againt collision with others
+     * @name setStatic
+     * @memberOf me.Body
+     * @public
+     * @function
+     * @param {Boolean} [isStatic=true]
+     */
+    setStatic(isStatic = true) {
+        this.isStatic = isStatic === true;
+    }
+
     /**
      * add a collision shape to this body <br>
      * (note: me.Rect objects will be converted to me.Polygon before being added)
@@ -302,7 +283,6 @@ class Body {
      * @public
      * @function
      * @param {me.Rect|me.Polygon|me.Line|me.Ellipse|me.Bounds|Object} shape a shape or JSON object
-     * @param {Boolean} batchInsert if true the body bounds won't be updated after adding a shape
      * @return {Number} the shape array length
      * @example
      * // add a rectangle shape
@@ -472,7 +452,7 @@ class Body {
         // clear the current bounds
         this.bounds.clear();
         // remove the shape from shape list
-        utils.array.remove(this.shapes, shape);
+        arrayUtil.remove(this.shapes, shape);
         // add everything left back
         for (var s = 0; s < this.shapes.length; s++) {
             this.addShape(this.shapes[s]);
@@ -568,7 +548,7 @@ class Body {
             }
 
             // cancel the falling an jumping flags if necessary
-            var dir = Math.sign(game.world.gravity.y * this.gravityScale) || 1;
+            var dir = Math.sign(world.gravity.y * this.gravityScale) || 1;
             this.falling = overlap.y >= dir;
             this.jumping = overlap.y <= -dir;
         }
@@ -685,28 +665,6 @@ class Body {
         return this;
     }
 
-    /**
-     * Sets accel to Velocity if x or y is not 0.  Net effect is to set the maxVel.x/y to the passed values for x/y<br>
-     * note: This does not set the vel member of the body object. This is identical to the setMaxVelocity call except that the
-     * accel property is updated to match the passed x and y.
-     * setMaxVelocity if needed<br>
-     * @name setVelocity
-     * @memberOf me.Body
-     * @function
-     * @param {Number} x velocity on x axis
-     * @param {Number} y velocity on y axis
-     * @protected
-     * @deprecated
-     * @see me.Body.force
-     */
-    setVelocity(x, y) {
-        this.accel.x = x !== 0 ? x : this.accel.x;
-        this.accel.y = y !== 0 ? y : this.accel.y;
-
-        // limit by default to the same max value
-        this.setMaxVelocity(x, y);
-    }
-
     /**
      * cap the body velocity (body.maxVel property) to the specified value<br>
      * @name setMaxVelocity
@@ -730,69 +688,70 @@ class Body {
      * @param {Number} y vertical friction
      * @protected
      */
-    setFriction(x, y) {
-        this.friction.x = x || 0;
-        this.friction.y = y || 0;
-    }
-
-    /**
-     * apply friction to a vector
-     * @ignore
-     */
-    applyFriction(vel) {
-        var fx = this.friction.x * timer.tick,
-            nx = vel.x + fx,
-            x = vel.x - fx,
-            fy = this.friction.y * timer.tick,
-            ny = vel.y + fy,
-            y = vel.y - fy;
-
-        vel.x = (
-            (nx < 0) ? nx :
-            ( x > 0) ? x  : 0
-        );
-        vel.y = (
-            (ny < 0) ? ny :
-            ( y > 0) ? y  : 0
-        );
+    setFriction(x = 0, y = 0) {
+        this.friction.x = x;
+        this.friction.y = y;
     }
 
     /**
      * compute the new velocity value
      * @ignore
      */
-    computeVelocity(vel) {
-        // apply fore if defined
-        if (this.force.x) {
-            vel.x += this.force.x * timer.tick;
-        }
-        if (this.force.y) {
-            vel.y += this.force.y * timer.tick;
-        }
-
-        // apply friction
-        if (this.friction.x || this.friction.y) {
-            this.applyFriction(vel);
-        }
+    computeVelocity(/* dt */) {
+        // apply timer.tick to delta time for linear interpolation (when enabled)
+        // #761 add delta time in body update
+        var deltaTime = /* dt * */ timer.tick;
 
+        // apply gravity to the current velocity
         if (!this.ignoreGravity) {
-            var worldGravity = game.world.gravity;
+            var worldGravity = world.gravity;
+
             // apply gravity if defined
-            vel.x += worldGravity.x * this.gravityScale * this.mass * timer.tick;
-            vel.y += worldGravity.y * this.gravityScale * this.mass * timer.tick;
+            this.vel.x += worldGravity.x * this.gravityScale * deltaTime;
+            this.vel.y += worldGravity.y * this.gravityScale * deltaTime;
+
             // check if falling / jumping
-            this.falling = (vel.y * Math.sign(worldGravity.y * this.gravityScale)) > 0;
+            this.falling = (this.vel.y * Math.sign(worldGravity.y * this.gravityScale)) > 0;
             this.jumping = (this.falling ? false : this.jumping);
         }
 
-        // cap velocity
-        if (vel.y !== 0) {
-            vel.y = clamp(vel.y, -this.maxVel.y, this.maxVel.y);
+        // apply force if defined
+        if (this.force.x !== 0) {
+            this.vel.x += this.force.x * deltaTime;
+        }
+        if (this.force.y !== 0) {
+            this.vel.y += this.force.y * deltaTime;
+        }
+
+        // apply friction if defined
+        if (this.friction.x > 0) {
+            var fx = this.friction.x * deltaTime,
+                nx = this.vel.x + fx,
+                x = this.vel.x - fx;
+
+            this.vel.x = (
+                (nx < 0) ? nx :
+                ( x > 0) ? x  : 0
+            );
         }
-        if (vel.x !== 0) {
-            vel.x = clamp(vel.x, -this.maxVel.x, this.maxVel.x);
+        if (this.friction.y > 0) {
+            var fy = this.friction.y * deltaTime,
+                ny = this.vel.y + fy,
+                y = this.vel.y - fy;
+
+            this.vel.y = (
+                (ny < 0) ? ny :
+                ( y > 0) ? y  : 0
+            );
         }
 
+        // cap velocity
+        if (this.vel.y !== 0) {
+            this.vel.y = clamp(this.vel.y, -this.maxVel.y, this.maxVel.y);
+        }
+        if (this.vel.x !== 0) {
+            this.vel.x = clamp(this.vel.x, -this.maxVel.x, this.maxVel.x);
+        }
     }
 
     /**
@@ -807,16 +766,17 @@ class Body {
      * In addition, when the gravity calcuation is made, if the Body.vel.y > 0 then the Body.falling
      * property is set to true and Body.jumping is set to !Body.falling.
      *
-     * At this time a call to Body.Update does not call the onBodyUpdate callback that is listed in the init: function.
+     * At this time a call to Body.Update does not call the onBodyUpdate callback that is listed in the constructor arguments.
      * @name update
+     * @ignore
      * @memberOf me.Body
      * @function
      * @return {boolean} true if resulting velocity is different than 0
      * @see source code for me.Body.computeVelocity (private member)
      */
-    update(/* dt */) {
+    update(dt) {
         // update the velocity
-        this.computeVelocity(this.vel);
+        this.computeVelocity(dt);
 
         // update the body ancestor position
         this.ancestor.pos.add(this.vel);
@@ -832,6 +792,8 @@ class Body {
     destroy() {
         this.onBodyUpdate = undefined;
         this.ancestor = undefined;
+        this.bounds = undefined;
+        this.setStatic(false);
         this.shapes.length = 0;
     }
 };

package/src/physics/collision.js

@@ -1,73 +1,9 @@
-import * as SAT from "./sat.js";
-import Vector2d from "./../math/vector2.js";
-import game from "./../game.js";
-
-// a dummy object when using Line for raycasting
-var dummyObj = {
-    pos : new Vector2d(0, 0),
-    ancestor : {
-        _absPos : new Vector2d(0, 0),
-        getAbsolutePosition : function () {
-            return this._absPos;
-        }
-    }
-};
-
-/**
- * @classdesc
- * An object representing the result of an intersection.
- * @property {me.Renderable} a The first object participating in the intersection
- * @property {me.Renderable} b The second object participating in the intersection
- * @property {Number} overlap Magnitude of the overlap on the shortest colliding axis
- * @property {me.Vector2d} overlapV The overlap vector (i.e. `overlapN.scale(overlap, overlap)`). If this vector is subtracted from the position of a, a and b will no longer be colliding
- * @property {me.Vector2d} overlapN The shortest colliding axis (unit-vector)
- * @property {Boolean} aInB Whether the first object is entirely inside the second
- * @property {Boolean} bInA Whether the second object is entirely inside the first
- * @property {Number} indexShapeA The index of the colliding shape for the object a body
- * @property {Number} indexShapeB The index of the colliding shape for the object b body
- * @name ResponseObject
- * @memberOf me.collision
- * @public
- * @see me.collision.check
- */
-class ResponseObject {
-    constructor() {
-        this.a = null;
-        this.b = null;
-        this.overlapN = new Vector2d();
-        this.overlapV = new Vector2d();
-        this.aInB = true;
-        this.bInA = true;
-        this.indexShapeA = -1;
-        this.indexShapeB = -1;
-        this.overlap = Number.MAX_VALUE;
-        return this;
-    }
-
-    /**
-     * Set some values of the response back to their defaults. <br>
-     * Call this between tests if you are going to reuse a single <br>
-     * Response object for multiple intersection tests <br>
-     * (recommended as it will avoid allocating extra memory) <br>
-     * @name clear
-     * @memberOf me.collision.ResponseObject
-     * @public
-     * @function
-     */
-    clear () {
-        this.aInB = true;
-        this.bInA = true;
-        this.overlap = Number.MAX_VALUE;
-        this.indexShapeA = -1;
-        this.indexShapeB = -1;
-        return this;
-    }
-}
+import { rayCast, globalResponse } from "./detector.js";
 
 /**
- * A singleton for managing collision detection (and projection-based collision response) of 2D shapes.<br>
+ * Collision detection (and projection-based collision response) of 2D shapes.<br>
  * Based on the Separating Axis Theorem and supports detecting collisions between simple Axis-Aligned Boxes, convex polygons and circles based shapes.
- * @namespace me.collision
+ * @namespace collision
  * @memberOf me
  */
 
@@ -166,124 +102,7 @@ var collision = {
      * @public
      * @type {me.collision.ResponseObject}
      */
-    response : new ResponseObject(),
-
-    /**
-     * a callback used to determine if two objects should collide (based on both respective objects collision mask and type).<br>
-     * you can redefine this function if you need any specific rules over what should collide with what.
-     * @name shouldCollide
-     * @memberOf me.collision
-     * @public
-     * @function
-     * @param {me.Renderable} a a reference to the object A.
-     * @param {me.Renderable} b a reference to the object B.
-     * @return {Boolean} true if they should collide, false otherwise
-     */
-    shouldCollide(a, b) {
-        return (
-            a.isKinematic !== true && b.isKinematic !== true &&
-            a.body && b.body &&
-            (a.body.collisionMask & b.body.collisionType) !== 0 &&
-            (a.body.collisionType & b.body.collisionMask) !== 0
-        );
-    },
-
-    /**
-     * Checks if the specified object collides with others
-     * @name check
-     * @memberOf me.collision
-     * @public
-     * @function
-     * @param {me.Renderable} obj object to be tested for collision
-     * @param {me.collision.ResponseObject} [respObj=me.collision.response] a user defined response object that will be populated if they intersect.
-     * @return {Boolean} in case of collision, false otherwise
-     * @example
-     * update : function (dt) {
-     *    // ...
-     *
-     *    // handle collisions against other shapes
-     *    me.collision.check(this);
-     *
-     *    // ...
-     * },
-     *
-     * // colision handler
-     * onCollision : function (response) {
-     *     if (response.b.body.collisionType === me.collision.types.ENEMY_OBJECT) {
-     *         // makes the other object solid, by substracting the overlap vector to the current position
-     *         this.pos.sub(response.overlapV);
-     *         this.hurt();
-     *         // not solid
-     *         return false;
-     *     }
-     *     // Make the object solid
-     *     return true;
-     * },
-     */
-    check(objA, responseObject) {
-        var collision = 0;
-        var response = responseObject || this.response;
-
-        // retreive a list of potential colliding objects
-        var candidates = game.world.broadphase.retrieve(objA);
-
-        for (var i = candidates.length, objB; i--, (objB = candidates[i]);) {
-
-            // check if both objects "should" collide
-            if ((objB !== objA) && this.shouldCollide(objA, objB) &&
-                // fast AABB check if both bounding boxes are overlaping
-                objA.body.getBounds().overlaps(objB.body.getBounds())) {
-
-                // go trough all defined shapes in A
-                var aLen = objA.body.shapes.length;
-                var bLen = objB.body.shapes.length;
-                if (aLen === 0 || bLen === 0) {
-                    continue;
-                }
-
-                var indexA = 0;
-                do {
-                    var shapeA = objA.body.getShape(indexA);
-                    // go through all defined shapes in B
-                    var indexB = 0;
-                    do {
-                        var shapeB = objB.body.getShape(indexB);
-
-                        // full SAT collision check
-                        if (SAT["test" + shapeA.shapeType + shapeB.shapeType]
-                            .call(
-                                this,
-                                objA, // a reference to the object A
-                                shapeA,
-                                objB,  // a reference to the object B
-                                shapeB,
-                                 // clear response object before reusing
-                                response.clear()) === true
-                        ) {
-                            // we touched something !
-                            collision++;
-
-                            // set the shape index
-                            response.indexShapeA = indexA;
-                            response.indexShapeB = indexB;
-
-                            // execute the onCollision callback
-                            if (objA.onCollision && objA.onCollision(response, objB) !== false) {
-                                objA.body.respondToCollision.call(objA.body, response);
-                            }
-                            if (objB.onCollision && objB.onCollision(response, objA) !== false) {
-                                objB.body.respondToCollision.call(objB.body, response);
-                            }
-                        }
-                        indexB++;
-                    } while (indexB < bLen);
-                    indexA++;
-                } while (indexA < aLen);
-            }
-        }
-        // we could return the amount of objects we collided with ?
-        return collision > 0;
-    },
+    response : globalResponse,
 
     /**
      * Checks for object colliding with the given line
@@ -312,56 +131,7 @@ var collision = {
      *        // ...
      *    }
      */
-    rayCast(line, resultArray) {
-        var collision = 0;
-        var result = resultArray || [];
-
-        // retrieve a list of potential colliding objects
-        var candidates = game.world.broadphase.retrieve(line);
-
-        for (var i = candidates.length, objB; i--, (objB = candidates[i]);) {
-
-            // fast AABB check if both bounding boxes are overlaping
-            if (objB.body && line.getBounds().overlaps(objB.getBounds())) {
-
-                // go trough all defined shapes in B (if any)
-                var bLen = objB.body.shapes.length;
-                if ( objB.body.shapes.length === 0) {
-                    continue;
-                }
-
-                var shapeA = line;
-
-                // go through all defined shapes in B
-                var indexB = 0;
-                do {
-                    var shapeB = objB.body.getShape(indexB);
-
-                    // full SAT collision check
-                    if (SAT["test" + shapeA.shapeType + shapeB.shapeType]
-                        .call(
-                            this,
-                            dummyObj, // a reference to the object A
-                            shapeA,
-                            objB,  // a reference to the object B
-                            shapeB
-                    )) {
-                        // we touched something !
-                        result[collision] = objB;
-                        collision++;
-                    }
-                    indexB++;
-                } while (indexB < bLen);
-            }
-        }
-
-        // cap result in case it was not empty
-        result.length = collision;
-
-        // return the list of colliding objects
-        return result;
-    }
-
+    rayCast(line, resultArray) { return rayCast(line, resultArray); }
 };
 
 export default collision;