FSM 和动画管理器做的AI

最新推荐文章于 2022-07-21 22:00:47 发布
最新推荐文章于 2022-07-21 22:00:47 发布
阅读量250 收藏
点赞数
分类专栏： C# 文章标签： AI
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yuan_bowen/article/details/80214387
版权

FSM控制AI的行为切换，每次切换都通过委托给动画控制器发消息，改变AI的行为与动画。



代码:

FSM管理类：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 管理类
/// </summary>
public class FSMSystem  {
    public Dictionary<StateID, FSMState> states = new Dictionary<StateID, FSMState>();
    
    private StateID currentStateID;
    private FSMState currentState;

    /// <summary>
    /// 遍历字典  测试是使用
    /// </summary>
    public void Foreach()
    {
        foreach (var item in states)
        {
            Debug.Log("System:"+item.Key + "::" + item.Value);
        }
    }

    public void Update(GameObject obj)
    {
        if (currentState == null)
        {
            Debug.LogError(currentState+"状态为空");
            return;
        }
        currentState.Act(obj);
        currentState.Reason(obj);
    }

    /// <summary>
    /// 添加状态
    /// </summary>
    /// <param name="s">状态</param>
    public void AddState(FSMState s)
    {
        if(s==null)
        {
            Debug.LogError("FSMState为空");
            return;
        }
        if (currentState ==null)
        {
            currentState = s;
            currentStateID = s.ID;
        }
        if (states .ContainsKey (s.ID))
        {
            Debug.LogError("该状态已存在");
            return;
        }
        states.Add(s.ID, s);
    }
    /// <summary>
    /// 状态删除
    /// </summary>
    /// <param name="id"></param>
    public void DelegateState(StateID id)
    {
        if(id ==StateID .NullStateID)
        {
            Debug.LogError("无法删除空状态");
            return;
        }
        if (states .ContainsKey (id )==false)
        {
            Debug.LogError("无法删除不存在的状态");
            return;
        }
        states.Remove(id);
    }
    
    /// <summary>
    /// 状态转换
    /// </summary>
    /// <param name="trans"></param>
    public void PerfromTransition(Transition trans)
    {
       if(trans==Transition.NullTransition)
        {
            Debug.LogError("空的转换条件");
            return;
        }
        StateID id = currentState.GetOutputState(trans);

//        Debug.Log(id);

        if (id == StateID.NullStateID)
        {
            Debug.LogError("无法根据条件转换");
            return;
        }
        if (states.ContainsKey(id )==false)
        {
            Debug.LogError(id +"::状态机里不存在该转态,无法转换");
            return;
        }
        FSMState state = states[id];
        currentState.DoAdterLeaving();
        currentState = state;
        currentStateID = id;
        currentState.DoBeforEntering();
    }
}

FSM基类：


using System.Collections;
using System.Collections.Generic;
using UnityEngine;




/// <summary>
/// 状态基类
/// </summary>
public abstract   class FSMState {
    protected StateID stateID;
    public StateID ID {get{return stateID ;}}
    protected Dictionary<Transition, StateID> map = new Dictionary<Transition, StateID>();

    protected FSMSystem fsm;
    protected  int Id; 
    protected AnimatorStateInfo ani;
    protected   FSMState(FSMSystem fsm ,Transform trans)
    {
        Id = trans.GetInstanceID(); 
        
        //Debug.Log(ani );
        this.fsm = fsm;
        
    }



    /// <summary>
    /// 查错
    /// </summary>
    public void Foreach()
    {
        foreach (var item in map)
        {
            Debug.Log(item.Key + "::" + item.Value);

        }
    }

