1
00:00:04,080 --> 00:00:05,890
‫你好, 欢迎回来｡

2
00:00:05,910 --> 00:00:11,990
‫现在我们正在向前和向后移动我们的坦克, 但我们没有办法实际驾驶坦克｡

3
00:00:12,000 --> 00:00:18,260
‫所以在这段视频中, 我们将使用一种叫做局部旋转的方法来实际转动水箱｡

4
00:00:18,270 --> 00:00:23,040
‫这是添加演员局部偏移的旋转模拟｡

5
00:00:23,070 --> 00:00:29,850
‫现在, add actor local offset有多个输入参数, 我们只传入了第一个参数,

6
00:00:29,850 --> 00:00:31,470
‫因为其他三个参数是可选的｡

7
00:00:31,650 --> 00:00:35,010
‫但另外三个中有一个是和扫地有关的｡

8
00:00:35,010 --> 00:00:41,190
‫在我们继续实施轮换之前, 我们将讨论一些关于清扫的内容｡

9
00:00:41,190 --> 00:00:45,660
‫因此, 我回到了ADD Actor Local Offset的文档中｡

10
00:00:45,660 --> 00:00:48,720
‫让我们再看一遍这些输入参数｡

11
00:00:48,750 --> 00:00:52,770
‫第二个叫做B扫描, 它是一个布尔值.

12
00:00:53,160 --> 00:00:59,790
‫现在, 如果我们再向下滚动一点,

13
00:00:59,790 --> 00:01:08,820
‫读取B扫描的信息, 它会显示我们是否扫描到目标位置, 触发沿着重叠, 如果被什么东西挡住, 则在未到达目标位置时停止｡

14
00:01:09,180 --> 00:01:14,790
‫它还继续说明, 仅扫描根组件并检查阻塞冲突｡

15
00:01:14,790 --> 00:01:17,430
‫子元件移动时不扫掠｡

16
00:01:17,700 --> 00:01:20,820
‫如果碰撞处于禁用状态, 则此选项无效｡

17
00:01:21,060 --> 00:01:30,390
‫让我们来讨论一下这在游戏编程中的意义, 扫描是一种由引擎完成的技术, 只要启用了扫描｡

18
00:01:30,570 --> 00:01:42,090
‫如果我们有一个移动对象（如由该圆表示的球体）, 则在该球体移动的每一帧中, 引擎都将执行扫描检查｡

19
00:01:42,090 --> 00:01:51,420
‫这意味着它正在检查该特定帧的移动是否会导致两个对象之间的重叠｡

20
00:01:51,630 --> 00:01:55,560
‫所以我用这个矩形来表示这个方块｡

21
00:01:56,010 --> 00:01:59,580
‫现在让我们考虑一下这是世界上仅有的两个物体｡

22
00:01:59,580 --> 00:02:09,330
‫因此, 当球体移向对象时启用扫描时, 引擎会检查这两个对象是否重叠｡

23
00:02:09,570 --> 00:02:16,410
‫现在, 当球体继续移动时, 假设在其中一帧中,

24
00:02:16,410 --> 00:02:19,500
‫球体移动到与另一个对象重叠｡

25
00:02:19,500 --> 00:02:26,760
‫现在, 启用扫描的功能是引擎将检测此重叠, 并将该球体移回该特定帧,

26
00:02:26,790 --> 00:02:31,920
‫以便它永远不会实际穿透对象｡

27
00:02:31,950 --> 00:02:35,460
‫现在我们实际上看不到球体穿透物体｡

28
00:02:35,490 --> 00:02:40,530
‫引擎会在实际执行移动之前捕获重叠｡

29
00:02:40,530 --> 00:02:46,020
‫所以结果是我们看到球体在没有重叠的地方停了下来｡

30
00:02:46,020 --> 00:02:52,710
‫因此, 如果这个矩形是一面墙, 例如, 球体将停止在墙的表面｡

