diff --git a/resources/docstrap-master/template/tmpl/layout.tmpl b/resources/docstrap-master/template/tmpl/layout.tmpl
index 1c10534ef..3bdb178bb 100644
--- a/resources/docstrap-master/template/tmpl/layout.tmpl
+++ b/resources/docstrap-master/template/tmpl/layout.tmpl
@@ -49,6 +49,7 @@
 				<li class="dropdown">
 					<a href="#" class="dropdown-toggle" data-toggle="dropdown">Core<b class="caret"></b></a>
 					<ul class="dropdown-menu ">
+						<li class="class-depth-1"><a href="Phaser.Game.html">Game</a></li>
 						<li class="class-depth-1"><a href="Phaser.Group.html">Group</a></li>
 						<li class="class-depth-1"><a href="Phaser.World.html">World</a></li>
 						<li class="class-depth-1"><a href="Phaser.Loader.html">Loader</a></li>
@@ -71,6 +72,7 @@
 						<li class="class-depth-1"><a href="Phaser.Image.html">Image</a></li>
 						<li class="class-depth-1"><a href="Phaser.Sound.html">Sound</a></li>
 						<li class="class-depth-1"><a href="Phaser.Emitter.html">Emitter</a></li>
+						<li class="class-depth-1"><a href="Phaser.Particle.html">Particle</a></li>
 						<li class="class-depth-1"><a href="Phaser.Text.html">Text</a></li>
 						<li class="class-depth-1"><a href="Phaser.Tween.html">Tween</a></li>
 						<li class="class-depth-1"><a href="Phaser.BitmapText.html">BitmapText</a></li>