    /// <summary>
    /// 添加状态
    /// </summary>
    /// <param name="trans"></param>
    /// <param name="id"></param>
    public void Addtransition(Transition  trans,StateID id)
    {
        if (trans == Transition.NullTransition)
        {
            Debug.LogError("不允许NullTransition");
            return;
        }
        if (id  == StateID .NullStateID)
        {
            Debug.LogError("不允许Nullstate");
            return;
        }
        if (map .ContainsKey (trans ))
        {            
            Debug.LogError("已存在");
            return;
        }
        map.Add(trans, id);
        
       
    }
    /// <summary>
    /// 删除状态
    /// </summary>
    /// <param name="trans"></param>
    public void DeleteTransition(Transition trans)
    {
        if (trans == Transition.NullTransition)
        {
            Debug.LogError("不允许NullTransition");
            return;
        }
        
        if (map.ContainsKey(trans)==false )
        {
            Debug.LogError("不存在");
            return;
        }

        map.Remove(trans);
    }

    /// <summary>
    /// 判断当前状态
    /// </summary>
    /// <param name="trans"></param>
    /// <returns></returns>
    public StateID GetOutputState(Transition trans)
    {
        if (map.ContainsKey (trans))
        {
            return map[trans];
        }
        return StateID.NullStateID;
    }


    /// <summary>
    /// 进入状态之前所做的事情
    /// </summary>
    public  virtual void DoBeforEntering() { }
    /// <summary>
    /// 离开状态的时候
    /// </summary>
    public virtual void DoAdterLeaving() { }

    /// <summary>
    /// 在当前状态下要做的事情
    /// </summary>
    public abstract void Act(GameObject obj);

    /// <summary>
    /// 判断转换条件
    /// </summary>
    public abstract void  Reason(GameObject obj);
}

继承基类的状态：

    Idle

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// Idel状态
/// </summary>
public class IdelState : FSMState
{


    private Transform playerTransform;
    public float attackJvLi = 3;

    public IdelState(FSMSystem fsm, Transform trans) : base(fsm, trans)
    {
        stateID = StateID.Idel;
        playerTransform = GameObject.FindGameObjectWithTag(StringText.Player).transform;
    }



    public override void DoBeforEntering()
    {
        SelectState.Instance.OnEvent(Id, stateID);
        
        // Enemy.Instance.Enemy_Idel();
    }

    public override void Act(GameObject obj)
    {
        Quaternion q = Quaternion.LookRotation(playerTransform.position - obj.transform.position);

        obj.transform.rotation = Quaternion.Lerp(obj.transform.rotation, q, Time.deltaTime * 5);
    }

    public override void Reason(GameObject obj)
    {
        if (Vector3.Angle(obj.transform.forward, playerTransform.position - obj.transform.position) < 20)
        {
            fsm.PerfromTransition(Transition.AttackPlayer);
        }
        else if (Vector3.Distance(playerTransform.position, obj.transform.position) > attackJvLi)
        {
            fsm.PerfromTransition(Transition.LostPlayer);
        }

    }
}

动画管理器：


using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 动画状态机管理类
/// </summary>
public class StateMger  {

    // 定义一个链表来存放人物的所有状态
    // 存放人物所能拥有的所有行为状态
    private List<StateBase> mStateList = new List<StateBase>();
    // 人物所处的状态
    public StateBase mCurrentState = null;


    /// <summary>
    /// 添加状态
    /// </summary>
    /// <param name="state"></param>
    public void AddState(StateBase state)
    {
        if (!mStateList.Contains(state))
        {
            mStateList.Add(state);
            if (mStateList.Count == 1)
            {
                mCurrentState = state;
            }
        }
        
    }
    /// <summary>
    /// 删除状态
    /// </summary>
    /// <param name="state"></param>
    public void RemoveState(StateBase state) {
        if (mStateList.Contains(state))
        {
            mStateList.Remove(state);
        }
    }


    /// <summary>
    /// 更换状态
    /// </summary>
    /// <param name="state"></param>
    public void ChangeState(Type state )
    {
        foreach(StateBase s in mStateList)
        {
            if (s.GetType() == state)
            {
                if (mCurrentState != null)
                {
                    mCurrentState.OnExit();
                }
                mCurrentState = s;
                mCurrentState.OnEnter();

                break;
            }
        }
    }