31
00:02:52,710 --> 00:02:55,170
‫这就是清扫为我们所实现的｡

32
00:02:55,170 --> 00:03:00,030
‫现在, 文档说明如果碰撞处于禁用状态, 则此操作没有任何效果｡

33
00:03:00,030 --> 00:03:04,590
‫因此, 必须启用碰撞才能使扫描工作｡

34
00:03:04,740 --> 00:03:12,090
‫回到坦克CP的move函数, 这里是添加演员局部偏移的调用,

35
00:03:12,120 --> 00:03:20,310
‫如果需要, 我们可以在这里传入另一个输入参数, 第二个是扫描布尔值, 所以我们可以在这里传入true｡

36
00:03:20,310 --> 00:03:24,540
‫让我们编译一下, 看看启用扫描的效果｡

37
00:03:24,540 --> 00:03:31,560
‫现在如果我们按下播放键, 我们试图穿过一堵墙, 我们会看到我们穿过了墙.

38
00:03:31,560 --> 00:03:34,020
‫所以这里有些不太对劲｡

39
00:03:34,020 --> 00:03:38,280
‫现在, 让我们了解一下BP水池的路由组件是什么｡

40
00:03:38,280 --> 00:03:41,730
‫回想一下, 我们在路径中使用了胶囊组件｡

41
00:03:41,730 --> 00:03:45,570
‫所以用胶囊组件选定在BP池罐内｡

42
00:03:45,570 --> 00:03:51,690
‫让我们转到详细信息面板并向下滚动, 我们将在这里看到一个名为“碰撞”的部分｡

43
00:03:51,690 --> 00:03:55,860
‫这里我们可以看到“碰撞预设”, 它有一个下拉菜单｡

44
00:03:55,860 --> 00:03:57,420
‫让我们把它扩展一下｡

45
00:03:57,420 --> 00:04:05,010
‫现在, “碰撞预设”可以设置为任意数量的选项, 默认情况下, 我们会看到所有动态重叠｡

46
00:04:05,010 --> 00:04:08,280
‫现在, 根据你使用的虚幻引擎的版本｡

47
00:04:08,280 --> 00:04:11,580
‫您可能会在此处看到其他内容, 但我们可以更改此内容｡

48
00:04:11,580 --> 00:04:18,750
‫如果我们选择下拉菜单并选择“阻止所有动态”, 则下面的灰显选项会发生变化｡

49
00:04:18,750 --> 00:04:25,470
‫请记住, 我们是在重叠所有动态, 这里我们看到三列复选框｡

50
00:04:25,590 --> 00:04:33,240
‫这些是碰撞响应, 左侧的列显示碰撞对象类型的列表｡

51
00:04:33,240 --> 00:04:37,860
‫因此, 任何给定的组件都有其自己的碰撞对象类型｡

52
00:04:37,860 --> 00:04:42,840
‫请注意, 我们可以看到胶囊的对象类型设置为世界动力学｡

53
00:04:42,840 --> 00:04:54,450
‫当我们更改碰撞预设以阻止所有动态时, 您会看到碰撞响应都被选中以阻止所有其他碰撞对象类型｡

54
00:04:54,450 --> 00:04:59,160
‫让我们按下播放键, 看看当我们试图穿过物体时会发生什么｡

55
00:04:59,160 --> 00:05:03,630
‫您会看到我们在与重叠的地方停止｡

56
00:05:03,710 --> 00:05:04,860
‫其他池塘｡

57
00:05:04,880 --> 00:05:14,340
‫现在, 如果我移动水池这样我们就可以尝试与墙重叠然后绕过其他池塘.

58
00:05:14,360 --> 00:05:17,900
‫现在, 如果我按下播放, 我也会挡住墙｡

59
00:05:17,900 --> 00:05:26,330
‫因此, 此碰撞预设块, 所有动态设置碰撞响应以阻止所有其他对象类型｡

