#ifndef __ACTION_CCACTION_MANAGER_H__

#define __ACTION_CCACTION_MANAGER_H__

#include "CCAction.h"

#include "cocoa/CCArray.h"

#include "cocoa/CCObject.h"

NS_CC_BEGIN

//要用到CCSet类进行存储

 

class CCSet;

//使用哈希表元素

 

struct _hashElement;

//

 @brief CCActionManager is a singleton that manages all the actions.

 Normally you won't need to use this singleton directly. 99% of the cases you will use the CCNode interface,

 which uses this singleton.

 But there are some cases where you might need to use this singleton.

 Examples:

    - When you want to run an action where the target is different from a CCNode. 

    - When you want to pause / resume the actions

 ///

class CC_DLL CCActionManager : public CCObject

{

public:

    CCActionManager(void);

    ~CCActionManager(void);

    // actions

    ///

   Adds an action with a target. 

     If the target is already present, then the action will be added to the existing target.

     If the target is not present, a new instance of this target will be created either paused or not, and the action will be added to the newly created target.

     When the target is paused, the queued actions won't be 'ticked'.

    ///

    void addAction(CCAction *pAction, CCNode *pTarget, bool paused);//3、是否立即播放

 // Removes all actions from all the targets.

    void removeAllActions(void);

  //Removes all actions from a certain target.

    void removeAllActionsFromTarget(CCObject *pTarget);

   // Removes an action given an action reference.

    void removeAction(CCAction *pAction);

   //Removes an action given its tag and the target 

    void removeActionByTag(unsigned int tag, CCObject *pTarget);

    CCAction* getActionByTag(unsigned int tag, CCObject *pTarget);

//返回指定目标所应用的动作数量

 

    unsigned int numberOfRunningActionsInTarget(CCObject *pTarget);

   

//停止指定目标的所有的动作。

    void pauseTarget(CCObject *pTarget);

//继续播放指定目标的所有动作

 

    void resumeTarget(CCObject *pTarget);

    

 

//暂停所有正在动行的动作，并将这些暂停的动作存入CCSet中返回。

 

    CCSet* pauseAllRunningActions();

    

 

 

//继结播放CCSet中的所有动作。

  

    void resumeTargets(CCSet *targetsToResume);

protected:

    void removeActionAtIndex(unsigned int uIndex, struct _hashElement *pElement);

    void deleteHashElement(struct _hashElement *pElement);

//为pElement申请内存存放动画集。

 

    void actionAllocWithHashElement(struct _hashElement *pElement);

    

    //这个函数重要了~，它在每一帧被调用，通过传入的时间流逝长度传给每一个非暂停的动作进行相应的更新

    void update(float dt);

protected:

    struct _hashElement    *m_pTargets;

    struct _hashElement    *m_pCurrentTarget;

    bool            m_bCurrentTargetSalvaged;

};

// end of actions group

/// @}

NS_CC_END

#endif // __ACTION_CCACTION_MANAGER_H__

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

