next »

[JK]

So I have a base class called GameState. I have derived classes MenuState and PlayState.

I declare an object of GameState and set it equal to "new MenuState" or "new PlayState". The game loop looks like this.

while( gameIsRunning )
{
    game->HandleEvents();
    game->Update();
    game->Draw();
}

How do I transition from one to the other? Can I do it internally, or should I create a StateManager class?

[ProgramGamer]

You could make a function which changes the game state to whichever one you want, and in there you could handle things like freeing the old state's memory or making sure that the argument is valid before doing anything. you don't really need a state manager until you want to start having multiple states in memory at once, which is only really useful for technical stuff anyways.

I'm assuming of course that "game" is your pointer variable to the active game state. As long as you can change that pointer to either one of your states, you should be fine.

[JK]

Oh. Well that simplifies matters! Therefore...

void ChangeState(GameState *state)
{
    // logic for MenuState to PlayState transition here
    delete state;
    state = new PlayState;
}

I've never used the "new" and "delete" keywords before this particular game, so I don't know if that is correct syntax or not. If so, that's pretty nifty.

[ProgramGamer]

yes and no. You actually want to pass the pointer's address from your main code into the function, that way you still delete the old state but you also store the new one in the variable that was in your main scope. If my c++ memory is correct you simply need to add one star in front of the two "state"s in your code.

Let me just double check that though.

Edit: I did my homework and here's en example of what should work and how it does.

Code:

#include <iostream>
using namespace std;

void changeToFive(int **funcPointer);

int main()
{
    //making a pointer to int and initializing it with the adress of a new int
    int *pointer = new int;

    //Initializing the int which "pointer" points to with 3
    *pointer = 3;

    //Returns the value of the int which pointer points to
    cout << *pointer << endl;

    //Calls the function that gets you a brand new int!
    changeToFive(&pointer);

    //Returns the value of the int which pointer points to, again
    cout << *pointer << endl;

    //return 0, duh :)
    return 0;
}

void changeToFive(int **funcPointer)
{
    //Deleting the int which "pointer" pointed to
    //Also worth noting, in the function scope, "funcPointer" points to the pointer "pointer" back in the main scope
    delete *funcPointer;

    //Creating a new int and storing it inside "pointer", which "funcPointer" points to
    *funcPointer = new int;

    //Initialising the int which "pointer" points to with 5
    **funcPointer = 5;
}

[JK]

Yea you're right, my game wouldn't compile after I tried the code in my original post. After performing some google foo I ended up changing the line to ChangeState(GameState *&state){/*stuff*/} and it works now 

Thanks a million for the huge refresher on pointer logic! I really wish I'd seen your reply earlier

[Cheezmeister]

Rather than deleting the old state and replacing it, you may wish to store a stack of states and push/pop as you transition. This comes in handy for example to show a pause screen.

Just something to think about down the line

[JK]

Rather than deleting the old state and replacing it, you may wish to store a stack of states and push/pop as you transition. This comes in handy for example to show a pause screen.

Just something to think about down the line

Duly noted, friend. Thanks!

[ProgramGamer]

Yep, had not thought of that at all, I don't even actually know how to pop and push things from a stack. Still, I know pointers at least!

[SamSerious]

I call my states "screens" and those lend the design from java applets. kind of

Code:

class Screen
{
public:
 virtual std::string Name()=0;//a name, like e.g. "logo" or "main_menu"

 virtual bool Create()=0;//called once during initialization of the game
 virtual bool Resume()=0;//called before it's used
 virtual void Suspend()=0;//called before switching to other Screens
 virtual void Release()=0;//called once at the end of the game

 virtual Next Update()=0;//called 60times/s
 virtual void Paint()=0;//called as fast as it gets
};

now the magic is mostly the "Next" object that gets returned from the update function, it tells the game loop how to proceed with the screens

Code:

enum NextStack
{
 EN_NOP,
 EN_PUSH,
 EN_POP,
 EN_SWITCH
};
struct Next
{
  std::string Name;
  NextStack Action;
};

;

the initialization looks something like this

Code:

main(..)
{
std::vector<Screen*> Stack,Screens;

Screens.push_back(new Logo());
Screens.push_back(new Menu());
Screens.push_back(new HighScore());
....
for(size_t a=0;a<Screens.size();a++)
 if(!Screens[a]->Init())
 {
//handle init fail
 }

Screen* pCurrent = Screens[0];//just assume that's the logo, but for deving you might want to start straight in-game
if(!pCurrent->Resume())
{
//handle init fail
}

while(pCurrent)
{
 Next N = pCurrent->Update();
 switch(N.Action)
 {
 case EN_NOP:break;
 case EN_PUSH:
  pCurrent->Suspend();
  Stack.push_back(pCurrent);
  pCurrent = Screens.find(N.Name);//pseudo code, but lets keep it simple here
  if(!pCurrent)
  {
   //handle fail
  }
  pCurrent->Resume();
 break;
 case EN_POP:
  pCurrent->Suspend();
  pCurrent = Stack.pop_last();
  if(!pCurrent)
  {
   //handle fail
  }
  pCurrent->Resume();
 break;
 case EN_SWITCH:
  pCurrent->Suspend();
  pCurrent = Screens.find(N.Name);//pseudo code, but lets keep it simple here
  if(!pCurrent)
  {
   //handle fail
  }
  pCurrent->Resume();
  break;
 }

 if(time_left)
   pCurrent->Render();
}

for(size_t a=0;a<Screens.size();a++)
 !Screens[a]->Release();

the logo screen returns

Code:

Next Update()
{
  return CurrentTime-StartTime>10seconds?Next("menu",EN_SWITCH):Next("logo",EN_NOP);
}

the menu screen pushes itself and points at the "new game" screen, or "options" or "highscore", so if those end, those can "pop" to the previous state, that way also the game could push "options" or "highscore" and those would return to the game instead of the menu
This works not only for big states, if e.g. you had a game like GTA where you're roaming in a sandbox world, you could create "screens" for every mission type and push/pop those while the big "game" screen is kinda the stack base you return to all the time.

[BlackseaOdyssey]

Definitely use a State Machine.

[Allen Chou]

You can also try action lists.

I wrote a post about it, and there's a

of a lecture session from DigiPen's Game Engine Architecture Club.

It is possible to use an action list framework to simulate a full-blown state machine framework. Further, the lane structure can be used to simulate "stacked states" mentioned earlier in this thread: making a blocking action and push it in front of a lane simulates a state push; completing the blocking action and pop it off the front of the lane to allow the previous active action to kick back in simulates a state pop.