cocos creater常用的函数

1.cc.moveTo

参数列表
-时间
-位置

var actionBy = cc.moveTo(2, cc.v2(80, 80));

2.cc.sequence

顺序执行动作，创建的动作将按顺序依次运行。

参数列表

• actionOrActionArray FiniteTimeAction | FiniteTimeAction[]参 数数组
• tempArray FiniteTimeAction

// example
// create sequence with actions
var seq = cc.sequence(act1, act2);

// create sequence with array
var seq = cc.sequence(actArray);

3.Action类

API

/**
 * @module cc
 */

/**
 * !#en Base class cc.Action for action classes.
 * !#zh Action 类是所有动作类型的基类。
 * @class Action
 */
cc.Action = cc.Class({
    name: 'cc.Action',

    //**************Public Functions***********

    ctor:function () {
        this.originalTarget = null;
        this.target = null;
        this.tag = cc.Action.TAG_INVALID;
    },

    /**
     * !#en
     * to copy object with deep copy.
     * returns a clone of action.
     * !#zh 返回一个克隆的动作。
     * @method clone
     * @return {Action}
     */
    clone:function () {
        var action = new cc.Action();
        action.originalTarget = null;
        action.target = null;
        action.tag = this.tag;
        return action;
    },

    /**
     * !#en
     * return true if the action has finished.
     * !#zh 如果动作已完成就返回 true。
     * @method isDone
     * @return {Boolean}
     */
    isDone:function () {
        return true;
    },

    // called before the action start. It will also set the target.
    startWithTarget:function (target) {
        this.originalTarget = target;
        this.target = target;
    },

    // called after the action has finished. It will set the 'target' to nil.
    stop:function () {
        this.target = null;
    },

    // called every frame with it's delta time. <br />
    step:function (dt) {
        cc.logID(1006);
    },

    // Called once per frame. Time is the number of seconds of a frame interval.
    update:function (dt) {
        cc.logID(1007);
    },

    /**
     * !#en get the target.
     * !#zh 获取当前目标节点。
     * @method getTarget
     * @return {Node}
     */
    getTarget:function () {
        return this.target;
    },

    /**
     * !#en The action will modify the target properties.
     * !#zh 设置目标节点。
     * @method setTarget
     * @param {Node} target
     */
    setTarget:function (target) {
        this.target = target;
    },

    /**
     * !#en get the original target.
     * !#zh 获取原始目标节点。
     * @method getOriginalTarget
     * @return {Node}
     */
    getOriginalTarget:function () {
        return this.originalTarget;
    },

    // Set the original target, since target can be nil.
    // Is the target that were used to run the action.
    // Unless you are doing something complex, like cc.ActionManager, you should NOT call this method.
    setOriginalTarget:function (originalTarget) {
        this.originalTarget = originalTarget;
    },

    /**
     * !#en get tag number.
     * !#zh 获取用于识别动作的标签。
     * @method getTag
     * @return {Number}
     */
    getTag:function () {
        return this.tag;
    },

    /**
     * !#en set tag number.
     * !#zh 设置标签，用于识别动作。
     * @method setTag
     * @param {Number} tag
     */
    setTag:function (tag) {
        this.tag = tag;
    },

    // Currently JavaScript Bindigns (JSB), in some cases, needs to use retain and release. This is a bug in JSB,
    // and the ugly workaround is to use retain/release. So, these 2 methods were added to be compatible with JSB.
    // This is a hack, and should be removed once JSB fixes the retain/release bug.
    retain:function () {
    },

    // Currently JavaScript Bindigns (JSB), in some cases, needs to use retain and release. This is a bug in JSB,
    // and the ugly workaround is to use retain/release. So, these 2 methods were added to be compatible with JSB.
    // This is a hack, and should be removed once JSB fixes the retain/release bug.
    release:function () {
    }
});

/**
 * !#en Default Action tag.
 * !#zh 默认动作标签。
 * @property TAG_INVALID
 * @constant
 * @static
 * @type {Number}
 * @default -1
 */
cc.Action.TAG_INVALID = -1;


/**
 * !#en
 * Base class actions that do have a finite time duration. <br/>
 * Possible actions: <br/>
 * - An action with a duration of 0 seconds. <br/>
 * - An action with a duration of 35.5 seconds.
 *
 * Infinite time actions are valid
 * !#zh 有限时间动作，这种动作拥有时长 duration 属性。
 * @class FiniteTimeAction
 * @extends Action
 */
