基于Unity有限状态机框架

1 usingSystem;
2 usingSystem.Collections;
3 usingSystem.Collections.Generic;
4 usingUnityEngine;
5  
6 /**
7 A Finite State Machine System based on Chapter 3.1 of Game Programming Gems 1 by Eric Dybsand
8  
9 Written by Roberto Cezar Bianchini, July 2010
10  
11  
12 How to use:
13 1. Place the labels for the transitions and the states of the Finite State System
14 in the corresponding enums.
15  
16 2. Write new class(es) inheriting from FSMState and fill each one with pairs (transition-state).
17 These pairs represent the state S2 the FSMSystem should be if while being on state S1, a
18 transition T is fired and state S1 has a transition from it to S2. Remember this is a Deterministic FSM. 
19 You can't have one transition leading to two different states.
20  
21 Method Reason is used to determine which transition should be fired.
22 You can write the code to fire transitions in another place, and leave this method empty if you
23 feel it's more appropriate to your project.
24  
25 Method Act has the code to perform the actions the NPC is supposed do if it's on this state.
26 You can write the code for the actions in another place, and leave this method empty if you
27 feel it's more appropriate to your project.
28  
29 3. Create an instance of FSMSystem class and add the states to it.
30  
31 4. Call Reason and Act (or whichever methods you have for firing transitions and making the NPCs
32 behave in your game) from your Update or FixedUpdate methods.
33  
34 Asynchronous transitions from Unity Engine, like OnTriggerEnter, SendMessage, can also be used, 
35 just call the Method PerformTransition from your FSMSystem instance with the correct Transition 
36 when the event occurs.
37  
38  
39  
40 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
41 INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE 
42 AND NON-INFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
43 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
44 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
45 */
46  
47  
48 /// <summary>
49 ///Place the labels for the Transitions in this enum.
50 ///Don't change the first label, NullTransition as FSMSystem class uses it.
51 /// </summary>
52 public enumTransition
53 {
54     NullTransition = 0, //Use this transition to represent a non-existing transition in your system
55 }
56  
57 /// <summary>
58 ///Place the labels for the States in this enum.
59 ///Don't change the first label, NullTransition as FSMSystem class uses it.
60 /// </summary>
61 public enumStateID
62 {
63     NullStateID = 0, //Use this ID to represent a non-existing State in your system    
64 }
65  
66 /// <summary>
67 ///This class represents the States in the Finite State System.
68 ///Each state has a Dictionary with pairs (transition-state) showing
69 ///which state the FSM should be if a transition is fired while this state
70 ///is the current state.
71 ///Method Reason is used to determine which transition should be fired .
72 ///Method Act has the code to perform the actions the NPC is supposed do if it's on this state.
73 /// </summary>
74 public abstract classFSMState
75 {
76     protected Dictionary<Transition, StateID> map = new Dictionary<Transition, StateID>();
77     protectedStateID stateID;
78     public StateID ID { get { returnstateID; } }
79  
80     public voidAddTransition(Transition trans, StateID id)
81 {
82         //Check if anyone of the args is invalid
83         if (trans ==Transition.NullTransition)
84 {
85             Debug.LogError("FSMState ERROR: NullTransition is not allowed for a real transition");
86             return;
87 }
88  
89         if (id ==StateID.NullStateID)
90 {
91             Debug.LogError("FSMState ERROR: NullStateID is not allowed for a real ID");
92             return;
93 }
94  
95         //Since this is a Deterministic FSM,
96         //check if the current transition was already inside the map
97         if(map.ContainsKey(trans))
98 {
99             Debug.LogError("FSMState ERROR: State " + stateID.ToString() + "already has transition " + trans.ToString() + 
100                            "Impossible to assign to another state");
101             return;
102 }
103  
104 map.Add(trans, id);
105 }
106  
107     /// <summary>
108     ///This method deletes a pair transition-state from this state's map.
109     ///If the transition was not inside the state's map, an ERROR message is printed.
110     /// </summary>
111     public voidDeleteTransition(Transition trans)
112 {
113         //Check for NullTransition
114         if (trans ==Transition.NullTransition)
115 {
116             Debug.LogError("FSMState ERROR: NullTransition is not allowed");
117             return;
118 }
119  
120         //Check if the pair is inside the map before deleting
121         if(map.ContainsKey(trans))
122 {
123 map.Remove(trans);
124             return;
125 }
126         Debug.LogError("FSMState ERROR: Transition " + trans.ToString() + "passed to " + stateID.ToString() + 
127                        "was not on the state's transition list");
128 }
129  
130     /// <summary>
131     ///This method returns the new state the FSM should be if
132     ///this state receives a transition and 
133     /// </summary>
134     publicStateID GetOutputState(Transition trans)
135 {
136         //Check if the map has this transition
137         if(map.ContainsKey(trans))
138 {
139             returnmap[trans];
140 }
141         returnStateID.NullStateID;
142 }
143  
144     /// <summary>
145     ///This method is used to set up the State condition before entering it.
146     ///It is called automatically by the FSMSystem class before assigning it
147     ///to the current state.
148     /// </summary>
149     public virtual voidDoBeforeEntering() { }
150  
151     /// <summary>
152     ///This method is used to make anything necessary, as reseting variables
153     ///before the FSMSystem changes to another one. It is called automatically
154     ///by the FSMSystem before changing to a new state.
155     /// </summary>
156     public virtual voidDoBeforeLeaving() { } 
157  
158     /// <summary>
159     ///This method decides if the state should transition to another on its list
160     ///NPC is a reference to the object that is controlled by this class
161     /// </summary>
162     public abstract voidReason(GameObject player, GameObject npc);
163  
164     /// <summary>
165     ///This method controls the behavior of the NPC in the game World.
166     ///Every action, movement or communication the NPC does should be placed here
167     ///NPC is a reference to the object that is controlled by this class
168     /// </summary>
169     public abstract voidAct(GameObject player, GameObject npc);
170  
171 } //class FSMState
172  
173  
174 /// <summary>
175 ///FSMSystem class represents the Finite State Machine class.
176 ///It has a List with the States the NPC has and methods to add,
177 ///delete a state, and to change the current state the Machine is on.
178 /// </summary>
179 public classFSMSystem
180 {
181     private List<FSMState>states;
182  
183     //The only way one can change the state of the FSM is by performing a transition
184     //Don't change the CurrentState directly
185     privateStateID currentStateID;
186     public StateID CurrentStateID { get { returncurrentStateID; } }
187     privateFSMState currentState;
188     public FSMState CurrentState { get { returncurrentState; } }
189  
190     publicFSMSystem()
191 {
192         states = new List<FSMState>();
193 }
194  
195     /// <summary>
196     ///This method places new states inside the FSM,
197     ///or prints an ERROR message if the state was already inside the List.
198     ///First state added is also the initial state.
199     /// </summary>
200     public voidAddState(FSMState s)
201 {
202         //Check for Null reference before deleting
203         if (s == null)
204 {
205             Debug.LogError("FSM ERROR: Null reference is not allowed");
206 }
207  
208         //First State inserted is also the Initial state,
209         //the state the machine is in when the simulation begins
210         if (states.Count == 0)
211 {
212 states.Add(s);
213             currentState =s;
214             currentStateID =s.ID;
215             return;
216 }
217  
218         //Add the state to the List if it's not inside it
219         foreach (FSMState state instates)
220 {
221             if (state.ID ==s.ID)
222 {
223                 Debug.LogError("FSM ERROR: Impossible to add state " + s.ID.ToString() + 
224                                "because state has already been added");
225                 return;
226 }
227 }
228 states.Add(s);
229 }
230  
231     /// <summary>
232     ///This method delete a state from the FSM List if it exists, 
233     ///or prints an ERROR message if the state was not on the List.
234     /// </summary>
235     public voidDeleteState(StateID id)
236 {
237         //Check for NullState before deleting
238         if (id ==StateID.NullStateID)
239 {
240             Debug.LogError("FSM ERROR: NullStateID is not allowed for a real state");
241             return;
242 }
243  
244         //Search the List and delete the state if it's inside it
245         foreach (FSMState state instates)
246 {
247             if (state.ID ==id)
248 {
249 states.Remove(state);
250                 return;
251 }
252 }
253         Debug.LogError("FSM ERROR: Impossible to delete state " + id.ToString() + 
254                        ". It was not on the list of states");
255 }
256  
257     /// <summary>
258     ///This method tries to change the state the FSM is in based on
259     ///the current state and the transition passed. If current state
260     ///doesn't have a target state for the transition passed, 
261     ///an ERROR message is printed.
262     /// </summary>
263     public voidPerformTransition(Transition trans)
264 {
265         //Check for NullTransition before changing the current state
266         if (trans ==Transition.NullTransition)
267 {
268             Debug.LogError("FSM ERROR: NullTransition is not allowed for a real transition");
269             return;
270 }
271  
272         //Check if the currentState has the transition passed as argument
273         StateID id =currentState.GetOutputState(trans);
274         if (id ==StateID.NullStateID)
275 {
276             Debug.LogError("FSM ERROR: State " + currentStateID.ToString() +  "does not have a target state " + 
277                            "for transition " +trans.ToString());
278             return;
279 }
280  
281         //Update the currentStateID and currentState        
282         currentStateID =id;
283         foreach (FSMState state instates)
284 {
285             if (state.ID ==currentStateID)
286 {
287                 //Do the post processing of the state before setting the new one
288 currentState.DoBeforeLeaving();
289  
290                 currentState =state;
291  
292                 //Reset the state to its desired condition before it can reason or act
293 currentState.DoBeforeEntering();
294                 break;
295 }
296 }
297  
298     } //PerformTransition()
299  
300 } //class FSMSystem

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;
usingUnityEngine;
 
