[游戏架构] 有限状态机的实际应用

什么是有限状态机

有限状态机（Finite State Machine，简称FSM）是一种常用的计算机科学中的建模工具，用于描述由离散状态和状态之间的转换组成的系统。它主要由一个有限的状态集合、一个初始状态、一个输入事件集合、状态之间的转换以及与每个状态相关联的输出动作组成。

简单来说，有限状态机是一种表示系统状态的方法，它将系统看做一系列状态，而每个状态都有其对应的行为和转换条件。它的应用非常广泛，包括游戏、人工智能、自动控制等领域。

怎么应用到游戏中

在游戏中，可以将各种游戏对象和游戏系统抽象为状态和转移，使用有限状态机来描述它们之间的关系，来实现游戏的逻辑和行为。

在游戏开发中，有限状态机可以应用于各种场景，例如：

角色行为控制：游戏角色的行为通常会根据不同状态来变化，例如走、跑、跳、攻击等。通过使用有限状态机来描述角色的状态和状态之间的转移，可以实现角色行为的流畅切换和控制。

NPC 行为控制：游戏中的 NPC 通常需要有一定的 AI 行为，例如巡逻、追击、攻击等。通过使用有限状态机来描述 NPC 的行为状态和转移条件，可以实现 NPC 行为的智能控制。

游戏流程控制：游戏的各个流程可以看做状态，例如登录、主界面、游戏场景等。通过使用有限状态机来描述游戏的流程状态和转移条件，可以实现游戏流程的控制和管理。

特效控制：游戏中的特效通常需要有一定的生命周期和触发条件，通过使用有限状态机来描述特效的状态和转移条件，可以实现特效的生命周期和触发控制。

在实际应用中，可以使用一些第三方工具来创建和管理有限状态机，例如 Unity3D 引擎中的 State Machine 和 PlayMaker 插件。也可以自己手动实现一个简单的有限状态机，使用代码来描述状态和转移条件。

举个例子

假设你正在制作一个角色扮演游戏，角色有几种状态：站立、行走、奔跑、攻击和防御。这些状态之间有各种转换，例如从站立到行走，从行走到奔跑，从奔跑到攻击等等。

你可以使用有限状态机（FSM）来管理这些状态。每个状态是一个节点，节点之间的转换是边。当角色执行某个动作时，FSM将当前状态转换为新的状态。

例如，当玩家按下W键时，FSM将从当前状态（例如站立或行走）转换为行走状态。当玩家按下空格键时，FSM将从当前状态（例如行走或奔跑）转换为攻击状态。

使用FSM可以使游戏状态管理更加清晰和简单，便于控制角色的状态转换，提高游戏体验。

简单的

public enum CharacterState
{
    Idle,
    Walk,
    Attack,
    Dead
}

public class Character : MonoBehaviour
{
    public CharacterState currentState;

    private void Update()
    {
        switch (currentState)
        {
            case CharacterState.Idle:
                // Do idle behavior
                break;
            case CharacterState.Walk:
                // Do walk behavior
                break;
            case CharacterState.Attack:
                // Do attack behavior
                break;
            case CharacterState.Dead:
                // Do dead behavior
                break;
            default:
                break;
        }
    }

    public void ChangeState(CharacterState newState)
    {
        currentState = newState;
    }
}

在这个例子中，我们定义了一个 CharacterState 枚举类型，其中包含了角色可能的状态：空闲、行走、攻击和死亡。在 Character 类中，我们使用一个 currentState 变量来记录当前状态。在 Update 函数中，我们根据当前状态执行相应的行为。在 ChangeState 函数中，我们可以根据需要改变状态。

使用有限状态机可以帮助我们将游戏角色的行为分离成离散的状态，使得我们更容易设计和维护游戏逻辑。

复杂一点的

public class AIController : MonoBehaviour
{
    private enum AIState
    {
        Idle,
        Patrol,
        Chase,
        Attack
    }

