Cocos2d-html5（version2.2.1）常用API

亦凉 2022-08-08 00:59 167阅读 0赞

**一些约定：**  
1.实例的引用，新的实例交由cc.\_xxx变量存储，并在类的内部使用的  
为了能让外部能使用，并统一接口，都会给类定义一个getInstance方法  
并将对应的实例返回出去的。  
cc.Application的实例  
eg：cc.Application.getInstance(),当然在执行之前要先创建cc.Application实例  
  
2.另外一些cocos层面的全局变量，作者都将其纳入到cc的命名空间下了。 防止冲突。  
而我们就不要再使用cc作为自己的变量。  
  
**一、常量**  
cc.IS\_SHOW\_DEBUG\_ON\_PAGE  
类型：boolean  
默认值：false  
位置：CCCommon.js  
<static> <constant> (静态、常量)  
功能：是否在网页上显示调试信息  
  
**二、cc命名空间下的方法 **  
1.cc.log  
功能：输出调试信息  
依赖：cc.IS\_SHOW\_DEBUG\_ON\_PAGE  
位置：CCCommon.js  
默认：在控制台输出调试信息  
描述：cc.IS\_SHOW\_DEBUG\_ON\_PAGE为true时，在网页上显示调试信息  
cc.IS\_SHOW\_DEBUG\_ON\_PAGE为false时，在控制台输出调试信息  
  
2.cc.Assert  
功能：输出断言信息  
依赖：cc.IS\_SHOW\_DEBUG\_ON\_PAGE  
位置：CCCommon.js  
参数：cond 条件，true、false或者条件表达式  
message 当cond为false时，输出该信息到控制台，当不支持console.assert时，用alert方式替代  
描述：只有当cc.COCOS2D\_DEBUG为0时才会被屏蔽，当然还要调用cc.initDebugSetting方法  
  
3.<static> cc.initDebugSetting  
功能：更新调试模式  
依赖：cc.COCOS2D\_DEBUG（大于等于0的数）  
位置：CCCommon.js  
描述：当cc.COCOS2D\_DEBUG = 0时，cc.log, cc.Assert, cc.logINFO, cc.logERROR 被屏蔽  
当cc.COCOS2D\_DEBUG = 1时，cc.logINFO被赋值为cc.log, cc.logERROR 被屏蔽  
当cc.COCOS2D\_DEBUG > 1时，cc.logINFO, cc.logERROR 均被赋值为cc.log  
  
4.<static> cc.setup(el, width, height)  
功能：设置canvas的尺寸  
参数：el：可以是[dom][]元素，也可以是dom元素的id  
width：canvas元素的宽度  
height：canvas元素的高度  
约束：el的标签必须采用DIV或者CANVAS  
描述：做了哪些事  
el为canvas时：  
1. [宽度][Link 1]以参数传入的为准，假如没传宽高，则以元素自身的宽高为准，假如  
自身没设置width、height样式时，cocos默认设置为480px宽，320px高，设置在属性中的。  
2. 在canvas的上一层再包裹一层div元素，尺寸与canvas一致（设置在内联style）  
，并做居中处理  
3. 将canvas对象赋值给cc.canvas  
el为div标签时：  
1. 创建一个canvas标签，用属性方式设置宽高，添加“gameCanvas”class  
2. 为div做居中处理,并用[style][]内联方式设置宽高  
3. 将canvas对象赋值给cc.canvas  
最后：  
1.当支持visibilitychange事件（选项卡显示隐藏状态变更）时，每当选项卡显示时，  
cc.Director.getInstance().\_resetLastUpdate();  
2.手机平台，将div、canvas、body设置为不可选中的状态,对iphone、ipad禁用选状态下背景默认高亮的效果。  
在pc端是可以选中的。  
疑惑：  
1.不知道为什么canvas的尺寸设置于属性，而包裹层div的尺寸却设置于内联样式中，为什么风格  
不统一一点？  
2.当el为div标签时，canvas有“gameCanvas”class，而el为canvas时，却没有为canvas添加该class的。  
  
5.cc.Color3B  
功能：创建一种颜色，颜色由rgb三种元色构成。是一个构造函数。  
参数：r1，g1，b1，分别代表rgb，取值在\[0,255\]  
位置：CCTypes.js  
默认：是参数缺失情况下，r，g，b成员变量赋值为0  
描述：没有传任何参数时，rgb均为0  
传入一个参数时，如果是cc.Color3B实例时，会返回该实例的拷贝  
传入三个参数时，分别赋值给成员变量r，g，b，并去除小数部分的。  
  
6.cc.Color4B  
功能：创建一种颜色，颜色由rgba三种元色构成。是一个构造[函数][Link 2]。  
参数：r1，g1，b1，分别代表rgb，a表示透明度，取值在\[0,255\]  
位置：CCTypes.js  
默认：是参数缺失情况下，r，g，b，a成员变量赋值为0  
描述：没有传任何参数时，rgb均为0  
传入一个参数时，如果是cc.Color3B实例时，会返回该实例的拷贝  
传入三个参数时，分别赋值给成员变量r，g，b，并去除小数部分的。  
注意：在我们获取颜色值时，通常是\#3c3c3c这种类型的颜色值，这些值是16进制的  
，我们可以用0x3c来作为参数，是一种快速转换成数值的方式。  
  
7.cc.RenderDoesnotSupport   
**功能: 返回cc.\_\_renderDoesnotSupport内置变量**  
**位置: miniFramework.js  
描述: 万一当****cc.\_\_renderDoesnotSupport为undefined时，返回false  
  
8.cc.create3DContext  
功能：创建一个webgl环境**  
**位置: ****miniFramework.js **  
**返回：一个webgl的环境，创建失败就返回null  
参数：canvas：canvas元素  
opt\_attribs：创建webgl的一些参数。  
位置：miniFramework.js  
描述：cocos在检测是否支持webgl的时候，opt\_attribs参数设置为  
\{'stencil': true, 'preserveDrawingBuffer': true \}，  
stencil: 是绘图缓存的一种，表示至少用8位来保存。  
它为屏幕上的每个像素点保存一个无符号的正数值。通过这个值，可以的得知哪些像素点的颜色值  
需要更新，哪些不需要，从而达到增加渲染管线的渲染速度的。  
preserveDrawingBuffer：缓存种类Color（颜色缓冲区），Depth（深度缓冲区），Stencil（模版缓存区），  
当设置为true时，表示会缓存绘图信息，除非canvas尺寸发生变化。  
当设置为false时，表示每次渲染后都会去清缓存，不管canvas尺寸是否发生变化。  
注意：  
\* DrawingBuffer绘图缓存在3种情况下是必须被系统自动清空的：  
1.首次创建的时候  
2.当canvas的尺寸发生变化时  
3.当创建webgl的preserveDrawingBuffer配置参数为false时，每当渲染结束后都会清空缓存  
\* Color（颜色缓冲区），Depth（深度缓冲区）默认值都是true的，而Stencil（模版缓存区）默认值为false。  
  
9.cc.Point  
功能：构造函数，创建一个点，包括x，y两个平面坐标  
参数：x，y  
位置：CCGeometry.js  
描述：当没有传入参数时，初始值为x = 0，y=0  
  
注意：cc.PointMake即将会被废弃，官方建议不要使用，起作用跟cc.Point作用一致。  
  
10.\{cc.Point\} cc.p  
功能：返回cc.Point实例  
参数：x，y  
位置：CCGeometry.js（Geometry：几何）  
描述：用cc.Point 新建一个实例然后返回而已，方便我们创建点对象，省去我们写new 关键字，  
说白就是简化书写，偷懒。  
  
11.\{cc.Point\} cc.PointZero  
功能：返回（0,0）点实例  
位置：CCGeometry.js  
  
12.\{Boolean\} cc.pointEqualToPoint  
功能：返回两个cc.Point实例是否指向同一个点  
参数：point1,point2 (类型为cc.Point)  
位置：CCGeometry.js  
注意：一旦传入0，false，undefined，null，或者没有传入参数，该方法均  
返回false，也许是cocos作者认为这些值没意义，不具备可比性，一律返回fasle  
  
13.\{cc.Size\} cc.Size  
功能：构造函数，创建一个尺寸实例，包含width宽度，height高度  
参数：width，height  
位置：CCGeometry.js  
描述：假如没传width，height参数进去，会给定默认值0，0  
  
注意：cc.SizeMake即将会被废弃，官方建议不要使用，起作用跟cc.Size作用一致。  
  
14.\{cc.Size\} cc.SizeZero  
功能：返回一个宽高都为0的尺寸实例  
参数：N/A  
位置：CCGeometry.js  
  
15.\{Boolean\} cc.sizeEqualToSize  
功能：返回两个cc.Size实例是否相同（width，height变量相等）  
参数：size1,size2 (类型为cc.Size)  
位置：CCGeometry.js  
注意：一旦传入0，false，undefined，null，或者没有传入参数，该方法均  
返回false。  
  
