精华内容
下载资源
问答
  • 基于FSMUnity3D游戏动画系统的设计与实现,陈玲鸿,黄小军,本文给出了基于FSMUnity3D游戏引擎的动画系统的一种新的解决方案。用FSM技术实现智能管理动画系统,并结合Unity3D游戏开发引擎,通过�
  • 前言本文参考自:Unity3d College - Unity3D AI with State Machine (FSM), Drones, and Lasers!(视频教程)https://www.youtube.com/watch?v=YdERlPfwUb0游戏设计模式-状态模式 (译文)...

    前言

    本文参考自:

    • Unity3d College - Unity3D AI with State Machine (FSM), Drones, and Lasers!(视频教程)

      • https://www.youtube.com/watch?v=YdERlPfwUb0

    • 游戏设计模式-状态模式 (译文)

      • https://gpp.tkchu.me/state.html

    • Game Programming Patterns - State (英语原文)

      • http://gameprogrammingpatterns.com/state.html

    在阅读完本文后,请查看上述链接内容。

    本文使用的示例工程:FINCTIVE/lost-in-the-wilderness-nightmare(荒野迷踪:噩梦)欢迎Star!(https://github.com/FINCTIVE/lost-in-the-wilderness-nightmare)

    由于水平有限,文章内容可能有误,欢迎探讨、交流、或直接批评。
    ┗|`O′|┛

    本文作者: FINCTIVE
    联系邮箱: finctive@qq.com

    应用场景

    在荒野迷踪:噩梦中,敌人的行为如下图(在线运行demo):

    de04aae0f7c07146c9d2dfefa9810a8c.png


    文字描述再详细也不如你亲自打开网页玩一下 :D

    看起来可以用大大的 if{...}else if{...}else{...} 语句实现,但实际上手开发之后我发现……

    切入正题:一个状态指AI的一系列行为,例如本项目中的静止、追逐、自爆状态,可以使用一个类描述。对于一个状态,应该把处理代码写在一个类中。比如,“追逐玩家”状态相关的代码,尽量不要写到其他状态的类里面。

    解决方案

    敌人AI游戏对象截图

    cc70023c36b1183bd509a4fd37666c8c.png


    以下是状态的基类

    public abstract class BaseState : MonoBehaviour{  // 执行本状态的相关操作,返回值是下一次游戏循环的状态    public abstract BaseState Tick();    // 与本状态有关的初始化代码    public virtual void OnStateStart(){}    // 与本状态有关的退出代码    public virtual void OnStateExit(){}}

    状态机

    public class StateMachine : MonoBehaviour{    public BaseState defaultState;    [HideInInspector]public BaseState currentState;    private void Awake()    {        currentState = defaultState;    }    void FixedUpdate()    {        BaseState nextStateType = currentState.Tick();        if (nextStateType != currentState)        {            nextStateType.OnStateStart();            currentState.OnStateExit();        }        currentState = nextStateType;    }}

    我把与所有状态相关的控制脚本写在了EnemyController组件中,暴露出公共方法让状态机脚本调用。这样可以复用代码,并且让状态机的逻辑代码只负责更高一层的控制,而不管细节如何。

    以下是追逐状态的代码,其他状态同理。

    public class EnemyChasingState : BaseState{    public EnemyAttackingState enemyAttackingState;    public EnemyIdlingState enemyIdlingState;        private EnemyController _enemyController;    private void Awake()    {        _enemyController = GetComponent();    }    private static readonly int AnimMove = Animator.StringToHash("move");    public override BaseState Tick()    {        Vector3 targetPos = PlayerController.playerTransform.position;        _enemyController.MoveToTarget(targetPos);                float distanceSqrMag = (targetPos - transform.position).sqrMagnitude;        // 距离足够近,开始攻击(自爆)        if(distanceSqrMag < _enemyController.enemyInfo.startAttackingDistance*_enemyController.enemyInfo.startAttackingDistance)        {            return enemyAttackingState;        }                // 距离太远,放弃追逐        if(distanceSqrMag > _enemyController.enemyInfo.stopChasingDistance*_enemyController.enemyInfo.stopChasingDistance)        {            return enemyIdlingState;        }        return this;    }    public override void OnStateExit()    {        _enemyController.modelAnimator.SetFloat(AnimMove, 0f);    }}

    声明:发布此文是出于传递更多知识以供交流学习之目的。若有来源标注错误或侵犯了您的合法权益,请作者持权属证明与我们联系,我们将及时更正、删除,谢谢。

    作者:FINCTIVE

    来源:https://www.yuque.com/finctive/game-dev/fsm-ai

    More:【微信公众号】 u3dnotes

    d048d7aa05e7aca29557c754f80ccdfd.png

    展开全文
  • 基于unityFSM

    2018-03-23 13:24:23
    一个基于unity设计的FSM状态机代码库, 一个基于unity设计的FSM状态机代码库
  • 最近实习做了【鼠标碰撞圆圈】的游戏。 一开始游戏的执行逻辑全部是依靠 if...因此,简单的学习并使用了有限状态机(Finite State Machine, FSM)。 先看看FSM定义:具有有限数量的状态,它可以在任何给定的时间根据...

    最近实习做了【鼠标碰撞圆圈】的游戏。

    一开始游戏的执行逻辑全部是依靠 if - else嵌套,但是随着添加的功能越来越复杂,几十个if- else嵌套在一起,不仅降低了代码的可读性,而且无法实现功能和逻辑分离,最关键是逻辑有bug肉眼无法检查。因此,简单的学习并使用了有限状态机(Finite State Machine, FSM)。

    先看看FSM定义:

    具有有限数量的状态,它可以在任何给定的时间根据输入进行操作,从一个状态变换到另一个状态,或者促使一个输出或者一种行为的发生。一个有限状态机在任何瞬间只能处在一种状态

    概括一下:

    1. 有限个状态,且状态间存在转移关系。

    2. 某个时间点,有且仅有一个状态存在。

    废话不多少,先展示一下功能:

    d7f911ecd666d3d4ff4151c56970173a.gif

    状态转移图如下:

    87bc9f1f09f2468201aedc1bd949b85e.png

    为了实现FSM,最关键是要定义清楚“状态-行为-转换”,按照三步走来实现:

    第一步:定义有限状态列表(状态)

    第二步:定义状态-函数耦合逻辑(状态函数)

    第三步:写函数内容,添加状态转换(行为)

    【第一步】定义状态列表

    存在六个状态:【圆圈出现,鼠标进入圆圈、鼠标移出圆圈、任务成功、任务失败、休息 】

    public enum GameState_Enum // 枚举 状态列表
        {
            STATE_CIRCLESHOWING, // 圆圈出现
            STATE_INCIRCLE,      // cursor进入圆圈
            STATE_OUTCIRCLE,     // cursor移出圆圈
            STATE_TRIALSUCCEED,  // 任务成功
            STATE_TRIALFAIL,     // 任务失败
            STATE_BREAK          // 休息
        }; 
    

    【第二步】定义状态函数

    有了状态列表,switch 语句实现 【状态】和【行为函数】对应。

    while(1)
    {
       switch (currState)
            {
                case GameState_Enum.STATE_CIRCLESHOWING:
                    CircleShowing(); // 圆圈出现 行为函数
                    break;
    
                case GameState_Enum.STATE_INCIRCLE:
                    InCircle();     // cursor进入圆圈 行为函数
                    break;
    
                case GameState_Enum.STATE_OUTCIRCLE:
                    OutCircle();    // cursor移出圆圈 行为函数
                    break;
    
                case GameState_Enum.STATE_TRIALSUCCEED:
                    TaskSucceed();   // 任务成功 行为函数
                    break;
    
                case GameState_Enum.STATE_TRIALFAIL:
                    TaskFail();     // 任务失败 行为函数
                    break;
    
                case GameState_Enum.STATE_BREAK:
                    Break();      // 休息 行为函数
                    break;
            }
    }

    【第三步】行为函数内容,状态转移

    接下来,定义每个【行为函数】的功能。以 TaskSucceed() 为例:

    private void TaskSucceed()
    {
         // 功能
         timeLine += Time.deltaTime; // 时间轴
         /// 
            你还可以写其他功能
         ///
    
         // 状态转移       
         currState = GameState_Enum.STATE_BREAK;
    }

    完成了FSM搭建,给全局变量currState一个初始状态值,FSM就执行起来了。

    接下来就可以愉快的玩耍啦!

    展开全文
  • Unity FSM有限状态机

    2020-05-22 22:36:51
    https://blog.csdn.net/a592733740/article/details/106292148
  • Unity3D_FSM

    2018-07-14 11:18:55
    FSM有限状态机State 状态类,由机器类控制Machine 机器类,控制状态的切换、保持,状态的存储Template 模板类,继承自State类,定义了状态机的拥有着IdleState 角色所有状态中的的某个状态(通常状态),继承自Template&...

    FSM有限状态机


    简单说:

    就是让动画有三种触发状态(进入触发,保持触发,退出触发),当条件触发了"进入触发"就开始执行动画;"保持触发"就是保持动画的运行;"退出触发"就是退出动画播发,停止播放动画----这样就有了 动画的状态类State 

    但这还是不够的,还要让状态类能够自我进行识别运行起来,这样就需要一个机器来控制"动画的状态类",来执行(进入触发,保持触发,退出触发)这三个状态----控制状态的机器类Machine

    不同的动画属于不同的角色,所以还要有个模板类继承自动画的状态类State,用<T>中的T来定义所属的角色----Template<T>

    IdleState,RunState等继承自 动画的状态类State 



    State 状态类,由机器类控制
    Machine 机器类,控制状态的切换、保持,状态的存储
    Template 模板类,继承自State类,定义了状态机的拥有着
    IdleState 角色所有状态中的的某个状态(通常状态),继承自Template<PlayerControl>状态类
    PlayerControl 角色控制脚本


    State 包含了动画的进入,保持,退出这三种触发状态
    Machine 负责控制 State类中的触发状态 在什么情况下执行

            负责存储 编号-State类(例如0-IdleState)

    State基类:

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class StateBase{
    
        //状态的ID
        public int id;
    
        //状态机
        public StateMachine Machine;
    
        public StateBase(int _id)
        {
            this.id = _id;
        }
        //进入
        public virtual void OnStart(params object[] args)
        {
    
        }
        //保持
        public virtual void OnKeep(params object[] args)
        {
    
        }
        //退出
        public virtual void OnExit(params object[] args)
        {
    
        }
    }

    StateTemplate模板类:

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    
    public class StateTemplate<T> : StateBase{
        //状态的拥有者
        public T owner;
    
    
        public StateTemplate(int id, T o) : base(id)
        {
            this.owner = o;
        }
    }

    Machine机器类:

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    
    public class StateMachine{
    
    
        public Dictionary<int, StateBase> StateChche;
    
    
        //上一个状态
        public StateBase PreviousState;
        //当前状态
        public StateBase CurrentState;
    
    
        public StateMachine(StateBase _beganstate)
        {
            PreviousState = null;
            this.CurrentState = _beganstate;
    
    
            StateChche = new Dictionary<int, StateBase>();  //为集合开辟空间
    
    
            RegisterState(CurrentState);    //保存当前状态
            CurrentState.OnStart(); //当前状态.运行
        }
    
    
        //存储状态
        public void RegisterState(StateBase _state)
        {
            int id = _state.id;
            // 判断集合中是否已经存在这个状态,存在则不储存
            if (StateChche.ContainsKey(id))
            {
                return;
            }
            StateChche.Add(id, _state); //状态储存进集合
            _state.Machine = this;  //设置此状态的Machine属性为this
        }
    
    
        //状态的保持
        public void FSMUpdate()
        {
            if(CurrentState != null)
            {
                CurrentState.OnKeep();
            }
        }
    
    
        //状态的切换
        public void TransformState(int _id)
        {
            int stateid = _id;
            if(!StateChche.ContainsKey(stateid))
            {
                return;
            }
            PreviousState = CurrentState;
            CurrentState = StateChche[stateid];
            CurrentState.OnStart();
        }
    }

    IdleState类:继承自StateTemplate<T>类,T代表这个类的拥有者

                        这里IdleState类:继承自StateTemplate<PlayerControl>类

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    
    public class IdleState : StateTemplate<PlayerControl>
    {
        public IdleState(int id, PlayerControl o) : base(id, o)
        {
        }
        public override void OnStart(params object[] args)
        {
            base.OnStart(args);
            owner.ani.Play("Idel");
        }
        public override void OnKeep(params object[] args)
        {
            base.OnKeep(args);
            if(!owner.ani.IsPlaying("Idel"))
            {
                OnExit();
            }
        }
        public override void OnExit(params object[] args)
        {
            base.OnExit(args);
        }
    }

    PlayerControl脚本:(挂在到物体上执行的脚本)

    这里Attack和Run并未完成

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public enum PlayerState
    {
        Idle,
        Attack,
        Run
    }
    public class PlayerControl : MonoBehaviour {
    
        private StateMachine psm;
    
        public Animation ani;
    
        public PlayerState State = PlayerState.Idle;
    
        private void Awake()
        {
            ani = this.GetComponent<Animation>();
        }
        private void Start()
        {
            //第一句开辟空间并存储第一个动画状态机
            //后面使用RegisterState()方法存储第n动画状态机
            psm = new StateMachine(new IdleState(0, this));
            //psm.RegisterState(new Attack(1, this));
        }
        private void Update()
        {
            //进行输入判断并切换状态机
            if(Input.GetKeyDown(KeyCode.W))
            {
                State = PlayerState.Idle;
            }
            //....
            PlayAni();
        }
        void PlayAni()
        {
            switch(State)
            {
                case PlayerState.Idle:
                    psm.TransformState(0);
                    break;
            }
        }
    }
    

    初学者,还请老司机赐教

    展开全文
  • Unity FSM状态机

    2017-03-20 13:43:00
    状态类: 1 using System; 2 using System.Collections; 3 using System.Collections.Generic; 4 using UnityEngine; 5 6 public class State 7 { 8 /// <summary>... 9 //...

    状态类:

      1 using System;
      2 using System.Collections;
      3 using System.Collections.Generic;
      4 using UnityEngine;
      5 
      6 public class State 
      7 {
      8     /// <summary>
      9     /// 存储状态能够转换的列表
     10     /// </summary>
     11     protected List<Type> list = new List<Type>();
     12 
     13     /// <summary>
     14     /// 添加可转换状态到列表中存储
     15     /// </summary>
     16     /// <typeparam name="T"></typeparam>
     17     public void AddTransition<T>() where T :State
     18     {
     19         if (list.Contains(typeof(T)))
     20         {
     21             Debug.LogError("转换状态:" + typeof(T) + "已经有了对应的状态");
     22             return;
     23         }
     24         list.Add(typeof(T));
     25     }
     26 
     27     /// <summary>
     28     /// 从列表中删除某个可转换的状态
     29     /// </summary>
     30     /// <typeparam name="T"></typeparam>
     31     public void DeleteTransition<T>() where T : State
     32     {
     33         if (list.Contains(typeof(T)) == false)
     34         {
     35             Debug.LogWarning("转换条件:" + typeof(T) + "没有存在在map字典内!");
     36             return;
     37         }
     38         list.Remove(typeof(T));
     39     }
     40 
     41     /// <summary>
     42     /// 判断某个类型是否可转换
     43     /// </summary>
     44     /// <param name="type"></param>
     45     /// <returns></returns>
     46     public bool IsTransition(Type type)
     47     {
     48         if (list.Contains(type))
     49         {
     50             return true;
     51         }
     52         return false;
     53     }
     54 
     55     /// <summary>
     56     /// 状态是否启用
     57     /// </summary>
     58     public bool isActive
     59     {
     60         get { return machine.IsCurrentState(GetType()); }
     61     }
     62 
     63     /// <summary>
     64     /// 获取控制当前状态的状态机
     65     /// </summary>
     66     public MachineBehaviour machine
     67     {
     68         get;
     69         internal set;
     70     }
     71 
     72     /// <summary>
     73     /// 状态初始化
     74     /// </summary>
     75     public virtual void Initialize()
     76     {
     77 
     78     }
     79     /// <summary>
     80     /// 进入状态时执行
     81     /// </summary>
     82     public virtual void Enter()
     83     {
     84 
     85     }
     86     /// <summary>
     87     /// 状态Update时执行
     88     /// </summary>
     89     public virtual void Execute()
     90     {
     91 
     92     }
     93     /// <summary>
     94     /// 退出状态时执行
     95     /// </summary>
     96     public virtual void Exit()
     97     {
     98 
     99     }
    100     /// <summary>
    101     /// 状态FixedUpdate时执行
    102     /// </summary>
    103     public virtual void FixedExecute()
    104     {
    105 
    106     }
    107     /// <summary>
    108     /// 状态LateUpdate时执行
    109     /// </summary>
    110     public virtual void LateExecute()
    111     {
    112 
    113     }
    114 
    115     public virtual void OnCollisionEnter(Collision collision)
    116     {
    117 
    118     }
    119     public virtual void OnCollisionExit(Collision collision)
    120     {
    121 
    122     }
    123     public virtual void OnCollisionStay(Collision collision)
    124     {
    125 
    126     }
    127     public virtual void OnTriggerEnter(Collider collider)
    128     {
    129 
    130     }
    131     public virtual void OnTriggerExit(Collider collider)
    132     {
    133 
    134     }
    135     public virtual void OnTriggerStay(Collider collider)
    136     {
    137 
    138     }
    139 }
    State

    状态机类:

      1 using System;
      2 using System.Collections;
      3 using System.Collections.Generic;
      4 using UnityEngine;
      5 
      6 public abstract class MachineBehaviour : MonoBehaviour
      7 {
      8     /// <summary>
      9     /// 状态机的当前状态
     10     /// </summary>
     11     protected State currentState { get; set; }
     12 
     13     /// <summary>
     14     /// 状态机存储的状态列表
     15     /// </summary>
     16     protected Dictionary<Type, State> states = new Dictionary<Type, State>();
     17 
     18     /// <summary>
     19     /// 对状态机添加一些状态
     20     /// </summary>
     21     public abstract void AddStates();
     22 
     23     /// <summary>
     24     /// 对状态机的初始化操作
     25     /// </summary>
     26     public virtual void Initialize()
     27     {
     28         AddStates();
     29 
     30         if (currentState == null)
     31         {
     32             throw new System.Exception("状态机:" + name + "的currentState没有设置,请通过SetCurrentState()函数设置!");
     33         }
     34 
     35         // 对状态机里的每个状态进行初始化
     36         foreach (KeyValuePair<Type, State> pair in states)
     37         {
     38             pair.Value.Initialize();
     39         }
     40 
     41         currentState.Enter();
     42     }
     43 
     44     /// <summary>
     45     /// 添加一个状态到状态机
     46     /// </summary>
     47     /// <typeparam name="T"></typeparam>
     48     public void AddState<T>() where T : State, new()
     49     {
     50         if (!ContainsState<T>())
     51         {
     52             State item = new T();
     53             item.machine = this;
     54 
     55             states.Add(typeof(T), item);
     56         }
     57     }
     58 
     59     /// <summary>
     60     /// 转换状态
     61     /// </summary>
     62     /// <typeparam name="T"></typeparam>
     63     public void ChangeState<T>() where T : State
     64     {
     65         if (states[typeof(T)] == null)
     66         {
     67             throw new System.Exception("状态机查找不到状态:" + typeof(T).Name);
     68         }
     69         if (!currentState.IsTransition(typeof(T)))
     70         {
     71             throw new System.Exception("状态机查找不到状态转换条件:" + typeof(T).Name);
     72         }
     73         currentState.Exit();
     74         currentState = states[typeof(T)];
     75         currentState.Enter();
     76     }
     77 
     78     /// <summary>
     79     /// 检查状态机是否包含某个状态
     80     /// </summary>
     81     /// <typeparam name="T"></typeparam>
     82     /// <returns></returns>
     83     public bool ContainsState<T>() where T : State
     84     {
     85         return states.ContainsKey(typeof(T));
     86     }
     87 
     88     /// <summary>
     89     /// 获得状态机的当前状态
     90     /// </summary>
     91     /// <typeparam name="T"></typeparam>
     92     /// <returns></returns>
     93     public T CurrentState<T>() where T : State
     94     {
     95         return (T)currentState;
     96     }
     97 
     98     /// <summary>
     99     /// 获取状态机某个状态
    100     /// </summary>
    101     /// <typeparam name="T"></typeparam>
    102     /// <returns></returns>
    103     public T GetState<T>() where T : State
    104     {
    105         if (states[typeof(T)] == null)
    106         {
    107             throw new System.Exception("状态机:" + name + "查找不到状态:" + typeof(T).Name);
    108         }
    109         return (T)states[typeof(T)];
    110     }
    111 
    112     /// <summary>
    113     /// 判断某个状态是否为状态机当前状态
    114     /// </summary>
    115     /// <typeparam name="T"></typeparam>
    116     /// <returns></returns>
    117     public bool IsCurrentState<T>() where T : State
    118     {
    119         return (currentState.GetType() == typeof(T)) ? true : false;
    120     }
    121     public bool IsCurrentState(System.Type T) { return (currentState.GetType() == T) ? true : false; }
    122 
    123 
    124     /// <summary>
    125     /// 移除状态机所有状态
    126     /// </summary>
    127     public void RemoveAllStates()
    128     {
    129         states.Clear();
    130     }
    131 
    132     /// <summary>
    133     /// 移除状态机某个状态
    134     /// </summary>
    135     /// <typeparam name="T"></typeparam>
    136     public void RemoveState<T>() where T : State
    137     {
    138         states.Remove(typeof(T));
    139     }
    140 
    141     /// <summary>
    142     /// 设置状态机当前状态
    143     /// </summary>
    144     /// <typeparam name="T"></typeparam>
    145     public void SetCurrentState<T>() where T : State
    146     {
    147         currentState = states[typeof(T)];
    148     }
    149 
    150     public virtual void Start()
    151     {
    152         Initialize();
    153     }
    154     public virtual void Update()
    155     {
    156         currentState.Execute();
    157     }
    158     public virtual void FixedUpdate()
    159     {
    160         currentState.FixedExecute();
    161     }
    162     public virtual void LateUpdate()
    163     {
    164         currentState.LateExecute();
    165     }
    166 
    167     // 状态机传递一些特殊的操作给状态
    168     public void OnCollisionEnter(Collision collision)
    169     {
    170         currentState.OnCollisionEnter(collision);
    171     }
    172     public void OnCollisionExit(Collision collision)
    173     {
    174         currentState.OnCollisionExit(collision);
    175 
    176     }
    177     public void OnCollisionStay(Collision collision)
    178     {
    179         currentState.OnCollisionStay(collision);
    180     }
    181     public void OnTriggerEnter(Collider collider)
    182     {
    183         currentState.OnTriggerEnter(collider);
    184     }
    185     public void OnTriggerExit(Collider collider)
    186     {
    187         currentState.OnTriggerExit(collider);
    188     }
    189     public void OnTriggerStay(Collider collider)
    190     {
    191         currentState.OnTriggerStay(collider);
    192     }
    193 
    194 
    195 }
    MachineBehaviour

    案例:

     1 using System.Collections;
     2 using System.Collections.Generic;
     3 using UnityEngine;
     4 
     5 public class PlayerIdleState : State
     6 {
     7     private bool isExecute = false;
     8     private PlayerStateMachine playerMachine { get { return (PlayerStateMachine)machine; } }
     9 
    10     public override void Initialize()
    11     {
    12         AddTransition<PlayerWalkState>();
    13     }
    14 
    15     public override void Enter()
    16     {
    17         Debug.Log("PlayerIdleState Enter");
    18         isExecute = false;
    19     }
    20 
    21     public override void Execute()
    22     {
    23         if (!isExecute)
    24         {
    25             Debug.Log("PlayerIdleState Execute");
    26             isExecute = true;
    27         }
    28         if (Input.GetKeyDown(KeyCode.S))
    29         {
    30             Debug.Log("转到状态PlayerWalkState");
    31             playerMachine.ChangeState<PlayerWalkState>();
    32         }
    33     }
    34 
    35     public override void Exit()
    36     {
    37         Debug.Log("PlayerIdleState Exit");
    38     }
    39 }
    PlayerIdleState
     1 using System.Collections;
     2 using System.Collections.Generic;
     3 using UnityEngine;
     4 
     5 public class PlayerWalkState : State
     6 {
     7     private bool isExecute = false;
     8     private PlayerStateMachine playerMachine { get { return (PlayerStateMachine)machine; } }
     9 
    10     public override void Initialize()
    11     {
    12         AddTransition<PlayerIdleState>();
    13     }
    14 
    15     public override void Enter()
    16     {
    17         Debug.Log("PlayerWalkState Enter");
    18         isExecute = false;
    19     }
    20 
    21     public override void Execute()
    22     {
    23         if (!isExecute)
    24         {
    25             Debug.Log("PlayerWalkState Execute");
    26             isExecute = true;
    27         }
    28         if (Input.GetKeyDown(KeyCode.S))
    29         {
    30             Debug.Log("转到状态PlayerIdleState");
    31             playerMachine.ChangeState<PlayerIdleState>();
    32         }
    33     }
    34 
    35     public override void Exit()
    36     {
    37         Debug.Log("PlayerWalkState Exit");
    38     }
    39 }
    PlayerWalkState
     1 using System;
     2 using System.Collections;
     3 using System.Collections.Generic;
     4 using UnityEngine;
     5 
     6 public class PlayerStateMachine : MachineBehaviour {
     7 
     8     public override void AddStates()
     9     {
    10         AddState<PlayerIdleState>();
    11         AddState<PlayerWalkState>();
    12 
    13         SetCurrentState<PlayerIdleState>();
    14     }
    15 }
    PlayerStateMachine

    运行截图:

     

    转载于:https://www.cnblogs.com/SeaSwallow/p/6588289.html

    展开全文
  • Unity FSM 有限状态机

    2019-09-29 02:59:50
    翻译了一下unity wiki上对于有限状态机的案例,等有空时在详细写一下。在场景中添加两个游戏物体,一个为玩家并修改其Tag为Player,另一个为NPC为其添加NPCControl脚本,并为其将玩家角色和路径添加上去。(该案例...
  • Unity FSM(有限状态机)

    2020-04-14 01:12:47
    先看下效果: FSM ,有限状态机,一个可以枚举出有限个状态,...Unity中的Animator就是一个FSM了,不过Animator是控制角色动画播放的,什么状态的时候播放什么动画。而这里写的FSM是控制角色AI的,什么状态就做什么...
  • Unity3D 利用FSM设计相机跟随实现

    千次阅读 2017-05-13 20:34:32
    笔者介绍:姜雪伟,IT公司技术合伙人,IT高级讲师,CSDN社区专家,特邀...CSDN视频网址:http://edu.csdn.net/lecturer/144 FSM有限状态机前面已经跟读者介绍过,使用Unity3D引擎实现了动作状态以及技能切换,FSM使用
  • 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 ...
  • UnityFSM有限状态机

    2019-05-31 16:29:00
    什么是FSM FSM 即有限状态机,它是一个状态管理系统,表示一个对象的几种状态在指定条件下转移行为,即随着条件的不断改变内部状态不断地切换。 FSM用处或者使用背景 通常使用FSM去实现一些简单的AI逻辑,对于...
  • unity - FSM 有限状态机

    2019-01-08 17:30:36
    而使用FSM(有限状态机),可以轻松解决以上问题。 以下是我个人的理解,有不足或者错误的地方,还望不吝赐教。 有限状态机思想:通过传递不同的状态,控制当前人物的行为。 设计思路: 1、创建状态基类,定义...
  • FSM 有限状态机 概念 如其名,在有限的状态下,管理状态的转移的一种设计模式 基本思路 如 状态a 要切换到 状态b,需要通过中介也就是状态管理机进行切换,而不是两种状态直接切换,降低了耦合 另外每种状态...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 322
精华内容 128
关键字:

fsmunity