游戏编程模式
	定价	69.00
	出版社	人民邮电出版社
	版次	第1版
	出版时间	2016年09月
	开本	16
	作者	Robert Nystrom
	装帧	平装
	页数	0
	字数	437
	ISBN编码	9787115426888

目录  
第1篇 概述  
第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篇 再探设计模式  
第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 不用担心，我们有GC 44  
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 提供一个全局指针以访问wei一实例 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篇 序列型模式  
第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篇 行为型模式  
第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 法术API 147  
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篇 解耦型模式  
第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 重构Bjorn 202  
14.5.5 删掉Bjorn 204  
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篇 优化型模式  
第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 yan时重算 268  
18.2 脏标记模式 269  
18.3 使用情境 269  
18.4 使用须知 270  
18.4.1 yan时太长会有代价 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 分区依赖于对象集合吗 302  
20.6.3 对象只存储在分区中吗 304  
20.7 参考 305