cocos2d-x CCAction动作学习笔记

1、ActionManual中设置三个精灵的放缩，旋转，颜色和位置

m_tamara->setScaleX( 2.5f);
    m_tamara->setScaleY( -1.0f);
    m_tamara->setPosition( ccp(100,70) );
    m_tamara->setOpacity( 128);

    m_grossini->setRotation( 120);
    m_grossini->setPosition( ccp(s.width/2, s.height/2));
    m_grossini->setColor( ccc3( 255,0,0));

    m_kathia->setPosition( ccp(s.width-100, s.height/2));
    m_kathia->setColor( ccBLUE);
           

2、ActionMove移动处理

centerSprites(3);
    CCSize s = CCDirector::sharedDirector()->getWinSize();
    -- 分别创建CCMoveTo，CCMoveBy动作
    CCActionInterval*  actionTo = CCMoveTo::create(2, ccp(s.width-40, s.height-40));
    CCActionInterval*  actionBy = CCMoveBy::create(2, ccp(80,80));
    CCActionInterval*  actionByBack = actionBy->reverse();
    -- 三个精灵分别执行各自的动作
    m_tamara->runAction( actionTo);
    m_grossini->runAction( CCSequence::create(actionBy, actionByBack, NULL));
    m_kathia->runAction(CCMoveTo::create(1, ccp(40,40)));
           

3、ActionScale放缩处理

centerSprites(3);
    -- 创建CCScaleTo，CCScaleBy动作
    CCActionInterval*  actionTo = CCScaleTo::create(2.0f, 0.5f);
    CCActionInterval*  actionBy = CCScaleBy::create(2.0f, 1.0f, 10.0f);
    CCActionInterval*  actionBy2 = CCScaleBy::create(2.0f, 5.0f, 1.0f);
    m_grossini->runAction( actionTo);
    m_tamara->runAction( CCSequence::create(actionBy, actionBy->reverse(), NULL));
    m_kathia->runAction( CCSequence::create(actionBy2, actionBy2->reverse(), NULL));
           

4、创建CCSkewTo动作，参数对应变换时间，x扭曲，y扭曲

// static CCSkewTo* create(float t, float sx, float sy);
// static CCSkewBy* create(float t, float deltaSkewX, float deltaSkewY);
// CCSequence* CCSequence::create(CCFiniteTimeAction *pAction1, ...) 创建可变数目的一系列动作
    CCActionInterval *actionTo = CCSkewTo::create(2, 37.2f, -37.2f);
    CCActionInterval *actionToBack = CCSkewTo::create(2, 0, 0);
    CCActionInterval *actionBy = CCSkewBy::create(2, 0.0f, -90.0f);
    CCActionInterval *actionBy2 = CCSkewBy::create(2, 45.0f, 45.0f);
    CCActionInterval *actionByBack = actionBy->reverse();
    m_tamara->runAction(CCSequence::create(actionTo, actionToBack, NULL));
    m_grossini->runAction(CCSequence::create(actionBy, actionByBack, NULL));
    m_kathia->runAction(CCSequence::create(actionBy2, actionBy2->reverse(), NULL));
           

5、创建ActionRotationalSkew变换，fDuration时间内，X方向旋转变化fDeltaAngleX，Y方向旋转变化fDeltaAngleY

// CCRotateTo* CCRotateTo::create(float fDuration, float fDeltaAngleX, float fDeltaAngleY)
// CCRotateBy* CCRotateBy::create(float fDuration, float fDeltaAngleX, float fDeltaAngleY)
    CCRotateTo* actionTo = CCRotateTo::create(2, 37.2f, -37.2f);
    CCRotateTo* actionToBack = CCRotateTo::create(2, 0, 0);
    CCRotateBy* actionBy = CCRotateBy::create(2, 0.0f, -90.0f);
    CCRotateBy* actionBy2 = CCRotateBy::create(2, 45.0f, 45.0f);
    CCRotateBy* actionByBack = (CCRotateBy*)actionBy->reverse();

    m_tamara->runAction(CCSequence::create(actionTo, actionToBack, NULL));
    m_grossini->runAction(CCSequence::create(actionBy, actionByBack, NULL));
    m_kathia->runAction(CCSequence::create(actionBy2, actionBy2->reverse(), NULL));
           

