cocos2d-x动画加速与减速（转载）

最近的游戏学习中使用到精灵运动的加速与减速，于是征集了一些权威的文章供参考。

---

文章一：

cocos2d-x动画加速与减速

动画是游戏的必然要素之一，在整个游戏过程中，又有着加速、减速动画的需求。以塔防为例子，布塔的时候希望能够将游戏减速，布好塔后，则希 望能将游戏加速；当某个怪被冰冻后，移动速度减缓，而其他怪的移动速度不变。cocos2d-x引擎为我们提供了很强大的接口，下面就将我实验的过程复述 一遍，也方便他人。

1）实现全局的加速、减速。

通过设置Scheduler的timeScale，可以实现全局的加、减速。代码非常简单：
CCScheduler* pScheduler = CCDirector::sharedDirector()->getScheduler();
pScheduler->setTimeScale(2.0f); //实现加速效果
pScheduler->setTimeScale(0.5f);//实现减速效果

 

2）实现对某个CCActionInterval动作的加速、减速

方法一：很容易想到的一个方法就是改变CCAnimation的delay unit。代码如下：

CCAnimation* pAnimation = CCAnimationCache::sharedAnimationCache()->animationByName(“xxx”);

pAnimation->setDelayUnit(pAnimation->getDelayUnit()*0.2f); //速度为原来的5倍

这个方法有一个缺点：改变了CCAnimationCache中这个animation的delay unit。也就是说以后即使再从CCAnimationCache中获取这个animation，其delay unit已经是原来的0.2倍了。

 

方法二：cocos2d-x提供了CCSpeed的类，可以实现动画速度的调节。用法如下：

CCActionInterval* pActionInterval = CCMoveTo::create(5.0f, ccp(500.0f, 100.0f));

CCSpeed* pSpeed= CCSpeed::create(pActionInterval, 1.5f); //1.5倍速运行

CCSpeed* pSpeed1 = CCSpeed::create(pActionInterval, 0.2f);// 0.2倍速运行

pSprite->runAction(pSpeed);

注意，如果pSprite有已经运行的动作，要用pSprite->stopActionByTag()停掉之前的动作，不然两个动作就叠加到一起了。

—————————————————————–华丽丽的分割线————————————————————————–

来自HIMI的提示：

很多时候你的主角的动作利用CCAction来实现，移动则是在update刷帧函 数或者一些选择器的方法中进行的，那么为了让你的主角慢动作比较逼真，那么Himi建议不要使用scheduleUpdate函数,因为这个你无法修改每 次调用update的时间默认都是每帧都调用，那么你应该自己定义一个选择器当刷逻辑的函数，这样就能配合CCSpeed实现逼真慢动作拉～

3）对某个CCFiniteTimeAction类型动作的加速、减速

大部分时候，一个游戏人物的动作并非由单一一个CCActionInterval类型的动作构成，而是一串动作连起来，构成一个Sequence。 用CCSequence::create(…)创建的对象都是CCFinteTimeAction类型的，CCSpeed并不适用。在CCSpeed类的 说明里，明确指 出”This action can’t be Sequenceable because it is not an CCIntervalAction”。 那对于Sequence就束手无策了吗？非也。cocos2d-x引擎自带例子中，schedulerTest给我们展示了如何控制某个sprite的 scheduler的timescale。废话少说，直接看代码。

在class TwoSchedulers中定义了两个customer的scheduler和两个CCActionManager。
CCScheduler *sched1;
CCScheduler *sched2;
CCActionManager *actionManager1;
CCActionManager *actionManager2;

在onEnter函数中，分别对两个sprite设置customer的ActionManager.
CCScheduler *defaultScheduler = CCDirector::sharedDirector()->getScheduler();
// Create a new scheduler, and link it to the main scheduler
sched1 = new CCScheduler();
defaultScheduler->scheduleUpdateForTarget(sched1, 0, false);
// Create a new ActionManager, and link it to the new scheudler
actionManager1 = new CCActionManager();
sched1->scheduleUpdateForTarget(actionManager1, 0, false);
// Replace the default ActionManager with the new one.
pSprite1->setActionManager(actionManager1);

通过以上的代码，就可以通过改变sched1的timescale来改变pSprite1的动作的快慢了。有了这种方法，那么就可以放弃CCSpeed的那种方法了。

---

文章二：

在实现运动中，我们常常需要实现一些加速度或者减速度的效果，cocos2d-x引擎为我们提供了相应的实现接口，这样我们就不用再用原来的公式计算方法来实现加减速度的效果

Ease系列的方法改变了运动的速度，但是并没有改变总体时间，如果整个的action持续5秒钟，那么整个的时间仍然会持续5秒钟。

这些action可以被分成3类：

In actions: action开始的时候加速

Out actions: action结束的时候加速

InOut actions: action开始，结束的时候加速

第一个参数为要加减速度的动作，第二个为加减的速率

还有一些特殊的缓冲公式继承了进来

1.指数缓冲

 

EaseExponentialIn

EaseExponentialOut

EaseExponentialInOut

2.赛因缓冲

 

EaseSineIn

EaseSineOut

EaseSineInOut

 

3.弹性缓冲

 

EaseElasticIn

EaseElasticOut

EaseElasticInOut

4.跳跃缓冲

 

EaseBounceIn

EaseBounceOut

EaseBounceInOut

5.回震缓冲

 

EaseBackIn

EaseBackOut

EaseBackInOut

另外还可以设置速度的倍数

通过把动作定义为CCSpeed并改变速度，使用setSpeed将速度按参数的倍数变大或者缩小,这样可以手动实现加减速度

---

文章三： 移动开发:Cocos2d-x 2.0变速动画深入分析

变 速动画都是由时间动画所衍生出来的，它是通过对一个匀速动画的进度进行调节来实现的，所以你要运行一个变速动画，首先要给他指定一个匀速动画，播放这个变 速动画，它也播放被指定的匀速动画，在变速动画的更新函数中对被指定的匀速动画通过一个变速曲线计算得到相应的播放进度，变速动画停止播放时，被指定的匀 速动画也必须被停止。所以，变速动画其实就是一个控制器，用来控制一个匀速动画的播放进度，使其产生变速的效果。

      为了讲述好本节，我专门写了一个曲线生成工具，这样可以更直观的看到变速曲线的形态。有兴趣的可以到我的群里下载这个工具。

      打开CActionEase.h:

[cpp]   view plain copy

 #ifndef __ACTION_CCEASE_ACTION_H__
 #define __ACTION_CCEASE_ACTION_H__

 #include "CCActionInterval.h"
 //使用Cocos2d命名空间
 NS_CC_BEGIN
 //要用到以下两个类
 class CCObject;
 class CCZone;

 //所有变速动画的基类。
 class CC_DLL CCActionEase : public CCActionInterval
 {
 public:
     //析构
     virtual ~CCActionEase(void);

     //初始化动画，参数为一个匀速时间动画。
     bool initWithAction(CCActionInterval *pAction);
     //产生一个当前实例的拷贝。
 　　virtual CCObject* copyWithZone(CCZone* pZone);
 　　//指定演示当前动画的演员。
 　　virtual void startWithTarget(CCNode *pTarget);
 　　//停止当前动画。
 　　virtual void stop(void);
 　　//更新动画。
 　　virtual void update(float time);
 　　　//创建一个反向播放的当前动画。
 　　 virtual CCActionInterval* reverse(void);

 public:
     //静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
     CC_DEPRECATED_ATTRIBUTE static CCActionEase* actionWithAction(CCActionInterval *pAction);

     //同上
     static CCActionEase* create(CCActionInterval *pAction);

 protected:
     //保存对应的匀速动画。
     CCActionInterval *m_pOther;
 };

对应CPP：

[cpp]   view plain copy

 //静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
 CCActionEase* CCActionEase::actionWithAction(CCActionInterval *pAction)
 {
     return CCActionEase::create(pAction);
 }
 //同上
 CCActionEase* CCActionEase::create(CCActionInterval *pAction)
 {
 　　//使用new创建一个当前类实例.
     CCActionEase *pRet = new CCActionEase();
     if (pRet)
 　　　{
 　　　　　//初始化.
         if (pRet->initWithAction(pAction))
         {
 　　 //交由内存管理器进行释放管理.
             pRet->autorelease();
         }
         else
         {
 　　 //如果初始化失败,则直接释放
             CC_SAFE_RELEASE_NULL(pRet);
         }
     }
 　　//返回创建的实例.
     return pRet;
 }
 //初始化.
 bool CCActionEase::initWithAction(CCActionInterval *pAction)
 {
 　　//有效性判断.
     CCAssert(pAction != NULL, "");
 　　//先调用基类的初始化函数.
     if (CCActionInterval::initWithDuration(pAction->getDuration()))
 　　　{
 　　　　　//如果成功保存参数动画,本着"占用就加1"的原则,对其引用计数加一.
         m_pOther = pAction;
         pAction->retain();

         return true;
     }

     return false;
 }
 //产生一个当前类的实例拷贝.
 CCObject* CCActionEase::copyWithZone(CCZone *pZone)
 {
 　　//
     CCZone* pNewZone = NULL;
     CCActionEase* pCopy = NULL;
     //判断参数有效以及其内部已经有创建好的拷贝。
 　　if(pZone && pZone->m_pCopyObject)
     {
         //直接强转后返回这个创建好的拷贝。
         pCopy = (CCActionEase*)(pZone->m_pCopyObject);
     }
     else
 　　　{
 　　　　　//如果无效，新创建一个当前类实例，并创建一个用于拷贝的类实例，将当前类实例设为拷贝类实例的内部拷贝，其实就是建立一个通用的拷贝对象，它内部有一个万物基类CCObject的指针，用来保存各个派生类的实例对象。
         pCopy = new CCActionEase();
         pZone = pNewZone = new CCZone(pCopy);
     }
 　　//先调用基类的相应函数对其进行基类属性的相关初始化，这个函数会一层层调用当前类基类直至CCAction的相应函数。
     CCActionInterval::copyWithZone(pZone);
 　　//使用保存的匀速动画来初始化拷贝实例。
     pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));
     //释放通用的拷贝对象。
     CC_SAFE_DELETE(pNewZone);
     return pCopy;
 }
 //析构
 CCActionEase::~CCActionEase(void)
 {
 　　//释放占用的匀速动画实例。
     CC_SAFE_RELEASE(m_pOther);
 }

 //指定演示当前动画的演员。
 void CCActionEase::startWithTarget(CCNode *pTarget)
 {
 　　//调用基类的相应函数。
 　　　CCActionInterval::startWithTarget(pTarget);
 　　　//设定匀速动画的演员。
     m_pOther->startWithTarget(m_pTarget);
 }
 //停止当前动画。
 void CCActionEase::stop(void)
 {
 　　//让匀速动画停止播放。
 　　　m_pOther->stop();
 　　　//调用基类的相应函数停止当前动画。
     CCActionInterval::stop();
 }
 //更新动画。
 void CCActionEase::update(float time)
 {
 　　//更新匀速动画。
     m_pOther->update(time);
 }
 //创建一个反向播放的变速动画。
 CCActionInterval* CCActionEase::reverse(void)
 {
 　　//通过创建一个反向播放的匀速动画做为参数来创建相应的变速动画。
     return CCActionEase::create(m_pOther->reverse());
 }

       上面只是一个基类，它并未真正的提供速度的变化调节，下面还有一个基类，提供了一个速度调节系数值。

[cpp]   view plain copy

 //可以设定速度的变速动画基类。
 class CC_DLL CCEaseRateAction : public CCActionEase
 {
 public:
     //析构函数。
     virtual ~CCEaseRateAction(void);

     //设置速度调节系数。
     inline void setRate(float rate) { m_fRate = rate; }
     //取得速度调节系数。
     inline float getRate(void) { return m_fRate; }

     //初始化当前动画。
     bool initWithAction(CCActionInterval *pAction, float fRate);
     //创建一个当前动画的实例拷贝。
 　　　virtual CCObject* copyWithZone(CCZone* pZone);
 　　　//创建一个反向播放的当前动画。
     virtual CCActionInterval* reverse(void);

 public:
     //静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为速度。内部调用create实现。
     CC_DEPRECATED_ATTRIBUTE static CCEaseRateAction* actionWithAction(CCActionInterval* pAction, float fRate);

    //同上。
     static CCEaseRateAction* create(CCActionInterval* pAction, float fRate);

 protected:
     //保存速度调节系数值。
     float m_fRate;
 };

CPP实现:

[cpp]   view plain copy

  //静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为速度。内部调用create实现。
 CCEaseRateAction* CCEaseRateAction::actionWithAction(CCActionInterval *pAction, float fRate)
 {
     return CCEaseRateAction::create(pAction, fRate);
 }
 //同上。
 CCEaseRateAction* CCEaseRateAction::create(CCActionInterval *pAction, float fRate)
 {
 　　//先创建相应的变速动画。
     CCEaseRateAction *pRet = new CCEaseRateAction();
     if (pRet)
 　　　{
 　　　　　//如果成功，进行初始化后交由内存管理器处理。
         if (pRet->initWithAction(pAction, fRate))
         {
             pRet->autorelease();
         }
         else
         {
 　　//如果失败，释放并置空。
             CC_SAFE_RELEASE_NULL(pRet);
         }
     }

     return pRet;
 }

 //初始化函数。
 bool CCEaseRateAction::initWithAction(CCActionInterval *pAction, float fRate)
 {
 　　//调用基类的初始化处理。
     if (CCActionEase::initWithAction(pAction))
 　　　{
 　　　　　//保存速度。
         m_fRate = fRate;
         return true;
     }

     return false;
 }

 //产生一个当前类的实例拷贝。参见基类的解释。
 CCObject* CCEaseRateAction::copyWithZone(CCZone *pZone)
 {
     CCZone* pNewZone = NULL;
     CCEaseRateAction* pCopy = NULL;
     if(pZone && pZone->m_pCopyObject)
     {
         //in case of being called at sub class
         pCopy = (CCEaseRateAction*)(pZone->m_pCopyObject);
     }
     else
     {
         pCopy = new CCEaseRateAction();
         pNewZone = new CCZone(pCopy);
     }

     pCopy->initWithAction((CCActionInterval*)(m_pOther->copy()->autorelease()), m_fRate);

     CC_SAFE_DELETE(pNewZone);
     return pCopy;
 }

 //析构
 CCEaseRateAction::~CCEaseRateAction(void)
 {
 }
 //创建一个反向播放的变速动画。
 CCActionInterval* CCEaseRateAction::reverse(void)
 {
     return CCEaseRateAction::create(m_pOther->reverse(), 1 / m_fRate);
 }

       第二个类有了速度属性，但这个速度属性并未对动画起任何作用。后面的类由这个带速度属性的动画基类派生，真正实现相应的变速效果。

[cpp]   view plain copy

 //由快变慢的变速动画。
 class CC_DLL CCEaseIn : public CCEaseRateAction
 {
 public:
     //更新动画。
 　　　virtual void update(float time);
 　　　//创建一个反向播放的当前动画。
 　　　virtual CCActionInterval* reverse(void);
 　　　//创建一个当前动画的实例拷贝。
     virtual CCObject* copyWithZone(CCZone* pZone);
 public:
 　　　//静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为速度。内部调用create实现。
 　　　  CC_DEPRECATED_ATTRIBUTE static CCEaseIn* actionWithAction(CCActionInterval* pAction, float fRate);

      //同上。
     static CCEaseIn* create(CCActionInterval* pAction, float fRate);
 };

CPP:

[cpp]   view plain copy

 //静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为速度。内部调用create实现。
 CCEaseIn* CCEaseIn::actionWithAction(CCActionInterval *pAction, float fRate)
 {
     return CCEaseIn::create(pAction, fRate);
 }
 //同上，参见CCEaseRateAction的create函数。
 CCEaseIn* CCEaseIn::create(CCActionInterval *pAction, float fRate)
 {
     CCEaseIn *pRet = new CCEaseIn();
     if (pRet)
     {
         if (pRet->initWithAction(pAction, fRate))
         {
             pRet->autorelease();
         }
         else
         {
             CC_SAFE_RELEASE_NULL(pRet);
         }
     }

     return pRet;
 }
 //产生一个当前类的实例的拷贝，参见CCEaseRateAction的相应函数。
 CCObject* CCEaseIn::copyWithZone(CCZone *pZone)
 {
     CCZone* pNewZone = NULL;
     CCEaseIn* pCopy = NULL;
     if(pZone && pZone->m_pCopyObject)
     {
         //in case of being called at sub class
         pCopy = (CCEaseIn*)(pZone->m_pCopyObject);
     }
     else
     {
         pCopy = new CCEaseIn();
         pNewZone = new CCZone(pCopy);
     }

     pCopy->initWithAction((CCActionInterval*)(m_pOther->copy()->autorelease()), m_fRate);

     CC_SAFE_DELETE(pNewZone);
     return pCopy;
 }
 //更新动画。
 void CCEaseIn::update(float time)
 {
 　　//这里使用了一个浮点的m_fRate次方计算,time值在0~1间变化，但使用powf（time,m_fRate）会在第一象限生成一个曲线。
 　　　m_pOther->update(powf(time, m_fRate));
 　　　// 后面的图把m_fRate在0.1到10之间的曲线表现出来，其中X方向代表的是time，也就是进度，系数值就是m_fRate，红色线代表了 powf(time,m_fRate)函数。大家可以看到，在m_fRate小于1时函数是先很短时间内达到接近1之后的增速越来越慢，大于1时函数是开 始基本都不递增，到后面增速加快，最后非常快。
 }

 //创建一个反向播放的变速动画。
 CCActionInterval*   CCEaseIn::reverse(void)
 {
        return       CCEaseIn::create(m_pOther->reverse(),m_fRate);
 }

[cpp]   view plain copy

 //由慢变快的变速动画，与上个类基个相同，只是在更新函数中速度值不同。
 class CC_DLL CCEaseOut : public CCEaseRateAction
 {
 public:
    //更新动画。
 　　　virtual void update(float time);
 　　　//创建一个反向播放的当前动画。
 　　　virtual CCActionInterval* reverse(void);
 　　　//创建一个当前动画的实例拷贝。
     virtual CCObject* copyWithZone(CCZone* pZone);

 public:
 　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
     CC_DEPRECATED_ATTRIBUTE static CCEaseOut* actionWithAction(CCActionInterval* pAction, float fRate);

      //同上。
     static CCEaseOut* create(CCActionInterval* pAction, float fRate);
 };

CPP:

[cpp]   view plain copy

 //静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为速度。内部调用create实现。
 CCEaseOut* CCEaseOut::actionWithAction(CCActionInterval *pAction, float fRate)
 {
     return CCEaseOut::create(pAction, fRate);
 }
 //同上。
 CCEaseOut* CCEaseOut::create(CCActionInterval *pAction, float fRate)
 {
     CCEaseOut *pRet = new CCEaseOut();
     if (pRet)
     {
         if (pRet->initWithAction(pAction, fRate))
         {
             pRet->autorelease();
         }
         else
         {
             CC_SAFE_RELEASE_NULL(pRet);
         }
     }

     return pRet;
 }
 //产生一个当前类的实例拷贝
 CCObject* CCEaseOut::copyWithZone(CCZone *pZone)
 {
     CCZone* pNewZone = NULL;
     CCEaseOut* pCopy = NULL;
     if(pZone && pZone->m_pCopyObject)
     {
         //in case of being called at sub class
         pCopy = (CCEaseOut*)(pZone->m_pCopyObject);
     }
     else
     {
         pCopy = new CCEaseOut();
         pNewZone = new CCZone(pCopy);
     }

     pCopy->initWithAction((CCActionInterval*)(m_pOther->copy()->autorelease()), m_fRate);

     CC_SAFE_DELETE(pNewZone);
     return pCopy;
 }
 //更新函数。
 void CCEaseOut::update(float time)
 {
 　　//本动画与上面的动画相似。我也给出曲线图：
     m_pOther->update(powf(time, 1 / m_fRate));
 }
 //创建一个反向播放的变速动画。
 CCActionInterval* CCEaseOut::reverse()
 {
     return CCEaseOut::create(m_pOther->reverse(), 1 / m_fRate);
 }

