*misc

3 files changed, 123 insertions, 99 deletions

diff --git a/Assets/Scripts/Unit/Components/UnitAnimation/MonsterAnimation.cs b/Assets/Scripts/Unit/Components/UnitAnimation/MonsterAnimation.cs
index 26361098..d7138516 100644
--- a/Assets/Scripts/Unit/Components/UnitAnimation/MonsterAnimation.cs
+++ b/Assets/Scripts/Unit/Components/UnitAnimation/MonsterAnimation.cs
@@ -18,23 +18,11 @@ public class MonsterAnimation : UnitAnimation
         Idle = 0,
         Move,
         Jump,
-        Hit,
-        Attack,
-        Rise,
-        Stinger,
-        Turn,
-        Landing,
-
-        AirAttack0,
-        AirAttack1,
-        AirAttack2,
-        AirAttack3,
-
-        Attack0,
-        Attack1,
-        Attack2,
-        Attack3,
-    }
+
+		HitLight,
+		HitAir,
+		Rise,
+	}
 
     public override void Initialize()
     {
@@ -45,7 +33,7 @@ public class MonsterAnimation : UnitAnimation
         m_Animator.speed = 0;
 
         m_LayerInfo = new AnimatorLayerInfo[2];
-        m_LayerInfo[0] = new AnimatorLayerInfo(this, m_Animator, (int)ELayer.Basic);
+        m_LayerInfo[0] = new AnimatorLayerInfo(this, m_Animator, (int)ELayer.Basic, ELayer.Basic.ToString());
         //m_LayerInfo[1] = new AnimatorLayerInfo(this, m_Animator, ELayer.Attack);
 
         if (m_Animator == null)
@@ -88,23 +76,39 @@ public class MonsterAnimation : UnitAnimation
 
     public void AnimIdle()
     {
-        m_Animator.CrossFade("Idle", 0.2f, 0);
+        this.CrossFade(EAnimState.Idle, 0.2f, 0);
     }
 
     public void AnimHitLight()
     {
-        m_Animator.Play("HitLight", 0, 0);
+		this.Play(EAnimState.HitLight, 0, 0);
         //m_Animator.CrossFade("HitLight", 0.05f, 0, 0, 0);
     }
     public void AnimHitAir()
     {
-        m_Animator.Play("HitAir", 0, 0);
+		this.Play(EAnimState.HitAir, 0, 0);
         //m_Animator.CrossFade("HitLight", 0.05f, 0, 0, 0);
     }
 
     public void AnimRise()
     {
-        m_Animator.CrossFade("Rise", 0);
+		this.CrossFade(EAnimState.Rise, 0);
     }
 
+	private void Play(EAnimState animState, int layerIndex = 0, float normalizedTime = float.NegativeInfinity)
+	{
+		AnimatorLayerInfo layer = this.layers[layerIndex];
+		if (layer == null)
+			return;
+		layer.OnPlay(animState.ToString(), normalizedTime);
+	}
+
+	public void CrossFade(EAnimState animState, float normalizedTransitionDuration, int layerIndex = 0, float normalizedTimeOffset = float.NegativeInfinity, float normalizedTransitionTime = 0.0f)
+	{
+		AnimatorLayerInfo layer = this.layers[layerIndex];
+		if (layer == null)
+			return;
+		layer.OnCrossFade(animState.ToString(), normalizedTransitionDuration, normalizedTimeOffset, normalizedTransitionTime);
+	}
+
 }
diff --git a/Assets/Scripts/Unit/Components/UnitAnimation/PCAnimation.cs b/Assets/Scripts/Unit/Components/UnitAnimation/PCAnimation.cs
index 8a265f45..41f9e8b6 100644
--- a/Assets/Scripts/Unit/Components/UnitAnimation/PCAnimation.cs
+++ b/Assets/Scripts/Unit/Components/UnitAnimation/PCAnimation.cs
@@ -6,7 +6,21 @@ using UnityEngine;
 
 public class PCAnimation : UnitAnimation
 {
-    public enum ELayer
+
+#if !ANIM_CROSS_FADE
+    // 切换动画
+    public enum ETrigger
+    {
+        ToIdle,
+        ToMove,
+        ToJump,
+        ToAttack,
+        ToAirAttack,
+        ToLanding,
+    }
+#endif
+
+	public enum ELayer
     {
         Basic = 0,
         Attack,
@@ -41,20 +55,11 @@ public class PCAnimation : UnitAnimation
         Attack1,
         Attack2,
         Attack3,
-    }
 
-#if !ANIM_CROSS_FADE
-    // 切换动画
-    public enum ETrigger
-    {
-        ToIdle,
-        ToMove,
-        ToJump,
-        ToAttack,
-        ToAirAttack,
-        ToLanding,
-    }
-#endif
+		AirDash,
+
+		LandingGround,
+	}
 
     private UnitActionData m_ActionData;
 
