State Manager holds all given states until booted before creating them.

Author: photonstorm

src/components/Transform.js

@@ -55,7 +55,7 @@ Phaser.Component.Transform = function (gameObject, x, y, scaleX, scaleY)
     this._worldScaleY = scaleY;
 
     this._dirty = true;
-   
+
     this.game.updates.add(this);
 
     //  The parent Transform (NOT the parent GameObject, although very often they are related)

src/core/Game.js

@@ -184,7 +184,7 @@ Phaser.Game = function (width, height, renderer, parent, state, pixelArt)
     /**
     * @property {Phaser.StateManager} state - The StateManager.
     */
-    this.state = null;
+    this.state = new Phaser.StateManager(this, state);
 
     /**
     * @property {boolean} isBooted - Whether the game engine is booted, aka available.
@@ -484,8 +484,6 @@ Phaser.Game = function (width, height, renderer, parent, state, pixelArt)
         }
 
         this.rnd = new Phaser.RandomDataGenerator([(Date.now() * Math.random()).toString()]);
-
-        this.state = new Phaser.StateManager(this, state);
     }
 
     this.device.whenReady(this.boot, this);
@@ -565,15 +563,10 @@ Phaser.Game.prototype = {
 
         this.rnd = new Phaser.RandomDataGenerator(seed);
 
-        var state = null;
-
         if (config['state'])
         {
-            state = config['state'];
+            this.state.add(null, config['state'], true);
         }
-
-        this.state = new Phaser.StateManager(this, state);
-
     },
 
     /**
@@ -589,6 +582,19 @@ Phaser.Game.prototype = {
             return;
         }
 
+        //  Inject any new Factory helpers that exist in the build
+        for (var gameobject in Phaser.GameObject)
+        {
+            if (Phaser.GameObject[gameobject].hasOwnProperty('FACTORY_KEY'))
+            {
+                var key = Phaser.GameObject[gameobject]['FACTORY_KEY'];
+
+                // console.log('found', key);
+
+                Phaser.GameObject.Factory.prototype[key] = Phaser.GameObject[gameobject]['FACTORY_ADD'];
+            }
+        }
+
         this.onPause = new Phaser.Signal();
         this.onResume = new Phaser.Signal();
         this.onBlur = new Phaser.Signal();
@@ -605,9 +611,8 @@ Phaser.Game.prototype = {
             }
         };
 
-        this.updates = new Phaser.UpdateManager(this);
-
         this.scale = new Phaser.ScaleManager(this, this._width, this._height);
+
         // this.stage = new Phaser.Stage(this);
 
         this.setUpRenderer();
@@ -616,18 +621,9 @@ Phaser.Game.prototype = {
 
         // this.world = new Phaser.World(this);
 
-        //  Inject any new Factory helpers that exist in the build
-        for (var gameobject in Phaser.GameObject)
-        {
-            if (Phaser.GameObject[gameobject].hasOwnProperty('FACTORY_KEY'))
-            {
-                var key = Phaser.GameObject[gameobject]['FACTORY_KEY'];
-
-                // console.log('found', key);
+        this.updates = new Phaser.UpdateManager(this);
 
-                Phaser.GameObject.Factory.prototype[key] = Phaser.GameObject[gameobject]['FACTORY_ADD'];
-            }
-        }
+        // this.state = new Phaser.StateManager(this, this._pendingState);
 
         this.add = new Phaser.GameObject.Factory(this);
 
@@ -650,6 +646,7 @@ Phaser.Game.prototype = {
         this.scale.boot();
         this.input.boot();
         this.sound.boot();
+
         this.state.boot();
 
         // if (this.config['enableDebug'])

src/states/State.js

@@ -40,18 +40,22 @@ Phaser.State.prototype.constructor = Phaser.State;
 
 Phaser.State.prototype = {
 
+    //  Can be overridden by your own States
     preUpdate: function ()
     {
     },
 
+    //  Can be overridden by your own States
     update: function ()
     {
     },
 
+    //  Can be overridden by your own States
     postUpdate: function ()
     {
     },
 
+    //  Can be overridden by your own States
     render: function ()
     {
     }
@@ -155,6 +159,41 @@ Object.defineProperties(Phaser.State.prototype, {
             throw Error('Cannot re-assign protected property: transform');
         }
 
+    },
+
+    //  Just a test
+    rotation: {
+
+        enumerable: true,
+
+        get: function ()
+        {
+            return this.transform._rotation;
+        },
+
+        set: function (value)
+        {
+            if (this.transform._rotation === value)
+            {
+                return;
+            }
+
+            this.transform._rotation = value;
+            this.transform.dirty = true;
+
+            if (this.transform._rotation % Phaser.Math.PI2)
+            {
+                this.transform.cache.sr = Math.sin(this.transform._rotation);
+                this.transform.cache.cr = Math.cos(this.transform._rotation);
+                this.transform.updateCache();
+                this.transform.hasLocalRotation = true;
+            }
+            else
+            {
+                this.transform.hasLocalRotation = false;
+            }
+        }
+
     }
 
 });

src/states/StateManager.js

@@ -22,9 +22,23 @@ Phaser.StateManager = function (game, pending)
     //  Only active states are kept in here
     this.active = [];
 
-    this._pending = pending;
+    this._pending = [];
 
-    this._start = [];
+    if (pending)
+    {
+        if (Array.isArray(pending))
+        {
+            for (var i = 0; i < pending.length; i++)
+            {
+                //  The i === 0 part just starts the first State given
+                this._pending.push({ key: 'default', state: pending[i], autoStart: (i === 0) });
+            }
+        }
+        else
+        {
+            this._pending.push({ key: 'default', state: pending, autoStart: true });
+        }
+    }
 };
 
 Phaser.StateManager.prototype = {
@@ -41,28 +55,21 @@ Phaser.StateManager.prototype = {
         // this.game.onPause.add(this.pause, this);
         // this.game.onResume.add(this.resume, this);
 
-        if (this._pending)
+        console.log('StateManager.boot');
+
+        for (var i = 0; i < this._pending.length; i++)
         {
-            if (Array.isArray(this._pending))
-            {
-                for (var i = 0; i < this._pending.length; i++)
-                {
-                    //  The i === 0 part just starts the first State given
-                    this.add('default', this._pending[i], (i === 0));
-                }
-            }
-            else
-            {
-                this.add('default', this._pending, true);
-            }
+            var entry = this._pending[i];
 
-            this._pending = null;
+            this.add(entry.key, entry.state, entry.autoStart);
         }
+
+        this._pending = [];
     },
 
     getKey: function (key, state)
     {
-        if (key === undefined) { key = 'default'; }
+        if (!key) { key = 'default'; }
 
         if (state instanceof Phaser.State)
         {
@@ -99,24 +106,34 @@ Phaser.StateManager.prototype = {
     {
         if (autoStart === undefined) { autoStart = false; }
 
-        //  if not booted, then do something else - put state into a holding pattern?
-        // if (this.game.isBooted)
+        //  if not booted, then put state into a holding pattern
+        if (!this.game.isBooted)
+        {
+            console.log('StateManager not yet booted, adding to list');
+
+            this._pending.push({ key: key, state: state, autoStart: autoStart });
+
+            return;
+        }
 
         key = this.getKey(key, state);
 
         var newState;
 
         if (state instanceof Phaser.State)
         {
+            console.log('StateManager.add from instance', key);
             newState = this.createStateFromInstance(key, state);
         }
         else if (typeof state === 'object')
         {
+            console.log('StateManager.add from object', key);
             newState = this.createStateFromObject(key, state);
         }
         else if (typeof state === 'function')
         {
-            newState = new state(this.game);
+            console.log('StateManager.add from function', key);
+            newState = this.createStateFromFunction(key, state);
         }
 
         this.keys[key] = newState;
@@ -140,12 +157,22 @@ Phaser.StateManager.prototype = {
         return newState;
     },
 
-    createStateFromInstance: function (key, newState)
+    createStateFromFunction: function (key, state)
     {
-        newState.game = this.game;
+        var newState = new state();
 
-        newState.settings.key = key;
+        if (newState instanceof Phaser.State)
+        {
+            return this.createStateFromInstance(key, newState);
+        }
+        else
+        {
+            throw new Error('Given State object must extend Phaser.State');
+        }
+    },
 
+    injectDefaultSystems: function (newState)
+    {
         //  Inject the default (non-optional) managers
 
         newState._sys.add = new Phaser.GameObject.Factory(this.game, newState);
@@ -161,6 +188,17 @@ Phaser.StateManager.prototype = {
 
         newState._sys.children = new Phaser.Component.Children(newState);
 
+        return newState;
+    },
+
+    createStateFromInstance: function (key, newState)
+    {
+        newState.game = this.game;
+
+        newState.settings.key = key;
+
+        this.injectDefaultSystems(newState);
+
         if (this.game.renderType === Phaser.WEBGL)
         {
             this.createStateFrameBuffer(newState);
@@ -192,22 +230,11 @@ Phaser.StateManager.prototype = {
 
     createStateFromObject: function (key, state)
     {
-        var newState = new Phaser.State(key, this.game);
-
-        //  Inject the default (non-optional) managers
-
-        newState._sys.add = new Phaser.GameObject.Factory(this.game, newState);
-
-        //  States have their own Loaders? Would make a lot of sense actually
-        // newState._sys.load = this.game.load;
-
-        newState._sys.transform = new Phaser.Component.Transform(newState);
-
-        newState._sys.data = new Phaser.Component.Data(newState);
+        var newState = new Phaser.State(key);
 
-        newState._sys.color = new Phaser.Component.Color(newState);
+        newState.game = this.game;
 
-        newState._sys.children = new Phaser.Component.Children(newState);
+        this.injectDefaultSystems(newState);
 
         //  Inject custom managers
 
@@ -282,6 +309,24 @@ Phaser.StateManager.prototype = {
 
     start: function (key)
     {
+        //  if not booted, then put state into a holding pattern
+        if (!this.game.isBooted)
+        {
+            console.log('StateManager not yet booted, setting autoStart on pending list');
+
+            for (var i = 0; i < this._pending.length; i++)
+            {
+                var entry = this._pending[i];
+
+                if (entry.key === key)
+                {
+                    entry.autoStart = true;
+                }
+            }
+
+            return;
+        }
+
         var state = this.getState(key);
 
         if (state)