我们先看下CCAction的继承关系：

可以看到整个继承关系图比较复杂。下面我们就逐一讲解。可以看出CCAction继承自CCobject，CCAction又派生了4个子类，
CCFiniteTimeAction：有限次动作执行类，就是按时间顺序执行一系列动作，执行完后动作结束；

CCSpeed：调整实体(节点)的执行速度；

CCFollow：可以使节点跟随指定的另一个节点移动。下面我们主要来学习CCFiniteTimeAction，这个类在平常的开发中很常见。
CCFiniteTimeAction又分为CCActionInstanse（瞬时动作的基类）和CCActionInterval（延时动作的基类）。

CCActionInstanse：没什么特别，跟CCActionInterval主要区别是没有执行过程，动作瞬间就执行完成了；

CCActionInterval：执行需要一定的时间（或者说一个过程）。我们用的最多的就是延时动作，下面对它进行单独介绍。

我们先看下源代码CCAction的实现：

CCAction

（此处就不贴代码了，见cocos2dx源码文件CCAction.h）。从中我们可以看到CCAction继承CCObject，所以重写了copyWithZone函数。CCAction有许多内敛函数，都是实现内部变量的设置和获取，比如设置动作的tag以及Target。同时CCAction也是有create的静态成员函数。

CCFiniteTimeAction

继承自CCAction，同时添加了一个float的变量，表示动作的持续时间。以及一个虚函数reverse，表示动作的反序进行。根据上面的类结构图，CCActionInterval的子类有很多，可以通过cocos2d-x自带的tests例子来学习，主要有这些动作：移动(CCMoveTo/CCMoveBy)、缩放(CCScaleTo/CCScaleBy)、旋转(CCRotateTO/CCRotateBy)、扭曲(CCSkewTo/CCSkewBy)、跳跃(CCJumpTo/CCJumpBy)、贝塞尔曲线(CCBezierTo/CCBezierBy)、闪烁(CCBink)、淡入淡出(CCFadeIn/CCFadeOut)、染色(CCTintTo/CCTintBy)等，还可以把上面这些动作的几个组合成一个序列。

CCMoveTo和CCMoveBy
移动精灵，两者的区别在于：CCMoveTo是移动到指定坐标，CCMoveBy是相对坐标。如ccp(50,50)，前者表示移动到x=50，y=50处，后者表示向x方向移动50个单位，向y方向移动50个单位。实例代码如下：

http://bbs.9ria.com/thread-199302-1-1.html

1. bool HelloWorld::init()
   
