[套装书]百万在线:大型游戏服务端开发+Unity3D网络游戏实战(第2版)(2册)

作者
罗培羽
丛书名
游戏开发与设计技术丛书
出版社
机械工业出版社
ISBN
9782108261732
简要
简介
内容简介书籍计算机书籍 ---------------------------8083549 - 百万在线:大型游戏服务端开发--------------------------- 第 一部分“学以致用”揭示了 Skynet 引擎的使用方法及注意事项,以“球球大作战”的案例贯穿本篇内容,全面又详尽地剖析服务端结构设计、通信协议格式、数据表结构设计、断线重连方案等众多核心技术。第二部分“入木三分”揭示了在多核时代采用现代 C++ 编写多线程 TCP 网络服务器的高效做法,以 C++ 重写 Skynet 的案例贯穿本篇内容,使用大量图表,生动翔实地描述 Linux 环境下的编程技术。第三部分“各个击破”列举了同步算法、热更新、防外挂等实际工程难题,并对其逐一击破,非常具有实用价值。 ---------------------------8054539 - Unity3D网络游戏实战(第2版)--------------------------- 本书针对第1版进行改版,将“单机游戏”融入到网络部分的实例中,在讲解网络通信原理的同时,给出各个知识点的案例,并开发客户端的网络模块和服务端程序框架。然后将一部分的坦克游戏改造成联网对战的多人游戏。本书基于Unity3D最新版本编写,书中例子为商业游戏简化版本,读者可以从中了解商业游戏的设计思路和实现方法。读者看完本书,初步拥有开发一款完整网络游戏的能力。
目录
[套装书具体书目]
8054539 - Unity3D网络游戏实战(第2版) - 9787111612179 - 机械工业出版社 - 定价 89
8083549 - 百万在线:大型游戏服务端开发 - 9787111687559 - 机械工业出版社 - 定价 99



---------------------------8083549 - 百万在线:大型游戏服务端开发---------------------------