[RequireComponent(typeof(Rigidbody))]
public classNPCControl : MonoBehaviour
{
    publicGameObject player;
    publicTransform[] path;
    privateFSMSystem fsm;
 
    public voidSetTransition(Transition t) { fsm.PerformTransition(t); }
 
    public voidStart()
    {
        MakeFSM();
    }
 
    public voidFixedUpdate()
    {
        fsm.CurrentState.Reason(player, gameObject);
        fsm.CurrentState.Act(player, gameObject);
    }
 
    //The NPC has two states: FollowPath and ChasePlayer
    //If it's on the first state and SawPlayer transition is fired, it changes to ChasePlayer
    //If it's on ChasePlayerState and LostPlayer transition is fired, it returns to FollowPath
    private voidMakeFSM()
    {
        FollowPathState follow = newFollowPathState(path);
        follow.AddTransition(Transition.SawPlayer, StateID.ChasingPlayer);
 
        ChasePlayerState chase = newChasePlayerState();
        chase.AddTransition(Transition.LostPlayer, StateID.FollowingPath);
 
        fsm = newFSMSystem();
        fsm.AddState(follow);
        fsm.AddState(chase);
    }
}
 
public classFollowPathState : FSMState
{
    private intcurrentWayPoint;
    privateTransform[] waypoints;
 
    publicFollowPathState(Transform[] wp) 
    { 
        waypoints =wp;
        currentWayPoint = 0;
        stateID =StateID.FollowingPath;
    }
 
    public override voidReason(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, outhit, 15F))
        {
            if (hit.transform.gameObject.tag == "Player")
                npc.GetComponent<NPCControl>().SetTransition(Transition.SawPlayer);
        }
    }
 
    public override voidAct(GameObject player, GameObject npc)
    {
        //Follow the path of waypoints
        //Find the direction of the current way point 
        Vector3 vel =npc.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.rigidbody.velocity =vel;
    }
 
} //FollowPathState
 
public classChasePlayerState : FSMState
{
    publicChasePlayerState()
    {
        stateID =StateID.ChasingPlayer;
    }
 
    public override voidReason(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) >= 30)
            npc.GetComponent<NPCControl>().SetTransition(Transition.LostPlayer);
    }
 
    public override voidAct(GameObject player, GameObject npc)
    {
        //Follow the path of waypoints
        //Find the direction of the player         
        Vector3 vel =npc.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.rigidbody.velocity =vel;
    }
 
} //ChasePlayerState