1. 项目概述：为什么我们需要动画回调？

在Unity开发中，Animator组件是驱动角色、UI乃至场景物件动画的核心。我们通过Animator Controller设置状态机，用参数控制状态切换，动画就能流畅播放。但很多开发者，尤其是刚接触Unity不久的朋友，常常会遇到一个看似简单却非常关键的需求：“我怎么知道某个动画什么时候开始播放，又是什么时候播放结束的？”

这个需求就是“动画回调”。想象一下这些场景：你的角色挥剑攻击，你需要在剑刃划到最高点的瞬间触发伤害判定；一个UI面板滑入屏幕，你需要在它完全进入后激活上面的按钮交互；一个宝箱打开动画播放完毕，你需要立即生成奖励物品。如果你只是简单地调用Animator.Play(“Attack”)，代码会立刻执行下一行，而动画可能才播了第一帧。没有精确的回调机制，你的游戏逻辑和视觉表现就会脱节，导致判定不准、交互失灵或逻辑错乱。

Unity的Animator本身并没有直接提供像AnimationEvent那样直观的、在特定帧调用函数的事件系统（尽管它支持）。对于状态机层面的开始与结束，我们需要通过代码来“监听”。网上有很多零散的代码片段，但往往只解决了部分问题，或者没有解释清楚背后的原理和坑点。今天，我就结合自己多年的项目经验，从状态机原理到代码实现，再到实战避坑，完整地拆解如何在代码中可靠地获取Animator动画的开始与结束回调。

2. 核心原理：Animator状态机与信息查询

在动手写代码之前，我们必须理解Animator是如何工作的。这能帮你写出更健壮、高效的代码，而不是盲目复制粘贴。

2.1 Animator的运行时信息栈

Animator组件每一帧都在做大量计算：融合（Blending）、过渡（Transition）、计算骨骼最终姿势。它通过AnimatorStateInfo这个结构体向我们暴露当前状态的信息。获取这个信息的主要入口是Animator.GetCurrentAnimatorStateInfo(int layerIndex)方法。

这里有个关键点：“当前状态”并不总是等于“你看到的动画”。因为动画之间存在过渡（CrossFade）。在过渡期间，GetCurrentAnimatorStateInfo返回的可能是正在退出的旧状态，也可能是正在进入的新状态，这取决于过渡的进度。为了精确，我们通常需要同时查询当前状态和下一状态。

// 获取第0层（基础层）的状态信息 AnimatorStateInfo currentStateInfo = animator.GetCurrentAnimatorStateInfo(0); AnimatorStateInfo nextStateInfo = animator.GetNextAnimatorStateInfo(0); // 检查是否处于过渡中 bool isInTransition = animator.IsInTransition(0);

AnimatorStateInfo提供了几个核心属性：

• shortNameHash: 状态在Animator Controller中的短名称哈希值（最常用）。
• fullPathHash: 状态的完整路径哈希值。
• normalizedTime: 动画的标准化时间。范围通常为[0,1]，表示一个循环的进度。注意，如果动画设置为循环（Loop），这个值会超过1。
• length: 动画的时长（秒）。
• loop: 动画是否循环。

2.2 为何使用哈希（Hash）而非字符串名？

你可能注意到，很多代码比较的是shortNameHash，而不是直接的字符串状态名。这是出于性能考虑。字符串比较在游戏循环中（如Update里）是相对昂贵的操作。而整数哈希值的比较则快得多。Unity允许我们通过Animator.StringToHash(string name)方法将状态名预先计算成哈希值。

// 在类初始化时计算，避免在Update中重复计算 private readonly int _stateIdleHash = Animator.StringToHash(“Idle”); private readonly int _stateAttackHash = Animator.StringToHash(“Attack”); void Update() { var stateInfo = animator.GetCurrentAnimatorStateInfo(0); if (stateInfo.shortNameHash == _stateAttackHash) { // 高效地判断当前是否为攻击状态 } }

2.3 理解“开始”与“结束”的界定

这是实现回调的逻辑核心，定义不清会导致回调触发混乱。

