游戏开发常用设计模式完全指南

1
public class GameManager : MonoBehaviour
2
{
3
    public static GameManager Instance { get; private set; }
4

5
    private void Awake()
6
    {
7
        if (Instance != null && Instance != this)
8
        {
9
            Destroy(gameObject);
10
            return;
11
        }
12
        Instance = this;
13
        DontDestroyOnLoad(gameObject);
14
    }
15
}

1
// 事件参数
2
public class PlayerHealthChangedEvent
3
{
4
    public int CurrentHealth;
5
    public int MaxHealth;
6
}
7

8
// 事件管理器
9
public class EventManager
10
{
11
    public static EventManager Instance { get; private set; }
12

13
    private Dictionary<string, List<System.Action<object>>> _listeners = new();
14

15
    public void Subscribe(string eventName, System.Action<object> callback)
16
    {
17
        if (!_listeners.ContainsKey(eventName))
18
            _listeners[eventName] = new List<System.Action<object>>();
19
        _listeners[eventName].Add(callback);
20
    }
21

22
    public void Publish(string eventName, object data = null)
23
    {
24
        if (_listeners.ContainsKey(eventName))
25
        {
26
            foreach (var callback in _listeners[eventName])
27
            {
28
                callback?.Invoke(data);
29
            }
30
        }
31
    }
32
}
33

34
// 使用
35
public class HealthBar : MonoBehaviour
36
{
37
    private void Start()
38
    {
39
        EventManager.Instance.Subscribe("PlayerHealthChanged", OnHealthChanged);
40
    }
41

42
    private void OnHealthChanged(object data)
43
    {
44
        if (data is PlayerHealthChangedEvent e)
45
        {
46
            UpdateHealthBar(e.CurrentHealth, e.MaxHealth);
47
        }
48
    }
49
}

1
public interface IState
2
{
3
    void Enter();
4
    void Update();
5
    void Exit();
6
}
7

8
public class StateMachine
9
{
10
    private IState _currentState;
11

12
    public void TransitionTo(IState newState)
13
    {
14
        _currentState?.Exit();
15
        _currentState = newState;
16
        _currentState.Enter();
17
    }
18

19
    public void Update()
20
    {
21
        _currentState?.Update();
22
    }
23
}

1
// 待机状态
2
public class IdleState : IState
3
{
4
    private PlayerController _player;
5

6
    public IdleState(PlayerController player)
7
    {
8
        _player = player;
9
    }
10

11
    public void Enter()
12
    {
13
        _player.Animator.SetBool("IsWalking", false);
14
    }
15

16
    public void Update()
17
    {
18
        float h = Input.GetAxisRaw("Horizontal");
19
        if (Mathf.Abs(h) > 0.1f)
20
        {
21
            _player.StateMachine.TransitionTo(new WalkState(_player));
22
        }
23
    }
24

25
    public void Exit() { }
26
}
27

28
// 行走状态
29
public class WalkState : IState
30
{
31
    private PlayerController _player;
32

33
    public WalkState(PlayerController player)
34
    {
35
        _player = player;
36
    }
37

38
    public void Enter()
39
    {
40
        _player.Animator.SetBool("IsWalking", true);
41
    }
42

43
    public void Update()
44
    {
45
        float h = Input.GetAxisRaw("Horizontal");
46
        _player.transform.Translate(Vector3.right * h * _player.Speed * Time.deltaTime);
47

48
        if (Mathf.Abs(h) < 0.1f)
49
        {
50
            _player.StateMachine.TransitionTo(new IdleState(_player));
51
        }
52
    }
53

54
    public void Exit() { }
55
}

1
public class ObjectPool<T> where T : class, new()
2
{
3
    private Stack<T> _pool = new();
4
    private System.Func<T> _createFunc;
5

6
    public ObjectPool(System.Func<T> createFunc)
7
    {
8
        _createFunc = createFunc;
9
    }
10

11
    public T Get()
12
    {
13
        return _pool.Count > 0 ? _pool.Pop() : _createFunc();
14
    }
15

16
    public void Return(T obj)
17
    {
18
        _pool.Push(obj);
19
    }
20
}
21

