我：我看在ActionInterval的孩子中你们好像有些与众不同。
Sequence、ExtraAction、Repeat、RepeatForever、DelayTime以及ReverseTime（异口同声）：没错，我们的能力不是作用于您指定的物体上，而是作用于您指定的动作上。换句话说，我们是为了辅助其他动作的运行而存在的。
我：这无私奉献的精神，那么来One By One的做个自我介绍吧。

Sequence：我能将您交给我的动作一个接着一个的执行，对了就是您刚才说的词，One By One。给我多少个动作我都能胜任，但是请注意一定要在最后一个动作参数之后加上一个nullptr参数，用这种方式来告诉我：“我给你的动作就这么多了，没有其他的了。”
我（不明觉厉）：看起来很厉害的样子，说说怎么使用吧。
Sequence：好的。我可以接收任意多个动作作为参数，就像刚才描述中的用法，

sprite->runAction(Sequence::create(action1,action2,...,nullptr));    // ...代表可以写任意多个动作。

还可以接收一个存储着多个动作的容器，

Vector<FiniteTimeAction *> vector;
vector.pushBack(static_cast<FiniteTimeAction *>(action1));
vector.pushBack(static_cast<FiniteTimeAction *>(action2));
...
sprite->runAction(Sequence::create(vector));

我：我看到你的第一种使用方式的函数声明最后有个CC_REQUIRES_NULL_TERMINATION，我研究了一下，请参见我的这篇博文。
Sequence：没错，正如您所说的那样。
我：给你多少个动作你都能接收，你的肚子到底有多大？
Sequence：:)，其实我的肚子没有多大，再说我也不是用肚子存储的，是用我的双手，所以我只能存储两个动作。我之所以能存储多个动作，是因为我影分身出了多个同胞来帮助我，人多力量大嘛。我的左手拿着您给我的其中一个动作，右手就拿着我的一个影分身；我右手的影分身也和我一样，左手拿着您给我的其中一个动作，右手拿着我的另外一个影分身，以此类推；我的最后一个影分身左右手拿的就是您给我的最后两个动作。这么说可能有些绕，还是来张图更直观些。比如您指定给我5个动作，那么我就是按如下方式存储的，

// 第一个是我，后面是我影分身出的3个同胞。
Sequence -- Sequence -- Sequence -- Sequence -- action1
         | | | |- action2
         | | |- action3
         | |- action4
         |- action5

此外还要说明两点，
1、我向长辈们传递的“规定的时间”是我手里两个动作各自的“规定的时间”之和。还是上面的那个例子，比如action1~action5规定的时间是10～6，还是上面的那张图，在括号中表示向长辈们上报的规定的时间，

Sequence(40) -- Sequence(34) -- Sequence(27) -- Sequence(19) -- action1(10)
             |               |               |               |- action2(9)
             |               |               |- action3(8)
             |               |- action4(7)
             |- action5(6)

2、如果您只传递给我一个动作，那么我的另一只手也不会空着，我会自己创建一个ExtraAction类型的动作在手里攥着，这个动作的“规定的时间”为0（因为这个动作也是ActionInterval的儿子，并且他没有上报规定的时间，而长辈FiniteTimeAction在构造函数中初始化规定的时间为0）。

Sequence(10) -- action1(10)
             |- extraaction(0)

并且这个动作在update()的时候什么也不做，您可以理解为一个空动作。
我：为什么是这么个方式？
Sequence：这与我One By One的运行动作的实现方式有关，这个实现方式还是来看代码更直观些，首先runAction()时会调用我的startWithTarget()，

