melonjs 14.0.1 → 14.1.0

package/dist/melonjs.mjs/plugin/plugin.js

@@ -0,0 +1,141 @@
+/*!
+ * melonJS Game Engine - v14.1.0
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import utils from '../utils/utils.js';
+import { version } from '../index.js';
+
+/**
+ * This namespace is a container for all registered plugins.
+ * @see plugin.register
+ * @namespace plugins
+ */
+var plugins = {};
+
+
+class BasePlugin {
+
+    constructor() {
+        /**
+         * define the minimum required version of melonJS<br>
+         * this can be overridden by the plugin
+         * @public
+         * @type {string}
+         * @default "14.1.0"
+         * @name plugin.Base#version
+         */
+        this.version = "14.1.0";
+    }
+}
+
+/**
+ * @namespace plugin
+ */
+var plugin = {
+
+    /**
+     * a base Object for plugin <br>
+     * plugin must be installed using the register function
+     * @see plugin
+     * @class
+     * @name Base
+     * @memberof plugin
+     */
+    Base : BasePlugin,
+
+    /**
+     * patch a melonJS function
+     * @name patch
+     * @memberof plugin
+     * @public
+     * @param {object} proto - target object
+     * @param {string} name - target function
+     * @param {Function} fn - replacement function
+     * @example
+     * // redefine the me.game.update function with a new one
+     * me.plugin.patch(me.game, "update", function () {
+     *   // display something in the console
+     *   console.log("duh");
+     *   // call the original me.game.update function
+     *   this._patched();
+     * });
+     */
+    patch : function (proto, name, fn) {
+        // use the object prototype if possible
+        if (typeof proto.prototype !== "undefined") {
+            proto = proto.prototype;
+        }
+        // reuse the logic behind object extends
+        if (typeof(proto[name]) === "function") {
+            // save the original function
+            var _parent = proto[name];
+            // override the function with the new one
+            Object.defineProperty(proto, name, {
+                "configurable" : true,
+                "value" : (function (name, fn) {
+                    return function () {
+                        this._patched = _parent;
+                        var ret = fn.apply(this, arguments);
+                        this._patched = null;
+                        return ret;
+                    };
+                })(name, fn)
+            });
+        }
+        else {
+            throw new Error(name + " is not an existing function");
+        }
+    },
+
+    /**
+     * Register a plugin.
+     * @name register
+     * @memberof plugin
+     * @see Base
+     * @public
+     * @param {plugin.Base} pluginObj - Plugin object to instantiate and register
+     * @param {string} name
+     * @param {object} [...arguments] - all extra parameters will be passed to the plugin constructor
+     * @example
+     * // register a new plugin
+     * me.plugin.register(TestPlugin, "testPlugin");
+     * // the plugin then also become available
+     * // under then me.plugins namespace
+     * me.plugins.testPlugin.myfunction ();
+     */
+    register : function (pluginObj, name) {
+        // ensure me.plugins[name] is not already "used"
+        if (plugins[name]) {
+            throw new Error("plugin " + name + " already registered");
+        }
+
+        // get extra arguments
+        var _args = [];
+        if (arguments.length > 2) {
+            // store extra arguments if any
+            _args = Array.prototype.slice.call(arguments, 1);
+        }
+
+        // try to instantiate the plugin
+        _args[0] = pluginObj;
+        var instance = new (pluginObj.bind.apply(pluginObj, _args))();
+
+        // inheritance check
+        if (typeof instance === "undefined" || !(instance instanceof plugin.Base)) {
+            throw new Error("Plugin should extend the me.plugin.Base Class !");
+        }
+
+        // compatibility testing
+        if (utils.checkVersion(instance.version) > 0) {
+            throw new Error("Plugin version mismatch, expected: " + instance.version + ", got: " + version);
+        }
+
+        // create a reference to the new plugin
+        plugins[name] = instance;
+    }
+};
+
+export { plugin, plugins };

package/dist/melonjs.mjs/renderable/collectable.js

