【木头Cocos2d-x 023】状态机篇(第02章) --状态模式之我很胖但我很强!

【Cocos2d-x状态机篇】第02章--状态模式之我很胖但我很强!

笨木头花心贡献，啥？花心？不呢，是用心~

转载请注明，原文地址：http://blog.csdn.net/musicvs/article/details/8348323

正文：

状态机的应用当然就少不了状态模式了，因为它们都有“状态”两个字。

（旁白：总感觉这句话十分不可靠==）

本章我们来简单地介绍一下状态模式，并且利用状态模式优化我们的有限状态机的实现。

1.什么是状态模式

说实话，我不知道，但我知道怎么使用...

用一句话来概括，也许是这样：同一件事情，让不同的人去做，每个人都会用自己的方式来做事，但，同一时间，只会让一个人在做这件事情。由老板来决定某一刻由谁来做事。

（旁白：又你可爱的妹纸的，这明明是两句话，两个句话有没有==）

用程序来说，也许是这样：同一个动作，让不同的类去执行，每个类都有自己独特的处理方式，至于由哪个类来执行这个动作，要根据当前的状态来判断。并且，不同的类执行完动作之后，会切换状态。

（旁白：还是没听懂。。。）

OK，我相信大家都明白了什么是状态模式了，接下来我们把第01章的例子稍微改改，很简单的~！

（旁白：等等，我压根儿就没搞懂什么是状态模式啊！）

好吧，我画了一个图，帮助大家理解：

图中有一个对象（蓝色方块），有三个状态处理类。

比如我有一件事情要做，那就是，起床之后要做的事情，但是由哪个类来执行这件事情呢？这要根据我的当前状态来决定（我有三种状态：肚子饿，想看电影，想吐槽），默认的状态是肚子饿。

然后，今天起床，我的状态是“肚子饿”。那我就会自动调用小木厨师来执行事件，执行完之后，状态会切换到“想看电影”。

那么，第二天，我起床的状态就是“想看电影”。那我就会自动调用电影院来执行事件，执行完之后，状态会切换到“想吐槽”。

第三天，我起床的状态就是“想吐槽”。那我就会自动调用吐槽旁白来执行事件，执行完之后，状态会切换到“肚子饿”。

第四天，我起床之后的状态就是“肚子饿”。那我就会自动调用小木厨师来执行事件，执行完之后，状态切换到“想看电影”。

第五天，我起床...（旁白：停~！！！你想说到天亮吗？！）

其实这个例子有点不准确，甚至是十分不准确，但是对于理解状态模式还是有点帮助了。

现在，大家在接着往下看之前，请确认你已经大概了解状态模式（起码去百度过，看过一篇正式介绍状态模式的文章）。因为接下来的代码和上面那张图的差别还是不小的，如果对状态模式不理解，就会产生混乱。

那么，用什么方法实现自动调用哪个类呢？当然是多态了，小木厨师、电影院、吐槽旁白这三个类都继承了同一个父类，它们就是我们要说的状态类了。

2.用状态模式实现有限状态机

还记得上一章的Mutou类吗？兴趣爱好很广泛的那个~（旁白：我不想吐槽了...）大家应该对它的update函数印象很深刻吧？那我就不贴出来了：

void Mutou::update( float dt ) {
    /* 判断在每一种状态下应该做什么事情 */
    switch(enCurState) {
    case enStateWriteCode:
        /* 如果累了就休息,并且切换到休息状态 */
        if(isTire()) {
            rest();
            changeState(enStateRest);
        }
        break;
    case enStateWriteArticle:
        /* 如果累了就休息,并且切换到休息状态 */
        if(isTire()) {
            rest();
            changeState(enStateRest);
        }
        break;
    case enStateRest:
        /* 一定的概率写代码,一定的概率写教程,并且切换到相应的状态 */
        if(isWantToWriteArticle()) {
            writeArticle();
            changeState(enStateWriteArticle);
        }
        else {
            writeCode();
            changeState(enStateWriteCode);
        }
        break;
    }
}

