C# Unity FSM 状态机
使用状态机可以降低代码耦合性，并且可以优化代码可读性，方便团队协作等。
对于游戏开发内容来讲游戏开发的流程控制玩家动画都可以使用FSM有限状态机来实现。
1.FsmState
每个状态的基类，泛型参数表示所拥有者
public abstract class FsmState<T> where T : class
{
protected internal abstract void OnInit(IFsm<T> fsm);
protected internal abstract void OnEnter(IFsm<T> fsm);
protected internal abstract void OnUpdate(IFsm<T> fsm);
protected internal abstract void OnLeave(IFsm<T> fsm);
protected internal abstract void OnDestroy(IFsm<T> fsm);
protected void ChangeState<TState>(IFsm<T> fsm) where TState : FsmState<T>
{
Fsm<T> fsmImplement = (Fsm<T>)fsm;
if(fsmImplement == null)
{
throw new Exception("FSM is invalid.");
}
fsmImplement.ChangeState<TState>();
}
protected void ChangeState(IFsm<T> fsm, Type stateType)
{
Fsm<T> fsmImplement = (Fsm<T>)fsm;
if (fsmImplement == null)
{
throw new Exception("FSM is invalid.");
}
if (stateType == null)
{
throw new Exception("State type is invalid.");
}
if (!typeof(FsmState<T>).IsAssignableFrom(stateType))
{
throw new Exception("State type is invalid.");
}
fsmImplement.ChangeState(stateType);
}
}
2.IFsm
有限状态机的接口
public interface IFsm<T> where T : class
{
string Name
{
get;
}
string FullName
{
get;
}
T Owner
{
get;
}
int FsmStateCount
{
get;
}
bool IsRunning
{
get;
}
bool IsDestroyed
{
get;
}
FsmState<T> CurrentState
{
get;
}
float CurrentStateTime
{
get;
}
void Start<TState>() where TState : FsmState<T>;
bool HasState<TState>() where TState : FsmState<T>;
TState GetState<TState>() where TState : FsmState<T>;
FsmState<T> GetState(Type stateType);
FsmState<T>[] GetAllStates();
}
3.IFsmManager
有限状态机管理器接口
public interface IFsmManager
{
int Count {
get; }
bool HasFsm<T>() where T : class;
bool HasFsm(Type ownerType);
bool HasFsm<T>(string name) where T : class;
bool HasFsm(Type ownerType, string name);
IFsm<T> GetFsm<T>() where T : class;
IFsm<T> GetFsm<T>(string name) where T : class;
IFsm<T> CreateFsm<T>(T owner, params FsmState<T>[] fsmStates) where T : class;
IFsm<T> CreateFsm<T>(string name, T owner, params FsmState<T>[] states) where T : class;
IFsm<T> CreateFsm<T>(T owner, List<FsmState<T>> states) where T : class;
IFsm<T> CreateFsm<T>(string name, T owner, List<FsmState<T>> states) where T : class;
bool DestroyFsm<T>() where T : class;
bool DestroyFsm(Type ownerType);
bool DestroyFsm<T>(string name) where T : class;
bool DestroyFsm(Type ownerType, string name);
bool DestroyFsm<T>(IFsm<T> fsm) where T : class;
}
4.FsmBase
有限状态机的基类
public abstract class FsmBase
{
private string m_Name;
public FsmBase()
{
m_Name = string.Empty;
}
public string Name
{
get
{
return m_Name;
}
protected set
{
m_Name = value ?? string.Empty;
}
}
public string FullName
{
get
{
return $"{
OwnerType.FullName}.{
Name}";
}
}
public abstract Type OwnerType
{
get;
}
public abstract int FsmStateCount
{
get;
}
public abstract bool IsRunning
{
get;
}
public abstract bool IsDestroyed
{
get;
}
public abstract string CurrentStateName
{
get;
}
public abstract float CurrentStateTime
{
get;
}
public abstract void Update();
public abstract void Shutdown();
}
5.Fsm
状态机类
public class Fsm<T> : FsmBase, IFsm<T> where T : class
{
private T m_Owner;
private readonly Dictionary<Type, FsmState<T>> m_States;
private FsmState<T> m_CurrentState;
private float m_CurrentStateTime;
private bool m_IsDestroyed;
public Fsm()
{
m_Owner = null;
m_States = new Dictionary<Type, FsmState<T>>();
m_CurrentState = null;
m_CurrentStateTime = 0f;
m_IsDestroyed = true;
}
public T Owner => m_Owner;
public FsmState<T> CurrentState => m_CurrentState;
public override Type OwnerType => typeof(T);
public override int FsmStateCount => m_States.Count;
public override bool IsRunning => m_CurrentState != null;
public override bool IsDestroyed => m_IsDestroyed;
public override string CurrentStateName => m_CurrentState != null ? m_CurrentState.GetType().FullName : null;
public override float CurrentStateTime => m_CurrentStateTime;
public static Fsm<T> Create(string name,T owner,params FsmState<T>[] states)
{
if(owner == null)
{
throw new Exception("FSM owner is invalid.");
}
if(states== null|| states.Length < 1)
{
throw new Exception("FSM states is invalid.");
}
Fsm<T> fsm = Pool<Fsm<T>>.Rent();
fsm.Name = name;
fsm.m_Owner = owner;
fsm.m_IsDestroyed = false;
foreach (FsmState<T> oneState in states)
{
if(oneState == null)
{
throw new Exception("FSM states is invalid.");
}
Type stateType = oneState.GetType();
if (fsm.m_States.ContainsKey(stateType))
{
throw new Exception($"{
stateType} state is already exist");
}
fsm.m_States.Add(stateType, oneState);
oneState.OnInit(fsm);
}
return fsm;
}
public static Fsm<T> Create(string name,T owner,List<FsmState<T>> states)
{
if (owner == null)
{
throw new Exception("FSM owner is invalid.");
}
if (states == null || states.Count < 1)
{
throw new Exception("FSM states is invalid.");
}
Fsm<T> fsm = Pool<Fsm<T>>.Rent();
fsm.Name = name;
fsm.m_Owner = owner;
fsm.m_IsDestroyed = false;
foreach (FsmState<T> oneState in states)
{
if (oneState == null)
{
throw new Exception("FSM states is invalid.");
}
Type stateType = oneState.GetType();
if (fsm.m_States.ContainsKey(stateType))
{
throw new Exception($"{
stateType} state is already exist");
}
fsm.m_States.Add(stateType, oneState);
oneState.OnInit(fsm);
}
return fsm;
}
public FsmState<T>[] GetAllStates()
{
int index = 0;
FsmState<T>[] arr = new FsmState<T>[m_States.Count];
foreach (FsmState<T> fsmState in m_States.Values)
{
arr[index++] = fsmState;
}
return arr;
}
public bool HasState<TState>() where TState : FsmState<T>
{
return m_States.ContainsKey(typeof(TState));
}
public override void Shutdown()
{
Pool<Fsm<T>>.Return(this, (fsm) =>
{
if(m_CurrentState != null)
{
m_CurrentState.OnLeave(this);
}
foreach (FsmState<T> oneState in m_States.Values)
{
oneState.OnDestroy(this);
}
Name = null;
m_Owner = null;
m_States.Clear();
m_CurrentState = null;
m_CurrentStateTime = 0f;
m_IsDestroyed = true;
});
}
public void Start<TState>() where TState : FsmState<T>
{
if (IsRunning)
{
throw new Exception("FSM is running, can not start again.");
}
FsmState<T> state = GetState<TState>();
if (state == null)
{
throw new Exception("can not start state");
}
m_CurrentStateTime = 0f;
m_CurrentState = state;
m_CurrentState.OnEnter(this);
}
public void Start(Type stateType)
{
if (IsRunning)
{
throw new Exception("FSM is running, can not start again.");
}
if (stateType == null)
{
throw new Exception("State type is invalid.");
}
if (!typeof(FsmState<T>).IsAssignableFrom(stateType))
{
throw new Exception("State type is invalid.");
}
FsmState<T> state = GetState(stateType);
if (state == null)
{
throw new Exception("FSM can not start state which is not exist.");
}
m_CurrentStateTime = 0f;
m_CurrentState = state;
m_CurrentState.OnEnter(this);
}
public override void Update()
{
m_CurrentStateTime += Time.deltaTime;
m_CurrentState.OnUpdate(this);
}
public TState GetState<TState>() where TState : FsmState<T>
{
if (m_States.TryGetValue(typeof(TState), out FsmState<T> fsmState))
{
return (TState)fsmState;
}
return null;
}
public FsmState<T> GetState(Type stateType)
{
if (stateType == null)
{
throw new Exception("State type is invalid.");
}
if (!typeof(FsmState<T>).IsAssignableFrom(stateType))
{
throw new Exception("State type is invalid.");
}
if (m_States.TryGetValue(stateType, out FsmState<T> fsmState))
{
return fsmState;
}
return null;
}
public void ChangeState<TState>()
{
ChangeState(typeof(TState));
}
public void ChangeState(Type stateType)
{
if (m_CurrentState == null)
{
throw new Exception("Current state is invalid.");
}
FsmState<T> state = GetState(stateType);
if (state == null)
{
throw new Exception("FSM can not change state which is not exist.");
}
m_CurrentState.OnLeave(this);
m_CurrentStateTime = 0f;
m_CurrentState = state;
m_CurrentState.OnEnter(this);
}
}
6.FsmManager
状态机管理器
public class FsmManager : Singleton<FsmManager>,IFsmManager,IUpdateSingleton
{
private readonly Dictionary<string, FsmBase> m_FsmDic;
private readonly List<FsmBase> m_TempFsms;
public FsmManager()
{
m_FsmDic = new Dictionary<string, FsmBase>();
m_TempFsms = new List<FsmBase>();
}
public int Count => m_FsmDic.Count;
public IFsm<T> CreateFsm<T>(T owner, params FsmState<T>[] fsmStates) where T : class
{
return CreateFsm(string.Empty, owner, fsmStates);
}
public IFsm<T> CreateFsm<T>(string name, T owner, params FsmState<T>[] states) where T : class
{
if (HasFsm<T>(name))
{
throw new Exception("Already exist FSM");
}
Fsm<T> fsm = Fsm<T>.Create(name, owner, states);
m_FsmDic.Add(fsm.FullName, fsm);
return fsm;
}
public IFsm<T> CreateFsm<T>(T owner, List<FsmState<T>> states) where T : class
{
return CreateFsm(string.Empty, owner, states);
}
public IFsm<T> CreateFsm<T>(string name, T owner, List<FsmState<T>> states) where T : class
{
if (HasFsm<T>(name))
{
throw new Exception("Already exist FSM");
}
Fsm<T> fsm = Fsm<T>.Create(name, owner, states);
m_FsmDic.Add(fsm.FullName, fsm);
return fsm;
}
public bool DestroyFsm<T>() where T : class
{
return InternalDestroyFsm($"{
typeof(T).FullName}.{
string.Empty}");
}
public bool DestroyFsm(Type ownerType)
{
if (ownerType == null)
{
throw new Exception("Owner type is invalid.");
}
return InternalDestroyFsm($"{
ownerType.FullName}.{
string.Empty}");
}
public bool DestroyFsm<T>(string name) where T : class
{
return InternalDestroyFsm($"{
typeof(T).FullName}.{
name}");
}
public bool DestroyFsm(Type ownerType, string name)
{
if (ownerType == null)
{
throw new Exception("Owner type is invalid.");
}
return InternalDestroyFsm($"{
ownerType.FullName}.{
name}");
}
public bool DestroyFsm<T>(IFsm<T> fsm) where T : class
{
if (fsm == null)
{
throw new Exception("FSM is invalid.");
}
return InternalDestroyFsm(fsm.FullName);
}
public IFsm<T> GetFsm<T>() where T : class
{
return (IFsm<T>)InternalGetFsm($"{
typeof(T).FullName}.{
string.Empty}");
}
public IFsm<T> GetFsm<T>(string name) where T : class
{
return (IFsm<T>)InternalGetFsm($"{
typeof(T).FullName}.{
name}");
}
public bool HasFsm<T>() where T : class
{
return InternalHasFsm($"{
typeof(T).FullName}.{
string.Empty}");
}
public bool HasFsm(Type ownerType)
{
if(ownerType == null)
{
throw new Exception("Owner type is invalid.");
}
return InternalHasFsm($"{
ownerType.FullName}.{
string.Empty}");
}
public bool HasFsm<T>(string name) where T : class
{
return InternalHasFsm($"{
typeof(T).FullName}.{
name}");
}
public bool HasFsm(Type ownerType, string name)
{
if (ownerType == null)
{
throw new Exception("Owner type is invalid.");
}
return InternalHasFsm($"{
ownerType.FullName}.{
name}");
}
private bool InternalDestroyFsm(string name)
{
if(m_FsmDic.TryGetValue(name,out FsmBase fsmBase))
{
fsmBase.Shutdown();
return m_FsmDic.Remove(name);
}
return false;
}
private FsmBase InternalGetFsm(string name)
{
FsmBase fsm = null;
if (m_FsmDic.TryGetValue(name, out fsm))
{
return fsm;
}
return null;
}
private bool InternalHasFsm(string name)
{
return m_FsmDic.ContainsKey(name);
}
public void Update()
{
m_TempFsms.Clear();
if (m_FsmDic.Count <= 0)
return;
foreach (FsmBase fsmBase in m_FsmDic.Values)
{
m_TempFsms.Add(fsmBase);
}
foreach (FsmBase fsmBase in m_TempFsms)
{
if (fsmBase.IsDestroyed)
continue;
fsmBase.Update();
}
}
protected override void Load(int assemblyName)
{
}
protected override void UnLoad(int assemblyName)
{
}
}
7.测试
（一）IdleState
public class IdleState : FsmState<FsmTest>
{
protected internal override void OnDestroy(IFsm<FsmTest> fsm)
{
Debug.Log("销毁 IdleState");
}
protected internal override void OnEnter(IFsm<FsmTest> fsm)
{
Debug.Log("进入 IdleState");
}
protected internal override void OnInit(IFsm<FsmTest> fsm)
{
}
protected internal override void OnLeave(IFsm<FsmTest> fsm)
{
Debug.Log("离开 IdleState");
}
protected internal override void OnUpdate(IFsm<FsmTest> fsm)
{
if (Input.GetKeyDown(KeyCode.A))
{
ChangeState<WalkState>(fsm);
}
}
}
（二）WalkState
public class WalkState : FsmState<FsmTest>
{
protected internal override void OnDestroy(IFsm<FsmTest> fsm)
{
Debug.Log("销毁 WalkState");
}
protected internal override void OnEnter(IFsm<FsmTest> fsm)
{
Debug.Log("进入 WalkState");
}
protected internal override void OnInit(IFsm<FsmTest> fsm)
{
}
protected internal override void OnLeave(IFsm<FsmTest> fsm)
{
Debug.Log("离开 WalkState");
}
protected internal override void OnUpdate(IFsm<FsmTest> fsm)
{
if (Input.GetKeyDown(KeyCode.B))
{
ChangeState<RunState>(fsm);
}
}
}
（三）RunState
public class RunState : FsmState<FsmTest>
{
protected internal override void OnDestroy(IFsm<FsmTest> fsm)
{
Debug.Log("销毁 RunState");
}
protected internal override void OnEnter(IFsm<FsmTest> fsm)
{
Debug.Log("进入 RunState");
}
protected internal override void OnInit(IFsm<FsmTest> fsm)
{
}
protected internal override void OnLeave(IFsm<FsmTest> fsm)
{
Debug.Log("离开 RunState");
}
protected internal override void OnUpdate(IFsm<FsmTest> fsm)
{
if (Input.GetKeyDown(KeyCode.C))
{
ChangeState<IdleState>(fsm);
}
}
}
mono测试
public class FsmTest : MonoBehaviour
{
private IFsm<FsmTest> m_TestFsm;
void Start()
{
SingletonSystem.Initialize();
AssemblyManager.Load(1, GetType().Assembly);
m_TestFsm = FsmManager.Instance.CreateFsm<FsmTest>("MyTestFsm",this, new IdleState(),new WalkState(),new RunState());
m_TestFsm.Start<IdleState>();
}
void Update()
{
SingletonSystem.Update();
if (Input.GetKeyDown(KeyCode.P))
{
FsmManager.Instance.DestroyFsm(m_TestFsm);
}
}
}