【Unity】简易有限状态机FSM实现2D人物的跑、跳、蹲、攀爬等

最新推荐文章于 2024-06-29 15:34:04 发布
最新推荐文章于 2024-06-29 15:34:04 发布
阅读量6.9k 收藏 59
点赞数 15
分类专栏： Unity 文章标签： Unity 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjj616806129/article/details/86633291
版权

不自己独立做一整个儿游戏，就不知道里面的细节(坑)数不胜数。正像鲁迅说的那句名言——不亲自吃螃蟹，就不知道螃蟹有多好吃(x)。

虽然只是一个简单的2D横版过关游戏，还是在方方面面让我焦头烂额。现在快做完了，回过头看看，简直是目不忍视，各种沙雕代码充斥其中。不管了，能跑就行(不是)。

今天记录一下游戏的核心，如何实现2D人物的跑、跳、攀爬等等状态。

人物各种状态

有限状态机,也称为FSM(Finite State Machine)，其在任意时刻都处于有限状态集合中的某一状态。当其获得一个输入字符时，将从当前状态转换到另一个状态，或者仍然保持在当前状态。

人物的运动状态用FSM实现还是比较合适的。

这里因为状态简单，就用了个超简易有限状态机。

状态类与状态机类

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

public abstract class State<T>
{
    public T owner;

    public abstract void Enter();

    public abstract void Execute();

    public abstract void Exit();  
}


public class StateMachine<T>
{
    //当前状态
    public State<T> CurrentState { get; private set; }

    //上一个状态
    //public State<T> PreviousState { get; private set; }

    //全局状态
    public State<T> GlobalState { get; private set; }

    public StateMachine(T owner ,State<T> firstState, State<T> globalState = null)
    {    
        if(globalState != null)
        {
            GlobalState = globalState;
            GlobalState.owner = owner;
            GlobalState.Enter();
        }
        
        CurrentState = firstState;
        CurrentState.owner = owner;
        CurrentState.Enter();
    }

    public void ChangeState(State<T> targetState)
    {
        if(targetState == null)
            throw new System.Exception("Can't find target state!");

        targetState.owner = CurrentState.owner;
        CurrentState.Exit();
        CurrentState = targetState;
        CurrentState.Enter();
    }

	public void SMUpDate()
    {
        if (GlobalState != null)
            GlobalState.Execute();
        if (CurrentState != null)
            CurrentState.Execute();
    }
}

PlayerControl

可以看到，状态机里只有一个全局状态和一个当前状态，全局状态用来检测player的通关和死亡。player的各种数据通过状态机的owner传给状态里。

在PlayerControl里创建一台状态机，然后把状态机的SMUpdate()放进FixedUpdate()里就行了。因为运动大部分涉及到物理检测，所以放进FixedUpdate()里用稳定的帧率刷新。

同时也在FixedUpdate()里把人物动画需要的各项参数传进去，就可以让运动和人物动画完美契合了。

另开了一个继承自ScriptableObject的类playerInfo用来储存人物的信息，这样不同的人物使用不同的PlayerInfo和同一playerControl就可以有不同的操作体验了。

using System.Collections;
using UnityEngine;

public class PlayerControl : MonoBehaviour
{
    private StateMachine<PlayerControl> _stateMachine;
    public StateMachine<PlayerControl> StateMachine
    {
        get
        {
            if (_stateMachine == null)
                _stateMachine = new StateMachine<PlayerControl>(this, PlayerIdleState.Instance, PlayerGlobalState.Instance);
            return _stateMachine;
        }
    }

    public PlayerInfo playerInfo;

    [HideInInspector]
    public Ctrl ctrl;

    [HideInInspector]
    public Rigidbody2D rgd2D;

    [HideInInspector]
    public AudioSource audioSource;

    private Animator anim;       
    
    [HideInInspector]
    public int HP;

    [HideInInspector]
    public float speedX;

    [HideInInspector]
    public float speedY;

    [HideInInspector]
    public Transform ladderTriggle;

    [HideInInspector]
    public bool isGrounded = true;

