cocos2d-x学习笔记08：动作1：立即动作

时间：2023-02-08 13:00:48
cocos2d-x学习笔记08：动作1：立即动作 cocos2d-x学习笔记08：动作1：立即动作2012-01-12 12:18:34 标签：cocos2d-x 立即动作 cocos2d-x学习笔记08：动作1：立即动作 原创作品，允许转载，转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。http://4137613.blog.51cto.com/4127613/762321

 cocos2d-x学习笔记08：动作1：立即动作


第一部分：动作概述动作可以说构成了cocos2dx的精华（你看动作类有多少子类就知道了）。
动作是什么？动作可以理解为指令，这些指令由节点执行。
动作由节点（node）执行，该节点执行动作的时候，他的所有子节点跟着执行，这一特性是非常有用的。
执行动作的代码非常简单，先生成，然后让节点执行：
  
  
    

  1. CCAction *action=.... 
    2. 
   
   
  2. node->runAction(action); 
    3.
 
CCAction及其子类的继承树非常庞大，我们需要一个一个介绍。
CCAction及其子类简图：
cocos2d-x学习笔记08：动作1：立即动作   第二部分：CCActionInstant家族（立即动作）立即动作就是不需要时间,马上就完成的动作。立即动作的共同基类是CCActionInstant。CCActionInstant的常用子类有：
CCFlipX：X轴翻转、CCFlipY：Y轴翻转CCHide：隐藏、CCShow：显示、CCToggleVisibility：切换可视性CCPlace：放置到一个位置 

CCCallFunc家族：回调函数包装器

 


这些类的使用非常简单，就不说了
第三部分：CCCallFunc家族（回调函数包装器）CCCallFunc是CCActionInstant的子类，是非常重要的一个类族，就是适配器。用大白话说，就是做了一层包装，把函数包装成动作，这样你在执行动作的时候，就可以执行函数了。听起来很怪异吗？为什么不直接执行函数呢？这是因为执行条件不同。
我们看个例子：玩家死亡动画（也是个动作）播放完成后，结束游戏。(该例子来自于炸弹人，有改动)
   
   
    

  1. CCAction *sequneceAction = CCSequence::actions( 
    2. 
    
    
  2.                         getAnimate(),//获得死亡动画，自己实现的函数 
    3. 
    
    
  3.                         CCCallFunc::actionWithTarget(this, callfunc_selector(Hero::deadDoneCallback)),//结束游戏用的回调 
    4. 
    
    
  4.                         NULL); 
    5. 
    
    
  5.  
    6. 
    
    
  6. this->runAction( ); 
    7. 
    
    
  7.  
    8. 
    
    
  8. //回调函数的定义 
    9. 
    
    
  9. void Hero::deadDoneCallback() 
    10. 
    
    
  10. { 
    11. 
    
    
  11.             this->setIsVisible(false);//设置节点隐藏，让cocos2dx自身清理，而不是马上清理。 
    12. 
    
    
  12.             CCScene *scene=GameOverScene::scene(); 
    13. 
    
    
  13.             CCDirector::sharedDirector()->replaceScene(CCTransitionFade::transitionWithDuration(1.2f,scene)); 
    14. 
    
    
  14. } 
    15.

