企业官网建设流程全解析

1. 被大多数人忽略的DOTween回调层

DOTween在Unity项目里几乎是标配，随便找个商业项目，十有八九能看到它。但绝大多数人对它的使用停留在transform.DOMove()、DOMove()、DOFade()这类基础API上，回调部分翻来覆去就是OnComplete()和OnStart()。我见过不少项目，动画逻辑写得又长又乱，一个简单的"动画播完再执行下一步"要绕好几个状态变量去判断，代码里到处是isAnimating、hasFinished这种标志位。实际上DOTween的回调体系远比表面看到的丰富，用好了能把动画流程的代码量砍掉一半以上，而且逻辑更清晰、更不容易出bug。

这篇内容面向的是已经用过DOTween、但还没系统研究过它回调机制的Unity开发者。我会把DOTween回调函数里那些文档里写得含糊、实际项目中却极其好用的技巧拆开讲清楚，包括回调的触发时机、执行顺序、参数传递、与协程和UniTask的配合方式，以及一些容易踩坑的边界情况。所有内容都基于实际项目经验，不是照搬官方文档。

先说一个基本认知：DOTween的回调不是简单的"开始"和"结束"两个钩子。它有一套完整的生命周期回调，包括OnStart、OnPlay、OnUpdate、OnStepComplete、OnComplete、OnRewind、OnPause、OnKill等。这些回调的触发条件和执行顺序有明确的规则，理解这些规则是优化动画流程的前提。很多人只知道OnComplete，结果遇到"动画被中途杀掉时也要执行清理逻辑"这种需求就不知道怎么处理了。

注意：DOTween的回调默认在主线程执行，且是在DOTween的更新循环中触发的，不是在Unity的Update里。这意味着回调的执行时机和MonoBehaviour的Update有微妙的差异，后面会详细说。

2. 回调触发顺序与执行时机的底层逻辑

2.1 一次完整动画生命周期中回调的触发序列

要搞清楚回调怎么用，先得知道它们什么时候被调用。假设有一个transform.DOMove(target, 1f)的动画，从创建到结束，回调的触发顺序是这样的：

1. 调用DOMove()时，动画被创建，但还没开始播放（除非设置了autoPlay）。
2. 调用Play()或自动播放后，OnPlay触发。
3. 动画第一次更新时，OnStart触发（注意：OnStart只触发一次，在动画真正开始计算的第一帧）。
4. 每一帧更新时，OnUpdate触发。
5. 如果设置了循环（Loops），每次循环结束时OnStepComplete触发。
6. 整个动画（包括所有循环）结束时，OnComplete触发。
7. 如果动画被Rewind()，OnRewind触发。
8. 如果动画被Kill()，OnKill触发。

这里有个容易混淆的点：OnStart和OnPlay的区别。OnPlay在每次调用Play()时都会触发，包括从暂停状态恢复播放。而OnStart只在动画第一次真正开始更新时触发一次。如果你有一个动画被暂停后再播放，OnPlay会再次触发，但OnStart不会。

// 演示OnStart和OnPlay的区别 var tween = transform.DOMove(Vector3.one, 1f) .SetAutoKill(false) .OnStart(() => Debug.Log("OnStart - 只触发一次")) .OnPlay(() => Debug.Log("OnPlay - 每次播放都触发")) .OnComplete(() => Debug.Log("OnComplete")); // 第一次播放 tween.Play(); // 输出: OnPlay -> OnStart -> OnComplete // 暂停后再次播放 tween.Pause(); tween.Play(); // 输出: OnPlay (没有OnStart)

这个区别在实际项目中很重要。比如你想在动画第一次开始时初始化某些数据，应该用OnStart；如果你想在每次恢复播放时都做一些事情（比如恢复音效），应该用OnPlay。

2.2 OnUpdate与OnStepComplete的精确触发条件

OnUpdate是最容易被滥用的回调。它在动画每一帧更新时都会触发，包括循环动画的每一帧。很多人用它来做进度条更新，但没意识到如果动画有循环，OnUpdate会在每次循环中重复触发，导致进度计算错误。

OnStepComplete只在循环动画的每次循环结束时触发。如果你有一个无限循环的动画，OnStepComplete会一直触发，而OnComplete永远不会触发（因为动画不会结束）。这个特性可以用来做"每次循环结束时检查某个条件"的逻辑。

