游戏开发中的状态机模式：从入门到精通的完整指南#

1
public enum PlayerState
2
{
3
    Idle,       // 站立
4
    Walking,    // 行走
5
    Running,    // 奔跑
6
    Jumping,    // 跳跃
7
    Attacking   // 攻击
8
}
9

10
public class Player : MonoBehaviour
11
{
12
    private PlayerState currentState = PlayerState.Idle;
13

14
    void Update()
15
    {
16
        HandleInput();
17
        UpdateState();
18
    }
19

20
    void HandleInput()
21
    {
22
        switch (currentState)
23
        {
24
            case PlayerState.Idle:
25
                if (Input.GetKey(KeyCode.W) || Input.GetKey(KeyCode.A) ||
26
                    Input.GetKey(KeyCode.S) || Input.GetKey(KeyCode.D))
27
                {
28
                    currentState = Input.GetKey(KeyCode.LeftShift)
29
                        ? PlayerState.Running
30
                        : PlayerState.Walking;
31
                }
32
                else if (Input.GetKeyDown(KeyCode.Space))
33
                {
34
                    currentState = PlayerState.Jumping;
35
                }
36
                else if (Input.GetKeyDown(KeyCode.J))
37
                {
38
                    currentState = PlayerState.Attacking;
39
                }
40
                break;
41

42
            case PlayerState.Walking:
43
            case PlayerState.Running:
44
                if (!IsMoving())
45
                {
46
                    currentState = PlayerState.Idle;
47
                }
48
                else if (Input.GetKeyDown(KeyCode.Space))
49
                {
50
                    currentState = PlayerState.Jumping;
51
                }
52
                break;
53

54
            case PlayerState.Jumping:
55
                if (IsGrounded())
56
                {
57
                    currentState = PlayerState.Idle;
58
                }
59
                break;
60

61
            case PlayerState.Attacking:
62
                if (AttackFinished())
63
                {
64
                    currentState = PlayerState.Idle;
65
                }
66
                break;
67
        }
68
    }
69

70
    void UpdateState()
71
    {
72
        switch (currentState)
73
        {
74
            case PlayerState.Idle:
75
                PlayIdleAnimation();
76
                break;
77
            case PlayerState.Walking:
78
                Move(walkSpeed);
79
                PlayWalkAnimation();
80
                break;
81
            case PlayerState.Running:
82
                Move(runSpeed);
83
                PlayRunAnimation();
84
                break;
85
            case PlayerState.Jumping:
86
                ApplyJumpPhysics();
87
                PlayJumpAnimation();
88
                break;
89
            case PlayerState.Attacking:
90
                PerformAttack();
91
                PlayAttackAnimation();
92
                break;
93
        }
94
    }
95
}

1
┌─────────────────────────────────────────────────────────────┐
2
│                      State Pattern 结构                      │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                             │
5
│  ┌─────────────┐       ┌─────────────────────────────┐     │
6
│  │   Context   │──────>│        State (抽象)          │     │
7
│  │  (持有状态)  │       │  + Enter()                   │     │
8
│  └─────────────┘       │  + Exit()                    │     │
9
│         │              │  + Update()                  │     │
10
│         │              │  + HandleInput()             │     │
11
│         ↓              └─────────────────────────────┘     │
12
│  ┌─────────────┘                    △                       │
13
│  │ currentState│          ┌─────────┴─────────┐            │
14
│  └─────────────┘          │                   │            │
15
│                    ┌──────┴──────┐     ┌──────┴──────┐     │
16
│                    │ ConcreteState│     │ ConcreteState│   │
17
│                    │   (Idle)     │     │  (Walking)   │   │
18
│                    └─────────────┘     └─────────────┘     │
19
│                                                             │
20
└─────────────────────────────────────────────────────────────┘

1
// State.cs - 状态基类
2
public abstract class State
3
{
4
    protected FSM fsm;  // 所属的状态机
5

6
    public State(FSM fsm)
7
    {
8
        this.fsm = fsm;
9
    }
10

11
    // 进入状态时调用（状态开始）
12
    public virtual void Enter() { }
13

14
    // 离开状态时调用（状态结束）
15
    public virtual void Exit() { }
16

17
    // 每帧更新
18
    public virtual void Update() { }
19

20
    // 固定时间步更新（物理相关）
21
    public virtual void FixedUpdate() { }
22

23
    // 处理输入
24
    public virtual void HandleInput() { }
25
}

