Tilemap & layer methods: FilterTiles & CreateFromTiles

Author: mikewesthad

v3/src/gameobjects/tilemap/Tilemap.js

@@ -200,6 +200,13 @@ var Tilemap = new Class({
         return this;
     },
 
+    createFromTiles: function (indexes, replacements, spriteConfig, scene, camera, layer)
+    {
+        layer = this.getLayer(layer);
+        if (layer === null) { return null; }
+        return TilemapComponents.CreateFromTiles(indexes, replacements, spriteConfig, scene, camera, layer);
+    },
+
     destroy: function ()
     {
         this.layers.length = 0;
@@ -220,6 +227,13 @@ var Tilemap = new Class({
         return this;
     },
 
+    filterTiles: function (callback, context, tileX, tileY, width, height, filteringOptions, layer)
+    {
+        layer = this.getLayer(layer);
+        if (layer === null) { return null; }
+        return TilemapComponents.FilterTiles(callback, context, tileX, tileY, width, height, filteringOptions, layer);
+    },
+
     findByIndex: function (findIndex, skip, reverse, layer)
     {
         layer = this.getLayer(layer);

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

@@ -0,0 +1,71 @@
+var TileToWorldX = require('./TileToWorldX');
+var TileToWorldY = require('./TileToWorldY');
+var GetTilesWithin = require('./GetTilesWithin');
+var ReplaceByIndex = require('./ReplaceByIndex');
+
+/**
+ * Creates a Sprite for every object matching the given tile indexes in the layer. You can
+ * optionally specify if each tile will be replaced with a new tile after the Sprite has been
+ * created. This is useful if you want to lay down special tiles in a level that are converted to
+ * Sprites, but want to replace the tile itself with a floor tile or similar once converted.
+ *
+ * @param {number|array} indexes - The tile index, or array of indexes, to create Sprites from.
+ * @param {number|array} replacements - The tile index, or array of indexes, to change a converted
+ * tile to. Set to `null` to leave the tiles unchanged. If an array is given, it is assumed to be a
+ * one-to-one mapping with the indexes array.
+ * @param {object} spriteConfig - The config object to pass into the Sprite creator (i.e.
+ * scene.make.sprite).
+ * @param {Scene} [scene=scene the map is within] - The Scene to create the Sprites within.
+ * @param {Camera} [camera=main camera] - The Camera to use when determining the world XY
+ * @param {LayerData} layer - [description]
+ * @return {array} An array of the Sprites that were created.
+ */
+var CreateFromTiles = function (indexes, replacements, spriteConfig, scene, camera, layer)
+{
+    if (spriteConfig === undefined) { spriteConfig = {}; }
+
+    if (!Array.isArray(indexes)) { indexes = [ indexes ]; }
+
+    var tilemapLayer = layer.tilemapLayer;
+    if (scene === undefined) { scene = tilemapLayer.scene; }
+    if (camera === undefined) { camera = scene.cameras.main; }
+
+    var tiles = GetTilesWithin(0, 0, layer.width, layer.height, null, layer);
+    var sprites = [];
+    var i;
+
+    for (i = 0; i < tiles.length; i++)
+    {
+        var tile = tiles[i];
+
+        if (indexes.indexOf(tile.index) !== -1)
+        {
+            spriteConfig.x = TileToWorldX(tile.x, camera, layer);
+            spriteConfig.y = TileToWorldY(tile.y, camera, layer);
+
+            var sprite = scene.make.sprite(spriteConfig);
+            sprites.push(sprite);
+        }
+    }
+
+    if (typeof replacements === 'number')
+    {
+        //  Assume 1 replacement for all types of tile given
+        for (i = 0; i < indexes.length; i++)
+        {
+            ReplaceByIndex(indexes[i], replacements, 0, 0, layer.width, layer.height, layer);
+        }
+    }
+    else if (Array.isArray(replacements))
+    {
+        //  Assume 1 to 1 mapping with indexes array
+        for (i = 0; i < indexes.length; i++)
+        {
+            ReplaceByIndex(indexes[i], replacements[i], 0, 0, layer.width, layer.height, layer);
+        }
+    }
+
+    return sprites;
+};
+
+module.exports = CreateFromTiles;

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

@@ -0,0 +1,33 @@
+var GetTilesWithin = require('./GetTilesWithin');
+
+/**
+ * For each tile in the given rectangular area (in tile coordinates) of the layer, run the given
+ * filter callback function. Any tiles that pass the filter test (i.e. where the callback returns
+ * true) will returned as a new array. Similar to Array.prototype.Filter in vanilla JS.
+ *
+ * @param {number} callback - The callback. Each tile in the given area will be passed to this
+ * callback as the first and only parameter. The callback should return true for tiles that pass the
+ * filter.
+ * @param {number} [context] - The context under which the callback should be run.
+ * @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 {object} [filteringOptions] - Optional filters to apply when getting the tiles.
+ * @param {boolean} [filteringOptions.isNotEmpty=false] - If true, only return tiles that don't have
+ * -1 for an index.
+ * @param {boolean} [filteringOptions.isColliding=false] - If true, only return tiles that collide
+ * on at least one side.
+ * @param {boolean} [filteringOptions.hasInterestingFace=false] - If true, only return tiles that
+ * have at least one interesting face.
+ * @param {LayerData} layer - [description]
+ * @returns {array} The filtered array of Tiles.
+ */
+var FilterTiles = function (callback, context, tileX, tileY, width, height, filteringOptions, layer)
+{
+    var tiles = GetTilesWithin(tileX, tileY, width, height, filteringOptions, layer);
+    return tiles.filter(callback, context);
+};
+
+module.exports = FilterTiles;
+

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

@@ -1,9 +1,11 @@
 module.exports = {
 
     Copy: require('./Copy'),
+    CreateFromTiles: require('./CreateFromTiles'),
     CullTiles: require('./CullTiles'),
     Fill: require('./Fill'),
     FindByIndex: require('./FindByIndex'),
+    FilterTiles: require('./FilterTiles'),
     ForEachTile: require('./ForEachTile'),
     GetTileAt: require('./GetTileAt'),
     GetTileAtWorldXY: require('./GetTileAtWorldXY'),

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

@@ -55,6 +55,11 @@ var DynamicTilemapLayer = new Class({
         return this;
     },
 
+    createFromTiles: function (indexes, replacements, spriteConfig, scene, camera)
+    {
+        return TilemapComponents.CreateFromTiles(indexes, replacements, spriteConfig, scene, camera, this.layer);
+    },
+
     cull: function (camera)
     {
         TilemapComponents.CullTiles(this.layer, camera, this.culledTiles);
@@ -82,6 +87,11 @@ var DynamicTilemapLayer = new Class({
         return this;
     },
 
+    filterTiles: function (callback, context, tileX, tileY, width, height, filteringOptions)
+    {
+        return TilemapComponents.FilterTiles(callback, context, tileX, tileY, width, height, filteringOptions, this.layer);
+    },
+
     findByIndex: function (findIndex, skip, reverse)
     {
         return TilemapComponents.FindByIndex(findIndex, skip, reverse, this.layer);

v3/src/gameobjects/tilemap/staticlayer/StaticTilemapLayer.js

@@ -209,6 +209,11 @@ var StaticTilemapLayer = new Class({
         return this;
     },
 
+    createFromTiles: function (indexes, replacements, spriteConfig, scene, camera)
+    {
+        return TilemapComponents.CreateFromTiles(indexes, replacements, spriteConfig, scene, camera, this.layer);
+    },
+
     cull: function (camera)
     {
         TilemapComponents.CullTiles(this.layer, camera, this.culledTiles);
@@ -228,6 +233,11 @@ var StaticTilemapLayer = new Class({
         return TilemapComponents.FindByIndex(findIndex, skip, reverse, this.layer);
     },
 
+    filterTiles: function (callback, context, tileX, tileY, width, height, filteringOptions)
+    {
+        return TilemapComponents.FilterTiles(callback, context, tileX, tileY, width, height, filteringOptions, this.layer);
+    },
+
     forEachTile: function (callback, context, tileX, tileY, width, height, filteringOptions)
     {
         TilemapComponents.ForEachTile(callback, context, tileX, tileY, width, height, filteringOptions, this.layer);