ccb 0.0.1

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/core/platform/CCClass.js

@@ -0,0 +1,333 @@
+/****************************************************************************
+ Copyright (c) 2008-2010 Ricardo Quesada
+ Copyright (c) 2011-2012 cocos2d-x.org
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+
+ http://www.cocos2d-x.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+
+var cc = cc || {};
+
+/**
+ * @namespace
+ * @name ClassManager
+ */
+var ClassManager = {
+    id : (0|(Math.random()*998)),
+
+    instanceId : (0|(Math.random()*998)),
+
+    compileSuper : function(func, name, id){
+        //make the func to a string
+        var str = func.toString();
+        //find parameters
+        var pstart = str.indexOf('('), pend = str.indexOf(')');
+        var params = str.substring(pstart+1, pend);
+        params = params.trim();
+
+        //find function body
+        var bstart = str.indexOf('{'), bend = str.lastIndexOf('}');
+        var str = str.substring(bstart+1, bend);
+
+        //now we have the content of the function, replace this._super
+        //find this._super
+        while(str.indexOf('this._super')!= -1)
+        {
+            var sp = str.indexOf('this._super');
+            //find the first '(' from this._super)
+            var bp = str.indexOf('(', sp);
+
+            //find if we are passing params to super
+            var bbp = str.indexOf(')', bp);
+            var superParams = str.substring(bp+1, bbp);
+            superParams = superParams.trim();
+            var coma = superParams? ',':'';
+
+            //replace this._super
+            str = str.substring(0, sp)+  'ClassManager['+id+'].'+name+'.call(this'+coma+str.substring(bp+1);
+        }
+        return Function(params, str);
+    },
+
+    getNewID : function(){
+        return this.id++;
+    },
+
+    getNewInstanceId : function(){
+        return this.instanceId++;
+    }
+};
+ClassManager.compileSuper.ClassManager = ClassManager;
+
+/* Managed JavaScript Inheritance
+ * Based on John Resig's Simple JavaScript Inheritance http://ejohn.org/blog/simple-javascript-inheritance/
+ * MIT Licensed.
+ */
+(function () {
+    var fnTest = /\b_super\b/;
+    var config = cc.game.config;
+    var releaseMode = config[cc.game.CONFIG_KEY.classReleaseMode];
+    if(releaseMode) {
+        console.log("release Mode");
+    }
+
+    /**
+     * The base Class implementation (does nothing)
+     * @class
+     */
+    cc.Class = function () {
+    };
+
+    /**
+     * Create a new Class that inherits from this Class
+     * @static
+     * @param {object} props
+     * @return {function}
+     */
+    cc.Class.extend = function (props) {
+        var _super = this.prototype;
+
+        // Instantiate a base Class (but only create the instance,
+        // don't run the init constructor)
+        var prototype = Object.create(_super);
+
+        var classId = ClassManager.getNewID();
+        ClassManager[classId] = _super;
+        // Copy the properties over onto the new prototype. We make function
+        // properties non-eumerable as this makes typeof === 'function' check
+        // unneccessary in the for...in loop used 1) for generating Class()
+        // 2) for cc.clone and perhaps more. It is also required to make
+        // these function properties cacheable in Carakan.
+        var desc = { writable: true, enumerable: false, configurable: true };
+
+	    prototype.__instanceId = null;
+
+	    // The dummy Class constructor
+	    function Class() {
+		    this.__instanceId = ClassManager.getNewInstanceId();
+		    // All construction is actually done in the init method
+		    if (this.ctor)
+			    this.ctor.apply(this, arguments);
+	    }
+
+	    Class.id = classId;
+	    // desc = { writable: true, enumerable: false, configurable: true,
+	    //          value: XXX }; Again, we make this non-enumerable.
+	    desc.value = classId;
+	    Object.defineProperty(prototype, '__pid', desc);
+
+	    // Populate our constructed prototype object
+	    Class.prototype = prototype;
+
+	    // Enforce the constructor to be what we expect
+	    desc.value = Class;
+	    Object.defineProperty(Class.prototype, 'constructor', desc);
+
+	    // Copy getter/setter
+	    this.__getters__ && (Class.__getters__ = cc.clone(this.__getters__));
+	    this.__setters__ && (Class.__setters__ = cc.clone(this.__setters__));
+
+        for(var idx = 0, li = arguments.length; idx < li; ++idx) {
+            var prop = arguments[idx];
+            for (var name in prop) {
+                var isFunc = (typeof prop[name] === "function");
+                var override = (typeof _super[name] === "function");
+                var hasSuperCall = fnTest.test(prop[name]);
+
+                if (releaseMode && isFunc && override && hasSuperCall) {
+                    desc.value = ClassManager.compileSuper(prop[name], name, classId);
+                    Object.defineProperty(prototype, name, desc);
+                } else if (isFunc && override && hasSuperCall) {
+                    desc.value = (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]);
+                    Object.defineProperty(prototype, name, desc);
+                } else if (isFunc) {
+                    desc.value = prop[name];
+                    Object.defineProperty(prototype, name, desc);
+                } else {
+                    prototype[name] = prop[name];
+                }
+
+                if (isFunc) {
+                    // Override registered getter/setter
+                    var getter, setter, propertyName;
+                    if (this.__getters__ && this.__getters__[name]) {
+                        propertyName = this.__getters__[name];
+                        for (var i in this.__setters__) {
+                            if (this.__setters__[i] == propertyName) {
+                                setter = i;
+                                break;
+                            }
+                        }
+                        cc.defineGetterSetter(prototype, propertyName, prop[name], prop[setter] ? prop[setter] : prototype[setter], name, setter);
+                    }
+                    if (this.__setters__ && this.__setters__[name]) {
+                        propertyName = this.__setters__[name];
+                        for (var i in this.__getters__) {
+                            if (this.__getters__[i] == propertyName) {
+                                getter = i;
+                                break;
+                            }
+                        }
+                        cc.defineGetterSetter(prototype, propertyName, prop[getter] ? prop[getter] : prototype[getter], prop[name], getter, name);
+                    }
+                }
+            }
+        }
+
+        // And make this Class extendable
+        Class.extend = cc.Class.extend;
+
+        //add implementation method
+        Class.implement = function (prop) {
+            for (var name in prop) {
+                prototype[name] = prop[name];
+            }
+        };
+        return Class;
+    };
+})();
+
+/**
+ * Common getter setter configuration function
+ * @function
+ * @param {Object}   proto      A class prototype or an object to config<br/>
+ * @param {String}   prop       Property name
+ * @param {function} getter     Getter function for the property
+ * @param {function} setter     Setter function for the property
+ * @param {String}   getterName Name of getter function for the property
+ * @param {String}   setterName Name of setter function for the property
+ */
+cc.defineGetterSetter = function (proto, prop, getter, setter, getterName, setterName){
+    if (proto.__defineGetter__) {
+        getter && proto.__defineGetter__(prop, getter);
+        setter && proto.__defineSetter__(prop, setter);
+    } else if (Object.defineProperty) {
+        var desc = { enumerable: false, configurable: true };
+        getter && (desc.get = getter);
+        setter && (desc.set = setter);
+        Object.defineProperty(proto, prop, desc);
+    } else {
+        throw new Error("browser does not support getters");
+    }
+
+    if(!getterName && !setterName) {
+        // Lookup getter/setter function
+        var hasGetter = (getter != null), hasSetter = (setter != undefined), props = Object.getOwnPropertyNames(proto);
+        for (var i = 0; i < props.length; i++) {
+            var name = props[i];
+
+            if( (proto.__lookupGetter__ ? proto.__lookupGetter__(name)
+                                        : Object.getOwnPropertyDescriptor(proto, name))
+                || typeof proto[name] !== "function" )
+                continue;
+
+            var func = proto[name];
+            if (hasGetter && func === getter) {
+                getterName = name;
+                if(!hasSetter || setterName) break;
+            }
+            if (hasSetter && func === setter) {
+                setterName = name;
+                if(!hasGetter || getterName) break;
+            }
+        }
+    }
+
+    // Found getter/setter
+    var ctor = proto.constructor;
+    if (getterName) {
+        if (!ctor.__getters__) {
+            ctor.__getters__ = {};
+        }
+        ctor.__getters__[getterName] = prop;
+    }
+    if (setterName) {
+        if (!ctor.__setters__) {
+            ctor.__setters__ = {};
+        }
+        ctor.__setters__[setterName] = prop;
+    }
+};
+
+/**
+ * Create a new object and copy all properties in an exist object to the new object
+ * @function
+ * @param {object|Array} obj The source object
+ * @return {Array|object} The created object
+ */
+cc.clone = function (obj) {
+    // Cloning is better if the new object is having the same prototype chain
+    // as the copied obj (or otherwise, the cloned object is certainly going to
+    // have a different hidden class). Play with C1/C2 of the
+    // PerformanceVirtualMachineTests suite to see how this makes an impact
+    // under extreme conditions.
+    //
+    // Object.create(Object.getPrototypeOf(obj)) doesn't work well because the
+    // prototype lacks a link to the constructor (Carakan, V8) so the new
+    // object wouldn't have the hidden class that's associated with the
+    // constructor (also, for whatever reasons, utilizing
+    // Object.create(Object.getPrototypeOf(obj)) + Object.defineProperty is even
+    // slower than the original in V8). Therefore, we call the constructor, but
+    // there is a big caveat - it is possible that the this.init() in the
+    // constructor would throw with no argument. It is also possible that a
+    // derived class forgets to set "constructor" on the prototype. We ignore
+    // these possibities for and the ultimate solution is a standardized
+    // Object.clone(<object>).
+    var newObj = (obj.constructor) ? new obj.constructor : {};
+
+    // Assuming that the constuctor above initialized all properies on obj, the
+    // following keyed assignments won't turn newObj into dictionary mode
+    // becasue they're not *appending new properties* but *assigning existing
+    // ones* (note that appending indexed properties is another story). See
+    // CCClass.js for a link to the devils when the assumption fails.
+    for (var key in obj) {
+        var copy = obj[key];
+        // Beware that typeof null == "object" !
+        if (((typeof copy) == "object") && copy &&
+            !(copy instanceof cc.Node) && !(copy instanceof HTMLElement)) {
+            newObj[key] = cc.clone(copy);
+        } else {
+            newObj[key] = copy;
+        }
+    }
+    return newObj;
+};
+
+cc.inject = function(srcPrototype, destPrototype){
+    for(var key in srcPrototype)
+        destPrototype[key] = srcPrototype[key];
+};
+

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/cocos2d/core/platform/CCCommon.js

