FSM(有限状态机)：多态
在各个小状态类中因为是在保持动作的过程中执行的退出动作，所以将退出动画的函数放在了保持动画的函数中
在各个小状态的类中判断状态是否在执行是根据动画本身的播放属性来判断的，与其它的无关，是动画自己的事情
简而言之：在英雄类中的Update中做的事情就是切换状态，而在LateUpdate(),做的事情就是时刻监测状态播放是否结束，如果结束那么就回到默认状态；如果没有就继续播放动画
第一部分构造状态机器：
第一个类：状态父类1.
using UnityEngine;
using System.Collections;
public class stateBase
{
public int ID{ get; set;}
public stateMachine nachine;//自己的状态被哪个机器控制。
public stateBase(int i)
{
this.ID = i;
}
public virtual void OnEnter(params object [] args)//参数的意思：可以传参数也可以不传参数；
{
}
public virtual void OnStay(params object [] args)
{
}
public virtual void OnExit(params object [] args)
{
}
//给每一个状态设置一个id；
//有一个要控制自己状态的状态机。
//构造函数
//虚方法（当前状态的进入，当前状态的保持，当前状态的退出）；
}
第二个类：确定这个状态机属于那个对象，继承自stateBase；
using UnityEngine;
using System.Collections;
public class
<T> : stateBase {
public T owner;
public stateTemplate (int _id, T _owner) : base (_id)
{
owner = _owner;
}
//状态的拥有者(当前状态归属于哪一个对象，有可能是英雄，有可能是敌人)；
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
}
状态的类
1，默认状态类
using UnityEngine;
using System.Collections;
public class IdleSatae : stateTemplate<Player> {
public IdleSatae (int id,Player p):base(id,p)
{
}
public override void OnEnter (params object[] args)
{
base.OnEnter (args);
owner.ani.Play ("Idle");
}
public override void OnStay (params object[] args)
{
base.OnStay (args);
if (owner.ani.IsPlaying ("Idle") == false) {
this.OnExit ();
}
}
public override void OnExit (params object[] args)
{
base.OnExit (args);
}
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
}
2，攻击状态类
using UnityEngine;
using System.Collections;
public class AttackSatae : stateTemplate<Player> {
public AttackSatae (int id,Player p):base(id,p)
{
}
public override void OnEnter (params object[] args)
{
base.OnEnter (args);
owner.ani.Play ("Attack");
}
public override void OnStay (params object[] args)//因为是在保持动作的过程中执行的退出动作，所以将退出动画的函数放在了保持动画的函数中
{
base.OnStay (args);
if (owner.ani.IsPlaying ("Attack") == false)
{
this.OnExit ();
}
}
public override void OnExit (params object[] args)
{
base.OnExit (args);
//退出的时候想办法由攻击状态回到 Idle
owner.playstate = PlayerState.Idle;
}
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
}
3，防御状态类
using UnityEngine;
using System.Collections;
public class JumpSatae : stateTemplate<Player> {
public JumpSatae (int id,Player p):base(id,p)
{
}
public override void OnEnter (params object[] args)
{
base.OnEnter (args);
owner.ani.Play ("Jump");
}
public override void OnStay (params object[] args)
{
base.OnStay (args);
if (owner.ani.IsPlaying ("Jump") == false)
{
this.OnExit ();
}
}
public override void OnExit (params object[] args)
{
base.OnExit (args);
owner.playstate = PlayerState.Idle;
//退出的时候想办法由攻击状态回到 Idle
}
}
主角：状态机类：
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class stateMachine
{
public Dictionary<int,stateBase> m_stateBase;
public stateBase m_currentStater;//记录当前状态
public stateBase m_PreviouStarter;//记录当前状态的上一个状态
//状态机器
//一个集合存储所有状态，有构造函数，存储状态方法，状态保持，最后是改变状态
//机器生产出来以后，就应该有一个默认状态被执行，所以构造函数应该传递默认的状态，并且播放它
public stateMachine(stateBase beganStarter)
{
m_PreviouStarter = null;
m_currentStater = beganStarter;
m_stateBase = new Dictionary<int, stateBase> ();
RegisterState (beganStarter);
m_currentStater.OnEnter ();
}
public void RegisterState(stateBase sb)
{
if (m_stateBase.ContainsKey (sb.ID)) {
return;
}
m_stateBase.Add (sb.ID,sb);
sb.nachine = this;//表示sb这个状态被当前状态机所控制
}
public void FSMUpdate()//保持状态
{
if (m_currentStater != null) //表示如果有这个状态就始终执行这个方法 保持住状态
{
m_currentStater.OnStay ();
}
}
public void TranslateState(int id,params object [] args)//切换状态
{
if (!m_stateBase.ContainsKey (id)) {
return;
}
m_PreviouStarter = m_currentStater;
m_currentStater = m_stateBase [id];
m_currentStater.OnEnter ();
}
}
第二部分使用状态机；
英雄类：
using UnityEngine;
using System.Collections;
public enum PlayerState
{
Idle,
Attack,
Jump,
}
public class Player : MonoBehaviour {
public stateMachine m_stateMachine;
public Animation ani;
public PlayerState playstate = PlayerState.Idle;
//记录状态
//控制机器
void Start () {
//初始化机器
m_stateMachine = new stateMachine (new IdleSatae(0,this));
//把所有状态添加到字典中，用来改变状态；
m_stateMachine.RegisterState (new AttackSatae(1,this));
m_stateMachine.RegisterState (new JumpSatae(2,this));
}
void Update () {
if (Input.GetKey (KeyCode.A)) {
playstate = PlayerState.Attack;
}
if (Input.GetKey (KeyCode.D)) {
playstate = PlayerState.Jump;
}
PlayAi ();
}
void PlayAi()
{
switch (playstate) {
case PlayerState.Idle:
m_stateMachine.TranslateState (0);
break;
case PlayerState.Attack:
m_stateMachine.TranslateState (1);
break;
case PlayerState.Jump:
m_stateMachine.TranslateState (2);
break;
default:
break;
}
}
void LateUpdate()
{
m_stateMachine.FSMUpdate ();
}
}
FSM(有限状态机)：多态
在各个小状态类中因为是在保持动作的过程中执行的退出动作，所以将退出动画的函数放在了保持动画的函数中
在各个小状态的类中判断状态是否在执行是根据动画本身的播放属性来判断的，与其它的无关，是动画自己的事情
简而言之：在英雄类中的Update中做的事情就是切换状态，而在LateUpdate(),做的事情就是时刻监测状态播放是否结束，如果结束那么就回到默认状态；如果没有就继续播放动画
第一部分构造状态机器：
第一个类：状态父类1.
using UnityEngine;
using System.Collections;
public class stateBase
{
public int ID{ get; set;}
public stateMachine nachine;//自己的状态被哪个机器控制。
public stateBase(int i)
{
this.ID = i;
}
public virtual void OnEnter(params object [] args)//参数的意思：可以传参数也可以不传参数；
{
}
public virtual void OnStay(params object [] args)
{
}
public virtual void OnExit(params object [] args)
{
}
//给每一个状态设置一个id；
//有一个要控制自己状态的状态机。
//构造函数
//虚方法（当前状态的进入，当前状态的保持，当前状态的退出）；
}
第二个类：确定这个状态机属于那个对象，继承自stateBase；
using UnityEngine;
using System.Collections;
public class
<T> : stateBase {
public T owner;
public stateTemplate (int _id, T _owner) : base (_id)
{
owner = _owner;
}
//状态的拥有者(当前状态归属于哪一个对象，有可能是英雄，有可能是敌人)；
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
}
状态的类
1，默认状态类
using UnityEngine;
using System.Collections;
public class IdleSatae : stateTemplate<Player> {
public IdleSatae (int id,Player p):base(id,p)
{
}
public override void OnEnter (params object[] args)
{
base.OnEnter (args);
owner.ani.Play ("Idle");
}
public override void OnStay (params object[] args)
{
base.OnStay (args);
if (owner.ani.IsPlaying ("Idle") == false) {
this.OnExit ();
}
}
public override void OnExit (params object[] args)
{
base.OnExit (args);
}
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
}
2，攻击状态类
using UnityEngine;
using System.Collections;
public class AttackSatae : stateTemplate<Player> {
public AttackSatae (int id,Player p):base(id,p)
{
}
public override void OnEnter (params object[] args)
{
base.OnEnter (args);
owner.ani.Play ("Attack");
}
public override void OnStay (params object[] args)//因为是在保持动作的过程中执行的退出动作，所以将退出动画的函数放在了保持动画的函数中
{
base.OnStay (args);
if (owner.ani.IsPlaying ("Attack") == false)
{
this.OnExit ();
}
}
public override void OnExit (params object[] args)
{
base.OnExit (args);
//退出的时候想办法由攻击状态回到 Idle
owner.playstate = PlayerState.Idle;
}
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
}
3，防御状态类
using UnityEngine;
using System.Collections;
public class JumpSatae : stateTemplate<Player> {
public JumpSatae (int id,Player p):base(id,p)
{
}
public override void OnEnter (params object[] args)
{
base.OnEnter (args);
owner.ani.Play ("Jump");
}
public override void OnStay (params object[] args)
{
base.OnStay (args);
if (owner.ani.IsPlaying ("Jump") == false)
{
this.OnExit ();
}
}
public override void OnExit (params object[] args)
{
base.OnExit (args);
owner.playstate = PlayerState.Idle;
//退出的时候想办法由攻击状态回到 Idle
}
}
主角：状态机类：
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class stateMachine
{
public Dictionary<int,stateBase> m_stateBase;
public stateBase m_currentStater;//记录当前状态
public stateBase m_PreviouStarter;//记录当前状态的上一个状态
//状态机器
//一个集合存储所有状态，有构造函数，存储状态方法，状态保持，最后是改变状态
//机器生产出来以后，就应该有一个默认状态被执行，所以构造函数应该传递默认的状态，并且播放它
public stateMachine(stateBase beganStarter)
{
m_PreviouStarter = null;
m_currentStater = beganStarter;
m_stateBase = new Dictionary<int, stateBase> ();
RegisterState (beganStarter);
m_currentStater.OnEnter ();
}
public void RegisterState(stateBase sb)
{
if (m_stateBase.ContainsKey (sb.ID)) {
return;
}
m_stateBase.Add (sb.ID,sb);
sb.nachine = this;//表示sb这个状态被当前状态机所控制
}
public void FSMUpdate()//保持状态
{
if (m_currentStater != null) //表示如果有这个状态就始终执行这个方法 保持住状态
{
m_currentStater.OnStay ();
}
}
public void TranslateState(int id,params object [] args)//切换状态
{
if (!m_stateBase.ContainsKey (id)) {
return;
}
m_PreviouStarter = m_currentStater;
m_currentStater = m_stateBase [id];
m_currentStater.OnEnter ();
}
}
第二部分使用状态机；
英雄类：
using UnityEngine;
using System.Collections;
public enum PlayerState
{
Idle,
Attack,
Jump,
}
public class Player : MonoBehaviour {
public stateMachine m_stateMachine;
public Animation ani;
public PlayerState playstate = PlayerState.Idle;
//记录状态
//控制机器
void Start () {
//初始化机器
m_stateMachine = new stateMachine (new IdleSatae(0,this));
//把所有状态添加到字典中，用来改变状态；
m_stateMachine.RegisterState (new AttackSatae(1,this));
m_stateMachine.RegisterState (new JumpSatae(2,this));
}
void Update () {
if (Input.GetKey (KeyCode.A)) {
playstate = PlayerState.Attack;
}
if (Input.GetKey (KeyCode.D)) {
playstate = PlayerState.Jump;
}
PlayAi ();
}
void PlayAi()
{
switch (playstate) {
case PlayerState.Idle:
m_stateMachine.TranslateState (0);
break;
case PlayerState.Attack:
m_stateMachine.TranslateState (1);
break;
case PlayerState.Jump:
m_stateMachine.TranslateState (2);
break;
default:
break;
}
}
void LateUpdate()
{
m_stateMachine.FSMUpdate ();
}
}
FSM(有限状态机)：多态
在各个小状态类中因为是在保持动作的过程中执行的退出动作，所以将退出动画的函数放在了保持动画的函数中
在各个小状态的类中判断状态是否在执行是根据动画本身的播放属性来判断的，与其它的无关，是动画自己的事情
简而言之：在英雄类中的Update中做的事情就是切换状态，而在LateUpdate(),做的事情就是时刻监测状态播放是否结束，如果结束那么就回到默认状态；如果没有就继续播放动画
第一部分构造状态机器：
第一个类：状态父类1.
using UnityEngine;
using System.Collections;
public class stateBase
{
public int ID{ get; set;}
public stateMachine nachine;//自己的状态被哪个机器控制。
public stateBase(int i)
{
this.ID = i;
}
public virtual void OnEnter(params object [] args)//参数的意思：可以传参数也可以不传参数；
{
}
public virtual void OnStay(params object [] args)
{
}
public virtual void OnExit(params object [] args)
{
}
//给每一个状态设置一个id；
//有一个要控制自己状态的状态机。
//构造函数
//虚方法（当前状态的进入，当前状态的保持，当前状态的退出）；
}
第二个类：确定这个状态机属于那个对象，继承自stateBase；
using UnityEngine;
using System.Collections;
public class
<T> : stateBase {
public T owner;
public stateTemplate (int _id, T _owner) : base (_id)
{
owner = _owner;
}
//状态的拥有者(当前状态归属于哪一个对象，有可能是英雄，有可能是敌人)；
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
}
状态的类
1，默认状态类
using UnityEngine;
using System.Collections;
public class IdleSatae : stateTemplate<Player> {
public IdleSatae (int id,Player p):base(id,p)
{
}
public override void OnEnter (params object[] args)
{
base.OnEnter (args);
owner.ani.Play ("Idle");
}
public override void OnStay (params object[] args)
{
base.OnStay (args);
if (owner.ani.IsPlaying ("Idle") == false) {
this.OnExit ();
}
}
public override void OnExit (params object[] args)
{
base.OnExit (args);
}
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
}
2，攻击状态类
using UnityEngine;
using System.Collections;
public class AttackSatae : stateTemplate<Player> {
public AttackSatae (int id,Player p):base(id,p)
{
}
public override void OnEnter (params object[] args)
{
base.OnEnter (args);
owner.ani.Play ("Attack");
}
public override void OnStay (params object[] args)//因为是在保持动作的过程中执行的退出动作，所以将退出动画的函数放在了保持动画的函数中
{
base.OnStay (args);
if (owner.ani.IsPlaying ("Attack") == false)
{
this.OnExit ();
}
}
public override void OnExit (params object[] args)
{
base.OnExit (args);
//退出的时候想办法由攻击状态回到 Idle
owner.playstate = PlayerState.Idle;
}
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
}
3，防御状态类
using UnityEngine;
using System.Collections;
public class JumpSatae : stateTemplate<Player> {
public JumpSatae (int id,Player p):base(id,p)
{
}
public override void OnEnter (params object[] args)
{
base.OnEnter (args);
owner.ani.Play ("Jump");
}
public override void OnStay (params object[] args)
{
base.OnStay (args);
if (owner.ani.IsPlaying ("Jump") == false)
{
this.OnExit ();
}
}
public override void OnExit (params object[] args)
{
base.OnExit (args);
owner.playstate = PlayerState.Idle;
//退出的时候想办法由攻击状态回到 Idle
}
}
主角：状态机类：
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class stateMachine
{
public Dictionary<int,stateBase> m_stateBase;
public stateBase m_currentStater;//记录当前状态
public stateBase m_PreviouStarter;//记录当前状态的上一个状态
//状态机器
//一个集合存储所有状态，有构造函数，存储状态方法，状态保持，最后是改变状态
//机器生产出来以后，就应该有一个默认状态被执行，所以构造函数应该传递默认的状态，并且播放它
public stateMachine(stateBase beganStarter)
{
m_PreviouStarter = null;
m_currentStater = beganStarter;
m_stateBase = new Dictionary<int, stateBase> ();
RegisterState (beganStarter);
m_currentStater.OnEnter ();
}
public void RegisterState(stateBase sb)
{
if (m_stateBase.ContainsKey (sb.ID)) {
return;
}
m_stateBase.Add (sb.ID,sb);
sb.nachine = this;//表示sb这个状态被当前状态机所控制
}
public void FSMUpdate()//保持状态
{
if (m_currentStater != null) //表示如果有这个状态就始终执行这个方法 保持住状态
{
m_currentStater.OnStay ();
}
}
public void TranslateState(int id,params object [] args)//切换状态
{
if (!m_stateBase.ContainsKey (id)) {
return;
}
m_PreviouStarter = m_currentStater;
m_currentStater = m_stateBase [id];
m_currentStater.OnEnter ();
}
}
第二部分使用状态机；
英雄类：
using UnityEngine;
using System.Collections;
public enum PlayerState
{
Idle,
Attack,
Jump,
}
public class Player : MonoBehaviour {
public stateMachine m_stateMachine;
public Animation ani;
public PlayerState playstate = PlayerState.Idle;
//记录状态
//控制机器
void Start () {
//初始化机器
m_stateMachine = new stateMachine (new IdleSatae(0,this));
//把所有状态添加到字典中，用来改变状态；
m_stateMachine.RegisterState (new AttackSatae(1,this));
m_stateMachine.RegisterState (new JumpSatae(2,this));
}
void Update () {
if (Input.GetKey (KeyCode.A)) {
playstate = PlayerState.Attack;
}
if (Input.GetKey (KeyCode.D)) {
playstate = PlayerState.Jump;
}
PlayAi ();
}
void PlayAi()
{
switch (playstate) {
case PlayerState.Idle:
m_stateMachine.TranslateState (0);
break;
case PlayerState.Attack:
m_stateMachine.TranslateState (1);
break;
case PlayerState.Jump:
m_stateMachine.TranslateState (2);
break;
default:
break;
}
}
void LateUpdate()
{
m_stateMachine.FSMUpdate ();
}
}
FSM(有限状态机)：多态
在各个小状态类中因为是在保持动作的过程中执行的退出动作，所以将退出动画的函数放在了保持动画的函数中
在各个小状态的类中判断状态是否在执行是根据动画本身的播放属性来判断的，与其它的无关，是动画自己的事情
简而言之：在英雄类中的Update中做的事情就是切换状态，而在LateUpdate(),做的事情就是时刻监测状态播放是否结束，如果结束那么就回到默认状态；如果没有就继续播放动画
第一部分构造状态机器：
第一个类：状态父类1.
using UnityEngine;
using System.Collections;
public class stateBase
{
public int ID{ get; set;}
public stateMachine nachine;//自己的状态被哪个机器控制。
public stateBase(int i)
{
this.ID = i;
}
public virtual void OnEnter(params object [] args)//参数的意思：可以传参数也可以不传参数；
{
}
public virtual void OnStay(params object [] args)
{
}
public virtual void OnExit(params object [] args)
{
}
//给每一个状态设置一个id；
//有一个要控制自己状态的状态机。
//构造函数
//虚方法（当前状态的进入，当前状态的保持，当前状态的退出）；
}
第二个类：确定这个状态机属于那个对象，继承自stateBase；
using UnityEngine;
using System.Collections;
public class
<T> : stateBase {
public T owner;
public stateTemplate (int _id, T _owner) : base (_id)
{
owner = _owner;
}
//状态的拥有者(当前状态归属于哪一个对象，有可能是英雄，有可能是敌人)；
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
}
状态的类
1，默认状态类
using UnityEngine;
using System.Collections;
public class IdleSatae : stateTemplate<Player> {
public IdleSatae (int id,Player p):base(id,p)
{
}
public override void OnEnter (params object[] args)
{
base.OnEnter (args);
owner.ani.Play ("Idle");
}
public override void OnStay (params object[] args)
{
base.OnStay (args);
if (owner.ani.IsPlaying ("Idle") == false) {
this.OnExit ();
}
}
public override void OnExit (params object[] args)
{
base.OnExit (args);
}
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
}
2，攻击状态类
using UnityEngine;
using System.Collections;
public class AttackSatae : stateTemplate<Player> {
public AttackSatae (int id,Player p):base(id,p)
{
}
public override void OnEnter (params object[] args)
{
base.OnEnter (args);
owner.ani.Play ("Attack");
}
public override void OnStay (params object[] args)//因为是在保持动作的过程中执行的退出动作，所以将退出动画的函数放在了保持动画的函数中
{
base.OnStay (args);
if (owner.ani.IsPlaying ("Attack") == false)
{
this.OnExit ();
}
}
public override void OnExit (params object[] args)
{
base.OnExit (args);
//退出的时候想办法由攻击状态回到 Idle
owner.playstate = PlayerState.Idle;
}
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
}
3，防御状态类
using UnityEngine;
using System.Collections;
public class JumpSatae : stateTemplate<Player> {
public JumpSatae (int id,Player p):base(id,p)
{
}
public override void OnEnter (params object[] args)
{
base.OnEnter (args);
owner.ani.Play ("Jump");
}
public override void OnStay (params object[] args)
{
base.OnStay (args);
if (owner.ani.IsPlaying ("Jump") == false)
{
this.OnExit ();
}
}
public override void OnExit (params object[] args)
{
base.OnExit (args);
owner.playstate = PlayerState.Idle;
//退出的时候想办法由攻击状态回到 Idle
}
}
主角：状态机类：
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class stateMachine
{
public Dictionary<int,stateBase> m_stateBase;
public stateBase m_currentStater;//记录当前状态
public stateBase m_PreviouStarter;//记录当前状态的上一个状态
//状态机器
//一个集合存储所有状态，有构造函数，存储状态方法，状态保持，最后是改变状态
//机器生产出来以后，就应该有一个默认状态被执行，所以构造函数应该传递默认的状态，并且播放它
public stateMachine(stateBase beganStarter)
{
m_PreviouStarter = null;
m_currentStater = beganStarter;
m_stateBase = new Dictionary<int, stateBase> ();
RegisterState (beganStarter);
m_currentStater.OnEnter ();
}
public void RegisterState(stateBase sb)
{
if (m_stateBase.ContainsKey (sb.ID)) {
return;
}
m_stateBase.Add (sb.ID,sb);
sb.nachine = this;//表示sb这个状态被当前状态机所控制
}
public void FSMUpdate()//保持状态
{
if (m_currentStater != null) //表示如果有这个状态就始终执行这个方法 保持住状态
{
m_currentStater.OnStay ();
}
}
public void TranslateState(int id,params object [] args)//切换状态
{
if (!m_stateBase.ContainsKey (id)) {
return;
}
m_PreviouStarter = m_currentStater;
m_currentStater = m_stateBase [id];
m_currentStater.OnEnter ();
}
}
第二部分使用状态机；
英雄类：
using UnityEngine;
using System.Collections;
public enum PlayerState
{
Idle,
Attack,
Jump,
}
public class Player : MonoBehaviour {
public stateMachine m_stateMachine;
public Animation ani;
public PlayerState playstate = PlayerState.Idle;
//记录状态
//控制机器
void Start () {
//初始化机器
m_stateMachine = new stateMachine (new IdleSatae(0,this));
//把所有状态添加到字典中，用来改变状态；
m_stateMachine.RegisterState (new AttackSatae(1,this));
m_stateMachine.RegisterState (new JumpSatae(2,this));
}
void Update () {
if (Input.GetKey (KeyCode.A)) {
playstate = PlayerState.Attack;
}
if (Input.GetKey (KeyCode.D)) {
playstate = PlayerState.Jump;
}
PlayAi ();
}
void PlayAi()
{
switch (playstate) {
case PlayerState.Idle:
m_stateMachine.TranslateState (0);
break;
case PlayerState.Attack:
m_stateMachine.TranslateState (1);
break;
case PlayerState.Jump:
m_stateMachine.TranslateState (2);
break;
default:
break;
}
}
void LateUpdate()
{
m_stateMachine.FSMUpdate ();
}
}