void Sequence::startWithTarget(Node *target)
{
    ActionInterval::startWithTarget(target);
    /* _split代表第一个动作与第二个动作在时间上的百分比分界线。 * 比如我的_split = 34 / 40，我的第一个影分身的_split = 27 / 34，我的其他影分身的_split以此类推。 * _last代表上一次update()后执行的是第几个动作，这个值会在update()中赋值。 */
    _split = _actions[0]->getDuration() / _duration; _last = -1; // 现在还没有执行过动作，所以初始化为-1。 }

接下来动作运行起来后，ActionManager会调用我的update()，

void Sequence::update(float t)
{
    int found = 0;    // 本次需要执行第几个动作，初始化为需要执行第一个动作。
    /* 因为Sequence上报了两个动作的规定时间和，所以t是这个时间和的时间进度百分比。 * new_t的作用是存储针对于每个动作（_actions[0]或_actions[1]）的时间进度百分比。 */
    float new_t = 0.0f;

    if( t < _split ) {    // 需要执行第一个动作。
        found = 0;
        /* 如果_actions[0]上报的规定的时间就为0时，_split就等于0。 * 否则_split就是个时间上的百分比分界线。 */
        if( _split != 0 )
            new_t = t / _split;    // _actions[0]的时间进度。
        else
            new_t = 1;    // 对于没有实质的动作，进度直接是100%就好了。

    } else {    // 需要执行第二个动作。
        found = 1;
        /* 如果_actions[1]为ExtraAction或者上报的规定的时间就为0时，_split就等于1。 * 否则_split就是个时间上的百分比分界线。 */
        if ( _split == 1 )
            new_t = 1;    // 对于没有实质的动作，进度直接是100%就好了。
        else    // 如果_actions[1]非ExtraAction。
            new_t = (t-_split) / (1 - _split );    // _actions[1]的时间进度。
    }

    if ( found==1 ) {

        if( _last == -1 ) {
            // _actions[0]被跳过了（有可能在别的代码部分运行时间过长），需要直接执行完它。
            _actions[0]->startWithTarget(_target);
            if (!(sendUpdateEventToScript(1.0f,_actions[0])))
                _actions[0]->update(1.0f);
            _actions[0]->stop();
        }
        else if( _last == 0 )
        {
            // _actions[0] --> _actions[1]。
            if (!(sendUpdateEventToScript(1.0f,_actions[0])))
                _actions[0]->update(1.0f);
            _actions[0]->stop();
        }
    }
    else if(found==0 && _last==1 )    // 现在需要执行_actions[0]，但上一次执行的是_actions[1]，这种情况应该不会出现。
    {
        // Reverse mode ?
        // FIXME: 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 overridden,and the "reverseMode" value propagated to inner Sequences.
        if (!(sendUpdateEventToScript(0,_actions[1])))
            _actions[1]->update(0);    // _actions[1]复位。
        _actions[1]->stop();    // _actions[1]停止执行。
    }

     * _actions[0]执行完成不会走到这里，_actions[1]执行完成会进入这里。
    if( found == _last && _actions[found]->isDone() )    // 如果一直在执行的动作已经执行完成了。
    {
        // _actions[0]执行完成不会走到这里，_actions[1]执行完成会进入这里。
        return;
    }

    if( found != _last )    // 需要切换动作（开始执行_actions[0]或者_actions[0] --> _actions[1]）。
    {
        /* 着重看这里和下面的update()。 * 如果这个动作是Sequence，那么同样会执行这个Sequence的这么个流程， * 联系上面多个动作如何上报规定的时间看，把他们联系在一起思考。 * 如果你想通了，会发现这种调用方式有点儿像递归， * 但却不是通过不断的调用自己相同的函数而实现的，而是通过调用同胞的。 */
        _actions[found]->startWithTarget(_target);
    }
    // 如果绑定了脚本，会将时间进度和动作交给脚本，由脚本来执行动作。
    if (!(sendUpdateEventToScript(new_t,_actions[found])))
        _actions[found]->update(new_t);    // 如果没有绑定脚本就会到这里来处理，执行动作。
    _last = found;    // 存储本次执行的是第几个动作。
}

我：这种实现方式很有意思，看起来也很聪明。
Sequence：谢谢夸奖！ :)

我：下一个到谁了？
Repeat：到我了，我能将您指定的动作重复执行指定的次数。至于实现上，还是看源码来的直观些，首先创建我时我会上报规定的时间，

