Lots of new State Manager features (sleep, wake, pause, resume, etc)

Author: photonstorm

v3/src/checksum.js

@@ -1,4 +1,4 @@
 var CHECKSUM = {
-build: '0d93fb90-5d23-11e7-a642-d974c901baec'
+build: 'f20e3110-5d2c-11e7-9a51-cfbdba7f8363'
 };
 module.exports = CHECKSUM;

v3/src/state/GlobalStateManager.js

@@ -347,6 +347,19 @@ GlobalStateManager.prototype = {
         return this.states.indexOf(state);
     },
 
+    getActiveState: function (key)
+    {
+        var state = this.getState(key);
+
+        for (var i = 0; i < this.active.length; i++)
+        {
+            if (this.active[i].state === state)
+            {
+                return this.active[i];
+            }
+        }
+    },
+
     getActiveStateIndex: function (state)
     {
         var index = -1;
@@ -373,7 +386,7 @@ GlobalStateManager.prototype = {
     {
         if (data === undefined) { data = {}; }
 
-        // console.log('start:', key);
+        console.log('start:', key);
         // console.dir(data);
 
         //  if not booted, then put state into a holding pattern
@@ -518,17 +531,67 @@ GlobalStateManager.prototype = {
 
     pause: function (key)
     {
-        var index = this.getActiveStateIndex(this.getState(key));
+        var entry = this.getActiveState(key);
+
+        if (entry)
+        {
+            entry.state.sys.pause();
+        }
+    },
+
+    resume: function (key)
+    {
+        var entry = this.getActiveState(key);
+
+        if (entry)
+        {
+            entry.state.sys.resume();
+        }
+    },
+
+    sleep: function (key)
+    {
+        var entry = this.getActiveState(key);
+
+        if (entry)
+        {
+            entry.state.sys.sleep();
+        }
+    },
+
+    wake: function (key)
+    {
+        var entry = this.getActiveState(key);
+
+        if (entry)
+        {
+            entry.state.sys.wake();
+        }
+    },
+
+    swap: function (from, to)
+    {
+        this.sleep(from);
+        this.start(to);
+    },
+
+    stop: function (key)
+    {
+        var entry = this.getActiveState(key);
 
-        if (index > -1)
+        if (entry)
         {
-            var state = this.getState(key);
+            entry.state.sys.shutdown();
 
-            state.sys.settings.active = false;
+            //  Remove from the active list
+            var index = this.active.indexOf(entry);
 
-            this.active.splice(index, 1);
+            if (index !== -1)
+            {
+                this.active.splice(index, 1);
 
-            this.active.sort(this.sortStates);
+                this.active.sort(this.sortStates);
+            }
         }
     },
 

v3/src/state/Systems.js

@@ -45,16 +45,14 @@ var Systems = function (state, config)
     this.stateManager;
     this.time;
     this.tweens;
-    this.updates;
+    // this.updates;
 
     //  State properties
     this.children;
     this.color;
     this.data;
 };
 
-Systems.prototype.constructor = Systems;
-
 Systems.prototype = {
 
     init: function (game)
@@ -85,7 +83,7 @@ Systems.prototype = {
         this.stateManager = new StateManager(this.state, game);
         this.time = new Clock(this.state);
         this.tweens = new TweenManager(this.state);
-        this.updates = new UpdateManager(this.state);
+        // this.updates = new UpdateManager(this.state);
 
         this.inject();
     },
@@ -107,6 +105,11 @@ Systems.prototype = {
 
     step: function (time, delta)
     {
+        if (!this.settings.active)
+        {
+            return;
+        }
+
         this.time.begin(time);
 
         this.tweens.begin(time);
@@ -143,12 +146,87 @@ Systems.prototype = {
         }
 
         this.cameras.render(renderer, this.children, interpolation);
+
+        //  After everything has rendered are there any pending StateManager actions?
+        this.stateManager.update();
     },
 
     sortZ: function (childA, childB)
     {
         return childA._z - childB._z;
+    },
+
+    //  A paused State still renders, it just doesn't run ANY of its update handlers or systems
+    pause: function ()
+    {
+        //  Was paused by the GlobalStateManager
+
+        this.settings.active = false;
+
+        //  Notify the State callback or dispatch an event
+    },
+
+    resume: function ()
+    {
+        //  Was resumed by the GlobalStateManager
+
+        this.settings.active = true;
+
+        //  Notify the State callback or dispatch an event
+    },
+
+    sleep: function ()
+    {
+        //  Was sent to sleep by the GlobalStateManager
+
+        this.settings.active = false;
+        this.settings.visible = false;
+
+        //  Notify the State callback or dispatch an event
+    },
+
+    wake: function ()
+    {
+        //  Was woken up by the GlobalStateManager
+
+        this.settings.active = true;
+        this.settings.visible = true;
+
+        //  Notify the State callback or dispatch an event
+    },
+
+    shutdown: function ()
+    {
+        //  Was stopped by the GlobalStateManager
+
+        this.settings.active = false;
+
+        //  If all State level managers followed the same pattern then we could just iterate
+        //  the map and call shutdown on all of them, same for destroy
+
+        //  Move to a Plugin based system? Then plugins can look-up other plugins via the State
+        //  and store their own references to them to avoid constant look-ups.
+
+        this.children.removeAll();
+
+        this.time.shutdown();
+        this.tweens.shutdown();
+
+        this.state.shutdown.call(this.state);
+    },
+
+    //  Game level nuke
+    destroy: function ()
+    {
+        //  TODO
+
+        this.time.destroy();
+        this.tweens.destroy();
+
+        //  etc
     }
 };
 
+Systems.prototype.constructor = Systems;
+
 module.exports = Systems;