文章目录

初始化构造函数
析构函数
删除哈希元素
分配存放动作对象的空间
通过索引移除动作
暂停动作
恢复动作
暂停所有的动作
恢复所有的动作
添加动作
移除所有的动作
移除target中的所有动作
移除动作
通过Tag移除Action
通过Tag移除所有的action
获取指定target下的action个数
获取指定target下的指定tag的action的个数
获取所有在actions列表中的action个数
！ActionManager的刷新函数

初始化构造函数

ActionManager::ActionManager()

: _targets(nullptr),  //目标节点的表头

  _currentTarget(nullptr), //当前正在运行的节点

  _currentTargetSalvaged(false) //释放标记

  {}

typedef struct _hashElement

{

    struct _ccArray     *actions; //和taget绑定的所有action组成的数组

    Node                *target; //执行action的节点

    int                 actionIndex; //actions的索引

    Action              *currentAction; //当前正在执行的action，（异步线程才会用到

    bool                currentActionSalvaged; //释放标记（异步线程使用

    bool                paused; //是否暂停

    UT_hash_handle      hh; //哈希表的句柄

} tHashElement;

在调用了node->runAction后，ActionManager会将node和action信息加入到hash表中。在ActionManger的update函数中遍历_targets的所有元素，并执行和每个target绑定的actions，然后对actions遍历执行step。

在Direction的初始化时调用_scheduler->scheduleUpdate(_actionManager, Scheduler::PRIORITY_SYSTEM, false);

保证了每帧都会调用ActionManager的update方法

析构函数

ActionManager::~ActionManager()

{

    CCLOGINFO("deallocing ActionManager: %p", this);

    removeAllActions(); //移除所有的动作

}

删除哈希元素

void ActionManager::deleteHashElement(tHashElement *element)

{

    ccArrayFree(element->actions); //释放element的所有动作

    HASH_DEL(_targets, element); //从targets中删除element

    element->target->release(); //target引用计数-1

    free(element); //释放element的内存空间

}

分配存放动作对象的空间

void ActionManager::actionAllocWithHashElement(tHashElement *element)

{

    // 4 actions per Node by default

    if (element->actions == nullptr)  //如果当前动作数组为空则分配四个空间

    {

        element->actions = ccArrayNew(4);

    }else

    if (element->actions->num == element->actions->max) //如果将要超过最大容量，就将内存加倍

    {

        ccArrayDoubleCapacity(element->actions);

    }

}

通过索引移除动作

除了移除全部动作的方法以外，都是调用这个方法来移除action

void ActionManager::removeActionAtIndex(ssize_t index, tHashElement *element)

{

	//获取要移除的action对象

    Action *action = static_cast<Action*>(element->actions->arr[index]);

	//判断是否是正在运行的action，一般不会进入这个判断，

	//除非是正在执行update的step的时候，异步线程调用了remove来移除正在执行的这个action，

	//才会进到这个判断中，currentActionSalvaged就是一个安全锁，确保了动作执行不会出错

    if (action == element->currentAction && (! element->currentActionSalvaged))

    {

        element->currentAction->retain(); //引用计数+1

        element->currentActionSalvaged = true; //标记将要删除

    }

	//从actions中移除索引index的action

    ccArrayRemoveObjectAtIndex(element->actions, index, true);

    // update actionIndex in case we are in tick. looping over the actions

    if (element->actionIndex >= index)

    {

    	//索引总数-1

        element->actionIndex--;

    }

	//如果节点没有动作，将节点删除(延迟删除和立即删除)

    if (element->actions->num == 0)

    {

        if (_currentTarget == element)

        {

            _currentTargetSalvaged = true;

        }

        else

        {

            deleteHashElement(element);

        }

    }

}

暂停动作

void ActionManager::pauseTarget(Node *target)

{

    tHashElement *element = nullptr;

    HASH_FIND_PTR(_targets, &target, element);//找到目标节点返回element

    if (element)//标记暂停

    {

        element->paused = true;

    }

}

恢复动作

void ActionManager::resumeTarget(Node *target)

{

    tHashElement *element = nullptr;

    HASH_FIND_PTR(_targets, &target, element);//找到目标节点返回element

    if (element) //标记不暂停

    {

        element->paused = false;

    }

}

暂停所有的动作

Vector<Node*> ActionManager::pauseAllRunningActions()

