1 /** 
 2 @brief Base class for CCAction objects.
 3  */
 4 class CC_DLL CCAction : public CCObject 
 5 {
 6 public:
 7     CCAction(void);
 8     virtual ~CCAction(void);
 9 
10     char * description();
11 
12     virtual CCObject* copyWithZone(CCZone *pZone);
13 
14     //! return true if the action has finished
15     virtual bool isDone(void);
16 
17     //! called before the action start. It will also set the target.
18     virtual void startWithTarget(CCNode *pTarget);
19 
20     /** 
21     called after the action has finished. It will set the 'target' to nil.
22     IMPORTANT: You should never call "[action stop]" manually. Instead, use: "target->stopAction(action);"
23     */
24     virtual void stop(void);
25 
26     //! called every frame with it's delta time. DON'T override unless you know what you are doing.
27     virtual void step(ccTime dt);
28 
29     /** 
30     called once per frame. time a value between 0 and 1
31 
32     For example: 
33     - 0 means that the action just started
34     - 0.5 means that the action is in the middle
35     - 1 means that the action is over
36     */
37     virtual void update(ccTime time);
38     
39     inline CCNode* getTarget(void) { return m_pTarget; }
40     /** The action will modify the target properties. */
41     inline void setTarget(CCNode *pTarget) { m_pTarget = pTarget; }
42     
43     inline CCNode* getOriginalTarget(void) { return m_pOriginalTarget; } 
44     /** Set the original target, since target can be nil.
45     Is the target that were used to run the action.
46     Unless you are doing something complex, like CCActionManager, you should NOT call this method.
47     The target is 'assigned', it is not 'retained'.
48     @since v0.8.2
49     */
50     inline void setOriginalTarget(CCNode *pOriginalTarget) { m_pOriginalTarget = pOriginalTarget; }
51 
52     inline int getTag(void) { return m_nTag; }
53     inline void setTag(int nTag) { m_nTag = nTag; }
54 
55 public:
56     /** Allocates and initializes the action */
57     static CCAction* action();
58 
59 protected:
60     CCNode    *m_pOriginalTarget;
61     /** The "target".
62     The target will be set with the 'startWithTarget' method.
63     When the 'stop' method is called, target will be set to nil.
64     The target is 'assigned', it is not 'retained'.
65     */
66     CCNode    *m_pTarget;
67     /** The action tag. An identifier of the action */
68     int       m_nTag;
69 };

1 char * CCAction::description()
2 {
3     char *ret = new char[100] ;
4     sprintf(ret,"<CCAction | Tag = %d>", m_nTag);
5     return ret;
6 }

 1 CCAction * CCNode::runAction(CCAction* action)
 2 {
 3     CCAssert( action != NULL, "Argument must be non-nil");
 4     CCActionManager::sharedManager()->addAction(action, this, !m_bIsRunning);
 5     return action;
 6 }
 7 
 8 void CCActionManager::addAction(CCAction *pAction, CCNode *pTarget, bool paused)
 9 {
10     CCAssert(pAction != NULL, "");
11     CCAssert(pTarget != NULL, "");
12 
13     tHashElement *pElement = NULL;
14     // we should convert it to CCObject*, because we save it as CCObject*
15     CCObject *tmp = pTarget;
16     HASH_FIND_INT(m_pTargets, &tmp, pElement);
17     if (! pElement)
18     {
19         pElement = (tHashElement*)calloc(sizeof(*pElement), 1);
20         pElement->paused = paused;
21         pTarget->retain();
22         pElement->target = pTarget;
23         HASH_ADD_INT(m_pTargets, target, pElement);
24     }
25 
26     actionAllocWithHashElement(pElement);
27 
28     CCAssert(! ccArrayContainsObject(pElement->actions, pAction), "");
29     ccArrayAppendObject(pElement->actions, pAction);
30 
31     pAction->startWithTarget(pTarget);
32 }

 1 // main loop
 2 void CCActionManager::update(ccTime dt)
 3 {
 4     for (tHashElement *elt = m_pTargets; elt != NULL; )
 5     {
 6         m_pCurrentTarget = elt;
 7         m_bCurrentTargetSalvaged = false;
 8 
 9         if (! m_pCurrentTarget->paused)
10         {
11             // The 'actions' CCMutableArray may change while inside this loop.
12             for (m_pCurrentTarget->actionIndex = 0;
                   m_pCurrentTarget->actionIndex < m_pCurrentTarget->actions->num;
13                 m_pCurrentTarget->actionIndex++)
14             {
15                 m_pCurrentTarget->currentAction =
                   (CCAction*)m_pCurrentTarget->actions->arr[m_pCurrentTarget->actionIndex];
16                 if (m_pCurrentTarget->currentAction == NULL)
17                 {
18                     continue;
19                 }
20 
21                 m_pCurrentTarget->currentActionSalvaged = false;
22 
23                 m_pCurrentTarget->currentAction->step(dt);
24 
25                 if (m_pCurrentTarget->currentActionSalvaged)
26                 {
27                     // The currentAction told the node to remove it. To prevent the action from
28                     // accidentally deallocating itself before finishing its step, we retained
29                     // it. Now that step is done, it's safe to release it.
30                     m_pCurrentTarget->currentAction->release();
31                 } else
32                 if (m_pCurrentTarget->currentAction->isDone())
33                 {
34                     m_pCurrentTarget->currentAction->stop();
35 
36                     CCAction *pAction = m_pCurrentTarget->currentAction;
37                     // Make currentAction nil to prevent removeAction from salvaging it.
38                     m_pCurrentTarget->currentAction = NULL;
39                     removeAction(pAction);
40                 }
41 
42                 m_pCurrentTarget->currentAction = NULL;
43             }
44         }
45 
46         // elt, at this moment, is still valid
47         // so it is safe to ask this here (issue #490)
48         elt = (tHashElement*)(elt->hh.next);
49 
50         // only delete currentTarget if no actions were scheduled during the cycle (issue #481)
51         if (m_bCurrentTargetSalvaged && m_pCurrentTarget->actions->num == 0)
52         {
53             deleteHashElement(m_pCurrentTarget);
54         }
55     }
56 
57     // issue #635
58     m_pCurrentTarget = NULL;
59 }

1 bool CCActionManager::init(void)
2 {
3     CCScheduler::sharedScheduler()->scheduleUpdateForTarget(this, 0, false);
4     m_pTargets = NULL;
5     return true;
6 }