6、ActionRotationalSkewVSStandardSkew旋转扭曲与标准扭曲对比

CCSize s = CCDirector::sharedDirector()->getWinSize();
    CCSize boxSize = CCSizeMake(100.0f, 100.0f);
// 创建一个CCLayerColor层颜色:ccc4(255,255,0,255),设置锚点，内容大小，开启锚点有效，然后把它加入到场景中
    CCLayerColor *box = CCLayerColor::create(ccc4(255,255,0,255));
    box->setAnchorPoint(ccp(0.5,0.5));
    box->setContentSize( boxSize );
    box->ignoreAnchorPointForPosition(false);
    box->setPosition(ccp(s.width/2, s.height - 100 - box->getContentSize().height/2));
    this->addChild(box);
// 添加描述性文字，1:显示字符串，2:字体名称，3:字体大小
// CCLabelTTF * CCLabelTTF::create(const char *string, const char *fontName, float fontSize)
    CCLabelTTF *label = CCLabelTTF::create("Standard cocos2d Skew", "Marker Felt", 16);
    label->setPosition(ccp(s.width/2, s.height - 100 + label->getContentSize().height));
    this->addChild(label);
// 创建动作序列 ，对应Standard cocos2d Skew
    CCSkewBy* actionTo = CCSkewBy::create(2, 360, 0);
    CCSkewBy* actionToBack = CCSkewBy::create(2, -360, 0);
    box->runAction(CCSequence::create(actionTo, actionToBack, NULL));

    box = CCLayerColor::create(ccc4(255,255,0,255));
    box->setAnchorPoint(ccp(0.5,0.5));
    box->setContentSize(boxSize);
    box->ignoreAnchorPointForPosition(false);
    box->setPosition(ccp(s.width/2, s.height - 250 - box->getContentSize().height/2));
    this->addChild(box);
    label = CCLabelTTF::create("Rotational Skew", "Marker Felt", 16);
    label->setPosition(ccp(s.width/2, s.height - 250 + label->getContentSize().height/2));
    this->addChild(label);
// 创建动作序列，对应Rotational Skew
    CCRotateBy* actionTo2 = CCRotateBy::create(2, 360, 0);
    CCRotateBy* actionToBack2 = CCRotateBy::create(2, -360, 0);
    box->runAction(CCSequence::create(actionTo2, actionToBack2, NULL));
           

7、ActionSkewRotateScale创建不同动作的组合

CCSize boxSize = CCSizeMake(100.0f, 100.0f);
// 创建一个box层用来执行动画序列
    CCLayerColor *box = CCLayerColor::create(ccc4(255, 255, 0, 255));
    box->setAnchorPoint(ccp(0, 0));
    box->setPosition(ccp(190, 110));
    box->setContentSize(boxSize);
// 创建两个小格子，红色左边，蓝色右边
    static float markrside = 10.0f;
    CCLayerColor *uL = CCLayerColor::create(ccc4(255, 0, 0, 255));
    box->addChild(uL);
    uL->setContentSize(CCSizeMake(markrside, markrside));
    uL->setPosition(ccp(0.f, boxSize.height - markrside));
    uL->setAnchorPoint(ccp(0, 0));

    CCLayerColor *uR = CCLayerColor::create(ccc4(0, 0, 255, 255));
    box->addChild(uR);
    uR->setContentSize(CCSizeMake(markrside, markrside));
    uR->setPosition(ccp(boxSize.width - markrside, boxSize.height - markrside));
    uR->setAnchorPoint(ccp(0, 0));
    addChild(box);
// 创建扭曲，旋转，放缩的动作序列
    CCActionInterval *actionTo = CCSkewTo::create(2, 0.f, 2.f);
    CCActionInterval *rotateTo = CCRotateTo::create(2, 61.0f);
    CCActionInterval *actionScaleTo = CCScaleTo::create(2, -0.44f, 0.47f);

    CCActionInterval *actionScaleToBack = CCScaleTo::create(2, 1.0f, 1.0f);
    CCActionInterval *rotateToBack = CCRotateTo::create(2, 0);
    CCActionInterval *actionToBack = CCSkewTo::create(2, 0, 0);