1
// FSM.cs - 有限状态机
2
using System.Collections.Generic;
3

4
public class FSM
5
{
6
    protected Dictionary<int, State> states = new Dictionary<int, State>();
7
    protected State currentState;
8

9
    // 添加状态
10
    public void AddState(int key, State state)
11
    {
12
        states.Add(key, state);
13
    }
14

15
    // 获取状态
16
    public State GetState(int key)
17
    {
18
        return states[key];
19
    }
20

21
    // 设置当前状态
22
    public void SetCurrentState(State state)
23
    {
24
        // 先调用上一个状态的 Exit
25
        if (currentState != null)
26
        {
27
            currentState.Exit();
28
        }
29

30
        currentState = state;
31

32
        // 再调用新状态的 Enter
33
        if (currentState != null)
34
        {
35
            currentState.Enter();
36
        }
37
    }
38

39
    // 每帧更新
40
    public void Update()
41
    {
42
        if (currentState != null)
43
        {
44
            currentState.Update();
45
        }
46
    }
47

48
    // 物理更新
49
    public void FixedUpdate()
50
    {
51
        if (currentState != null)
52
        {
53
            currentState.FixedUpdate();
54
        }
55
    }
56

57
    // 处理输入
58
    public void HandleInput()
59
    {
60
        if (currentState != null)
61
        {
62
            currentState.HandleInput();
63
        }
64
    }
65
}

1
// PlayerIdleState.cs - 站立状态
2
public class PlayerIdleState : State
3
{
4
    private PlayerController player;
5

6
    public PlayerIdleState(FSM fsm, PlayerController player) : base(fsm)
7
    {
8
        this.player = player;
9
    }
10

11
    public override void Enter()
12
    {
13
        // 进入站立状态：播放站立动画
14
        player.PlayAnimation("Idle");
15
    }
16

17
    public override void Exit()
18
    {
19
        // 离开站立状态：可以做清理工作
20
    }
21

22
    public override void HandleInput()
23
    {
24
        // 检测是否开始移动
25
        if (player.MoveInput != Vector3.zero)
26
        {
27
            if (player.IsRunPressed)
28
            {
29
                fsm.SetCurrentState(fsm.GetState(PlayerStateID.Running));
30
            }
31
            else
32
            {
33
                fsm.SetCurrentState(fsm.GetState(PlayerStateID.Walking));
34
            }
35
            return;
36
        }
37

38
        // 检测跳跃
39
        if (player.IsJumpPressed && player.IsGrounded)
40
        {
41
            fsm.SetCurrentState(fsm.GetState(PlayerStateID.Jumping));
42
            return;
43
        }
44

45
        // 检测攻击
46
        if (player.IsAttackPressed)
47
        {
48
            fsm.SetCurrentState(fsm.GetState(PlayerStateID.Attacking));
49
            return;
50
        }
51
    }
52

53
    public override void Update()
54
    {
55
        // 站立状态的持续逻辑
56
        // 比如：站立时恢复体力
57
    }
58
}

1
// PlayerWalkingState.cs - 行走状态
2
public class PlayerWalkingState : State
3
{
4
    private PlayerController player;
5

6
    public PlayerWalkingState(FSM fsm, PlayerController player) : base(fsm)
7
    {
8
        this.player = player;
9
    }
10

11
    public override void Enter()
12
    {
13
        player.PlayAnimation("Walk");
14
    }
15

16
    public override void HandleInput()
17
    {
18
        // 停止移动 -> 切换到站立
19
        if (player.MoveInput == Vector3.zero)
20
        {
21
            fsm.SetCurrentState(fsm.GetState(PlayerStateID.Idle));
22
            return;
23
        }
24

25
        // 按住 Shift -> 切换到奔跑
26
        if (player.IsRunPressed)
27
        {
28
            fsm.SetCurrentState(fsm.GetState(PlayerStateID.Running));
29
            return;
30
        }
31

32
        // 跳跃
33
        if (player.IsJumpPressed && player.IsGrounded)
34
        {
35
            fsm.SetCurrentState(fsm.GetState(PlayerStateID.Jumping));
36
            return;
37
        }
38
    }
39

40
    public override void FixedUpdate()
41
    {
42
        player.Move(player.walkSpeed);
43
    }
44
}