    [HideInInspector]
    public bool isJump = false;

    [HideInInspector]
    public bool isClimb = false;

    [HideInInspector]
    public bool isCrouch = false;

    [HideInInspector]
    public bool isHurt = false;

    [HideInInspector]
    public bool isEnding = false;

    [HideInInspector]
    public bool isPlayHurtAnim = false;

    [HideInInspector]
    public bool isLadderTop = false;

    private bool isFacingRight = true;

    private Transform groundCheck;
    private readonly float groundRadius = 0.1f;
    private Transform ladderCheck;
    private readonly float ladderRadius = 0.6f;

    private void Awake()
    {
        ctrl = transform.parent.GetComponent<Ctrl>();
        rgd2D = GetComponent<Rigidbody2D>();
        anim = GetComponent<Animator>();
        audioSource = GetComponent<AudioSource>();

        groundCheck = transform.Find("GroundCheck");
        ladderCheck = transform.Find("LadderCheck");        
    }

    private void Start()
    {
        HP = playerInfo.maxHP;
    }

    private void FixedUpdate()
    {
        StateMachine.SMUpDate();

        anim.SetFloat("SpeedX", Mathf.Abs(rgd2D.velocity.x));
        anim.SetFloat("SpeedY", speedY);
        anim.SetBool("isGrounded", isGrounded);
        anim.SetBool("isJump", isJump);
        anim.SetBool("isClimb", isClimb);
        anim.SetBool("isLadderTop", isLadderTop);
        anim.SetBool("isCrouch", isCrouch);
        anim.SetBool("isEnding", isEnding);
    }

空闲、奔跑、跳跃、蹲下

这几个状态是参考unity standardasset包里那个2d角色控制的跑跳蹲检测方法写的，就是创造几个空物体，设为player的子物体，然后使用OverlapCircleAll进行检测是否接地等等。

我把检测是否接地和其他的一些要在状态类里做的事情，在playerControl里写成了方法，在状态类里直接调用就好啦。还尝试写了蹩脚的英文注释，我的英文真的很烂……不过万事还是要尝试，不试试怎么知道不行呢？

PlayerIdleState

using UnityEngine;

public class PlayerIdleState : State<PlayerControl>
{
    private static PlayerIdleState _instance;
    public static PlayerIdleState Instance
    {
        get
        {
            if (_instance == null)
                _instance = new PlayerIdleState();
            return _instance;
        }
    }

    private PlayerIdleState()
    {
    }

    public override void Enter()
    {
    }

    public override void Execute()
    {
        #region check Ground

        owner.CheckLadderTopForGround();
        owner.CheckGrounded();

        #endregion


        #region change state

        if (!owner.isEnding)
        {
            if (Input.GetKey(KeyCode.LeftArrow) || Input.GetKey(KeyCode.RightArrow) || Input.GetKeyDown(KeyCode.LeftArrow) || Input.GetKeyDown(KeyCode.RightArrow))
            {
                owner.StateMachine.ChangeState(PlayerRunState.Instance);
            }
            else if (owner.isLadderTop == false && (Input.GetKeyDown(KeyCode.UpArrow) || Input.GetKey(KeyCode.UpArrow)))
            {
                owner.StateMachine.ChangeState(PlayerJumpState.Instance);
            }
            else if (owner.isLadderTop == false && Input.GetKey(KeyCode.DownArrow))
            {
                owner.StateMachine.ChangeState(PlayerCrouchState.Instance);
            }
        }
        #endregion
    }