60
00:05:26,330 --> 00:05:32,900
‫您可以随时查看特定组件的碰撞对象类型,

61
00:05:32,900 --> 00:05:40,790
‫方法是在组件面板中选择该组件, 向下滚动到详细信息面板中的碰撞部分, 然后打开“碰撞预设”下拉列表｡

62
00:05:40,790 --> 00:05:47,540
‫我选择了基础网格, 其对象类型为世界动态, 并设置为全部阻止｡

63
00:05:47,540 --> 00:05:55,490
‫现在我们可以看到, 由于我们为胶囊补偿设置了碰撞预设, 以阻止所有动态, 因此扫描工作正常｡

64
00:05:55,490 --> 00:06:02,720
‫我们在文档中看到, 只有根组件被扫描并检查阻塞冲突｡

65
00:06:02,720 --> 00:06:06,140
‫因此, 其他组件设置为什么并不重要｡

66
00:06:06,170 --> 00:06:10,790
‫我们只是检查根组件是否阻塞了某些内容｡

67
00:06:10,790 --> 00:06:15,800
‫现在, 一个问题, 绊倒了一些学生是, 他们不能移动, 只要他们设置胶囊,

68
00:06:15,800 --> 00:06:17,510
‫以阻止所有的动态｡

69
00:06:17,810 --> 00:06:23,750
‫其中一个原因可能是您的胶囊与地板重叠｡

70
00:06:23,780 --> 00:06:28,820
‫如果胶囊与地板重叠,

71
00:06:28,820 --> 00:06:35,390
‫您将无法移动, 因为如果胶囊组件与它设置为阻挡的东西重叠, 引擎将不允许您的坦克移动｡

72
00:06:35,390 --> 00:06:41,240
‫因此, 一个简单的解决办法是确保你的胶囊不会与地板重叠｡

73
00:06:41,720 --> 00:06:49,370
‫现在, 你可以进入你的BP-—油箱, 确保你的胶囊就在轮子的上方｡

74
00:06:49,370 --> 00:06:52,640
‫我将进入正交视图｡

75
00:06:53,720 --> 00:06:56,840
‫然后选择我的基础网格, 然后把它放下来｡

76
00:06:56,840 --> 00:07:00,980
‫所以轮子就在胶囊组件的下面｡

77
00:07:01,190 --> 00:07:06,470
‫现在如果你的网片在地板上胶囊就在网片上方｡

78
00:07:06,680 --> 00:07:09,010
‫你应该可以走动了｡

79
00:07:09,020 --> 00:07:12,110
‫我现在要按播放键, 开始了｡

80
00:07:12,740 --> 00:07:17,620
‫现在我们已经扫除了障碍, 是时候开始实施轮换了｡

81
00:07:17,630 --> 00:07:19,520
‫让我们返回项目设置｡

82
00:07:19,520 --> 00:07:29,060
‫因此, 我们进入编辑项目设置, 向下滚动到输入, 在输入部分, 我们有我们的轴映射｡

83
00:07:29,060 --> 00:07:30,710
‫现在我们已经解决了｡

84
00:07:30,710 --> 00:07:31,790
‫往前走｡

85
00:07:31,790 --> 00:07:40,220
‫现在是时候处理下一个称为Turn的问题了, Turn有D和A, 其中D的比例为1,

86
00:07:40,220 --> 00:07:44,060
‫A的比例为负1｡

87
00:07:44,060 --> 00:07:48,080
‫我们想用D和AX来旋转坦克｡

88
00:07:48,170 --> 00:07:54,470
‫因此, 为了将函数绑定到旋转轴映射, 我们需要绑定一个函数｡

89
00:07:54,470 --> 00:08:04,100
‫现在我们回到V的代码中, 我将进入tank文件, 这样我们就可以创建一个函数来绑定到旋转轴映射｡

90
00:08:04,100 --> 00:08:08,630
‫现在我把这个void函数叫做turn和move.

