当前位置：网站首页>FSM状态机
FSM状态机
2022-06-13 06:41:00 【renwen1579】
【千锋合集】史上最全Unity3D全套教程|匠心之作_哔哩哔哩_bilibili
FSM有限状态机
动画状态机只能用于动画
游戏的正常速度、2倍速、暂停
吃鸡中的
半蹲 爬行状态 走路
字典
委托
有返回值 返回bool
协程必须继承monobehavior类才可以执行
字典可以同时执行多个事件的更新状态
A函数和B函数同时执行
状态机的嵌套
17：00
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;namespace FSMFrame
{
public class State {
public State(string name){
StateName = name;
TransitionStates = new Dictionary<string, Func<bool>>();
}
/// <summary>
/// 状态名称
/// </summary>
private string StateName { get; set; }
#region Transition States Control
/// <summary>
/// 当前状态可以切换的其他状态，传入的是一个委托，返回是bool值
/// </summary>
private Dictionary<string, Func<bool>> TransitionStates { get; set; }
/// <summary>
/// 注册状态切换
/// </summary>
/// <param name="stateName">要切换的状态名称</param>
/// <param name="condition">切换的条件</param>
public void RegisterTransitionState(String stateName,Func<bool> condition) {
if (!TransitionStates.ContainsKey(stateName))
{
//添加
TransitionStates.Add(stateName, condition);
}
else {
//更新
TransitionStates[stateName] = condition;
}
}
/// <summary>
/// 取消注册切换的状态
/// </summary>
/// <param name="stateName"></param>
public void UnRegisterTransitionState(string stateName) {
if (TransitionStates.ContainsKey(stateName)) {
//移除
TransitionStates.Remove(stateName);
}
}
#endregion
#region State Machine Event
/// <summary>
/// 状态进入事件
/// </summary>
public event Action<object[]> OnStateEnter;
/// <summary>
/// 状态跟新事件【在状态过程中，持续调用】
/// </summary>
public event Action<object[]> OnStateUpdate;
/// <summary>
/// 离开状态事件
/// </summary>
public event Action<object[]> OnStateExit;
/// <summary>
/// 进入状态
/// </summary>
/// <param name="paramters"></param>
public void EnterState(object[] enterEventparamters,object[] updateEventParamters) {
if (OnStateEnter != null) {
//执行进入状态的事件
OnStateEnter(enterEventparamters);
}
//绑定当前状态的更新事件，以便后期执行
MonoHelper.Instance.AddUpdateEvent(StateName, OnStateUpdate,updateEventParamters);
}
/// <summary>
/// 离开状态
/// </summary>
/// <param name="paramters"></param>
public void ExitState(object[] paramters) {
//解除绑定当前状态的更新事件，以便后期停止执行
MonoHelper.Instance.RemoveUpdateEvent(StateName);
if (OnStateExit != null) {
//执行离开状态事件
OnStateExit(paramters);
}
}
#endregion
}
}
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace FSMFrame
{
public class MonoHelper : MonoBehaviour
{
/// <summary>
/// 状态更新模块
/// </summary>
class StateUpdateModule {
/// <summary>
/// 状态名称
/// </summary>
//public string stateName;
/// <summary>
/// 状态更新事件
/// </summary>
public Action<object[]> stateUpdateEvent;
/// <summary>
/// 触发状态更新事件的参数
/// </summary>
public object[] stateUpdateEventParamters;
public StateUpdateModule(Action<object[]> e, object[] paras) {
stateUpdateEvent = e;
stateUpdateEventParamters = paras;
}
}
/// <summary>
/// 单例脚本
/// </summary>
public static MonoHelper Instance;
private void Awake()
{
Instance = this;
StateUpdateModuleDic = new Dictionary<string, StateUpdateModule>();
}
/// <summary>
/// 更新事件执行的时间间隔
/// </summary>
[Header("更新事件执行的时间间隔")]
public float invokeInterval = -1;/// <summary>
/// 状态更新模块字典
/// </summary>
private Dictionary<string, StateUpdateModule> StateUpdateModuleDic;
/// <summary>
/// 添加更新事件
/// </summary>
/// <param name="stateName">状态名称</param>
/// <param name="updateEvent">更新事件</param>
/// <param name="updateEventParamters">更新事件执行时用的参数</param>
public void AddUpdateEvent(string stateName, Action<object[]> updateEvent, object[] updateEventParamters) {
//如果字典中存在该状态
if (StateUpdateModuleDic.ContainsKey(stateName))
{
//更新Update事件及参数
StateUpdateModuleDic[stateName] = new StateUpdateModule(updateEvent, updateEventParamters);
}
else {
//添加Update事件及参数
StateUpdateModuleDic.Add(stateName, new StateUpdateModule(updateEvent, updateEventParamters));
}
}
/// <summary>
/// 移除更新事件
/// </summary>
/// <param name="stateName"></param>
public void RemoveUpdateEvent(string stateName) {
if (StateUpdateModuleDic.ContainsKey(stateName)) {
//移除
StateUpdateModuleDic.Remove(stateName);
}}
/// <summary>
/// test
/// </summary>
/// <returns></returns>
private void Test1(object[] objs) {
Debug.Log("Test");
Debug.Log("Objs:"+objs.Length);
}
private void Test2(object[] objs)
{
Debug.Log("Test2" + objs.Length);
}
private IEnumerator Start()
{
//Test:
AddUpdateEvent(stateName:"TestState",updateEvent:Test1,updateEventParamters:new object[] { 1,2,3});
AddUpdateEvent(stateName: "NewTestState", updateEvent: Test2, updateEventParamters: new object[] { 4,5 });
while (true) {
if (invokeInterval <= 0)
{
//等一帧
yield return 0;}
else {
//等一个时间间隔
yield return new WaitForSeconds(invokeInterval);
}
//执行事件
foreach (KeyValuePair<string,StateUpdateModule> updateModule in StateUpdateModuleDic)
{
if (updateModule.Value.stateUpdateEvent != null) {
//调用该字典中的每个事件,并传递参数
updateModule.Value.stateUpdateEvent(updateModule.Value.stateUpdateEventParamters);
}
}
}
}}
}
Lambda表达式。
Lambda表达式是C#3.0的新内容，如果您之前学习的C#2.0，不认识也就不奇怪了。
给您举个例子。
例如，我定义一个委托：
delegate int Method(int a, int b);
再定义一个方法：
int Add(int a, int b)
{
return a + b;
}
我可能需要这样通过委托调用方法：
Method m += Add;
Console.WriteLine(m(2, 3));
====================================================
但如果用 Lambda 表达式：
Method m += (a ,b) => a + b;
Console.WriteLine(m(2, 3));
可以省去方法的定义。
实际上， Lambda 表达式只是简化了匿名方法的语法而已。
附 C# 2.0 的匿名方法语法：
Method m += delegate(int a, int b) { return a + b; };
Console.WriteLine(m(2, 3));
*******************************************************************************
C#中 += (s, e) => 这些字符什么意思
public MainWindow()
{
InitializeComponent();
this.Loaded += (s, e) => DiscoverKinectSensor();
this.Unloaded += (s, e) => this.kinect = null;
}
=========================================================================
state有可能是statemachine，因为statemachine是state的子类
可以实现递归，一个状态机管理几个子类状态机
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace FSMFrame
{
public class StateMachine : State
{
#region Manager States
/// <summary>
/// 被管理的状态
/// </summary>
private Dictionary<string, State> manageredStates;
/// <summary>
/// 默认状态
/// </summary>
private State defaultState;
/// <summary>
/// 当前状态
/// </summary>
private State currentState;
public StateMachine(string name) : base(name)
{
manageredStates = new Dictionary<string, State>();
//绑定初始事件
StateMachineEventBind();
}private void StateMachineEventBind() {
OnStateUpdate += CheckCurrentSTateTransition;
}
/// <summary>
/// 添加状态
/// </summary>
/// <param name="stateName"></param>
/// //通过状态名添加
public State AddState(string stateName) {
if (IsRun)
{
Debug.LogWarning("状态已经启动，不能进行状态删除");
return null;
}
if (manageredStates.ContainsKey(stateName))
{
Debug.LogWarning("该状态已存在");
return manageredStates[stateName];
}
//创建状态
State crtState = new State(stateName);
//添加状态
manageredStates.Add(stateName, crtState);
//当前添加的状态是第一个状态
if (manageredStates.Count == 1) {
//当前状态就是默认状态
defaultState = crtState;
}
return crtState;
}
/// <summary>
/// 添加状态
/// </summary>
/// <param name="crtState"></param>
public void AddState(State crtState) {
if (manageredStates.ContainsKey(crtState.StateName))
{
Debug.LogWarning("该状态已存在");
return;
}
//添加状态
manageredStates.Add(crtState.StateName, crtState);
//当前添加的状态是第一个状态
if (manageredStates.Count == 1)
{
//当前状态就是默认状态
defaultState = crtState;
}
}
/// <summary>
/// 移除状态
/// </summary>
/// <param name="stateName"></param>
public void RemoveState(string stateName) {
if (IsRun)
{
Debug.LogWarning("状态已经启动，不能进行状态删除");
return;
}
//如果当前状态在状态机内，且不是当前状态
if (manageredStates.ContainsKey(stateName)&&manageredStates[stateName]!=currentState) {
//当前要删除的状态
State crtState = manageredStates[stateName];
//移除状态
manageredStates.Remove(stateName);
//如果当前状态是默认状态
if (manageredStates[stateName] == defaultState) {
//清除上一次默认状态
defaultState = null;
//选择新的默认状态
ChooseNewDefaultState();
}
}
}
/// <summary>
/// 选择新的默认状态
/// </summary>
private void ChooseNewDefaultState() {
foreach (KeyValuePair<string,State> item in manageredStates) {
//遍历到第一个状态设置为默认状态
defaultState = item.Value;
return;
}
}
#endregion#region State Machine Event
/// <summary>
/// 状态机的进入
/// </summary>
/// <param name="enterEventparamters"></param>
/// <param name="updateEventParamters"></param>
public override void EnterState(object[] enterEventparamters, object[] updateEventParamters)
{
//先执行当前状态机的进入事件
base.EnterState(enterEventparamters, updateEventParamters);
//在执行子状态的进入
//判断是否有默认状态
if (defaultState == null) {
return;
}
//此时当前状态就是默认状态
currentState = defaultState;
//当前状态执行进入事件[进入默认的子状态]
currentState.EnterState(enterEventparamters, updateEventParamters);
}
/// <summary>
/// 状态机的离开
/// </summary>
/// <param name="paramters"></param>
public override void ExitState(object[] paramters)
{ //如果状态不为空
if (currentState != null)
{
//当前状态先离开
currentState.ExitState(paramters);
}
//状态机再离开
base.ExitState(paramters);
}
#endregion#region State Machine Check State Transition
/// <summary>
/// 检测当前状态是否满足过渡条件，满足就过渡
/// </summary>
private void CheckCurrentSTateTransition(object[] objs) {
//检测过渡事件
string targetState=currentState.CheckTransition();
//当前状态达到过渡事件满足了
if (targetState != null) {
//过渡到新状态
TransitionToState(targetState);
}
}private void TransitionToState(string targetStateName) {
//要过渡的状态是否被当前状态机所管理
if (manageredStates.ContainsKey(targetStateName)) {
//当前状态离开
currentState.ExitState(null);
//切换当前状态为新状态
currentState = manageredStates[targetStateName];
//新的当前状态执行进入
currentState.EnterState(null, null);
}
}
#endregion
}
}
全部代码
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;namespace FSMFrame
{
public class State {
public State(string name){
StateName = name;
TransitionStates = new Dictionary<string, Func<bool>>();
//绑定基础回调
StateBaseEventBind();
}
/// <summary>
/// 状态名称
/// </summary>
public string StateName { get; set; }
/// <summary>
/// 标记当前状态是否已经正在执行
/// </summary>
public bool IsRun { get; set; }
#region State Base EventBinding
private void StateBaseEventBind()
{
//进入状态标记
OnStateEnter += objects => { IsRun = true; };
OnStateExit += objects => { IsRun = false; };
}#endregion
#region Transition States Control
/// <summary>
/// 当前状态可以切换的其他状态，传入的是一个委托，返回是bool值
/// </summary>
private Dictionary<string, Func<bool>> TransitionStates { get; set; }
/// <summary>
/// 注册状态切换
/// </summary>
/// <param name="stateName">要切换的状态名称</param>
/// <param name="condition">切换的条件</param>
public void RegisterTransitionState(String stateName,Func<bool> condition) {
if (!TransitionStates.ContainsKey(stateName))
{
//添加
TransitionStates.Add(stateName, condition);
}
else {
//更新
TransitionStates[stateName] = condition;
}
}
/// <summary>
/// 取消注册切换的状态
/// </summary>
/// <param name="stateName"></param>
public void UnRegisterTransitionState(string stateName) {
if (TransitionStates.ContainsKey(stateName)) {
//移除
TransitionStates.Remove(stateName);
}
}
#endregion
#region State Machine Event
/// <summary>
/// 状态进入事件
/// </summary>
public event Action<object[]> OnStateEnter;
/// <summary>
/// 状态跟新事件【在状态过程中，持续调用】
/// </summary>
public event Action<object[]> OnStateUpdate;
/// <summary>
/// 离开状态事件
/// </summary>
public event Action<object[]> OnStateExit;
/// <summary>
/// 进入状态
/// </summary>
/// <param name="paramters"></param>
public virtual void EnterState(object[] enterEventparamters,object[] updateEventParamters) {
if (OnStateEnter != null) {
//执行进入状态的事件
OnStateEnter(enterEventparamters);
}
//绑定当前状态的更新事件，以便后期执行
MonoHelper.Instance.AddUpdateEvent(StateName, OnStateUpdate,updateEventParamters);
}
/// <summary>
/// 离开状态
/// </summary>
/// <param name="paramters"></param>
public virtual void ExitState(object[] paramters) {
//解除绑定当前状态的更新事件，以便后期停止执行
MonoHelper.Instance.RemoveUpdateEvent(StateName);
if (OnStateExit != null) {
//执行离开状态事件
OnStateExit(paramters);
}
}
#endregion#region Check Transition
/// <summary>
/// 检测状态过渡
/// </summary>
/// <returns></returns>
public string CheckTransition() {
foreach (KeyValuePair<string, Func<bool>> item in TransitionStates)
{ //执行判断条件
if (item.Value())
{
//条件满足，过渡状态
return item.Key;
}
}
return null;
}#endregion
}
}
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace FSMFrame
{
public class MonoHelper : MonoBehaviour
{
/// <summary>
/// 状态更新模块
/// </summary>
class StateUpdateModule {
/// <summary>
/// 状态名称
/// </summary>
//public string stateName;
/// <summary>
/// 状态更新事件
/// </summary>
public Action<object[]> stateUpdateEvent;
/// <summary>
/// 触发状态更新事件的参数
/// </summary>
public object[] stateUpdateEventParamters;
public StateUpdateModule(Action<object[]> e, object[] paras) {
stateUpdateEvent = e;
stateUpdateEventParamters = paras;
}
}
/// <summary>
/// 单例脚本
/// </summary>
public static MonoHelper Instance;
private void Awake()
{
Instance = this;
StateUpdateModuleDic = new Dictionary<string, StateUpdateModule>();
}
/// <summary>
/// 更新事件执行的时间间隔
/// </summary>
[Header("更新事件执行的时间间隔")]
public float invokeInterval = -1;/// <summary>
/// 状态更新模块字典
/// </summary>
private Dictionary<string, StateUpdateModule> StateUpdateModuleDic;
/// <summary>
/// 状态更新模块数组
/// </summary>
private StateUpdateModule[] stateUpdateModuleArray;private void DicToArray()
{
//实例化数组
stateUpdateModuleArray = new StateUpdateModule[StateUpdateModuleDic.Count];
//计数器
int counter = 0;
foreach (KeyValuePair<string, StateUpdateModule> item in StateUpdateModuleDic) {
//模块事件对象
stateUpdateModuleArray[counter] = item.Value;
//计数器递增
counter++;
}
}/// <summary>
/// 添加更新事件
/// </summary>
/// <param name="stateName">状态名称</param>
/// <param name="updateEvent">更新事件</param>
/// <param name="updateEventParamters">更新事件执行时用的参数</param>
public void AddUpdateEvent(string stateName, Action<object[]> updateEvent, object[] updateEventParamters) {
//如果字典中存在该状态
if (StateUpdateModuleDic.ContainsKey(stateName))
{
//更新Update事件及参数
StateUpdateModuleDic[stateName] = new StateUpdateModule(updateEvent, updateEventParamters);
}
else {
//添加Update事件及参数
StateUpdateModuleDic.Add(stateName, new StateUpdateModule(updateEvent, updateEventParamters));
}
//倒一下
DicToArray();
}
/// <summary>
/// 移除更新事件
/// </summary>
/// <param name="stateName"></param>
public void RemoveUpdateEvent(string stateName) {
if (StateUpdateModuleDic.ContainsKey(stateName)) {
//移除
StateUpdateModuleDic.Remove(stateName);
//倒一下
DicToArray();
}}
/// <summary>
/// test
/// </summary>
/// <returns></returns>
private void Test1(object[] objs) {
Debug.Log("Test");
Debug.Log("Objs:"+objs.Length);
}
private void Test2(object[] objs)
{
Debug.Log("Test2" + objs.Length);
}
private IEnumerator Start()
{
//Test:
//AddUpdateEvent(stateName:"TestState",updateEvent:Test1,updateEventParamters:new object[] { 1,2,3});
//AddUpdateEvent(stateName: "NewTestState", updateEvent: Test2, updateEventParamters: new object[] { 4,5 });
while (true) {
if (invokeInterval <= 0)
{
//等一帧
yield return 0;}
else {
//等一个时间间隔
yield return new WaitForSeconds(invokeInterval);
}
执行事件
for (int i = 0; i < stateUpdateModuleArray.Length; i++) {
if (stateUpdateModuleArray[i].stateUpdateEvent != null) {
//调用该数组中的每个事件,并传递参数
stateUpdateModuleArray[i].stateUpdateEvent(stateUpdateModuleArray[i].stateUpdateEventParamters);
}
}
//foreach (KeyValuePair<string,StateUpdateModule> updateModule in StateUpdateModuleDic)
//{
// if (updateModule.Value.stateUpdateEvent != null) {
// //调用该字典中的每个事件,并传递参数
// updateModule.Value.stateUpdateEvent(updateModule.Value.stateUpdateEventParamters);
// }
//}
}
}}
}
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace FSMFrame
{
public class StateMachine : State
{
#region Manager States
/// <summary>
/// 被管理的状态
/// </summary>
private Dictionary<string, State> manageredStates;
/// <summary>
/// 默认状态
/// </summary>
private State defaultState;
/// <summary>
/// 当前状态
/// </summary>
private State currentState;
public StateMachine(string name) : base(name)
{
manageredStates = new Dictionary<string, State>();
//绑定初始事件
StateMachineEventBind();
}private void StateMachineEventBind() {
OnStateUpdate += CheckCurrentSTateTransition;
}
/// <summary>
/// 添加状态
/// </summary>
/// <param name="stateName"></param>
/// //通过状态名添加
public State AddState(string stateName) {
if (IsRun)
{
Debug.LogWarning("状态已经启动，不能进行状态删除");
return null;
}
if (manageredStates.ContainsKey(stateName))
{
Debug.LogWarning("该状态已存在");
return manageredStates[stateName];
}
//创建状态
State crtState = new State(stateName);
//添加状态
manageredStates.Add(stateName, crtState);
//当前添加的状态是第一个状态
if (manageredStates.Count == 1) {
//当前状态就是默认状态
defaultState = crtState;
}
return crtState;
}
/// <summary>
/// 添加状态
/// </summary>
/// <param name="crtState"></param>
public void AddState(State crtState) {
if (manageredStates.ContainsKey(crtState.StateName))
{
Debug.LogWarning("该状态已存在");
return;
}
//添加状态
manageredStates.Add(crtState.StateName, crtState);
//当前添加的状态是第一个状态
if (manageredStates.Count == 1)
{
//当前状态就是默认状态
defaultState = crtState;
}
}
/// <summary>
/// 移除状态
/// </summary>
/// <param name="stateName"></param>
public void RemoveState(string stateName) {
if (IsRun)
{
Debug.LogWarning("状态已经启动，不能进行状态删除");
return;
}
//如果当前状态在状态机内，且不是当前状态
if (manageredStates.ContainsKey(stateName)&&manageredStates[stateName]!=currentState) {
//当前要删除的状态
State crtState = manageredStates[stateName];
//移除状态
manageredStates.Remove(stateName);
//如果当前状态是默认状态
if (manageredStates[stateName] == defaultState) {
//清除上一次默认状态
defaultState = null;
//选择新的默认状态
ChooseNewDefaultState();
}
}
}
/// <summary>
/// 选择新的默认状态
/// </summary>
private void ChooseNewDefaultState() {
foreach (KeyValuePair<string,State> item in manageredStates) {
//遍历到第一个状态设置为默认状态
defaultState = item.Value;
return;
}
}
#endregion#region State Machine Event
/// <summary>
/// 状态机的进入
/// </summary>
/// <param name="enterEventparamters"></param>
/// <param name="updateEventParamters"></param>
public override void EnterState(object[] enterEventparamters, object[] updateEventParamters)
{
//先执行当前状态机的进入事件
base.EnterState(enterEventparamters, updateEventParamters);
//在执行子状态的进入
//判断是否有默认状态
if (defaultState == null) {
return;
}
//此时当前状态就是默认状态
currentState = defaultState;
//当前状态执行进入事件[进入默认的子状态]
currentState.EnterState(enterEventparamters, updateEventParamters);
}
/// <summary>
/// 状态机的离开
/// </summary>
/// <param name="paramters"></param>
public override void ExitState(object[] paramters)
{ //如果状态不为空
if (currentState != null)
{
//当前状态先离开
currentState.ExitState(paramters);
}
//状态机再离开
base.ExitState(paramters);
}
#endregion#region State Machine Check State Transition
/// <summary>
/// 检测当前状态是否满足过渡条件，满足就过渡
/// </summary>
private void CheckCurrentSTateTransition(object[] objs) {
//检测过渡事件
string targetState=currentState.CheckTransition();
//当前状态达到过渡事件满足了
if (targetState != null) {
//过渡到新状态
TransitionToState(targetState);
}
}private void TransitionToState(string targetStateName) {
//要过渡的状态是否被当前状态机所管理
if (manageredStates.ContainsKey(targetStateName)) {
//当前状态离开
currentState.ExitState(null);
//切换当前状态为新状态
currentState = manageredStates[targetStateName];
//新的当前状态执行进入
currentState.EnterState(null, null);
}
}
#endregion
}
}
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using FSMFrame;public class UseFSM : MonoBehaviour {
/// <summary>
/// 总状态机
/// </summary>
private StateMachine leader;
[Range(0,10)]
[Header("速度参数")]
public float speed;
private void Start()
{
//实例化
leader = new StateMachine("leader");
//创建子状态
State idleState = new State("Idle");
State walkState = new State("Walk");
State runState = new State("Run");
//创建子状态机
StateMachine locomotionState = new StateMachine("Locomotion");
//建立状态关系
locomotionState.AddState(walkState);
locomotionState.AddState(runState);
leader.AddState(idleState);
leader.AddState(locomotionState);
//添加状态事件
leader.OnStateEnter += objects => { Debug.Log("Leader Enter!"); };
leader.OnStateUpdate += objects => { Debug.Log("Leader Update!"); };
leader.OnStateExit += objects => { Debug.Log("Leader Exit!"); };locomotionState.OnStateEnter += objects => { Debug.Log("locomotionState Enter!"); };
locomotionState.OnStateUpdate += objects => { Debug.Log("locomotionState Update!"); };
locomotionState.OnStateExit += objects => { Debug.Log("locomotionState Exit!"); };idleState.OnStateEnter += objects => { Debug.Log("idleState Enter!"); };
idleState.OnStateUpdate += objects => { Debug.Log("idleState Update!"); };
idleState.OnStateExit += objects => { Debug.Log("idleState Exit!"); };walkState.OnStateEnter += objects => { Debug.Log("walkState Enter!"); };
walkState.OnStateUpdate += objects => { Debug.Log("walkState Update!"); };
walkState.OnStateExit += objects => { Debug.Log("walkState Exit!"); };runState.OnStateEnter += objects => { Debug.Log("runState Enter!"); };
runState.OnStateUpdate += objects => { Debug.Log("runState Update!"); };
runState.OnStateExit += objects => { Debug.Log("runState Exit!"); };//添加状态过渡关系
idleState.RegisterTransitionState("Locomotion", () => {return speed > 1; });
locomotionState.RegisterTransitionState("Idle", () => { return speed <= 1; });
walkState.RegisterTransitionState("Run", () => { return speed > 5;});
runState.RegisterTransitionState("Walk",()=> { return speed <= 5; });//启动状态机
leader.EnterState(null, null);
}
}
边栏推荐
- Ijkplayer compilation process record
- MySQL系列之分库分表学习笔记
- Time formatting tool ----moment JS (real time display of web page time)
- The causes of font and style enlargement when the applet is horizontal have been solved
- 105. 从前序与中序遍历序列构造二叉树
- 数据在内存中的存储（C语言）
- Analysis of synchronized
- Smart finance is upgraded again, and jinglianwen technology provides data collection and labeling services
- Kotlin collaboration -- context and exception handling
- Soup side (8)
猜你喜欢
MySQL系列之分库分表学习笔记
树莓派高级开发——“IO口驱动代码的编写“ 包含总线地址、物理_虚拟地址、BCM2835芯片手册知识
![[SketchUp 2021] sketch master's image output and rendering style description [edge setting, plane setting, background setting, watermark setting, modeling setting, sky background creating sky, creatin](/img/95/a86b461c547bab41b2053073275d24.png)
[SketchUp 2021] sketch master's image output and rendering style description [edge setting, plane setting, background setting, watermark setting, modeling setting, sky background creating sky, creatin
测试开发程序员，你还在迷茫吗？不能把自己定义为码农......
上位机开发（固件下载软件之详细设计）
JS case Xiaomi second kill countdown New Year Countdown
How to quickly support the team leader to attract new fission users in the business marketing mode of group rebate?
15、 IO stream (I)
Detailed Mr Atlas of hip joint (Reprinted)
Gold jewelry enterprise operation mode, beautiful tiantians business solution
随机推荐
BlockingQueue source code
MySQL系列之分库分表学习笔记
JetPack - - - LifeCycle、ViewModel、LiveData
Kotlin basic definition class, initialization and inheritance
Notes on wechat applet development
[virtual machine] VMware virtual machine occupies too much space. Solution
Ffmpeg compressed video.
Chain 2+1 reward, what kind of mode is beautiful everyday seconds?
[cloud native | kubernetes] kubernetes configuration
Intelligent entertainment has developed steadily, and jinglianwen technology provides data collection and labeling services
Soup side (8)
【騰訊阿裏最全面試題集錦】（四面：3輪技術+1輪HR）
上位机开发（固件下载软件之编码调试）
Kotlin collaboration -- context and exception handling
[SketchUp 2021] sketch master's image output and rendering style description [edge setting, plane setting, background setting, watermark setting, modeling setting, sky background creating sky, creatin
Pngquant batch bat and parameter description
The new business outlet of beautiful Tiantian second mode will be popular in the Internet e-commerce market
What is the essence of social e-commerce disruption? How can businesses get more traffic?
智能金融再升级，景联文科技提供数据采集标注服务
Data storage in memory (C language)