• 动画开始：通常指动画状态真正开始播放的第一帧。注意，从其他状态通过过渡（CrossFade）进入目标状态时，会有一个混合过程。一种严谨的定义是：当目标状态的normalizedTime首次大于0（且小于一个很小的阈值，如0.05）时，视为开始。
• 动画结束：对于非循环动画，结束指normalizedTime首次达到或超过1.0。对于循环动画，它没有传统意义上的“结束”，我们需要的是“单次循环完成”的时刻，即normalizedTime的整数部分增加时（例如从0.99跳变到1.01）。

3. 方案选型：三种主流实现路径对比

根据项目复杂度和对精度的要求，主要有三种实现方式。没有绝对的好坏，只有适合与否。

3.1 方案一：Update轮询检查（最基础、最可控）

这是最直接的方法。在MonoBehaviour的Update方法中，持续检查Animator的当前状态和标准化时间。

优点：

• 实现简单，逻辑一目了然。
• 控制粒度细，可以在任何你想要的进度点触发回调（例如，在normalizedTime为0.5时触发中间事件）。
• 不依赖特定Unity版本或设置，兼容性最好。

缺点：

• 性能开销：每一帧都需要执行查询和比较逻辑，虽然单次开销很小，但角色数量多时需留意。
• 代码分散：逻辑写在Update中，如果多个动画需要回调，Update方法会变得臃肿。

适用场景：原型开发、动画数量不多的角色、需要非常规进度回调（如25%，50%）的情况。

3.2 方案二：利用Animator的IK或更新回调（更高效）

Unity为Animator提供了两个特殊的消息方法：OnAnimatorIK和OnAnimatorMove。它们本身用于逆向动力学和根运动处理，但有一个重要特性：它们会在Animator完成当前帧的状态评估之后、应用姿势之前被调用。这意味着在这里获取的状态信息是“新鲜”且“确定”的。

我们可以利用OnAnimatorIK（即使你不使用IK功能）作为我们的检查点。

优点：

• 时机准确：调用时机与动画系统更新紧密耦合，避免了在Update中可能出现的帧延迟问题。
• 相对高效：将检查逻辑放在一个专为动画设计的回调中，比漫无目的的Update轮询更规范。

缺点：

• 需要开启IK层：即使不写IK代码，也需要在Animator组件上勾选“Apply Root Motion”或确保有IK层被启用，否则OnAnimatorIK可能不会被调用。
• 理解成本稍高：需要开发者了解这两个特殊回调的用途。

适用场景：对动画回调时机要求精确的项目，尤其是涉及状态同步或物理交互时。

3.3 方案三：基于StateMachineBehaviour（最优雅、最模块化）

StateMachineBehaviour是一个可以挂载到Animator Controller中单个状态或子状态机上的脚本。它提供了诸如OnStateEnter、OnStateUpdate、OnStateExit等生命周期回调。这几乎是解决本需求的“官方”完美方案。

优点：

• 高内聚：回调逻辑与动画状态绑定在一起，管理清晰。不需要在角色的主控脚本里写一堆if...else来判断状态。
• 可复用：可以轻松地将同一个StateMachineBehaviour脚本拖到多个相同需求的状态上。
• 功能强大：除了开始结束，还能获得OnStateMove、OnStateIK等精细控制。

缺点：

• 配置在动画控制器中：逻辑与资源（Animator Controller文件）耦合，对于喜欢纯代码控制的开发者可能不习惯。
• 跨脚本通信：StateMachineBehaviour如何将事件（如“攻击动画结束”）通知给角色的战斗系统？这通常需要通过发送消息（SendMessage、BroadcastMessage）或获取父对象上的组件来实现，设计上需要一些考量。

适用场景：中大型项目，动画状态多且逻辑复杂，追求架构清晰度和可维护性。

个人心得：在快速迭代的早期，我常用方案一。当项目结构逐渐稳定，动画逻辑变复杂后，我会毫不犹豫地迁移到方案三。方案二则是一个不错的折中选择，特别是在处理需要与动画帧精确同步的物理逻辑时。

4. 代码实现与逐行解析

下面，我将分别展示三种方案的完整代码实现，并附上详细注释和注意事项。

4.1 方案一实现：Update轮询

我们创建一个通用的AnimatorCallbackMonitor组件。