diff --git a/src/animation/Animation.js b/src/animation/Animation.js
index 825a70cc2..829c09300 100644
--- a/src/animation/Animation.js
+++ b/src/animation/Animation.js
@@ -741,7 +741,7 @@ Object.defineProperty(Phaser.Animation.prototype, 'enableUpdate', {
 * @param {number} stop - The number to count to. If your frames are named 'explosion_0001' to 'explosion_0034' the stop value is 34.
 * @param {string} [suffix=''] - The end of the filename. If the filename was 'explosion_0001-large' the prefix would be '-large'.
 * @param {number} [zeroPad=0] - The number of zeroes to pad the min and max values with. If your frames are named 'explosion_0001' to 'explosion_0034' then the zeroPad is 4.
-* @return {array} An array of framenames.
+* @return {string[]} An array of framenames.
 */
 Phaser.Animation.generateFrameNames = function (prefix, start, stop, suffix, zeroPad) {
 
diff --git a/src/animation/AnimationParser.js b/src/animation/AnimationParser.js
index 3a73a77f4..8f07d881b 100644
--- a/src/animation/AnimationParser.js
+++ b/src/animation/AnimationParser.js
@@ -101,7 +101,7 @@ Phaser.AnimationParser = {
     *
     * @method Phaser.AnimationParser.JSONData
     * @param {Phaser.Game} game - A reference to the currently running game.
-    * @param {Object} json - The JSON data from the Texture Atlas. Must be in Array format.
+    * @param {object} json - The JSON data from the Texture Atlas. Must be in Array format.
     * @param {string} cacheKey - The Game.Cache asset key of the texture image.
     * @return {Phaser.FrameData} A FrameData object containing the parsed frames.
     */
@@ -166,7 +166,7 @@ Phaser.AnimationParser = {
     *
     * @method Phaser.AnimationParser.JSONDataHash
     * @param {Phaser.Game} game - A reference to the currently running game.
-    * @param {Object} json - The JSON data from the Texture Atlas. Must be in JSON Hash format.
+    * @param {object} json - The JSON data from the Texture Atlas. Must be in JSON Hash format.
     * @param {string} cacheKey - The Game.Cache asset key of the texture image.
     * @return {Phaser.FrameData} A FrameData object containing the parsed frames.
     */
@@ -234,7 +234,7 @@ Phaser.AnimationParser = {
     *
     * @method Phaser.AnimationParser.XMLData
     * @param {Phaser.Game} game - A reference to the currently running game.
-    * @param {Object} xml - The XML data from the Texture Atlas. Must be in Starling XML format.
+    * @param {object} xml - The XML data from the Texture Atlas. Must be in Starling XML format.
     * @param {string} cacheKey - The Game.Cache asset key of the texture image.
     * @return {Phaser.FrameData} A FrameData object containing the parsed frames.
     */
diff --git a/src/core/Camera.js b/src/core/Camera.js
index a1f98e297..4fdb62747 100644
--- a/src/core/Camera.js
+++ b/src/core/Camera.js
@@ -99,7 +99,7 @@ Phaser.Camera = function (game, id, x, y, width, height) {
 
     /**
     * @property {number} totalInView - The total number of Sprites with `autoCull` set to `true` that are visible by this Camera.
-    * @readOnly
+    * @readonly
     */
     this.totalInView = 0;
 
diff --git a/src/core/Filter.js b/src/core/Filter.js
index 6ed99169c..895e2b1f9 100644
--- a/src/core/Filter.js
+++ b/src/core/Filter.js
@@ -10,7 +10,7 @@
 * @class Phaser.Filter
 * @constructor
 * @param {Phaser.Game} game - A reference to the currently running game.
-* @param {Object} uniforms - Uniform mappings object
+* @param {object} uniforms - Uniform mappings object
 * @param {Array} fragmentSrc - The fragment shader code.
 */
 Phaser.Filter = function (game, uniforms, fragmentSrc) {
diff --git a/src/core/FlexGrid.js b/src/core/FlexGrid.js
index 68c53a404..eb3e47722 100644
--- a/src/core/FlexGrid.js
+++ b/src/core/FlexGrid.js
@@ -107,7 +107,7 @@ Phaser.FlexGrid.prototype = {
      * @method Phaser.FlexGrid#createCustomLayer
      * @param {number} width - Width of this layer in pixels.
      * @param {number} height - Height of this layer in pixels.
-     * @param {array} [children] - An array of children that are used to populate the FlexLayer.
+     * @param {PIXI.DisplayObject[]} [children] - An array of children that are used to populate the FlexLayer.
      * @return {Phaser.FlexLayer} The Layer object.
      */
     createCustomLayer: function (width, height, children, addToWorld) {
@@ -195,7 +195,7 @@ Phaser.FlexGrid.prototype = {
      * A fixed layer is centered on the game and is the size of the required dimensions and is never scaled.
      *
      * @method Phaser.FlexGrid#createFixedLayer
-     * @param {array} [children] - An array of children that are used to populate the FlexLayer.
+     * @param {PIXI.DisplayObject[]} [children] - An array of children that are used to populate the FlexLayer.
      * @return {Phaser.FlexLayer} The Layer object.
      */
     createFixedLayer: function (children) {
diff --git a/src/core/Game.js b/src/core/Game.js
index 0508b2694..ae759ed8c 100644
--- a/src/core/Game.js
+++ b/src/core/Game.js
@@ -26,6 +26,7 @@ Phaser.Game = function (width, height, renderer, parent, state, transparent, ant
 
     /**
     * @property {number} id - Phaser Game ID (for when Pixi supports multiple instances).
+    * @readonly
     */
     this.id = Phaser.GAMES.push(this) - 1;
 
@@ -99,11 +100,13 @@ Phaser.Game = function (width, height, renderer, parent, state, transparent, ant
 
     /**
     * @property {PIXI.CanvasRenderer|PIXI.WebGLRenderer} renderer - The Pixi Renderer.
+    * @protected
     */
     this.renderer = null;
 
     /**
     * @property {number} renderType - The Renderer this game will use. Either Phaser.AUTO, Phaser.CANVAS or Phaser.WEBGL.
+    * @readonly
     */
     this.renderType = Phaser.AUTO;
 
@@ -114,18 +117,19 @@ Phaser.Game = function (width, height, renderer, parent, state, transparent, ant
 
     /**
     * @property {boolean} isBooted - Whether the game engine is booted, aka available.
-    * @default
+    * @readonly
     */
     this.isBooted = false;
 
     /**
-    * @property {boolean} id -Is game running or paused?
-    * @default
+    * @property {boolean} isRunning - Is game running or paused?
+    * @readonly
     */
     this.isRunning = false;
 
     /**
     * @property {Phaser.RequestAnimationFrame} raf - Automatically handles the core game loop via requestAnimationFrame or setTimeout
+    * @protected
     */
     this.raf = null;
 
diff --git a/src/core/Group.js b/src/core/Group.js
index 6c45d36ba..5b001b1b4 100644
--- a/src/core/Group.js
+++ b/src/core/Group.js
@@ -5,18 +5,24 @@
 */
 
 /**
-* A Group is a container for display objects that allows for fast pooling and object recycling.
-* Groups can be nested within other Groups and have their own local transforms.
+* A Group is a container for {@link DisplayObject display objects} including {@link Phaser.Sprite Sprites} and {@link Phaser.Image Images}.
+*
+* Groups form the logical tree structure of the display/scene graph where local transformations are applied to children.
+* For instance, all children are also moved/rotated/scaled when the group is moved/rotated/scaled.
+*
+* In addition, Groups provides support for fast pooling and object recycling.
+*
+* Groups are also display objects and can be nested as children within other Groups.
 * 
 * @class Phaser.Group
 * @extends PIXI.DisplayObjectContainer
-* @constructor
 * @param {Phaser.Game} game - A reference to the currently running game.
-* @param {Phaser.Group|Phaser.Sprite|null} parent - The parent Group, DisplayObject or DisplayObjectContainer that this Group will be added to. If `undefined` it will use game.world. If null it won't be added to anything.
-* @param {string} [name=group] - A name for this Group. Not used internally but useful for debugging.
-* @param {boolean} [addToStage=false] - If set to true this Group will be added directly to the Game.Stage instead of Game.World.
-* @param {boolean} [enableBody=false] - If true all Sprites created with `Group.create` or `Group.createMulitple` will have a physics body created on them. Change the body type with physicsBodyType.
-* @param {number} [physicsBodyType=0] - If enableBody is true this is the type of physics body that is created on new Sprites. Phaser.Physics.ARCADE, Phaser.Physics.P2, Phaser.Physics.NINJA, etc.
+* @param {DisplayObject|null} [parent=(game world)] - The parent Group (or other {@link DisplayObject}) that this group will be added to.
+*     If undefined/unspecified the Group will be added to the {@link Phaser.Game#world Game World}; if null the Group will not be added to any parent.
+* @param {string} [name='group'] - A name for this group. Not used internally but useful for debugging.
+* @param {boolean} [addToStage=false] - If true this group will be added directly to the Game.Stage instead of Game.World.
+* @param {boolean} [enableBody=false] - If true all Sprites created with {@link #create} or {@link #createMulitple} will have a physics body created on them. Change the body type with {@link #physicsBodyType}.
+* @param {integer} [physicsBodyType=0] - The physics body type to use when physics bodies are automatically added. See {@link #physicsBodyType} for values.
 */
 Phaser.Group = function (game, parent, name, addToStage, enableBody, physicsBodyType) {
 
@@ -25,7 +31,9 @@ Phaser.Group = function (game, parent, name, addToStage, enableBody, physicsBody
     if (typeof physicsBodyType === 'undefined') { physicsBodyType = Phaser.Physics.ARCADE; }
 
     /**
-    * @property {Phaser.Game} game - A reference to the currently running Game.
+    * A reference to the currently running Game.
+    * @property {Phaser.Game} game
+    * @protected
     */
     this.game = game;
 
@@ -35,12 +43,15 @@ Phaser.Group = function (game, parent, name, addToStage, enableBody, physicsBody
     }
 
     /**
-    * @property {string} name - A name for this Group. Not used internally but useful for debugging.
+    * A name for this group. Not used internally but useful for debugging.
+    * @property {string} name
     */
     this.name = name || 'group';
 
     /**
-    * @property {number} z - The z-depth value of this object within its Group (remember the World is a Group as well). No two objects in a Group can have the same z value.
+    * The z-depth value of this object within its parent container/Group - the World is a Group as well.
+    * This value must be unique for each child in a Group.
+    * @property {integer} z
     */
     this.z = 0;
 
@@ -58,77 +69,99 @@ Phaser.Group = function (game, parent, name, addToStage, enableBody, physicsBody
     }
 
     /**
-    * @property {number} type - Internal Phaser Type value.
+    * Internal Phaser Type value.
+    * @property {integer} type
     * @protected
     */
     this.type = Phaser.GROUP;
 
     /**
-    * @property {boolean} alive - The alive property is useful for Groups that are children of other Groups and need to be included/excluded in checks like forEachAlive.
+    * The alive property is useful for Groups that are children of other Groups and need to be included/excluded in checks like forEachAlive.
+    * @property {boolean} alive
     * @default
     */
     this.alive = true;
 
     /**
-    * @property {boolean} exists - If exists is true the Group is updated, otherwise it is skipped.
+    * If exists is true the group is updated, otherwise it is skipped.
+    * @property {boolean} exists
     * @default
     */
     this.exists = true;
 
     /**
-    * @property {boolean} ignoreDestroy - A Group with `ignoreDestroy` set to `true` ignores all calls to its `destroy` method.
+    * A group with `ignoreDestroy` set to `true` ignores all calls to its `destroy` method.
+    * @property {boolean} ignoreDestroy
     * @default
     */
     this.ignoreDestroy = false;
 
     /**
-    * The type of objects that will be created when you use Group.create or Group.createMultiple. Defaults to Phaser.Sprite.
-    * When a new object is created it is passed the following parameters to its constructor: game, x, y, key, frame.
+    * The type of objects that will be created when using {@link #create} or {@link #createMultiple}.
+    *
+    * Any object may be used but it should extend either Sprite or Image and accept the same constructor arguments:
+    * when a new object is created it is passed the following parameters to its constructor: `(game, x, y, key, frame)`.
+    *
     * @property {object} classType
-    * @default
+    * @default {@link Phaser.Sprite}
     */
     this.classType = Phaser.Sprite;
 
     /**
-    * @property {Phaser.Point} scale - The scale of the Group container.
+    * The scale of the group container.
+    *
+    * @property {Phaser.Point} scale
     */
     this.scale = new Phaser.Point(1, 1);
 
     /**
-    * The cursor is a simple way to iterate through the objects in a Group using the Group.next and Group.previous functions.
-    * The cursor is set to the first child added to the Group and doesn't change unless you call next, previous or set it directly with Group.cursor.
-    * @property {any} cursor - The current display object that the Group cursor is pointing to.
+    * The current display object that the group cursor is pointing to, if any. (Can be set manully.)
+    *
+    * The cursor is a way to iterate through the children in a Group using {@link #next} and {@link #previous}.
+    * @property {?DisplayObject} cursor
     */
     this.cursor = null;
 
     /**
-    * @property {Phaser.Point} cameraOffset - If this object is fixedToCamera then this stores the x/y offset that its drawn at, from the top-left of the camera view.
+    * If this object is {@link #fixedToCamera} then this stores the x/y position offset relative to the top-left of the camera view.
+    * @property {Phaser.Point} cameraOffset
     */
     this.cameraOffset = new Phaser.Point();
 
     /**
-    * @property {boolean} enableBody - If true all Sprites created by, or added to this Group, will have a physics body enabled on them. Change the body type with `Group.physicsBodyType`.
-    * @default
+    * If true all Sprites created by, or added to this group, will have a physics body enabled on them.
+    *
+    * The default body type is controlled with {@link #physicsBodyType}.
+    * @property {boolean} enableBody
     */
     this.enableBody = enableBody;
 
     /**
-    * @property {boolean} enableBodyDebug - If true when a physics body is created (via Group.enableBody) it will create a physics debug object as well. Only works for P2 bodies.
+    * If true when a physics body is created (via {@link #enableBody}) it will create a physics debug object as well.
+    *
+    * This only works for P2 bodies.
+    * @property {boolean} enableBodyDebug
+    * @default
     */
     this.enableBodyDebug = false;
 
     /**
-    * @property {number} physicsBodyType - If Group.enableBody is true this is the type of physics body that is created on new Sprites. Phaser.Physics.ARCADE, Phaser.Physics.P2, Phaser.Physics.NINJA, etc.
+    * If {@link #enableBody} is true this is the type of physics body that is created on new Sprites.
+    *
+    * The valid values are {@link Phaser.Physics.ARCADE}, {@link Phaser.Physics.P2}, {@link Phaser.Physics.NINJA}, etc.
+    * @property {integer} physicsBodyType
     */
     this.physicsBodyType = physicsBodyType;
 
     /**
-    * @property {Phaser.Signal} onDestroy - This signal is dispatched if this Group is destroyed.
+    * This signal is dispatched when the group is destroyed.
+    * @property {Phaser.Signal} onDestroy
     */
     this.onDestroy = new Phaser.Signal();
 
     /**
-    * @property {string} _sortProperty - The property on which children are sorted.
+    * The property on which children are sorted.
+    * @property {string} _sortProperty
     * @private
     */
     this._sortProperty = 'z';
@@ -156,46 +189,51 @@ Phaser.Group.prototype = Object.create(PIXI.DisplayObjectContainer.prototype);
 Phaser.Group.prototype.constructor = Phaser.Group;
 
 /**
+* A returnType value, as specified in {@link #iterate} eg.
 * @constant
-* @type {number}
+* @type {integer}
 */
 Phaser.Group.RETURN_NONE = 0;
 
 /**
+* A returnType value, as specified in {@link #iterate} eg.
 * @constant
-* @type {number}
+* @type {integer}
 */
 Phaser.Group.RETURN_TOTAL = 1;
 
 /**
+* A returnType value, as specified in {@link #iterate} eg.
 * @constant
-* @type {number}
+* @type {integer}
 */
 Phaser.Group.RETURN_CHILD = 2;
 
 /**
+* A sort ordering value, as specified in {@link #sort} eg.
 * @constant
-* @type {number}
+* @type {integer}
 */
 Phaser.Group.SORT_ASCENDING = -1;
 
 /**
+* A sort ordering value, as specified in {@link #sort} eg.
 * @constant
-* @type {number}
+* @type {integer}
 */
 Phaser.Group.SORT_DESCENDING = 1;
 
 /**
-* Adds an existing object to this Group. The object can be an instance of Phaser.Sprite, Phaser.Button or any other display object.
-* The child is automatically added to the top of the Group, so renders on-top of everything else within the Group. If you need to control
-* that then see the addAt method.
+* Adds an existing object as the top child in this group.
+*
+* The child is automatically added to the top of the group and is displayed on top of every previous child.
+*
+* Use {@link #addAt} to control where a child is added. Use {@link #create} to create and add a new child.
 *
-* @see Phaser.Group#create
-* @see Phaser.Group#addAt
 * @method Phaser.Group#add
-* @param {*} child - An instance of Phaser.Sprite, Phaser.Button or any other display object.
-* @param {boolean} [silent=false] - If the silent parameter is `true` the child will not dispatch the onAddedToGroup event.
-* @return {*} The child that was added to the Group.
+* @param {DisplayObject} child - The display object to add as a child.
+* @param {boolean} [silent=false] - If true the child will not dispatch the `onAddedToGroup` event.
+* @return {DisplayObject} The child that was added to the group.
 */
 Phaser.Group.prototype.add = function (child, silent) {
 
@@ -228,14 +266,16 @@ Phaser.Group.prototype.add = function (child, silent) {
 };
 
 /**
-* Adds an array existing objects to this Group. The objects can be instances of Phaser.Sprite, Phaser.Button or any other display object.
-* The children are automatically added to the top of the Group, so render on-top of everything else within the Group.
+* Adds an array of existing display objects to this group.
+*
+* The children are automatically added to the top of the group, so render on-top of everything else within the group.
+*
 * TODO: Add ability to pass the children as parameters rather than having to be an array.
 *
 * @method Phaser.Group#addMultiple
-* @param {array} children - An array containing instances of Phaser.Sprite, Phaser.Button or any other display object.
-* @param {boolean} [silent=false] - If the silent parameter is `true` the children will not dispatch the onAddedToGroup event.
-* @return {*} The array of children that were added to the Group.
+* @param {DisplayObject[]} children - An array of display objects to add as children.
+* @param {boolean} [silent=false] - If true the children will not dispatch the `onAddedToGroup` event.
+* @return {DisplayObject[]} The array of children that were added to the group.
 */
 Phaser.Group.prototype.addMultiple = function (children, silent) {
 
@@ -252,14 +292,15 @@ Phaser.Group.prototype.addMultiple = function (children, silent) {
 };
 
 /**
-* Adds an existing object to this Group. The object can be an instance of Phaser.Sprite, Phaser.Button or any other display object.
-* The child is added to the Group at the location specified by the index value, this allows you to control child ordering.
+* Adds an existing object to this group.
+*
+* The child is added to the group at the location specified by the index value, this allows you to control child ordering.
 *
 * @method Phaser.Group#addAt
-* @param {*} child - An instance of Phaser.Sprite, Phaser.Button or any other display object..
-* @param {number} index - The index within the Group to insert the child to.
-* @param {boolean} [silent=false] - If the silent parameter is `true` the child will not dispatch the onAddedToGroup event.
-* @return {*} The child that was added to the Group.
+* @param {DisplayObject} child - The display object to add as a child.
+* @param {integer} [index=0] - The index within the group to insert the child to.
+* @param {boolean} [silent=false] - If true the child will not dispatch the `onAddedToGroup` event.
+* @return {DisplayObject} The child that was added to the group.
 */
 Phaser.Group.prototype.addAt = function (child, index, silent) {
 
@@ -292,11 +333,11 @@ Phaser.Group.prototype.addAt = function (child, index, silent) {
 };
 
 /**
-* Returns the child found at the given index within this Group.
+* Returns the child found at the given index within this group.
 *
 * @method Phaser.Group#getAt
-* @param {number} index - The index to return the child from.
-* @return {*} The child that was found at the given index. If the index was out of bounds then this will return -1.
+* @param {integer} index - The index to return the child from.
+* @return {DisplayObject} The child that was found at the given index, or -1 for an invalid index.
 */
 Phaser.Group.prototype.getAt = function (index) {
 
@@ -312,16 +353,17 @@ Phaser.Group.prototype.getAt = function (index) {
 };
 
 /**
-* Automatically creates a new Phaser.Sprite object and adds it to the top of this Group.
-* You can change Group.classType to any object and this call will create an object of that type instead, but it should extend either Sprite or Image.
+* Creates a new Phaser.Sprite object and adds it to the top of this group.
+*
+* Use {@link #classType} to change the type of object creaded.
 *
 * @method Phaser.Group#create
-* @param {number} x - The x coordinate to display the newly created Sprite at. The value is in relation to the Group.x point.
-* @param {number} y - The y coordinate to display the newly created Sprite at. The value is in relation to the Group.y point.
+* @param {number} x - The x coordinate to display the newly created Sprite at. The value is in relation to the group.x point.
+* @param {number} y - The y coordinate to display the newly created Sprite at. The value is in relation to the group.y point.
 * @param {string} key - The Game.cache key of the image that this Sprite will use.
-* @param {number|string} [frame] - If the Sprite image contains multiple frames you can specify which one to use here.
+* @param {integer|string} [frame] - If the Sprite image contains multiple frames you can specify which one to use here.
 * @param {boolean} [exists=true] - The default exists state of the Sprite.
-* @return {Phaser.Sprite|object} The child that was created. Will be a Phaser.Sprite unless Group.classType has been changed.
+* @return {DisplayObject} The child that was created: will be a {@link Phaser.Sprite} unless {@link #classType} has been changed.
 */
 Phaser.Group.prototype.create = function (x, y, key, frame, exists) {
 
@@ -357,15 +399,17 @@ Phaser.Group.prototype.create = function (x, y, key, frame, exists) {
 };
 
 /**
-* Automatically creates multiple Phaser.Sprite objects and adds them to the top of this Group.
-* Useful if you need to quickly generate a pool of identical sprites, such as bullets. By default the sprites will be set to not exist
-* and will be positioned at 0, 0 (relative to the Group.x/y)
-* You can change Group.classType to any object and this call will create an object of that type instead, but it should extend either Sprite or Image.
+* Creates multiple Phaser.Sprite objects and adds them to the top of this group.
+*
+* Useful if you need to quickly generate a pool of identical sprites, such as bullets.
+*
+* By default the sprites will be set to not exist and will be positioned at 0, 0 (relative to the group.x/y).
+* Use {@link #classType} to change the type of object creaded.
 *
 * @method Phaser.Group#createMultiple
-* @param {number} quantity - The number of Sprites to create.
+* @param {integer} quantity - The number of Sprites to create.
 * @param {string} key - The Game.cache key of the image that this Sprite will use.
-* @param {number|string} [frame] - If the Sprite image contains multiple frames you can specify which one to use here.
+* @param {integer|string} [frame] - If the Sprite image contains multiple frames you can specify which one to use here.
 * @param {boolean} [exists=false] - The default exists state of the Sprite.
 */
 Phaser.Group.prototype.createMultiple = function (quantity, key, frame, exists) {
@@ -382,6 +426,8 @@ Phaser.Group.prototype.createMultiple = function (quantity, key, frame, exists)
 /**
 * Internal method that re-applies all of the childrens Z values.
 *
+* This must be called whenever children ordering is altered so that their `z` indices are correctly updated.
+*
 * @method Phaser.Group#updateZ
 * @protected
 */
@@ -397,11 +443,13 @@ Phaser.Group.prototype.updateZ = function () {
 };
 
 /**
-* Sets the Group cursor to the first object in the Group. If the optional index parameter is given it sets the cursor to the object at that index instead.
+* Sets the group cursor to the first child in the group.
+*
+* If the optional index parameter is given it sets the cursor to the object at that index instead.
 *
 * @method Phaser.Group#resetCursor
-* @param {number} [index=0] - Set the cursor to point to a specific index.
-* @return {*} The child the cursor now points to.
+* @param {integer} [index=0] - Set the cursor to point to a specific index.
+* @return {any} The child the cursor now points to.
 */
 Phaser.Group.prototype.resetCursor = function (index) {
 
@@ -422,10 +470,12 @@ Phaser.Group.prototype.resetCursor = function (index) {
 };
 
 /**
-* Advances the Group cursor to the next object in the Group. If it's at the end of the Group it wraps around to the first object.
+* Advances the group cursor to the next (higher) object in the group.
+*
+* If the cursor is at the end of the group (top child) it is moved the start of the group (bottom child).
 *
 * @method Phaser.Group#next
-* @return {*} The child the cursor now points to.
+* @return {any} The child the cursor now points to.
 */
 Phaser.Group.prototype.next = function () {
 
@@ -449,10 +499,12 @@ Phaser.Group.prototype.next = function () {
 };
 
 /**
-* Moves the Group cursor to the previous object in the Group. If it's at the start of the Group it wraps around to the last object.
+* Moves the group cursor to the previous (lower) child in the group.
+*
+* If the cursor is at the start of the group (bottom child) it is moved to the end (top child).
 *
 * @method Phaser.Group#previous
-* @return {*} The child the cursor now points to.
+* @return {any} The child the cursor now points to.
 */
 Phaser.Group.prototype.previous = function () {
 
@@ -476,12 +528,13 @@ Phaser.Group.prototype.previous = function () {
 };
 
 /**
-* Swaps the position of two children in this Group. Both children must be in this Group.
-* You cannot swap a child with itself, or swap un-parented children.
+* Swaps the position of two children in this group.
+*
+* Both children must be in this group, a child cannot be swapped with itself, and unparented children cannot be swapped.
 *
 * @method Phaser.Group#swap
-* @param {*} child1 - The first child to swap.
-* @param {*} child2 - The second child to swap.
+* @param {any} child1 - The first child to swap.
+* @param {any} child2 - The second child to swap.
 */
 Phaser.Group.prototype.swap = function (child1, child2) {
 
@@ -491,11 +544,11 @@ Phaser.Group.prototype.swap = function (child1, child2) {
 };
 
 /**
-* Brings the given child to the top of this Group so it renders above all other children.
+* Brings the given child to the top of this group so it renders above all other children.
 *
 * @method Phaser.Group#bringToTop
-* @param {*} child - The child to bring to the top of this Group.
-* @return {*} The child that was moved.
+* @param {any} child - The child to bring to the top of this group.
+* @return {any} The child that was moved.
 */
 Phaser.Group.prototype.bringToTop = function (child) {
 
@@ -510,11 +563,11 @@ Phaser.Group.prototype.bringToTop = function (child) {
 };
 
 /**
-* Sends the given child to the bottom of this Group so it renders below all other children.
+* Sends the given child to the bottom of this group so it renders below all other children.
 *
 * @method Phaser.Group#sendToBack
-* @param {*} child - The child to send to the bottom of this Group.
-* @return {*} The child that was moved.
+* @param {any} child - The child to send to the bottom of this group.
+* @return {any} The child that was moved.
 */
 Phaser.Group.prototype.sendToBack = function (child) {
 
@@ -529,11 +582,11 @@ Phaser.Group.prototype.sendToBack = function (child) {
 };
 
 /**
-* Moves the given child up one place in this Group unless it's already at the top.
+* Moves the given child up one place in this group unless it's already at the top.
 *
 * @method Phaser.Group#moveUp
-* @param {*} child - The child to move up in the Group.
-* @return {*} The child that was moved.
+* @param {any} child - The child to move up in the group.
+* @return {any} The child that was moved.
 */
 Phaser.Group.prototype.moveUp = function (child) {
 
@@ -553,11 +606,11 @@ Phaser.Group.prototype.moveUp = function (child) {
 };
 
 /**
-* Moves the given child down one place in this Group unless it's already at the top.
+* Moves the given child down one place in this group unless it's already at the bottom.
 *
 * @method Phaser.Group#moveDown
-* @param {*} child - The child to move down in the Group.
-* @return {*} The child that was moved.
+* @param {any} child - The child to move down in the group.
+* @return {any} The child that was moved.
 */
 Phaser.Group.prototype.moveDown = function (child) {
 
@@ -577,10 +630,10 @@ Phaser.Group.prototype.moveDown = function (child) {
 };
 
 /**
-* Positions the child found at the given index within this Group to the given x and y coordinates.
+* Positions the child found at the given index within this group to the given x and y coordinates.
 *
 * @method Phaser.Group#xy
-* @param {number} index - The index of the child in the Group to set the position of.
+* @param {integer} index - The index of the child in the group to set the position of.
 * @param {number} x - The new x position of the child.
 * @param {number} y - The new y position of the child.
 */
@@ -599,7 +652,9 @@ Phaser.Group.prototype.xy = function (index, x, y) {
 };
 
 /**
-* Reverses all children in this Group. Note that this does not propagate, only direct children are re-ordered.
+* Reverses all children in this group.
+*
+* This operaation applies only to immediate children and does not propagate to subgroups.
 *
 * @method Phaser.Group#reverse
 */
@@ -611,11 +666,11 @@ Phaser.Group.prototype.reverse = function () {
 };
 
 /**
-* Get the index position of the given child in this Group. This should always match the childs z property.
+* Get the index position of the given child in this group, which should match the child's `z` property.
 *
 * @method Phaser.Group#getIndex
-* @param {*} child - The child to get the index for.
-* @return {number} The index of the child or -1 if it's not a member of this Group.
+* @param {any} child - The child to get the index for.
+* @return {integer} The index of the child or -1 if it's not a member of this group.
 */
 Phaser.Group.prototype.getIndex = function (child) {
 
@@ -624,12 +679,12 @@ Phaser.Group.prototype.getIndex = function (child) {
 };
 
 /**
-* Replaces a child of this Group with the given newChild. The newChild cannot be a member of this Group.
+* Replaces a child of this group with the given newChild. The newChild cannot be a member of this group.
 *
 * @method Phaser.Group#replace
-* @param {*} oldChild - The child in this Group that will be replaced.
-* @param {*} newChild - The child to be inserted into this Group.
-* @return {*} Returns the oldChild that was replaced within this Group.
+* @param {any} oldChild - The child in this group that will be replaced.
+* @param {any} newChild - The child to be inserted into this group.
+* @return {any} Returns the oldChild that was replaced within this group.
 */
 Phaser.Group.prototype.replace = function (oldChild, newChild) {
 
@@ -660,11 +715,13 @@ Phaser.Group.prototype.replace = function (oldChild, newChild) {
 };
 
 /**
-* Checks if the child has the given property. Will scan up to 4 levels deep only.
+* Checks if the child has the given property.
+*
+* Will scan up to 4 levels deep only.
 *
 * @method Phaser.Group#hasProperty
-* @param {*} child - The child to check for the existance of the property on.
-* @param {array} key - An array of strings that make up the property.
+* @param {any} child - The child to check for the existance of the property on.
+* @param {string[]} key - An array of strings that make up the property.
 * @return {boolean} True if the child has the property, otherwise false.
 */
 Phaser.Group.prototype.hasProperty = function (child, key) {
@@ -694,17 +751,19 @@ Phaser.Group.prototype.hasProperty = function (child, key) {
 
 /**
 * Sets a property to the given value on the child. The operation parameter controls how the value is set.
-* Operation 0 means set the existing value to the given value, or if force is `false` create a new property with the given value.
-* 1 will add the given value to the value already present.
-* 2 will subtract the given value from the value already present.
-* 3 will multiply the value already present by the given value.
-* 4 will divide the value already present by the given value.
+*
+* The operations are:
+* - 0: set the existing value to the given value; if force is `true` a new property will be created if needed
+* - 1: will add the given value to the value already present.
+* - 2: will subtract the given value from the value already present.
+* - 3: will multiply the value already present by the given value.
+* - 4: will divide the value already present by the given value.
 *
 * @method Phaser.Group#setProperty
-* @param {*} child - The child to set the property value on.
+* @param {any} child - The child to set the property value on.
 * @param {array} key - An array of strings that make up the property that will be set.
-* @param {*} value - The value that will be set.
-* @param {number} [operation=0] - Controls how the value is assigned. A value of 0 replaces the value with the new one. A value of 1 adds it, 2 subtracts it, 3 multiplies it and 4 divides it.
+* @param {any} value - The value that will be set.
+* @param {integer} [operation=0] - Controls how the value is assigned. A value of 0 replaces the value with the new one. A value of 1 adds it, 2 subtracts it, 3 multiplies it and 4 divides it.
 * @param {boolean} [force=false] - If `force` is true then the property will be set on the child regardless if it already exists or not. If false and the property doesn't exist, nothing will be set.
 * @return {boolean} True if the property was set, false if not.
 */
@@ -772,9 +831,9 @@ Phaser.Group.prototype.setProperty = function (child, key, value, operation, for
 * Checks a property for the given value on the child.
 *
 * @method Phaser.Group#checkProperty
-* @param {*} child - The child to check the property value on.
+* @param {any} child - The child to check the property value on.
 * @param {array} key - An array of strings that make up the property that will be set.
-* @param {*} value - The value that will be checked.
+* @param {any} value - The value that will be checked.
 * @param {boolean} [force=false] - If `force` is true then the property will be checked on the child regardless if it already exists or not. If true and the property doesn't exist, false will be returned.
 * @return {boolean} True if the property was was equal to value, false if not.
 */
@@ -798,16 +857,17 @@ Phaser.Group.prototype.checkProperty = function (child, key, value, force) {
 };
 
 /**
-* This function allows you to quickly set a property on a single child of this Group to a new value.
+* Quickly set a property on a single child of this group to a new value.
+*
 * The operation parameter controls how the new value is assigned to the property, from simple replacement to addition and multiplication.
 *
 * @method Phaser.Group#set
 * @param {Phaser.Sprite} child - The child to set the property on.
 * @param {string} key - The property, as a string, to be set. For example: 'body.velocity.x'
-* @param {*} value - The value that will be set.
+* @param {any} value - The value that will be set.
 * @param {boolean} [checkAlive=false] - If set then the child will only be updated if alive=true.
 * @param {boolean} [checkVisible=false] - If set then the child will only be updated if visible=true.
-* @param {number} [operation=0] - Controls how the value is assigned. A value of 0 replaces the value with the new one. A value of 1 adds it, 2 subtracts it, 3 multiplies it and 4 divides it.
+* @param {integer} [operation=0] - Controls how the value is assigned. A value of 0 replaces the value with the new one. A value of 1 adds it, 2 subtracts it, 3 multiplies it and 4 divides it.
 * @param {boolean} [force=false] - If `force` is true then the property will be set on the child regardless if it already exists or not. If false and the property doesn't exist, nothing will be set.
 * @return {boolean} True if the property was set, false if not.
 */
@@ -828,18 +888,19 @@ Phaser.Group.prototype.set = function (child, key, value, checkAlive, checkVisib
 };
 
 /**
-* This function allows you to quickly set the same property across all children of this Group to a new value.
-* This call doesn't descend down children, so if you have a Group inside of this Group, the property will be set on the Group but not its children.
+* Quickly set the same property across all children of this group to a new value.
+*
+* This call doesn't descend down children, so if you have a Group inside of this group, the property will be set on the group but not its children.
 * If you need that ability please see `Group.setAllChildren`.
 *
 * The operation parameter controls how the new value is assigned to the property, from simple replacement to addition and multiplication.
 *
 * @method Phaser.Group#setAll
 * @param {string} key - The property, as a string, to be set. For example: 'body.velocity.x'
-* @param {*} value - The value that will be set.
+* @param {any} value - The value that will be set.
 * @param {boolean} [checkAlive=false] - If set then only children with alive=true will be updated. This includes any Groups that are children.
 * @param {boolean} [checkVisible=false] - If set then only children with visible=true will be updated. This includes any Groups that are children.
-* @param {number} [operation=0] - Controls how the value is assigned. A value of 0 replaces the value with the new one. A value of 1 adds it, 2 subtracts it, 3 multiplies it and 4 divides it.
+* @param {integer} [operation=0] - Controls how the value is assigned. A value of 0 replaces the value with the new one. A value of 1 adds it, 2 subtracts it, 3 multiplies it and 4 divides it.
 * @param {boolean} [force=false] - If `force` is true then the property will be set on the child regardless if it already exists or not. If false and the property doesn't exist, nothing will be set.
 */
 Phaser.Group.prototype.setAll = function (key, value, checkAlive, checkVisible, operation, force) {
@@ -862,19 +923,19 @@ Phaser.Group.prototype.setAll = function (key, value, checkAlive, checkVisible,
 };
 
 /**
-* This function allows you to quickly set the same property across all children of this Group, and any child Groups, to a new value.
+* Quickly set the same property across all children of this group, and any child Groups, to a new value.
 *
-* If this Group contains other Groups then the same property is set across their children as well, iterating down until it reaches the bottom.
-* Unlike with Group.setAll the property is NOT set on child Groups itself.
+* If this group contains other Groups then the same property is set across their children as well, iterating down until it reaches the bottom.
+* Unlike with `setAll` the property is NOT set on child Groups itself.
 *
 * The operation parameter controls how the new value is assigned to the property, from simple replacement to addition and multiplication.
 *
 * @method Phaser.Group#setAllChildren
 * @param {string} key - The property, as a string, to be set. For example: 'body.velocity.x'
-* @param {*} value - The value that will be set.
+* @param {any} value - The value that will be set.
 * @param {boolean} [checkAlive=false] - If set then only children with alive=true will be updated. This includes any Groups that are children.
 * @param {boolean} [checkVisible=false] - If set then only children with visible=true will be updated. This includes any Groups that are children.
-* @param {number} [operation=0] - Controls how the value is assigned. A value of 0 replaces the value with the new one. A value of 1 adds it, 2 subtracts it, 3 multiplies it and 4 divides it.
+* @param {integer} [operation=0] - Controls how the value is assigned. A value of 0 replaces the value with the new one. A value of 1 adds it, 2 subtracts it, 3 multiplies it and 4 divides it.
 * @param {boolean} [force=false] - If `force` is true then the property will be set on the child regardless if it already exists or not. If false and the property doesn't exist, nothing will be set.
 */
 Phaser.Group.prototype.setAllChildren = function (key, value, checkAlive, checkVisible, operation, force) {
@@ -903,12 +964,13 @@ Phaser.Group.prototype.setAllChildren = function (key, value, checkAlive, checkV
 };
 
 /**
-* This function allows you to quickly check that the same property across all children of this Group is equal to the given value.
-* This call doesn't descend down children, so if you have a Group inside of this Group, the property will be checked on the Group but not its children.
+* Quickly check that the same property across all children of this group is equal to the given value.
+*
+* This call doesn't descend down children, so if you have a Group inside of this group, the property will be checked on the group but not its children.
 *
 * @method Phaser.Group#checkAll
 * @param {string} key - The property, as a string, to be set. For example: 'body.velocity.x'
-* @param {*} value - The value that will be checked.
+* @param {any} value - The value that will be checked.
 * @param {boolean} [checkAlive=false] - If set then only children with alive=true will be checked. This includes any Groups that are children.
 * @param {boolean} [checkVisible=false] - If set then only children with visible=true will be checked. This includes any Groups that are children.
 * @param {boolean} [force=false] - If `force` is true then the property will be checked on the child regardless if it already exists or not. If true and the property doesn't exist, false will be returned.
@@ -935,8 +997,9 @@ Phaser.Group.prototype.checkAll = function (key, value, checkAlive, checkVisible
 };
 
 /**
-* Adds the amount to the given property on all children in this Group.
-* Group.addAll('x', 10) will add 10 to the child.x value.
+* Adds the amount to the given property on all children in this group.
+*
+* `Group.addAll('x', 10)` will add 10 to the child.x value for each child.
 *
 * @method Phaser.Group#addAll
 * @param {string} property - The property to increment, for example 'body.velocity.x' or 'angle'.
@@ -951,8 +1014,9 @@ Phaser.Group.prototype.addAll = function (property, amount, checkAlive, checkVis
 };
 
 /**
-* Subtracts the amount from the given property on all children in this Group.
-* Group.subAll('x', 10) will minus 10 from the child.x value.
+* Subtracts the amount from the given property on all children in this group.
+*
+* `Group.subAll('x', 10)` will minus 10 from the child.x value for each child.
 *
 * @method Phaser.Group#subAll
 * @param {string} property - The property to decrement, for example 'body.velocity.x' or 'angle'.
@@ -967,8 +1031,9 @@ Phaser.Group.prototype.subAll = function (property, amount, checkAlive, checkVis
 };
 
 /**
-* Multiplies the given property by the amount on all children in this Group.
-* Group.multiplyAll('x', 2) will x2 the child.x value.
+* Multiplies the given property by the amount on all children in this group.
+*
+* `Group.multiplyAll('x', 2)` will x2 the child.x value for each child.
 *
 * @method Phaser.Group#multiplyAll
 * @param {string} property - The property to multiply, for example 'body.velocity.x' or 'angle'.
@@ -983,8 +1048,9 @@ Phaser.Group.prototype.multiplyAll = function (property, amount, checkAlive, che
 };
 
 /**
-* Divides the given property by the amount on all children in this Group.
-* Group.divideAll('x', 2) will half the child.x value.
+* Divides the given property by the amount on all children in this group.
+*
+* `Group.divideAll('x', 2)` will half the child.x value for each child.
 *
 * @method Phaser.Group#divideAll
 * @param {string} property - The property to divide, for example 'body.velocity.x' or 'angle'.
@@ -999,13 +1065,14 @@ Phaser.Group.prototype.divideAll = function (property, amount, checkAlive, check
 };
 
 /**
-* Calls a function on all of the children that have exists=true in this Group.
+* Calls a function, specified by name, on all children in the group who exist (or do not exist).
+*
 * After the existsValue parameter you can add as many parameters as you like, which will all be passed to the child callback.
 *
 * @method Phaser.Group#callAllExists
-* @param {function} callback - The function that exists on the children that will be called.
+* @param {string} callback - Name of the function on the children to call.
 * @param {boolean} existsValue - Only children with exists=existsValue will be called.
-* @param {...*} parameter - Additional parameters that will be passed to the callback.
+* @param {...any} parameter - Additional parameters that will be passed to the callback.
 */
 Phaser.Group.prototype.callAllExists = function (callback, existsValue) {
 
@@ -1027,12 +1094,12 @@ Phaser.Group.prototype.callAllExists = function (callback, existsValue) {
 };
 
 /**
-* Returns a reference to a function that exists on a child of the Group based on the given callback array.
+* Returns a reference to a function that exists on a child of the group based on the given callback array.
 *
 * @method Phaser.Group#callbackFromArray
 * @param {object} child - The object to inspect.
 * @param {array} callback - The array of function names.
-* @param {number} length - The size of the array (pre-calculated in callAll).
+* @param {integer} length - The size of the array (pre-calculated in callAll).
 * @protected
 */
 Phaser.Group.prototype.callbackFromArray = function (child, callback, length) {
@@ -1080,13 +1147,15 @@ Phaser.Group.prototype.callbackFromArray = function (child, callback, length) {
 };
 
 /**
-* Calls a function on all of the children regardless if they are dead or alive (see callAllExists if you need control over that)
+* Calls a function, specified by name, on all on children.
+*
+* The function is called for all children regardless if they are dead or alive (see callAllExists for different options).
 * After the method parameter and context you can add as many extra parameters as you like, which will all be passed to the child.
 *
 * @method Phaser.Group#callAll
-* @param {string} method - A string containing the name of the function that will be called. The function must exist on the child.
+* @param {string} method - Name of the function on the child to call. Deep property lookup is supported.
 * @param {string} [context=null] - A string containing the context under which the method will be executed. Set to null to default to the child.
-* @param {...*} parameter - Additional parameters that will be passed to the method.
+* @param {...any} args - Additional parameters that will be passed to the method.
 */
 Phaser.Group.prototype.callAll = function (method, context) {
 
@@ -1210,7 +1279,8 @@ Phaser.Group.prototype.postUpdate = function () {
 
 
 /**
-* Allows you to obtain a Phaser.ArraySet of children that return true for the given predicate
+* Find children matching a certain predicate.
+*
 * For example:
 *
 *     var healthyList = Group.filter(function(child, index, children) {
@@ -1221,8 +1291,8 @@ Phaser.Group.prototype.postUpdate = function () {
 * Note: Currently this will skip any children which are Groups themselves.
 *
 * @method Phaser.Group#filter
-* @param {function} predicate - The function that each child will be evaluated against. Each child of the Group will be passed to it as its first parameter, the index as the second, and the entire child array as the third
-* @param {boolean} [checkExists=false] - If set only children with exists=true will be passed to the callback, otherwise all children will be passed.
+* @param {function} predicate - The function that each child will be evaluated against. Each child of the group will be passed to it as its first parameter, the index as the second, and the entire child array as the third
+* @param {boolean} [checkExists=false] - If true, only existing can be selected; otherwise all children can be selected and will be passed to the predicate.
 * @return {Phaser.ArraySet} Returns an array list containing all the children that the predicate returned true for
 */
 Phaser.Group.prototype.filter = function (predicate, checkExists) {
@@ -1249,15 +1319,21 @@ Phaser.Group.prototype.filter = function (predicate, checkExists) {
 };
 
 /**
-* Allows you to call your own function on each member of this Group. You must pass the callback and context in which it will run.
-* After the checkExists parameter you can add as many parameters as you like, which will all be passed to the callback along with the child.
-* For example: Group.forEach(awardBonusGold, this, true, 100, 500)
+* Call a function on each child in this group.
+*
+* Additional arguments for the callback can be specified after the `checkExists` parameter. For example,
+*
+*     Group.forEach(awardBonusGold, this, true, 100, 500)
+*
+* would invoke thee `awardBonusGolds` with the parameters `(child, 100, 500)`.
+*
 * Note: Currently this will skip any children which are Groups themselves.
 *
 * @method Phaser.Group#forEach
-* @param {function} callback - The function that will be called. Each child of the Group will be passed to it as its first parameter.
-* @param {Object} callbackContext - The context in which the function should be called (usually 'this').
-* @param {boolean} [checkExists=false] - If set only children with exists=true will be passed to the callback, otherwise all children will be passed.
+* @param {function} callback - The function that will be called for each applicable child. The child will be passed as the first argument.
+* @param {object} callbackContext - The context in which the function should be called (usually 'this').
+* @param {boolean} [checkExists=false] - If set only children matching for which `exists` is true will be passed to the callback, otherwise all children will be passed.
+* @param {...any} [args=(none)] - Additional arguments to pass to the callback function, after the child item.
 */
 Phaser.Group.prototype.forEach = function (callback, callbackContext, checkExists) {
 
@@ -1293,13 +1369,14 @@ Phaser.Group.prototype.forEach = function (callback, callbackContext, checkExist
 };
 
 /**
-* Allows you to call your own function on each member of this Group where child.exists=true. You must pass the callback and context in which it will run.
-* You can add as many parameters as you like, which will all be passed to the callback along with the child.
-* For example: Group.forEachExists(causeDamage, this, 500)
+* Call a function on each existing child in this group.
+*
+* See {@link Phaser.Group#forEach forEach} for details.
 *
 * @method Phaser.Group#forEachExists
-* @param {function} callback - The function that will be called. Each child of the Group will be passed to it as its first parameter.
-* @param {Object} callbackContext - The context in which the function should be called (usually 'this').
+* @param {function} callback - The function that will be called for each applicable child. The child will be passed as the first argument.
+* @param {object} callbackContext - The context in which the function should be called (usually 'this').
+* @param {...any} [args=(none)] - Additional arguments to pass to the callback function, after the child item.
 */
 Phaser.Group.prototype.forEachExists = function (callback, callbackContext) {
 
@@ -1315,13 +1392,14 @@ Phaser.Group.prototype.forEachExists = function (callback, callbackContext) {
 };
 
 /**
-* Allows you to call your own function on each alive member of this Group (where child.alive=true). You must pass the callback and context in which it will run.
-* You can add as many parameters as you like, which will all be passed to the callback along with the child.
-* For example: Group.forEachAlive(causeDamage, this, 500)
+* Call a function on each alive child in this group.
+*
+* See {@link Phaser.Group#forEach forEach} for details.
 *
 * @method Phaser.Group#forEachAlive
-* @param {function} callback - The function that will be called. Each child of the Group will be passed to it as its first parameter.
-* @param {Object} callbackContext - The context in which the function should be called (usually 'this').
+* @param {function} callback - The function that will be called for each applicable child. The child will be passed as the first argument.
+* @param {object} callbackContext - The context in which the function should be called (usually 'this').
+* @param {...any} [args=(none)] - Additional arguments to pass to the callback function, after the child item.
 */
 Phaser.Group.prototype.forEachAlive = function (callback, callbackContext) {
 
@@ -1337,13 +1415,14 @@ Phaser.Group.prototype.forEachAlive = function (callback, callbackContext) {
 };
 
 /**
-* Allows you to call your own function on each dead member of this Group (where alive=false). You must pass the callback and context in which it will run.
-* You can add as many parameters as you like, which will all be passed to the callback along with the child.
-* For example: Group.forEachDead(bringToLife, this)
+* Call a function on each dead child in this group.
+*
+* See {@link Phaser.Group#forEach forEach} for details.
 *
 * @method Phaser.Group#forEachDead
-* @param {function} callback - The function that will be called. Each child of the Group will be passed to it as its first parameter.
-* @param {Object} callbackContext - The context in which the function should be called (usually 'this').
+* @param {function} callback - The function that will be called for each applicable child. The child will be passed as the first argument.
+* @param {object} callbackContext - The context in which the function should be called (usually 'this').
+* @param {...any} [args=(none)] - Additional arguments to pass to the callback function, after the child item.
 */
 Phaser.Group.prototype.forEachDead = function (callback, callbackContext) {
 
@@ -1359,14 +1438,16 @@ Phaser.Group.prototype.forEachDead = function (callback, callbackContext) {
 };
 
 /**
-* Call this function to sort the group according to a particular value and order.
+* Sort the children in the group according to a particular key and ordering.
+*
+* Call this function to sort the group according to a particular key value and order.
 * For example to depth sort Sprites for Zelda-style game you might call `group.sort('y', Phaser.Group.SORT_ASCENDING)` at the bottom of your `State.update()`.
 *
 * @method Phaser.Group#sort
-* @param {string} [index='z'] - The `string` name of the property you want to sort on. Defaults to the objects z-depth value.
-* @param {number} [order=Phaser.Group.SORT_ASCENDING] - The `Group` constant that defines the sort order. Possible values are Phaser.Group.SORT_ASCENDING and Phaser.Group.SORT_DESCENDING.
+* @param {string} [key='z'] - The name of the property to sort on. Defaults to the objects z-depth value.
+* @param {integer} [order=Phaser.Group.SORT_ASCENDING] - Order ascending ({@link Phaser.Group.SORT_ASCENDING SORT_ASCENDING}) or descending ({@link Phaser.Group.SORT_DESCENDING SORT_DESCENDING}).
 */
-Phaser.Group.prototype.sort = function (index, order) {
+Phaser.Group.prototype.sort = function (key, order) {
 
     if (this.children.length < 2)
     {
@@ -1374,10 +1455,10 @@ Phaser.Group.prototype.sort = function (index, order) {
         return;
     }
 
-    if (typeof index === 'undefined') { index = 'z'; }
+    if (typeof key === 'undefined') { key = 'z'; }
     if (typeof order === 'undefined') { order = Phaser.Group.SORT_ASCENDING; }
 
-    this._sortProperty = index;
+    this._sortProperty = key;
 
     if (order === Phaser.Group.SORT_ASCENDING)
     {
@@ -1393,12 +1474,14 @@ Phaser.Group.prototype.sort = function (index, order) {
 };
 
 /**
-* This allows you to use your own sort handler function.
-* It will be sent two parameters: the two children involved in the comparison (a and b). It should return -1 if a > b, 1 if a < b or 0 if a === b.
+* Sort the children in the group according to custom sort function.
+*
+* The `sortHandler` is provided the two parameters: the two children involved in the comparison (a and b).
+* It should return -1 if `a > b`, 1 if `a < b` or 0 if `a === b`.
 *
 * @method Phaser.Group#customSort
-* @param {function} sortHandler - Your sort handler function. It will be sent two parameters: the two children involved in the comparison. It must return -1, 1 or 0.
-* @param {object} context - The scope in which the sortHandler is called.
+* @param {function} sortHandler - The custom sort function.
+* @param {object} [context=undefined] - The context in which the sortHandler is called.
 */
 Phaser.Group.prototype.customSort = function (sortHandler, context) {
 
@@ -1418,6 +1501,7 @@ Phaser.Group.prototype.customSort = function (sortHandler, context) {
 * An internal helper function for the sort process.
 *
 * @method Phaser.Group#ascendingSortHandler
+* @protected
 * @param {object} a - The first object being sorted.
 * @param {object} b - The second object being sorted.
 */
@@ -1449,6 +1533,7 @@ Phaser.Group.prototype.ascendingSortHandler = function (a, b) {
 * An internal helper function for the sort process.
 *
 * @method Phaser.Group#descendingSortHandler
+* @protected
 * @param {object} a - The first object being sorted.
 * @param {object} b - The second object being sorted.
 */
@@ -1470,17 +1555,32 @@ Phaser.Group.prototype.descendingSortHandler = function (a, b) {
 };
 
 /**
-* Iterates over the children of the Group. When a child has a property matching key that equals the given value, it is considered as a match.
-* Matched children can be sent to the optional callback, or simply returned or counted.
-* You can add as many callback parameters as you like, which will all be passed to the callback along with the child, after the callbackContext parameter.
+* Iterates over the children of the group performing one of several actions for matched children.
+*
+* A child is considered a match when it has a property, named `key`, whose value is equal to `value`
+* according to a strict equality comparison.
+*
+* The result depends on the `returnType`:
+*
+* - {@link Phaser.Group.RETURN_TOTAL RETURN_TOTAL}:
+*     The callback, if any, is applied to all matching children. The number of matched children is returned.
+* - {@link Phaser.Group.RETURN_NONE RETURN_NONE}:
+*     The callback, if any, is applied to all matching children. No value is returned.
+* - {@link Phaser.Group.RETURN_CHILD RETURN_CHILD}:
+*     The callback, if any, is applied to the *first* matching child and the *first* matched child is returned.
+*     If there is no matching child then null is returned.
+*
+* If `args` is specified it must be an array. The matched child will be assigned to the first
+* element and the entire array will be applied to the callback function.
 *
 * @method Phaser.Group#iterate
 * @param {string} key - The child property to check, i.e. 'exists', 'alive', 'health'
-* @param {any} value - If child.key === this value it will be considered a match. Note that a strict comparison is used.
-* @param {number} returnType - How to return the data from this method. Either Phaser.Group.RETURN_NONE, Phaser.Group.RETURN_TOTAL or Phaser.Group.RETURN_CHILD.
-* @param {function} [callback=null] - Optional function that will be called on each matching child. Each child of the Group will be passed to it as its first parameter.
-* @param {Object} [callbackContext] - The context in which the function should be called (usually 'this').
-* @return {any} Returns either a numeric total (if RETURN_TOTAL was specified) or the child object.
+* @param {any} value - A child matches if `child[key] === value` is true.
+* @param {integer} returnType - How to iterate the childen and what to return.
+* @param {function} [callback=null] - Optional function that will be called on each matching child. The matched child is supplied as the first argument.
+* @param {object} [callbackContext] - The context in which the function should be called (usually 'this').
+* @param {any[]} [args=(none)] - The arguments supplied to to the callback; the first array index (argument) will be replaced with the matched child.
+* @return {any} Returns either an integer (for RETURN_TOTAL), the first matched child (for RETURN_CHILD), or null.
 */
 Phaser.Group.prototype.iterate = function (key, value, returnType, callback, callbackContext, args) {
 
@@ -1528,29 +1628,30 @@ Phaser.Group.prototype.iterate = function (key, value, returnType, callback, cal
 };
 
 /**
-* Call this function to retrieve the first object with exists == (the given state) in the Group.
+* Get the first display object that exists, or doesn't exist.
 *
 * @method Phaser.Group#getFirstExists
-* @param {boolean} state - True or false.
-* @return {Any} The first child, or null if none found.
+* @param {boolean} [exists=true] - If true, find the first existing child; otherwise find the first non-existing child.
+* @return {any} The first child, or null if none found.
 */
-Phaser.Group.prototype.getFirstExists = function (state) {
+Phaser.Group.prototype.getFirstExists = function (exists) {
 
-    if (typeof state !== 'boolean')
+    if (typeof exists !== 'boolean')
     {
-        state = true;
+        exists = true;
     }
 
-    return this.iterate('exists', state, Phaser.Group.RETURN_CHILD);
+    return this.iterate('exists', exists, Phaser.Group.RETURN_CHILD);
 
 };
 
 /**
-* Call this function to retrieve the first object with alive === true in the group.
+* Get the first child that is alive (`child.alive === true`).
+*
 * This is handy for checking if everything has been wiped out, or choosing a squad leader, etc.
 *
 * @method Phaser.Group#getFirstAlive
-* @return {Any} The first alive child, or null if none found.
+* @return {any} The first alive child, or null if none found.
 */
 Phaser.Group.prototype.getFirstAlive = function () {
 
@@ -1559,11 +1660,12 @@ Phaser.Group.prototype.getFirstAlive = function () {
 };
 
 /**
-* Call this function to retrieve the first object with alive === false in the group.
+* Get the first child that is dead (`child.alive === false`).
+*
 * This is handy for checking if everything has been wiped out, or choosing a squad leader, etc.
 *
 * @method Phaser.Group#getFirstDead
-* @return {Any} The first dead child, or null if none found.
+* @return {any} The first dead child, or null if none found.
 */
 Phaser.Group.prototype.getFirstDead = function () {
 
@@ -1572,10 +1674,12 @@ Phaser.Group.prototype.getFirstDead = function () {
 };
 
 /**
-* Returns the child at the top of this Group. The top is the one being displayed (rendered) above every other child.
+* Return the child at the top of this group.
+*
+* The top child is the child displayed (rendered) above every other child.
 *
 * @method Phaser.Group#getTop
-* @return {Any} The child at the top of the Group.
+* @return {any} The child at the top of the Group.
 */
 Phaser.Group.prototype.getTop = function () {
 
@@ -1587,10 +1691,12 @@ Phaser.Group.prototype.getTop = function () {
 };
 
 /**
-* Returns the child at the bottom of this Group. The bottom is the one being displayed (rendered) below every other child.
+* Returns the child at the bottom of this group.
+*
+* The bottom child the child being displayed (rendered) below every other child.
 *
 * @method Phaser.Group#getBottom
-* @return {Any} The child at the bottom of the Group.
+* @return {any} The child at the bottom of the Group.
 */
 Phaser.Group.prototype.getBottom = function () {
 
@@ -1602,10 +1708,10 @@ Phaser.Group.prototype.getBottom = function () {
 };
 
 /**
-* Call this function to find out how many members of the group are alive.
+* Get the number of living children in this group.
 *
 * @method Phaser.Group#countLiving
-* @return {number} The number of children flagged as alive.
+* @return {integer} The number of children flagged as alive.
 */
 Phaser.Group.prototype.countLiving = function () {
 
@@ -1614,10 +1720,10 @@ Phaser.Group.prototype.countLiving = function () {
 };
 
 /**
-* Call this function to find out how many members of the group are dead.
+* Get the number of dead children in this group.
 *
 * @method Phaser.Group#countDead
-* @return {number} The number of children flagged as dead.
+* @return {integer} The number of children flagged as dead.
 */
 Phaser.Group.prototype.countDead = function () {
 
@@ -1626,12 +1732,12 @@ Phaser.Group.prototype.countDead = function () {
 };
 
 /**
-* Returns a member at random from the group.
+* Returns a random child from the group.
 *
 * @method Phaser.Group#getRandom
-* @param {number} startIndex - Optional offset off the front of the array. Default value is 0, or the beginning of the array.
-* @param {number} length - Optional restriction on the number of values you want to randomly select from.
-* @return {Any} A random child of this Group.
+* @param {integer} [startIndex=0] - Offset from the front of the front of the group (lowest child).
+* @param {integer} [length=(to top)] - Restriction on the number of values you want to randomly select from.
+* @return {any} A random child of this Group.
 */
 Phaser.Group.prototype.getRandom = function (startIndex, length) {
 
@@ -1648,14 +1754,17 @@ Phaser.Group.prototype.getRandom = function (startIndex, length) {
 };
 
 /**
-* Removes the given child from this Group. This will dispatch an onRemovedFromGroup event from the child (if it has one),
-* reset the Group cursor and optionally destroy the child.
+* Removes the given child from this group.
+*
+* This will dispatch an `onRemovedFromGroup` event from the child (if it has one), and optionally destroy the child.
+*
+* If the group cursor was referring to the removed child it is updated to refer to the next child.
 *
 * @method Phaser.Group#remove
-* @param {Any} child - The child to remove.
-* @param {boolean} [destroy=false] - You can optionally call destroy on the child that was removed.
-* @param {boolean} [silent=false] - If the silent parameter is `true` the child will not dispatch the onRemovedFromGroup event.
-* @return {boolean} true if the child was removed from this Group, otherwise false.
+* @param {any} child - The child to remove.
+* @param {boolean} [destroy=false] - If true `destroy` will be invoked on the removed child.
+* @param {boolean} [silent=false] - If true the the child will not dispatch the `onRemovedFromGroup` event.
+* @return {boolean} true if the child was removed from this group, otherwise false.
 */
 Phaser.Group.prototype.remove = function (child, destroy, silent) {
 
@@ -1691,12 +1800,11 @@ Phaser.Group.prototype.remove = function (child, destroy, silent) {
 };
 
 /**
-* Removes all children from this Group, setting the `parent` property of the children to `null`.
-* The Group container remains on the display list.
+* Removes all children from this group, but does not remove the group from its parent.
 *
 * @method Phaser.Group#removeAll
-* @param {boolean} [destroy=false] - You can optionally call destroy on each child that is removed.
-* @param {boolean} [silent=false] - If the silent parameter is `true` the children will not dispatch their onRemovedFromGroup events.
+* @param {boolean} [destroy=false] - If true `destroy` will be invoked on each removed child.
+* @param {boolean} [silent=false] - If true the children will not dispatch their `onRemovedFromGroup` events.
 */
 Phaser.Group.prototype.removeAll = function (destroy, silent) {
 
@@ -1729,13 +1837,13 @@ Phaser.Group.prototype.removeAll = function (destroy, silent) {
 };
 
 /**
-* Removes all children from this Group whos index falls beteen the given startIndex and endIndex values.
+* Removes all children from this group whose index falls beteen the given startIndex and endIndex values.
 *
 * @method Phaser.Group#removeBetween
-* @param {number} startIndex - The index to start removing children from.
-* @param {number} [endIndex] - The index to stop removing children at. Must be higher than startIndex. If undefined this method will remove all children between startIndex and the end of the Group.
-* @param {boolean} [destroy=false] - You can optionally call destroy on the child that was removed.
-* @param {boolean} [silent=false] - If the silent parameter is `true` the children will not dispatch their onRemovedFromGroup events.
+* @param {integer} startIndex - The index to start removing children from.
+* @param {integer} [endIndex] - The index to stop removing children at. Must be higher than startIndex. If undefined this method will remove all children between startIndex and the end of the group.
+* @param {boolean} [destroy=false] - If true `destroy` will be invoked on each removed child.
+* @param {boolean} [silent=false] - If true the children will not dispatch their `onRemovedFromGroup` events.
 */
 Phaser.Group.prototype.removeBetween = function (startIndex, endIndex, destroy, silent) {
 
@@ -1782,11 +1890,13 @@ Phaser.Group.prototype.removeBetween = function (startIndex, endIndex, destroy,
 };
 
 /**
-* Destroys this Group. Removes all children, then removes the container from the display list and nulls references.
+* Destroys this group.
+*
+* Removes all children, then removes this group from its parent and nulls references.
 *
 * @method Phaser.Group#destroy
-* @param {boolean} [destroyChildren=true] - Should every child of this Group have its destroy method called?
-* @param {boolean} [soft=false] - A 'soft destroy' (set to true) doesn't remove this Group from its parent or null the game reference. Set to false and it does.
+* @param {boolean} [destroyChildren=true] - If true `destroy` will be invoked on each removed child.
+* @param {boolean} [soft=false] - A 'soft destroy' (set to true) doesn't remove this group from its parent or null the game reference. Set to false and it does.
 */
 Phaser.Group.prototype.destroy = function (destroyChildren, soft) {
 
@@ -1816,8 +1926,10 @@ Phaser.Group.prototype.destroy = function (destroyChildren, soft) {
 };
 
 /**
+* Total number of existing children in the group.
+*
 * @name Phaser.Group#total
-* @property {number} total - The total number of children in this Group who have a state of exists = true.
+* @property {integer} total
 * @readonly
 */
 Object.defineProperty(Phaser.Group.prototype, "total", {
@@ -1831,8 +1943,10 @@ Object.defineProperty(Phaser.Group.prototype, "total", {
 });
 
 /**
+* Total number of children in this group, regardless of exists/alive status.
+*
 * @name Phaser.Group#length
-* @property {number} length - The total number of children in this Group, regardless of their exists/alive status.
+* @property {integer} length 
 * @readonly
 */
 Object.defineProperty(Phaser.Group.prototype, "length", {
@@ -1846,10 +1960,15 @@ Object.defineProperty(Phaser.Group.prototype, "length", {
 });
 
 /**
-* The angle of rotation of the Group container. This will adjust the Group container itself by modifying its rotation.
-* This will have no impact on the rotation value of its children, but it will update their worldTransform and on-screen position.
+* The angle of rotation of the group container, in degrees.
+*
+* This adjusts the group itself by modifying its local rotation transform.
+*
+* This has no impact on the rotation/angle properties of the children, but it will update their worldTransform
+* and on-screen orientation and position.
+*
 * @name Phaser.Group#angle
-* @property {number} angle - The angle of rotation given in degrees, where 0 degrees = to the right.
+* @property {number} angle
 */
 Object.defineProperty(Phaser.Group.prototype, "angle", {
 
@@ -1864,12 +1983,15 @@ Object.defineProperty(Phaser.Group.prototype, "angle", {
 });
 
 /**
-* A Group that is fixed to the camera uses its x/y coordinates as offsets from the top left of the camera. These are stored in Group.cameraOffset.
-* Note that the cameraOffset values are in addition to any parent in the display list.
-* So if this Group was in a Group that has x: 200, then this will be added to the cameraOffset.x
+* Is this group fixed to the camera?
+*
+* A Group that is fixed to the camera uses its x/y coordinates as offsets from the top left of the camera.
+*
+* These are stored in {@link #cameraOffset} and are in addition to any parent in the display list.
+* So if this group was in a Group that has x: 200, then this will be added to the cameraOffset.x
 *
 * @name Phaser.Group#fixedToCamera
-* @property {boolean} fixedToCamera - Set to true to fix this Group to the Camera at its current world coordinates.
+* @property {boolean} fixedToCamera
 */
 Object.defineProperty(Phaser.Group.prototype, "fixedToCamera", {
 
@@ -1894,35 +2016,54 @@ Object.defineProperty(Phaser.Group.prototype, "fixedToCamera", {
 
 });
 
-//  Documentation stubs
+/**
+* A display object is any object that can be rendered in the Phaser/pixi.js scene graph.
+*
+* This includes {@link Phaser.Group} (groups are display objects!),
+* {@link Phaser.Sprite}, {@link Phaser.Button}, {@link Phaser.Text}
+* as well as {@link PIXI.DisplayObject} and all derived types.
+*
+* @typedef {object} DisplayObject
+*/
+// Documentation stub for linking.
 
 /**
-* The x coordinate of the Group container. You can adjust the Group container itself by modifying its coordinates.
+* The x coordinate of the group container.
+*
+* You can adjust the group container itself by modifying its coordinates.
 * This will have no impact on the x/y coordinates of its children, but it will update their worldTransform and on-screen position.
 * @name Phaser.Group#x
-* @property {number} x - The x coordinate of the Group container.
+* @property {number} x
 */
 
 /**
-* The y coordinate of the Group container. You can adjust the Group container itself by modifying its coordinates.
+* The y coordinate of the group container.
+*
+* You can adjust the group container itself by modifying its coordinates.
 * This will have no impact on the x/y coordinates of its children, but it will update their worldTransform and on-screen position.
 * @name Phaser.Group#y
-* @property {number} y - The y coordinate of the Group container.
+* @property {number} y
 */
 
 /**
-* The angle of rotation of the Group container. This will adjust the Group container itself by modifying its rotation.
+* The angle of rotation of the group container, in radians.
+*
+* This will adjust the group container itself by modifying its rotation.
 * This will have no impact on the rotation value of its children, but it will update their worldTransform and on-screen position.
 * @name Phaser.Group#rotation
-* @property {number} rotation - The angle of rotation given in radians.
+* @property {number} rotation
 */
 
 /**
+* The visible state of the group. Non-visible Groups and all of their children are not rendered.
+*
 * @name Phaser.Group#visible
-* @property {boolean} visible - The visible state of the Group. Non-visible Groups and all of their children are not rendered.
+* @property {boolean} visible
 */
 
 /**
+* The alpha value of the group container.
+*
 * @name Phaser.Group#alpha
-* @property {number} alpha - The alpha value of the Group container.
+* @property {number} alpha
 */
diff --git a/src/core/Plugin.js b/src/core/Plugin.js
index 052ae1377..bd8d9a62c 100644
--- a/src/core/Plugin.js
+++ b/src/core/Plugin.js
@@ -10,7 +10,7 @@
 * @class Phaser.Plugin
 * @constructor
 * @param {Phaser.Game} game - A reference to the currently running game.
-* @param {Any} parent - The object that owns this plugin, usually Phaser.PluginManager.
+* @param {any} parent - The object that owns this plugin, usually Phaser.PluginManager.
 */
 Phaser.Plugin = function (game, parent) {
 
@@ -22,7 +22,7 @@ Phaser.Plugin = function (game, parent) {
     this.game = game;
 
     /**
-    * @property {Any} parent - The parent of this plugin. If added to the PluginManager the parent will be set to that, otherwise it will be null.
+    * @property {any} parent - The parent of this plugin. If added to the PluginManager the parent will be set to that, otherwise it will be null.
     */
     this.parent = parent;
 
diff --git a/src/core/PluginManager.js b/src/core/PluginManager.js
index 5b8b456f1..d2436c9fa 100644
--- a/src/core/PluginManager.js
+++ b/src/core/PluginManager.js
@@ -21,7 +21,7 @@ Phaser.PluginManager = function(game) {
     this.game = game;
 
     /**
-    * @property {array} plugins - An array of all the plugins being managed by this PluginManager.
+    * @property {Phaser.Plugin[]} plugins - An array of all the plugins being managed by this PluginManager.
     */
     this.plugins = [];
 
diff --git a/src/core/Signal.js b/src/core/Signal.js
index d364bf3ec..2a5dbfcf8 100644
--- a/src/core/Signal.js
+++ b/src/core/Signal.js
@@ -6,7 +6,9 @@
 */
 
 /**
-* A Signal is used for object communication via a custom broadcaster instead of Events.
+* A Signal is an event dispatch mechansim than supports broadcasting to multiple listeners.
+*
+* Event listeners are uniquely identified by the listener/callback function and the context.
 * 
 * @class Phaser.Signal
 * @constructor
@@ -29,9 +31,11 @@ Phaser.Signal.prototype = {
     _prevParams: null,
 
     /**
-    * If Signal should keep record of previously dispatched parameters and
-    * automatically execute listener during `add()`/`addOnce()` if Signal was
-    * already dispatched before.
+    * Memorize the previously dispatched event?
+    *
+    * If an event has been memorized it is automatically dispatched when a new listener is added with {@link #add} or {@link #addOnce}.
+    * Use {@link #forget} to clear any currently memorized event.
+    *
     * @property {boolean} memorize
     */
     memorize: false,
@@ -43,8 +47,10 @@ Phaser.Signal.prototype = {
     _shouldPropagate: true,
 
     /**
-    * If Signal is active and should broadcast events.
-    * IMPORTANT: Setting this property during a dispatch will only affect the next dispatch, if you want to stop the propagation of a signal use `halt()` instead.
+    * Is the Signal active? Only active signal will broadcast dispatched events.
+    *
+    * Setting this property during a dispatch will only affect the next dispatch. To stop the propagation of a signal from a listener use {@link #halt}.
+    *
     * @property {boolean} active
     * @default
     */
@@ -167,7 +173,7 @@ Phaser.Signal.prototype = {
     },
 
     /**
-    * Check if listener was attached to Signal.
+    * Check if a specific listener is attached.
     *
     * @method Phaser.Signal#has
     * @param {function} listener - Signal handler function.
@@ -181,7 +187,7 @@ Phaser.Signal.prototype = {
     },
 
     /**
-    * Add a listener to the signal.
+    * Add an event listener.
     *
     * @method Phaser.Signal#add
     * @param {function} listener - The function to call when this Signal is dispatched.
@@ -198,7 +204,10 @@ Phaser.Signal.prototype = {
     },
 
     /**
-    * Add listener to the signal that should be removed after first execution (will be executed only once).
+    * Add a one-time listener - the listener is automatically removed after the first execution.
+    *
+    * If there is as {@link Phaser.Signal#memorize memorized} event then it will be dispatched and
+    * the listener will be removed immediately.
     *
     * @method Phaser.Signal#addOnce
     * @param {function} listener - The function to call when this Signal is dispatched.
@@ -215,7 +224,7 @@ Phaser.Signal.prototype = {
     },
 
     /**
-    * Remove a single listener from the dispatch queue.
+    * Remove a single event listener.
     *
     * @method Phaser.Signal#remove
     * @param {function} listener - Handler function that should be removed.
@@ -239,7 +248,7 @@ Phaser.Signal.prototype = {
     },
 
     /**
-    * Remove all listeners from the Signal.
+    * Remove all event listeners.
     *
     * @method Phaser.Signal#removeAll
     * @param {object} [context=null] - If specified only listeners for the given context will be removed.
@@ -282,7 +291,7 @@ Phaser.Signal.prototype = {
     * Gets the total number of listeners attached to this Signal.
     *
     * @method Phaser.Signal#getNumListeners
-    * @return {number} Number of listeners attached to the Signal.
+    * @return {integer} Number of listeners attached to the Signal.
     */
     getNumListeners: function () {
 
@@ -292,8 +301,9 @@ Phaser.Signal.prototype = {
 
     /**
     * Stop propagation of the event, blocking the dispatch to next listener on the queue.
-    * IMPORTANT: should be called only during signal dispatch, calling it before/after dispatch won't affect signal broadcast.
-    * @see Signal.prototype.disable
+    *
+    * This should be called only during event dispatch as calling it before/after dispatch won't affect other broadcast.
+    * See {@link #active} to enable/disable the signal entirely.
     *
     * @method Phaser.Signal#halt
     */
@@ -304,9 +314,9 @@ Phaser.Signal.prototype = {
     },
 
     /**
-    * Dispatch/Broadcast Signal to all listeners added to the queue.
+    * Dispatch / broadcast the event to all listeners.
     *
-    * To create a bound dispatch for this Signal, use {@link Phaser.Signal#boundDispatch}.
+    * To create an instance-bound dispatch for this Signal, use {@link #boundDispatch}.
     *
     * @method Phaser.Signal#dispatch
     * @param {any} [params] - Parameters that should be passed to each handler.
@@ -346,8 +356,7 @@ Phaser.Signal.prototype = {
     },
 
     /**
-    * Forget memorized arguments.
-    * @see Signal.memorize
+    * Forget the currently {@link Phaser.Signal#memorize memorized} event, if any.
     *
     * @method Phaser.Signal#forget
     */
@@ -361,8 +370,10 @@ Phaser.Signal.prototype = {
     },
 
     /**
-    * Remove all bindings from signal and destroy any reference to external objects (destroy Signal object).
-    * IMPORTANT: calling any method on the signal instance after calling dispose will throw errors.
+    * Dispose the signal - no more events can be dispatched.
+    *
+    * This removes all event listeners and clears references to external objects.
+    * Calling methods on a disposed objects results in undefined behavior.
     *
     * @method Phaser.Signal#dispose
     */
@@ -379,6 +390,7 @@ Phaser.Signal.prototype = {
     },
 
     /**
+    * A string representation of the object.
     *
     * @method Phaser.Signal#toString
     * @return {string} String representation of the object.
@@ -392,8 +404,10 @@ Phaser.Signal.prototype = {
 };
 
 /**
-* If the dispatch function needs to be passed somewhere, or called independently
-* of the Signal object, use this function.
+* Create a `dispatch` function that maintains a binding to the original Signal context.
+*
+* Use the resulting value if the dispatch function needs to be passed somewhere
+* or called independently of the Signal object.
 *
 * @memberof Phaser.Signal
 * @property {function} boundDispatch
diff --git a/src/core/SignalBinding.js b/src/core/SignalBinding.js
index 5cef6c336..cb4122b7a 100644
--- a/src/core/SignalBinding.js
+++ b/src/core/SignalBinding.js
@@ -91,7 +91,7 @@ Phaser.SignalBinding.prototype = {
     * Call listener passing arbitrary parameters.
     * If binding was added using `Signal.addOnce()` it will be automatically removed from signal dispatch queue, this method is used internally for the signal dispatch.
     * @method Phaser.SignalBinding#execute
-    * @param {array} [paramsArr] - Array of parameters that should be passed to the listener.
+    * @param {any[]} [paramsArr] - Array of parameters that should be passed to the listener.
     * @return {any} Value returned by the listener.
     */
     execute: function(paramsArr) {
diff --git a/src/core/StateManager.js b/src/core/StateManager.js
index eabf757c0..4bff5b417 100644
--- a/src/core/StateManager.js
+++ b/src/core/StateManager.js
@@ -22,7 +22,7 @@ Phaser.StateManager = function (game, pendingState) {
     this.game = game;
 
     /**
-    * @property {Object} states - The object containing Phaser.States.
+    * @property {object} states - The object containing Phaser.States.
     */
     this.states = {};
 
@@ -56,7 +56,7 @@ Phaser.StateManager = function (game, pendingState) {
     this._created = false;
 
     /**
-    * @property {array} _args - Temporary container when you pass vars from one State to another.
+    * @property {any[]} _args - Temporary container when you pass vars from one State to another.
     * @private
     */
     this._args = [];
diff --git a/src/gameobjects/BitmapData.js b/src/gameobjects/BitmapData.js
index 16afb89e7..774d55eba 100644
--- a/src/gameobjects/BitmapData.js
+++ b/src/gameobjects/BitmapData.js
@@ -164,7 +164,7 @@ Phaser.BitmapData = function (game, key, width, height) {
     this._rotate = 0;
 
     /**
-    * @property {Object} _alpha - Internal cache var.
+    * @property {object} _alpha - Internal cache var.
     * @private
     */
     this._alpha = { prev: 1, current: 1 };
@@ -1792,7 +1792,7 @@ Object.defineProperty(Phaser.BitmapData.prototype, "smoothed", {
  * @param {number} scaleY - The scale y value.
  * @param {number} skewX - The skew x value.
  * @param {number} skewY - The skew y value.
- * @return {Object} A JavaScript object containing all of the properties BitmapData needs for transforms.
+ * @return {object} A JavaScript object containing all of the properties BitmapData needs for transforms.
  */
 Phaser.BitmapData.getTransform = function (translateX, translateY, scaleX, scaleY, skewX, skewY) {
 
diff --git a/src/gameobjects/GameObjectCreator.js b/src/gameobjects/GameObjectCreator.js
index d996cd3fe..f600a0e5b 100644
--- a/src/gameobjects/GameObjectCreator.js
+++ b/src/gameobjects/GameObjectCreator.js
@@ -5,8 +5,8 @@
 */
 
 /**
-* The Game Object Creator is a quick way to create all of the different sorts of core objects that Phaser uses, but not add them to the game world.
-* Use the GameObjectFactory to create and add the objects into the world.
+* The GameObjectCreator is a quick way to create common game objects _without_ adding them to the game world.
+* The object creator can be accessed with {@linkcode Phaser.Game#make `game.make`}.
 *
 * @class Phaser.GameObjectCreator
 * @constructor
@@ -16,11 +16,13 @@ Phaser.GameObjectCreator = function (game) {
 
     /**
     * @property {Phaser.Game} game - A reference to the currently running Game.
+    * @protected
     */
     this.game = game;
 
     /**
     * @property {Phaser.World} world - A reference to the game world.
+    * @protected
     */
     this.world = this.game.world;
 
@@ -29,7 +31,9 @@ Phaser.GameObjectCreator = function (game) {
 Phaser.GameObjectCreator.prototype = {
 
     /**
-    * Create a new `Image` object. An Image is a light-weight object you can use to display anything that doesn't need physics or animation.
+    * Create a new Image object.
+    *
+    * An Image is a light-weight object you can use to display anything that doesn't need physics or animation.
     * It can still rotate, scale, crop and receive input events. This makes it perfect for logos, backgrounds, simple buttons and other non-Sprite graphics.
     *
     * @method Phaser.GameObjectCreator#image
@@ -37,7 +41,7 @@ Phaser.GameObjectCreator.prototype = {
     * @param {number} y - Y position of the image.
     * @param {string|Phaser.RenderTexture|PIXI.Texture} key - This is the image or texture used by the Sprite during rendering. It can be a string which is a reference to the Cache entry, or an instance of a RenderTexture or PIXI.Texture.
     * @param {string|number} [frame] - If the sprite uses an image from a texture atlas or sprite sheet you can pass the frame here. Either a number for a frame ID or a string for a frame name.
-    * @returns {Phaser.Sprite} the newly created sprite object.
+    * @returns {Phaser.Image} the newly created sprite object.
     */
     image: function (x, y, key, frame) {
 
@@ -62,7 +66,9 @@ Phaser.GameObjectCreator.prototype = {
     },
 
     /**
-    * Create a tween object for a specific object. The object can be any JavaScript object or Phaser object such as Sprite.
+    * Create a tween object for a specific object.
+    *
+    * The object can be any JavaScript object or Phaser object such as Sprite.
     *
     * @method Phaser.GameObjectCreator#tween
     * @param {object} obj - Object the tween will be run on.
@@ -92,13 +98,13 @@ Phaser.GameObjectCreator.prototype = {
     },
 
     /**
-    * A Group is a container for display objects that allows for fast pooling, recycling and collision checks.
+    * Create a new SpriteBatch.
     *
     * @method Phaser.GameObjectCreator#spriteBatch
     * @param {any} parent - The parent Group or DisplayObjectContainer that will hold this group, if any.
     * @param {string} [name='group'] - A name for this Group. Not used internally but useful for debugging.
     * @param {boolean} [addToStage=false] - If set to true this Group will be added directly to the Game.Stage instead of Game.World.
-    * @return {Phaser.Group} The newly created group.
+    * @return {Phaser.SpriteBatch} The newly created group.
     */
     spriteBatch: function (parent, name, addToStage) {
 
@@ -242,7 +248,9 @@ Phaser.GameObjectCreator.prototype = {
     },
 
     /**
-    * Emitter is a lightweight particle emitter. It can be used for one-time explosions or for
+    * Creat a new Emitter.
+    *
+    * An Emitter is a lightweight particle emitter. It can be used for one-time explosions or for
     * continuous effects like rain and fire. All it really does is launch Particle objects out
     * at set intervals, and fixes their positions and velocities accorindgly.
     *
@@ -259,7 +267,9 @@ Phaser.GameObjectCreator.prototype = {
     },
 
     /**
-    * Create a new RetroFont object to be used as a texture for an Image or Sprite and optionally add it to the Cache.
+    * Create a new RetroFont object.
+    *
+    * A RetroFont can be used as a texture for an Image or Sprite and optionally add it to the Cache.
     * A RetroFont uses a bitmap which contains fixed with characters for the font set. You use character spacing to define the set.
     * If you need variable width character support then use a BitmapText object instead. The main difference between a RetroFont and a BitmapText
     * is that a RetroFont creates a single texture that you can apply to a game object, where-as a BitmapText creates one Sprite object per letter of text.
@@ -302,7 +312,9 @@ Phaser.GameObjectCreator.prototype = {
     },
 
     /**
-    * Creates a new Phaser.Tilemap object. The map can either be populated with data from a Tiled JSON file or from a CSV file.
+    * Creates a new Phaser.Tilemap object.
+    *
+    * The map can either be populated with data from a Tiled JSON file or from a CSV file.
     * To do this pass the Cache key as the first parameter. When using Tiled data you need only provide the key.
     * When using CSV data you must provide the key and the tileWidth and tileHeight parameters.
     * If creating a blank tilemap to be populated later, you can either specify no parameters at all and then use `Tilemap.create` or pass the map and tile dimensions here.
@@ -348,7 +360,9 @@ Phaser.GameObjectCreator.prototype = {
     },
 
     /**
-    * A BitmapData object which can be manipulated and drawn to like a traditional Canvas object and used to texture Sprites.
+    * Create a BitmpaData object.
+    *
+    * A BitmapData object can be manipulated and drawn to like a traditional Canvas object and used to texture Sprites.
     *
     * @method Phaser.GameObjectCreator#bitmapData
     * @param {number} [width=256] - The width of the BitmapData in pixels.
diff --git a/src/gameobjects/GameObjectFactory.js b/src/gameobjects/GameObjectFactory.js
index e13dffd99..7ba54b4f2 100644
--- a/src/gameobjects/GameObjectFactory.js
+++ b/src/gameobjects/GameObjectFactory.js
@@ -5,7 +5,10 @@
 */
 
 /**
-* The Game Object Factory is a quick way to create all of the different sorts of core objects that Phaser uses.
+* The GameObjectFactory is a quick way to create mamy common game objects
+* using {@linkcode Phaser.Game#add `game.add`}.
+*
+* Created objects are _automtically added_ to the appropriate Manager, World, or manually specified parent Group.
 *
 * @class Phaser.GameObjectFactory
 * @constructor
@@ -15,11 +18,13 @@ Phaser.GameObjectFactory = function (game) {
 
     /**
     * @property {Phaser.Game} game - A reference to the currently running Game.
+    * @protected
     */
     this.game = game;
 
     /**
     * @property {Phaser.World} world - A reference to the game world.
+    * @protected
     */
     this.world = this.game.world;
 
@@ -30,8 +35,8 @@ Phaser.GameObjectFactory.prototype = {
     /**
     * Adds an existing object to the game world.
     * @method Phaser.GameObjectFactory#existing
-    * @param {*} object - An instance of Phaser.Sprite, Phaser.Button or any other display object..
-    * @return {*} The child that was added to the Group.
+    * @param {any} object - An instance of Phaser.Sprite, Phaser.Button or any other display object..
+    * @return {any} The child that was added to the Group.
     */
     existing: function (object) {
 
@@ -221,10 +226,10 @@ Phaser.GameObjectFactory.prototype = {
     * @param {number} y - The y coordinate (in world space) to position the TileSprite at.
     * @param {string|Phaser.RenderTexture|Phaser.BitmapData|PIXI.Texture} key - This is the image or texture used by the TileSprite during rendering. It can be a string which is a reference to the Cache entry, or an instance of a RenderTexture or PIXI.Texture.
     * @param {string|number} frame - If this TileSprite is using part of a sprite sheet or texture atlas you can specify the exact frame to use by giving a string or numeric index.
-		* @param {Array} points - An array of {Phaser.Point}.
+    * @param {Array} points - An array of {Phaser.Point}.
     * @param {Phaser.Group} [group] - Optional Group to add the object to. If not specified it will be added to the World group.
     * @return {Phaser.TileSprite} The newly created tileSprite object.
-		* Example usage: https://github.com/codevinsky/phaser-rope-demo/blob/master/dist/demo.js
+    * Example usage: https://github.com/codevinsky/phaser-rope-demo/blob/master/dist/demo.js
     */
     rope: function (x, y, key, frame, points, group) {
 
@@ -257,15 +262,15 @@ Phaser.GameObjectFactory.prototype = {
     * Creates a new Button object.
     *
     * @method Phaser.GameObjectFactory#button
-    * @param {number} [x] X position of the new button object.
-    * @param {number} [y] Y position of the new button object.
-    * @param {string} [key] The image key as defined in the Game.Cache to use as the texture for this button.
-    * @param {function} [callback] The function to call when this button is pressed
-    * @param {object} [callbackContext] The context in which the callback will be called (usually 'this')
-    * @param {string|number} [overFrame] This is the frame or frameName that will be set when this button is in an over state. Give either a number to use a frame ID or a string for a frame name.
-    * @param {string|number} [outFrame] This is the frame or frameName that will be set when this button is in an out state. Give either a number to use a frame ID or a string for a frame name.
-    * @param {string|number} [downFrame] This is the frame or frameName that will be set when this button is in a down state. Give either a number to use a frame ID or a string for a frame name.
-    * @param {string|number} [upFrame] This is the frame or frameName that will be set when this button is in an up state. Give either a number to use a frame ID or a string for a frame name.
+    * @param {number} [x] - X position of the new button object.
+    * @param {number} [y] - Y position of the new button object.
+    * @param {string} [key] - The image key as defined in the Game.Cache to use as the texture for this button.
+    * @param {function} [callback] - The function to call when this button is pressed
+    * @param {object} [callbackContext] - The context in which the callback will be called (usually 'this')
+    * @param {string|number} [overFrame] - This is the frame or frameName that will be set when this button is in an over state. Give either a number to use a frame ID or a string for a frame name.
+    * @param {string|number} [outFrame] - This is the frame or frameName that will be set when this button is in an out state. Give either a number to use a frame ID or a string for a frame name.
+    * @param {string|number} [downFrame] - This is the frame or frameName that will be set when this button is in a down state. Give either a number to use a frame ID or a string for a frame name.
+    * @param {string|number} [upFrame] - This is the frame or frameName that will be set when this button is in an up state. Give either a number to use a frame ID or a string for a frame name.
     * @param {Phaser.Group} [group] - Optional Group to add the object to. If not specified it will be added to the World group.
     * @return {Phaser.Button} The newly created button object.
     */
@@ -295,7 +300,9 @@ Phaser.GameObjectFactory.prototype = {
     },
 
     /**
-    * Emitter is a lightweight particle emitter. It can be used for one-time explosions or for
+    * Create a new Emitter.
+    *
+    * A particle emitter can be used for one-time explosions or for
     * continuous effects like rain and fire. All it really does is launch Particle objects out
     * at set intervals, and fixes their positions and velocities accorindgly.
     *
@@ -312,7 +319,9 @@ Phaser.GameObjectFactory.prototype = {
     },
 
     /**
-    * Create a new RetroFont object to be used as a texture for an Image or Sprite and optionally add it to the Cache.
+    * Create a new RetroFont object.
+    *
+    * A RetroFont can be used as a texture for an Image or Sprite and optionally add it to the Cache.
     * A RetroFont uses a bitmap which contains fixed with characters for the font set. You use character spacing to define the set.
     * If you need variable width character support then use a BitmapText object instead. The main difference between a RetroFont and a BitmapText
     * is that a RetroFont creates a single texture that you can apply to a game object, where-as a BitmapText creates one Sprite object per letter of text.
@@ -358,7 +367,9 @@ Phaser.GameObjectFactory.prototype = {
     },
 
     /**
-    * Creates a new Phaser.Tilemap object. The map can either be populated with data from a Tiled JSON file or from a CSV file.
+    * Creates a new Phaser.Tilemap object.
+    *
+    * The map can either be populated with data from a Tiled JSON file or from a CSV file.
     * To do this pass the Cache key as the first parameter. When using Tiled data you need only provide the key.
     * When using CSV data you must provide the key and the tileWidth and tileHeight parameters.
     * If creating a blank tilemap to be populated later, you can either specify no parameters at all and then use `Tilemap.create` or pass the map and tile dimensions here.
@@ -405,7 +416,9 @@ Phaser.GameObjectFactory.prototype = {
     },
 
     /**
-    * A BitmapData object which can be manipulated and drawn to like a traditional Canvas object and used to texture Sprites.
+    * Create a BitmapData object.
+    *
+    * A BitmapData object can be manipulated and drawn to like a traditional Canvas object and used to texture Sprites.
     *
     * @method Phaser.GameObjectFactory#bitmapData
     * @param {number} [width=256] - The width of the BitmapData in pixels.
@@ -452,7 +465,8 @@ Phaser.GameObjectFactory.prototype = {
 
     /**
     * Add a new Plugin into the PluginManager.
-    * The Plugin must have 2 properties: game and parent. Plugin.game is set to the game reference the PluginManager uses, and parent is set to the PluginManager.
+    *
+    * The Plugin must have 2 properties: `game` and `parent`. Plugin.game is set to the game reference the PluginManager uses, and parent is set to the PluginManager.
     *
     * @method Phaser.GameObjectFactory#plugin
     * @param {object|Phaser.Plugin} plugin - The Plugin to add into the PluginManager. This can be a function or an existing object.
diff --git a/src/gameobjects/Rope.js b/src/gameobjects/Rope.js
index 99236aa9a..07ef69fce 100644
--- a/src/gameobjects/Rope.js
+++ b/src/gameobjects/Rope.js
@@ -791,7 +791,7 @@ Object.defineProperty(Phaser.Rope.prototype, "updateAnimation", {
 * The segments that make up the rope body as an array of Phaser.Rectangles
 *
 * @name Phaser.Rope#segments
-* @property {array} updateAnimation - Returns an array of Phaser.Rectangles that represent the segments of the given rope
+* @property {Phaser.Rectangles[]} updateAnimation - Returns an array of Phaser.Rectangles that represent the segments of the given rope
 */
 Object.defineProperty(Phaser.Rope.prototype, "segments", {
     get: function() {
diff --git a/src/gameobjects/Text.js b/src/gameobjects/Text.js
index eb3ad19db..843d8ce60 100644
--- a/src/gameobjects/Text.js
+++ b/src/gameobjects/Text.js
@@ -317,7 +317,7 @@ Phaser.Text.prototype.setShadow = function (x, y, color, blur) {
 * Set the style of the text by passing a single style object to it.
 *
 * @method Phaser.Text#setStyle
-* @param {Object} [style] - The style properties to be set on the Text.
+* @param {object} [style] - The style properties to be set on the Text.
 * @param {string} [style.font='bold 20pt Arial'] - The style and size of the font.
 * @param {string} [style.fill='black'] - A canvas fillstyle that will be used on the text eg 'red', '#00FF00'.
 * @param {string} [style.align='left'] - Alignment for multiline text ('left', 'center' or 'right'), does not affect single line text.
diff --git a/src/geom/Circle.js b/src/geom/Circle.js
index b5db2185a..d37e0df42 100644
--- a/src/geom/Circle.js
+++ b/src/geom/Circle.js
@@ -108,7 +108,7 @@ Phaser.Circle.prototype = {
     * Copies the x, y and diameter properties from this Circle to any given object.
     * @method Phaser.Circle#copyTo
     * @param {any} dest - The object to copy to.
-    * @return {Object} This dest object.
+    * @return {object} This dest object.
     */
     copyTo: function (dest) {
 
diff --git a/src/geom/Ellipse.js b/src/geom/Ellipse.js
index fd94ebbb0..00cfd32b2 100644
--- a/src/geom/Ellipse.js
+++ b/src/geom/Ellipse.js
@@ -95,7 +95,7 @@ Phaser.Ellipse.prototype = {
     * Copies the x, y, width and height properties from this Ellipse to any given object.
     * @method Phaser.Ellipse#copyTo
     * @param {any} dest - The object to copy to.
-    * @return {Object} This dest object.
+    * @return {object} This dest object.
     */
     copyTo: function(dest) {
 
diff --git a/src/geom/Point.js b/src/geom/Point.js
index 3594a8dcf..8efaa90df 100644
--- a/src/geom/Point.js
+++ b/src/geom/Point.js
@@ -234,7 +234,7 @@ Phaser.Point.prototype = {
     *
     * @method Phaser.Point#copyTo
     * @param {any} dest - The object to copy to.
-    * @return {Object} The dest object.
+    * @return {object} The dest object.
     */
     copyTo: function (dest) {
 
@@ -886,7 +886,7 @@ Phaser.Point.centroid = function (points, out) {
 *
 * @method Phaser.Point.parse
 * @static
-* @param {Object} obj - The object to parse.
+* @param {object} obj - The object to parse.
 * @param {string} [xProp='x'] - The property used to set the Point.x value.
 * @param {string} [yProp='y'] - The property used to set the Point.y value.
 * @return {Phaser.Point} The new Point object.
diff --git a/src/input/Gamepad.js b/src/input/Gamepad.js
index 492c71403..fc789cb8c 100644
--- a/src/input/Gamepad.js
+++ b/src/input/Gamepad.js
@@ -26,7 +26,7 @@ Phaser.Gamepad = function (game) {
     this.game = game;
 
     /**
-    * @property {Object} _gamepadIndexMap - Maps the browsers gamepad indices to our Phaser Gamepads
+    * @property {object} _gamepadIndexMap - Maps the browsers gamepad indices to our Phaser Gamepads
     * @private
     */
     this._gamepadIndexMap = {};
@@ -75,7 +75,7 @@ Phaser.Gamepad = function (game) {
     this._prevTimestamps = [];
 
     /**
-    * @property {Object} callbackContext - The context under which the callbacks are run.
+    * @property {object} callbackContext - The context under which the callbacks are run.
     */
     this.callbackContext = this;
 
@@ -140,8 +140,8 @@ Phaser.Gamepad.prototype = {
     * Add callbacks to the main Gamepad handler to handle connect/disconnect/button down/button up/axis change/float value buttons.
     * 
     * @method Phaser.Gamepad#addCallbacks
-    * @param {Object} context - The context under which the callbacks are run.
-    * @param {Object} callbacks - Object that takes six different callback methods:
+    * @param {object} context - The context under which the callbacks are run.
+    * @param {object} callbacks - Object that takes six different callback methods:
     * onConnectCallback, onDisconnectCallback, onDownCallback, onUpCallback, onAxisCallback, onFloatCallback
     */
     addCallbacks: function (context, callbacks) {
diff --git a/src/input/Input.js b/src/input/Input.js
index 4937fc270..7016a4b1b 100644
--- a/src/input/Input.js
+++ b/src/input/Input.js
@@ -587,7 +587,7 @@ Phaser.Input.prototype = {
     *
     * @method Phaser.Input#startPointer
     * @protected
-    * @param {Any} event - The event data from the Touch event.
+    * @param {any} event - The event data from the Touch event.
     * @return {Phaser.Pointer} The Pointer object that was started or null if no Pointer object is available.
     */
     startPointer: function (event) {
@@ -625,7 +625,7 @@ Phaser.Input.prototype = {
     *
     * @method Phaser.Input#updatePointer
     * @protected
-    * @param {Any} event - The event data from the Touch event.
+    * @param {any} event - The event data from the Touch event.
     * @return {Phaser.Pointer} The Pointer object that was updated; null if no pointer was updated.
     */
     updatePointer: function (event) {
@@ -657,7 +657,7 @@ Phaser.Input.prototype = {
     *
     * @method Phaser.Input#stopPointer
     * @protected
-    * @param {Any} event - The event data from the Touch event.
+    * @param {any} event - The event data from the Touch event.
     * @return {Phaser.Pointer} The Pointer object that was stopped or null if no Pointer object is available.
     */
     stopPointer: function (event) {
diff --git a/src/input/Keyboard.js b/src/input/Keyboard.js
index 4cc47c8c5..02c2f1976 100644
--- a/src/input/Keyboard.js
+++ b/src/input/Keyboard.js
@@ -29,17 +29,17 @@ Phaser.Keyboard = function (game) {
     this.enabled = true;
 
     /**
-    * @property {Object} event - The most recent DOM event from keydown or keyup. This is updated every time a new key is pressed or released.
+    * @property {object} event - The most recent DOM event from keydown or keyup. This is updated every time a new key is pressed or released.
     */
     this.event = null;
 
     /**
-    * @property {Object} pressEvent - The most recent DOM event from keypress.
+    * @property {object} pressEvent - The most recent DOM event from keypress.
     */
     this.pressEvent = null;
 
     /**
-    * @property {Object} callbackContext - The context under which the callbacks are run.
+    * @property {object} callbackContext - The context under which the callbacks are run.
     */
     this.callbackContext = this;
 
@@ -111,7 +111,7 @@ Phaser.Keyboard.prototype = {
     * Add callbacks to the Keyboard handler so that each time a key is pressed down or released the callbacks are activated.
     *
     * @method Phaser.Keyboard#addCallbacks
-    * @param {Object} context - The context under which the callbacks are run.
+    * @param {object} context - The context under which the callbacks are run.
     * @param {function} [onDown=null] - This callback is invoked every time a key is pressed down.
     * @param {function} [onUp=null] - This callback is invoked every time a key is released.
     * @param {function} [onPress=null] - This callback is invoked every time the onkeypress event is raised.
diff --git a/src/input/MSPointer.js b/src/input/MSPointer.js
index 674150ff2..fbc2986a1 100644
--- a/src/input/MSPointer.js
+++ b/src/input/MSPointer.js
@@ -22,7 +22,7 @@ Phaser.MSPointer = function (game) {
     this.game = game;
 
     /**
-    * @property {Object} callbackContext - The context under which callbacks are called (defaults to game).
+    * @property {object} callbackContext - The context under which callbacks are called (defaults to game).
     */
     this.callbackContext = this.game;
 
diff --git a/src/input/Mouse.js b/src/input/Mouse.js
index 2e7e79183..f2429fca7 100644
--- a/src/input/Mouse.js
+++ b/src/input/Mouse.js
@@ -22,7 +22,7 @@ Phaser.Mouse = function (game) {
     this.game = game;
 
     /**
-    * @property {Object} callbackContext - The context under which callbacks are called.
+    * @property {object} callbackContext - The context under which callbacks are called.
     */
     this.callbackContext = this.game;
 
diff --git a/src/input/SinglePad.js b/src/input/SinglePad.js
index 58f842a0b..096647792 100644
--- a/src/input/SinglePad.js
+++ b/src/input/SinglePad.js
@@ -11,7 +11,7 @@
 * @class Phaser.SinglePad
 * @constructor
 * @param {Phaser.Game} game - Current game instance.
-* @param {Object} padParent - The parent Phaser.Gamepad object (all gamepads reside under this)
+* @param {object} padParent - The parent Phaser.Gamepad object (all gamepads reside under this)
 */
 Phaser.SinglePad = function (game, padParent) {
 
@@ -33,7 +33,7 @@ Phaser.SinglePad = function (game, padParent) {
     this.connected = false;
 
     /**
-    * @property {Object} callbackContext - The context under which the callbacks are run.
+    * @property {object} callbackContext - The context under which the callbacks are run.
     */
     this.callbackContext = this;
 
@@ -79,7 +79,7 @@ Phaser.SinglePad = function (game, padParent) {
     this._padParent = padParent;
 
     /**
-    * @property {Object} _rawPad - The 'raw' gamepad data.
+    * @property {object} _rawPad - The 'raw' gamepad data.
     * @private
     */
     this._rawPad = null;
@@ -122,8 +122,8 @@ Phaser.SinglePad.prototype = {
     * Add callbacks to this Gamepad to handle connect / disconnect / button down / button up / axis change / float value buttons.
     * 
     * @method Phaser.SinglePad#addCallbacks
-    * @param {Object} context - The context under which the callbacks are run.
-    * @param {Object} callbacks - Object that takes six different callbak methods:
+    * @param {object} context - The context under which the callbacks are run.
+    * @param {object} callbacks - Object that takes six different callbak methods:
     * onConnectCallback, onDisconnectCallback, onDownCallback, onUpCallback, onAxisCallback, onFloatCallback
     */
     addCallbacks: function (context, callbacks) {
@@ -216,7 +216,7 @@ Phaser.SinglePad.prototype = {
     * Gamepad connect function, should be called by Phaser.Gamepad.
     * 
     * @method Phaser.SinglePad#connect
-    * @param {Object} rawPad - The raw gamepad object
+    * @param {object} rawPad - The raw gamepad object
     */
     connect: function (rawPad) {
 
@@ -327,7 +327,7 @@ Phaser.SinglePad.prototype = {
     * Handles changes in axis.
     * 
     * @method Phaser.SinglePad#processAxisChange
-    * @param {Object} axisState - State of the relevant axis
+    * @param {object} axisState - State of the relevant axis
     */
     processAxisChange: function (index, value) {
 
@@ -355,7 +355,7 @@ Phaser.SinglePad.prototype = {
     * 
     * @method Phaser.SinglePad#processButtonDown
     * @param {number} buttonCode - Which buttonCode of this button
-    * @param {Object} value - Button value
+    * @param {object} value - Button value
     */
     processButtonDown: function (buttonCode, value) {
 
@@ -381,7 +381,7 @@ Phaser.SinglePad.prototype = {
     * 
     * @method Phaser.SinglePad#processButtonUp
     * @param {number} buttonCode - Which buttonCode of this button
-    * @param {Object} value - Button value
+    * @param {object} value - Button value
     */
     processButtonUp: function (buttonCode, value) {
 
@@ -407,7 +407,7 @@ Phaser.SinglePad.prototype = {
     * 
     * @method Phaser.SinglePad#processButtonFloat
     * @param {number} buttonCode - Which buttonCode of this button
-    * @param {Object} value - Button value (will range somewhere between 0 and 1, but not specifically 0 or 1.
+    * @param {object} value - Button value (will range somewhere between 0 and 1, but not specifically 0 or 1.
     */
     processButtonFloat: function (buttonCode, value) {
 
diff --git a/src/input/Touch.js b/src/input/Touch.js
index cddcad781..9a4fe0a0c 100644
--- a/src/input/Touch.js
+++ b/src/input/Touch.js
@@ -26,7 +26,7 @@ Phaser.Touch = function (game) {
     this.enabled = true;
 
     /**
-    * @property {Object} callbackContext - The context under which callbacks are called.
+    * @property {object} callbackContext - The context under which callbacks are called.
     */
     this.callbackContext = this.game;
 
diff --git a/src/loader/Cache.js b/src/loader/Cache.js
index 6a3808601..b9761da52 100644
--- a/src/loader/Cache.js
+++ b/src/loader/Cache.js
@@ -959,7 +959,7 @@ Phaser.Cache.prototype = {
     *
     * @method Phaser.Cache#getTilemapData
     * @param {string} key - Asset key of the tilemap data to retrieve from the Cache.
-    * @return {Object} The raw tilemap data in CSV or JSON format.
+    * @return {object} The raw tilemap data in CSV or JSON format.
     */
     getTilemapData: function (key) {
 
diff --git a/src/math/Math.js b/src/math/Math.js
index 0de42adb8..7a91f2e34 100644
--- a/src/math/Math.js
+++ b/src/math/Math.js
@@ -440,7 +440,7 @@ Phaser.Math = {
     * @method Phaser.Math#numberArray
     * @param {number} start - The minimum value the array starts with.
     * @param {number} end - The maximum value the array contains.
-    * @return {array} The array of number values.
+    * @return {number[]} The array of number values.
     * @deprecated 2.2.0 - See {@link Phaser.ArrayUtils.numberArray}
     */
     numberArray: function (start, end) {
@@ -933,10 +933,10 @@ Phaser.Math = {
     * Will return null if random selection is missing, or array has no entries.
     *
     * @method Phaser.Math#getRandom
-    * @param {array} objects - An array of objects.
+    * @param {any[]} objects - An array of objects.
     * @param {number} startIndex - Optional offset off the front of the array. Default value is 0, or the beginning of the array.
     * @param {number} length - Optional restriction on the number of values you want to randomly select from.
-    * @return {object} The random object that was selected.
+    * @return {any} The random object that was selected.
     * @deprecated 2.2.0 - Use {@link Phaser.ArrayUtils.getRandomItem}
     */
     getRandom: function (objects, startIndex, length) {
@@ -948,10 +948,10 @@ Phaser.Math = {
     * Will return null if random selection is missing, or array has no entries.
     *
     * @method Phaser.Math#removeRandom
-    * @param {array} objects - An array of objects.
+    * @param {any[]} objects - An array of objects.
     * @param {number} startIndex - Optional offset off the front of the array. Default value is 0, or the beginning of the array.
     * @param {number} length - Optional restriction on the number of values you want to randomly select from.
-    * @return {object} The random object that was removed.
+    * @return {any} The random object that was removed.
     * @deprecated 2.2.0 - Use {@link Phaser.ArrayUtils.removeRandomItem}
     */
     removeRandom: function (objects, startIndex, length) {
@@ -1062,8 +1062,8 @@ Phaser.Math = {
     /**
     * Shuffles the data in the given array into a new order.
     * @method Phaser.Math#shuffleArray
-    * @param {array} array - The array to shuffle
-    * @return {array} The array
+    * @param {any[]} array - The array to shuffle
+    * @return {any[]} The array
     * @deprecated 2.2.0 - Use {@link Phaser.ArrayUtils.shuffle}
     */
     shuffleArray: function (array) {
diff --git a/src/math/RandomDataGenerator.js b/src/math/RandomDataGenerator.js
index df9c89d7b..a36af65ef 100644
--- a/src/math/RandomDataGenerator.js
+++ b/src/math/RandomDataGenerator.js
@@ -13,7 +13,7 @@
 *
 * @class Phaser.RandomDataGenerator
 * @constructor
-* @param {array} [seeds] - An array of values to use as the seed.
+* @param {any[]} [seeds] - An array of values to use as the seed.
 */
 Phaser.RandomDataGenerator = function (seeds) {
 
@@ -72,7 +72,7 @@ Phaser.RandomDataGenerator.prototype = {
     * Reset the seed of the random data generator.
     *
     * @method Phaser.RandomDataGenerator#sow
-    * @param {array} seeds
+    * @param {any[]} seeds
     */
     sow: function (seeds) {
 
@@ -102,7 +102,7 @@ Phaser.RandomDataGenerator.prototype = {
     *
     * @method Phaser.RandomDataGenerator#hash
     * @private
-    * @param {Any} data
+    * @param {any} data
     * @return {number} hashed value.
     */
     hash: function (data) {
diff --git a/src/physics/arcade/World.js b/src/physics/arcade/World.js
index 9a763a514..f518da6a9 100644
--- a/src/physics/arcade/World.js
+++ b/src/physics/arcade/World.js
@@ -1398,7 +1398,7 @@ Phaser.Physics.Arcade.prototype = {
     * @param {Phaser.Group} group - The Group to check.
     * @param {function} [callback] - A callback function that is called if the object overlaps with the Pointer. The callback will be sent two parameters: the Pointer and the Object that overlapped with it.
     * @param {object} [callbackContext] - The context in which to run the callback.
-    * @return {array} An array of the Sprites from the Group that overlapped the Pointer coordinates.
+    * @return {PIXI.DisplayObject[]} An array of the Sprites from the Group that overlapped the Pointer coordinates.
     */
     getObjectsUnderPointer: function (pointer, group, callback, callbackContext) {
 
@@ -1422,7 +1422,7 @@ Phaser.Physics.Arcade.prototype = {
     * @param {function} [callback] - A callback function that is called if the object overlaps the coordinates. The callback will be sent two parameters: the callbackArg and the Object that overlapped the location.
     * @param {object} [callbackContext] - The context in which to run the callback.
     * @param {object} [callbackArg] - An argument to pass to the callback.
-    * @return {array} An array of the Sprites from the Group that overlapped the coordinates.
+    * @return {PIXI.DisplayObject[]} An array of the Sprites from the Group that overlapped the coordinates.
     */
     getObjectsAtLocation: function (x, y, group, callback, callbackContext, callbackArg) {
 
diff --git a/src/system/Canvas.js b/src/system/Canvas.js
index 8a56e7289..bdb0b33eb 100644
--- a/src/system/Canvas.js
+++ b/src/system/Canvas.js
@@ -65,7 +65,7 @@ Phaser.Canvas = {
     *
     * @method Phaser.Canvas.setTouchAction
     * @param {HTMLCanvasElement} canvas - The canvas to set the touch action on.
-    * @param {String} [value] - The touch action to set. Defaults to 'none'.
+    * @param {string} [value] - The touch action to set. Defaults to 'none'.
     * @return {HTMLCanvasElement} The source canvas.
     */
     setTouchAction: function (canvas, value) {
@@ -85,7 +85,7 @@ Phaser.Canvas = {
     *
     * @method Phaser.Canvas.setUserSelect
     * @param {HTMLCanvasElement} canvas - The canvas to set the touch action on.
-    * @param {String} [value] - The touch action to set. Defaults to 'none'.
+    * @param {string} [value] - The touch action to set. Defaults to 'none'.
     * @return {HTMLCanvasElement} The source canvas.
     */
     setUserSelect: function (canvas, value) {
diff --git a/src/system/DOM.js b/src/system/DOM.js
index 657969367..921bc7a7a 100644
--- a/src/system/DOM.js
+++ b/src/system/DOM.js
@@ -79,9 +79,9 @@ Phaser.DOM = {
     *
     * @method Phaser.DOM.calibrate
     * @private
-    * @param {Object} coords - An object containing the following properties: `{top: number, right: number, bottom: number, left: number}`
+    * @param {object} coords - An object containing the following properties: `{top: number, right: number, bottom: number, left: number}`
     * @param {number} [cushion] - A value to adjust the coordinates by.
-    * @return {Object} The calibrated element coordinates
+    * @return {object} The calibrated element coordinates
     */
     calibrate: function (coords, cushion) {
 
diff --git a/src/time/Time.js b/src/time/Time.js
index a8753d33c..d05cf6890 100644
--- a/src/time/Time.js
+++ b/src/time/Time.js
@@ -252,7 +252,7 @@ Phaser.Time = function (game) {
     this._justResumed = false;
 
     /**
-    * @property {array} _timers - Internal store of Phaser.Timer objects.
+    * @property {Phaser.Timer[]} _timers - Internal store of Phaser.Timer objects.
     * @private
     */
     this._timers = [];
diff --git a/src/time/Timer.js b/src/time/Timer.js
index bf74d3b22..56c5c06d6 100644
--- a/src/time/Timer.js
+++ b/src/time/Timer.js
@@ -196,7 +196,7 @@ Phaser.Timer.prototype = {
     * @param {number} repeatCount - The number of times the event will repeat.
     * @param {function} callback - The callback that will be called when the Timer event occurs.
     * @param {object} callbackContext - The context in which the callback will be called.
-    * @param {array} arguments - The values to be sent to your callback function when it is called.
+    * @param {any[]} arguments - The values to be sent to your callback function when it is called.
     * @return {Phaser.TimerEvent} The Phaser.TimerEvent object that was created.
     */
     create: function (delay, loop, repeatCount, callback, callbackContext, args) {
diff --git a/src/time/TimerEvent.js b/src/time/TimerEvent.js
index 35b68717c..3631cae41 100644
--- a/src/time/TimerEvent.js
+++ b/src/time/TimerEvent.js
@@ -21,7 +21,7 @@
 * @param {boolean} loop - True if this TimerEvent loops, otherwise false.
 * @param {function} callback - The callback that will be called when the TimerEvent occurs.
 * @param {object} callbackContext - The context in which the callback will be called.
-* @param {array} arguments - Additional arguments to be passed to the callback.
+* @param {any[]} arguments - Additional arguments to be passed to the callback.
 */
 Phaser.TimerEvent = function (timer, delay, tick, repeatCount, loop, callback, callbackContext, args) {
 
diff --git a/src/tween/Tween.js b/src/tween/Tween.js
index e89d7aa80..c8e1936e9 100644
--- a/src/tween/Tween.js
+++ b/src/tween/Tween.js
@@ -70,7 +70,7 @@ Phaser.Tween = function (target, game, manager) {
     /**
     * @property {boolean} pendingDelete - True if this Tween is ready to be deleted by the TweenManager.
     * @default
-    * @readOnly
+    * @readonly
     */
     this.pendingDelete = false;
 
@@ -119,12 +119,12 @@ Phaser.Tween = function (target, game, manager) {
     /**
     * @property {number} current - The current Tween child being run.
     * @default
-    * @readOnly
+    * @readonly
     */
     this.current = 0;
 
     /**
-    * @property {Object} properties - Target property cache used when building the child data values.
+    * @property {object} properties - Target property cache used when building the child data values.
     */
     this.properties = {};
 
diff --git a/src/tween/TweenData.js b/src/tween/TweenData.js
index 74ea1b3d0..1eceb3edf 100644
--- a/src/tween/TweenData.js
+++ b/src/tween/TweenData.js
@@ -57,13 +57,13 @@ Phaser.TweenData = function (parent) {
 
     /**
     * @property {number} percent - A value between 0 and 1 that represents how far through the duration this tween is.
-    * @readOnly
+    * @readonly
     */
     this.percent = 0;
 
     /**
     * @property {number} value - The current calculated value.
-    * @readOnly
+    * @readonly
     */
     this.value = 0;
 
diff --git a/src/tween/TweenManager.js b/src/tween/TweenManager.js
index c9ac2f1b7..4cc170899 100644
--- a/src/tween/TweenManager.js
+++ b/src/tween/TweenManager.js
@@ -191,7 +191,7 @@ Phaser.TweenManager.prototype = {
     * Create a tween object for a specific object. The object can be any JavaScript object or Phaser object such as Sprite.
     *
     * @method Phaser.TweenManager#create
-    * @param {Object} object - Object the tween will be run on.
+    * @param {object} object - Object the tween will be run on.
     * @returns {Phaser.Tween} The newly created tween object.
     */
     create: function (object) {
diff --git a/src/utils/ArraySet.js b/src/utils/ArraySet.js
index bc67eda5f..84524b4ab 100644
--- a/src/utils/ArraySet.js
+++ b/src/utils/ArraySet.js
@@ -40,8 +40,8 @@ Phaser.ArraySet.prototype = {
     * If the item already exists in the list it is not moved.
     *
     * @method Phaser.ArraySet#add
-    * @param {*} item - The element to add to this list.
-    * @return {*} The item that was added.
+    * @param {any} item - The element to add to this list.
+    * @return {any} The item that was added.
     */
     add: function (item) {
 
@@ -58,8 +58,8 @@ Phaser.ArraySet.prototype = {
     * Gets the index of the item in the list, or -1 if it isn't in the list.
     *
     * @method Phaser.ArraySet#getIndex
-    * @param {*} item - The element to get the list index for.
-    * @return {number} The index of the item or -1 if not found.
+    * @param {any} item - The element to get the list index for.
+    * @return {integer} The index of the item or -1 if not found.
     */
     getIndex: function (item) {
 
@@ -71,7 +71,7 @@ Phaser.ArraySet.prototype = {
     * Checks for the item within this list.
     *
     * @method Phaser.ArraySet#exists
-    * @param {*} item - The element to get the list index for.
+    * @param {any} item - The element to get the list index for.
     * @return {boolean} True if the item is found in the list, otherwise false.
     */
     exists: function (item) {
@@ -95,8 +95,8 @@ Phaser.ArraySet.prototype = {
     * Removes the given element from this list if it exists.
     *
     * @method Phaser.ArraySet#remove
-    * @param {*} item - The item to be removed from the list.
-    * @return {*} item - The item that was removed.
+    * @param {any} item - The item to be removed from the list.
+    * @return {any} item - The item that was removed.
     */
     remove: function (item) {
 
@@ -114,8 +114,8 @@ Phaser.ArraySet.prototype = {
     * Sets the property `key` to the given value on all members of this list.
     *
     * @method Phaser.ArraySet#setAll
-    * @param {*} key - The propety of the item to set.
-    * @param {*} value - The value to set the property to.
+    * @param {any} key - The propety of the item to set.
+    * @param {any} value - The value to set the property to.
     */
     setAll: function (key, value) {
 
@@ -177,7 +177,7 @@ Object.defineProperty(Phaser.ArraySet.prototype, "total", {
 * Returns the first item and resets the cursor to the start.
 *
 * @name Phaser.ArraySet#first
-* @property {*} first
+* @property {any} first
 */
 Object.defineProperty(Phaser.ArraySet.prototype, "first", {
 
@@ -202,7 +202,7 @@ Object.defineProperty(Phaser.ArraySet.prototype, "first", {
 * Returns the the next item (based on the cursor) and advances the cursor.
 *
 * @name Phaser.ArraySet#next
-* @property {*} next
+* @property {any} next
 */
 Object.defineProperty(Phaser.ArraySet.prototype, "next", {
 
diff --git a/src/utils/ArrayUtils.js b/src/utils/ArrayUtils.js
index 992c25e47..b263fc741 100644
--- a/src/utils/ArrayUtils.js
+++ b/src/utils/ArrayUtils.js
@@ -72,8 +72,8 @@ Phaser.ArrayUtils = {
     * A standard Fisher-Yates Array shuffle implementation which modifies the array in place.
     *
     * @method
-    * @param {array} array - The array to shuffle.
-    * @return {array} The original array, now shuffled.
+    * @param {any[]} array - The array to shuffle.
+    * @return {any[]} The original array, now shuffled.
     */
     shuffle: function (array) {
 
@@ -93,8 +93,8 @@ Phaser.ArrayUtils = {
     * Transposes the elements of the given Array.
     *
     * @method
-    * @param {array} array - The array to transpose.
-    * @return {array} The transposed array.
+    * @param {array[]} array - The array to transpose.
+    * @return {array[]} The transposed array.
     */
     transposeMatrix: function (array) {
 
@@ -119,9 +119,9 @@ Phaser.ArrayUtils = {
     * Based on the routine from http://jsfiddle.net/MrPolywhirl/NH42z/
     *
     * @method
-    * @param {array} matrix - The array to rotate.
+    * @param {array[]} matrix - The array to rotate.
     * @param {number|string} direction - The amount to rotate. Either a number: 90, -90, 270, -270, 180 or a string: 'rotateLeft', 'rotateRight' or 'rotate180'
-    * @return {array} The rotated array
+    * @return {array[]} The rotated array
     */
     rotateMatrix: function (matrix, direction) {
 
@@ -210,7 +210,7 @@ Phaser.ArrayUtils = {
     * @method Phaser.Math#numberArray
     * @param {number} start - The minimum value the array starts with.
     * @param {number} end - The maximum value the array contains.
-    * @return {array} The array of number values.
+    * @return {number[]} The array of number values.
     */
     numberArray: function (start, end) {
 
diff --git a/src/utils/Utils.js b/src/utils/Utils.js
index 5d2345c8b..dd907d9e8 100644
--- a/src/utils/Utils.js
+++ b/src/utils/Utils.js
@@ -105,8 +105,8 @@ Phaser.Utils = {
     * Transposes the elements of the given Array.
     *
     * @method Phaser.Utils.transposeArray
-    * @param {array} array - The array to transpose.
-    * @return {array} The transposed array.
+    * @param {array[]} array - The array to transpose.
+    * @return {array[]} The transposed array.
     * @deprecated 2.2.0 - Use Phaser.ArrayUtils.transposeMatrix
     */
     transposeArray: function (array) {
@@ -118,9 +118,9 @@ Phaser.Utils = {
     * Based on the routine from http://jsfiddle.net/MrPolywhirl/NH42z/
     *
     * @method Phaser.Utils.rotateArray
-    * @param {array} matrix - The array to rotate.
+    * @param {array[]} matrix - The array to rotate.
     * @param {number|string} direction - The amount to rotate. Either a number: 90, -90, 270, -270, 180 or a string: 'rotateLeft', 'rotateRight' or 'rotate180'
-    * @return {array} The rotated array
+    * @return {array[]} The rotated array
     * @deprecated 2.2.0 - Use Phaser.ArrayUtils.rotateMatrix
     */
     rotateArray: function (matrix, direction) {
@@ -131,8 +131,8 @@ Phaser.Utils = {
     * A standard Fisher-Yates Array shuffle implementation.
     *
     * @method Phaser.Utils.shuffle
-    * @param {array} array - The array to shuffle.
-    * @return {array} The shuffled array.
+    * @param {any[]} array - The array to shuffle.
+    * @return {any[]} The shuffled array.
     * @deprecated 2.2.0 - User Phaser.ArrayUtils.shuffle
     */
     shuffle: function (array) {