    public override void Exit()
    {

    }
}

//Check is Grounded or not in generally
    public void CheckGrounded()
    {
        Collider2D[] colliders = Physics2D.OverlapCircleAll(groundCheck.position, groundRadius, playerInfo.Ground);
        foreach (var item in colliders)
        {
            if (item != gameObject && item.tag != "CheckLadderTop")
            {
                isGrounded = true;
                isLadderTop = false;
            }
        }
    }

//Check is it necessary to change to ClimbState in the IdleState  
    public void CheckLadderTopForGround()
    {
        Collider2D[] colliders = Physics2D.OverlapCircleAll(groundCheck.position, groundRadius, playerInfo.Ground);
        foreach (var item in colliders)
        {
            if (item.tag == "CheckLadderTop")
            {
                isLadderTop = true;
                ladderTriggle = item.transform.parent.Find("LadderTrigger");

                if (Input.GetKeyDown(KeyCode.DownArrow) || Input.GetKey(KeyCode.DownArrow))
                {
                    //Let groundCheck(a gameObject,player's childObject) far from CheckLadderTopForGround
                    //let player at the middle of the ladder
                    Vector2 newVec = transform.position;
                    newVec.x = ladderTriggle.position.x;
                    newVec.y -= 0.5f;
                    transform.position = newVec;

                    isClimb = true;
                    StateMachine.ChangeState(PlayerClimbState.Instance);
                }
            }
        }
    }

PlayerRunState

using UnityEngine;

public class PlayerRunState : State<PlayerControl>
{
    private static PlayerRunState _instance;
    public static PlayerRunState Instance
    {
        get
        {
            if (_instance == null)
                _instance = new PlayerRunState();
            return _instance;
        }
    }

    private PlayerRunState()
    {

    }

    public override void Enter()
    {

    }

    public override void Execute()
    {
        owner.HorizontalMove();


        #region change state

        if (Mathf.Abs(owner.speedX) < 0.1f || Input.GetKeyUp(KeyCode.LeftArrow) || Input.GetKeyUp(KeyCode.RightArrow))
        {
            owner.StateMachine.ChangeState(PlayerIdleState.Instance);
        }
        else if (Input.GetKeyDown(KeyCode.UpArrow) || Input.GetKey(KeyCode.UpArrow))
        {
            owner.StateMachine.ChangeState(PlayerJumpState.Instance);
        }
        else if(owner.isLadderTop == false && Input.GetKey(KeyCode.DownArrow))
        {
            owner.StateMachine.ChangeState(PlayerCrouchState.Instance);
        }

        #endregion
    }

    public override void Exit()
    {

    }   
}


 //Control player' Horizontal move when state is Run and Crouch
    public void HorizontalMove()
    {
        float moveFactor = 1; 

        if(StateMachine.CurrentState == PlayerRunState.Instance)
        {
            moveFactor = 1;
        }
        else if (StateMachine.CurrentState == PlayerCrouchState.Instance)
        {
            moveFactor = playerInfo.crouchSpeedFactor;
        }

        if (Input.GetKey(KeyCode.LeftArrow))
        {
            speedX = -playerInfo.maxSpeed * moveFactor;
        }
        else if (Input.GetKey(KeyCode.RightArrow))
        {
            speedX = playerInfo.maxSpeed * moveFactor;
        }
        else
        {
            speedX = 0;
        }

        rgd2D.velocity = new Vector2(speedX, rgd2D.velocity.y);

        if (speedX > 0 && isFacingRight == false)
        {
            HorizontalFilp();
        }
        else if (speedX < 0 && isFacingRight == true)
        {
            HorizontalFilp();
        }
    }

    //Control player' horizontal flip when state is Run and Crouch
    private void HorizontalFilp()
    {
        GetComponent<SpriteRenderer>().flipX = !GetComponent<SpriteRenderer>().flipX;
        isFacingRight = !isFacingRight;
    }

PlayerCrouchState

using UnityEngine;

public class PlayerCrouchState : State<PlayerControl>
{
    private static PlayerCrouchState _instance;
    public static PlayerCrouchState Instance
    {
        get
        {
            if (_instance == null)
                _instance = new PlayerCrouchState();
            return _instance;
        }
    }

    Collider2D[] colliders = null;

    private PlayerCrouchState()
    {
        
    }

    public override void Enter()
    {
        owner.isCrouch = true;

        if(colliders == null)
            colliders = owner.GetComponents<BoxCollider2D>();

        foreach (var item in colliders)
            item.enabled = false;
    }