using UnityEngine; /// <summary> /// 通过Update轮询监控指定Animator状态的开始与结束。 /// </summary> public class AnimatorCallbackMonitor : MonoBehaviour { [SerializeField] private Animator _targetAnimator; // 目标Animator组件 [SerializeField] private string _stateToWatch = “Attack”; // 要监控的状态名 [SerializeField] private bool _debugLog = false; // 调试开关 // 事件定义，用于外部订阅 public System.Action OnStateStarted; public System.Action OnStateEnded; private int _stateHash; // 状态名哈希缓存 private bool _wasInState = false; // 上一帧是否在目标状态 private float _lastNormalizedTime = 0f; // 上一帧的标准化时间 void Start() { if (_targetAnimator == null) _targetAnimator = GetComponent<Animator>(); if (_targetAnimator == null) { Debug.LogError($“AnimatorCallbackMonitor on {gameObject.name}: No Animator found!”, this); enabled = false; return; } _stateHash = Animator.StringToHash(_stateToWatch); if (_debugLog) Debug.Log($“开始监控状态: {_stateToWatch} (Hash: {_stateHash})”, this); } void Update() { if (_targetAnimator == null) return; // 获取当前层（0）的状态信息 AnimatorStateInfo currentStateInfo = _targetAnimator.GetCurrentAnimatorStateInfo(0); bool isCurrentlyInState = currentStateInfo.shortNameHash == _stateHash; // —————— 状态进入检测 —————— if (isCurrentlyInState && !_wasInState) { // 刚进入状态，可能是过渡刚开始，normalizedTime可能还为0。 // 我们等待下一帧，当normalizedTime > 一个小阈值时，才认为是“开始播放” _lastNormalizedTime = currentStateInfo.normalizedTime; // 这里不立即触发，由下面的时间检测逻辑处理 if (_debugLog) Debug.Log($“进入状态 {_stateToWatch}，当前进度: {_lastNormalizedTime}”, this); } // —————— 状态内进度检测（用于判断开始和结束） —————— if (isCurrentlyInState) { float currentNormalizedTime = currentStateInfo.normalizedTime; // 检测动画“开始”：从非播放状态到首次有进度 // _lastNormalizedTime <= 0.01f 是为了避免在循环动画的每次循环起点误触发 if (_lastNormalizedTime <= 0.01f && currentNormalizedTime > 0.01f && currentNormalizedTime < 0.5f) { OnStateStarted?.Invoke(); if (_debugLog) Debug.Log($“[{Time.frameCount}] 状态 {_stateToWatch} 开始播放。”, this); } // 检测动画“结束”（非循环动画） // 注意：normalizedTime在播放完毕后会停留在>=1.0的值，不会重置。 if (!currentStateInfo.loop) // 仅对非循环动画检测结束 { // 上一帧<1，当前帧>=1，表示刚好播完 if (_lastNormalizedTime < 1.0f && currentNormalizedTime >= 1.0f) { OnStateEnded?.Invoke(); if (_debugLog) Debug.Log($“[{Time.frameCount}] 状态 {_stateToWatch} 播放结束。”, this); } } else // 对于循环动画，检测单次循环完成 { // 通过取整判断是否完成了一次循环 int lastLoopCount = Mathf.FloorToInt(_lastNormalizedTime); int currentLoopCount = Mathf.FloorToInt(currentNormalizedTime); if (currentLoopCount > lastLoopCount) { // 可以触发一个“循环完成”事件，如果需要的话 // OnLoopCompleted?.Invoke(); if (_debugLog) Debug.Log($“[{Time.frameCount}] 状态 {_stateToWatch} 完成一次循环。”, this); } } _lastNormalizedTime = currentNormalizedTime; } // 更新上一帧的状态记录 _wasInState = isCurrentlyInState; } }

使用方式：

1. 将此脚本挂载到拥有Animator的游戏对象上。
2. 在Inspector中指定要监控的状态名（如“Attack”）。
3. 在其他脚本中，获取该组件并订阅其OnStateStarted和OnStateEnded事件。

// 在其他脚本中（如PlayerAttack） void Start() { var monitor = GetComponent<AnimatorCallbackMonitor>(); if (monitor != null) { monitor.OnStateStarted += HandleAttackStart; monitor.OnStateEnded += HandleAttackEnd; } } void HandleAttackStart() { /* 攻击生效帧逻辑 */ } void HandleAttackEnd() { /* 攻击后摇结束，可接下一个动作 */ }