    //public void Update()
    //{
    //    mCurrentState.OnUpdate(); 
    //}
}

动画基类：

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 状态机基类
/// </summary>
public abstract class StateBase  {

    // 表示每个状态所影响的那个对象
    public Transform transform = null;

    public StateBase(Transform transform)
    {
        this.transform = transform;
    }

    public abstract void OnEnter();
    public abstract void OnUpdate();
    public abstract void OnExit();

    public static implicit operator StateBase(Type v)
    {
        throw new NotImplementedException();
    }
}

继承动画基类：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Enemy_Idle : StateBase {

    public Enemy_Idle(Transform transform) : base(transform)
    {

    }

    #region
    public override void OnEnter()
    {
        this.transform.GetComponent<Animator>().SetBool(StringText.Idle, true);
    }
    public override void OnUpdate()
    {
       
    }
    public override void OnExit()
    {
        this.transform.GetComponent<Animator>().SetBool(StringText.Idle, false);
    }
    #endregion

}

连接两个管理器的单例：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SelectState
{

    #region 单例  

    private static SelectState instance;

    public static SelectState Instance
    {
        get
        {
            if (instance == null)
            {
                instance = new SelectState();
            }

            return instance;
        }
    }
    SelectState() { }

    #endregion

    //委托字典  
    Dictionary<int, Enemy> dic = new Dictionary<int, Enemy>();


    public void AddInt(int n, Enemy e)
    {
        //if(!dic .ContainsKey(n))
        //{
        dic.Add(n, e);
        //}
    }


    /// <summary>  
    /// 调用 
    /// </summary>  
    /// <param name="protoID"></param>  
    /// <param name="handler"></param>  
    public void OnEvent(int protoID, StateID state)
    {
        if (dic.ContainsKey(protoID))
        {
            switch (state)
            {
                case StateID.Attack:
                    dic[protoID].Enemy_Attack();

                    break;
                case StateID.Death:
                    dic[protoID].Enemy_Deate();

                    break;
                case StateID.Idel:
                    dic[protoID].Enemy_Idel();

                    break;
                case StateID.Patorl:
                    dic[protoID].Enemy_Walk();

                    break;
                case StateID.Chase:
                    dic[protoID].Enemy_Run();
                    break;
            }

        }
    }


    public void OnEvent(int protoID, Transition x)
    {
        if (dic.ContainsKey(protoID))
        {

            dic[protoID].fsm.PerfromTransition(x);
        }
    }
}


初始化两个管理器 
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SelectState
{

    #region 单例  

    private static SelectState instance;

    public static SelectState Instance
    {
        get
        {
            if (instance == null)
            {
                instance = new SelectState();
            }

            return instance;
        }
    }
    SelectState() { }

    #endregion

    //委托字典  
    Dictionary<int, Enemy> dic = new Dictionary<int, Enemy>();


    public void AddInt(int n, Enemy e)
    {
        //if(!dic .ContainsKey(n))
        //{
        dic.Add(n, e);
        //}
    }


    /// <summary>  
    /// 调用 
    /// </summary>  
    /// <param name="protoID"></param>  
    /// <param name="handler"></param>  
    public void OnEvent(int protoID, StateID state)
    {
        if (dic.ContainsKey(protoID))
        {
            switch (state)
            {
                case StateID.Attack:
                    dic[protoID].Enemy_Attack();

                    break;
                case StateID.Death:
                    dic[protoID].Enemy_Deate();

                    break;
                case StateID.Idel:
                    dic[protoID].Enemy_Idel();

                    break;
                case StateID.Patorl:
                    dic[protoID].Enemy_Walk();

                    break;
                case StateID.Chase:
                    dic[protoID].Enemy_Run();
                    break;
            }

        }
    }


    public void OnEvent(int protoID, Transition x)
    {
        if (dic.ContainsKey(protoID))
        {

            dic[protoID].fsm.PerfromTransition(x);
        }
    }
}