// 这里让颜色层同时执行三个动画，runAction会把动作对象和主角传给动画管理器，这些动画会存入相应的动画集，动画管理器会在每一帧更新相应的动画，
// 虽然他们是动画序列但本身仍然是动画，所以多次调用runAction会将多个动画或动画序列同时播放
    box->runAction(CCSequence::create(actionTo, actionToBack, NULL));
    box->runAction(CCSequence::create(rotateTo, rotateToBack, NULL));
    box->runAction(CCSequence::create(actionScaleTo, actionScaleToBack, NULL));
           

8、旋转动作序列，时间-旋转角度

// CCRotateTo* CCRotateTo::create(float fDuration, float fDeltaAngle)
// CCRotateBy* CCRotateBy::create(float fDuration, float fDeltaAngle)
    CCActionInterval*  actionTo = CCRotateTo::create( 2, 45);
    CCActionInterval*  actionTo2 = CCRotateTo::create( 2, -45);
    CCActionInterval*  actionTo0 = CCRotateTo::create(2 , 0);
    m_tamara->runAction( CCSequence::create(actionTo, actionTo0, NULL));

    CCActionInterval*  actionBy = CCRotateBy::create(2 ,  360);
    CCActionInterval*  actionByBack = actionBy->reverse();
    m_grossini->runAction( CCSequence::create(actionBy, actionByBack, NULL));
    m_kathia->runAction( CCSequence::create(actionTo2, actionTo0->copy()->autorelease(), NULL));
           

9、跳动动画序列，时间-位置点-跳跃高度-跳跃次数(to:跳到position，by:相对于当前位置跳转position标示的相对位置)

// CCJumpTo* CCJumpTo::create(float duration, const CCPoint& position, float height, int jumps)
// CCJumpBy* CCJumpBy::create(float duration, const CCPoint& position, float height, unsigned int jumps)
    CCActionInterval*  actionTo = CCJumpTo::create(2, ccp(300,300), 50, 4);
    CCActionInterval*  actionBy = CCJumpBy::create(2, ccp(300,0), 50, 4);
    CCActionInterval*  actionUp = CCJumpBy::create(2, ccp(0,0), 80, 4);
    CCActionInterval*  actionByBack = actionBy->reverse();

    m_tamara->runAction( actionTo);
    m_grossini->runAction( CCSequence::create(actionBy, actionByBack, NULL));
    m_kathia->runAction( CCRepeatForever::create(actionUp));
           

10、贝塞尔曲线动作序列ActionBezier 

// CCBezierBy* CCBezierBy::create(float t, const ccBezierConfig& c)		时间-贝塞尔参数创建贝塞尔曲线动作序列
// CCRepeatForever *CCRepeatForever::create(CCActionInterval *pAction)		根据CCActionInterval对象创建永久性动作
    // 设置贝塞尔曲线的控制参数，控制点1-控制点2-结束点
    ccBezierConfig bezier;
    bezier.controlPoint_1 = ccp(0, s.height/2);
    bezier.controlPoint_2 = ccp(300, -s.height/2);
    bezier.endPosition = ccp(300,100);

    CCActionInterval*  bezierForward = CCBezierBy::create(3, bezier);
    CCActionInterval*  bezierBack = bezierForward->reverse();    
    CCAction*  rep = CCRepeatForever::create(CCSequence::create( bezierForward, bezierBack, NULL));
    m_grossini->runAction( rep);
           

11、闪烁动画序列ActionBlink 时间-闪烁次数

// CCBlink* CCBlink::create(float duration, unsigned int uBlinks)
    CCActionInterval*  action1 = CCBlink::create(2, 2);
    CCActionInterval*  action2 = CCBlink::create(2, 10);

    m_tamara->runAction( action1);
    m_kathia->runAction(action2);
           

