观察者模式--游戏开发

  今天要写的是观察者模式，还是老规矩先上概念，有好的理论基础和理论思想做引导，才能写出好代码。

   观察者模式：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都得到通知并作出更新。

  下面的例子是以前在项目里面写过的一个简单案例，观察的Subject是游戏的控制器，观察者对象在控制器低电量或者是连接异常

的时候得到通知并作出相应的反应

首先，定义一个抽象的观察者接口，注意我们的观察者可以同时观察多个Subject对象，因为游戏的控制器可能是多个的。

这里我将specificFun定义成了私有，是为了得到更好的封装性：

#ifndef _OBSERVER_H 
#define _OBSERVER_H

#include <map>

enum ControllerState		// controller's state
{
	E_NORMAL,
	E_POWEROFF,
	E_DISCONNECTED,
};

class Controller;
//---------------define interface---------------------
class observer
{
public:
	virtual ~observer(){}
	
	/*
	 * called by subject's method ,notify()
	 */
	virtual void handler( Controller* controller )=0;
	virtual void addSubject( Controller* controller )=0;
	virtual void removeSubject( Controller* controller )=0;

private:
	/*
	 * called by handler Fun, overrun by derived class
	 */
	virtual void specificFun( Controller* controller )=0;

protected:
	/*
	 * map/list/vector, we all use list symbol to name them
	 */
	std::map<Controller*, ControllerState>	mControllerStateList;

};

#endif//_OBSERVER_H

然后，定义具体的观察者类 ControllerObserver.h, 仅为了简单介绍一下观察者模型，所以连remove方法也没写。对于有多个观察主题的处理，需要根据自己项目的需求的不同进行自定义：

#ifndef _CONTROLLER_OBSERVER_H
#define _CONTROLLER_OBSERVER_H

class observer;

//-----------define specific observer----------------------
class ControllerObserver : public observer
{
public:
	ControllerObserver();
	virtual ~ControllerObserver();

	virtual void handler( Controller* controller );
	virtual void addSubject( Controller* controller );

private:
	virtual void specificFun( Controller* controller );

};
#endif//_CONTROLLER_OBSERVER_H

给出具体的实现 ControllerObserver.cpp：

#include "ControllerObserver.h"
#include "Controller.h"
#include "Observer.h"
#include <map>

ControllerObserver::ControllerObserver()
{
}

ControllerObserver::~ControllerObserver()
{
}

void ControllerObserver::handler( Controller* controller )
{
	specificFun( controller );
}

void ControllerObserver::addSubject( Controller* controller )
{
	bool isfind    = false;
	std::map<Controller*, ControllerState>::iterator itr = mControllerStateList.begin();
	for ( ; itr != mControllerStateList.end(); ++itr)
	{
		if ( itr->first == controller )
		{
			isfind = true;
			break;
		}
	}

	if ( !isfind )
	{
		mControllerStateList.insert( std::make_pair( controller, controller->getState() ) );
	}
}

void ControllerObserver::specificFun( Controller* controller )
{
	// specific disposition that you want
}

接着，定义我们的Subject类，游戏的控制器，可以拥有多个观察者，在控制器状态改变的时候通知每一个观察者并更新他们的状态：

#ifndef _CONTROLLER_H
#define _CONTROLLER_H

#include <vector>
#include "ControllerObserver.h"

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

	void notify();
	void addObserver( observer* ob );

	void setState(ControllerState state);
	ControllerState getState();

private:
	ControllerState		mState;
	std::vector<observer*>  mObserverList;
};
#endif//_CONTROLLER_H

给出简单的定义，Controller.cpp:

#include "Controller.h"

Controller::Controller()
	: mState(E_NORMAL)
{

}

Controller::~Controller()
{

}

void Controller::notify()
{
	std::vector<observer*>::iterator itr = mObserverList.begin();
	for ( ; itr != mObserverList.end(); ++itr )
	{
		(*itr)->handler( this );
	}
}

void Controller::addObserver( observer* ob )
{
	mObserverList.push_back( ob );
}

void Controller::setState( ControllerState state )
{
	mState  = state;
	if ( mState != E_NORMAL )
	{
		notify();
	}
}

ControllerState Controller::getState()
{
	return mState;
}

该模式挺简单，但是在游戏开发中也会经常用到，在观察者里的map可以很好的管理不同Subject对象的状态情况，从而进行灵活的处理