text: /****************************************************************************
   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.
   ****************************************************************************/
  
  cc.BuilderAnimationManagerDelegate = cc._Class.extend({
      completedAnimationSequenceNamed:function (name) {}
  });
  
  cc.BuilderAnimationManager = cc._Class.extend({
      _sequences:null,
      _nodeSequences:null,
      _baseValues:null,
      _autoPlaySequenceId:0,
  
      _rootNode:null,
      _owner:null,
      _rootContainerSize:null,
  
      _delegate:null,
      _runningSequence:null,
  
      _documentOutletNames:null,
      _documentOutletNodes:null,
      _documentCallbackNames:null,
      _documentCallbackNodes:null,
      _documentCallbackControlEvents:null,
      _documentControllerName:"",
      _lastCompletedSequenceName:"",
      _keyframeCallbacks:null,
      _keyframeCallFuncs:null,
  
      _animationCompleteCallbackFunc:null,
      _target:null,
      _jsControlled:false,
  
      ctor:function () {
          this._rootContainerSize = cc.size(0, 0);
          this.init();
      },
  
      init:function () {
          this._sequences = [];
          this._nodeSequences = new cc._Dictionary();
          this._baseValues = new cc._Dictionary();
  
          this._documentOutletNames = [];
          this._documentOutletNodes = [];
          this._documentCallbackNames = [];
          this._documentCallbackNodes = [];
          this._documentCallbackControlEvents = [];
  
          this._keyframeCallbacks = [];
          this._keyframeCallFuncs = {};
  
          return true;
      },
  
      getSequences:function () {
          return this._sequences;
      },
  
      setSequences:function(seqs){
          this._sequences = seqs;
      },
  
      getAutoPlaySequenceId:function () {
          return this._autoPlaySequenceId;
      },
      setAutoPlaySequenceId:function (autoPlaySequenceId) {
          this._autoPlaySequenceId = autoPlaySequenceId;
      },
  
      getRootNode:function () {
          return this._rootNode;
      },
      setRootNode:function (rootNode) {
          this._rootNode = rootNode;
      },
  
      getOwner:function () {
          return this._owner;
      },
      setOwner:function (owner) {
          this._owner = owner;
      },
  
      addDocumentCallbackNode:function(node){
          this._documentCallbackNodes.push(node);
      },
  
      addDocumentCallbackName:function(name){
          this._documentCallbackNames.push(name);
      },
  
      addDocumentCallbackControlEvents:function(controlEvents){
          this._documentCallbackControlEvents.push(controlEvents);
      },
  
      addDocumentOutletNode:function(node){
          this._documentOutletNodes.push(node);
      },
  
      addDocumentOutletName:function(name){
          this._documentOutletNames.push(name);
      },
  
      setDocumentControllerName:function(name){
          this._documentControllerName = name;
      },
  
      getDocumentControllerName:function(){
          return this._documentControllerName;
      },
  
      getDocumentCallbackNames:function(){
          return this._documentCallbackNames;
      },
  
      getDocumentCallbackNodes:function(){
          return this._documentCallbackNodes;
      },
  
      getDocumentCallbackControlEvents:function(){
          return this._documentCallbackControlEvents;
      },
  
      getDocumentOutletNames:function(){
          return this._documentOutletNames;
      },
  
      getDocumentOutletNodes:function(){
          return this._documentOutletNodes;
      },
  
      getLastCompletedSequenceName:function(){
          return this._lastCompletedSequenceName;
      },
  
      getKeyframeCallbacks:function(){
          return this._keyframeCallbacks;
      },
  
      getRootContainerSize:function () {
          return this._rootContainerSize;
      },
      setRootContainerSize:function (rootContainerSize) {
          this._rootContainerSize = cc.size(rootContainerSize.width, rootContainerSize.height);
      },
  
      getDelegate:function () {
          return this._delegate;
      },
      setDelegate:function (delegate) {
          this._delegate = delegate;
      },
  
      getRunningSequenceName:function () {
          if(this._runningSequence)
              return this._runningSequence.getName();
          return null;
      },
  
      getContainerSize:function (node) {
          if (node)
              return node.getContentSize();
          else
              return this._rootContainerSize;
      },
  
      addNode:function (node, seq) {
          this._nodeSequences.setObject(seq, node);
      },
      setBaseValue:function (value, node, propName) {
          var props = this._baseValues.objectForKey(node);
          if (!props) {
              props = new cc._Dictionary();
              this._baseValues.setObject(props, node);
          }
          props.setObject(value, propName);
      },
  
      moveAnimationsFromNode:function(fromNode,toNode){
          // Move base values
          var locBaseValues = this._baseValues;
          var baseValue = locBaseValues.objectForKey(fromNode);
          if(baseValue !== null) {
              locBaseValues.setObject(baseValue, toNode);
              locBaseValues.removeObjectForKey(fromNode);
          }
  
          // Move seqs
          var locNodeSequences = this._nodeSequences;
          var seqs = locNodeSequences.objectForKey(fromNode);
          if(seqs != null) {
              locNodeSequences.setObject(seqs, toNode);
              locNodeSequences.removeObjectForKey(fromNode);
          }
      },
  
      getActionForCallbackChannel:function(channel) {
          var lastKeyframeTime = 0;
  
          var actions = [];
          var keyframes = channel.getKeyframes();
          var numKeyframes = keyframes.length;
  
          for (var i = 0; i < numKeyframes; ++i) {
              var keyframe = keyframes[i];
              var timeSinceLastKeyframe = keyframe.getTime() - lastKeyframeTime;
              lastKeyframeTime = keyframe.getTime();
              if(timeSinceLastKeyframe > 0) {
                  actions.push(cc.delayTime(timeSinceLastKeyframe));
              }
  
              var keyVal = keyframe.getValue();
              var selectorName = keyVal[0];
              var selectorTarget = keyVal[1];
  
              if(this._jsControlled) {
                  var callbackName = selectorTarget + ":" + selectorName;    //add number to the stream
                  var callback = this._keyframeCallFuncs[callbackName];
  
                  if(callback != null)
                      actions.push(callback);
              } else {
                  var target;
                  if(selectorTarget === CCB_TARGETTYPE_DOCUMENTROOT)
                      target = this._rootNode;
                  else if (selectorTarget === CCB_TARGETTYPE_OWNER)
                      target = this._owner;
  
                  if(target != null) {
                      if(selectorName.length > 0) {
                          var selCallFunc = 0;
  
                          if(target.onResolveCCBCCCallFuncSelector != null)
                              selCallFunc = target.onResolveCCBCCCallFuncSelector(target, selectorName);
                          if(selCallFunc === 0)
                              cc.log("Skipping selector '" + selectorName + "' since no CCBSelectorResolver is present.");
                          else
                              actions.push(cc.callFunc(selCallFunc,target));
                      } else {
                          cc.log("Unexpected empty selector.");
                      }
                  }
              }
          }
          if(actions.length < 1)
              return null;
  
          return cc.sequence(actions);
      },
      getActionForSoundChannel:function(channel) {
          var lastKeyframeTime = 0;
  
          var actions = [];
          var keyframes = channel.getKeyframes();
          var numKeyframes = keyframes.length;
  
          for (var i = 0; i < numKeyframes; ++i) {
              var keyframe = keyframes[i];
              var timeSinceLastKeyframe = keyframe.getTime() - lastKeyframeTime;
              lastKeyframeTime = keyframe.getTime();
              if(timeSinceLastKeyframe > 0) {
                  actions.push(cc.delayTime(timeSinceLastKeyframe));
              }
  
              var keyVal = keyframe.getValue();
              var soundFile = cc.BuilderReader.getResourcePath() + keyVal[0];
              var pitch = parseFloat(keyVal[1]), pan = parseFloat(keyVal[2]), gain = parseFloat(keyVal[3]);
              actions.push(cc.BuilderSoundEffect.create(soundFile, pitch, pan, gain));
          }
  
          if(actions.length < 1)
              return null;
  
          return cc.sequence(actions);
      },
  
      runAnimationsForSequenceNamed:function(name){
          this.runAnimationsForSequenceIdTweenDuration(this._getSequenceId(name), 0);
      },
  
      runAnimationsForSequenceNamedTweenDuration:function(name, tweenDuration){
           this.runAnimationsForSequenceIdTweenDuration(this._getSequenceId(name), tweenDuration);
      },
  
      runAnimationsForSequenceIdTweenDuration:function(nSeqId, tweenDuration){
          if(nSeqId === -1)
              throw new Error("cc.BuilderAnimationManager.runAnimationsForSequenceIdTweenDuration(): Sequence id should not be -1");
          tweenDuration = tweenDuration || 0;
  
          this._rootNode.stopAllActions();
  
          var allKeys = this._nodeSequences.allKeys();
          for(var i  = 0,len = allKeys.length  ; i< len;i++){
              var node = allKeys[i];
              node.stopAllActions();
  
              var seqs = this._nodeSequences.objectForKey(node);
              var seqNodeProps = seqs.objectForKey(nSeqId);
              var j;
              var seqNodePropNames = [];
              if(seqNodeProps){
                  var propKeys = seqNodeProps.allKeys();
                  for(j = 0; j < propKeys.length; j++){
                      var propName = propKeys[j];
                      var seqProp = seqNodeProps.objectForKey(propName);
                      seqNodePropNames.push(propName);
  
                      this._setFirstFrame(node, seqProp,tweenDuration);
                      this._runAction(node,seqProp,tweenDuration);
                  }
              }
  
              var nodeBaseValues = this._baseValues.objectForKey(node);
              if(nodeBaseValues){
                  var baseKeys = nodeBaseValues.allKeys();
                  for(j = 0; j < baseKeys.length;j++){
                      var selBaseKey =  baseKeys[j];
                      if(seqNodePropNames.indexOf(selBaseKey) === -1){
                          var value = nodeBaseValues.objectForKey(selBaseKey);
                          if(value != null)
                              this._setAnimatedProperty(selBaseKey,node, value, tweenDuration);
                      }
                  }
              }
          }
  
          // Make callback at end of sequence
          var seq = this._getSequence(nSeqId);
          var completeAction = cc.sequence(cc.delayTime(seq.getDuration() + tweenDuration),
              cc.callFunc(this._sequenceCompleted,this));
          this._rootNode.runAction(completeAction);
  
          // Playback callbacks and sounds
          var action;
          if (seq.getCallbackChannel()) {
              // Build sound actions for channel
              action = this.getActionForCallbackChannel(seq.getCallbackChannel());
              if (action) {
                  this._rootNode.runAction(action);
              }
          }
  
          if (seq.getSoundChannel()) {
              // Build sound actions for channel
              action = this.getActionForSoundChannel(seq.getSoundChannel());
              if (action) {
                  this._rootNode.runAction(action);
              }
          }
          // Set the running scene
          this._runningSequence = this._getSequence(nSeqId);
      },
  
      runAnimations:function (name, tweenDuration) {
          tweenDuration = tweenDuration || 0;
          var nSeqId;
          if(cc.js.isString(name))
              nSeqId = this._getSequenceId(name);
          else
              nSeqId = name;
  
          this.runAnimationsForSequenceIdTweenDuration(nSeqId, tweenDuration);
      },
  
      setAnimationCompletedCallback:function(target,callbackFunc){
          this._target = target;
          this._animationCompleteCallbackFunc = callbackFunc;
      },
  
      setCompletedAnimationCallback:function(target,callbackFunc){
          this.setAnimationCompletedCallback(target,callbackFunc);
      },
      setCallFunc:function(callFunc, callbackNamed) {
          this._keyframeCallFuncs[callbackNamed] = callFunc;
      },
  
      debug:function () {
      },
  
      _getBaseValue:function (node, propName) {
          var props = this._baseValues.objectForKey(node);
          if (props)
              return props.objectForKey(propName);
          return null;
      },
  
      _getSequenceId:function (sequenceName) {
          var element = null;
          var locSequences = this._sequences;
          for (var i = 0, len = locSequences.length; i < len; i++) {
              element = locSequences[i];
              if (element && element.getName() === sequenceName)
                  return element.getSequenceId();
          }
          return -1;
      },
  
      _getSequence:function (sequenceId) {
          var element = null;
          var locSequences = this._sequences;
          for (var i = 0, len = locSequences.length; i < len; i++) {
              element = locSequences[i];
              if (element && element.getSequenceId() === sequenceId)
                  return element;
          }
          return null;
      },
  
      _getAction:function (keyframe0, keyframe1, propName, node) {
          var duration = keyframe1.getTime() - (keyframe0 ? keyframe0.getTime() : 0);
          var getArr,type,getValueArr, x, y;
  
          if (propName === "rotation") {
              return cc.BuilderRotateTo.create(duration, keyframe1.getValue());
          } else if (propName === "rotationX") {
              return cc.BuilderRotateXTo.create(duration, keyframe1.getValue());
          } else if (propName === "rotationY") {
              return cc.BuilderRotateYTo.create(duration, keyframe1.getValue());
          } else if (propName === "opacity") {
              return cc.fadeTo(duration, keyframe1.getValue());
          } else if (propName === "color") {
              var selColor = keyframe1.getValue().getColor();
              return cc.tintTo(duration, selColor.r, selColor.g, selColor.b);
          } else if (propName === "visible") {
              var isVisible = keyframe1.getValue();
              if (isVisible) {
                  return cc.sequence(cc.delayTime(duration), cc.show());
              } else {
                  return cc.sequence(cc.delayTime(duration), cc.hide());
              }
          } else if (propName === "displayFrame") {
              return cc.sequence(cc.delayTime(duration), cc.BuilderSetSpriteFrame.create(keyframe1.getValue()));
          } else if(propName === "position"){
              getArr = this._getBaseValue(node,propName);
              type = getArr[2];
  
              //get relative position
              getValueArr = keyframe1.getValue();
              x = getValueArr[0];
              y = getValueArr[1];
  
              var containerSize = this.getContainerSize(node.getParent());
  
              var absPos = cc._getAbsolutePosition(x,y, type,containerSize,propName);
  
              return cc.moveTo(duration,absPos);
          } else if( propName === "scale"){
              getArr = this._getBaseValue(node,propName);
              type = getArr[2];
  
              //get relative position
              getValueArr = keyframe1.getValue();
              x = getValueArr[0];
              y = getValueArr[1];
  
              if(type === CCB_SCALETYPE_MULTIPLY_RESOLUTION){
                  //TODO need to test
                  var resolutionScale = cc.BuilderReader.getResolutionScale();
                  x *= resolutionScale;
                  y *= resolutionScale;
              }
  
              return cc.scaleTo(duration,x,y);
          } else if( propName === "skew") {
              //get relative position
              getValueArr = keyframe1.getValue();
              x = getValueArr[0];
              y = getValueArr[1];
              return cc.skewTo(duration,x,y);
          } else {
              cc.log("BuilderReader: Failed to create animation for property: " + propName);
          }
          return null;
      },
  
      _setAnimatedProperty:function (propName, node, value, tweenDuration) {
          if(tweenDuration > 0){
              // Create a fake keyframe to generate the action from
              var kf1 = new cc.BuilderKeyframe();
              kf1.setValue(value);
              kf1.setTime(tweenDuration);
              kf1.setEasingType(CCB_KEYFRAME_EASING_LINEAR);
  
              // Animate
              var tweenAction = this._getAction(null, kf1, propName, node);
              node.runAction(tweenAction);
          } else {
              // Just set the value
              var getArr, nType, x,y;
              if(propName === "position"){
                  getArr = this._getBaseValue(node,propName);
                  nType = getArr[2];
  
                  x = value[0];
                  y = value[1];
                  node.setPosition(cc._getAbsolutePosition(x,y,nType, this.getContainerSize(node.getParent()),propName));
              }else if(propName === "scale"){
                  getArr = this._getBaseValue(node,propName);
                  nType = getArr[2];
  
                  x = value[0];
                  y = value[1];
  
                  cc.setRelativeScale(node,x,y,nType,propName);
              } else if( propName === "skew") {
                  x = value[0];
                  y = value[1];
                  node.setSkewX(x);
                  node.setSkewY(y);
              }else {
                  // [node setValue:value forKey:name];
                  // TODO only handle rotation, opacity, displayFrame, color
                  if(propName === "rotation"){
                      node.setRotation(value);
                  }  else if(propName === "rotationX")
                  {
                      node.setRotationSkewX(value);
                  }else if(propName === "rotationY")
                  {
                      node.setRotationSkewY(value);
                  }else if(propName === "opacity"){
                      node.setOpacity(value);
                  } else if(propName === "displayFrame"){
                      node.setSpriteFrame(value);
                  } else if(propName === "color"){
                      var ccColor3B = value.getColor();
                      if(ccColor3B.r !== 255 || ccColor3B.g !== 255 || ccColor3B.b !== 255){
                          node.setColor(ccColor3B);
                      }
                  } else if( propName === "visible"){
                      value = value || false;
                      node.setVisible(value);
                  } else {
                      cc.log("unsupported property name is "+ propName);
                  }
              }
          }
      },
  
      _setFirstFrame:function (node, seqProp, tweenDuration) {
          var keyframes = seqProp.getKeyframes();
  
          if (keyframes.length === 0) {
              // Use base value (no animation)
              var baseValue = this._getBaseValue(node, seqProp.getName());
              if(!baseValue)
                  cc.log("cc.BuilderAnimationManager._setFirstFrame(): No baseValue found for property");
              this._setAnimatedProperty(seqProp.getName(), node, baseValue, tweenDuration);
          } else {
              // Use first keyframe
              var keyframe = keyframes[0];
              this._setAnimatedProperty(seqProp.getName(), node, keyframe.getValue(), tweenDuration);
          }
      },
  
      _getEaseAction:function (action, easingType, easingOpt) {
          if (easingType === CCB_KEYFRAME_EASING_LINEAR || easingType === CCB_KEYFRAME_EASING_INSTANT ) {
              return action;
          } else if (easingType === CCB_KEYFRAME_EASING_CUBIC_IN) {
              return action.easing(cc.easeIn(easingOpt));
          } else if (easingType === CCB_KEYFRAME_EASING_CUBIC_OUT) {
              return action.easing(cc.easeOut(easingOpt));
          } else if (easingType === CCB_KEYFRAME_EASING_CUBIC_INOUT) {
              return action.easing(cc.easeInOut(easingOpt));
          } else if (easingType === CCB_KEYFRAME_EASING_BACK_IN) {
              return action.easing(cc.easeBackIn());
          } else if (easingType === CCB_KEYFRAME_EASING_BACK_OUT) {
              return action.easing(cc.easeBackOut());
          } else if (easingType === CCB_KEYFRAME_EASING_BACK_INOUT) {
              return action.easing(cc.easeBackInOut());
          } else if (easingType === CCB_KEYFRAME_EASING_BOUNCE_IN) {
              return action.easing(cc.easeBounceIn());
          } else if (easingType === CCB_KEYFRAME_EASING_BOUNCE_OUT) {
              return action.easing(cc.easeBounceOut());
          } else if (easingType === CCB_KEYFRAME_EASING_BOUNCE_INOUT) {
              return action.easing(cc.easeBounceInOut());
          } else if (easingType === CCB_KEYFRAME_EASING_ELASTIC_IN) {
              return action.easing(cc.easeElasticIn(easingOpt));
          } else if (easingType === CCB_KEYFRAME_EASING_ELASTIC_OUT) {
              return action.easing(cc.easeElasticOut(easingOpt));
          } else if (easingType === CCB_KEYFRAME_EASING_ELASTIC_INOUT) {
              return action.easing(cc.easeElasticInOut(easingOpt));
          } else {
              cc.log("BuilderReader: Unkown easing type " + easingType);
              return action;
          }
      },
  
      _runAction:function (node, seqProp, tweenDuration) {
          var keyframes = seqProp.getKeyframes();
          var numKeyframes = keyframes.length;
  
          if (numKeyframes > 1) {
              // Make an animation!
              var actions = [];
  
              var keyframeFirst = keyframes[0];
              var timeFirst = keyframeFirst.getTime() + tweenDuration;
  
              if (timeFirst > 0) {
                  actions.push(cc.delayTime(timeFirst));
              }
  
              for (var i = 0; i < numKeyframes - 1; ++i) {
                  var kf0 = keyframes[i];
                  var kf1 = keyframes[(i+1)];
  
                  var action = this._getAction(kf0, kf1, seqProp.getName(), node);
                  if (action) {
                      // Apply easing
                      action = this._getEaseAction(action, kf0.getEasingType(), kf0.getEasingOpt());
                      actions.push(action);
                  }
              }
  
              node.runAction(cc.sequence(actions));
          }
      },
  
      _sequenceCompleted:function () {
          var locRunningSequence = this._runningSequence;
  
          var locRunningName = locRunningSequence.getName();
  
          if(this._lastCompletedSequenceName != locRunningSequence.getName()){
              this._lastCompletedSequenceName = locRunningSequence.getName();
          }
  
          var nextSeqId = locRunningSequence.getChainedSequenceId();
          this._runningSequence = null;
  
          if (nextSeqId !== -1)
              this.runAnimations(nextSeqId, 0);
  
          if (this._delegate)
              this._delegate.completedAnimationSequenceNamed(locRunningName);
  
          if(this._target && this._animationCompleteCallbackFunc){
              this._animationCompleteCallbackFunc.call(this._target);
          }
      }
  });
  
  
  cc.BuilderSetSpriteFrame = cc.ActionInstant.extend({
      _spriteFrame:null,
  
      initWithSpriteFrame:function (spriteFrame) {
          this._spriteFrame = spriteFrame;
          return true;
      },
      update:function (time) {
          this.target.setSpriteFrame(this._spriteFrame);
      }
  });
  
  cc.BuilderSetSpriteFrame.create = function (spriteFrame) {
      var ret = new cc.BuilderSetSpriteFrame();
      if (ret) {
          if (ret.initWithSpriteFrame(spriteFrame))
              return ret;
      }
      return null;
  };
  
  //
  // cc.BuilderRotateTo
  //
  cc.BuilderRotateTo = cc.ActionInterval.extend({
      _startAngle:0,
      _dstAngle:0,
      _diffAngle:0,
  
      initWithDuration:function (duration, angle) {
          if (cc.ActionInterval.prototype.initWithDuration.call(this, duration)) {
              this._dstAngle = angle;
              return true;
          } else {
              return false;
          }
      },
      update:function (time) {
          this.target.setRotation(this._startAngle + (this._diffAngle * time));
      },
  
      startWithTarget:function (node) {
          cc.ActionInterval.prototype.startWithTarget.call(this, node);
          this._startAngle = this.target.getRotation();
          this._diffAngle = this._dstAngle - this._startAngle;
      }
  });
  
  cc.BuilderRotateTo.create = function (duration, angle) {
      var ret = new cc.BuilderRotateTo();
      if (ret) {
          if (ret.initWithDuration(duration, angle))
              return ret;
      }
      return null;
  };
  
  //
  // cc.BuilderRotateXTo
  //
  cc.BuilderRotateXTo = cc.ActionInterval.extend({
      // TODO: rotationX is not implemented in HTML5
  });
  
  cc.BuilderRotateXTo.create = function (duration, angle) {
      throw new Error("rotationX has not been implemented in cocos2d-html5");
  };
  
  //
  // cc.BuilderRotateYTo
  //
  cc.BuilderRotateYTo = cc.ActionInterval.extend({
      // TODO: rotationX is not implemented in HTML5
  });
  
  cc.BuilderRotateYTo.create = function (duration, angle) {
      throw new Error("rotationY has not been implemented in cocos2d-html5");
  };
  
  //
  // cc.BuilderSoundEffect
  //
  cc.BuilderSoundEffect = cc.ActionInstant.extend({
      init:function(file) {
          this._file = file;
          return true;
      },
      update:function(dt) {
          cc.audioEngine.playEffect(this._file);
      }
  });
  cc.BuilderSoundEffect.create = function (file, pitch, pan, gain) {
      var ret = new cc.BuilderSoundEffect();
      if (ret && ret.init(file)) {
              return ret;
      }
      return null;
  };
  
  