12、消隐动作序列CCFadeIn

// CCFadeIn* CCFadeIn::create(float d)			淡入(时间)
// CCFadeOut* CCFadeOut::create(float d)		淡出(时间)
    CCActionInterval*  action1 = CCFadeIn::create(1.0f);
    CCActionInterval*  action1Back = action1->reverse();
    CCActionInterval*  action2 = CCFadeOut::create(1.0f);
    CCActionInterval*  action2Back = action2->reverse();

    m_tamara->runAction( CCSequence::create( action1, action1Back, NULL));
    m_kathia->runAction( CCSequence::create( action2, action2Back, NULL));
           

13、色调调节CCTintTo/CCTintBy

// static CCTintTo* create(float duration, GLubyte red, GLubyte green, GLubyte blue);					时间-rgb颜色
// static CCTintBy* create(float duration, GLshort deltaRed, GLshort deltaGreen, GLshort deltaBlue);	时间-rgb颜色
    CCActionInterval*  action1 = CCTintTo::create(2, 255, 0, 255);
    CCActionInterval*  action2 = CCTintBy::create(2, -127, -255, -127);
    CCActionInterval*  action2Back = action2->reverse();

    m_tamara->runAction( action1);
    m_kathia->runAction( CCSequence::create( action2, action2Back, NULL));
           

14、ActionAnimate动画效果

// static CCAnimation* create(void);							创建动画效果
// void addSpriteFrameWithFileName(const char *pszFileName);	根据文件名创建精灵帧，并加入到动画序列中，有一定的时延
// static CCAnimate* create(CCAnimation *pAnimation);			根据动画创建动作序列，能恢复到最初的精灵帧
// void addAnimationsWithFile(const char* plist);				根据给定的plist文件添加一个动画序列
// CCAnimation* animationByName(const char* name);				根据文件名获取之前添加的动画序列
// 定义一个来创建保护成员变量，和它的一套获取设置方，方便快捷的设置对象的属性
// #define CC_SYNTHESIZE(varType, varName, funName)\
// protected: varType varName;\
// public: virtual varType get##funName(void) const { return varName; }\
// public: virtual void set##funName(varType var){ varName = var; }
           

CCAnimation* animation = CCAnimation::create();
    for( int i=1;i<15;i++)
    {
        char szName[100] = {0};
        sprintf(szName, "Images/grossini_dance_%02d.png", i);
        animation->addSpriteFrameWithFileName(szName);
    }
    // 设置每个精灵帧的时延为2.8f / 14.0f,并恢复到最初的精灵帧
    animation->setDelayPerUnit(2.8f / 14.0f);
    animation->setRestoreOriginalFrame(true);
    //根据动画创建动作序列用来执行实际的动作
    CCAnimate* action = CCAnimate::create(animation);
    m_grossini->runAction(CCSequence::create(action, action->reverse(), NULL));
    
    //从plist文件创建动画效果
    CCAnimationCache *cache = CCAnimationCache::sharedAnimationCache();
    cache->addAnimationsWithFile("animations/animations-2.plist");
    CCAnimation *animation2 = cache->animationByName("dance_1");

    CCAnimate* action2 = CCAnimate::create(animation2);
    m_tamara->runAction(CCSequence::create(action2, action2->reverse(), NULL));

    //设置循环4次
    CCAnimation *animation3 = (CCAnimation *)animation2->copy()->autorelease();
    animation3->setLoops(4);
    CCAnimate* action3 = CCAnimate::create(animation3);
    m_kathia->runAction(action3);
           

15、动作序列创建

// CCSequence* CCSequence::create(CCFiniteTimeAction *pAction1, ...)	创建可变动个数的动作序列
    CCFiniteTimeAction*  action = CCSequence::create(
        CCMoveBy::create( 2, ccp(240,0)),
        CCRotateBy::create( 2,  540),
        NULL);

    m_grossini->runAction(action);
