Tilemap & layers: optimized SetCollision methods

v2 was structured in a way where a full pass through ALL tiles would occur if SetCollisionBetween or SetCollisionByExclusion was used. That's a huge penalty for large tilemaps, so this version duplicates some loop code for the sake of speed.

Author: mikewesthad

v3/src/gameobjects/tilemap/Tilemap.js

@@ -361,6 +361,14 @@ var Tilemap = new Class({
         return this;
     },
 
+    recalculateFaces: function (layer)
+    {
+        layer = this.getLayer(layer);
+        if (layer === null) { return this; }
+        TilemapComponents.RecalculateFaces(layer);
+        return this;
+    },
+
     removeAllLayers: function ()
     {
         this.layers.length = 0;
@@ -395,6 +403,30 @@ var Tilemap = new Class({
         return this;
     },
 
+    setCollision: function (indexes, collides, recalculateFaces, layer)
+    {
+        layer = this.getLayer(layer);
+        if (layer === null) { return this; }
+        TilemapComponents.SetCollision(indexes, collides, recalculateFaces, layer);
+        return this;
+    },
+
+    setCollisionBetween: function (start, stop, collides, recalculateFaces, layer)
+    {
+        layer = this.getLayer(layer);
+        if (layer === null) { return this; }
+        TilemapComponents.SetCollisionBetween(start, stop, collides, recalculateFaces, layer);
+        return this;
+    },
+
+    setCollisionByExclusion: function (indexes, collides, recalculateFaces, layer)
+    {
+        layer = this.getLayer(layer);
+        if (layer === null) { return this; }
+        TilemapComponents.SetCollisionByExclusion(indexes, collides, recalculateFaces, layer);
+        return this;
+    },
+
     setLayer: function (layer)
     {
         var index = this.getLayerIndex(layer);

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

@@ -31,7 +31,7 @@ var PutTileAt = function (tile, tileX, tileY, layer)
         }
     }
 
-    // TODO: re-calculate faces
+    // TODO: collision & re-calculate faces
 
     return layer.data[tileY][tileX];
 };

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

@@ -0,0 +1,6 @@
+var RecalculateFaces = function (layer)
+{
+    return;
+};
+
+module.exports = RecalculateFaces;

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

@@ -0,0 +1,26 @@
+var SetTileCollision = require('./SetTileCollision');
+var RecalculateFaces = require('./RecalculateFaces');
+
+var SetCollision = function (indexes, collides, recalculateFaces, layer)
+{
+    if (collides === undefined) { collides = true; }
+    if (recalculateFaces === undefined) { recalculateFaces = true; }
+    if (!Array.isArray(indexes)) { indexes = [ indexes ]; }
+
+    for (var ty = 0; ty < layer.height; ty++)
+    {
+        for (var tx = 0; tx < layer.width; tx++)
+        {
+            var tile = layer.data[ty][tx];
+
+            if (tile && indexes.indexOf(tile.index) !== -1)
+            {
+                SetTileCollision(tile, collides);
+            }
+        }
+    }
+
+    if (recalculateFaces) { RecalculateFaces(layer); }
+};
+
+module.exports = SetCollision;

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

@@ -0,0 +1,29 @@
+var SetTileCollision = require('./SetTileCollision');
+var RecalculateFaces = require('./RecalculateFaces');
+
+var SetCollisionBetween = function (start, stop, collides, recalculateFaces, layer)
+{
+    if (collides === undefined) { collides = true; }
+    if (recalculateFaces === undefined) { recalculateFaces = true; }
+
+    if (start > stop) { return; }
+
+    for (var ty = 0; ty < layer.height; ty++)
+    {
+        for (var tx = 0; tx < layer.width; tx++)
+        {
+            var tile = layer.data[ty][tx];
+            if (tile)
+            {
+                if (tile.index >= start && tile.index <= stop)
+                {
+                    SetTileCollision(tile, collides);
+                }
+            }
+        }
+    }
+
+    if (recalculateFaces) { RecalculateFaces(layer); }
+};
+
+module.exports = SetCollisionBetween;

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

@@ -0,0 +1,25 @@
+var SetTileCollision = require('./SetTileCollision');
+var RecalculateFaces = require('./RecalculateFaces');
+
+var SetCollisionByExclusion = function (indexes, collides, recalculateFaces, layer)
+{
+    if (collides === undefined) { collides = true; }
+    if (recalculateFaces === undefined) { recalculateFaces = true; }
+    if (!Array.isArray(indexes)) { indexes = [ indexes ]; }
+
+    for (var ty = 0; ty < layer.height; ty++)
+    {
+        for (var tx = 0; tx < layer.width; tx++)
+        {
+            var tile = layer.data[ty][tx];
+            if (tile && indexes.indexOf(tile.index) === -1)
+            {
+                SetTileCollision(tile, collides);
+            }
+        }
+    }
+
+    if (recalculateFaces) { RecalculateFaces(layer); }
+};
+
+module.exports = SetCollisionByExclusion;

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

@@ -0,0 +1,13 @@
+var SetTileCollision = function (tile, collides)
+{
+    if (collides)
+    {
+        tile.setCollision(true, true, true, true);
+    }
+    else
+    {
+        tile.resetCollision();
+    }
+};
+
+module.exports = SetTileCollision;

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

@@ -14,9 +14,13 @@ module.exports = {
     PutTileAt: require('./PutTileAt'),
     PutTileAtWorldXY: require('./PutTileAtWorldXY'),
     Randomize: require('./Randomize'),
+    RecalculateFaces: require('./RecalculateFaces'),
     RemoveTileAt: require('./RemoveTileAt'),
     RemoveTileAtWorldXY: require('./RemoveTileAtWorldXY'),
     ReplaceByIndex: require('./ReplaceByIndex'),
+    SetCollision: require('./SetCollision'),
+    SetCollisionBetween: require('./SetCollisionBetween'),
+    SetCollisionByExclusion: require('./SetCollisionByExclusion'),
     Shuffle: require('./Shuffle'),
     SwapByIndex: require('./SwapByIndex'),
     WorldToTileX: require('./WorldToTileX'),

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

@@ -128,6 +128,12 @@ var DynamicTilemapLayer = new Class({
         return this;
     },
 
+    recalculateFaces: function ()
+    {
+        TilemapComponents.RecalculateFaces(this.layer);
+        return this;
+    },
+
     removeTileAt: function (tileX, tileY, replaceWithNull)
     {
         return TilemapComponents.RemoveTileAt(tileX, tileY, replaceWithNull, this.layer);
@@ -144,6 +150,24 @@ var DynamicTilemapLayer = new Class({
         return this;
     },
 
+    setCollision: function (indexes, collides, recalculateFaces)
+    {
+        TilemapComponents.SetCollision(indexes, collides, recalculateFaces, this.layer);
+        return this;
+    },
+
+    setCollisionBetween: function (start, stop, collides, recalculateFaces)
+    {
+        TilemapComponents.SetCollisionBetween(start, stop, collides, recalculateFaces, this.layer);
+        return this;
+    },
+
+    setCollisionByExclusion: function (indexes, collides, recalculateFaces)
+    {
+        TilemapComponents.SetCollisionByExclusion(indexes, collides, recalculateFaces, this.layer);
+        return this;
+    },
+
     shuffle: function (tileX, tileY, width, height)
     {
         TilemapComponents.Shuffle(tileX, tileY, width, height, this.layer);

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

@@ -253,6 +253,30 @@ var StaticTilemapLayer = new Class({
         return TilemapComponents.HasTileAtWorldXY(worldX, worldY, camera, this.layer);
     },
 
+    recalculateFaces: function ()
+    {
+        TilemapComponents.RecalculateFaces(this.layer);
+        return this;
+    },
+
+    setCollision: function (indexes, collides, recalculateFaces)
+    {
+        TilemapComponents.SetCollision(indexes, collides, recalculateFaces, this.layer);
+        return this;
+    },
+
+    setCollisionBetween: function (start, stop, collides, recalculateFaces)
+    {
+        TilemapComponents.SetCollisionBetween(start, stop, collides, recalculateFaces, this.layer);
+        return this;
+    },
+
+    setCollisionByExclusion: function (indexes, collides, recalculateFaces)
+    {
+        TilemapComponents.SetCollisionByExclusion(indexes, collides, recalculateFaces, this.layer);
+        return this;
+    },
+
     worldToTileX: function (worldX, camera)
     {
         return TilemapComponents.WorldToTileX(worldX, camera, this.layer);