16.\{cc.Rect\} cc.Rect  
功能：构造函数，具有两个成员参数  
\{cc.Point\} origin: origin.x, origin.y  
\{cc.Size\} size: size.width,size.height  
参数：x1,y1,width1,height1  
位置：CCGeometry.js  
描述：这个方法采用模拟了方法的重载  
当没有传入参数：origin赋值为横纵坐标为0的cc.Point实例，size赋值为高度为0的cc.Size实例  
当传入一个参数：认定这个参数的类型就是cc.Rect  
当传入二个参数：认定第一个参数为cc.Point类型，第二个参数为cc.Size类型  
当传入四个参数：将参数分别赋值给origin.x, origin.y, size.width, size.height  
注意：  
\* 我觉得它根据了arguments.length，按传入参数个数来做不同处理，对于模拟方法重载  
的层面来讲，个人觉得是好赞的做法！  
\* cc.RectMake即将会被废弃，官方建议不要使用，起作用跟cc.Rect作用一致。  
\* 在这里不要以为它就只有这个成员变量，它还有四个对应的类成员属性，分别  
为x，y，width，height，以Object.defineProperties(cc.Rect.prototype,这样的方式定义的。  
  
17.\{cc.Rect\} cc.rect  
参数：x1,y1,width1,height1  
位置：CCGeometry.js  
描述：用cc.Rect 新建一个实例然后返回而已，方便我们创建矩形对象，省去我们写new 关键字，  
说白就是简化书写，偷懒。  
  
18.\{cc.Rect\} cc.RectZero  
功能：返回一个以（0,0）作为原点，宽度高度均为0的矩形对象  
  
19.\{Boolean\} cc.rectEqualToRect  
功能：比较两个矩形实例是否相等  
参数：rect1, rect2 均为\{cc.Rect\}类型  
描述：一旦传入0，false，undefined，null，或者没有传入参数，该方法均  
返回false。  
  
20.\{Boolean\} cc.rectContainsRect  
功能：返回一个矩形是否包含另一个矩形  
true：第一个矩形包含第二个矩形，且第一个矩形的尺寸较大  
false：第一个矩形没有包含第二个矩形，或者跟第二个矩形相同  
参数：rect1, rect2 均为\{cc.Rect\}类型  
描述：一旦传入0，false，undefined，null，或者没有传入参数，该方法均  
返回false。  
注意：这里当两个矩形相同，会返回false。  
  
21.\{Number\} cc.rectGetMaxX  
功能：返回矩形右下角点的x坐标  
  
22.\{Number\} cc.rectGetMidX  
功能：返回矩形底边中点的x坐标  
  
23.\{Number\} cc.rectGetMinX  
功能：返回矩形左下角点的x坐标  
  
24.\{Number\} cc.rectGetMaxY  
功能：返回矩形左上角点y坐标  
  
25.\{Number\} cc.rectGetMidY  
功能：返回矩形左边中点y坐标  
  
26.\{Number\} cc.rectGetMinY  
功能：返回矩形左下角点y坐标  
  
27.\{Boolean\} cc.rectContainsPoint  
功能：判断点是否在矩形上  
参数：\{cc.Rect\} rect, \{cc.Point\} point  
  
28.\{Boolean\} cc.rectIntersectsRect  
功能：判断两个矩形是否存在交集  
参数：\{cc.Rect\} rectA, \{cc.Point\} rectB  
  
29.\{Boolean\} cc.rectOverlapsRect  
功能：判断两个矩形是否存在交集  
参数：\{cc.Rect\} rectA, \{cc.Point\} rectB  
质疑：这两个函数在功能上与cc.rectIntersectsRect完全一致，不知道cocos作者为什么  
要搞两个功能一样的方法出来。  
  
30.\{cc.Rect\} cc.rectUnion  
功能：返回一个包含这两个矩形的最小矩形  
参数：\{cc.Rect\} rectA, \{cc.Point\} rectB  
  
31.\{cc.Rect\} cc.rectIntersection  
功能：获取两个矩形重合部分的矩形  
参数：\{cc.Rect\} rectA, \{cc.Point\} rectB  
  
32.cc.setContextMenuEnable  
功能：设置canvas元素上点击鼠标右键是否弹出菜单列表  
参数：true：弹出菜单  
false：不弹出菜单（默认值）  
位置：CCApplication.js  
  
（33-46为仿射矩阵相关操作）   
33.AffineTransform  
功能：构造函数，定义a，b，c，d，tx，ty成员变量  
返回：\{cc.AffineTransform\}  
描述：以上变量构成一个坐标矩阵  
参数：a，b，c，d，tx，ty  
  
34.\_\_AffineTransformMake  
功能：返回包含a，b，c，d，tx，ty属性的jason对象  
返回：\{object\}  
  
35.\_\_PointApplyAffineTransform  
功能：计算指定点point通过变换矩阵t后得到的目标坐标值  
返回：\{object\}  
参数：\{cc.Point\} point , \{objct\} t(变换矩阵)  
描述：\[a, b \] \* \[point.x,point.y\] 计算得出坐标值的。  
c, d  
tx,ty  
遵循f(x) = a\*x + b，  
\[a\*pint.x + c\*point.y + tx,b\*point.x + d\*point.y + ty\]  
36.PointApplyAffineTransform  
功能：计算指定点point通过变换矩阵t后得到的目标坐标值  
返回：\{object\}  
参数：\{cc.Point\} point , \{objct\} t  
描述：功能跟\_\_PointApplyAffineTransform一样，只不过这个方法对外作为  
构造器角色。  
  
37.\_PointApplyAffineTransform  
功能：计算指定点point通过变换矩阵t后得到的目标坐标值  
返回：\{object\}  
参数：\{Number\} x , \{Number\} y, \{objct\} t  
描述：功能跟\_\_PointApplyAffineTransform一样。只是参数\{cc.Point\} point  
拆分成x,y。x为point.x，y为point.y。  
  
38.\_\_SizeApplyAffineTransform  
功能：计算指定点point通过变换矩阵t后得到的目标坐标值  
返回：\{object\}  
参数：\{cc.Size\} size , \{objct\} t  
描述：\[a, b \] \* \[size.widht,size.height\] 计算得出目标尺寸。  
c, d  
tx,ty  
由于面积不需要叠加位移，所以不用遵循f(x) = a\*x + b，只要f(x) = a\*x就ok。  
\[a\*size.widht + c\*size.height,b\*size.widht + d\*size.height\]  
  
39.AffineTransformMakeIdentity  
功能：返回一个变换矩阵，这个矩阵不包含任何变化。  
描述：任何点或尺寸与该方法返回的矩阵进行乘法运算，都不会对原始点或尺寸对象  
产生任何变化。  
返回：\{object\}  
\{a: 1.0, b: 0.0, c: 0.0, d: 1.0, tx: 0.0, ty: 0.0\}  
  
40.AffineTransformIdentity  
功能：返回一个变换矩阵，这个矩阵不包含任何变化。  
描述：任何点或尺寸与该方法返回的矩阵进行乘法运算，都不会对原始点或尺寸对象  
产生任何变化。  
返回：\{object\}  
质疑：功能跟cc.AffineTransformMakeIdentity一样，都用作构造器，不知道为什么要  
搞两个方法出来。  
  
41.RectApplyAffineTransform  
功能：获取一个经过变换矩阵变形后的矩形。  
返回：\{cc.Rect\} rect, \{cc.AffineTransform\} anAffineTransform  
描述：其原理是通过获取四个顶点坐标，计算每个点通过变换矩阵t后得到的目标坐标值，  
再从四个变换后的顶点求出该矩形的圆点和尺寸。根据这些属性新创建一个矩形  
对象并返回该对象。  
质疑：var top = cc.rectGetMinY(rect);应该改为var bottm = cc.rectGetMinY(rect);  
var bottom = cc.rectGetMaxY(rect);应该改为var top = cc.rectGetMaxY(rect);  
语义上会更好。  
  
42.\_RectApplyAffineTransformIn  
功能：获取一个经过变换矩阵变形后的矩形。  
返回：\{cc.Rect\} rect, \{cc.AffineTransform\} anAffineTransform  
描述：功能与RectApplyAffineTransform一样，但\_RectApplyAffineTransformIn将变换后的  
矩形属性拷贝到rect参数，并返回该参数。  
质疑：var top = cc.rectGetMinY(rect);应该改为var bottm = cc.rectGetMinY(rect);  
var bottom = cc.rectGetMaxY(rect);应该改为var top = cc.rectGetMaxY(rect);  
语义上会更好。  
  
43.AffineTransformTranslate  
功能：仿射矩阵的平移操作后的结果。  
返回：\{cc.AffineTransform\} t，\{Number\} tx，\{Number\} ty  
描述：仿射矩阵的结合顺序一般最后才做平移操作。  
\[t.a, t.b \] \* \[tx,ty\] => \[tx\*t.a+ ty\*t.c, tx\*t.b + ty\*t.d\]  
t.c, t.d  
\[t.a, t.b \] + \[tx\*t.a+ ty\*t.c, tx\*t.b + ty\*t.d\] =>\[t.a,t.b\]  
t.c, t.d t.c,t.d  
t.tx,t.ty tx\*t.a+ ty\*t.c + tx, tx\*t.b + ty\*t.d + ty  
  
注意：这里是先做乘法操作，得出的结果是平移操作的变换矩阵，也就是说tx，ty是未经历任何转换的平移量，  
但要融合到t，先要做一下矩阵乘法操作，然后才能与t的直接相加操作得到组合后的变换矩阵。  
  
44.AffineTransformScale  
功能：仿射矩阵的缩放操作后的结果。  
返回：\{cc.AffineTransform\}  
描述：仿射矩阵的与缩放操作组合后的结果。  
\[t.a, t.b \] + \[sx,0\] =>\[t.a\*sx,t.b\*sx\]  
t.c, t.d 0,sy t.c\*sy,t.d\*sy  
t.tx,t.ty t.tx, t.ty  
  
45.AffineTransformConcat  
功能：仿射矩阵的缩放操作后的结果。  
返回：\{cc.AffineTransform\}  
参数：\{cc.AffineTransform\} t1, \{cc.AffineTransform\} t2  
描述：两个仿射矩阵组合后的结果，非平移的都是采用乘法操作。  
\[t1.a,t1.b\] \* \[t2.a,t2.b\]  
t1.c,t1.d t2.c,t2.d  
t1.tx,t1.ty t2.tx,t2.ty  
=>\[t1.a\*t2.a+t1.b\*t2.c, t1.a\*t2.b+t1.b\*t2.d\]  
t1.c\*t2.a+t1.d\*t2.c, t1.c\*t2.b+t1.d\*t2.d  
t1.tx\*t2.a+ t1.ty\*t2.c + t2.tx, t1.tx\*t2.b + t1.ty\*t2.d + t2.ty  
  
a,b,c,d都是通过矩阵乘法算来的，后面的tx，ty要做两步才能得出结果，  
第一：先算出\[t1.tx,t1.ty\]在\[t2.a,t2.b\]变换矩阵变换后的平移量，按照乘法得到  
t2.c,t2.d  
\[t1.tx\*t2.a+ t1.ty\*t2.c, t1.tx\*t2.b + t1.ty\*t2.d\]  
第二：知道变换后的平移量就可以直接与\[t2.tx,t2.ty\]相加得出结果。  
这两步做了AffineTransformTranslate方法做的事了。  
  
46.AffineTransformEqualToTransform  
功能：判断两个矩阵是否相等。  
返回：true/false  
参数：\{cc.AffineTransform\} t1, \{cc.AffineTransform\} t2  
描述：判断它们的a，b，c，d，tx，ty属性是否相等  
  
47.ArrayRemoveObject  
功能：从数组中移除指定对象  
参数：\{Array\} arr  
\{\*\} var  
描述：arr数组元素类型决定了var的类型  
  
三、cc属性  
1.\{String\} cc.ENGINE\_VERSION  
功能：返回当前正在使用的cocos-html5的引擎版本  
位置：CCConfig.js  
eg:“Cocos2d-html5-v2.2.1”  
  
2.\{c.Point\} cc.POINT\_ZERO  
位置：CCGeometry.js  
返回（0,0）点实例，该实例包含x，y两个成员变量  
  
3.\{c.Size\} cc.SIZE\_ZERO  
位置：CCGeometry.js  
返回（0,0）尺寸实例，该实例包含width，height两个成员变量  
  
4.\{c.Point\} cc.SIZE\_ZERO  
位置：CCGeometry.js  
返回：左下角点（0,0）作为原点，宽，高长度均为0的矩形实例，  
该实例包含x，y，width，height均为0的四个成员变量  
  
5.cc.\_sharedApplication  
功能：指向cc.Application创建的实例  
描述：在cc.Application构造器中，初始化时，将实例指针this赋值给cc.\_sharedApplication  
，所以完全等价于当做是cc.Application实例。  
注意：用意为cocos其他类或者方法使用之，主要用于引擎内其他方法使用，外部用cc.Application.**getInstance()来获取  
**位置：CCApplication.js   
  
四、sys命名空间 **  
位置：cocos2d/core/platform/Sys.js  
描述：在cocos2d-html这个分支中，Sys只有属性，没有方法。  
属性：  
1.platform  
返回：“browser”  
只读，可枚举，可配置（enumerable、configurable）  
  
2.version  
返回：cc.ENGINE\_VERSION  
只读，可枚举，可配置（enumerable、configurable）  
如在v2.2.1的话，返回“Cocos2d-html5-v2.2.1”  
  
3.os  
返回设备[操作系统][Link 3]类型的名称  
只读，可枚举，可配置（enumerable、configurable）  
\* 'Windows'(WP7会被断言为Windows的)  
\* 'OS X'  
\* 'UNIX'  
\* 'Linux'  
\* 'iOS'  
\* 'Android'  
  
4.capabilities  
返回JSON对象  
\{  
canvas: true  
opengl:  
touches:  
mouse:  
keyboard:  
accelerometer:  
\}  
只读，可枚举，可配置（enumerable、configurable）  
  
5.localStorage  
返回window.localStorage对象，假如不支持本地存储时，将返回一个空[函数][Link 2]function()\{\}.  
质疑：这里cocos的写法有一些低级错误，我要指出，源码如下：  
*try\{  
sys.localStorage = window.localStorage;  
\}catch(e)\{  
if( e.name === "SECURITY\_ERR" ) \{  
cc.log("Warning: localStorage isn't enabled. Please confirm browser cookie or privacy option");  
\}  
sys.localStorage = function()\{\};  
\}*  
这里做了一个try..catch捕获异常，目的是应付用户对Chrome浏览器的Cookie栏目勾选了阻止网站设置任何数据，但是在这种情况下 cc.log并没有将错误信息打印出来，因为在最新版的Chrome中，e.name显示为”SecurityError“了，没有下划线的。所以[源码][Link 4]存在一点  
问题的。  
  
**五、cc.Browser**  
cc.Browser  
位置: miniFramework.js  
属性  
1.ua: userAgent(小写)  
  
2.platform: navigator.platform(小写),eg:"Win32"  
  
3.isMobile: 是否移动设备，根据ua是否含有'mobile'和'[android][]'字样。  
质疑：从判断逻辑来睇，并不只是判断Mobile,因为iPad平台都有'mobile'字样，Android平台的平板  
也是必定有'android',所以isMobile我认为是断言是否移动设备，而不是字面上的手机设备  
  
4.mode: 如果为ie浏览器，则返回document.documentMode,获知ie处于哪种内核模式  
IE6/IE7:undefined  
IE8: 8  
IE8（兼容模式）:7  
IE9: 9  
IE9（兼容模式）:7||8  
IE10: 10  
IE10（兼容模式）:7||8||9  
  
5.supportWebGL  
false: 当document.ccConfig.renderMode为1时  
或者 document.ccConfig.renderMode为0时的移动设备  
true: 必须先支持WebGL，  
pc: renderMode为0或2  
移动设备: renderMode 为2  
质疑: 当我们指定document.ccConfig.renderMode为2时，也即只选用WebGL渲染页面，在最新版的Chrome中测试出现了  
相当多的关于WebGL的警告错误，多的程度已经让Chrome报如下的错误：  
too many errors, no more errors will be reported to the console for this context.  
最终导致不能正常显示cocos2d-html5引擎的功能测试的。唯一能解决目前的方案是将document.ccConfig.renderMode设为1，  
也即强制只采用canvas来渲染。  
  
6.\{Boolean\} \_\_renderDoesnotSupport:  
true: 当document.ccConfig.renderMode强制用WebGL来渲染，但浏览器不支持WebGL，表示不支持渲染。  
false: 表示支持渲染，由cc.RenderDoesnotSupport **方法设置。  
注意:  
\* 即使返回false时，也不表示肯定没问题的，如****supportWebGL中，提到的质疑部分。**  
\* 在tests-boot-html5.js里面我们为document.ccConfig赋值，假如没赋值，将其赋值为\{\}  
\* document.ccConfig.renderMode = 2表示只选择WebGL方式来渲染  
\* document.ccConfig.renderMode = 1表示只选择canvas方式来渲染  
\* 移动设备默认就是只采用canvas进行渲染的  
  
7.\{Boolean\} supportWebAudio  
true: 表示支持html5的音频处理接口（对应html标签为<audio>）  
false: 表示不支持  
  
8.\{String\} type  
检测浏览器品牌  
返回值如下：  
wechat ----------微信内置浏览器识别，通过检测ua是否包含'MicroMessenger',有就断言为wechat  
qqbrowser  
mqqbrowser  
ucbrowser  
360browser  
baidubrowser  
maxthon  
ie  
opera  
firefox  
chrome  
safari  
注意：以上的顺序也是cocos的检测顺序，假如浏览器匹配多项，那么只会返回最先获得匹配的那一项。假如  
没有匹配的返回'unknow'  
  
**六、cc.LayerGradient**  
类 cc.LayerGradient  
继承树：cc.Class  
cc.Node  
cc.Layer  
cc.LayerColor  
cc.LayerGradient  
功能：作为cc.LayerColor子类，用于显示渐变的背景色  
位置：CCLayer.js  
  
事件：介绍常用的事件  
1.onEnter  
继承自：cc.Layer  
描述：当一个层变成可见时执行该方法  
  
2.onTouchesMoved  
继承自：cc.Layer  
描述：当触点移动后执行该方法  
参数：  
touch：cc.Touch实例  
event：事件参数  
  
3.\{Boolean\} onMouseDragged  
继承自：cc.Node  
描述：当接收到‘mouseDragged’事件(按住鼠标左键并移动鼠标时触发)后执行该方法  
参数：event 事件参数  
注意：返回true,阻止事件传播到其他的事件代理  
  
4.\{Boolean\} onScrollWheel  
继承自：cc.Layer  
描述：当接收到‘scrollWheel’事件后执行该方法  
参数：event 事件参数  
注意：返回true,阻止事件传播到其他的事件代理  
  
**七、cc.AppController  
类 cc.AppController  
继承树：cc.Class  
cc.AppController  
功能：控制游戏执行的调度  
位置：AppControl.js  
  
1.shareAppController  
功能：新创建一个cc.AppController  
参数：N/A  
返回：\{cc.Application\}  
位置：****AppControl.js  
质疑：之前很多类都统一了接口，像cc.DisplayLinkDirector，同样是做了创建实例并返回的操作  
而cc.DisplayLinkDirector.getInstance(),还有类似的cc.Application.getInstance()，这个  
就只管返回创建好的实例，按道理cc.AppController也应该定一个cc.AppController.getInstance()  
  
2.didFinishLaunchingWithOptions  
功能：控制当cc.Application的构造器做好了相关配置之后，事前准备如cc.setup做的事等，  
完事之后要执行的东西都定义在这，执行cc.Application实例的run方法。**  
**位置：AppControl.js   
  
八、 ****cc.Application方法**  
类 cc.Application  
继承树：cc.Class  
cc.Application  
功能：整个游戏[应用][Link 5]的控制器，用于启动游戏  
位置：CCApplication.js  
类成员变量：  
\* \_animationInterval：表示每帧之间的时间间隔，用秒作为单位  
类成员方法：  
\* ctor 构造器  
一个游戏只要一个 cc.Application实例就ok，重复创建抛异常“Application has been initialized”  
，但只是控制台输出错误，不会导致js跑不了！  
V2.1.5的实现: cc.Assert(!cc.\_sharedApplication, "CCApplication ctor");  
v2.2.1的实现: if(cc.\_sharedApplication) throw "Application has been initialized";  
  
\* setAnimationInterval  
参数：\{number\} interval  
功能：设置\_animationInterval  
描述：director.setAnimationInterval的实现就是回调该方法  
注意：会被cc.DisplayLinkDirector实例的startAnimation方法使用。  
cc.DisplayLinkDirector实例由cc.Director.getInstance获得，跟我们之前的约定有些  
不同，该方法连创建对象的事都做了。  
eg： director.setAnimationInterval(1.0 / this.config\['frameRate'\]);  
  
\* getTargetPlatform  
参数：N/A  
功能：主要用于判断是否移动设备的  
描述：就目前2.2.1版本，其实就两个平台，pc平台、移动设备平台  
返回值：数值  
用法：  
返回值 == cc.TARGET\_PLATFORM.MOBILE\_BROWSER  
返回值 == cc.TARGET\_PLATFORM.PC\_BROWSER  
  
1.getCurrentLanguage  
功能：获取浏览器使用的语言种类  
返回：语言代号，cc.LANGUAGE\_ENGLISH这类枚举变量保存的数值  
描述：在firefox中的工具->选项->内容->语言可以设置你要使用的语言设置，  
但是Cocos只有以下语种：  
英文（cc.LANGUAGE\_ENGLISH）、中文（cc.LANGUAGE\_CHINESE）、法语（cc.LANGUAGE\_FRENCH）  
、意大利语（cc.LANGUAGE\_ITALIAN）、德语（cc.LANGUAGE\_GERMAN）  
、西班牙语（cc.LANGUAGE\_SPANISH）、俄语（cc.LANGUAGE\_RUSSIAN）、韩文（cc.LANGUAGE\_KOREAN）  
、日语（cc.LANGUAGE\_JAPANESE）、匈牙利语（cc.LANGUAGE\_HUNGARIAN）  
、葡萄牙语（cc.LANGUAGE\_PORTUGUESE）、阿拉伯语（cc.LANGUAGE\_ARABIC）  
、挪威语（cc.LANGUAGE\_NORWEGIAN）、波兰语（cc.LANGUAGE\_POLISH）  
假如都匹配不到的话，就返回cc.LANGUAGE\_ENGLISH。  
注意：cc.LANGUAGE\_ENGLISH都是枚举类型，保存的是number类型的数值，具体值无需记忆。  
判断当前浏览器的语言设置是否为中文：  
cc.Application.getCurrentLanguage() == cc.LANGUAGE\_CHINESE  
位置：CCApplication.js  
  
2.getInstance  
功能：看做一个接口，获取之前创建的实例。  
参数：N/A  
返回：\{cc.Application\}  
  
3.applicationDidFinishLaunching  
功能：一个接口，这个方法调用的时机cc.AppController.shareAppController().didFinishLaunchingWithOptions();  
返回：true，false  
描述：返回false，则立即返回。不进行场景的渲染  
返回true，则继续进行场景的渲染。  
场景渲染都是采用setInterval或requestAnimFrame，使用requestAnimFrame的前提，支持该特性，另外  
document\['ccConfig'\].frameRate要设为60（默认值）  
  
4.run  
功能：进行场景的渲染  
描述：渲染场景之前，执行applicationDidFinishLaunching接口，用户自己定义的  
并根据返回值，若果返回true执行场景渲染，否则不作任何事。  
  
**九、 ****cc.Node类**  
cc.Class  
cc.Node  
功能：节点类，所有游戏画出来的元素，例如背景层、图片精灵等都继承自该类。  
位置：CCNode.js  
继承树：  
cc.Class  
cc.Node  
  
node的属性：  
1.StateCallbackType  
功能：枚举回调的状态类型  
类型：\{Object\} json  
描述：onEnter:1, onExit:2, cleanup:3, onEnterTransitionDidFinish:4  
, updateTransform:5, onExitTransitionDidStart:6, sortAllChildren:7  
  
内置方法：  
1.\_nodeToParentTransformForWebGL  
功能：返回从当前节点到父节点的变换矩阵。  
描述：这个变换矩阵的意义是，在当前节点上的点坐标可以通过这个矩阵  
得出该坐标在父节点坐标系上的坐标值。也就是说从本地坐标系切换到  
父节点坐标系。  
注意：通过递归获取，可以切换到gl坐标系上的。因此本方法对于坐标系的切换  
是极其重要的一个方法！  
细节：这里我介绍下变换矩阵的计算过程  
\* 初始变换矩阵为t = \[1 0\]，称为单位矩阵（Identity [matrix][]）  
0 1  
0 0  
\* 将本地坐标系平移，使本地坐标系原点与节点位置点重合  
平移向量: (0,0)->(x,y) => (x,y)  
t = \[1 , 0 \]  
0 , 1  
x , y  
\* 计算旋转、缩放[矩阵][Link 6]变换，并且合并他们  
scx : x轴放大系数，scy : y轴放大系数  
t\_process = \[cos(\_rotationX)\*y\*scx sin(\_rotationY)\*scx\]  
\-sin(\_rotationY)\*scy cos(\_rotationX)\*scy  
\* 得出旋转、缩放与t1合并  
t = t \* t\_process  
\--------------------------------------------------------------  
假如发生了错切（为了优化，假如没发生就不计算了）：  
\* 合并错切操作  
sky：底边与x轴的夹角的正切值，skx：左边与y轴的夹角的正切值  
t = t \* \[1, sky\]  
skx, 1  
\--------------------------------------------------------------  
\* 最后使节点锚点平移到节点位置点上  
这里转一下脑筋，这里等价于本地坐标上的(0,0)移到(-apx,-apy)  
说明：本地坐标上的(0,0)，现在等价于节点位置点的。  
  
平移向量: (0,0)->(-apx,-apy)=> \[-apx, -apy\]  
t = t \* \[-apx,-apy\]  
\* 与附加变换复合一次  
并将最终结果作为最终的变换矩阵！  
返回：\{ cc.AffineTransform \} 一个仿射[矩阵][Link 6]  
质疑：在这个方法的旋转角度我认为以逆时针为正，而非API所说以顺时针为正。  
这个是我怀疑的地方！  
  
2.\_arrayMakeObjectsPerformSelector  
功能：遍历节点数组中的每个节点，并根据状态的类型进行回调  
参数：\[\{cc.Node\},\{cc.Node\}...\] array, callbackType  
返回：N/A  
描述：对每个节点都进行相应的回调操作。当获取的回调状态类型不存于cc.Node.StateCallbackType  
中，将抛出异常“Unknown callback function”  
  
3.\_setNodeDirtyForCache  
功能：标识节点为已被修改  
参数：N/A  
返回：N/A  
描述：用cc.Node的内部属性\_cacheDirty设为true来标识，并且将该节点的所有父节点  
都[标识][Link 7]为已被修改的。  
  
4.\_setNodeDirtyForCanvas  
功能：设置节点为已被修改  
参数：N/A  
返回：N/A  
描述：第一，将该节点以及其所有父节点的\_cacheDirty设为true  
第二，将该节点的\_transformDirty（是否发生变形转换）和\_inverseDirty（是否发生反射变换）设为true  
质疑：假如这个方法在反射变换以外的其他变换也执行的话，那么会有不妥。因为没理由将\_inverseDirty  
也设为true。  
  
5.\_setNodeDirtyForWebGL  
功能：设置节点已发生变形转换（反射、旋转、缩放、平移等仿射变换）  
参数：N/A  
返回：N/A  
描述：将该节点的\_transformDirty（是否发生变形转换）和\_inverseDirty（是否发生反射变换）设为true  
质疑：假如这个方法在反射变换以外的其他变换也执行的话，那么会有不妥。因为没理由将\_inverseDirty  
也设为true。  
  
6.\_nodeToParentTransformForCanvas  
功能：返回从当前节点到父节点的变换矩阵。  
描述：这个变换矩阵的意义是，在当前节点上的点坐标可以通过这个矩阵  
得出该坐标在父节点坐标系上的坐标值。也就是说从本地坐标系切换到  
父节点坐标系。  
注意：通过递归获取，可以切换到gl坐标系上的。因此本方法对于坐标系的切换  
是极其重要的一个方法!  
细节：这里我介绍下变换矩阵的计算过程  
1.初始变换[矩阵][Link 6]为t = \[1 0\]，称为单位矩阵（Identity [matrix][]）  
0 1  
0 0  
2.将本地坐标系平移，使本地坐标系原点与节点位置点重合  
平移向量: (0,0)->(x,y) => (x,y)  
t = \[1 , 0 \]  
0 , 1  
x , y  
  
3.对变换进行复合  
\* 没发生错切变换：旋转、缩放二者复合  
sx : x轴放大系数，sy : y轴放大系数  
t = \[sx 0 \] \* \[cos -sin \]  
0 sy sin cos  
= \[cos\*sx -sin\*sx \]  
sin\*sy cos\*sy  
\-> a = cos\*sx  
b = -sin\*sy  
c = -sin\*sy  
d = cos\*sy  
\--------------------------------------------------------------------------------  
\* 当发生了错切变换：错切、旋转、缩放三者复合  
sky：底边与x轴的夹角的正切值，skx：左边与y轴的夹角的正切值  
t = \[1 sky\] \* \[cos sin \] \* \[sx 0 \]  
skx 1 -sin cos 0 sy  
= \[cos\*sx-sin\*sky\*sx sin\*sy+sky\*cos\*sy\]  
skx\*cos\*sx-sin\*sx skx\*sin\*sy+cos\*sy  
\-> a = cos\*sx-sin\*sky\*sx  
b = skx\*cos\*sx-sin\*sx  
c = sin\*sy+sky\*cos\*sy  
d = skx\*sin\*sy+cos\*sy  
  
\* 计算锚点偏移量  
\[appx,appy\] \* \[1 sky\] \* \[sx 0\] \* \[cos sin\]  
skx 1 0 sy -sin cos  
\-> \[appx+ appy\*skx , appx\*sky + appy\] \* \[sx 0\] \* \[cos sin\]  
0 sy -sin cos  
  
\[appx+ appy\*skx , appx\*sky + appy\]提取为偏移部分：\[appy\*skx,appx\*sky\]  
\-> \[appy\*skx,appx\*sky\] \* \[sx 0\] \* \[cos sin\]  
0 sy -sin cos  
\-> \[appy\*skx\*sx\*cos-appx\*sky\*sy\*sin,appy\*skx\*sx\*sin+appx\*sky\*sy\*cos\]  
  
设xx = appy\*skx\*sx，yy = appx\*sky\*sy  
\-> \[cos\*xx-sin\*yy, sin\*xx+cos\*xx\]  
tx += cos\*xx-sin\*yy  
ty += sin\*xx+cos\*xx  
\--------------------------------------------------------------------------------  
4.计算tx，ty  
t \* \[-appx,-appy\] = \[-appx\*cos\*sx -appy\*sin\*sy,appx\*sin\*sx-appy\*cos\*sy\]  
  
\-> tx += -appx\*cos\*sx -appy\*sin\*sy  
ty += appx\*sin\*sx-appy\*cos\*sy  
  
5.如果存在附加变换，则再复合一下  
t = t \* t附加变换  
此时t就是我们最终要得到的仿射变换[矩阵][Link 6]了！  
注意：  
错切角度  
1.底边与x轴的夹角的正切值，以逆时针为正  
2.左边与y轴的夹角的正切值，以顺时针为正  
旋转角度以顺时针为正。  
  
7.\_setZOrder  
功能：获取节点的z-index  
参数：\{Number\} z  
注意：1.默认值为0  
2.该方法作为内部方法使用，不要在框架外部使用  
  
8.\_detachChild  
功能：剥离子节点（从当前节点移除字节点）  
参数：\{cc.Node\} child  
\{Boolean\} doCleanup  
描述：1.当前节点显示在舞台上的时候，执行子节点退出时的过渡处理函数onExitTransitionDidStart  
，然后执行子节点退出后的处理函数onExit  
2.将子节点的父节点指针\_parent置空  
3.当前节点的子节点数组（\_children）中移除子节点（child）  
4.当doCleanup为true时，将停止子节点的所有动作和取消所有回调[函数][Link 2]的绑定。  
这个实际上对内存进行了释放，cocos内部使用该方法时，都默认将doCleanup置为true。  
注意：onExitTransitionDidStart，onExit都是提供给我们按需重写的，要理解成公共接口。  
  
普通方法：  
1.getSkewX  
功能：获取矩形的左边与y轴形成的夹角，并以顺时针为正角度。  
参数：N/A  
注意：这里返回的是角度，而不是弧度。  
  
2.setSkewX  
功能：设置矩形的左边与y轴形成的夹角，并以顺时针为正角度。  
参数：\{Number\} newSkewX  
描述：设置后，将节点设为已被修改状态。  
注意：这里newSkewX的单位为角度。  
  
3.setNodeDirty  
功能：设置节点为已被修改  
参数：N/A  
描述：按照浏览器是否支持webgl，支持会赋值为\_setNodeDirtyForWebGL方法，  
否则赋值为\_setNodeDirtyForCanvas  
  
4.getSkewY  
功能：获取矩形的底边与x轴形成的夹角，并以逆时针为正角度。  
参数：N/A  
注意：这里返回的是角度，而不是弧度。  
  
5.setSkewY  
功能：设置矩形的底边与x轴形成的夹角，并以逆时针为正角度。  
参数：\{Number\} newSkewY  
描述：设置后，将节点设为已被修改状态。  
注意：这里newSkewY的单位为角度。  
  
6.setRotation  
功能：设置矩形的旋转角度（以点为镜像）  
参数：\{Number\} newRotation  
描述：这个方法就是以z轴为中心轴旋转。  
在手机屏幕上，水平向右为x轴方向，向上为y轴方向，指向我们的方向就是z轴。  
将x轴和y轴的旋转角度都设置为newRotation。  
设置后，将节点设为已被修改状态。  
注意：这里newRotation的单位为角度。  
  
7.getRotation  
功能：获取矩形在x轴上的旋转角度  
参数：N/A  
描述：当x轴上的旋转角度与y轴的不同时，会抛出一个警告出来，提醒你cocos不知道你  
究竟想获取哪个轴上的旋转角度。  
注意：这里返回值的单位为角度。  
质疑：这个方法，在采用webgl渲染时，从实现来推导，应该是逆时针为正。与[api][]的说明好像有冲突，  
至于在canvas时没问题。  
  
8.setRotationX  
功能：设置矩形的x轴为中心轴上旋转角度，顺时针为正。  
参数：\{Number\} rotationX  
描述：在webgl的渲染模式下，x轴为中心轴上旋转（垂直翻转）（以轴为镜像）  
在canvas模式，会以该角度作为普通旋转的角度。（以点为镜像）  
设置后，将节点设为已被修改状态。  
注意：rotationX的单位为角度。  
  
9.setRotationY  
功能：设置矩形的y轴为中心轴上的旋转角度，顺时针为正。  
参数：\{Number\} rotationY  
描述：这个在webgl的渲染模式下，y轴为中心轴上的旋转（水平翻转）（以轴为镜像）  
在canvas模式是应用不上的。  
设置后，将节点设为已被修改状态。  
注意：rotationY的单位为角度。  
  
10.getScale  
功能：获取x轴上的缩放系数  
参数：N/A  
描述：当x轴上的缩放系数与y轴上的不一致时，cocos会抛出一个警告，提醒你在获取缩放系数时  
存在歧义。  
  
11.setScale  
功能：设置x轴和y轴上的缩放系数  
参数：\{Number\} scale  
\{Number\} scaleY (可选)  
描述：当只有一个scale参数时，将x轴和y轴上缩放系数都设为scale  
当传两个参数时，x轴缩放系数设为scale，y轴缩放系数设为scaleY  
设置后，将节点设为已被修改状态。  
  
12.getScaleX  
功能：获取x轴上的缩放系数  
参数：N/A  
注意：默认值为1.0  
  
13.setScaleX  
功能：设置x轴上的缩放系数  
参数：\{Number\} newScaleX  
描述：设置后，将节点设为已被修改状态。  
  
14.setScaleY  
功能：设置y轴上的缩放系数  
参数：\{Number\} newScaleY  
描述：设置后，将节点设为已被修改状态。  
  
15.getScaleY  
功能：设置y轴上的缩放系数  
参数：N/A  
注意：默认值为1.0  
  
16.setPosition  
功能：设置节点的位置点坐标（坐标系为父坐标系，也叫相对坐标系，本地坐标系）  
参数：\{cc.Point\} newPosOrxValue  
\{Number\} yValue  
描述：当传一个参数时，该参数为cc.Point实例赋值给\_position属性  
当传两个个参数时，newPosOrxValue，yValue分别赋值给\_position.x，\_position.y  
设置后，将节点设为已被修改状态。  
  
17.getPosition  
功能：获取节点的位置点坐标（坐标系为父坐标系）  
参数：N/A  
  
18.getPositionX  
功能：获取节点的位置点坐标的x坐标值  
参数：N/A  
  
19.setPositionX  
功能：设置节点的位置点坐标的x坐标值  
参数：\{Number\} x  
描述：设置后，将节点设为已被修改状态。  
  
20.getPositionY  
功能：获取节点的位置点坐标的y坐标值  
参数：N/A  
  
21.setPositionY  
功能：设置节点的位置点坐标的y坐标值  
参数：\{Number\} y  
描述：设置后，将节点设为已被修改状态。  
  
22.getChildrenCount  
功能：获取节点的子节点数量  
参数：N/A  
  
23.getChildren  
功能：获取节点的所有子节点  
描述：子节点放在一个数组（this.\_children）中  
参数：N/A  
  
24.isVisible  
功能：获取节点是否处于显示状态  
参数：N/A  
  
25.setVisible  
功能：设置节点的是否显示  
参数：\{Boolean\} Var  
注意：默认值true  
  
26.getAnchorPoint  
功能：获取节点锚点坐标（坐标系原点为节点的左下角点）  
参数：N/A  
注意：这里的坐标值是一个比值，x为节点[宽度][Link 1]的比值，y为节点高度的比值  
所以，要获取像素值则为(x\*this.\_contentSize.width,y\*this.\_contentSize.height)  
默认值：（0.5,0.5）也就是节点的中心点  
  
27.setAnchorPoint  
功能：设置节点锚点坐标（坐标系原点为节点的左下角点）  
参数：\{cc.Point\} point  
\{Number\} y  
描述：1.当传一个参数时，\{cc.Point\} point 赋值给\_anchorPoint属性  
当传两个个参数时，\{Number\} point，\{Number\} y分别赋值给\_anchorPoint.x，\_anchorPoint.y  
2.将锚点转化为以像素为单位后赋值给\_anchorPointInPoints属性  
3.设置后，将节点设为已被修改状态。  
  
28.getAnchorPointInPoints  
功能：获取节点锚点，以像素为单位  
参数：N/A  
  
29.setContentSize  
功能：设置节点锚点坐标（坐标系原点为节点的左下角点）  
参数：\{cc.Point\} size  
\{Number\} height  
描述：1.当传一个参数时，\{cc.Point\} size 赋值给\_contentSize属性  
当传两个个参数时，\{Number\} size，\{Number\} height分别赋值给\_contentSize.\_width，\_contentSize.\_height  
2.更新以像素为单位的锚点对象，因为尺寸发生了变更  
3.设置后，将节点设为已被修改状态。  
  
30.getContentSize  
功能：获取节点尺寸对象  
返回值类型：\{cc.Size\}  
  
31.isRunning  
功能：获取节点是否在舞台（canvas画布）上  
返回值类型：\{Boolean\}  
描述：当节点进入舞台的时候，isRunning为true  
当节点离开舞台的时候，isRunning为false  
注意：默认值为false  
  
32.getParent  
功能：获取父节点  
返回值类型：\{cc.Node\}  
  
33.isIgnoreAnchorPointForPosition  
功能：获取节点的定位是否忽略其锚点  
返回：\{Boolean\}  
描述：在cocos中有一个规则，对节点定位于某个点，默认情况下，会使节点锚点与  
这个定点重合。当我们忽略锚点，实际上我们就等同于将锚点视为（0,0）了。  
  
34.ignoreAnchorPointForPosition  
功能：设置节点的定位是否忽略其锚点  
参数：\{Boolean\} newValue  
描述：设置后，将节点设为已被修改状态。  
  
35.setTag  
功能：设置节点的标识  
参数：\{Number\} Var  
描述：设置[标识][Link 7]目的是方便我们区分节点的，同时提高代码的可阅读性  
注意：默认值为cc.NODE\_TAG\_INVALID，其值为-1  
例子：  
TAG\_PLAYER = 1;  
TAG\_MONSTER = 2;  
TAG\_BOSS = 3;  
node1.setTag(TAG\_PLAYER);  
node2.setTag(TAG\_MONSTER);  
node3.setTag(TAG\_BOSS);  
  
36.getTag  
功能：设置节点的定位是否忽略其锚点  
参数：N/A  
描述：设置后，将节点设为已被修改状态。  
例子：  
for(var i = 0; i < nodes.length; i++)\{  
var node = nodes\[i\]  
switch(node.getTag()) \{  
case TAG\_PLAYER:  
break;  
case TAG\_MONSTER:  
break;  
case TAG\_BOSS:  
break;  
\}  
\}  
  
37.setUserData  
功能：设置节点的用户数据  
参数：\{object\} Var  
描述：参数Var可以是一个数据块，数组、jason格式数据集、对象  
注意：1.默认值为null  
2.当这部分数据没用的时候，要记得手动释放其内存  
  
38.getUserData  
功能：获取节点的用户数据  
参数：N/A  
返回：\{object\} Var  
描述：Var可以是一个数据块，数组、jason格式数据集、对象  
  
39.setUserObject  
功能：设置节点的用户数据对象  
参数：\{cc.Class\} newValue  
描述：跟setUserData用法差不多，  
不同点是参数newValue为一个对象，该对象继承自cc.Class  
而setUserData既可以是对象，也可以是其他类型格式的数据  
注意：1.默认值为null  
2.当这部分数据没用的时候，要记得手动释放其内存  
  
40.getUserObject  
功能：获取节点的用户数据对象  
参数：N/A  
返回值类型：\{cc.Class\}  
描述：返回的对象继承自cc.Class  
  
41.getZOrder  
功能：获取节点的z-index  
参数：N/A  
返回：\{Number\}  
描述：这个值和css当中的z-index是一个概念，用于控制节点的显示层级，  
值较大的显示在值较小的上面。  
  
42.getVertexZ  
功能：获取节点的webgl的z-index  
参数：N/A  
返回：\{Number\}  
描述：这个VertexZ值和ZOrder的值有什么区别，由于webgl本身是应用于3d图形绘制的  
，所以webgl有z轴上的层级概念，用VertexZ来表示，假如层A的VertexZ为0，层B的VertexZ为1，  
层A的子节点a的ZOrder为100，层B的子节点b的zOrder为0，最终b会显示在a的上面，尽管b的ZOrder  
小于a，但b的老爸的VertexZ高于a的老爸的，所以b会显示在a之上。在cocos2d中，建议所有节点的VertexZ都使用0，  
让节点都没得拼爹，那就只管ZOrder来控制上下显示层级就ok了。  
  
43.setVertexZ  
功能：设置节点的webgl的z轴上的层级  
参数：Var  
返回：\{Number\}  
  
44.setZOrder  
功能：设置节点的z-index  
参数：\{Number\} z  
概念解析：  
1.Arrival Order：  
当两个子节点的ZOrder相同时，最终会选择Arrival Order较大的显示在上面的。  
问题是cocos是如何保证不会出现两个子节点的Arrival Order出现相同的情况？  
答：玄机就在reorderChild这个方法，每当你设置节点的ZOrder时，就会产生一个唯一的Arrival Order  
，而且是递增的，也就是说，越迟设置，节点的Arrival Order越大。  
注意：我们在设置节点ZOrder时，要调用setZOrder方法，而不要调用内置的\_setZOrder方法，因为后者是  
不会帮你去维护节点的Arrival Order的。  
描述：1.设置节点的z-index  
2.当该节点存在父节点时，对所有父节点标识为已修改状态  
3.设置该节点的Arrival Order。  
4.将该节点的上一级父节点的是否整理子节点[标识][Link 7]（\_reorderChildDirty）为true  
  
45.getOrderOfArrival  
功能：设置节点的Arrival Order  
描述：当节点的ZOrder一样的时候，就会比较Arrival Order来确定显示的层级，具体  
可参考方法setZOrder的介绍。  
参数：N/A  
返回：\{Number\}  
  
46.getActionManager  
功能：获取动作管理器  
参数：N/A  
返回：\{cc.ActionManager\}  
  
47.setActionManager  
功能：设置动作管理器  
参数：\{cc.ActionManager\} actionManager  
描述：当设置的动作管理器和当前正在使用的不同时，先把当前节点的所有动作都停止，然后再变更动作管理器。  
否则不做任何事。  
  
48.getScheduler  
功能：获取调度器  
参数：N/A  
返回：\{cc.Scheduler\}  
  
49.setScheduler  
功能：设置调度器  
参数：\{cc.Scheduler\} scheduler  
描述：当设置的调度器和当前正在使用的不同时，先取消对所有回调函数的绑定  
（在订阅/发布模式中，相当于取消所有订阅）， 然后再变更调度器。否则不做任何事。  
  
50.setScheduler  
功能：设置调度器  
参数：\{cc.Scheduler\} scheduler  
  
51.getBoundingBox  
功能：获取包含节点的最小矩形，而这个矩形的四个顶点坐标以父坐标系作为基准的。  
参数：N/A  
返回值类型：\{cc.Rect\}  
描述：简单讲下计算过程  
1.先基于本地坐标系，将节点的四个顶点坐标计算出来  
2.对每个顶点与nodeToPranet的变换[矩阵][Link 6]进行运算，得出四个新顶点坐标  
（实现从本地坐标系切换到父坐标系）  
3.通过心刚获取的四个顶点坐标，计算出矩形的[宽度][Link 1]和高度。  
  
52.cleanup  
功能：停止所有动作和解除所有回调[函数][Link 2]的绑定（取消所有订阅）  
参数：N/A  
描述：这个方法也会对该节点下的所有子节点进行相同的操作。  
  
53.description  
功能：返回描述字符串  
参数：N/A  
描述：这个方法主要是为了方便调试，让我们调试的时候知道这个对象的类型和标识。  
返回的字符串："<cc.Node | Tag =" + this.\_tag + ">"  
cc.Node：表示这个对象时一个cc.Node实例  
this.\_tag：表示这个节点的[标识][Link 7]，它时通过setTag方法来设置的，主要方便我们  
识别这个节点是一个什么游戏角色，是怪物，还是英雄等。属于一个数值类型。  
  
54.getChildByTag  
功能：通过Tag来找子节点  
参数：\{Number\} aTag  
描述：假如出现多个标识都为aTag子节点，则只返回最先找到的那一个，  
当没找到的时候，返回null  
  
55.addChild  
功能：添加子节点  
参数：\{cc.Node\} child  
\{Number\} zOrder(可选)  
\{Number\} tag(可选)  
描述：1.child的zOrder和tag属性值优先服从参数zOrder和tag，假如参数为空时  
才以child自带的为准。  
2.设置child的父节点为当前节点，并将child添加到当前节点的\_children数组中  
3.将当前节点的是否需要重新调整子节点标识（\_reorderChildDirty）设置为true。  
  
  
注意：1.不允许将自身作为子节点的，这个主要是防止死循环的  
2.当child已经存在父节点，也不允许添加到当前节点  
3.当child为空时，cocos抛出异常信息  
4.\_reorderChildDirty这个[标识][Link 7]为true时，会对当前节点的所有子节点根据zOrder进行排序的  
  
56.removeChild  
功能：移除子节点  
参数：\{cc.Node\} child  
\{Boolean|null\} cleanup  
描述：1.从当前节点移除指定子。具体请参照内置的\_detachChild方法  
2.移除完，设置将节点设为已被修改状态。  
3.cleanup设置true的时候，将子节点的进行cleanup操作，主要就是释放  
内存。  
注意：cleanup，默认为true  
  
57.removeChildByTag  
功能：根据tag来移除子节点  
参数：\{Number\} tag  
\{Boolean\} cleanup  
  
描述：1.通过tag找到对应的子节点，然后移除之  
2.cleanup为true时，将子节点的进行cleanup操作，主要就是释放  
内存。  
注意：当tag为-1时，cocos会提示无效的tag值并将信息记录到日志上。  
  
58.removeAllChildren  
功能：移除所有子节点  
参数：\{Boolean\} cleanup（可选）  
描述：没传cleanup参数时，会以cleanup=true处理  
注意：1.官方称不建议使用这个方法，用removeAllChildren替代  
2.在这个方法其实可以复用\_detachChild方法删除子节点，但为了提高性能，  
采用了复用\_detachChild实现代码，而不是调用该方法。  
  
59.removeAllChildrenWithCleanup  
功能：移除所有子节点  
参数：\{Boolean\} cleanup（可选）  
描述：这个方法的使用与removeAllChildren完全一致  
注意：官方称不建议使用这个方法，用removeAllChildren替代  
  
60.sortAllChildren  
功能：按照子节点的zOrder和orderOfArrival进行排序  
优先级的定义：  
1.zOrder越大的优先级越小  
2.zOrder相同的，orderOfArrival越大的优先级越小  
排序依据：  
1.按优先级进行降序排列，越往后排，优先级越小  
参数：N/A  
描述：优先级越小的越迟绘画在舞台上，所以优先级越小会在较上层显示的。  
排序的算法为冒泡排序。  
注意：排序完之后，是否重新整理子节点的属性（\_reorderChildDirty）设置为false  
  
61.reorderChild  
功能：修改（整理）子节点属性  
参数：\{cc.Node\} child  
\{Number\} zOrder  
描述：1.设置子节点child的zOrder属性  
2.设置当前节点（child的父节点）的是否重新整理子节点的属性（\_reorderChildDirty）设置为true  
3.设置当前节点（child的父节点）为已修改状态  
4.设置子节点child的Arrival为cc.s\_globalOrderOfArrival++  
  
注意：\_reorderChildDirty为true，激活sortAllChildren方法进行排序，因为设置zOrder影响了排序  
因子。  
  
62.draw  
功能：绘图  
参数：\{CanvasContext\} ctx  
描述：提供给外面重写的一个方法  
  
63.transformAncestors  
功能：基于gl坐标系对节点进行绘画  
参数：N/A  
描述：原理就是从当前节点一直向祖先节点追溯，直至最顶层的节点，然后往下逐一进行变换，  
直至当前节点，所以最终绘画的坐标系就是基于最顶层节点坐标系，即是gl坐标系。  
  
64.onEnter  
功能：刚进入舞台要做的处理  
被调用的时机：进入舞台的过渡效果开始的那一刻  
参数：N/A  
描述：1.过渡结束的标识设置为false  
2.是否在舞台的标识设置为true  
3.对当前节点的下一级子节点都执行各自的onEnter方法  
4.激活调度和启动动作  
注意：假如这个节点有过度效果，则onEnter会在这个过渡效果开始的时候被调用，不是等到过渡效果  
结束后才被调用。  
  
65.onEnterTransitionDidFinish  
功能：进入舞台后要做的处理  
被调用的时机：进入舞台的过渡效果结束的那一刻  
参数：N/A  
描述：1.将过渡结束的[标识][Link 7]设置为true  
2.对当前节点的下一级子节点都执行各自的onEnterTransitionDidFinish方法  
  
66.onExitTransitionDidStart  
功能：离开舞台的过渡效果开始的那一刻被调用  
参数：N/A  
描述：对当前节点的下一级子节点都执行各自的onExitTransitionDidStart方法  
  
67.onExit  
功能：离开舞台时被调用  
被调用的时机：离开舞台的过渡效果结束的那一刻  
参数：N/A  
描述：1.当前节点是否在舞台的标识设置为false  
2.暂停调度和所有动作  
3.对当前节点的下一级子节点都执行各自的onExit方法  
  
68.runAction  
功能：执行一个动作  
参数：\{cc.Action\} action  
返回：\{cc.Action\} action  
描述：假如节点不在舞台上，那么执行该方法时，会暂停动作。  
  
69.stopAllActions  
功能：停止所有动作  
参数：N/A  
返回：通过动作管理器移除该节点所有动作对象  
  
70.stopAction  
功能：停止指定动作  
参数：\{cc.Action\} action  
返回：通过动作管理器移除该节点指定的动作对象  
  
71.stopActionByTag  
功能：停止指定动作  
参数：\{Number\} tag  
返回：\{cc.Action\} action  
描述：cc.Action的实例也有对应的tag[标识][Link 7]，那么stopActionByTag通过tag  
找到对应的动作对象，并从节点中移除该动作对象。  
  
72.getActionByTag  
功能：停止指定动作  
参数：\{Number\} tag  
返回：\{cc.Action\} action  
描述：通过tag找到对应的动作对象。  
  
73.getNumberOfRunningActions  
功能：获取正在执行当中的动作对象（非暂停状态）的个数  
参数：N/A  
返回：\{Number\}  
  
**十、 ****cc.Action类**  
功能：动作类，用于实现节点动作的相关操作。  
位置：CCAction.js  
继承树：  
cc.Class  
cc.Action  
  
1.description  
功能：返回描述字符串  
参数：N/A  
描述：这个方法主要是为了方便调试，让我们调试的时候知道这个对象的类型和标识。  
返回的字符串："<cc.Action | Tag = " + this.\_tag + ">"  
cc.Action：表示这个对象是一个cc.Action实例  
this.\_tag：表示这个动作对象的标识，它时通过setTag方法来设置的，主要方便我们  
识别这个它  
  
2.setTag  
功能：设置动作对象的标识  
参数：\{Number\} tag  
描述：设置标识目的是方便我们区分节点的，同时提高代码的可阅读性  
注意：默认值为cc.ACTION\_TAG\_INVALID，其值为-1  
  
3.clone  
功能：返回自身的一个克隆副本  
参数：N/A  
描述：1.创建一个动作对象实例  
2.将新实例的\_tag设置为自身的\_tag[标识][Link 7]  
3.返回这个对象。  
注意：克隆副本的\_originalTarget，\_target都被重新设置为null，也就是说这个克隆副本并不是  
完全等价于自身的。  
  
4.copy  
功能：返回自身的一个克隆副本  
参数：N/A  
描述：跟clone方法功能一致，它的实现调用了clone方法。  
  
5.isDone  
功能：返回是否已经完成动作  
参数：N/A  
返回值类型：\{Boolean\}  
注意：这里采用了硬编码方式，永远都返回true  
  
6.startWithTarget  
功能：将动作对象挂载在节点上  
调用时机：动作开始之前的那一刻  
参数：\{cc.Node\} target  
描述：动作，在语文里，都有主谓宾，谓语之前总要有主语，而该方法就是为动作  
添加主语，这个主语就是节点。  
  
7.stop  
功能：将动作的主语（节点）卸载  
调用时机：动作完成之后的那一刻  
参数：N/A  
描述：所谓卸载，就是将动作对象的\_[target][]设置为null，为了释放内存  
  
8.step  
功能：将动作对象挂载在节点上  
调用时机：每隔一帧调用一次  
参数：\{Number\} dt  
描述：在设置document.ccConfig的时候，有一个属性frameRate（画面每秒显示的帧数,默认值60）  
，那么每帧的时间间隔为1/frameRate。  
注意：  
1.官方称当你知道该做哪些事的时候才去改写之（意为一般情况下无需改写）。  
2.参数dt单位为秒  
3.frameRate默认为60，是为了能应用requestAnimationFrame来做间竭调用，从侧面反映出其实  
默认的往往就是最好的。  
  
9.update  
功能：进行一些必要的更新  
（[api][]文档也没说清究竟更新什么，实际就是提供一个接口，方便我们做更新而已）  
调用时机：每隔一帧调用一次  
参数：\{Number\} time  
描述：参数time是表示处于动画时间段的比例，并用0到1的浮点数表示  
例如：  
0 -> 动作刚开始  
0.5 -> 动作完成一半的时候  
1 -> 动作完成的时候  
  
10.getTarget  
功能：获取动作的主语（节点）  
参数：N/A  
返回值类型：\{cc.Node\}  
  
**十一、 ****cc.FiniteTimeAction类**  
功能：用于处理有时间限制的动作。  
位置：CCAction.js  
继承树：  
cc.Class  
cc.Action  
cc.FiniteTimeAction  
  
普通方法  
1.setDuration  
功能：设置动作的持续时间（以秒为单位）  
参数：\{Number\} duration  
注意：\_duration默认值为0  
  
2.getDuration  
功能：获取动作的持续时间（以秒为单位）  
返回值类型：\{Number\}  
  
3.clone  
功能：返回一个新的cc.FiniteTimeAction实例  
返回值类型：\{cc.FiniteTimeAction\}  
质疑：这个方法应该作为类的方法，好像cc.Action的create方法那样。   
  
4.reverse  
功能：返回一个反向的动作  
参数：N/A  
描述：这个方法主要提供给子类重写的，并返回\{cc.Action\}动作对象，假如子类不重写，会一律返回null  
注意：这个方法在子类中cc.Speed被重写，并返回\{cc.ActionInterval\}类型  
（继承自cc.FiniteTimeAction ，而cc.FiniteTimeAction继承自cc.Action）  
  
5.ctor  
功能：初始化函数  
参数：N/A  
描述: 1.设置\_duration为0  
2.执行cc.Action的初始化[函数][Link 2]  
  
**十二、 ****cc.Speed类**  
功能：用于控制动作的快慢操作。  
位置：CCAction.js  
继承树：  
cc.Class  
cc.Action  
cc.Speed

类的方法

1.create

功能：创建一个cc.Speed实例

参数：N/A

返回值类型：\{cc.Speed\}

普通方法

1.setSpeed

功能：设置速度

参数：\{Number\} speed

描述：这里speed的用法，主要控制速度的，

1 -> 速度不变

>1 -> 提速

<1 -> 减速

2.getSpeed

功能：获取速度

返回值类型：\{Number\}

3.clone

功能：返回自身的一个拷贝副本

返回值类型：\{cc.Speed\}

描述：这个副本将会拥有与自身一样的速度(\_speed)，但是自身的内建动作对象(\_innerAction)

与副本的\_innerAction并不完全等价，只是它们在动作的持续时间\_duration属性是相同的。

4.initWithAction

功能：初始化动作对象

参数：\{cc.ActionInterval\} action

\{Number\} speed

描述：1.将action设置为内建动作对象(\_innerAction)

2.speed设置为该实例的\_speed属性值。

注意：初始化成功后会返回true，但action为空时，cocos抛出异常

5.ctor

功能：初始化函数

参数：N/A

描述: 1.设置\_speed为0

2.设置\_innerAction为null

3.执行cc.Action的初始化[函数][Link 2]

6.startWithTarget

功能：将动作对象挂载在节点上

调用时机：动作开始之前的那一刻

参数：\{cc.Node\} target

描述：1.将自身(动作)的节点(主语)设置为target

2.内建动作对象的节点(主语)设置为[target][]

3.内建动作对象的\_elapsed(动作已执行时间)初始化为0

4.内建动作对象的\_firstTick(动作是否首次被激活)设置为true

7.isDone

功能：获取动作是否已经结束

参数：N/A

返回：\{Boolean\}

描述：通过调用内建动作对象(\_innerAction)的同名方法，

其实现依据为 动作当前已执行的时间 >= 动作的持续总时间.

8.getInnerAction

功能：获取内建动作对象

参数：N/A

返回值类型：\{cc.ActionInterval\}

9.setInnerAction

功能：设置内建动作对象

参数：\{cc.ActionInterval\} action

10.stop

功能：停止动作

参数：N/A

描述：将自身和内建动作对象(\_innerAction)的目标节点都设置为null

11.step

功能：停止动作

参数：\{Number\} dt 单位为秒

描述：内建动作对象(\_innerAction)执行同名方法。

调整速度的原理：

1.首先step的调用的时间间隔是固定的

2.通过dt\*this.\_speed/this.\_duration的得出每一帧占动作总进程的比例，也就是说在经过相同的时间，而动作的进程比例增大，则意味著提速，反之，减速。

所以推导出this.\_speed>1为提速，this.\_speed<1为减速。

十三、 cc.Follow类  
功能：用于模拟[摄像机][Link 8]跟拍效果。  
位置：CCAction.js  
[继承][Link 9]树：  
cc.Class  
cc.Action  
cc.Follow  
  
概念解析：  
1.什么是跟拍？  
答：首先存在一个对象，它正在运动，然后拍摄镜头跟着这个对象拍摄。  
好像你看足球比赛的时候，直播的镜头总是把镜头跟随足球而调整它的位置，让足球尽可能保持在屏幕的  
正中央，这就是跟拍，镜头追随者运动之中的足球做跟随运动。在cocos2d当中，足球就相当于游戏中的  
角色，角色在地图中进行移动，为了让角色（sprite对象）维持在屏幕正中间，我们让地图（layer对象）跟随角色  
跟随运动，角色向左走，那么模拟镜头的跟拍，那么实质就是地图向右走。所以这个动作一般为layer对象执行  
的动作。  
  
2.什么是跟拍范围？  
答：拿足球比赛为例，一般[镜头][Link 10]只会[拍摄][Link 11]球场以内的范围，当有球员被红牌罚下场，并走进更衣室，镜头只会跟拍这个  
球员到球场更衣室的出入口处，然后就不跟拍了，那么这个足球场内的这个范围就是所谓的跟拍范围。  
在cocos2d，跟拍范围是一个cc.Rect实例来的。  
  
3.设置跟拍范围的目的何在？  
答：在cocos2d中，设置跟拍范围是为了控制超出这个范围就不跟拍了。  
  
4.什么是边界？  
答：跟拍范围是一个矩形来的（cc.Rect实例），  
左边界：跟拍对象向左运动到x轴的该坐标值时，则停止跟拍运动  
右边界：跟拍对象向右运动到x轴的该坐标值时，则停止跟拍运动  
上边界：跟拍对象向上运动到y轴的该坐标值时，则停止跟拍运动  
下边界：跟拍对象向下运动到y轴的该坐标值时，则停止跟拍运动  
  
注意：跟拍对象的位移在超出跟拍范围之后，依然会继续运动的，只是摄像头不再进行跟拍而已。  
  
介绍一下边界值的计算：  
\* 假设我规定了跟拍范围为（-300，-400，屏幕[宽度][Link 12]\+300\*2，屏幕高度+400\*2）  
[拍摄][Link 11]范围你可以理解成直播中的足球场，而直播画面理解成canvas的视口，  
在最初的时候，很多人以为左边界为-300，右边界为屏幕宽度+300，上边界为屏幕高度+400，下边界为-400，  
这些是跟拍范围的范围边界，和cocos的边界概念是不等价的！  
  
\* cocos的边界是基于跟拍对象的，它计算的是这个对象的在哪个范围内会被跟拍的意思  
而跟拍的过程有一个规定就是跟拍对象维持在屏幕的正中央位置，所以，  
左边界：-300  
右边界：300  
上边界：400  
下边界：-400  
表达的意思就是这个对象在cc.Rect \{-300,-400,600,800\}这个矩形范围内都是会被跟拍的。  
  
\* 推导出的规律就是  
设跟拍范围为rect  
左边界：-(跟拍范围的右边界的x坐标值 - 屏幕宽度)  
=> -(rect.x+rect.width - 屏幕宽度)  
右边界：-rect.x  
上边界：-rect.y  
下边界：-(跟拍范围的上边界的y坐标值 - 屏幕高度)  
=> -(rect.y+rect.height - 屏幕[宽度][Link 12])  
  
1.ctor  
功能：初始化[函数][Link 13]  
参数：N/A  
返回值类型：cc.Follow  
描述：  
1.跟拍范围的四个边界（上下左右）都设置为0  
2.跟拍范围（\_worldRect）设置为空范围\{0,0,0,0\}  
3.跟拍对象（\_followedNode）设置为null  
4.屏幕右下角的点对象（\_fullScreenSize）与 屏幕正中央的点对象（\_halfScreenSize）  
都设置为null  
5.是否限制[拍摄][Link 11]范围的[标识][Link 14]（\_boundarySet）设置为false  
6.将是否需要根据跟拍对象的位移来调整跟拍动作的执行者（通常为layer，如地图）的位置  
的标识（\_boundaryFullyCovered）设置为false。  
  
2.isBoundarySet  
功能：获取是否限制摄像机的跟拍范围。  
参数：N/A  
返回值类型：\{Boolean\}  
描述：1.返回true的话，当超出跟拍范围就会停止跟拍  
2.返回false的话，一直进行跟拍  
注意：1.当初始化[函数][Link 13]中，会将其默认设置为false的  
2.当在initWithTarget方法中，当传入一个非空的cc.Rect实例作为跟拍范围（rect）参数  
时，设置\_boundarySet属性为true，否则都会被设置为false的。  
  
3.setBoudarySet  
功能：设置是否限制摄像机的跟拍范围。  
参数：\{Boolean\} value  
注意：从isBoundarySet方法的注意部分看出，这个方法应尽量少使用，因为  
是否限制[摄像机][Link 8]的跟拍范围的[标识][Link 14]（\_boundarySet）会由initWithTarget方法自动维护的。  
  
4.isDone  
功能：返回跟拍动作是否已完成  
参数：N/A  
返回值：\{Boolean\}  
描述：判断依据为跟拍对象是否还在舞台上。  
这个就好比球赛结束的时候，裁判收回足球并离开球场（跟拍对象离开舞台），  
则直播的画面就会结束一样（跟拍动作结束）。  
  
5.stop  
功能：返回跟拍动作是否已完成  
参数：N/A  
返回值：\{Boolean\}  
描述：1.将动作对象的节点（动作的执行者\_[target][target 1]）设置为null  
2.重新执行父类cc.Action的同名方法。  
质疑：在父类cc.Action的同名方法就已经做了对\_[target][target 1]设置为null的工作了，  
但在该方法中，重复了该操作，这是多余的。  
  
6.initWithTarget  
功能：初始化跟拍动作对象的节点和跟拍范围  
参数：\{cc.Node\} followedNode  
\{cc.Rect\} rect  
返回值：\{Boolean\}  
描述：  
1.计算屏幕右下角的点对象（\_fullScreenSize）与 屏幕正中央的点对象（\_halfScreenSize）  
2.设置是否限制[摄像机][Link 8]的跟拍范围的[标识][Link 14]（\_boundarySet），当rect为非空矩形（\{0,0,0,0\}）则为true，  
否则设置为false  
3.设置四个边界值  
4.初始化成功后返回true值  
  
注意：当跟拍对象（followedNode）为空时，cocos抛出异常，并终止该方法的所有后续操作。  
  
7.step  
功能：每帧画面要做的更新  
参数：\{Number\} dt 单位为秒  
描述：  
1.假如没有设置跟拍，那么跟拍对象会由屏幕的正中央为起始点（0.5\*屏幕[宽度][Link 12]，0.5\*屏幕高度）进行位移的。  
2.假如设置了跟拍，则跟拍对象会由屏幕的正中央为起始点进行位移，并且当运动超出它的边界时，则停留在  
相应的边界上。例如，左边界为-300，而跟拍对象向左移动到-350，则它在-301到-350这段距离时，位置以  
左边界为准，实际上就是欺骗跟随动作的执行者（layer层），让它认为跟拍对象以经停止运动来达到不跟拍  
的效果的。  
  
特殊情况：当跟拍范围小于屏幕时，则不做任何事。因为地图都无屏幕大，那么精灵在上面移动也无必要调整地图位置，  
源于精灵不会超出屏幕以外。  
注意：1.跟随动作的执行者（通常为layer）要根据跟拍对象的位置来调整自身的位置的。  
2.设置对跟拍对象的运动的目的是以此来推算layer层究竟要如何位移，来达到跟拍的效果。  
  
十四、 cc.ActionInterval类  
功能：用于设置动作的间竭变化（相当于分解动作）。  
位置：CCActionInterval.js  
[继承][Link 9]树：  
cc.Class  
cc.Action  
cc.FiniteTimeAction  
cc.ActionInterval  
  
类的方法：  
1.create  
功能：构造函数  
参数：\{Number\} d （单位：秒）  
返回值类型：\{Boolean\}  
描述: 1.创建一个cc.ActionInterval实例  
2.初始化实例的过渡时间为d  
  
普通方法：  
1.ctor  
功能：初始化[函数][Link 13]  
参数：N/A  
描述: 1.执行cc.FiniteTimeAction的同名方法  
（  
过度时间\_duration设置为0  
动作标识\_tag设置为-1  
将动作的执行节点\_[target][target 1]/\_originalTarget设置为null  
）  
2.将动作已执行的时间(\_elapsed)设置为0  
3.是否首次被激活的标识（\_firstTick）设置为false  
  
2.getElapsed  
功能：获取动作已执行的时间（单位：秒）  
参数：N/A  
  
3.initWithDuration  
功能：初始化动作的过渡时间（动作由开始到结束所经历的时间）  
参数：\{Number\} d （单位：秒）  
返回值类型：\{Boolean\}  
描述: 1.设置过渡时间  
2.将动作已执行的时间(\_elapsed)设置为0  
3.是否首次被激活的[标识][Link 14]（\_firstTick）设置为true  
4.设置完之后返回true  
注意：当参数d为0的时候，会用一个表示极小数的常量cc.FLT\_EPSILON作为过渡时间，  
cc.FLT\_EPSILON为0.0000001192092896，这种处理手法的目的不明。  
  
4.isDone  
功能：获取动作是否完成  
参数：\{Number\} d （单位：秒）  
返回值类型：\{Boolean\}  
描述: 动作已执行的时间(\_elapsed) 是否大于等于 动作的过渡时间  
  
5.clone  
功能：返回自身的一个副本  
参数：N/A  
返回值类型：\{Boolean\}  
描述: 1.创建一个cc.ActionInterval实例  
2.初始化实例的过渡时间为自身的过渡时间  
  
6.step  
功能：每一帧画面要做的更新  
参数：\{Number\} dt （单位：秒）  
描述：1.对动作已执行的时间(\_elapsed)增加dt时间  
但当是否首次被激活的[标识][Link 14]（\_firstTick）为true时，(\_elapsed)设置为0  
2.计算当前动作的进程比例（用0-1的值表示）  
3.将进程比例作为参数调用实例的update方法  
注意：这个update方法需要子类去重写，step只负责调用之  
质疑：这个方法直接使用数值0.0000001192092896，而不使用cc.FLT\_EPSILON，这个使  
代码风格很不统一  
  
7.getTarget  
功能：获取动作实施者（节点）  
参数：N/A  
返回类型：\{cc.Node\}  
  
8.setTarget  
功能：设置动作实施者（节点）  
参数：\{cc.Node\} [target][target 1]  
  
9.getOriginalTarget  
功能：获取动作初始实施者（节点）  
参数：N/A  
返回类型：\{cc.Node\}  
注意：OriginalTarget和Target差别在于，在动作对象执行stop方法时，Target会被设置为null  
，而OriginalTarget不会，相同之处是它们都在startWithTarget方法中被初始化为相同的  
节点。OriginalTarget可以理解成动作对象的主要实施者（经常执行该动作的节点）。  
  
10.setOriginalTarget  
功能：设置动作初始实施者（节点）  
参数：\{cc.Node\} originalTarget  
  
11.startWithTarget  
功能：设置动作初始实施者（节点）  
参数：  
  
12.reverse  
功能：返回反向的动作对象  
参数：N/A  
描述：这个方法用于被重写，理解其为一个接口。  
注意：假如子类不重写，则永远会返回null  
  
13.setAmplitudeRate  
功能：设置振幅的比率  
参数：\{Number\} amp  
描述：空方法，主要用于让子类重写的。  
  
14.getAmplitudeRate  
功能：获取振幅的比率  
参数：N/A  
返回值类型：\{Number\}  
描述：空方法，主要用于让子类重写的。  
  
十五、 cc.Sequence类  
功能：用于设置动作的间竭变化（相当于分解动作）。  
位置：CCActionInterval.js  
[继承][Link 9]树：  
cc.Class  
cc.Action  
cc.FiniteTimeAction  
cc.ActionInterval  
cc.Sequence  
  
类的成员变量：  
1.\_actions  
类型：Array  
默认值：null  
作用：存储动作对象  
  
2.\_split  
类型：\{Number\}  
默认值：null  
作用：第一个动作占序列动作的时间比例  
注意：类的内部，永远都是只处理两个动作对象，假如序列动作由两个以上动作组成，  
则将前两个合并成序列动作，再进行操作。  
例如：4个动作组成的序列动作会如下：  
动作1，动作2 => 序列动作1  
序列动作1，动作3 => 序列动作2  
序列动作2，动作4 => 序列动作3  
最终这4个动作的合并结果为序列动作3  
  
3.\_last  
类型：\{Number\}  
默认值：0  
作用：用于[标识][Link 14]动作序列中哪个动作在执行中。如第一个动作在执行中，那么\_last为0，  
第二个动作在执行中，那么\_last为1。  
  
类的方法：  
1.create  
功能：创建一个序列动作  
参数：\{Array|cc.FiniteTimeAction\} tempArray  
描述：这里的参数既可以是\{Array|cc.FiniteTimeAction\}，也可以是以多个参数方式  
例如：  
cc.Sequence.create(\[action1,action2,action3\]);  
也可以写成：  
cc.Sequence.create(action1,action2,action3);  
注意：这种参数类型可变的处理迎合不同人的书写习惯，可以借鉴其处理手法。  
  
2.\_actionOneTwo  
功能：合并两个动作对象  
参数：\{cc.FiniteTimeAction\} actionOne，\{cc.FiniteTimeAction\} actionTwo  
描述：内置方法，不建议在cocos框架外部使用。  
  
普通方法：  
1.initWithTwoActions  
功能：合并两个动作对象。  
参数：\{cc.FiniteTimeAction\} actionOne, \{cc.FiniteTimeAction\} actionTwo  
描述：1.将参数存储于\_actions  
2.叠加两个动作对象的过渡时间，调用父类\{cc.ActionInterval\}同名方法  
注意：两个参数任意一个为null都会抛出异常，初始化成功之后返回true。  
  
2.ctor  
功能：构造器  
参数：N/A  
描述：1.调用上一级父类cc.ActionInterval的同名方法  
2.将\_actions赋值为空数组  
  
3.clone  
功能：返回一个序列动作的拷贝  
返回值类型：\{cc.Sequence\}  
参数：N/A  
  
4.startWithTarget  
功能：挂载动作执行者  
返回值类型：\{cc.Sequence\}  
参数：1.计算动作一与动作二的切换时间点（动作一占动作序列总时间的比例）  
2.\_last赋值为-1  
  
5.stop  
功能：卸载动作执行者  
参数：N/A  
描述：1.执行父类\{cc.Action\}的同名方法  
2.卸载最后一个动作的执行者  
  
6.update  
功能：更新序列动作的每一帧变化操作  
参数：\{Number\} time（0-1的比例,标识序列动作的进程的）  
描述：\* 处理第一个动作（可能是序列动作）  
1.推算第一个动作的当前进程（0-1的比例，标识序动作一的进程的）  
2.关停动作2  
  
\* 处理第二个动作  
1.推算第二个动作的当前进程（0-1的比例，标识序动作二的进程的）  
2.关停动作1  
  
注意：1.从实现的角度来看，支持顺时动作的，顺时动作的进程[标识][Link 14]为1。  
2.该方法主要对两个动作对象进行调度的，在动作一执行时，停掉动作二  
动作二执行时，停掉动作一，每个动作的更新由动作一，动作二的update  
方法具体处理。让我们只要处理好单个动作，再结合本类就可以轻松达到  
串联动作的效果。  
  
7.reverse  
功能：返回一个倒序列动作（反向做的序列动作）  
返回值类型：\{cc.Sequence\}  
参数：N/A  
  
8.copy  
功能：返回一个序列动作的拷贝  
返回值类型：\{cc.Sequence\}  
参数：N/A  
描述：功能等价于clone  
  
十六、 cc.Repeat类  
功能：用于设置动作的重复执行，主要控制重复的那个动作对象的update方法调用。  
位置：CCActionInterval.js  
[继承][Link 9]树：  
cc.Class  
cc.Action  
cc.FiniteTimeAction  
cc.ActionInterval  
cc.Repeat  
  
类的成员变量：  
1.\_times  
类型：\{Number\}  
功能：需要重复的总次数  
  
2.\_total  
类型：\{Number\}  
功能：当前重复次数  
  
普通方法：  
1.initWithAction  
类型：\{cc.FiniteTimeAction\} action, \{Number\} times  
描述：1.计算重复动作总的执行时间  
2.action作为内部对象（重复的那个动作）  
3.times作为需要重复的总次数  
注意：action为\{cc.ActionInstant\}，即时动作，瞬间完成，重复的总次数-1  
  
2.isDone  
功能：是否完成所有动作  
类型：\{Number\}  
返回值类型：\{Boolean\}  
描述：当前重复次数 等于 需要重复的总次数  
  
3.clone  
功能：拷贝重复动作副本  
类型：N/A  
返回类型：\{cc.Repeat\}  
  
4.stop  
功能：关停动作  
描述：1.卸载自身的执行者  
2.卸载内部动作的执行者  
  
5.startWithTarget  
功能：挂载动作执行者  
类型：\{cc.Node\} [target][target 1]  
描述：1.自身挂载执行者  
2.内部动作挂载执行者  
3.计算当前循环的时间区间（\_nextDt），用于与update方法的参数time进行比较，  
识别是否进入下一次重复动作。  
  
6.setInnerAction  
功能：设置内部动作（被重复的那个动作）  
参数：\{cc.FiniteTimeAction\} action  
  
7.getInnerAction  
功能：获取内部动作（被重复的那个动作）  
返回类型：\{cc.FiniteTimeAction\} action  
  
8.reverse  
功能：获取反向重复动作  
返回类型：cc.Repeat  
  
9.update  
功能：更新序列动作的每一帧变化操作  
参数：\{Number\} time（0-1的比例,标识序列动作的进程的）  
描述：1.管理重复的那个动作的update调用时机  
2.根据time识别每一轮循环的结束，关停动作，并重启之，同时更新当前循环  
的完成的时间点\_nextDt。  
  
注意：1.因为动作的update方法传入的参数为0-1之间的，确保所有数值都落在  
这个区间，例如即使我有一个数为1235.23时，我将其与1取余，即提取  
数据的小数部分，1235.23 % 1 = 0.23，从而达到目的，这种写法很值得  
借鉴，不难，但用得很妙！  
  
疑问：1.类的成员变量\_actionInstant，用于[标识][Link 14]重复动作是否为瞬时完成，默认值为false  
，而这个属性没有公开的方法提供修改，类的内部除了初始化的时候赋值以外，没有  
任何对其进行任何操作。在update方法中的使用很费解。  
2.当time大于1时，理论上表示所有循环结束，但当出现当前循环数小于指定重复数时，  
对\_total加1处理，这个\_total在 \_actionInstant为true时，使用到。而\_actionInstant  
在本类中，不可能被修改为true，除非它的子类修改了。  
  
十七、cc.RepeatForever类  
功能：用于设置动作的无限重复执行。  
位置：CCActionInterval.js  
[继承][Link 9]树：  
cc.Class  
cc.Action  
cc.FiniteTimeAction  
cc.ActionInterval  
cc.RepeatForever  
  
类的方法：  
1.create  
功能：创建\{cc.RepeatForever\}实例  
参数：\{cc.ActionInterval\} action  
返回类型：\{cc.RepeatForever\}  
描述：这个方法是为了方便创建无限循环动作的，除了new一个实例，  
并初始化实例（设置需要重复的那个动作对象为内部动作）  
  
普通方法：  
1.reverse  
功能：获取反向重复动作  
返回类型：cc.RepeatForever  
  
2.isDone  
功能：是否完成所有动作  
类型：\{Number\}  
返回值类型：\{Boolean\}  
描述：永远都返回false，因为无限循环的，就是没有停下来的那一刻。  
  
3.setInnerAction  
功能：设置内部动作（被重复的那个动作）  
参数：\{cc.ActionInterval\} action  
注意：cc.RepeatForever 和 cc.Repeat 都有该方法，但是cc.Repeat类传入的  
action类型为\{cc.FiniteTimeAction\}（是cc.ActionInterval的父类）  
  
4.getInnerAction  
功能：获取内部动作（被重复的那个动作）  
返回类型：\{cc.ActionInterval\} action  
注意：cc.RepeatForever 和 cc.Repeat 都有该方法，但是cc.Repeat类传入的  
action类型为\{cc.FiniteTimeAction\}（是cc.ActionInterval的父类）  
  
5.initWithAction  
功能：设置内部动作（被重复的那个动作）  
参数：\{cc.ActionInterval\} action  
  
6.clone  
功能：拷贝重复动作副本  
类型：N/A  
返回类型：\{cc.RepeatForever\}  
  
7.startWithTarget  
功能：挂载动作执行者  
类型：\{cc.Node\} [target][target 1]  
  
8.step  
功能：每隔一帧被调用一次  
参数：\{Number\} dt(单位：秒)  
类型：当检测内部动作（需要重复执行的那个动作）已经完成之后，再重新执行该动作。  
  
十八、cc.Touch类功能：触摸点相关  
位置：CCTouchDelegateProtocol.js  
[继承][Link 9]树：  
cc.Class  
cc.Touch  
  
公共方法：  
1.cc.pSub  
功能：计算两点之间的差距  
参数：\{cc.Point\} v1，\{cc.Point\} v2  
返回类型：\{cc.Point\}  
描述：点v1(10,10)与v2(4,5)的差距为(6,5)  
  
普通方法：  
1.getLocation  
功能：获取当前触点的位置  
参数：N/A  
返回类型：\{cc.Point\}  
  
2.getPreviousLocation  
功能：获取较早前触点的位置  
参数：N/A  
返回类型：\{cc.Point\}  
  
3.getDelta  
功能：获取触点当前位置与较早前的位置的差距  
返回类型：\{cc.Point\}  
  
4.getID  
功能：获取ID  
  
5.getId  
功能：获取ID  
描述：功能与getID一样  
  
6.setTouchInfo  
功能：获取ID  
参数：\{Number\} id，\{Number\} x，\{Number\} y  
描述：将x,y作为最新触点的坐标，并设置id值  
  
7.\_setPrevPoint  
功能：设置较早前的触点坐标  
参数：\{Number\} x，\{Number\} y  
  
8.ctor  
功能：构造[函数][Link 13]  
描述：1.id初始化为0  
2.当前触点，较早前触点位置初始化（0,0）  
  
十九、cc.TouchDispatcher类  
功能：触摸相关事件的调度分发  
位置：CCTouchDispatcher.js  
[继承][Link 9]树：  
cc.Class  
CCTouchDispatcher.js  
  
常量介绍：  
1.cc.TOUCH\_BEGAN  
功能：标识触摸开始的事件  
常量值：0  
  
2.cc.TOUCH\_MOVED  
功能：标识触摸滑动的事件  
常量值：1  
  
3.cc.TOUCH\_ENDED  
功能：标识触摸结束的事件  
常量值：2  
  
4.cc.TOUCH\_CANCELLED  
功能：[标识][Link 14]触摸结束的事件  
常量值：3  
  
相关公共方法：  
1.cc.less  
功能：判断第一个事件[处理器][Link 15]的优先级是否低于第二个  
参数：\{cc.TouchHandler\} p1，\{cc.TouchHandler\} p2  
返回类型：\{Boolean\}  
描述：数字越大，表示优先级低。  
  
2.cc.ArrayAppendObjectToIndex  
功能：将指定对象添加到数组的指定位置  
参数：\{Array\} arr，\{\*\} addObj，\{Number\} index  
返回类型：\{Boolean\}  
描述：指定对象为addObj，指定的位置为index  
  
3.cc.ArrayRemoveObjectAtIndex  
功能：删除数组指定位置的元素  
参数：\{Array\} arr，\{Number\} index  
  
普通方法：  
1.isDispatchEvents  
功能：获取是否分派事件（注册事件）  
返回类型：\{Boolean\}  
  
2.setDispatchEvents  
功能：设置是否分派事件（注册事件）  
参数：\{Boolean\} dispatchEvents  
  
3.forceAddHandler  
功能：强制添加事件[处理器][Link 15]  
参数：\{cc.TouchHandler\} handler，\{Array|cc.TouchHandler\} array  
描述：1.将handler与array的所有元素进行对比优先级，按照优先级越低，插入到array的位置  
将会越后。  
2.当发现handler的代理\{cc.TouchDelegate\}出现在array时，不添加hanndler，并直接  
返回array。  
  
注意：有必要了解一下\{cc.TouchDelegate\}是什么，[代理][Link 16]是什么意思？  
答:\{cc.TouchDelegate\}包含了所有触摸相关的事件类型，如onTouchBegan，onTouchesMoved等等，  
主要是为了统一事件接口，统一管理触摸类的事件。  
  
4.forceRemoveAllDelegates  
功能：强制移除所有事件代理  
参数：N/A  
描述：1.清空保存标准事件处理器的数组  
2.清空保存绑定了作用域的事件[处理器][Link 15]的数组  
注意：清空数组的手法比较新颖，采用\[\].length = 0来实现。  
  
5.\_removeDelegate  
功能：强制移除事件代理  
参数：\{cc.TouchDelegate\} delegate  
描述：1.在没有停止添加，删除事件代理的情况下：  
从\_[target][target 1]edHandlers和\_standardHandlers分别搜索匹配的事件代理，然后删除之。  
2.在停止添加，删除事件代理的情况下：  
从this.\_handlersToAdd搜索匹配，找到就删除之，假如匹配不到，就将delegate  
添加到\_handlersToRemove  
  
注意：1.有个锁（\_locked）的概念，就是是否停止添加，删除事件[代理][Link 16]  
2.\_handlersToAdd和\_handlersToRemove用于锁（\_locked）生效的情况下，  
分别用于暂时存放要添加的事件处理器和要删除的事件处理器，待解锁时  
再去进行添加、删除操作。  
  
6.findHandler  
功能：找出事件[处理器][Link 15]  
参数：\{Array||cc.TouchDelegate\} array， \{cc.TouchDelegate\} delegate  
返回值类型：\{cc.TargetedTouchHandler|cc.StandardTouchHandler|Null\}  
描述：1.当传入一个参数时，认为该参数为delegate，  
首先从\_targetedHandlers找出匹配参数的事件处理器（\{cc.TargetedTouchHandler\}）  
如找不到，从\_standardHandlers找出匹配参数的事件处理器（\{cc.StandardTouchHandler\}）  
2.当传入两个个参数时，  
从array找出匹配参数的事件处理器。  
3.都找不到时，返回null  
注意：\{cc.TouchHandler\} 与 \{cc.TouchDelegate\}的区别是，前者包含后者，并且包含事件代理的优先级等信息  
，后者只是封装了事件。  
  
7.forceRemoveDelegate  
功能：强制移除指定事件代理  
参数：\{cc.TouchDelegate\} delegate  
描述：从\_[target][target 1]edHandlers和\_standardHandlers分别搜索匹配的事件[代理][Link 16]，然后删除之。  
  
8.rearrangeHandlers  
功能：事件[处理器][Link 15]按优先级降序排列  
参数：\{Array\} array  
描述：优先级[标识][Link 14]越大的，拍在越后。

源引：http://www.52ij.com/jishu/4241.html

[dom]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=9805f7118696931b&k=dom&k0=dom&kdi0=0&luki=3&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=1b93968611f70598&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4241%2Ehtml&urlid=0
[Link 1]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=9805f7118696931b&k=%BF%ED%B6%C8&k0=%BF%ED%B6%C8&kdi0=0&luki=5&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=1b93968611f70598&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4241%2Ehtml&urlid=0
[style]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=9805f7118696931b&k=style&k0=style&kdi0=0&luki=2&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=1b93968611f70598&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4241%2Ehtml&urlid=0
[Link 2]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=9805f7118696931b&k=%BA%AF%CA%FD&k0=%BA%AF%CA%FD&kdi0=0&luki=7&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=1b93968611f70598&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4241%2Ehtml&urlid=0
[Link 3]: http://www.52ij.com/op/
[Link 4]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=9805f7118696931b&k=%D4%B4%C2%EB&k0=%D4%B4%C2%EB&kdi0=0&luki=4&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=1b93968611f70598&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4241%2Ehtml&urlid=0
[android]: http://www.52ij.com/jishu/android/
[Link 5]: http://www.52ij.com/app/
[matrix]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=9805f7118696931b&k=matrix&k0=matrix&kdi0=0&luki=1&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=1b93968611f70598&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4241%2Ehtml&urlid=0
[Link 6]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=9805f7118696931b&k=%BE%D8%D5%F3&k0=%BE%D8%D5%F3&kdi0=0&luki=10&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=1b93968611f70598&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4241%2Ehtml&urlid=0
[Link 7]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=9805f7118696931b&k=%B1%EA%CA%B6&k0=%B1%EA%CA%B6&kdi0=0&luki=9&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=1b93968611f70598&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4241%2Ehtml&urlid=0
[api]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=9805f7118696931b&k=api&k0=api&kdi0=0&luki=8&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=1b93968611f70598&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4241%2Ehtml&urlid=0
[target]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=9805f7118696931b&k=target&k0=target&kdi0=0&luki=6&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=1b93968611f70598&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4241%2Ehtml&urlid=0
[Link 8]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=fcf2b6e2f34f7436&k=%C9%E3%CF%F1%BB%FA&k0=%C9%E3%CF%F1%BB%FA&kdi0=0&luki=6&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=36744ff3e2b6f2fc&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4242%2Ehtml&urlid=0
[Link 9]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=fcf2b6e2f34f7436&k=%BC%CC%B3%D0&k0=%BC%CC%B3%D0&kdi0=0&luki=1&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=36744ff3e2b6f2fc&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4242%2Ehtml&urlid=0
[Link 10]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=fcf2b6e2f34f7436&k=%BE%B5%CD%B7&k0=%BE%B5%CD%B7&kdi0=0&luki=3&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=36744ff3e2b6f2fc&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4242%2Ehtml&urlid=0
[Link 11]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=fcf2b6e2f34f7436&k=%C5%C4%C9%E3&k0=%C5%C4%C9%E3&kdi0=0&luki=2&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=36744ff3e2b6f2fc&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4242%2Ehtml&urlid=0
[Link 12]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=fcf2b6e2f34f7436&k=%BF%ED%B6%C8&k0=%BF%ED%B6%C8&kdi0=0&luki=7&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=36744ff3e2b6f2fc&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4242%2Ehtml&urlid=0
[Link 13]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=fcf2b6e2f34f7436&k=%BA%AF%CA%FD&k0=%BA%AF%CA%FD&kdi0=0&luki=5&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=36744ff3e2b6f2fc&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4242%2Ehtml&urlid=0
[Link 14]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=fcf2b6e2f34f7436&k=%B1%EA%CA%B6&k0=%B1%EA%CA%B6&kdi0=0&luki=10&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=36744ff3e2b6f2fc&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4242%2Ehtml&urlid=0
[target 1]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=fcf2b6e2f34f7436&k=target&k0=target&kdi0=0&luki=9&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=36744ff3e2b6f2fc&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4242%2Ehtml&urlid=0
[Link 15]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=fcf2b6e2f34f7436&k=%B4%A6%C0%ED%C6%F7&k0=%B4%A6%C0%ED%C6%F7&kdi0=0&luki=8&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=36744ff3e2b6f2fc&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4242%2Ehtml&urlid=0
[Link 16]: http://cpro.baidu.com/cpro/ui/uijs.php?c=news&cf=1001&ch=0&di=128&fv=17&jk=fcf2b6e2f34f7436&k=%B4%FA%C0%ED&k0=%B4%FA%C0%ED&kdi0=0&luki=4&n=10&p=baidu&q=xiaoxiaobai_cpr&rb=0&rs=1&seller_id=1&sid=36744ff3e2b6f2fc&ssp2=1&stid=0&t=tpclicked3_hc&tu=u1972324&u=http%3A%2F%2Fwww%2E52ij%2Ecom%2Fjishu%2F4242%2Ehtml&urlid=0