动作完成之后处理不同的函数
// static CCPlace * create(const CCPoint& pos);														创建节点在pos位置
// static CCShow * create();																		创建节点，并初始化
// static CCCallFunc * create(CCObject* pSelectorTarget, SEL_CallFunc selector);					创建动作附带的回调函数，无参
// static CCCallFuncN * create(CCObject* pSelectorTarget, SEL_CallFuncN selector);					创建动作附带的回调函数，节点对象
// static CCCallFuncND * create(CCObject* pSelectorTarget, SEL_CallFuncND selector, void* d);		创建动作附带的回调函数，节点对象-数据
    CCFiniteTimeAction*  action = CCSequence::create(
    CCPlace::create(ccp(200,200)),
    CCShow::create(),
    CCMoveBy::create(1, ccp(100,0)),
    CCCallFunc::create(this, callfunc_selector(ActionSequence2::callback1)),
    CCCallFuncN::create(this, callfuncN_selector(ActionSequence2::callback2)),
    CCCallFuncND::create(this, callfuncND_selector(ActionSequence2::callback3), (void*)0xbebabeba),
    NULL);

    m_grossini->runAction(action);

对应的三个回调函数，我们可在里面进行相应的处理
void ActionSequence2::callback1()
void ActionSequence2::callback2(CCNode* sender)
void ActionSequence2::callback3(CCNode* sender, void* data)
           

16、连续的动作序列

// static CCSpawn* create(CCFiniteTimeAction *pAction1, ...);	传入动作序列，他会同时执行这几个动作
    CCAction*  action = CCSpawn::create(
        CCJumpBy::create(2, ccp(300,0), 50, 4),
        CCRotateBy::create( 2,  720),
        NULL);

    m_grossini->runAction(action);
           

17、逆序动作序列ActionReverse

// virtual CCActionInterval* reverse(void);	返回这个动作序列的逆序列
    CCActionInterval*  jump = CCJumpBy::create(2, ccp(300,0), 50, 4);
    CCFiniteTimeAction*  action = CCSequence::create( jump, jump->reverse(), NULL);
    m_grossini->runAction(action);
           

18、重复性的序列动作

// static CCRepeat* create(CCFiniteTimeAction *pAction, unsigned int times);	要重复的动作序列-次数
// static CCRepeatForever* create(CCActionInterval *pAction);					一直持续性的动作序列
    CCActionInterval*  a1 = CCMoveBy::create(1, ccp(150,0));
    CCActionInterval*  action1 = CCRepeat::create(
        CCSequence::create( CCPlace::create(ccp(60,60)), a1, NULL) , 
        3); 
    CCAction*  action2 = CCRepeatForever::create(
        CCSequence::create((CCActionInterval*)(a1->copy()->autorelease()), a1->reverse(), NULL)
        );
    m_kathia->runAction(action1);
    m_tamara->runAction(action2);
           

19、延时性的动作序列

// static CCDelayTime* create(float d);		延迟的时间，单位:秒
    CCActionInterval*  move = CCMoveBy::create(1, ccp(150,0));
    CCFiniteTimeAction*  action = CCSequence::create( move, CCDelayTime::create(2), move, NULL);
           

m_grossini->runAction(action);
           

20、逆序的一组动作序列

