The Indie Stone Community
http://theindiestone.com/community/

Game Flow and State Machines in C# / XNA
http://theindiestone.com/community/tutorials-f12/game-flow-and-state-machines-xna-t33.html		 Page 1 of 1
Author:  lemmy101 [ Thu Apr 02, 2009 4:57 am ]
Post subject:  Game Flow and State Machines in C# / XNA
A State Machine is a system for allowing a game to pass through a list of states which define different sections of the game. These are insanely useful for defining your gameflow.

Basically they are comprised of two base classes: StateMachine and State.

The StateMachine contains a list of States, which it will move through sequentially. Each State has four main methods:

Enter
During
Exit
Draw

A StateMachine has multiple States, each which have three Stages: 'Enter', 'During', 'Exit'.

Each of the three stage methods; 'Enter', 'During' and 'Exit', can return whether the state machine should 'Remain' in that stage, or 'Continue' onto the next.

When the StateMachine first moves onto a state, it will run the Enter method. This is where the state is set up and everything is initialised. The Enter method then returns Continue and the StateMachine ends its update.

Next frame, when the StateMachine is updated, it will call the state's 'During' method, which will process the state and will return Remain for as long as the State is active and thus the StateMachine will remain in that state. As soon as, for whatever reason, you're done with it, return Continue and next frame the StateMachine will run the Exit method, and assuming that method returns Continue, the frame after the StateMachine will move to the next state, calling the Enter method, and so on...

So where can this be used? The answer is in LOTS of places... In PAWS main game class, for example, we have:

  1.  
  2. GameGlobals.MainStateMachine.AddState(new States.TitleScreen());
  3. GameGlobals.MainStateMachine.AddState(new States.MainMenuState());
  4. GameGlobals.MainStateMachine.AddState(new States.CharacterSelect());
  5. GameGlobals.MainStateMachine.AddState(new States.LevelSelect());
  6. GameGlobals.MainStateMachine.AddState(new States.InGameState());
  7. GameGlobals.MainStateMachine.SetLooped(true);
  8.  


Tada. By calling:

  1.  
  2. GameGlobals.MainStateMachine.Update(gameTime);
  3.  


and...

  1.  
  2. GameGlobals.MainStateMachine.Draw(spriteBatch);
  3.  


...in the Update / Draw methods of the Game class, I can now have all these different State derived classes take care of all the gameflow of the game, the Game class itself simply taking care of the lower level stuff like updating audio systems, control systems etc that I want to happen in all areas of the game.

As soon as the state machine reaches the end of the states, it will loop and I'll be back at the title screen! Providing each of the states takes care of reinitialising themselves in their Enter method, and cleaning up on their Exit method, this makes gameflow a cinch.

You can use as many state machines as you like, perhaps having one for handling mission flow, game mode logic... anything you like!

Here are the two classes. Beware that this is 'in progress code' so I make no promises about it being perfect and totally bug free, but it's working fine for me, so... ;)

