Cocos2d-html5（version2.2.1）常用API

一些约定：
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. 宽度以参数传入的为准，假如没传宽高，则以元素自身的宽高为准，假如
自身没设置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三种元色构成。是一个构造函数。
参数：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
返回设备操作系统类型的名称
只读，可枚举，可配置（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对象，假如不支持本地存储时，将返回一个空函数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“了，没有下划线的。所以源码存在一点
问题的。

五、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
功能：整个游戏应用的控制器，用于启动游戏
位置：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
* 计算旋转、缩放矩阵变换，并且合并他们
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 } 一个仿射矩阵
质疑：在这个方法的旋转角度我认为以逆时针为正，而非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来标识，并且将该节点的所有父节点
都标识为已被修改的。

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.初始变换矩阵为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就是我们最终要得到的仿射变换矩阵了！
注意：
错切角度
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时，将停止子节点的所有动作和取消所有回调函数的绑定。
这个实际上对内存进行了释放，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为节点宽度的比值，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
描述：设置标识目的是方便我们区分节点的，同时提高代码的可阅读性
注意：默认值为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.将该节点的上一级父节点的是否整理子节点标识（_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的变换矩阵进行运算，得出四个新顶点坐标
（实现从本地坐标系切换到父坐标系）
3.通过心刚获取的四个顶点坐标，计算出矩形的宽度和高度。

52.cleanup
功能：停止所有动作和解除所有回调函数的绑定（取消所有订阅）
参数：N/A
描述：这个方法也会对该节点下的所有子节点进行相同的操作。

53.description
功能：返回描述字符串
参数：N/A
描述：这个方法主要是为了方便调试，让我们调试的时候知道这个对象的类型和标识。
返回的字符串："<cc.Node | Tag =" + this._tag + ">"
cc.Node：表示这个对象时一个cc.Node实例
this._tag：表示这个节点的标识，它时通过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这个标识为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.将过渡结束的标识设置为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标识，那么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标识
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的初始化函数

十二、 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的初始化函数

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类
功能：用于模拟摄像机跟拍效果。
位置：CCAction.js
继承树：
cc.Class
cc.Action
cc.Follow

概念解析：
1.什么是跟拍？
答：首先存在一个对象，它正在运动，然后拍摄镜头跟着这个对象拍摄。
好像你看足球比赛的时候，直播的镜头总是把镜头跟随足球而调整它的位置，让足球尽可能保持在屏幕的
正中央，这就是跟拍，镜头追随者运动之中的足球做跟随运动。在cocos2d当中，足球就相当于游戏中的
角色，角色在地图中进行移动，为了让角色（sprite对象）维持在屏幕正中间，我们让地图（layer对象）跟随角色
跟随运动，角色向左走，那么模拟镜头的跟拍，那么实质就是地图向右走。所以这个动作一般为layer对象执行
的动作。

2.什么是跟拍范围？
答：拿足球比赛为例，一般镜头只会拍摄球场以内的范围，当有球员被红牌罚下场，并走进更衣室，镜头只会跟拍这个
球员到球场更衣室的出入口处，然后就不跟拍了，那么这个足球场内的这个范围就是所谓的跟拍范围。
在cocos2d，跟拍范围是一个cc.Rect实例来的。

3.设置跟拍范围的目的何在？
答：在cocos2d中，设置跟拍范围是为了控制超出这个范围就不跟拍了。

4.什么是边界？
答：跟拍范围是一个矩形来的（cc.Rect实例），
左边界：跟拍对象向左运动到x轴的该坐标值时，则停止跟拍运动
右边界：跟拍对象向右运动到x轴的该坐标值时，则停止跟拍运动
上边界：跟拍对象向上运动到y轴的该坐标值时，则停止跟拍运动
下边界：跟拍对象向下运动到y轴的该坐标值时，则停止跟拍运动

注意：跟拍对象的位移在超出跟拍范围之后，依然会继续运动的，只是摄像头不再进行跟拍而已。

介绍一下边界值的计算：
* 假设我规定了跟拍范围为（-300，-400，屏幕宽度+300*2，屏幕高度+400*2）
拍摄范围你可以理解成直播中的足球场，而直播画面理解成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 - 屏幕宽度)

1.ctor
功能：初始化函数
参数：N/A
返回值类型：cc.Follow
描述：
1.跟拍范围的四个边界（上下左右）都设置为0
2.跟拍范围（_worldRect）设置为空范围{0,0,0,0}
3.跟拍对象（_followedNode）设置为null
4.屏幕右下角的点对象（_fullScreenSize）与 屏幕正中央的点对象（_halfScreenSize）
都设置为null
5.是否限制拍摄范围的标识（_boundarySet）设置为false
6.将是否需要根据跟拍对象的位移来调整跟拍动作的执行者（通常为layer，如地图）的位置
的标识（_boundaryFullyCovered）设置为false。