.cpp

 #include "CCActionManager.h"
 #include "base_nodes/CCNode.h"
 #include "CCScheduler.h"
 #include "ccMacros.h"
 #include "support/data_support/ccCArray.h"
 #include "support/data_support/uthash.h"
 #include "cocoa/CCSet.h"
 //使用Cocos2d命名空间
 NS_CC_BEGIN
 //这里定义了一个哈希表项结构，用于存储一个演员的动画集相关信息。
 typedef struct _hashElement
 {
     struct _ccArray             *actions;   //动画集
     CCObject                    *target;    //演员的指针
     unsigned int                actionIndex;//动画在动画集中的索引。
     CCAction                    *currentAction;//当前正在播放的动画
     bool                        currentActionSalvaged;//当前动画是否被回收。
     bool                        paused;//是否停止播放。
     UT_hash_handle                hh;//哈希表查询句柄。
 } tHashElement;

 //构造函数
 CCActionManager::CCActionManager(void)
 : m_pTargets(NULL),
   m_pCurrentTarget(NULL),
   m_bCurrentTargetSalvaged(false)
 {

 }

 //析构函数
 CCActionManager::~CCActionManager(void)
 {
     CCLOGINFO("cocos2d: deallocing %p", this);
     //清空所有的动画
     removeAllActions();
 }

 //删除相应的哈希表项
 void CCActionManager::deleteHashElement(tHashElement *pElement)
 {
     //释放pElement存储的动画集
     ccArrayFree(pElement->actions);
     //从哈希表m_pTargets中删除pElement项
     HASH_DEL(m_pTargets, pElement);
     //释放pElement
     pElement->target->release();
     free(pElement);
 }
 //为哈希表项pElement申请内存，以存放动画集
 void CCActionManager::actionAllocWithHashElement(tHashElement *pElement)
 {
     // 默认每个哈希表项存四个动画,所以如果当前哈希表项的动画集为空，则为其申请可存放4个动画指针的内存大小。
     if (pElement->actions == NULL)
     {
         pElement->actions = ccArrayNew(4);
     }else
     if (pElement->actions->num == pElement->actions->max)
     {   //如果哈希表项的动作集需要扩大，则扩增为原来的2倍直至达到最大容量。
         ccArrayDoubleCapacity(pElement->actions);
     }

 }
 //从哈希表项的动画集中移除掉指定的动画。
 void CCActionManager::removeActionAtIndex(unsigned int uIndex, tHashElement *pElement)
 {
     //通过参数uIndex找到哈希表项的动画集中的对应动画。
     CCAction *pAction = (CCAction*)pElement->actions->arr[uIndex];

     //如果当前动画正在播放中而且回收标记为否
     if (pAction == pElement->currentAction && (! pElement->currentActionSalvaged))
     {
         //引用计数器加1,代表被管理器使用中。
         pElement->currentAction->retain();
         //设其回收标记为true。
         pElement->currentActionSalvaged = true;
     }
     //从动画集中移除指定位置的动画。
     ccArrayRemoveObjectAtIndex(pElement->actions, uIndex, true);
     //
     if (pElement->actionIndex >= uIndex)
     {
         pElement->actionIndex--;
     }
     //如果pElement的动画集的数量为0
     if (pElement->actions->num == 0)
     {
          //如果当前正有演员在演示本动画，那么先将其要回收标记设为true 。
         if (m_pCurrentTarget == pElement)
         {
             m_bCurrentTargetSalvaged = true;
         }
         else
         {
               //否则立即释放
             deleteHashElement(pElement);
         }
     }
 }
 //暂停目标演员身上的所有动画
 void CCActionManager::pauseTarget(CCObject *pTarget)
 {
     //声明一个哈希表项指针
     tHashElement *pElement = NULL;
     //通过哈希表处理相关宏找到对应的哈希表项。
     HASH_FIND_INT(m_pTargets, &pTarget, pElement);
     //如果找到，则将其暂停开关变量设为true
     if (pElement)
     {
         pElement->paused = true;
     }
 }
 //继续目标演员身上的所有动画
 void CCActionManager::resumeTarget(CCObject *pTarget)
 {
     //定义一个哈希表项指针变量并置空。
     tHashElement *pElement = NULL;
     //通过哈希表处理相关宏找到对应的哈希表项。
     HASH_FIND_INT(m_pTargets, &pTarget, pElement);
     //如果找到，则将其暂停开关变量设为false，使其处于播放状态。
     if (pElement)
     {
         pElement->paused = false;
     }
 }
 //暂停所有正在播放中的动画
 CCSet* CCActionManager::pauseAllRunningActions()
 {
     //创建一个CCSet容器
     CCSet *idsWithActions = new CCSet();
     //此容器交由内存管理器进行内存的最后释放。无需手动delete。
     idsWithActions->autorelease();
     //遍历所有的哈希表项
     for (tHashElement *element=m_pTargets; element != NULL; element = (tHashElement *)element->hh.next)
     {
         //如果当前遍历位置的哈希表项处于播放状态，设置其暂停并将其放入CCSet容器中。
         if (! element->paused)
         {
             element->paused = true;
             idsWithActions->addObject(element->target);
         }
     }
     //返回容器。
     return idsWithActions;
 }
 //继续播放容器中的所有动画
 void CCActionManager::resumeTargets(cocos2d::CCSet *targetsToResume)
 {
     //定义CCSet容器的迭代器。之后遍历参数容器。将每一个项设为播放状态。
     CCSetIterator iter;
     for (iter = targetsToResume->begin(); iter != targetsToResume->end(); ++iter)
     {
         resumeTarget(*iter);
     }
 }

 //将一个动画和应用此动画的演员，以及当前动画是否处于暂停状态信息存入管理器中。
 void CCActionManager::addAction(CCAction *pAction, CCNode *pTarget, bool paused)
 {
     //有效性判断。
     CCAssert(pAction != NULL, "");
     CCAssert(pTarget != NULL, "");
     //定义一个哈希表项的指针变量并置空。
     tHashElement *pElement = NULL;
     //将pTarget转为一个CCObject类型的指针。用于哈希表查询。
     CCObject *tmp = pTarget;
     //通过这个指针，找到对应的哈希表项返回给pElement;
     HASH_FIND_INT(m_pTargets, &tmp, pElement);
     //如果找不到。则代表新加入的哈希表项。则申请内存创建此哈希表项，并将其加入哈希表中。
     if (! pElement)
     {
         //创建一个哈希表项
         pElement = (tHashElement*)calloc(sizeof(*pElement), 1);
          //设置其是否为暂停状态。
         pElement->paused = paused;
          //引用计数器加1,代表被管理器使用中。
         pTarget->retain();
          //设置哈希表项中的演员为参数指定的演员。
         pElement->target = pTarget;
          //调用哈希表处理宏将哈希表项加入哈希表。
         HASH_ADD_INT(m_pTargets, target, pElement);
     }
     //为哈希表项pElement申请内存，以存放动画集
      actionAllocWithHashElement(pElement);
     //判断pAction是否在pElement的动画集中。确保只放入一次。
      CCAssert(! ccArrayContainsObject(pElement->actions, pAction), "");
     //将pAction放入pElement的动画集中。
      ccArrayAppendObject(pElement->actions, pAction);
      //设置是哪个CCNode要进行当前动画
      pAction->startWithTarget(pTarget);
 }

 //清除所有的动画
 void CCActionManager::removeAllActions(void)
 {
     //遍历哈希表中的所有项
     for (tHashElement *pElement = m_pTargets; pElement != NULL; )
     {
         //取得对应项信息中的演员指针
         CCObject *pTarget = pElement->target;
         //这里是用于继续循环的处理，将当前项指向下一个哈希表项。
         pElement = (tHashElement*)pElement->hh.next;
         //释放演员的所有动画
         removeAllActionsFromTarget(pTarget);
     }
 }

 //删除对应演员的所有动画
 void CCActionManager::removeAllActionsFromTarget(CCObject *pTarget)
 {
     // 有效性判断
     if (pTarget == NULL)
     {
         return;
     }
     //定义一个哈希表项指针，并通过哈希表的查询宏取得对应项地址返回给指针。
     tHashElement *pElement = NULL;
     HASH_FIND_INT(m_pTargets, &pTarget, pElement);
     //如果找到此项
     if (pElement)
     {
         //如果此哈希表项有正在播放的动画并且这个动画并未被设为要回收。
         if (ccArrayContainsObject(pElement->actions, pElement->currentAction) && (! pElement->currentActionSalvaged))
         {
               //将当前正在播放的动画的引用计数器加1并设置其回收标记为true。引用计数加1的目的是人为使其暂不能被正常释放，需要待后面再减1后才可以被释放。
             pElement->currentAction->retain();
             pElement->currentActionSalvaged = true;
         }
          //清空当前哈希表项的动画集。
         ccArrayRemoveAllObjects(pElement->actions);
          //如果当前哈希表项正处于使用中，暂不释放，只将其要回收的标记设为true。
         if (m_pCurrentTarget == pElement)
         {
             m_bCurrentTargetSalvaged = true;
         }
         else
         {
               //释放当前哈希表项
             deleteHashElement(pElement);
         }
     }
     else
     {
 //        CCLOG("cocos2d: removeAllActionsFromTarget: Target not found");
     }
 }
 //将指定动画从动画管理器中移除
 void CCActionManager::removeAction(CCAction *pAction)
 {
     //有效性判断
     if (pAction == NULL)
     {
         return;
     }
     //定义一个哈希表项指针，并通过哈希表的查询宏取得对应项地址返回给指针。
     tHashElement *pElement = NULL;
     CCObject *pTarget = pAction->getOriginalTarget();
     HASH_FIND_INT(m_pTargets, &pTarget, pElement);
     //如果找到此项
     if (pElement)
     {
          //取得pAction处于当前项的动画集的索引
         unsigned int i = ccArrayGetIndexOfObject(pElement->actions, pAction);
          //如果这个索引是有效的，调用函数将pElement的指定索引的动画移除。
         if (UINT_MAX != i)
         {
             removeActionAtIndex(i, pElement);
         }
     }
     else
     {
         CCLOG("cocos2d: removeAction: Target not found");
     }
 }
 //将指定演员的指定动画删除
 void CCActionManager::removeActionByTag(unsigned int tag, CCObject *pTarget)
 {
     //有效性判断
     CCAssert((int)tag != kCCActionTagInvalid, "");
     CCAssert(pTarget != NULL, "");
     //定义哈希表项指针变量，并通过哈希表处理宏取得相应哈希表项
     tHashElement *pElement = NULL;
     HASH_FIND_INT(m_pTargets, &pTarget, pElement);
     //如果能找到哈希表项
     if (pElement)
     {
         //取得哈希表项的动画集中的动画数量
         unsigned int limit = pElement->actions->num;
         //遍历动画集中的所有动画
         for (unsigned int i = 0; i < limit; ++i)
         {
             //取得每一项动画
             CCAction *pAction = (CCAction*)pElement->actions->arr[i];
             //查看是否是指定演员的指定动画。
             if (pAction->getTag() == (int)tag && pAction->getOriginalTarget() == pTarget)
             {
                   //如果是，则删除此项。
                 removeActionAtIndex(i, pElement);
                 break;
             }
         }
     }
 }

 //取得指定演员的指定动画
 CCAction* CCActionManager::getActionByTag(unsigned int tag, CCObject *pTarget)
 {
     //有效性判断
     CCAssert((int)tag != kCCActionTagInvalid, "");
     //定义哈希表项指针变量，并通过哈希表处理宏取得相应哈希表项
     tHashElement *pElement = NULL;
     HASH_FIND_INT(m_pTargets, &pTarget, pElement);
     //如果能找到哈希表项
     if (pElement)
     {
          //如果此哈希表项的动画集不为空
         if (pElement->actions != NULL)
         {
             //取得哈希表项的动画集中的动画数量
             unsigned int limit = pElement->actions->num;
         //遍历动画集中的所有动画

             for (unsigned int i = 0; i < limit; ++i)
             {
                 //取得每一项动画
                CCAction *pAction = (CCAction*)pElement->actions->arr[i];
                 //查看是否是指定动画。
                 if (pAction->getTag() == (int)tag)
                 {
                     return pAction;
                 }
             }
         }
         CCLOG("cocos2d : getActionByTag: Action not found");
     }
     else
     {
         // CCLOG("cocos2d : getActionByTag: Target not found");
     }
     //找不到要找的动画。返回NULL。
     return NULL;
 }
 //取得指定演员的动画集中的动画数量
 unsigned int CCActionManager::numberOfRunningActionsInTarget(CCObject *pTarget)
 {

     //定义哈希表项指针变量，并通过哈希表处理宏取得相应哈希表项
     tHashElement *pElement = NULL;
     HASH_FIND_INT(m_pTargets, &pTarget, pElement);
     if (pElement)
     {
          //如果找到了，判断动画集是否为空，如果不为空返回动画数量，否则返回零。
         return pElement->actions ? pElement->actions->num : 0;
     }

     return 0;
 }

 //动画管理器的更新函数。
 void CCActionManager::update(float dt)
 {
     //遍历哈希表的所有项。
     for (tHashElement *elt = m_pTargets; elt != NULL; )
     {
          //将当前哈希表项保存到变量m_pCurrentTarget中。并将此项对应的回收标记m_bCurrentTargetSalvaged 设为false，
         m_pCurrentTarget = elt;
         m_bCurrentTargetSalvaged = false;
          //如果当前项的动画处于播放状态。
         if (! m_pCurrentTarget->paused)
         {
             //遍历当前项的动画集中的所有动画
             for (m_pCurrentTarget->actionIndex = 0; m_pCurrentTarget->actionIndex < m_pCurrentTarget->actions->num;
                 m_pCurrentTarget->actionIndex++)
             {
                   //取得遍历项的动画
                 m_pCurrentTarget->currentAction = (CCAction*)m_pCurrentTarget->actions->arr[m_pCurrentTarget->actionIndex];
                   //如果遍历项动画为空，跳过后遍历下一个动画。
                 if (m_pCurrentTarget->currentAction == NULL)
                 {
                     continue;
                 }
                   //设置回收标记为false。
                 m_pCurrentTarget->currentActionSalvaged = false;
                   //更新当前动画的播放
                 m_pCurrentTarget->currentAction->step(dt);
                   //如果当前项的回收标记为true，则进行释放处理。
                 if (m_pCurrentTarget->currentActionSalvaged)
                 {
                     m_pCurrentTarget->currentAction->release();
                 } else
                 if (m_pCurrentTarget->currentAction->isDone())
                 {   //如果当前动画处于结束状态，则停止动画
                     m_pCurrentTarget->currentAction->stop();
                        //为了在removeAction中正确释放动画，这里先创建一个临时变量pAction记录一下要释放的动画。
                     CCAction *pAction = m_pCurrentTarget->currentAction;
                     //在removeAction之前将当前哈希表项中的当前动画设为NULL，否则不能释放。
                     m_pCurrentTarget->currentAction = NULL;
                     removeAction(pAction);
                 }

                 m_pCurrentTarget->currentAction = NULL;
             }
         }

         //使for循环能够继续
         elt = (tHashElement*)(elt->hh.next);

         // 如果当前哈希表项处于回收状态且其动画集为空，删除此哈希表项。
         if (m_bCurrentTargetSalvaged && m_pCurrentTarget->actions->num == 0)
         {
             deleteHashElement(m_pCurrentTarget);
         }
     }

     // 将变量m_pCurrentTarge置空。
     m_pCurrentTarget = NULL;
 }

 NS_CC_END

     动画管理器的代码读完了，大概了解了它的功能，但它在哪里使用呢？我们可以打开显示设备管理器CCDirector类的头文件，在其中找到：