StateMachine.cs

  1.  
  2.     public enum Stage
  3.     {
  4.         Enter,
  5.         During,
  6.         Exit,
  7.     }
  8.  
  9.     public enum StateAction
  10.     {
  11.         Remain,
  12.         Continue,
  13.     }
  14.  
  15.     public class StateMachine
  16.     {
  17.         protected List<State> StateList = new List<State>();
  18.         public bool bRan = false;
  19.         public bool bFinished = false;
  20.         bool bCycleStates = false;
  21.         bool bRunning = false;
  22.         int ActiveState = -1;
  23.         protected State CurrentState = null;
  24.         Stage CurrentStage = Stage.Enter;
  25.         bool AutoStart = true;
  26.         public StateMachine()
  27.         {
  28.            
  29.         }
  30.  
  31.         public StateMachine(bool AutoStart)
  32.         {
  33.             this.AutoStart = AutoStart;
  34.         }
  35.  
  36.         public void ClearStates()
  37.         {
  38.             StateList.Clear();
  39.         }
  40.  
  41.         public void Start()
  42.         {
  43.             if (StateList.Count > 0)
  44.             {
  45.                 ActiveState = 0;
  46.                 CurrentState = StateList[ActiveState];
  47.                 CurrentStage = Stage.Enter;
  48.                 bRunning = true;
  49.                 bFinished = false;
  50.             }
  51.  
  52.         }
  53.  
  54.         public bool Running()
  55.         {
  56.             if (!bRunning || CurrentState == null || bFinished)
  57.                 return false;
  58.  
  59.             return true;
  60.         }
  61.  
  62.         public void RemoveState(State state)
  63.         {
  64.             StateList.Remove(state);
  65.         }
  66.  
  67.         public void SetLooped(bool bLooped)
  68.         {
  69.             bCycleStates = bLooped;
  70.         }
  71.  
  72.         public void AddState(State state)
  73.         {
  74.             StateList.Add(state);
  75.  
  76.             if (StateList.Count == 1)
  77.             {
  78.                 ActiveState = 0;
  79.                 CurrentState = StateList[ActiveState];
  80.                 CurrentStage = Stage.Enter;
  81.                 bRunning = true;
  82.             }
  83.         }
  84.  
  85.         public void Draw(SpriteBatch batch)
  86.         {
  87.             if (StateList.Count == 0)
  88.                 return;
  89.  
  90.             if (CurrentState != null)
  91.                 CurrentState.Draw(batch, CurrentStage);
  92.         }
  93.  
  94.         public virtual void Update(GameTime gameTime)
  95.         {
  96.             if (StateList.Count == 0)
  97.                 return;
  98.  
  99.             // Loop?
  100.             if (ActiveState == -1 && CurrentState == null)
  101.             {
  102.                 bFinished = true;
  103.                 if (bCycleStates || (!bRunning && !bRan && AutoStart))
  104.                 {
  105.                     ActiveState = 0;
  106.                     CurrentState = StateList[ActiveState];
  107.                     CurrentStage = Stage.Enter;
  108.                     bRunning = true;
  109.                     bFinished = false;
  110.                     bRan = true;
  111.                 }
  112.             }
  113.  
  114.             if (bFinished == true || CurrentState == null)
  115.                 return;
  116.  
  117.             StateAction returnAction = CurrentState.Update(gameTime, CurrentStage);
  118.  
  119.             if (returnAction == StateAction.Continue)
  120.             {
  121.                 switch (CurrentStage)
  122.                 {
  123.                     case Stage.Enter:
  124.                         CurrentStage = Stage.During;
  125.                         break;
  126.                     case Stage.During:
  127.                         CurrentStage = Stage.Exit;
  128.                         break;
  129.                     case Stage.Exit:
  130.                         {
  131.                             if (ActiveState != -1)
  132.                             {
  133.                                 if (CurrentState == StateList[ActiveState])
  134.                                 {
  135.                                     ActiveState++;
  136.                                     if (ActiveState >= StateList.Count)
  137.                                         ActiveState = -1;
  138.                                 }
  139.  
  140.                             }
  141.  
  142.                             CurrentStage = Stage.Enter;
  143.                             State Override = CurrentState.OverrideGetNext();
  144.  
  145.                             if (Override != null)
  146.                             {
  147.                                 CurrentState = Override;
  148.                             }
  149.                             else
  150.                             {
  151.                                 if (ActiveState == -1)
  152.                                     CurrentState = null;
  153.                                 else
  154.                                     CurrentState = StateList[ActiveState];
  155.                             }
  156.                         }
  157.                         break;
  158.  
  159.                 }
  160.             }
  161.         }
  162.     }
  163.  


State.cs

  1.  
  2.   public class State
  3.     {
  4.         virtual public StateAction Enter(GameTime gameTime)
  5.         {
  6.             return StateAction.Continue;
  7.         }
  8.         virtual public StateAction During(GameTime gameTime)
  9.         {
  10.             return StateAction.Continue;
  11.         }
  12.         virtual public StateAction Exit(GameTime gameTime)
  13.         {
  14.             return StateAction.Continue;
  15.         }
  16.  
  17.         virtual public void Draw(SpriteBatch batch, Stage stage)
  18.         {
  19.  
  20.         }
  21.  
  22.         virtual public State OverrideGetNext()
  23.         {
  24.             return null;
  25.         }
  26.  
  27.         virtual public State Reset()
  28.         {
  29.             return this;
  30.         }
  31.  
  32.         public StateAction Update(GameTime gameTime, Stage stage)
  33.         {
  34.             switch (stage)
  35.             {
  36.                 case Stage.Enter:
  37.                     return Enter(gameTime);
  38.                 case Stage.During:
  39.                     return During(gameTime);
  40.                 case Stage.Exit:
  41.                     return Exit(gameTime);
  42.                 default:
  43.                     return StateAction.Continue;
  44.             }
  45.         }
  46.  
  47.  
  48.     }
  49.  


Okay, so to use it, you just need to declare a StateMachine:

  1.  
  2. StateMachine MyStateMachine = new StateMachine();
  3.  


