Unity3D自学笔记——有限状态机（一）框架搭建

框架搭建

概念

有限状态机（FSM），即在有限的状态里面进行状态的转移，并执行相应状态下的动作。

状态机主要要素有

1. 当前状态
2. 当前状态下执行的动作
3. 切换到下一个状态的条件
4. 下一个状态

Animator就是一个状态机模型

状态机架构对现有控制模式的改变

拿角色移动举例

现状

    void Update()
    {
       // Move(-Input.GetAxis("Horizontal"), -Input.GetAxis("Vertical"));
    }



    //private void Move(float horizontal, float vertical)
    //{
    //    if (Mathf.Abs(horizontal) > 0.5 || Mathf.Abs(vertical) > 0.5)
    //    {
    //        this.m_Animator.SetBool("IsRun", true);
    //        Rotating(horizontal, vertical);
    //        Vector3 direct = Vector3.zero;
    //        if (m_Controller.isGrounded)
    //        {
    //            direct = new Vector3(transform.forward.x, -1, transform.forward.z);
    //        }
    //        direct.y -= 20 * Time.deltaTime;
    //        m_Controller.Move(direct * speed * Time.deltaTime);
    //    }
    //    else
    //    {
    //        this.m_Animator.SetBool("IsRun", false);
    //    }
    //}

1.PlayerController 监听键盘事件
2.当用户按下前进按钮，执行Move方法

状态机模式
1.FSM监听键盘事件
2.当用户按下前进按钮后，验证是否满足由 Idle 切换至 Move 状态的条件
3.满足后， 当前状态由Idle变为Move，执行Move状态的Action
4.Move状态调用PlayerController的Move方法进行移动

状态机模式的好处

1. 结构清晰，避免程序的复杂性，提高系统的可维护性
2. 方便状态的扩展

状态机模式的坏处

1. 子类会很多

设计

主要有三大类：

• 控制类，用于控制状态的切换，如上图Animator就是一个控制类
• 状态类，表示当前处于的状态，如Idle, Run
• 条件触发类，就是每个状态之间的转换条件，就是上图中的连线

由于状态机不只是控制角色，也可以用来实现敌人的AI，所以再抽象下

实现

Trigger

负责状态切换检测条件是否满足

TriggerType： 唯一标识，枚举类型
HandleEvaluate : 检测条件是否满足

在派生类中具体实现检查方法

public enum FSMTriggerType
{
    CanBeMove,
    IsIdle,
}
public abstract class FSMTrigger
{
    private List<FSMTrigger> m_SubTriggerList = new List<FSMTrigger>();
    public FSMTriggerType TriggerType { get; set; }
    public FSMTrigger()
    {
        Init();
    }

    public abstract void Init();
    /// <summary>
    /// 是否满足状态切换的条件
    /// </summary>
    /// <param name="fsm"></param>
    /// <returns></returns>
    protected abstract bool Evaluate(FSMBase fsm);
    /// <summary>
    /// 检查子条件
    /// </summary>
    /// <param name="fsm"></param>
    /// <returns></returns>
    protected bool CheckSubTriggerList(FSMBase fsm)
    {
        if (this.m_SubTriggerList.Count == 0)
            return true;

        for (int i = 0; i < this.m_SubTriggerList.Count; i++)
        {//子条件全部满足返回真，否则返回假
            if (!this.m_SubTriggerList[i].Evaluate(fsm))
            {
                return false;
            }
        }

        return true;
    }
    public bool HandleEvaluate(FSMBase fsm)
    {
       return Evaluate(fsm);
    }
}

State

TriggerList： 当前状态的触发器
TriggerStateMap：触发器与状态的对应关系
EnterState：进入这个状态要执行的操作
ExitState: 离开状态要执行的操作
Action: 循环执行的操作

public enum FSMStateType
{
    None,
    Default,
    Idle,
    Move,
}
public abstract class FSMState
{
    public FSMStateType StateType { get; set; }
    protected List<FSMTrigger> triggerList = new List<FSMTrigger>();
    protected Dictionary<FSMTriggerType, FSMStateType> triggerStateMap = new Dictionary<FSMTriggerType, FSMStateType>();
    public FSMState()
    {
        InitState();
    }

    public abstract void EnterState(FSMBase fsm);
    public abstract void ExitState(FSMBase fsm);
    public abstract void Action(FSMBase fsm);
    public void CheckTrigger(FSMBase fsm)
    {
        foreach (FSMTrigger trigger in this.triggerList)
        {
            if (trigger.HandleEvaluate(fsm))
                fsm.ChangeActiveState(trigger.TriggerType);
        }
    }
    public abstract void InitState();

    public void AddTrigger(FSMTriggerType triggerType, FSMStateType stateType)
    {
        if (!this.triggerStateMap.ContainsKey(triggerType))
        {
            this.triggerStateMap.Add(triggerType, stateType);
            var type = Type.GetType(triggerType.ToString() + "Trigger");
            if(type != null)
            {
                var trigger = Activator.CreateInstance(type) as FSMTrigger;
                this.triggerList.Add(trigger);
            }
        }
        else
        {
            this.triggerStateMap[triggerType] = stateType;
        }
    }