// 循环动画中OnStepComplete的用法 transform.DORotate(new Vector3(0, 360, 0), 1f, RotateMode.FastBeyond360) .SetLoops(-1, LoopType.Restart) .OnStepComplete(() => { // 每次旋转一圈后触发 Debug.Log("完成一圈"); // 可以在这里检查是否需要停止 if (shouldStop) { // 注意：不能直接在这里Kill，否则可能出问题 // 应该用DOTween的延迟调用 DOVirtual.DelayedCall(0, () => tween.Kill()); } });

提示：在OnStepComplete里直接调用Kill()有时会导致不可预期的问题，因为此时DOTween正在处理循环逻辑。安全的做法是用DOVirtual.DelayedCall(0, ...)延迟一帧执行。

2.3 回调执行顺序与Unity Update的关系

DOTween的更新默认是在Unity的Update之后执行的（可以通过DOTween.SetTweensCapacity和DOTween.Init调整更新方式）。这意味着在OnComplete里修改Transform，不会立即反映到这一帧的渲染中，而是下一帧才生效。如果你在OnComplete里做了一些依赖Transform位置的计算，要注意这个时序问题。

更关键的是，如果在OnComplete里启动另一个动画，这个新动画会在下一帧才开始更新。如果你需要两个动画无缝衔接，应该用OnComplete里直接Play()下一个动画，而不是用协程yield return等待。

// 无缝衔接两个动画的正确方式 transform.DOMove(Vector3.one, 1f) .OnComplete(() => { // 直接启动下一个动画，DOTween会处理衔接 transform.DOScale(Vector3.one * 2, 0.5f); }); // 不推荐的方式：用协程等待 IEnumerator Sequence() { yield return transform.DOMove(Vector3.one, 1f).WaitForCompletion(); // 这里会有一帧的延迟 transform.DOScale(Vector3.one * 2, 0.5f); }

3. 回调参数传递与闭包陷阱的实战处理

3.1 利用闭包传递上下文信息的正确姿势

DOTween的回调本身不直接支持参数传递，但通过C#的闭包可以轻松实现。问题在于，很多人在循环中创建动画时，闭包捕获的变量会出现"所有回调都拿到最后一个值"的经典问题。

// 错误示范：所有回调都会打印相同的索引 for (int i = 0; i < 5; i++) { transform.DOMove(targets[i].position, 1f) .OnComplete(() => Debug.Log($"到达目标 {i}")); // i总是5 } // 正确示范：用局部变量捕获当前值 for (int i = 0; i < 5; i++) { int index = i; // 关键：创建局部副本 transform.DOMove(targets[index].position, 1f) .OnComplete(() => Debug.Log($"到达目标 {index}")); }

这个坑在Unity开发中非常常见，尤其是批量创建动画时。C#的闭包捕获的是变量本身，而不是变量的值。在循环中，所有闭包共享同一个循环变量，所以最终都拿到循环结束后的值。

3.2 回调中访问已销毁对象的安全检查

另一个高频问题是：动画还在播放，但目标对象已经被销毁了。DOTween默认会在目标销毁时自动Kill动画，但如果你在OnComplete里访问了其他可能已销毁的对象，就会报MissingReferenceException。

// 不安全的写法 someObject.transform.DOMove(target, 1f) .OnComplete(() => { // 如果otherObject在这1秒内被销毁了，这里会报错 otherObject.DoSomething(); }); // 安全的写法 someObject.transform.DOMove(target, 1f) .OnComplete(() => { if (otherObject != null && otherObject.activeInHierarchy) { otherObject.DoSomething(); } });

注意：Unity的== null重载了，对于已销毁的UnityEngine.Object，== null会返回true。但对于纯C#对象，需要用is not null或额外的标志位来判断。

3.3 用OnUpdate实现自定义插值逻辑

OnUpdate除了做进度更新，还可以用来实现DOTween不直接支持的插值逻辑。比如你想在动画过程中根据当前进度动态调整其他属性，可以在OnUpdate里读取tween.ElapsedPercentage()。