[cpp]   view plain copy

 class CC_DLL CCEaseInOut : public CCEaseRateAction
 {
 public:
    //更新动画。
 　　　virtual void update(float time);
 　　　//创建一个反向播放的当前动画。
 　　　virtual CCActionInterval* reverse(void);
 　　　//创建一个当前动画的实例拷贝。
     virtual CCObject* copyWithZone(CCZone* pZone);

 public:
 　　//静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为速度。内部调用create实现。
     CC_DEPRECATED_ATTRIBUTE static CCEaseInOut* actionWithAction(CCActionInterval* pAction, float fRate);

      //同上。
     static CCEaseInOut* create(CCActionInterval* pAction, float fRate);
 };
 //静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为速度。内部调用create实现。
 CCEaseInOut* CCEaseInOut::actionWithAction(CCActionInterval *pAction, float fRate)
 {
     return CCEaseInOut::create(pAction, fRate);
 }
 //同上
 CCEaseInOut* CCEaseInOut::create(CCActionInterval *pAction, float fRate)
 {
     CCEaseInOut *pRet = new CCEaseInOut();
     if (pRet)
     {
         if (pRet->initWithAction(pAction, fRate))
         {
             pRet->autorelease();
         }
         else
         {
             CC_SAFE_RELEASE_NULL(pRet);
         }
     }

     return pRet;
 }
 //创建一个当前类的实例拷贝。
 CCObject* CCEaseInOut::copyWithZone(CCZone *pZone)
 {
     CCZone* pNewZone = NULL;
     CCEaseInOut* pCopy = NULL;
     if(pZone && pZone->m_pCopyObject)
     {
         //in case of being called at sub class
         pCopy = (CCEaseInOut*)(pZone->m_pCopyObject);
     }
     else
     {
         pCopy = new CCEaseInOut();
         pNewZone = new CCZone(pCopy);
     }

     pCopy->initWithAction((CCActionInterval*)(m_pOther->copy()->autorelease()), m_fRate);

     CC_SAFE_DELETE(pNewZone);
     return pCopy;
 }

 //更新动画的函数。
 void CCEaseInOut::update(float time)
 {
 　　//这个曲线稍复杂，继续上图
     time *= 2;
     if (time < 1)
     {
         m_pOther->update(0.5f * powf(time, m_fRate));
     }
     else
     {
         m_pOther->update(1.0f - 0.5f * powf(2-time, m_fRate));
     }
 }
 //创建一个反向播放的变速动画。
 CCActionInterval* CCEaseInOut::reverse(void)
 {
     return CCEaseInOut::create(m_pOther->reverse(), m_fRate);
 }

[cpp]   view plain copy

 class CC_DLL CCEaseExponentialIn : public CCActionEase
 {
 public:
     //更新动画。
 　　　virtual void update(float time);
 　　　//创建一个反向播放的当前动画。
 　　　virtual CCActionInterval* reverse(void);
 　　　//创建一个当前动画的实例拷贝。
     virtual CCObject* copyWithZone(CCZone* pZone);

 public:
 　　　 //静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
     CC_DEPRECATED_ATTRIBUTE static CCEaseExponentialIn* actionWithAction(CCActionInterval* pAction);
      //同上。
     static CCEaseExponentialIn* create(CCActionInterval* pAction);
 };
 //静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
 CCEaseExponentialIn* CCEaseExponentialIn::actionWithAction(CCActionInterval* pAction)
 {
     return CCEaseExponentialIn::create(pAction);
 }
 //同上。
 CCEaseExponentialIn* CCEaseExponentialIn::create(CCActionInterval* pAction)
 {
     CCEaseExponentialIn *pRet = new CCEaseExponentialIn();
     if (pRet)
     {
         if (pRet->initWithAction(pAction))
         {
             pRet->autorelease();
         }
         else
         {
             CC_SAFE_RELEASE_NULL(pRet);
         }
     }

     return pRet;
 }
 //创建一个当前类的实例拷贝。
 CCObject* CCEaseExponentialIn::copyWithZone(CCZone *pZone)
 {
     CCZone* pNewZone = NULL;
     CCEaseExponentialIn* pCopy = NULL;
     if(pZone && pZone->m_pCopyObject)
     {
         //in case of being called at sub class
         pCopy = (CCEaseExponentialIn*)(pZone->m_pCopyObject);
     }
     else
     {
         pCopy = new CCEaseExponentialIn();
         pNewZone = new CCZone(pCopy);
     }

     pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));

     CC_SAFE_DELETE(pNewZone);
     return pCopy;
 }

 //更新动画。
 void CCEaseExponentialIn::update(float time)
 {
 　　//不废话，上曲线，此曲线没有系数。是固定曲线。
     m_pOther->update(time == 0 ? 0 : powf(2, 10 * (time/1 - 1)) - 1 * 0.001f);
 }

 //创建一个反向播放的变速动画。
 CCActionInterval* CCEaseExponentialIn::reverse(void)
 {
     return CCEaseExponentialOut::create(m_pOther->reverse());
 }

[cpp]   view plain copy

 class CC_DLL CCEaseExponentialOut : public CCActionEase
 {
 public:
     //更新动画。
 　　　virtual void update(float time);
 　　　//创建一个反向播放的当前动画。
 　　　virtual CCActionInterval* reverse(void);
 　　　//创建一个当前动画的实例拷贝。
     virtual CCObject* copyWithZone(CCZone* pZone);

 public:
 　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
     CC_DEPRECATED_ATTRIBUTE static CCEaseExponentialOut* actionWithAction(CCActionInterval* pAction);
      //同上。
     static CCEaseExponentialOut* create(CCActionInterval* pAction);
 };
 //静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
 CCEaseExponentialOut* CCEaseExponentialOut::actionWithAction(CCActionInterval* pAction)
 {
     return CCEaseExponentialOut::create(pAction);
 }
  //同上。
 CCEaseExponentialOut* CCEaseExponentialOut::create(CCActionInterval* pAction)
 {
     CCEaseExponentialOut *pRet = new CCEaseExponentialOut();
     if (pRet)
     {
         if (pRet->initWithAction(pAction))
         {
             pRet->autorelease();
         }
         else
         {
             CC_SAFE_RELEASE_NULL(pRet);
         }
     }

     return pRet;
 }
 //创建一个当前动画的实例拷贝。
 CCObject* CCEaseExponentialOut::copyWithZone(CCZone *pZone)
 {
     CCZone* pNewZone = NULL;
     CCEaseExponentialOut* pCopy = NULL;
     if(pZone && pZone->m_pCopyObject)
     {
         //in case of being called at sub class
         pCopy = (CCEaseExponentialOut*)(pZone->m_pCopyObject);
     }
     else
     {
         pCopy = new CCEaseExponentialOut();
         pNewZone = new CCZone(pCopy);
     }

     pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));

     CC_SAFE_DELETE(pNewZone);
     return pCopy;
 }
 //更新函数。
 void CCEaseExponentialOut::update(float time)
 {
 　　//上曲线说明，此曲线没有系数。是固定曲线。

     m_pOther->update(time == 1 ? 1 : (-powf(2, -10 * time / 1) + 1));
 }
 //创建一个反向播放的当前动画。
 CCActionInterval* CCEaseExponentialOut::reverse(void)
 {
     return CCEaseExponentialIn::create(m_pOther->reverse());
 }

