（博主qq，1204802552，歡迎交流）

 有時候，我們想在Sequence或者Spawn中加入RepeatForever的動作，但在實際執行中，該迴圈動作並未得到執行，我們先來說下解決的方法。

   對於Spawn，很簡單，我們只需要把RepeatForever動作拿出來單獨執行即可

        Animation *animation = Animation::createWithSpriteFrames(aniframe,0.1f);
Animate *animate = Animate::create(animation);
aniSprite->runAction(RepeatForever::create((ActionInterval *)animate));
aniSprite->runAction(MoveTo::create(5,PointMake(visibleSize.width-40, visibleSize.height/2)));

   對於Sequence，則要使用回撥函式來執行RepeatForever動作

      CallFunc *callfunc = CallFunc::create(this,callfunc_selector(HelloWorld::animateCallback));

       aniSprite->runAction(seq);

下面分析下具體原因：Spawn和Sequence都採用遞迴的建立方式

   我們先來看看Spawn的建立原始碼：Spawn有不同形式的Create函式，但最終它們都會呼叫CreateWithTwoActions，所以我們直接看該函式

   Spawn* Spawn::createWithTwoActions(FiniteTimeAction *action1, FiniteTimeAction *action2)
{
    Spawn *spawn = new Spawn();
    spawn->initWithTwoActions(action1, action2);
    spawn->autorelease();


    return spawn;
}


bool Spawn::initWithTwoActions(FiniteTimeAction *action1, FiniteTimeAction *action2)
{
    CCASSERT(action1 != nullptr, "");
    CCASSERT(action2 != nullptr, "");


    bool ret = false;


    float d1 = action1->getDuration();
    float d2 = action2->getDuration();


    if (ActionInterval::initWithDuration(MAX(d1, d2)))
    {
        _one = action1;
        _two = action2;


        if (d1 > d2)
        {
            _two = Sequence::createWithTwoActions(action2, DelayTime::create(d1 - d2));
        } 
        else if (d1 < d2)
        {
            _one = Sequence::createWithTwoActions(action1, DelayTime::create(d2 - d1));
        }


        _one->retain();
        _two->retain();


        ret = true;
    }


    return ret;
}

從上面的程式碼中可以看到，Spawn為了同步不同的動作，會呼叫Sequence，即它最終執行的其實是由Sequence建立的動作，那麼下面我們就來看看Sequence的建立和執行

  bool Sequence::initWithTwoActions(FiniteTimeAction *actionOne, FiniteTimeAction *actionTwo)
{
    CCASSERT(actionOne != nullptr, "");
    CCASSERT(actionTwo != nullptr, "");


    float d = actionOne->getDuration() + actionTwo->getDuration();
    ActionInterval::initWithDuration(d);


    _actions[0] = actionOne;
    actionOne->retain();


    _actions[1] = actionTwo;
    actionTwo->retain();


    return true;
}

從上面這段程式碼可以看出，一個Sequence動作包含了兩個子動作，它的duration為兩個動作的總和。

void Sequence::startWithTarget(Node *target)
{
    ActionInterval::startWithTarget(target);
    _split = _actions[0]->getDuration() / _duration;
    _last = -1;
}

void Sequence::update(float t)
{
    int found = 0;
    float new_t = 0.0f;


    if( t < _split ) {
        // action[0]
        found = 0;
        if( _split != 0 )
            new_t = t / _split;
        else
            new_t = 1;


    } else {
        // action[1]
        found = 1;
        if ( _split == 1 )
            new_t = 1;
        else
            new_t = (t-_split) / (1 - _split );
    }


    if ( found==1 ) {


        if( _last == -1 ) {
            // action[0] was skipped, execute it.
            _actions[0]->startWithTarget(_target);
            _actions[0]->update(1.0f);
            _actions[0]->stop();
        }
        else if( _last == 0 )
        {
            // switching to action 1. stop action 0.
            _actions[0]->update(1.0f);
            _actions[0]->stop();
        }
    }
else if(found==0 && _last==1 )
{
// Reverse mode ?
// XXX: Bug. this case doesn't contemplate when _last==-1, found=0 and in "reverse mode"
// since it will require a hack to know if an action is on reverse mode or not.
// "step" should be overriden, and the "reverseMode" value propagated to inner Sequences.
_actions[1]->update(0);
_actions[1]->stop();
}
    // Last action found and it is done.
    if( found == _last && _actions[found]->isDone() )
    {
        return;
    }


    // Last action found and it is done
    if( found != _last )
    {
        _actions[found]->startWithTarget(_target);
    }


    _actions[found]->update(new_t);
    _last = found;
}

從上面兩段程式碼可以理解到：Sequence根據子動作的duration所佔比例以及執行時間來判斷哪個動作需要得到執行。對於普通的兩個動作，他們都可以得到執行。。。。。。。。但是，一個RepeatForever動作的duration為0，也就是說其所佔執行時間的比例為0，即是不會執行，這個可以從Update的前段程式碼可以看出，這個分析結果也符合我們看到的實際執行效果。

    但是，我們來看看紅色的那部分程式碼。假如我們把RepeatForever動作當做引數1傳入，當執行的時候，該動作被跳過了，於是紅色部分的程式碼得到執行，經過除錯也確實如此。

      我們看下注釋：// action[0] was skipped, execute it. ----------excute可以翻譯為執行，也可以翻譯為處死！！從程式碼看，action [ 0 ]在啟動之後馬上被結束，所以註釋中的excute極有可能是處死的意思。於是我嘗試改造程式碼，不呼叫stop，並向update傳入0.0f，我想要看到的效果是：RepeatForever動作得到執行，但是實際執行效果並沒有發生變化，令我百思不得其解，也許我瞭解的還不夠深入有什麼遺漏了，待我找個時間再研究研究，也希望各位能指點迷津