Game state management (Game, Menu, Titlescreen, etc)

Question

Basically, in every single game I've made so far, I always have a variable like "current_state", which can be "game", "titlescreen", "gameoverscreen", etc.

And then on my Update function I have a huge:

if current_state == "game" 
  game stuf
  ...
else if current_state == "titlescreen"
  ...

However, I don't feel like this is a professional/clean way of handling states. Any ideas on how to do this in a better way? Or is this the standard way?

Answer 1

Since you are talking about screens, I feel it's best to separate all that logic into different Screens. What I normally do:

Define an interface called screen, and have multiple screens implement it. Like LoadingScreen, MainMenuScreen, GameScreen, GameOverScreen, HighScoreScreen etc. In your game you put a variable that holds the current screen. Each loop, you call screen.update() and render the current screen. This will save you a lot of "if this state do that" as your state is defined by current screen.

This will separate your logic very nicely.

Example code:

### Screen interface ###
public interface Screen {

    public void show();

    public void update(float delta);

    public void render(float delta);

    public void hide ();
}

### An implementation of screen ###
public class MainMenuScreen implements Screen {

    private Game game;

    public MainMenuScreen(Game game) {
        this.game = game;
    }

    public void show() {
        // init stuff
    }

    public void update(float delta) {
        // react to clicks, update animations etc.
        if (buttonwasclicked) {
            game.setScreen(new GameScreen(game)); // change the screen
        }
    }

    public void render(float delta) {
        // draw everything
    }

    public void hide() {
        // release all resources, as the screen is being hidden
    }
}

### Game, drawing the appropriate screen ###
public class Game {

    public Screen screen;

    public void update() {
        screen.update(getDeltaTime);
        screen.render();
    }

    public void setScreen(Screen screen) {
        this.screen.hide();

        this.screen = screen;
        this.screen.show();
    }
}

Or depending on your game setup, you maybe have an infinite loop as your game.

while(true) {
    calculatetimesincelastframe()
    screen.update(time);
    screen.render(time);
}

Answer 2

If you're already using Middleclass, there's an excellent state-machine library to go along with it called Statefull. It's easy to use and esposes the same ideas that Matsemann proposed.

Answer 3

If your current_state variable is a string, then this is really easy in Lua:

game_states = {}
function game_states.game()
    -- game stuff
end
function game_states.titlescreen()
    -- title screen stuff
end

-- then, inside the Update function:
game_states[current_state]()

Answer 4

What I do is roughly as follows:

I have a directed acyclic graph data structure, which is essentially just a bunch of nodes that point at each other. Each node represents a game system. e.g. the UI, the world, the input, the rendering. And each node points at other nodes that come before or after it. Once all the nodes are in place, it's easy to flatten it out into a simple list. Setting up this DAG is the first thing I do during the game's start up. Any time I want to add a new system, say AI, I can just say write that code then tell my game what it depends on and what should depend on it.

My main game loop comes after that and simply runs each system in order. First input is handled, then world updates, then other stuff... UI is near the end, and rendering is last. When the game first starts, there is no world or physics or AI, so those steps are essentially skipped, and just the title screen is displayed. When the you start the game proper, the UI sends a message to the world system to turn on, and it just takes care of itself. Managing game state just means turning on and off the various systems. Each system has it's own set of state information that is handled more or less independently of all others (That's not totally true actually, many systems act on the same set of data - the UI system for example grabs data from the world to display info for example. The AI system also needs to look at and send messages to entities in the world).

Answer 5

Here's how I organize my states in Lua + Love2d. It avoids the long if/then statements.

First, I create a basic class that contains an update(dt) and render() methods. You can also give it event handling methods, like onKeyDown(key). I call this class Stage, but any object that implements the methods will work. Then, I make an instance of that class for each game state, implementing the necessary methods. I then create a key/value table with the state's name and the instance of the state. Then keep track of the currentState at the global scope so the states can change it when a certain condition is met.

states = {}
states["title"] = title   -- Where title implements Stage class.
states["game"] = game     -- You could create the instance of 'game' lazily too.
currentState = "title"

function love.update(dt)
    if states[currentState] ~= nil then
       states[currentState]:update(dt) 
    end
end

Answer 6

Well, though it's not pretty it's OK to handle states this way, IMO. You can make it much more cleaner using functions for each state, like:

if current_state == "game" 
  game()
else if current_state == "titlescreen"
  titlescreen()

or something other bothers you in this approach (I mean except that Update method is very long)?