2.isBoundarySet
功能：获取是否限制摄像机的跟拍范围。
参数：N/A
返回值类型：{Boolean}
描述：1.返回true的话，当超出跟拍范围就会停止跟拍
2.返回false的话，一直进行跟拍
注意：1.当初始化函数中，会将其默认设置为false的
2.当在initWithTarget方法中，当传入一个非空的cc.Rect实例作为跟拍范围（rect）参数
时，设置_boundarySet属性为true，否则都会被设置为false的。

3.setBoudarySet
功能：设置是否限制摄像机的跟拍范围。
参数：{Boolean} value
注意：从isBoundarySet方法的注意部分看出，这个方法应尽量少使用，因为
是否限制摄像机的跟拍范围的标识（_boundarySet）会由initWithTarget方法自动维护的。

4.isDone
功能：返回跟拍动作是否已完成
参数：N/A
返回值：{Boolean}
描述：判断依据为跟拍对象是否还在舞台上。
这个就好比球赛结束的时候，裁判收回足球并离开球场（跟拍对象离开舞台），
则直播的画面就会结束一样（跟拍动作结束）。

5.stop
功能：返回跟拍动作是否已完成
参数：N/A
返回值：{Boolean}
描述：1.将动作对象的节点（动作的执行者_target）设置为null
2.重新执行父类cc.Action的同名方法。
质疑：在父类cc.Action的同名方法就已经做了对_target设置为null的工作了，
但在该方法中，重复了该操作，这是多余的。

6.initWithTarget
功能：初始化跟拍动作对象的节点和跟拍范围
参数：{cc.Node} followedNode
{cc.Rect} rect
返回值：{Boolean}
描述：
1.计算屏幕右下角的点对象（_fullScreenSize）与 屏幕正中央的点对象（_halfScreenSize）
2.设置是否限制摄像机的跟拍范围的标识（_boundarySet），当rect为非空矩形（{0,0,0,0}）则为true，
否则设置为false
3.设置四个边界值
4.初始化成功后返回true值

注意：当跟拍对象（followedNode）为空时，cocos抛出异常，并终止该方法的所有后续操作。

7.step
功能：每帧画面要做的更新
参数：{Number} dt 单位为秒
描述：
1.假如没有设置跟拍，那么跟拍对象会由屏幕的正中央为起始点（0.5*屏幕宽度，0.5*屏幕高度）进行位移的。
2.假如设置了跟拍，则跟拍对象会由屏幕的正中央为起始点进行位移，并且当运动超出它的边界时，则停留在
相应的边界上。例如，左边界为-300，而跟拍对象向左移动到-350，则它在-301到-350这段距离时，位置以
左边界为准，实际上就是欺骗跟随动作的执行者（layer层），让它认为跟拍对象以经停止运动来达到不跟拍
的效果的。

特殊情况：当跟拍范围小于屏幕时，则不做任何事。因为地图都无屏幕大，那么精灵在上面移动也无必要调整地图位置，
源于精灵不会超出屏幕以外。
注意：1.跟随动作的执行者（通常为layer）要根据跟拍对象的位置来调整自身的位置的。
2.设置对跟拍对象的运动的目的是以此来推算layer层究竟要如何位移，来达到跟拍的效果。

十四、 cc.ActionInterval类
功能：用于设置动作的间竭变化（相当于分解动作）。
位置：CCActionInterval.js
继承树：
cc.Class
cc.Action
cc.FiniteTimeAction
cc.ActionInterval

类的方法：
1.create
功能：构造函数
参数：{Number} d （单位：秒）
返回值类型：{Boolean}
描述: 1.创建一个cc.ActionInterval实例
2.初始化实例的过渡时间为d

普通方法：
1.ctor
功能：初始化函数
参数：N/A
描述: 1.执行cc.FiniteTimeAction的同名方法
（
过度时间_duration设置为0
动作标识_tag设置为-1
将动作的执行节点_target/_originalTarget设置为null
）
2.将动作已执行的时间(_elapsed)设置为0
3.是否首次被激活的标识（_firstTick）设置为false

2.getElapsed
功能：获取动作已执行的时间（单位：秒）
参数：N/A