    public override void Execute()
    {
        owner.HorizontalMove();

        if(!Input.GetKey(KeyCode.DownArrow) || Input.GetKeyUp(KeyCode.DownArrow))
        {
            owner.StateMachine.ChangeState(PlayerIdleState.Instance);
        }
    }

    public override void Exit()
    {
        owner.isCrouch = false;
        foreach (var item in colliders)
            item.enabled = true;
    }
}

PlayerJumpState

using UnityEngine;

public class PlayerJumpState : State<PlayerControl>
{
    private static PlayerJumpState _instance;
    public static PlayerJumpState Instance
    {
        get
        {
            if (_instance == null)
                _instance = new PlayerJumpState();
            return _instance;
        }
    }

    private PlayerJumpState()
    {

    }

    public override void Enter()
    {
        owner.ctrl.audioManager.Play(owner.ctrl.audioManager.jump, owner.audioSource);
        owner.rgd2D.AddForce(owner.playerInfo.jumpForce * Vector2.up);      
        owner.isJump = true;
        owner.isGrounded = false;      
    }

    public override void Execute()
    {
        #region check Grounded
        
        owner.CheckGrounded();
        owner.CheckLadderTopForLadder();

        if(owner.isGrounded)
        {
            owner.StateMachine.ChangeState(PlayerIdleState.Instance);
        }

        #endregion


        #region check ladder

        owner.CheckLadderTriggleForJumpState();

        if(owner.isClimb)
        {
            owner.StateMachine.ChangeState(PlayerClimbState.Instance);
        }

        #endregion
    }

    public override void Exit()
    {
        //Clear the rest of force
        owner.rgd2D.Sleep();
        owner.isJump = false;
    }   
}

//Help change to IdleState when player in the top of ladder 
    public void CheckLadderTopForLadder()
    {
        Collider2D[] colliders = Physics2D.OverlapCircleAll(groundCheck.position, groundRadius, playerInfo.Ladder);
        foreach (var item in colliders)
        {
            //Check Player is already in the top of ladder
            if (item.tag == "CheckLadderTop")
            {
                isLadderTop = true;
                isGrounded = true;
            }
        }
    }


 //Check is it necessary to change to ClimbState in the JumpState  
    public void CheckLadderTriggleForJumpState()
    {
        Collider2D[] colliders = Physics2D.OverlapCircleAll(ladderCheck.position, ladderRadius, playerInfo.Ladder);
        foreach (var item in colliders)
        {
            if (item.tag == "LadderTrigger")
            {
                ladderTriggle = item.transform;

                if (Input.GetKeyDown(KeyCode.UpArrow) || Input.GetKey(KeyCode.UpArrow))
                {
                    isClimb = true;

                    //let player at the middle of the ladder
                    Vector3 newVec = transform.position;
                    newVec.x = item.transform.position.x;
                    transform.position = newVec;
                }
            }
        }
    }

攀爬状态

攀爬状态可以说是花费时间最多的了，因为standardasset包里的2d人物控制没有攀爬……

在网上找了很久也没有找到满意的2D人物爬梯子实现代码，最后只能自己硬着头皮写了。

爬梯子真的复杂很多，要注意诸多细节：