then derive your own State class:

  1.  
  2.    public class MyState : State
  3.     {
  4.         public override StateAction Enter(GameTime gameTime)
  5.         {
  6.             return StateAction.Continue;
  7.         }
  8.  
  9.         public override StateAction During(GameTime gameTime)
  10.         {
  11.             if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
  12.                 return StateAction.Continue;
  13.  
  14.             return StateAction.Remain;
  15.         }
  16.  
  17.         public override StateAction Exit(GameTime gameTime)
  18.         {
  19.             return StateAction.Continue;
  20.         }
  21.  
  22.         public override void Draw(SpriteBatch batch, Stage stage)
  23.         {
  24.      
  25.         }
  26.     }
  27.  


And finally add the class to the state machine, as explained above in my PAWS example, and call the Update / Draw of the state machine from wherever relevant...

In our MyState class, it will only process the Enter method on the first update, and then will go into the During and will remain there indefinitely until the Back button is pressed, at which point it will continue out and run the Exit method for one update, and then move onto the next state.

Note it may, depending on your update times, call the Draw method before it's called the Enter method. So it's important to make sure you don't try and draw something you've not yet loaded... so you might want to add a check in to the Draw method to only draw during the During or Exit stages...

  1.  
  2.         public override void Draw(SpriteBatch batch, Stage stage)
  3.         {
  4.             if(stage == Stage.During || stage == Stage.Exit)
  5.             {
  6.                   // Draw stuff...
  7.             }
  8.         }
  9.  


These are a great way to quickly get gameflow into your game. And they're quite easy to implement into an existing game in production too, if your game loads instantly in-game and all your main stuff is at the moment just plonked into your game class it's often quite easy just to lift all that out and put it into an InGameState class... move all the stuff in Init into the Enter, and all the stuff in Update into During, all the stuff in Draw into... well, Draw.... then you can start making menu states, credits states, or whatever, and Bob's your uncle!

Oh there is one other useful override for the State class:

  1.  
  2.         public override State OverrideGetNext()
  3.         {
  4.             return null;
  5.         }
  6.  


This method basically allows us to, on a whim, decide to divert the state machine to a different state after this one, based upon some kind of criteria...

For example, if the player collected all the magic baboon droppings on a level, you might award them with a bonus mini-game!

  1.  
  2.         public override State OverrideGetNext()
  3.         {
  4.              if(nBaboonPooCollected >= BaboonPooQuota)
  5.                return new MonkeyPooMinigameState();
  6.  
  7.              return null;
  8.         }
  9.  


Bingo! This will check if the baboon poo collection was prestigious enough, and return the minigame's state, otherwise returning null which will just progress the states as normal.

If it does divert to a new state, it will then run that state through completely before resuming its original place in the statemachine's state list.

What's useful with StateMachines (except the obvious, obviously) is that while coding a new state, you can just add it to your main StateMachine first before the titlescreen and there it will be as soon as you run the game. Once you've finished it you can put it where it's supposed to be. Likewise things like logos at the start of the game, or even the entire front end menu system, can be removed by simply commenting out the line adding the state to the state machine. Magic!

Hopefully this proves useful!

lemmy
Author:  bignobody [ Thu Apr 02, 2009 5:08 pm ]
Post subject:  Re: Game Flow and State Machines
Awesome tutorial! Having had to do these tasks before, I'm really impressed with how clean this is. Thanks for sharing!
Author:  seregrail7 [ Thu Apr 02, 2009 5:30 pm ]
Post subject:  Re: Game Flow and State Machines
What I like the most is how automated it is. I've been using enums all this time. They do the job but are a bit messy.
Author:  WorldMaker [ Sat May 09, 2009 8:34 am ]
Post subject:  Re: Game Flow and State Machines in C# / XNA
lemmy101 wrote:
Not to be confused with Finite State Machines a State Machine (in this context) is a system for allowing a game to pass through a list of states which define different sections of the game.


Um, actually, that also is a Finite State Machine. You have a set of states, that can transition between each other (given some input), and there is a finite (countable) number of possible states. There's no context difference here, you really are describing the exact same thing. Certainly the math of the above Wikipedia page may seem confusing, or the number of subtly different models that are sometimes used, but the basics are the same for just about every FSM. There are probably things on that very Wikipedia page that could apply directly to your sample, and I would suggest that its worth taking the time to learn at least some of the basic "maths" of Finite State Machines.
Author:  lemmy101 [ Sat May 09, 2009 12:37 pm ]
Post subject:  Re: Game Flow and State Machines in C# / XNA
Awesome thanks World Maker! :)
Page 1 of 1 All times are UTC [ DST ]
Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group
http://www.phpbb.com/