melonjs 9.1.0 → 10.0.1

package/src/entity/entity.js

@@ -28,17 +28,14 @@ import Polygon from "./../shapes/poly.js";
  * @param {Number} [settings.collisionMask] Mask collision detection for this object
  * @param {me.Rect[]|me.Polygon[]|me.Line[]|me.Ellipse[]} [settings.shapes] the initial list of collision shapes (usually populated through Tiled)
  */
-var Entity = Renderable.extend({
+
+class Entity extends Renderable {
+
+
     /**
      * @ignore
      */
-    init : function (x, y, settings) {
-
-        /**
-         * The array of renderable children of this entity.
-         * @ignore
-         */
-        this.children = [];
+    constructor(x, y, settings) {
 
         // ensure mandatory properties are defined
         if ((typeof settings.width !== "number") || (typeof settings.height !== "number")) {
@@ -46,7 +43,13 @@ var Entity = Renderable.extend({
         }
 
         // call the super constructor
-        this._super(Renderable, "init", [x, y, settings.width, settings.height]);
+        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
@@ -104,7 +107,6 @@ var Entity = Renderable.extend({
          * @memberOf me.Entity
          */
         // initialize the default body
-
         if (typeof settings.shapes === "undefined") {
             settings.shapes = new Polygon(0, 0, [
                 new Vector2d(0,          0),
@@ -113,13 +115,7 @@ var Entity = Renderable.extend({
                 new Vector2d(0,          this.height)
             ]);
         }
-
-        if (typeof this.body !== "undefined") {
-            this.body.init(this, settings.shapes, this.onBodyUpdate.bind(this));
-        }
-        else {
-            this.body = new Body(this, settings.shapes, this.onBodyUpdate.bind(this));
-        }
+        this.body = new Body(this, settings.shapes, this.onBodyUpdate.bind(this));
 
         // resize the entity if required
         if (this.width === 0 && this.height === 0) {
@@ -132,15 +128,42 @@ var Entity = Renderable.extend({
 
         // 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 me.Renderable
+     * @name renderable
+     * @memberOf me.Entity
+     */
+
+    /**
+     * @ignore
+     */
+    get renderable() {
+        return this.children[0];
+    }
+    /**
+     * @ignore
+     */
+    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 : function (dt) {
+    update(dt) {
         if (this.renderable) {
-            return this.renderable.update(dt);
+            this.isDirty |= this.renderable.update(dt);
         }
-        return this._super(Renderable, "update", [dt]);
-    },
+        return super.update(dt);
+    }
 
     /**
      * update the bounds position when the body is modified
@@ -149,14 +172,14 @@ var Entity = Renderable.extend({
      * @memberOf me.Entity
      * @function
      */
-    onBodyUpdate : function (body) {
+    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 : function (renderer) {
+    preDraw(renderer) {
         renderer.save();
 
         // translate to the entity position
@@ -174,7 +197,7 @@ var Entity = Renderable.extend({
                 this.anchorPoint.y * this.body.getBounds().height
             );
         }
-    },
+    }
 
     /**
      * object draw<br>
@@ -187,7 +210,7 @@ var Entity = Renderable.extend({
      * @param {me.CanvasRenderer|me.WebGLRenderer} renderer a renderer object
      * @param {me.Rect} region to draw
      **/
-    draw : function (renderer, rect) {
+    draw(renderer, rect) {
         var renderable = this.renderable;
         if (renderable instanceof Renderable) {
             // predraw (apply transforms)
@@ -199,13 +222,13 @@ var Entity = Renderable.extend({
             // postdraw (clean-up);
             renderable.postDraw(renderer);
         }
-    },
+    }
 
     /**
      * Destroy function<br>
      * @ignore
      */
-    destroy : function () {
+    destroy() {
         // free some property objects
         if (this.renderable) {
             this.renderable.destroy.apply(this.renderable, arguments);
@@ -213,8 +236,8 @@ var Entity = Renderable.extend({
         }
 
         // call the parent destroy method
-        this._super(Renderable, "destroy", arguments);
-    },
+        super.destroy(arguments);
+    }
 
     /**
      * onDeactivateEvent Notification function<br>
@@ -223,55 +246,12 @@ var Entity = Renderable.extend({
      * @memberOf me.Entity
      * @function
      */
-    onDeactivateEvent : function () {
-      if (this.renderable && this.renderable.onDeactivateEvent) {
-          this.renderable.onDeactivateEvent();
-      }
-    },
-
-    /**
-     * onCollision callback<br>
-     * triggered in case of collision, when this entity body is being "touched" by another one<br>
-     * @name onCollision
-     * @memberOf me.Entity
-     * @function
-     * @param {me.collision.ResponseObject} response the collision response object
-     * @param {me.Entity} other the other entity touching this one (a reference to response.a or response.b)
-     * @return {Boolean} true if the object should respond to the collision (its position and velocity will be corrected)
-     */
-    onCollision : function () {
-        return false;
+    onDeactivateEvent() {
+        if (this.renderable && this.renderable.onDeactivateEvent) {
+            this.renderable.onDeactivateEvent();
+        }
     }
-});
-
 
-/**
- * The entity renderable component (can be any objects deriving from me.Renderable, like me.Sprite for example)
- * @public
- * @type me.Renderable
- * @name renderable
- * @memberOf me.Entity
- */
-Object.defineProperty(Entity.prototype, "renderable", {
-    /* for backward compatiblity */
-    /**
-     * @ignore
-     */
-    get : function () {
-        return this.children[0];
-    },
-    /**
-     * @ignore
-     */
-    set : function (value) {
-        if (value instanceof Renderable) {
-            this.children[0] = value;
-            this.children[0].ancestor = this;
-        } else {
-            throw new Error(value + "should extend me.Renderable");
-        }
-    },
-    configurable : true
-});
+};
 
 export default Entity;

package/src/game.js

@@ -1,5 +1,5 @@
-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 timer from "./system/timer.js";
 import state from "./state/state.js";
 import World from "./physics/world.js";
@@ -35,220 +35,210 @@ var lastUpdateStart = null;
 var updateAverageDelta = 0;
 
 
-var game = {
-
-    /**
-     * a reference to the current active stage "default" camera
-     * @public
-     * @type {me.Camera2d}
-     * @name viewport
-     * @memberOf me.game
-     */
-    viewport : undefined,
-
-    /**
-     * a reference to the game world, <br>
-     * a world is a virtual environment containing all the game objects
-     * @public
-     * @type {me.World}
-     * @name world
-     * @memberOf me.game
-     */
-    world : null,
-
-    /**
-     * when true, all objects will be added under the root world container.<br>
-     * When false, a `me.Container` object will be created for each corresponding groups
-     * @public
-     * @type {boolean}
-     * @default true
-     * @name mergeGroup
-     * @memberOf me.game
-     */
-    mergeGroup : true,
-
-    /**
-     * Specify the property to be used when sorting entities.
-     * Accepted values : "x", "y", "z"
-     * @public
-     * @type {string}
-     * @default "z"
-     * @name sortOn
-     * @memberOf me.game
-     */
-    sortOn : "z",
-
-    /**
-     * Fired when a level is fully loaded and <br>
-     * and all entities instantiated. <br>
-     * Additionnaly the level id will also be passed
-     * to the called function.
-     * @public
-     * @function
-     * @name onLevelLoaded
-     * @memberOf me.game
-     * @example
-     * // call myFunction () everytime a level is loaded
-     * me.game.onLevelLoaded = this.myFunction.bind(this);
-     */
-    onLevelLoaded : function () {},
-
-    /**
-     * Initialize the game manager
-     * @name init
-     * @memberOf me.game
-     * @ignore
-     * @function
-     */
-    init : function () {
-        // the root object of our world is an entity container
-        this.world = new World();
-
-        // publish init notification
-        event.publish(event.GAME_INIT);
-
-        // make display dirty by default
-        isDirty = true;
-    },
-
-    /**
-     * reset the game Object manager<br>
-     * destroy all current objects
-     * @name reset
-     * @memberOf me.game
-     * @public
-     * @function
-     */
-    reset : function () {
-        // point to the current active stage "default" camera
-        var current = state.current();
-        if (typeof current !== "undefined") {
-            this.viewport = state.current().cameras.get("default");
-        }
+ // initialize the game manager on system boot
+event.on(event.BOOT, () => {
+    // the root object of our world is an entity container
+    world = new World();
+    // publish init notification
+    event.emit(event.GAME_INIT);
+});
+
+
+/**
+ * a reference to the current active stage "default" camera
+ * @public
+ * @type {me.Camera2d}
+ * @name viewport
+ * @memberOf me.game
+ */
+export let viewport;
+
+/**
+ * a reference to the game world, <br>
+ * a world is a virtual environment containing all the game objects
+ * @public
+ * @type {me.World}
+ * @name world
+ * @memberOf me.game
+ */
+export let world;
 
-        // publish reset notification
-        event.publish(event.GAME_RESET);
-
-        // Refresh internal variables for framerate  limiting
-        this.updateFrameRate();
-    },
-
-    /**
-     * Update the renderer framerate using the system config variables.
-     * @name updateFrameRate
-     * @memberOf me.game
-     * @public
-     * @function
-     * @see me.timer.maxfps
-     * @see me.game.world.fps
-     */
-    updateFrameRate : function () {
+/**
+ * when true, all objects will be added under the root world container.<br>
+ * When false, a `me.Container` object will be created for each corresponding groups
+ * @public
+ * @type {boolean}
+ * @default true
+ * @name mergeGroup
+ * @memberOf me.game
+ */
+export let mergeGroup = true;
+
+/**
+ * Specify the property to be used when sorting entities.
+ * Accepted values : "x", "y", "z"
+ * @public
+ * @type {string}
+ * @default "z"
+ * @name sortOn
+ * @memberOf me.game
+ */
+export let sortOn = "z";
+
+/**
+ * Last time the game update loop was executed. <br>
+ * Use this value to implement frame prediction in drawing events,
+ * for creating smooth motion while running game update logic at
+ * a lower fps.
+ * @public
+ * @type {DOMHighResTimeStamp}
+ * @name lastUpdate
+ * @memberOf me.game
+ */
+export let lastUpdate = window.performance.now();
+
+/**
+ * Fired when a level is fully loaded and all entities instantiated. <br>
+ * Additionnaly the level id will also be passed to the called function.
+ * @function me.game.onLevelLoaded
+ * @example
+ * // call myFunction () everytime a level is loaded
+ * me.game.onLevelLoaded = this.myFunction.bind(this);
+ */
+export function onLevelLoaded() {};
+
+/**
+ * reset the game Object manager<br>
+ * destroy all current objects
+ * @function me.game.reset
+ */
+export function reset () {
+    // point to the current active stage "default" camera
+    var current = state.current();
+    if (typeof current !== "undefined") {
+        viewport = current.cameras.get("default");
+    }
+
+    // publish reset notification
+    event.emit(event.GAME_RESET);
+
+    // Refresh internal variables for framerate  limiting
+    updateFrameRate();
+}
+
+/**
+ * Update the renderer framerate using the system config variables.
+ * @function me.game.updateFrameRate
+ * @see me.timer.maxfps
+ * @see me.game.world.fps
+ */
+export function updateFrameRate() {
+    // reset the frame counter
+    frameCounter = 0;
+    frameRate = ~~(0.5 + 60 / timer.maxfps);
+
+    // set step size based on the updatesPerSecond
+    stepSize = (1000 / world.fps);
+    accumulator = 0.0;
+    accumulatorMax = stepSize * 10;
+
+    // display should always re-draw when update speed doesn't match fps
+    // this means the user intends to write position prediction drawing logic
+    isAlwaysDirty = (timer.maxfps > world.fps);
+};
+
+/**
+ * Returns the parent container of the specified Child in the game world
+ * @function me.game.getParentContainer
+ * @param {me.Renderable} child
+ * @return {me.Container}
+ */
+export function getParentContainer(child) {
+    return child.ancestor;
+};
+
+/**
+ * force the redraw (not update) of all objects
+ * @function me.game.repaint
+ */
+export function repaint() {
+    isDirty = true;
+};
+
+
+/**
+ * update all objects of the game manager
+ * @ignore
+ * @function me.game.update
+ * @param {Number} time current timestamp as provided by the RAF callback
+ * @param {me.Stage} stage the current stage
+ */
+export function update(time, stage) {
+    // handle frame skipping if required
+    if ((++frameCounter % frameRate) === 0) {
         // reset the frame counter
         frameCounter = 0;
-        frameRate = ~~(0.5 + 60 / timer.maxfps);
-
-        // set step size based on the updatesPerSecond
-        stepSize = (1000 / this.world.fps);
-        accumulator = 0.0;
-        accumulatorMax = stepSize * 10;
-
-        // display should always re-draw when update speed doesn't match fps
-        // this means the user intends to write position prediction drawing logic
-        isAlwaysDirty = (timer.maxfps > this.world.fps);
-    },
-
-    /**
-     * Returns the parent container of the specified Child in the game world
-     * @name getParentContainer
-     * @memberOf me.game
-     * @function
-     * @param {me.Renderable} child
-     * @return {me.Container}
-     */
-    getParentContainer : function (child) {
-        return child.ancestor;
-    },
-
-    /**
-     * force the redraw (not update) of all objects
-     * @name repaint
-     * @memberOf me.game
-     * @public
-     * @function
-     */
-
-    repaint : function () {
-        isDirty = true;
-    },
-
-
-    /**
-     * update all objects of the game manager
-     * @name update
-     * @memberOf me.game
-     * @ignore
-     * @function
-     * @param {Number} time current timestamp as provided by the RAF callback
-     * @param {me.Stage} stage the current stage
-     */
-    update : function (time, stage) {
-        // handle frame skipping if required
-        if ((++frameCounter % frameRate) === 0) {
-            // reset the frame counter
-            frameCounter = 0;
 
-            // game update event
-            event.publish(event.GAME_UPDATE, [ time ]);
+        // publish notification
+        event.emit(event.GAME_BEFORE_UPDATE, time);
+
+        accumulator += timer.getDelta();
+        accumulator = Math.min(accumulator, accumulatorMax);
 
-            accumulator += timer.getDelta();
-            accumulator = Math.min(accumulator, accumulatorMax);
+        updateDelta = (timer.interpolation) ? timer.getDelta() : stepSize;
+        accumulatorUpdateDelta = (timer.interpolation) ? updateDelta : Math.max(updateDelta, updateAverageDelta);
 
-            updateDelta = (timer.interpolation) ? timer.getDelta() : stepSize;
-            accumulatorUpdateDelta = (timer.interpolation) ? updateDelta : Math.max(updateDelta, updateAverageDelta);
+        while (accumulator >= accumulatorUpdateDelta || timer.interpolation) {
+            lastUpdateStart = window.performance.now();
 
-            while (accumulator >= accumulatorUpdateDelta || timer.interpolation) {
-                lastUpdateStart = window.performance.now();
+            // game update event
+            if (state.isPaused() !== true) {
+                event.emit(event.GAME_UPDATE, time);
+            }
 
-                // update all objects (and pass the elapsed time since last frame)
-                isDirty = stage.update(updateDelta) || isDirty;
+            // update all objects (and pass the elapsed time since last frame)
+            isDirty = stage.update(updateDelta) || isDirty;
 
-                timer.lastUpdate = window.performance.now();
-                updateAverageDelta = timer.lastUpdate - lastUpdateStart;
+            lastUpdate = window.performance.now();
+            updateAverageDelta = lastUpdate - lastUpdateStart;
 
-                accumulator -= accumulatorUpdateDelta;
-                if (timer.interpolation) {
-                    accumulator = 0;
-                    break;
-                }
+            accumulator -= accumulatorUpdateDelta;
+            if (timer.interpolation) {
+                accumulator = 0;
+                break;
             }
         }
-    },
-
-    /**
-     * draw the current scene/stage
-     * @name draw
-     * @memberOf me.game
-     * @ignore
-     * @function
-     * @param {me.Stage} stage the current stage
-     */
-    draw : function (stage) {
-        var renderer = video.renderer;
-
-        if (renderer.isContextValid === true && (isDirty || isAlwaysDirty)) {
-            // prepare renderer to draw a new frame
-            renderer.clear();
-
-            // render the stage
-            stage.draw(renderer);
-
-            // set back to flag
-            isDirty = false;
-
-            // flush/render our frame
-            renderer.flush();
-        }
+
+        // publish notification
+        event.emit(event.GAME_AFTER_UPDATE, lastUpdate);
     }
 };
 
-export default game;
+/**
+ * draw the current scene/stage
+ * @function me.game.draw
+ * @ignore
+ * @param {me.Stage} stage the current stage
+ */
+export function draw(stage) {
+
+    if (renderer.isContextValid === true && (isDirty || isAlwaysDirty)) {
+        // publish notification
+        event.emit(event.GAME_BEFORE_DRAW, window.performance.now());
+
+        // prepare renderer to draw a new frame
+        renderer.clear();
+
+        // render the stage
+        stage.draw(renderer);
+
+        // set back to flag
+        isDirty = false;
+
+        // flush/render our frame
+        renderer.flush();
+
+        // publish notification
+        event.emit(event.GAME_AFTER_DRAW, window.performance.now());
+    }
+};