-------------------------------

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class AI_AnimationInit : MonoBehaviour
{

    public StateMger m_stateMgr;

    /// <summary> 
    /// 初始化动画状态机
    /// </summary>
    private void Start()
    {
        this.GetComponent<Enemy>().Enemy_Walk = OnJoystickDragAction;
        this.GetComponent<Enemy>().Enemy_Run = OnRun;
        this.GetComponent<Enemy>().Enemy_Attack = OnSkillButonClickAction;
        this.GetComponent<Enemy>().Enemy_Deate = Death;
        this.GetComponent<Enemy>(). Enemy_Idel = OnJoysticksUPAction;


        m_stateMgr = new StateMger();
        Enemy_Run run = new Enemy_Run(transform);
        m_stateMgr.AddState(run);
        Enemy_Idle idle = new Enemy_Idle(transform);
        m_stateMgr.AddState(idle);
        Enemy_Walk walk = new Enemy_Walk(transform);
        m_stateMgr.AddState(walk);
        Enemy_Attack attack = new Enemy_Attack(transform);
        m_stateMgr.AddState(attack);
        Enemy_Death death = new Enemy_Death(transform);
        m_stateMgr.AddState(death);



        //默认Idle状态
        m_stateMgr.ChangeState(typeof(Enemy_Walk));
    }



   



    /// <summary>
    /// 拖拽时
    /// </summary>
    /// <param name="coor"></param>
    private void OnJoystickDragAction()
    {


        //Vector3 dir = new Vector3(coor.x, 0, coor.y);
        //Quaternion q = Quaternion.LookRotation(dir);
        //transform.rotation = Quaternion.Lerp(transform.rotation, q, Time.deltaTime);
        // 人物进入RUN状态
        m_stateMgr.ChangeState(typeof(Enemy_Walk));
    }

    /// <summary>
    /// 停止移动时
    /// </summary>
    private void OnJoysticksUPAction()
    {

        // 人物进入Idle状态
        m_stateMgr.ChangeState(typeof(Enemy_Idle));
    }

    /// <summary>
    /// 看见player的时候
    /// </summary>
    private void OnRun()
    {

        m_stateMgr.ChangeState(typeof(Enemy_Run));
    }

    /// <summary>
    /// 释放技能时
    /// 
    /// </summary>
    /// <param name="arg"></param>
    private void OnSkillButonClickAction()
    {
        m_stateMgr.ChangeState(typeof(Enemy_Attack));
    }

    /// <summary>
    /// 挨打动作
    /// </summary>
    private void OnWound()
    {

    }
    /// <summary>
    /// 死亡
    /// </summary>
    private void Death()
    {
        m_stateMgr.ChangeState(typeof(Enemy_Death));
    }

    /// <summary>
    /// 持续调用OnUpdate状态
    /// </summary>
    //private void Update()
    //{
    //    m_stateMgr.Update();
    //}
}






