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

于 2015-02-06 11:37:46 发布
阅读量1k 收藏 1
点赞数
分类专栏： Unity3d

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


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

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

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

         wKiom1THrgnDFZcsAAOShIcUaH0197.jpg

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

    第一个是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类。用于处理事件的注册，分发等功能。



评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值