一、简单有限状态机(FSM)实现

using UnityEngine;
using System.Collections;

/**
 * 简单状态机实现
 */
public class SimpleFSM : FSM {
	
	//枚举，定义状态机的四种状态，巡逻，追逐，攻击，死亡
	public enum FSMState
	{
		Patrolling,
		Chasing,
		Attacking,
		Dead,
	}

	//AI角色的当前状态
	public FSMState curState;

	protected override void Initialize(){
		//设置FSM的当前状态为巡逻状态；
		curState = FSMState.Patrolling;
	}

	protected override void FSMUpdate() {
		//判断当前状态，调用函数进行状态更新
		switch(curState){
		case FSMState.Patrolling:
			UpdatePatrolState();
			break;
		case FSMState.Chasing:
			UpdateChaseState();
			break;
		case FSMState.Attacking:
			UpdateAttackState();
			break;
		case FSMState.Dead:
			UpdateDeadState();
			break;
		}
	}

	//更新巡逻状态
	protected void UpdatePatrolState() {

	}

	//更新追逐状态
	protected void UpdateChaseState() {

	}

	//更新攻击状态
	protected void UpdateAttackState() {

	}

	//更新死亡状态
	protected void UpdateDeadState() {

	}
}

二、通用有限状态机(FSM)框架实现

using UnityEngine;
using System.Collections;
/**
 * 有限状态机基类
 */
public class FSM : MonoBehaviour {

	protected virtual void Initialize() {}
	protected virtual void FSMUpdate() {}
	protected virtual void FSMFixedUpdate() {}

	void Start () {
		//初始化FSM
		Initialize ();
	}

	void Update () {
		//每帧更新FSM
		FSMUpdate ();
	}

	void FixedUpdate(){
		//以固定的时间周期更新FSM
		FSMFixedUpdate ();
	}
}

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

//定义枚举，为可能的转换分配编号
public enum Transition
{
	SawPlayer = 0,  //看到玩家
	ReachPlayer,	//接近玩家，即玩家在攻击范围内
	LostPlayer,		//玩家离开视线
	NoHealth,		//死亡
}

//定义枚举，为可能的状态分配编号
public enum FSMStateID
{
	Patrolling = 0, //巡逻的状态编号为0
	Chasing,		//追逐的状态编号为1
	Attacking,		//攻击的状态编号为2
	Dead,			//死亡的状态编号为3
}

/**
 * 管理所有状态类
 */
public class AdvancedFSM : FSM {

	//FSM中的所有状态(多个FSMState)组成的列表
	private List<FSMState> fsmStates;

	//当前状态编号
	private FSMStateID currentStateID;
	public FSMStateID CurrentStateID {get {return currentStateID;}}

	//当前状态
	private FSMState currentState;
	public FSMState CurrentState {get {return currentState;}}

	public AdvancedFSM() {
		//新建一个空的状态列表
		fsmStates = new List<FSMState> ();
	}

	//向状态列表中加入一个新状态；
	public void AddFSMState(FSMState fsmState) {
		if (fsmState == null)
			Debug.LogError ("FSM ERROR: Null reference is not allowed");

		if(fsmStates.Count == 0){
			fsmStates.Add(fsmState);
			currentState = fsmState;
			currentStateID = fsmState.ID;
			return;
		}

		//检查要加入的状态是否已经在列表中，如果是，报告错误并返回；
		foreach(FSMState state in fsmStates){
			if(state.ID == fsmState.ID){
				Debug.LogError("FSM ERROR: Trying to add a state that was already inside the list");
				return;
			}
		}

		//如果要加入的状态不在列表中，那么将它加入列表；
		fsmStates.Add (fsmState);
	}

	//从状态列表中删除一个状态
	public void DeleteState(FSMStateID fsmState) {
		foreach (FSMState state in fsmStates) {
			if(state.ID == fsmState){
				fsmStates.Remove(state);
				return;
			}
		}
		Debug.LogError ("FSM ERROR: The state passed was not on the list. Impossible to delete it");
	}

	//根据当前状态，和参娄传递的转换，转移到新的状态；
	public void PerformTransition(Transition trans){
		//根据当前的状态类，以trans为参娄调用它的GetOutputState方法
		//确定转移后新状态的编号
		FSMStateID id = currentState.GetOutputState (trans);
		//将当前状态编号设置为刚刚返回的新状态编号；
		currentStateID = id;
		//根据状态编号查找状态列表，这个查找是通过一个遍历过程实现的；
		//将当前状态设置为查找到的状态；
		foreach(FSMState state in fsmStates){
			if(state.ID == currentStateID){
				currentState = state;
				break;
			}
		}
	}
}

using UnityEngine;
using System.Collections;

/**
 * 负责创建有限状态机，通过此类来控制AI角色
 */
public class AIController : AdvancedFSM {

	//初始化AI角色的FSM，在FSM基类的Start函数中调用；
	protected override void Initialize(){
		//Do something

		//调用ConstructFSM函数，开始构造状态机；
		ConstructFSM ();
	}

	//在FSM基类的Update函数中调用；
	protected override void FSMUpdate() {
		//Do something
	}

	//在FSM基类的FixedUpdate函数中调用；
	protected override void FSMFixedUpdate() {
		//调用当前状态的Reason方法，确定当前发生的转换
		CurrentState.Reason (transform);
		//调用当前状态的Act方法，确定角色的行为
		//注意，如果Reason中检查到满足某个转换条件，就会进行状态转换，
		//因此，在这两个调用之间，CurrentState可能会发生变化
		CurrentState.Act (transform);
	}