前 言
第一部分 学以致用
第1章 从角色走路说起 2
1.1 每走一步都有事情发生 2
1.1.1 走路的五个步骤 3
1.1.2 服务端视角的游戏流程 3
1.2 从网络编程着手 4
1.2.1 用打电话做比喻 4
1.2.2 最少要掌握的三个概念 5
1.2.3 搭一个简单的服务器 6
1.2.4 让角色走起来 8
1.3 能够承载多少玩家 9
1.3.1 单线事件模型 9
1.3.2 承载量估算 9
1.4 用分布式扩能 10
1.4.1 多个程序协同工作 11
1.4.2 三个层次的交互 11
1.4.3 搭个简单的分布式服务端 12
1.4.4 一致性问题 14
1.5 回头看操作系统 15
1.5.1 多进程为什么能提升性能 15
1.5.2 阻塞为什么不占CPU 16
1.5.3 线程会占用多少资源 17
1.6 一张地图的极限 18
1.6.1 难以分割的业务 19
1.6.2 在延迟和容量间权衡 19
1.7 万物皆Actor 19
1.7.1 灵感来自Erlang 20
1.7.2 对世界的抽象 20
1.7.3 为何适用 22
第2章 Skynet入门精要 25
2.1 下载、编译、运行 26
2.1.1 下载和编译 26
2.1.2 运行范例 27
2.2 理解Skynet 28
2.2.1 节点和服务 28
2.2.2 配置文件 29
2.2.3 结构 30
2.2.4 启动流程 31
2.3 第一个程序PingPong 32
2.3.1 功能需求 32
2.3.2 学习服务模块 32
2.3.3 代码实现 33
2.3.4 运行结果 35
2.4 写Echo,练习网络编程 35
2.4.1 功能需求 36
2.4.2 学习网络模块 36
2.4.3 代码实现 37
2.4.4 运行结果 37
2.5 做聊天室,学习多人交互 38
2.5.1 功能需求 38
2.5.2 代码实现 38
2.6 做留言板,使用数据库 39
2.6.1 功能需求 39
2.6.2 学习数据库模块 40
2.6.3 准备数据库 40
2.6.4 代码实现 43
2.6.5 运行结果 45
2.7 监控服务状态 45
2.7.1 启用调试控制台 45
2.7.2 监控指令 46
2.8 使用节点集群建立分布式系统 48
2.8.1 功能需求 48
2.8.2 学习集群模块 48
2.8.3 节点配置 49
2.8.4 代码实现 49
2.8.5 运行结果 51
2.8.6 使用代理 52
2.9 使用Skynet的注意事项 52
2.9.1 协程的作用 52
2.9.2 扣除金币的Bug 52
第3章 案例:《球球大作战》 54
3.1 功能需求 54
3.2 方案设计 55
3.2.1 拓扑结构 55
3.2.2 各服务功能 56
3.2.3 消息流程 57
3.2.4 设计要点 57
3.3 搭架子:结构和配置 58
3.3.1 结构 58
3.3.2 配置文件 58
3.3.3 第1版主服务 59
3.3.4 启动脚本 60
3.3.5 服务配置 60
3.4 磨刀工:封装易用的API 62
3.4.1 定义属性 63
3.4.2 启动逻辑 63
3.4.3 消息分发 64
3.4.4 辅助方法 65
3.4.5 编写空服务 66
3.5 分布式登录流程 67
3.5.1 完整的登录流程 67
3.5.2 掉线登出流程 69
3.5.3 协议格式 69
3.6 代码实现:gateway 70
3.6.1 连接类和玩家类 70
3.6.2 接收客户端连接 71
3.6.3 处理客户端协议 74
3.6.4 编码和解码 75
3.6.5 消息分发 76
3.6.6 发送消息接口 78
3.6.7 确认登录接口 79
3.6.8 登出流程 80
3.7 代码实现:login 81
3.7.1 登录协议 81
3.7.2 客户端消息分发 81
3.7.3 登录流程处理 82
3.8 代码实现:agentmgr 83
3.8.1 玩家类 83
3.8.2 请求登录接口 84
3.8.3 请求登出接口 86
3.9 代码实现:nodemgr 86
3.10 代码实现:agent(单机版) 87
3.10.1 消息分发 87
3.10.2 数据加载 87
3.10.3 保存和退出 88
3.10.4 单机测试 88
3.11 测试登录流程 89
3.11.1 第2版主服务 89
3.11.2 单节点测试 90
3.11.3 跨节点测试 90
3.12 战斗流程梳理 91
3.12.1 战斗流程 91
3.12.2 协议 91
3.13 代码实现:场景服务 93
3.13.1 Ball类 93
3.13.2 Food类 94
3.13.3 进入战斗 95
3.13.4 退出战斗 97
3.13.5 操作移动 97
3.13.6 主循环 97
3.13.7 移动逻辑 99
3.13.8 生成食物 99
3.13.9 吞下食物 100
3.13.10 第3版主服务 101
3.14 代码实现:agent(跨服务器版) 101
3.14.1 多个模块 101
3.14.2 进入战斗 101
3.14.3 退出战斗 103
3.14.4 最后的辅助方法 103
3.14.5 运行结果 104
3.15 改进 104
第4章 Skynet进阶技法 106
4.1 用“长度信息”解TCP包 107
4.1.1 长度信息法 107
4.1.2 使用netpack模块解析网络包 107
4.1.3 测试小案例 110
4.1.4 阻塞方法的时序 113
4.2 用Json序列化协议 114
4.2.1 安装lua-cjson模块 115
4.2.2 使用lua-cjson模块 115
4.2.3 设计完整协议格式 117
4.2.4 编码Json协议 117
4.2.5 解码Json协议 118
4.2.6 测试 118
4.3 用Protobuf高效传输 119
4.3.1 什么是Protobuf 120
4.3.2 安装Protobuf和pbc 120
4.3.3 编译proto文件 121
4.3.4 编码和解码 121
4.4 如何设计游戏数据库 122
4.4.1 传统设计方法 123
4.4.2 传统的数据库难以应对版本更新 124
4.4.3 Key-Value表结构 125
4.4.4 用Protobuf描述玩家数据 126
4.4.5 创建角色 126
4.4.6 读取角色数据 127
4.4.7 应对游戏版本更新 128
4.4.8 拆分数据表 129
4.5 如何关闭服务器 130
4.5.1 管理控制台 130
4.5.2 关闭服务器的流程 131
4.5.3 阻止新玩家连入 132
4.5.4 缓缓踢下线 133
4.5.5 测试关闭服务器的功能 135
4.6 怎样做定时系统 136
4.6.1 每天第一次登录 136
4.6.2 定时唤醒 137
4.7 断线重连 138
4.7.1 原理解析 139
4.7.2 身份标识 139
4.7.3 消息缓存 140
4.7.4 处理重连请求 141
4.7.5 断线处理 142
4.7.6 测试 143
第二部分 入木三分
第5章 你好,C++并发世界 146
5.1 从HelloWorld开始 147
5.1.1 HelloWorld 147
5.1.2 用CMake构建工程 147
5.1.3 “学猫叫”小例子 149
5.1.4 各文件的依赖关系 151
5.1.5 模仿Skynet写底层 151
5.2 多核多线程 153
5.2.1 操作系统调度原理 153
5.2.2 创建线程对象 154
5.2.3 模仿Skynet开启线程 155
5.2.4 等待线程退出 158
5.2.5 Worker设计模式 159
5.3 探索C++对象模型 160
5.3.1 Actor模型的消息类 160
5.3.2 栈、堆、智能指针 161
5.3.3 对象的内存分布 162
5.4 队列与锁 162
5.4.1 模仿Skynet写服务类 163
5.4.2 锁的初始化 164
5.4.3 多线程队列插入 166
5.4.4 在多线程队列取出元素 166
5.4.5 三个回调方法 168
5.4.6 分析临界区 168
5.5 多线程下的对象管理 170
5.5.1 使用哈希表 170
5.5.2 浅析读写锁 171
5.5.3 新建服务 172
5.5.4 查找服务 172
5.5.5 删除服务 173
5.5.6 程序终于能运行了 174
5.6 充分利用CPU 175
5.6.1 全局消息队列 175
5.6.2 插入和弹出 177
5.6.3 标志位 178
5.6.4 模仿Skynet发送消息 179
5.6.5 工作线程调度 180
5.7 演示程序PingPong 183
5.7.1 辅助函数 183
5.7.2 编写ping服务 183
5.7.3 测试 184
5.8 条件变量与唤醒机制 185
5.8.1 改进版线程调度 185
5.8.2 如何使用条件变量 186
5.8.3 工作线程的等待与唤醒 188
5.8.4 测试 189
5.9 后台运行 189
第6章 图解TCP网络模块 191
6.1 启动网络线程 192
6.1.1 方案设计 192
6.1.2 新增两种消息 192
6.1.3 套接字到底是什么 193
6.1.4 模仿Skynet的网络线程 195
6.1.5 自定义连接类 197
6.2 半小时搞懂Epoll的用法 201
6.2.1 从轮询说起 202
6.2.2 创建epoll对象 203
6.2.3 直观理解监听列表 204
6.2.4 最重要的步骤:等待 207
6.2.5 监听对象的生命周期 210
6.2.6 水平触发和边缘触发 211
6.3 打开监听端口 212
6.3.1 三个API:socket、bind和listen 212
6.3.2 如何保障线程安全 215
6.3.3 关闭连接 215
6.3.4 测试:感知新连接 216
6.4 网络事件分发 216
6.4.1 拆分事件 217
6.4.2 接收新客户端 218
6.4.3 传递可读写事件 220
6.4.4 测试:Echo程序 220
6.5 如何安全读写数据 222
6.5.1 消息分支 222
6.5.2 可读、可写、关闭 224
6.5.3 处理莫名其妙退出的问题 226
6.5.4 PIPE信号处理 228
6.6 写缓冲区满 229
6.6.1 实验:发送大数据 229
6.6.2 解决方法1:设置SNDBUFFORCE 230
6.6.3 解决方法2:自写缓冲区 230
第7章 嵌入Lua脚本语言 234
7.1 方案设计 234
7.1.1 隔离数千个服务 235
7.1.2 结构 235
7.1.3 启动流程 235
7.2 嵌入Lua虚拟机 236
7.2.1 下载、编译源码 236
7.2.2 理解静态库 237
7.2.3 最重要的结构:lua_State 238
7.2.4 从创建到销毁 239
7.2.5 编译指令 240
7.3 C++调用Lua方法 241
7.3.1 代码示例 241
7.3.2 涉及4个API 242
7.3.3 直观理解Lua栈 243
7.3.4 再回顾调用方法 244
7.4 Lua调用C++函数 245
7.4.1 Sunnet的脚本模块 245
7.4.2 写接口 246
7.4.3 分析4个API 246
7.4.4 还需注册函数 248
7.4.5 思考题 250
7.5 Lua版的PingPong 251
7.5.1 封装两个新接口 251
7.5.2 Lua版的ping服务 253
7.5.3 运行结果 254
7.5.4 参数序列化 255
7.6 Lua版聊天室 256
7.6.1 继续封装 256
7.6.2 Lua版的聊天服务 258
7.6.3 运行结果 258
7.6.4 拓展说明 259
第三部分 各个击破
第8章 同步算法 262
8.1 同步难题 263
8.1.1 一种移动方法 263
8.1.2 瞬移、顿挫、打不中 264
8.1.3 抖动和延迟 265
8.2 客户端障眼法 267
8.2.1 插值算法 267
8.2.2 缓存队列 268
8.2.3 主动方优先 269
8.3 各类同步方案及适用场景 269
8.3.1 三种同步方案 270
8.3.2 适用场景 271
8.3.3 案例:《天涯明月刀》 271
8.3.4 案例:《王者荣耀》 272
8.3.5 案例:《绝地求生大逃杀》 273
8.4 帧同步 273
8.4.1 帧同步究竟是什么 274
8.4.2 代码范例 275
8.4.3 确定性计算 279
8.4.4 乐观帧同步 280
8.5 AOI算法 282
8.5.1 感兴趣区域 282
8.5.2 实体模型 283
8.5.3 九宫格法 284
8.6 可靠UDP 287
8.6.1 三角制约 287
8.6.2 几种现成方案 288
第9章 热更新 289
9.1 Skynet热更新 290
9.1.1 业务范例 290
9.1.2 利用独立虚拟机热更新 292
9.1.3 注入补丁 294
9.2 切换进程 296
9.2.1 从冷更新说起 296
9.2.2 《跳一跳》游戏案例 297
9.2.3 优雅的进程切换 298
9.2.4 fork和exec 298
9.2.5 Nginx的热更新方法 299
9.2.6 利用网关实现热更新 300
9.2.7 数据与逻辑分离 300
9.2.8 微服务 301
9.3 动态库 302
9.3.1 模拟案例 302
9.3.2 实现动态库热更新 303
9.3.3 动态库的限制 305
9.3.4 动态库在游戏中的应用 306
9.3.5 多线程与版本管理 306
9.4 脚本语言 308
9.4.1 业务需求 308
9.4.2 实现Lua热更新 310
9.4.3 尽量做正确的热更新 310
9.4.4 没有“万能药”的根源 311
9.4.5 工程实践 313
9.4.6 选择合适的热更新范围 316
第10章 防外挂 318
10.1 不信任客户端 319
10.1.1 刷金币案例 319
10.1.2 连发技能案例 320
10.1.3 透视外挂案例 322
10.2 尽可能多的校验 324
10.2.1 小游戏防刷榜 324
10.2.2 篮球游戏案例 327
10.2.3 部署校验服务 328
10.3 反外挂常用措施 329
10.3.1 防变速器 329
10.3.2 防封包工具 331
10.3.3 帧同步投票 332
第11章 未尽之路 333
11.1 高并发 333
11.1.1 Actor模型 333
11.1.2 One Loop Per Thread 334
11.2 服务端架构 334
11.2.1 大世界架构 334
11.2.2 BigWorld 334
11.2.3 无缝大地图 335
11.2.4 滚服架构 336
11.3 工程管理 337
11.3.1 分层架构 337
11.3.2 人员分工 337
11.3.3 版本管理 338
11.4 结语 339



