【千锋合集】史上最全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);
}
}
712
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
