# Source: time/Time.js

    /**
    * @author       Richard Davey <rich@photonstorm.com>
    * @copyright    2014 Photon Storm Ltd.
    * @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
    */

    /**
    * Time constructor.
    *
    * @class Phaser.Time
    * @classdesc This is the core internal game clock. It manages the elapsed time and calculation of elapsed values, used for game object motion and tweens.
    * @constructor
    * @param {Phaser.Game} game A reference to the currently running game.
    */
    Phaser.Time = function (game) {

        /**
        * @property {Phaser.Game} game - Local reference to game.
        */
        this.game = game;

        /**
        * @property {number} time - Game time counter. If you need a value for in-game calculation please use Phaser.Time.now instead.
        * @protected
        */
        this.time = 0;

        /**
        * @property {number} now - The time right now.
        * @protected
        */
        this.now = 0;

        /**
        * @property {number} elapsed - Elapsed time since the last frame (in ms).
        * @protected
        */
        this.elapsed = 0;

        /**
        * @property {number} pausedTime - Records how long the game has been paused for. Is reset each time the game pauses.
        * @protected
        */
        this.pausedTime = 0;

        /**
        * @property {boolean} advancedTiming - If true Phaser.Time will perform advanced profiling including the fps rate, fps min/max and msMin and msMax.
        * @default
        */
        this.advancedTiming = false;

        /**
        * @property {number} fps - Frames per second. Only calculated if Time.advancedTiming is true.
        * @protected
        */
        this.fps = 0;

        /**
        * @property {number} fpsMin - The lowest rate the fps has dropped to. Only calculated if Time.advancedTiming is true.
        */
        this.fpsMin = 1000;

        /**
        * @property {number} fpsMax - The highest rate the fps has reached (usually no higher than 60fps). Only calculated if Time.advancedTiming is true.
        */
        this.fpsMax = 0;

        /**
        * @property {number} msMin - The minimum amount of time the game has taken between two frames. Only calculated if Time.advancedTiming is true.
        * @default
        */
        this.msMin = 1000;

        /**
        * @property {number} msMax - The maximum amount of time the game has taken between two frames. Only calculated if Time.advancedTiming is true.
        */
        this.msMax = 0;

        /**
        * @property {number} physicsElapsed - The elapsed time calculated for the physics motion updates. In a stable 60fps system this will be 0.016 every frame.
        */
        this.physicsElapsed = 0;

        /**
        * @property {number} deltaCap - If you need to cap the delta timer, set the value here. For 60fps the delta should be 0.016, so try variances just above this.
        */
        this.deltaCap = 0;

        /**
        * @property {number} timeCap - If the difference in time between two frame updates exceeds this value, the frame time is reset to avoid huge elapsed counts.
        */
        this.timeCap = 1000;

        /**
        * @property {number} frames - The number of frames record in the last second. Only calculated if Time.advancedTiming is true.
        */
        this.frames = 0;

        /**
        * @property {number} pauseDuration - Records how long the game was paused for in miliseconds.
        */
        this.pauseDuration = 0;

        /**
        * @property {number} timeToCall - The value that setTimeout needs to work out when to next update
        */
        this.timeToCall = 0;

        /**
        * @property {number} lastTime - Internal value used by timeToCall as part of the setTimeout loop
        */
        this.lastTime = 0;

        /**
        * @property {Phaser.Timer} events - This is a Phaser.Timer object bound to the master clock to which you can add timed events.
        */
        this.events = new Phaser.Timer(this.game, false);

        /**
        * @property {number} _started - The time at which the Game instance started.
        * @private
        */
        this._started = 0;

        /**
        * @property {number} _timeLastSecond - The time (in ms) that the last second counter ticked over.
        * @private
        */
        this._timeLastSecond = 0;

        /**
        * @property {number} _pauseStarted - The time the game started being paused.
        * @private
        */
        this._pauseStarted = 0;

        /**
        * @property {boolean} _justResumed - Internal value used to recover from the game pause state.
        * @private
        */
        this._justResumed = false;

        /**
        * @property {array} _timers - Internal store of Phaser.Timer objects.
        * @private
        */
        this._timers = [];

        /**
        * @property {number} _len - Temp. array length variable.
        * @private
        */
        this._len = 0;

        /**
        * @property {number} _i - Temp. array counter variable.
        * @private
        */
        this._i = 0;

    };

    Phaser.Time.prototype = {

        /**
        * Called automatically by Phaser.Game after boot. Should not be called directly.
        *
        * @method Phaser.Time#boot
        * @protected
        */
        boot: function () {

            this._started = Date.now();
            this.events.start();

        },

        /**
        * Creates a new stand-alone Phaser.Timer object.
        *
        * @method Phaser.Time#create
        * @param {boolean} [autoDestroy=true] - A Timer that is set to automatically destroy itself will do so after all of its events have been dispatched (assuming no looping events).
        * @return {Phaser.Timer} The Timer object that was created.
        */
        create: function (autoDestroy) {

            if (typeof autoDestroy === 'undefined') { autoDestroy = true; }

            var timer = new Phaser.Timer(this.game, autoDestroy);

            this._timers.push(timer);

            return timer;

        },

        /**
        * Remove all Timer objects, regardless of their state. Also clears all Timers from the Time.events timer.
        *
        * @method Phaser.Time#removeAll
        */
        removeAll: function () {

            for (var i = 0; i < this._timers.length; i++)
            {
                this._timers[i].destroy();
            }

            this._timers = [];

            this.events.removeAll();

        },

        /**
        * Updates the game clock and if enabled the advanced timing data. This is called automatically by Phaser.Game.
        *
        * @method Phaser.Time#update
        * @protected
        * @param {number} time - The current timestamp.
        */
        update: function (time) {

            this.now = time;

            this.timeToCall = this.game.math.max(0, 16 - (time - this.lastTime));

            this.elapsed = this.now - this.time;

            //  spike-dislike
            if (this.elapsed > this.timeCap)
            {
                //  For some reason the time between now and the last time the game was updated was larger than our timeCap
                //  This can happen if the Stage.disableVisibilityChange is true and you swap tabs, which makes the raf pause.
                //  In this case we'll drop to some default values to stop the game timers going nuts.
                this.elapsed = 1 / 60;
            }

            //  Calculate physics elapsed, ensure it's > 0, use 1/60 as a fallback
            this.physicsElapsed = this.elapsed / 1000 || 1 / 60;

            if (this.deltaCap > 0 && this.physicsElapsed > this.deltaCap)
            {
                this.physicsElapsed = this.deltaCap;
            }

            if (this.advancedTiming)
            {
                this.msMin = this.game.math.min(this.msMin, this.elapsed);
                this.msMax = this.game.math.max(this.msMax, this.elapsed);

                this.frames++;

                if (this.now > this._timeLastSecond + 1000)
                {
                    this.fps = Math.round((this.frames * 1000) / (this.now - this._timeLastSecond));
                    this.fpsMin = this.game.math.min(this.fpsMin, this.fps);
                    this.fpsMax = this.game.math.max(this.fpsMax, this.fps);
                    this._timeLastSecond = this.now;
                    this.frames = 0;
                }
            }

            this.time = this.now;
            this.lastTime = time + this.timeToCall;

            //  Paused but still running?
            if (!this.game.paused)
            {
                //  Our internal Phaser.Timer
                this.events.update(this.now);

                //  Any game level timers
                this._i = 0;
                this._len = this._timers.length;

                while (this._i < this._len)
                {
                    if (this._timers[this._i].update(this.now))
                    {
                        this._i++;
                    }
                    else
                    {
                        this._timers.splice(this._i, 1);

                        this._len--;
                    }
                }
            }

        },

        /**
        * Called when the game enters a paused state.
        *
        * @method Phaser.Time#gamePaused
        * @private
        */
        gamePaused: function () {

            this._pauseStarted = this.now;

            this.events.pause();

            var i = this._timers.length;

            while (i--)
            {
                this._timers[i]._pause();
            }

        },

        /**
        * Called when the game resumes from a paused state.
        *
        * @method Phaser.Time#gameResumed
        * @private
        */
        gameResumed: function () {

            //  Level out the elapsed timer to avoid spikes
            this.time = this.now = Date.now();

            this.pauseDuration = this.time - this._pauseStarted;

            this.events.resume();

            var i = this._timers.length;

            while (i--)
            {
                this._timers[i]._resume();
            }

        },

        /**
        * The number of seconds that have elapsed since the game was started.
        *
        * @method Phaser.Time#totalElapsedSeconds
        * @return {number} The number of seconds that have elapsed since the game was started.
        */
        totalElapsedSeconds: function() {
            return (this.now - this._started) * 0.001;
        },

        /**
        * How long has passed since the given time.
        *
        * @method Phaser.Time#elapsedSince
        * @param {number} since - The time you want to measure against.
        * @return {number} The difference between the given time and now.
        */
        elapsedSince: function (since) {
            return this.now - since;
        },

        /**
        * How long has passed since the given time (in seconds).
        *
        * @method Phaser.Time#elapsedSecondsSince
        * @param {number} since - The time you want to measure (in seconds).
        * @return {number} Duration between given time and now (in seconds).
        */
        elapsedSecondsSince: function (since) {
            return (this.now - since) * 0.001;
        },

        /**
        * Resets the private _started value to now and removes all currently running Timers.
        *
        * @method Phaser.Time#reset
        */
        reset: function () {

            this._started = this.now;
            this.removeAll();

        }

    };

    Phaser.Time.prototype.constructor = Phaser.Time;