var tween = transform.DOMove(target, 1f) .OnUpdate(() => { float progress = tween.ElapsedPercentage(); // 根据进度动态调整颜色 renderer.material.color = Color.Lerp(Color.white, Color.red, progress); // 根据进度调整音量 audioSource.volume = Mathf.Lerp(1f, 0f, progress); });

这里有个性能注意点：OnUpdate每帧都触发，如果在里面做复杂的计算或频繁的材质修改，会造成性能问题。建议只在必要时使用，并且尽量缓存计算结果。

4. 回调与协程、UniTask的配合策略

4.1 WaitForCompletion与回调的取舍

DOTween提供了WaitForCompletion()方法，可以在协程中等待动画完成。很多人用它来替代OnComplete，但两者有本质区别。

// 方式一：用OnComplete transform.DOMove(target, 1f) .OnComplete(() => { // 动画完成后执行 NextStep(); }); // 方式二：用协程等待 IEnumerator DoAnimation() { yield return transform.DOMove(target, 1f).WaitForCompletion(); NextStep(); }

WaitForCompletion()的本质是创建一个临时的Tween来监听目标动画的完成，它会额外分配内存。在大量动画的场景下，频繁使用WaitForCompletion()会增加GC压力。而OnComplete是直接注册回调，没有额外分配。

但WaitForCompletion()在需要顺序执行多个动画时更直观。我的建议是：简单的顺序逻辑用OnComplete链式调用，复杂的流程控制用协程或UniTask。

4.2 用UniTask替代协程处理动画流程

如果你的项目用了UniTask，可以用AsyncWaitForCompletion()来等待动画，它比协程更轻量，而且支持取消。

using Cysharp.Threading.Tasks; async UniTaskVoid PlayAnimationAsync(CancellationToken token) { await transform.DOMove(target, 1f).AsyncWaitForCompletion().AttachExternalCancellation(token); // 动画完成后继续 await transform.DOScale(Vector3.one * 2, 0.5f).AsyncWaitForCompletion().AttachExternalCancellation(token); }

AttachExternalCancellation让动画可以被取消，这在切换场景或对象池回收时非常有用。如果不用取消，动画可能在对象销毁后还在尝试更新，导致报错。

4.3 回调中启动协程的注意事项

在OnComplete里启动协程是常见需求，但要注意：如果动画所在的GameObject被禁用了，协程无法启动。

transform.DOMove(target, 1f) .OnComplete(() => { // 如果this.gameObject被禁用，StartCoroutine会报错 StartCoroutine(NextStep()); });

安全的做法是用一个独立的MonoBehaviour来管理协程，或者用DOVirtual.DelayedCall替代简单的延迟逻辑。

// 用DOVirtual替代协程做延迟 transform.DOMove(target, 1f) .OnComplete(() => { DOVirtual.DelayedCall(0.5f, () => { // 延迟0.5秒后执行 NextStep(); }); });

5. 回调在复杂动画流程中的组合应用

5.1 用Sequence和回调构建可复用的动画模块

DOTween的Sequence可以把多个动画组合成一个序列，配合回调可以构建高度可复用的动画模块。比如一个"按钮点击反馈"的动画模块：

public class ButtonFeedback : MonoBehaviour { private Sequence sequence; public void PlayClickFeedback() { // 先杀掉之前的动画，避免冲突 sequence?.Kill(); sequence = DOTween.Sequence(); sequence.Append(transform.DOScale(0.9f, 0.1f)); sequence.Append(transform.DOScale(1.1f, 0.1f)); sequence.Append(transform.DOScale(1f, 0.1f)); sequence.OnComplete(() => { // 动画完成后恢复初始状态 transform.localScale = Vector3.one; }); sequence.OnKill(() => { // 被中断时也要恢复状态 transform.localScale = Vector3.one; }); } }

这里同时用了OnComplete和OnKill，确保无论动画是正常完成还是被中断，状态都能恢复。这是很多项目容易忽略的点：只写了OnComplete，结果动画被中断时状态就乱了。

5.2 回调链式调用的执行顺序陷阱

DOTween的回调可以链式调用，但多个OnComplete的执行顺序是按照注册顺序来的，不是按照代码书写顺序。

var tween = transform.DOMove(target, 1f); tween.OnComplete(() => Debug.Log("第一个注册")); tween.OnComplete(() => Debug.Log("第二个注册")); // 输出: 第一个注册 -> 第二个注册 // 但如果分开写： transform.DOMove(target, 1f) .OnComplete(() => Debug.Log("A")) .OnComplete(() => Debug.Log("B")); // 输出: A -> B

这个顺序在大多数情况下符合直觉，但如果你在回调里又注册了新的回调，就要小心执行顺序的变化。

5.3 用OnKill处理对象池回收时的清理逻辑

对象池是Unity性能优化的常用手段，但动画和对象池配合时容易出问题。当一个对象被回收到池中时，如果动画还在播放，需要正确清理。

public class PooledObject : MonoBehaviour { private Tween currentTween; public void PlayAnimation() { currentTween?.Kill(); currentTween = transform.DOMove(target, 1f) .OnComplete(() => { // 动画完成后回收到池中 ReturnToPool(); }) .OnKill(() => { // 被强制回收时，确保状态重置 transform.localPosition = Vector3.zero; transform.localScale = Vector3.one; }); } public void ReturnToPool() { currentTween?.Kill(); // 其他回收逻辑 } }

关键点是：OnKill在Kill()调用时触发，包括主动Kill和自动Kill（动画完成后的自动销毁）。所以OnKill里不要写"动画完成"相关的逻辑，否则会重复执行。

6. 那些文档没写但实际会遇到的坑

6.1 SetAutoKill(false)与回调的相互影响

默认情况下，DOTween动画在完成后会自动Kill。如果你设置了SetAutoKill(false)，动画完成后不会自动销毁，可以重复使用。但这会影响回调的触发。

var tween = transform.DOMove(target, 1f) .SetAutoKill(false) .OnComplete(() => Debug.Log("完成")); tween.Play(); // 输出: 完成 tween.Play(); // 再次播放 // 输出: 完成 (OnComplete再次触发)

如果动画设置了SetAutoKill(false)，OnComplete会在每次播放完成后触发。这可以用来做可重复的动画，但要注意在回调里不要做只应该执行一次的事情。

6.2 回调中修改动画参数导致的问题

在OnUpdate里修改动画的目标值或持续时间，会导致不可预期的结果。DOTween在动画开始时缓存了起始值和目标值，中途修改不会生效，除非调用ChangeValues()。

// 错误示范：在OnUpdate里修改目标值 transform.DOMove(target, 1f) .OnUpdate(() => { // 这行代码不会改变动画的目标 target = newTarget; }); // 正确示范：用ChangeValues var tween = transform.DOMove(target, 1f); tween.OnUpdate(() => { if (needChange) { tween.ChangeValues(transform.position, newTarget, 1f); } });

6.3 时间缩放（TimeScale）对回调的影响

DOTween默认受Unity的Time.timeScale影响。当timeScale为0时，动画暂停，回调也不会触发。如果你希望动画不受时间缩放影响，需要设置SetUpdate(true)。

// 不受时间缩放影响的动画 transform.DOMove(target, 1f) .SetUpdate(true) // 使用 unscaledDeltaTime .OnComplete(() => { // 即使timeScale为0，这个回调也会触发 });

这个特性在制作暂停菜单时非常有用：暂停游戏时，UI动画仍然需要播放，就可以用SetUpdate(true)。

6.4 回调中的异常处理

DOTween的回调如果抛出异常，DOTween会捕获并记录，但不会中断其他动画。这看起来是好事，但实际上会导致问题被隐藏。建议在回调里做好异常处理，至少在开发阶段把异常暴露出来。

transform.DOMove(target, 1f) .OnComplete(() => { try { // 可能出错的逻辑 DoSomethingRisky(); } catch (Exception e) { Debug.LogError($"动画回调出错: {e}"); // 根据情况决定是否重新抛出 } });

提示：在Unity Editor中，可以通过DOTween.defaultEaseType和DOTween.logBehaviour来调整DOTween的日志行为，方便调试回调问题。

7. 性能优化与回调的最佳实践

7.1 减少回调中的GC分配

每次在回调里创建闭包都会产生GC分配。在大量动画的场景下，这些分配会累积成可观的GC压力。

// 高GC的写法：每次调用都创建新闭包 public void PlayAnimation() { transform.DOMove(target, 1f) .OnComplete(() => { // 这个lambda每次调用都会分配 NextStep(); }); } // 低GC的写法：缓存回调委托 private Action onCompleteCallback; void Awake() { onCompleteCallback = () => NextStep(); } public void PlayAnimation() { transform.DOMove(target, 1f) .OnComplete(onCompleteCallback); // 复用同一个委托 }

如果回调逻辑简单，还可以用静态方法或方法组来避免闭包分配。

7.2 用DOTween的静态方法减少Tween创建

DOTween提供了一些静态方法，可以在不创建Tween的情况下执行简单动画，减少开销。

// 创建Tween transform.DOMove(target, 1f); // 静态方法（不创建Tween对象） DOVirtual.Float(0, 1, 1f, (value) => { // 用value做插值 transform.position = Vector3.Lerp(start, end, value); });

DOVirtual系列方法适合做一次性的简单动画，不需要Tween对象的管理开销。

7.3 回调中的对象池与资源管理

在回调里创建或销毁对象时，尽量用对象池。比如动画完成后生成一个特效，用对象池比Instantiate更高效。

transform.DOMove(target, 1f) .OnComplete(() => { // 从对象池获取特效 var effect = EffectPool.Get(); effect.transform.position = transform.position; effect.Play(); });

同时要注意：如果动画所在的对象被销毁，回调里的对象池操作可能会失败。确保在对象销毁前Kill掉所有相关动画。

7.4 批量动画的回调管理

当场景中有大量动画同时播放时，每个动画都注册回调会导致管理困难。可以用一个统一的回调管理器来集中处理。

public class AnimationCallbackManager : MonoBehaviour { private Dictionary<Tween, Action> callbacks = new Dictionary<Tween, Action>(); public void RegisterCallback(Tween tween, Action callback) { callbacks[tween] = callback; tween.OnComplete(() => { callback?.Invoke(); callbacks.Remove(tween); }); } void OnDestroy() { // 清理所有回调 foreach (var kvp in callbacks) { kvp.Key?.Kill(); } callbacks.Clear(); } }

这种方式在管理大量动画时更清晰，也方便统一清理。

8. 从实际项目出发的回调选型建议

8.1 不同场景下回调的选择对照

8.2 回调链的调试技巧

DOTween的回调链如果很长，调试起来很麻烦。可以在每个回调里加日志，但更高效的方式是用DOTween的DOTween.defaultTimeScaleIndependent和Editor的Tween Inspector。

在Unity Editor中，可以通过DOTween Utility Panel查看当前所有活跃的Tween，包括它们的回调注册情况。这个面板在调试动画流程时非常有用。

// 在回调里加标识，方便调试 transform.DOMove(target, 1f) .OnComplete(() => { Debug.Log($"[动画流程] {gameObject.name} 移动完成"); NextStep(); });

8.3 回调与状态机的结合

在复杂的动画流程中，回调最好和状态机结合使用，而不是在回调里写一堆if-else。

public enum AnimationState { Idle, Moving, Scaling, Completed } public class AnimationController : MonoBehaviour { private AnimationState currentState = AnimationState.Idle; public void PlayMoveAnimation() { currentState = AnimationState.Moving; transform.DOMove(target, 1f) .OnComplete(() => { if (currentState == AnimationState.Moving) { currentState = AnimationState.Completed; OnMoveCompleted(); } }); } void OnMoveCompleted() { // 处理移动完成后的逻辑 } }

用状态机可以避免回调在错误的状态下执行，也方便调试和扩展。

8.4 回调的替代方案：用DOTween的Sequence替代复杂回调链

如果发现回调链太长太复杂，考虑用Sequence重构。Sequence可以把多个动画和回调组织成更清晰的结构。

// 回调链写法 transform.DOMove(target, 1f) .OnComplete(() => { transform.DOScale(Vector3.one * 2, 0.5f) .OnComplete(() => { transform.DORotate(new Vector3(0, 180, 0), 0.5f) .OnComplete(() => { // 更多嵌套... }); }); }); // Sequence写法 var sequence = DOTween.Sequence(); sequence.Append(transform.DOMove(target, 1f)); sequence.Append(transform.DOScale(Vector3.one * 2, 0.5f)); sequence.Append(transform.DORotate(new Vector3(0, 180, 0), 0.5f)); sequence.OnComplete(() => { // 所有动画完成后执行 });

Sequence不仅代码更清晰，而且可以统一控制播放、暂停、倒放，比嵌套回调灵活得多。

8.5 回调中的异步操作处理

如果回调里需要执行异步操作（比如加载资源），直接用async void会有问题。推荐用UniTask的Forget()或者把异步逻辑封装成UniTask方法。

// 不推荐：async void transform.DOMove(target, 1f) .OnComplete(async () => { // async void 无法捕获异常 await LoadNextScene(); }); // 推荐：用UniTask transform.DOMove(target, 1f) .OnComplete(() => { LoadNextSceneAsync().Forget(); }); async UniTaskVoid LoadNextSceneAsync() { await UniTask.Delay(1000); // 加载逻辑 }

Forget()会忽略异常，如果需要在异常时做处理，可以用Forget(Debug.LogException)。

8.6 回调在UI动画中的特殊处理

UI动画和场景动画有一些不同的注意点。UI元素经常需要根据屏幕分辨率或布局动态调整，回调里访问RectTransform时要小心。

// UI动画回调中访问RectTransform rectTransform.DOAnchorPos(targetPos, 0.3f) .OnComplete(() => { // 确保RectTransform还有效 if (rectTransform != null) { // 可能需要重新计算布局 LayoutRebuilder.ForceRebuildLayoutImmediate(rectTransform.parent as RectTransform); } });

UI动画还经常需要处理快速点击导致的动画冲突。用SetAutoKill(false)配合Restart()可以避免重复创建Tween。

private Tween uiTween; public void PlayUIFeedback() { if (uiTween == null) { uiTween = rectTransform.DOScale(1.1f, 0.1f) .SetAutoKill(false) .SetLoops(2, LoopType.Yoyo); } else { uiTween.Restart(); } }

这种写法在按钮快速点击时特别有用，不会因为重复创建Tween导致性能问题。

8.7 回调与DOTween的全局设置

DOTween有一些全局设置会影响回调的行为，比如DOTween.defaultAutoKill、DOTween.defaultUpdateType等。在项目初始化时统一设置，可以避免在每个Tween上单独配置。

// 在游戏启动时设置全局默认值 void Awake() { DOTween.Init(); DOTween.defaultAutoKill = true; DOTween.defaultUpdateType = UpdateType.Normal; DOTween.defaultTimeScaleIndependent = false; DOTween.defaultEaseType = Ease.OutQuad; }

但要注意：全局设置会影响所有Tween，如果项目中有特殊需求的Tween，还是需要单独配置。

8.8 回调在热更新和资源加载中的注意事项

如果项目用了热更新，DOTween的回调里引用的方法可能会在热更新后失效。建议把回调逻辑放在热更新代码中，或者用委托的方式动态绑定。

// 用委托动态绑定回调 public Action onAnimationComplete; transform.DOMove(target, 1f) .OnComplete(() => { onAnimationComplete?.Invoke(); });

这样即使回调逻辑在热更新中改变，只要重新赋值onAnimationComplete就能生效。

8.9 回调的单元测试思路

DOTween的回调逻辑也可以做单元测试。用DOTween.ManualUpdate可以在测试中手动控制动画更新。

[Test] public void TestAnimationCallback() { bool callbackCalled = false; var tween = transform.DOMove(Vector3.one, 1f) .OnComplete(() => callbackCalled = true); // 手动推进动画 tween.ManualUpdate(1f, 1f); Assert.IsTrue(callbackCalled); }

这种方式可以在不运行游戏的情况下测试回调逻辑，适合在CI流程中做自动化测试。

8.10 回调在多人游戏中的同步问题

如果动画需要网络同步，回调里不要直接修改游戏状态，而是通过RPC或网络消息来同步。

transform.DOMove(target, 1f) .OnComplete(() => { // 不要直接修改状态 // 而是发送网络消息 if (isLocalPlayer) { SendAnimationCompleteMessage(); } });

这样可以避免因为网络延迟导致的动画状态不一致。

9. 个人在实际项目中的几点体会

DOTween的回调体系看起来简单，但真正用好需要理解它的执行时机和边界条件。我在多个商业项目中踩过的坑主要集中在几个方面：一是闭包捕获问题，批量创建动画时几乎必踩；二是OnKill和OnComplete的区分，很多人只写OnComplete，结果动画被中断时状态就乱了；三是回调里的异常处理，DOTween会吞掉异常，导致问题很难排查。

一个比较实用的建议是：在项目初期就建立一套动画回调的规范，比如统一用OnComplete处理完成逻辑，用OnKill处理清理逻辑，用OnStart处理初始化逻辑。这样团队协作时不容易出错。另外，对于复杂的动画流程，优先考虑用Sequence而不是嵌套回调，代码可读性和可维护性都会好很多。

最后分享一个小技巧：如果发现某个动画的回调没有按预期触发，先检查动画是否被Kill了，再检查SetAutoKill和SetUpdate的设置。这两个地方是最容易出问题的。另外，在Editor中可以用DOTween Utility Panel查看所有活跃的Tween，对调试非常有帮助。