22
// Unity 中的对象池
23
public class BulletPool : MonoBehaviour
24
{
25
    public GameObject bulletPrefab;
26
    private ObjectPool<GameObject> _pool;
27

28
    private void Start()
29
    {
30
        _pool = new ObjectPool<GameObject>(() =>
31
        {
32
            return Instantiate(bulletPrefab);
33
        });
34
    }
35

36
    public GameObject GetBullet()
37
    {
38
        var bullet = _pool.Get();
39
        bullet.SetActive(true);
40
        return bullet;
41
    }
42

43
    public void ReturnBullet(GameObject bullet)
44
    {
45
        bullet.SetActive(false);
46
        _pool.Return(bullet);
47
    }
48
}

1
// 命令接口
2
public interface ICommand
3
{
4
    void Execute();
5
    void Undo();
6
}
7

8
// 移动命令
9
public class MoveCommand : ICommand
10
{
11
    private Transform _target;
12
    private Vector3 _direction;
13
    private Vector3 _previousPosition;
14

15
    public MoveCommand(Transform target, Vector3 direction)
16
    {
17
        _target = target;
18
        _direction = direction;
19
    }
20

21
    public void Execute()
22
    {
23
        _previousPosition = _target.position;
24
        _target.position += _direction;
25
    }
26

27
    public void Undo()
28
    {
29
        _target.position = _previousPosition;
30
    }
31
}
32

33
// 命令管理器
34
public class CommandManager
35
{
36
    private Stack<ICommand> _history = new();
37
    private Stack<ICommand> _redoStack = new();
38

39
    public void ExecuteCommand(ICommand command)
40
    {
41
        command.Execute();
42
        _history.Push(command);
43
        _redoStack.Clear();
44
    }
45

46
    public void Undo()
47
    {
48
        if (_history.Count > 0)
49
        {
50
            var cmd = _history.Pop();
51
            cmd.Undo();
52
            _redoStack.Push(cmd);
53
        }
54
    }
55

56
    public void Redo()
57
    {
58
        if (_redoStack.Count > 0)
59
        {
60
            var cmd = _redoStack.Pop();
61
            cmd.Execute();
62
            _history.Push(cmd);
63
        }
64
    }
65
}

1
// 抽象工厂
2
public abstract class EnemyFactory
3
{
4
    public abstract Enemy CreateEnemy(EnemyType type);
5
}
6

7
// 具体工厂
8
public class UnityEnemyFactory : EnemyFactory
9
{
10
    public override Enemy CreateEnemy(EnemyType type)
11
    {
12
        Enemy enemy = type switch
13
        {
14
            EnemyType.Slime => Resources.Load<Slime>("Prefabs/Enemies/Slime"),
15
            EnemyType.Goblin => Resources.Load<Goblin>("Prefabs/Enemies/Goblin"),
16
            EnemyType.Dragon => Resources.Load<Dragon>("Prefabs/Enemies/Dragon"),
17
            _ => throw new ArgumentException("Unknown enemy type")
18
        };
19

20
        return Instantiate(enemy);
21
    }
22
}
23

24
// 使用
25
public class WaveManager : MonoBehaviour
26
{
27
    private EnemyFactory _factory = new UnityEnemyFactory();
28

29
    public void SpawnWave(WaveConfig config)
30
    {
31
        foreach (var enemyType in config.Enemies)
32
        {
33
            var enemy = _factory.CreateEnemy(enemyType);
34
            enemy.transform.position = GetSpawnPoint();
35
        }
36
    }
37
}

1
// 子系统
2
public class AudioSubsystem { }
3
public class SaveSubsystem { }
4
public class NetworkSubsystem { }
5

6
// 外观类
7
public class GameFacade
8
{
9
    public AudioSubsystem Audio { get; }
10
    public SaveSubsystem Save { get; }
11
    public NetworkSubsystem Network { get; }
12

13
    public GameFacade()
14
    {
15
        Audio = new AudioSubsystem();
16
        Save = new SaveSubsystem();
17
        Network = new NetworkSubsystem();
18
    }
19

20
    public void Initialize()
21
    {
22
        Audio.Init();
23
        Save.Init();
24
        Network.Connect();
25
    }
26
}
27