91
00:08:08,660 --> 00:08:12,560
‫它需要一个浮点输入参数, 我们调用这个值.

92
00:08:12,560 --> 00:08:19,790
‫我们已经声明了这个函数, 让我们定义它和tank CP, 我会把它放在move函数下面｡

93
00:08:19,790 --> 00:08:27,590
‫所以我给了它一个函数体, 我需要类名和函数名前面的双冒号｡

94
00:08:27,590 --> 00:08:29,270
‫现在我们有了一个适当的函数｡

95
00:08:29,270 --> 00:08:31,400
‫现在, 这不是我们唯一需要做的事情｡

96
00:08:31,430 --> 00:08:36,590
‫我们需要确保此函数绑定到称为turn的轴映射｡

97
00:08:36,590 --> 00:08:44,000
‫我们在设置播放器输入组件中执行此操作, 就像我们执行向前移动轴映射一样｡

98
00:08:44,000 --> 00:08:51,290
‫我们将使用玩家输入组件, 我们将使用箭头操作符和绑定轴｡

99
00:08:52,100 --> 00:08:58,250
‫现在, 第一个参数将是包含在文本宏中的轴映射名称｡

100
00:08:58,340 --> 00:09:02,420
‫所以我们要说turn, 因为这是轴映射的名称｡

101
00:09:02,420 --> 00:09:05,180
‫接下来是我们要绑定函数的对象｡

102
00:09:05,180 --> 00:09:10,100
‫我们可以传入这个函数, 最后传入我们想要再次绑定的函数｡

103
00:09:10,100 --> 00:09:14,600
‫我们需要操作员的地址, 这将是一个坦克转弯｡

104
00:09:14,600 --> 00:09:16,550
‫所以就这么简单｡

105
00:09:16,580 --> 00:09:21,200
‫我们已经将转弯函数绑定到转弯轴映射｡

106
00:09:21,500 --> 00:09:26,330
‫唯一剩下的事情就是在turn函数中做一些事情｡

107
00:09:26,330 --> 00:09:32,390
‫现在我们已经看到, 我们有添加演员局部偏移, 但有一个旋转模拟这个函数,

108
00:09:32,390 --> 00:09:35,240
‫它被称为添加演员局部旋转｡

109
00:09:35,240 --> 00:09:41,600
‫它的作用是给演员添加一个局部旋转, 正如它的名字所暗示的,

110
00:09:41,600 --> 00:09:48,530
‫你会看到这个函数有两个不同的版本, 一个使用F旋转器, 另一个使用F四边形.

111
00:09:48,530 --> 00:09:51,140
‫我们将使用一个F旋转器的版本｡

112
00:09:51,140 --> 00:09:53,480
‫这叫做三角形旋转｡

113
00:09:53,480 --> 00:10:03,170
‫就像“添加执行元局部偏移”一样, 它也可以采用一个扫描参数和与“添加执行元局部偏移”相同的另外两个输入参数｡

114
00:10:03,170 --> 00:10:08,720
‫最后这三个输入参数是可选的, 就像添加演员局部偏移一样｡

115
00:10:08,720 --> 00:10:13,060
‫所以我们要传入一个F旋转器, 而不是一个F向量｡

116
00:10:13,070 --> 00:10:20,210
‫现在回到turn函数, 如果我们创建一个F旋转器, 我们称之为Delta旋转, 我们会看到,

117
00:10:20,210 --> 00:10:26,960
‫如果我们右键点击F旋转器, 然后转到定义, 我们会转到旋转器,

118
00:10:26,960 --> 00:10:30,410
‫我们会看到三个float类型的公共成员变量.

119
00:10:30,410 --> 00:10:39,140
‫现在就像F矢量F旋转器只有这三个分量而不是X, Y和Z, 我们有俯仰, 偏航和滚动｡

120
00:10:39,140 --> 00:10:42,050
‫现在, 偏航是我们感兴趣的部分｡

