New isLayer handling

Author: photonstorm

src/physics/arcade/tilemap/SeparateTile.js

@@ -20,10 +20,11 @@ var TileIntersectsBody = require('./TileIntersectsBody');
  * @param {Phaser.Geom.Rectangle} tileWorldRect - A rectangle-like object defining the dimensions of the tile.
  * @param {(Phaser.Tilemaps.DynamicTilemapLayer|Phaser.Tilemaps.StaticTilemapLayer)} tilemapLayer - The tilemapLayer to collide against.
  * @param {number} tileBias - The tile bias value. Populated by the `World.TILE_BIAS` constant.
+ * @param {boolean} isLayer - Is this check coming from a TilemapLayer or an array of tiles?
  *
  * @return {boolean} `true` if the body was separated, otherwise `false`.
  */
-var SeparateTile = function (i, body, tile, tileWorldRect, tilemapLayer, tileBias)
+var SeparateTile = function (i, body, tile, tileWorldRect, tilemapLayer, tileBias, isLayer)
 {
     var tileLeft = tileWorldRect.left;
     var tileTop = tileWorldRect.top;
@@ -32,6 +33,12 @@ var SeparateTile = function (i, body, tile, tileWorldRect, tilemapLayer, tileBia
     var faceHorizontal = tile.faceLeft || tile.faceRight;
     var faceVertical = tile.faceTop || tile.faceBottom;
 
+    if (!isLayer)
+    {
+        faceHorizontal = true;
+        faceVertical = true;
+    }
+
     //  We don't need to go any further if this tile doesn't actually have any colliding faces. This
     //  could happen if the tile was meant to be collided with re: a callback, but otherwise isn't
     //  needed for separation.
@@ -68,7 +75,7 @@ var SeparateTile = function (i, body, tile, tileWorldRect, tilemapLayer, tileBia
     {
         if (faceHorizontal)
         {
-            ox = TileCheckX(body, tile, tileLeft, tileRight, tileBias);
+            ox = TileCheckX(body, tile, tileLeft, tileRight, tileBias, isLayer);
 
             //  That's horizontal done, check if we still intersects? If not then we can return now
             if (ox !== 0 && !TileIntersectsBody(tileWorldRect, body))
@@ -79,14 +86,14 @@ var SeparateTile = function (i, body, tile, tileWorldRect, tilemapLayer, tileBia
 
         if (faceVertical)
         {
-            oy = TileCheckY(body, tile, tileTop, tileBottom, tileBias);
+            oy = TileCheckY(body, tile, tileTop, tileBottom, tileBias, isLayer);
         }
     }
     else
     {
         if (faceVertical)
         {
-            oy = TileCheckY(body, tile, tileTop, tileBottom, tileBias);
+            oy = TileCheckY(body, tile, tileTop, tileBottom, tileBias, isLayer);
 
             //  That's vertical done, check if we still intersects? If not then we can return now
             if (oy !== 0 && !TileIntersectsBody(tileWorldRect, body))
@@ -97,7 +104,7 @@ var SeparateTile = function (i, body, tile, tileWorldRect, tilemapLayer, tileBia
 
         if (faceHorizontal)
         {
-            ox = TileCheckX(body, tile, tileLeft, tileRight, tileBias);
+            ox = TileCheckX(body, tile, tileLeft, tileRight, tileBias, isLayer);
         }
     }
 

src/physics/arcade/tilemap/TileCheckX.js

@@ -18,17 +18,31 @@ var ProcessTileSeparationX = require('./ProcessTileSeparationX');
  * @param {number} tileLeft - The left position of the tile within the tile world.
  * @param {number} tileRight - The right position of the tile within the tile world.
  * @param {number} tileBias - The tile bias value. Populated by the `World.TILE_BIAS` constant.
+ * @param {boolean} isLayer - Is this check coming from a TilemapLayer or an array of tiles?
  *
  * @return {number} The amount of separation that occurred.
  */
-var TileCheckX = function (body, tile, tileLeft, tileRight, tileBias)
+var TileCheckX = function (body, tile, tileLeft, tileRight, tileBias, isLayer)
 {
     var ox = 0;
 
-    if (body.deltaX() < 0 && !body.blocked.left && tile.collideRight && body.checkCollision.left)
+    var faceLeft = tile.faceLeft;
+    var faceRight = tile.faceRight;
+    var collideLeft = tile.collideLeft;
+    var collideRight = tile.collideRight;
+
+    if (!isLayer)
+    {
+        faceLeft = true;
+        faceRight = true;
+        collideLeft = true;
+        collideRight = true;
+    }
+
+    if (body.deltaX() < 0 && !body.blocked.left && collideRight && body.checkCollision.left)
     {
         //  Body is moving LEFT
-        if (tile.faceRight && body.x < tileRight)
+        if (faceRight && body.x < tileRight)
         {
             ox = body.x - tileRight;
 
@@ -38,10 +52,10 @@ var TileCheckX = function (body, tile, tileLeft, tileRight, tileBias)
             }
         }
     }
-    else if (body.deltaX() > 0 && !body.blocked.right && tile.collideLeft && body.checkCollision.right)
+    else if (body.deltaX() > 0 && !body.blocked.right && collideLeft && body.checkCollision.right)
     {
         //  Body is moving RIGHT
-        if (tile.faceLeft && body.right > tileLeft)
+        if (faceLeft && body.right > tileLeft)
         {
             ox = body.right - tileLeft;
 

src/physics/arcade/tilemap/TileCheckY.js

@@ -18,17 +18,31 @@ var ProcessTileSeparationY = require('./ProcessTileSeparationY');
  * @param {number} tileTop - The top position of the tile within the tile world.
  * @param {number} tileBottom - The bottom position of the tile within the tile world.
  * @param {number} tileBias - The tile bias value. Populated by the `World.TILE_BIAS` constant.
+ * @param {boolean} isLayer - Is this check coming from a TilemapLayer or an array of tiles?
  *
  * @return {number} The amount of separation that occurred.
  */
-var TileCheckY = function (body, tile, tileTop, tileBottom, tileBias)
+var TileCheckY = function (body, tile, tileTop, tileBottom, tileBias, isLayer)
 {
     var oy = 0;
 
-    if (body.deltaY() < 0 && !body.blocked.up && tile.collideDown && body.checkCollision.up)
+    var faceTop = tile.faceTop;
+    var faceBottom = tile.faceBottom;
+    var collideUp = tile.collideUp;
+    var collideDown = tile.collideDown;
+
+    if (!isLayer)
+    {
+        faceTop = true;
+        faceBottom = true;
+        collideUp = true;
+        collideDown = true;
+    }
+
+    if (body.deltaY() < 0 && !body.blocked.up && collideDown && body.checkCollision.up)
     {
         //  Body is moving UP
-        if (tile.faceBottom && body.y < tileBottom)
+        if (faceBottom && body.y < tileBottom)
         {
             oy = body.y - tileBottom;
 
@@ -38,10 +52,10 @@ var TileCheckY = function (body, tile, tileTop, tileBottom, tileBias)
             }
         }
     }
-    else if (body.deltaY() > 0 && !body.blocked.down && tile.collideUp && body.checkCollision.down)
+    else if (body.deltaY() > 0 && !body.blocked.down && collideUp && body.checkCollision.down)
     {
         //  Body is moving DOWN
-        if (tile.faceTop && body.bottom > tileTop)
+        if (faceTop && body.bottom > tileTop)
         {
             oy = body.bottom - tileTop;