4.2 方案二实现：利用OnAnimatorIK回调

这个方案我们将检查逻辑放在更精确的时机。

using UnityEngine; public class AnimatorCallbackViaIK : MonoBehaviour { [SerializeField] private string _stateToWatch = “Jump”; [SerializeField] private bool _debugLog = false; public System.Action OnStateStarted; public System.Action OnStateEnded; private Animator _animator; private int _stateHash; private bool _previousFrameInState; private float _previousNormalizedTime; void Start() { _animator = GetComponent<Animator>(); if (_animator == null) { Debug.LogError(“AnimatorCallbackViaIK requires an Animator component!”, this); enabled = false; return; } _stateHash = Animator.StringToHash(_stateToWatch); // 确保Animator的IK权重不为0，否则OnAnimatorIK可能不被调用。 // 通常只要Avatar有效且存在Humanoid骨骼，默认就会调用。 } // 这是一个特殊的Unity消息，在动画状态更新后被调用 void OnAnimatorIK(int layerIndex) { // 通常我们只关心基础层（layer 0） if (layerIndex != 0) return; if (_animator == null) return; AnimatorStateInfo stateInfo = _animator.GetCurrentAnimatorStateInfo(0); bool isInState = stateInfo.shortNameHash == _stateHash; float currentTime = stateInfo.normalizedTime; // 状态进入检测 if (isInState && !_previousFrameInState) { // 刚进入状态，记录初始时间 _previousNormalizedTime = currentTime; } // 状态内逻辑 if (isInState) { // 开始检测：从初始状态（时间接近0）到开始有进度 // 这里阈值可以设得更小，因为OnAnimatorIK调用时机更准 if (_previousNormalizedTime < 0.01f && currentTime >= 0.01f && currentTime < 0.1f) { OnStateStarted?.Invoke(); if (_debugLog) Debug.Log($“IK回调: {_stateToWatch} 开始”, this); } // 结束检测（非循环） if (!stateInfo.loop && _previousNormalizedTime < 1.0f && currentTime >= 1.0f) { OnStateEnded?.Invoke(); if (_debugLog) Debug.Log($“IK回调: {_stateToWatch} 结束”, this); } _previousNormalizedTime = currentTime; } _previousFrameInState = isInState; // 可选：如果你完全不用IK，可以把权重设回去，避免影响动画 // _animator.SetIKPositionWeight(AvatarIKGoal.RightHand, 0); // _animator.SetIKRotationWeight(AvatarIKGoal.RightHand, 0); } }

重要提示：使用此方法需确保对象的Animator组件配置的Avatar是有效的（特别是人形动画），并且没有禁用IK相关的功能。对于Generic类型的动画，OnAnimatorIK的调用可能不稳定，需测试验证。

4.3 方案三实现：使用StateMachineBehaviour（推荐）

这是最模块化的方式。我们创建一个StateMachineBehaviour脚本。

using UnityEngine; /// <summary> /// 挂载到Animator State上，用于触发该状态的开始和结束事件。 /// 需要通过消息传递等方式通知外部对象。 /// </summary> public class StateCallbackBehaviour : StateMachineBehaviour { [SerializeField] private bool _triggerOnEnter = true; [SerializeField] private bool _triggerOnExit = true; [Tooltip(“状态结束是否只在非循环动画且播放完毕时触发？若为false，则退出状态即触发。”)] [SerializeField] private bool _exitOnlyOnComplete = true; // 可以使用字符串定义事件名，方便通过SendMessage传递 [SerializeField] private string _onStateEnterMessage = “OnAnimStateEntered”; [SerializeField] private string _onStateExitMessage = “OnAnimStateExited”; // 存储进入状态时的信息，用于判断是否播放完毕 private AnimatorStateInfo _enterStateInfo; private int _enterStateHash; // OnStateEnter is called when a transition starts and the state machine starts to evaluate this state override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) { _enterStateInfo = stateInfo; _enterStateHash = stateInfo.fullPathHash; // 使用fullPathHash更精确 if (_triggerOnEnter) { // 方式1：通过SendMessage发送给Animator所在GameObject animator.SendMessage(_onStateEnterMessage, stateInfo.shortNameHash, SendMessageOptions.DontRequireReceiver); // 方式2（更优）：获取一个预设的接口或组件 // var listener = animator.GetComponent<IAnimationStateListener>(); // listener?.OnAnimStateEnter(stateInfo.shortNameHash); } } // OnStateUpdate is called on each Update frame between OnStateEnter and OnStateExit callbacks override public void OnStateUpdate(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) { // 如果需要基于进度触发事件（如攻击命中帧），可以在这里判断stateInfo.normalizedTime // if (stateInfo.normalizedTime >= 0.3f && stateInfo.normalizedTime < 0.4f) { ... } } // OnStateExit is called when a transition ends and the state machine finishes evaluating this state override public void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex) { if (!_triggerOnExit) return; bool shouldTriggerExit = true; if (_exitOnlyOnComplete) { // 检查退出时是否是因为播放完毕（非循环动画） // 注意：stateInfo是即将进入的新状态信息，要判断旧状态是否完成，需要用_enterStateInfo // 但OnStateExit时，旧状态可能已经不可直接获取。一个替代方法是检查normalizedTime。 // 更可靠的方法是在OnStateUpdate里记录播放完成标志。 // 这里简化处理：如果退出时旧状态的标准化时间>=1，则认为完成。 // 但stateInfo已是新状态，此方法不准确。因此，对于精确的“播放完毕”事件，建议在OnStateUpdate中检测并触发。 // 此处我们触发通用的“状态退出”事件，并在注释中说明限制。 // 对于“播放完毕”，建议使用下面OnStateUpdate的示例。 } if (shouldTriggerExit) { animator.SendMessage(_onStateExitMessage, stateInfo.shortNameHash, SendMessageOptions.DontRequireReceiver); } } // 如果需要精确的“播放完毕”事件，应在OnStateUpdate中检测 // private bool _hasTriggeredComplete = false; // override public void OnStateUpdate(...) // { // if (!_enterStateInfo.loop && _enterStateInfo.normalizedTime >= 1.0f && !_hasTriggeredComplete) // { // animator.SendMessage(“OnAnimStateComplete”, _enterStateInfo.shortNameHash, SendMessageOptions.DontRequireReceiver); // _hasTriggeredComplete = true; // } // } }

配置与使用：

1. 在Project中创建此脚本。
2. 打开你的Animator Controller，在Inspector中选择一个状态（如“Attack”）。
3. 在状态Inspector的底部，点击“Add Behaviour”，选择StateCallbackBehaviour。
4. 在Behaviour组件上配置参数，比如设置On State Enter Message为“OnAttackStart”。
5. 在控制该Animator的脚本中，实现名为OnAttackStart和OnAttackEnd的方法。

// 在PlayerController.cs中 public class PlayerController : MonoBehaviour { private void OnAttackStart(int stateHash) { // 攻击动画开始，激活伤害碰撞体 Debug.Log(“Attack Animation Started!”); } private void OnAttackEnd(int stateHash) { // 攻击动画结束，收回武器，进入可切换状态 Debug.Log(“Attack Animation Ended!”); } }

5. 实战避坑与进阶技巧

掌握了基本实现，我们来看看实际项目中容易踩的坑和一些提升体验的技巧。

5.1 坑点一：过渡（CrossFade）导致的误触发

当你使用CrossFade或设置过渡条件时，动画状态切换不是瞬时的。在过渡期间，GetCurrentAnimatorStateInfo可能返回旧状态，而normalizedTime可能会继续增加（对于旧状态）或从0开始（对新状态，但被混合）。这会导致你的“开始”检测逻辑在过渡中途或过渡刚开始时就触发。

解决方案：更严谨的判断。结合Animator.IsInTransition和下一状态信息(GetNextAnimatorStateInfo)。

bool isInTransition = animator.IsInTransition(0); AnimatorStateInfo nextStateInfo = animator.GetNextAnimatorStateInfo(0); if (isInTransition && nextStateInfo.shortNameHash == _targetStateHash) { // 正在过渡到目标状态 float transitionProgress = animator.GetAnimatorTransitionInfo(0).normalizedTime; // 可以等过渡进行到一半(>0.5)后再开始检测目标状态的开始，避免干扰 }

5.2 坑点二：循环动画与结束判断

对于循环动画，normalizedTime会不断增长（如1.2, 2.3...）。用>=1.0判断“结束”会每一帧都触发。你需要的是“单次循环完成”的事件。

解决方案：通过取整（Mathf.Floor）判断循环次数是否增加。

float currentTime = stateInfo.normalizedTime; int currentLoop = Mathf.FloorToInt(currentTime); int previousLoop = Mathf.FloorToInt(_lastNormalizedTime); if (currentLoop > previousLoop) { // 触发“单次循环完成”事件 OnLoopCompleted?.Invoke(); }

5.3 坑点三：状态机层（Layers）与权重

如果你的Animator使用了多层（Layer），例如基础层负责移动，上层负责上半身攻击。你需要明确监控哪一层。GetCurrentAnimatorStateInfo需要传入层索引。上层动画可能会覆盖下层，影响你对下层动画状态的判断。

解决方案：在监控时指定正确的层索引。对于全身动画监控基础层(0)，对于叠加动画监控对应的上层。

// 监控第1层（索引为1）的状态 AnimatorStateInfo upperLayerState = animator.GetCurrentAnimatorStateInfo(1);

5.4 技巧一：使用ScriptableObject创建事件通道

对于方案三（StateMachineBehaviour），通过SendMessage通信虽然简单，但类型不安全，且耦合较紧。一个更优雅的架构是使用ScriptableObject作为事件通道。

1. 创建一个AnimationEventChannel的ScriptableObject。
2. 在StateMachineBehaviour中持有该通道的引用，在事件发生时调用通道的方法（如RaiseStateEnterEvent(int hash, GameObject animatorOwner)）。
3. 任何需要监听动画事件的脚本（如技能系统、音效系统），都去订阅这个通道的事件。

这样做实现了完全解耦，事件发布者和订阅者互不知晓，非常适合大型项目。

5.5 技巧二：编辑器扩展辅助调试

你可以编写一个简单的编辑器脚本，在Scene视图或Animator窗口实时显示当前状态和标准化时间，辅助调试。

#if UNITY_EDITOR using UnityEditor; using UnityEngine; [CustomEditor(typeof(YourAnimatorMonitorScript))] public class YourAnimatorMonitorEditor : Editor { public override void OnInspectorGUI() { base.OnInspectorGUI(); YourAnimatorMonitorScript monitor = (YourAnimatorMonitorScript)target; if (monitor != null && Application.isPlaying) { EditorGUILayout.Space(); EditorGUILayout.LabelField(“Debug Info”, EditorStyles.boldLabel); // 这里可以显示从monitor脚本中获取的运行时信息，如当前状态哈希、进度等。 // 需要你的monitor脚本暴露这些信息。 EditorGUILayout.LabelField($“Current State Hash: {monitor.CurrentStateHash}”); EditorGUILayout.LabelField($“Normalized Time: {monitor.CurrentNormalizedTime:F3}”); } } } #endif

5.6 性能优化考量

• 哈希缓存：务必在Start或Awake中缓存状态名的哈希值，绝不在Update或OnAnimatorIK中调用Animator.StringToHash。
• 减少每帧查询：如果对象很多，考虑将轮询逻辑放在一个统一的、按需更新的管理器中，而不是每个对象都有自己的Update。
• 事件订阅管理：使用Action事件时，注意在对象销毁（OnDestroy）时取消订阅，防止内存泄漏和空引用异常。
• StateMachineBehaviour的效率：StateMachineBehaviour本身是高效的，因为Unity内部会优化其调用。但要避免在OnStateUpdate中执行过于沉重的逻辑。

6. 方案对比与选型指南

为了帮助你快速决策，我将三种方案的核心特点总结如下：

个人最终建议： 对于新手或小型项目，从方案一开始，它能帮你快速理解原理。当项目复杂度增加，或者你开始构建一个需要清晰架构的系统时，毫不犹豫地转向方案三。方案二则是一个在某些特定性能敏感或同步要求极高的场景下的专家级选择。理解每一种方案的原理，你就能在面对具体问题时，选出最得心应手的那把“螺丝刀”。