melonjs 10.6.1 → 10.8.0

package/src/system/pooling.js

@@ -1,7 +1,5 @@
-var objectClass = {};
-var instance_counter = 0;
-
 /**
+ * @classdesc
  * This object is used for object pooling - a technique that might speed up your game if used properly.<br>
  * If some of your classes will be instantiated and removed a lot at a time, it is a
  * good idea to add the class to this object pool. A separate pool for that class
@@ -12,172 +10,181 @@ var instance_counter = 0;
  * which means, that on level loading the engine will try to instantiate every object
  * found in the map, based on the user defined name in each Object Properties<br>
  * <img src="images/object_properties.png"/><br>
- * @namespace pool
+ * @see {@link pool} a default global instance of ObjectPool
  */
+class ObjectPool {
 
-/**
- * register an object to the pool. <br>
- * Pooling must be set to true if more than one such objects will be created. <br>
- * (Note: for an object to be poolable, it must implements a `onResetEvent` method)
- * @function pool.register
- * @param {string} className as defined in the Name field of the Object Properties (in Tiled)
- * @param {object} classObj corresponding Class to be instantiated
- * @param {boolean} [recycling=false] enables object recycling for the specified class
- * @example
- * // 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);
- */
-export function register(className, classObj, recycling = false) {
-     if (typeof (classObj) !== "undefined") {
-         objectClass[className] = {
-             "class" : classObj,
-             "pool" : (recycling ? [] : undefined)
-         };
-     } else {
-         throw new Error("Cannot register object '" + className + "', invalid class");
+    constructor() {
+        this.objectClass = {};
+        this.instance_counter = 0;
+    }
+
+    /**
+     * register an object to the pool. <br>
+     * Pooling must be set to true if more than one such objects will be created. <br>
+     * (Note: for an object to be poolable, it must implements a `onResetEvent` method)
+     * @param {string} className as defined in the Name field of the Object Properties (in Tiled)
+     * @param {object} classObj corresponding Class to be instantiated
+     * @param {boolean} [recycling=false] enables object recycling for the specified class
+     * @example
+     * // 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);
+     */
+    register(className, classObj, recycling = false) {
+         if (typeof (classObj) !== "undefined") {
+             this.objectClass[className] = {
+                 "class" : classObj,
+                 "pool" : (recycling ? [] : undefined)
+             };
+         } else {
+             throw new Error("Cannot register object '" + className + "', invalid class");
+         }
      }
- };
 
-/**
- * Pull a new instance of the requested object (if added into the object pool)
- * @function pool.pull
- * @param {string} name as used in {@link pool.register}
- * @param {object} [...arguments] arguments to be passed when instantiating/reinitializing the object
- * @returns {object} the instance of the requested object
- * @example
- * me.pool.register("bullet", BulletEntity, true);
- * me.pool.register("enemy", EnemyEntity, true);
- * // ...
- * // when we need to manually create a new bullet:
- * var bullet = me.pool.pull("bullet", x, y, direction);
- * // ...
- * // params aren't a fixed number
- * // when we need new enemy we can add more params, that the object construct requires:
- * var enemy = me.pool.pull("enemy", x, y, direction, speed, power, life);
- * // ...
- * // when we want to destroy existing object, the remove
- * // function will ensure the object can then be reallocated later
- * me.game.world.removeChild(enemy);
- * me.game.world.removeChild(bullet);
- */
-export function pull(name) {
-    var args = new Array(arguments.length);
-    for (var i = 0; i < arguments.length; i++) {
-        args[i] = arguments[i];
-    }
-    var className = objectClass[name];
-    if (className) {
-        var proto = className["class"],
-            poolArray = className.pool,
-            obj;
+    /**
+     * Pull a new instance of the requested object (if added into the object pool)
+     * @param {string} name as used in {@link pool.register}
+     * @param {object} [...arguments] arguments to be passed when instantiating/reinitializing the object
+     * @returns {object} the instance of the requested object
+     * @example
+     * me.pool.register("bullet", BulletEntity, true);
+     * me.pool.register("enemy", EnemyEntity, true);
+     * // ...
+     * // when we need to manually create a new bullet:
+     * var bullet = me.pool.pull("bullet", x, y, direction);
+     * // ...
+     * // params aren't a fixed number
+     * // when we need new enemy we can add more params, that the object construct requires:
+     * var enemy = me.pool.pull("enemy", x, y, direction, speed, power, life);
+     * // ...
+     * // when we want to destroy existing object, the remove
+     * // function will ensure the object can then be reallocated later
+     * me.game.world.removeChild(enemy);
+     * me.game.world.removeChild(bullet);
+     */
+    pull(name) {
+        var args = new Array(arguments.length);
+        for (var i = 0; i < arguments.length; i++) {
+            args[i] = arguments[i];
+        }
+        var className = this.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);
+            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);
+                }
+                this.instance_counter--;
             }
-            instance_counter--;
-        }
-        else {
-            // create a new instance
-            args[0] = proto;
-            obj = new (proto.bind.apply(proto, args))();
-            if (poolArray) {
-                obj.className = name;
+            else {
+                // create a new instance
+                args[0] = proto;
+                obj = new (proto.bind.apply(proto, args))();
+                if (poolArray) {
+                    obj.className = name;
+                }
             }
+            return obj;
         }
-        return obj;
+        throw new Error("Cannot instantiate object of type '" + name + "'");
     }
