├── IState.cs
├── IStateMachine.cs
├── ITransition.cs
├── LState.cs
├── LStateMachine.cs
├── LTransition.cs
└── README.md


/IState.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using System.Collections;
 3 | using System.Collections.Generic;
 4 | 
 5 | 
 6 | namespace FSM{
 7 | 	/// <summary>
 8 | 	/// 状态接口
 9 | 	/// </summary>
10 | 	public interface IState  {
11 | 		
12 | 		/// <summary>
13 | 		/// 状态名
14 | 		/// </summary>
15 | 		/// <value> 状态名 </value>
16 | 		string Name{get;}
17 | 
18 | 		/// <summary>
19 | 		/// 状态标签
20 | 		/// </summary>
21 | 		/// <value> 状态标签 </value>
22 | 		string Tag{ get; set; }
23 | 
24 | 		/// <summary>
25 | 		/// 当前状态的状态机
26 | 		/// </summary>
27 | 		/// <value> 状态机 </value>
28 | 		IStateMachine Parent{get;set;}
29 | 
30 | 		/// <summary>
31 | 		/// 从进入状态开始计算的时长
32 | 		/// </summary>
33 | 		/// <value> 时长 </value>
34 | 		float Timer{get;}
35 | 
36 | 		/// <summary>
37 | 		/// 状态过渡
38 | 		/// </summary>
39 | 		/// <value> 当前状态的所有过渡 </value>
40 | 		List<ITransition> Transitions{get;}
41 | 
42 | 		/// <summary>
43 | 		/// 进入状态时的回调		
44 | 		/// </summary>
45 | 		/// <param name="prev"> 上一个状态 </param>
46 | 		void EnterCallback (IState prev);
47 | 
48 | 		/// <summary>
49 | 		/// 退出状态时的回调
50 | 		/// </summary>
51 | 		/// <param name="next"> 下一个状态 </param>
52 | 		void ExitCallback (IState next);
53 | 
54 | 		/// <summary>
55 | 		/// Update 的回调
56 | 		/// </summary>
57 | 		/// <param name="deltaTime"> Time.deltaTime </param>
58 | 		void UpdateCallback (float deltaTime);
59 | 
60 | 		/// <summary>
61 | 		/// LateUpdate 的回调
62 | 		/// </summary>
63 | 		/// <param name="deltaTime"> Time.deltaTime </param>
64 | 		void LateUpdateCallback (float deltaTime);
65 | 
66 | 		/// <summary>
67 | 		/// FixedUpdate 的回调
68 | 		/// </summary>
69 | 		void FixedUpdateCallback ();
70 | 
71 | 		/// <summary>
72 | 		/// 添加过渡
73 | 		/// </summary>
74 | 		/// <param name="t"> 状态过渡 </param>
75 | 		void AddTransition (ITransition t);
76 | 	}
77 | }
78 | 


--------------------------------------------------------------------------------
/IStateMachine.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using System.Collections;
 3 | 
 4 | namespace FSM{
 5 | 	/// <summary>
 6 | 	/// 状态机接口
 7 | 	/// </summary>
 8 | 	public interface IStateMachine {
 9 | 
10 | 		/// <summary>
11 | 		/// 当前状态
12 | 		/// </summary>
13 | 		/// <value> 状态机的当前状态 </value>
14 | 		IState CurrentState{ get; }
15 | 
16 | 		/// <summary>
17 | 		/// 默认状态
18 | 		/// </summary>
19 | 		/// <value> 状态机的默认状态 </value>
20 | 		IState DefaultState{ get; set; }
21 | 
22 | 		/// <summary>
23 | 		/// 添加状态
24 | 		/// </summary>
25 | 		/// <param name="state"> 要添加的状态 </param>
26 | 		void AddState (IState state);
27 | 
28 | 		/// <summary>
29 | 		/// 删除状态
30 | 		/// </summary>
31 | 		/// <param name="state"> 要删除的状态 </param>
32 | 		void RemoveState(IState state);
33 | 
34 | 		/// <summary>
35 | 		/// 通过指定 Tag 值查找状态
36 | 		/// </summary>
37 | 		/// <returns> 查找到的状态 </returns>
38 | 		/// <param name="tag"> 状态的 Tag 值 </param>
39 | 		IState GetStateWithTag(string tag);
40 | 
41 |         /// <summary>
42 |         /// 添加任意状态切换过渡
43 |         /// </summary>
44 |         void AddAnyState(ITransition t);
45 | 	}
46 | }
47 | 


