Moving to a value ops system for emitters, like the TweenBuilder

Author: photonstorm

v3/src/gameobjects/particles/GetValueOp.js

@@ -0,0 +1,170 @@
+var GetEaseFunction = require('../../tweens/builder/GetEaseFunction');
+var GetValue = require('../../utils/object/GetValue');
+var GetFastValue = require('../../utils/object/GetFastValue');
+var FloatBetween = require('../../math/FloatBetween');
+
+function hasOnEmit (def)
+{
+    return (!!def.onEmit && typeof def.onEmit === 'function');
+}
+
+function hasOnUpdate (def)
+{
+    return (!!def.onUpdate && typeof def.onUpdate === 'function');
+}
+
+function hasGetters (def)
+{
+    return hasOnEmit(def) || hasOnUpdate(def);
+}
+
+var GetValueOp = function (config, key, defaultValue)
+{
+    var propertyValue = GetFastValue(config, key, defaultValue);
+
+    //  The returned value sets what the property will be at the START of the particles life, on emit
+    var particleEmit = function (particle, key, value) { return value; };
+
+    //  The returned value updates the property for the duration of the particles life
+    var particleUpdate = function (particle, key, t, value) { return value; };
+
+    var t = typeof(propertyValue);
+
+    if (t === 'number')
+    {
+        //  Explicit static value:
+
+        //  x: 400
+
+        particleEmit = function ()
+        {
+            return propertyValue;
+        };
+
+        particleUpdate = function ()
+        {
+            return propertyValue;
+        };
+    }
+    else if (Array.isArray(propertyValue))
+    {
+        //  Picks a random element from the array:
+
+        //  x: [ 100, 200, 300, 400 ]
+
+        particleEmit = function ()
+        {
+            var randomIndex = Math.floor(Math.random() * propertyValue.length);
+
+            return propertyValue[randomIndex];
+        };
+    }
+    else if (t === 'function')
+    {
+        //  The same as setting just the onUpdate function and no onEmit
+        //  Custom callback, must return a value:
+
+        /*
+        x: function (particle, key, t, value)
+           {
+               return value + 50;
+           }
+        */
+
+        particleUpdate = propertyValue;
+    }
+    else if (t === 'object' && propertyValue.hasOwnProperty('start') && propertyValue.hasOwnProperty('end'))
+    {
+        var start = propertyValue.start;
+        var end = propertyValue.end;
+
+        //  A random starting value:
+
+        //  x: { start: 100, end: 400, randomStart: true }
+
+        if (propertyValue.hasOwnProperty('randomStart'))
+        {
+            particleEmit = function ()
+            {
+                return FloatBetween(start, end);
+            };
+        }
+        else
+        {
+            particleEmit = function ()
+            {
+                return start;
+            };
+        }
+
+        if (propertyValue.hasOwnProperty('steps'))
+        {
+            //  A stepped (per emit) range
+
+            //  x: { start: 100, end: 400, steps: 64 }
+
+            //  Increments a value stored in the emitter
+
+            particleUpdate = function (particle, key)
+            {
+                var emitter = particle.emitter;
+
+                return emitter.getNext(key);
+            };
+        }
+        else
+        {
+            //  An eased range (defaults to Linear if not specified)
+
+            //  x: { start: 100, end: 400, [ ease: 'Linear' ] }
+
+            var ease = (propertyValue.hasOwnProperty('ease')) ? propertyValue.ease : 'Linear';
+
+            var easeFunc = GetEaseFunction(ease);
+
+            particleUpdate = function (particle, key, t, value)
+            {
+                var data = particle.data[key];
+
+                return data.calc * easeFunc(t) + data.min;
+            }
+        }
+    }
+    else if (t === 'object' && hasGetters(propertyValue))
+    {
+        //  Custom onEmit and onUpdate callbacks
+
+        /*
+        x: {
+            //  Called at the start of the particles life, when it is being created
+            onEmit: function (particle, key, t, value)
+            {
+                return value;
+            },
+
+            //  Called during the particles life on each update
+            onUpdate: function (particle, key, t, value)
+            {
+                return value;
+            }
+        }
+        */
+
+        if (hasOnEmit(propertyValue))
+        {
+            particleEmit = propertyValue.onEmit;
+        }
+
+        if (hasOnUpdate(propertyValue))
+        {
+            particleUpdate = propertyValue.onUpdate;
+        }
+    }
+
+    return {
+        onEmit: particleEmit,
+        onUpdate: particleUpdate
+    };
+};
+
+module.exports = GetValueOp;

v3/src/gameobjects/particles/Particle.js

@@ -6,8 +6,10 @@ var Particle = new Class({
 
     initialize:
 
-    function Particle ()
+    function Particle (emitter)
     {
+        this.emitter = emitter;
+
         //  Phaser.Texture.Frame
         this.frame = null;
 
@@ -54,24 +56,26 @@ var Particle = new Class({
         return (this.lifeCurrent > 0);
     },
 
-    emit: function (emitter)
+    emit: function ()
     {
+        var emitter = this.emitter;
+
         this.frame = emitter.getFrame();
 
         if (emitter.zone)
         {
             emitter.zone.getRandomPoint(this);
         }
 
-        this.x += emitter.x;
-        this.y += emitter.y;
+        this.x += emitter.x.getNext();
+        this.y += emitter.y.getNext();
 
-        var sx = emitter.speed.getRandomX();
-        var sy = emitter.speed.getRandomY();
+        var sx = emitter.speedX.getNext();
+        var sy = emitter.speedY.getNext();
 
         if (emitter.radial)
         {
-            var rad = DegToRad(emitter.emitterAngle.getRandom());
+            var rad = DegToRad(emitter.emitterAngle.getNext());
 
             this.velocityX = Math.cos(rad) * Math.abs(sx);
             this.velocityY = Math.sin(rad) * Math.abs(sy);
@@ -82,7 +86,7 @@ var Particle = new Class({
             this.velocityY = sy;
         }
 
-        this.life = emitter.lifespan.getRandom();
+        this.life = emitter.lifespan.getNext();
         this.lifeCurrent = this.life;
 
         //  eased values
@@ -92,9 +96,9 @@ var Particle = new Class({
         var dataAngle = this.data.angle;
         var dataAlpha = this.data.alpha;
 
-        emitter.scale.copyXToMinMax(dataScaleX);
-        emitter.scale.copyYToMinMax(dataScaleY);
-        emitter.angle.copyToMinMax(dataAngle);
+        emitter.scaleX.copyToMinMax(dataScaleX);
+        emitter.scaleY.copyToMinMax(dataScaleY);
+        emitter.particleAngle.copyToMinMax(dataAngle);
         emitter.alpha.copyToMinMax(dataAlpha);
 
         //  Random overrides
@@ -186,8 +190,10 @@ var Particle = new Class({
     },
 
     //  delta = ms, step = delta / 1000
-    update: function (emitter, delta, step)
+    update: function (delta, step)
     {
+        var emitter = this.emitter;
+
         //  How far along in life is this particle? (t = 0 to 1)
         var t = 1 - (this.lifeCurrent / this.life);