melonjs 10.4.0 → 10.5.2

package/dist/melonjs.module.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v10.4.0
+ * melonJS Game Engine - v10.5.2
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -13572,7 +13572,7 @@ class Renderable extends Rect {
      * @param {number} dt time since the last update in milliseconds.
      * @returns {boolean} true if the renderable is dirty
      */
-    update(/* dt */) {
+    update(dt) { // eslint-disable-line no-unused-vars
         return this.isDirty;
     }
 
@@ -13720,7 +13720,7 @@ class Renderable extends Rect {
      * @protected
      * @param {CanvasRenderer|WebGLRenderer} renderer a renderer object
      */
-    draw(/*renderer*/) {
+    draw(renderer) {  // eslint-disable-line no-unused-vars
         // empty one !
     }
 
@@ -13734,7 +13734,6 @@ class Renderable extends Rect {
      * @param {CanvasRenderer|WebGLRenderer} renderer a renderer object
      */
     postDraw(renderer) {
-
         // remove the previously applied tint
         renderer.clearTint();
 
@@ -14619,7 +14618,8 @@ var dummyObj = {
 function shouldCollide(a, b) {
     return (
         a.isKinematic !== true && b.isKinematic !== true &&
-        a.body && b.body &&
+        typeof a.body === "object" && typeof b.body === "object" &&
+        !(a.body.isStatic === true && b.body.isStatic === true) &&
         (a.body.collisionMask & b.body.collisionType) !== 0 &&
         (a.body.collisionType & b.body.collisionMask) !== 0
     );
@@ -14732,10 +14732,10 @@ function collisionCheck(objA, response = globalResponse) {
                         response.indexShapeB = indexB;
 
                         // execute the onCollision callback
-                        if (objA.onCollision && objA.onCollision(response, objB) !== false) {
+                        if (objA.onCollision && objA.onCollision(response, objB) !== false && objA.body.isStatic === false) {
                             objA.body.respondToCollision.call(objA.body, response);
                         }
-                        if (objB.onCollision && objB.onCollision(response, objA) !== false) {
+                        if (objB.onCollision && objB.onCollision(response, objA) !== false && objB.body.isStatic === false) {
                             objB.body.respondToCollision.call(objB.body, response);
                         }
                     }
@@ -15099,7 +15099,8 @@ class Body {
 
 
         /**
-         * either this body is a static body or not
+         * Either this body is a static body or not.
+         * A static body is completely fixed and can never change position or angle.
          * @readonly
          * @public
          * @type {boolean}
@@ -19388,6 +19389,455 @@ function applyTMXProperties(obj, data) {
     }
 }
 
+var src = {};
+
+var arraymultimap = {};
+
+var multimap = {};
+
+var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (commonjsGlobal && commonjsGlobal.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (commonjsGlobal && commonjsGlobal.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(multimap, "__esModule", { value: true });
+multimap.Multimap = void 0;
+var Multimap = /** @class */ (function () {
+    function Multimap(operator, iterable) {
+        var e_1, _a;
+        this.size_ = 0;
+        this.map = new Map();
+        this.operator = operator;
+        if (iterable) {
+            try {
+                for (var iterable_1 = __values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
+                    var _b = __read(iterable_1_1.value, 2), key = _b[0], value = _b[1];
+                    this.put(key, value);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return)) _a.call(iterable_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        return this;
+    }
+    Object.defineProperty(Multimap.prototype, "size", {
+        get: function () {
+            return this.size_;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Multimap.prototype.get = function (key) {
+        var values = this.map.get(key);
+        if (values) {
+            return this.operator.clone(values);
+        }
+        else {
+            return this.operator.create();
+        }
+    };
+    Multimap.prototype.put = function (key, value) {
+        var values = this.map.get(key);
+        if (!values) {
+            values = this.operator.create();
+        }
+        if (!this.operator.add(value, values)) {
+            return false;
+        }
+        this.map.set(key, values);
+        this.size_++;
+        return true;
+    };
+    Multimap.prototype.putAll = function (arg1, arg2) {
+        var e_2, _a, e_3, _b;
+        var pushed = 0;
+        if (arg2) {
+            var key = arg1;
+            var values = arg2;
+            try {
+                for (var values_1 = __values(values), values_1_1 = values_1.next(); !values_1_1.done; values_1_1 = values_1.next()) {
+                    var value = values_1_1.value;
+                    this.put(key, value);
+                    pushed++;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (values_1_1 && !values_1_1.done && (_a = values_1.return)) _a.call(values_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+        else if (arg1 instanceof Multimap) {
+            try {
+                for (var _c = __values(arg1.entries()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var _e = __read(_d.value, 2), key = _e[0], value = _e[1];
+                    this.put(key, value);
+                    pushed++;
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+        }
+        else {
+            throw new TypeError("unexpected arguments");
+        }
+        return pushed > 0;
+    };
+    Multimap.prototype.has = function (key) {
+        return this.map.has(key);
+    };
+    Multimap.prototype.hasEntry = function (key, value) {
+        return this.operator.has(value, this.get(key));
+    };
+    Multimap.prototype.delete = function (key) {
+        this.size_ -= this.operator.size(this.get(key));
+        return this.map.delete(key);
+    };
+    Multimap.prototype.deleteEntry = function (key, value) {
+        var current = this.get(key);
+        if (!this.operator.delete(value, current)) {
+            return false;
+        }
+        this.map.set(key, current);
+        this.size_--;
+        return true;
+    };
+    Multimap.prototype.clear = function () {
+        this.map.clear();
+        this.size_ = 0;
+    };
+    Multimap.prototype.keys = function () {
+        return this.map.keys();
+    };
+    Multimap.prototype.entries = function () {
+        var self = this;
+        function gen() {
+            var _a, _b, _c, key, values, values_2, values_2_1, value, e_4_1, e_5_1;
+            var e_5, _d, e_4, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        _f.trys.push([0, 11, 12, 13]);
+                        _a = __values(self.map.entries()), _b = _a.next();
+                        _f.label = 1;
+                    case 1:
+                        if (!!_b.done) return [3 /*break*/, 10];
+                        _c = __read(_b.value, 2), key = _c[0], values = _c[1];
+                        _f.label = 2;
+                    case 2:
+                        _f.trys.push([2, 7, 8, 9]);
+                        values_2 = (e_4 = void 0, __values(values)), values_2_1 = values_2.next();
+                        _f.label = 3;
+                    case 3:
+                        if (!!values_2_1.done) return [3 /*break*/, 6];
+                        value = values_2_1.value;
+                        return [4 /*yield*/, [key, value]];
+                    case 4:
+                        _f.sent();
+                        _f.label = 5;
+                    case 5:
+                        values_2_1 = values_2.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_4_1 = _f.sent();
+                        e_4 = { error: e_4_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (values_2_1 && !values_2_1.done && (_e = values_2.return)) _e.call(values_2);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                        return [7 /*endfinally*/];
+                    case 9:
+                        _b = _a.next();
+                        return [3 /*break*/, 1];
+                    case 10: return [3 /*break*/, 13];
+                    case 11:
+                        e_5_1 = _f.sent();
+                        e_5 = { error: e_5_1 };
+                        return [3 /*break*/, 13];
+                    case 12:
+                        try {
+                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                        return [7 /*endfinally*/];
+                    case 13: return [2 /*return*/];
+                }
+            });
+        }
+        return gen();
+    };
+    Multimap.prototype.values = function () {
+        var self = this;
+        function gen() {
+            var _a, _b, _c, value, e_6_1;
+            var e_6, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _e.trys.push([0, 5, 6, 7]);
+                        _a = __values(self.entries()), _b = _a.next();
+                        _e.label = 1;
+                    case 1:
+                        if (!!_b.done) return [3 /*break*/, 4];
+                        _c = __read(_b.value, 2), value = _c[1];
+                        return [4 /*yield*/, value];
+                    case 2:
+                        _e.sent();
+                        _e.label = 3;
+                    case 3:
+                        _b = _a.next();
+                        return [3 /*break*/, 1];
+                    case 4: return [3 /*break*/, 7];
+                    case 5:
+                        e_6_1 = _e.sent();
+                        e_6 = { error: e_6_1 };
+                        return [3 /*break*/, 7];
+                    case 6:
+                        try {
+                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                        return [7 /*endfinally*/];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        }
+        return gen();
+    };
+    Multimap.prototype.forEach = function (callback, thisArg) {
+        var e_7, _a;
+        try {
+            for (var _b = __values(this.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), key = _d[0], value = _d[1];
+                callback.call(thisArg === undefined ? this : thisArg, value, key, this);
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+    };
+    Multimap.prototype[Symbol.iterator] = function () {
+        return this.entries();
+    };
+    Multimap.prototype.asMap = function () {
+        var e_8, _a;
+        var ret = new Map();
+        try {
+            for (var _b = __values(this.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var key = _c.value;
+                ret.set(key, this.operator.clone(this.get(key)));
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        return ret;
+    };
+    return Multimap;
+}());
+multimap.Multimap = Multimap;
+
+var __extends$1 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(arraymultimap, "__esModule", { value: true });
+arraymultimap.ArrayMultimap = void 0;
+var multimap_1$1 = multimap;
+var ArrayMultimap = /** @class */ (function (_super) {
+    __extends$1(ArrayMultimap, _super);
+    function ArrayMultimap(iterable) {
+        return _super.call(this, new ArrayOperator(), iterable) || this;
+    }
+    Object.defineProperty(ArrayMultimap.prototype, Symbol.toStringTag, {
+        get: function () {
+            return "ArrayMultimap";
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ArrayMultimap;
+}(multimap_1$1.Multimap));
+arraymultimap.ArrayMultimap = ArrayMultimap;
+var ArrayOperator = /** @class */ (function () {
+    function ArrayOperator() {
+    }
+    ArrayOperator.prototype.create = function () {
+        return [];
+    };
+    ArrayOperator.prototype.clone = function (collection) {
+        return collection.slice();
+    };
+    ArrayOperator.prototype.add = function (value, collection) {
+        collection.push(value);
+        return true;
+    };
+    ArrayOperator.prototype.size = function (collection) {
+        return collection.length;
+    };
+    ArrayOperator.prototype.delete = function (value, collection) {
+        var index = collection.indexOf(value);
+        if (index > -1) {
+            collection.splice(index, 1);
+            return true;
+        }
+        return false;
+    };
+    ArrayOperator.prototype.has = function (value, collection) {
+        return collection.includes(value);
+    };
+    return ArrayOperator;
+}());
+
+var setmultimap = {};
+
+var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(setmultimap, "__esModule", { value: true });
+setmultimap.SetMultimap = void 0;
+var multimap_1 = multimap;
+var SetMultimap = /** @class */ (function (_super) {
+    __extends(SetMultimap, _super);
+    function SetMultimap(iterable) {
+        return _super.call(this, new SetOperator(), iterable) || this;
+    }
+    Object.defineProperty(SetMultimap.prototype, Symbol.toStringTag, {
+        get: function () {
+            return "SetMultimap";
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return SetMultimap;
+}(multimap_1.Multimap));
+setmultimap.SetMultimap = SetMultimap;
+var SetOperator = /** @class */ (function () {
+    function SetOperator() {
+    }
+    SetOperator.prototype.create = function () {
+        return new Set();
+    };
+    SetOperator.prototype.clone = function (collection) {
+        return new Set(collection);
+    };
+    SetOperator.prototype.add = function (value, collection) {
+        var prev = collection.size;
+        collection.add(value);
+        return prev !== collection.size;
+    };
+    SetOperator.prototype.size = function (collection) {
+        return collection.size;
+    };
+    SetOperator.prototype.delete = function (value, collection) {
+        return collection.delete(value);
+    };
+    SetOperator.prototype.has = function (value, collection) {
+        return collection.has(value);
+    };
+    return SetOperator;
+}());
+
+(function (exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetMultimap = exports.ArrayMultimap = void 0;
+var arraymultimap_1 = arraymultimap;
+Object.defineProperty(exports, "ArrayMultimap", { enumerable: true, get: function () { return arraymultimap_1.ArrayMultimap; } });
+var setmultimap_1 = setmultimap;
+Object.defineProperty(exports, "SetMultimap", { enumerable: true, get: function () { return setmultimap_1.SetMultimap; } });
+}(src));
+
 /**
  * a basic texture cache object
  * @ignore
@@ -19398,7 +19848,8 @@ class TextureCache {
      * @ignore
      */
     constructor(max_size) {
-        this.cache = new Map();
+        // cache uses an array to allow for duplicated key
+        this.cache = new src.ArrayMultimap();
         this.tinted = new Map();
         this.units = new Map();
         this.max_size = max_size || Infinity;
@@ -19432,13 +19883,29 @@ class TextureCache {
      * @ignore
      */
     get(image, atlas) {
-        if (!this.cache.has(image)) {
+        var entry;
+
+        if (typeof atlas === "undefined") {
+            entry = this.cache.get(image)[0];
+        } else {
+            // manage cases where a specific atlas is specified
+            this.cache.forEach((value, key) => {
+                var _atlas = value.getAtlas();
+                if (key === image && _atlas[0].width === atlas.framewidth && _atlas[0].height === atlas.frameheight) {
+                    entry = value;
+                }
+            });
+        }
+
+        if (typeof entry === "undefined") {
             if (!atlas) {
                 atlas = createAtlas(image.width, image.height, image.src ? getBasename(image.src) : undefined);
             }
-            this.set(image, new TextureAtlas(atlas, image, false));
+            entry = new TextureAtlas(atlas, image, false);
+            this.set(image, entry);
         }
-        return this.cache.get(image);
+
+        return entry;
     }
 
     /**
@@ -19483,7 +19950,7 @@ class TextureCache {
                 "(" + width + "x" + height + ")"
             );
         }
-        this.cache.set(image, texture);
+        return this.cache.put(image, texture);
     }
 
     /**
@@ -25381,6 +25848,8 @@ class TMXTileMap {
                 if (isCollisionGroup && !settings.name && obj.body) {
                     // configure the body accordingly
                     obj.body.collisionType = collision.types.WORLD_SHAPE;
+                    // mark collision shapes as static
+                    obj.body.isStatic = true;
                 }
 
                 //apply group opacity value to the child objects if group are merged
@@ -29129,6 +29598,17 @@ class WebGLCompositor {
         return this.currentTextureUnit;
     }
 
+    /**
+     * set/change the current projection matrix
+     * @name setProjection
+     * @memberof WebGLCompositor
+     * @function
+     * @param {Matrix3d} matrix
+     */
+    setProjection(matrix) {
+        this.activeShader.setUniform("uProjectionMatrix", matrix);
+    }
+
     /**
      * Select the shader to use for compositing
      * @name useShader
@@ -29608,6 +30088,18 @@ class WebGLRenderer extends Renderer {
         this.currentCompositor.flush();
     }
 
+    /**
+     * set/change the current projection matrix (WebGL only)
+     * @name setProjection
+     * @memberof WebGLRenderer.prototype
+     * @function
+     * @param {Matrix3d} matrix
+     */
+    setProjection(matrix) {
+        super.setProjection(matrix);
+        this.currentCompositor.setProjection(matrix);
+    }
+
     /**
      * Clears the gl context with the given color.
      * @name clearColor
@@ -30708,7 +31200,7 @@ function init(width, height, options) {
 
     // default scaled size value
     settings.zoomX = width * scaleRatio.x;
-    settings.zoomY = width * scaleRatio.y;
+    settings.zoomY = height * scaleRatio.y;
 
     //add a channel for the onresize/onorientationchange event
     window.addEventListener(
@@ -31374,10 +31866,10 @@ class BasePlugin {
          * this can be overridden by the plugin
          * @public
          * @type {string}
-         * @default "10.4.0"
+         * @default "10.5.2"
          * @name plugin.Base#version
          */
-        this.version = "10.4.0";
+        this.version = "10.5.2";
     }
 }
 
@@ -34517,6 +35009,225 @@ class Trigger extends Renderable {
 
 }
 
+/**
+ * @classdesc
+ * A Draggable base object
+ * @see DropTarget
+ * @augments Renderable
+ */
+class Draggable extends Renderable {
+    /**
+     * @param {number} x the x coordinates of the draggable object
+     * @param {number} y the y coordinates of the draggable object
+     * @param {number} width draggable object width
+     * @param {number} height draggable object height
+     */
+    constructor(x, y, width, height) {
+        super(x, y, width, height);
+        this.isKinematic = false;
+        this.dragging = false;
+        this.dragId = null;
+        this.grabOffset = new Vector2d(0, 0);
+        this.initEvents();
+    }
+
+    /**
+     * Initializes the events the modules needs to listen to
+     * It translates the pointer events to me.events
+     * in order to make them pass through the system and to make
+     * this module testable. Then we subscribe this module to the
+     * transformed events.
+     * @name initEvents
+     * @memberof Draggable
+     * @function
+     * @private
+     */
+    initEvents() {
+        registerPointerEvent("pointerdown", this, (e) => { emit(DRAGSTART, e, this); });
+        registerPointerEvent("pointerup", this,  (e) => { emit(DRAGEND, e, this); });
+        registerPointerEvent("pointercancel", this, (e) => { emit(DRAGEND, e, this); });
+        on(POINTERMOVE, this.dragMove.bind(this));
+        on(DRAGSTART, (e, draggable) => {
+            if (draggable === this) {
+                this.dragStart(e);
+            }
+        });
+        on(DRAGEND, (e, draggable) => {
+            if (draggable === this) {
+                this.dragEnd(e);
+            }
+        });
+    }
+
+    /**
+     * Gets called when the user starts dragging the entity
+     * @name dragStart
+     * @memberof Draggable
+     * @function
+     * @param {object} e the pointer event
+     * @returns {boolean} false if the object is being dragged
+     */
+    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
+     * @name dragMove
+     * @memberof Draggable
+     * @function
+     * @param {object} e the pointer event
+     */
+    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
+     * @name dragEnd
+     * @memberof Draggable
+     * @function
+     * @returns {boolean} false if the object stopped being dragged
+     */
+    dragEnd() {
+        if (this.dragging === true) {
+            this.dragging = false;
+            return false;
+        }
+    }
+
+    /**
+     * Destructor
+     * @name destroy
+     * @memberof Draggable
+     * @function
+     * @ignore
+     */
+    destroy() {
+        off(POINTERMOVE, this.dragMove);
+        off(DRAGSTART, this.dragStart);
+        off(DRAGEND, this.dragEnd);
+        releasePointerEvent("pointerdown", this);
+        releasePointerEvent("pointerup", this);
+        releasePointerEvent("pointercancel", this);
+        super.destroy();
+    }
+}
+/**
+ * @classdesc
+ * a base drop target object
+ * @see Draggable
+ * @augments Renderable
+ */
+class DropTarget extends Renderable {
+    /**
+     * @param {number} x the x coordinates of the drop target
+     * @param {number} y the y coordinates of the drop target
+     * @param {number} width drop target width
+     * @param {number} height drop target height
+     */
+    constructor(x, y, width, height) {
+        super(x, y, width, height);
+
+        this.isKinematic = false;
+
+        /**
+         * constant for the overlaps method
+         * @public
+         * @constant
+         * @type {string}
+         * @name CHECKMETHOD_OVERLAP
+         * @memberof DropTarget
+         */
+        this.CHECKMETHOD_OVERLAP = "overlaps";
+
+        /**
+         * constant for the contains method
+         * @public
+         * @constant
+         * @type {string}
+         * @name CHECKMETHOD_CONTAINS
+         * @memberof DropTarget
+         */
+        this.CHECKMETHOD_CONTAINS = "contains";
+
+        /**
+         * the checkmethod we want to use
+         * @public
+         * @constant
+         * @type {string}
+         * @name checkMethod
+         * @default "overlaps"
+         * @memberof DropTarget
+         */
+        this.checkMethod = this.CHECKMETHOD_OVERLAP;
+
+        on(DRAGEND, this.checkOnMe, this);
+
+    }
+
+    /**
+     * Sets the collision method which is going to be used to check a valid drop
+     * @name setCheckMethod
+     * @memberof DropTarget
+     * @function
+     * @param {string} checkMethod the checkmethod (defaults to CHECKMETHOD_OVERLAP)
+     */
+    setCheckMethod(checkMethod) {
+        //  We can improve this check,
+        //  because now you can use every method in theory
+        if (typeof(this.getBounds()[this.checkMethod]) === "function") {
+            this.checkMethod = checkMethod;
+        }
+    }
+
+    /**
+     * Checks if a dropped entity is dropped on the current entity
+     * @name checkOnMe
+     * @memberof DropTarget
+     * @function
+     * @param {object} e the triggering event
+     * @param {Draggable} draggable the draggable object that is dropped
+     */
+    checkOnMe(e, draggable) {
+        if (draggable && this.getBounds()[this.checkMethod](draggable.getBounds())) {
+            // call the drop method on the current entity
+            this.drop(draggable);
+        }
+    }
+
+    /**
+     * Gets called when a draggable entity is dropped on the current entity
+     * @name drop
+     * @memberof DropTarget
+     * @function
+     * @param {Draggable} draggable the draggable object that is dropped
+     */
+    drop() {
+
+    }
+
+    /**
+     * Destructor
+     * @name destroy
+     * @memberof DropTarget
+     * @function
+     * @ignore
+     */
+    destroy() {
+        off(DRAGEND, this.checkOnMe);
+        super.destroy();
+    }
+}
+
 /**
  * @classdesc
  * Particle Container Object.
@@ -35571,226 +36282,6 @@ class Entity extends Renderable {
 
 }
 
-/**
- * @classdesc
- * Used to make a game entity draggable
- * @augments Entity
- */
-class DraggableEntity extends Entity {
-    /**
-     * @param {number} x the x coordinates of the entity object
-     * @param {number} y the y coordinates of the entity object
-     * @param {object} settings Entity properties (see {@link Entity})
-     */
-    constructor(x, y, settings) {
-        super(x, y, settings);
-        this.dragging = false;
-        this.dragId = null;
-        this.grabOffset = new Vector2d(0, 0);
-        this.onPointerEvent = registerPointerEvent;
-        this.removePointerEvent = releasePointerEvent;
-        this.initEvents();
-    }
-
-    /**
-     * Initializes the events the modules needs to listen to
-     * It translates the pointer events to me.events
-     * in order to make them pass through the system and to make
-     * this module testable. Then we subscribe this module to the
-     * transformed events.
-     * @name initEvents
-     * @memberof DraggableEntity
-     * @function
-     */
-    initEvents() {
-        /**
-         * @ignore
-         */
-        this.mouseDown = function (e) {
-            this.translatePointerEvent(e, DRAGSTART);
-        };
-        /**
-         * @ignore
-         */
-        this.mouseUp = function (e) {
-            this.translatePointerEvent(e, DRAGEND);
-        };
-        this.onPointerEvent("pointerdown", this, this.mouseDown.bind(this));
-        this.onPointerEvent("pointerup", this, this.mouseUp.bind(this));
-        this.onPointerEvent("pointercancel", this, this.mouseUp.bind(this));
-        on(POINTERMOVE, this.dragMove, this);
-        on(DRAGSTART, this.dragStart, this);
-        on(DRAGEND, this.dragEnd, this);
-    }
-
-    /**
-     * Translates a pointer event to a me.event
-     * @name translatePointerEvent
-     * @memberof 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
-     */
-    translatePointerEvent(e, translation) {
-        emit(translation, e);
-    }
-
-    /**
-     * Gets called when the user starts dragging the entity
-     * @name dragStart
-     * @memberof DraggableEntity
-     * @function
-     * @param {object} e the pointer event
-     * @returns {boolean} false if the object is being dragged
-     */
-    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
-     * @name dragMove
-     * @memberof DraggableEntity
-     * @function
-     * @param {object} e the pointer event
-     */
-    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
-     * @name dragEnd
-     * @memberof DraggableEntity
-     * @function
-     * @returns {boolean} false if the object stopped being dragged
-     */
-    dragEnd() {
-        if (this.dragging === true) {
-            this.dragging = false;
-            return false;
-        }
-    }
-
-    /**
-     * Destructor
-     * @name destroy
-     * @memberof DraggableEntity
-     * @function
-     */
-    destroy() {
-        off(POINTERMOVE, this.dragMove);
-        off(DRAGSTART, this.dragStart);
-        off(DRAGEND, this.dragEnd);
-        this.removePointerEvent("pointerdown", this);
-        this.removePointerEvent("pointerup", this);
-    }
-}
-
-/**
- * @classdesc
- * Used to make a game entity a droptarget
- * @augments Entity
- */
-class DroptargetEntity extends Entity {
-    /**
-     * @param {number} x the x coordinates of the entity object
-     * @param {number} y the y coordinates of the entity object
-     * @param {object} settings Entity properties (see {@link Entity})
-     */
-    constructor(x, y, settings) {
-        super(x, y, settings);
-        /**
-         * constant for the overlaps method
-         * @public
-         * @constant
-         * @type {string}
-         * @name CHECKMETHOD_OVERLAP
-         * @memberof DroptargetEntity
-         */
-        this.CHECKMETHOD_OVERLAP = "overlaps";
-        /**
-         * constant for the contains method
-         * @public
-         * @constant
-         * @type {string}
-         * @name CHECKMETHOD_CONTAINS
-         * @memberof DroptargetEntity
-         */
-        this.CHECKMETHOD_CONTAINS = "contains";
-        /**
-         * the checkmethod we want to use
-         * @public
-         * @constant
-         * @type {string}
-         * @name checkMethod
-         * @memberof DroptargetEntity
-         */
-        this.checkMethod = null;
-        on(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
-     * @name setCheckMethod
-     * @memberof DroptargetEntity
-     * @function
-     * @param {string} checkMethod the checkmethod (defaults to CHECKMETHOD_OVERLAP)
-     */
-    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
-     * @name checkOnMe
-     * @memberof DroptargetEntity
-     * @function
-     * @param {object} e the triggering event
-     * @param {object} draggableEntity the draggable entity that is dropped
-     */
-    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
-     * @name drop
-     * @memberof DroptargetEntity
-     * @function
-     * @param {object} draggableEntity the draggable entity that is dropped
-     */
-    drop() {
-
-    }
-
-    /**
-     * Destructor
-     * @name destroy
-     * @memberof DroptargetEntity
-     * @function
-     */
-    destroy() {
-        off(DRAGEND, this.checkOnMe);
-    }
-}
-
 /**
  * placeholder for all deprecated classes and corresponding alias for backward compatibility
  */
@@ -35874,13 +36365,48 @@ Object.defineProperty(Renderer.prototype, "Texture", {
     }
 });
 
-var deprecated = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    warning: warning
-});
+
+/**
+ * @classdesc
+ * Used to make a game entity draggable
+ * @augments Entity
+ * @deprecated since 10.5.0
+ * @see Draggable
+ */
+class DraggableEntity extends Draggable {
+    /**
+     * @param {number} x the x coordinates of the draggable object
+     * @param {number} y the y coordinates of the draggable object
+     * @param {object} settings Entity properties (see {@link Entity})
+     */
+    constructor(x, y, settings) {
+        warning("DraggableEntity", "Draggable", "10.5.0");
+        super(x, y, settings.width, settings.height);
+    }
+}
+
+/**
+ * @classdesc
+ * Used to make a game entity a droptarget
+ * @augments Entity
+ * @deprecated since 10.5.0
+ * @see DropTarget
+ */
+class DroptargetEntity extends DropTarget {
+    /**
+     * @param {number} x the x coordinates of the draggable object
+     * @param {number} y the y coordinates of the draggable object
+     * @param {object} settings Entity properties (see {@link Entity})
+     */
+    constructor(x, y, settings) {
+        warning("DroptargetEntity", "DropTarget", "10.5.0");
+        super(x, y, settings.width, settings.height);
+    }
+}
 
 // ES5 polyfills
 
+
 /**
  * current melonJS version
  * @static
@@ -35888,7 +36414,7 @@ var deprecated = /*#__PURE__*/Object.freeze({
  * @name version
  * @type {string}
  */
-const version = "10.4.0";
+const version = "10.5.2";
 
 
 /**
@@ -35995,4 +36521,4 @@ device$1.onReady(function () {
     }
 });
 
-export { BitmapText, BitmapTextData, Body, Bounds$1 as Bounds, Camera2d, CanvasRenderer, Collectable, Color, ColorLayer, Container, DraggableEntity, DroptargetEntity, Ellipse, Entity, GLShader, GUI_Object, ImageLayer, Line, math as Math, Matrix2d, Matrix3d, NineSliceSprite, ObservableVector2d, ObservableVector3d, Particle, ParticleEmitter, ParticleEmitterSettings, Pointer, Polygon, QuadTree, Rect, Renderable, Renderer, Sprite, Stage, TMXHexagonalRenderer, TMXIsometricRenderer, TMXLayer, TMXOrthogonalRenderer, TMXRenderer, TMXStaggeredRenderer, TMXTileMap, TMXTileset, TMXTilesetGroup, Text, TextureAtlas, Tile, Trigger, Tween, Vector2d, Vector3d, WebGLCompositor, WebGLRenderer, World, audio, boot, collision, deprecated, device$1 as device, event, game, initialized, input, level, loader, plugin, plugins, pool, save, skipAutoInit, state, timer$1 as timer, utils, version, video };
+export { BitmapText, BitmapTextData, Body, Bounds$1 as Bounds, Camera2d, CanvasRenderer, Collectable, Color, ColorLayer, Container, Draggable, DraggableEntity, DropTarget, DroptargetEntity, Ellipse, Entity, GLShader, GUI_Object, ImageLayer, Line, math as Math, Matrix2d, Matrix3d, NineSliceSprite, ObservableVector2d, ObservableVector3d, Particle, ParticleEmitter, ParticleEmitterSettings, Pointer, Polygon, QuadTree, Rect, Renderable, Renderer, Sprite, Stage, TMXHexagonalRenderer, TMXIsometricRenderer, TMXLayer, TMXOrthogonalRenderer, TMXRenderer, TMXStaggeredRenderer, TMXTileMap, TMXTileset, TMXTilesetGroup, Text, TextureAtlas, Tile, Trigger, Tween, Vector2d, Vector3d, WebGLCompositor, WebGLRenderer, World, audio, boot, collision, device$1 as device, event, game, initialized, input, level, loader, plugin, plugins, pool, save, skipAutoInit, state, timer$1 as timer, utils, version, video, warning };