    private AIState currentState = AIState.Idle;
    private Transform target;
    private Vector3 lastKnownPosition;

    public float patrolSpeed = 1f;
    public float chaseSpeed = 2f;
    public float attackRange = 1.5f;
    public float sightRange = 5f;

    private void Start()
    {
        // 初始化状态机
        ChangeState(AIState.Idle);
    }

    private void Update()
    {
        // 检测目标是否可见
        if (target != null && CanSeeTarget())
        {
            lastKnownPosition = target.position;
        }

        // 根据当前状态执行对应的行为
        switch (currentState)
        {
            case AIState.Idle:
                UpdateIdleState();
                break;
            case AIState.Patrol:
                UpdatePatrolState();
                break;
            case AIState.Chase:
                UpdateChaseState();
                break;
            case AIState.Attack:
                UpdateAttackState();
                break;
        }
    }

    private void ChangeState(AIState newState)
    {
        currentState = newState;

        // 进入新状态时执行对应的行为
        switch (currentState)
        {
            case AIState.Idle:
                // 停止移动，等待一段时间后切换到巡逻状态
                StopMoving();
                Invoke("StartPatrolling", Random.Range(1f, 5f));
                break;
            case AIState.Patrol:
                // 开始巡逻
                StartPatrolling();
                break;
            case AIState.Chase:
                // 开始追击
                StartChasing();
                break;
            case AIState.Attack:
                // 开始攻击
                StartAttacking();
                break;
        }
    }

    private void UpdateIdleState()
    {
        // 无行为，等待切换状态
    }

    private void UpdatePatrolState()
    {
        // 巡逻时，移动到指定位置或随机位置
        if (IsAtDestination())
        {
            SetRandomDestination();
        }
        else
        {
            MoveTowardsDestination(patrolSpeed);
        }

        // 如果看到目标，切换到追击状态
        if (CanSeeTarget())
        {
            ChangeState(AIState.Chase);
        }
    }

    private void UpdateChaseState()
    {
        // 追击时，朝向目标并移动，如果目标跑出视野范围则记录最后的位置并切换到巡逻状态
        if (CanSeeTarget())
        {
            lastKnownPosition = target.position;
            MoveTowards(lastKnownPosition, chaseSpeed);
        }
        else if (CanRememberTarget())
        {
            MoveTowards(lastKnownPosition, chaseSpeed);
        }
        else
        {
            ChangeState(AIState.Patrol);
        }

        // 如果进入攻击范围，切换到攻击状态
        if (IsInAttackRange())
        {
            ChangeState(AIState.Attack);
        }
    }
    
	private void UpdateAttackState()
	{
   	 // 攻击时，朝向目标并攻击，如果
   	 if (target != null && CanAttackTarget(target))
   	 {
        // 转向目标
        Vector3 direction = (attackTarget.transform.position - transform.position).normalized;
        Quaternion lookRotation = Quaternion.LookRotation(new Vector3(direction.x, 0, direction.z));
        transform.rotation = Quaternion.Slerp(transform.rotation, lookRotation, Time.deltaTime * rotationSpeed);

        // 攻击目标
        if (Time.time > nextAttackTime)
        {
            nextAttackTime = Time.time + attackInterval;
            attackTarget.TakeDamage(attackDamage);
        }
    }
    else
    {
        // 没有攻击目标，进入巡逻状态
        ChangeState(AIState.Patrol);
    }
}

这是一个简单的状态机实现，主要是处理角色攻击状态。如果角色有攻击目标，就朝向目标并攻击，攻击间隔由 attackInterval 控制。如果没有攻击目标，则进入巡逻状态。

在这个状态机中，StateType.Attack 状态的实现就是上面这段代码。而其他状态的实现类似，只是处理的逻辑不同。例如 StateType.Patrol 状态可能会让角色随机巡逻，而 StateType.Idle 状态则是让角色保持静止等待指令。状态机的作用就是让这些不同的状态有机地切换，从而实现复杂的游戏逻辑。