@@ -70,7 +75,7 @@ public class PCAnimation : UnitAnimation
         m_Animator.speed = 0;
 
         m_LayerInfo = new AnimatorLayerInfo[2];
-        m_LayerInfo[0] = new AnimatorLayerInfo(this, m_Animator, (int)ELayer.Basic);
+        m_LayerInfo[0] = new AnimatorLayerInfo(this, m_Animator, (int)ELayer.Basic, ELayer.Basic.ToString());
         //m_LayerInfo[1] = new AnimatorLayerInfo(this, m_Animator, ELayer.Attack);
 
         if (m_Animator == null)
@@ -122,96 +127,95 @@ public class PCAnimation : UnitAnimation
 
     public void AnimIdle()
     {
-#if ANIM_CROSS_FADE
-        m_Animator.CrossFade("Idle", 0.2f, 0);
-#else
-        ResetAllTriggers();
-        m_Animator.SetTrigger(ETrigger.ToIdle.ToString());
-#endif
+        this.CrossFade(EAnimState.Idle, 0.2f, 0);
     }
 
     public void AnimMove()
     {
-#if ANIM_CROSS_FADE
-        m_Animator.CrossFade("Move", 0.01f, 0);
-#else
-        ResetAllTriggers();
-        m_Animator.SetTrigger(ETrigger.ToMove.ToString());
-#endif
+        this.CrossFade(EAnimState.Move, 0.01f, 0);
     }
 
     public void AnimJump()
     {
-#if ANIM_CROSS_FADE
-        m_Animator.CrossFade("Jump", 0.01f);
-#else
-        ResetAllTriggers();
-        SetTrigger(ETrigger.ToJump);
-#endif
+        this.CrossFade(EAnimState.Jump, 0.01f);
     }
 
     public void AnimAirAttack(int id)
     {
         m_Owner.unitCollider.OnAnimationChange();
-#if ANIM_CROSS_FADE
-        m_Animator.CrossFade("AirAttack" + id, 0.05f);
-#else
-        ResetAllTriggers();
-        SetTrigger(ETrigger.ToAirAttack);
-#endif
-    }
+		switch (id)
+		{
+			case 0:
+				this.CrossFade(EAnimState.AirAttack0, 0.05f);
+				break;
+			case 1:
+				this.CrossFade(EAnimState.AirAttack1, 0.05f);
+				break;
+			case 2:
+				this.CrossFade(EAnimState.AirAttack2, 0.05f);
+				break;
+			case 3:
+				this.CrossFade(EAnimState.AirAttack3, 0.05f);
+				break;
+		}
+	}
 
 	public void AnimAttack(int id)
 	{
         m_Owner.unitCollider.OnAnimationChange();
-		m_Animator.CrossFade("Attack" + id, 0.05f);
+		switch (id)
+		{
+			case 0:
+				this.CrossFade(EAnimState.Attack0, 0.05f);
+				break;
+			case 1:
+				this.CrossFade(EAnimState.Attack1, 0.05f);
+				break;
+			case 2:
+				this.CrossFade(EAnimState.Attack2, 0.05f);
+				break;
+			case 3:
+				this.CrossFade(EAnimState.Attack3, 0.05f);
+				break;
+		}
 	}
 
 	public void AnimAirDash()
     {
         if (layers[0].stateInfo.IsName("AirDash"))
         {
-            m_Animator.Play("AirDash", 0, 0);
+            this.Play(EAnimState.AirDash, 0, 0);
         }
         else
         {
-            m_Animator.CrossFade("AirDash", 0.05f);
+            this.CrossFade(EAnimState.AirDash, 0.05f);
         }
     }
 
     public void AnimLanding()
     {
-#if ANIM_CROSS_FADE
-        m_Animator.CrossFade("Landing", 0.05f);
-#else
-        ResetAllTriggers();
-        SetTrigger(ETrigger.ToLanding);
-#endif
+        this.CrossFade(EAnimState.Landing, 0.05f);
     }
 
     public void AnimLandingGround()
     {
-#if ANIM_CROSS_FADE
-        m_Animator.CrossFade("LandingGround", 0.00f);
-#else
-        ResetAllTriggers();
-        SetTrigger(ETrigger.ToLanding);
-#endif
+        this.CrossFade(EAnimState.LandingGround, 0.00f);
     }
 
