状态模式--游戏开发

   先来概念：状态模式主要解决当控制一个对象状态转换的条件表达式过于复杂时，把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的判断逻辑简化。状态模式的好处：将与特定状态相关的行为局部化，并且将不同状态的行为分割开来。

     在游戏开发中，状态模式也是会经常用到的一种设计模式。比如在实现AI，游戏过程切换，甚至是复杂UI的状态切换等都可以用状态模式来方便的实现。

     今天会写一个用状态模式来实现游戏状态切换的小例子，代码如下：

首先，定义需要的状态接口和Load/Run/Outro三个具象状态，GameState.h:

#ifndef _GAME_STATE_H
#define _GAME_STATE_H

class MiniGame;

// define interface class
class GameState
{
public:
	virtual void onEnter()=0;
	virtual void onUpdate( float deltaTime )=0;
	virtual void onExit()=0;
	virtual void setOwner( MiniGame* owner)=0;
        virtual ~GameState(){}
};

//----------------------------------------------
class StateBase : public GameState
{
public:
	MiniGame* getGame()const{ return mOwner; }
	virtual void setOwner( MiniGame* owner ) { mOwner = owner; }
protected:
	MiniGame*	mOwner;
};
//----------------------------------------------

//----------------concrete States----------------
class LoadGame : public StateBase
{
public:
	LoadGame():mDuringTime(0){}
	~LoadGame(){}
	virtual void onEnter();
	virtual void onUpdate( float deltaTime );
	virtual void onExit();
private:
	float	mDuringTime;
};

class RunGame : public StateBase
{
public:
	RunGame():mDuringTime(0){}
	~RunGame(){}
	virtual void onEnter();
	virtual void onUpdate( float deltaTime );
	virtual void onExit();
private:
	float	mDuringTime;
};

class OutroGame : public StateBase
{
public:
	OutroGame():mDuringTime(0){}
	~OutroGame(){}
	virtual void onEnter();
	virtual void onUpdate( float deltaTime );
	virtual void onExit();
private:
	float	mDuringTime;
};
//----------------------------------------------
#endif//_GAME_STATE_H

给出定义GameState.cpp:

#include "GameState.h"
#include "MiniGame.h"
//----------------------------------------------
void LoadGame::onEnter()
{
	printf("now enter loading game ,do something\n");
}

void LoadGame::onUpdate( float deltaTime )
{
	printf("deal with LoadGame state update\n");
	mDuringTime	+= deltaTime;
	if ( mDuringTime>5.0f )
	{
		getGame()->setGameState( E_RUN);
	}
}

void LoadGame::onExit()
{
	printf("now exit loading game ,do something\n");
}

void RunGame::onEnter()
{
	printf("now enter RunGame state,do something\n");
}

void RunGame::onUpdate( float deltaTime )
{
	printf("deal with RunGame state update\n");
	mDuringTime	+= deltaTime;
	if ( mDuringTime>5.0f )
	{
		getGame()->setGameState( E_OUTRO);
	}
}

void RunGame::onExit()
{
	printf("now exit RunGame state,do something\n");
}

void OutroGame::onEnter()
{
	printf("now enter OutroGame state ,do something\n");
}

void OutroGame::onUpdate( float deltaTime )
{
	printf("deal with OutroGame state update\n");
	mDuringTime	+= deltaTime;
	if ( mDuringTime>5.0f )
	{
		getGame()->setGameOver();
	}
}

void OutroGame::onExit()
{
	printf("now exit OutroGame state,do something\n");
}
//----------------------------------------------

然后，定义简单的MiniGame类，引用前一篇Factory的模板，创建GameState的工厂，oldState和currentState用来处理交换状态时候的行为，如下MiniGame.h:

#ifndef _MINI_GAME_H
#define _MINI_GAME_H

#include "Factory.h"

;class GameState;
enum EState
{
	E_LOAD,
	E_RUN,
	E_OUTRO
};

class MiniGame
{
public:
	MiniGame();
	~MiniGame();

	void init();
	void update( float deltaTime );
	void setGameState( EState state );
	void setGameOver(){ mIsGameOver = true; }
	void RegisterStates();

private:
	Factory<EState, GameState>	mFactory;
	GameState*			mOldState;
	GameState*			mCurrentState;
	bool				mIsGameOver;
};
#endif//_MINI_GAME_H

定义如下 MiniGame.cpp,(坚持谁创建谁析构原则，避免内存泄露):

#include "MiniGame.h"
#include "GameState.h"
MiniGame::MiniGame()
	: mOldState(NULL)
	, mCurrentState(NULL)
	, mIsGameOver(false)
{
}

MiniGame::~MiniGame()
{
	if ( mOldState != NULL )
	{
		delete mOldState;
		mOldState       = NULL;
	}
	if ( mCurrentState != NULL )
	{
		mCurrentState->onExit();
		delete mCurrentState;
		mCurrentState	= NULL;
	}	
}

void MiniGame::init()
{
	setGameState( E_LOAD );
}

void MiniGame::setGameState( EState state )
{
	if ( mOldState != NULL )
	{
		delete mOldState;
		mOldState	= NULL;
	}
	if ( mCurrentState != NULL )
	{
		mCurrentState->onExit();
		mOldState	= mCurrentState;
	}

	mCurrentState	= mFactory.createInstance( state );
	if ( mCurrentState != NULL )
	{
		mCurrentState->setOwner( this );
		mCurrentState->onEnter();
	}
}

void MiniGame::update( float deltaTime )
{
	if ( mOldState != NULL )
	{
		delete mOldState;
		mOldState	= NULL;
	}
	if ( mCurrentState != NULL )
	{
		mCurrentState->onUpdate( deltaTime );
	}
}

void MiniGame::RegisterStates()
{
	mFactory.registerClass<LoadGame>( E_LOAD );
	mFactory.registerClass<RunGame>( E_RUN );
	mFactory.registerClass<OutroGame>( E_OUTRO );
}

最后测试一下，一开始游戏进入Load，5s后切到Run，再过5s切换到Outro，如Main.cpp:

/**	created by Luo Zheng@chengdu 2014.8.31 **/
/*
 this project used to describe the State Pattern;
 Game state: LoadGame --> RunGame --> OutroGame,switch every 5 secs;
 every state disposes its own Logic;
*/

#ifndef _MAIN_H
#define _MAIN_H

#include <time.h>
#include "MiniGame.h"

double gTime		= 0;
double deltaTime	= 0;
double gFrameTime	= 1.0f;		// we just update one frame every 1 sec 

int main()
{
	MiniGame* game	= new MiniGame;
	game->RegisterStates();		// register every state construction method
	game->init();				// jump to LoadGame state

	gTime		= time( 0 );
	double temp	= 0;
	while( true )
	{
		if ( game->isGameOver() )
		{
			printf( "game is over\n" );
			break;
		}
		temp		= time( 0 );
		deltaTime	= temp - gTime;
		if ( deltaTime<gFrameTime )
		{
			continue;
		}

		game->update( deltaTime );
		gTime		= temp;
	}

	getchar();
	return 0;
}
#endif//_MAIN_H

运行后的结果如下图，说明开始设定的状态流转OK，并且处理了各自阶段的逻辑：