Jump to content

  • Log In with Google      Sign In   
  • Create Account

We're offering banner ads on our site from just $5!

1. Details HERE. 2. GDNet+ Subscriptions HERE. 3. Ad upload HERE.






State Machines in Games – Part 2

Posted by frob, in Programming 10 March 2013 · 989 views

We completed Part 1 with a simple boring hard-coded state machine, implemented by a switch statement.

It didn’t do much. In textbooks that would be called “an exercise for the reader.”

In this entry (Part 2) we're going to prepare the rest of the way for our game. Since I know in advance where I am leading you, I'll tell you that we need a bunch of state machines.

As this is going to become a collection of state machines, we’ll extend it out into a common interface.

Programming to an interface, also called the Dependency Inversion Principle, allows us to extend a simple state machine into many different types of machines.

The Interface

Here are the two interface classes used in all the examples.
public abstract class IStateMachine
{
    // Accessor to look at the current state.
    public abstract IState CurrentState { get; }

    // List of all possible transitions we can make from this current state.
    public abstract string[] PossibleTransitions();

    // Advance to a named state, returning true on success.
    public abstract bool Advance(string nextState);

    // Is this state a "completion" state. Are we there yet?
    public abstract bool IsComplete();
}
public abstract class IState
{
    // Utility function to help us display useful things
    public abstract string GetName();
    // Do something
    public abstract void Run();

    // This isn't really needed, but it helps in debugging and other tasks.
    // It allows hover-tips and debug info to show me the name of the state
    // rather than the default of the type of the object
    public override string ToString()
    {
        return GetName();
    }
}


That’s it for our interface.

The State Machine Runner

Now that we have the interface we can start using it.

One of the beauties of using interfaces ("Dependency Inversion Pattern") is that we can start writing our state machine without any other details.

So here is the app I wrote. Again I didn’t actually implement any of the state machines for this state machine runner. I just used the interfaces:
static void Main(string[] args)
{
    // First we need to create the state machine.
    // Note that I'm using the abstract IStateMachine instead of a concrete class.
    IStateMachine machine = GetMachine();

    // We have a machine, now run it.
    while(!machine.IsComplete())
    {
        // Print out our current state
        Console.WriteLine("Currently in " + machine.CurrentState);
        machine.CurrentState.Run();

        // Print out our possible transitions
        Console.WriteLine("\nAvailable choices are:");
        string[] transitions = machine.PossibleTransitions();
        foreach (string item in transitions)
        {
            Console.WriteLine(" " + item);
        }

        // Request a transition from the user
        Console.WriteLine("\nWhat do you want to do?");
        string nextState = Console.ReadLine();
        machine.Advance(nextState);
    }

    // And we're done!
    // Run our final node as a special case since the above loop won't do it.
    Console.WriteLine("Currently in " + machine.CurrentState);
    machine.CurrentState.Run();

    // Finish off.
    Console.WriteLine("\n\nPress any key to continue.");
    Console.ReadKey(true);
}
That’s it! 36 lines of code and our game runner is finished.

What?! The game runner is finished?

That little beauty will run any state machine that implements the interface. And our little game can fit into that interface. So let’s get on to filling in those pesky details.

Let’s try it out with a traditional textbook state machine. I’m talking about how textbooks use labels like 0, 1, 2, and variables like x, y, and z, that carry no real useful information.

Boring State Machine Implementation

There are two major options when it comes to state machines. You can make the machine know about traversing the machine, or you can make the state know about it. It's just like in graphics how you can either have objects move around the world or you can have the world move around objects. Either way, the result is the same.

In this boring example I made a single state and made the state modify itself as the machine moved around it.

Boring Machine Source
class BoringMachine : IStateMachine
{
    BoringMachineState mState = new BoringMachineState();

    public override IState CurrentState
    {
        get { return mState; }
    }
    public override string[] PossibleTransitions()
    {
        // For this simple example, forward it on to the state
        return mState.ListTransitions();
    }
    public override bool Advance(string nextState)
    {
        Console.WriteLine("I'm a boring state machine. I don't care what you entered. Advancing state.");
        return mState.Advance();
    }
    public override bool IsComplete()
    {
        // For the simple example, forward it on to the state
        return mState.IsComplete();
    }
}
Because it is a boring example I’ve simply ignored the name of the state transition. We don’t need it, we simply tell the state that it is time to move on.

Boring Machine State code

Here it is, in all it’s boring detail:
class BoringMachineState : IState
{
    #region Members
    internal enum SameOldStates
    {
        Enter,
        DoStuff,
        Exiting,
        Done
    }
    SameOldStates mState = SameOldStates.Enter;
    #endregion
    #region IState overrides
    public override string GetName()
    {
        return mState.ToString();
    }
    public override void Run()
    {
         // Do nothing. This is the game logic.
    }
    #endregion
    #region Helper functions
    public bool IsComplete()
    {
        return mState == SameOldStates.Done;
    }
    public string[] ListTransitions()
    {
        List<string> result = new List<string>();
        switch (mState)
        {
        case SameOldStates.Enter:
            result.Add("DoStuff");
            break;
        case SameOldStates.DoStuff:
            result.Add("Exiting");
            break;
        case SameOldStates.Exiting:
            result.Add("Done");
            break;
        case SameOldStates.Done:
            result.Add("Done");
            break;
        }
        return result.ToArray();
    }
    public bool Advance()
    {
        switch (mState)
        {
        case SameOldStates.Enter:
            mState = SameOldStates.DoStuff;
            break;
        case SameOldStates.DoStuff:
            mState = SameOldStates.Exiting;
            break;
        case SameOldStates.Exiting:
            mState = SameOldStates.Done;
            break;
        case SameOldStates.Done:
            // Do nothing.
            break;
        }
        return true;
    }
    #endregion
}
It is a little boring. Everything is hard coded. It doesn’t look like a game. It ignores user input.

But when I run it, IT WORKS!

And that’s what matters.

Always Leave Them Wanting More

Okay, my game really is close to being finished.

The game runner is complete. It works perfectly for the game we’re trying to make.

In part three, I’ll create a second implementation of IStateMachine and IState that make an actual interactive game.

(Okay, part 3 isn't an actual FUN game, but it is enough to technically be a text adventure. That is for a very loose definition of 'adventure'.)

You can download the code in the link below. Just like before it has a preview of what is to come.

Attached File  StateMachineTutorials.zip   13.42KB   74 downloads




November 2014 »

S M T W T F S
      1
2345678
9101112131415
16171819202122
23242526 27 2829
30      

Recent Comments

PARTNERS