Lots of documentation updates and new Loader examples.

README.md

@@ -44,10 +44,12 @@ Version 1.1.3 - in build
 * New: Added a .jshintrc so contributions can be run through JSHint to help retain formatting across the library (thanks kevinthompson)
 * New: The entire Phaser library has been updated to match the new JSHint configuration.
 * New: Added a new in-built texture. Sprites now use __default if no texture was provided (a 32x32 transparent PNG) or __missing if one was given but not found (a 32x32 black box with a green cross through it)
-* New: Added Phaser.Filter. A new way to use the new WebGL shaders/filters that the new version of Pixi supports.
+* New: Phaser.Filter. A new way to use the new WebGL shaders/filters that the new version of Pixi supports.
-* New: The object returned by Math.sinCosGenerator now contains a length property.
 * New: Phaser.BitmapData object. A Canvas you can freely draw to with lots of functions. Can be used as a texture for Sprites. See the new examples and docs for details.
 * New: RenderTexture.render now takes a Phaser.Group. Also added renderXY for when you don't want to make a new Point object.
+* New: Physics.overlap now supports Sprites, Groups or Emitters and can perform group vs. group (etc) overlap checks with a custom callback and process handler.
+* New: Added Sound.externalNode which allows you to connect a Sound to an external node input rather than the SoundManager gain node.
+* New: Added SoundManager.connectToMaster boolean. Used in conjunction with Sound.externalNode you can easily configure audio nodes to connect together for special effects.
 * New: PluginManager.remove, added PluginManager.removeAll (thanks crazysam)
 * New: scrollFactorX/scrollFactorY have been added to TilemapLayers (thanks jcd-as)
 * New: Phaser.Game parent can now be an HTMLElement or a string (thanks beeglebug)
