melonjs 9.1.0 → 10.0.1

package/src/camera/camera2d.js

@@ -5,12 +5,12 @@ import ObservableVector3d from "./../math/observable_vector3.js";
 import Matrix2d from "./../math/matrix2.js";
 import Matrix3d from "./../math/matrix3.js";
 import Rect from "./../shapes/rectangle.js";
-import video from "./../video/video.js";
-import event from "./../system/event.js";
+import { renderer } from "./../video/video.js";
+import * as event from "./../system/event.js";
 import pool from "./../system/pooling.js";
 import Renderable from "./../renderable/renderable.js";
 import {clamp, toBeCloseTo} from "./../math/math.js";
-import game from "./../game.js";
+import { world } from "./../game.js";
 
 
 // some ref shortcut
@@ -30,12 +30,13 @@ var targetV = new Vector2d();
  * @param {Number} maxX end x offset
  * @param {Number} maxY end y offset
  */
-var Camera2d = Renderable.extend({
+class Camera2d extends Renderable {
+
     /**
      * @ignore
      */
-    init : function (minX, minY, maxX, maxY) {
-        this._super(Renderable, "init", [minX, minY, maxX - minX, maxY - minY]);
+    constructor(minX, minY, maxX, maxY) {
+        super(minX, minY, maxX - minX, maxY - minY);
 
         /**
          * Axis definition
@@ -172,21 +173,21 @@ var Camera2d = Renderable.extend({
         this._updateProjectionMatrix();
 
         // subscribe to the game reset event
-        event.subscribe(event.GAME_RESET, this.reset.bind(this));
+        event.on(event.GAME_RESET, this.reset, this);
         // subscribe to the canvas resize event
-        event.subscribe(event.CANVAS_ONRESIZE, this.resize.bind(this));
-    },
+        event.on(event.CANVAS_ONRESIZE, this.resize, this);
+    }
 
     // -- some private function ---
 
     /** @ignore */
     // update the projection matrix based on the projection frame (a rectangle)
-    _updateProjectionMatrix : function () {
+    _updateProjectionMatrix() {
         this.projectionMatrix.ortho(0, this.width, this.height, 0, this.near, this.far);
-    },
+    }
 
     /** @ignore */
-    _followH : function (target) {
+    _followH(target) {
         var targetX = this.pos.x;
         if ((target.x - this.pos.x) > (this.deadzone.right)) {
             targetX = MIN((target.x) - (this.deadzone.right), this.bounds.width - this.width);
@@ -196,10 +197,10 @@ var Camera2d = Renderable.extend({
         }
         return targetX;
 
-    },
+    }
 
     /** @ignore */
-    _followV : function (target) {
+    _followV(target) {
         var targetY = this.pos.y;
         if ((target.y - this.pos.y) > (this.deadzone.bottom)) {
             targetY = MIN((target.y) - (this.deadzone.bottom), this.bounds.height - this.height);
@@ -208,7 +209,7 @@ var Camera2d = Renderable.extend({
             targetY = MAX((target.y) - this.deadzone.pos.y, this.bounds.top);
         }
         return targetY;
-    },
+    }
 
     // -- public function ---
 
@@ -220,7 +221,7 @@ var Camera2d = Renderable.extend({
      * @param {Number} [x=0]
      * @param {Number} [y=0]
      */
-    reset : function (x, y) {
+    reset(x, y) {
         // reset the initial camera position to 0,0
         this.pos.x = x || 0;
         this.pos.y = y || 0;
@@ -238,7 +239,7 @@ var Camera2d = Renderable.extend({
 
         // update the projection matrix
         this._updateProjectionMatrix();
-    },
+    }
 
     /**
      * change the deadzone settings.
@@ -251,7 +252,7 @@ var Camera2d = Renderable.extend({
      * @param {Number} w deadzone width
      * @param {Number} h deadzone height
      */
-    setDeadzone : function (w, h) {
+    setDeadzone(w, h) {
         if (typeof(this.deadzone) === "undefined") {
             this.deadzone = new Rect(0, 0, 0, 0);
         }
@@ -269,8 +270,7 @@ var Camera2d = Renderable.extend({
         this.updateTarget();
 
         this.smoothFollow = true;
-    },
-
+    }
 
     /**
      * resize the camera
@@ -281,9 +281,9 @@ var Camera2d = Renderable.extend({
      * @param {Number} h new height of the camera
      * @return {me.Camera2d} this camera
     */
-    resize : function (w, h) {
+    resize(w, h) {
         // parent consctructor, resize camera rect
-        this._super(Renderable, "resize", [w, h]);
+        super.resize(w, h);
 
         // disable damping while resizing
         this.smoothFollow = false;
@@ -298,10 +298,10 @@ var Camera2d = Renderable.extend({
         this._updateProjectionMatrix();
 
         // publish the viewport resize event
-        event.publish(event.VIEWPORT_ONRESIZE, [ this.width, this.height ]);
+        event.emit(event.VIEWPORT_ONRESIZE, this.width, this.height);
 
         return this;
-    },
+    }
 
     /**
      * set the camera boundaries (set to the world limit by default).
@@ -314,13 +314,13 @@ var Camera2d = Renderable.extend({
      * @param {Number} w world width limit
      * @param {Number} h world height limit
      */
-    setBounds : function (x, y, w, h) {
+    setBounds(x, y, w, h) {
         this.smoothFollow = false;
         this.bounds.setMinMax(x, y, w + x, h + y);
         this.moveTo(this.pos.x, this.pos.y);
         this.update();
         this.smoothFollow = true;
-    },
+    }
 
     /**
      * set the camera to follow the specified renderable. <br>
@@ -335,7 +335,7 @@ var Camera2d = Renderable.extend({
      * // set the camera to follow this renderable on both axis, and enable damping
      * me.game.viewport.follow(this, me.game.viewport.AXIS.BOTH, 0.1);
      */
-    follow : function (target, axis, damping) {
+    follow(target, axis, damping) {
         if (target instanceof Renderable) {
             this.target = target.pos;
         }
@@ -363,7 +363,7 @@ var Camera2d = Renderable.extend({
         this.updateTarget();
 
         this.smoothFollow = true;
-    },
+    }
 
     /**
      * unfollow the current target
@@ -371,10 +371,10 @@ var Camera2d = Renderable.extend({
      * @memberOf me.Camera2d
      * @function
      */
-    unfollow : function () {
+    unfollow() {
         this.target = null;
         this.follow_axis = this.AXIS.NONE;
-    },
+    }
 
     /**
      * move the camera upper-left position by the specified offset.
@@ -388,9 +388,9 @@ var Camera2d = Renderable.extend({
      * // Move the camera up by four pixels
      * me.game.viewport.move(0, -4);
      */
-    move : function (x, y) {
+    move(x, y) {
         this.moveTo(this.pos.x + x, this.pos.y + y);
-    },
+    }
 
     /**
      * move the camera upper-left position to the specified coordinates
@@ -401,7 +401,7 @@ var Camera2d = Renderable.extend({
      * @param {Number} x
      * @param {Number} y
      */
-    moveTo : function (x, y) {
+    moveTo(x, y) {
         var _x = this.pos.x;
         var _y = this.pos.y;
 
@@ -418,12 +418,12 @@ var Camera2d = Renderable.extend({
 
         //publish the VIEWPORT_ONCHANGE event if necessary
         if (_x !== this.pos.x || _y !== this.pos.y) {
-            event.publish(event.VIEWPORT_ONCHANGE, [this.pos]);
+            event.emit(event.VIEWPORT_ONCHANGE, this.pos);
         }
-    },
+    }
 
     /** @ignore */
-    updateTarget : function () {
+    updateTarget() {
         if (this.target) {
 
             targetV.setV(this.pos);
@@ -468,10 +468,10 @@ var Camera2d = Renderable.extend({
             }
         }
         return false;
-    },
+    }
 
     /** @ignore */
-    update : function (dt) {
+    update(dt) {
         var updated = this.updateTarget(dt);
 
         if (this._shake.duration > 0) {
@@ -499,7 +499,7 @@ var Camera2d = Renderable.extend({
 
         if (updated === true) {
             //publish the corresponding message
-            event.publish(event.VIEWPORT_ONCHANGE, [this.pos]);
+            event.emit(event.VIEWPORT_ONCHANGE, this.pos);
         }
 
         // check for fade/flash effect
@@ -514,7 +514,7 @@ var Camera2d = Renderable.extend({
             this.invCurrentTransform.identity();
         }
         return updated;
-    },
+    }
 
     /**
      * shake the camera
@@ -532,14 +532,14 @@ var Camera2d = Renderable.extend({
      * // shake it baby !
      * me.game.viewport.shake(10, 500, me.game.viewport.AXIS.BOTH);
      */
-    shake : function (intensity, duration, axis, onComplete, force) {
+    shake(intensity, duration, axis, onComplete, force) {
         if (this._shake.duration === 0 || force === true) {
             this._shake.intensity = intensity;
             this._shake.duration = duration;
             this._shake.axis = axis || this.AXIS.BOTH;
             this._shake.onComplete = typeof (onComplete) === "function" ? onComplete : undefined;
         }
-    },
+    }
 
     /**
      * fadeOut(flash) effect<p>
@@ -558,14 +558,14 @@ var Camera2d = Renderable.extend({
      *     me.game.viewport.fadeOut("#fff", 150);
      * });
      */
-    fadeOut : function (color, duration = 1000, onComplete) {
+    fadeOut(color, duration = 1000, onComplete) {
         this._fadeOut.color = pool.pull("Color").copy(color);
         this._fadeOut.tween = pool.pull("Tween", this._fadeOut.color)
             .to({ alpha: 0.0 }, duration)
             .onComplete(onComplete || null);
         this._fadeOut.tween.isPersistent = true;
         this._fadeOut.tween.start();
-    },
+    }
 
     /**
      * fadeIn effect <p>
@@ -580,7 +580,7 @@ var Camera2d = Renderable.extend({
      * // flash the camera to white for 75ms
      * me.game.viewport.fadeIn("#FFFFFF", 75);
      */
-    fadeIn : function (color, duration = 1000, onComplete) {
+    fadeIn(color, duration = 1000, onComplete) {
         this._fadeIn.color = pool.pull("Color").copy(color);
         var _alpha = this._fadeIn.color.alpha;
         this._fadeIn.color.alpha = 0.0;
@@ -589,7 +589,7 @@ var Camera2d = Renderable.extend({
             .onComplete(onComplete || null);
         this._fadeIn.tween.isPersistent = true;
         this._fadeIn.tween.start();
-    },
+    }
 
     /**
      * return the camera width
@@ -598,9 +598,9 @@ var Camera2d = Renderable.extend({
      * @function
      * @return {Number}
      */
-    getWidth : function () {
+    getWidth() {
         return this.width;
-    },
+    }
 
     /**
      * return the camera height
@@ -609,9 +609,9 @@ var Camera2d = Renderable.extend({
      * @function
      * @return {Number}
      */
-    getHeight : function () {
+    getHeight() {
         return this.height;
-    },
+    }
 
     /**
      * set the camera position around the specified object
@@ -620,13 +620,13 @@ var Camera2d = Renderable.extend({
      * @function
      * @param {me.Renderable}
      */
-    focusOn : function (target) {
+    focusOn(target) {
         var bounds = target.getBounds();
         this.moveTo(
             target.pos.x + bounds.left + (bounds.width / 2),
             target.pos.y + bounds.top + (bounds.height / 2)
         );
-    },
+    }
 
     /**
      * check if the specified renderable is in the camera
@@ -637,15 +637,15 @@ var Camera2d = Renderable.extend({
      * @param {Boolean} [floating===object.floating] if visibility check should be done against screen coordinates
      * @return {Boolean}
      */
-    isVisible : function (obj, floating = obj.floating) {
+    isVisible(obj, floating = obj.floating) {
         if (floating === true || obj.floating === true) {
             // check against screen coordinates
-            return video.renderer.overlaps(obj.getBounds());
+            return renderer.overlaps(obj.getBounds());
         } else {
             // check if within the current camera
             return obj.getBounds().overlaps(this);
         }
-    },
+    }
 
     /**
      * convert the given "local" (screen) coordinates into world coordinates
@@ -658,15 +658,15 @@ var Camera2d = Renderable.extend({
      * converted value
      * @return {me.Vector2d}
      */
-    localToWorld : function (x, y, v) {
+    localToWorld(x, y, v) {
         // TODO memoization for one set of coords (multitouch)
         v = v || new Vector2d();
-        v.set(x, y).add(this.pos).sub(game.world.pos);
+        v.set(x, y).add(this.pos).sub(world.pos);
         if (!this.currentTransform.isIdentity()) {
             this.invCurrentTransform.apply(v);
         }
         return v;
-    },
+    }
 
     /**
      * convert the given world coordinates into "local" (screen) coordinates
@@ -679,21 +679,21 @@ var Camera2d = Renderable.extend({
      * converted value
      * @return {me.Vector2d}
      */
-    worldToLocal : function (x, y, v) {
+    worldToLocal(x, y, v) {
         // TODO memoization for one set of coords (multitouch)
         v = v || new Vector2d();
         v.set(x, y);
         if (!this.currentTransform.isIdentity()) {
             this.currentTransform.apply(v);
         }
-        return v.sub(this.pos).add(game.world.pos);
-    },
+        return v.sub(this.pos).add(world.pos);
+    }
 
     /**
      * render the camera effects
      * @ignore
      */
-    drawFX : function (renderer) {
+    drawFX(renderer) {
         // fading effect
         if (this._fadeIn.tween) {
             // add an overlay
@@ -727,13 +727,13 @@ var Camera2d = Renderable.extend({
                 this._fadeOut.color = null;
             }
         }
-    },
+    }
 
     /**
      * draw all object visibile in this viewport
      * @ignore
      */
-    draw : function (renderer, container) {
+    draw(renderer, container) {
         var translateX = this.pos.x + this.offset.x;
         var translateY = this.pos.y + this.offset.y;
 
@@ -769,5 +769,7 @@ var Camera2d = Renderable.extend({
         // translate the world coordinates by default to screen coordinates
         container.currentTransform.translate(translateX, translateY);
     }
-});
+
+};
+
 export default Camera2d;

package/src/entity/draggable.js

@@ -1,6 +1,6 @@
 import Vector2d from "./../math/vector2.js";
 import * as input from "./../input/input.js";
-import event from "./../system/event.js";
+import * as event from "./../system/event.js";
 import Entity from "./entity.js";
 
 /**
@@ -13,7 +13,8 @@ import Entity from "./entity.js";
 * @param {Number} y the y coordinates of the entity object
 * @param {Object} settings Entity properties (see {@link me.Entity})
 */
-var DraggableEntity = Entity.extend({
+class DraggableEntity extends Entity {
+
     /**
      * Constructor
      * @name init
@@ -23,15 +24,15 @@ var DraggableEntity = Entity.extend({
      * @param {Number} y the y postion of the entity
      * @param {Object} settings the additional entity settings
      */
-    init: function (x, y, settings) {
-        this._super(Entity, "init", [x, y, settings]);
+    constructor(x, y, settings) {
+        super(x, y, settings);
         this.dragging = false;
         this.dragId = null;
         this.grabOffset = new Vector2d(0, 0);
         this.onPointerEvent = input.registerPointerEvent;
         this.removePointerEvent = input.releasePointerEvent;
         this.initEvents();
-    },
+    }
 
     /**
      * Initializes the events the modules needs to listen to
@@ -43,8 +44,7 @@ var DraggableEntity = Entity.extend({
      * @memberOf me.DraggableEntity
      * @function
      */
-    initEvents: function () {
-        var self = this;
+    initEvents() {
         /**
          * @ignore
          */
@@ -60,18 +60,10 @@ var DraggableEntity = Entity.extend({
         this.onPointerEvent("pointerdown", this, this.mouseDown.bind(this));
         this.onPointerEvent("pointerup", this, this.mouseUp.bind(this));
         this.onPointerEvent("pointercancel", this, this.mouseUp.bind(this));
-        event.subscribe(event.POINTERMOVE, this.dragMove.bind(this));
-        event.subscribe(event.DRAGSTART, function (e, draggable) {
-            if (draggable === self) {
-                self.dragStart(e);
-            }
-        });
-        event.subscribe(event.DRAGEND, function (e, draggable) {
-            if (draggable === self) {
-                self.dragEnd(e);
-            }
-        });
-    },
+        event.on(event.POINTERMOVE, this.dragMove, this);
+        event.on(event.DRAGSTART, this.dragStart, this);
+        event.on(event.DRAGEND, this.dragEnd, this);
+    }
 
     /**
      * Translates a pointer event to a me.event
@@ -79,12 +71,11 @@ var DraggableEntity = Entity.extend({
      * @memberOf me.DraggableEntity
      * @function
      * @param {Object} e the pointer event you want to translate
-     * @param {String} translation the me.event you want to translate
-     * the event to
+     * @param {String} translation the me.event you want to translate the event to
      */
-    translatePointerEvent: function (e, translation) {
-        event.publish(translation, [e, this]);
-    },
+    translatePointerEvent(e, translation) {
+        event.emit(translation, e);
+    }
 
     /**
      * Gets called when the user starts dragging the entity
@@ -93,14 +84,14 @@ var DraggableEntity = Entity.extend({
      * @function
      * @param {Object} x the pointer event
      */
-    dragStart: function (e) {
+    dragStart(e) {
         if (this.dragging === false) {
             this.dragging = true;
             this.grabOffset.set(e.gameX, e.gameY);
             this.grabOffset.sub(this.pos);
             return false;
         }
-    },
+    }
 
     /**
      * Gets called when the user drags this entity around
@@ -109,12 +100,12 @@ var DraggableEntity = Entity.extend({
      * @function
      * @param {Object} x the pointer event
      */
-    dragMove: function (e) {
+    dragMove(e) {
         if (this.dragging === true) {
             this.pos.set(e.gameX, e.gameY, this.pos.z); //TODO : z ?
             this.pos.sub(this.grabOffset);
         }
-    },
+    }
 
     /**
      * Gets called when the user stops dragging the entity
@@ -123,12 +114,12 @@ var DraggableEntity = Entity.extend({
      * @function
      * @param {Object} x the pointer event
      */
-    dragEnd: function () {
+    dragEnd() {
         if (this.dragging === true) {
             this.dragging = false;
             return false;
         }
-    },
+    }
 
     /**
      * Destructor
@@ -136,12 +127,12 @@ var DraggableEntity = Entity.extend({
      * @memberOf me.DraggableEntity
      * @function
      */
-    destroy: function () {
-        event.unsubscribe(event.POINTERMOVE, this.dragMove);
-        event.unsubscribe(event.DRAGSTART, this.dragStart);
-        event.unsubscribe(event.DRAGEND, this.dragEnd);
+    destroy() {
+        event.off(event.POINTERMOVE, this.dragMove);
+        event.off(event.DRAGSTART, this.dragStart);
+        event.off(event.DRAGEND, this.dragEnd);
         this.removePointerEvent("pointerdown", this);
         this.removePointerEvent("pointerup", this);
     }
-});
+};
 export default DraggableEntity;

package/src/entity/droptarget.js

@@ -1,4 +1,4 @@
-import event from "./../system/event.js";
+import * as event from "./../system/event.js";
 import Entity from "./entity.js";
 
 /**
@@ -11,7 +11,8 @@ import Entity from "./entity.js";
 * @param {Number} y the y coordinates of the entity object
 * @param {Object} settings Entity properties (see {@link me.Entity})
 */
-var DroptargetEntity = Entity.extend({
+
+class DroptargetEntity extends Entity {
     /**
      * Constructor
      * @name init
@@ -21,7 +22,8 @@ var DroptargetEntity = Entity.extend({
      * @param {Number} y the y postion of the entity
      * @param {Object} settings the additional entity settings
      */
-    init: function (x, y, settings) {
+    constructor(x, y, settings) {
+        super(x, y, settings);
         /**
          * constant for the overlaps method
          * @public
@@ -49,10 +51,9 @@ var DroptargetEntity = Entity.extend({
          * @memberOf me.DroptargetEntity
          */
         this.checkMethod = null;
-        this._super(Entity, "init", [x, y, settings]);
-        event.subscribe(event.DRAGEND, this.checkOnMe.bind(this));
+        event.on(event.DRAGEND, this.checkOnMe, this);
         this.checkMethod = this[this.CHECKMETHOD_OVERLAP];
-    },
+    }
 
     /**
      * Sets the collision method which is going to be used to check a valid drop
@@ -61,13 +62,13 @@ var DroptargetEntity = Entity.extend({
      * @function
      * @param {Constant} checkMethod the checkmethod (defaults to CHECKMETHOD_OVERLAP)
      */
-    setCheckMethod: function (checkMethod) {
+    setCheckMethod(checkMethod) {
         //  We can improve this check,
         //  because now you can use every method in theory
         if (typeof(this[checkMethod]) !== "undefined") {
             this.checkMethod = this[checkMethod];
         }
-    },
+    }
 
     /**
      * Checks if a dropped entity is dropped on the current entity
@@ -76,12 +77,12 @@ var DroptargetEntity = Entity.extend({
      * @function
      * @param {Object} draggableEntity the draggable entity that is dropped
      */
-    checkOnMe: function (e, draggableEntity) {
+    checkOnMe(e, draggableEntity) {
         if (draggableEntity && this.checkMethod(draggableEntity.getBounds())) {
             // call the drop method on the current entity
             this.drop(draggableEntity);
         }
-    },
+    }
 
     /**
      * Gets called when a draggable entity is dropped on the current entity
@@ -90,7 +91,9 @@ var DroptargetEntity = Entity.extend({
      * @function
      * @param {Object} draggableEntity the draggable entity that is dropped
      */
-    drop: function () {},
+    drop() {
+
+    }
 
     /**
      * Destructor
@@ -98,8 +101,8 @@ var DroptargetEntity = Entity.extend({
      * @memberOf me.DroptargetEntity
      * @function
      */
-    destroy: function () {
-        event.unsubscribe(event.DRAGEND, this.checkOnMe);
+    destroy() {
+        event.off(event.DRAGEND, this.checkOnMe);
     }
-});
+};
 export default DroptargetEntity;