Fixed an issue where passing null as the Group parent wouldn't set it to game.world as it should have (thanks tito100).

Continued work on the tilemap collision - again, please don't use this version if you need working tilemaps.

Author: photonstorm

README.md

@@ -65,6 +65,7 @@ Bug Fixes:
 * Moved 'dirty' flag for Tilemap to a per-layer flag. Fixes #242
 * Group.length now returns the number of children in the Group regardless of their exists/alive state, or 0 if the Group is has no children.
 * Switch Camera.setBoundsToWorld to match world.bounds instead of world (thanks cocoademon)
+* Fixed an issue where passing null as the Group parent wouldn't set it to game.world as it should have (thanks tito100)
 
 
 You can view the Change Log for all previous versions at https://github.com/photonstorm/phaser/changelog.md

examples/wip/tilemap.js

@@ -36,8 +36,8 @@ function create() {
     //  this screws something up - not quite sure what, but needs investigating!
     // layer.resizeWorld();
 
-    sprite = game.add.sprite(120, 510, 'phaser');
-    sprite.anchor.setTo(0.5, 0.5);
+    sprite = game.add.sprite(120, 450, 'phaser');
+    // sprite.anchor.setTo(0.5, 0.5);
     // sprite.angle = 5;
 
     // game.camera.follow(sprite);
@@ -96,12 +96,12 @@ function update() {
     if (cursors.left.isDown)
     {
         sprite.body.velocity.x = -150;
-        sprite.scale.x = -1;
+        // sprite.scale.x = -1;
     }
     else if (cursors.right.isDown)
     {
         sprite.body.velocity.x = 150;
-        sprite.scale.x = 1;
+        // sprite.scale.x = 1;
     }
 
 
@@ -113,6 +113,6 @@ function render() {
     // game.debug.renderSpriteBounds(sprite);
 
     game.debug.renderText(sprite.x, 32, 32);
-    game.debug.renderText(sprite.y, 32, 64);
+    game.debug.renderText(sprite.y, 32, 48);
 
 }

src/core/Group.js

@@ -10,32 +10,32 @@
 * @classdesc A Group is a container for display objects that allows for fast pooling, recycling and collision checks.
 * @constructor
 * @param {Phaser.Game} game - A reference to the currently running game.
-* @param {*} parent - The parent Group or DisplayObjectContainer that will hold this group, if any.
+* @param {*} parent - The parent Group or DisplayObjectContainer that will hold this group, if any. If not set, or set to null, it will use game.world.
 * @param {string} [name=group] - A name for this Group. Not used internally but useful for debugging.
 * @param {boolean} [useStage=false] - Should the DisplayObjectContainer this Group creates be added to the World (default, false) or direct to the Stage (true).
 */
 Phaser.Group = function (game, parent, name, useStage) {
 
-    if (typeof parent === 'undefined' || typeof parent === null)
-    {
-        parent = game.world;
-    }
-
-    if (typeof useStage === 'undefined')
-    {
-        useStage = false;
-    }
-
     /**
     * @property {Phaser.Game} game - A reference to the currently running Game.
     */
     this.game = game;
-    
+
+    if (typeof parent === 'undefined' || parent === null)
+    {
+        parent = game.world;
+    }
+
     /**
     * @property {string} name - A name for this Group. Not used internally but useful for debugging.
     */
     this.name = name || 'group';
 
+    if (typeof useStage === 'undefined')
+    {
+        useStage = false;
+    }
+
     if (useStage)
     {
         this._container = this.game.stage._stage;

src/gameobjects/GameObjectFactory.js

@@ -90,7 +90,7 @@ Phaser.GameObjectFactory.prototype = {
     *
     * @method Phaser.GameObjectFactory#group
     * @param {*} parent - The parent Group or DisplayObjectContainer that will hold this group, if any.
-    * @param {string} [name=group] - A name for this Group. Not used internally but useful for debugging.
+    * @param {string} [name='group'] - A name for this Group. Not used internally but useful for debugging.
     * @return {Phaser.Group} The newly created group.
     */
     group: function (parent, name) {

src/geom/Rectangle.js

@@ -644,7 +644,14 @@ Phaser.Rectangle.intersection = function (a, b, out) {
 */
 Phaser.Rectangle.intersects = function (a, b) {
 
-    return (a.x < b.right && b.x < a.right && a.y < b.bottom && b.y < a.bottom);
+    if (a.width <= 0 || a.height <= 0 || b.width <= 0 || b.height <= 0)
+    {
+        return false;
+    }
+
+    return !(a.right < b.x || a.bottom < b.y || a.x > b.right || a.y > b.bottom);
+
+    // return (a.x < b.right && b.x < a.right && a.y < b.bottom && b.y < a.bottom);
 
     // return (a.x <= b.right && b.x <= a.right && a.y <= b.bottom && b.y <= a.bottom);
 

src/physics/arcade/ArcadePhysics.js

@@ -566,6 +566,8 @@ Phaser.Physics.Arcade.prototype = {
             return;
         }
 
+        console.log('collideSpriteVsTilemapLayer', this._mapData.length);
+
         for (var i = 0; i < this._mapData.length; i++)
         {
             if (this.separateTile(sprite.body, this._mapData[i]))
@@ -1006,31 +1008,41 @@ Phaser.Physics.Arcade.prototype = {
             return false;
         }
 
-        var overlapX = 0;
-        var overlapY = 0;
+        //  use body var instead
+        body.overlapX = 0;
+        body.overlapY = 0;
 
-        console.log('x', tile.x, 'y', tile.y, 'r', tile.right, 'b', tile.bottom);
-        console.log('x', body.x, 'y', body.y, 'r', body.right, 'b', body.bottom);
-        console.log(Phaser.Rectangle.intersects(body, tile));
+        //  Remember - this happens AFTER the body has been moved by the motion update, so it needs moving back again
+        // console.log('---------------------------------------------------------------------------------------------');
+        // console.log('tx', tile.x, 'ty', tile.y, 'tw', tile.width, 'th', tile.height, 'tr', tile.right, 'tb', tile.bottom);
+        // console.log('bx', body.x, 'by', body.y, 'bw', body.width, 'bh', body.height, 'br', body.right, 'bb', body.bottom);
+        // console.log(Phaser.Rectangle.intersects(body, tile));
+        // console.log('dx', body.deltaX(), 'dy', body.deltaY(), 'dax', body.deltaAbsX(), 'day', body.deltaAbsY(), 'cax', Math.ceil(body.deltaAbsX()), 'cay', Math.ceil(body.deltaAbsY()));
 
         if (body.deltaX() < 0 && body.allowCollision.left && tile.tile.faceRight)
         {
             //  LEFT
-            if (tile.right - body.x < Math.ceil(body.deltaAbsX()))
-            {
-                overlapX = tile.right - body.x;
+            body.overlapX = body.x - tile.right;
 
+            if (body.overlapX > body.deltaX())
+            {
+                console.log('left overlapX', body.overlapX);
+                //  use touching instead of blocked?
+                body.blocked.left = true;
                 body.touching.left = true;
                 body.touching.none = false;
             }
         }
         else if (body.deltaX() > 0 && body.allowCollision.right && tile.tile.faceLeft)
         {
             //  RIGHT
-            if (body.right - tile.x < Math.ceil(body.deltaAbsX()))
-            {
-                overlapX = tile.x - body.right;
+            body.overlapX = body.right - tile.x;
 
+            //  Distance check
+            if (body.overlapX < body.deltaX())
+            {
+                console.log('right overlapX', body.overlapX);
+                body.blocked.right = true;
                 body.touching.right = true;
                 body.touching.none = false;
             }
@@ -1039,62 +1051,65 @@ Phaser.Physics.Arcade.prototype = {
         if (body.deltaY() < 0 && body.allowCollision.up && tile.tile.faceBottom)
         {
             //  UP
-            if (tile.bottom - body.y < Math.ceil(body.deltaAbsY()))
-            {
-                overlapY = tile.bottom - body.y;
+            body.overlapY = body.y - tile.bottom;
 
+            //  Distance check
+            if (body.overlapY > body.deltaY())
+            {
+                console.log('up overlapY', body.overlapY);
+                body.blocked.up = true;
                 body.touching.up = true;
                 body.touching.none = false;
             }
         }
         else if (body.deltaY() > 0 && body.allowCollision.down && tile.tile.faceTop)
         {
             //  DOWN
-            if (body.bottom - tile.y < Math.ceil(body.deltaAbsY()))
-            {
-                overlapY = tile.y - body.bottom;
+            body.overlapY = body.bottom - tile.y;
 
+            if (body.overlapY < body.deltaY())
+            {
+                console.log('down overlapY', body.overlapY);
+                body.blocked.down = true;
                 body.touching.down = true;
                 body.touching.none = false;
             }
         }
 
         //  Separate in a single sweep
 
-        if (overlapX === 0 && overlapY === 0)
+        if (body.touching.none)
         {
             return false;
         }
 
-        if (overlapX !== 0)
+        if (body.overlapX !== 0)
         {
-            // body.overlapX = overlapX;
-            body.x += overlapX;
-            body.preX = body.x;
+            body.x -= body.overlapX;
+            body.preX -= body.overlapX;
 
             if (body.bounce.x === 0)
             {
-                body.velocity.x = 0;
+                // body.velocity.x = 0;
             }
             else
             {
-                body.velocity.x = -body.velocity.x * body.bounce.x;
+                // body.velocity.x = -body.velocity.x * body.bounce.x;
             }
         }
 
-        if (overlapY !== 0)
+        if (body.overlapY !== 0)
         {
-            // body.overlapY = overlapY;
-            body.y += overlapY;
-            body.preY = body.y;
+            body.y -= body.overlapY;
+            body.preY -= body.overlapY;
 
             if (body.bounce.y === 0)
             {
-                body.velocity.y = 0;
+                // body.velocity.y = 0;
             }
             else
             {
-                body.velocity.y = -body.velocity.y * body.bounce.y;
+                // body.velocity.y = -body.velocity.y * body.bounce.y;
             }
         }