Merge branch 'master' of https://github.com/photonstorm/phaser

Author: photonstorm

v3/src/gameobjects/tilemap/Tilemap.js

@@ -209,13 +209,13 @@ var Tilemap = new Class({
         this.scene = undefined;
     },
 
-    fill: function (index, tileX, tileY, width, height, layer)
+    fill: function (index, tileX, tileY, width, height, recalculateFaces, layer)
     {
         layer = this.getLayer(layer);
         if (this._isStaticCall(layer, 'fill')) { return this; }
         if (layer !== null)
         {
-            TilemapComponents.Fill(index, tileX, tileY, width, height, layer);
+            TilemapComponents.Fill(index, tileX, tileY, width, height, recalculateFaces, layer);
         }
         return this;
     },

v3/src/gameobjects/tilemap/components/CalculateFacesWithin.js

@@ -1,6 +1,17 @@
 var GetTileAt = require('./GetTileAt');
 var GetTilesWithin = require('./GetTilesWithin');
 
+/**
+ * Calculates interesting faces within the rectangular area specified (in tile coordinates).
+ * Interesting faces are used internally for optimizing collisions against tiles. This method is
+ * mostly used internally.
+ *
+ * @param {number} [tileX=0] - [description]
+ * @param {number} [tileY=0] - [description]
+ * @param {number} [width=max width based on tileX] - [description]
+ * @param {number} [height=max height based on tileY] - [description]
+ * @param {LayerData} layer - [description]
+ */
 var CalculateFacesWithin = function (tileX, tileY, width, height, layer)
 {
     var above = null;

v3/src/gameobjects/tilemap/components/Copy.js

@@ -1,7 +1,22 @@
 var GetTilesWithin = require('./GetTilesWithin');
 var CalculateFacesWithin = require('./CalculateFacesWithin');
 
-// Copies indices, not other properties. Does not modify collisions.
+/**
+ * Copies the tiles in the source rectangular area to a new destination (all specified in tile
+ * coordinates). This copies all tile properties & recalculates interesting tile faces in the
+ * destination region.
+ *
+ * @param {number} srcTileX - [description]
+ * @param {number} srcTileY - [description]
+ * @param {number} width - [description]
+ * @param {number} height - [description]
+ * @param {number} destTileX - [description]
+ * @param {number} destTileY - [description]
+ * @param {number} destTileY - [description]
+ * @param {boolean} [recalculateFaces=true] - [description]
+ * @param {LayerData} layer - [description]
+ */
+
 var Copy = function (srcTileX, srcTileY, width, height, destTileX, destTileY, recalculateFaces, layer)
 {
     if (srcTileX < 0) { srcTileX = 0; }

v3/src/gameobjects/tilemap/components/CullTiles.js

@@ -1,3 +1,12 @@
+/**
+ * Returns the tiles in the given layer that are within the camera's viewport. This is used
+ * internally.
+ *
+ * @param {LayerData} layer - [description]
+ * @param {Camera} camera - [description]
+ * @param {array} [outputArray] - [description]
+ * @returns {array}
+ */
 var CullTiles = function (layer, camera, outputArray)
 {
     if (outputArray === undefined) { outputArray = []; }

v3/src/gameobjects/tilemap/components/Fill.js

@@ -1,12 +1,46 @@
 var GetTilesWithin = require('./GetTilesWithin');
+var CalculateFacesWithin = require('./CalculateFacesWithin');
+
+/**
+ * Sets the tiles in the given rectangular area (in tile coordinates) with the specified index.
+ * Tiles will be set to collide if the given index is a colliding index. Interesting tile faces in
+ * the region will be recalculated.
+ *
+ * @param {number} index - [description]
+ * @param {number} tileX - [description]
+ * @param {number} tileY - [description]
+ * @param {number} width - [description]
+ * @param {number} height - [description]
+ * @param {boolean} [recalculateFaces=true] - [description]
+ * @param {LayerData} layer - [description]
+ */
 
 // Fills indices, not other properties. Does not modify collisions. Matches v2 functionality.
-var Fill = function (index, tileX, tileY, width, height, layer)
+var Fill = function (index, tileX, tileY, width, height, recalculateFaces, layer)
 {
+    if (recalculateFaces === undefined) { recalculateFaces = true; }
+
+    var doesIndexCollide = (layer.collideIndexes.indexOf(index) !== -1);
+
     var tiles = GetTilesWithin(tileX, tileY, width, height, null, layer);
     for (var i = 0; i < tiles.length; i++)
     {
         tiles[i].index = index;
+
+        if (doesIndexCollide)
+        {
+            tiles[i].setCollision(true);
+        }
+        else
+        {
+            tiles[i].resetCollision();
+        }
+    }
+
+    if (recalculateFaces)
+    {
+        // Recalculate the faces within the area and neighboring tiles
+        CalculateFacesWithin(tileX - 1, tileY - 1, width + 2, height + 2, layer);
     }
 };
 

v3/src/gameobjects/tilemap/components/GetTilesWithinShape.js

@@ -14,8 +14,8 @@ var TriangleToRectangle = function (triangle, rect)
 };
 
 // Circle, Line, Rect, Triangle in world coordinates.
-// Notes: circle is not working yet - see CircleToRectangle in geom. Could possibly be optimized
-// by copying the shape and shifting it into tilemapLayer coordinates instead of shifting the tiles.
+// Note: Could possibly be optimized by copying the shape and shifting it into tilemapLayer
+// coordinates instead of shifting the tiles.
 var GetTilesWithinShape = function (shape, filteringOptions, camera, layer)
 {
     if (shape === undefined) { return []; }

v3/src/gameobjects/tilemap/dynamiclayer/DynamicTilemapLayer.js

@@ -76,9 +76,9 @@ var DynamicTilemapLayer = new Class({
         GameObject.prototype.destroy.call(this);
     },
 
-    fill: function (index, tileX, tileY, width, height)
+    fill: function (index, tileX, tileY, width, height, recalculateFaces)
     {
-        TilemapComponents.Fill(index, tileX, tileY, width, height, this.layer);
+        TilemapComponents.Fill(index, tileX, tileY, width, height, recalculateFaces, this.layer);
         return this;
     },