今天周末，在家无事可做，不知道为什么，突发奇想，想写一个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; };
};
到现在为止，目前所用到的状态就写完了，本章先到处介绍，未完待续··········