Swift游戏开发实战PDF电子书下载

第1章 Swift语言简介 1

1.1 Swift的概念 1

1.2 Swift的特点 1

1.3 Swift与Objective-C的异同 2

1.4 搭建Swift开发环境 3

1.5 创建Swift工程 4

1.6 Playground 5

1.7 本章小结 7

1.8 习题 7

第2章 Swift语言基础 8

2.1 标示符和关键字 8

2.2 简单值 9

2.3 类型推导 9

2.4 类型注释 10

2.5 打印常量和变量 10

2.6 字符串插值 11

2.7 注释 11

2.8 基本数据类型 12

2.8.1 整型 12

2.8.2 数制转换 13

2.8.3 浮点型 13

2.8.4 数字的易读性 14

2.8.5 数值间的类型转换 14

2.8.6 布尔类型 15

2.8.7 类型别名 16

2.9 字符和字符串 17

2.9.1 字符类型 17

2.9.2 字符串类型 17

2.9.3 字符串拼接 18

2.9.4 遍历字符串中的所有字符 18

2.9.5 字符串间的比较 18

2.9.6 判断字符串是否包含某个字符串 19

2.9.7 字符串的大小写转换 19

2.10 元组（Tuples） 20

2.10.1 元组的声明与定义 20

2.10.2 读取元组中的数据 20

2.10.3 为元组中的数值命名 21

2.11 可选表达式 21

2.12 强取值表达式 21

2.13 本章小结 22

2.14 习题 22

第3章 基本操作符 23

3.1 操作符的种类 23

3.2 赋值操作符 23

3.3 数值操作符 24

3.3.1 四则运算操作符 24

3.3.2 复合赋值操作符 25

3.3.3 取余操作 25

3.3.4 一元正号操作符和一元负号操作符 26

3.3.5 自增与自减操作符 26

3.4 比较操作符 27

3.5 三元条件操作符 27

3.6 空值合并操作符 28

3.7 区间操作符 28

3.7.1 闭区间运算符 29

3.7.2 半开区间运算符 29

3.8 逻辑操作符 29

3.8.1 逻辑与 29

3.8.2 逻辑或 30

3.8.3 逻辑非 30

3.8.4 逻辑操作符的组合 31

3.8.5 使用括号来明确复杂逻辑运算的优先级 31

3.9 本章小结 32

3.10 习题 32

第4章 XAML的使用 33

4.1 数组 33

4.1.1 数组声明和初始化 33

4.1.2 声明一个空的数组 34

4.1.3 数组的下标访问 34

4.1.4 添加和删除数组元素 35

4.1.5 遍历数组 36

4.1.6 数组的其他内置方法 36

4.2 字典 37

4.2.1 字典声明和初始化 37

4.2.2 创建一个空字典 38

4.2.3 读取和修改字典 38

4.2.4 遍历字典 39

4.3 本章小结 40

4.4 习题 40

第5章 控制流 41

5.1 for循环 41

5.1.1 对区间操作符循环 41

5.1.2 对数组和字典进行遍历 42

5.1.3 枚举字符串 43

5.1.4 条件增量循环 43

5.2 While循环 44

5.3 Do...While循环 45

5.4 条件语句 45

5.4.1 if条件语句 45

5.4.2 Switch语句 46

5.4.3 Fallthrough 47

5.4.4 基于区间操作符的条件判断 48

5.4.5 基于元组的条件判断 48

5.4.6 绑定值 49

5.4.7 Where语句 49

5.5 控制转移语句 50

5.5.1 continue语句 50

5.5.2 break语句 50

5.6 标签语句 51

5.7 本章小结 52

5.8 习题 52

第6章 函数 53

6.1 函数的定义和调用 53

6.2 多重参数函数 54

6.3 无参数函数 54

6.4 多重返回值函数 55

6.5 外部参数名 55

6.6 内部参数和外部参数的统一 56

6.7 默认参数 56

6.8 可变参数 57

6.9 变量参数 57

6.10 输入输出参数 58

6.11 函数类型 58

6.12 函数类型作为函数的参数 59