{

    Vector<Node*> idsWithActions;

    for (tHashElement *element=_targets; element != nullptr; element = (tHashElement *)element->hh.next)  //遍历target链表，paused是true就修改为false

    {

        if (! element->paused)

        {

            element->paused = true;

            idsWithActions.pushBack(element->target);

        }

    }    

    return idsWithActions;

}

恢复所有的动作

void ActionManager::resumeTargets(const Vector<Node*>& targetsToResume)

{

    for(const auto &node : targetsToResume)//遍历所有的target，将其中的所有pause设为false

    {

        this->resumeTarget(node);

    }

}

添加动作

void ActionManager::addAction(Action *action, Node *target, bool paused)

{

    CCASSERT(action != nullptr, "action can't be nullptr!");

    CCASSERT(target != nullptr, "target can't be nullptr!");

    if(action == nullptr || target == nullptr)

        return;

    tHashElement *element = nullptr;

    // we should convert it to Ref*, because we save it as Ref*

    Ref *tmp = target;

    //在target列表中查找需要的target，返回element

    HASH_FIND_PTR(_targets, &tmp, element);

    //如果没查到，就新建一个element 并且初始化

    if (! element)

    {

        element = (tHashElement*)calloc(sizeof(*element), 1);

        element->paused = paused;

        target->retain();

        element->target = target;

        HASH_ADD_PTR(_targets, target, element); //创建新的表头

    }

     actionAllocWithHashElement(element);  //target创建存储动作的列表，如果放不下了，让空间加倍

     CCASSERT(! ccArrayContainsObject(element->actions, action), "action already be added!");//判断是否已经加入列表中

     ccArrayAppendObject(element->actions, action);//将action加入actions数组中

     action->startWithTarget(target); //（重新）设定action的target

}

移除所有的动作

void ActionManager::removeAllActions()

{

    for (tHashElement *element = _targets; element != nullptr; )//清空所有的target的动作

    {

        auto target = element->target;

        element = (tHashElement*)element->hh.next;

        removeAllActionsFromTarget(target);

    }

}

移除target中的所有动作

void ActionManager::removeAllActionsFromTarget(Node *target)

{

    // explicit null handling

    if (target == nullptr)

    {

        return;

    }

		//在target列表中查找目标target

    tHashElement *element = nullptr;

    HASH_FIND_PTR(_targets, &target, element);

  	//找到目标

    if (element)

    {

      //并且当前的action在action列表中，并且没有被标记为Salvaged

      //salvaged标记的意义是，当前动作需要被释放，但它还没有完成，需要完成之后在释放，所以先做标记，之后动作完成之后释放，类似于延迟release

        if (ccArrayContainsObject(element->actions, element->currentAction) && (! element->currentActionSalvaged))

        {

            element->currentAction->retain();

            element->currentActionSalvaged = true;

        }

        ccArrayRemoveAllObjects(element->actions);//移除目标节点的所有动作

     		 /*

     			 while (arr->num > 0)

    			{

							(arr->arr[--arr->num])->release();

    			}

    			*/

    	//当前节点的动作都被移除了，节点没有作用了，之后也会被删除

        if (_currentTarget == element)

        {

            _currentTargetSalvaged = true; //当前正在运行，之后移除

        }

        else

        {

            deleteHashElement(element); //不在运行，立即release

        }

    }

}

移除动作

void ActionManager::removeAction(Action *action)

{

    // explicit null handling

    if (action == nullptr)

    {

        return;

    }

    tHashElement *element = nullptr;

    Ref *target = action->getOriginalTarget();//获取和动作绑定的节点

    HASH_FIND_PTR(_targets, &target, element);

  	//在actions数组中查找需要移除的action，找到就移除

  	if (element)

    {

        auto i = ccArrayGetIndexOfObject(element->actions, action);

        if (i != CC_INVALID_INDEX)

        {

            removeActionAtIndex(i, element);

        }

    }

}

通过Tag移除Action

void ActionManager::removeActionByTag(int tag, Node *target)

{

    CCASSERT(tag != Action::INVALID_TAG, "Invalid tag value!");

    CCASSERT(target != nullptr, "target can't be nullptr!");

    if (target == nullptr)

    {

        return;

    }

    tHashElement *element = nullptr;

    //在target列表中查找需要的target，返回element+

    HASH_FIND_PTR(_targets, &target, element);

    if (element)

    {

        auto limit = element->actions->num; //获取action的个数

        for (int i = 0; i < limit; ++i) //遍历action，找到对应的tag即删除action

        {

            Action *action = static_cast<Action*>(element->actions->arr[i]);

            if (action->getTag() == (int)tag && action->getOriginalTarget() == target)

            {

                removeActionAtIndex(i, element);

                break;

            }

        }

    }

}