2. {
   
3. //////////////////////////////
   
4. // 1. super init first
   
5. if ( !CCLayer::init() )
   
6. {
   
7. return false;
   
8. }
   
9. 
   
10. CCSprite * sp= CCSprite::create("Icon.png");
    
11. sp->setPosition(ccp(150,150));
    
12. addChild(sp,922);
    
13. //// Action动作
    
14. //
    
15. ////CCMoveBy创建一个移动的动作 参数1：移动到目标坐标所需的时间 参数2：目标坐标 支持reverse 可以获取其反向动作
    
16. //// CCMoveTo一样的
    
17. // CCActionInterval * moveBy = CCMoveBy::create(5,ccp(300,100));
    
18. // CCActionInterval * actionmoveback= moveBy->reverse();
    
19. // sp->runAction(actionmoveback);
    
20. //// CCScaleTo 作用：创建一个缩放的动作
    
21. //// 参数1：达到缩放大小所需的时间
    
22. //// 参数2 ：缩放的比例
    
23. // CCActionInterval * scaleto = CCScaleTo ::create(2,2);
    
24. // sp->runAction(scaleto);
    
25. //// CCScaleBy作用:创建一个缩放的动作
    
26. //// 参数1：达到缩放大小的所需时间参数2：缩放比例
    
27. // CCActionInterval * scaleby = CCScaleBy::create(2,serif; font-size:12px; line-height:1.8em"> // CCActionInterval * actionbyback = scaleby->reverse();
    
28. // sp->runAction(actionbyback);
    
29. //// CCRotateTo
    
30. //// 作用创建一个旋转的动作
    
31. //// 参数1：旋转的时间参数2：旋转饿角度0 - 360
    
32. // CCActionInterval * rotateto = CCRotateTo::create(2,90);
    
33. // sp->runAction(rotateto);
    
34. ////CCSkewTo
    
35. //// 作用创建一个倾斜的动作
    
36. //// 参数1：倾斜到特定角度所需的时间
    
37. //// 参数2：x轴的倾斜角度
    
38. //// 参数3：y轴的倾斜角度
    
39. // CCActionInterval * skewto = CCSkewTo::create(2,10,10);
    
40. // sp->runAction(skewto);
    
41. //// CCJumpTo
    
42. //// 作用：创建一个跳的动作
    
43. //// 参数1：跳到目标动作位子的所需时间
    
44. //// 参数2：目标位置
    
45. //// 参数3：跳的高度
    
46. //// 参数4跳到目标位置的次数
    
47. // CCActionInterval* jumpto = CCJumpTo ::create(2,200),50,4 );
    
48. // sp->runAction(jumpto);
    
49. //// CCJumpBy
    
50. // // 作用：创建一个跳的动作
    
51. // // 参数1：跳到目标动作位子的所需时间
    
52. // // 参数2：目标位置
    
53. // // 参数3：跳的高度
    
54. // // 参数4跳到目标位置的次数
    
55. //// 这个支持方向动作reverse
    
56. // CCActionInterval * jumpby = CCJumpBy ::create(3,4);
    
57. // CCActionInterval * ac= jumpby->reverse();
    
58. // sp->runAction(ac);
    
59. 
    
60. // CCBezier
    
61. //ccBezierConfig结构体
    
62. // ccBezierConfig bezierCon;
    
63. // bezierCon.controlPoint_1=CCPointMake(200,150);//控制点1
    
64. // bezierCon.controlPoint_2=CCPointMake(200,160);//控制点2
    
65. // bezierCon.endPosition =CCPointMake(340,100);// 结束位置
    
66. // CCBezierTo
    
67. // 创建一个贝塞尔曲线运动的动作
    
68. // 参数1：贝塞尔曲线运动的时间
    
69. // 参数2 ：ccBezierConfig结构体
    
70. // CCActionInterval * action = CCBezierTo::create(2,bezierCon);
    
71. // CCActionInterval * action = CCBezierBy::create(3,bezierCon);//支持反向
    
72. // CCActionInterval * action1 = action->reverse();
    
73. // sp->runAction(action1);
    
74. // CCFadeIn
    
75. // 作用：创建一个渐变出现的动作
    
76. // 参数是时间
    
77. // CCActionInterval * fadein = CCFadeIn::create(2);
    
78. // sp->runAction(fadein);
    
79. // CCFadeOut
    
80. // 作用：创建一个渐变消失的动作
    
81. // 参数是时间
    
82. // CCActionInterval * fadeout = CCFadeOut::create(2);
    
83. // sp->runAction(fadeout);
    
84. //CCTintTo
    
85. // 作用：创建一个色彩变化的消失动作
    
86. // 参数1：色彩变化的动作
    
87. // 参数2 ：红色分量
    
88. // 参数3：蓝色分量
    
89. // CCActionInterval * tinto = CCTintTo ::create(3,255,0);
    
90. // sp->runAction(tinto);
    
91. // CCTintBy
    
92. // 作用：创建一个色彩变化的出现动作
    
93. // 参数1：色彩变化的动作
    
94. // 参数2 ：红色分量
    
95. // 参数3：蓝色分量 但是家了reverse就是 反向的
    
96. // CCActionInterval * tintby = CCTintBy::create(3,255);
    
97. // CCActionInterval * tintby1 = tintby->reverse();
    
98. // sp->runAction(tintby1);
    
99. // CCBlink
    
100. // 作用 :创建一额闪烁的动作
     
101. // 参数1：闪烁完成的时间
     
102. // 参数2:闪烁的次数
     
103. // CCActionInterval * blink = CCBlink ::create(3,serif; font-size:12px; line-height:1.8em"> // sp->runAction(blink);
     
104. // CCDelayTime
     
105. // 创建一个延迟的动作
     
106. // 参数延迟的时间
     
107. // CCActionInterval * delaytime = CCDelayTime::create(3);
     
108. // sp->runAction(delaytime);
     
109. // CCOrbitCamera
     
110. // 作用：创建一个球面坐标轨迹进行旋转的动作
     
111. // 参数1 ： 旋转轨迹的时间
     
112. // 参数2 ：起始半径
     
113. // 参数3：半径差
     
114. // 参数4：起始z角
     
115. // 参数5：旋转z角的差
     
116. // 参数6：起始x角
     
117. // 参数7：旋转x角的差
     
118. // CCActionInterval * orbitcamera = CCOrbitCamera::create(3,45,180,90,serif; font-size:12px; line-height:1.8em"> // sp->runAction(orbitcamera);
     
119. // CCCardinalSpline
     
120. // 作用：创建数组点的数组
     
121. CCPointArray * array = CCPointArray::create(20);
     
122. array->addControlPoint(ccp(0,0));
     
123. array->addControlPoint(ccp(210,240));
     
124. array->addControlPoint(ccp(0,160));
     
125. // CCCardinalSplineTo
     
126. // 作用：创建一个样条曲线轨迹的动作
     
127. // 参数1：完成轨迹所需的时间
     
128. // 参数2：控制点的坐标数组
     
129. // 拟合度其值= 0 路径最柔和
     
130. // CCActionInterval* CardinalSplineTo=CCCardinalSplineTo::create(3,array,serif; font-size:12px; line-height:1.8em"> // sp->runAction(CardinalSplineTo);
     
131. //CCCardinalSplineBy
     
132. // 作用：创建一个样条曲线轨迹的动作
     
133. // 参数1：完成轨迹所需的时间
     
134. // 参数2：控制点的坐标数组
     
135. // 拟合度其值= 0 路径最柔和
     
136. // CCActionInterval * CardinalSplineBy = CCCardinalSplineBy::create(3,serif; font-size:12px; line-height:1.8em"> // sp->runAction(CardinalSplineBy);
     
137. // CCCatmullRomToCCCatmullRomBY
     
138. // 作用：创建一个样条插值轨迹
     
139. // 参数1：完成轨迹的时间
     
140. // 参数2：控制点的数组坐标
     
141. // CCActionInterval * catmullRomTo = CCCatmullRomTo::create(3,array);
     
142. // sp->runAction(catmullRomTo);
     
143. // CCFollow
     
144. // 作用：创建一个跟随动作
     
145. // 参数1：跟随的目标对象
     
146. // 跟随范围，离开范围就不再跟随
     
147. //创建一个参照物spT
     
148. // CCSprite * spt = CCSprite::create("Icon.png");
     
149. // spt->setPosition(ccp(420,40));
     
150. // addChild(spt);
     
151. // sp->runAction(CCMoveTo::create(3,ccp(940,sp->getPositionY())));
     
152. // CCFollow * follow = CCFollow::create(sp,CCRectMake(0,960,320));
     
153. // this-> runAction(follow);
     
154. // CCEaseBounceIn
     
155. // 目标动作
     
156. // CCActionInterval* move = CCMoveTo::create(3,sp->getPositionY()));
     
157. //// 让目标动作缓慢开始
     
158. //// 参数：目标动作
     
159. // CCActionInterval * EaseBounceIn = CCEaseBounceIn::create(move);
     
160. // sp->runAction(EaseBounceIn);
     
161. //CCEaseBounceOut
     
162. // 作用：让目标动作赋予反弹力，且以目标动作结束位子开始反弹
     
163. // 参数目标动作
     
164. // CCActionInterval * easeBounceOut = CCEaseBounceOut ::create(move);
     
165. // sp->runAction(easeBounceOut);
     
166. // CCEaseBounceInOut
     
167. // 作用：让目标动作赋予反弹力，且以目标动作起始与结束位子开始反弹
     
168. // CCActionInterval * easeBounceInOut= CCEaseBounceInOut::create(move);
     
169. // sp->runAction(easeBounceInOut);
     
170. // CCEaseBackIn
     
171. // 作用：让目标动作赋予回力 ， 且以目标动作起点位置作为回力点
     
172. // 参数：目标动作
     
173. // CCActionInterval * easeBackIn = CCEaseBackIn::create(move);
     
174. // sp->runAction(easeBackIn);
     
175. // CCEaseBackOut
     
176. // 作用：让目标动作赋予回力 ， 且以目标动作终点位置作为回力点
     
177. // 参数：目标动作
     
178. // CCActionInterval *easeBackOut = CCEaseBackOut::create(move);
     
179. // sp->runAction(easeBackOut);
     
180. // CCEaseBackInOut
     
181. // 作用：让目标动作赋予回力 ， 且以目标动作起点和终点位置作为回力点
     
182. // CCActionInterval * easeBackInOut = CCEaseBackInOut::create(move);
     
183. // sp->runAction(easeBackInOut);
     
184. // CCEaseElasticIn
     
185. // 作用：让目标动作赋予弹性 ，且以目标动作起点位子赋予弹性
     
186. // 参数：目标动作
     
187. // CCActionInterval * easeElasticIn= CCEaseElasticIn::create(move);
     
188. // sp->runAction(easeElasticIn);
     
189. // CCEaseElasticOut
     
190. // 作用：让目标动作赋予弹性 ，且以目标动作终点位子赋予弹性
     
191. // 参数：目标动作
     
192. // CCActionInterval *easeElasticOut = CCEaseElasticOut::create(move);
     
193. // sp->runAction(easeElasticOut);
     
194. // CCEaseElasticInOut
     
195. // 作用：让目标动作赋予弹性 ，且以目标动作起点和终点位子赋予弹性
     
196. // CCActionInterval *easeElasticInOut = CCEaseElasticOut::create(move);
     
197. // sp->runAction(easeElasticInOut);
     
198. // CCEaseExponentialIn
     
199. // 让目标动作缓慢开始
     
200. // CCActionInterval * easeExponentialIn= CCEaseExponentialIn::create(move);
     
201. // sp->runAction(easeExponentialIn);
     
202. // CCEaseExponentialOut
     
203. // 让目标动作缓慢中止
     
204. // CCActionInterval * easeExponentialIn= CCEaseExponentialOut::create(move);
     
205. // CCEaseExponentialInOut
     
206. // 让目标动作缓慢开始和中止
     
207. // CCActionInterval * easeExponentialInOut= CCEaseExponentialInOut::create(move);
     
208. // sp->runAction(easeExponentialInOut);
     
209. // CCEaseRateAction
     
210. // 作用 ： 让目标动作设置速率
     
211. // 参数1:目标动作
     
212. // 参数2：速率
     
213. // CCActionInterval * move = CCMoveTo::create(5,serif; font-size:12px; line-height:1.8em"> // CCActionInterval * easeRateAction = CCEaseRateAction::create(move,3);
     
214. // sp->runAction(easeRateAction);
     
215. // CCEaseSineIn
     
216. // 作用：动作由慢到快
     
217. // CCActionInterval * easeSineIn = CCEaseSineIn::create(move);
     
218. // sp->runAction(easeSineIn);
     
219. // CCEaseSineOut
     
220. // 作用：动作由快到慢
     
221. // CCActionInterval * easeSineOut = CCEaseSineOut::create(move);
     
222. // sp->runAction(easeSineOut);
     
223. // CCEaseSineInOut
     
224. // 作用：动作由慢到快再快到慢
     
225. // CCActionInterval * easeSineInOut = CCEaseSineInOut::create(move);
     
226. // sp->runAction(easeSineInOut);
     
227. // CCSpeed
     
228. // 作用：让目标动作运行速度加倍
     
229. // 参数1：目标动作
     
230. // 参数2:倍速
     
231. // CCActionInterval * move = CCMoveTo::create(10,serif; font-size:12px; line-height:1.8em"> // CCSpeed * speed =CCSpeed::create(move,100);
     
232. // sp->runAction(speed);
     
233. // CCSpawn
     
234. //作用：让多个动作同时执行
     
235. // 参数：目标动作的可变参数
     
236. // CCActionInterval * scale = CCScaleTo::create(2,serif; font-size:12px; line-height:1.8em"> // CCActionInterval * rotate = CCRotateTo::create(4,190);
     
237. // CCFiniteTimeAction * spawn =CCSpawn::create(move,scale,rotate,NULL);
     
238. // sp->runAction(spawn);
     
239. // CCSequence
     
240. // 作用：让多个动作按照前后顺序逐一执行
     
241. // 参数：目标动作的可变参数
     
242. // CCActionInterval * move = CCMoveTo::create(2,serif; font-size:12px; line-height:1.8em"> // CCFiniteTimeAction * seq= CCSequence::create(move,serif; font-size:12px; line-height:1.8em"> // sp->runAction(seq);
     
243. // 扩展如果要对目标动作全部进行方向运动，可以使用如下形式操作
     
244. // CCFiniteTimeAction *seq=CCSequence::create(moveby,scaleby,...NULL);
     
245. // CCFiniteTimeAction * reverseseq = CCSequence::create(seq,seq->reverse(),NULL)
     
246. // 注意CCSequence中的所有动作都必须支持reverse函数，否则会出现异常
     
247. // CCActionInterval * move = CCMoveBy::create(2,serif; font-size:12px; line-height:1.8em"> // CCActionInterval * scale = CCScaleBy::create(2,serif; font-size:12px; line-height:1.8em"> // CCFiniteTimeAction * reveseseq = CCSequence::create(seq,serif; font-size:12px; line-height:1.8em"> // sp->runAction(reveseseq);
     
248. // CCRepeat
     
249. // 作用：对目标动作进行重复运动（目标动作可以是CCSequence ，CCSpawn）
     
250. // 参数2：重复次数
     
251. // CCActionInterval * move2 = CCMoveTo::create(2,ccp(100,serif; font-size:12px; line-height:1.8em"> // CCFiniteTimeAction*seq =CCSequence::create(move,move2,serif; font-size:12px; line-height:1.8em"> // CCFiniteTimeAction *repeat = CCRepeat::create(seq,serif; font-size:12px; line-height:1.8em"> // sp->runAction(repeat);
     
252. // CCRepeatForever
     
253. // 作用：对目标动作进行永久性的重复运动（目标动作可以是CCSequence ，CCSpawn）
     
254. // CCActionInterval * move = CCMoveTo::create(1,serif; font-size:12px; line-height:1.8em"> // CCActionInterval * move1 = CCMoveTo::create(1,serif; font-size:12px; line-height:1.8em"> // CCFiniteTimeAction* seq = CCSequence::create(move,move1,serif; font-size:12px; line-height:1.8em"> // CCActionInterval * repeatForever =CCRepeatForever::create((CCActionInterval* )seq);
     
255. // sp->runAction(repeatForever);
     
256. // CCCallFunc
     
257. // 作用：创建一个回调动作（调用不带参数的回调方法）；
     
258. // 参数2：目标回调函数
     
259. // CCCallFunc * funcall= CCCallFunc::create(this,callfunc_selector(HelloWorld::callbackC));
     
260. // CCFiniteTimeAction * seq = CCSequence::create(move,funcall,serif; font-size:12px; line-height:1.8em"> // CCCallFuncN
     
261. // 作用：创建一个回调动作（调用 带一个参数的回调方法）；
     
262. // 参数1：目标动作
     
263. // 参数2：目标回调函数
     
264. // CCCallFuncN * funcall= CCCallFuncN::create(this,callfuncN_selector(HelloWorld::callbackN));
     
265. // CCCallFuncND
     
266. // 作用：创建一个回调动作（调用 带两个参数的回调方法）；
     
267. CCActionInterval * move = CCMoveTo::create(1,serif; font-size:12px; line-height:1.8em"> CCCallFuncND * funcall= CCCallFuncND::create(this,callfuncND_selector(HelloWorld::callbackND),(void*)0xbebabeba);
     
268. CCFiniteTimeAction * seq = CCSequence::create(move,serif; font-size:12px; line-height:1.8em"> sp->runAction(seq);
     
269. return true;
     
270. }
     
271. void HelloWorld::callbackC()
     
272. CCLOG("callbackC");
     
273. 
     
274. void HelloWorld::callbackN(CCNode* sender)
     
275. CCLOG("callbackN");
     
276. void HelloWorld::callbackND(CCNode* sender,void* data)
     
277. CCLOG("callbackND");

CCFollow

CCFollow动作，可以让一个节点跟随另一个节点做位移。
CCFollow经常用来设置layer跟随sprite，可以实现类似摄像机跟拍的效果
效果是精灵在地图上移动，地图也会跟着移动，但是精灵仍然是在整个界面的中心位置

CCSpeed

CCSpeed用于线性地改变某个动作的速度，因此，可以实现成倍地快放或慢放功能。为了改变一个动作的速度，首先需要将目标动作包装到CCSpeed动作中