121
00:10:42,050 --> 00:10:46,940
‫它表示围绕Z轴的圆括号中的上轴旋转｡

122
00:10:46,940 --> 00:10:52,370
‫这是我们唯一关心的绕Z轴旋转的类型｡

123
00:10:52,370 --> 00:10:54,500
‫这样我们才能控制坦克｡

124
00:10:54,500 --> 00:11:00,860
‫现在, 我想指出的是, F旋转器也有多个构造函数,

125
00:11:00,860 --> 00:11:06,110
‫默认值也是不初始化的, 就像F向量一样｡

126
00:11:06,110 --> 00:11:13,190
‫因此, 我们可以使用一个接受单个浮点数的函数, 所有组件都将被初始化为该浮点数值｡

127
00:11:13,220 --> 00:11:18,560
‫有一个有三个浮点值, 你可以看看其他的｡

128
00:11:18,560 --> 00:11:25,820
‫现在, 我还要指出, 还有一个零点旋转器, 顺便说一下, 这是一个静态零点旋转器｡

129
00:11:25,820 --> 00:11:34,880
‫这就是为什么我们可以回到坦克CP中, 说, equals, F, rotator, zero,

130
00:11:34,880 --> 00:11:42,170
‫rotator, zero, rotator, 是一个静态成员变量, 你可以访问静态成员函数和变量,

131
00:11:42,170 --> 00:11:48,440
‫就像这样, 通过指定作用域解析操作符的类名, 然后引用静态变量或函数的名字｡

132
00:11:48,440 --> 00:11:50,180
‫这就是我们和你在一起的原因｡

133
00:11:50,180 --> 00:11:53,060
‫游戏静态得到世界三角洲秒是一个静态｡

134
00:11:53,310 --> 00:12:02,230
‫函数, 这意味着我们不需要一个实际的游戏静态类的实例来访问该静态函数｡

135
00:12:02,250 --> 00:12:04,160
‫它已经存在了｡

136
00:12:04,170 --> 00:12:06,930
‫零旋转器和零向量也是如此｡

137
00:12:07,080 --> 00:12:14,700
‫所以我将关闭旋转器h, 我们有这个delta旋转, 它被初始化为零旋转器｡

138
00:12:14,730 --> 00:12:20,280
‫现在, 您的音高和角色被置零, 就像F向量的X､ Y和Z被置零一样｡

139
00:12:20,280 --> 00:12:22,920
‫所以我们需要改变你的组件｡

140
00:12:22,920 --> 00:12:30,120
‫就像我在MOV函数中处理delta位置一样, 让我们为delta旋转创建一些伪代码｡

141
00:12:30,120 --> 00:12:36,690
‫当然, 我们希望将你们的值设置为Delta时间的比例值,

142
00:12:36,690 --> 00:12:43,560
‫因为我们希望这种转向与帧速率无关, 但我们还需要某种转向速度, 我们可以称之为转向速率｡

143
00:12:43,560 --> 00:12:49,890
‫一旦我们设置好了, 我们就可以添加局部旋转, 它将根据F旋转器在每一帧旋转演员,

144
00:12:49,890 --> 00:12:54,630
‫ya将按值缩放｡

145
00:12:54,630 --> 00:13:00,320
‫所以如果我们没有按任何键它就会是零, 如果我们按DX和ax它就会有一个值｡

146
00:13:00,330 --> 00:13:02,190
‫所以现在你有个挑战｡

147
00:13:02,190 --> 00:13:06,090
‫这将像添加演员局部偏移一样工作｡

148
00:13:06,120 --> 00:13:09,000
‫唯一的区别是我们现在是轮流演员｡

149
00:13:09,000 --> 00:13:14,820
‫因为我们需要一些旋转速率来旋转演员, 你要创建一个旋转速率变量, 把它变成一个浮点数,

150
00:13:14,820 --> 00:13:20,550
‫然后把它放在速度变量旁边的私有区域｡

