mirror of https://github.com/axmolengine/axmol.git
503 lines
12 KiB
JavaScript
503 lines
12 KiB
JavaScript
//
|
|
// cocos2d constants
|
|
//
|
|
cc.DIRECTOR_PROJECTION_2D = 0;
|
|
cc.DIRECTOR_PROJECTION_3D = 1;
|
|
|
|
cc.TEXTURE_PIXELFORMAT_RGBA8888 = 0;
|
|
cc.TEXTURE_PIXELFORMAT_RGB888 = 1;
|
|
cc.TEXTURE_PIXELFORMAT_RGB565 = 2;
|
|
cc.TEXTURE_PIXELFORMAT_A8 = 3;
|
|
cc.TEXTURE_PIXELFORMAT_I8 = 4;
|
|
cc.TEXTURE_PIXELFORMAT_AI88 = 5;
|
|
cc.TEXTURE_PIXELFORMAT_RGBA4444 = 6;
|
|
cc.TEXTURE_PIXELFORMAT_RGB5A1 = 7;
|
|
cc.TEXTURE_PIXELFORMAT_PVRTC4 = 8;
|
|
cc.TEXTURE_PIXELFORMAT_PVRTC4 = 9;
|
|
cc.TEXTURE_PIXELFORMAT_DEFAULT = cc.TEXTURE_PIXELFORMAT_RGBA8888;
|
|
|
|
cc.TEXT_ALIGNMENT_LEFT = 0;
|
|
cc.TEXT_ALIGNMENT_CENTER = 1;
|
|
cc.TEXT_ALIGNMENT_RIGHT = 2;
|
|
|
|
cc.VERTICAL_TEXT_ALIGNMENT_TOP = 0;
|
|
cc.VERTICAL_TEXT_ALIGNMENT_CENTER = 1;
|
|
cc.VERTICAL_TEXT_ALIGNMENT_BOTTOM = 2;
|
|
|
|
cc.IMAGE_FORMAT_JPEG = 0;
|
|
cc.IMAGE_FORMAT_PNG = 0;
|
|
|
|
cc.PROGRESS_TIMER_TYPE_RADIAL = 0;
|
|
cc.PROGRESS_TIMER_TYPE_BAR = 1;
|
|
|
|
cc.PARTICLE_TYPE_FREE = 0;
|
|
cc.PARTICLE_TYPE_RELATIVE = 1;
|
|
cc.PARTICLE_TYPE_GROUPED = 2;
|
|
cc.PARTICLE_DURATION_INFINITY = -1;
|
|
cc.PARTICLE_MODE_GRAVITY = 0;
|
|
cc.PARTICLE_MODE_RADIUS = 1;
|
|
cc.PARTICLE_START_SIZE_EQUAL_TO_END_SIZE = -1;
|
|
cc.PARTICLE_START_RADIUS_EQUAL_TO_END_RADIUS = -1;
|
|
|
|
cc.TOUCH_ALL_AT_ONCE = 0;
|
|
cc.TOUCH_ONE_BY_ONE = 1;
|
|
|
|
cc.TMX_TILE_HORIZONTAL_FLAG = 0x80000000;
|
|
cc.TMX_TILE_VERTICAL_FLAG = 0x40000000;
|
|
cc.TMX_TILE_DIAGONAL_FLAG = 0x20000000;
|
|
|
|
cc.TRANSITION_ORIENTATION_LEFT_OVER = 0;
|
|
cc.TRANSITION_ORIENTATION_RIGHT_OVER = 1;
|
|
cc.TRANSITION_ORIENTATION_UP_OVER = 0;
|
|
cc.TRANSITION_ORIENTATION_DOWN_OVER = 1;
|
|
|
|
cc.RED = {r:255, g:0, b:0};
|
|
cc.GREEN = {r:0, g:255, b:0};
|
|
cc.BLUE = {r:0, g:0, b:255};
|
|
cc.BLACK = {r:0, g:0, b:0};
|
|
cc.WHITE = {r:255, g:255, b:255};
|
|
|
|
cc.POINT_ZERO = {x:0, y:0};
|
|
|
|
// XXX: This definition is different than cocos2d-html5
|
|
cc.REPEAT_FOREVER = - 1;
|
|
|
|
|
|
cc.MENU_STATE_WAITING = 0;
|
|
cc.MENU_STATE_TRACKING_TOUCH = 1;
|
|
cc.MENU_HANDLER_PRIORITY = -128;
|
|
cc.DEFAULT_PADDING = 5;
|
|
|
|
// reusable objects
|
|
cc._reuse_p = [ {x:0, y:0}, {x:0,y:0}, {x:0,y:0}, {x:0,y:0} ];
|
|
cc._reuse_p_index = 0;
|
|
cc._reuse_size = {width:0, height:0};
|
|
cc._reuse_rect = {x:0, y:0, width:0, height:0};
|
|
cc._reuse_color3b = {r:255, g:255, b:255 };
|
|
cc._reuse_color4b = {r:255, g:255, b:255, a:255 };
|
|
|
|
//
|
|
// Point
|
|
//
|
|
cc.p = function( x, y )
|
|
{
|
|
return {x:x, y:y};
|
|
};
|
|
|
|
cc.g = cc.g || cc.p;
|
|
cc._reuse_grid = cc.g(0,0);
|
|
|
|
cc.log = cc.log || log;
|
|
|
|
//
|
|
// Color 3B
|
|
//
|
|
cc.c3b = function( r, g, b )
|
|
{
|
|
return {r:r, g:g, b:b };
|
|
};
|
|
cc._c3b = function( r, g, b )
|
|
{
|
|
cc._reuse_color3b.r = r;
|
|
cc._reuse_color3b.g = g;
|
|
cc._reuse_color3b.b = b;
|
|
return cc._reuse_color3b;
|
|
};
|
|
|
|
//
|
|
// Color 4B
|
|
//
|
|
cc.c4b = function( r, g, b, a )
|
|
{
|
|
return {r:r, g:g, b:b, a:a };
|
|
};
|
|
cc._c4b = function( r, g, b, a )
|
|
{
|
|
cc._reuse_color4b.r = r;
|
|
cc._reuse_color4b.g = g;
|
|
cc._reuse_color4b.b = b;
|
|
cc._reuse_color4b.a = a;
|
|
return cc._reuse_color4b;
|
|
};
|
|
// compatibility
|
|
cc.c4 = cc.c4b;
|
|
cc._c4 = cc._c4b;
|
|
|
|
//
|
|
// Color 4F
|
|
//
|
|
cc.c4f = function( r, g, b, a )
|
|
{
|
|
return {r:r, g:g, b:b, a:a };
|
|
};
|
|
|
|
//
|
|
// Point
|
|
//
|
|
|
|
cc._p = function( x, y )
|
|
{
|
|
if( cc._reuse_p_index == cc._reuse_p.length )
|
|
cc._reuse_p_index = 0;
|
|
|
|
var p = cc._reuse_p[ cc._reuse_p_index];
|
|
cc._reuse_p_index++;
|
|
p.x = x;
|
|
p.y = y;
|
|
return p;
|
|
};
|
|
|
|
cc.pointEqualToPoint = function (point1, point2) {
|
|
return ((point1.x == point2.x) && (point1.y == point2.y));
|
|
};
|
|
|
|
//
|
|
// Grid
|
|
//
|
|
cc._g = function( x, y )
|
|
{
|
|
cc._reuse_grid.x = x;
|
|
cc._reuse_grid.y = y;
|
|
return cc._reuse_grid;
|
|
};
|
|
|
|
//
|
|
// Size
|
|
//
|
|
cc.size = function(w,h)
|
|
{
|
|
return {width:w, height:h};
|
|
};
|
|
cc._size = function(w,h)
|
|
{
|
|
cc._reuse_size.width = w;
|
|
cc._reuse_size.height = h;
|
|
return cc._reuse_size;
|
|
};
|
|
cc.sizeEqualToSize = function (size1, size2)
|
|
{
|
|
return ((size1.width == size2.width) && (size1.height == size2.height));
|
|
};
|
|
|
|
//
|
|
// Rect
|
|
//
|
|
cc.rect = function(x,y,w,h)
|
|
{
|
|
return {x:x, y:y, width:w, height:h};
|
|
};
|
|
cc._rect = function(x,y,w,h)
|
|
{
|
|
cc._reuse_rect.x = x;
|
|
cc._reuse_rect.y = y;
|
|
cc._reuse_rect.width = w;
|
|
cc._reuse_rect.height = h;
|
|
return cc._reuse_rect;
|
|
};
|
|
cc.rectEqualToRect = function (rect1, rect2) {
|
|
return ( rect1.x==rect2.x && rect1.y==rect2.y && rect1.width==rect2.width && rect1.height==rect2.height);
|
|
};
|
|
|
|
cc.rectContainsRect = function (rect1, rect2) {
|
|
if ((rect1.x >= rect2.x) || (rect1.y >= rect2.y) ||
|
|
( rect1.x + rect1.width <= rect2.x + rect2.width) ||
|
|
( rect1.y + rect1.height <= rect2.y + rect2.height))
|
|
return false;
|
|
return true;
|
|
};
|
|
|
|
cc.rectGetMaxX = function (rect) {
|
|
return (rect.x + rect.width);
|
|
};
|
|
|
|
cc.rectGetMidX = function (rect) {
|
|
return (rect.x + rect.width / 2.0);
|
|
};
|
|
|
|
cc.rectGetMinX = function (rect) {
|
|
return rect.x;
|
|
};
|
|
|
|
cc.rectGetMaxY = function (rect) {
|
|
return(rect.y + rect.height);
|
|
};
|
|
|
|
cc.rectGetMidY = function (rect) {
|
|
return rect.y + rect.height / 2.0;
|
|
};
|
|
|
|
cc.rectGetMinY = function (rect) {
|
|
return rect.y;
|
|
};
|
|
|
|
cc.rectContainsPoint = function (rect, point) {
|
|
var ret = false;
|
|
if (point.x >= rect.x && point.x <= rect.x + rect.width &&
|
|
point.y >= rect.y && point.y <= rect.y + rect.height) {
|
|
ret = true;
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
cc.rectIntersectsRect = function( rectA, rectB )
|
|
{
|
|
var bool = ! ( rectA.x > rectB.x + rectB.width ||
|
|
rectA.x + rectA.width < rectB.x ||
|
|
rectA.y > rectB.y +rectB.height ||
|
|
rectA.y + rectA.height < rectB.y );
|
|
|
|
return bool;
|
|
};
|
|
|
|
cc.rectUnion = function (rectA, rectB) {
|
|
var rect = cc.rect(0, 0, 0, 0);
|
|
rect.x = Math.min(rectA.x, rectB.x);
|
|
rect.y = Math.min(rectA.y, rectB.y);
|
|
rect.width = Math.max(rectA.x + rectA.width, rectB.x + rectB.width) - rect.x;
|
|
rect.height = Math.max(rectA.y + rectA.height, rectB.y + rectB.height) - rect.y;
|
|
return rect;
|
|
};
|
|
|
|
cc.rectIntersection = function (rectA, rectB) {
|
|
var intersection = cc.rect(
|
|
Math.max(rectA.x, rectB.x),
|
|
Math.max(rectA.y, rectB.y),
|
|
0, 0);
|
|
|
|
intersection.width = Math.min(rectA.x+rectA.width, rectB.x+rectB.width) - intersection.x;
|
|
intersection.height = Math.min(rectA.y+rectA.height, rectB.y+rectB.height) - intersection.y;
|
|
return intersection;
|
|
};
|
|
|
|
//
|
|
// Array: for cocos2d-html5 compatibility
|
|
//
|
|
cc.ArrayRemoveObject = function (arr, delObj) {
|
|
for (var i = 0; i < arr.length; i++) {
|
|
if (arr[i] == delObj) {
|
|
arr.splice(i, 1);
|
|
}
|
|
}
|
|
};
|
|
|
|
//
|
|
// Helpers
|
|
//
|
|
cc.dump = function(obj)
|
|
{
|
|
for( var i in obj )
|
|
cc.log( i + " = " + obj[i] );
|
|
};
|
|
|
|
// dump config info, but only in debug mode
|
|
cc.dumpConfig = function()
|
|
{
|
|
if( cc.config.debug )
|
|
cc.dump(cc.config);
|
|
};
|
|
|
|
//
|
|
// Bindings Overrides
|
|
//
|
|
// MenuItemToggle
|
|
cc.MenuItemToggle.create = function( /* var args */) {
|
|
|
|
var n = arguments.length;
|
|
|
|
if (typeof arguments[n-2] === 'function' || typeof arguments[n-1] === 'function') {
|
|
var args = Array.prototype.slice.call(arguments);
|
|
var obj = null;
|
|
if( typeof arguments[n-2] === 'function' )
|
|
obj = args.pop();
|
|
|
|
var func = args.pop();
|
|
|
|
// create it with arguments,
|
|
var item = cc.MenuItemToggle._create.apply(this, args);
|
|
|
|
// then set the callback
|
|
if( obj !== null )
|
|
item.setCallback(func, obj);
|
|
else
|
|
item.setCallback(func);
|
|
return item;
|
|
} else {
|
|
return cc.MenuItemToggle._create.apply(this, arguments);
|
|
}
|
|
};
|
|
|
|
// LabelAtlas
|
|
cc.LabelAtlas.create = function( a,b,c,d,e ) {
|
|
|
|
var n = arguments.length;
|
|
|
|
if ( n == 5) {
|
|
return cc.LabelAtlas._create(a,b,c,d,e.charCodeAt(0));
|
|
} else {
|
|
return cc.LabelAtlas._create.apply(this, arguments);
|
|
}
|
|
};
|
|
|
|
cc.LayerMultiplex.create = cc.LayerMultiplex.createWithArray;
|
|
|
|
// PhysicsDebugNode
|
|
cc.PhysicsDebugNode.create = function( space ) {
|
|
var s = space;
|
|
if( space.handle !== undefined )
|
|
s = space.handle;
|
|
return cc.PhysicsDebugNode._create( s );
|
|
};
|
|
cc.PhysicsDebugNode.prototype.setSpace = function( space ) {
|
|
var s = space;
|
|
if( space.handle !== undefined )
|
|
s = space.handle;
|
|
return this._setSpace( s );
|
|
};
|
|
|
|
// PhysicsSprite
|
|
cc.PhysicsSprite.prototype.setBody = function( body ) {
|
|
var b = body;
|
|
if( body.handle !== undefined )
|
|
b = body.handle;
|
|
return this._setBody( b );
|
|
};
|
|
|
|
|
|
/**
|
|
* Associates a base class with a native superclass
|
|
* @function
|
|
* @param {object} jsobj subclass
|
|
* @param {object} klass superclass
|
|
*/
|
|
cc.associateWithNative = function( jsobj, superclass_or_instance ) {
|
|
|
|
try {
|
|
// Used when subclassing using the "extend" method
|
|
var native = new superclass_or_instance();
|
|
__associateObjWithNative( jsobj, native );
|
|
} catch(err) {
|
|
// Used when subclassing using the goog.inherits method
|
|
__associateObjWithNative( jsobj, superclass_or_instance );
|
|
}
|
|
};
|
|
|
|
//
|
|
// JSB supports 2 official ways to create subclasses
|
|
//
|
|
// 1) Google "subclasses" borrowed from closure library
|
|
// This is the recommended way to do it
|
|
//
|
|
cc.inherits = function (childCtor, parentCtor) {
|
|
/** @constructor */
|
|
function tempCtor() {};
|
|
tempCtor.prototype = parentCtor.prototype;
|
|
childCtor.superClass_ = parentCtor.prototype;
|
|
childCtor.prototype = new tempCtor();
|
|
childCtor.prototype.constructor = childCtor;
|
|
|
|
// Copy "static" method, but doesn't generate subclasses.
|
|
// for( var i in parentCtor ) {
|
|
// childCtor[ i ] = parentCtor[ i ];
|
|
// }
|
|
};
|
|
cc.base = function(me, opt_methodName, var_args) {
|
|
var caller = arguments.callee.caller;
|
|
if (caller.superClass_) {
|
|
// This is a constructor. Call the superclass constructor.
|
|
ret = caller.superClass_.constructor.apply( me, Array.prototype.slice.call(arguments, 1));
|
|
return ret;
|
|
}
|
|
|
|
var args = Array.prototype.slice.call(arguments, 2);
|
|
var foundCaller = false;
|
|
for (var ctor = me.constructor;
|
|
ctor; ctor = ctor.superClass_ && ctor.superClass_.constructor) {
|
|
if (ctor.prototype[opt_methodName] === caller) {
|
|
foundCaller = true;
|
|
} else if (foundCaller) {
|
|
return ctor.prototype[opt_methodName].apply(me, args);
|
|
}
|
|
}
|
|
|
|
// If we did not find the caller in the prototype chain,
|
|
// then one of two things happened:
|
|
// 1) The caller is an instance method.
|
|
// 2) This method was not called by the right caller.
|
|
if (me[opt_methodName] === caller) {
|
|
return me.constructor.prototype[opt_methodName].apply(me, args);
|
|
} else {
|
|
throw Error(
|
|
'cc.base called from a method of one name ' +
|
|
'to a method of a different name');
|
|
}
|
|
};
|
|
|
|
|
|
//
|
|
// 2) Using "extend" subclassing
|
|
// Simple JavaScript Inheritance By John Resig http://ejohn.org/
|
|
//
|
|
cc.Class = function(){};
|
|
cc.Class.extend = function (prop) {
|
|
var _super = this.prototype;
|
|
|
|
// Instantiate a base class (but only create the instance,
|
|
// don't run the init constructor)
|
|
initializing = true;
|
|
var prototype = new this();
|
|
initializing = false;
|
|
fnTest = /xyz/.test(function(){xyz;}) ? /\b_super\b/ : /.*/;
|
|
|
|
// Copy the properties over onto the new prototype
|
|
for (var name in prop) {
|
|
// Check if we're overwriting an existing function
|
|
prototype[name] = typeof prop[name] == "function" &&
|
|
typeof _super[name] == "function" && fnTest.test(prop[name]) ?
|
|
(function (name, fn) {
|
|
return function () {
|
|
var tmp = this._super;
|
|
|
|
// Add a new ._super() method that is the same method
|
|
// but on the super-class
|
|
this._super = _super[name];
|
|
|
|
// The method only need to be bound temporarily, so we
|
|
// remove it when we're done executing
|
|
var ret = fn.apply(this, arguments);
|
|
this._super = tmp;
|
|
|
|
return ret;
|
|
};
|
|
})(name, prop[name]) :
|
|
prop[name];
|
|
}
|
|
|
|
// The dummy class constructor
|
|
function Class() {
|
|
// All construction is actually done in the init method
|
|
if (!initializing && this.ctor)
|
|
this.ctor.apply(this, arguments);
|
|
}
|
|
|
|
// Populate our constructed prototype object
|
|
Class.prototype = prototype;
|
|
|
|
// Enforce the constructor to be what we expect
|
|
Class.prototype.constructor = Class;
|
|
|
|
// And make this class extendable
|
|
Class.extend = arguments.callee;
|
|
|
|
return Class;
|
|
};
|
|
|
|
cc.Node.prototype.ctor = function() {};
|
|
cc.Node.extend = cc.Class.extend;
|
|
cc.Layer.extend = cc.Class.extend;
|
|
cc.LayerGradient.extend = cc.Class.extend;
|
|
cc.LayerColor.extend = cc.Class.extend;
|
|
cc.Sprite.extend = cc.Class.extend;
|
|
cc.MenuItemFont.extend = cc.Class.extend;
|
|
cc.Scene.extend = cc.Class.extend;
|
|
cc.DrawNode.extend = cc.Class.extend;
|