	//这个方法在每个状态类的Reason方法中被调用
	public void SetTransition(Transition t) {
		//Do something

		//调用AdvanceFSM类的PerformTransition方法，设置新状态
		PerformTransition (t);
	}

	//这个函数在初始化Initialize方法中调用，为AI角色构造FSM
	private void ConstructFSM(){
		//创建一个巡逻状态类
		PatrolState patrol = new PatrolState ();
		//调用巡逻状态类中的AddTransition函数
		//将这个状态下可能的两个“转换-状态”对(“看到玩家-追逐” 和 "生命值-死亡")
		//加入到PatrolState类的字典中
		patrol.AddTransition (Transition.SawPlayer, FSMStateID.Chasing);
		patrol.AddTransition (Transition.NoHealth, FSMStateID.Dead);

		//创建一个追逐状态类
		ChaseState chase = new ChaseState();
		//将这个状态下可能的三个“转换-状态”对加入到ChaseState类的字典中
		chase.AddTransition(Transition.LostPlayer, FSMStateID.Patrolling);
		chase.AddTransition(Transition.ReachPlayer, FSMStateID.Attacking);
		chase.AddTransition(Transition.NoHealth, FSMStateID.Dead);
		//创建一个攻击状态类
		AttackState attack = new AttackState ();
		//将这个状态下可能的三个“转换-状态”对加入到AttackState类的字典中
		attack.AddTransition(Transition.LostPlayer, FSMStateID.Patrolling);
		attack.AddTransition(Transition.SawPlayer, FSMStateID.Chasing);
		attack.AddTransition(Transition.NoHealth, FSMStateID.Dead);
		//创建一个死亡状态类
		DeadState dead = new DeadState ();
		//将这个状态下可能的一个“转换-状态”对加入到DeadState类的字典中
		dead.AddTransition(Transition.NoHealth, FSMStateID.Dead);
	}

	//当AI角色与其他物体碰撞时，调用这个函数
	void OnCollisionEnter(Collision collision) {

	}
}

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

/**
 * 状态抽象类
 */
public abstract class FSMState {

	//字典，字典中的每一项都记录了一个 “转换-状态” 对的信息
	protected Dictionary<Transition, FSMStateID> map = new Dictionary<Transition, FSMStateID> ();

	//状态编号ID
	protected FSMStateID stateID;
	public FSMStateID ID {get{return stateID;}}

	#region 根据实际情况定义需要用到的，与各状态相关的变量

	#endregion

	//向字典中添加项；每项是一个“转换-状态”对；
	public void AddTransition (Transition transition, FSMStateID id) {
		if(map.ContainsKey(transition)){
			Debug.LogWarning("FSMState ERROR: transition is already inside the map");
			return;
		}
		map.Add (transition, id);
		Debug.Log ("Added : " + transition + " with ID : " + id);
	}

	//从字典中删除某一项
	public void DeleteTransition(Transition trans){
		if (map.ContainsKey (trans)) {
			map.Remove(trans);
			return;
		}
		Debug.LogError ("FSMState ERROR: Transition passed was not on this State's List");
	}

	//通过查询字典，确定在当前状态下，发生trans转换时，应该转换到的新状态编号；
	//并返回这个新状态编号；
	public FSMStateID GetOutputState(Transition trans){
		return map[trans];
	}

	//Reason方法用来确定是否需要转换到其他状态，应该发生哪个转换；
	//至于此方法是否需要定义参数以及定义哪些参数，可根据实际情况决定
	//在此方法中若满足条件需要进行状态转移,可以AIPlayer.GetComponent<AIController>().SetTransition(xx,xx);
	public abstract void Reason(Transform AIPlayer);

	//Act方法定义了在本状态的角色行为，例如移动，动画等
	//至于此方法是否需要定义参数以及定义哪些参数，可根据实际情况决定
	public abstract void Act(Transform AIPlayer);
}

==================== 以上为框架代码============

using UnityEngine;
using System.Collections;

/**
 * 巡逻状态类
 */
public class PatrolState : FSMState {

	public PatrolState(){
		//设置状态编号
		stateID = FSMStateID.Patrolling;
	}

	//这个方法决定是否需要转换状态，以及发生哪种转换
	public override void Reason(Transform AIPlayer) {

	}

	//这个方法定义了在这个状态下AI角色的行为
	public override void Act(Transform AIPlayer) {

	}
}

using UnityEngine;
using System.Collections;

/**
 * 追逐状态类
 */
public class ChaseState : FSMState {

	public ChaseState(){
		//设置状态编号
		stateID = FSMStateID.Chasing;
	}
	
	//这个方法决定是否需要转换状态，以及发生哪种转换
	public override void Reason(Transform AIPlayer) {
		
	}
	
	//这个方法定义了在这个状态下AI角色的行为
	public override void Act(Transform AIPlayer) {
		
	}
}

using UnityEngine;
using System.Collections;

/**
 * 攻击状态类
 */
public class AttackState : FSMState {

	public AttackState(){
		//设置状态编号
		stateID = FSMStateID.Attacking;
	}
	
	//这个方法决定是否需要转换状态，以及发生哪种转换
	public override void Reason(Transform AIPlayer) {
		
	}
	
	//这个方法定义了在这个状态下AI角色的行为
	public override void Act(Transform AIPlayer) {
		
	}
}

using UnityEngine;
using System.Collections;

/**
 * 死亡状态类
 */
public class DeadState : FSMState {

	public DeadState(){
		//设置状态编号
		stateID = FSMStateID.Dead;
	}
	
	//这个方法决定是否需要转换状态，以及发生哪种转换
	public override void Reason(Transform AIPlayer) {
		
	}
	
	//这个方法定义了在这个状态下AI角色的行为
	public override void Act(Transform AIPlayer) {
		
	}
}