--------------------------------------------------------------------------------
/ITransition.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using System.Collections;
 3 | 
 4 | namespace FSM{
 5 | 	/// <summary>
 6 | 	/// 用于状态过渡的接口
 7 | 	/// </summary>
 8 | 	public interface ITransition {
 9 | 
10 | 		/// <summary>
11 | 		/// 从哪个状态开始过渡
12 | 		/// </summary>
13 | 		/// <value> 原状态 </value>
14 | 		IState From{get;set;}
15 | 
16 | 		/// <summary>
17 | 		/// 要过渡到哪个状态
18 | 		/// </summary>
19 | 		/// <value> 目标状态 </value>
20 | 		IState To{get;set;}
21 | 
22 | 		/// <summary>
23 | 		/// 过渡名字
24 | 		/// </summary>
25 | 		/// <value> 名字 </value>
26 | 		string Name{ get; set; }
27 | 
28 | 		/// <summary>
29 | 		/// 过渡时的回调
30 | 		/// </summary>
31 | 		/// <returns><c>true</c>, 过渡结束 <c>false</c> 继续进行过渡 </returns>
32 | 		bool TransitionCallback();
33 | 
34 | 		/// <summary>
35 | 		/// 能否开始过渡
36 | 		/// </summary>
37 | 		/// <returns><c>true</c> 开始进行过渡 <c>false</c> 不进行过渡 </returns>
38 | 		bool ShouldBengin ();
39 | 	}
40 | }
41 | 


