melonjs 9.1.0 → 10.0.1

package/src/tweens/tween.js

@@ -1,6 +1,6 @@
 import timer from "./../system/timer.js";
-import event from "./../system/event.js";
-import game from "./../game.js";
+import * as event from "./../system/event.js";
+import { world, lastUpdate } from "./../game.js";
 import { Easing } from "./easing.js";
 import { Interpolation } from "./interpolation.js";
 
@@ -9,9 +9,8 @@ import { Interpolation } from "./interpolation.js";
 * https://github.com/tweenjs/tween.js
 */
 
-/* eslint-disable quotes, keyword-spacing, comma-spacing, no-return-assign */
-
 /**
+ * @classdesc
  * Javascript Tweening Engine<p>
  * Super simple, fast and easy to use tweening engine which incorporates optimised Robert Penner's equation<p>
  * <a href="https://github.com/sole/Tween.js">https://github.com/sole/Tween.js</a><p>
@@ -23,7 +22,7 @@ import { Interpolation } from "./interpolation.js";
  * author Paul Lewis / http://www.aerotwist.com/<br>
  * author lechecacharro<br>
  * author Josh Faul / http://jocafa.com/
- * @class
+ * @class Tween
  * @memberOf me
  * @constructor
  * @param {Object} object object on which to apply the tween
@@ -42,454 +41,436 @@ class Tween {
 
     // constructor
     constructor ( object ) {
+        this.setProperties(object);
+    }
 
-        var _object = null;
-        var _valuesStart = null;
-        var _valuesEnd = null;
-        var _valuesStartRepeat = null;
-        var _duration = null;
-        var _repeat = null;
-        var _yoyo = null;
-        var _reversed = null;
-        var _delayTime = null;
-        var _startTime = null;
-        var _easingFunction = null;
-        var _interpolationFunction = null;
-        var _chainedTweens = null;
-        var _onStartCallback = null;
-        var _onStartCallbackFired = null;
-        var _onUpdateCallback = null;
-        var _onCompleteCallback = null;
-        var _tweenTimeTracker = null;
+    /**
+     * reset the tween object to default value
+     * @ignore
+     */
+    onResetEvent( object ) {
+        this.setProperties(object);
+    }
 