  1. 站立(空闲)状态跳跃后按上键，如果此时碰到了梯子，则进入攀爬状态。
  2. 跑动状态跳跃后按上键，如果此时碰到了梯子，则进入攀爬状态。这与上一条不同是因为站立的跳跃动画与跑动的跳跃动画不同，不过其实都差不多，具体实现是jump状态里调用的CheckLadderTriggleForJumpState()函数。
  3. 上述两条进入攀爬状态后，要把梯子顶端的一块Ground层的方块的collider的isTrigger给置为true，否则到梯子顶就爬不上去了。而如果没有这个方块的话，在梯子上面走路又会直接掉下来。总结就是，默认这块浮动地砖不是trigger，当人物进入攀爬状态时，这块地砖变成trigger，当人物退出攀爬状态时，这块地砖又不是trigger了。
  4. 站立状态按下键，如果此时脚下是梯子顶端，那么进入攀爬状态。
  5. 从下往上爬的时候，攀爬状态的结束检测(爬梯子爬完了)是一个让人头痛的问题。
  6. 原本我是把从下往上爬的状态结束检测与站立状态的脚下梯子顶端检测放在同一个collider身上，把这个collider设置为isTrigger=true
  7. 但是！因为是使用的OverlapCircleAll分层级的进行是否接地检测，所以总是导致各种问题，要么能下不能上，要么能下不能上，最后还是老老实实的分开用两个collider检测，也分了两个层级和方法，分别是CheckLadderTopForGround()和CheckLadderTopForLadder()
  8. 还有其他一些小细节，比如人物爬上梯子后，把position.y改成跟梯子一样，否则就歪歪斜斜了。
  9. 刚刚进入攀爬状态是静止攀爬动画，如果speedY大于0，就进入动态攀爬动画。

LadderSetting

把梯子做好后弄成prefab，以后哪里要哪里搬，就不用再想这么多让人头大的问题了。层级的设置我也放在了playerInfo里。

using UnityEngine;

public class PlayerClimbState:State<PlayerControl>
{
    private static PlayerClimbState _instance;
    public static PlayerClimbState Instance
    {
        get
        {
            if (_instance == null)
                _instance = new PlayerClimbState();
            return _instance;
        }
    }

    private PlayerClimbState()
    {

    }

    public override void Enter()
    {
        owner.isGrounded = false;

        owner.speedY = owner.playerInfo.climbSpeed;
        owner.ladderTriggle.parent.Find("LadderTop").GetComponent<BoxCollider2D>().enabled = false;
    }

    public override void Execute()
    {
        //remove player's gravity
        owner.rgd2D.constraints |= RigidbodyConstraints2D.FreezePositionY;
                
        owner.CheckGrounded();
        owner.CheckLadderTopForLadder();


        #region control vertical move when player in the ladder

        if (Input.GetKey(KeyCode.UpArrow))
        {
            Vector2 tempVec = owner.transform.position;
            tempVec.y += Time.deltaTime * owner.playerInfo.climbSpeed;
            owner.transform.position = tempVec;
            owner.speedY = owner.playerInfo.climbSpeed;
        }
        else if (Input.GetKey(KeyCode.DownArrow))
        {
            Vector2 tempVec = owner.transform.position;
            tempVec.y -= Time.deltaTime * owner.playerInfo.climbSpeed;
            owner.transform.position = tempVec;
            owner.speedY = owner.playerInfo.climbSpeed;
        }
        else
        {
            owner.speedY = 0;
        }

        #endregion


        if (owner.isGrounded)
        {
            owner.rgd2D.constraints = RigidbodyConstraints2D.FreezeRotation;
            owner.StateMachine.ChangeState(PlayerIdleState.Instance);
        }        
    }

    public override void Exit()
    {
        owner.speedY = 0;
        owner.isClimb = false;

        owner.ladderTriggle.parent.Find("LadderTop").GetComponent<BoxCollider2D>().enabled = true;        
    }    
   
}

受伤状态

这一部分挺简单的，放在了全局状态里，因为无论什么状态，碰到怪物都会受伤。总而言之就是碰到怪物就减一条命并进入无敌状态一段时间，用协程做了个闪烁动画。碰撞检测和减命在工程其他部分脚本里。

public class PlayerGlobalState : State<PlayerControl>
{
    private static PlayerGlobalState _instance;
    public static PlayerGlobalState Instance
    {
        get
        {
            if (_instance == null)
                _instance = new PlayerGlobalState();
            return _instance;
        }
    }

    private PlayerGlobalState()
    {

    }
  
    public override void Enter()
    {
        
    }

    public override void Execute()
    {
        if (!owner.isPlayHurtAnim && owner.isHurt == true)
        {
            owner.HP--;
            owner.isPlayHurtAnim = true;
            owner.isHurt = false;
            owner.StartCoroutine(owner.HurtAnim());
        }

        if(owner.isEnding)
        {

        }
    }