Yuan_bowen
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
论文研究-基于FSM的Unity3D游戏动画系统的设计与实现 .pdf
08-16
基于FSM的Unity3D游戏动画系统的设计与实现，陈玲鸿，黄小军，本文给出了基于FSM和Unity3D游戏引擎的动画系统的一种新的解决方案。用FSM技术实现智能管理动画系统，并结合Unity3D游戏开发引擎，通过�
Unity中使用FSM状态机处理AI敌人追击玩家的功能
qq_38139885的博客
07-28 1228
实现的功能：AI在固定的路径上巡逻，当玩家靠近AI的视野范围时，AI会追击玩家。当玩家跑出AI的视野范围时，AI则会放弃追击继续回到原来的地方进行巡逻。 参考资料：http://wiki.unity3d.com/index.php/Finite_State_Machine. 效果： FSM基类： using System.Collections; using System.Collections.Generic; using UnityEngine; //状态转化的条件枚举 public enum Tra
C# FSM (仿Unity 中的Mecanim动画系统的状态机)
Jave.Lin 的学习笔记
03-11 2万+
FSM 精简版
FSM 旧版动画控制类，技能特效，冷却时间
JingDuiTell的博客
10-23 260
FSM 旧版动画控制类，技能特效，冷却时间动画状态机FsmState枚举FsmStateBase基类FsmIdleStateFsmRunStateFsmSkill1StateFsmRunState 状态总管理类PlayerContrl 角色管理类调用状态管理类技能按钮冷却方法1技能按钮冷却方法2控制粒子播放时间，播放完最长的时间后隐藏 动画状态机 FsmState枚举 public enum Fs...
[Unity3D] 漫谈有限状态机（FSM）
Peter的博客
06-18 489
一.为什么FSM？ FSM ，如其名有限状态机，就是说啊这是一个可以枚举出有限个状态，并且这些个状态在特定条件下能够来回切换的机器。 在小游戏里面出现的简单 AI 体验：怪物巡逻、怪物追击、目标丢失继续巡逻、发生战斗血量不足逃跑、发生战斗血量为0死亡等等，大多出自它手啦！ 另外FSM的理念又似乎随处可见，细心的你有没有在某一刻发现 Unity 的 Animator 其实就是一个有限状态机呢？ 也许了解了FSM 会不会更好的理解这个Animator组件了呢？ 二.FSM与设计模式 细节依赖抽...
FSM有限状态机demo
07-01
有限状态机（Finite State Machine, FSM）是一种数学模型，用于描述和设计具有固定数量状态的系统，这些系统根据外部输入或内部条件在不同状态之间转换。在计算机科学中，FSM广泛应用于各种领域，如编译器设计、网络...
lazy-wise-ass:网络应用程序呆滞呆板，精疲力尽，聪明的人服务于随机报价，并表现出可怕的职业道德。 创建用于尝试在Svelte中使用Wikiquote API和Web Speech API的Robot FSM和Spine动画
05-23
"Robot FSM"和"Spine动画"提到了应用程序中使用的两种技术：有限状态机（FSM）和Spine动画库。 有限状态机（FSM）是一种计算模型，用于模拟具有固定数量状态的系统，这些状态可以通过某些输入或事件进行转换。在Web...
Unity FSM有限状态机
05-22
在给定的压缩包文件"StateMachine"中，可能包含了用于实现Unity FSM的资源，如C#脚本（状态和状态管理器）、Unity的Animator Controller资产（图形化状态机编辑）或者其他辅助工具。使用这些资源，开发者可以快速...
Unity之FSM插件使用教程.rar
07-01
5. **测试和调试**：教授如何在Unity编辑器中测试FSM，以及如何定位和修复问题。 通过本教程的学习，你将掌握在Unity中运用FSM插件的方法，从而能够更高效地开发出逻辑复杂、行为丰富的游戏项目。无论你是新手还是...
Unity进阶第三章-有限状态机FSM(三种方法实现角色动画操作)
weixin_43853077的博客
07-21 1779
uniy进阶
FSMRoleCtrl.unitypackage
01-02
FSM动画控制器实现动画任意随意切换并实现附带缓冲的起跑和停止，双摇杆控制技能释放方向，附带人物模型等多个动画
有限状态机FSM详解(1)——最简单的FSM
enternalstar的博客
11-19 1万+
【基本概念】 有限状态机（finite-state machine，FSM)可以解决有限个状态转换的问题。具体的定义和相关的概念先不说，我们直接通过例子来理解。 我们知道一个角色通常会至少有idle，walk，jump，attack，dead这五种状态，我们在操作角色时角色会根据我们的操作转换为不同的状态，那么角色如何根据输入转换为相应的状态呢，这就是状态机的要解决的问题。 【我们的需求】 按I键，角色变为Idle状态，播放相应动画 按W键，角色变为walk状态，播放相应动画，也即角色开始行.
手把手教你做Unity中的FSM状态机（二）动画机
dark9spring的博客
11-05 3380
       上篇文章讲了通用状态机的实现（文末），这次讲讲如何在实际情况中去使用。这次先做一个简单的控制Animator的状态机。        鉴于我用来做动画的模型只有Idle、Run、Die三种状态，所以就较为简单，这次只是教基本的使用，下次讲如何做AI巡逻。        动画机不介绍了，这
