游戏编程模式【2025|PDF下载-Epub版本|mobi电子书|kindle百度云盘下载】

游戏编程模式PDF格式电子书版下载

注意：本站所有压缩包均有解压码： 点击下载压缩包解压工具

第1篇 概述3

第1章 架构、性能和游戏3

1.1 什么是软件架构3

1.1.1 什么是好的软件架构3

1.1.2 你如何做出改变4

1.1.3 我们如何从解耦中受益5

1.2 有什么代价5

1.3 性能和速度6

1.4 坏代码中的好代码7

1.5 寻求平衡8

1.6 简单性9

1.7 准备出发9

第2篇 再探设计模式13

第2章 命令模式13

2.1 配置输入14

2.2 关于角色的说明16

2.3 撤销和重做18

2.4 类风格化还是函数风格化21

2.5 参考22

第3章 享元模式23

3.1 森林之树23

3.2 一千个实例25

3.3 享元模式26

3.4 扎根之地26

3.5 性能表现如何30

3.6 参考31

第4章 观察者模式33

4.1 解锁成就33

4.2 这一切是怎么工作的34

4.2.1 观察者35

4.2.2 被观察者35

4.2.3 可被观察的物理模块37

4.3 它太慢了38

4.4 太多的动态内存分配39

4.4.1 链式观察者39

4.4.2 链表节点池42

4.5 余下的问题43

4.5.1 销毁被观察者和观察者43

4.5.2 不用担心，我们有GC44

4.5.3 接下来呢44

4.6 观察者模式的现状45

4.7 观察者模式的未来46

第5章 原型模式47

5.1 原型设计模式47

5.1.1 原型模式效果如何50

5.1.2 生成器函数51

5.1.3 模板51

5.1.4 头等公民类型（First-class types）52

5.2 原型语言范式52

5.2.1 Self语言53

5.2.2 结果如何54

5.2.3 JavaScript如何55

5.3 原型数据建模57

第6章 单例模式61

6.1 单例模式61

6.1.1 确保一个类只有一个实例61

6.1.2 提供一个全局指针以访问唯一实例62

6.2 使用情境63

6.3 后悔使用单例的原因65

6.3.1 它是一个全局变量65

6.3.2 它是个画蛇添足的解决方案66

6.3.3 延迟初始化剥离了你的控制67

6.4 那么我们该怎么做68

6.4.1 看你究竟是否需要类68

6.4.2 将类限制为单一实例70

6.4.3 为实例提供便捷的访问方式71

6.5 剩下的问题73

第7章 状态模式75

7.1 我们曾经相遇过75

7.2 救星：有限状态机78

7.3 枚举和分支79

7.4 状态模式82

7.4.1 一个状态接口82

7.4.2 为每一个状态定义一个类83

7.4.3 状态委托84

7.5 状态对象应该放在哪里呢84

7.5.1 静态状态84

7.5.2 实例化状态85

7.6 进入状态和退出状态的行为86

7.7 有什么收获吗88

7.8 并发状态机88

7.9 层次状态机89

7.10 下推自动机91

7.11 现在知道它们有多有用了吧92

第3篇 序列型模式95

第8章 双缓冲95

8.1 动机95

8.1.1 计算机图形系统是如何工作的（概述）95

8.1.2 第一幕，第一场96

8.1.3 回到图形上97

8.2 模式98

8.3 使用情境98

8.4 注意事项98

8.4.1 交换本身需要时间98

8.4.2 我们必须有两份缓冲区99

8.5 示例代码99

8.5.1 并非只针对图形102

8.5.2 人工非智能102

8.5.3 缓存这些巴掌106

8.6 设计决策107

8.6.1 缓冲区如何交换107

8.6.2 缓冲区的粒度如何109

8.7 参考110

第9章 游戏循环111

9.1 动机111

9.1.1 CPU探秘111

9.1.2 事件循环112

9.1.3 时间之外的世界113

9.1.4 秒的长短113

9.2 模式114

9.3 使用情境114

9.4 使用须知114

9.5 示例代码115

9.5.1 跑，能跑多快就跑多快115

9.5.2 小睡一会儿115

9.5.3 小改动，大进步116

9.5.4 把时间追回来118

9.5.5 留在两帧之间119

9.6 设计决策120

9.6.1 谁来控制游戏循环，你还是平台121

9.6.2 你如何解决能量耗损121

9.6.3 如何控制游戏速度122

9.7 参考123

第10章 更新方法125

10.1 动机125

10.2 模式127

10.3 使用情境128

10.4 使用须知128

10.4.1 将代码划分至单帧之中使其变得更加复杂128

10.4.2 你需要在每帧结束前存储游戏状态以便下一帧继续128

10.4.3 所有对象都在每帧进行模拟，但并非真正同步129

10.4.4 在更新期间修改对象列表时必须谨慎129

10.5 示例代码130

10.5.1 子类化实体132

10.5.2 定义实体132

10.5.3 逝去的时间135

10.6 设计决策136

10.6.1 update方法依存于何类中136

10.6.2 那些未被利用的对象该如何处理137

10.7 参考137

第4篇 行为型模式141

第11章 字节码141

11.1 动机141

11.1.1 魔法大战141

11.1.2 先数据后编码142

11.1.3 解释器模式142

11.1.4 虚拟机器码145

11.2 字节码模式145

11.3 使用情境145

11.4 使用须知146

11.4.1 你需要个前端界面146

11.4.2 你会想念调试器的147

11.5 示例147

11.5.1 法术API147

11.5.2 法术指令集148

11.5.3 栈机149

11.5.4 组合就能得到行为153

11.5.5 一个虚拟机155