    public void DeleteTrigger(FSMTriggerType triggerType)
    {
        if (this.triggerStateMap.ContainsKey(triggerType))
        {
            this.triggerStateMap.Remove(triggerType);
            this.triggerList.RemoveAll(x => x.TriggerType == triggerType);
        }
    }

    public FSMStateType GetState(FSMTriggerType triggerType)
    {
        if (this.triggerStateMap.ContainsKey(triggerType))
            return this.triggerStateMap[triggerType];
        else
            return FSMStateType.None;
    }

FSMBase

CurrentState: 记录当前状态
DefaultState: 默认状态
CharacterController : 不是U3D的组件，而是PlayerController的基类，用于实现角色具体执行动作的方法
StateList: 所有状态的集合
Update: 实现轮询监听是否有促发当前状态的切换条件
Config: 配置所有状态的的切换关系
ChangeActiveState: 切换状态

[RequireComponent(typeof(AliCharacterController))]
[RequireComponent(typeof(CharacterStatus))]
[RequireComponent(typeof(CharacterAnimationManager))]
public abstract class FSMBase : MonoBehaviour
{
    public CharacterStatus CharacterStatus { get; private set;}
    public AliCharacterController Controller { get; private set; }
    private CharacterAnimationManager m_AnimManger;
    private List<FSMState> m_StateList;
    private FSMState m_StateCur;
    private FSMState m_StateDft;
    public FSMStateType CurrentStateType;
    public FSMStateType DefaultStateType;

    void Awake()
    {
        this.m_StateList = new List<FSMState>();
    }

    void Start()
    {
        this.CharacterStatus = this.GetComponent<CharacterStatus>();
        this.m_AnimManger = this.GetComponent<CharacterAnimationManager>();
        this.Controller = this.GetComponent<AliCharacterController>();
        ConfigFSM();
        InitDefaultState();
    }

    void Update()
    {
        if(this.m_StateCur != null)
        {
            this.m_StateCur.Action(this);
            this.m_StateCur.CheckTrigger(this);
        }
    }

    private void InitDefaultState()
    {
        this.m_StateDft = this.m_StateList.Find(x => x.StateType == DefaultStateType);
        this.m_StateCur = this.m_StateDft;
        this.CurrentStateType = this.m_StateCur.StateType;
        this.m_StateCur.EnterState(this);
    }

    public abstract void ConfigFSM();

    public void AddState(FSMState state)
    {
        if(!this.m_StateList.Exists(x => x.StateType == state.StateType))
        {
            this.m_StateList.Add(state);
        }
    }
    public void RemoveState(FSMState state)
    {
        this.m_StateList.Remove(state);
    }
    public void ChangeActiveState(FSMTriggerType triggerType)
    {
        if (this.m_StateCur == null)
            return;

        FSMStateType stateType = this.m_StateCur.GetState(triggerType);
        if (stateType == FSMStateType.None)
            return;
        this.m_StateCur.ExitState(this);
        if (stateType == FSMStateType.Default)
            this.m_StateCur = this.m_StateDft;
        else
            this.m_StateCur = this.m_StateList.Find(x => x.StateType == stateType);

        this.CurrentStateType = this.m_StateCur.StateType;
        this.m_StateCur.EnterState(this);
    }

    public void PlayAnimation(string paramName)
    {
        this.m_AnimManger.PlayAnimation(paramName);
    }
}

其他相关类

角色控制基类

public abstract class AliCharacterController : MonoBehaviour
{
    public float rotaionSpeed = 0.5f;
    private CharacterController m_Controller;
    protected CharacterStatus m_Status;

    protected virtual void Start()
    {
        this.m_Controller = this.GetComponent<CharacterController>();
        this.m_Status = this.GetComponent<CharacterStatus>();
    }

    public abstract void Move();

    protected void Move(Vector3 target, float speed)
    {
        Rotating(target.x, target.z);

        Vector3 direct = Vector3.zero;
        if (m_Controller.isGrounded)
        {
            direct = new Vector3(transform.forward.x, -1, transform.forward.z);
        }
        direct.y -= 20 * Time.deltaTime;
        this.m_Controller.Move(direct * speed * Time.deltaTime);
    }

    protected void Rotating(float horizontal, float vertical)
    {
        var targetDirection = new Vector3(horizontal, 0, vertical);
        var targetRotation = Quaternion.LookRotation(targetDirection, Vector3.up);
        this.transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, this.rotaionSpeed);
    }
}

动画参数常量

public class AnimationParameters
{
    public static string Idle = "Idle";
    public static string Move = "Move";
    public static string Attck = "Attack";
}

动画管理基类

public abstract class CharacterAnimationManager: MonoBehaviour
{
    private Animator m_Anim;
    private bool m_IsAttack;
    private string m_AnimCur;

    void Start()
    {
        this.m_Anim = GetComponent<Animator>();
        this.m_AnimCur = "Idle";
    }

    public void PlayAnimation(string paraName)
    {
        if (paraName.Contains("Attack"))
        {
            this.m_IsAttack = true;
        }

        this.m_Anim.SetBool(m_AnimCur, false);
        this.m_Anim.SetBool(paraName, true);
        this.m_AnimCur = paraName;
    }
}