28
// 使用方不需要了解子系统细节
29
public class GameManager : MonoBehaviour
30
{
31
    private GameFacade _facade;
32

33
    private void Start()
34
    {
35
        _facade = new GameFacade();
36
        _facade.Initialize();
37
    }
38
}

1
// 策略接口
2
public interface IMoveStrategy
3
{
4
    void Move(Transform transform, float speed);
5
}
6

7
// 行走策略
8
public class WalkStrategy : IMoveStrategy
9
{
10
    public void Move(Transform transform, float speed)
11
    {
12
        float h = Input.GetAxis("Horizontal");
13
        float v = Input.GetAxis("Vertical");
14
        Vector3 dir = new Vector3(h, 0, v).normalized;
15
        transform.position += dir * speed * Time.deltaTime;
16
    }
17
}
18

19
// 翻滚策略
20
public class RollStrategy : IMoveStrategy
21
{
22
    public void Move(Transform transform, float speed)
23
    {
24
        if (Input.GetKeyDown(KeyCode.Space))
25
        {
26
            // 执行翻滚
27
        }
28
    }
29
}
30

31
// 使用
32
public class PlayerController : MonoBehaviour
33
{
34
    public IMoveStrategy MoveStrategy { get; set; }
35

36
    private void Update()
37
    {
38
        MoveStrategy?.Move(transform, Speed);
39
    }
40
}

1
// 基础攻击
2
public class AttackComponent
3
{
4
    public virtual int CalculateDamage()
5
    {
6
        return 10;
7
    }
8
}
9

10
// 装饰器基类
11
public abstract class AttackDecorator : AttackComponent
12
{
13
    protected AttackComponent _baseAttack;
14

15
    public AttackDecorator(AttackComponent baseAttack)
16
    {
17
        _baseAttack = baseAttack;
18
    }
19

20
    public override int CalculateDamage()
21
    {
22
        return _baseAttack.CalculateDamage();
23
    }
24
}
25

26
// 火焰附魔
27
public class FireEnchantment : AttackDecorator
28
{
29
    public FireEnchantment(AttackComponent baseAttack) : base(baseAttack) { }
30

31
    public override int CalculateDamage()
32
    {
33
        int baseDamage = base.CalculateDamage();
34
        int fireDamage = 5;
35
        Debug.Log($"造成 {baseDamage} 物理伤害 + {fireDamage} 火焰伤害");
36
        return baseDamage + fireDamage;
37
    }
38
}
39

40
// 冰霜附魔
41
public class IceEnchantment : AttackDecorator
42
{
43
    public IceEnchantment(AttackComponent baseAttack) : base(baseAttack) { }
44

45
    public override int CalculateDamage()
46
    {
47
        int baseDamage = base.CalculateDamage();
48
        int iceDamage = 3;
49
        Debug.Log($"造成 {baseDamage} 物理伤害 + {iceDamage} 冰霜伤害 + 减速效果");
50
        return baseDamage + iceDamage;
51
    }
52
}

1
Model（模型）     ←→     View（视图）
2
       ↑                    ↑
3
       └──── Controller ────┘

1
// ViewModel 示例
2
public class HealthBarViewModel : MonoBehaviour
3
{
4
    public Observable<int> CurrentHealth { get; } = new();
5
    public Observable<int> MaxHealth { get; } = new();
6

7
    private void Start()
8
    {
9
        // 绑定到 View
10
        CurrentHealth.OnChanged += UpdateHealthBar;
11
    }
12

13
    public void TakeDamage(int damage)
14
    {
15
        CurrentHealth.Value = Mathf.Max(0, CurrentHealth.Value - damage);
16
    }
17

18
    private void UpdateHealthBar(int health)
19
    {
20
        healthBarImage.fillAmount = (float)health / MaxHealth.Value;
21
    }
22
}