+    /**
+     * @ignore
+     */
+    setProperties(object) {
+        this._object = object;
+        this._valuesStart = {};
+        this._valuesEnd = {};
+        this._valuesStartRepeat = {};
+        this._duration = 1000;
+        this._repeat = 0;
+        this._yoyo = false;
+        this._reversed = false;
+        this._delayTime = 0;
+        this._startTime = null;
+        this._easingFunction = Easing.Linear.None;
+        this._interpolationFunction = Interpolation.Linear;
+        this._chainedTweens = [];
+        this._onStartCallback = null;
+        this._onStartCallbackFired = false;
+        this._onUpdateCallback = null;
+        this._onCompleteCallback = null;
+        // tweens are synchronized with the game update loop
+        this._tweenTimeTracker = lastUpdate;
+
+        // reset flags to default value
+        this.isPersistent = false;
+        // this is not really supported
+        this.updateWhenPaused = false;
         // comply with the container contract
         this.isRenderable = false;
 
-        /**
-         * @ignore
-         */
-        this._resumeCallback = function (elapsed) {
-            if (_startTime) {
-                _startTime += elapsed;
-            }
-        };
-
-        /**
-         * @ignore
-         */
-        this.setProperties = function (object) {
-            _object = object;
-            _valuesStart = {};
-            _valuesEnd = {};
-            _valuesStartRepeat = {};
-            _duration = 1000;
-            _repeat = 0;
-            _yoyo = false;
-            _reversed = false;
-            _delayTime = 0;
-            _startTime = null;
-            _easingFunction = Easing.Linear.None;
-            _interpolationFunction = Interpolation.Linear;
-            _chainedTweens = [];
-            _onStartCallback = null;
-            _onStartCallbackFired = false;
-            _onUpdateCallback = null;
-            _onCompleteCallback = null;
-            _tweenTimeTracker = timer.lastUpdate;
-
-            // reset flags to default value
-            this.isPersistent = false;
-            // this is not really supported
-            this.updateWhenPaused = false;
-
-            // Set all starting values present on the target object
-            for ( var field in object ) {
-                if(typeof object !== 'object') {
-                    _valuesStart[ field ] = parseFloat(object[field]);
-                }
+        // Set all starting values present on the target object
+        for ( var field in object ) {
+            if (typeof object !== "object") {
+                this._valuesStart[ field ] = parseFloat(object[field]);
             }
-        };
+        }
+    }
 
-        this.setProperties(object);
+    /**
+     * @ignore
+     */
+    _resumeCallback(elapsed) {
+        if (this._startTime) {
+            this._startTime += elapsed;
+        }
+    }
 
-        /**
-         * reset the tween object to default value
-         * @ignore
-         */
-        this.onResetEvent = function ( object ) {
-            this.setProperties(object);
-        };
-
-        /**
-         * subscribe to the resume event when added
-         * @ignore
-         */
-        this.onActivateEvent = function () {
-            event.subscribe(event.STATE_RESUME, this._resumeCallback);
-        };
-
-        /**
-         * Unsubscribe when tween is removed
-         * @ignore
-         */
-        this.onDeactivateEvent = function () {
-            event.unsubscribe(event.STATE_RESUME, this._resumeCallback);
-        };
-
-        /**
-         * object properties to be updated and duration
-         * @name me.Tween#to
-         * @public
-         * @function
-         * @param {Object} properties hash of properties
-         * @param {Object|Number} [options] object of tween properties, or a duration if a numeric value is passed
-         * @param {Number} [options.duration] tween duration
-         * @param {me.Tween.Easing} [options.easing] easing function
-         * @param {Number} [options.delay] delay amount expressed in milliseconds
-         * @param {Boolean} [options.yoyo] allows the tween to bounce back to their original value when finished. To be used together with repeat to create endless loops.
-         * @param {Number} [options.repeat] amount of times the tween should be repeated
-         * @param {me.Tween.Interpolation} [options.interpolation] interpolation function
-         * @param {Boolean} [options.autoStart] allow this tween to start automatically. Otherwise call me.Tween.start().
-         */
-        this.to = function ( properties, options ) {
-
-            _valuesEnd = properties;
-
-            if (typeof options !== "undefined") {
-                if (typeof options === 'number') {
-                    // for backward compatiblity
-                    _duration = options;
-                } else if (typeof options === 'object') {
-                    if (options.duration) { _duration = options.duration; }
-                    if (options.yoyo) { this.yoyo(options.yoyo); }
-                    if (options.easing) { this.easing(options.easing); }
-                    if (options.repeat) { this.repeat(options.repeat); }
-                    if (options.delay) { this.delay(options.delay); }
-                    if (options.interpolation) { this.interpolation(options.interpolation); }
-
-                    if (options.autoStart) {
-                        this.start();
-                    }
-                }
-            }
 
-            return this;
 
-        };
+    /**
+     * subscribe to the resume event when added
+     * @ignore
+     */
+    onActivateEvent() {
+        event.on(event.STATE_RESUME, this._resumeCallback, this);
+    }
 
-        /**
-         * start the tween
-         * @name me.Tween#start
-         * @public
-         * @function
-         */
-        this.start = function ( _time ) {
+    /**
+     * Unsubscribe when tween is removed
+     * @ignore
+     */
+    onDeactivateEvent() {
+        event.off(event.STATE_RESUME, this._resumeCallback);
+    }
 
-            _onStartCallbackFired = false;
+    /**
+     * object properties to be updated and duration
+     * @name to
+     * @memberOf me.Tween
+     * @public
+     * @function
+     * @param {Object} properties hash of properties
+     * @param {Object|Number} [options] object of tween properties, or a duration if a numeric value is passed
+     * @param {Number} [options.duration] tween duration
+     * @param {me.Tween.Easing} [options.easing] easing function
+     * @param {Number} [options.delay] delay amount expressed in milliseconds
+     * @param {Boolean} [options.yoyo] allows the tween to bounce back to their original value when finished. To be used together with repeat to create endless loops.
+     * @param {Number} [options.repeat] amount of times the tween should be repeated
+     * @param {me.Tween.Interpolation} [options.interpolation] interpolation function
+     * @param {Boolean} [options.autoStart] allow this tween to start automatically. Otherwise call me.Tween.start().
+     */
+    to( properties, options ) {
+
+        this._valuesEnd = properties;
+
+        if (typeof options !== "undefined") {
+            if (typeof options === "number") {
+                // for backward compatiblity
+                this._duration = options;
+            } else if (typeof options === "object") {
+                if (options.duration) { this._duration = options.duration; }
+                if (options.yoyo) { this.yoyo(options.yoyo); }
+                if (options.easing) { this.easing(options.easing); }
+                if (options.repeat) { this.repeat(options.repeat); }
+                if (options.delay) { this.delay(options.delay); }
+                if (options.interpolation) { this.interpolation(options.interpolation); }
+
+                if (options.autoStart) {
+                    this.start();
+                }
+            }
+        }
 
-            // add the tween to the object pool on start
-            game.world.addChild(this);
+        return this;
 
-            _startTime = (typeof(_time) === 'undefined' ? timer.getTime() : _time) + _delayTime;
+    }
 
-            for ( var property in _valuesEnd ) {
+    /**
+     * start the tween
+     * @name start
+     * @memberOf me.Tween
+     * @public
+     * @function
+     */
+    start( time = timer.getTime() ) {
 
-                // check if an Array was provided as property value
-                if ( _valuesEnd[ property ] instanceof Array ) {
+        this._onStartCallbackFired = false;
 
-                    if ( _valuesEnd[ property ].length === 0 ) {
+        // add the tween to the object pool on start
+        world.addChild(this);
 
-                        continue;
+        this._startTime =  time + this._delayTime;
 
-                    }
+        for ( var property in this._valuesEnd ) {
 
-                    // create a local copy of the Array with the start value at the front
-                    _valuesEnd[ property ] = [ _object[ property ] ].concat( _valuesEnd[ property ] );
+            // check if an Array was provided as property value
+            if ( this._valuesEnd[ property ] instanceof Array ) {
 
-                }
+                if ( this._valuesEnd[ property ].length === 0 ) {
 
-                _valuesStart[ property ] = _object[ property ];
+                    continue;
 
-                if( ( _valuesStart[ property ] instanceof Array ) === false ) {
-                    _valuesStart[ property ] *= 1.0; // Ensures we're using numbers, not strings
                 }
 
-                _valuesStartRepeat[ property ] = _valuesStart[ property ] || 0;
+                // create a local copy of the Array with the start value at the front
+                this._valuesEnd[ property ] = [ this._object[ property ] ].concat( this._valuesEnd[ property ] );
 
             }
 
-            return this;
-
-        };
-
-        /**
-         * stop the tween
-         * @name me.Tween#stop
-         * @public
-         * @function
-         */
-        this.stop = function () {
-            // remove the tween from the world container
-            game.world.removeChildNow(this);
-            return this;
-        };
-
-        /**
-         * delay the tween
-         * @name me.Tween#delay
-         * @public
-         * @function
-         * @param {Number} amount delay amount expressed in milliseconds
-         */
-        this.delay = function ( amount ) {
-
-            _delayTime = amount;
-            return this;
-
-        };
-
-        /**
-         * Repeat the tween
-         * @name me.Tween#repeat
-         * @public
-         * @function
-         * @param {Number} times amount of times the tween should be repeated
-         */
-        this.repeat = function ( times ) {
-
-            _repeat = times;
-            return this;
-
-        };
-
-        /**
-         * Allows the tween to bounce back to their original value when finished.
-         * To be used together with repeat to create endless loops.
-         * @name me.Tween#yoyo
-         * @public
-         * @function
-         * @see me.Tween#repeat
-         * @param {Boolean} yoyo
-         */
-        this.yoyo = function( yoyo ) {
-
-            _yoyo = yoyo;
-            return this;
-
-        };
-
-        /**
-         * set the easing function
-         * @name me.Tween#easing
-         * @public
-         * @function
-         * @param {me.Tween.Easing} fn easing function
-         */
-        this.easing = function ( easing ) {
-            if (typeof easing !== 'function') {
-                throw new Error("invalid easing function for me.Tween.easing()");
+            this._valuesStart[ property ] = this._object[ property ];
+
+            if ( ( this._valuesStart[ property ] instanceof Array ) === false ) {
+                this._valuesStart[ property ] *= 1.0; // Ensures we're using numbers, not strings
             }
-            _easingFunction = easing;
-            return this;
 
-        };
+            this._valuesStartRepeat[ property ] = this._valuesStart[ property ] || 0;
 
-        /**
-         * set the interpolation function
-         * @name me.Tween#interpolation
-         * @public
-         * @function
-         * @param {me.Tween.Interpolation} fn interpolation function
-         */
-        this.interpolation = function ( interpolation ) {
+        }
 
-            _interpolationFunction = interpolation;
-            return this;
+        return this;
 
-        };
+    }
 
-        /**
-         * chain the tween
-         * @name me.Tween#chain
-         * @public
-         * @function
-         * @param {me.Tween} chainedTween Tween to be chained
-         */
-        this.chain = function () {
+    /**
+     * stop the tween
+     * @name stop
+     * @memberOf me.Tween
+     * @public
+     * @function
+     */
+    stop() {
+        // remove the tween from the world container
+        world.removeChildNow(this);
+        return this;
+    }
 
-            _chainedTweens = arguments;
-            return this;
+    /**
+     * delay the tween
+     * @name delay
+     * @memberOf me.Tween
+     * @public
+     * @function
+     * @param {Number} amount delay amount expressed in milliseconds
+     */
+    delay( amount ) {
 
-        };
+        this._delayTime = amount;
+        return this;
 
-        /**
-         * onStart callback
-         * @name me.Tween#onStart
-         * @public
-         * @function
-         * @param {Function} onStartCallback callback
-         */
-        this.onStart = function ( callback ) {
+    }
 
-            _onStartCallback = callback;
-            return this;
+    /**
+     * Repeat the tween
+     * @name repeat
+     * @memberOf me.Tween
+     * @public
+     * @function
+     * @param {Number} times amount of times the tween should be repeated
+     */
+    repeat( times ) {
 
-        };
+        this._repeat = times;
+        return this;
 
-        /**
-         * onUpdate callback
-         * @name me.Tween#onUpdate
-         * @public
-         * @function
-         * @param {Function} onUpdateCallback callback
-         */
-        this.onUpdate = function ( callback ) {
+    }
 
-            _onUpdateCallback = callback;
-            return this;
+    /**
+     * Allows the tween to bounce back to their original value when finished.
+     * To be used together with repeat to create endless loops.
+     * @name yoyo
+     * @memberOf me.Tween
+     * @public
+     * @function
+     * @see me.Tween#repeat
+     * @param {Boolean} yoyo
+     */
+    yoyo( yoyo ) {
+
+        this._yoyo = yoyo;
+        return this;
 
-        };
+    }
 
-        /**
-         * onComplete callback
-         * @name me.Tween#onComplete
-         * @public
-         * @function
-         * @param {Function} onCompleteCallback callback
-         */
-        this.onComplete = function ( callback ) {
+    /**
+     * set the easing function
+     * @name easing
+     * @memberOf me.Tween
+     * @public
+     * @function
+     * @param {me.Tween.Easing} fn easing function
+     */
+    easing( easing ) {
+        if (typeof easing !== "function") {
+            throw new Error("invalid easing function for me.Tween.easing()");
+        }
+        this._easingFunction = easing;
+        return this;
 
-            _onCompleteCallback = callback;
-            return this;
+    }
 
-        };
+    /**
+     * set the interpolation function
+     * @name interpolation
+     * @memberOf me.Tween
+     * @public
+     * @function
+     * @param {me.Tween.Interpolation} fn interpolation function
+     */
+    interpolation( interpolation ) {
+        this._interpolationFunction = interpolation;
+        return this;
+    }
 
-        /** @ignore */
-        this.update = function ( dt ) {
+    /**
+     * chain the tween
+     * @name chain
+     * @memberOf me.Tween
+     * @public
+     * @function
+     * @param {me.Tween} chainedTween Tween to be chained
+     */
+    chain() {
+        this._chainedTweens = arguments;
+        return this;
+    }
 
-            // the original Tween implementation expect
-            // a timestamp and not a time delta
-            _tweenTimeTracker = (timer.lastUpdate > _tweenTimeTracker) ? timer.lastUpdate : _tweenTimeTracker + dt;
-            var time = _tweenTimeTracker;
+    /**
+     * onStart callback
+     * @name onStart
+     * @memberOf me.Tween
+     * @public
+     * @function
+     * @param {Function} onStartCallback callback
+     */
+    onStart( callback ) {
+        this._onStartCallback = callback;
+        return this;
+    }
 
-            var property;
+    /**
+     * onUpdate callback
+     * @name onUpdate
+     * @memberOf me.Tween
+     * @public
+     * @function
+     * @param {Function} onUpdateCallback callback
+     */
+    onUpdate( callback ) {
+        this._onUpdateCallback = callback;
+        return this;
+    }
 
-            if ( time < _startTime ) {
+    /**
+     * onComplete callback
+     * @name onComplete
+     * @memberOf me.Tween
+     * @public
+     * @function
+     * @param {Function} onCompleteCallback callback
+     */
+    onComplete( callback ) {
+        this._onCompleteCallback = callback;
+        return this;
+    };
 
-                return true;
+    /** @ignore */
+    update( dt ) {
 
-            }
+        // the original Tween implementation expect
+        // a timestamp and not a time delta
+        this._tweenTimeTracker = (lastUpdate > this._tweenTimeTracker) ? lastUpdate : this._tweenTimeTracker + dt;
+        var time = this._tweenTimeTracker;
 
-            if ( _onStartCallbackFired === false ) {
+        var property;
 
-                if ( _onStartCallback !== null ) {
+        if ( time < this._startTime ) {
 
-                    _onStartCallback.call( _object );
+            return true;
 
-                }
+        }
 
-                _onStartCallbackFired = true;
+        if ( this._onStartCallbackFired === false ) {
+
+            if ( this._onStartCallback !== null ) {
+
+                this._onStartCallback.call( this._object );
 
             }
 
-            var elapsed = ( time - _startTime ) / _duration;
-            elapsed = elapsed > 1 ? 1 : elapsed;
+            this._onStartCallbackFired = true;
 
-            var value = _easingFunction( elapsed );
+        }
 
-            for ( property in _valuesEnd ) {
+        var elapsed = ( time - this._startTime ) / this._duration;
+        elapsed = elapsed > 1 ? 1 : elapsed;
 
-                var start = _valuesStart[ property ] || 0;
-                var end = _valuesEnd[ property ];
+        var value = this._easingFunction( elapsed );
 
-                if ( end instanceof Array ) {
+        for ( property in this._valuesEnd ) {
 
-                    _object[ property ] = _interpolationFunction( end, value );
+            var start = this._valuesStart[ property ] || 0;
+            var end = this._valuesEnd[ property ];
 
-                } else {
+            if ( end instanceof Array ) {
 
-                    // Parses relative end values with start as base (e.g.: +10, -3)
-                    if ( typeof(end) === "string" ) {
-                        end = start + parseFloat(end);
-                    }
+                this._object[ property ] = this._interpolationFunction( end, value );
 
-                    // protect against non numeric properties.
-                    if ( typeof(end) === "number" ) {
-                        _object[ property ] = start + ( end - start ) * value;
-                    }
+            } else {
 
+                // Parses relative end values with start as base (e.g.: +10, -3)
+                if ( typeof(end) === "string" ) {
+                    end = start + parseFloat(end);
+                }
+
+                // protect against non numeric properties.
+                if ( typeof(end) === "number" ) {
+                    this._object[ property ] = start + ( end - start ) * value;
                 }
 
             }
 
-            if ( _onUpdateCallback !== null ) {
+        }
 
-                _onUpdateCallback.call( _object, value );
+        if ( this._onUpdateCallback !== null ) {
 
-            }
+            this._onUpdateCallback.call( this._object, value );
 
-            if ( elapsed === 1 ) {
+        }
 
-                if ( _repeat > 0 ) {
+        if ( elapsed === 1 ) {
 
-                    if( isFinite( _repeat ) ) {
-                        _repeat--;
-                    }
-
-                    // reassign starting values, restart by making startTime = now
-                    for( property in _valuesStartRepeat ) {
+            if ( this._repeat > 0 ) {
 
-                        if ( typeof( _valuesEnd[ property ] ) === "string" ) {
-                            _valuesStartRepeat[ property ] = _valuesStartRepeat[ property ] + parseFloat(_valuesEnd[ property ]);
-                        }
+                if ( isFinite( this._repeat ) ) {
+                    this._repeat--;
+                }
 
-                        if (_yoyo) {
-                            var tmp = _valuesStartRepeat[ property ];
-                            _valuesStartRepeat[ property ] = _valuesEnd[ property ];
-                            _valuesEnd[ property ] = tmp;
-                        }
-                        _valuesStart[ property ] = _valuesStartRepeat[ property ];
+                // reassign starting values, restart by making startTime = now
+                for ( property in this._valuesStartRepeat ) {
 
+                    if ( typeof( this._valuesEnd[ property ] ) === "string" ) {
+                        this._valuesStartRepeat[ property ] = this._valuesStartRepeat[ property ] + parseFloat(this._valuesEnd[ property ]);
                     }
 
-                    if (_yoyo) {
-                        _reversed = !_reversed;
+                    if (this._yoyo) {
+                        var tmp = this._valuesStartRepeat[ property ];
+                        this._valuesStartRepeat[ property ] = this._valuesEnd[ property ];
+                        this._valuesEnd[ property ] = tmp;
                     }
+                    this._valuesStart[ property ] = this._valuesStartRepeat[ property ];
 
-                    _startTime = time + _delayTime;
+                }
 
-                    return true;
+                if (this._yoyo) {
+                    this._reversed = !this._reversed;
+                }
 
-                } else {
-                    // remove the tween from the world container
-                    game.world.removeChildNow(this);
+                this._startTime = time + this._delayTime;
 
-                    if ( _onCompleteCallback !== null ) {
+                return true;
 
-                        _onCompleteCallback.call( _object );
+            } else {
+                // remove the tween from the world container
+                world.removeChildNow(this);
 
-                    }
+                if ( this._onCompleteCallback !== null ) {
 
-                    for ( var i = 0, numChainedTweens = _chainedTweens.length; i < numChainedTweens; i ++ ) {
+                    this._onCompleteCallback.call( this._object );
 
-                        _chainedTweens[ i ].start( time );
+                }
 
-                    }
+                for ( var i = 0, numChainedTweens = this._chainedTweens.length; i < numChainedTweens; i ++ ) {
 
-                    return false;
+                    this._chainedTweens[ i ].start( time );
 
                 }
 
-            }
+                return false;
 
-            return true;
+            }
 
-        };
+        }
+        return true;
     }
 
     // export easing function as static class property
     static get Easing() { return Easing; }
     static get Interpolation() { return Interpolation; }
 };
-/* eslint-enable quotes, keyword-spacing, comma-spacing, no-return-assign */
+
 export default Tween;