--------------------------------------------------------------------------------
/LState.cs:
--------------------------------------------------------------------------------
  1 | using UnityEngine;
  2 | using System.Collections;
  3 | using System.Collections.Generic;
  4 | 
  5 | namespace FSM{
  6 | 	
  7 | 	public delegate void LStateDelegate();
  8 | 	public delegate void LStateDelegateState(IState state);
  9 | 	public delegate void LStateDelegateFloat(float f);
 10 | 	/// <summary>
 11 | 	/// 实现 IState 接口
 12 | 	/// </summary>
 13 | 	public class LState : IState {
 14 | 
 15 | 		/// <summary>
 16 | 		/// 当进入状态时调用的事件
 17 | 		/// </summary>
 18 | 		public event LStateDelegateState OnEnter;
 19 | 
 20 | 		/// <summary>
 21 | 		/// 当离开状态时调用的事件
 22 | 		/// </summary>
 23 | 		public event LStateDelegateState OnExit;
 24 | 
 25 | 		/// <summary>
 26 | 		/// Update 时调用
 27 | 		/// </summary>
 28 | 		public event LStateDelegateFloat OnUpdate;
 29 | 
 30 | 		/// <summary>
 31 | 		/// LateUpdate 时调用
 32 | 		/// </summary>
 33 | 		public event LStateDelegateFloat OnLateUpdate;
 34 | 
 35 | 		/// <summary>
 36 | 		/// FixedUpdate 时调用
 37 | 		/// </summary>
 38 | 		public event LStateDelegate OnFixedUpdate;
 39 | 
 40 | 		/// <summary>
 41 | 		/// 状态名
 42 | 		/// </summary>
 43 | 		/// <value>状态名</value>
 44 | 		public string Name {
 45 | 			get {
 46 | 				return _name;
 47 | 			}
 48 | 		}
 49 | 		/// <summary>
 50 | 		/// 状态标签
 51 | 		/// </summary>
 52 | 		/// <value>状态标签</value>
 53 | 		public string Tag {
 54 | 			get {
 55 | 				return _tag;
 56 | 			}
 57 | 			set {
 58 | 				_tag = value;
 59 | 			}
 60 | 		}
 61 | 
 62 | 		/// <summary>
 63 | 		/// 当前状态的状态机
 64 | 		/// </summary>
 65 | 		/// <value>状态机</value>
 66 | 		public IStateMachine Parent{
 67 | 			get {
 68 | 				return _parent;
 69 | 			}
 70 | 			set {
 71 | 				_parent = value;
 72 | 			}
 73 | 		}
 74 | 
 75 | 		/// <summary>
 76 | 		/// 从进入状态开始计算的时长
 77 | 		/// </summary>
 78 | 		/// <value>时长</value>
 79 | 		public float Timer{
 80 | 			get {
 81 | 				return _timer;
 82 | 			}
 83 | 		}
 84 | 
 85 | 		/// <summary>
 86 | 		/// 状态过渡
 87 | 		/// </summary>
 88 | 		/// <value>当前状态的所有过渡</value>
 89 | 		public List<ITransition> Transitions{
 90 | 			get{ 
 91 | 				return _transitions;
 92 | 			}
 93 | 		}
 94 | 
 95 | 		/// <summary>
 96 | 		/// 添加过渡
 97 | 		/// </summary>
 98 | 		/// <param name="t">状态过渡</param>
 99 | 		public void AddTransition(ITransition t){
100 | 			if (t != null && !_transitions.Contains (t)) {
101 | 				_transitions.Add (t);	
102 | 			}
103 | 		}
104 | 
105 | 		/// <summary>
106 | 		/// 构造方法
107 | 		/// </summary>
108 | 		/// <param name="name"> 状态名 </param>
109 | 		public LState(string name){
110 | 			_name = name;
111 | 			_transitions = new List<ITransition> ();
112 | 		}
113 | 
114 | 		/// <summary>
115 | 		/// 进入状态时的回调
116 | 		/// </summary>
117 | 		/// <param name="prev">上一个状态</param>
118 | 		public virtual void EnterCallback (IState prev)
119 | 		{
120 | 			// 进入状态时调用 OnEnter 事件
121 | 			_timer = 0f;
122 | 			if (OnEnter != null) {
123 | 				OnEnter (prev);
124 | 			}
125 | 		}
126 | 
127 | 		/// <summary>
128 | 		/// 退出状态时的回调
129 | 		/// </summary>
130 | 		/// <param name="next">下一个状态</param>
131 | 		public virtual void ExitCallback (IState next)
132 | 		{
133 | 			_timer = 0f;
134 | 			// 离开状态时调用 OnExit 事件
135 | 			if (OnExit != null) {
136 | 				OnExit (next);
137 | 			}
138 | 		}
139 | 
140 | 		/// <summary>
141 | 		/// Update 的回调
142 | 		/// </summary>
143 | 		/// <param name="deltaTime">Time.deltaTime</param>
144 | 		public virtual void UpdateCallback (float deltaTime)
145 | 		{
146 | 			_timer += deltaTime;
147 | 			// Update 时调用 OnUpdate 事件
148 | 			if (OnUpdate != null) {
149 | 				OnUpdate (deltaTime);
150 | 			}
151 | 		}
152 | 
153 | 		/// <summary>
154 | 		/// LateUpdate 的回调
155 | 		/// </summary>
156 | 		/// <param name="deltaTime">Time.deltaTime</param>
157 | 		public virtual void LateUpdateCallback (float deltaTime)
158 | 		{
159 | 			// LateUpdate 时调用 OnLateUpdate 事件
160 | 			if (OnLateUpdate != null) {
161 | 				OnLateUpdate (deltaTime);
162 | 			}
163 | 		}
164 | 
165 | 		/// <summary>
166 | 		/// FixedUpdate 的回调
167 | 		/// </summary>
168 | 		public virtual void FixedUpdateCallback ()
169 | 		{
170 | 			// FixedUpdate 时调用 OnFixedUpdate 事件
171 | 			if (OnFixedUpdate != null) {
172 | 				OnFixedUpdate ();
173 | 			}
174 | 		}
175 | 
176 | 		private string _name;		// 状态名
177 | 		private string _tag;		// 状态标签
178 | 		private float _timer;		// 计时器
179 | 		private IStateMachine _parent; //当前状态的状态机
180 | 		private List<ITransition> _transitions; //状态过渡
181 | 	}
182 | }
183 | 