    public override void Exit()
    {

    }
}

 //Player's hurt Animation with Coroutine
    //Player can't hurt when the hurt Animation play
    public IEnumerator HurtAnim()
    {
        Vector4 color = GetComponent<SpriteRenderer>().color;
        for (int i = 0; i < 20; i++)
        {
            if (i % 2 == 0)
                color.w = 0f;
            else
                color.w = 1f;

            GetComponent<SpriteRenderer>().color = color;
            yield return new WaitForSeconds(0.2f);
        }
       
        StopCoroutine(HurtAnim());

        isPlayHurtAnim = false;        
    }

当通关的时候，屏幕除了player周围都变黑，此时player不能控制且处于idle状态，写了一个OnPassLevel()，在工程其他部分调用。

public void OnPassLevel()
    {
        rgd2D.velocity = Vector2.zero;
        anim.SetFloat("SpeedX", 0);
        anim.SetFloat("SpeedY", 0);
        rgd2D.constraints |= RigidbodyConstraints2D.FreezePositionX;
    }

大概就这些了，其他碰撞受伤死亡检测都是在GameManager里写的，这里就不写了。放一下Unity动画状态机的图：动画状态机

希望我能尽快完成这个游戏吧……写UI脚本真的好心累啊啊啊！！！

Torta_two
关注
  • 15
    点赞
  • 踩
  • 59
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
Unity高级——状态机——有限状态机二
蓝鸥_Unity3D开发的专栏
08-29 2696
Unity高级—— 状态机——有限状态机二
Unity2D入门5 爬梯子
pancakeface的博客
03-14 3926
完整代码 public float climbspeed = 2f; private bool inLadder; public Collider2D platf; private void OnTriggerStay2D(Collider2D collision) { if (collision.tag == "Player") ...
Unity进阶第三章-有限状态机FSM(三种方法实现角色动画操作)
weixin_43853077的博客
07-21 1774
uniy进阶
Unity2D - 状态机(State Machine)详解
最新发布
qq_51222843的博客
06-29 601
在角色的生成中，由于事件的不同，动作的不同，角色会处于不同的状态中，例如对战冒险游戏，面临Boss的攻击，角色会受到例如中毒，恐惧等Debuff效果，若单纯的在一个脚本中使用if等语句进行事件处理，往往会比较冗杂，程序出现bug后也无法及时排查出问题。定义状态机作用类似于一个机器，将player的各个状态进行调配，例如类中的方法初始化状态，以及改变当前状态。
unity2D笔记-状态机控制人物
qq_43008645的博客
05-21 1278
参考了大佬文章：https://blog.csdn.net/wjj616806129/article/details/86633291 并将之前控制人物的方式改成了状态机方式。 1.引入状态机后，状态的改变变得更加明晰了，在statemachine中的fixedup对状态机的状态进行执行，所有状态都在他的onenter做更新，onexit做清理，保证了各种状态不会相互污染，避免动画出现异常。 2.方便后面的状态扩展。 （一）按键管理脚本 1.便于修改按键。 2.对于检测水平和垂直方向的输入，引入了INPUT
[转]Untiy学习 -一个简单的有限状态机(FSM)
小小姑娘
11-24 959
unity3D FSM有限状态机（状态设计模式）
Unity C# 《有限状态机》的用法教程详解
ChinarCSDN的博客
08-31 7313
Unity C# 《有限状态机》的用法教程详解 有限状态机用法教程 本文提供全流程，中文翻译。 助力快速理解 FSM 有限状态机，完成游戏状态的切换 为新手节省宝贵的时间，避免采坑！ 有限状态机简称： FSM —— 简称状态机 是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型 FSM 一共2个类，不需要挂载到游戏对象上 FSMState 状态父类，所有子类状态都继承与这个类 例如以下工程：我们要需要2个状态： 菜单状态 与 游戏状态 那么这两个类MenuState 和 Ga
Unity FSM有限状态机
05-22
Unity FSM（有限状态机）是一种在游戏开发中广泛使用的编程模型，特别适用于处理有固定行为模式的游戏对象，如NPC（非玩家角色）的行为控制、动画系统或是游戏逻辑流程的管理。在Unity中，有限状态机可以帮助开发者...
Unity工具包-可视化的简易有限状态机编辑器工具
06-17
使用Unity编辑器扩展类GraphView和UI ToolKit写出来的一个可视化简易有限状态机编辑器工具。可以在编辑器中进行拖拽进行连接前后节点的关联和分离，支持撤回和运行时可视化编辑节点状态。
Unity有限状态机Demo下载
07-28
https://blog.csdn.net/q764424567/article/details/119182977 下载前，请先看一下这篇文章
有限状态机FSM
09-19
Unity C# 《有限状态机》的用法教程详解Demo 助力快速理解 FSM 有限状态机，完成游戏状态的切换 教程地址：https://blog.csdn.net/ChinarCSDN/article/details/82263126
Unity状态机Demo
01-08
Unity3D状态机的Demo，PPG游戏中的人物动作技能释放
Unity动画状态机实现源码
08-04
FSM(Finite State Machine)，无限状态机。一个状态机就是一个设备，具有有限的状态数量，在任何给定的时间根据输入和自己预先定好的状态转换规则，从一个状态跳转到另一个状态。一个有限状态机在同一时间只能处于某一个状态。
unity2D横版冒险跳跃游戏源码
01-04
unity2D横版冒险跳跃游戏源码;
FSM：用C＃编写的分层有限状态机。 主要用于Unity
02-17
总的来说，这个名为“FSM”的项目提供了一种用C#编写的、针对Unity的分层有限状态机实现，旨在帮助开发者更高效、有序地管理游戏中的动态行为。通过深入学习和使用这个库，开发者可以提升其在游戏逻辑设计上的能力，...
Unity3d的一个状态机实现
嘿嘿
07-16 534
1.这是State的实现：public class State{    private readonly List&lt;StateTransition&gt; transitions = new List&lt;StateTransition&gt;();     protected Action StartAction { get; set; }    protected Action Sto...
【Unity3D日常开发】有限状态机的简单实现
CSDN博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
07-28 4659
推荐阅读 CSDN主页 GitHub开源地址 Unity3D插件分享 简书地址 我的个人博客 QQ群：1040082875 一、前言 Hello，大家好，我是☆恬静的小魔龙☆，正所谓学而不思则罔，思而不学则殆，最近项目开发中，人物的动作特别多，用状态机去切换感觉太麻烦，然后切换的效果也并不理想。 比如下面的状态机： 每次“走→站立→跑”，都一些卡顿，没有那么丝滑，所以就想学习一下FSM（有限状态机）。 二、有限状态机 什么是有限状态机： 如其名有限状态机，就是可以枚举出有限个状态，然后状态直接可.
Unity2D基础之人物动画、移动、跳跃
qq_43478882的博客
02-11 7514
Unity2D基础之人物动画、移动、跳跃
unity2D学习（9）爬墙、跳跃修改、组织Inspector中的属性显示
qq_40306845的博客
02-28 4137
1 爬墙 我把cling看成了climb，所以做了个爬墙的代码。 代码的思路：把角色分为在地上、在墙上、空中三种状态。在地上的时候，可以左右移动、如果碰到墙可以爬墙；在墙上的时候，可以上下爬；在空中的时候，碰到墙可以爬墙。 伪代码：（这个思路有伪代码好理解一点） 2 跳跃修改 问题：之前写的跳跃，跳跃起来之后还能够左右移动，但是喜欢角色跳起来后不能左右控制。但是不能左右控制后，跳跃的横向...
unity中什么是FSM有限状态机
05-16
在Unity中，有限状态机（FSM）是一种常见的编程模式，用于处理对象在不同状态下的行为和转换。简单来说，FSM是一种将对象行为分解为有限的状态集合的方法，每个状态都有一个相应的行为。对象可以在不同状态之间转换...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值