FSM实现敌人简单AI
Yuan_bowen的博客
05-03 427
管理类：using System.Collections; using System.Collections.Generic; using UnityEngine; /// &lt;summary&gt; /// 管理类 /// &lt;/summary&gt; public class FSMSystem { public Dictionary&lt;StateID, FSMStat...
通用的FSM有限状态机（状态管理，可实现NPC简单AI）
萧然
11-13 1056
在角色状态较多，状态之间切换关系复杂时，简单的使用if...else...和switch...case...已经满足不了需求了，不仅代码结构很乱，难以扩展，别人看起来也会很费劲，这时候就需要FSM有限状态机，清晰方便的实现多状态管理 参考： unity3D FSM有限状态机（状态设计模式） 一个通用的有限状态机（FSM）框架 状态机结构示意图： 首先要拆分角色状态，列成枚举 ...
Unity动画知识之二：Animator动画状态机
热门推荐
冰与火之歌
11-09 2万+
文/拉撒路 　　上次我们讲过Unity游戏动画从入门到住院，今天我们来讲一下动画状态机。 　　好了，现在我们已经成功的导入了动画。接下来要玩的东西就很装13啦。因为大部分动画师是用不到这家伙的，需要掌握这个技能的，至少也是动画组长级别了。嗯。。。一个组只有你一个动画的，闭嘴！给你个同情的眼神。 　　这个装叉的东西就是动画状态机 　　嘛~肯定有不明真相的吃
Unity 进阶 之 实现简单(AI)的状态机（FSM）管理Npc状态
仙魁XAN
11-23 6889
Unity 进阶 之 实现简单(AI)的状态机（FSM）管理Npc状态 目录 Unity 进阶 之 实现简单(AI)的状态机（FSM）管理Npc状态 一、简单介绍 二、实现原理 三、注意事项 四、效果预览 五、实现步骤 六、关键代码 一、简单介绍 Unity 工具类，自己整理的一些游戏开发可能用到的模块，单独独立使用，方便游戏开发。 本节介绍，使用状态机，进行管理 Npc 状态切换管理，如果你有更好的方法，欢迎留言交流。 有限状态机,也称为FSM(Finite St..
【Unity 笔记】有限状态机 FSM
Mr.River的博客
05-18 1301
【Unity】 有限状态机 FSM 游戏引擎：Unity 版本：2019.4.6f1 【2017版本以上均可】 编译平台：Visual Studio 2019   一、什么是FSM   FSM 全名 [Finite State Machine]。中文名 [有限状态机]，又称 [有限状态自动机]，简称 [状态机]。 1.1 了解Animator组件   Unity为我们提供了Animator组件，便利开发者更加自主的实现更多动画的控制方式。   快捷链接：Unity Animator官方文档介绍 2.2 有
状态机FSM代码框架
yuanyuanluoluo的博客
09-09 2287
左边摇杆控制英雄移动，右边三个按钮分别是三个动画，不用animation，纯代码写 最基础的有三个类，第一个是保存英雄状态的枚举using UnityEngine; using System.Collections;#region StateType 角色的状态类型 /// <summary> /// 角色的状态类型 /// </summary> public enum StateType {
unity动画状态机底层原理是什么
最新发布
07-11
Unity的动画状态机底层原理涉及以下几个关键概念和步骤： 1. 动画状态：动画状态是指一个特定的动画片段或动画状态机中的一个...通过使用动画状态机，开发者可以管理和控制角色的动画行为，实现丰富多样的动画效果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值