[cpp]   view plain copy

 class CC_DLL CCEaseExponentialInOut : public CCActionEase
 {
 public:
     //更新动画。
 　　　virtual void update(float time);
 　　　//创建一个反向播放的当前动画。
 　　　virtual CCActionInterval* reverse(void);
 　　　//创建一个当前动画的实例拷贝。
     virtual CCObject* copyWithZone(CCZone* pZone);
 public:
 　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
     CC_DEPRECATED_ATTRIBUTE static CCEaseExponentialInOut* actionWithAction(CCActionInterval* pAction);

 　　　//同上。
     static CCEaseExponentialInOut* create(CCActionInterval* pAction);
 };
 //静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
 CCEaseExponentialInOut* CCEaseExponentialInOut::actionWithAction(CCActionInterval *pAction)
 {
     return CCEaseExponentialInOut::create(pAction);
 }
 //同上。
 CCEaseExponentialInOut* CCEaseExponentialInOut::create(CCActionInterval *pAction)
 {
     CCEaseExponentialInOut *pRet = new CCEaseExponentialInOut();
     if (pRet)
     {
         if (pRet->initWithAction(pAction))
         {
             pRet->autorelease();
         }
         else
         {
             CC_SAFE_RELEASE_NULL(pRet);
         }
     }

     return pRet;
 }
 //创建一个当前动画的实例拷贝。
 CCObject* CCEaseExponentialInOut::copyWithZone(CCZone *pZone)
 {
     CCZone* pNewZone = NULL;
     CCEaseExponentialInOut* pCopy = NULL;
     if(pZone && pZone->m_pCopyObject)
     {
         //in case of being called at sub class
         pCopy = (CCEaseExponentialInOut*)(pZone->m_pCopyObject);
     }
     else
     {
         pCopy = new CCEaseExponentialInOut();
         pNewZone = new CCZone(pCopy);
     }

     pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));

     CC_SAFE_DELETE(pNewZone);
     return pCopy;
 }
 //动画更新。
 void CCEaseExponentialInOut::update(float time)
 {
 　　//上曲线，没有系数，固定曲线

     time /= 0.5f;
     if (time < 1)
     {
         time = 0.5f * powf(2, 10 * (time - 1));
     }
     else
     {
         time = 0.5f * (-powf(2, -10 * (time - 1)) + 2);
     }

     m_pOther->update(time);
 }
 //创建一个反向播放的当前动画。
 CCActionInterval* CCEaseExponentialInOut::reverse()
 {
     return CCEaseExponentialInOut::create(m_pOther->reverse());
 }

[cpp]   view plain copy

 //cos曲线方式变化的变速动画。
 class CC_DLL CCEaseSineIn : public CCActionEase
 {
 public:
     //更新动画。
 　　　virtual void update(float time);
 　　　//创建一个反向播放的当前动画。
 　　　virtual CCActionInterval* reverse(void);
 　　　//创建一个当前动画的实例拷贝。
     virtual CCObject* copyWithZone(CCZone* pZone);

 public:
 　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
     CC_DEPRECATED_ATTRIBUTE static CCEaseSineIn* actionWithAction(CCActionInterval* pAction);
     //同上
     static CCEaseSineIn* create(CCActionInterval* pAction);
 };
 //静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
 CCEaseSineIn* CCEaseSineIn::actionWithAction(CCActionInterval* pAction)
 {
     return CCEaseSineIn::create(pAction);
 }
 //同上
 CCEaseSineIn* CCEaseSineIn::create(CCActionInterval* pAction)
 {
     CCEaseSineIn *pRet = new CCEaseSineIn();
     if (pRet)
     {
         if (pRet->initWithAction(pAction))
         {
             pRet->autorelease();
         }
         else
         {
             CC_SAFE_RELEASE_NULL(pRet);
         }
     }

     return pRet;
 }
 //创建一个当前动画的实例拷贝。
 CCObject* CCEaseSineIn::copyWithZone(CCZone *pZone)
 {
     CCZone* pNewZone = NULL;
     CCEaseSineIn* pCopy = NULL;
     if(pZone && pZone->m_pCopyObject)
     {
         //in case of being called at sub class
         pCopy = (CCEaseSineIn*)(pZone->m_pCopyObject);
     }
     else
     {
         pCopy = new CCEaseSineIn();
         pNewZone = new CCZone(pCopy);
     }

     pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));

     CC_SAFE_DELETE(pNewZone);
     return pCopy;
 }
 //更新
 void CCEaseSineIn::update(float time)
 {   //上曲线图，无需参数，固定曲线:

     m_pOther->update(-1 * cosf(time * (float)M_PI_2) + 1);
 }
 //创建一个反向播放的当前动画。
 CCActionInterval* CCEaseSineIn::reverse(void)
 {
     return CCEaseSineOut::create(m_pOther->reverse());
 }

[cpp]   view plain copy

 //sin曲线方式变化的变速动画。
 class CC_DLL CCEaseSineOut : public CCActionEase
 {
 public:
     //更新动画。
 　　　virtual void update(float time);
 　　　//创建一个反向播放的当前动画。
 　　　virtual CCActionInterval* reverse(void);
 　　　//创建一个当前动画的实例拷贝。
     virtual CCObject* copyWithZone(CCZone* pZone);

 public:
 　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
     CC_DEPRECATED_ATTRIBUTE static CCEaseSineOut* actionWithAction(CCActionInterval* pAction);
     //同上
     static CCEaseSineOut* create(CCActionInterval* pAction);
 };
 //静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
 CCEaseSineOut* CCEaseSineOut::actionWithAction(CCActionInterval* pAction)
 {
     return CCEaseSineOut::create(pAction);
 }
 //同上
 CCEaseSineOut* CCEaseSineOut::create(CCActionInterval* pAction)
 {
     CCEaseSineOut *pRet = new CCEaseSineOut();
     if (pRet)
     {
         if (pRet->initWithAction(pAction))
         {
             pRet->autorelease();
         }
         else
         {
             CC_SAFE_RELEASE_NULL(pRet);
         }
     }

     return pRet;
 }
 //创建一个当前动画的实例拷贝。
 CCObject* CCEaseSineOut::copyWithZone(CCZone *pZone)
 {
     CCZone* pNewZone = NULL;
     CCEaseSineOut* pCopy = NULL;
     if(pZone && pZone->m_pCopyObject)
     {
         //in case of being called at sub class
         pCopy = (CCEaseSineOut*)(pZone->m_pCopyObject);
     }
     else
     {
         pCopy = new CCEaseSineOut();
         pNewZone = new CCZone(pCopy);
     }

     pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));

     CC_SAFE_DELETE(pNewZone);
     return pCopy;
 }
 //更新
 void CCEaseSineOut::update(float time)
 {
 　　//上图说明:

     m_pOther->update(sinf(time * (float)M_PI_2));
 }
 //创建一个反向播放的当前动画。
 CCActionInterval* CCEaseSineOut::reverse(void)
 {
     return CCEaseSineIn::create(m_pOther->reverse());
 }