-#if !ANIM_CROSS_FADE
-    void ResetAllTriggers()
+    private void Play(EAnimState animState, int layerIndex = 0, float normalizedTime = float.NegativeInfinity)
     {
-        var values = Enum.GetValues(typeof(ETrigger));
-        foreach (var e in values)
-        {
-            m_Animator.ResetTrigger(e.ToString());
-        }
-    }
-#endif
+		AnimatorLayerInfo layer = this.layers[layerIndex];
+		if (layer == null)
+			return;
+		layer.OnPlay(animState.ToString(), normalizedTime);
+	}
+
+	public void CrossFade(EAnimState animState, float normalizedTransitionDuration, int layerIndex = 0, float normalizedTimeOffset = float.NegativeInfinity, float normalizedTransitionTime = 0.0f)
+	{
+		AnimatorLayerInfo layer = this.layers[layerIndex];
+		if (layer == null)
+			return;
+		layer.OnCrossFade(animState.ToString(), normalizedTransitionDuration, normalizedTimeOffset, normalizedTransitionTime);
+	}
 
-    private void Play(string animState, float fade = 0.1f, float offset = 0f, int layer = 0)
-    {
-        m_Animator.CrossFade(animState, fade, layer, offset);
-    }
 }
diff --git a/Assets/Scripts/Unit/Components/UnitAnimation/UnitAnimation.cs b/Assets/Scripts/Unit/Components/UnitAnimation/UnitAnimation.cs
index 586bfbaa..f07d9671 100644
--- a/Assets/Scripts/Unit/Components/UnitAnimation/UnitAnimation.cs
+++ b/Assets/Scripts/Unit/Components/UnitAnimation/UnitAnimation.cs
@@ -55,14 +55,14 @@ public class AnimatorLayerInfo
     {
         get
         {
-            AnimatorStateInfo stateInfo = m_Animator.GetCurrentAnimatorStateInfo(layerIndex);
-            AnimatorClipInfo[] clips = m_Animator.GetCurrentAnimatorClipInfo(layerIndex);
-            if(clips == null || clips.Length == 0)
-            {
-                stateInfo = m_Animator.GetNextAnimatorStateInfo(layerIndex);
-            }
-            return stateInfo;
-        }
+			AnimatorStateInfo stateInfo = m_Animator.GetCurrentAnimatorStateInfo(layerIndex);
+			if (isInTransition)
+			{
+				stateInfo = m_Animator.GetNextAnimatorStateInfo(layerIndex);
+			}
+		//	Debug.Assert(stateInfo.IsName(layerName + "." + m_CurrentState));
+			return stateInfo;
+		}
     }
 
     private int preStateHash = -1;
@@ -178,8 +178,13 @@ public class AnimatorLayerInfo
 
 	TimelineEventProxy m_TimelineEventProxy;
 
-	public AnimatorLayerInfo(UnitAnimation unitAnimation, Animator animator, int layer)
+	public string m_CurrentState;
+
+	public readonly string layerName;
+
+	public AnimatorLayerInfo(UnitAnimation unitAnimation, Animator animator, int layer, string layerName)
     {
+		this.layerName = layerName;
         this.m_UnitAnimation = unitAnimation;
         this.m_Animator = animator;
         this.layer = layer;
@@ -219,7 +224,18 @@ public class AnimatorLayerInfo
 		{
 			playbackSpeed = animationData.speedCurve.Evaluate(playbackNormalizedTime);
 		}
+	}
 
+	public void OnCrossFade(string animState, float normalizedTransitionDuration, float normalizedTimeOffset, float normalizedTransitionTime )
+	{
+		m_CurrentState = animState; 
+		m_Animator.CrossFade(animState.ToString(), normalizedTransitionDuration, layerIndex, normalizedTimeOffset, normalizedTransitionTime);
+	}
+
+	public void OnPlay(string animState, float normalizedTime)
+	{
+		m_CurrentState = animState;
+		m_Animator.Play(animState, layerIndex, normalizedTime);
 	}
 
 }