其他的代码先不用管它，我们重点是：
  
  
    

  1. CCCallFunc::actionWithTarget(this, callfunc_selector(Hero::deadDoneCallback); 
    2.
cocos2dx中，一般对象都是采用静态方法生成的，我们看这个函数签名：
   
   
    

  1. static CCCallFunc * actionWithTarget(SelectorProtocol* pSelectorTarget, SEL_CallFunc selector); 
    2.
pSelectorTarget是指这个函数的执行对象，这点不要和动作的执行节点搞混，两者可以是一个也可以不是一个。比如这里，我用的是this，那么动作的执行节点和函数的执行对象就是同一个。

    
    
    

  1. void CCCallFunc::execute() { 
    2. 
     
     
  2.             if (m_pCallFunc) { 
    3. 
     
     
  3.                         (m_pSelectorTarget->*m_pCallFunc)(); 
    4. 
     
     
  4.             } 
    5. 
     
     
  5.  
    6. 
     
     
  6.             if (CCScriptEngineManager::sharedScriptEngineManager()->getScriptEngine()) { 
    7. 
     
     
  7.                         CCScriptEngineManager::sharedScriptEngineManager()->getScriptEngine()->executeCallFunc( 
    8. 
     
     
  8.                                                 m_scriptFuncName.c_str()); 
    9. 
     
     
  9.             } 
    10. 
     
     
  10. } 
    11.
上面是CCCallFunc::execute()的源码，m_pSelectorTarget就是之前在签名里绑定的pSelectorTarget，而该动作的执行节点则是另外一个变量m_pTarget    

第四部分：使用CCCallFunc家族的类CCCallFunc家族一共有四个类。这是四个类对象的静态生成函数:
  
  
    

  1. CCCallFunc * CCCallFunc::actionWithTarget(SelectorProtocol* pSelectorTarget,SEL_CallFunc selector); 
    2. 
   
   
  2. CCCallFuncN * CCCallFuncN::actionWithTarget(SelectorProtocol* pSelectorTarget,SEL_CallFuncN selector); 
    3. 
   
   
  3. CCCallFuncND * CCCallFuncND::actionWithTarget(SelectorProtocol* pSelectorTarget,SEL_CallFuncND selector, void* d); 
    4. 
   
   
  4. CCCallFuncO * CCCallFuncO::actionWithTarget(SelectorProtocol* pSelectorTarget,SEL_CallFuncO selector, CCObject* pObject) 
    5.
我们在写的时候，就直接用这四个生成相关的动作对象，然后让节点执行就行。   但是要注意这四个类，分别对应的是四种不同的函数接口，也可以说是他包装了四种不同的回调函数。这四个回调函数的不同主要是参数表的不同。（貌似是废话）我们来看这四个回调函数的类型定义
     
     
    

  1. typedef void (SelectorProtocol::*SEL_CallFunc)(); 
    2. 
      
      
  2. typedef void (SelectorProtocol::*SEL_CallFuncN)(CCNode*); 
    3. 
      
      
  3. typedef void (SelectorProtocol::*SEL_CallFuncND)(CCNode*, void*); 
    4. 
      
      
  4. typedef void (SelectorProtocol::*SEL_CallFuncO)(CCObject*); 
    5.
这四个玩意要解释清楚比较麻烦，这是用typedef定义了类成员函数指针。如果你对C++不熟悉，你不需要搞懂具体什么意思，但你必须保证你的函数签名和这四个其中之一一致。 也就是说，你自己写的回调函数签名，看起来像这样：
      
      
    

  1. void A::f1( ); 
    2. 
       
       
  2. void A::f2(CCNode *node);//接受一个节点，该节点是动作的执行节点 
    3. 
       
       
  3. void A::f3(CCNode *node,void *param);//接受动作的执行节点，还有一个void参数 
    4. 
       
       
  4. void A::f4(CCObject* obj);//接受一个CCObject对象指针 
    5.
你可以在回调函数里操作这些被传进来的参数。
另外，在用静态函数生成动作的时候，你需要使用一个宏，来帮助转换函数指针类型，就是上面那个callfunc_selector，因为有四种类型的回调函数，所以也就有四个类型转换宏
       
       
    

  1. #define callfunc_selector(_SELECTOR) (SEL_CallFunc)(&_SELECTOR) 
    2. 
        
        
  2. #define callfuncN_selector(_SELECTOR) (SEL_CallFuncN)(&_SELECTOR) 
    3. 
        
        
  3. #define callfuncND_selector(_SELECTOR) (SEL_CallFuncND)(&_SELECTOR) 
    4. 
        
        
  4. #define callfuncO_selector(_SELECTOR) (SEL_CallFuncO)(&_SELECTOR) 
    5.

最终，我们写出来的代码看起来像是这样的：
        
        
    

  1. CCAction *a1=CCCallFunc::actionWithTarget(this, callfunc_selector(A::f1)); 
    2. 
         
         
  2. this->runAction(a1); 
    3. 
         
         
  3.  
    4. 
         
         
  4. CCAction *a2=CCCallFuncN::actionWithTarget(this, callfuncN_selector(A::f2)); 
    5. 
         
         
  5. this->runAction(a2); 
    6. 
         
         
  6.  
    7. 
         
         
  7. int i; 
    8. 
         
         
  8. CCAction *a3=CCCallFuncND::actionWithTarget(this, callfuncND_selector(A::f3),(void*)&i); 
    9. 
         
         
  9. this->runAction(a3); 
    10. 
         
         
  10.  
    11. 
         
         
  11. CCObject *obj; 
    12. 
         
         
  12. CCAction *a4=CCCallFuncO::actionWithTarget(this, callfuncO_selector(A::f4),obj); 
    13. 
         
         
  13. this->runAction(a4); 
    14.
标签：

相关文章