Unity FSM 有限狀態機

翻譯了一下unity wiki上對於有限狀態機的案例,等有空時在詳細寫一下。在場景中添加兩個游戲物體，一個為玩家並修改其Tag為Player，另一個為NPC為其添加NPCControl腳本，並為其將玩家角色和路徑添加上去。（該案例利用狀態機簡單的實現了一個NPC的簡單AI---巡邏---看到玩家----追逐玩家----丟失玩家----巡邏）

效果：

 

狀態機：

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

/**
A Finite State Machine System based on Chapter 3.1 of Game Programming Gems 1 by Eric Dybsand
 
Written by Roberto Cezar Bianchini, July 2010
 
 
How to use:
    1. Place the labels for the transitions and the states of the Finite State System
        in the corresponding enums.
 
    2. Write new class(es) inheriting from FSMState and fill each one with pairs (transition-state).
        These pairs represent the state S2 the FSMSystem should be if while being on state S1, a
        transition T is fired and state S1 has a transition from it to S2. Remember this is a Deterministic（確定的） FSM. 
        You can't have one transition leading to two different states.
 
       Method Reason is used to determine which transition should be fired.
       You can write the code to fire transitions in another place, and leave this method empty if you
       feel it's more appropriate 合適 to your project.
 
       Method Act has the code to perform the actions the NPC is supposed do if it's on this state.
       You can write the code for the actions in another place, and leave this method empty if you
       feel it's more appropriate to your project.
 
    3. Create an instance of FSMSystem class and add the states to it.
 
    4. Call Reason and Act (or whichever methods you have for firing transitions and making the NPCs
         behave in your game) from your Update or FixedUpdate methods.
 
    Asynchronous transitions from Unity Engine, like OnTriggerEnter, SendMessage, can also be used, 
    just call the Method PerformTransition from your FSMSystem instance with the correct Transition 
    when the event occurs 重現.
 
 
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE 
AND NON-INFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/


/// <summary>
/// Place the labels for the Transitions in this enum.
/// Don't change the first label, NullTransition as FSMSystem class uses it.
/// 為過渡加入枚舉標簽
/// 不要修改第一個標簽，NullTransition會在FSMSytem類中使用
/// </summary>
public enum Transition
{
    NullTransition = 0, // Use this transition to represent a non-existing transition in your system
    //用這個過度來代表你的系統中不存在的狀態
    SawPlayer,//這里配合NPCControl添加兩個NPC的過渡
    LostPlayer,
}

/// <summary>
/// Place the labels for the States in this enum.
/// Don't change the first label, NullStateID as FSMSystem class uses it.
/// 為狀態加入枚舉標簽
/// 不要修改第一個標簽，NullStateID會在FSMSytem中使用 
/// </summary>
public enum StateID
{
    NullStateID = 0, // Use this ID to represent a non-existing State in your syste
    //使用這個ID來代表你系統中不存在的狀態ID    
    ChasingPlayer,//這里配合NPCControl添加兩個狀態
    FollowingPath,

}

/// <summary>
/// This class represents the States in the Finite State System.
/// Each state has a Dictionary with pairs (transition-state) showing
/// which state the FSM should be if a transition is fired while this state
/// is the current state.
/// Method Reason is used to determine which transition should be fired .
/// Method Act has the code to perform the actions the NPC is supposed do if it's on this state.
/// 這個類代表狀態在有限狀態機系統中
/// 每個狀態都有一個由一對搭檔（過渡-狀態）組成的字典來表示當前狀態下如果一個過渡被觸發狀態機會進入那個狀態
/// Reason方法被用來決定那個過渡會被觸發
/// Act方法來表現NPC出在當前狀態的行為
/// </summary>
public abstract class FSMState
{
    protected Dictionary<Transition, StateID> map = new Dictionary<Transition, StateID>();
    protected StateID stateID;
    public StateID ID { get { return stateID; } }

    public void AddTransition(Transition trans, StateID id)
    {
        // Check if anyone of the args is invalid
        //驗證每個參數是否合法
        if (trans == Transition.NullTransition)
        {
            Debug.LogError("FSMState ERROR: NullTransition is not allowed for a real transition");
            return;
        }

        if (id == StateID.NullStateID)
        {
            Debug.LogError("FSMState ERROR: NullStateID is not allowed for a real ID");
            return;
        }

        // Since this is a Deterministic FSM,
        //   check if the current transition was already inside the map
        //要知道這是一個確定的有限狀態機（每個狀態后金對應一種狀態，而不能產生分支）
        //檢查當前的過渡是否已經在地圖字典中了
        if (map.ContainsKey(trans))
        {
            Debug.LogError("FSMState ERROR: State " + stateID.ToString() + " already has transition " + trans.ToString() +
                           "Impossible to assign to another state");
            return;
        }

        map.Add(trans, id);
    }

    /// <summary>
    /// This method deletes a pair transition-state from this state's map.
    /// If the transition was not inside the state's map, an ERROR message is printed.
    /// 這個方法用來在狀態地圖中刪除transition-state對兒
    /// 如果過渡並不存在於狀態地圖中，那么將會打印出一個錯誤
    /// </summary>
    public void DeleteTransition(Transition trans)
    {
        // Check for NullTransition
        if (trans == Transition.NullTransition)
        {
            Debug.LogError("FSMState ERROR: NullTransition is not allowed");
            return;
        }

        // Check if the pair is inside the map before deleting
        //再刪除之前確認該鍵值對是否存在於狀態地圖中（鍵值對集合）
        if (map.ContainsKey(trans))
        {
            map.Remove(trans);
            return;
        }
        Debug.LogError("FSMState ERROR: Transition " + trans.ToString() + " passed to " + stateID.ToString() +
                       " was not on the state's transition list");
    }

    /// <summary>
    /// This method returns the new state the FSM should be if
    ///    this state receives a transition and 
    /// 該方法在該狀態接收到一個過渡時返回狀態機需要成為的新狀態
    /// </summary>
    public StateID GetOutputState(Transition trans)
    {
        // Check if the map has this transition
        if (map.ContainsKey(trans))
        {
            return map[trans];
        }
        return StateID.NullStateID;
    }

    /// <summary>
    /// This method is used to set up the State condition before entering it.
    /// It is called automatically by the FSMSystem class before assigning it
    /// to the current state.
    /// 這個方法用來設立進入狀態前的條件
    /// 在狀態機分配它到當前狀態之前他會被自動調用
    /// </summary>
    public virtual void DoBeforeEntering() { }

    /// <summary>
    /// This method is used to make anything necessary, as reseting variables
    /// before the FSMSystem changes to another one. It is called automatically
    /// by the FSMSystem before changing to a new state.
    /// 這個方法用來讓一切都是必要的，例如在有限狀態機變化的另一個時重置變量。
    /// 在狀態機切換到新的狀態之前它會被自動調用。
    /// </summary>
    public virtual void DoBeforeLeaving() { }

    /// <summary>
    /// This method decides if the state should transition to another on its list
    /// 動機-->這個方法用來決定當前狀態是否需要過渡到列表中的其他狀態
    /// NPC is a reference to the object that is controlled by this class
    /// NPC是被該類約束下對象的一個引用
    /// </summary>
    public abstract void Reason(GameObject player, GameObject npc);

    /// <summary>
    /// This method controls the behavior of the NPC in the game World.
    /// 表現-->該方法用來控制NPC在游戲世界中的行為
    /// Every action, movement or communication the NPC does should be placed here
    /// NPC的任何動作，移動或者交流都需要防止在這兒
    /// NPC is a reference to the object that is controlled by this class
    /// NPC是被該類約束下對象的一個引用
    /// </summary>
    public abstract void Act(GameObject player, GameObject npc);

} // class FSMState


/// <summary>
/// FSMSystem class represents the Finite State Machine class.
///  It has a List with the States the NPC has and methods to add,
///  delete a state, and to change the current state the Machine is on.
/// 該類便是有限狀態機類
/// 它持有者NPC的狀態集合並且有添加，刪除狀態的方法，以及改變當前正在執行的狀態
/// </summary>
public class FSMSystem
{
    private List<FSMState> states;

    // The only way one can change the state of the FSM is by performing a transition
    // Don't change the CurrentState directly
    //通過預裝一個過渡的唯一方式來蓋面狀態機的狀態
    //不要直接改變當前的狀態
    private StateID currentStateID;
    public StateID CurrentStateID { get { return currentStateID; } }
    private FSMState currentState;
    public FSMState CurrentState { get { return currentState; } }

    public FSMSystem()
    {
        states = new List<FSMState>();
    }
    /// <summary>
    /// This method places new states inside the FSM,
    /// or prints an ERROR message if the state was already inside the List.
    /// First state added is also the initial state.
    /// 這個方法為有限狀態機置入新的狀態
    /// 或者在該狀態已經存在於列表中時打印錯誤信息
    /// 第一個添加的狀態也是最初的狀態!
    /// </summary>
    public void AddState(FSMState s)
    {
        // Check for Null reference before deleting
        //在添加前檢測空引用
        if (s == null)
        {
            Debug.LogError("FSM ERROR: Null reference is not allowed");
        }

       

        // First State inserted is also the Initial state,
        //   the state the machine is in when the   begins
        //被裝在的第一個狀態也是初始狀態
        //這個狀態便是狀態機開始時的狀態
        if (states.Count == 0)
        {
            states.Add(s);
            currentState = s;
            currentStateID = s.ID;
            return;
        }

        // Add the state to the List if it's not inside it
        //如果該狀態未被添加過，則加入集合
        foreach (FSMState state in states)
        {
            if (state.ID == s.ID)
            {
                Debug.LogError("FSM ERROR: Impossible to add state " + s.ID.ToString() +
                               " because state has already been added");
                return;
            }
        }
        states.Add(s);
    }

    /// <summary>
    /// This method delete a state from the FSM List if it exists, 
    ///   or prints an ERROR message if the state was not on the List.
    /// 該方法刪除一個已存在以狀態幾個中的狀態
    /// 在它不存在時打印錯誤信息
    /// </summary>
    public void DeleteState(StateID id)
    {
        // Check for NullState before deleting
        //在刪除前檢查其是否為空狀態
        if (id == StateID.NullStateID)
        {
            Debug.LogError("FSM ERROR: NullStateID is not allowed for a real state");
            return;
        }

        // Search the List and delete the state if it's inside it
        //遍歷集合如果存在該狀態則刪除它
        foreach (FSMState state in states)
        {
            if (state.ID == id)
            {
                states.Remove(state);
                return;
            }
        }
        Debug.LogError("FSM ERROR: Impossible to delete state " + id.ToString() +
                       ". It was not on the list of states");
    }

    /// <summary>
    /// This method tries to change the state the FSM is in based on
    /// the current state and the transition passed. If current state
    ///  doesn't have a target state for the transition passed, 
    /// an ERROR message is printed.
    /// 該方法基於當前狀態和過渡是否通過來嘗試改變狀態機的狀態，當當前的狀態沒有目標狀態用來過渡（叫通道應該更合適吧）時通過時則打印錯誤消息
    /// </summary>
    public void PerformTransition(Transition trans)
    {
        // Check for NullTransition before changing the current state
        //在改變當前狀態前檢測NullTransition
        if (trans == Transition.NullTransition)
        {
            Debug.LogError("FSM ERROR: NullTransition is not allowed for a real transition");
            return;
        }

        // Check if the currentState has the transition passed as argument
        //在改變當前狀態前檢測當前狀態是否可作為過渡的參數

        StateID id = currentState.GetOutputState(trans);
        if (id == StateID.NullStateID)
        {
            Debug.LogError("FSM ERROR: State " + currentStateID.ToString() + " does not have a target state " +
                           " for transition " + trans.ToString());
            return;
        }

        // Update the currentStateID and currentState        
        //更新當前的狀態個和狀態編號
        currentStateID = id;
        foreach (FSMState state in states)
        {
            if (state.ID == currentStateID)
            {
                // Do the post processing of the state before setting the new one
                //在狀態變為新狀態前執行后處理
                currentState.DoBeforeLeaving();

                currentState = state;

                // Reset the state to its desired condition before it can reason or act
                //在狀態可以使用Reason（動機）或者Act(行為)之前為它的的決定條件重置它自己
                currentState.DoBeforeEntering();
                break;
            }
        }

    } // PerformTransition()

} //class FSMSystem

NPCControl:

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

[RequireComponent(typeof(Rigidbody))]
public class NPCControl : MonoBehaviour
{
    public GameObject player;
    public Transform[] path;
    private FSMSystem fsm;

    public void SetTransition(Transition t)
    {
        //該方法用來改變有限狀態機的狀體，有限狀態機基於當前的狀態和通過的過渡狀態。
        //如果當前的狀態沒有用來通過的過度狀態，則會拋出錯誤
        fsm.PerformTransition(t);
    }

    public void Start()
    {
        MakeFSM();
    }

    public void FixedUpdate()
    {
        fsm.CurrentState.Reason(player, gameObject);
        fsm.CurrentState.Act(player, gameObject);
    }

    
    //NPC有兩個狀態分別是在路徑中巡邏和追逐玩家
    //如果他在第一個狀態並且SawPlayer 過度狀態被出發了，它就轉變到ChasePlayer狀態
    //如果他在ChasePlayer狀態並且LostPlayer狀態被觸發了，它就轉變到FollowPath狀態

    private void MakeFSM()//建造狀態機
    {
        FollowPathState follow = new FollowPathState(path);
        follow.AddTransition(Transition.SawPlayer, StateID.ChasingPlayer);

        ChasePlayerState chase = new ChasePlayerState();
        chase.AddTransition(Transition.LostPlayer, StateID.FollowingPath);

        fsm = new FSMSystem();
        fsm.AddState(follow);//添加狀態到狀態機，第一個添加的狀態將作為初始狀態
        fsm.AddState(chase);
    }
}

public class FollowPathState : FSMState
{
    private int currentWayPoint;
    private Transform[] waypoints;

    //構造函數裝填自己
    public FollowPathState(Transform[] wp)
    {
        waypoints = wp;
        currentWayPoint = 0;
        stateID = StateID.FollowingPath;//別忘設置自己的StateID  61     }

    public override void DoBeforeEntering()
    {
        Debug.Log("FollowingPath BeforeEntering--------");
    }

    public override void DoBeforeLeaving()
    {
        Debug.Log("FollowingPath BeforeLeaving---------");
    }

    //重寫動機方法
    public override void Reason(GameObject player, GameObject npc)
    {
        // If the Player passes less than 15 meters away in front of the NPC
        RaycastHit hit;
        if (Physics.Raycast(npc.transform.position, npc.transform.forward, out hit, 15F))
        {
            if (hit.transform.gameObject.tag == "Player")
                npc.GetComponent<NPCControl>().SetTransition(Transition.SawPlayer);
        }
    }

    //重寫表現方法
    public override void Act(GameObject player, GameObject npc)
    {
        // Follow the path of waypoints
        // Find the direction of the current way point 
        Vector3 vel = npc.GetComponent<Rigidbody>().velocity;
        Vector3 moveDir = waypoints[currentWayPoint].position - npc.transform.position;

        if (moveDir.magnitude < 1)
        {
            currentWayPoint++;
            if (currentWayPoint >= waypoints.Length)
            {
                currentWayPoint = 0;
            }
        }
        else
        {
            vel = moveDir.normalized * 10;

            // Rotate towards the waypoint
            npc.transform.rotation = Quaternion.Slerp(npc.transform.rotation,
                                                      Quaternion.LookRotation(moveDir),
                                                      5 * Time.deltaTime);
            npc.transform.eulerAngles = new Vector3(0, npc.transform.eulerAngles.y, 0);

        }

        // Apply the Velocity
        npc.GetComponent<Rigidbody>().velocity = vel;
    }

} // FollowPathState

public class ChasePlayerState : FSMState
{
    //構造函數裝填自己
    public ChasePlayerState()
    {
        stateID = StateID.ChasingPlayer;
    }

    public override void DoBeforeEntering()
    {
        Debug.Log("ChasingPlayer BeforeEntering--------");
    }

    public override void DoBeforeLeaving()
    {
        Debug.Log("ChasingPlayer BeforeLeaving---------");
    }

    public override void Reason(GameObject player, GameObject npc)
    {
        // If the player has gone 30 meters away from the NPC, fire LostPlayer transition
        if (Vector3.Distance(npc.transform.position, player.transform.position) >= 3)
            npc.GetComponent<NPCControl>().SetTransition(Transition.LostPlayer);
    }

    public override void Act(GameObject player, GameObject npc)
    {
        // Follow the path of waypoints
        // Find the direction of the player         
        Vector3 vel = npc.GetComponent<Rigidbody>().velocity;
        Vector3 moveDir = player.transform.position - npc.transform.position;

        // Rotate towards the waypoint
        npc.transform.rotation = Quaternion.Slerp(npc.transform.rotation,
                                                  Quaternion.LookRotation(moveDir),
                                                  5 * Time.deltaTime);
        npc.transform.eulerAngles = new Vector3(0, npc.transform.eulerAngles.y, 0);

        vel = moveDir.normalized * 10;

        // Apply the new Velocity
        npc.GetComponent<Rigidbody>().velocity = vel;
    }

} // ChasePlayerState

 

Unity最受歡迎的插件，可以讓您的游戲如虎添翼，為您節省大量時間可以投入在游戲的創意和細節上