bool Repeat::initWithAction(FiniteTimeAction *action,unsigned int times)
{
    // 上报的规定的时间为：动作每次用时 × 执行次数。
    float d = action->getDuration() * times;

    if (ActionInterval::initWithDuration(d))
    {
        _times = times;
        _innerAction = action;
        action->retain();

        /* 这里的dynamic_cast有类型检查的作用， * 判断action是否与ActionInstant有继承关系，即action是否为瞬时动作类型。 */
        _actionInstant = dynamic_cast<ActionInstant*>(action) ? true : false;
        //an instant action needs to be executed one time less in the update method since it uses startWithTarget to execute the action
        /* 上面的这段注释可能是历史遗留问题， * 因为现在所有的瞬时动作没有用startWithTarget()执行动作的， */
        if (_actionInstant)
        {
            _times -=1;    // 我认为Repeat::update()中的issue #1288就是这里导致的。
        }
        _total = 0;

        return true;
    }

    return false;
}

接着runAction()时会调用我的startWithTarget()，

void Repeat::startWithTarget(Node *target)
{
    _total = 0;
    _nextDt = _innerAction->getDuration()/_duration;    // 存储每次动作执行完成的时间进度百分比（这里初始化为第一次的）。
    ActionInterval::startWithTarget(target);    // Repeat父类的startWithTarget()。
    _innerAction->startWithTarget(target);    // 被执行动作的startWithTarget()。
}

最后动作运行起来后，ActionManager会调用我的update()，

void Repeat::update(float dt)
{
    if (dt >= _nextDt)    // 如果本次动作执行完成。
    {
        // 本次动作执行完成并且还未超出执行次数。
        while (dt > _nextDt && _total < _times)
        {
            // 如果绑定了脚本，会将时间进度和动作交给脚本，由脚本来执行动作。
            if (!(sendUpdateEventToScript(1.0f,_innerAction)))
                _innerAction->update(1.0f);    // 让本次动作update()完成。
            _total++;    // 执行次数+1。

            _innerAction->stop();    // 本次动作结束。
            _innerAction->startWithTarget(_target);    // 重新开始。
            _nextDt = _innerAction->getDuration()/_duration * (_total+1);    // 下一次动作执行完成的时间进度百分比。
        }

        // fix for issue #1288,incorrect end value of repeat
        // 非瞬时动作不会有这个问题，瞬时动作才会有，罪魁祸首看Repeat::initWithAction()中。
        if(dt >= 1.0f && _total < _times)
        {
            _total++;
        }

        // don't set an instant action back or update it,it has no use because it has no duration
        if (!_actionInstant)    // 如果是非瞬时动作。
        {
            if (_total == _times)    // 如果整个Repeat执行完成。
            {
                /* 这里这么做是因为上面的while()在整个Repeat执行完成时没有做判断， * 又将动作重新启动了，所以这里要停止。 */
                if (!(sendUpdateEventToScript(1,_innerAction)))
                    _innerAction->update(1);
                _innerAction->stop();
            }
            else    // 如果整个Repeat还未执行完成。
            {
                // issue #390 prevent jerk,use right update
                /* 这里和下面的fmodf(dt * _times,1.0f)是一个作用，只不过是另一种实现方式。 */
                if (!(sendUpdateEventToScript(dt - (_nextDt - _innerAction->getDuration()/_duration),_innerAction)))
                    _innerAction->update(dt - (_nextDt - _innerAction->getDuration()/_duration));
            }
        }
    }
    else    // 如果本次动作还没有执行完成。
    {
        // 如果绑定了脚本，会将时间进度和动作交给脚本，由脚本来执行动作。
        if (!(sendUpdateEventToScript(fmodf(dt * _times,1.0f),_innerAction)))
            /* dt = 当前流逝时间 / （动作的_duration × _times），看Repeat上报的时间就是这个， * 所以dt × _times = 当前流逝时间 / 动作的_duration， * 所以fmodf(dt * _times,1.0f)就是针对于每次动作的时间进度百分比。 */
            _innerAction->update(fmodf(dt * _times,1.0f));    // 继续执行动作。
    }
}

我：实现的好像有些臃肿，其实我觉得可以更简单的，比如，

bool Repeat::initWithAction(FiniteTimeAction *action,unsigned int times)
{
    float d = action->getDuration() * times;

    if (ActionInterval::initWithDuration(d))
    {
        _times = times;
        _innerAction = action;
        action->retain();
        _total = 0;

        return true;
    }

    return false;
}