3.initWithDuration
功能：初始化动作的过渡时间（动作由开始到结束所经历的时间）
参数：{Number} d （单位：秒）
返回值类型：{Boolean}
描述: 1.设置过渡时间
2.将动作已执行的时间(_elapsed)设置为0
3.是否首次被激活的标识（_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时间
但当是否首次被激活的标识（_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

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
继承树：
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
作用：用于标识动作序列中哪个动作在执行中。如第一个动作在执行中，那么_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.从实现的角度来看，支持顺时动作的，顺时动作的进程标识为1。
2.该方法主要对两个动作对象进行调度的，在动作一执行时，停掉动作二
动作二执行时，停掉动作一，每个动作的更新由动作一，动作二的update
方法具体处理。让我们只要处理好单个动作，再结合本类就可以轻松达到
串联动作的效果。

7.reverse
功能：返回一个倒序列动作（反向做的序列动作）
返回值类型：{cc.Sequence}
参数：N/A

8.copy
功能：返回一个序列动作的拷贝
返回值类型：{cc.Sequence}
参数：N/A
描述：功能等价于clone

十六、 cc.Repeat类
功能：用于设置动作的重复执行，主要控制重复的那个动作对象的update方法调用。
位置：CCActionInterval.js
继承树：
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
描述：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，用于标识重复动作是否为瞬时完成，默认值为false
，而这个属性没有公开的方法提供修改，类的内部除了初始化的时候赋值以外，没有
任何对其进行任何操作。在update方法中的使用很费解。
2.当time大于1时，理论上表示所有循环结束，但当出现当前循环数小于指定重复数时，
对_total加1处理，这个_total在 _actionInstant为true时，使用到。而_actionInstant
在本类中，不可能被修改为true，除非它的子类修改了。

十七、cc.RepeatForever类
功能：用于设置动作的无限重复执行。
位置：CCActionInterval.js
继承树：
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

8.step
功能：每隔一帧被调用一次
参数：{Number} dt(单位：秒)
类型：当检测内部动作（需要重复执行的那个动作）已经完成之后，再重新执行该动作。

十八、cc.Touch类功能：触摸点相关
位置：CCTouchDelegateProtocol.js
继承树：
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
功能：构造函数
描述：1.id初始化为0
2.当前触点，较早前触点位置初始化（0,0）

十九、cc.TouchDispatcher类
功能：触摸相关事件的调度分发
位置：CCTouchDispatcher.js
继承树：
cc.Class
CCTouchDispatcher.js

常量介绍：
1.cc.TOUCH_BEGAN
功能：标识触摸开始的事件
常量值：0

2.cc.TOUCH_MOVED
功能：标识触摸滑动的事件
常量值：1

3.cc.TOUCH_ENDED
功能：标识触摸结束的事件
常量值：2

4.cc.TOUCH_CANCELLED
功能：标识触摸结束的事件
常量值：3

相关公共方法：
1.cc.less
功能：判断第一个事件处理器的优先级是否低于第二个
参数：{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
功能：强制添加事件处理器
参数：{cc.TouchHandler} handler，{Array|cc.TouchHandler} array
描述：1.将handler与array的所有元素进行对比优先级，按照优先级越低，插入到array的位置
将会越后。
2.当发现handler的代理{cc.TouchDelegate}出现在array时，不添加hanndler，并直接
返回array。

注意：有必要了解一下{cc.TouchDelegate}是什么，代理是什么意思？
答:{cc.TouchDelegate}包含了所有触摸相关的事件类型，如onTouchBegan，onTouchesMoved等等，
主要是为了统一事件接口，统一管理触摸类的事件。

4.forceRemoveAllDelegates
功能：强制移除所有事件代理
参数：N/A
描述：1.清空保存标准事件处理器的数组
2.清空保存绑定了作用域的事件处理器的数组
注意：清空数组的手法比较新颖，采用[].length = 0来实现。

5._removeDelegate
功能：强制移除事件代理
参数：{cc.TouchDelegate} delegate
描述：1.在没有停止添加，删除事件代理的情况下：
从_targetedHandlers和_standardHandlers分别搜索匹配的事件代理，然后删除之。
2.在停止添加，删除事件代理的情况下：
从this._handlersToAdd搜索匹配，找到就删除之，假如匹配不到，就将delegate
添加到_handlersToRemove

注意：1.有个锁（_locked）的概念，就是是否停止添加，删除事件代理
2._handlersToAdd和_handlersToRemove用于锁（_locked）生效的情况下，
分别用于暂时存放要添加的事件处理器和要删除的事件处理器，待解锁时
再去进行添加、删除操作。

6.findHandler
功能：找出事件处理器
参数：{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
描述：从_targetedHandlers和_standardHandlers分别搜索匹配的事件代理，然后删除之。

8.rearrangeHandlers
功能：事件处理器按优先级降序排列
参数：{Array} array
描述：优先级标识越大的，拍在越后。

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