// 这里的CCSequence本质上还是一个动作序列，虽然他包括了一组的动作序列，所以我们可以对他直接取逆序操作
    CCActionInterval*  move1 = CCMoveBy::create(1, ccp(250,0));
    CCActionInterval*  move2 = CCMoveBy::create(1, ccp(0,50));
    CCFiniteTimeAction*  seq = CCSequence::create( move1, move2, move1->reverse(), NULL);
    CCFiniteTimeAction*  action = CCSequence::create( seq, seq->reverse(), NULL);
    m_grossini->runAction(action);

    //   一组动作序列包括IntervalAction和InstantActions两种
    // class CC_DLL CCToggleVisibility : public CCActionInstant	转变节点的可见性，new出来的要自动释放(显示调用autorelease)
    CCActionInterval*  move1 = CCMoveBy::create(1, ccp(250,0));
    CCActionInterval*  move2 = CCMoveBy::create(1, ccp(0,50));
    CCToggleVisibility*  tog1 = new CCToggleVisibility();
    CCToggleVisibility*  tog2 = new CCToggleVisibility();
    tog1->autorelease();
    tog2->autorelease();
    CCFiniteTimeAction*  seq = CCSequence::create( move1, tog1,tog2, move2,  move1->reverse(), NULL);
    CCActionInterval*  action = CCRepeat::create(CCSequence::create( seq, seq->reverse(), NULL), 3);
    m_kathia->runAction(action);

    //   class CC_DLL CCHide : public CCActionInstant 用来隐藏一个节点
    CCActionInterval*  move_tamara = CCMoveBy::create(1, ccp(100,0));
    CCActionInterval*  move_tamara2 = CCMoveBy::create(1, ccp(50,0));
    CCActionInstant*  hide = CCHide::create();
    CCFiniteTimeAction*  seq_tamara = CCSequence::create( move_tamara, hide, move_tamara2, NULL);
    CCFiniteTimeAction*  seq_back = seq_tamara->reverse();
    m_tamara->runAction( CCSequence::create( seq_tamara, seq_back, NULL));
           

21、创建一个球面坐标轨迹进行的旋转动作序列

// 参数:旋转轨迹的时间差-起始半径-半径差-起始z角-旋转z角差-起始x角-旋转x角差
// static CCOrbitCamera* create(float t, float radius, float deltaRadius, float angleZ, float deltaAngleZ, float angleX, float deltaAngleX);

    CCActionInterval*  orbit1 = CCOrbitCamera::create(2,1, 0, 0, 180, 0, 0);
    CCSequence*  action1 = CCSequence::create(
        orbit1,
        orbit1->reverse(),
        NULL);
	m_kathia->runAction(CCRepeatForever::create(action1));

    CCActionInterval*  move = CCMoveBy::create(3, ccp(100,-100));
    CCActionInterval*  move_back = move->reverse();
    CCSequence*  seq = CCSequence::create(move, move_back, NULL);
    CCAction*  rfe = CCRepeatForever::create(seq);
    m_kathia->runAction(rfe);
           

22、移除节点动作

// static CCRemoveSelf * create(bool isNeedCleanUp = true);	移除自身，并默认清空自身
	CCFiniteTimeAction*  action = CCSequence::create(
		CCMoveBy::create( 2, ccp(240,0)),
		CCRotateBy::create( 2,  540),
		CCScaleTo::create(1,0.1f),
		CCRemoveSelf::create(),
		NULL);
	m_grossini->runAction(action);
           

23、ActionRepeatForever重复动作放在动作的毁掉函数中

CCFiniteTimeAction*  action = CCSequence::create(
        CCDelayTime::create(1),
        CCCallFuncN::create( this, callfuncN_selector(ActionRepeatForever::repeatForever) ), 
        NULL);

    m_grossini->runAction(action);
// 回调加入永远执行的旋转动作
void ActionRepeatForever::repeatForever(CCNode* pSender)
{
    CCRepeatForever *repeat = CCRepeatForever::create( CCRotateBy::create(1.0f, 360) );
    pSender->runAction(repeat);
}
// 旋转的重复动作
    CCActionInterval*  act1 = CCRotateTo::create(1, 90);
    CCActionInterval*  act2 = CCRotateTo::create(1, 0);
    CCActionInterval*  seq = CCSequence::create(act1, act2, NULL);
    CCAction*  rep1 = CCRepeatForever::create(seq);
    m_tamara->runAction(rep1);
           

24、创建跟随动作CCFollow

