melonjs 10.4.0 → 10.5.0

package/dist/melonjs.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v10.4.0
+ * melonJS Game Engine - v10.5.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -14707,7 +14707,8 @@
     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
         );
@@ -14820,10 +14821,10 @@
                             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);
                             }
                         }
@@ -15183,7 +15184,8 @@
 
 
         /**
-         * 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}
@@ -19523,12 +19525,462 @@
         }
     }
 
+    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
      */
     var TextureCache = function TextureCache(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;
@@ -19562,13 +20014,29 @@
      * @ignore
      */
     TextureCache.prototype.get = function 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(function (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;
     };
 
     /**
@@ -19613,7 +20081,7 @@
                 "(" + width + "x" + height + ")"
             );
         }
-        this.cache.set(image, texture);
+        return this.cache.put(image, texture);
     };
 
     /**
@@ -25425,6 +25893,8 @@
                 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
@@ -31430,10 +31900,10 @@
          * this can be overridden by the plugin
          * @public
          * @type {string}
-         * @default "10.4.0"
+         * @default "10.5.0"
          * @name plugin.Base#version
          */
-        this.version = "10.4.0";
+        this.version = "10.5.0";
     };
 
     /**
@@ -34459,6 +34929,227 @@
         return Trigger;
     }(Renderable));
 
+    /**
+     * @classdesc
+     * A Draggable base object
+     * @see DropTarget
+     * @augments Renderable
+     */
+    var Draggable = /*@__PURE__*/(function (Renderable) {
+        function Draggable(x, y, width, height) {
+            Renderable.call(this, x, y, width, height);
+            this.isKinematic = false;
+            this.dragging = false;
+            this.dragId = null;
+            this.grabOffset = new Vector2d(0, 0);
+            this.initEvents();
+        }
+
+        if ( Renderable ) Draggable.__proto__ = Renderable;
+        Draggable.prototype = Object.create( Renderable && Renderable.prototype );
+        Draggable.prototype.constructor = Draggable;
+
+        /**
+         * 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
+         */
+        Draggable.prototype.initEvents = function initEvents () {
+            var this$1$1 = this;
+
+            registerPointerEvent("pointerdown", this, function (e) { emit(DRAGSTART, e, this$1$1); });
+            registerPointerEvent("pointerup", this,  function (e) { emit(DRAGEND, e, this$1$1); });
+            registerPointerEvent("pointercancel", this, function (e) { emit(DRAGEND, e, this$1$1); });
+            on(POINTERMOVE, this.dragMove.bind(this));
+            on(DRAGSTART, function (e, draggable) {
+                if (draggable === this$1$1) {
+                    this$1$1.dragStart(e);
+                }
+            });
+            on(DRAGEND, function (e, draggable) {
+                if (draggable === this$1$1) {
+                    this$1$1.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
+         */
+        Draggable.prototype.dragStart = function 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
+         */
+        Draggable.prototype.dragMove = function 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
+         */
+        Draggable.prototype.dragEnd = function dragEnd () {
+            if (this.dragging === true) {
+                this.dragging = false;
+                return false;
+            }
+        };
+
+        /**
+         * Destructor
+         * @name destroy
+         * @memberof Draggable
+         * @function
+         * @private
+         */
+        Draggable.prototype.destroy = function destroy () {
+            off(POINTERMOVE, this.dragMove);
+            off(DRAGSTART, this.dragStart);
+            off(DRAGEND, this.dragEnd);
+            releasePointerEvent("pointerdown", this);
+            releasePointerEvent("pointerup", this);
+            releasePointerEvent("pointercancel", this);
+            Renderable.prototype.destroy.call(this);
+        };
+
+        return Draggable;
+    }(Renderable));
+    /**
+     * @classdesc
+     * a base drop target object
+     * @see Draggable
+     * @augments Renderable
+     */
+    var DropTarget = /*@__PURE__*/(function (Renderable) {
+        function DropTarget(x, y, width, height) {
+            Renderable.call(this, 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);
+
+        }
+
+        if ( Renderable ) DropTarget.__proto__ = Renderable;
+        DropTarget.prototype = Object.create( Renderable && Renderable.prototype );
+        DropTarget.prototype.constructor = DropTarget;
+
+        /**
+         * 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)
+         */
+        DropTarget.prototype.setCheckMethod = function 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
+         */
+        DropTarget.prototype.checkOnMe = function 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
+         */
+        DropTarget.prototype.drop = function drop () {
+
+        };
+
+        /**
+         * Destructor
+         * @name destroy
+         * @memberof DropTarget
+         * @function
+         * @private
+         */
+        DropTarget.prototype.destroy = function destroy () {
+            off(DRAGEND, this.checkOnMe);
+            Renderable.prototype.destroy.call(this);
+        };
+
+        return DropTarget;
+    }(Renderable));
+
     /**
      * @classdesc
      * Particle Container Object.
@@ -35517,228 +36208,6 @@
         return Entity;
     }(Renderable));
 
-    /**
-     * @classdesc
-     * Used to make a game entity draggable
-     * @augments Entity
-     */
-    var DraggableEntity = /*@__PURE__*/(function (Entity) {
-        function DraggableEntity(x, y, settings) {
-            Entity.call(this, x, y, settings);
-            this.dragging = false;
-            this.dragId = null;
-            this.grabOffset = new Vector2d(0, 0);
-            this.onPointerEvent = registerPointerEvent;
-            this.removePointerEvent = releasePointerEvent;
-            this.initEvents();
-        }
-
-        if ( Entity ) DraggableEntity.__proto__ = Entity;
-        DraggableEntity.prototype = Object.create( Entity && Entity.prototype );
-        DraggableEntity.prototype.constructor = DraggableEntity;
-
-        /**
-         * 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
-         */
-        DraggableEntity.prototype.initEvents = 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
-         */
-        DraggableEntity.prototype.translatePointerEvent = function 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
-         */
-        DraggableEntity.prototype.dragStart = function 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
-         */
-        DraggableEntity.prototype.dragMove = function 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
-         */
-        DraggableEntity.prototype.dragEnd = function dragEnd () {
-            if (this.dragging === true) {
-                this.dragging = false;
-                return false;
-            }
-        };
-
-        /**
-         * Destructor
-         * @name destroy
-         * @memberof DraggableEntity
-         * @function
-         */
-        DraggableEntity.prototype.destroy = function destroy () {
-            off(POINTERMOVE, this.dragMove);
-            off(DRAGSTART, this.dragStart);
-            off(DRAGEND, this.dragEnd);
-            this.removePointerEvent("pointerdown", this);
-            this.removePointerEvent("pointerup", this);
-        };
-
-        return DraggableEntity;
-    }(Entity));
-
-    /**
-     * @classdesc
-     * Used to make a game entity a droptarget
-     * @augments Entity
-     */
-    var DroptargetEntity = /*@__PURE__*/(function (Entity) {
-        function DroptargetEntity(x, y, settings) {
-            Entity.call(this, 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];
-        }
-
-        if ( Entity ) DroptargetEntity.__proto__ = Entity;
-        DroptargetEntity.prototype = Object.create( Entity && Entity.prototype );
-        DroptargetEntity.prototype.constructor = DroptargetEntity;
-
-        /**
-         * 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)
-         */
-        DroptargetEntity.prototype.setCheckMethod = function 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
-         */
-        DroptargetEntity.prototype.checkOnMe = function 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
-         */
-        DroptargetEntity.prototype.drop = function drop () {
-
-        };
-
-        /**
-         * Destructor
-         * @name destroy
-         * @memberof DroptargetEntity
-         * @function
-         */
-        DroptargetEntity.prototype.destroy = function destroy () {
-            off(DRAGEND, this.checkOnMe);
-        };
-
-        return DroptargetEntity;
-    }(Entity));
-
     /**
      * placeholder for all deprecated classes and corresponding alias for backward compatibility
      */
@@ -35822,13 +36291,50 @@
         }
     });
 
-    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
+     */
+    var DraggableEntity = /*@__PURE__*/(function (Draggable) {
+        function DraggableEntity(x, y, settings) {
+            warning("DraggableEntity", "Draggable", "10.5.0");
+            Draggable.call(this, x, y, settings.width, settings.height);
+        }
+
+        if ( Draggable ) DraggableEntity.__proto__ = Draggable;
+        DraggableEntity.prototype = Object.create( Draggable && Draggable.prototype );
+        DraggableEntity.prototype.constructor = DraggableEntity;
+
+        return DraggableEntity;
+    }(Draggable));
+
+    /**
+     * @classdesc
+     * Used to make a game entity a droptarget
+     * @augments Entity
+     * @deprecated since 10.5.0
+     * @see DropTarget
+     */
+    var DroptargetEntity = /*@__PURE__*/(function (DropTarget) {
+        function DroptargetEntity(x, y, settings) {
+            warning("DroptargetEntity", "DropTarget", "10.5.0");
+            DropTarget.call(this, x, y, settings.width, settings.height);
+        }
+
+        if ( DropTarget ) DroptargetEntity.__proto__ = DropTarget;
+        DroptargetEntity.prototype = Object.create( DropTarget && DropTarget.prototype );
+        DroptargetEntity.prototype.constructor = DroptargetEntity;
+
+        return DroptargetEntity;
+    }(DropTarget));
 
     // ES5 polyfills
 
+
     /**
      * current melonJS version
      * @static
@@ -35836,7 +36342,7 @@
      * @name version
      * @type {string}
      */
-    var version = "10.4.0";
+    var version = "10.5.0";
 
 
     /**
@@ -35953,7 +36459,9 @@
     exports.Color = Color;
     exports.ColorLayer = ColorLayer;
     exports.Container = Container;
+    exports.Draggable = Draggable;
     exports.DraggableEntity = DraggableEntity;
+    exports.DropTarget = DropTarget;
     exports.DroptargetEntity = DroptargetEntity;
     exports.Ellipse = Ellipse;
     exports.Entity = Entity;
@@ -36000,7 +36508,6 @@
     exports.audio = audio;
     exports.boot = boot;
     exports.collision = collision;
-    exports.deprecated = deprecated;
     exports.device = device$1;
     exports.event = event;
     exports.game = game;
@@ -36017,6 +36524,7 @@
     exports.utils = utils;
     exports.version = version;
     exports.video = video;
+    exports.warning = warning;
 
     Object.defineProperty(exports, '__esModule', { value: true });