Layer.createMultiple can now take an array of config objects.

Author: photonstorm

v3/src/checksum.js

@@ -1,4 +1,4 @@
 var CHECKSUM = {
-build: '262e7d70-1411-11e7-8d7e-9ffab0018bd6'
+build: '448d6cb0-1414-11e7-9400-83d0899b34cd'
 };
 module.exports = CHECKSUM;

v3/src/gameobjects/layer/Layer.js

@@ -54,62 +54,30 @@ var Layer = new Class({
         return child;
     },
 
-    /**
-    * 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.
-    *
-    * 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 be positioned at 0x0.
-    *
-    * @method Phaser.Group#createMultiple
-    * @param {integer} quantity - The number of Sprites to create.
-    * @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.
-    */
-    createMultiple: function (key, frame, options)
-    {
-        if (frame === undefined) { frame = null; }
-
+    createFromConfig: function (options)
+    {
+        var key = GetObjectValue(options, 'key', undefined);
+        var frame = GetObjectValue(options, 'frame', null);
         var visible = GetObjectValue(options, 'visible', true);
 
-        if (!Array.isArray(key))
+        var entries = [];
+
+        //  Can't do anything without at least a key
+        if (key === undefined)
         {
-            key = [ key ];
+            return entries;
         }
-
-        if (!Array.isArray(frame))
+        else
         {
-            frame = [ frame ];
+            if (!Array.isArray(key))
+            {
+                key = [ key ];
+            }
+
+            if (!Array.isArray(frame))
+            {
+                frame = [ frame ];
+            }
         }
 
         //  Build an array of key frame pairs to loop through
@@ -121,8 +89,6 @@ var Layer = new Class({
         var quantity = GetObjectValue(options, 'quantity', 1);
         var max = GetObjectValue(options, 'max', 0);
 
-        var entries = [];
-
         var range = Range(key, frame, {
             max: max,
             qty: quantity,
@@ -132,9 +98,9 @@ var Layer = new Class({
             yoyo: yoyo
         });
 
-        for (var i = 0; i < range.length; i++)
+        for (var c = 0; c < range.length; c++)
         {
-            entries.push(this.create(0, 0, range[i].a, range[i].b, visible));
+            entries.push(this.create(0, 0, range[c].a, range[c].b, visible));
         }
 
         //  Post-creation options (applied only to those items created in this call):
@@ -166,6 +132,25 @@ var Layer = new Class({
         return entries;
     },
 
+    createMultiple: function (config)
+    {
+        if (!Array.isArray(config))
+        {
+            config = [ config ];
+        }
+
+        var output = [];
+
+        for (var i = 0; i < config.length; i++)
+        {
+            var entries = this.createFromConfig(config[i]);
+
+            output = output.concat(entries);
+        }
+
+        return output;
+    },
+
     remove: function (child)
     {
         this.children.delete(child);