--------------------------------------------------------------------------------
/LStateMachine.cs:
--------------------------------------------------------------------------------
  1 | using UnityEngine;
  2 | using System.Collections;
  3 | using System.Collections.Generic;
  4 | 
  5 | namespace FSM{
  6 | 	/// <summary>
  7 | 	/// 状态机类,需要继承于状态类并实现状态机接口
  8 | 	/// </summary>
  9 | 	public class LStateMachine : LState, IStateMachine {
 10 | 		
 11 | 		/// <summary>
 12 | 		/// 当前状态
 13 | 		/// </summary>
 14 | 		/// <value>状态机的当前状态</value>
 15 | 		public IState CurrentState {
 16 | 			get {
 17 | 				return _currentState;
 18 | 			}
 19 | 		}
 20 | 		/// <summary>
 21 | 		/// 默认状态
 22 | 		/// </summary>
 23 | 		/// <value>状态机的默认状态</value>
 24 | 		public IState DefaultState {
 25 | 			get {
 26 | 				return _defaultState;
 27 | 			}
 28 | 			set {
 29 | 				AddState (value);
 30 | 				_defaultState = value;
 31 | 			}
 32 | 		}
 33 | 
 34 | 		/// <summary>
 35 | 		/// 构造方法
 36 | 		/// </summary>
 37 | 		public LStateMachine(string name,IState defaultState) : base (name){
 38 | 			_states = new List<IState> ();
 39 |             _anyStateTransitions = new List<ITransition>();
 40 | 			_defaultState = defaultState;
 41 | 		}
 42 | 
 43 | 		/// <summary>
 44 | 		/// 添加状态
 45 | 		/// </summary>
 46 | 		/// <param name="state">要添加的状态</param>
 47 | 		public void AddState (IState state)
 48 | 		{
 49 | 			if (state != null && !_states.Contains (state)) {
 50 | 				_states.Add (state);
 51 | 				state.Parent = this;
 52 | 				if (_defaultState==null) {
 53 | 					_defaultState = state;
 54 | 				}
 55 | 			}
 56 | 		}
 57 | 		/// <summary>
 58 | 		/// 删除状态
 59 | 		/// </summary>
 60 | 		/// <param name="state">要删除的状态</param>
 61 | 		public void RemoveState (IState state){
 62 | 			// 状态机运行过程中,不能删除当前状态
 63 | 			if (_currentState == state) {
 64 | 				return;
 65 | 			}
 66 | 			if (state != null && _states.Contains (state)) {
 67 | 				_states.Remove (state);	
 68 | 				state.Parent = null;
 69 | 				if (_defaultState == state) {
 70 | 					_defaultState = (_states.Count >= 1) ? _states [0] : null;
 71 | 				}
 72 | 			}
 73 | 		}
 74 | 		/// <summary>
 75 | 		/// 通过指定 Tag 值查找状态
 76 | 		/// </summary>
 77 | 		/// <returns>查找到的状态</returns>
 78 | 		/// <param name="tag">状态的 Tag 值</param>
 79 | 		public IState GetStateWithTag (string tag)
 80 | 		{
 81 | 			return null;
 82 | 		}
 83 | 
 84 | 		/// <summary>
 85 | 		/// 进入状态时的回调
 86 | 		/// </summary>
 87 | 		/// <param name="prev">上一个状态</param>
 88 | 		public override void EnterCallback (IState prev)
 89 | 		{
 90 | 			base.EnterCallback (prev);
 91 | 			_currentState.EnterCallback (prev);
 92 | 		}
 93 | 
 94 | 		/// <summary>
 95 | 		/// 退出状态时的回调
 96 | 		/// </summary>
 97 | 		/// <param name="next">下一个状态</param>
 98 | 		public override void ExitCallback (IState next)
 99 | 		{
100 | 			base.ExitCallback (next);
101 | 			_currentState.ExitCallback (next);
102 | 		}
103 | 
104 | 		/// <summary>
105 | 		/// Update 的回调
106 | 		/// </summary>
107 | 		/// <param name="deltaTime">Time.deltaTime</param>
108 | 		public override void UpdateCallback (float deltaTime)
109 | 		{
110 | 			if (_isTransition) {
111 | 				if (_t.TransitionCallback()) {
112 | 					DoTransition (_t);
113 | 					_isTransition = false;
114 | 				}
115 | 				return;
116 |             }
117 | 
118 |             base.UpdateCallback (deltaTime);
119 | 
120 |             int count = _anyStateTransitions.Count;
121 | 
122 |             if (_currentState == null) {
123 |                 _currentState = _defaultState;
124 |             }
125 | 
126 |             for (int i = 0; i < count; i++)
127 |             {
128 |                 ITransition t = _anyStateTransitions [i];
129 |                 if (t.To!= _currentState && t.ShouldBengin())
130 |                 {
131 |                     _isTransition = true;
132 |                     _t = t;
133 |                     return;
134 |                 }
135 |             }
136 | 
137 | 			List<ITransition> ts = _currentState.Transitions;
138 | 			count = ts.Count;
139 | 			for (int i = 0; i < count; i++) {
140 | 				ITransition t = ts [i];
141 | 				if (t.ShouldBengin()) {
142 | 					_isTransition = true;
143 | 					_t = t;
144 | 					return;
145 | 				}
146 | 			}
147 | 			_currentState.UpdateCallback (deltaTime);
148 | 		}
149 | 
150 | 		/// <summary>
151 | 		/// LateUpdate 的回调
152 | 		/// </summary>
153 | 		/// <param name="deltaTime">Time.deltaTime</param>
154 | 		public override void LateUpdateCallback (float deltaTime)
155 | 		{
156 | 			if (_isTransition) {
157 | 				if (_t.TransitionCallback()) {
158 | 					DoTransition (_t);
159 | 					_isTransition = false;
160 | 				}
161 | 				return;
162 | 			}
163 |             base.LateUpdateCallback (deltaTime);
164 | 
165 |             if (_currentState == null) {
166 |                 _currentState = _defaultState;
167 |             }
168 | 
169 |             int count = _anyStateTransitions.Count;
170 |             for (int i = 0; i < count; i++)
171 |             {
172 |                 ITransition t = _anyStateTransitions [i];
173 |                 if (t.To!= _currentState && t.ShouldBengin())
174 |                 {
175 |                     _isTransition = true;
176 |                     _t = t;
177 |                     return;
178 |                 }
179 |             }
180 | 			List<ITransition> ts = _currentState.Transitions;
181 | 			count = ts.Count;
182 | 			for (int i = 0; i < count; i++) {
183 | 				ITransition t = ts [i];
184 | 				if (t.ShouldBengin()) {
185 | 					_isTransition = true;
186 | 					_t = t;
187 | 					return;
188 | 				}
189 | 			}
190 | 			_currentState.LateUpdateCallback (deltaTime);
191 | 		}
192 | 
193 | 		/// <summary>
194 | 		/// FixedUpdate 的回调
195 | 		/// </summary>
196 | 		public override void FixedUpdateCallback ()
197 | 		{
198 | 			if (_isTransition) {
199 | 				if (_t.TransitionCallback()) {
200 | 					DoTransition (_t);
201 | 					_isTransition = false;
202 | 				}
203 | 				return;
204 | 			}
205 |             base.FixedUpdateCallback ();
206 | 
207 |             if (_currentState == null) {
208 |                 _currentState = _defaultState;
209 |             }
210 | 
211 |             int count = _anyStateTransitions.Count;
212 |             for (int i = 0; i < count; i++)
213 |             {
214 |                 ITransition t = _anyStateTransitions [i];
215 |                 if (t.To!= _currentState && t.ShouldBengin())
216 |                 {
217 |                     _isTransition = true;
218 |                     _t = t;
219 |                     return;
220 |                 }
221 |             }
222 | 
223 | 			List<ITransition> ts = _currentState.Transitions;
224 | 			count = ts.Count;
225 | 			for (int i = 0; i < count; i++) {
226 | 				ITransition t = ts [i];
227 | 				if (t.ShouldBengin()) {
228 | 					_isTransition = true;
229 | 					_t = t;
230 | 					return;
231 | 				}
232 | 			}
233 | 			_currentState.FixedUpdateCallback ();
234 | 		}
235 | 
236 |         private IState _tempState;
237 | 		// 开始进行过渡
238 | 		private void DoTransition(ITransition t){
239 |             _tempState = _currentState;
240 | 			_currentState.ExitCallback (t.To);
241 | 			_currentState = t.To;
242 |             if (t.From != null)
243 |             {
244 |                 _tempState = t.From;
245 |             }
246 |             _currentState.EnterCallback(_tempState);
247 | 		}
248 | 
249 | 		private IState _currentState;	// 当前状态
250 | 		private IState _defaultState;	// 默认状态
251 | 		private List<IState> _states;	// 所有状态
252 | 
253 | 
254 | 		private bool _isTransition=false;	// 是否在过渡
255 | 		private ITransition _t;			// 当前正在执行的过渡
256 | 
257 |         private List<ITransition> _anyStateTransitions;     // 任何状态下的过渡
258 | 
259 |         public void AddAnyState(ITransition t)
260 |         {
261 |             if (_anyStateTransitions.Contains(t))
262 |                 return;
263 |             t.From = null;
264 |             _anyStateTransitions.Add(t);
265 |         }
266 | 	}
267 | }
268 | 