update函数会先判断木头当前所在的状态，然后再去执行相对应的逻辑。

（旁白：你刚刚说你不贴的代码的...）

那个旁白什么的，你刚刚也说你不想吐槽啊~！

但是啊，要是木头有好多好多状态，那这个函数也太庞大了~！是的，我们现在就要用到状态模式了，很简单的，别走神咯~！

3.状态基类

首先，我们需要一个状态基类，它只有一个抽象方法execute，表示要执行一件事情。至于执行什么事情，由它的子类来决定。

/*
    文件名：    State.h
    描　述：    状态基类
    创建人：    笨木头 (CSDN博客：http://blog.csdn.net/musicvs)

    创建日期：   2012.12.17
*/
#ifndef __I_STATE_H__
#define __I_STATE_H__

class MutouT;

class I_State {
public:
    virtual void execute(MutouT* mutou) = 0;
};

#endif

4三种状态对应的状态类

接下来，我们要实现最核心的类：状态类。

木头有3种状态：写代码、写教程、休息。

/*
    文件名：    StateWirteCode.h
    描　述：    写代码状态
    创建人：    笨木头 (CSDN博客：http://blog.csdn.net/musicvs)

    创建日期：   2012.12.17
*/
#ifndef __STATE_WRITE_CODE_H__
#define __STATE_WRITE_CODE_H__

#include "I_State.h"

class MutouT;
class StateWirteCode : public I_State {
public:
    virtual void execute( MutouT* mutou );
};

#endif

/* cpp文件 */
#include "StateWirteCode.h"
#include "StateRest.h"
#include "MutouT.h"

void StateWirteCode::execute( MutouT* mutou ) {
    /* 如果累了就休息,并且切换到休息状态 */
    if(mutou->isTire()) {
        mutou->rest();
        mutou->changeState(new StateRest());
    }
}

上面这个就是写代码状态类，它继承了I_State，拥有一个execute方法，它表示，在写代码状态下执行一个动作。

那么，接下来，另外两种状态的类也是一样的，唯一不同的就是execute的具体实现。

/*
    文件名：    StateWirteArticle.h
    描　述：    写教程状态
    创建人：    笨木头 (CSDN博客：http://blog.csdn.net/musicvs)

    创建日期：   2012.12.17
*/
#ifndef __STATE_WRITE_ARTICLE_H__
#define __STATE_WRITE_ARTICLE_H__

#include "I_State.h"

class MutouT;
class StateWriteArticle : public I_State {
public:
    virtual void execute( MutouT* mutou );
};

#endif

/* cpp文件 */
#include "StateWriteArticle.h"
#include "StateRest.h"
#include "MutouT.h"

void StateWriteArticle::execute( MutouT* mutou ) {
    /* 如果累了就休息,并且切换到休息状态 */
    if(mutou->isTire()) {
        mutou->rest();
        mutou->changeState(new StateRest());
    }
}

/*
    文件名：    StateRest.h
    描　述：    休息状态
    创建人：    笨木头 (CSDN博客：http://blog.csdn.net/musicvs)

    创建日期：   2012.12.17
*/
#ifndef __STATE_REST_H__
#define __STATE_REST_H__

#include "I_State.h"

class MutouT;
class StateRest : public I_State {
public:
    virtual void execute( MutouT* mutou );
};

#endif

/* cpp文件 */
#include "StateRest.h"
#include "StateWriteArticle.h"
#include "StateWirteCode.h"
#include "MutouT.h"

void StateRest::execute( MutouT* mutou ) {
    /* 一定的概率写代码,一定的概率写教程,并且切换到相应的状态 */
    if(mutou->isWantToWriteArticle()) {
        mutou->writeArticle();
        mutou->changeState(new StateWriteArticle());
    }
    else {
        mutou->writeCode();
        mutou->changeState(new StateWirteCode());
    }
}

5.新的木头类

为了使用状态模式，Mutou类要修改，先看看头文件：

#ifndef __MUTOU_T_H__
#define __MUTOU_T_H__

