melonjs 14.0.2 → 14.1.1

package/src/math/vector2.js

@@ -5,10 +5,10 @@ import pool from "./../system/pooling.js";
  * @classdesc
  * a generic 2D Vector Object
  */
-class Vector2d {
+ export default class Vector2d {
     /**
-     * @param {number} [x=0] x value of the vector
-     * @param {number} [y=0] y value of the vector
+     * @param {number} [x=0] - x value of the vector
+     * @param {number} [y=0] - y value of the vector
      */
     constructor(x = 0, y = 0) {
         this.onResetEvent(x, y);
@@ -159,7 +159,7 @@ class Vector2d {
      * Divide this vector values by the passed value
      * @name div
      * @memberof Vector2d
-     * @param {number} n the value to divide the vector by
+     * @param {number} n - the value to divide the vector by
      * @returns {Vector2d} Reference to this object for method chaining
      */
     div(n) {
@@ -348,8 +348,8 @@ class Vector2d {
      * Rotate this vector (counter-clockwise) by the specified angle (in radians).
      * @name rotate
      * @memberof Vector2d
-     * @param {number} angle The angle to rotate (in radians)
-     * @param {Vector2d|ObservableVector2d} [v] an optional point to rotate around
+     * @param {number} angle - The angle to rotate (in radians)
+     * @param {Vector2d|ObservableVector2d} [v] - an optional point to rotate around
      * @returns {Vector2d} Reference to this object for method chaining
      */
     rotate(angle, v) {
@@ -417,7 +417,7 @@ class Vector2d {
      * @name lerp
      * @memberof Vector2d
      * @param {Vector2d} v
-     * @param {number} alpha distance along the line (alpha = 0 will be this vector, and alpha = 1 will be the given one).
+     * @param {number} alpha - distance along the line (alpha = 0 will be this vector, and alpha = 1 will be the given one).
      * @returns {Vector2d} Reference to this object for method chaining
      */
     lerp(v, alpha) {
@@ -431,7 +431,7 @@ class Vector2d {
      * @name moveTowards
      * @memberof Vector2d
      * @param {Vector2d} target
-     * @param {number} step the maximum step per iteration (Negative values will push the vector away from the target)
+     * @param {number} step - the maximum step per iteration (Negative values will push the vector away from the target)
      * @returns {Vector2d} Reference to this object for method chaining
      */
      moveTowards(target, step) {
@@ -476,7 +476,7 @@ class Vector2d {
      * project this vector on to another vector.
      * @name project
      * @memberof Vector2d
-     * @param {Vector2d} v The vector to project onto.
+     * @param {Vector2d} v - The vector to project onto.
      * @returns {Vector2d} Reference to this object for method chaining
      */
     project(v) {
@@ -488,7 +488,7 @@ class Vector2d {
      * This is slightly more efficient than `project` when dealing with unit vectors.
      * @name projectN
      * @memberof Vector2d
-     * @param {Vector2d} v The unit vector to project onto.
+     * @param {Vector2d} v - The unit vector to project onto.
      * @returns {Vector2d} Reference to this object for method chaining
      */
     projectN(v) {
@@ -516,4 +516,3 @@ class Vector2d {
     }
 }
 
-export default Vector2d;

package/src/math/vector3.js

@@ -5,11 +5,11 @@ import pool from "./../system/pooling.js";
  * @classdesc
  * a generic 3D Vector Object
  */
-class Vector3d {
+ export default class Vector3d {
     /**
-     * @param {number} [x=0] x value of the vector
-     * @param {number} [y=0] y value of the vector
-     * @param {number} [z=0] z value of the vector
+     * @param {number} [x=0] - x value of the vector
+     * @param {number} [y=0] - y value of the vector
+     * @param {number} [z=0] - z value of the vector
      */
     constructor(x = 0, y = 0, z = 0) {
         this.onResetEvent(x, y, z);
@@ -174,7 +174,7 @@ class Vector3d {
      * Divide this vector values by the passed value
      * @name div
      * @memberof Vector3d
-     * @param {number} n the value to divide the vector by
+     * @param {number} n - the value to divide the vector by
      * @returns {Vector3d} Reference to this object for method chaining
      */
     div(n) {
@@ -373,8 +373,8 @@ class Vector3d {
      * Rotate this vector (counter-clockwise) by the specified angle (in radians) around the z axis
      * @name rotate
      * @memberof Vector3d
-     * @param {number} angle The angle to rotate (in radians)
-     * @param {Vector2d|ObservableVector2d} [v] an optional point to rotate around (on the same z axis)
+     * @param {number} angle - The angle to rotate (in radians)
+     * @param {Vector2d|ObservableVector2d} [v] - an optional point to rotate around (on the same z axis)
      * @returns {Vector3d} Reference to this object for method chaining
      */
     rotate(angle, v) {
@@ -450,7 +450,7 @@ class Vector3d {
      * @name lerp
      * @memberof Vector3d
      * @param {Vector3d} v
-     * @param {number} alpha distance along the line (alpha = 0 will be this vector, and alpha = 1 will be the given one).
+     * @param {number} alpha - distance along the line (alpha = 0 will be this vector, and alpha = 1 will be the given one).
      * @returns {Vector3d} Reference to this object for method chaining
      */
     lerp(v, alpha) {
@@ -465,7 +465,7 @@ class Vector3d {
      * @name moveTowards
      * @memberof Vector3d
      * @param {Vector2d|Vector3d} target
-     * @param {number} step the maximum step per iteration (Negative values will push the vector away from the target)
+     * @param {number} step - the maximum step per iteration (Negative values will push the vector away from the target)
      * @returns {Vector3d} Reference to this object for method chaining
      */
     moveTowards(target, step) {
@@ -515,7 +515,7 @@ class Vector3d {
      * project this vector on to another vector.
      * @name project
      * @memberof Vector3d
-     * @param {Vector2d|Vector3d} v The vector to project onto.
+     * @param {Vector2d|Vector3d} v - The vector to project onto.
      * @returns {Vector3d} Reference to this object for method chaining
      */
     project(v) {
@@ -528,7 +528,7 @@ class Vector3d {
      * This is slightly more efficient than `project` when dealing with unit vectors.
      * @name projectN
      * @memberof Vector3d
-     * @param {Vector2d|Vector3d} v The unit vector to project onto.
+     * @param {Vector2d|Vector3d} v - The unit vector to project onto.
      * @returns {Vector3d} Reference to this object for method chaining
      */
     projectN(v) {
@@ -557,4 +557,3 @@ class Vector3d {
     }
 }
 
-export default Vector3d;

package/src/particles/emitter.js

@@ -21,11 +21,11 @@ function createDefaultParticleTexture(w = 8, h = 8) {
  * Particle Emitter Object.
  * @augments Container
  */
-class ParticleEmitter extends Container {
+ export default class ParticleEmitter extends Container {
     /**
-     * @param {number} x x position of the particle emitter
-     * @param {number} y y position of the particle emitter
-     * @param {ParticleEmitterSettings} [settings=ParticleEmitterSettings] the settings for the particle emitter.
+     * @param {number} x - x position of the particle emitter
+     * @param {number} y - y position of the particle emitter
+     * @param {ParticleEmitterSettings} [settings=ParticleEmitterSettings] - the settings for the particle emitter.
      * @example
      * // Create a particle emitter at position 100, 100
      * var emitter = new ParticleEmitter(100, 100, {
@@ -110,7 +110,7 @@ class ParticleEmitter extends Container {
 
     /**
      * Reset the emitter with particle emitter settings.
-     * @param {ParticleEmitterSettings} settings [optional] object with emitter settings. See {@link ParticleEmitterSettings}
+     * @param {ParticleEmitterSettings} settings - [optional] object with emitter settings. See {@link ParticleEmitterSettings}
      */
     reset(settings = {}) {
         Object.assign(this.settings, ParticleEmitterSettings, settings);
@@ -161,7 +161,7 @@ class ParticleEmitter extends Container {
 
     /**
      * Launch particles from emitter constantly (e.g. for stream)
-     * @param {number} duration [optional] time that the emitter releases particles in ms
+     * @param {number} duration - [optional] time that the emitter releases particles in ms
      */
     streamParticles(duration) {
         this._enabled = true;
@@ -179,7 +179,7 @@ class ParticleEmitter extends Container {
 
     /**
      * Launch all particles from emitter and stop (e.g. for explosion)
-     * @param {number} total [optional] number of particles to launch
+     * @param {number} total - [optional] number of particles to launch
      */
     burstParticles(total) {
         this._enabled = true;
@@ -256,4 +256,3 @@ class ParticleEmitter extends Container {
     }
 }
 
-export default ParticleEmitter;

package/src/particles/particle.js

@@ -8,9 +8,9 @@ import Renderable from "./../renderable/renderable.js";
  * Single Particle Object.
  * @augments Renderable
  */
-class Particle extends Renderable {
+ export default class Particle extends Renderable {
     /**
-     * @param {ParticleEmitter} emitter the particle emitter
+     * @param {ParticleEmitter} emitter - the particle emitter
      */
     constructor(emitter) {
         // Call the super constructor
@@ -107,7 +107,7 @@ class Particle extends Renderable {
      * Update the Particle <br>
      * This is automatically called by the game manager {@link game}
      * @ignore
-     * @param {number} dt time since the last update in milliseconds
+     * @param {number} dt - time since the last update in milliseconds
      */
     update(dt) {
         // move things forward independent of the current frame rate
@@ -176,4 +176,3 @@ class Particle extends Renderable {
     }
 }
 
-export default Particle;

package/src/physics/body.js

@@ -14,11 +14,11 @@ import Point from "../geometries/point.js";
  * a Generic Physic Body Object with some physic properties and behavior functionality, to as a member of a Renderable.
  * @see Renderable.body
  */
-class Body {
+ export default class Body {
     /**
-     * @param {Renderable} ancestor the parent object this body is attached to
-     * @param {Rect|Rect[]|Polygon|Polygon[]|Line|Line[]|Ellipse|Ellipse[]|Point|Point[]|Bounds|Bounds[]|object} [shapes] a initial shape, list of shapes, or JSON object defining the body
-     * @param {Function} [onBodyUpdate] callback for when the body is updated (e.g. add/remove shapes)
+     * @param {Renderable} ancestor - the parent object this body is attached to
+     * @param {Rect|Rect[]|Polygon|Polygon[]|Line|Line[]|Ellipse|Ellipse[]|Point|Point[]|Bounds|Bounds[]|object} [shapes] - a initial shape, list of shapes, or JSON object defining the body
+     * @param {Function} [onBodyUpdate] - callback for when the body is updated (e.g. add/remove shapes)
      */
     constructor(ancestor, shapes, onBodyUpdate) {
 
@@ -236,7 +236,7 @@ class Body {
     /**
      * add a collision shape to this body <br>
      * (note: me.Rect objects will be converted to me.Polygon before being added)
-     * @param {Rect|Polygon|Line|Ellipse|Point|Point[]|Bounds|object} shape a shape or JSON object
+     * @param {Rect|Polygon|Line|Ellipse|Point|Point[]|Bounds|object} shape - a shape or JSON object
      * @returns {number} the shape array length
      * @example
      * // add a rectangle shape
@@ -292,9 +292,9 @@ class Body {
 
     /**
      * set the body vertices to the given one
-     * @param {Vector2d[]} vertices an array of me.Vector2d points defining a convex hull
-     * @param {number} [index=0] the shape object for which to set the vertices
-     * @param {boolean} [clear=true] either to reset the body definition before adding the new vertices
+     * @param {Vector2d[]} vertices - an array of me.Vector2d points defining a convex hull
+     * @param {number} [index=0] - the shape object for which to set the vertices
+     * @param {boolean} [clear=true] - either to reset the body definition before adding the new vertices
      */
     setVertices(vertices, index = 0, clear = true) {
         var polygon = this.getShape(index);
@@ -315,8 +315,8 @@ class Body {
 
     /**
      * add the given vertices to the body shape
-     * @param {Vector2d[]} vertices an array of me.Vector2d points defining a convex hull
-     * @param {number} [index=0] the shape object for which to set the vertices
+     * @param {Vector2d[]} vertices - an array of me.Vector2d points defining a convex hull
+     * @param {number} [index=0] - the shape object for which to set the vertices
      */
     addVertices(vertices, index = 0) {
         this.setVertices(vertices, index, false);
@@ -325,8 +325,8 @@ class Body {
     /**
      * add collision mesh based on a JSON object
      * (this will also apply any physic properties defined in the given JSON file)
-     * @param {object} json a JSON object as exported from a Physics Editor tool
-     * @param {string} [id] an optional shape identifier within the given the json object
+     * @param {object} json - a JSON object as exported from a Physics Editor tool
+     * @param {string} [id] - an optional shape identifier within the given the json object
      * @see https://www.codeandweb.com/physicseditor
      * @returns {number} how many shapes were added to the body
      * @example
@@ -365,7 +365,7 @@ class Body {
 
     /**
      * return the collision shape at the given index
-     * @param {number} [index=0] the shape object at the specified index
+     * @param {number} [index=0] - the shape object at the specified index
      * @returns {Polygon|Line|Ellipse} shape a shape object if defined
      */
     getShape(index) {
@@ -382,7 +382,7 @@ class Body {
 
     /**
      * remove the specified shape from the body shape list
-     * @param {Polygon|Line|Ellipse} shape a shape object
+     * @param {Polygon|Line|Ellipse} shape - a shape object
      * @returns {number} the shape array length
      */
     removeShape(shape) {
@@ -400,7 +400,7 @@ class Body {
 
     /**
      * remove the shape at the given index from the body shape list
-     * @param {number} index the shape object at the specified index
+     * @param {number} index - the shape object at the specified index
      * @returns {number} the shape array length
      */
     removeShapeAt(index) {
@@ -412,7 +412,7 @@ class Body {
      * but it's also possible to specify 'collision filters' to provide a finer <br>
      * control over which body can collide with each other.
      * @see collision.types
-     * @param {number} [bitmask = collision.types.ALL_OBJECT] the collision mask
+     * @param {number} [bitmask = collision.types.ALL_OBJECT] - the collision mask
      * @example
      * // filter collision detection with collision shapes, enemies and collectables
      * body.setCollisionMask(me.collision.types.WORLD_SHAPE | me.collision.types.ENEMY_OBJECT | me.collision.types.COLLECTABLE_OBJECT);
@@ -427,7 +427,7 @@ class Body {
     /**
      * define the collision type of the body for collision filtering
      * @see collision.types
-     * @param {number} type the collision type
+     * @param {number} type - the collision type
      * @example
      * // set the body collision type
      * body.collisionType = me.collision.types.PLAYER_OBJECT;
@@ -444,7 +444,7 @@ class Body {
 
     /**
      * the built-in function to solve the collision response
-     * @param {object} response the collision response object (see {@link ResponseObject})
+     * @param {object} response - the collision response object (see {@link ResponseObject})
      */
     respondToCollision(response) {
         // the overlap vector
@@ -483,8 +483,8 @@ class Body {
      *    - The current element being processed in the array <br>
      *    - The index of element in the array. <br>
      *    - The array forEach() was called upon. <br>
-     * @param {Function} callback fnction to execute on each element
-     * @param {object} [thisArg] value to use as this(i.e reference Object) when executing callback.
+     * @param {Function} callback - fnction to execute on each element
+     * @param {object} [thisArg] - value to use as this(i.e reference Object) when executing callback.
      * @example
      * // iterate through all shapes of the physic body
      * mySprite.body.forEach((shape) => {
@@ -522,8 +522,8 @@ class Body {
      */
     /**
      * Returns true if the any of the shape composing the body contains the given point.
-     * @param  {number} x x coordinate
-     * @param  {number} y y coordinate
+     * @param  {number} x -  x coordinate
+     * @param  {number} y -  y coordinate
      * @returns {boolean} true if contains
      */
     contains() {
@@ -553,8 +553,8 @@ class Body {
     /**
      * Rotate this body (counter-clockwise) by the specified angle (in radians).
      * Unless specified the body will be rotated around its center point
-     * @param {number} angle The angle to rotate (in radians)
-     * @param {Vector2d|ObservableVector2d} [v=Body.getBounds().center] an optional point to rotate around
+     * @param {number} angle - The angle to rotate (in radians)
+     * @param {Vector2d|ObservableVector2d} [v=Body.getBounds().center] - an optional point to rotate around
      * @returns {Body} Reference to this object for method chaining
      */
     rotate(angle, v = this.getBounds().center) {
@@ -577,8 +577,8 @@ class Body {
 
     /**
      * cap the body velocity (body.maxVel property) to the specified value<br>
-     * @param {number} x max velocity on x axis
-     * @param {number} y max velocity on y axis
+     * @param {number} x - max velocity on x axis
+     * @param {number} y - max velocity on y axis
      */
     setMaxVelocity(x, y) {
         this.maxVel.x = x;
@@ -587,8 +587,8 @@ class Body {
 
     /**
      * set the body default friction
-     * @param {number} x horizontal friction
-     * @param {number} y vertical friction
+     * @param {number} x - horizontal friction
+     * @param {number} y - vertical friction
      */
     setFriction(x = 0, y = 0) {
         this.friction.x = x;
@@ -605,7 +605,7 @@ class Body {
      * Updates to Body.vel are bounded by maxVel (which defaults to viewport size if not set) <br>
      * At this time a call to Body.Update does not call the onBodyUpdate callback that is listed in the constructor arguments.
      * @protected
-     * @param {number} dt time since the last update in milliseconds.
+     * @param {number} dt - time since the last update in milliseconds.
      * @returns {boolean} true if resulting velocity is different than 0
      */
     update(dt) { // eslint-disable-line no-unused-vars
@@ -692,4 +692,3 @@ class Body {
     }
 }
 
-export default Body;

package/src/physics/bounds.js

@@ -5,9 +5,9 @@ import Vector2d from "./../math/vector2.js";
  * @classdesc
  * a bound object contains methods for creating and manipulating axis-aligned bounding boxes (AABB).
  */
-class Bounds {
+ export default class Bounds {
     /**
-     * @param {Vector2d[]} [vertices] an array of me.Vector2d points
+     * @param {Vector2d[]} [vertices] - an array of me.Vector2d points
      */
     constructor(vertices) {
         // @ignore
@@ -203,7 +203,7 @@ class Bounds {
      * Updates bounds using the given vertices
      * @name update
      * @memberof Bounds
-     * @param {Vector2d[]} vertices an array of me.Vector2d points
+     * @param {Vector2d[]} vertices - an array of me.Vector2d points
      */
     update(vertices) {
         this.add(vertices, true);
@@ -213,8 +213,8 @@ class Bounds {
      * add the given vertices to the bounds definition.
      * @name add
      * @memberof Bounds
-     * @param {Vector2d[]} vertices an array of me.Vector2d points
-     * @param {boolean} [clear=false] either to reset the bounds before adding the new vertices
+     * @param {Vector2d[]} vertices - an array of me.Vector2d points
+     * @param {boolean} [clear=false] - either to reset the bounds before adding the new vertices
      */
     add(vertices, clear = false) {
         if (clear === true) {
@@ -234,7 +234,7 @@ class Bounds {
      * @name addBounds
      * @memberof Bounds
      * @param {Bounds} bounds
-     * @param {boolean} [clear=false] either to reset the bounds before adding the new vertices
+     * @param {boolean} [clear=false] - either to reset the bounds before adding the new vertices
      */
     addBounds(bounds, clear = false) {
         if (clear === true) {
@@ -254,8 +254,8 @@ class Bounds {
      * add the given point to the bounds definition.
      * @name addPoint
      * @memberof Bounds
-     * @param {Vector2d|Point} point the point to be added to the bounds
-     * @param {Matrix2d} [m] an optional transform to apply to the given point (only if the given point is a vector)
+     * @param {Vector2d|Point} point - the point to be added to the bounds
+     * @param {Matrix2d} [m] - an optional transform to apply to the given point (only if the given point is a vector)
      */
     addPoint(point, m) {
         if ((typeof m !== "undefined") && (typeof point.rotate === "function")) {
@@ -276,7 +276,7 @@ class Bounds {
      * @param {number} y0 - top Y coordinates of the quad
      * @param {number} x1 - right X coordinates of the quad
      * @param {number} y1 - bottom y coordinates of the quad
-     * @param {Matrix2d} [m] an optional transform to apply to the given frame coordinates
+     * @param {Matrix2d} [m] - an optional transform to apply to the given frame coordinates
      */
     addFrame(x0, y0, x1, y1, m) {
         var v = pool.pull("Vector2d");
@@ -448,4 +448,4 @@ class Bounds {
     }
 
 }
-export default Bounds;
+

package/src/physics/collision.js

@@ -96,8 +96,8 @@ var collision = {
      * @name rayCast
      * @memberof collision
      * @public
-     * @param {Line} line line to be tested for collision
-     * @param {Array.<Renderable>} [result] a user defined array that will be populated with intersecting physic objects.
+     * @param {Line} line - line to be tested for collision
+     * @param {Array.<Renderable>} [result] - a user defined array that will be populated with intersecting physic objects.
      * @returns {Array.<Renderable>} an array of intersecting physic objects
      * @example
      *    // define a line accross the viewport

package/src/physics/detector.js

@@ -28,8 +28,8 @@ let globalResponse = new ResponseObject();
  * @name shouldCollide
  * @memberof collision
  * @ignore
- * @param {Renderable} a a reference to the object A.
- * @param {Renderable} b a reference to the object B.
+ * @param {Renderable} a - a reference to the object A.
+ * @param {Renderable} b - a reference to the object B.
  * @returns {boolean} true if they should collide, false otherwise
  */
 function shouldCollide(a, b) {
@@ -52,8 +52,8 @@ function shouldCollide(a, b) {
  * find all the collisions for the specified object
  * @name collisionCheck
  * @ignore
- * @param {Renderable} objA object to be tested for collision
- * @param {ResponseObject} [response] a user defined response object that will be populated if they intersect.
+ * @param {Renderable} objA - object to be tested for collision
+ * @param {ResponseObject} [response] - a user defined response object that will be populated if they intersect.
  * @returns {boolean} in case of collision, false otherwise
  */
 export function collisionCheck(objA, response = globalResponse) {
@@ -115,8 +115,8 @@ export function collisionCheck(objA, response = globalResponse) {
  * Checks for object colliding with the given line
  * @name rayCast
  * @ignore
- * @param {Line} line line to be tested for collision
- * @param {Array.<Renderable>} [result] a user defined array that will be populated with intersecting physic objects.
+ * @param {Line} line - line to be tested for collision
+ * @param {Array.<Renderable>} [result] - a user defined array that will be populated with intersecting physic objects.
  * @returns {Array.<Renderable>} an array of intersecting physic objects
  * @example
  *    // define a line accross the viewport

package/src/physics/quadtree.js

@@ -1,5 +1,4 @@
 import Vector2d from "./../math/vector2.js";
-import Container from "./../renderable/container.js";
 import * as arrayUtil from "./../utils/array.js";
 
 /*
@@ -8,7 +7,6 @@ import * as arrayUtil from "./../utils/array.js";
  * https://github.com/timohausmann/quadtree-js/
 **/
 
-
 /**
  * a pool of `QuadTree` objects
  * @ignore
@@ -53,13 +51,13 @@ var QT_VECTOR = new Vector2d();
  * a QuadTree implementation in JavaScript, a 2d spatial subdivision algorithm.
  * @see game.world.broadphase
  */
-class QuadTree {
+ export default class QuadTree {
     /**
-     * @param {World} world the physic world this QuadTree belongs to
-     * @param {Bounds} bounds bounds of the node
-     * @param {number} [max_objects=4] max objects a node can hold before splitting into 4 subnodes
-     * @param {number} [max_levels=4] total max levels inside root Quadtree
-     * @param {number} [level] deepth level, required for subnodes
+     * @param {World} world - the physic world this QuadTree belongs to
+     * @param {Bounds} bounds - bounds of the node
+     * @param {number} [max_objects=4] - max objects a node can hold before splitting into 4 subnodes
+     * @param {number} [max_levels=4] - total max levels inside root Quadtree
+     * @param {number} [level] - deepth level, required for subnodes
      */
     constructor(world, bounds, max_objects = 4, max_levels = 4, level = 0) {
 
@@ -70,7 +68,6 @@ class QuadTree {
         this.max_levels  = max_levels;
 
         this.level = level;
-        this.bounds = bounds;
 
         this.objects = [];
         this.nodes = [];
@@ -89,7 +86,7 @@ class QuadTree {
          //top right node
         this.nodes[0] = QT_ARRAY_POP(
             this.world,
-            this.bounds, {
+            {
                 left : left + subWidth,
                 top : top,
                 width : subWidth,
@@ -103,7 +100,7 @@ class QuadTree {
         //top left node
         this.nodes[1] = QT_ARRAY_POP(
             this.world,
-            this.bounds, {
+            {
                 left : left,
                 top: top,
                 width : subWidth,
@@ -117,7 +114,7 @@ class QuadTree {
         //bottom left node
         this.nodes[2] = QT_ARRAY_POP(
             this.world,
-            this.bounds, {
+            {
                 left : left,
                 top : top + subHeight,
                 width : subWidth,
@@ -131,7 +128,7 @@ class QuadTree {
         //bottom right node
         this.nodes[3] = QT_ARRAY_POP(
             this.world,
-            this.bounds, {
+            {
                 left : left + subWidth,
                 top : top + subHeight,
                 width : subWidth,
@@ -156,7 +153,7 @@ class QuadTree {
         if (item.isFloating === true) {
             pos = this.world.app.viewport.localToWorld(bounds.left, bounds.top, QT_VECTOR);
         } else {
-            pos = QT_VECTOR.set(bounds.left, bounds.top);
+            pos = QT_VECTOR.set(item.left, item.top);
         }
 
         var index = -1,
@@ -194,12 +191,12 @@ class QuadTree {
      * Insert the given object container into the node.
      * @name insertContainer
      * @memberof QuadTree
-     * @param {Container} container group of objects to be added
+     * @param {Container} container - group of objects to be added
      */
     insertContainer(container) {
         for (var i = container.children.length, child; i--, (child = container.children[i]);) {
             if (child.isKinematic !== true) {
-                if (child instanceof Container) {
+                if (typeof child.addChild === "function") {
                     if (child.name !== "rootContainer") {
                         this.insert(child);
                     }
@@ -222,7 +219,7 @@ class QuadTree {
      * objects to their corresponding subnodes.
      * @name insert
      * @memberof QuadTree
-     * @param {object} item object to be added
+     * @param {object} item - object to be added
      */
     insert(item) {
         var index = -1;
@@ -266,8 +263,8 @@ class QuadTree {
      * Return all objects that could collide with the given object
      * @name retrieve
      * @memberof QuadTree
-     * @param {object} item object to be checked against
-     * @param {object} [fn] a sorting function for the returned array
+     * @param {object} item - object to be checked against
+     * @param {object} [fn] - a sorting function for the returned array
      * @returns {object[]} array with all detected objects
      */
     retrieve(item, fn) {
@@ -301,7 +298,7 @@ class QuadTree {
      * (this function won't recalculate the impacted node)
      * @name remove
      * @memberof QuadTree
-     * @param {object} item object to be removed
+     * @param {object} item - object to be removed
      * @returns {boolean} true if the item was found and removed.
      */
      remove(item) {
@@ -367,7 +364,7 @@ class QuadTree {
      * clear the quadtree
      * @name clear
      * @memberof QuadTree
-     * @param {Bounds} [bounds=this.bounds] the bounds to be cleared
+     * @param {Bounds} [bounds=this.bounds] - the bounds to be cleared
      */
     clear(bounds) {
         this.objects.length = 0;
@@ -386,5 +383,3 @@ class QuadTree {
         }
     }
 }
-
-export default QuadTree;