void Repeat::update(float dt)
{
    if (dt >= _nextDt)
    {
        while (dt > _nextDt && _total < _times)
        {
            if (!(sendUpdateEventToScript(1.0f,_innerAction)))
                _innerAction->update(1.0f);

            _innerAction->stop();
            if(++_total < _times)
            {
                _innerAction->startWithTarget(_target);
                _nextDt = _innerAction->getDuration()/_duration * (_total+1);
            }
        }
    }
    else
    {
        if (!(sendUpdateEventToScript(fmodf(dt * _times,_innerAction)))
            _innerAction->update(fmodf(dt * _times,1.0f));
    }
}

Repeat：嗯，好的，希望设计者能看到。
我：我看到了个和你长得很像的家伙。
RepeatForever：您是在说我吗？我的确和Repeat的功能类似，我可以让您指定的动作永远重复运行下去。
我：哦？说来听听。
RepeatForever：我的实现与Repeat不同，我不上报规定的时间，而是重写了老爸的step()由我自己来管理时间，

void RepeatForever::step(float dt)    // 注意这里传入的是从上一帧到这一帧流逝的时间。
{
    /* 让具体动作的老爸管理他的孩子的时间。 * 本次动作未执行完成，ActionManager不停的调用RepeatForever::step()， * RepeatForever::step()不停的调用具体动作的step()。 */
    _innerAction->step(dt);
    if (_innerAction->isDone())    // 本次动作执行完成。
        /* 以下对于diff的计算以及使用均是为了防止抖动(jerk)。 * 但具体抖动是什么样的我没有研究过。 */
         // 动作刚刚执行完成时getElapsed()会比getDuration()大一点点，isDone()就是据此判断动作是否执行完成的。
        float diff = _innerAction->getElapsed() - _innerAction->getDuration();
        if (diff > _innerAction->getDuration())    // 如果跳过了多次动作（有可能是在别的地方执行时间过长）。
            diff = fmodf(diff,_innerAction->getDuration());    // 忽略跳过的动作。
        _innerAction->startWithTarget(_target);    // 动作重新开始。
        // to prevent jerk. issue #390,1247
        // 由于是永远重复执行，所以两次动作的衔接要连贯，diff这点时间也要step()一下。
        _innerAction->step(0.0f);
        _innerAction->step(diff);
    }
}

我：实现的层面不同，不过我觉得你俩既然功能类似，还是应该合并在一起，实现上往相同的模式转化更合理。

我：还有两位，不要害羞，也来说两句吧。
DelayTime：到Zzz我了Zzz，我的Zzz作Zzz用Zzz是睡觉。您Zzz让我Zzz睡多久Zzz我Zzz就睡Zzz多Zzz久Zzzzzz（进入深度睡眠…）。
我：看出来了…，我说你现在先不要睡了…
DelayTime：好的，您给我规定的睡眠时间是以秒为单位的。我在实现上也非常的简单，总之一句话，就是什么都不做。您告诉我的规定的时间直接交给老爸，update()中也什么都不做。
我：好了…，你可以继续睡了。
DelayTime：好的。（瞬间进入深度睡眠中…）
我：最后就剩你了，ReverseTime。
ReverseTime：来了。我的作用有点儿像时光机，能让时光倒流。举个例子，

// 假设sprite的初始位置为(10,10)。
auto moveby = MoveBy::create(3,Vec2(100,100));
/* 本来moveby是让sprite在3秒内从(10,10)移动到(110,110)， * 而经过我手之后，sprite将会在3秒内从(100,100)移动到(10,10)。 * 这里可以对比moveby->reverse()，效果是不一样的哦。 */
sprite->runAction(ReverseTime::create(moveby));

而我的实现上也很简单，创建一个您提供的动作的分身，然后传递给他总时间进度与当前时间进度百分比的差值，

_other->update(1 - time);

不过为什么要创建个动作的分身我也没有搞明白，嘿嘿。
我：你俩的实现倒都是很简单。今天聊了很多，先暂时到这里。