U3d架构系列之-FSM有限状态机设计

来源：互联网发布：淘宝网商城首页编辑：程序博客网时间：2024/04/30 11:51

出处http://jxwgame.blog.51cto.com/943299/1608980

我们在游戏开发中经常面临架构设计问题，在蛮牛问答里面也有好多朋友问关于架构方面的问题，在这里我就将一些经常使用的游戏开发方面的知识跟大家介绍一下，一是给大家提供一个设计思路，在此基础上可以举一反三，二是大家可以通过这个平台共同学习。闲话不多说了，切入正题，FSM有限状态机，在游戏开发中如何使用？那些模块的设计需要它？接下来我们就分析一下游戏：

比如我们的玩家自身的状态切换，Idle，walk，attack等等，这些都属于状态的切换，可以用有限状态机；还有比如玩家去完任务：领取任务，杀怪，交易，交接任务；还有界面逻辑比如登录，进入场景，退出等等，在游戏中状态切换还是很多的，以上我说的都可以使用有限状态机。既然这么多地方可以使用，那么我们如何去设计有限状态机？

下面我们先设计我们的FSM有限状态机类图，如下所示：

在这里我的优先状态机，共五个类文件组成。下面就给大家一一说明：

第一个是IState类，这个类是抽象的，主要是实现有限状态机的接口，书写如下：

1
2
3
4
5
6
7
8
using UnityEngine;
using System.Collections;
 
public interface IState {
    void OnEnter(string prevState);
    void OnExit(string nextState);
    void OnUpdate();
}

这个抽象类一共只有三个接口，一个是进入状态，停止状态，更新状态。

在设计一中，我们把IState类设计了一下，接下来，我们写一下FiniteStateMachine这个类，这个类主要的作用就是对于外界调用，这个类是独立封装的，不继承Mono。这个类的功能是提供一个栈，用于存放FSState，还有通过Update进行状态的切换，以及对栈的管理，Pop和Push操作以及状态的注册。最重要的一点是声明了三个委托函数代码如下：

1
2
3
4
5
public delegate void EnterState(string stateName);
 
 public delegate void PushState(string stateName, string lastStateName);
 
 public delegate void PopState();

主要是用于状态之间的切换。定义了Dictionary和Stack，前者用于State注册，后者是状态切换。代码如下：

1
2
3
protected Dictionary<string, FSState> mStates;
 
 protected Stack<FSState>    mStateStack;

对应的相关处理函数如下：

1
2
3
4
5
6
7
8
9
public void Register(string stateName, IState stateObject) {
 
   if (mStates.Count == 0)
 
    mEntryPoint = stateName;
 
   mStates.Add(stateName, new FSState(stateObject, this, stateName, Enter, Push, Pop));
 
 }

用于状态机的注册，对Stack的操作是如下两个函数，一个是Pop，一个是Push函数。代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public void Push(string newState) {
  string lastName = null;
  if (mStateStack.Count > 1) {
   lastName = mStateStack.Peek().StateName;
  }
  Push(newState, lastName);
 }
 protected void Push(string stateName, string lastStateName) {
  mStateStack.Push(mStates[stateName]);
  mStateStack.Peek().StateObject.OnEnter(lastStateName);
 }
 public void Pop() {
  Pop(null);
 }
 protected string Pop(string newName) {
  FSState lastState = mStateStack.Peek();
  string newState = null;
  if (newName == null && mStateStack.Count > 1) {
   int index = 0;
   foreach (FSState item in mStateStack) {
    if (index++ == mStateStack.Count - 2) {
     newState = item.StateName;
    }
   }
  }
  else {
   newState = newName;
  }
  string lastStateName = null;
  if (lastState != null) {
   lastStateName = lastState.StateName;
   lastState.StateObject.OnExit(newState);
  }
  mStateStack.Pop();
  return lastStateName;
 }

下面增加了状态触发消息事件，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void Trigger(string eventName) {
  CurrentState.Trigger(eventName);
 }
 public void Trigger(string eventName, object param1) {
  CurrentState.Trigger(eventName, param1);
 }
  
 public void Trigger(string eventName, object param1, object param2) {
  CurrentState.Trigger(eventName, param1, param2);
 }
  
 public void Trigger(string eventName, object param1, object param2, object param3) {
  CurrentState.Trigger(eventName, param1, param2, param3);
 }