---------------------------8054539 - Unity3D网络游戏实战(第2版)---------------------------


前言
第1章 网络游戏的开端:Echo 1
1.1 藏在幕后的服务端 1
1.2 网络连接的端点:Socket 3
1.2.1 Socket 3
1.2.2 IP地址 3
1.2.3 端口 4
1.2.4 Socket通信的流程 6
1.2.5 TCP和UDP协议 7
1.3 开始网络编程:Echo 8
1.3.1 什么是Echo程序 8
1.3.2 编写客户端程序 8
1.3.3 客户端代码知识点 10
1.3.4 完成客户端 11
1.3.5 创建服务端程序 12
1.3.6 编写服务端程序 14
1.3.7 服务端知识点 15
1.3.8 测试Echo程序 15
1.4 更多API 16
1.5 公网和局域网 17
第2章 分身有术:异步和多路复用 19
2.1 什么样的代码是异步代码 19
2.2 异步客户端 20
2.2.1 异步Connect 21
2.2.2 Show Me The Code 22
2.2.3 异步Receive 23
2.2.4 异步Send 26
2.3 异步服务端 29
2.3.1 管理客户端 29
2.3.2 异步Accept 30
2.3.3 程序结构 31
2.3.4 代码展示 31
2.4 实践:做个聊天室 35
2.4.1 服务端 35
2.4.2 客户端 35
2.4.3 测试 36
2.5 状态检测Poll 36
2.5.1 什么是Poll 36
2.5.2 Poll客户端 37
2.5.3 Poll服务端 38
2.6 多路复用Select 41
2.6.1 什么是多路复用 41
2.6.2 Select服务端 42
2.6.3 Select客户端 44
第3章 实践出真知:大乱斗游戏 45
3.1 什么是大乱斗游戏 45
3.2 搭建场景 46
3.3 角色类Human 49
3.3.1 类结构设计 49
3.3.2 BaseHuman 49
3.3.3 角色预设 51
3.3.4 CtrlHuman 54
3.3.5 SyncHuman 57
3.4 如何使用网络模块 57
3.4.1 委托 57
3.4.2 通信协议 59
3.4.3 消息队列 60
3.4.4 NetManager类 60
3.4.5 测试网络模块 64
3.5 进入游戏:Enter协议 66
3.5.1 创建角色 67
3.5.2 接收Enter协议 70
3.5.3 测试Enter协议 70
3.6 服务端如何处理消息 72
3.6.1 反射机制 72
3.6.2 消息处理函数 73
3.6.3 事件处理 74
3.6.4 玩家数据 76
3.6.5 处理Enter协议 77
3.7 玩家列表:List协议 77
3.7.1 客户端处理 78
3.7.2 服务端处理 79
3.7.3 测试 79
3.8 移动同步:Move协议 80
3.8.1 客户端处理 80
3.8.2 服务端处理 81
3.8.3 测试 81
3.9 玩家离开:Leave协议 82
3.9.1 客户端处理 82
3.9.2 服务端处理 82
3.9.3 测试 82
3.10 攻击动作:Attack协议 83
3.10.1 播放攻击动作 83
3.10.2 客户端处理 87
3.10.3 服务端处理 88
3.10.4 测试 88
3.11 攻击伤害:Hit协议 89
3.11.1 客户端处理 89
3.11.2 服务端处理 91
3.12 角色死亡:Die协议 91
3.12.1 客户端处理 91
3.12.2 测试 92
第4章 正确收发数据流 94
4.1 TCP数据流 94
4.1.1 系统缓冲区 94
4.1.2 粘包半包现象 96
4.1.3 人工重现粘包现象 97
4.2 解决粘包问题的方法 97
4.2.1 长度信息法 97
4.2.2 固定长度法 98
4.2.3 结束符号法 98
4.3 解决粘包的代码实现 99
4.3.1 发送数据 99
4.3.2 接收数据 99
4.3.3 处理数据 101
4.3.4 完整的示例 104
4.3.5 测试程序 106
4.4 大端小端问题 109
4.4.1 为什么会有大端小端之分 110
4.4.2 使用Reverse()兼容大小端编码 111
4.4.3 手动还原数值 111
4.5 完整发送数据 112
4.5.1 不完整发送示例 113
4.5.2 如何解决发送不完整问题 113
4.5.3 ByteArray和Queue 117
4.5.4 解决线程冲突 120
4.5.5 为什么要使用队列 121
4.6 高效的接收数据 122
4.6.1 不足之处 122
4.6.2 完整的ByteArray 123
4.6.3 将ByteArray应用到异步程序 129
第5章 深入了解TCP,解决暗藏问题 133
5.1 从TCP到铜线 133
5.1.1 应用层 133
5.1.2 传输层 134
5.1.3 网络层 135
5.1.4 网络接口 135
5.2 数据传输流程 136
5.2.1 TCP连接的建立 136
5.2.2 TCP的数据传输 137
5.2.3 TCP连接的终止 138
5.3 常用TCP参数 138
5.3.1 ReceiveBufferSize 138
5.3.2 SendBufferSize 139
5.3.3 NoDelay 139
5.3.4 TTL 140
5.3.5 ReuseAddress 141
5.3.6 LingerState 142
5.4 Close的恰当时机 144
5.5 异常处理 146
5.6 心跳机制 147
第6章 通用客户端网络模块 148
6.1 网络模块设计 148
6.1.1 对外接口 148
6.1.2 内部设计 149
6.2 网络事件 150
6.2.1 事件类型 151
6.2.2 监听列表 151
6.2.3 分发事件 152
6.3 连接服务端 152
6.3.1 Connect 152
6.3.2 ConnectCallback 154
6.3.3 测试程序 155
6.4 关闭连接 156
6.4.1 isClosing 157
6.4.2 Close 157
6.4.3 测试 158
6.5 Json协议 158
6.5.1 为什么会有协议类 158
6.5.2 使用JsonUtility 159
6.5.3 协议格式 160
6.5.4 协议文件 161
6.5.5 协议体的编码解码 162
6.5.6 协议名的编码解码 163
6.6 发送数据 165
6.6.1 Send 165
6.6.2 SendCallback 166
6.6.3 测试 167
6.7 消息事件 168
6.8 接收数据 170
6.8.1 新的成员 171
6.8.2 ConnectCallback 171
6.8.3 ReceiveCallback 172
6.8.4 OnReceiveData 172
6.8.5 Update 174
6.8.6 测试 175
6.9 心跳机制 176
6.9.1 PING和PONG协议 176
6.9.2 成员变量 177
6.9.3 发送PING协议 178
6.9.4 监听PONG协议 178
6.9.5 测试 179
6.10 Protobuf协议 179
6.10.1 什么是Protobuf 179
6.10.2 编写proto文件 180
6.10.3 生成协议类 181
6.10.4 导入protobuf-net.dll 183
6.10.5 编码解码 183
第7章 通用服务端框架 186
7.1 服务端架构 187
7.1.1 总体架构 187
7.1.2 模块划分 187
7.1.3 游戏流程 188
7.2 Json编码解码 189
7.2.1 添加协议文件 189
7.2.2 引用System.web.Extensions 190
7.2.3 修改MsgBase类 191
7.2.4 测试 192
7.3 网络模块 193
7.3.1 整体结构 193
7.3.2 ClientState 194
7.3.3 开启监听和多路复用 194
7.3.4 处理监听消息 196
7.3.5 处理客户端消息 197
7.3.6 关闭连接 198
7.3.7 处理协议 199
7.3.8 Timer 200
7.3.9 发送协议 201
7.3.10 测试 202
7.4 心跳机制 204
7.4.1 lastPingTime 204
7.4.2 时间戳 204
7.4.3 回应MsgPing协议 205
7.4.4 超时处理 205
7.4.5 测试程序 206
7.5 玩家的数据结构 206
7.5.1 完整的ClientState 206
7.5.2 PlayerData 208
7.5.3 Player 208
7.5.4 PlayerManager 209
7.6 配置MySQL数据库 211
7.6.1 安装并启动MySQL数据库 211
7.6.2 安装Navicat for MySQL 213
7.6.3 配置数据表 214
7.6.4 安装connector 215
7.6.5 MySQL基础知识 216
7.7 数据库模块 217
7.7.1 连接数据库 218
7.7.2 防止SQL注入 220
7.7.3 IsAccountExist 220
7.7.4 Register 221
7.7.5 CreatePlayer 223
7.7.6 CheckPassword 224
7.7.7 GetPlayerData 225
7.7.8 UpdatePlayerData 226
7.8 登录注册功能 226
7.8.1 注册登录协议 227
7.8.2 记事本协议 228
7.8.3 注册功能 229
7.8.4 登录功能 229
7.8.5 退出功能 231
7.8.6 获取文本功能 231
7.8.7 保存文本功能 231
7.8.8 客户端界面 232
7.8.9 客户端监听 233
7.8.10 客户端注册功能 235
7.8.11 客户端登录功能 235
7.8.12 客户端记事本功能 236
7.8.13 测试 236
第8章 完整大项目《坦克大战》 239
8.1 《坦克大战》游戏功能 239
8.1.1 登录注册 239
8.1.2 房间系统 240
8.1.3 战斗系统 241
8.2 坦克模型 242
8.2.1 导入模型 242
8.2.2 模型结构 243
8.3 资源管理器 245
8.3.1 设计构想 245
8.3.2 代码实现 245
8.3.3 测试 246
8.4 坦克类 246
8.4.1 设计构想 246
8.4.2 代码实现 246
8.4.3 测试 247
8.5 行走控制 248
8.5.1 速度参数 249
8.5.2 移动控制 249
8.5.3 测试 250
8.5.4 走在地形上 251
8.6 坦克爬坡 253
8.6.1 Unity的物理系统 253
8.6.2 添加物理组件 253
8.6.3 测试 254
8.7 相机跟随 255
8.7.1 功能需求 255
8.7.2 数学原理 255
8.7.3 编写代码 257
8.7.4 测试 258
8.8 旋转炮塔 260
8.8.1 炮塔元素 260
8.8.2 旋转控制 261
8.8.3 测试 262
8.9 发射炮弹 262
8.9.1 制作炮弹预设 262
8.9.2 制作爆炸效果 263
8.9.3 炮弹组件 264
8.9.4 坦克开炮 266
8.9.5 测试 268
8.10 摧毁敌人 269
8.10.1 坦克的生命值 269
8.10.2 焚烧特效 270
8.10.3 坦克被击中处理 271
8.10.4 炮弹的攻击处理 272
8.10.5 测试 272
第9章 UI界面模块 274
9.1 界面模块的设计 274
9.1.1 简单的界面调用 274
9.1.2 通用界面模块 275
9.2 场景结构 277
9.3 面板基类BasePanel 278
9.3.1 设计要点 278
9.3.2 代码实现 278
9.3.3 知识点 279
9.4 界面管理器PanelManager 281
9.4.1 层级管理 281
9.4.2 打开面板 282
9.4.3 关闭面板 284
9.5 登录面板LoginPanel 284
9.5.1 导入资源 284
9.5.2 UI组件 286
9.5.3 制作面板预设 286
9.5.4 登录面板类 289
9.5.5 打开面板 289
9.5.6 引用UI组件 290
9.5.7 网络监听 291
9.5.8 登录和注册按钮 293
9.5.9 收到登录协议 293
9.6 注册面板RegisterPanel 294
9.6.1 制作面板预设 294
9.6.2 注册面板类 296
9.6.3 按钮事件 298
9.6.4 收到注册协议 299
9.7 提示面板TipPanel 300
9.7.1 制作面板预设 300
9.7.2 提示面板类 301
9.7.3 测试面板 302
9.8 游戏入口GameMain 303
9.8.1 设计要点 303
9.8.2 代码实现 304
9.8.3 缓存用户名 305
9.9 功能测试 306
9.9.1 登录 306
9.9.2 注册 307
9.9.3 下线 309
第10章 游戏大厅和房间 310
10.1 列表面板预设 311
10.1.1 整体结构 311
10.1.2 个人信息栏 312
10.1.3 操作栏 312
10.1.4 房间列表栏 313
10.1.5 Scroll View 315
10.1.6 列表项Room 316
10.2 房间面板预设 318
10.2.1 整体结构 318
10.2.2 列表栏 319
10.2.3 列表项Player 320
10.2.4 控制栏 322
10.3 协议设计 322
10.3.1 查询战绩MsgGetAchieve协议 323
10.3.2 查询房间列表MsgGetRoom--List协议 323
10.3.3 创建房间MsgCreateRoom协议 324
10.3.4 进入房间MsgEnterRoom协议 324
10.3.5 查询房间信息MsgGetRoom-Info协议 324
10.3.6 退出房间MsgLeaveRoom协议 325
10.3.7 开始战斗MsgStartBattle协议 325
10.4 列表面板逻辑 326
10.4.1 面板类 326
10.4.2 获取部件 326
10.4.3 网络监听 328
10.4.4 刷新战绩 329
10.4.5 刷新房间列表 329
10.4.6 加入房间 330
10.4.7 创建房间 331
10.4.8 刷新按钮 332
10.5 房间面板逻辑 332
10.5.1 面板类 332
10.5.2 获取部件 333
10.5.3 网络监听 334
10.5.4 刷新玩家列表 334
10.5.5 退出房间 336
10.5.6 开始战斗 336
10.6 打开列表面板 337
10.7 服务端玩家数据 337
10.7.1 存储数据 338
10.7.2 临时数据 338
10.8 服务端房间类 339
10.8.1 管理器和房间类的关系 339
10.8.2 房间类的设计要点 340
10.8.3 添加玩家 341
10.8.4 选择阵营 343
10.8.5 删除玩家 343
10.8.6 选择新房主 345
10.8.7 广播消息 345
10.8.8 生成房间信息 345
10.9 服务端房间管理器 347
10.9.1 数据结构 347
10.9.2 获取房间 347
10.9.3 添加房间 348
10.9.4 删除房间 348
10.9.5 生成列表信息 348
10.10 服务端消息处理 349
10.10.1 查询战绩MsgGet-Achieve 350
10.10.2 查询房间列表MsgGetRoom-List 350
10.10.3 创建房间MsgCreate-Room 351
10.10.4 进入房间MsgEnterRoom 351
10.10.5 查询房间信息MsgGet-RoomInfo 352
10.10.6 离开房间MsgLeave-Room 352
10.11 玩家事件处理 353
10.12 测试 354
第11章 战斗和胜负判定 358
11.1 协议设计 358
11.1.1 进入战斗MsgEnterBattle 359
11.1.2 战斗结果MsgBattleResult 359
11.1.3 退出战斗MsgLeaveBattle 360
11.2 坦克 360
11.2.1 不同阵营的坦克预设 360
11.2.2 战斗模块 361
11.2.3 同步坦克SyncTank 362
11.2.4 坦克的属性 362
11.3 战斗管理器 363
11.3.1 设计要点 363
11.3.2 管理器类 363
11.3.3 坦克管理 364
11.3.4 重置战场 365
11.3.5 开始战斗 366
11.3.6 产生坦克 367
11.3.7 战斗结束 369
11.3.8 玩家离开 369
11.4 战斗结果面板 369
11.4.1 面板预设 369
11.4.2 面板逻辑 371
11.5 服务端开启战斗 373
11.5.1 能否开始战斗 373
11.5.2 定义出生点 373
11.5.3 坦克信息 376
11.5.4 开启战斗 377
11.5.5 消息处理 377
11.6 服务端胜负判断 378
11.6.1 是否死亡 379
11.6.2 胜负决断函数 379
11.6.3 定时器 380
11.6.4 Room::Update 380
11.7 服务端断线处理 381
11.8 测试 382
11.8.1 进入战场 382
11.8.2 离开战场 384
第12章 同步战斗信息 386
12.1 同步理论 387
12.1.1 同步的过程 387
12.1.2 同步的难题 387
12.2 状态同步 389
12.2.1 直接状态同步 389
12.2.2 跟随算法 390
12.2.3 预测算法 390
12.3 帧同步 391
12.3.1 指令同步 391
12.3.2 从Update说起 392
12.3.3 什么是同步帧 393
12.3.4 指令 394
12.3.5 指令的执行 394
12.4 协议设计 395
12.4.1 位置同步MsgSyncTank 396
12.4.2 开火MsgFire 396
12.4.3 击中MsgHit 397
12.5 发送同步信息 397
12.5.1 发送位置信息 397
12.5.2 发送开火信息 398
12.5.3 发送击中信息 399
12.6 处理同步信息 400
12.6.1 协议监听 400
12.6.2 OnMsgSyncTank 401
12.6.3 OnMsgFire 401
12.6.4 OnMsgHit 402
12.7 同步坦克SyncTank 402
12.7.1 预测算法的成员变量 402
12.7.2 移动到预测位置 403
12.7.3 初始化 404
12.7.4 更新预测位置 405
12.7.5 炮弹同步 406
12.8 服务端消息处理 406
12.8.1 位置同步MsgSyncTank 407
12.8.2 开火MsgFire 408
12.8.3 击中MsgHit 409
12.8.4 调试 410
12.9 完善细节 412
12.9.1 滚动的轮子和履带 412
12.9.2 灵活操作 413
12.9.3 准心 413
12.9.4 自动瞄准 414
12.9.5 界面和场景优化 414
12.9.6 战斗面板 415
12.9.7 击杀提示 416
12.10 结语 416

推荐

车牌查询
桂ICP备20004708号-3