功能介绍：
1.整合Append与Insert接口，支持串行与并行动画
2.支持随物体/界面等销毁而自动关闭动画
3.易读性高，action的写法很直观看出具体操作内容
PS：该文章部分源码依据于此在lua里实现类似unity生命周期的监听事件_Le_Sam的博客-CSDN博客
源码：
c#
namespace Game.Scripts.Common
{
[XLua.LuaCallCSharp]
public class DoTweenEx
{
private Tweener tweener;
private Sequence sequence;
private Tween current;
public static DoTweenEx Sequence()
{
return new DoTweenEx(DOTween.Sequence());
}
private DoTweenEx(Sequence sequence)
{
this.sequence = sequence;
current = sequence;
this.Ease(1); //默认EaseType为DoTweenAction.Linear
}
private DoTweenEx(Transform target, Tweener tweener)
{
this.tweener = tweener;
current = tweener;
this.Ease(1); //默认EaseType为DoTweenAction.Linear
}
public DoTweenEx Append(DoTweenEx tweener)
{
sequence.Append(tweener.current);
return this;
}
public DoTweenEx Insert(DoTweenEx tweener)
{
sequence.Insert(0, tweener.current);
return this;
}
public DoTweenEx Play()
{
current.Play();
return this;
}
public DoTweenEx Pause()
{
current.Pause();
return this;
}
public DoTweenEx Kill(bool complete)
{
current.Kill(complete);
return this;
}
public DoTweenEx Ease(uint ease)
{
current.SetEase((Ease)ease);
return this;
}
public DoTweenEx Loop(int loops, uint type)
{
loops = loops == -1 ? 99999 : loops; // Temp:循环为-1时，并没有生效，强制改为固定值
if (sequence != null)
sequence.SetLoops(loops);
if (tweener != null)
tweener.SetLoops(loops, (LoopType)type);
return this;
}
public DoTweenEx Delay(float delay)
{
current.SetDelay(delay);
return this;
}
public DoTweenEx Restart()
{
current.Restart();
return this;
}
public DoTweenEx OnComplete(LuaFunction func)
{
current.OnComplete(delegate() { func.Call(this); });
return this;
}
public DoTweenEx SetUpdate(uint type, bool isAlone)
{
current.SetUpdate((UpdateType)type, isAlone);
return this;
}
public DoTweenEx SetPlaySpeed(float speed)
{
current.timeScale = speed;
return this;
}
public static DoTweenEx NoneTo(Transform target, float duration)
{
return new DoTweenEx(target, DOTween.To(() => 0, v => v = 0, 0, duration + 0.001f));
}
public static DoTweenEx LocalMoveTo(Transform target, Vector3 pos, float duration)
{
return new DoTweenEx(target, target.DOLocalMove(pos, duration + 0.001f));
}
public static DoTweenEx LocalMoveBy(Transform target, Vector3 pos, float duration)
{
return new DoTweenEx(target, target.DOBlendableLocalMoveBy(pos, duration + 0.001f));
}
public static DoTweenEx MoveTo(Transform target, Vector3 pos, float duration)
{
return new DoTweenEx(target, target.DOMove(pos, duration + 0.001f));
}
public static DoTweenEx MoveBy(Transform target, Vector3 pos, float duration)
{
return new DoTweenEx(target, target.DOBlendableMoveBy(pos, duration + 0.001f));
}
public static DoTweenEx RotateTo(Transform target, Vector3 angle, float duration)
{
return new DoTweenEx(target, target.DORotate(angle, duration + 0.001f, RotateMode.FastBeyond360));
}
public static DoTweenEx RotateBy(Transform target, Vector3 angle, float duration)
{
return new DoTweenEx(target, target.DOBlendableRotateBy(angle, duration + 0.001f, RotateMode.FastBeyond360));
}
public static DoTweenEx LocalRotateTo(Transform target, Quaternion angle, float duration)
{
return new DoTweenEx(target, target.DOLocalRotateQuaternion(angle, duration + 0.001f));
}
public static DoTweenEx LocalRotateBy(Transform target, Vector3 angle, float duration)
{
return new DoTweenEx(target, target.DOBlendableLocalRotateBy(angle, duration + 0.001f, RotateMode.FastBeyond360));
}
public static DoTweenEx ScaleTo(Transform target, Vector3 scale, float duration)
{
return new DoTweenEx(target, target.DOScale(scale, duration + 0.001f));
}
public static DoTweenEx ScaleBy(Transform target, Vector3 scale, float duration)
{
return new DoTweenEx(target, target.DOBlendableScaleBy(scale, duration + 0.001f));
}
public static DoTweenEx To(Transform target, int startValue, int endValue, float duration, LuaFunction setter)
{
int currValue = startValue;
return new DoTweenEx(target, DOTween.To(() => startValue, delegate(int v)
{
if (currValue != v)
{
currValue = v;
setter.Call(v);
}
}, endValue, duration + 0.001f));
}
public static DoTweenEx FadeTo(Transform target, float alpha, float duration)
{
var graphic = target.GetComponent<Graphic>();
if (graphic != null)
{
alpha = alpha > 1 ? 1 : alpha;
return new DoTweenEx(target, graphic.DOFade(alpha, duration + 0.001f));
}
return NoneTo(target, duration);
}
public static DoTweenEx FadeToAll(Transform target, float alpha, float duration, bool ignoreTS)
{
alpha = alpha > 1 ? 1 : alpha;
var tween = FadeTo(target, alpha, duration);
tween.current.OnStart(delegate () {
Graphic[] graphics = target.GetComponentsInChildren<Graphic>();
foreach (var g in graphics)
{
g.CrossFadeAlpha(alpha, duration, ignoreTS);
}
});
return tween;
}
public static DoTweenEx ColorTo(Transform target, Color color, float duration)
{
var graphic = target.GetComponent<Graphic>();
if (graphic != null)
{
return new DoTweenEx(target, graphic.DOColor(color, duration + 0.001f));
}
return NoneTo(target, duration);
}
public static DoTweenEx ColorToAll(Transform target, Color color, float duration, bool ignoreTS)
{
var tween = ColorTo(target, color, duration);
tween.current.OnStart(delegate()
{
Graphic[] graphics = target.GetComponentsInChildren<Graphic>();
foreach (var g in graphics)
{
g.CrossFadeColor(color, duration, ignoreTS, true);
}
});
return tween;
}
public static DoTweenEx ShakeRotation(Transform target, float duration, Vector3 strength, int vibrato, float randomness)
{
return new DoTweenEx(target, target.DOShakeRotation(duration, strength, vibrato, randomness));
}
}
}Lua
local DoTweenAction = {}
local DoTweenEx = CS.Game.Scripts.Common.DoTweenEx
DoTweenAction.Linear = 1--默认EaseType
DoTweenAction.InSine = 2
DoTweenAction.OutSine = 3
DoTweenAction.InOutSine = 4
DoTweenAction.InQuad = 5
DoTweenAction.OutQuad = 6
DoTweenAction.InOutQuad = 7
DoTweenAction.InCubic = 8
DoTweenAction.OutCubic = 9
DoTweenAction.InOutCubic = 10
DoTweenAction.InQuart = 11
DoTweenAction.OutQuart = 12
DoTweenAction.InOutQuart = 13
DoTweenAction.InQuint = 14
DoTweenAction.OutQuint = 15
DoTweenAction.InOutQuint = 16
DoTweenAction.InExpo = 17
DoTweenAction.OutExpo = 18
DoTweenAction.InOutExpo = 19
DoTweenAction.InCirc = 20
DoTweenAction.OutCirc = 21
DoTweenAction.InOutCirc = 22
DoTweenAction.InElastic = 23
DoTweenAction.OutElastic = 24
DoTweenAction.InOutElastic = 25
DoTweenAction.InBack = 26
DoTweenAction.OutBack = 27
DoTweenAction.InOutBack = 28
DoTweenAction.InBounce = 29
DoTweenAction.OutBounce = 30
DoTweenAction.InOutBounce = 31
DoTweenAction.Flash = 32
DoTweenAction.InFlash = 33
DoTweenAction.OutFlash = 34
DoTweenAction.InOutFlash = 35
DoTweenAction.LTRestart = 0 -- 默认LoopType
DoTweenAction.LTYoyo = 1
DoTweenAction.LTIncremental = 2
DoTweenAction.UpdateNormal = 0 -- 默认UpdateType
DoTweenAction.UpdateLate = 1
DoTweenAction.UpdateFixed = 2
DoTweenAction.UpdateManual = 3
local Param = {
ease = function(tween, aEaseType)
return tween:Ease(aEaseType)
end,
loop = function(tween, aTimes, aLoopType)
return tween:Loop(aTimes, aLoopType or DoTweenAction.LTRestart)
end,
delay = function(tween, aSecend)
return tween:Delay(aSecend)
end,
-- DoTween终止回调
OnEnd = function(tween, ...)
return DoTweenAction.SetOnComplete(tween, ...)
end,
}
local Function = {
-- 并行
spawn = function(target, ...)
return DoTweenAction.SequenceAction(target, {...}, "Insert")
end,
delay = function(target, delay, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.NoneTo(target, delay), ...)
end,
call = function(target, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.NoneTo(target), ...)
end,
to = function(target, startValue, endValue, duration, setter, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.To(target, startValue, endValue, duration, setter), ...)
end,
localMoveBy = function(target, vec, duration, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.LocalMoveBy(target, vec, duration), ...)
end,
localMoveTo = function(target, vec, duration, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.LocalMoveTo(target, vec, duration), ...)
end,
moveBy = function(target, vec, duration, camera, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.MoveBy(target, vec, duration, camera), ...)
end,
moveTo = function(target, vec, duration, camera, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.MoveTo(target, vec, duration, camera), ...)
end,
rotateBy = function(target, vec, duration, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.RotateBy(target, vec, duration), ...)
end,
rotateTo = function(target, vec, duration, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.RotateTo(target, vec, duration), ...)
end,
localRotateBy = function(target, vec, duration, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.LocalRotateBy(target, vec, duration), ...)
end,
localRotateTo = function(target, vec, duration, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.LocalRotateTo(target, vec, duration), ...)
end,
scaleBy = function(target, vec, duration, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.ScaleBy(target, vec, duration), ...)
end,
scaleTo = function(target, vec, duration, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.ScaleTo(target, vec, duration), ...)
end,
fadeTo = function(target, opacity, duration, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.FadeTo(target, opacity, duration), ...)
end,
fadeToAll = function(target, opacity, duration, ignoreTS, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.FadeToAll(target, opacity, duration, ignoreTS or true), ...)
end,
colorTo = function(target, color, duration, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.ColorTo(target, color, duration), ...)
end,
colorToAll = function(target, color, duration, ignoreTS, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.ColorToAll(target, color, duration, ignoreTS or true), ...)
end,
shakeRotation = function(target, duration, vec, vibrato, randomness, ...)
return DoTweenAction.SetOnComplete(DoTweenEx.ShakeRotation(target, duration, vec, vibrato or 10, randomness or 90), ...)
end,
}
function DoTweenAction.SetCallBack(tween, callback, aFunc, ...)
if aFunc and type(aFunc) == "function" then
local args = {...}
return tween[callback](tween, #args == 0 and aFunc or function()
aFunc(table.unpack(args))
end)
end
return tween
end
function DoTweenAction.SetOnComplete(tween, aFunc, ...)
return DoTweenAction.SetCallBack(tween, 'OnComplete', aFunc, ...)
end
function DoTweenAction.SetParam(tween, action, funcName)
if tween then
for name, param in pairs(action) do
if type(name) == "string" then
assert(Param[name] ~= nil, "DoTweenAction SetParam not find : ".. name);
if type(param) == "table" then
Param[name](tween, table.unpack(param))
else
Param[name](tween, param)
end
end
end
else
logerror("DoTweenAction SetParam not find : ".. funcName)
end
return tween
end
function DoTweenAction.SequenceAction(target, action, opt)
local sequence = DoTweenEx.Sequence()
for _, act in ipairs(action) do
if type(act) == "table" then
if opt == "Append" then
sequence:Append(DoTweenAction.RunAction(target, act))
elseif opt == "Insert" then
sequence:Insert(DoTweenAction.RunAction(target, act))
end
end
end
return DoTweenAction.SetParam(sequence, action)
end
function DoTweenAction.RunAction(target, action)
return DoTweenAction.CreateAction(target.transform or target, action, table.unpack(action))
end
function DoTweenAction.CreateAction(target, action, funcName, ...)
-- 代表一个动作
if type(funcName) == "string" then
assert(Function[funcName] ~= nil, "DoTweenAction CreateAction not find : ".. funcName);
local tween = Function[funcName](target, ...)
tween = DoTweenAction.SetParam(tween, action, funcName)
return tween
-- Action是一个动作数组，需要拆分其动作并组合成数组动作
elseif type(funcName) == "table" then
return DoTweenAction.SequenceAction(target, action, "Append")
-- 表示这个动作只是执行这个function
elseif type(funcName) == "function" then
return Function.call(target, funcName, ...)
end
end
return DoTweenAction
local DoTweenAction = require("DoTweenAction")
local ActionTool = {}
local actionMap = {};
local actionKey = 0;
-- 运行动作
function ActionTool.RunAction(target, action, ignoreTS)
actionKey = actionKey + 1
local curKey = actionKey
local function onDestory()
ActionTool.StopAction(curKey)
end
local function onComplete()
actionMap[curKey] = nil
end
Helpers.AddDestroyListener(target.transform or target, onDestory)
actionMap[curKey] = DoTweenAction.RunAction(target, {
action,
OnEnd = onComplete,
})
ActionTool.ChangeUpdateAction(curKey, DoTweenAction.UpdateNormal, ignoreTS or true) -- 默认忽略Time.timeScale
return curKey
end
-- 停止动作
function ActionTool.StopAction(actionKey, complete)
local action = actionMap[actionKey];
if action then
action:Kill(complete or false);
actionMap[actionKey] = nil;
end
end
--暂停动作
function ActionTool.PauseAction(actionKey)
if not actionKey then return end
if not actionMap[actionKey] then return end
actionMap[actionKey]:Pause()
end
--恢复动作
function ActionTool.ResumeAction(actionKey)
if not actionKey then return end
if not actionMap[actionKey] then return end
actionMap[actionKey]:Play()
end
-- 改变速度
function ActionTool.ChangeSpeedAction(actionKey, speed)
if not actionKey then return end
if not actionMap[actionKey] then return end
actionMap[actionKey]:SetPlaySpeed(speed)
end
-- 改变Update
function ActionTool.ChangeUpdateAction(actionKey, type, isAlone)
if not actionKey then return end
if not actionMap[actionKey] then return end
actionMap[actionKey]:SetUpdate(type, isAlone)
end
-- 停止所有动作
function ActionTool.StopAllAction(complete)
for _,v in pairs(actionMap) do
v:Kill(complete or false);
end
actionKey = 0;
actionMap = {};
end
return ActionTool示例：
-- View
local UITest = ClassView("UITest")
local ActionTool = require("ActionTool")
local DoTweenAction = require("DoTweenAction")
function UITest:OnCreate()
local testTxt = self:FindChild("testUI"):GetComponent("Text")
-- Test1
do
local action = {
{"spawn",
{"localMoveTo", Vector3(-100, 0, 0), 0.25, ease = DoTweenAction.OutQuad},
{"scaleTo", Vector3(1.1, 1.1, 1.1), 0.15, delay = 0.1, ease = DoTweenAction.OutQuad},
},
{"call", function()
logdebug(string.format("Test1 call ==> testTxt:%s", testTxt))
end},
{"delay", 5},
OnEnd = function()
logdebug(string.format("Test1 OnEnd ==> testTxt:%s", testTxt))
end,
};
ActionTool.RunAction(testTxt.transform, action)
end
-- Test2
do
local maxP = 100
local centreP = maxP / 2
local tempColor = Color(1,1,1,1)
local action = {
{"to", 1, maxP, 1, function(value)
local curValue = value >= centreP and value or -value + maxP
tempColor.a = curValue / maxP
testTxt.color = tempColor
end, loop = -1
},
};
ActionTool.RunAction(testTxt.transform, action)
end
