melonjs 9.1.0 → 10.0.1

package/src/physics/detector.js

@@ -0,0 +1,235 @@
+import * as SAT from "./sat.js";
+import Vector2d from "./../math/vector2.js";
+import { world } 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;
+        }
+    }
+};
+
+/**
+ * a function 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
+ * @ignore
+ * @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
+ */
+function 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
+    );
+};
+
+/**
+ * @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;
+    }
+}
+
+// @ignore
+export var globalResponse = new ResponseObject();
+
+/**
+ * find all the collisions for the specified object
+ * @name collisionCheck
+ * @ignore
+ * @function
+ * @param {me.Renderable} obj object to be tested for collision
+ * @param {me.collision.ResponseObject} [response=me.collision.response] a user defined response object that will be populated if they intersect.
+ * @return {Boolean} in case of collision, false otherwise
+ */
+export function collisionCheck(objA, response = globalResponse) {
+    var collisionCounter = 0;
+    // retreive a list of potential colliding objects from the game world
+    var candidates = world.broadphase.retrieve(objA);
+
+    for (var i = candidates.length, objB; i--, (objB = candidates[i]);) {
+
+        // check if both objects "should" collide
+        if ((objB !== objA) && 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 !
+                        collisionCounter++;
+
+                        // 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 collisionCounter > 0;
+};
+
+/**
+ * Checks for object colliding with the given line
+ * @name rayCast
+ * @ignore
+ * @function
+ * @param {me.Line} line line to be tested for collision
+ * @param {Array.<me.Renderable>} [result] a user defined array that will be populated with intersecting physic objects.
+ * @return {Array.<me.Renderable>} an array of intersecting physic objects
+ * @example
+ *    // define a line accross the viewport
+ *    var ray = new me.Line(
+ *        // absolute position of the line
+ *        0, 0, [
+ *        // starting point relative to the initial position
+ *        new me.Vector2d(0, 0),
+ *        // ending point
+ *        new me.Vector2d(me.game.viewport.width, me.game.viewport.height)
+ *    ]);
+ *
+ *    // check for collition
+ *    result = me.collision.rayCast(ray);
+ *
+ *    if (result.length > 0) {
+ *        // ...
+ *    }
+ */
+export function rayCast(line, result = []) {
+    var collisionCounter = 0;
+
+    // retrieve a list of potential colliding objects from the game world
+    var candidates = 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[collisionCounter] = objB;
+                    collisionCounter++;
+                }
+                indexB++;
+            } while (indexB < bLen);
+        }
+    }
+
+    // cap result in case it was not empty
+    result.length = collisionCounter;
+
+    // return the list of colliding objects
+    return result;
+};

package/src/physics/quadtree.js

@@ -1,7 +1,7 @@
 import Vector2d from "./../math/vector2.js";
 import Container from "./../renderable/container.js";
-import utils from "./../utils/utils.js";
-import game from "./../game.js";
+import * as arrayUtil from "./../utils/array.js";
+import { viewport } from "./../game.js";
 
 /*
  * A QuadTree implementation in JavaScript, a 2d spatial subdivision algorithm.
@@ -21,13 +21,13 @@ var QT_ARRAY = [];
  * or create a new one if the array is empty
  * @ignore
  */
