Group.createMultiple can now accept Arrays for both the key and frame arguments. This allows you to create multiple sprites using each key and/or frame in the arrays, which is a great and quick way to build diverse Groups. See the JSDocs for complete details and code examples.

Author: photonstorm

README.md

@@ -391,6 +391,7 @@ You can read all about the philosophy behind Lazer [here](http://phaser.io/news/
 * Group.createMultiple now returns an Array containing references to all of the children that the method created.
 * Cache.getJSON will now return an Array if the `key` you provided points to an array instead of an Object (thanks @drhayes #2552 #2551)
 * Phaser.Matrix if passed a 0 value would consider it falsy, and replace it with the default by mistake. It now checks if the arguments are `undefined` or `null` and only then sets the defaults (thanks mmcs)
+* Group.createMultiple can now accept Arrays for both the `key` and `frame` arguments. This allows you to create multiple sprites using each key and/or frame in the arrays, which is a great and quick way to build diverse Groups. See the JSDocs for complete details and code examples.
 
 ### Bug Fixes
 

src/core/Group.js

@@ -573,10 +573,36 @@ Phaser.Group.prototype.create = function (x, y, key, frame, exists, index) {
 
 /**
 * Creates multiple Phaser.Sprite objects and adds them to the top of this Group.
+* 
+* This method is useful if you need to quickly generate a pool of sprites, such as bullets.
 *
 * Use {@link #classType} to change the type of object created.
 *
-* This method is useful if you need to quickly generate a pool of identical sprites, such as bullets.
+* You can provide an array as the `key` and / or `frame` arguments. When you do this
+* it will create `quantity` Sprites for every key (and frame) in the arrays.
+* 
+* For example:
+* 
+* `createMultiple(25, ['ball', 'carrot'])`
+*
+* In the above code there are 2 keys (ball and carrot) which means that 50 sprites will be
+* created in total, 25 of each. You can also have the `frame` as an array:
+*
+* `createMultiple(5, 'bricks', [0, 1, 2, 3])`
+*
+* In the above there is one key (bricks), which is a sprite sheet. The frames array tells
+* this method to use frames 0, 1, 2 and 3. So in total it will create 20 sprites, because
+* the quantity was set to 5, so that is 5 brick sprites of frame 0, 5 brick sprites with
+* frame 1, and so on.
+*
+* If you set both the key and frame arguments to be arrays then understand it will create
+* a total quantity of sprites equal to the size of both arrays times each other. I.e.:
+*
+* `createMultiple(20, ['diamonds', 'balls'], [0, 1, 2])`
+*
+* The above will create 20 'diamonds' of frame 0, 20 with frame 1 and 20 with frame 2.
+* It will then create 20 'balls' of frame 0, 20 with frame 1 and 20 with frame 2.
+* In total it will have created 120 sprites.
 *
 * By default the Sprites will have their `exists` property set to `false`, and they will be 
 * positioned at 0x0, relative to the `Group.x / y` values.
@@ -587,22 +613,42 @@ Phaser.Group.prototype.create = function (x, y, key, frame, exists, index) {
 *
 * @method Phaser.Group#createMultiple
 * @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 {integer|string} [frame] - If the Sprite image contains multiple frames you can specify which one to use here.
+* @param {string|array} key - The Cache key of the image that the Sprites will use. Or an Array of keys. See the description for details on how the quantity applies when arrays are used.
+* @param {integer|string|array} [frame=0] - If the Sprite image contains multiple frames you can specify which one to use here. Or an Array of frames. See the description for details on how the quantity applies when arrays are used.
 * @param {boolean} [exists=false] - The default exists state of the Sprite.
 * @return {array} An array containing all of the Sprites that were created.
 */
 Phaser.Group.prototype.createMultiple = function (quantity, key, frame, exists) {
 
+    if (frame === undefined) { frame = 0; }
     if (exists === undefined) { exists = false; }
 
-    var children = [];
+    if (!Array.isArray(key))
+    {
+        key = [ key ];
+    }
 
-    for (var i = 0; i < quantity; i++)
+    if (!Array.isArray(frame))
     {
-        children.push(this.create(0, 0, key, frame, exists));
+        frame = [ frame ];
     }
 
+    var _this = this;
+    var children = [];
+
+    key.forEach(function(singleKey) {
+
+        frame.forEach(function(singleFrame) {
+
+            for (var i = 0; i < quantity; i++)
+            {
+                children.push(_this.create(0, 0, singleKey, singleFrame, exists));
+            }
+
+        });
+
+    });
+
     return children;
 
 };
@@ -626,6 +672,37 @@ Phaser.Group.prototype.updateZ = function () {
 
 };
 
+Phaser.Group.prototype.align = function (rows, columns, cellWidth, cellHeight, alignType) {
+
+    if (this.children.length === 0) { return; }
+
+    var x = 0;
+    var y = 0;
+    var c = 0;
+
+    for (var i = 0; i < this.children.length; i++)
+    {
+        var child = this.children[i];
+
+        var b = child.getBounds();
+
+        //  First let's just align based on the top-left of the child
+        x = c * cellWidth;
+
+        child.x = x;
+        child.y = y;
+
+        c++;
+
+        if (c === rows)
+        {
+            c = 0;
+            y += cellHeight;
+        }
+    }
+
+};
+
 /**
 * Sets the group cursor to the first child in the group.
 *

typescript/phaser.d.ts

@@ -1,7 +1,7 @@
 /// <reference path="pixi.d.ts" />
 /// <reference path="p2.d.ts" />
 
-// Type definitions for Phaser 2.4.9 - 14th June 2016
+// Type definitions for Phaser 2.4.9 - 15th June 2016
 // Project: https://github.com/photonstorm/phaser
 
 declare module "phaser" {
@@ -1727,7 +1727,7 @@ declare module "phaser" {
             countDead(): number;
             countLiving(): number;
             create(x: number, y: number, key?: string | Phaser.RenderTexture | Phaser.BitmapData | Phaser.Video | PIXI.Texture, frame?: string | number, exists?: boolean, index?: number): any;
-            createMultiple(quantity: number, key: string, frame?: any, exists?: boolean): any[];
+            createMultiple(quantity: number, key: string | string[], frame?: any | any[], exists?: boolean): any[];
             customSort(sortHandler: Function, context?: any): void;
             destroy(destroyChildren?: boolean, soft?: boolean): void;
             divideAll(property: string, amount: number, checkAlive?: boolean, checkVisible?: boolean): void;