通过Tag移除所有的action

void ActionManager::removeAllActionsByTag(int tag, Node *target)

{

    CCASSERT(tag != Action::INVALID_TAG, "Invalid tag value!");

    CCASSERT(target != nullptr, "target can't be nullptr!");

    if (target == nullptr)

    {

        return;

    }

    tHashElement *element = nullptr;

    HASH_FIND_PTR(_targets, &target, element); 

    if (element)

    {

        auto limit = element->actions->num;

        for (int i = 0; i < limit;)  //遍历动作列表，删除所有与需要删除的tag匹配的action

        {

            Action *action = static_cast<Action*>(element->actions->arr[i]);

            if (action->getTag() == (int)tag && action->getOriginalTarget() == target)

            {

                removeActionAtIndex(i, element);

                --limit;

            }

            else

            {

                ++i;

            }

        }

    }

}

获取指定target下的action个数

ssize_t ActionManager::getNumberOfRunningActionsInTarget(const Node *target) const

{

    tHashElement *element = nullptr;

    HASH_FIND_PTR(_targets, &target, element);

    if (element)

    {

        return element->actions ? element->actions->num : 0;

    }

    return 0;

}

获取指定target下的指定tag的action的个数

size_t ActionManager::getNumberOfRunningActionsInTargetByTag(const Node *target,

                                                             int tag)

{

    CCASSERT(tag != Action::INVALID_TAG, "Invalid tag value!");

    tHashElement *element = nullptr;

    HASH_FIND_PTR(_targets, &target, element);

    if(!element || !element->actions)

        return 0;

    int count = 0;

    auto limit = element->actions->num;

    for(int i = 0; i < limit; ++i) //循环action列表，tag符合则计数器+1

    {

        auto action = static_cast<Action*>(element->actions->arr[i]);

        if(action->getTag() == tag)

            ++count;

    }

    return count;

}

获取所有在actions列表中的action个数

ssize_t ActionManager::getNumberOfRunningActions() const

{

    ssize_t count = 0;

    struct _hashElement* element = nullptr;

    struct _hashElement* tmp = nullptr;

    HASH_ITER(hh, _targets, element, tmp)//循环target列表

    {

        count += (element->actions ? element->actions->num : 0);

    }

    return count;

}

！ActionManager的刷新函数

void ActionManager::update(float dt)

{

	//遍历targets

    for (tHashElement *elt = _targets; elt != nullptr; )

    {

        _currentTarget = elt; //将当前遍历到的target保存为currentTarget

        _currentTargetSalvaged = false;//将延迟删除标记设为false

        if (! _currentTarget->paused) //如果不是暂停状态

        {

            // The 'actions' MutableArray may change while inside this loop.

            //遍历当前节点的所有action

            for (_currentTarget->actionIndex = 0; _currentTarget->actionIndex < _currentTarget->actions->num;

                _currentTarget->actionIndex++)

            {

              	//获取当前action

                _currentTarget->currentAction = static_cast<Action*>(_currentTarget->actions->arr[_currentTarget->actionIndex]);

              	//如果当前节点的当前动作是空，则遍历下一个action

                if (_currentTarget->currentAction == nullptr)

                {

                    continue;

                }

                //先设置释放标记为false

                _currentTarget->currentActionSalvaged = false;

				//刷新当前动作的进程(根据经过时间和设置的时间判断动作需要执行多少)

                _currentTarget->currentAction->step(dt);

				//如果被标记为需要释放则释放(正常不会)

                if (_currentTarget->currentActionSalvaged)

                {

                    // The currentAction told the node to remove it. To prevent the action from

                    // accidentally deallocating itself before finishing its step, we retained

                    // it. Now that step is done, it's safe to release it.

                    //对应上面延时删除时的retain

                    _currentTarget->currentAction->release();

                } else

                //否则判断是否已经完成 ，完成则停止动作

                if (_currentTarget->currentAction->isDone())

                {

                    _currentTarget->currentAction->stop();

					//获取当前action对象

                    Action *action = _currentTarget->currentAction;

                    // Make currentAction nil to prevent removeAction from salvaging it.

					//将当前动作变量设置为空

                    _currentTarget->currentAction = nullptr;

                    removeAction(action);//释放临时变量中已经完成的action

                }

				//初始化currentAction变量

                _currentTarget->currentAction = nullptr;

            }

        }

        // elt, at this moment, is still valid

        // so it is safe to ask this here (issue #490)

      	//取得下一个target

        elt = (tHashElement*)(elt->hh.next);

        // only delete currentTarget if no actions were scheduled during the cycle (issue #481)

      	//如果当前target被标记为需要释放，并且当前节点的动作列表为空，则立即释放当前节点

        if (_currentTargetSalvaged && _currentTarget->actions->num == 0)

        {

            deleteHashElement(_currentTarget);

        }

        //if some node reference 'target', it's reference count >= 2 (issues #14050)

        //否则判断其引用标记是否为1，是则释放当前节点

        else if (_currentTarget->target->getReferenceCount() == 1)

        {

            deleteHashElement(_currentTarget);

        }

    }

    // issue #635

  	//遍历结束，哈希表中的当前节点指针设置为空

    _currentTarget = nullptr;

}

