无聊之作，RPGdemo制作（一）角色state模式

今天周末，在家无事可做，不知道为什么，突发奇想，想写一个RPG游戏的demo玩玩。所以就记录一下。

第一步要做的是，为以后的角色类写一个state模式的类，考虑到可能以后会用到，所以用模版来实现，

//状态枚举
enum _EN_STATE_TYPE
{
	EN_STATE_STANBY,
	EN_STATE_MOVE,
	EN_STATE_ATK,
	EN_STATE_DEAD
};

//状态父类
template < class T >
class state_object
{
protected:
	_EN_STATE_TYPE _Type;

public:

	state_object(){};

	~state_object(){};

	//在本类内创建非本类型的新状态
	state_object<T>*	createState(_EN_STATE_TYPE Type_)
	{
		state_object<T>* state_ = nullptr;

		if (_Type != Type_)
		{
			switch (Type_)
			{
			case EN_STATE_STANBY:
				state_ = new state_stanby<T>;
				break;
			case EN_STATE_MOVE:
				state_ = new state_move<T>;
				break;
			case EN_STATE_ATK:
				state_ = new state_atk<T>;
				break;
			case EN_STATE_DEAD:
				state_ = new state_dead<T>;
				break;
			default:
				break;
			}
		}

		return state_;
	}

	//状态检测
	virtual  void		update(T*  host)
	{
		//如果宿主血条为空
		if (host->isDead())
		{
			//切换到死亡状态
			host->changeState(createState(EN_STATE_DEAD));
		}

	};

	//是否状态相同
	virtual bool		isState(state_object<T>* state_)
	{
		if (state_)
		{
			return _Type == state_->getType();
		}

		return false;
	}

	virtual void				onExit(){};

	virtual void				onEnter(){};

	//获取状态类型
	virtual _EN_STATE_TYPE		getType(){ return _Type; }

private:

};

这样就用模版创建了一个状态父类，以后的状态都继承于它。再上其他类的代码。

各个状态的update函数负责随时检测更新状态

template < class T >
class state_stanby : public state_object<T>
{
public:
	state_stanby(){ _Type = EN_STATE_STANBY; };

	~state_stanby(){};

	virtual  void		update(T*  host)
	{
		state_object::update(host);
		if (host->isRival())//如果宿主有攻击对象
		{
			//切换到攻击状态
			host->changeState(createState(EN_STATE_ATK));
		}
	};

	virtual void				onExit()
	{
		cout << "退出《state_stanby》状态" << endl;
	};

	virtual void				onEnter()
	{
		cout << "进入《state_stanby》状态" << endl;
	};
};

template < class T >
class state_move : public state_object<T>
{
public:
	state_move() { _Type = EN_STATE_MOVE; };

	~state_move(){};

	virtual  void		update(T*  host)
	{
		state_object::update(host);
		//暂时没写到画面，所以暂时没写移动状态
	};
	virtual void				onExit()
	{
		cout << "退出《state_move》状态" << endl;
	};

	virtual void				onEnter()
	{
		cout << "进入《state_move》状态" << endl;
	};
};

template < class T >
class state_atk : public state_object<T>
{
public:
	state_atk(){ _Type = EN_STATE_ATK; };

	~state_atk(){};

	virtual  void		update(T*  host)
	{
		state_object::update(host);
		//如果有攻击对象
		if (host->isRival())
		{
			//攻击它
			host->hit_Rival();
		}
		else
		{
			//没有对象就回到待机状态
			host->changeState(createState(EN_STATE_STANBY));
		}
	};

	virtual void				onExit()
	{
		cout << "退出《state_atk》状态" << endl;
	};

	virtual void				onEnter()
	{
		cout << "进入《state_atk》状态" << endl;
	};
};

template < class T >
class state_dead : public state_object<T>
{
public:
	state_dead(){ _Type = EN_STATE_DEAD; };

	~state_dead(){};

	virtual  void		update(T*  host)
	{
		state_object::update(host);

		if (host->isRival())
		{
			//死亡了,清除宿主的对手信息，以及对手的对手信息
			host->getRival()->Configure_Role(nullptr);
			host->Configure_Role(nullptr);
		}

	};

	virtual void				onExit()
	{
		cout << "退出《state_dead》状态" << endl;
	};

	virtual void				onEnter()
	{
		cout << "进入《state_dead》状态" << endl;

	};
};

到现在为止，目前所用到的状态就写完了，本章先到处介绍，未完待续··········