6.13 函数类型作为函数的返回值 59

6.14 嵌套函数 60

6.15 本章小结 60

6.16 习题 60

第7章 闭包 61

7.1 闭包表达式 61

7.1.1 闭包表达式的语法 62

7.1.2 省略参数类型 62

7.1.3 省略return语句 62

7.1.4 参数名省略 63

7.1.5 操作符函数 63

7.2 尾随闭包 63

7.3 捕获值 64

7.4 闭包是引用类型 65

7.5 本章小结 65

7.6 习题 65

第8章 枚举类型 66

8.1 枚举类型的语法 66

8.2 匹配枚举成员 67

8.3 相关值 68

8.4 初始值 69

8.5 本章小结 69

8.6 习题 69

第9章 类和结构体 70

9.1 类和结构体的异同 70

9.2 定义类和结构体 71

9.3 创建类和结构体的实例 71

9.4 对类和结构体中属性访问与赋值 72

9.5 结构体类型手动构造属性初始值 72

9.6 值类型和引用类型 72

9.6.1 值类型 73

9.6.2 引用类型 73

9.6.3 恒等运算符 74

9.7 类和结构体的选择 75

9.8 属性 75

9.8.1 存储属性 75

9.8.2 惰性存储属性 76

9.8.3 计算属性 77

9.8.4 只读计算属性 78

9.9 属性观察器 78

9.10 静态属性 80

9.11 本章小结 82

9.12 习题 82

第10章 方法 83

10.1 方法的定义 83

10.2 实例方法 83

10.3 方法的局部参数名称和外部参数名称 84

10.4 为方法的第一个参数提供外部参数名 85

10.5 self属性 85

10.6 方法的变异 86

10.7 类型方法 87

10.8 下标脚本 88

10.8.1 下标脚本语法 88

10.8.2 下标语法的常用方法 89

10.9 构造过程和构造器 90

10.9.1 无参数构造器 90

10.9.2 构造参数 91

10.9.3 构造器的外部参数名和内部参数名 91

10.9.4 构造过程中常量属性的修改 92

10.9.5 默认构造器 92

10.9.6 逐一成员构造器 93

10.9.7 构造代理 93

10.10 析构过程 94

10.11 本章小结 95

10.12 习题 95

第11章 类的继承 96

11.1 继承的定义 96

11.2 定义一个基类 96

11.3 继承一个类 97

11.4 重写 98

11.4.1 访问超类的方法、属性、下标脚本 98

11.4.2 重写方法 98

11.4.3 重写属性 99

11.4.4 重写属性观察器 99

11.4.5 重写保护和继承保护 100

11.4.6 构造器的继承 100

11.5 本章小结 102

11.6 习题 102

第12章 自动引用计数（ARC） 103

12.1 自动引用计数的工作机制 103

12.2 循环强引用 104

12.3 弱引用和无主引用 106

12.3.1 弱引用 106

12.3.2 无主引用 107

12.3.3 弱引用和无主引用的适用范围 108

12.4 闭包引起的循环强引用 108

12.5 本章小结 110

12.6 习题 110

第13章 可选链 111

13.1 为什么要用可选链 111

13.2 通过可选链调用属性 112

13.3 通过可选链调用方法 112

13.4 使用可选链调用下标脚本 112

13.5 连接多层链接 113

13.6 链接可选返回值的方法 115

13.7 本章小结 115

13.8 习题 115

第14章 类型转换 117

14.1 类型转换的定义 117

14.2 类型检测 118

14.3 向下转换 118

14.4 Any和AnyObject的类型转换 119

14.4.1 AnyObject类型 119

14.4.2 Any 120

14.5 本章小结 121

14.6 习题 121

第15章 扩展 122

15.1 扩展的定义和语法 122

15.2 扩展计算型属性 122

15.3 扩展构造器 123

15.4 扩展方法 124

15.5 修改实例方法 125

15.6 扩展下标 125

15.7 嵌套类型 125

15.8 本章小结 126

15.9 习题 127

第16章 协议 128

16.1 协议的语法 128

16.2 协议中的属性 128