151
00:13:20,550 --> 00:13:25,560
‫使用您的属性公开这个变数, 并选择适当的新属性规范｡

152
00:13:25,560 --> 00:13:32,490
‫现在, 在turn函数中, 您将特别设置Delta

153
00:13:32,490 --> 00:13:41,280
‫rotation, 我们关心的是您的组件将值设置为value乘以我们的turn rate变量, 并乘以delta time,

154
00:13:41,280 --> 00:13:48,780
‫然后您准备好调用add actor local rotation,

155
00:13:48,780 --> 00:13:56,880
‫现在将第二个参数传递到该f旋转器中, 继续, 并为B扫描输入传递true, 因为我们确实希望在旋转时进行扫描, 暂停视频,

156
00:13:56,880 --> 00:13:59,190
‫现在执行坦克的旋转｡

157
00:14:02,110 --> 00:14:02,500
‫好吧, 我会的

158
00:14:02,500 --> 00:14:04,630
‫所以这会相当简单｡

159
00:14:04,630 --> 00:14:07,360
‫我们只需要一个转弯速度变量｡

160
00:14:07,390 --> 00:14:14,440
‫现在我将以低于速度的速度进入油箱并产生浮动转弯速率｡

161
00:14:14,590 --> 00:14:18,640
‫现在你可以把它初始化为某个值, 这没问题.

162
00:14:18,640 --> 00:14:24,040
‫如果它与我选择的不同, 我会选择45 F, 看看它是如何工作的｡

163
00:14:24,040 --> 00:14:29,150
‫但我们要把它暴露在蓝图中, 这样我们就可以在开发过程中改变它｡

164
00:14:29,170 --> 00:14:35,620
‫现在, 我希望它可以在任何地方编辑, 我会坚持在同一类别的运动作为速度｡

165
00:14:35,620 --> 00:14:42,180
‫所以我会把这个属性粘贴到这里, 然后右转, 这样就可以把它设置在任何地方了.

166
00:14:42,190 --> 00:14:45,280
‫现在移动类别和坦克CP｡

167
00:14:45,310 --> 00:14:48,190
‫我已经准备好为Delta轮换设置年份了｡

168
00:14:48,190 --> 00:14:50,320
‫我们称之为三角形旋转｡

169
00:14:50,650 --> 00:14:51,400
‫是的, 我知道

170
00:14:51,790 --> 00:14:57,060
‫我们要把它设为, 价值时间, 转弯角速度时间, 时间增量｡

171
00:14:57,070 --> 00:15:06,340
‫当然, 我们可以通过U游戏静态获取Delta时间, 获取世界Delta秒, 作为世界上下文对象｡

172
00:15:06,460 --> 00:15:08,350
‫所以我把它贴在这里｡

173
00:15:08,470 --> 00:15:12,220
‫现在我知道我的伪代码并不完全匹配｡

174
00:15:12,220 --> 00:15:13,270
‫顺序不对｡

175
00:15:13,270 --> 00:15:14,830
‫德尔塔时间在中间｡

176
00:15:14,830 --> 00:15:21,940
‫这并不重要, 因为当三个值相乘时, 可以按任何顺序相乘, 仍然得到相同的结果｡

177
00:15:21,940 --> 00:15:29,350
‫如果你想知道的话, 如果你把这三个值以不同的顺序相乘, 数学结果还是一样的｡

178
00:15:29,350 --> 00:15:30,910
‫所以不用太担心这个｡

179
00:15:30,910 --> 00:15:32,830
‫现在我们有了δ旋转｡

180
00:15:32,830 --> 00:15:41,860
‫剩下要做的就是调用add actor local rotation, 我们将传入Delta rotation,

181
00:15:41,950 --> 00:15:47,290
‫对于第二个输入, 我们将传入true, 以便在旋转时启用扫描｡

182
00:15:47,290 --> 00:15:48,670
‫我们来编译一下｡

