"use strict";
cc._RF.push(module, '581d4g4UqNNJ6dZi3gVqXrP', 'nx.tween');
// Scripts/nx/kernel/nx.tween.js

"use strict";

/*******************************************************************************
 * 
 * Nx 动作Tween
 * 
 *      
 * 
 *          2021.12.10
 ******************************************************************************/

var NxObject = require("nx.object");
var nxTween = cc.Class({
  "extends": NxObject,
  name: "nxTween",
  // 初始化
  initialize: function initialize(_args) {
    // USPER
    if (!this._super(_args)) {
      return false;
    }

    // 全局服务开启
    nx.tween = this;
    return true;
  },
  // 销毁
  uninitialize: function uninitialize() {
    // 全局服务关闭
    nx.tween = null;

    // USPER
    return this._super();
  },
  // 淡进
  fadeIn: function fadeIn(_refnode, _names, _secs, _cb, _to, _from) {
    // 找不到节点
    var node = nx.gui.find(_refnode, _names);
    if (!node) {
      nx.dt.fnInvoke(_cb);
      return;
    }

    // 参数补全
    var cb = _cb || nx.dt.fnEmpty;
    var opTo = nx.dt.numFix(_to, 255);
    var opFrom = nx.dt.numFix(_from, 0);

    // 销毁
    if (node.__tween_fade) {
      node.__tween_fade.stop();
      delete node.__tween_fade;
      node.__tween_fade = null;
    }

    // 执行
    node.active = true;
    node.opacity = opFrom;
    node.__tween_fade = cc.tween(node).to(_secs, {
      opacity: opTo
    }).call(cb).start();
  },
  // 淡出
  fadeOut: function fadeOut(_refnode, _names, _secs, _cb, _to, _from) {
    // 找不到节点
    var node = nx.gui.find(_refnode, _names);
    if (!node) {
      nx.dt.fnInvoke(_cb);
      return;
    }

    // 参数补全
    var cb = _cb || nx.dt.fnEmpty;
    var opTo = nx.dt.numFix(_to, 0);
    var opFrom = nx.dt.numFix(_from, node.opacity);

    // 销毁
    if (node.__tween_fade) {
      node.__tween_fade.stop();
      delete node.__tween_fade;
      node.__tween_fade = null;
    }

    // 执行
    node.active = true;
    node.opacity = opFrom;
    node.__tween_fade = cc.tween(node).to(_secs, {
      opacity: opTo
    }).call(cb).start();
  },
  // 贝塞尔计算
  bezier: function bezier(_start, _end, _height, _t) {
    var t1 = (1 - _t) * (1 - _t);
    var t2 = 2 * _t * (1 - _t);
    var t3 = _t * _t;
    var p1 = cc.v2(_start.x + (_end.x - _start.x) / 2, _start.x + _height);
    return _start.mul(t1).add(p1.mul(t2)).add(_end.mul(t3));
  },
  /**
   * 贝塞尔位移淡出
   * @param {*} _secs		移动耗时
   * @param {*} _delay	移动延迟
   * @param {*} _to 		目标点
   * @param {*} _from 	起始点
   * @param {*} _scale 	目标缩放
   * @param {*} _opacity 	目标透明度
   * @param {*} _h 		贝塞尔幅度
   * @returns 
   */
  fadeOutBezier: function fadeOutBezier(_refnode, _names, _secs, _delay, _cb, _to, _from, _scale, _opacity, _h) {
    if (_scale === void 0) {
      _scale = 1;
    }
    if (_opacity === void 0) {
      _opacity = 255;
    }
    if (_h === void 0) {
      _h = 200;
    }
    // 找不到节点
    var node = nx.gui.find(_refnode, _names);
    if (!node) {
      nx.dt.fnInvoke(_cb);
      return;
    }

    // 初始
    var rop = node.opacity;
    var rsc = node.scale;
    node.opacity = 0;
    node.position = _from;

    // 销毁
    if (node.__tween_fadeOutBezier) {
      node.__tween_fadeOutBezier.stop();
      delete node.__tween_fadeOutBezier;
      node.__tween_fadeOutBezier = null;
    }

    // 行动
    var self = this;
    cc.Tween.stopAllByTarget(node);
    node.__tween_fadeOutBezier = cc.tween(node).delay(_delay).to(_secs * 0.1, {
      scale: rsc * 1.1,
      opacity: rop
    }).to(_secs * 0.1, {
      scale: rsc
    }).delay(_secs * 0.3).to(_secs * 0.5, {
      scale: rsc * _scale,
      opacity: _opacity,
      position: {
        value: _to,
        progress: function progress(_s, _e, _c, _t) {
          return self.bezier(_s, _e, _h, _t);
        }
      }
    }).call(function () {
      nx.dt.fnInvoke(_cb, node);
    }).start();
  },
  /**
   * 无限旋转
   * @param {*} _refnode 
   * @param {*} _names 
   * @param {*} _speed 
   */
  rotateForever: function rotateForever(_refnode, _names, _speed) {
    // 找不到节点
    var node = nx.gui.find(_refnode, _names);
    if (!node) {
      return;
    }

    // 销毁
    if (node.__tween_rotateForever) {
      node.__tween_rotateForever.stop();
      delete node.__tween_rotateForever;
      node.__tween_rotateForever = null;
    }
    node.__tween_rotateForever = cc.tween(node).repeatForever(cc.tween().by(_speed, {
      angle: 360
    })).start();
  },
  /**
   * 无限呼吸
   * @param {*} _refnode 
   * @param {*} _names 
   * @param {*} _speed 
   * @param {*} _scale 呼吸幅度 
   */
  breatheForever: function breatheForever(_refnode, _names, _speed, _scale) {
    if (_scale === void 0) {
      _scale = 0.1;
    }
    // 找不到节点
    var node = nx.gui.find(_refnode, _names);
    if (!node) {
      return;
    }

    // 销毁
    if (node.__tween_breatheForever) {
      node.__tween_breatheForever.stop();
      delete node.__tween_breatheForever;
      node.__tween_breatheForever = null;
      node.scale = node.breathScale || 1;
    }
    node.breathScale = node.scale;
    var smaller = node.scale - _scale;
    var bigger = node.scale + _scale;
    node.__tween_breatheForever = cc.tween(node).repeatForever(cc.tween().to(_speed / 4, {
      scale: bigger
    }).to(_speed / 2, {
      scale: smaller
    }).delay(_speed / 4)).start();
  },
  /**
   * 移动
   * @param {*} _refnode 
   * @param {*} _names 
   * @param {*} _secs 
   * @param {*} _pos 
   */
  moveTo: function moveTo(_refnode, _names, _secs, _pos, _cb) {
    // 找不到节点
    var node = nx.gui.find(_refnode, _names);
    if (!node) {
      return;
    }

    // 销毁
    if (node.__tween_moveTo) {
      node.__tween_moveTo.stop();
      delete node.__tween_moveTo;
      node.__tween_moveTo = null;
    }
    node.__tween_moveTo = cc.tween(node).to(_secs, {
      position: _pos
    }).call(function () {
      nx.dt.fnInvoke(_cb, node);
    }).start();
  },
  /**
   * 缓移动
   * @param {*} _refnode 
   * @param {*} _names 
   * @param {*} _secs 
   * @param {*} _pos 
   */
  moveToEasing: function moveToEasing(_refnode, _names, _secs, _pos, _key, _cb) {
    // 找不到节点
    var node = nx.gui.find(_refnode, _names);
    if (!node) {
      return;
    }

    // 销毁
    if (node.__tween_moveTo) {
      node.__tween_moveTo.stop();
      delete node.__tween_moveTo;
      node.__tween_moveTo = null;
    }
    node.__tween_moveTo = cc.tween(node).to(_secs, {
      position: {
        value: _pos,
        easing: _key
      }
    }).call(function () {
      nx.dt.fnInvoke(_cb, node);
    }).start();
  },
  /**
   * 缩放
   * @param {*} _refnode 
   * @param {*} _names 
   * @param {*} _secs 
   * @param {*} _pos 
   */
  scaleTo: function scaleTo(_refnode, _names, _secs, _x, _y, _cb) {
    // 找不到节点
    var node = nx.gui.find(_refnode, _names);
    if (!node) {
      return;
    }

    // 销毁
    if (node.__tween_scaleTo) {
      node.__tween_scaleTo.stop();
      delete node.__tween_scaleTo;
      node.__tween_scaleTo = null;
    }
    node.__tween_scaleTo = cc.tween(node).to(_secs, {
      scaleX: _x,
      scaleY: _y
    }).call(function () {
      nx.dt.fnInvoke(_cb, node);
    }).start();
  },
  // 淡进
  delayFadeIn: function delayFadeIn(_refnode, _names, _delay, _secs, _cb, _to, _from) {
    // 找不到节点
    var node = nx.gui.find(_refnode, _names);
    if (!node) {
      nx.dt.fnInvoke(_cb);
      return;
    }

    // 参数补全
    var cb = _cb || nx.dt.fnEmpty;
    var opTo = nx.dt.numFix(_to, 255);
    var opFrom = nx.dt.numFix(_from, 0);

    // 销毁
    if (node.__tween_fade) {
      node.__tween_fade.stop();
      delete node.__tween_fade;
      node.__tween_fade = null;
    }

    // 执行
    node.active = true;
    node.opacity = opFrom;
    node.__tween_fade = cc.tween(node).delay(_delay).to(_secs, {
      opacity: opTo
    }).call(cb).start();
  },
  /**
   * 抖动
   * @param {*} _refnode 
   * @param {*} _names 
   * @param {*} _secs 
   * @param {*} _offset 
   */
  shake: function shake(_refnode, _names, _secs, _offset, _cb) {
    // 找不到节点
    var node = nx.gui.find(_refnode, _names);
    if (!node) {
      return;
    }

    // 销毁
    if (node.__tween_shake) {
      node.__tween_shake.stop();
      delete node.__tween_shake;
      node.__tween_shake = null;
    }
    var raw = node.position;
    var ofx = _offset ? _offset.x : 10;
    var ofy = _offset ? _offset.y : 10;
    var secs = _secs || 1;
    var times = Math.ceil(secs / 0.2);
    var rand = function rand(_x) {
      var ofs = _x ? ofx : ofy;
      var ret = nx.dt.randomRange(-ofs, ofs);
      if (Math.abs(ret) < ofs / 2) {
        ret *= 2;
      }
      return _x ? raw.x + ret * 2 : raw.y + ret * 2;
    };
    node.__tween_shake = cc.tween(node).repeat(times, cc.tween().to(0.03, {
      x: rand(true),
      y: rand(false)
    }).to(0.03, {
      x: rand(true),
      y: rand(false)
    }).to(0.03, {
      x: rand(true),
      y: rand(false)
    }).to(0.03, {
      x: rand(true),
      y: rand(false)
    }).to(0.03, {
      x: rand(true),
      y: rand(false)
    }).to(0.03, {
      x: rand(true),
      y: rand(false)
    })).to(0.03, {
      position: raw
    }).call(function () {
      nx.dt.fnInvoke(_cb, node);
    }).start();
  }
});

// 模块导出
module.exports = nxTween;

cc._RF.pop();