[cpp]   view plain copy

 //另种cos曲线方式变化的变速动画。
 class CC_DLL CCEaseSineInOut : public CCActionEase
 {
 public:
     //更新动画。
 　　　virtual void update(float time);
 　　　//创建一个反向播放的当前动画。
 　　　virtual CCActionInterval* reverse(void);
 　　　//创建一个当前动画的实例拷贝。
     virtual CCObject* copyWithZone(CCZone* pZone);

 public:
 　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
     CC_DEPRECATED_ATTRIBUTE static CCEaseSineInOut* actionWithAction(CCActionInterval* pAction);
 　　　//同上
     static CCEaseSineInOut* create(CCActionInterval* pAction);
 };

 //静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
 CCEaseSineInOut* CCEaseSineInOut::actionWithAction(CCActionInterval* pAction)
 {
     return CCEaseSineInOut::create(pAction);
 }
 //同上
 CCEaseSineInOut* CCEaseSineInOut::create(CCActionInterval* pAction)
 {
     CCEaseSineInOut *pRet = new CCEaseSineInOut();
     if (pRet)
     {
         if (pRet->initWithAction(pAction))
         {
             pRet->autorelease();
         }
         else
         {
             CC_SAFE_RELEASE_NULL(pRet);
         }
     }

     return pRet;
 }
 //创建一个当前动画的实例拷贝。
 CCObject* CCEaseSineInOut::copyWithZone(CCZone *pZone)
 {
     CCZone* pNewZone = NULL;
     CCEaseSineInOut* pCopy = NULL;
     if(pZone && pZone->m_pCopyObject)
     {
         //in case of being called at sub class
         pCopy = (CCEaseSineInOut*)(pZone->m_pCopyObject);
     }
     else
     {
         pCopy = new CCEaseSineInOut();
         pNewZone = new CCZone(pCopy);
     }

     pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));

     CC_SAFE_DELETE(pNewZone);
     return pCopy;
 }
 //更新函数。
 void CCEaseSineInOut::update(float time)
 {
 　　//上曲线说明：
     m_pOther->update(-0.5f * (cosf((float)M_PI * time) - 1));
 }

 //创建一个反向播放的当前动画。
 CCActionInterval* CCEaseSineInOut::reverse()
 {
     return CCEaseSineInOut::create(m_pOther->reverse());
 }