最后把FiniteStateMachine核心的功能给大家介绍完了，下面奉上整个类的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class FiniteStateMachine {
 public delegate void EnterState(string stateName);
 public delegate void PushState(string stateName, string lastStateName);
 public delegate void PopState();
 protected Dictionary<string, FSState> mStates;
 protected string      mEntryPoint;
 protected Stack<FSState>    mStateStack;
 public FiniteStateMachine() {
  mStates = new Dictionary<string, FSState>();
  mStateStack = new Stack<FSState>();
  mEntryPoint = null;
 }
 public void Update() {
  if (CurrentState == null) {
   mStateStack.Push(mStates[mEntryPoint]);
   CurrentState.StateObject.OnEnter(null);
  }
  CurrentState.StateObject.OnUpdate();
 }
 public void Register(string stateName, IState stateObject) {
  if (mStates.Count == 0)
   mEntryPoint = stateName;
  mStates.Add(stateName, new FSState(stateObject, this, stateName, Enter, Push, Pop));
 }
 public FSState State(string stateName) {
  return mStates[stateName];
 }
 public void EntryPoint(string startName) {
  mEntryPoint = startName;
 }
 public FSState CurrentState { 
  get { 
   if (mStateStack.Count == 0)
    return null;
   return mStateStack.Peek(); 
  } 
 }
 public void Enter(string stateName) {
  Push(stateName, Pop(stateName));
 }
 public void Push(string newState) {
  string lastName = null;
  if (mStateStack.Count > 1) {
   lastName = mStateStack.Peek().StateName;
  }
  Push(newState, lastName);
 }
 protected void Push(string stateName, string lastStateName) {
  mStateStack.Push(mStates[stateName]);
  mStateStack.Peek().StateObject.OnEnter(lastStateName);
 }
 public void Pop() {
  Pop(null);
 }
 protected string Pop(string newName) {
  FSState lastState = mStateStack.Peek();
  string newState = null;
  if (newName == null && mStateStack.Count > 1) {
   int index = 0;
   foreach (FSState item in mStateStack) {
    if (index++ == mStateStack.Count - 2) {
     newState = item.StateName;
    }
   }
  }
  else {
   newState = newName;
  }
  string lastStateName = null;
  if (lastState != null) {
   lastStateName = lastState.StateName;
   lastState.StateObject.OnExit(newState);
  }
  mStateStack.Pop();
  return lastStateName;
 }
 public void Trigger(string eventName) {
  CurrentState.Trigger(eventName);
 }
 public void Trigger(string eventName, object param1) {
  CurrentState.Trigger(eventName, param1);
 }
  
 public void Trigger(string eventName, object param1, object param2) {
  CurrentState.Trigger(eventName, param1, param2);
 }
  
 public void Trigger(string eventName, object param1, object param2, object param3) {
  CurrentState.Trigger(eventName, param1, param2, param3);
 }
}

上面整个FSMStateMachine类就封装完了

在设计二中，我们实现了有限状态机管理类，接下来，我们实现FSState这个类，这里类主要是状态的基本操作以及事件触发。在这里我们定义了在FiniteStateMachine类里声明的三个委托。在FSState里面使用的代码如下：

1
2
3
protected FiniteStateMachine.EnterState mEnterDelegate;
protected FiniteStateMachine.PushState mPushDelegate;
protected FiniteStateMachine.PopState mPopDelegate;

这个FSState是独立的一个类，不继承Mono，我们定义了一个构造函数，将我们的委托进行了初始化：

1
2
3
4
5
6
7
8
9
10
public FSState(IState obj, FiniteStateMachine owner, string name, FiniteStateMachine.EnterState e, FiniteStateMachine.PushState pu, FiniteStateMachine.PopState po) {
                mStateObject = obj;
                mStateName = name;
                mOwner = owner;
                mEnterDelegate = e;
                mPushDelegate = pu;
                mPopDelegate = po;
                mTranslationEvents = new Dictionary<string, FSEvent>();
 
        }

我们声明了FSEvent事件处理函数用于将事件的名字和事件加入的Dictionary里面

1
2
3
4
5
6
public FSEvent On(string eventName) {
                FSEvent newEvent = new FSEvent(eventName, null, this, mOwner, mEnterDelegate, mPushDelegate, mPopDelegate);
                mTranslationEvents.Add(eventName, newEvent);
                return newEvent;
 
        }

加入到列表后，我们需要从表里面取出去执行，这就需要Trigger触发函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void Trigger(string name) {
                mTranslationEvents[name].Execute(null, null, null);
        }
 
 
        public void Trigger(string eventName, object param1) {
                mTranslationEvents[eventName].Execute(param1, null, null);
        }
         
        public void Trigger(string eventName, object param1, object param2) {
                mTranslationEvents[eventName].Execute(param1, param2, null);
        }
         
        public void Trigger(string eventName, object param1, object param2, object param3) {
                mTranslationEvents[eventName].Execute(param1, param2, param3);
 
        }

