读Game Programming Patters（1） - 灵感狐的灵感小窝

根据哈基米的推荐买了一本Game Programming Patterns，准备系统的学习一下，边学边把自己的理解写下来（

看了一下目录，正如其名，这本书基本都再说一些设计模式。之前虽然接触学习过不少的设计模式，但是游戏中经常会用到一些特定的设计模式，所以还是很有必要系统的学习一下的。

当然，还是以很常见的设计模式为基础的啦

1.命令模式#

命令模式的核心思想是把一个请求封装成一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。

这个模式还是很常见的。之前写RPMEditor的时候，这种软件的操作需要用到很多命令模式。甚至说WPF本身就提供了一个ICommand接口。

一个最简单的例子就是对玩家输入的监听。

[!Note] 原书用的cpp写的代码，但是我不太熟（所以用kotlin写了

1
typealias Command = () -> Unit
2

3
// 将行为和命令绑定在一起
4
var buttonX: Command = ::jump
5
var buttonY: Command = ::attack
6
var buttonA: Command = ::swapWeapon
7
var buttonB: Command = ::useItem
8

9
fun handleInput(){
10
    if (input.isPressed(BUTTON_X)){
11
        buttonX()
12
    }else if (input.isPressed(BUTTON_Y)){
13
        buttonY()
14
    }else if (input.isPressed(BUTTON_A)){
15
        buttonA()
16
    }else if (input.isPressed(BUTTON_B)){
17
        buttonB()
18
    }
19
}

2.享元模式#

享元模式的核心思想是运用共享技术有效地支持大量细粒度的对象。

看起来可能会和单例模式有一点相似的地方，但是享元模式侧重于共享对象而减少多余对象的创建，单例模式一般用于全局唯一的对象，保证一致性。

享元模式的一个经典例子就是在游戏中对树木的渲染。假设我们有一个森林场景，其中有成千上万棵树，如果每棵树都创建一个独立的对象来存储它们的属性和状态，那么会占用大量的内存资源。但是这些树木往往共享了相同的纹理、模型和行为，我们可以通过享元模式来共享这些公共的部分，从而减少内存的使用。

1
class TreeType(val name: String, val texture: Texture, val model: Model)
2
class Tree(val x: Int, val y: Int, val type: TreeType)
3
class TreeFactory {
4
    private val treeTypes = mutableMapOf<String, TreeType>()
5

6
    fun getTreeType(name: String, texture: Texture, model: Model): TreeType {
7
        return treeTypes.getOrPut(name) { TreeType(name, texture, model) }
8
    }
9
}

享元模式将单个的对象分为了两部分——每个对象自己的状态，以及所有对象之间共享的数据，或者说和上下文无关的状态，从而减少内存的使用，或者节约向GPU发送数据的开销。

3.观察者模式#

观察者模式可以说是应用得最广泛的设计模式了。它的核心思想是定义对象间的一种一对多的依赖关系，以便当一个对象改变状态时，所有依赖于它的对象都得到通知并被自动更新。

比如说，我们要在玩家物品栏发生变动的时候，检查物品栏的物品，并决定要不要弹出成就。我们当然不会中每个可能修改玩家物品栏的地方都写一个checkItems，相反，我们可以在玩家物品栏发生变动的时候，发出一个事件，所有需要监听这个事件的地方都可以订阅这个事件，从而在事件发生的时候得到通知。

1
class Inventory {
2
    //一个简单的物品栏
3
    private val items = mutableListOf<Item>()
4

5
    //简单的观察者列表，我们不像原书里面自己实现一个复杂的列表，直接用ArrayList就好了
6
    private val listeners = mutableListOf<() -> Unit>()
7

8
    //我们不直接暴露列表，而是暴露操作列表的接口
9
    //当列表被操作的时候，触发列表更改的事件，通知所有的观察者
10
    fun addItem(item: Item) {
11
        items.add(item)
12
        notifyListeners()
13
    }
14
    fun removeItem(item: Item) {
15
        items.remove(item)
16
        notifyListeners()
17
    }
18
    fun subscribe(listener: () -> Unit) {
19
        listeners.add(listener)
20
    }
21
    private fun notifyListeners() {
22
        listeners.forEach { it() }
23
    }
24
}
25

26
class AchievementSystem(val inventory: Inventory) {
27
    //简单的成就系统，对物品更改的事件进行订阅
28
    init {
29
        inventory.subscribe { checkAchievements() }
30
    }
31
    fun checkAchievements() {
32
        // 检查成就
33
    }
34
}

但是用一点需要注意的是，观察者往往会持有被观察者的引用。如果被观察者是一个需要被清除的非长期对象，比如说一个临时弹出的UI，那就需要注意观察者对事件订阅的取消了。不然，GC永远不会清理这些临时对象，很容易造成内存泄露的问题。

Java早期提供了一个观察者模式接口java.util.Observer，用于实现发布-订阅式的通知，但是它在Java 9中已经被标记为depercated。更现代的解决方案是PropertyChangeListener，适合JavaBeans属性变化通知。

1
PropertyChangeSupport pcs = new PropertyChangeSupport(this);
2

3
pcs.addPropertyChangeListener(evt -> {
4
    System.out.println(evt.getPropertyName() + " changed");
5
});
6

7
pcs.firePropertyChange("name", "old", "new");

或者使用Java 9+的Flow API。

当然，在C#中，事件作为语法功能被直接提供了。

1
public class Inventory {
2
    public event Action OnInventoryChanged;
3

4
    public void AddItem(Item item) {
5
        // 添加物品逻辑
6
        OnInventoryChanged?.Invoke();
7
    }
8
}

4. 原型模式#

原型模式的核心思想是用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

原型模式在游戏中经常被用来创建大量相似的对象，比如说敌人、子弹等等。通过克隆一个原型对象，我们可以快速地创建出新的对象，而不需要重新初始化它们的属性。

1
interface Prototype {
2
    fun clone(): Prototype
3
}
4

5
class Enemy(val health: Int, val damage: Int) : Prototype {
6
    override fun clone(): Prototype {
7
        return Enemy(health, damage)
8
    }
9
}

原型模式一个很有意思的地方就是，它不需要类的定义，因为它总是将一个已有的对象作为原型，并以此生成新的对象。现代语言中一个经典的例子就是 javascript。javascript虽然拥有class关键字，拥有类定义的语法，但是它并不是传统的类继承为主，而是构造原型链来共享属性和方法的。

1
//定义了一个对象
2
const parent = { say() { console.log("hi") } }
3
//以parent为原型创造对象
4
const child = Object.create(parent)
5

6
//child中并没有say，但是它的原型parent中有，所以child可以访问到say方法
7
child.say() // hi

javascript的函数中也有一个prototype属性，用来给通过new创建的对象共享方法：

1
function Person(name) {
2
  this.name = name
3
}
4

5
Person.prototype.say = function () {
6
  console.log(this.name)
7
}
8

9
const p = new Person("Alice")
10
p.say()

p的原型指向Person.prototype，方法say不会复制到每个实例，所有实例共享同一个方法。

在构造游戏中常用的Json数据的时候，原型思维同样适用。例如，我们需要构造多种剑，我们可以先构建一个剑的原型对象：

1
{
2
    "name": "Sword",
3
    "damage": 10,
4
    "otherProperties": "..."
5
}

随后，例如，构造一把有技能的剑：

1
{
2
    "prototype": "Sword",
3
    "name": "Sword of Fire",
4
    "skill": "Fire Blast"
5
}

这样子，我们只需要花费更少的精力，就能构造新的物品了。

继续看书喵，还有好多好多呢。