-    throw new Error("Cannot instantiate object of type '" + name + "'");
-};
 
-/**
- * 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
- * @function pool.purge
- */
-export function purge() {
-    for (var className in objectClass) {
-        if (objectClass[className]) {
-            objectClass[className].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
+     */
+    purge() {
+        for (var className in this.objectClass) {
+            if (this.objectClass[className]) {
+                this.objectClass[className].pool = [];
+            }
         }
+        this.instance_counter = 0;
     }
-    instance_counter = 0;
-};
 
-/**
- * Push back an object instance into the object pool <br>
- * Object pooling for the object class must be enabled,
- * and object must have been instantiated using {@link pool#pull},
- * otherwise this function won't work
- * @function pool.push
- * @throws will throw an error if the object cannot be recycled
- * @param {object} obj instance to be recycled
- * @param {boolean} [throwOnError=true] throw an exception if the object cannot be recycled
- * @returns {boolean} true if the object was successfully recycled in the object pool
- */
-export function push(obj, throwOnError = true) {
-    if (!poolable(obj)) {
-        if (throwOnError === true ) {
-            throw new Error("me.pool: object " + obj + " cannot be recycled");
-        } else {
-            return false;
+    /**
+     * Push back an object instance into the object pool <br>
+     * Object pooling for the object class must be enabled,
+     * and object must have been instantiated using {@link pool#pull},
+     * otherwise this function won't work
+     * @throws will throw an error if the object cannot be recycled
+     * @param {object} obj instance to be recycled
+     * @param {boolean} [throwOnError=true] throw an exception if the object cannot be recycled
+     * @returns {boolean} true if the object was successfully recycled in the object pool
+     */
+    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[obj.className].pool.push(obj);
-    instance_counter++;
+        // store back the object instance for later recycling
+        this.objectClass[obj.className].pool.push(obj);
+        this.instance_counter++;
 
-    return true;
-};
+        return true;
+    }
 
-/**
- * Check if an object with the provided name is registered
- * @function pool.exists
- * @param {string} name of the registered object class
- * @returns {boolean} true if the classname is registered
- */
-export function exists(name) {
-    return name in objectClass;
-};
+    /**
+     * Check if an object with the provided name is registered
+     * @param {string} name of the registered object class
+     * @returns {boolean} true if the classname is registered
+     */
+    exists(name) {
+        return name in this.objectClass;
+    };
 
-/**
- * Check if an object is poolable
- * (was properly registered with the recycling feature enable)
- * @function pool.poolable
- * @see pool.register
- * @param {object} obj object to be checked
- * @returns {boolean} true if the object is poolable
- * @example
- * if (!me.pool.poolable(myCherryEntity)) {
- *     // object was not properly registered
- * }
- */
-export function poolable(obj) {
-    var className = obj.className;
-    return (typeof className !== "undefined") &&
-            (typeof obj.onResetEvent === "function") &&
-            (className in objectClass) &&
-            (objectClass[className].pool !== "undefined");
+    /**
+     * Check if an object is poolable
+     * (was properly registered with the recycling feature enable)
+     * @see register
+     * @param {object} obj object to be checked
+     * @returns {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 this.objectClass) &&
+                (this.objectClass[className].pool !== "undefined");
+
+    }
 
+    /**
+     * returns the amount of object instance currently in the pool
+     * @returns {number} amount of object instance
+     */
+    getInstanceCount() {
+        return this.instance_counter;
+    }
 };
 
 /**
- * returns the amount of object instance currently in the pool
- * @function pool.getInstanceCount
- * @returns {number} amount of object instance
+ * a default global object pool instance
+ * @public
+ * @type {ObjectPool}
  */
-export function getInstanceCount() {
-    return instance_counter;
-};
+var pool = new ObjectPool();
+
+export default pool;

package/src/system/timer.js

@@ -145,7 +145,7 @@ var timer = {
          */
         reset() {
             // set to "now"
-            last = now = window.performance.now();
+            last = now = globalThis.performance.now();
             delta = 0;
             // reset delta counting variables
             framedelta = 0;

package/src/text/bitmaptext.js

@@ -1,6 +1,6 @@
 import Color from "./../math/color.js";
 import * as stringUtil from "./../utils/string.js";
-import * as pool from "./../system/pooling.js";
+import pool from "./../system/pooling.js";
 import loader from "./../loader/loader.js";
 import Renderable from "./../renderable/renderable.js";
 import TextMetrics from "./textmetrics.js";

package/src/text/text.js

@@ -2,7 +2,7 @@ import Color from "./../math/color.js";
 import WebGLRenderer from "./../video/webgl/webgl_renderer.js";
 import { renderer as globalRenderer, createCanvas } from "./../video/video.js";
 import { trimRight } from "./../utils/string.js";
-import * as pool from "./../system/pooling.js";
+import pool from "./../system/pooling.js";
 import Renderable from "./../renderable/renderable.js";
 import { nextPowerOfTwo } from "./../math/math.js";
 import setContextStyle from "./textstyle.js";

package/src/utils/agent.js

@@ -17,12 +17,12 @@ var vendors = [ "ms", "MS", "moz", "webkit", "o" ];
  * @name prefixed
  * @function
  * @param {string} name Property name
- * @param {object} [obj=window] Object or element reference to access
+ * @param {object} [obj=globalThis] Object or element reference to access
  * @returns {string} Value of property
  * @memberof utils.agent
  */
 export function prefixed(name, obj) {
-    obj = obj || window;
+    obj = obj || globalThis;
     if (name in obj) {
         return obj[name];
     }
@@ -44,12 +44,12 @@ export function prefixed(name, obj) {
  * @function
  * @param {string} name Property name
  * @param {string} value Property value
- * @param {object} [obj=window] Object or element reference to access
+ * @param {object} [obj=globalThis] Object or element reference to access
  * @returns {boolean} true if one of the vendor-prefixed property was found
  * @memberof utils.agent
  */
 export function setPrefixed(name, value, obj) {
-    obj = obj || window;
+    obj = obj || globalThis;
     if (name in obj) {
         obj[name] = value;
         return;

package/src/utils/function.js

@@ -36,13 +36,13 @@ export function defer(func, thisArg, ...args) {
  * @returns {Function} the function that will be throttled
  */
 export function throttle(fn, delay, no_trailing) {
-    var last = window.performance.now(), deferTimer;
+    var last = globalThis.performance.now(), deferTimer;
     // `no_trailing` defaults to false.
     if (typeof no_trailing !== "boolean") {
         no_trailing = false;
     }
     return function () {
-        var now = window.performance.now();
+        var now = globalThis.performance.now();
         var elasped = now - last;
         var args = arguments;
         if (elasped < delay) {

package/src/utils/utils.js

@@ -103,12 +103,17 @@ var utils = {
         var hash = {};
 
         if (typeof url === "undefined") {
-            var location = document.location;
-
-            if (location && location.hash) {
-                url = location.hash;
+            if (typeof globalThis.document !== "undefined") {
+                var location = globalThis.document.location;
+
+                if (location && location.hash) {
+                    url = location.hash;
+                } else {
+                    // No "document.location" exist for Wechat mini game platform.
+                    return hash;
+                }
             } else {
-                // No "document.location" exist for Wechat mini game platform.
+                // "document" undefined on node.js
                 return hash;
             }
         } else {