1、actionAllocationWithHashElement方法用来给element的动作容器第一次创建空间，并且会判断当前的actions数组能不能放得下了，放不下了会扩容，容量加倍

2、removeActionAtIndex中会通过index移除对应的action，如果移除的这个action是当前正在使用的，会retain住，并且设Salvaged为true，但还是会从actions数组中移除这个action。如果element中的actions容器也空了，并且这个element是正在使用的，会给它的salvaged设为true，在update的时候再删除(延时删除)。

3、startWithTarget主要是设置执行action的target，但会根据不同的action再执行更多的操作，比如rotateBy的startWithTarget调用了actionInterval的startWithTarget

(actionInterval的startWithTarget又执行了①FiniteTimeAction的startWithTarget，而FiniteTimeAction没有重写这个方法，实际调用的是Action的这个方法，用来设置执行aciton的target，当调用stop的时候会将target设为空。②设置了执行的时间elapsed为0。③设置了第一次执行的标记firstTick。④设置了执行完成标记done为false)，

然后又设置了旋转x和y的角度。

4、removeAllAction中遍历了ActionManager中的targets来对每个元素都执行removeAllActionsFromTarget方法，从这里我们可以看到所有绑定了action的target都被放在了targets中，大概可以看出来ActionManager的部分结构。再接着往下看removeAllActionsFromTarget，在这个方法中先查找targets中是否存在要移除action的那个target；然后又判断了要移除的actions中有没有正在执行的action，如果有就ratain住不让它被删除，然后标记为待删除，延时删除，这里猜测在update中可能会有对标记为待删除的对象统一处理的代码，后面再看；然后对action容器中所有对象都release，除了上面retain的没有被删除外，都被删除了；最后判断了target是不是也正在使用，如果是，就标记为延时删除，否则release删除掉，因为actions如果已经空了，那target在ActionManager中存在就没有意义了，如果有正在执行的action，这里肯定是正在执行动作的target，延时删除它。

5、遍历targets中所有的元素(target) ，初始化延时标记为false，如果没有被暂停，遍历当前target的actions容器；

先获取当前正在执行的动作，判断是否存在，判断是不是空的，如果不是空，会将actionSalvaged置为false，然后执行action的step，刷新动作的进程；

下面判断了动作的salvaged，一般是false，只有在多线程的时候才可能会在这句代码之前执行了remove的操作，可能会让actionSalvaged变成true；

然后判断了动作是否执行完成了，因为有些动作是持续执行一段时间的，如果执行完了会在step中将done置为true；动作执行完了就执行stop方法，将action的_target设为空，并且移除了这个action；

将currentAction置为空；

往后递增；

下面判断了几个数组是不是空的，是就移除；

最后将currentTarget置为空；

ActionManager刷新方法中需要注意的是actionSalvaged标记，这个是安全锁，在update中我们可以看到它先被置为false，然后才判断是不是true，正常来说是不会执行这一步if的，但是如果在step中，也就是action正在执行的时候，异步线程执行了remove操作，就会在step的下面对执行完的action进行remove，保证的线程的安全。正常来说，如果要移除action，在removeActionAtIndex或者removeAllActions中是可以直接移除的。

如果这样写

断点之后会发现，在执行remove的时候currentTarget和currenAction都是空的，因为remove是在两次update中间执行的。

最后我们会发现ActionManager的结构是这样的：

巴特西

从零开始のcocos2dx生活（四）ActionManager