@@ -0,0 +1,62 @@
+/*!
+ * melonJS Game Engine - v14.1.0
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import Sprite from './sprite.js';
+import Body from '../physics/body.js';
+import collision from '../physics/collision.js';
+import pool from '../system/pooling.js';
+
+/**
+ * @classdesc
+ * a basic collectable helper class for immovable object (e.g. a coin)
+ * @augments Sprite
+ */
+class Collectable extends Sprite {
+    /**
+     * @param {number} x - the x coordinates of the collectable
+     * @param {number} y - the y coordinates of the collectable
+     * @param {object} settings - See {@link Sprite}
+     */
+    constructor(x, y, settings) {
+
+        // call the super constructor
+        super(x, y, settings);
+
+        this.name = settings.name;
+        this.type = settings.type;
+        this.id = settings.id;
+
+        // add and configure the physic body
+        var shape = settings.shapes;
+        if (typeof shape === "undefined") {
+            shape = pool.pull("Polygon", 0, 0, [
+                pool.pull("Vector2d", 0,          0),
+                pool.pull("Vector2d", this.width, 0),
+                pool.pull("Vector2d", this.width, this.height)
+            ]);
+        }
+        this.body = new Body(this, shape);
+        this.body.collisionType = collision.types.COLLECTABLE_OBJECT;
+        // by default only collides with PLAYER_OBJECT
+        this.body.setCollisionMask(collision.types.PLAYER_OBJECT);
+        this.body.setStatic(true);
+
+        // Update anchorPoint
+        if (settings.anchorPoint) {
+            this.anchorPoint.set(settings.anchorPoint.x, settings.anchorPoint.y);
+        } else {
+            // for backward compatibility
+            this.anchorPoint.set(0, 0);
+        }
+
+    }
+
+}
+
+var Collectable$1 = Collectable;
+
+export { Collectable$1 as default };

package/dist/melonjs.mjs/renderable/colorlayer.js

@@ -0,0 +1,80 @@
+/*!
+ * melonJS Game Engine - v14.1.0
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import pool from '../system/pooling.js';
+import Renderable from './renderable.js';
+
+/**
+ * @classdesc
+ * a generic Color Layer Object.  Fills the entire Canvas with the color not just the container the object belongs to.
+ * @augments Renderable
+ */
+class ColorLayer extends Renderable {
+    /**
+     * @param {string} name - Layer name
+     * @param {Color|string} color - CSS color
+     * @param {number} [z = 0] - z-index position
+     */
+    constructor(name, color, z) {
+        // parent constructor
+        super(0, 0, Infinity, Infinity);
+
+        /**
+         * the layer color component
+         * @public
+         * @type {Color}
+         * @name color
+         * @memberof ColorLayer#
+         */
+         this.color = pool.pull("Color").parseCSS(color);
+
+         this.onResetEvent(name, color, z);
+
+    }
+
+    onResetEvent(name, color, z = 0) {
+        // apply given parameters
+        this.name = name;
+        this.pos.z = z;
+        this.floating = true;
+        // string (#RGB, #ARGB, #RRGGBB, #AARRGGBB)
+        this.color.parseCSS(color);
+    }
+
+    /**
+     * draw this color layer (automatically called by melonJS)
+     * @name draw
+     * @memberof ColorLayer
+     * @protected
+     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer instance
+     * @param {Camera2d} [viewport] - the viewport to (re)draw
+     */
+    draw(renderer, viewport) {
+        renderer.save();
+        renderer.clipRect(
+            0, 0,
+            viewport.width, viewport.height
+        );
+        renderer.clearColor(this.color);
+        renderer.restore();
+    }
+
+    /**
+     * Destroy function
+     * @ignore
+     */
+    destroy() {
+        pool.push(this.color);
+        this.color = undefined;
+        super.destroy();
+    }
+
+}
+
+var ColorLayer$1 = ColorLayer;
+
+export { ColorLayer$1 as default };