CC_PROPERTY(CCActionManager*,m_pActionManager, ActionManager);

并在CPP中搜索m_pActionManager：

 

  C:\cocos2d-2.0-x-2.0.2\cocos2dx\CCDirector.cpp(145):    m_pActionManager = new CCActionManager();

 C:\cocos2d-2.0-x-2.0.2\cocos2dx\CCDirector.cpp(146):   m_pScheduler->scheduleUpdateForTarget(m_pActionManager,kCCPrioritySystem, false);

  C:\cocos2d-2.0-x-2.0.2\cocos2dx\CCDirector.cpp(175):    CC_SAFE_RELEASE(m_pActionManager);

 C:\cocos2d-2.0-x-2.0.2\cocos2dx\CCDirector.cpp(887):    if (m_pActionManager != pActionManager)

 C:\cocos2d-2.0-x-2.0.2\cocos2dx\CCDirector.cpp(890):        CC_SAFE_RELEASE(m_pActionManager);

 C:\cocos2d-2.0-x-2.0.2\cocos2dx\CCDirector.cpp(891):        m_pActionManager = pActionManager;

 C:\cocos2d-2.0-x-2.0.2\cocos2dx\CCDirector.cpp(897):    return m_pActionManager;

 

    第一句在init函数中创建动画管理器。

    第二句在创建后将其加入系统更新函数要调用更新的对象。

    第三句在析构函数中释放动画管理器。

    第四，五，六句在setActionManager中更改动画管理器。

    第七句是取得动画管理器。

    这其中关键是第二句。因为有了它，所以动画管理器的update才会被调用。这样，我们在动画管理器的Update中加断点，启动程序，你可以发现中断并显示调用堆栈。

 

 

    流程是这样的: 在CCApplication的run函数中，显示设备链调用相应的场景显示函数drawScene来绘制场景，然后调用了CCScheduler的update函数，在这个函数里，对所有注册要调用update的对象指针进行遍历并调用其update函数，而CCActionManager的update会对所有演员的动作调用step函数，最终实现各个动画的播放。

    好了，我们现在呼吸一下，听我把这个背后的故事讲给大家。

 

    CCAction 是 动画基类，它派生出了很多可爱的动画类型，当你要让某个演员去表现一个动画的时候，你就对这个演员使用“runAction”来表演对应的动画。这个演员在收到你的指令后，它把自已的名字（其实是自已的指针）和这个动画一起告诉了显示部门长官—“设备管理器”手下的成员之一  -- “动画管理器”，“动画管理器”这家伙在收到演员的需求后，就答应在每一次刷新时更新相应的动画。

 

    你懂了么？如果懂了？咱们就暂时休息一下。后面还有两斧子。