以上也是FSState类的核心代码，闲话少说，FSState类的整个代码，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
using System;
using System.Collections;
using System.Collections.Generic;
 
public class FSState {
    protected FiniteStateMachine.EnterState mEnterDelegate;
    protected FiniteStateMachine.PushState mPushDelegate;
    protected FiniteStateMachine.PopState mPopDelegate;
 
    protected IState mStateObject;
    protected string mStateName;
    protected FiniteStateMachine mOwner;
    protected Dictionary<string, FSEvent> mTranslationEvents;
 
    public FSState(IState obj, FiniteStateMachine owner, string name, FiniteStateMachine.EnterState e, FiniteStateMachine.PushState pu, FiniteStateMachine.PopState po) {
        mStateObject = obj;
        mStateName = name;
        mOwner = owner;
        mEnterDelegate = e;
        mPushDelegate = pu;
        mPopDelegate = po;
        mTranslationEvents = new Dictionary<string, FSEvent>();
    }
 
    public IState StateObject {
        get {
            return mStateObject;
        }
    }
 
    public string StateName {
        get {
            return mStateName;
        }
    }
 
    public FSEvent On(string eventName) {
        FSEvent newEvent = new FSEvent(eventName, null, this, mOwner, mEnterDelegate, mPushDelegate, mPopDelegate);
        mTranslationEvents.Add(eventName, newEvent);
        return newEvent;
    }
 
    public void Trigger(string name) {
        mTranslationEvents[name].Execute(null, null, null);
    }
 
    public void Trigger(string eventName, object param1) {
        mTranslationEvents[eventName].Execute(param1, null, null);
    }
     
    public void Trigger(string eventName, object param1, object param2) {
        mTranslationEvents[eventName].Execute(param1, param2, null);
    }
     
    public void Trigger(string eventName, object param1, object param2, object param3) {
        mTranslationEvents[eventName].Execute(param1, param2, param3);
    }
 
     
    public FSState On<T>(string eventName, Func<T, bool> action) {
        FSEvent newEvent = new FSEvent(eventName, null, this, mOwner, mEnterDelegate, mPushDelegate, mPopDelegate);
        newEvent.mAction = delegate (object o1, object o2, object o3) {
            T param1;
            try { param1 = (T)o1; } catch { param1 = default(T); }
            action(param1);
            return true;
        };
        mTranslationEvents.Add(eventName, newEvent);
        return this;
    }
     
    public FSState On<T>(string eventName, Action<T> action) {
        FSEvent newEvent = new FSEvent(eventName, null, this, mOwner, mEnterDelegate, mPushDelegate, mPopDelegate);
        newEvent.mAction = delegate (object o1, object o2, object o3) {
            T param1;
            try { param1 = (T)o1; } catch { param1 = default(T); }
            action(param1);
            return true;
        };
        mTranslationEvents.Add(eventName, newEvent);
        return this;
    }
     
    public FSState On<T1, T2>(string eventName, Func<T1, T2, bool> action) {
        FSEvent newEvent = new FSEvent(eventName, null, this, mOwner, mEnterDelegate, mPushDelegate, mPopDelegate);
        newEvent.mAction = delegate (object o1, object o2, object o3) {
            T1 param1;
            T2 param2;
            try { param1 = (T1)o1; } catch { param1 = default(T1); }
            try { param2 = (T2)o2; } catch { param2 = default(T2); }
            action(param1, param2);
            return true;
        };
        mTranslationEvents.Add(eventName, newEvent);
        return this;
    }
     
    public FSState On<T1, T2>(string eventName, Action<T1, T2> action) {
        FSEvent newEvent = new FSEvent(eventName, null, this, mOwner, mEnterDelegate, mPushDelegate, mPopDelegate);
        newEvent.mAction = delegate (object o1, object o2, object o3) {
            T1 param1;
            T2 param2;
            try { param1 = (T1)o1; } catch { param1 = default(T1); }
            try { param2 = (T2)o2; } catch { param2 = default(T2); }
            action(param1, param2);
            return true;
        };
        mTranslationEvents.Add(eventName, newEvent);
        return this;
    }
 
    public FSState On<T1, T2, T3>(string eventName, Func<T1, T2, T3, bool> action) {
        FSEvent newEvent = new FSEvent(eventName, null, this, mOwner, mEnterDelegate, mPushDelegate, mPopDelegate);
        newEvent.mAction = delegate (object o1, object o2, object o3) {
            T1 param1;
            T2 param2;
            T3 param3;
            try { param1 = (T1)o1; } catch { param1 = default(T1); }
            try { param2 = (T2)o2; } catch { param2 = default(T2); }
            try { param3 = (T3)o3; } catch { param3 = default(T3); }
            action(param1, param2, param3);
            return true;
        };
        mTranslationEvents.Add(eventName, newEvent);
        return this;
    }
     