cc.FiniteTimeAction = cc.Class({
    name: 'cc.FiniteTimeAction',
    extends: cc.Action,

    ctor:function () {
        //! duration in seconds
        this._duration = 0;
    },

    /**
     * !#en get duration of the action. (seconds).
     * !#zh 获取动作以秒为单位的持续时间。
     * @method getDuration
     * @return {Number}
     */
    getDuration:function () {
        return this._duration * (this._timesForRepeat || 1);
    },

    /**
     * !#en set duration of the action. (seconds).
     * !#zh 设置动作以秒为单位的持续时间。
     * @method setDuration
     * @param {Number} duration
     */
    setDuration:function (duration) {
        this._duration = duration;
    },

    /**
     * !#en
     * Returns a reversed action. <br />
     * For example: <br />
     * - The action will be x coordinates of 0 move to 100. <br />
     * - The reversed action will be x of 100 move to 0.
     * - Will be rewritten
     * !#zh 返回一个新的动作，执行与原动作完全相反的动作。
     * @method reverse
     * @return {Null}
     */
    reverse:function () {
        cc.logID(1008);
        return null;
    },

    /**
     * !#en
     * to copy object with deep copy.
     * returns a clone of action.
     * !#zh 返回一个克隆的动作。
     * @method clone
     * @return {FiniteTimeAction}
     */
    clone:function () {
        return new cc.FiniteTimeAction();
    }
});

/**
 * @module cc
 */

/*
 * Changes the speed of an action, making it take longer (speed > 1)
 * or less (speed < 1) time. <br/>
 * Useful to simulate 'slow motion' or 'fast forward' effect.
 *
 * @warning This action can't be Sequenceable because it is not an cc.IntervalAction
 * @class Speed
 * @extends Action
 *
 * @param {ActionInterval} action
 * @param {Number} speed
 */
cc.Speed = cc.Class({
    name: 'cc.Speed',
    extends: cc.Action,

    ctor:function (action, speed) {
        this._speed = 0;
        this._innerAction = null;

		action && this.initWithAction(action, speed);
    },

    /*
     * Gets the current running speed. <br />
     * Will get a percentage number, compared to the original speed.
     *
     * @method getSpeed
     * @return {Number}
     */
    getSpeed:function () {
        return this._speed;
    },

    /*
     * alter the speed of the inner function in runtime.
     * @method setSpeed
     * @param {Number} speed
     */
    setSpeed:function (speed) {
        this._speed = speed;
    },

    /*
     * initializes the action.
     * @method initWithAction
     * @param {ActionInterval} action
     * @param {Number} speed
     * @return {Boolean}
     */
    initWithAction:function (action, speed) {
        if (!action) {
            cc.errorID(1021);
            return false;
        }

        this._innerAction = action;
        this._speed = speed;
        return true;
    },

    clone:function () {
        var action = new cc.Speed();
        action.initWithAction(this._innerAction.clone(), this._speed);
        return action;
    },

    startWithTarget:function (target) {
        cc.Action.prototype.startWithTarget.call(this, target);
        this._innerAction.startWithTarget(target);
    },

    stop:function () {
        this._innerAction.stop();
        cc.Action.prototype.stop.call(this);
    },

    step:function (dt) {
        this._innerAction.step(dt * this._speed);
    },

    isDone:function () {
        return this._innerAction.isDone();
    },

    reverse:function () {
        return new cc.Speed(this._innerAction.reverse(), this._speed);
    },

    /*
     * Set inner Action.
     * @method setInnerAction
     * @param {ActionInterval} action
     */
    setInnerAction:function (action) {
        if (this._innerAction !== action) {
            this._innerAction = action;
        }
    },

    /*
     * Get inner Action.
     * @method getInnerAction
     * @return {ActionInterval}
     */
    getInnerAction:function () {
        return this._innerAction;
    }
});

/**
 * @module cc
 */

/**
 * !#en
 * Creates the speed action which changes the speed of an action, making it take longer (speed > 1)
 * or less (speed < 1) time. <br/>
 * Useful to simulate 'slow motion' or 'fast forward' effect.
 * !#zh 修改目标动作的速率。
 * @warning This action can't be Sequenceable because it is not an cc.IntervalAction
 *
 * @method speed
 * @param {ActionInterval} action
 * @param {Number} speed
 * @return {Action}
 * @example
 * // change the target action speed;
 * var action = cc.scaleTo(0.2, 1, 0.6);
 * var newAction = cc.speed(action, 0.5);
 */
cc.speed = function (action, speed) {
    return new cc.Speed(action, speed);
};

/*
 * cc.Follow is a follow action which makes its target follows another node.
 *
 * @example
 * //example
 * //Instead of using cc.Camera as a "follower", use this action instead.
 * layer.runAction(cc.follow(hero));
 *
 * @property {Number}  leftBoundary - world leftBoundary.
 * @property {Number}  rightBoundary - world rightBoundary.
 * @property {Number}  topBoundary - world topBoundary.
 * @property {Number}  bottomBoundary - world bottomBoundary.
 *
 * @param {cc.Node} followedNode
 * @param {Rect} rect
 * @example
 * // creates the action with a set boundary
 * var followAction = new cc.Follow(node, cc.rect(0, 0, s.width * 2 - 100, s.height));
 * this.runAction(followAction);
 *
 * // creates the action with no boundary set
 * var followAction = new cc.Follow(node);
 * this.runAction(followAction);
 *
 * @class
 * @extends Action
 */