@@ -64,8 +66,22 @@ Version 1.1.3 - in build
 * New: Device.littleEndian boolean added. Only safe to use if the browser supports TypedArrays (which IE9 doesn't, but nearly all others do)
 * New: You can now call game.sound.play() and simply pass it a key. The sound will play if the audio system is unlocked and optionally destroy itself on complete.
 * New: Mouse.capture is a boolean. If set to true then DOM mouse events will have event.preventDefault() applied, if false they will propogate fully.
-* New: Added Sound.externalNode which allows you to connect a Sound to an external node input rather than the SoundManager gain node.
+* New: The object returned by Math.sinCosGenerator now contains a length property.
-* New: Added SoundManager.connectToMaster boolean. Used in conjunction with Sound.externalNode you can easily configure audio nodes to connect together for special effects.
+
+* Updated: Lots of documentation fixes and updates across nearly all files. Tilemap now documented for example and lots of instances of 'Description' filled out.
+* Updated: ArcadePhysics.updateMotion applies the dt to the velocity calculations as well as position now (thanks jcs)
+* Updated: RequestAnimationFrame now retains the callbackID which is passed to cancelRequestAnimationFrame.
+* Updated: Button now goes back to over state when setFrames used in action (thanks beeglebug)
+* Updated: plugins now have a postUpdate callback (thanks cocoademon)
+* Updated: Tided up the Graphics object (thanks BorisKozo)
+* Updated: If running in Canvas mode and you have a render function it will save the context and reset the transform before running your render function.
+* Updated: Sprite will now check the exists property of the Group it is in, if the Group.exists = false the Sprite won't update.
+* Updated: If you specify 'null' as a Group parent it will now revert to using the World as the parent (before only 'undefined' worked)
+* Updated: Skip preupdate/update for PIXI hierarchies in which an ancestor doesn't exist (thanks cocoademon)
+* Updated: Loader.audio can now accept either an array of URL strings or a single URL string (thanks crazysam + kevinthompson)
+* Updated: MSPointer updated to support IE11 by dropping the prefix from the event listeners.
+* Updated: Device.cocoonJS added to detect if the game is running under Cocoon or a native browser.
+* Updated: Loader now uses a new queue system internally, meaning you can have assets with the same key spread across different types.
 
 * Fixed: Lots of fixes to the TypeScript definitions file (many thanks gltovar)
 * Fixed: Tilemap commands use specified layer when one given (thanks Izzimach)
@@ -82,20 +98,7 @@ Version 1.1.3 - in build
 * Fixed: Device.isTouch modified to test maxTouchPointers instead of MSPointer.
 * Fixed: InputHandler.checkPointerOver now checks the visible status of the Sprite Group before processing.
 * Fixed: The Sprite hulls (used for tile collision) were not being updated in sprite->sprite separations (thanks jcs)
-
+* Fixed: Plugins that had a postUpdate but no Update weren't being marked as active (thanks crazysam)
-* Updated: ArcadePhysics.updateMotion applies the dt to the velocity calculations as well as position now (thanks jcs)
-* Updated: RequestAnimationFrame now retains the callbackID which is passed to cancelRequestAnimationFrame.
-* Updated: Button now goes back to over state when setFrames used in action (thanks beeglebug)
-* Updated: plugins now have a postUpdate callback (thanks cocoademon)
-* Updated: Tided up the Graphics object (thanks BorisKozo)
-* Updated: If running in Canvas mode and you have a render function it will save the context and reset the transform before running your render function.
-* Updated: Sprite will now check the exists property of the Group it is in, if the Group.exists = false the Sprite won't update.
-* Updated: Lots of documentation fixes and updates across nearly all files.
-* Updated: If you specify 'null' as a Group parent it will now revert to using the World as the parent (before only 'undefined' worked)
-* Updated: Skip preupdate/update for PIXI hierarchies in which an ancestor doesn't exist (thanks cocoademon)
-* Updated: Loader.audio can now accept either an array of URL strings or a single URL string (thanks crazysam + kevinthompson)
-* Updated: MSPointer updated to support IE11 by dropping the prefix from the event listeners.
-* Updated: Device.cocoonJS added to detect if the game is running under Cocoon or a native browser.
 
 You can view the complete Change Log for all previous versions at https://github.com/photonstorm/phaser/changelog.md
 
@@ -211,12 +214,6 @@ The 1.1 release was a massive under-taking, but we're really happy with how Phas
 * Create more touch input examples (http://www.html5gamedevs.com/topic/1556-mobile-touch-event/)
 * Look at HiDPI Canvas settings.
 
-Some specific features / issues we will address soon:
-
-* Loader conflict if 2 keys are the same even if they are in different packages (i.e. you can't use "title" for both and image and sound file).
-* Sound.addMarker hh:mm:ss:ms.
-* Add support for a rotation offset.
-
 Learn By Example
 ----------------
 
@@ -243,10 +240,10 @@ If you find a bug (highly likely!) then please report it on github or our forum.
 
 If you have a feature request, or have written a small game or demo that shows Phaser in use, then please get in touch. We'd love to hear from you.
 
-Before submitting a pull request, please run your code through [JSHint](http://www.jshint.com/) to check for stylistic or formatting errors. To use JSHint, first install it by running `npm install jshint`, then test your code by running `jshint src`. This isn't a requirement, we are happy to receive pull requests that haven't been JSHinted, so don't let it put you off contributing - but do know that we'll reformat your source before going live with it.
-
 You can do this on the Phaser board that is part of the [HTML5 Game Devs forum](http://www.html5gamedevs.com/forum/14-phaser/) or email: rich@photonstorm.com
 
+Before submitting a pull request, please run your code through [JSHint](http://www.jshint.com/) to check for stylistic or formatting errors. To use JSHint, first install it by running `npm install jshint`, then test your code by running `jshint src`. This isn't a requirement, we are happy to receive pull requests that haven't been JSHinted, so don't let it put you off contributing - but do know that we'll reformat your source before going live with it.
+
 Bugs?
 -----
 

build/phaser.d.ts

@@ -1565,6 +1565,10 @@ declare module Phaser {
                   computeVelocity(axis: number, body: Phaser.Physics.Arcade.Body, velocity: number, acceleration: number, drag: number, max: number): void;
                   preUpdate(): void;
                   postUpdate(): void;
+                  overlap(object1: any, object2: any, overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
+                  overlapSpriteVsSprite(sprite1: Phaser.Sprite, sprite2: Phaser.Sprite,  overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
+                  overlapSpriteVsGroup(sprite1: Phaser.Sprite, group: Phaser.Group,  overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
+                  overlapGroupVsGroup(group: Phaser.Group, group2: Phaser.Group,  overlapCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
                   collide(object1: any, object2: any, collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
                   collideSpriteVsSprite(sprite1: Phaser.Sprite, sprite2: Phaser.Sprite,  collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;
                   collideSpriteVsTilemap(sprite1: Phaser.Sprite, tilemap: Phaser.Tilemap,  collideCallback?: Function, processCallback?: Function, callbackContext?: any): boolean;

build/ts.bat

@@ -1 +0,0 @@
-jsdocts -d:phaser.d.ts phaser.js

docs/build/conf.json

@@ -18,6 +18,7 @@
             "../../src/physics/arcade/", 
             "../../src/sound/", 
             "../../src/system/", 
+            "../../src/tilemap/", 
             "../../src/time/", 
             "../../src/tween/", 
             "../../src/utils/" 

docs/build/conf_dev.json

@@ -18,6 +18,7 @@
             "../../src/physics/arcade/", 
             "../../src/sound/", 
             "../../src/system/", 
+            "../../src/tilemap/", 
             "../../src/time/", 
             "../../src/tween/", 
             "../../src/utils/" 

examples/_site/examples.json

@@ -392,6 +392,10 @@
       "file": "load+audio.js",
       "title": "load audio"
     },
+    {
+      "file": "load+bitmap+font.js",
+      "title": "load bitmap font"
+    },
     {
       "file": "load+image.js",
       "title": "load image"
@@ -400,6 +404,18 @@
       "file": "load+spritesheet.js",
       "title": "load spritesheet"
     },
+    {
+      "file": "load+starling+atlas.js",
+      "title": "load starling atlas"
+    },
+    {
+      "file": "load+text+file.js",
+      "title": "load text file"
+    },
+    {
+      "file": "load+texture+atlas.js",
+      "title": "load texture atlas"
+    },
     {
       "file": "pick+images+from+cache.js",
       "title": "pick images from cache"
@@ -592,6 +608,10 @@
       "file": "animated+tiling+sprite.js",
       "title": "animated tiling sprite"
     },
+    {
+      "file": "tiling+sprite+input.js",
+      "title": "tiling sprite input"
+    },
     {
       "file": "tiling+sprite.js",
       "title": "tiling sprite"

examples/loader/load audio.js

@@ -1,5 +1,5 @@
 
-var game = new Phaser.Game(800, 600, Phaser.CANVAS, 'phaser-example', { preload: preload, create: create, update: update, render: render });
+var game = new Phaser.Game(800, 600, Phaser.CANVAS, 'phaser-example', { preload: preload, create: create, render: render });
 
 function preload() {
 
@@ -14,6 +14,9 @@ function preload() {
 
     game.load.audio('boden', ['assets/audio/bodenstaendig_2000_in_rock_4bit.mp3', 'assets/audio/bodenstaendig_2000_in_rock_4bit.ogg']);
 
+    //  If you know you only need to load 1 type of audio file, you can pass a string instead of an array, like this:
+    // game.load.audio('boden', 'assets/audio/bodenstaendig_2000_in_rock_4bit.mp3');
+
 }
 
 var music;
@@ -22,8 +25,6 @@ function create() {
 
     game.stage.backgroundColor = '#182d3b';
 
-    // game.input.touch.preventDefault = false;
-
     music = game.sound.play('boden');
 
 }
@@ -32,4 +33,9 @@ function render() {
 
     game.debug.renderSoundInfo(music, 32, 32);
 
+    if (music.isDecoding)
+    {
+        game.debug.renderText("Decoding MP3 ...", 32, 200);
+    }
+
 }

examples/loader/load bitmap font.js

@@ -0,0 +1,36 @@
+
+var game = new Phaser.Game(800, 600, Phaser.AUTO, 'phaser-example', { preload: preload, create: create, update: update });
+
+function preload() {
+
+    //  Phaser can load Bitmap Fonts.
+
+    //  As with all load operations the first parameter is a unique key, which must be unique between all image files.
+    //  Next is the bitmap font file itself, in this case desyrel.png
+    //  Finally is the path to the XML file that goes with the font.
+
+    game.load.bitmapFont('desyrel', 'assets/fonts/desyrel.png', 'assets/fonts/desyrel.xml');
+
+    //  Note that the XML file should be saved with UTF-8 encoding or some browsers (such as Firefox) won't load it.
+
+    //  There are various tools that can create Bitmap Fonts and the XML file needed.
+    //  On Windows you can use the free app BMFont: http://www.angelcode.com/products/bmfont/
+    //  On OS X we recommend Glyph Designer: http://www.71squared.com/en/glyphdesigner
+
+}
+
+var text;
+
+function create() {
+
+    game.stage.backgroundColor = '#0072bc';
+
+    text = game.add.bitmapText(200, 100, 'Bitmap Fonts!', { font: '64px Desyrel', align: 'center' });
+
+}
+
+function update() {
+
+    text.setText('Bitmap Fonts!\nx: ' + Math.round(game.input.x) + ' y: ' + Math.round(game.input.y));
+
+}

examples/loader/load starling atlas.js

@@ -0,0 +1,38 @@
+
+var game = new Phaser.Game(800, 600, Phaser.AUTO, 'phaser-example', { preload: preload, create: create });
+
+function preload() {
+
+    //  Phaser can load texture atlas files that use the Starling XML file format.
+
+    //  As with all load operations the first parameter is a unique key, which must be unique between all image files.
+
+    //  Next is the texture atlas itself, in this case seacreatures.png
+    //  Finally is the path to the XML file that goes with the atlas.
+    game.load.atlasXML('seacreatures', 'assets/sprites/seacreatures.png', 'assets/sprites/seacreatures.xml');
+
+    //  Note that the XML file should be saved with UTF-8 encoding or some browsers (such as Firefox) won't load it.
+
+
+
+    //  These are just a few images to use in our underwater scene.
+    game.load.image('undersea', 'assets/pics/undersea.jpg');
+    game.load.image('coral', 'assets/pics/seabed.png');
+
+}
+
+var jellyfish;
+
+function create() {
+
+    game.add.sprite(0, 0, 'undersea');
+
+    jellyfish = game.add.sprite(330, 100, 'seacreatures');
+    jellyfish.animations.add('swim', Phaser.Animation.generateFrameNames('greenJellyfish', 0, 39, '', 4), 30, true);
+    jellyfish.animations.play('swim');
+
+    game.add.sprite(0, 466, 'coral');
+
+    game.add.tween(jellyfish).to({ y: 250 }, 4000, Phaser.Easing.Quadratic.InOut, true, 0, 10000, true);
+
+}

examples/loader/load text file.js

@@ -0,0 +1,37 @@
+
+var game = new Phaser.Game(800, 600, Phaser.CANVAS, 'phaser-example', { preload: preload, create: create, render: render });
+
+function preload() {
+
+    //  Phaser can load Text files.
+
+    //  It does this using an XMLHttpRequest.
+    
+    //  If loading a file from outside of the domain in which the game is running 
+    //  a 'Access-Control-Allow-Origin' header must be present on the server.
+    //  No parsing of the text file is performed, it's literally just the raw data.
+
+    game.load.text('html', 'http://phaser.io');
+
+}
+
+var text;
+
+function create() {
+
+    game.stage.backgroundColor = '#0072bc';
+
+    var html = game.cache.getText('html');
+
+    text = html.split('\n');
+
+}
+
+function render() {
+
+    for (var i = 0; i < 30; i++)
+    {
+        game.debug.renderText(text[i], 32, i * 20);
+    }
+
+}

examples/loader/load texture atlas.js

@@ -0,0 +1,39 @@
+
+var game = new Phaser.Game(800, 600, Phaser.AUTO, 'phaser-example', { preload: preload, create: create });
+
+function preload() {
+
+    //  Phaser can load Texture Atlas files that use either JSON Hash or JSON Array format.
+
+    //  As with all load operations the first parameter is a unique key, which must be unique between all image files.
+
+    //  Next is the texture atlas itself, in this case seacreatures.png
+
+    //  Finally is the path to the JSON file that goes with the atlas.
+    game.load.atlas('seacreatures', 'assets/sprites/seacreatures_json.png', 'assets/sprites/seacreatures_json.json');
+
+    //  Note that the JSON file should be saved with UTF-8 encoding or some browsers (such as Firefox) won't load it.
+
+
+
+    //  These are just a few images to use in our underwater scene.
+    game.load.image('undersea', 'assets/pics/undersea.jpg');
+    game.load.image('coral', 'assets/pics/seabed.png');
+
+}
+
+var octopus;
+
+function create() {
+
+    game.add.sprite(0, 0, 'undersea');
+
+    octopus = game.add.sprite(330, 100, 'seacreatures');
+    octopus.animations.add('swim', Phaser.Animation.generateFrameNames('octopus', 0, 24, '', 4), 30, true);
+    octopus.animations.play('swim');
+
+    game.add.tween(octopus).to({ y: 250 }, 4000, Phaser.Easing.Quadratic.InOut, true, 0, 10000, true);
+
+    game.add.sprite(0, 466, 'coral');
+
+}

examples/wip/bunny.js

@@ -0,0 +1,55 @@
+
+    GameState = function (game) {
+        this.game = game;
+    };
+
+    GameState.prototype = Object.create(Phaser.State.prototype);
+    GameState.prototype.constructor = GameState;
+
+    GameState.prototype.preload = function preload() {
+        this.game.load.image('bunny', 'assets/sprites/bunny.png');
+        this.game.load.image('carrot', 'assets/sprites/carrot.png');
+        this.game.load.image('melon', 'assets/sprites/melon.png');
+    }
+
+    GameState.prototype.create = function () {
+        this.game.world.setBounds(0, 0, 1600, 600);
+
+        this.bunny = this.game.add.sprite(200, 200, 'bunny');
+        this.bunny.scale.setTo(0.2, 0.2);
+
+        var melon = this.game.add.sprite(0, 0, 'melon');
+        this.melonGroup = this.game.add.group(null, 'melonGroup');
+        this.melonGroup.add(melon);
+        melon.x = this.bunny.x;
+        melon.y = this.bunny.y - 40;
+
+        this.carrot = this.game.add.sprite(0, 0, 'carrot');
+
+        this.game.camera.follow(this.bunny);
+    }
+
+    GameState.prototype.update = function () {
+        this.bunny.body.velocity.x = 0;
+        
+        if (this.game.input.keyboard.isDown(Phaser.Keyboard.RIGHT)) {
+            this.bunny.body.velocity.x = 500;
+        }
+
+        if (this.game.input.keyboard.isDown(Phaser.Keyboard.LEFT)) {
+            this.bunny.body.velocity.x = -500;
+        }
+
+        // var melon = this.melonGroup.getFirstExists(true);
+        // melon.x = this.bunny.x;
+        // melon.y = this.bunny.y - 40;
+
+        this.carrot.x = this.bunny.x;
+        this.carrot.y = this.bunny.y - 20;
+
+    };
+
+    (function () {
+        var game = new Phaser.Game(800, 600, Phaser.CANVAS, 'phaser-example');
+        game.state.add('state', GameState, true);
+    })();

examples/wip/button scale.js

@@ -32,6 +32,8 @@ var button6;
 
 function create() {
 
+    console.log('create!');
+
     background = game.add.sprite(0, 0, 'sky0');
     background.name = 'background';
 
@@ -77,7 +79,7 @@ function create() {
     
     // Phaser.Canvas.setSmoothingEnabled(false);
 
-    game.input.onDown.add(gofull, this);
+    //game.input.onDown.add(gofull, this);
 
 }
 

src/IntroDocs.js

@@ -9,7 +9,7 @@
 *
 * Phaser - http://www.phaser.io
 *
-* v1.1.2 - Released November 1st 2013.
+* v1.1.3 - Released November 28th 2013.
 *
 * By Richard Davey http://www.photonstorm.com @photonstorm
 *

src/core/Filter.js

@@ -67,10 +67,21 @@ Phaser.Filter = function (game, uniforms, fragmentSrc) {
 
 Phaser.Filter.prototype = {
 
+    /**
+    * Should be over-ridden.
+    * @method Phaser.Filter#init
+    * @param {...}
+    */
     init: function () {
         //  This should be over-ridden. Will receive a variable number of arguments.
     },
 
+    /**
+    * Set the resolution uniforms on the filter.
+    * @method Phaser.Filter#setResolution
+    * @param {number} width - The width of the display.
+    * @param {number} height - The height of the display.
+    */
     setResolution: function (width, height) {
 
         this.uniforms.resolution.value.x = width;
@@ -78,6 +89,11 @@ Phaser.Filter.prototype = {
 
     },
 
+    /**
+    * Updates the filter.
+    * @method Phaser.Filter#update
+    * @param {Phaser.Pointer} [pointer] - A Pointer object to use for the filter. The coordinates are mapped to the mouse uniform.
+    */
     update: function (pointer) {
 
         if (typeof pointer !== 'undefined')
@@ -102,6 +118,10 @@ Phaser.Filter.prototype = {
 
 };
 
+/**
+* @name Phaser.Filter#width
+* @property {number} width - The width (resolution uniform)
+*/
 Object.defineProperty(Phaser.Filter.prototype, 'width', {
 
     get: function() {
@@ -114,6 +134,10 @@ Object.defineProperty(Phaser.Filter.prototype, 'width', {
 
 });
 
+/**
+* @name Phaser.Filter#height
+* @property {number} height - The height (resolution uniform)
+*/
 Object.defineProperty(Phaser.Filter.prototype, 'height', {
 
     get: function() {

src/core/Group.js

@@ -197,7 +197,6 @@ Phaser.Group.prototype = {
     * Returns the child found at the given index within this Group.
     *
     * @method Phaser.Group#getAt
-    * @memberof Phaser.Group
     * @param {number} index - The index to return the child from.
     * @return {*} The child that was found at the given index.
     */

src/core/PluginManager.js

@@ -100,7 +100,7 @@ Phaser.PluginManager.prototype = {
         //  The plugin must have at least one of the above functions to be added to the PluginManager.
         if (result)
         {
-            if (plugin.hasPreUpdate || plugin.hasUpdate)
+            if (plugin.hasPreUpdate || plugin.hasUpdate || plugin.hasPostUpdate)
             {
                 plugin.active = true;
             }

src/gameobjects/Sprite.js

@@ -1099,6 +1099,8 @@ Object.defineProperty(Phaser.Sprite.prototype, "inputEnabled", {
 
     set: function (value) {
 
+        console.log('inputEnabled', value, this.input);
+
         if (value)
         {
             if (this.input.enabled === false)

src/input/InputHandler.js

@@ -199,6 +199,8 @@ Phaser.InputHandler.prototype = {
     */
     start: function (priority, useHandCursor) {
 
+        console.log('InputHandler start');
+
         priority = priority || 0;
         if (typeof useHandCursor == 'undefined') { useHandCursor = false; }
 

src/input/Mouse.js

@@ -41,7 +41,7 @@ Phaser.Mouse = function (game) {
     /**
     * @property {boolean} capture - If true the DOM mouse events will have event.preventDefault applied to them, if false they will propogate fully.
     */
-    this.capture = true;
+    this.capture = false;
 
     /**
     * @property {number} button- The type of click, either: Phaser.Mouse.NO_BUTTON, Phaser.Mouse.LEFT_BUTTON, Phaser.Mouse.MIDDLE_BUTTON or Phaser.Mouse.RIGHT_BUTTON.
@@ -144,10 +144,6 @@ Phaser.Mouse.prototype = {
             return _this.onMouseUp(event);
         };
 
-        // this.game.renderer.view.addEventListener('mousedown', this._onMouseDown, true);
-        // this.game.renderer.view.addEventListener('mousemove', this._onMouseMove, true);
-        // this.game.renderer.view.addEventListener('mouseup', this._onMouseUp, true);
-
         document.addEventListener('mousedown', this._onMouseDown, true);
         document.addEventListener('mousemove', this._onMouseMove, true);
         document.addEventListener('mouseup', this._onMouseUp, true);
@@ -323,10 +319,6 @@ Phaser.Mouse.prototype = {
     */
     stop: function () {
 
-        // this.game.stage.canvas.removeEventListener('mousedown', this._onMouseDown, true);
-        // this.game.stage.canvas.removeEventListener('mousemove', this._onMouseMove, true);
-        // this.game.stage.canvas.removeEventListener('mouseup', this._onMouseUp, true);
-
         document.removeEventListener('mousedown', this._onMouseDown, true);
         document.removeEventListener('mousemove', this._onMouseMove, true);
         document.removeEventListener('mouseup', this._onMouseUp, true);

src/loader/Loader.js

@@ -244,8 +244,6 @@ Phaser.Loader.prototype = {
             loaded: false
         };
 
-        console.log('addToFileList', entry);
-
         if (typeof properties !== "undefined")
         {
             for (var prop in properties)
@@ -681,8 +679,6 @@ Phaser.Loader.prototype = {
     */
     start: function () {
 
-        console.log('Loader start', this._fileList);
-
         if (this.isLoading)
         {
             return;
@@ -887,8 +883,6 @@ Phaser.Loader.prototype = {
     */
     fileComplete: function (index) {
 
-console.log('fileComplete', index);
-
         if (!this._fileList[index])
         {
             console.warn('Phaser.Loader fileComplete invalid index ' + index);
@@ -997,7 +991,7 @@ console.log('fileComplete', index);
                         this.game.sound.context.decodeAudioData(file.data, function (buffer) {
                             if (buffer)
                             {
-                                that.game.cache.decodedSound(index, buffer);
+                                that.game.cache.decodedSound(key, buffer);
                             }
                         });
                     }

src/physics/arcade/ArcadePhysics.js

@@ -282,22 +282,179 @@ Phaser.Physics.Arcade.prototype = {
     },
 
     /**
-    * Checks if two Sprite objects overlap.
+    * Checks for overlaps between two game objects. The objects can be Sprites, Groups or Emitters.
+    * You can perform Sprite vs. Sprite, Sprite vs. Group and Group vs. Group overlap checks.
+    * Unlike collide the objects are NOT automatically separated or have any physics applied, they merely test for overlap results.
     *
     * @method Phaser.Physics.Arcade#overlap
-    * @param {Phaser.Sprite} object1 - The first object to check. Can be an instance of Phaser.Sprite or anything that extends it.
+    * @param {Phaser.Sprite|Phaser.Group|Phaser.Particles.Emitter} object1 - The first object to check. Can be an instance of Phaser.Sprite, Phaser.Group or Phaser.Particles.Emitter.
-    * @param {Phaser.Sprite} object2 - The second object to check. Can be an instance of Phaser.Sprite or anything that extends it.
+    * @param {Phaser.Sprite|Phaser.Group|Phaser.Particles.Emitter} object2 - The second object to check. Can be an instance of Phaser.Sprite, Phaser.Group or Phaser.Particles.Emitter.
-    * @returns {boolean} true if the two objects overlap.
+    * @param {function} [overlapCallback=null] - An optional callback function that is called if the objects overlap. The two objects will be passed to this function in the same order in which you specified them.
+    * @param {function} [processCallback=null] - A callback function that lets you perform additional checks against the two objects if they overlap. If this is set then overlapCallback will only be called if processCallback returns true.
+    * @param {object} [callbackContext] - The context in which to run the callbacks.
+    * @returns {boolean} True if an overlap occured otherwise false.
     */
-    overlap: function (object1, object2) {
+    overlap: function (object1, object2, overlapCallback, processCallback, callbackContext) {
+
+        overlapCallback = overlapCallback || null;
+        processCallback = processCallback || null;
+        callbackContext = callbackContext || overlapCallback;
+
+        this._result = false;
+        this._total = 0;
 
         //  Only test valid objects
         if (object1 && object2 && object1.exists && object2.exists)
         {
-            return (Phaser.Rectangle.intersects(object1.body, object2.body));
+            //  SPRITES
+            if (object1.type == Phaser.SPRITE)
+            {
+                if (object2.type == Phaser.SPRITE)
+                {
+                    this.overlapSpriteVsSprite(object1, object2, overlapCallback, processCallback, callbackContext);
+                }
+                else if (object2.type == Phaser.GROUP || object2.type == Phaser.EMITTER)
+                {
+                    this.overlapSpriteVsGroup(object1, object2, overlapCallback, processCallback, callbackContext);
+                }
+            }
+            //  GROUPS
+            else if (object1.type == Phaser.GROUP)
+            {
+                if (object2.type == Phaser.SPRITE)
+                {
+                    this.overlapSpriteVsGroup(object2, object1, overlapCallback, processCallback, callbackContext);
+                }
+                else if (object2.type == Phaser.GROUP || object2.type == Phaser.EMITTER)
+                {
+                    this.overlapGroupVsGroup(object1, object2, overlapCallback, processCallback, callbackContext);
+                }
+            }
+            //  EMITTER
+            else if (object1.type == Phaser.EMITTER)
+            {
+                if (object2.type == Phaser.SPRITE)
+                {
+                    this.overlapSpriteVsGroup(object2, object1, overlapCallback, processCallback, callbackContext);
+                }
+                else if (object2.type == Phaser.GROUP || object2.type == Phaser.EMITTER)
+                {
+                    this.overlapGroupVsGroup(object1, object2, overlapCallback, processCallback, callbackContext);
+                }
+            }
         }
 
-        return false;
+        return (this._total > 0);
+
+    },
+
+    /**
+    * An internal function. Use Phaser.Physics.Arcade.overlap instead.
+    *
+    * @method Phaser.Physics.Arcade#overlapSpriteVsSprite
+    * @private
+    */
+    overlapSpriteVsSprite: function (sprite1, sprite2, overlapCallback, processCallback, callbackContext) {
+
+        this._result = Phaser.Rectangle.intersects(sprite1.body, sprite2.body);
+
+        if (this._result)
+        {
+            //  They collided, is there a custom process callback?
+            if (processCallback)
+            {
+                if (processCallback.call(callbackContext, sprite1, sprite2))
+                {
+                    this._total++;
+
+                    if (overlapCallback)
+                    {
+                        overlapCallback.call(callbackContext, sprite1, sprite2);
+                    }
+                }
+            }
+            else
+            {
+                this._total++;
+
+                if (overlapCallback)
+                {
+                    overlapCallback.call(callbackContext, sprite1, sprite2);
+                }
+            }
+        }
+
+    },
+
+    /**
+    * An internal function. Use Phaser.Physics.Arcade.overlap instead.
+    *
+    * @method Phaser.Physics.Arcade#overlapSpriteVsGroup
+    * @private
+    */
+    overlapSpriteVsGroup: function (sprite, group, overlapCallback, processCallback, callbackContext) {
+
+        if (group.length === 0)
+        {
+            return;
+        }
+
+        //  What is the sprite colliding with in the quadtree?
+        this._potentials = this.quadTree.retrieve(sprite);
+
+        for (var i = 0, len = this._potentials.length; i < len; i++)
+        {
+            //  We have our potential suspects, are they in this group?
+            if (this._potentials[i].sprite.group == group)
+            {
+                this._result = Phaser.Rectangle.intersects(sprite.body, this._potentials[i]);
+
+                if (this._result && processCallback)
+                {
+                    this._result = processCallback.call(callbackContext, sprite, this._potentials[i].sprite);
+                }
+
+                if (this._result)
+                {
+                    this._total++;
+
+                    if (overlapCallback)
+                    {
+                        overlapCallback.call(callbackContext, sprite, this._potentials[i].sprite);
+                    }
+                }
+            }
+        }
+
+    },
+
+    /**
+    * An internal function. Use Phaser.Physics.Arcade.overlap instead.
+    *
+    * @method Phaser.Physics.Arcade#overlapGroupVsGroup
+    * @private
+    */
+    overlapGroupVsGroup: function (group1, group2, overlapCallback, processCallback, callbackContext) {
+
+        if (group1.length === 0 || group2.length === 0)
+        {
+            return;
+        }
+
+        if (group1._container.first._iNext)
+        {
+            var currentNode = group1._container.first._iNext;
+                
+            do
+            {
+                if (currentNode.exists)
+                {
+                    this.overlapSpriteVsGroup(currentNode, group2, overlapCallback, processCallback, callbackContext);
+                }
+                currentNode = currentNode._iNext;
+            }
+            while (currentNode != group1._container.last._iNext);
+        }
 
     },
 
@@ -309,10 +466,10 @@ Phaser.Physics.Arcade.prototype = {
     * @method Phaser.Physics.Arcade#collide
     * @param {Phaser.Sprite|Phaser.Group|Phaser.Particles.Emitter|Phaser.Tilemap} object1 - The first object to check. Can be an instance of Phaser.Sprite, Phaser.Group, Phaser.Particles.Emitter, or Phaser.Tilemap
     * @param {Phaser.Sprite|Phaser.Group|Phaser.Particles.Emitter|Phaser.Tilemap} object2 - The second object to check. Can be an instance of Phaser.Sprite, Phaser.Group, Phaser.Particles.Emitter or Phaser.Tilemap
-    * @param {function} [collideCallback=null] - An optional callback function that is called if the objects overlap. The two objects will be passed to this function in the same order in which you passed them to Collision.overlap.
+    * @param {function} [collideCallback=null] - An optional callback function that is called if the objects overlap. The two objects will be passed to this function in the same order in which you specified them.
     * @param {function} [processCallback=null] - A callback function that lets you perform additional checks against the two objects if they overlap. If this is set then collideCallback will only be called if processCallback returns true.
     * @param {object} [callbackContext] - The context in which to run the callbacks.
-    * @returns {number} The number of collisions that were processed.
+    * @returns {boolean} True if a collision occured otherwise false.
     */
     collide: function (object1, object2, collideCallback, processCallback, callbackContext) {
 

src/tilemap/Tile.js

@@ -6,21 +6,22 @@
 */
 
 /**
-* Create a new <code>Tile</code>.
+* Create a new `Tile` object. Tiles live inside of Tilesets and are rendered via TilemapLayers.
 *
 * @class Phaser.Tile
 * @classdesc A Tile is a single representation of a tile within a Tilemap.
 * @constructor
-* @param {Phaser.Game} game - A reference to the currently running game.
+* @param {Phaser.Tileset} tileset - The tileset this tile belongs to.
-* @param {Tilemap} tilemap - The tilemap this tile belongs to.
+* @param {number} index - The index of this tile type in the core map data.
-* @param {number}  index - The index of this tile type in the core map data.
+* @param {number} x - The x coordinate of this tile.
-* @param {number}  width - Width of the tile.
+* @param {number} y - The y coordinate of this tile.
-* @param {number}  height - Height of the tile.
+* @param {number} width - Width of the tile.
+* @param {number} height - Height of the tile.
 */
 Phaser.Tile = function (tileset, index, x, y, width, height) {
 
     /**
-    * @property {string} tileset - The tileset this tile belongs to.
+    * @property {Phaser.Tileset} tileset - The tileset this tile belongs to.
     */
     this.tileset = tileset;
     
@@ -118,7 +119,7 @@ Phaser.Tile.prototype = {
     /**
     * Set callback to be called when this tilemap collides.
     * 
-    * @method Phaser.Tilemap.prototype.setCollisionCallback
+    * @method Phaser.Tile#setCollisionCallback
     * @param {Function} callback - Callback function.
     * @param {object} context - Callback will be called with this context.
     */
@@ -131,7 +132,7 @@ Phaser.Tile.prototype = {
 
     /**
     * Clean up memory.
-    * @method destroy
+    * @method Phaser.Tile#destroy
     */
     destroy: function () {
 
@@ -140,15 +141,12 @@ Phaser.Tile.prototype = {
     },
 
     /**
-    * Set collision configs.
+    * Set collision settings on this tile.
-    * @method setCollision
+    * @method Phaser.Tile#setCollision
-    * @param {boolean}   left - Indicating collide with any object on the left.
+    * @param {boolean} left - Indicating collide with any object on the left.
-    * @param {boolean}   right - Indicating collide with any object on the right.
+    * @param {boolean} right - Indicating collide with any object on the right.
-    * @param {boolean}   up - Indicating collide with any object on the top.
+    * @param {boolean} up - Indicating collide with any object on the top.
-    * @param {boolean}   down - Indicating collide with any object on the bottom.
+    * @param {boolean} down - Indicating collide with any object on the bottom.
-    * @param {boolean}   reset - Description. 
-    * @param {boolean}   separateX - Separate at x-axis.
-    * @param {boolean}   separateY - Separate at y-axis.
     */
     setCollision: function (left, right, up, down) {
 
@@ -170,7 +168,7 @@ Phaser.Tile.prototype = {
 
     /**
     * Reset collision status flags.
-    * @method resetCollision
+    * @method Phaser.Tile#resetCollision
     */
     resetCollision: function () {
 
@@ -184,27 +182,26 @@ Phaser.Tile.prototype = {
 
 };
 
+/**
+* @name Phaser.Tile#bottom
+* @property {number} bottom - The sum of the y and height properties.
+* @readonly
+*/
 Object.defineProperty(Phaser.Tile.prototype, "bottom", {
     
-    /**
-    * The sum of the y and height properties. Changing the bottom property of a Rectangle object has no effect on the x, y and width properties, but does change the height property.
-    * @method bottom
-    * @return {number}
-    */
     get: function () {
         return this.y + this.height;
     }
 
 });
 
+/**
+* @name Phaser.Tile#right
+* @property {number} right - The sum of the x and width properties.
+* @readonly
+*/
 Object.defineProperty(Phaser.Tile.prototype, "right", {
     
-    /**
-    * The sum of the x and width properties. Changing the right property of a Rectangle object has no effect on the x, y and height properties.
-    * However it does affect the width property.
-    * @method right
-    * @return {number}
-    */
     get: function () {
         return this.x + this.width;
     }

src/tilemap/Tilemap.js

@@ -1,12 +1,27 @@
+/**
+* @author       Richard Davey <rich@photonstorm.com>
+* @copyright    2013 Photon Storm Ltd.
+* @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
+*/
+
+/**
+* A Tile Map object. A Tile map consists of a set of tile data and tile sets. It is rendered to the display using a TilemapLayer.
+* A map may have multiple layers. You can perform operations on the map data such as copying, pasting, filling and shuffling the tiles around.
+*
+* @class Phaser.Tilemap
+* @constructor
+* @param {Phaser.Game} game - Game reference to the currently running game.
+* @param {string} [key] - The key of the tilemap data as stored in the Cache.
+*/
 Phaser.Tilemap = function (game, key) {
 
     /**
-    * @property {Phaser.Game} game - Description.
+    * @property {Phaser.Game} game - A reference to the currently running Game.
     */
     this.game = game;
 
     /**
-    * @property {array} layers - Description.
+    * @property {array} layers - An array of Tilemap layers.
     */
     this.layers = null;
 
@@ -22,23 +37,64 @@ Phaser.Tilemap = function (game, key) {
         this.layers = [];
     }
 
+    /**
+    * @property {number} currentLayer - The current layer.
+    */
     this.currentLayer = 0;
 
+    /**
+    * @property {array} debugMap - Map data used for debug values only.
+    */
+
     this.debugMap = [];
 
+    /**
+    * @property {boolean} dirty - Internal rendering related flag.
+    */
     this.dirty = false;
 
+    /**
+    * @property {array} _results - Internal var.
+    * @private
+    */
     this._results = [];
+
+    /**
+    * @property {number} _tempA - Internal var.
+    * @private
+    */
     this._tempA = 0;
+
+    /**
+    * @property {number} _tempB - Internal var.
+    * @private
+    */
     this._tempB = 0;
 
 };
 
+/**
+* @constant
+* @type {number}
+*/
 Phaser.Tilemap.CSV = 0;
+
+/**
+* @constant
+* @type {number}
+*/
 Phaser.Tilemap.TILED_JSON = 1;
 
 Phaser.Tilemap.prototype = {
 
+    /**
+    * Creates an empty map of the given dimensions.
+    *
+    * @method Phaser.Tilemap#create
+    * @param {string} name - The name of the map (mostly used for debugging)
+    * @param {number} width - The width of the map in tiles.
+    * @param {number} height - The height of the map in tiles.
+    */
     create: function (name, width, height) {
 
         var data = [];
@@ -53,7 +109,7 @@ Phaser.Tilemap.prototype = {
             }
         }
 
-        this.currentLayer = this.layers.push({
+        this.layers.push({
 
             name: name,
             width: width,
@@ -68,10 +124,17 @@ Phaser.Tilemap.prototype = {
 
         });
 
+        this.currentLayer = this.layers.length - 1;
+
         this.dirty = true;
 
     },
 
+    /**
+    * Internal function that calculates the tile indexes for the map data.
+    *
+    * @method Phaser.Tilemap#calculateIndexes
+    */
     calculateIndexes: function () {
 
         for (var layer = 0; layer < this.layers.length; layer++)
@@ -94,6 +157,12 @@ Phaser.Tilemap.prototype = {
 
     },
 
+    /**
+    * Sets the current layer to the given index.
+    *
+    * @method Phaser.Tilemap#setLayer
+    * @param {number} layer - Sets the current layer to the given index.
+    */
     setLayer: function (layer) {
 
         if (this.layers[layer])
@@ -104,11 +173,12 @@ Phaser.Tilemap.prototype = {
     },
 
     /**
-    * Set a specific tile with its x and y in tiles.
+    * Puts a tile of the given index value at the coordinate specified.
-    * @method putTile
+    * @method Phaser.Tilemap#putTile
-    * @param {number} x - X position of this tile.
+    * @param {number} index - The index of this tile to set.
-    * @param {number} y - Y position of this tile.
+    * @param {number} x - X position to place the tile (given in tile units, not pixels)
-    * @param {number} index - The index of this tile type in the core map data.
+    * @param {number} y - Y position to place the tile (given in tile units, not pixels)
+    * @param {number} [layer] - The Tilemap Layer to operate on.
     */
     putTile: function (index, x, y, layer) {
 
@@ -123,6 +193,14 @@ Phaser.Tilemap.prototype = {
 
     },
 
+    /**
+    * Gets a tile from the Tilemap Layer. The coordinates are given in tile values.
+    * @method Phaser.Tilemap#getTile
+    * @param {number} x - X position to get the tile from (given in tile units, not pixels)
+    * @param {number} y - Y position to get the tile from (given in tile units, not pixels)
+    * @param {number} [layer] - The Tilemap Layer to operate on.
+    * @return {number} The index of the tile at the given coordinates.
+    */
     getTile: function (x, y, layer) {
 
         if (typeof layer === "undefined") { layer = this.currentLayer; }
@@ -134,6 +212,14 @@ Phaser.Tilemap.prototype = {
 
     },
 
+    /**
+    * Gets a tile from the Tilemap layer. The coordinates are given in pixel values.
+    * @method Phaser.Tilemap#getTileWorldXY
+    * @param {number} x - X position to get the tile from (given in pixels)
+    * @param {number} y - Y position to get the tile from (given in pixels)
+    * @param {number} [layer] - The Tilemap Layer to operate on.
+    * @return {number} The index of the tile at the given coordinates.
+    */
     getTileWorldXY: function (x, y, tileWidth, tileHeight, layer) {
 
         if (typeof layer === "undefined") { layer = this.currentLayer; }
@@ -149,14 +235,19 @@ Phaser.Tilemap.prototype = {
     },
 
     /**
-    * Set a specific tile with its x and y in tiles.
+    * Puts a tile into the Tilemap layer. The coordinates are given in pixel values.
-    * @method putTileWorldXY
+    * @method Phaser.Tilemap#putTileWorldXY
-    * @param {number} x - X position of this tile in world coordinates.
+    * @param {number} index - The index of the tile to put into the layer.
-    * @param {number} y - Y position of this tile in world coordinates.
+    * @param {number} x - X position to insert the tile (given in pixels)
-    * @param {number} index - The index of this tile type in the core map data.
+    * @param {number} y - Y position to insert the tile (given in pixels)
+    * @param {number} tileWidth - The width of the tile in pixels.
+    * @param {number} tileHeight - The height of the tile in pixels.
+    * @param {number} [layer] - The Tilemap Layer to operate on.
     */
     putTileWorldXY: function (index, x, y, tileWidth, tileHeight, layer) {
 
+        if (typeof layer === "undefined") { layer = this.currentLayer; }
+
         x = this.game.math.snapToFloor(x, tileWidth) / tileWidth;
         y = this.game.math.snapToFloor(y, tileHeight) / tileHeight;
 
@@ -169,7 +260,16 @@ Phaser.Tilemap.prototype = {
 
     },
 
-    //  Values are in TILEs, not pixels.
+    /**
+    * Copies all of the tiles in the given rectangular block into the tilemap data buffer.
+    * @method Phaser.Tilemap#copy
+    * @param {number} x - X position of the top left of the area to copy (given in tiles, not pixels)
+    * @param {number} y - Y position of the top left of the area to copy (given in tiles, not pixels)
+    * @param {number} width - The width of the area to copy (given in tiles, not pixels)
+    * @param {number} height - The height of the area to copy (given in tiles, not pixels)
+    * @param {number} [layer] - The Tilemap Layer to operate on.
+    * @return {array} An array of the tiles that were copied.
+    */
     copy: function (x, y, width, height, layer) {
 
         if (typeof layer === "undefined") { layer = this.currentLayer; }
@@ -221,6 +321,14 @@ Phaser.Tilemap.prototype = {
 
     },
 
+    /**
+    * Pastes a previously copied block of tile data into the given x/y coordinates. Data should have been prepared with Tilemap.copy.
+    * @method Phaser.Tilemap#paste
+    * @param {number} x - X position of the top left of the area to paste to (given in tiles, not pixels)
+    * @param {number} y - Y position of the top left of the area to paste to (given in tiles, not pixels)
+    * @param {array} tileblock - The block of tiles to paste.
+    * @param {number} layer - The Tilemap Layer to operate on.
+    */
     paste: function (x, y, tileblock, layer) {
 
         if (typeof x === "undefined") { x = 0; }
@@ -247,13 +355,13 @@ Phaser.Tilemap.prototype = {
 
     /**
     * Swap tiles with 2 kinds of indexes.
-    * @method swapTile
+    * @method Phaser.Tilemap#swapTile
     * @param {number} tileA - First tile index.
     * @param {number} tileB - Second tile index.
-    * @param {number} [x] - specify a Rectangle of tiles to operate. The x position in tiles of Rectangle's left-top corner.
+    * @param {number} x - X position of the top left of the area to operate one, given in tiles, not pixels.
-    * @param {number} [y] - specify a Rectangle of tiles to operate. The y position in tiles of Rectangle's left-top corner.
+    * @param {number} y - Y position of the top left of the area to operate one, given in tiles, not pixels.
-    * @param {number} [width] - specify a Rectangle of tiles to operate. The width in tiles.
+    * @param {number} width - The width in tiles of the area to operate on.
-    * @param {number} [height] - specify a Rectangle of tiles to operate. The height in tiles.
+    * @param {number} height - The height in tiles of the area to operate on.
     */
     swap: function (tileA, tileB, x, y, width, height, layer) {
 
@@ -273,6 +381,12 @@ Phaser.Tilemap.prototype = {
 
     },
 
+    /**
+    * Internal function that handles the swapping of tiles.
+    * @method Phaser.Tilemap#swapHandler
+    * @param {number} value
+    * @param {number} index
+    */
     swapHandler: function (value, index) {
 
         if (value.index === this._tempA)
@@ -287,14 +401,15 @@ Phaser.Tilemap.prototype = {
     },
 
     /**
-    * Swap tiles with 2 kinds of indexes.
+    * For each tile in the given area (defined by x/y and width/height) run the given callback.
-    * @method swapTile
+    * @method Phaser.Tilemap#forEach
-    * @param {number} tileA - First tile index.
+    * @param {number} callback - The callback. Each tile in the given area will be passed to this callback as the first and only parameter.
-    * @param {number} tileB - Second tile index.
+    * @param {number} context - The context under which the callback should be run.
-    * @param {number} [x] - specify a Rectangle of tiles to operate. The x position in tiles of Rectangle's left-top corner.
+    * @param {number} x - X position of the top left of the area to operate one, given in tiles, not pixels.
-    * @param {number} [y] - specify a Rectangle of tiles to operate. The y position in tiles of Rectangle's left-top corner.
+    * @param {number} y - Y position of the top left of the area to operate one, given in tiles, not pixels.
-    * @param {number} [width] - specify a Rectangle of tiles to operate. The width in tiles.
+    * @param {number} width - The width in tiles of the area to operate on.
-    * @param {number} [height] - specify a Rectangle of tiles to operate. The height in tiles.
+    * @param {number} height - The height in tiles of the area to operate on.
+    * @param {number} [layer] - The Tilemap Layer to operate on.
     */
     forEach: function (callback, context, x, y, width, height, layer) {
 
@@ -312,14 +427,15 @@ Phaser.Tilemap.prototype = {
     },
 
     /**
-    * Replaces one type of tile with another.
+    * Replaces one type of tile with another in the given area (defined by x/y and width/height).
-    * @method replace
+    * @method Phaser.Tilemap#replace
     * @param {number} tileA - First tile index.
     * @param {number} tileB - Second tile index.
-    * @param {number} [x] - specify a Rectangle of tiles to operate. The x position in tiles of Rectangle's left-top corner.
+    * @param {number} x - X position of the top left of the area to operate one, given in tiles, not pixels.
-    * @param {number} [y] - specify a Rectangle of tiles to operate. The y position in tiles of Rectangle's left-top corner.
+    * @param {number} y - Y position of the top left of the area to operate one, given in tiles, not pixels.
-    * @param {number} [width] - specify a Rectangle of tiles to operate. The width in tiles.
+    * @param {number} width - The width in tiles of the area to operate on.
-    * @param {number} [height] - specify a Rectangle of tiles to operate. The height in tiles.
+    * @param {number} height - The height in tiles of the area to operate on.
+    * @param {number} [layer] - The Tilemap Layer to operate on.
     */
     replace: function (tileA, tileB, x, y, width, height, layer) {
 
@@ -343,14 +459,15 @@ Phaser.Tilemap.prototype = {
     },
 
     /**
-    * Randomises a set of tiles in a given area. It will only randomise the tiles in that area, so if they're all the same nothing will appear to have changed!
+    * Randomises a set of tiles in a given area.
-    * @method random
+    * @method Phaser.Tilemap#random
     * @param {number} tileA - First tile index.
     * @param {number} tileB - Second tile index.
-    * @param {number} [x] - specify a Rectangle of tiles to operate. The x position in tiles of Rectangle's left-top corner.
+    * @param {number} x - X position of the top left of the area to operate one, given in tiles, not pixels.
-    * @param {number} [y] - specify a Rectangle of tiles to operate. The y position in tiles of Rectangle's left-top corner.
+    * @param {number} y - Y position of the top left of the area to operate one, given in tiles, not pixels.
-    * @param {number} [width] - specify a Rectangle of tiles to operate. The width in tiles.
+    * @param {number} width - The width in tiles of the area to operate on.
-    * @param {number} [height] - specify a Rectangle of tiles to operate. The height in tiles.
+    * @param {number} height - The height in tiles of the area to operate on.
+    * @param {number} [layer] - The Tilemap Layer to operate on.
     */
     random: function (x, y, width, height, layer) {
 
@@ -385,14 +502,15 @@ Phaser.Tilemap.prototype = {
     },
 
     /**
-    * Randomises a set of tiles in a given area. It will only randomise the tiles in that area, so if they're all the same nothing will appear to have changed!
+    * Shuffles a set of tiles in a given area. It will only randomise the tiles in that area, so if they're all the same nothing will appear to have changed!
-    * @method random
+    * @method Phaser.Tilemap#shuffle
     * @param {number} tileA - First tile index.
     * @param {number} tileB - Second tile index.
-    * @param {number} [x] - specify a Rectangle of tiles to operate. The x position in tiles of Rectangle's left-top corner.
+    * @param {number} x - X position of the top left of the area to operate one, given in tiles, not pixels.
-    * @param {number} [y] - specify a Rectangle of tiles to operate. The y position in tiles of Rectangle's left-top corner.
+    * @param {number} y - Y position of the top left of the area to operate one, given in tiles, not pixels.
-    * @param {number} [width] - specify a Rectangle of tiles to operate. The width in tiles.
+    * @param {number} width - The width in tiles of the area to operate on.
-    * @param {number} [height] - specify a Rectangle of tiles to operate. The height in tiles.
+    * @param {number} height - The height in tiles of the area to operate on.
+    * @param {number} [layer] - The Tilemap Layer to operate on.
     */
     shuffle: function (x, y, width, height, layer) {
 
@@ -416,13 +534,14 @@ Phaser.Tilemap.prototype = {
     },
 
     /**
-    * Fill a tile block with a specific tile index.
+    * Fill a block with a specific tile index.
-    * @method fill
+    * @method Phaser.Tilemap#fill
     * @param {number} index - Index of tiles you want to fill with.
-    * @param {number} [x] - X position (in tiles) of block's left-top corner.
+    * @param {number} x - X position of the top left of the area to operate one, given in tiles, not pixels.
-    * @param {number} [y] - Y position (in tiles) of block's left-top corner.
+    * @param {number} y - Y position of the top left of the area to operate one, given in tiles, not pixels.
-    * @param {number} [width] - width of block.
+    * @param {number} width - The width in tiles of the area to operate on.
-    * @param {number} [height] - height of block.
+    * @param {number} height - The height in tiles of the area to operate on.
+    * @param {number} [layer] - The Tilemap Layer to operate on.
     */
     fill: function (index, x, y, width, height, layer) {
 
@@ -442,6 +561,10 @@ Phaser.Tilemap.prototype = {
 
     },
 
+    /**
+    * Removes all layers from this tile map.
+    * @method Phaser.Tilemap#removeAllLayers
+    */
     removeAllLayers: function () {
 
         this.layers.length = 0;
@@ -449,6 +572,10 @@ Phaser.Tilemap.prototype = {
 
     },
 
+    /**
+    * Dumps the tilemap data out to the console.
+    * @method Phaser.Tilemap#dump
+    */
     dump: function () {
 
         var txt = '';
@@ -485,6 +612,10 @@ Phaser.Tilemap.prototype = {
 
     },
 
+    /**
+    * Removes all layers from this tile map and nulls the game reference.
+    * @method Phaser.Tilemap#destroy
+    */
     destroy: function () {
 
         this.removeAllLayers();

src/tilemap/TilemapLayer.js

@@ -1,69 +1,115 @@
-//  Maybe should extend Sprite?
+/**
+* @author       Richard Davey <rich@photonstorm.com>
+* @copyright    2013 Photon Storm Ltd.
+* @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
+*/
+
+/**
+* A Tilemap Layer is a set of map data combined with a Tileset in order to render that data to the game.
+*
+* @class Phaser.TilemapLayer
+* @constructor
+* @param {Phaser.Game} game - Game reference to the currently running game.
+* @param {number} x - The x coordinate of this layer.
+* @param {number} y - The y coordinate of this layer.
+* @param {number} renderWidth - Width of the layer.
+* @param {number} renderHeight - Height of the layer.
+* @param {Phaser.Tileset|string} tileset - The tile set used for rendering.
+* @param {Phaser.Tilemap} tilemap - The tilemap to which this layer belongs.
+* @param {number} layer - The layer index within the map.
+*/
 Phaser.TilemapLayer = function (game, x, y, renderWidth, renderHeight, tileset, tilemap, layer) {
 
     /**
-    * @property {Phaser.Game} game - Description.
+    * @property {Phaser.Game} game - A reference to the currently running Game.
     */
     this.game = game;
     
     /**
-    * @property {Description} canvas - Description.
+    * @property {HTMLCanvasElement} canvas - The canvas to which this BitmapData draws.
-    * @default
     */
     this.canvas = Phaser.Canvas.create(renderWidth, renderHeight);
     
     /**
-    * @property {Description} context - Description.
+    * @property {CanvasRenderingContext2D} context - The 2d context of the canvas.
-    * @default
     */
     this.context = this.canvas.getContext('2d');
     
     /**
-    * @property {Description} baseTexture - Description.
+    * @property {PIXI.BaseTexture} baseTexture - Required Pixi var.
-    * @default
     */
     this.baseTexture = new PIXI.BaseTexture(this.canvas);
     
     /**
-    * @property {Description} texture - Description.
+    * @property {PIXI.Texture} texture - Required Pixi var.
-    * @default
     */
     this.texture = new PIXI.Texture(this.baseTexture);
     
+    /**
+    * @property {Phaser.Frame} textureFrame - Dimensions of the renderable area.
+    */
     this.textureFrame = new Phaser.Frame(0, 0, 0, renderWidth, renderHeight, 'tilemaplayer', game.rnd.uuid());
 
     Phaser.Sprite.call(this, this.game, x, y, this.texture, this.textureFrame);
 
+    /**
+    * @property {number} type - The const type of this object.
+    * @default
+    */
     this.type = Phaser.TILEMAPLAYER;
 
+    /**
+    * A layer that is fixed to the camera ignores the position of any ancestors in the display list and uses its x/y coordinates as offsets from the top left of the camera.
+    * @property {boolean} fixedToCamera - Fixes this layer to the Camera.
+    * @default
+    */
     this.fixedToCamera = true;
 
     /**
-    * @property {Description} tileset - Description.
+    * @property {Phaser.Tileset} tileset - The tile set used for rendering.
     */
     this.tileset = null;
 
+    /**
+    * @property {number} tileWidth - The width of a single tile in pixels.
+    */
     this.tileWidth = 0;
+
+    /**
+    * @property {number} tileHeight - The height of a single tile in pixels.
+    */
     this.tileHeight = 0;
+
+    /**
+    * @property {number} tileMargin - The margin around the tiles.
+    */
     this.tileMargin = 0;
+
+    /**
+    * @property {number} tileSpacing - The spacing around the tiles.
+    */
     this.tileSpacing = 0;
 
     /**
-    * Read-only variable, do NOT recommend changing after the map is loaded!
+    * @property {number} widthInPixels - Do NOT recommend changing after the map is loaded!
-    * @property {number} widthInPixels
+    * @readonly
-    * @default
     */
     this.widthInPixels = 0;
 
     /**
-    * Read-only variable, do NOT recommend changing after the map is loaded!
+    * @property {number} heightInPixels - Do NOT recommend changing after the map is loaded!
-    * @property {number} heightInPixels
+    * @readonly
-    * @default
     */
     this.heightInPixels = 0;
 
-
+    /**
+    * @property {number} renderWidth - The width of the area being rendered.
+    */
     this.renderWidth = renderWidth;
+
+    /**
+    * @property {number} renderHeight - The height of the area being rendered.
+    */
     this.renderHeight = renderHeight;
 
     /**
@@ -108,9 +154,16 @@ Phaser.TilemapLayer = function (game, x, y, renderWidth, renderHeight, tileset,
     */
     this._ty = 0;
 
-    this._results = [];
+    /**
-
+    * @property {number} _tw - Local render loop var to help avoid gc spikes.
+    * @private 
+    */
     this._tw = 0;
+
+    /**
+    * @property {number} _th - Local render loop var to help avoid gc spikes.
+    * @private 
+    */
     this._th = 0;
     
     /**
@@ -143,6 +196,36 @@ Phaser.TilemapLayer = function (game, x, y, renderWidth, renderHeight, tileset,
     */
     this._startY = 0;
 
+    /**
+    * @property {array} _results - Local render loop var to help avoid gc spikes.
+    * @private 
+    */
+    this._results = [];
+
+    /**
+    * @property {number} _x - Private var.
+    * @private 
+    */
+    this._x = 0;
+
+    /**
+    * @property {number} _y - Private var.
+    * @private 
+    */
+    this._y = 0;
+
+    /**
+    * @property {number} _prevX - Private var.
+    * @private 
+    */
+    this._prevX = 0;
+
+    /**
+    * @property {number} _prevY - Private var.
+    * @private 
+    */
+    this._prevY = 0;
+
     /**
     * @property {number} scrollFactorX - speed at which this layer scrolls
     * horizontally, relative to the camera (e.g. scrollFactorX of 0.5 scrolls
@@ -150,6 +233,7 @@ Phaser.TilemapLayer = function (game, x, y, renderWidth, renderHeight, tileset,
     * @default 1
     */
     this.scrollFactorX = 1;
+
     /**
     * @property {number} scrollFactorY - speed at which this layer scrolls
     * vertically, relative to the camera (e.g. scrollFactorY of 0.5 scrolls
@@ -158,15 +242,24 @@ Phaser.TilemapLayer = function (game, x, y, renderWidth, renderHeight, tileset,
     */
     this.scrollFactorY = 1;
 
+    /**
+    * @property {Phaser.Tilemap} tilemap - The Tilemap to which this layer is bound.
+    */
     this.tilemap = null;
+
+    /**
+    * @property {number} layer - Tilemap layer index.
+    */
     this.layer = null;
+
+    /**
+    * @property {number} index
+    */
     this.index = 0;
 
-    this._x = 0;
+    /**
-    this._y = 0;
+    * @property {boolean} dirty - Flag controlling when to re-render the layer.
-    this._prevX = 0;
+    */
-    this._prevY = 0;
-
     this.dirty = true;
 
     if (tileset instanceof Phaser.Tileset || typeof tileset === 'string')
@@ -185,7 +278,12 @@ Phaser.TilemapLayer.prototype = Object.create(Phaser.Sprite.prototype);
 Phaser.TilemapLayer.prototype = Phaser.Utils.extend(true, Phaser.TilemapLayer.prototype, Phaser.Sprite.prototype, PIXI.Sprite.prototype);
 Phaser.TilemapLayer.prototype.constructor = Phaser.TilemapLayer;
 
-
+/**
+* Automatically called by World.preUpdate. Handles cache updates.
+*
+* @method Phaser.TilemapLayer#update
+* @memberof Phaser.TilemapLayer
+*/
 Phaser.TilemapLayer.prototype.update = function () {
 
     this.scrollX = this.game.camera.x * this.scrollFactorX;
@@ -195,12 +293,25 @@ Phaser.TilemapLayer.prototype.update = function () {
 
 }
 
+/**
+* Sets the world size to match the size of this layer.
+*
+* @method Phaser.TilemapLayer#resizeWorld
+* @memberof Phaser.TilemapLayer
+*/
 Phaser.TilemapLayer.prototype.resizeWorld = function () {
 
     this.game.world.setBounds(0, 0, this.widthInPixels, this.heightInPixels);
 
 }
 
+/**
+* Updates the Tileset data.
+*
+* @method Phaser.TilemapLayer#updateTileset
+* @memberof Phaser.TilemapLayer
+* @param {Phaser.Tileset|string} tileset - The tileset to use for this layer.
+*/
 Phaser.TilemapLayer.prototype.updateTileset = function (tileset) {
 
     if (tileset instanceof Phaser.Tileset)
@@ -225,6 +336,14 @@ Phaser.TilemapLayer.prototype.updateTileset = function (tileset) {
 
 }
 
+/**
+* Updates the Tilemap data.
+*
+* @method Phaser.TilemapLayer#updateMapData
+* @memberof Phaser.TilemapLayer
+* @param {Phaser.Tilemap} tilemap - The tilemap to which this layer belongs.
+* @param {number} layer - The layer index within the map.
+*/
 Phaser.TilemapLayer.prototype.updateMapData = function (tilemap, layer) {
 
     if (typeof layer === 'undefined')
@@ -244,11 +363,14 @@ Phaser.TilemapLayer.prototype.updateMapData = function (tilemap, layer) {
 }
 
 /**
- * Take an x coordinate that doesn't account for scrollFactorY and 'fix' it 
+* Take an x coordinate that doesn't account for scrollFactorY and 'fix' it 
- * into a scrolled local space. Used primarily internally
+* into a scrolled local space. Used primarily internally
- * @param {number} x - x coordinate in camera space
+* @method Phaser.TilemapLayer#_fixX
- * @return {number} x coordinate in scrollFactor-adjusted dimensions
+* @memberof Phaser.TilemapLayer
- */
+* @private
+* @param {number} x - x coordinate in camera space
+* @return {number} x coordinate in scrollFactor-adjusted dimensions
+*/
 Phaser.TilemapLayer.prototype._fixX = function(x) {
 
     if (this.scrollFactorX === 1)
@@ -263,11 +385,14 @@ Phaser.TilemapLayer.prototype._fixX = function(x) {
 }
 
 /**
- * Take an x coordinate that _does_ account for scrollFactorY and 'unfix' it 
+* Take an x coordinate that _does_ account for scrollFactorY and 'unfix' it 
- * back to camera space. Used primarily internally
+* back to camera space. Used primarily internally
- * @param {number} x - x coordinate in scrollFactor-adjusted dimensions
+* @method Phaser.TilemapLayer#_unfixX
- * @return {number} x coordinate in camera space
+* @memberof Phaser.TilemapLayer
- */
+* @private
+* @param {number} x - x coordinate in scrollFactor-adjusted dimensions
+* @return {number} x coordinate in camera space
+*/
 Phaser.TilemapLayer.prototype._unfixX = function(x) {
 
     if (this.scrollFactorX === 1)
@@ -282,11 +407,14 @@ Phaser.TilemapLayer.prototype._unfixX = function(x) {
 }
 
 /**
- * Take a y coordinate that doesn't account for scrollFactorY and 'fix' it 
+* Take a y coordinate that doesn't account for scrollFactorY and 'fix' it 
- * into a scrolled local space. Used primarily internally
+* into a scrolled local space. Used primarily internally
- * @param {number} y - y coordinate in camera space
+* @method Phaser.TilemapLayer#_fixY
- * @return {number} y coordinate in scrollFactor-adjusted dimensions
+* @memberof Phaser.TilemapLayer
- */
+* @private
+* @param {number} y - y coordinate in camera space
+* @return {number} y coordinate in scrollFactor-adjusted dimensions
+*/
 Phaser.TilemapLayer.prototype._fixY = function(y) {
 
     if (this.scrollFactorY === 1)
@@ -301,11 +429,14 @@ Phaser.TilemapLayer.prototype._fixY = function(y) {
 }
 
 /**
- * Take a y coordinate that _does_ account for scrollFactorY and 'unfix' it 
+* Take a y coordinate that _does_ account for scrollFactorY and 'unfix' it 
- * back to camera space. Used primarily internally
+* back to camera space. Used primarily internally
- * @param {number} y - y coordinate in scrollFactor-adjusted dimensions
+* @method Phaser.TilemapLayer#_unfixY
- * @return {number} y coordinate in camera space
+* @memberof Phaser.TilemapLayer
- */
+* @private
+* @param {number} y - y coordinate in scrollFactor-adjusted dimensions
+* @return {number} y coordinate in camera space
+*/
 Phaser.TilemapLayer.prototype._unfixY = function(y) {
 
     if (this.scrollFactorY === 1)
@@ -321,9 +452,10 @@ Phaser.TilemapLayer.prototype._unfixY = function(y) {
 
 /**
 * Convert a pixel value to a tile coordinate.
+* @method Phaser.TilemapLayer#getTileX
+* @memberof Phaser.TilemapLayer
 * @param {number} x - X position of the point in target tile.
-* @param {number} [layer] - layer of this tile located.
+* @return {Phaser.Tile} The tile with specific properties.
-* @return {number} The tile with specific properties.
 */
 Phaser.TilemapLayer.prototype.getTileX = function (x) {
 
@@ -335,9 +467,10 @@ Phaser.TilemapLayer.prototype.getTileX = function (x) {
 
 /**
 * Convert a pixel value to a tile coordinate.
-* @param {number} x - X position of the point in target tile.
+* @method Phaser.TilemapLayer#getTileY
-* @param {number} [layer] - layer of this tile located.
+* @memberof Phaser.TilemapLayer
-* @return {number} The tile with specific properties.
+* @param {number} y - Y position of the point in target tile.
+* @return {Phaser.Tile} The tile with specific properties.
 */
 Phaser.TilemapLayer.prototype.getTileY = function (y) {
 
@@ -347,6 +480,14 @@ Phaser.TilemapLayer.prototype.getTileY = function (y) {
 
 }
 
+/**
+* Convert a pixel value to a tile coordinate.
+* @method Phaser.TilemapLayer#getTileXY
+* @memberof Phaser.TilemapLayer
+* @param {number} x - X position of the point in target tile.
+* @param {number} y - Y position of the point in target tile.
+* @return {Phaser.Tile} The tile with specific properties.
+*/
 Phaser.TilemapLayer.prototype.getTileXY = function (x, y, point) {
 
     point.x = this.getTileX(x);
@@ -357,9 +498,14 @@ Phaser.TilemapLayer.prototype.getTileXY = function (x, y, point) {
 }
 
 /**
-* 
+* Get the tiles within the given area.
-* @method getTileOverlaps
+* @method Phaser.TilemapLayer#getTiles
-* @param {GameObject} object - Tiles you want to get that overlaps this.
+* @memberof Phaser.TilemapLayer
+* @param {number} x - X position of the top left of the area to copy (given in tiles, not pixels)
+* @param {number} y - Y position of the top left of the area to copy (given in tiles, not pixels)
+* @param {number} width - The width of the area to copy (given in tiles, not pixels)
+* @param {number} height - The height of the area to copy (given in tiles, not pixels)
+* @param {boolean} collides - If true only return tiles that collide on one or more faces.
 * @return {array} Array with tiles informations (each contains x, y, and the tile).
 */
 Phaser.TilemapLayer.prototype.getTiles = function (x, y, width, height, collides) {
@@ -448,6 +594,11 @@ Phaser.TilemapLayer.prototype.getTiles = function (x, y, width, height, collides
 
 }
 
+/**
+* Internal function to update maximum values.
+* @method Phaser.TilemapLayer#updateMax
+* @memberof Phaser.TilemapLayer
+*/
 Phaser.TilemapLayer.prototype.updateMax = function () {
 
     this._maxX = this.game.math.ceil(this.canvas.width / this.tileWidth) + 1;
@@ -473,6 +624,11 @@ Phaser.TilemapLayer.prototype.updateMax = function () {
 
 }
 
+/**
+* Renders the tiles to the layer canvas and pushes to the display.
+* @method Phaser.TilemapLayer#render
+* @memberof Phaser.TilemapLayer
+*/
 Phaser.TilemapLayer.prototype.render = function () {
 
     if (this.tilemap && this.tilemap.dirty)
@@ -545,22 +701,50 @@ Phaser.TilemapLayer.prototype.render = function () {
 
 }
 
+/**
+* Returns the absolute delta x value.
+* @method Phaser.TilemapLayer#deltaAbsX
+* @memberof Phaser.TilemapLayer
+* @return {number} Absolute delta X value
+*/
 Phaser.TilemapLayer.prototype.deltaAbsX = function () {
     return (this.deltaX() > 0 ? this.deltaX() : -this.deltaX());
 }
 
+/**
+* Returns the absolute delta y value.
+* @method Phaser.TilemapLayer#deltaAbsY
+* @memberof Phaser.TilemapLayer
+* @return {number} Absolute delta Y value
+*/
 Phaser.TilemapLayer.prototype.deltaAbsY = function () {
     return (this.deltaY() > 0 ? this.deltaY() : -this.deltaY());
 }
 
+/**
+* Returns the delta x value.
+* @method Phaser.TilemapLayer#deltaX
+* @memberof Phaser.TilemapLayer
+* @return {number} Delta X value
+*/
 Phaser.TilemapLayer.prototype.deltaX = function () {
     return this._dx - this._prevX;
 }
 
+/**
+* Returns the delta y value.
+* @method Phaser.TilemapLayer#deltaY
+* @memberof Phaser.TilemapLayer
+* @return {number} Delta Y value
+*/
 Phaser.TilemapLayer.prototype.deltaY = function () {
     return this._dy - this._prevY;
 }
 
+/**
+* @name Phaser.TilemapLayer#scrollX
+* @property {number} scrollX - Scrolls the map horizontally or returns the current x position.
+*/
 Object.defineProperty(Phaser.TilemapLayer.prototype, "scrollX", {
     
     get: function () {
@@ -597,6 +781,10 @@ Object.defineProperty(Phaser.TilemapLayer.prototype, "scrollX", {
 
 });
 
+/**
+* @name Phaser.TilemapLayer#scrollY
+* @property {number} scrollY - Scrolls the map vertically or returns the current y position.
+*/
 Object.defineProperty(Phaser.TilemapLayer.prototype, "scrollY", {
     
     get: function () {

src/tilemap/TilemapParser.js

@@ -1,5 +1,28 @@
+/**
+* @author       Richard Davey <rich@photonstorm.com>
+* @copyright    2013 Photon Storm Ltd.
+* @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
+*/
+
+/**
+* Phaser.TilemapParser parses data objects from Phaser.Loader that need more preparation before they can be inserted into a Tilemap.
+*
+* @class Phaser.TilemapParser
+*/
 Phaser.TilemapParser = {
 
+    /**
+    * Creates a Tileset object.
+    * @method Phaser.TilemapParser.tileset
+    * @param {Phaser.Game} game - Game reference to the currently running game.
+    * @param {string} key
+    * @param {number} tileWidth
+    * @param {number} tileHeight
+    * @param {number} tileMax
+    * @param {number} tileMargin
+    * @param {number} tileSpacing
+    * @return {Phaser.Tileset} Generated Tileset object.
+    */
     tileset: function (game, key, tileWidth, tileHeight, tileMax, tileMargin, tileSpacing) {
 
         //  How big is our image?
@@ -63,6 +86,14 @@ Phaser.TilemapParser = {
 
     },
 
+    /**
+    * Parse tileset data from the cache and creates a Tileset object.
+    * @method Phaser.TilemapParser.parse
+    * @param {Phaser.Game} game - Game reference to the currently running game.
+    * @param {object} data
+    * @param {string} format
+    * @return {Phaser.Tileset} Generated Tileset object.
+    */
     parse: function (game, data, format) {
 
         if (format === Phaser.Tilemap.CSV)
@@ -77,10 +108,10 @@ Phaser.TilemapParser = {
     },
 
     /**
-    * Parse csv map data and generate tiles.
+    * Parses a CSV file into valid map data.
-    * 
+    * @method Phaser.TilemapParser.parseCSV
-    * @method Phaser.Tilemap.prototype.parseCSV
+    * @param {string} data - The CSV file data.
-    * @param {string} data - CSV map data.
+    * @return {object} Generated map data.
     */
     parseCSV: function (data) {
 
@@ -114,11 +145,10 @@ Phaser.TilemapParser = {
     },
 
     /**
-    * Parse JSON map data and generate tiles.
+    * Parses a Tiled JSON file into valid map data.
-    * 
+    * @method Phaser.TilemapParser.parseJSON
-    * @method Phaser.Tilemap.prototype.parseTiledJSON
+    * @param {object} json- The Tiled JSON data.
-    * @param {string} data - JSON map data.
+    * @return {object} Generated map data.
-    * @param {string} key - Asset key for tileset image.
     */
     parseTiledJSON: function (json) {
 

src/tilemap/Tileset.js

@@ -1,4 +1,21 @@
+/**
+* @author       Richard Davey <rich@photonstorm.com>
+* @copyright    2013 Photon Storm Ltd.
+* @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
+*/
 
+/**
+* A Tile set is a combination of an image containing the tiles and collision data per tile.
+*
+* @class Phaser.Tileset
+* @constructor
+* @param {Image} image - The Image object from the Cache.
+* @param {string} key - The key of the tileset in the cache.
+* @param {number} tileWidth - The width of the tile in pixels.
+* @param {number} tileHeight - The height of the tile in pixels.
+* @param {number} [tileMargin] - The margin around the tiles in the sheet.
+* @param {number} [tileSpacing] - The spacing between the tiles in the sheet.
+*/
 Phaser.Tileset = function (image, key, tileWidth, tileHeight, tileMargin, tileSpacing) {
 
     if (typeof tileMargin === "undefined") { tileMargin = 0; }
@@ -9,19 +26,46 @@ Phaser.Tileset = function (image, key, tileWidth, tileHeight, tileMargin, tileSp
     */
     this.key = key;
 
+    /**
+    * @property {object} image - The image used for rendering.
+    */
     this.image = image;
 
+    /**
+    * @property {number} tileWidth - The width of a tile in pixels.
+    */
     this.tileWidth = tileWidth;
+
+    /**
+    * @property {number} tileHeight - The height of a tile in pixels.
+    */
     this.tileHeight = tileHeight;
+
+    /**
+    * @property {number} tileMargin - The margin around the tiles in the sheet.
+    */
     this.margin = tileMargin;
+
+    /**
+    * @property {number} tileSpacing - The margin around the tiles in the sheet.
+    */
     this.spacing = tileSpacing;
 
+    /**
+    * @property {array} tiles - An array of the tile collision data.
+    */
     this.tiles = [];
 
 }
 
 Phaser.Tileset.prototype = {
 
+    /**
+    * Adds a Tile into this set.
+    *
+    * @method Phaser.Tileset#addTile
+    * @param {Phaser.Tile} tile - The tile to add to this set.
+    */
     addTile: function (tile) {
 
         this.tiles.push(tile);
@@ -30,6 +74,13 @@ Phaser.Tileset.prototype = {
 
     },
 
+    /**
+    * Gets a Tile from this set.
+    *
+    * @method Phaser.Tileset#getTile
+    * @param {number} index - The index of the tile within the set.
+    * @return {Phaser.Tile} The tile.
+    */
     getTile: function (index) {
 
         if (this.tiles[index])
@@ -41,6 +92,13 @@ Phaser.Tileset.prototype = {
 
     },
 
+    /**
+    * Sets tile spacing and margins.
+    *
+    * @method Phaser.Tileset#setSpacing
+    * @param {number} [tileMargin] - The margin around the tiles in the sheet.
+    * @param {number} [tileSpacing] - The spacing between the tiles in the sheet.
+    */
     setSpacing: function (margin, spacing) {
 
         this.tileMargin = margin;
@@ -48,6 +106,13 @@ Phaser.Tileset.prototype = {
 
     },
 
+    /**
+    * Checks if the tile at the given index can collide.
+    *
+    * @method Phaser.Tileset#canCollide
+    * @param {number} index - The index of the tile within the set.
+    * @return {boolean} True or false depending on the tile collision or null if no tile was found at the given index.
+    */
     canCollide: function (index) {
 
         if (this.tiles[index])
@@ -59,12 +124,30 @@ Phaser.Tileset.prototype = {
 
     },
 
+    /**
+    * Checks if the tile at the given index exists.
+    *
+    * @method Phaser.Tileset#checkTileIndex
+    * @param {number} index - The index of the tile within the set.
+    * @return {boolean} True if a tile exists at the given index otherwise false.
+    */
     checkTileIndex: function (index) {
 
         return (this.tiles[index]);
 
     },
 
+    /**
+    * Sets collision values on a range of tiles in the set.
+    *
+    * @method Phaser.Tileset#setCollisionRange
+    * @param {number} start - The index to start setting the collision data on.
+    * @param {number} stop - The index to stop setting the collision data on.
+    * @param {boolean} left - Should the tile collide on the left?
+    * @param {boolean} right - Should the tile collide on the right?
+    * @param {boolean} up - Should the tile collide on the top?
+    * @param {boolean} down - Should the tile collide on the bottom?
+    */
     setCollisionRange: function (start, stop, left, right, up, down) {
 
         if (this.tiles[start] && this.tiles[stop] && start < stop)
@@ -77,6 +160,16 @@ Phaser.Tileset.prototype = {
 
     },
 
+    /**
+    * Sets collision values on a tile in the set.
+    *
+    * @method Phaser.Tileset#setCollision
+    * @param {number} index - The index of the tile within the set.
+    * @param {boolean} left - Should the tile collide on the left?
+    * @param {boolean} right - Should the tile collide on the right?
+    * @param {boolean} up - Should the tile collide on the top?
+    * @param {boolean} down - Should the tile collide on the bottom?
+    */
     setCollision: function (index, left, right, up, down) {
 
         if (this.tiles[index])