    public FSState On<T1, T2, T3>(string eventName, Action<T1, T2, T3> action) {
        FSEvent newEvent = new FSEvent(eventName, null, this, mOwner, mEnterDelegate, mPushDelegate, mPopDelegate);
        newEvent.mAction = delegate (object o1, object o2, object o3) {
            T1 param1;
            T2 param2;
            T3 param3;
            try { param1 = (T1)o1; } catch { param1 = default(T1); }
            try { param2 = (T2)o2; } catch { param2 = default(T2); }
            try { param3 = (T3)o3; } catch { param3 = default(T3); }
            action(param1, param2, param3);
            return true;
        };
        mTranslationEvents.Add(eventName, newEvent);
        return this;
    }
}

接下来会在设计四中继续讲解 FSEvent类

接下来，我们继续我们的FSM有限状态机的设计，在设计三中我们实现了FSState这个类，我们继续实现FSEvent事件处理类。在FSEvent类里面我们声明了FiniteStateMachine里面定义的委托函数。代码如下：

1
2
3
protected FiniteStateMachine.EnterState mEnterDelegate;
protected FiniteStateMachine.PushState mPushDelegate;
protected FiniteStateMachine.PopState mPopDelegate;

同时我们定义了一个枚举用于处理有限状态机的状态，使用了System里面自带的封装的一个具有三个参数并返回TResult参数制定的雷兴志的方法。

1
public Func<object,object,object,bool>   mAction = null;

这个FSEvent事件类也是独立的，不继承Mono。它的核心功能主要是处理FSState的Enter，Push，Pop。代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public FSState Enter(string stateName) {
        mTargetState = stateName;
        eType = EventType.ENTER;
        return mStateOwner;
    }
 
    public FSState Push(string stateName) {
        mTargetState = stateName;
        eType = EventType.PUSH;
        return mStateOwner;
    }
 
    public void Pop() {
        eType = EventType.POP;
    }
 
    public void Execute(object o1,object o2,object o3) {
        if (eType == EventType.POP) {
            mPopDelegate();
        }
        else if (eType == EventType.PUSH) {
            mPushDelegate(mTargetState, mOwner.CurrentState.StateName);
        }
        else if (eType == EventType.ENTER) {
            mEnterDelegate(mTargetState);
        }
        else if (mAction != null) {
            mAction(o1, o2, o3);
        }
    }

总的来说，FSEvent是通过调用Enter，Push，Pop，Execute执行状态的切换。下面把整个代码给大家展现一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
using System;
 
public class FSEvent {
    protected FiniteStateMachine.EnterState mEnterDelegate;
    protected FiniteStateMachine.PushState mPushDelegate;
    protected FiniteStateMachine.PopState mPopDelegate;
 
    protected enum EventType { NONE, ENTER, PUSH, POP };
    protected string mEventName;
    protected FSState mStateOwner;
    protected string mTargetState;
    protected FiniteStateMachine mOwner;
    protected EventType eType;
    public Func<object,object,object,bool>   mAction = null;
 
    public FSEvent(string name, string target, FSState state, FiniteStateMachine owner, FiniteStateMachine.EnterState e, FiniteStateMachine.PushState pu, FiniteStateMachine.PopState po) {
        mStateOwner = state;
        mEventName = name;
        mTargetState = target;
        mOwner = owner;
        eType = EventType.NONE;
        mEnterDelegate = e;
        mPushDelegate = pu;
        mPopDelegate = po;
    }
 
    public FSState Enter(string stateName) {
        mTargetState = stateName;
        eType = EventType.ENTER;
        return mStateOwner;
    }
 
    public FSState Push(string stateName) {
        mTargetState = stateName;
        eType = EventType.PUSH;
        return mStateOwner;
    }
 
    public void Pop() {
        eType = EventType.POP;
    }
 
    public void Execute(object o1,object o2,object o3) {
        if (eType == EventType.POP) {
            mPopDelegate();
        }
        else if (eType == EventType.PUSH) {
            mPushDelegate(mTargetState, mOwner.CurrentState.StateName);
        }
        else if (eType == EventType.ENTER) {
            mEnterDelegate(mTargetState);
        }
        else if (mAction != null) {
            mAction(o1, o2, o3);
        }
    }
}

设计四把FSM常用的类已经封装好了，接下来我们会在设计五中去封装一个EventSystem类。用于处理事件的注册，分发等功能。

0 0