--------------------------------------------------------------------------------
/LTransition.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using System.Collections;
 3 | 
 4 | namespace FSM{
 5 | 
 6 | 	public delegate bool LTransitionDelegate();
 7 | 
 8 | 	/// <summary>
 9 | 	/// 用于进行状态过渡
10 | 	/// </summary>
11 | 	public class LTransition : ITransition {
12 | 
13 | 		public event LTransitionDelegate OnTransition;
14 | 		public event LTransitionDelegate OnCheck;
15 | 
16 | 		/// <summary>
17 | 		/// 从哪个状态开始过渡
18 | 		/// </summary>
19 | 		/// <value>原状态</value>
20 | 		public IState From {
21 | 			get {
22 | 				return _from;
23 | 			}
24 | 			set {
25 | 				_from = value;
26 | 			}
27 | 		}
28 | 
29 | 		/// <summary>
30 | 		/// 要过渡到哪个状态
31 | 		/// </summary>
32 | 		/// <value>目标状态</value>
33 | 		public IState To {
34 | 			get {
35 | 				return _to;
36 | 			}
37 | 			set {
38 | 				_to = value;
39 | 			}
40 | 		}
41 | 		/// <summary>
42 | 		/// 过渡名字
43 | 		/// </summary>
44 | 		/// <value>名字</value>
45 | 		public string Name {
46 | 			get {
47 | 				return _name;
48 | 			}
49 | 			set {
50 | 				_name = value;
51 | 			}
52 | 		}
53 | 
54 | 		/// <summary>
55 | 		/// 构造方法
56 | 		/// </summary>
57 | 		public LTransition(string name,IState fromState,IState toState){
58 | 			_name = name;
59 | 			_from = fromState;
60 | 			_to = toState;
61 | 		}
62 | 
63 | 		/// <summary>
64 | 		/// 过渡时进行的回调
65 | 		/// </summary>
66 | 		/// <returns><c>true</c>, 过渡结束 , <c>false</c> 继续进行过渡 </returns>
67 | 		public bool TransitionCallback(){
68 | 			if (OnTransition != null) {
69 | 				return OnTransition();	
70 | 			}
71 | 			return true;
72 | 		}
73 | 
74 | 		public bool ShouldBengin (){
75 | 			if (OnCheck!=null) {
76 | 				return OnCheck ();
77 | 			}
78 | 			return false;
79 | 		}
80 | 
81 | 		private IState _from;	// 原状态
82 | 		private IState _to;		// 目标状态
83 | 		private string _name;	// 过渡名
84 | 
85 | 	}
86 | }
87 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # UnityFramework_FSM
2 | 对Unity有限状态机的封装
3 | 


--------------------------------------------------------------------------------