[cpp]   view plain copy

 //一个基类，用于衍生后面的变速动画。
 class CC_DLL CCEaseElastic : public CCActionEase
 {
 public:
     //取得系数
     inline float getPeriod(void) { return m_fPeriod; }
 　　　//设置系数
     inline void setPeriod(float fPeriod) { m_fPeriod = fPeriod; }

     //初始化函数。
     bool initWithAction(CCActionInterval *pAction, float fPeriod = 0.3f);
 　　//创建一个反向播放的当前动画。
 　　　virtual CCActionInterval* reverse(void);

 　　//创建一个当前动画的实例拷贝。
     virtual CCObject* copyWithZone(CCZone* pZone);

 public:
     //静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为系数。内部调用create实现。
     CC_DEPRECATED_ATTRIBUTE static CCEaseElastic* actionWithAction(CCActionInterval *pAction, float fPeriod = 0.3f);
     //同上
     static CCEaseElastic* create(CCActionInterval *pAction, float fPeriod = 0.3f);
 protected:
 　　 //曲线系数。
     float m_fPeriod;
 };

 //静态函数：创建对应匀速动画的变速动画，参数一为一个匀速动画。参数二为系数。内部调用create实现。
 CCEaseElastic* CCEaseElastic::actionWithAction(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
 {
     return CCEaseElastic::create(pAction, fPeriod);
 }
  //同上
 CCEaseElastic* CCEaseElastic::create(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
 {
     CCEaseElastic *pRet = new CCEaseElastic();
     if (pRet)
     {
         if (pRet->initWithAction(pAction, fPeriod))
         {
             pRet->autorelease();
         }
         else
         {
             CC_SAFE_RELEASE_NULL(pRet);
         }
     }

     return pRet;
 }
 //初始化函数。
 bool CCEaseElastic::initWithAction(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
 {
     if (CCActionEase::initWithAction(pAction))
 　　　{
 　　　　　//保存曲线系数。
         m_fPeriod = fPeriod;
         return true;
     }

     return false;
 }

 //创建一个当前动画的实例拷贝。
 CCObject* CCEaseElastic::copyWithZone(CCZone *pZone)
 {
     CCZone* pNewZone = NULL;
     CCEaseElastic* pCopy = NULL;
     if(pZone && pZone->m_pCopyObject)
     {
         //in case of being called at sub class
         pCopy = (CCEaseElastic*)(pZone->m_pCopyObject);
     }
     else
     {
         pCopy = new CCEaseElastic();
         pNewZone = new CCZone(pCopy);
     }

     pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()), m_fPeriod);

     CC_SAFE_DELETE(pNewZone);
     return pCopy;
 }
 //创建一个反向播放的当前动画。
 CCActionInterval* CCEaseElastic::reverse(void)
 {
     CCAssert(0, "Override me");

     return NULL;
 }

[cpp]   view plain copy

 //上面基类衍生的新类。
 class CC_DLL CCEaseElasticIn : public CCEaseElastic
 {
 public:
     //更新动画。
 　　　virtual void update(float time);
 　　　//创建一个反向播放的当前动画。
 　　　virtual CCActionInterval* reverse(void);
 　　　//创建一个当前动画的实例拷贝。
     virtual CCObject* copyWithZone(CCZone* pZone);

 public:
 　　　//静态函数：创建对应匀速动画的变速动画，第一参数为一个匀速动画。第二参数为曲线系数，内部调用create实现。
     CC_DEPRECATED_ATTRIBUTE static CCEaseElasticIn* actionWithAction(CCActionInterval *pAction, float fPeriod = 0.3f);
     //同上。
     static CCEaseElasticIn* create(CCActionInterval *pAction, float fPeriod = 0.3f);
 };

 //静态函数：创建对应匀速动画的变速动画，第一参数为一个匀速动画。第二参数为曲线系数，内部调用create实现。
 CCEaseElasticIn* CCEaseElasticIn::actionWithAction(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
 {
     return CCEaseElasticIn::create(pAction, fPeriod);
 }
  //同上。
 CCEaseElasticIn* CCEaseElasticIn::create(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
 {
     CCEaseElasticIn *pRet = new CCEaseElasticIn();
     if (pRet)
     {
         if (pRet->initWithAction(pAction, fPeriod))
         {
             pRet->autorelease();
         }
         else
         {
             CC_SAFE_RELEASE_NULL(pRet);
         }
     }

     return pRet;
 }
 //创建一个当前动画的实例拷贝。
 CCObject* CCEaseElasticIn::copyWithZone(CCZone *pZone)
 {
     CCZone* pNewZone = NULL;
     CCEaseElasticIn* pCopy = NULL;
     if(pZone && pZone->m_pCopyObject)
     {
         //in case of being called at sub class
         pCopy = (CCEaseElasticIn*)(pZone->m_pCopyObject);
     }
     else
     {
         pCopy = new CCEaseElasticIn();
         pNewZone = new CCZone(pCopy);
     }

     pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()), m_fPeriod);

     CC_SAFE_DELETE(pNewZone);
     return pCopy;
 }
 //更新动画。
 void CCEaseElasticIn::update(float time)
 {
 　　//比较复杂，上图说明在不同的系数时的曲线结果：

     float newT = 0;
     if (time == 0 || time == 1)
     {
         newT = time;
     }
     else
     {
         float s = m_fPeriod / 4;
         time = time - 1;
         newT = -powf(2, 10 * time) * sinf((time - s) * M_PI_X_2 / m_fPeriod);
     }

     m_pOther->update(newT);
 }
 //创建一个反向播放的当前动画。
 CCActionInterval* CCEaseElasticIn::reverse(void)
 {
     return CCEaseElasticOut::create(m_pOther->reverse(), m_fPeriod);
 }

[cpp]   view plain copy

 class CC_DLL CCEaseElasticOut : public CCEaseElastic
 {
 public:
     //更新动画。
 　　　virtual void update(float time);
 　　　//创建一个反向播放的当前动画。
 　　　virtual CCActionInterval* reverse(void);
 　　　//创建一个当前动画的实例拷贝。
     virtual CCObject* copyWithZone(CCZone* pZone);

 public:
 　　　//静态函数：创建对应匀速动画的变速动画，第一参数为一个匀速动画。第二参数为曲线系数，内部调用create实现。
     CC_DEPRECATED_ATTRIBUTE static CCEaseElasticOut* actionWithAction(CCActionInterval *pAction, float fPeriod = 0.3f);

     //同上
     static CCEaseElasticOut* create(CCActionInterval *pAction, float fPeriod = 0.3f);
 };
 　　　//静态函数：创建对应匀速动画的变速动画，第一参数为一个匀速动画。第二参数为曲线系数，内部调用create实现。

 CCEaseElasticOut* CCEaseElasticOut::actionWithAction(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
 {
     return CCEaseElasticOut::create(pAction, fPeriod);
 }
 //同上
 CCEaseElasticOut* CCEaseElasticOut::create(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
 {
     CCEaseElasticOut *pRet = new CCEaseElasticOut();
     if (pRet)
     {
         if (pRet->initWithAction(pAction, fPeriod))
         {
             pRet->autorelease();
         }
         else
         {
             CC_SAFE_RELEASE_NULL(pRet);
         }
     }

     return pRet;
 }
 //创建一个当前动画的实例拷贝。
 CCObject *CCEaseElasticOut::copyWithZone(CCZone *pZone)
 {
     CCZone* pNewZone = NULL;
     CCEaseElasticOut* pCopy = NULL;
     if(pZone && pZone->m_pCopyObject)
     {
         //in case of being called at sub class
         pCopy = (CCEaseElasticOut*)(pZone->m_pCopyObject);
     }
     else
     {
         pCopy = new CCEaseElasticOut();
         pNewZone = new CCZone(pCopy);
     }

     pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()), m_fPeriod);

     CC_SAFE_DELETE(pNewZone);
     return pCopy;
 }
 //更新动画。
 void CCEaseElasticOut::update(float time)
 {
 　　//继续上曲线说明：

     float newT = 0;
     if (time == 0 || time == 1)
     {
         newT = time;
     }
     else
     {
         float s = m_fPeriod / 4;
         newT = powf(2, -10 * time) * sinf((time - s) * M_PI_X_2 / m_fPeriod) + 1;
     }

     m_pOther->update(newT);
 }
 //创建一个反向播放的当前动画。
 CCActionInterval* CCEaseElasticOut::reverse(void)
 {
     return CCEaseElasticIn::create(m_pOther->reverse(), m_fPeriod);
 }

[cpp]   view plain copy

 class CC_DLL CCEaseElasticInOut : public CCEaseElastic
 {
 public:
     //更新动画。
 　　　virtual void update(float time);
 　　　//创建一个反向播放的当前动画。
 　　　virtual CCActionInterval* reverse(void);
 　　　//创建一个当前动画的实例拷贝。
     virtual CCObject* copyWithZone(CCZone* pZone);

 public:
 　　　//静态函数：创建对应匀速动画的变速动画，第一参数为一个匀速动画。第二参数为曲线系数，内部调用create实现。
     CC_DEPRECATED_ATTRIBUTE static CCEaseElasticInOut* actionWithAction(CCActionInterval *pAction, float fPeriod = 0.3f);

     //同上
     static CCEaseElasticInOut* create(CCActionInterval *pAction, float fPeriod = 0.3f);
 };
 //静态函数：创建对应匀速动画的变速动画，第一参数为一个匀速动画。第二参数为曲线系数，内部调用create实现。
 CCEaseElasticInOut* CCEaseElasticInOut::actionWithAction(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
 {
     return CCEaseElasticInOut::create(pAction, fPeriod);
 }
 //同上
 CCEaseElasticInOut* CCEaseElasticInOut::create(CCActionInterval *pAction, float fPeriod/* = 0.3f*/)
 {
     CCEaseElasticInOut *pRet = new CCEaseElasticInOut();
     if (pRet)
     {
         if (pRet->initWithAction(pAction, fPeriod))
         {
             pRet->autorelease();
         }
         else
         {
             CC_SAFE_RELEASE_NULL(pRet);
         }
     }

     return pRet;
 }
 //创建一个当前动画的实例拷贝。
 CCObject* CCEaseElasticInOut::copyWithZone(CCZone *pZone)
 {
     CCZone* pNewZone = NULL;
     CCEaseElasticInOut* pCopy = NULL;
     if(pZone && pZone->m_pCopyObject)
     {
         //in case of being called at sub class
         pCopy = (CCEaseElasticInOut*)(pZone->m_pCopyObject);
     }
     else
     {
         pCopy = new CCEaseElasticInOut();
         pNewZone = new CCZone(pCopy);
     }

     pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()), m_fPeriod);

     CC_SAFE_DELETE(pNewZone);
     return pCopy;

 }
 //更新动画。
 void CCEaseElasticInOut::update(float time)
 {
 　　//挺复杂的曲线：

     float newT = 0;
     if (time == 0 || time == 1)
     {
         newT = time;
     }
     else
     {
         time = time * 2;
         if (! m_fPeriod)
         {
             m_fPeriod = 0.3f * 1.5f;
         }

         float s = m_fPeriod / 4;

         time = time - 1;
         if (time < 0)
         {
             newT = -0.5f * powf(2, 10 * time) * sinf((time -s) * M_PI_X_2 / m_fPeriod);
         }
         else
         {
             newT = powf(2, -10 * time) * sinf((time - s) * M_PI_X_2 / m_fPeriod) * 0.5f + 1;
         }
     }

     m_pOther->update(newT);
 }
 //创建一个反向播放的当前动画。
 CCActionInterval* CCEaseElasticInOut::reverse(void)
 {
     return CCEaseElasticInOut::create(m_pOther->reverse(), m_fPeriod);
 }