1
// PlayerJumpingState.cs - 跳跃状态
2
public class PlayerJumpingState : State
3
{
4
    private PlayerController player;
5
    private bool hasJumped;
6

7
    public PlayerJumpingState(FSM fsm, PlayerController player) : base(fsm)
8
    {
9
        this.player = player;
10
    }
11

12
    public override void Enter()
13
    {
14
        player.PlayAnimation("Jump");
15
        player.Jump();
16
        hasJumped = true;
17
    }
18

19
    public override void Update()
20
    {
21
        // 等待落地
22
        if (hasJumped && player.IsGrounded)
23
        {
24
            fsm.SetCurrentState(fsm.GetState(PlayerStateID.Idle));
25
        }
26
    }
27

28
    public override void FixedUpdate()
29
    {
30
        // 跳跃时也可以空中移动（可选）
31
        player.Move(player.walkSpeed * 0.5f);
32
    }
33
}

1
// PlayerAttackingState.cs - 攻击状态
2
public class PlayerAttackingState : State
3
{
4
    private PlayerController player;
5
    private float attackDuration = 0.5f;
6
    private float attackTimer;
7

8
    public PlayerAttackingState(FSM fsm, PlayerController player) : base(fsm)
9
    {
10
        this.player = player;
11
    }
12

13
    public override void Enter()
14
    {
15
        player.PlayAnimation("Attack");
16
        attackTimer = 0f;
17

18
        // 触发攻击伤害检测等
19
        // player.PerformAttack();
20
    }
21

22
    public override void Update()
23
    {
24
        attackTimer += Time.deltaTime;
25

26
        // 攻击动画播放完毕
27
        if (attackTimer >= attackDuration)
28
        {
29
            fsm.SetCurrentState(fsm.GetState(PlayerStateID.Idle));
30
        }
31
    }
32
}

1
玩家角色状态转换图：
2

3
                    ┌──────────────────────────────────────────┐
4
                    │                                          │
5
                    ▼                                          │
6
              ┌─────────┐                                      │
7
              │  Idle   │◄─────────────────────────────┐       │
8
              └────┬────┘                              │       │
9
                   │                                   │       │
10
        移动键按下  │                                   │       │
11
                   │    Shift未按住                    │       │
12
                   ▼                                   │       │
13
              ┌─────────┐  移动键松开  ┌─────────┐     │       │
14
         ┌───>│ Walking │────────────►│  Idle   │─────┘       │
15
         │    └────┬────┘             └─────────┘             │
16
         │         │                            ▲              │
17
         │         │ Shift按住                  │              │
18
         │         ▼                            │              │
19
         │    ┌─────────┐  移动键松开           │              │
20
         │    │ Running │──────────────────────┤              │
21
         │    └────┬────┘                       │              │
22
         │         │                            │              │
23
         │         │ Space按下 (在地面)         │              │
24
         │         ▼                            │              │
25
         │    ┌─────────┐  落地                 │              │
26
         │    │ Jumping │──────────────────────┤              │
27
         │    └─────────┘                       │              │
28
         │                                      │              │
29
         │         J按下                        │              │
30
         │         │                            │              │
31
         └─────────┴──────────►┌─────────┐     │              │
32
                               │Attacking│─────┘              │
33
                               └─────────┘  攻击结束           │
34
                                                              │
35
                                                              │

1
public class ObservableFSM : FSM
2
{
3
    // 状态变化事件
4
    public event Action<State, State> OnStateChanged; // 前一个状态，新状态
5

6
    public override void SetCurrentState(State state)
7
    {
8
        State previousState = currentState;
9

10
        base.SetCurrentState(state);
11

12
        // 触发事件
13
        OnStateChanged?.Invoke(previousState, currentState);
14
    }
15
}
16

17
// 使用示例
18
fsm.OnStateChanged += (from, to) => {
19
    Debug.Log($"状态变化: {from?.GetType().Name} -> {to?.GetType().Name}");
20
    AudioManager.Instance.PlayStateChangeSound(to);
21
};

1
public class StatePool<T> where T : State, new()
2
{
3
    private Stack<T> pool = new Stack<T>();
4

5
    public T Get(FSM fsm)
6
    {
7
        T state = pool.Count > 0 ? pool.Pop() : new T();
8
        // 初始化状态...
9
        return state;
10
    }
11

12
    public void Return(T state)
13
    {
14
        // 重置状态...
15
        pool.Push(state);
16
    }
17
}