@@ -0,0 +1,303 @@
+/****************************************************************************
+ Copyright (c) 2008-2010 Ricardo Quesada
+ Copyright (c) 2011-2012 cocos2d-x.org
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+
+ http://www.cocos2d-x.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+
+var cc = cc || {};
+cc._tmp = cc._tmp || {};
+
+/**
+ * Function added for JS bindings compatibility. Not needed in cocos2d-html5.
+ * @function
+ * @param {object} jsObj subclass
+ * @param {object} superclass
+ */
+cc.associateWithNative = function (jsObj, superclass) {
+};
+
+/**
+ * Key map for keyboard event
+ *
+ * @constant
+ * @type {Object}
+ * @example
+    cc.eventManager.addListener({
+        event: cc.EventListener.KEYBOARD,
+        onKeyPressed:  function(keyCode, event){
+            if (cc.KEY["a"] == keyCode) {
+                cc.log("A is pressed");
+            }
+        }
+    }, this);
+ */
+cc.KEY = {
+    none:0,
+
+    // android
+    back:6,
+    menu:18,
+
+    backspace:8,
+    tab:9,
+
+    enter:13,
+
+    shift:16, //should use shiftkey instead
+    ctrl:17, //should use ctrlkey
+    alt:18, //should use altkey
+    pause:19,
+    capslock:20,
+
+    escape:27,
+    space:32,
+    pageup:33,
+    pagedown:34,
+    end:35,
+    home:36,
+    left:37,
+    up:38,
+    right:39,
+    down:40,
+    select:41,
+
+    insert:45,
+    Delete:46,
+    0:48,
+    1:49,
+    2:50,
+    3:51,
+    4:52,
+    5:53,
+    6:54,
+    7:55,
+    8:56,
+    9:57,
+    a:65,
+    b:66,
+    c:67,
+    d:68,
+    e:69,
+    f:70,
+    g:71,
+    h:72,
+    i:73,
+    j:74,
+    k:75,
+    l:76,
+    m:77,
+    n:78,
+    o:79,
+    p:80,
+    q:81,
+    r:82,
+    s:83,
+    t:84,
+    u:85,
+    v:86,
+    w:87,
+    x:88,
+    y:89,
+    z:90,
+
+    num0:96,
+    num1:97,
+    num2:98,
+    num3:99,
+    num4:100,
+    num5:101,
+    num6:102,
+    num7:103,
+    num8:104,
+    num9:105,
+    '*':106,
+    '+':107,
+    '-':109,
+    'numdel':110,
+    '/':111,
+    f1:112, //f1-f12 dont work on ie
+    f2:113,
+    f3:114,
+    f4:115,
+    f5:116,
+    f6:117,
+    f7:118,
+    f8:119,
+    f9:120,
+    f10:121,
+    f11:122,
+    f12:123,
+
+    numlock:144,
+    scrolllock:145,
+
+    ';':186,
+    semicolon:186,
+    equal:187,
+    '=':187,
+    ',':188,
+    comma:188,
+    dash:189,
+    '.':190,
+    period:190,
+    forwardslash:191,
+    grave:192,
+    '[':219,
+    openbracket:219,
+    backslash:220,
+    ']':221,
+    closebracket:221,
+    quote:222,
+
+    // gamepad controll
+    dpadLeft:1000,
+    dpadRight:1001,
+    dpadUp:1003,
+    dpadDown:1004,
+    dpadCenter:1005
+};
+
+/**
+ * Image Format:JPG
+ * @constant
+ * @type {Number}
+ */
+cc.FMT_JPG = 0;
+
+/**
+ * Image Format:PNG
+ * @constant
+ * @type {Number}
+ */
+cc.FMT_PNG = 1;
+
+/**
+ * Image Format:TIFF
+ * @constant
+ * @type {Number}
+ */
+cc.FMT_TIFF = 2;
+
+/**
+ * Image Format:RAWDATA
+ * @constant
+ * @type {Number}
+ */
+cc.FMT_RAWDATA = 3;
+
+/**
+ * Image Format:WEBP
+ * @constant
+ * @type {Number}
+ */
+cc.FMT_WEBP = 4;
+
+/**
+ * Image Format:UNKNOWN
+ * @constant
+ * @type {Number}
+ */
+cc.FMT_UNKNOWN = 5;
+
+/**
+ * get image format by image data
+ * @function
+ * @param {Array} imgData
+ * @returns {Number}
+ */
+cc.getImageFormatByData = function (imgData) {
+	// if it is a png file buffer.
+    if (imgData.length > 8 && imgData[0] == 0x89
+        && imgData[1] == 0x50
+        && imgData[2] == 0x4E
+        && imgData[3] == 0x47
+        && imgData[4] == 0x0D
+        && imgData[5] == 0x0A
+        && imgData[6] == 0x1A
+        && imgData[7] == 0x0A) {
+        return cc.FMT_PNG;
+    }
+
+	// if it is a tiff file buffer.
+    if (imgData.length > 2 && ((imgData[0] == 0x49 && imgData[1] == 0x49)
+        || (imgData[0] == 0x4d && imgData[1] == 0x4d)
+        || (imgData[0] == 0xff && imgData[1] == 0xd8))) {
+        return cc.FMT_TIFF;
+    }
+	return cc.FMT_UNKNOWN;
+};
+
+/**
+ * Another way to subclass: Using Google Closure.
+ * The following code was copied + pasted from goog.base / goog.inherits
+ * @function
+ * @param {Function} childCtor
+ * @param {Function} parentCtor
+ */
+cc.inherits = function (childCtor, parentCtor) {
+    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 ];
+// }
+};
+
+/**
+ * @deprecated since v3.0, please use cc.Class.extend and _super
+ * @cc.Class.extend
+ */
+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');
+    }
+};