melonjs 9.1.0 → 10.0.1

package/src/system/pooling.js

@@ -21,28 +21,27 @@ var pool = {
     /**
      * register an object to the pool. <br>
      * Pooling must be set to true if more than one such objects will be created. <br>
-     * (note) If pooling is enabled, you shouldn't instantiate objects with `new`.
-     * See examples in {@link me.pool#pull}
-     * @name register
-     * @memberOf me.pool
-     * @public
-     * @function
+     * (Note: for an object to be poolable, it must implements a `onResetEvent` method)
+     * @function me.pool.register
      * @param {String} className as defined in the Name field of the Object Properties (in Tiled)
      * @param {Object} class corresponding Class to be instantiated
-     * @param {Boolean} [objectPooling=false] enables object pooling for the specified class
-     * - speeds up the game by reusing existing objects
+     * @param {Boolean} [recycling=false] enables object recycling for the specified class
      * @example
-     * // add our users defined entities in the object pool
-     * me.pool.register("playerspawnpoint", PlayerEntity);
+     * // implement CherryEntity
+     * class CherryEntity extends Spritesheet {
+     *    onResetEvent() {
+     *        // reset object mutable properties
+     *        this.lifeBar = 100;
+     *    }
+     * };
+     * // add our users defined entities in the object pool and enable object recycling
      * me.pool.register("cherryentity", CherryEntity, true);
-     * me.pool.register("heartentity", HeartEntity, true);
-     * me.pool.register("starentity", StarEntity, true);
      */
-     register(className, classObj, pooling) {
+     register(className, classObj, recycling = false) {
          if (typeof (classObj) !== "undefined") {
              objectClass[className] = {
                  "class" : classObj,
-                 "pool" : (pooling ? [] : undefined)
+                 "pool" : (recycling ? [] : undefined)
              };
          } else {
              throw new Error("Cannot register object '" + className + "', invalid class");
@@ -51,17 +50,11 @@ var pool = {
 
     /**
      * Pull a new instance of the requested object (if added into the object pool)
-     * @name pull
-     * @memberOf me.pool
-     * @public
-     * @function
+     * @function me.pool.pull
      * @param {String} className as used in {@link me.pool.register}
      * @param {} [arguments...] arguments to be passed when instantiating/reinitializing the object
      * @return {Object} the instance of the requested object
      * @example
-     * me.pool.register("player", PlayerEntity);
-     * var player = me.pool.pull("player");
-     * @example
      * me.pool.register("bullet", BulletEntity, true);
      * me.pool.register("enemy", EnemyEntity, true);
      * // ...
@@ -82,25 +75,23 @@ var pool = {
         for (var i = 0; i < arguments.length; i++) {
             args[i] = arguments[i];
         }
-        var entity = objectClass[name];
-        if (entity) {
-            var proto = entity["class"],
-                poolArray = entity.pool,
+        var className = objectClass[name];
+        if (className) {
+            var proto = className["class"],
+                poolArray = className.pool,
                 obj;
 
             if (poolArray && ((obj = poolArray.pop()))) {
+                // pull an existing instance from the pool
                 args.shift();
                 // call the object onResetEvent function if defined
                 if (typeof(obj.onResetEvent) === "function") {
                     obj.onResetEvent.apply(obj, args);
                 }
-                else if (typeof(obj.init) === "function") {
-                    // backward compatibility with Jay Inheritance
-                    obj.init.apply(obj, args);
-                }
                 instance_counter--;
             }
             else {
+                // create a new instance
                 args[0] = proto;
                 obj = new (proto.bind.apply(proto, args))();
                 if (poolArray) {
@@ -109,7 +100,6 @@ var pool = {
             }
             return obj;
         }
-
         throw new Error("Cannot instantiate object of type '" + name + "'");
     },
 
@@ -117,10 +107,7 @@ var pool = {
      * purge the object pool from any inactive object <br>
      * Object pooling must be enabled for this function to work<br>
      * note: this will trigger the garbage collector
-     * @name purge
-     * @memberOf me.pool
-     * @public
-     * @function
+     * @function me.pool.purge
      */
     purge() {
         for (var className in objectClass) {
@@ -136,45 +123,65 @@ var pool = {
      * Object pooling for the object class must be enabled,
      * and object must have been instantiated using {@link me.pool#pull},
      * otherwise this function won't work
-     * @name push
-     * @memberOf me.pool
-     * @public
-     * @function
+     * @function me.pool.push
+     * @throws will throw an error if the object cannot be recycled
      * @param {Object} instance to be recycled
+     * @param {Boolean} [throwOnError=true] throw an exception if the object cannot be recycled
+     * @return {Boolean} true if the object was successfully recycled in the object pool
      */
-    push(obj) {
-        var name = obj.className;
-        if (typeof(name) === "undefined" || !objectClass[name]) {
-            // object is not registered, don't do anything
-            return;
+    push(obj, throwOnError = true) {
+        if (!this.poolable(obj)) {
+            if (throwOnError === true ) {
+                throw new Error("me.pool: object " + obj + " cannot be recycled");
+            } else {
+                return false;
+            }
         }
+
         // store back the object instance for later recycling
-        objectClass[name].pool.push(obj);
+        objectClass[obj.className].pool.push(obj);
         instance_counter++;
+
+        return true;
     },
 
     /**
      * Check if an object with the provided name is registered
-     * @name exists
-     * @memberOf me.pool
-     * @public
-     * @function
-     * @param {String} name of the registered object
+     * @function me.pool.exists
+     * @param {String} name of the registered object class
      * @return {Boolean} true if the classname is registered
      */
     exists(name) {
         return name in objectClass;
     },
 
+    /**
+     * Check if an object is poolable
+     * (was properly registered with the recycling feature enable)
+     * @function me.pool.poolable
+     * @see me.pool.register
+     * @param {Object} object
+     * @return {Boolean} true if the object is poolable
+     * @example
+     * if (!me.pool.poolable(myCherryEntity)) {
+     *     // object was not properly registered
+     * }
+     */
+    poolable(obj) {
+        var className = obj.className;
+        return (typeof className !== "undefined") &&
+                (typeof obj.onResetEvent === "function") &&
+                (className in objectClass) &&
+                (objectClass[className].pool !== "undefined");
+
+    },
+
     /**
      * returns the amount of object instance currently in the pool
-     * @name getInstanceCount
-     * @memberOf me.pool
-     * @public
-     * @function
+     * @function me.pool.getInstanceCount
      * @return {Number} amount of object instance
      */
-    getInstanceCount(name) {
+    getInstanceCount() {
         return instance_counter;
     }
 };

package/src/system/save.js

@@ -1,4 +1,6 @@
 import device from "./../system/device.js";
+import * as event from "./../system/event.js";
+
 /**
  * allow to access and manage the device localStorage
  * @example
@@ -37,26 +39,25 @@ import device from "./../system/device.js";
  // a function to check if the given key is a reserved word
  function isReserved(key) {
      return (key === "add" || key === "remove");
- };
+ }
 
-var save = {
 
-    /**
-     * @ignore
-     */
-    init() {
-        // Load previous data if local Storage is supported
-        if (device.localStorage === true) {
-            var me_save_content = localStorage.getItem("me.save");
+// Initialize me.save on Boot event
+event.on(event.BOOT, () => {
+    // Load previous data if local Storage is supported
+    if (device.localStorage === true) {
+        var me_save_content = localStorage.getItem("me.save");
 
-            if (typeof me_save_content === "string" && me_save_content.length > 0) {
-                var keys = JSON.parse(me_save_content) || [];
-                keys.forEach(function (key) {
-                    data[key] = JSON.parse(localStorage.getItem("me.save." + key));
-                });
-            }
+        if (typeof me_save_content === "string" && me_save_content.length > 0) {
+            var keys = JSON.parse(me_save_content) || [];
+            keys.forEach(function (key) {
+                data[key] = JSON.parse(localStorage.getItem("me.save." + key));
+            });
         }
-    },
+    }
+});
+
+var save = {
 
     /**
      * Add new keys to localStorage and set them to the given default values if they do not exist

package/src/system/timer.js

@@ -1,5 +1,5 @@
 import utils from "./../utils/utils.js";
-import event from "./../system/event.js";
+import * as event from "./../system/event.js";
 import state from "./../state/state.js";
 import { clamp } from "./../math/math.js";
 
@@ -20,6 +20,28 @@ var timers = [];
 var timerId = 0;
 
 /**
+ * update
+ * @ignore
+ */
+function update(time) {
+    last = now;
+    now = time;
+    delta = (now - last);
+
+    // fix for negative timestamp returned by wechat or chrome on startup
+    if (delta < 0) {
+        delta = 0;
+    }
+
+    // get the game tick
+    timer.tick = (delta > minstep && timer.interpolation) ? delta / step : 1;
+
+
+    updateTimers();
+};
+
+/**
+ * clear Timers
  * @ignore
  */
 function clearTimer(timerId) {
@@ -31,23 +53,12 @@ function clearTimer(timerId) {
     }
 };
 
+
 /**
  * update timers
  * @ignore
  */
-function updateTimers(time) {
-    last = now;
-    now = time;
-    delta = (now - last);
-
-    // fix for negative timestamp returned by wechat or chrome on startup
-    if (delta < 0) {
-        delta = 0;
-    }
-
-    // get the game tick
-    timer.tick = (delta > minstep && timer.interpolation) ? delta / step : 1;
-
+function updateTimers() {
     for (var i = 0, len = timers.length; i < len; i++) {
         var _timer = timers[i];
         if (!(_timer.pauseable && state.isPaused())) {
@@ -64,6 +75,15 @@ function updateTimers(time) {
     }
 };
 
+// Initialize me.timer on Boot event
+event.on(event.BOOT, () => {
+    // reset variables to initial state
+    timer.reset();
+    now = last = 0;
+    // register to the game before update event
+    event.on(event.GAME_BEFORE_UPDATE, update);
+});
+
 
 /**
  * a Timer class to manage timing related function (FPS, Game Tick, Time...)
@@ -117,30 +137,6 @@ var timer = {
          */
         interpolation : false,
 
-        /**
-         * Last update time.<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 Date
-         * @name lastUpdate
-         * @memberOf me.timer
-         */
-        lastUpdate : window.performance.now(),
-
-        /**
-         * init the timer
-         * @ignore
-         */
-        init() {
-            // reset variables to initial state
-            this.reset();
-            now = last = 0;
-            // register to the game update event
-            event.subscribe(event.GAME_UPDATE, updateTimers);
-        },
-
         /**
          * reset time (e.g. usefull in case of pause)
          * @name reset

package/src/text/bitmaptext.js

@@ -1,5 +1,5 @@
 import Color from "./../math/color.js";
-import utils from "./../utils/utils.js";
+import * as stringUtil from "./../utils/string.js";
 import pool from "./../system/pooling.js";
 import loader from "./../loader/loader.js";
 import Renderable from "./../renderable/renderable.js";
@@ -63,12 +63,13 @@ var measureTextHeight = function(font) {
  * // or just add it to the word container
  * me.game.world.addChild(myFont);
  */
-var BitmapText = Renderable.extend({
+
+class BitmapText extends Renderable {
 
     /** @ignore */
-    init : function (x, y, settings) {
+    constructor(x, y, settings) {
         // call the parent constructor
-        this._super(Renderable, "init", [x, y, settings.width || 0, settings.height || 0]);
+        super(x, y, settings.width || 0, settings.height || 0);
 
         /**
          * Set the default text alignment (or justification),<br>
@@ -158,7 +159,7 @@ var BitmapText = Renderable.extend({
 
         // set the text
         this.setText(settings.text);
-    },
+    }
 
     /**
      * change the font settings
@@ -169,7 +170,7 @@ var BitmapText = Renderable.extend({
      * @param {Number} [scale]
      * @return this object for chaining
      */
-    set : function (textAlign, scale) {
+    set(textAlign, scale) {
         this.textAlign = textAlign;
         // updated scaled Size
         if (scale) {
@@ -178,7 +179,7 @@ var BitmapText = Renderable.extend({
         this.isDirty = true;
 
         return this;
-    },
+    }
 
     /**
      * change the text to be displayed
@@ -188,7 +189,7 @@ var BitmapText = Renderable.extend({
      * @param {Number|String|String[]} value a string, or an array of strings
      * @return this object for chaining
      */
-    setText : function (value) {
+    setText(value) {
         if (typeof value === "undefined") {
             value = "";
         }
@@ -203,8 +204,29 @@ var BitmapText = Renderable.extend({
         }
 
         return this;
-    },
+    }
 
+    /**
+     * defines the color used to tint the bitmap text
+     * @public
+     * @type {me.Color}
+     * @name fillStyle
+     * @see me.Renderable#tint
+     * @memberOf me.BitmapText
+     */
+
+    /**
+     * @ignore
+     */
+    get fillStyle() {
+        return this.tint;
+    }
+    /**
+     * @ignore
+     */
+    set fillStyle(value) {
+        this.tint = value;
+    }
 
     /**
      * change the font display size
@@ -214,14 +236,13 @@ var BitmapText = Renderable.extend({
      * @param {Number} scale ratio
      * @return this object for chaining
      */
-    resize : function (scale) {
+    resize(scale) {
         this.fontScale.set(scale, scale);
         // clear the cache text to recalculate bounds
         this.isDirty = true;
 
         return this;
-    },
-
+    }
 
     /**
      * measure the given text size in pixels
@@ -232,7 +253,7 @@ var BitmapText = Renderable.extend({
      * @param {me.Rect} [ret] a object in which to store the text metrics
      * @returns {TextMetrics} a TextMetrics object with two properties: `width` and `height`, defining the output dimensions
      */
-    measureText : function (text, ret) {
+    measureText(text, ret) {
         text = text || this._text;
 
         var stringHeight = measureTextHeight(this);
@@ -246,17 +267,17 @@ var BitmapText = Renderable.extend({
             textMetrics.height += stringHeight;
         }
         return textMetrics;
-    },
+    }
 
     /**
      * @ignore
      */
-    update : function (/* dt */) {
+    update(/* dt */) {
         if (this.isDirty === true) {
             this.measureText();
         }
         return this.isDirty;
-    },
+    }
 
     /**
      * draw the bitmap font
@@ -268,7 +289,7 @@ var BitmapText = Renderable.extend({
      * @param {Number} [x]
      * @param {Number} [y]
      */
-    draw : function (renderer, text, x, y) {
+    draw(renderer, text, x, y) {
         // save the previous global alpha value
         var _alpha = renderer.globalAlpha();
 
@@ -292,7 +313,7 @@ var BitmapText = Renderable.extend({
 
         for (var i = 0; i < this._text.length; i++) {
             x = lX;
-            var string = utils.string.trimRight(this._text[i]);
+            var string = stringUtil.trimRight(this._text[i]);
             // adjust x pos based on alignment value
             var stringWidth = measureTextWidth(this, string);
             switch (this.textAlign) {
@@ -373,45 +394,22 @@ var BitmapText = Renderable.extend({
         // clear the dirty flag here for
         // backward compatibility
         this.isDirty = false;
-    },
-
+    }
 
     /**
      * Destroy function
      * @ignore
      */
-    destroy : function () {
+    destroy() {
         pool.push(this.fontScale);
         this.fontScale = undefined;
         pool.push(this.fontData);
         this.fontData = undefined;
         this._text.length = 0;
-        this._super(Renderable, "destroy");
+        super.destroy();
     }
-});
 
-/**
- * defines the color used to tint the bitmap text
- * @public
- * @type {me.Color}
- * @name fillStyle
- * @see me.Renderable#tint
- * @memberOf me.BitmapText
- */
-Object.defineProperty(BitmapText.prototype, "fillStyle", {
-    /**
-     * @ignore
-     */
-    get : function () {
-        return this.tint;
-    },
-    /**
-     * @ignore
-     */
-    set : function (value) {
-        this.tint = value;
-    },
-    configurable : true
-});
+};
+
 
 export default BitmapText;