[cpp]   view plain copy

 //又是一个变速动画的基类，用于衍生一些复杂的变速曲线。
 class CC_DLL CCEaseBounce : public CCActionEase
 {
 public:
 　　//计算曲线处理
 　　　float bounceTime(float time);
 　　　//产生一个当前类的实例拷贝。
 　　　virtual CCObject* copyWithZone(CCZone* pZone);
 　　　//创建一个反向播放的当前动画
     virtual CCActionInterval* reverse();

 public:
 　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
     CC_DEPRECATED_ATTRIBUTE static CCEaseBounce* actionWithAction(CCActionInterval* pAction);
     //同上。
     static CCEaseBounce* create(CCActionInterval* pAction);
 };

 //静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
 CCEaseBounce* CCEaseBounce::actionWithAction(CCActionInterval* pAction)
 {
     return CCEaseBounce::create(pAction);
 }
 //同上。
 CCEaseBounce* CCEaseBounce::create(CCActionInterval* pAction)
 {
     CCEaseBounce *pRet = new CCEaseBounce();
     if (pRet)
     {
         if (pRet->initWithAction(pAction))
         {
             pRet->autorelease();
         }
         else
         {
             CC_SAFE_RELEASE_NULL(pRet);
         }
     }

     return pRet;
 }
 //产生一个当前类的实例拷贝。
 CCObject* CCEaseBounce::copyWithZone(CCZone *pZone)
 {
     CCZone* pNewZone = NULL;
     CCEaseBounce* pCopy = NULL;
     if(pZone && pZone->m_pCopyObject)
     {
         //in case of being called at sub class
         pCopy = (CCEaseBounce*)(pZone->m_pCopyObject);
     }
     else
     {
         pCopy = new CCEaseBounce();
         pNewZone = new CCZone(pCopy);
     }

     pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));

     CC_SAFE_DELETE(pNewZone);
     return pCopy;
 }
 //计算曲线处理
 float CCEaseBounce::bounceTime(float time)
 {
 　　//复杂曲线说明：

     if (time < 1 / 2.75)
     {
         return 7.5625f * time * time;
     } else
     if (time < 2 / 2.75)
     {
         time -= 1.5f / 2.75f;
         return 7.5625f * time * time + 0.75f;
     } else
     if(time < 2.5 / 2.75)
     {
         time -= 2.25f / 2.75f;
         return 7.5625f * time * time + 0.9375f;
     }

     time -= 2.625f / 2.75f;
     return 7.5625f * time * time + 0.984375f;
 }
 //创建一个反向播放的当前动画
 CCActionInterval* CCEaseBounce::reverse()
 {
     return CCEaseBounce::create(m_pOther->reverse());
 }

[cpp]   view plain copy

 //上面类的衍生类。
 class CC_DLL CCEaseBounceIn : public CCEaseBounce
 {
 public:
     //更新动画。
 　　　virtual void update(float time);
 　　　//创建一个反向播放的当前动画。
 　　　virtual CCActionInterval* reverse(void);
 　　　//创建一个当前动画的实例拷贝。
     virtual CCObject* copyWithZone(CCZone* pZone);

 public:
 　　　//静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
     CC_DEPRECATED_ATTRIBUTE static CCEaseBounceIn* actionWithAction(CCActionInterval* pAction);
     //同上。
     static CCEaseBounceIn* create(CCActionInterval* pAction);
 };
 //静态函数：创建对应匀速动画的变速动画，参数为一个匀速动画。内部调用create实现。
 CCEaseBounceIn* CCEaseBounceIn::actionWithAction(CCActionInterval* pAction)
 {
     return CCEaseBounceIn::create(pAction);
 }
 //同上。
 CCEaseBounceIn* CCEaseBounceIn::create(CCActionInterval* pAction)
 {
     CCEaseBounceIn *pRet = new CCEaseBounceIn();
     if (pRet)
     {
         if (pRet->initWithAction(pAction))
         {
             pRet->autorelease();
         }
         else
         {
             CC_SAFE_RELEASE_NULL(pRet);
         }
     }

     return pRet;
 }
 //创建一个当前动画的实例拷贝。
 CCObject* CCEaseBounceIn::copyWithZone(CCZone *pZone)
 {
     CCZone* pNewZone = NULL;
     CCEaseBounceIn* pCopy = NULL;
     if(pZone && pZone->m_pCopyObject)
     {
         //in case of being called at sub class
         pCopy = (CCEaseBounceIn*)(pZone->m_pCopyObject);
     }
     else
     {
         pCopy = new CCEaseBounceIn();
         pNewZone = new CCZone(pCopy);
     }

     pCopy->initWithAction((CCActionInterval *)(m_pOther->copy()->autorelease()));

     CC_SAFE_DELETE(pNewZone);
     return pCopy;
 }
 //更新动画。
 void CCEaseBounceIn::update(float time)
 {
 　　//先计算出变速曲线的结果然后做为进度值设置给匀速动画。
 　　//曲线未设系数，为固定曲线。

     float newT = 1 - bounceTime(1 - time);
     m_pOther->update(newT);
 }
 //创建一个反向播放的当前动画。
 CCActionInterval* CCEaseBounceIn::reverse(void)
 {
     return CCEaseBounceOut::create(m_pOther->reverse());
 }