11.5.6 语法转换工具155

11.6 设计决策157

11.6.1 指令如何访问堆栈157

11.6.2 应该有哪些指令158

11.6.3 值应当如何表示158

11.6.4 如何生成字节码161

11.7 参考162

第12章 子类沙盒163

12.1 动机163

12.2 沙盒模式165

12.3 使用情境165

12.4 使用须知165

12.5 示例166

12.6 设计决策168

12.6.1 需要提供什么操作168

12.6.2 是直接提供函数，还是由包含它们的对象提供169

12.6.3 基类如何获取其所需的状态170

12.7 参考173

第13章 类型对象175

13.1 动机175

13.1.1 经典的面向对象方案175

13.1.2 一种类型一个类177

13.2 类型对象模式178

13.3 使用情境179

13.4 使用须知179

13.4.1 类型对象必须手动跟踪179

13.4.2 为每个类型定义行为更困难179

13.5 示例180

13.5.1 构造函数：让类型对象更加像类型181

13.5.2 通过继承共享数据183

13.6 设计决策185

13.6.1 类型对象应该封装还是暴露186

13.6.2 持有类型对象如何创建187

13.6.3 类型能否改变187

13.6.4 支持何种类型的派生188

13.7 参考189

第5篇 解耦型模式193

第14章 组件模式193

14.1 动机193

14.1.1 难题194

14.1.2 解决难题194

14.1.3 宽松的末端194

14.1.4 捆绑在一起195

14.2 模式196

14.3 使用情境196

14.4 注意事项196

14.5 示例代码197

14.5.1 一个庞大的类197

14.5.2 分割域198

14.5.3 分割其余部分200

14.5.4 重构Bjorn202

14.5.5 删掉Bjorn204

14.6 设计决策206

14.6.1 对象如何获得组件206

14.6.2 组件之间如何传递信息207

14.7 参考210

第15章 事件队列211

15.1 动机211

15.1.1 用户图形界面的事件循环211

15.1.2 中心事件总线212

15.1.3 说些什么好呢213

15.2 事件队列模式215

15.3 使用情境215

15.4 使用须知215

15.4.1 中心事件队列是个全局变量216

15.4.2 游戏世界的状态任你掌控216

15.4.3 你会在反馈系统循环中绕圈子216

15.5 示例代码217

15.5.1 环状缓冲区219

15.5.2 汇总请求222

15.5.3 跨越线程223

15.6 设计决策224

15.6.1 入队的是什么224

15.6.2 谁能从队列中读取224

15.6.3 谁可以写入队列225

15.6.4 队列中对象的生命周期是什么226

15.7 参考227

第16章 服务定位器229

16.1 动机229

16.2 服务定位器模式230

16.3 使用情境230

16.4 使用须知231

16.4.1 服务必须被定位231

16.4.2 服务不知道被谁定位231

16.5 示例代码231

16.5.1 服务231

16.5.2 服务提供器232

16.5.3 简单的定位器232

16.5.4 空服务233

16.5.5 日志装饰器235

16.6 设计决策236

16.6.1 服务是如何被定位的236

16.6.2 当服务不能被定位时发生了什么239

16.6.3 服务的作用域多大240

16.7 其他参考241

第6篇 优化型模式245

第17章 数据局部性245

17.1 动机245

17.1.1 数据仓库246

17.1.2 CPU的托盘247

17.1.3 等下，数据即性能248

17.2 数据局部性模式249

17.3 使用情境249

17.4 使用须知250

17.5 示例代码250

17.5.1 连续的数组251

17.5.2 包装数据255

17.5.3 热/冷分解258

17.6 设计决策260

17.6.1 你如何处理多态260

17.6.2 游戏实体是如何定义的261

17.7 参考263

第18章 脏标记模式265

18.1 动机265

18.1.1 局部变换和世界变换266

18.1.2 缓存世界变换267

18.1.3 延时重算268

18.2 脏标记模式269

18.3 使用情境269

18.4 使用须知270

18.4.1 延时太长会有代价270

18.4.2 必须保证每次状态改动时都设置脏标记271

18.4.3 必须在内存中保存上次的衍生数据271

18.5 示例代码271

18.5.1 未优化的遍历272

18.5.2 让我们“脏”起来273

18.6 设计抉择275

18.6.1 何时清除脏标记275

18.6.2 脏标记追踪的粒度多大276

18.7 参考276

第19章 对象池277

19.1 动机277

19.1.1 碎片化的害处277

19.1.2 二者兼顾278

19.2 对象池模式278

19.3 使用情境279

19.4 使用须知279

19.4.1 对象池可能在闲置的对象上浪费内存279

19.4.2 任意时刻处于存活状态的对象数目恒定279

19.4.3 每个对象的内存大小是固定的280

19.4.4 重用对象不会被自动清理281

19.4.5 未使用的对象将占用内存281

19.5 示例代码281

19.6 设计决策287

19.6.1 对象是否被加入对象池287

19.6.2 谁来初始化那些被重用的对象288

19.7 参考290

第20章 空间分区291

20.1 动机291

20.1.1 战场上的部队291

20.1.2 绘制战线292

20.2 空间分区模式293

20.3 使用情境293

20.4 使用须知293

20.5 示例代码293

20.5.1 一张方格纸294

20.5.2 相连单位的网格294

20.5.3 进入战场296

20.5.4 刀光剑影的战斗297

20.5.5 冲锋陷阵298

20.5.6 近在咫尺，短兵相接299

20.6 设计决策302

20.6.1 分区是层级的还是扁平的302

20.6.2 分区依赖于对象集合吗303

20.6.3 对象只存储在分区中吗305

20.7 参考305