16.3 协议中的方法 130

16.4 突变方法 131

16.5 构造器 131

16.6 协议类型 132

16.7 委托 133

16.8 在扩展中添加协议成员 135

16.9 通过扩展补充协议声明 136

16.10 集合中的协议类型 136

16.11 协议的继承 137

16.12 协议合成 138

16.13 校验协议 138

16.14 可选协议的规定 139

16.15 本章小结 141

16.16 习题 141

第17章 泛型 142

17.1 为什么引入泛型 142

17.2 泛型函数 143

17.3 类型参数 144

17.4 泛型类型 144

17.5 类型约束 147

17.5.1 类型约束语法 147

17.5.2 类型约束行为 147

17.6 关联类型 149

17.6.1 在协议中使用关联类型 149

17.6.2 扩展一个存在的类型为一指定关联类型 150

17.7 Where语句 150

17.8 本章小结 152

17.9 习题 152

第18章 访问控制 153

18.1 模块和源文件 153

18.2 访问级别 153

18.2.1 访问级别规则 153

18.2.2 默认访问级别 154

18.2.3 单目标应用程序的访问级别 154

18.2.4 Framework的访问级别 154

18.3 访问控制语法 154

18.4 自定义类型 155

18.5 元组类型 155

18.6 函数类型 155

18.7 枚举类型 156

18.8 嵌套类型 156

18.9 子类 156

18.10 常量、变量、属性、下标 157

18.11 本章小结 157

18.12 习题 157

第19章 高级操作符 158

19.1 位操作符 158

19.1.1 按位取反操作符 158

19.1.2 按位与操作 159

19.1.3 按位或操作 159

19.1.4 按位异或操作符 160

19.1.5 按位左移操作符和按位右移操作符 160

19.2 溢出操作符 162

19.2.1 值的上溢出 162

19.2.2 值的下溢出 163

19.2.3 除零溢出 164

19.3 操作符的优先级和结合性 164

19.4 操作符函数 165

19.4.1 中置操作符 165

19.4.2 前置和后置操作符 166

19.4.3 组合赋值操作符 166

19.4.4 比较操作符 167

19.5 自定义操作符 167

19.5.1 自定义前置操作符和后置操作符 167

19.5.2 自定义中置操作符 168

19.6 本章小结 169

19.7 习题 169

第20章 SpriteKit引擎 170

20.1 创建一个游戏工程 170

20.2 游戏工程的结构 172

20.2.1 AppDelegate.swift 172

20.2.2 GameScene.sks 173

20.2.3 GameScene.swift和GameViewController.swift 173

20.2.4 其他文件 174

20.3 编译并运行游戏 174

20.4 分析Xcode默认游戏工程代码 175

20.4.1 程序的第一个场景 175

20.4.2 视图控制器 176

20.5 本章小结 177

20.6 习题 177

第21章 进击的小鸟——Flappybird实战 178

21.1 游戏逻辑 178

21.2 准备工作 179

21.3 创建一个世界 179

21.4 添加一个小鸟 181

21.4.1 一个由帧动画组成的精灵 181

21.4.2 让小鸟自由落体 182

21.4.3 与地面碰撞 183

21.4.4 通过点击让小鸟上升 184

21.4.5 随着速度上下俯仰 184

21.5 生成管道 185

21.6 碰撞检测 187

21.7 分数统计和重新开始游戏 188

21.7.1 分数统计 188

21.7.2 重新开始游戏 189

21.8 本章小结 190

第22章 经典游戏——打砖块 191

22.1 游戏逻辑 191

22.2 资源准备 192

22.3 游戏界面准备 192

22.4 创建一个小球 193

22.4.1 给小球一个初始速度 194

22.4.2 给小球规定一个运动的范围 194

22.5 创建挡板 195

22.6 生成砖块 196

22.7 创建死亡区域 199

22.8 完善游戏的更多细节 200

22.8.1 添加音效 200

22.8.2 重置游戏和初始位置 200

22.8.3 增加难度系数 201

22.8.4 成功／失败画面 201

22.9 本章小结 203