*改变目录结构

1 files changed, 460 insertions, 0 deletions

diff --git a/Assets/Scripts/Unit/Components/UnitState/PCState.cs b/Assets/Scripts/Unit/Components/UnitState/PCState.cs
new file mode 100644
index 00000000..f6eb7045
--- /dev/null
+++ b/Assets/Scripts/Unit/Components/UnitState/PCState.cs
@@ -0,0 +1,460 @@
+using System;
+using System.Reflection;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+// 角色状态机
+[DisallowMultipleComponent]
+public class PCState : UnitState
+{
+    public enum EUnitState
+    {
+        Nien,
+
+        Idle,
+        Move,
+        Spawn,
+        Die,
+        Dead,
+        // 
+        Attack,
+        AirAttack,
+        AirDash,
+        // 		  
+        HitAir,
+        HitAirHit,
+        Knockdown,
+        //		  
+        HitGuard,
+        //		  
+        Walk,
+        // 		  
+        Rise,
+        // 		  
+        Jump,
+        // 转身   
+        Turn,
+        Landing,   // 从空中降落
+    }
+
+    [SerializeField] private EUnitState m_State;
+    public EUnitState CurrentState { get { return m_State; } }
+
+    public override void Initialize()
+    {
+        base.Initialize();
+    }
+
+    PCAnimation pcAnimation { get { return m_Owner.pcAnimation; } }
+
+    #region state param
+    public struct IdleParam { }
+
+    public struct MoveParam
+    {
+        public bool isRight;
+        public string key;
+    }
+
+    public struct SkillParam
+    {
+
+    }
+
+    public struct AirDashParam
+    {
+
+    }
+
+    public struct JumpParam
+    { }
+
+    public struct TurnParam
+    {
+        EUnitState nextState;
+    }
+
+    public struct LandingParam { }
+
+    #endregion  
+    public void ChangeState<T>(EUnitState nextState, T param = default, bool bForce = false)
+    {
+        if (!IsChange(nextState, bForce))
+            return;
+
+        LogHelper.Log("UnitState: " + m_State.ToString() + " -> " + nextState.ToString());
+
+        StopAllCoroutines();
+
+        EUnitState prevState = m_State;
+        string methodFunc = "On" + m_State.ToString() + "Exit";
+        MethodInfo exitMethod = GetType().GetMethod(methodFunc, BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[] { typeof(EUnitState) }, null);
+        if (exitMethod != null)
+        {
+            exitMethod.Invoke(this, new object[] { nextState });
+        }
+        else
+        {
+            LogHelper.LogError("缺少 " + methodFunc);
+        }
+        m_State = nextState;
+
+        StartCoroutine(m_State.ToString(), param);
+    }
+
+    bool IsChange(EUnitState newState, bool bForce)
+    {
+        if (newState != m_State || bForce)
+            return true;
+        return false;
+    }
+
+    IEnumerator Nein() { yield break; }
+    void OnNienExit(EUnitState nextState) { }
+
+    public void TurnAround(bool bRight)
+    {
+        m_Owner.transform.rotation = Quaternion.Euler(0, bRight ? 0 : 180, 0);
+    }
+
+    public void TurnLeft()
+    {
+        TurnAround(false);
+    }
+
+    public void TurnRight()
+    {
+        TurnAround(true);
+    }
+
+    #region Idle
+
+    IEnumerator Idle(IdleParam param)
+    {
+        //if (m_Owner.isInAir) // 浮空切换到landing
+        //{
+        //    ChangeState(EUnitState.Landing, new LandingParam());
+        //}
+        //else // idle
+        //{
+            m_Owner.SetYPosition(0);
+            m_Owner.pcAnimation.AnimIdle();
+            while (true)
+            {
+				if (Input.GetKeyDown("j"))
+				{
+					ChangeState(EUnitState.Attack, new SkillParam());
+				}
+				if (Input.GetKeyDown("space"))
+                {
+                    ChangeState(EUnitState.Jump, new JumpParam());
+                }
+                if (Input.GetKey("d"))
+                {
+                    MoveParam move = new MoveParam();
+                    move.isRight = true;
+                    move.key = "d";
+                    ChangeState(EUnitState.Move, move);
+                }
+                if (Input.GetKey("a"))
+                {
+                    MoveParam move = new MoveParam();
+                    move.isRight = false;
+                    move.key = "a";
+                    ChangeState(EUnitState.Move, move);
+                }
+                yield return null;
+            }
+        //}
+    }
+
+    void OnIdleExit(EUnitState nextState)
+    {
+    }
+    #endregion
+
+    #region Move 
+    IEnumerator Move(MoveParam param)
+    {
+        if (m_Owner.isTowardRight && !param.isRight
+        || !m_Owner.isTowardRight && param.isRight)
+        {
+            //m_Owner.pcAnimation.Play(UnitAnimation.EAnimState.Turn);
+            //yield return new WaitForActionReachEnd(m_Owner.pcAnimation);
+            //if (param.isRight)
+            //	m_Owner.transform.rotation = Quaternion.Euler(0, 0, 0);
+            //else
+            //	m_Owner.transform.rotation = Quaternion.Euler(0, 180, 0);
+            m_Owner.transform.rotation = Quaternion.Euler(0, param.isRight ? 0 : 180, 0);
+        }
+        //if (Input.GetKey(param.key))
+        m_Owner.pcAnimation.AnimMove();
+        while (Input.GetKey(param.key))
+        {
+            yield return null;
+        }
+        ChangeState(EUnitState.Idle, new IdleParam());
+    }
+
+    void OnMoveExit(EUnitState nextState)
+    {
+        m_Owner.pcAnimation.animator.ResetTrigger("ToMove");
+    }
+
+	#endregion
+
+	#region Attack
+
+	IEnumerator Attack(SkillParam param)
+	{
+		const int total = 3;
+		int id = 0;
+		m_Owner.pcAnimation.AnimAttack(id);
+		yield return null;
+		while (true)
+		{
+			bool canCombo = m_Owner.pcAnimation.layers[0].IsToggleOpen(EAnimationToogle.Combo);
+			if (canCombo)
+			{
+				if (Input.GetKeyDown("j"))
+				{
+					if (Input.GetKey("a"))
+					{
+						TurnAround(false);
+					}
+					if (Input.GetKey("d"))
+					{
+						TurnAround(true);
+					}
+					++id;
+					m_Owner.pcAnimation.AnimAttack(id);
+					yield return null; // 等待animator更新
+					yield return new WaitForTransitionDone(m_Owner.pcAnimation);
+				}
+			}
+
+			bool reachEnd = m_Owner.pcAnimation.layers[0].playbackNormalizedTime == 1;
+			if (reachEnd)
+			{
+				ChangeState(EUnitState.Idle, new IdleParam());
+			}
+
+			yield return null;
+		}
+	}
+
+    void OnAttackExit(EUnitState next)
+    {
+    }
+
+    #endregion
+
+    #region AirAttack 
+
+    IEnumerator AirAttack(SkillParam param)
+    {
+        int id = 0;
+        m_Owner.pcAnimation.AnimAirAttack(id);
+        yield return null; // 等待animator更新
+        while (true)
+        {
+            bool canCombo = m_Owner.pcAnimation.layers[0].IsToggleOpen(EAnimationToogle.Combo);
+            if (canCombo)
+            {
+                if (InputManager.Instance.TryCommand(0.5f, KeyCode.A, KeyCode.A))
+                {
+                    TurnLeft();
+                    ChangeState(EUnitState.AirDash, new AirDashParam());
+                }
+                if (InputManager.Instance.TryCommand(0.5f, KeyCode.D, KeyCode.D))
+                {
+                    TurnRight();
+                    ChangeState(EUnitState.AirDash, new AirDashParam());
+                }
+
+                if (Input.GetKeyDown("j"))
+                {
+                    if (Input.GetKey("a"))
+                    {
+                        TurnAround(false);
+                    }
+                    if (Input.GetKey("d"))
+                    {
+                        TurnAround(true);
+                    }
+                    ++id;
+                    m_Owner.pcAnimation.AnimAirAttack(id);
+                    yield return null; // 等待animator更新
+                    yield return new WaitForTransitionDone(m_Owner.pcAnimation);
+                }
+            }
+
+            bool reachEnd = m_Owner.pcAnimation.layers[0].playbackNormalizedTime == 1;
+            if (reachEnd)
+            {
+                ChangeState(EUnitState.Landing, new LandingParam());
+            }
+
+            yield return null;
+        }
+    }
+
+    void OnAirAttackExit(EUnitState next)
+    {
+
+    }
+
+    #endregion
+
+    #region AirDash  
+
+    IEnumerator AirDash(AirDashParam param)
+    {
+        m_Owner.pcAnimation.AnimAirDash();
+        yield return null;
+        while (true)
+        {
+            bool reachEnd = m_Owner.pcAnimation.layers[0].playbackNormalizedTime == 1;
+            if (reachEnd)
+            {
+                ChangeState(EUnitState.Landing, new LandingParam());
+            }
+
+            bool canCombo = m_Owner.pcAnimation.layers[0].IsToggleOpen(EAnimationToogle.Combo);
+            if (canCombo)
+            {
+                if (InputManager.Instance.TryCommand(0.5f, KeyCode.A, KeyCode.A))
+                {
+                    TurnLeft();
+                    m_Owner.pcAnimation.AnimAirDash();
+                }
+                if (InputManager.Instance.TryCommand(0.5f, KeyCode.D, KeyCode.D))
+                {
+                    TurnRight();
+                    m_Owner.pcAnimation.AnimAirDash();
+                }
+
+                if (Input.GetKeyDown("j"))
+                {
+                    if (Input.GetKey("a"))
+                    {
+                        TurnAround(false);
+                    }
+                    if (Input.GetKey("d"))
+                    {
+                        TurnAround(true);
+                    }
+                    ChangeState(EUnitState.AirAttack, new SkillParam());
+                }
+            }
+
+            yield return null;
+        }
+    }
+
+    void OnAirDashExit(EUnitState next)
+    {
+    }
+
+    #endregion
+
+    #region Jump 
+
+    IEnumerator Jump(JumpParam param)
+    {
+        pcAnimation.AnimJump();
+        yield return null;
+        yield return new WaitForTransitionDone(pcAnimation);
+        while (true)
+        {
+            if (InputManager.Instance.TryCommand(0.5f, KeyCode.A, KeyCode.A))
+            {
+                TurnLeft();
+                ChangeState(EUnitState.AirDash, new AirDashParam());
+            }
+            if (InputManager.Instance.TryCommand(0.5f, KeyCode.D, KeyCode.D))
+            {
+                TurnRight();
+                ChangeState(EUnitState.AirDash, new AirDashParam());
+            }
+            if (pcAnimation.layers[0].playbackNormalizedTime >= 1)
+                ChangeState(EUnitState.Idle, new IdleParam());
+            bool canAttack = m_Owner.pcAnimation.layers[0].IsToggleOpen(EAnimationToogle.Combo);
+            if (Input.GetKeyDown("j") && canAttack)
+            {
+                ChangeState(EUnitState.AirAttack, new SkillParam());
+            }
+            yield return null;
+        }
+    }
+
+    void OnJumpExit(EUnitState next)
+    {
+    }
+
+    #endregion
+
+    #region Landing
+
+    IEnumerator Landing(LandingParam param)
+    {
+        m_Owner.pcAnimation.AnimLanding();
+        yield return null;
+        yield return new WaitForTransitionDone(m_Owner.pcAnimation);
+        float vy = 2;
+        float g = 9.8f;
+        bool landingGround = false;
+        float vz = 5;
+        while (true)
+        {
+            Vector3 pos = m_Owner.transform.position;
+            vy += g * Time.deltaTime;
+            pos.y -= vy * Time.deltaTime;
+            pos.y = Mathf.Max(0, pos.y);
+            if (Input.GetKey("a"))
+            {
+                TurnAround(false);
+                pos.x -= vz * Time.deltaTime;
+            }
+            if (Input.GetKey("d"))
+            {
+                TurnAround(true);
+                pos.x += vz * Time.deltaTime;
+            }
+            m_Owner.transform.position = pos;
+            if (pos.y > 0 && pos.y <= 1 && !landingGround)
+            {
+                landingGround = true;
+                m_Owner.pcAnimation.AnimLandingGround();
+            }
+            if (pos.y <= 0)
+            {
+                pos.y = 0;
+                m_Owner.transform.position = pos;
+                ChangeState(EUnitState.Idle, new IdleParam());
+            }
+
+            if (InputManager.Instance.TryCommand(0.5f, KeyCode.A, KeyCode.A))
+            {
+                TurnLeft();
+                ChangeState(EUnitState.AirDash, new AirDashParam());
+            }
+            if (InputManager.Instance.TryCommand(0.5f, KeyCode.D, KeyCode.D))
+            {
+                TurnRight();
+                ChangeState(EUnitState.AirDash, new AirDashParam());
+            }
+
+            yield return null;
+        }
+    }
+
+    void OnLandingExit(EUnitState next)
+    {
+    }
+
+    #endregion
+
+}
+ 
\ No newline at end of file