Added Layer actions for create, createMultiple, rotation around a fixed point, rotation by distance, and positioning around a circle.

Author: photonstorm

v3/src/checksum.js

@@ -1,4 +1,4 @@
 var CHECKSUM = {
-build: 'fec73390-133d-11e7-8896-516d977f6ae4'
+build: 'b5ac0990-1358-11e7-8a48-1f6ad0f93601'
 };
 module.exports = CHECKSUM;

v3/src/gameobjects/layer/Layer.js

@@ -2,31 +2,19 @@
 var Class = require('../../utils/Class');
 var Set = require('../../structs/Set');
 var Actions = require('./actions/');
+var Sprite = require('../sprite/Sprite');
 
 var Layer = new Class({
 
-    Mixins: [
-        Actions.IncX,
-        Actions.IncY,
-        Actions.IncXY,
-        Actions.SetX,
-        Actions.SetY,
-        Actions.SetXY,
-        Actions.Rotate,
-        Actions.Angle,
-        Actions.SetRotation,
-        Actions.SetVisible,
-        Actions.ToggleVisible,
-        Actions.Align
-    ],
-
     initialize:
 
     function Layer (state, children)
     {
         this.state = state;
 
         this.children = new Set(children);
+
+        this.classType = Sprite;
     },
 
     //  Layer management methods:
@@ -51,6 +39,96 @@ var Layer = new Class({
         return this;
     },
 
+    create: function (x, y, key, frame, visible)
+    {
+        if (visible === undefined) { visible = true; }
+
+        var child = this.state.children.add(new this.classType(this.state, x, y, key, frame));
+
+        child.visible = visible;
+
+        return this.add(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 have their `exists` property set to `false`, and they will be 
+    * positioned at 0x0, relative to the `Group.x / y` values.
+    * 
+    * If `Group.enableBody` is set, then a physics body will be created on the objects, so long as one does not already exist.
+    *
+    * If `Group.inputEnableChildren` is set, then an Input Handler will be created on the objects, so long as one does not already exist.
+    *
+    * @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 (quantity, key, frame, visible)
+    {
+        if (frame === undefined) { frame = null; }
+        if (visible === undefined) { visible = true; }
+
+        if (!Array.isArray(key))
+        {
+            key = [ key ];
+        }
+
+        if (!Array.isArray(frame))
+        {
+            frame = [ frame ];
+        }
+
+        var _this = this;
+        var entries = [];
+
+        key.forEach(function (singleKey)
+        {
+            frame.forEach(function (singleFrame)
+            {
+                for (var i = 0; i < quantity; i++)
+                {
+                    entries.push(_this.create(0, 0, singleKey, singleFrame, visible));
+                }
+            });
+        });
+
+        return entries;
+    },
+
     remove: function (child)
     {
         this.children.delete(child);
@@ -71,7 +149,27 @@ var Layer = new Class({
 
         this.state = undefined;
         this.children = undefined;
-    }
+    },
+
+    //  Child related methods
+
+    align: Actions.Align,
+    angle: Actions.Angle,
+    incX: Actions.IncX,
+    incXY: Actions.IncXY,
+    incY: Actions.IncY,
+    positionAroundCircle: Actions.PositionAroundCircle,
+    rotate: Actions.Rotate,
+    rotateAround: Actions.RotateAround,
+    rotateAroundDistance: Actions.RotateAroundDistance,
+    setRotation: Actions.SetRotation,
+    setVisible: Actions.SetVisible,
+    setX: Actions.SetX,
+    setXY: Actions.SetXY,
+    setY: Actions.SetY,
+    toggleVisible: Actions.ToggleVisible
+
+
 });
 
 module.exports = Layer;

v3/src/gameobjects/layer/actions/PositionAroundCircle.js

@@ -0,0 +1,20 @@
+var PositionAroundCircle = function (circle, startAngle, endAngle)
+{
+    if (startAngle === undefined) { startAngle = 0; }
+    if (endAngle === undefined) { endAngle = 6.28; }
+
+    var children = this.children.entries;
+
+    var angle = startAngle;
+    var angleStep = (endAngle - startAngle) / children.length;
+
+    for (var i = 0; i < children.length; i++)
+    {
+        children[i].x = circle.x + (circle.radius * Math.cos(angle));
+        children[i].y = circle.y + (circle.radius * Math.sin(angle));
+
+        angle += angleStep;
+    }
+};
+
+module.exports = PositionAroundCircle;

v3/src/gameobjects/layer/actions/RotateAround.js

@@ -0,0 +1,22 @@
+var RotateAroundDistance = require('../../../math/RotateAroundDistance');
+var DistanceBetween = require('../../../math/distance/DistanceBetween');
+
+//  point = any object with public x/y properties
+
+var RotateAround = function (point, angle)
+{
+    var x = point.x;
+    var y = point.y;
+    var children = this.children.entries;
+
+    for (var i = 0; i < children.length; i++)
+    {
+        var child = children[i];
+
+        RotateAroundDistance(child, x, y, angle, Math.max(1, DistanceBetween(child.x, child.y, x, y)));
+    }
+
+    return this;
+};
+
+module.exports = RotateAround;

v3/src/gameobjects/layer/actions/RotateAroundDistance.js

@@ -0,0 +1,21 @@
+var MathRotateAroundDistance = require('../../../math/RotateAroundDistance');
+
+//  point = any object with public x/y properties
+//  angle = radians
+//  distance = px
+
+var RotateAroundDistance = function (point, angle, distance)
+{
+    var x = point.x;
+    var y = point.y;
+    var children = this.children.entries;
+
+    for (var i = 0; i < children.length; i++)
+    {
+        MathRotateAroundDistance(children[i], x, y, angle, distance);
+    }
+
+    return this;
+};
+
+module.exports = RotateAroundDistance;

v3/src/gameobjects/layer/actions/index.js

@@ -5,7 +5,10 @@ module.exports = {
     IncY: require('./IncY'),
     Align: require('./Align'),
     Angle: require('./Angle'),
+    PositionAroundCircle: require('./PositionAroundCircle'),
     Rotate: require('./Rotate'),
+    RotateAround: require('./RotateAround'),
+    RotateAroundDistance: require('./RotateAroundDistance'),
     SetRotation: require('./SetRotation'),
     SetVisible: require('./SetVisible'),
     SetX: require('./SetX'),

v3/src/geom/circle/CircumferencePoint.js

@@ -2,7 +2,7 @@
 * Returns a Point object containing the coordinates of a point on the circumference of the Circle based on the given angle.
 * @method Phaser.Circle.circumferencePoint
 * @param {Phaser.Circle} a - The first Circle object.
-* @param {number} angle - The angle in radians (unless asDegrees is true) to return the point from.
+* @param {number} angle - The angle in radians to return the point from.
 * @param {Phaser.Point} [out] - An optional Point object to put the result in to. If none specified a new Point object will be created.
 * @return {Phaser.Point} The Point object holding the result.
 */

v3/src/math/RotateAroundDistance.js

@@ -1,4 +1,7 @@
-//  p = Point or any object with public x/y properties
+//  p = Point or any object with public x/y properties, the item to be rotated
+//  x/y = the coordinate to rotate around
+//  angle = radians
+//  distance = in px
 
 var RotateAroundDistance = function (point, x, y, angle, distance)
 {

v3/src/textures/Texture.js

@@ -146,43 +146,9 @@ Texture.prototype = {
     */
     destroy: function ()
     {
-        //  Need to iterate though the TextureSources, and unload each one
-        //  then clear out the frames
-
-        /*
-        if (this.source)
-        {
-            Phaser.CanvasPool.removeByCanvas(this.source);
-        }
-
-        this.source = null;
-        */
-    }
-
-};
-
-/**
-* Helper function that creates a base texture from the given canvas element.
-*
-* @static
-* @method fromCanvas
-* @param canvas {Canvas} The canvas element source of the texture
-* @param scaleMode {Number} See {{#crossLink "PIXI/scaleModes:property"}}Phaser.scaleModes{{/crossLink}} for possible values
-* @return {BaseTexture}
-Phaser.Texture.fromCanvas = function (canvas, scaleMode)
-{
-    if (canvas.width === 0)
-    {
-        canvas.width = 1;
+        //  TODO
     }
 
-    if (canvas.height === 0)
-    {
-        canvas.height = 1;
-    }
-
-    return new Phaser.Texture(canvas, scaleMode);
 };
-*/
 
 module.exports = Texture;