183
00:15:48,820 --> 00:15:50,740
‫好了, 我们现在编好了｡

184
00:15:50,740 --> 00:15:57,700
‫您可能会注意到, 在接下来的几个视频中, 这些行中缺少零矢量和零旋转器｡

185
00:15:57,700 --> 00:16:05,890
‫这是因为我一开始就初始化了这些值, 后来意识到这些值应该至少初始化为零｡

186
00:16:05,890 --> 00:16:12,070
‫所以, 如果你们看到这些线, 在初始化时是这样的, 不要担心,

187
00:16:12,070 --> 00:16:16,690
‫保留零向量和零旋转器, 你们会看到我在不久的将来的视频中看到的｡

188
00:16:16,690 --> 00:16:17,770
‫所以别担心

189
00:16:17,770 --> 00:16:21,430
‫如果您没有看到这些初始化参数, 则它们应该在那里｡

190
00:16:21,430 --> 00:16:23,050
‫我们又回到了编辑器｡

191
00:16:23,050 --> 00:16:30,970
‫让我们点击播放, 我将使用D键, 我们旋转, A键将我旋转回来,

192
00:16:30,970 --> 00:16:33,790
‫我们也可以向前和向后移动｡

193
00:16:33,790 --> 00:16:39,570
‫所以现在我们可以旋转和前进, 我们有能力在世界各地移动｡

194
00:16:39,580 --> 00:16:41,890
‫这是一个伟大的里程碑｡

195
00:16:41,890 --> 00:16:47,620
‫现在我移动得很慢, 但这没关系, 因为我可以选择我的坦克, 我可以搜索移动类别,

196
00:16:47,620 --> 00:16:53,230
‫并改变转弯速度到更高的东西, 如90｡

197
00:16:53,230 --> 00:16:54,760
‫现在我们按播放键｡

198
00:16:55,460 --> 00:16:57,630
‫这是相当快一点｡

199
00:16:57,650 --> 00:17:00,110
‫现在, 如果你觉得这还是有点慢｡

200
00:17:00,140 --> 00:17:02,330
‫当然, 您可以调整这些参数｡

201
00:17:02,330 --> 00:17:05,570
‫所以我要再次选择水箱｡

202
00:17:05,570 --> 00:17:08,090
‫400就改成800吧｡

203
00:17:08,090 --> 00:17:08,720
‫为什么不呢？

204
00:17:08,750 --> 00:17:11,840
‫不要说90, 我们说120｡

205
00:17:12,260 --> 00:17:16,160
‫现在, 如果我按播放, 我会快很多｡

206
00:17:16,160 --> 00:17:18,800
‫所以这看起来真的, 真的很好｡

207
00:17:18,800 --> 00:17:23,390
‫所以回头看看剖面图, 我们现在有了一辆可以在世界各地移动的坦克｡

208
00:17:23,390 --> 00:17:29,300
‫第一个要点肯定是勾选的, 我们正在处理WASD运动｡

209
00:17:29,300 --> 00:17:32,510
‫我们还没有处理鼠标输入, 但我们会处理的｡

210
00:17:32,510 --> 00:17:35,870
‫但我们离完成这个游戏又近了一步｡

211
00:17:35,870 --> 00:17:43,130
‫总之, 我们了解了什么是扫描, 以及如何实现扫描, 使我们的对象不会相互穿过｡

212
00:17:43,130 --> 00:17:50,210
‫我们添加了演员局部旋转, 我们这样做实现了一个可以在细节中调整的旋转速率｡

213
00:17:50,210 --> 00:17:53,750
‫编辑器中的面板, 使开发更容易一些｡

214
00:17:53,750 --> 00:17:54,500
‫干得漂亮

215
00:17:54,500 --> 00:17:56,480
‫我们现在把坦克运到世界各地｡

216
00:17:56,480 --> 00:17:57,770
‫下一个视频里见｡