// static CCFollow* create(CCNode *pFollowedNode, const CCRect& rect = CCRectZero);    创建跟随动作序列，在指定的矩形区域中
    CCSize s = CCDirector::sharedDirector()->getWinSize();
    m_grossini->setPosition(ccp(-200, s.height / 2));
    // 创建相对移动的动作序列
    CCActionInterval* move      = CCMoveBy::create(2, ccp(s.width * 3, 0));
    CCActionInterval* move_back = move->reverse();
    CCSequence* seq       = CCSequence::create(move, move_back, NULL);
    CCAction* rep               = CCRepeatForever::create(seq);
    m_grossini->runAction(rep);
    // 在指定的区域CCRectMake跟随精灵m_grossini，
    this->runAction(CCFollow::create(m_grossini, CCRectMake(0, 0, s.width * 2 - 100, s.height)));

    // 绘制精灵移动的部分举行区域
    void ActionFollow::draw()
    {
        CCSize winSize = CCDirector::sharedDirector()->getWinSize();
        
        float x = winSize.width*2 - 100;
        float y = winSize.height;
        
        CCPoint vertices[] = { ccp(5,5), ccp(x-5,5), ccp(x-5,y-5), ccp(5,y-5) };
        ccDrawPoly(vertices, 4, true);
    }
           

25、创建指定节点对象的动作序列，可以使两个对象按照顺序演示动作序列

// static CCTargetedAction* create(CCNode* pTarget, CCFiniteTimeAction* pAction);  根据一个节点对象和动作序列创建，把动作序列绑定到节点对象
    CCJumpBy* jump1 = CCJumpBy::create(2,CCPointZero,100,3);
    CCJumpBy* jump2 = (CCJumpBy*)jump1->copy()->autorelease();
    CCRotateBy* rot1 =  CCRotateBy::create(1, 360);
    CCRotateBy* rot2 = (CCRotateBy*)rot1->copy()->autorelease();
// 把jump2和rot2动作序列绑定到精灵m_kathia
    CCTargetedAction *t1 = CCTargetedAction::create(m_kathia, jump2);
    CCTargetedAction *t2 = CCTargetedAction::create(m_kathia, rot2);
    CCSequence* seq = (CCSequence*)CCSequence::create(jump1, t1, rot1, t2, NULL);
    CCRepeatForever *always = CCRepeatForever::create(seq);
    m_tamara->runAction(always);
           

26、添加震动的精灵动作序列

// static CCTargetedAction* create(CCNode* pTarget, CCFiniteTimeAction* pAction);  根据一个节点对象和动作序列创建，把动作序列绑定到节点对象
    CCJumpBy* jump1 = CCJumpBy::create(2,CCPointZero,100,3);
    CCJumpBy* jump2 = (CCJumpBy*)jump1->copy()->autorelease();
    CCRotateBy* rot1 =  CCRotateBy::create(1, 360);
    CCRotateBy* rot2 = (CCRotateBy*)rot1->copy()->autorelease();
// 把jump2和rot2动作序列绑定到精灵m_kathia
    CCTargetedAction *t1 = CCTargetedAction::create(m_kathia, jump2);
    CCTargetedAction *t2 = CCTargetedAction::create(m_kathia, rot2);
    CCSequence* seq = (CCSequence*)CCSequence::create(jump1, t1, rot1, t2, NULL);
    CCRepeatForever *always = CCRepeatForever::create(seq);
    m_tamara->runAction(always);
           

27、添加暂停，重新执行动作序列处理

// 在3秒暂停旋转动作，5s恢复动作序列
    m_tamara->runAction(CCRepeatForever::create(CCRotateBy::create(3, 360)));
    m_grossini->runAction(CCRepeatForever::create(CCRotateBy::create(3, -360)));
    m_kathia->runAction(CCRepeatForever::create(CCRotateBy::create(3, 360)));
    
    this->schedule(schedule_selector(PauseResumeActions::pause), 3, false, 0);
    this->schedule(schedule_selector(PauseResumeActions::resume), 5, false, 0);

void PauseResumeActions::pause(float dt)
{
    // 暂停所有的运行动作
    CCLog("Pausing");
    CCDirector *director = CCDirector::sharedDirector();
    CC_SAFE_RELEASE(m_pPausedTargets);
    m_pPausedTargets = director->getActionManager()->pauseAllRunningActions();
    CC_SAFE_RETAIN(m_pPausedTargets);
}

void PauseResumeActions::resume(float dt)
{
    // 恢复所有的动作序列的执行
    CCLog("Resuming");
    CCDirector *director = CCDirector::sharedDirector();
    director->getActionManager()->resumeTargets(m_pPausedTargets);
}