Moving all the getTiles calls back again, as it's just a bit TOO API breaking to move them, for the sake of a few KB.

Author: photonstorm

README.md

@@ -326,14 +326,6 @@ You can read all about the philosophy behind Lazer [here](http://phaser.io/news/
 * The Loader.headers object has a new property `requestedWith`. By default this is set to `false`, but it can be used to set the `X-Requested-With` header to `XMLHttpRequest` (or any other value you need). To enable this do `this.load.headers.requestedWith = 'XMLHttpRequest'` before adding anything to the Loader.
 * ScaleManager.hasPhaserSetFullScreen is a new boolean that identifies if the browser is in full screen mode or not, and if Phaser was the one that requested it. As it's possible to enter full screen mode outside of Phaser, and it then gets confused about what bounding parent to use.
 * Phaser.Tileset has a new property `lastgid` which is populated automatically by the TilemapParser when importing Tiled map data, or can be set manually if building your own tileset.
-* TilemapLayer.rayStepRate has been moved to Tilemap.rayStepRate.
-* TilemapLayer.getRayCastTiles has been moved to Tilemap.getRayCastTiles.
-* TilemapLayer.getTiles has been moved to Tilemap.getTiles.
-* The private methods `TilemapLayer._fixX`, `_unfixX`, `_fixY` and `_unfixY` have been moved to the Tilemap class.
-* TilemapLayer.getTileX, getTileY and getTileXY have been moved to the Tilemap class.
-* TilemapLayer.getTileX, getTileY and getTileXY all now required a Phaser.TilemapLayer (or Phaser.TilemapLayerGL) as the first argument.
-* Tilemap.getRayCastTiles now requires a Phaser.TilemapLayer (or Phaser.TilemapLayerGL) as the first argument.
-* Tilemap.getTiles now requires a Phaser.TilemapLayer (or Phaser.TilemapLayerGL) as the first argument.
 
 ### Bug Fixes
 

src/tilemap/Tilemap.js

@@ -151,13 +151,6 @@ Phaser.Tilemap = function (game, key, tileWidth, tileHeight, width, height) {
     */
     this.debugMap = [];
 
-    /**
-    * When ray-casting against tiles this is the number of steps it will jump. For larger tile sizes you can increase this to improve performance.
-    * @property {integer} rayStepRate
-    * @default
-    */
-    this.rayStepRate = 4;
-
     /**
     * @property {array} _results - Internal var.
     * @private
@@ -1988,256 +1981,6 @@ Phaser.Tilemap.prototype = {
 
     },
 
-    /**
-    * Gets all tiles from `Tilemap.layer` that intersect with the given Phaser.Line object.
-    *
-    * If you need to get the tiles from a different layer, then set the `layer` property first.
-    *
-    * @method Phaser.Tilemap#getRayCastTiles
-    * @param {Phaser.TilemapLayer|Phaser.TilemapLayerGL} layer - The Tilemap Layer to check.
-    * @param {Phaser.Line} line - The line used to determine which tiles to return.
-    * @param {integer} [stepRate=(rayStepRate)] - How many steps through the ray will we check? Defaults to `rayStepRate`.
-    * @param {boolean} [collides=false] - If true, _only_ return tiles that collide on one or more faces.
-    * @param {boolean} [interestingFace=false] - If true, _only_ return tiles that have interesting faces.
-    * @return {Phaser.Tile[]} An array of Phaser.Tiles.
-    */
-    getRayCastTiles: function (layer, line, stepRate, collides, interestingFace) {
-
-        if (!stepRate) { stepRate = this.rayStepRate; }
-        if (collides === undefined) { collides = false; }
-        if (interestingFace === undefined) { interestingFace = false; }
-
-        //  First get all tiles that touch the bounds of the line
-        var tiles = this.getTiles(layer, line.x, line.y, line.width, line.height, collides, interestingFace);
-
-        if (tiles.length === 0)
-        {
-            return [];
-        }
-
-        //  Now we only want the tiles that intersect with the points on this line
-        var coords = line.coordinatesOnLine(stepRate);
-        var results = [];
-
-        for (var i = 0; i < tiles.length; i++)
-        {
-            for (var t = 0; t < coords.length; t++)
-            {
-                var tile = tiles[i];
-                var coord = coords[t];
-
-                if (tile.containsPoint(coord[0], coord[1]))
-                {
-                    results.push(tile);
-                    break;
-                }
-            }
-        }
-
-        return results;
-
-    },
-
-    /**
-    * Get all Tiles that exist on the current `Tilemap.layer`, within the given area, 
-    * as defined by the top-left corner, width and height arguments.
-    * 
-    * Values given are in pixels, not tiles.
-    *
-    * If you need to get the tiles from a different layer, then set the `layer` property first.
-    *
-    * @method Phaser.Tilemap#getTiles
-    * @param {Phaser.TilemapLayer|Phaser.TilemapLayerGL} layer - The Tilemap Layer to check.
-    * @param {number} x - X position of the top left corner (in pixels).
-    * @param {number} y - Y position of the top left corner (in pixels).
-    * @param {number} width - Width of the area to get (in pixels).
-    * @param {number} height - Height of the area to get (in pixels).
-    * @param {boolean} [collides=false] - If true, _only_ return tiles that collide on one or more faces.
-    * @param {boolean} [interestingFace=false] - If true, _only_ return tiles that have interesting faces.
-    * @return {array<Phaser.Tile>} An array of Tiles.
-    */
-    getTiles: function (layer, x, y, width, height, collides, interestingFace) {
-
-        //  Should we only get tiles that have at least one of their collision flags set? (true = yes, false = no just get them all)
-
-        if (collides === undefined) { collides = false; }
-        if (interestingFace === undefined) { interestingFace = false; }
-
-        var fetchAll = !(collides || interestingFace);
-
-        //  Adjust the x,y coordinates for scrollFactor
-        x = this._fixX(layer, x);
-        y = this._fixY(layer, y);
-
-        //  Convert the pixel values into tile coordinates
-        var tx = Math.floor(x / (layer._mc.cw * layer.scale.x));
-        var ty = Math.floor(y / (layer._mc.ch * layer.scale.y));
-
-        //  Don't just use ceil(width/cw) to allow account for x/y diff within cell
-        var tw = Math.ceil((x + width) / (layer._mc.cw * layer.scale.x)) - tx;
-        var th = Math.ceil((y + height) / (layer._mc.ch * layer.scale.y)) - ty;
-
-        this._results.length = 0;
-
-        for (var wy = ty; wy < ty + th; wy++)
-        {
-            for (var wx = tx; wx < tx + tw; wx++)
-            {
-                var row = layer.layer.data[wy];
-
-                if (row && row[wx])
-                {
-                    if (fetchAll || row[wx].isInteresting(collides, interestingFace))
-                    {
-                        this._results.push(row[wx]);
-                    }
-                }
-            }
-        }
-
-        return this._results.slice();
-
-    },
-
-    /**
-    * Take an x coordinate that doesn't account for scrollFactorX and 'fix' it into a scrolled local space.
-    *
-    * @method Phaser.Tilemap#_fixX
-    * @private
-    * @param {Phaser.TilemapLayer|Phaser.TilemapLayerGL} layer - The Tilemap Layer to check.
-    * @param {number} x - x coordinate in camera space
-    * @return {number} x coordinate in scrollFactor-adjusted dimensions
-    */
-    _fixX: function (layer, x) {
-
-        if (layer.scrollFactorX === 1 || (layer.scrollFactorX === 0 && layer.position.x === 0))
-        {
-            return x;
-        }
-        
-        //  This executes if the scrollFactorX is 0 and the x position of the tilemap is off from standard.
-        if (layer.scrollFactorX === 0 && layer.position.x !== 0)
-        {
-            return x - layer.position.x;
-        }
-
-        return layer._scrollX + (x - (layer._scrollX / layer.scrollFactorX));
-
-    },
-
-    /**
-    * Take an x coordinate that _does_ account for scrollFactorX and 'unfix' it back to camera space.
-    *
-    * @method Phaser.Tilemap#_unfixX
-    * @private
-    * @param {Phaser.TilemapLayer|Phaser.TilemapLayerGL} layer - The Tilemap Layer to check.
-    * @param {number} x - x coordinate in scrollFactor-adjusted dimensions
-    * @return {number} x coordinate in camera space
-    */
-    _unfixX: function (layer, x) {
-
-        if (layer.scrollFactorX === 1)
-        {
-            return x;
-        }
-
-        return (layer._scrollX / layer.scrollFactorX) + (x - layer._scrollX);
-
-    },
-
-    /**
-    * Take a y coordinate that doesn't account for scrollFactorY and 'fix' it into a scrolled local space.
-    *
-    * @method Phaser.Tilemap#_fixY
-    * @private
-    * @param {Phaser.TilemapLayer|Phaser.TilemapLayerGL} layer - The Tilemap Layer to check.
-    * @param {number} y - y coordinate in camera space
-    * @return {number} y coordinate in scrollFactor-adjusted dimensions
-    */
-    _fixY: function (layer, y) {
-
-        if (layer.scrollFactorY === 1 || (layer.scrollFactorY === 0 && layer.position.y === 0))
-        {
-            return y;
-        }
-        
-        //  This executes if the scrollFactorY is 0 and the y position of the tilemap is off from standard.
-        if (layer.scrollFactorY === 0 && layer.position.y !== 0)
-        {
-            return y - layer.position.y;
-        }
-        
-        return layer._scrollY + (y - (layer._scrollY / layer.scrollFactorY));
-
-    },
-
-    /**
-    * Take a y coordinate that _does_ account for scrollFactorY and 'unfix' it back to camera space.
-    *
-    * @method Phaser.Tilemap#_unfixY
-    * @private
-    * @param {Phaser.TilemapLayer|Phaser.TilemapLayerGL} layer - The Tilemap Layer to check.
-    * @param {number} y - y coordinate in scrollFactor-adjusted dimensions
-    * @return {number} y coordinate in camera space
-    */
-    _unfixY: function (layer, y) {
-
-        if (layer.scrollFactorY === 1)
-        {
-            return y;
-        }
-
-        return (layer._scrollY / layer.scrollFactorY) + (y - layer._scrollY);
-
-    },
-
-    /**
-    * Convert a pixel value to a tile coordinate.
-    *
-    * @method Phaser.Tilemap#getTileX
-    * @param {Phaser.TilemapLayer|Phaser.TilemapLayerGL} layer - The Tilemap Layer to check.
-    * @param {number} x - X position of the point in target tile (in pixels).
-    * @return {integer} The X map location of the tile.
-    */
-    getTileX: function (layer, x) {
-
-        return Math.floor(this._fixX(layer, x) / layer._mc.tileWidth);
-
-    },
-
-    /**
-    * Convert a pixel value to a tile coordinate.
-    *
-    * @method Phaser.Tilemap#getTileY
-    * @param {Phaser.TilemapLayer|Phaser.TilemapLayerGL} layer - The Tilemap Layer to check.
-    * @param {number} y - Y position of the point in target tile (in pixels).
-    * @return {integer} The Y map location of the tile.
-    */
-    getTileY: function (layer, y) {
-
-        return Math.floor(this._fixY(layer, y) / layer._mc.tileHeight);
-
-    },
-
-    /**
-    * Convert a pixel coordinate to a tile coordinate.
-    *
-    * @method Phaser.Tilemap#getTileXY
-    * @param {Phaser.TilemapLayer|Phaser.TilemapLayerGL} layer - The Tilemap Layer to check.
-    * @param {number} x - X position of the point in target tile (in pixels).
-    * @param {number} y - Y position of the point in target tile (in pixels).
-    * @param {(Phaser.Point|object)} point - The Point/object to update.
-    * @return {(Phaser.Point|object)} A Point/object with its `x` and `y` properties set.
-    */
-    getTileXY: function (layer, x, y, point) {
-
-        point.x = this.getTileX(layer, x);
-        point.y = this.getTileY(layer, y);
-
-        return point;
-
-    },
-
     /**
     * Removes all layer data from this tile map and nulls the game reference.
     * Note: You are responsible for destroying any TilemapLayer objects you generated yourself, as Tilemap doesn't keep a reference to them.