422 lines
8.5 KiB
JavaScript
422 lines
8.5 KiB
JavaScript
|
|
/*******************************************************************************
|
|
*
|
|
* Nx 动作Tween
|
|
*
|
|
*
|
|
*
|
|
* 2021.12.10
|
|
******************************************************************************/
|
|
|
|
const NxObject = require( "nx.object" );
|
|
|
|
var nxTween = cc.Class( {
|
|
|
|
extends: NxObject,
|
|
|
|
name: "nxTween",
|
|
|
|
// 初始化
|
|
initialize: function( _args ) {
|
|
|
|
// USPER
|
|
if( !this._super( _args ) ) {
|
|
return false;
|
|
}
|
|
|
|
// 全局服务开启
|
|
nx.tween = this;
|
|
|
|
return true;
|
|
},
|
|
|
|
// 销毁
|
|
uninitialize: function() {
|
|
|
|
// 全局服务关闭
|
|
nx.tween = null;
|
|
|
|
// USPER
|
|
return this._super();
|
|
},
|
|
|
|
// 淡进
|
|
fadeIn: function( _refnode, _names, _secs, _cb, _to, _from ) {
|
|
|
|
// 找不到节点
|
|
let node = nx.gui.find( _refnode, _names );
|
|
if( !node ) {
|
|
nx.dt.fnInvoke( _cb );
|
|
return;
|
|
}
|
|
|
|
// 参数补全
|
|
let cb = _cb || nx.dt.fnEmpty;
|
|
let opTo = nx.dt.numFix( _to, 255 );
|
|
let 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( _refnode, _names, _secs, _cb, _to, _from ) {
|
|
|
|
// 找不到节点
|
|
let node = nx.gui.find( _refnode, _names );
|
|
if( !node ) {
|
|
nx.dt.fnInvoke( _cb );
|
|
return;
|
|
}
|
|
|
|
// 参数补全
|
|
let cb = _cb || nx.dt.fnEmpty;
|
|
let opTo = nx.dt.numFix( _to, 0 );
|
|
let 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( _start, _end, _height, _t ) {
|
|
|
|
let t1 = ( 1 - _t ) * ( 1 - _t );
|
|
let t2 = 2 * _t * ( 1 - _t );
|
|
let t3 = _t * _t
|
|
let 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( _refnode, _names, _secs, _delay, _cb, _to, _from, _scale = 1, _opacity = 255, _h = 200 ) {
|
|
|
|
// 找不到节点
|
|
let node = nx.gui.find( _refnode, _names );
|
|
if( !node ) {
|
|
nx.dt.fnInvoke( _cb );
|
|
return;
|
|
}
|
|
|
|
// 初始
|
|
let rop = node.opacity;
|
|
let 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;
|
|
}
|
|
|
|
// 行动
|
|
let 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: ( _s, _e, _c, _t ) => {
|
|
return self.bezier( _s, _e, _h, _t );
|
|
}
|
|
}
|
|
} )
|
|
.call( () => {
|
|
nx.dt.fnInvoke( _cb, node );
|
|
} )
|
|
.start()
|
|
|
|
},
|
|
|
|
/**
|
|
* 无限旋转
|
|
* @param {*} _refnode
|
|
* @param {*} _names
|
|
* @param {*} _speed
|
|
*/
|
|
rotateForever: function( _refnode, _names, _speed ) {
|
|
|
|
// 找不到节点
|
|
let 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( _refnode, _names, _speed, _scale = 0.1 ) {
|
|
|
|
// 找不到节点
|
|
let 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;
|
|
let smaller = node.scale - _scale;
|
|
let 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( _refnode, _names, _secs, _pos, _cb ) {
|
|
|
|
// 找不到节点
|
|
let 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( () => {
|
|
nx.dt.fnInvoke( _cb, node );
|
|
} )
|
|
.start();
|
|
|
|
},
|
|
|
|
/**
|
|
* 缓移动
|
|
* @param {*} _refnode
|
|
* @param {*} _names
|
|
* @param {*} _secs
|
|
* @param {*} _pos
|
|
*/
|
|
moveToEasing: function( _refnode, _names, _secs, _pos, _key, _cb ) {
|
|
|
|
// 找不到节点
|
|
let 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( () => {
|
|
nx.dt.fnInvoke( _cb, node );
|
|
} )
|
|
.start();
|
|
|
|
},
|
|
|
|
/**
|
|
* 缩放
|
|
* @param {*} _refnode
|
|
* @param {*} _names
|
|
* @param {*} _secs
|
|
* @param {*} _pos
|
|
*/
|
|
scaleTo: function( _refnode, _names, _secs, _x, _y, _cb ) {
|
|
|
|
// 找不到节点
|
|
let 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( () => {
|
|
nx.dt.fnInvoke( _cb, node );
|
|
} )
|
|
.start();
|
|
|
|
},
|
|
|
|
// 淡进
|
|
delayFadeIn: function( _refnode, _names, _delay, _secs, _cb, _to, _from ) {
|
|
|
|
// 找不到节点
|
|
let node = nx.gui.find( _refnode, _names );
|
|
if( !node ) {
|
|
nx.dt.fnInvoke( _cb );
|
|
return;
|
|
}
|
|
|
|
// 参数补全
|
|
let cb = _cb || nx.dt.fnEmpty;
|
|
let opTo = nx.dt.numFix( _to, 255 );
|
|
let 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( _refnode, _names, _secs, _offset, _cb ) {
|
|
|
|
// 找不到节点
|
|
let 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;
|
|
}
|
|
|
|
let raw = node.position;
|
|
let ofx = _offset ? _offset.x : 10;
|
|
let ofy = _offset ? _offset.y : 10;
|
|
let secs = _secs || 1;
|
|
let times = Math.ceil( secs / 0.2 );
|
|
let rand = function( _x ) {
|
|
let ofs = _x ? ofx : ofy;
|
|
let 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( () => {
|
|
nx.dt.fnInvoke( _cb, node );
|
|
} )
|
|
.start();
|
|
|
|
},
|
|
|
|
} );
|
|
|
|
// 模块导出
|
|
module.exports = nxTween; |