-function QT_ARRAY_POP(bounds, max_objects, max_levels, level) {
+function QT_ARRAY_POP(bounds, max_objects = 4, max_levels = 4, level = 0) {
     if (QT_ARRAY.length > 0) {
         var _qt =  QT_ARRAY.pop();
         _qt.bounds = bounds;
-        _qt.max_objects = max_objects || 4;
-        _qt.max_levels  = max_levels || 4;
-        _qt.level = level || 0;
+        _qt.max_objects = max_objects;
+        _qt.max_levels  = max_levels;
+        _qt.level = level;
         return _qt;
     } else {
         return new QuadTree(bounds, max_objects, max_levels, level);
@@ -63,11 +63,11 @@ var QT_VECTOR = new Vector2d();
  */
 class QuadTree {
 
-    constructor(bounds, max_objects, max_levels, level) {
-        this.max_objects = max_objects || 4;
-        this.max_levels  = max_levels || 4;
+    constructor(bounds, max_objects = 4, max_levels = 4, level = 0) {
+        this.max_objects = max_objects;
+        this.max_levels  = max_levels;
 
-        this.level = level || 0;
+        this.level = level;
         this.bounds = bounds;
 
         this.objects = [];
@@ -125,9 +125,9 @@ class QuadTree {
     getIndex(item) {
         var pos;
 
-        // use world coordinates for floating items
+        // use game world coordinates for floating items
         if (item.floating || (item.ancestor && item.ancestor.floating)) {
-            pos = game.viewport.localToWorld(item.left, item.top, QT_VECTOR);
+            pos = viewport.localToWorld(item.left, item.top, QT_VECTOR);
         } else {
             pos = QT_VECTOR.set(item.left, item.top);
         }
@@ -295,7 +295,7 @@ class QuadTree {
             var index = this.getIndex(item);
 
             if (index !== -1) {
-                found = utils.array.remove(this.nodes[index], item);
+                found = arrayUtil.remove(this.nodes[index], item);
                 // trim node if empty
                 if (found && this.nodes[index].isPrunable()) {
                     this.nodes.splice(index, 1);
@@ -306,7 +306,7 @@ class QuadTree {
         if (found === false) {
             // try and remove the item from the list of items in this node
             if (this.objects.indexOf(item) !== -1) {
-                utils.array.remove(this.objects, item);
+                arrayUtil.remove(this.objects, item);
                 found = true;
             }
         }

package/src/physics/world.js

@@ -1,9 +1,10 @@
 import Vector2d from "./../math/vector2.js";
-import game from "./../game.js";
-import event from "./../system/event.js";
+import * as event from "./../system/event.js";
 import QuadTree from "./quadtree.js";
 import Container from "./../renderable/container.js";
 import collision from "./collision.js";
+import { collisionCheck } from "./detector.js";
+import state from "./../state/state.js";
 
 /**
  * an object representing the physic world, and responsible for managing and updating all childs and physics
@@ -16,13 +17,14 @@ import collision from "./collision.js";
  * @param {Number} [w=me.game.viewport.width] width of the container
  * @param {Number} [h=me.game.viewport.height] height of the container
  */
-var World = Container.extend({
+class World extends Container {
     /**
      * @ignore
      */
-    init : function (x = 0, y = 0, width = Infinity, height = Infinity) {
-        // call the _super constructor
-        this._super(Container, "init", [x, y, width, height, true]);
+    constructor(x = 0, y = 0, width = Infinity, height = Infinity) {
+
+        // call the super constructor
+        super(x, y, width, height, true);
 
         // world is the root container
         this.name = "rootContainer";
@@ -66,6 +68,15 @@ var World = Container.extend({
          */
         this.preRender = false;
 
+        /**
+         * the active physic bodies in this simulation
+         * @name bodies
+         * @memberOf me.World
+         * @public
+         * @type {Set}
+         */
+        this.bodies = new Set();
+
         /**
          * the instance of the game world quadtree used for broadphase
          * @name broadphase
@@ -76,14 +87,14 @@ var World = Container.extend({
         this.broadphase = new QuadTree(this.getBounds().clone(), collision.maxChildren, collision.maxDepth);
 
         // reset the world container on the game reset signal
-        event.subscribe(event.GAME_RESET, this.reset.bind(this));
+        event.on(event.GAME_RESET, this.reset, this);
 
         // update the broadband world bounds if a new level is loaded
-        event.subscribe(event.LEVEL_LOADED, function () {
+        event.on(event.LEVEL_LOADED, () => {
             // reset the quadtree
-            game.world.broadphase.clear(game.world.getBounds());
+            this.broadphase.clear(this.getBounds());
         });
-    },
+    }
 
     /**
      * reset the game world
@@ -91,16 +102,50 @@ var World = Container.extend({
      * @memberOf me.World
      * @function
      */
-    reset : function () {
+    reset() {
         // clear the quadtree
         this.broadphase.clear();
 
         // reset the anchorPoint
         this.anchorPoint.set(0, 0);
 
-        // call the _super constructor
-        this._super(Container, "reset");
-    },
+        // call the parent method
+        super.reset();
+
+        // empty the list of active physic bodies
+        // Note: this should be empty already when calling the parent method
+        this.bodies.clear();
+    }
+
+    /**
+     * Add a physic body to the game world
+     * @name addBody
+     * @memberOf me.World
+     * @see me.Container.addChild
+     * @function
+     * @param {me.Body} body
+     * @return {me.World} this game world
+     */
+    addBody(body) {
+        //add it to the list of active body
+        this.bodies.add(body);
+        return this;
+    }
+
+    /**
+     * Remove a physic body from the game world
+     * @name removeBody
+     * @memberOf me.World
+     * @see me.Container.removeChild
+     * @function
+     * @param {me.Body} body
+     * @return {me.World} this game world
+     */
+    removeBody(body) {
+        //remove from the list of active body
+        this.bodies.delete(body);
+        return this;
+    }
 
     /**
      * update the game world
@@ -108,16 +153,37 @@ var World = Container.extend({
      * @memberOf me.World
      * @function
      */
-    update : function (dt) {
+    update (dt) {
+        var isPaused = state.isPaused();
+
         // clear the quadtree
         this.broadphase.clear();
 
         // insert the world container (children) into the quadtree
         this.broadphase.insertContainer(this);
 
-        // call the _super constructor
-        return this._super(Container, "update", [dt]);
+        // iterate through all bodies
+        this.bodies.forEach((body) => {
+            if (!body.isStatic) {
+                var ancestor = body.ancestor;
+                // if the game is not paused, and ancestor can be updated
+                if (!(isPaused && (!ancestor.updateWhenPaused)) &&
+                   (ancestor.inViewport || ancestor.alwaysUpdate)) {
+                    // apply physics to the body (this moves it)
+                    if (body.update(dt) === true) {
+                        // mark ancestor as dirty
+                        ancestor.isDirty = true;
+                    };
+                    // handle collisions against other objects
+                    collisionCheck(ancestor);
+                }
+            }
+        });
+
+        // call the super constructor
+        return super.update(dt);
     }
-});
+
+};
 
 export default World;

package/src/plugin/plugin.js

@@ -1,6 +1,5 @@
 import utils from "./../utils/utils.js";
 import { version } from "./../index.js";
-import "jay-extend";
 
 /**
  * This namespace is a container for all registered plugins.
@@ -10,6 +9,22 @@ import "jay-extend";
  */
 export var plugins = {};
 
+
+class BasePlugin {
+
+    constructor() {
+        /**
+         * define the minimum required version of melonJS<br>
+         * this can be overridden by the plugin
+         * @public
+         * @type String
+         * @default "__VERSION__"
+         * @name me.plugin.Base#version
+         */
+        this.version = "__VERSION__";
+    }
+}
+
 /**
  * @namespace plugin
  * @memberOf me
@@ -17,29 +32,16 @@ export var plugins = {};
 export var plugin = {
 
     /**
-    * a base Object for plugin <br>
-    * plugin must be installed using the register function
-    * @see me.plugin
-    * @class
-    * @extends me.Object
-    * @name plugin.Base
-    * @memberOf me
-    * @constructor
-    */
-    Base : window.Jay.extend({
-        /** @ignore */
-        init : function () {
-            /**
-             * define the minimum required version of melonJS<br>
-             * this can be overridden by the plugin
-             * @public
-             * @type String
-             * @default "__VERSION__"
-             * @name me.plugin.Base#version
-             */
-            this.version = "__VERSION__";
-        }
-    }),
+     * a base Object for plugin <br>
+     * plugin must be installed using the register function
+     * @see me.plugin
+     * @class
+     * @extends me.Object
+     * @name plugin.Base
+     * @memberOf me
+     * @constructor
+     */
+    Base : BasePlugin,
 
     /**
      * patch a melonJS function

package/src/polyfill/console.js

@@ -1,16 +1,11 @@
-/* eslint-disable no-global-assign, no-native-reassign */
-if (typeof console === "undefined") {
-    /**
-     * Dummy console.log to avoid crash
-     * in case the browser does not support it
-     * @ignore
-     */
-    console = {
-        log : function () {},
-        info : function () {},
-        error : function () {
+if (typeof window !== "undefined") {
+    if (typeof window.console === "undefined") {
+        window.console = {};
+        window.console.log = function() {};
+        window.console.assert = function() {};
+        window.console.warn = function() {};
+        window.console.error = function() {
             alert(Array.prototype.slice.call(arguments).join(", "));
-        }
-    };
+        };
+    }
 }
-/* eslint-enable no-global-assign, no-native-reassign */