cc.Follow = cc.Class({
    name: 'cc.Follow',
    extends: cc.Action,

	/*
     * Constructor function, override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. <br />
	 * creates the action with a set boundary. <br/>
	 * creates the action with no boundary set.
     * @param {cc.Node} followedNode
     * @param {Rect} rect
	 */
    ctor:function (followedNode, rect) {
        // node to follow
        this._followedNode = null;
        // whether camera should be limited to certain area
        this._boundarySet = false;
        // if screen size is bigger than the boundary - update not needed
        this._boundaryFullyCovered = false;
        // fast access to the screen dimensions
        this._halfScreenSize = null;
        this._fullScreenSize = null;

        this.leftBoundary = 0.0;
        this.rightBoundary = 0.0;
        this.topBoundary = 0.0;
        this.bottomBoundary = 0.0;
        this._worldRect = cc.rect(0, 0, 0, 0);

		if(followedNode)
			rect ? this.initWithTarget(followedNode, rect)
				 : this.initWithTarget(followedNode);
    },

    clone:function () {
        var action = new cc.Follow();
        var locRect = this._worldRect;
        var rect = new cc.Rect(locRect.x, locRect.y, locRect.width, locRect.height);
        action.initWithTarget(this._followedNode, rect);
        return action;
    },

    /*
     * Get whether camera should be limited to certain area.
     *
     * @return {Boolean}
     */
    isBoundarySet:function () {
        return this._boundarySet;
    },

    /*
     * alter behavior - turn on/off boundary.
     *
     * @param {Boolean} value
     */
    setBoudarySet:function (value) {
        this._boundarySet = value;
    },

    /*
     * initializes the action with a set boundary.
     *
     * @param {cc.Node} followedNode
     * @param {Rect} [rect=]
     * @return {Boolean}
     */
    initWithTarget:function (followedNode, rect) {
        if (!followedNode) {
            cc.errorID(1022);
            return false;
        }

        var _this = this;
        rect = rect || cc.rect(0, 0, 0, 0);
        _this._followedNode = followedNode;
        _this._worldRect = rect;

        _this._boundarySet = !(rect.width === 0 && rect.height === 0);

        _this._boundaryFullyCovered = false;

        var winSize = cc.winSize;
        _this._fullScreenSize = cc.v2(winSize.width, winSize.height);
        _this._halfScreenSize = _this._fullScreenSize.mul(0.5);

        if (_this._boundarySet) {
            _this.leftBoundary = -((rect.x + rect.width) - _this._fullScreenSize.x);
            _this.rightBoundary = -rect.x;
            _this.topBoundary = -rect.y;
            _this.bottomBoundary = -((rect.y + rect.height) - _this._fullScreenSize.y);

            if (_this.rightBoundary < _this.leftBoundary) {
                // screen width is larger than world's boundary width
                //set both in the middle of the world
                _this.rightBoundary = _this.leftBoundary = (_this.leftBoundary + _this.rightBoundary) / 2;
            }
            if (_this.topBoundary < _this.bottomBoundary) {
                // screen width is larger than world's boundary width
                //set both in the middle of the world
                _this.topBoundary = _this.bottomBoundary = (_this.topBoundary + _this.bottomBoundary) / 2;
            }

            if ((_this.topBoundary === _this.bottomBoundary) && (_this.leftBoundary === _this.rightBoundary))
                _this._boundaryFullyCovered = true;
        }
        return true;
    },

    step:function (dt) {
        var targetWorldPos = this.target.convertToWorldSpaceAR(cc.Vec2.ZERO);
        var followedWorldPos = this._followedNode.convertToWorldSpaceAR(cc.Vec2.ZERO);
        // compute the offset between followed and target node
        var delta = targetWorldPos.sub(followedWorldPos);
        var tempPos = this.target.parent.convertToNodeSpaceAR(delta.add(this._halfScreenSize));

        if (this._boundarySet) {
            // whole map fits inside a single screen, no need to modify the position - unless map boundaries are increased
            if (this._boundaryFullyCovered)
                return;

	        this.target.setPosition(misc.clampf(tempPos.x, this.leftBoundary, this.rightBoundary), misc.clampf(tempPos.y, this.bottomBoundary, this.topBoundary));
        } else {
            this.target.setPosition(tempPos.x, tempPos.y);
        }
    },

    isDone:function () {
        return ( !this._followedNode.activeInHierarchy );
    },

    stop:function () {
        this.target = null;
        cc.Action.prototype.stop.call(this);
    }
});

/**
 * !#en Create a follow action which makes its target follows another node.
 * !#zh 追踪目标节点的位置。
 * @method follow
 * @param {Node} followedNode
 * @param {Rect} rect
 * @return {Action|Null} returns the cc.Follow object on success
 * @example
 * // example
 * // creates the action with a set boundary
 * var followAction = cc.follow(targetNode, cc.rect(0, 0, screenWidth * 2 - 100, screenHeight));
 * node.runAction(followAction);
 *
 * // creates the action with no boundary set
 * var followAction = cc.follow(targetNode);
 * node.runAction(followAction);
 */
cc.follow = function (followedNode, rect) {
    return new cc.Follow(followedNode, rect);
};

4. callback

// example
// CallFunc without data
var finish = cc.callFunc(this.removeSprite, this);

// CallFunc with data
var finish = cc.callFunc(this.removeFromParentAndCleanup, this._grossini,  true);