#include "cocos2d.h"
USING_NS_CC;

class I_State;
class MutouT : public CCNode {
public:
    CREATE_FUNC(MutouT);
    virtual bool init();

    bool isTire();                      /* 判断是否写代码写累了 */
    bool isWantToWriteArticle();        /* 是否想写教程 */
    void writeCode();                   /* 写代码 */
    void writeArticle();                /* 写教程 */
    void rest();                        /* 休息 */
    void changeState(I_State* state);   /* 切换状态 */

    virtual void update(float dt);

private:
    /* 存放当前状态类 */
    I_State* mCurState;
};
#endif

和以前的代码区别并不大，有两处修改：

1.changeState的参数变了，变成了I_State，同时，表示状态的枚举类也删掉了，因为已经有了状态类。

2.多了一个I_State成员变量，表示当前的状态，同时，表示状态的枚举变量删掉了，因为已经有了状态类。

那么，我们之前的逻辑几乎没有什么变化，依旧是在木头的update函数里做文章，只不过，这次的update函数可就简单多了~~~

（旁白：真的吗？倒是有点兴趣~）

#include "MutouT.h"
#include "I_State.h"

bool MutouT::init() {
    mCurState = NULL;
    this->scheduleUpdate();
    return true;
}

bool MutouT::isTire() {
    /* 每次问木头累不累,他都会说:累~ */
    return true;
}

bool MutouT::isWantToWriteArticle() {
    /* 有10%的概率想写教程(好懒~!) */
    float ran = CCRANDOM_0_1();
    if(ran < 0.1f) {
        return true;
    }

    return false;
}

void MutouT::writeCode() {
    CCLOG("mutou is wirting Code.");
}

void MutouT::writeArticle() {
    CCLOG("mutou is writing article.");
}

void MutouT::rest() {
    CCLOG("mutou is resting.");
}

void MutouT::changeState( I_State* state ) {
    CC_SAFE_DELETE(mCurState);

    mCurState = state;
}

void MutouT::update( float dt ) {
    mCurState->execute(this);
}

前面几乎没有变，看看最后那个：

voidMutouT::update(floatdt){

mCurState->execute(this);

}

这个就是新的update函数的处理了，是不是很简单？

先看看效果再解释，修改HelloWorld的init函数：

bool HelloWorld::init()
{
    bool bRet = false;
    do 
    {
        CC_BREAK_IF(! CCLayer::init());

        /* 新建木头2角色 */
        mMutou = MutouT::create();

        /* 初始化木头的状态为休息 */
        mMutou->changeState(new StateRest());

        this->addChild(mMutou);
        bRet = true;
    } while (0);

    return bRet;
}

和以前差不多，只是把Mutou类换成新的MutouT类。

（旁白：MutouT？就是MutouTow的意思？也就是Mutou2？噗，是的，木头是挺2的~）

然后用调试模式运行项目，将看到以下输出：

mutouiswirtingCode.

mutouisresting.

mutouiswritingarticle.

mutouisresting.

mutouiswritingarticle.

mutouisresting.

mutouiswirtingCode.

mutouisresting.

mutouiswirtingCode.

mutouisresting.

mutouiswirtingCode.

OK，和以前一样的效果。

稍微解释一下，其实这就是简单地利用了多态。神奇的地方就在execute这个函数，这个函数里面会根据不同的情况切换MutouT的当前状态，比如写教程状态的execute函数：

void StateWriteArticle::execute( MutouT* mutou ) {
    /* 如果累了就休息,并且切换到休息状态 */
    if(mutou->isTire()) {
        mutou->rest();
        mutou->changeState(new StateRest());
    }
}

如果累了，就切换到休息状态，那么，执行完这个函数之后，MutouT的状态其实就已经改变了，变成了休息状态，那么下一次的update函数就会调用休息状态的execute函数。以此类推。

看一个图，会不会好理解一些？

好吧，我承认我解释得有点糟糕，希望大家能看明白...

（旁白：我已经晕了。。。）