1
00:00:04,680 --> 00:00:05,640
‫你好, 欢迎｡

2
00:00:05,640 --> 00:00:11,910
‫在这节课中, 我们要让胜利条件起作用, 这样我就可以杀死我级别中的所有敌人｡

3
00:00:11,910 --> 00:00:14,220
‫它会显示这个挡风玻璃｡

4
00:00:14,220 --> 00:00:14,780
‫好耶!

5
00:00:14,790 --> 00:00:16,560
‫让我们来看看它是如何完成的｡

6
00:00:17,800 --> 00:00:22,210
‫所以我们希望我们的玩家有可能赢得这场比赛｡

7
00:00:22,210 --> 00:00:23,740
‫目前他们不能｡

8
00:00:23,950 --> 00:00:25,090
‫那我们要怎么做呢？

9
00:00:25,120 --> 00:00:27,070
‫好吧, 你可以用很多方法来做｡

10
00:00:27,070 --> 00:00:33,370
‫其中之一将是当卒杀死被调用, 卒不是玩家控制器, 而是一个AI｡

11
00:00:33,400 --> 00:00:40,090
‫我们可以从一个变量中减去, 这个变量表示世界上有多少人工智能, 我们要杀死多少｡

12
00:00:40,090 --> 00:00:43,830
‫然后当它降到零的时候, 我们就可以以有利于参与者的方式结束博弈｡

13
00:00:43,840 --> 00:00:51,070
‫然而, 我认为这有点脆弱, 因为它要求我们把世界上有多少敌人放在两个地方｡

14
00:00:51,070 --> 00:00:55,450
‫从本质上讲, 它需要在游戏模式下, 但也需要在世界上, 当你把敌人下来,

15
00:00:55,450 --> 00:00:59,530
‫这两个可能会失去同步, 这将导致一些问题｡

16
00:00:59,740 --> 00:01:05,740
‫所以我更喜欢这样做, 简单地说, 让我们计算一下世界上所有的敌人,

17
00:01:05,740 --> 00:01:13,060
‫每次一个棋子被杀, 让我们重新计算一下, 所有人工智能的人数, 看看哪些还活着｡

18
00:01:13,060 --> 00:01:16,600
‫如果他们中还有人活着, 那我们还不能结束游戏｡

19
00:01:16,600 --> 00:01:21,460
‫基本上, 游戏还没有结束, 但如果他们都死了, 而游戏控制器没有,

20
00:01:21,460 --> 00:01:23,110
‫那么玩家就赢了｡

21
00:01:23,530 --> 00:01:30,070
‫所以为了做到这一点, 我们需要有一种方法来查询一个玩家控制器是否已经死了｡

22
00:01:30,070 --> 00:01:32,140
‫对不起, 我是说, 人工智能控制器｡

23
00:01:32,290 --> 00:01:34,030
‫我们去找枪手吧｡

24
00:01:34,030 --> 00:01:35,260
‫AI控制器｡

25
00:01:36,370 --> 00:01:42,400
‫这里我们要做的是创建一个新的公共方法, 它允许我们查询它是否是死的｡

26
00:01:42,400 --> 00:01:49,330
‫所以我们要做的是一个基本上是死的球, 这将是一个竞赛, 因为它不应该改变控制器中实际发生的事情,

27
00:01:49,330 --> 00:01:52,930
‫当它被调用｡

28
00:01:53,440 --> 00:01:55,780
‫我们可以继续创建一个实现｡

29
00:01:56,510 --> 00:02:01,780
‫现在我们应该控制一个——它可以告诉我们它是否死了｡

30
00:02:01,790 --> 00:02:07,760
‫如果我们再去看一遍, 我们会看到射手的角色, 这是一个——｡

31
00:02:07,760 --> 00:02:12,160
‫记住, 我们已经本是死在那里不能发挥作用了｡

32
00:02:12,170 --> 00:02:17,390
‫所以本质上我们要做的就是把请求传递给我现在控制的射手｡

33
00:02:17,390 --> 00:02:17,990
‫是的, 我知道

34
00:02:17,990 --> 00:02:23,780
‫在KML游戏模式下, 你可以拿到控制器,

35
00:02:23,780 --> 00:02:30,380
‫拿到控制的东西, 投一个角色, 然后检查它是否死了.

36
00:02:30,380 --> 00:02:36,410
‫然而, 这通常不是最佳实践,

37
00:02:36,410 --> 00:02:43,520
‫因为这意味着, 如果我们计算死亡的方式突然发生了变化, 或者AI控制器将要控制不同类型的——, 我们突然需要改变游戏模式,

38
00:02:43,520 --> 00:02:46,880
‫这是没有意义的｡

39
00:02:46,880 --> 00:02:52,580
‫所以最好是这样做, 这样在AI控制内部传递就更鲁棒了｡

40
00:02:52,580 --> 00:02:58,790
‫它阻止了我们在其他类的内部进行操作, 这通常意味着我们可以限制当事情发生变化时,

41
00:02:58,790 --> 00:03:06,920
‫我们可以限制我们必须去接触, 更新和改变多少个类, 这总是一件好事｡

42
00:03:07,400 --> 00:03:13,160
‫所以我们要做的是得到——并投出——以确保它是一个射击角色｡

43
00:03:13,160 --> 00:03:14,450
‫我们来做个石膏吧｡

44
00:03:14,690 --> 00:03:17,270
‫这将是一个射手｡

45
00:03:18,040 --> 00:03:18,970
‫性格｡

46
00:03:19,360 --> 00:03:25,960
‫我认为我们需要在我们的眼睛控制顶部做一个哈希, 以确保我们了解射手角色｡

47
00:03:26,110 --> 00:03:37,000
‫然后我们要执行强制转换, 执行get, 我们要把它存储在一个变量里, 所以它是一个shooter.

48
00:03:37,000 --> 00:03:42,670
‫字符指针调用姑且称之为受控｡

49
00:03:43,830 --> 00:03:44,730
‫性格｡

50
00:03:46,030 --> 00:03:52,390
‫我不能直接称它为字符, 因为它已经是人工智能控制器上的一个变量了, 在行尾放一个分号,

51
00:03:52,390 --> 00:03:56,740
‫我们要检查它是否为空｡

52
00:03:56,980 --> 00:04:04,980
‫所以控制字符不等于空指针, 那么我们应该能够查询它的状态, 比如它是死的还是活的｡

53
00:04:04,990 --> 00:04:10,180
‫所以我们应该可以返回那个被控制的字符｡

54
00:04:11,100 --> 00:04:12,480
‫死了｡

55
00:04:12,810 --> 00:04:18,870
‫基本上, 如果控制角色是一个射手角色, 我们就把请求转发给控制角色｡

56
00:04:18,990 --> 00:04:22,350
‫但是, 请注意, 这里没有return语句｡

57
00:04:22,350 --> 00:04:29,130
‫在另一种情况下, 我们确实需要一个return语句, 如果返回值不是void, 那么它总是一个return｡

58
00:04:29,130 --> 00:04:37,950
‫所以我们需要在if语句的外面放一个return语句, 来捕捉我们在if语句里面还没有返回的情况｡

59
00:04:38,040 --> 00:04:40,950
‫这里我们要说的是, 这个角色死了吗？

60
00:04:40,950 --> 00:04:46,500
‫是的, 如果不是这样, 基本上它是死的｡

61
00:04:46,590 --> 00:04:53,850
‫如果我们没有兵, 如果我们没有控制兵, 那么基本上这个控制器对我们来说就是死的.

62
00:04:54,030 --> 00:05:00,360
‫这是可能发生的, 因为请记住, 当卒死亡时, 它会与其AI控制器分离｡

63
00:05:01,020 --> 00:05:06,630
‫现在我们回到游戏模式我们要做什么呢？

64
00:05:07,110 --> 00:05:16,650
‫本质上我们要做的是在所有的I上进行for循环. 我...我...

65
00:05:17,760 --> 00:05:19,380
‫在世界上｡

66
00:05:20,200 --> 00:05:22,450
‫还有for循环｡

67
00:05:22,570 --> 00:05:23,740
‫我们要做什么？

68
00:05:23,770 --> 00:05:25,990
‫我们要看的就是死｡

69
00:05:27,460 --> 00:05:32,380
‫基本上和或者说基本上是没死｡

70
00:05:33,040 --> 00:05:39,390
‫如果其中任何一个没有死, 那么我们立刻就知道我们根本不必检查所有的眼睛｡

71
00:05:39,400 --> 00:05:44,110
‫哪怕只是一个A｡  一､  还活着, 游戏就还没结束

72
00:05:44,110 --> 00:05:49,180
‫所以我们可以做一个早期返回, 你们可能已经见过了, 它会退出这个函数,

73
00:05:49,180 --> 00:05:54,220
‫而不执行其中的任何代码.

74
00:05:54,220 --> 00:06:00,010
‫所以在这个早期返回之后的所有东西都将停止执行for循环, 在它停止执行之后的任何东西都将停止执行｡

75
00:06:00,550 --> 00:06:07,240
‫但是我们可以说, 如果我们成功地通过了这个完整的循环, 而它没有提前返回,

76
00:06:07,240 --> 00:06:14,500
‫这意味着没有活的A｡ 一､  那我们就得结束这场游戏｡

77
00:06:15,130 --> 00:06:16,060
‫就这么简单｡

78
00:06:16,090 --> 00:06:22,060
‫现在, 我们需要关注的一个谜题是结局.

79
00:06:22,060 --> 00:06:25,860
‫因为我们的游戏已经在玩家控制器上结束了｡

80
00:06:25,870 --> 00:06:29,230
‫让我们来看看射手玩家控制器目前是如何处理这个问题的｡

81
00:06:29,230 --> 00:06:38,560
‫如果我们看它的CP, 我们现在看到的是它现在完全忽略了B是赢家现在忽略了它是不是赢家.

82
00:06:39,190 --> 00:06:44,140
‫所以我们要做的就是判断B是否是赢家｡

83
00:06:45,000 --> 00:06:48,600
‫那我们就做点别的｡

84
00:06:48,960 --> 00:06:52,090
‫我们将显示失败屏幕｡

85
00:06:52,110 --> 00:06:55,930
‫因此, 请将此处负责显示丢失屏幕的这些行剪掉｡

86
00:06:55,950 --> 00:07:00,210
‫把它放在alt语句中, 我们将在这两种情况下重新开始｡

87
00:07:00,690 --> 00:07:02,630
‫所以现在B是赢家｡

88
00:07:02,640 --> 00:07:03,540
‫我们该怎么办？

89
00:07:03,540 --> 00:07:12,440
‫好吧, 我们只是要继续下去, 并可能创造一个挡风玻璃, 以及, 这将是相当简单的｡

90
00:07:12,460 --> 00:07:16,410
‫我们转到射击游戏播放器控制器的头文件｡

91
00:07:16,410 --> 00:07:22,440
‫我们可以复制我们的失败屏幕类, 并在这里创建一个成功屏幕类｡

92
00:07:22,860 --> 00:07:24,750
‫我们还可以继续干下去｡

93
00:07:24,750 --> 00:07:26,160
‫事实上, 这对你来说是个小挑战｡

94
00:07:26,160 --> 00:07:29,650
‫也许可以把它安装起来, 这样它就可以做挡风玻璃了｡

95
00:07:29,970 --> 00:07:30,130
‫好吧, 我会的

96
00:07:30,240 --> 00:07:30,690
‫欢迎回来｡

97
00:07:30,690 --> 00:07:33,150
‫所以希望你已经试过了｡

98
00:07:33,150 --> 00:07:41,550
‫我们将把挡风玻璃放在这里, 而不是所有的损失, 并复制基本上所有其他的东西｡

99
00:07:42,960 --> 00:07:43,800
‫就像这样｡

100
00:07:44,860 --> 00:07:53,650
‫我们将继续编译它, 然后进入编辑器, 找到播放器控制器类.

101
00:07:53,650 --> 00:07:58,540
‫我们现在应该看到有一个空的挡风玻璃类, 我们要做的是进入UI,

102
00:07:58,540 --> 00:08:05,800
‫我将复制丢失的屏幕来调用挡风玻璃, 如果你愿意, 你可以从头开始创建你的挡风玻璃｡

103
00:08:05,800 --> 00:08:11,980
‫但我会用类似的方法, 只是我会把颜色换成绿色.

104
00:08:12,650 --> 00:08:17,180
‫把它变成你赢而不是你输｡

105
00:08:18,030 --> 00:08:21,870
‫因为重启逻辑实际上是相同的｡

106
00:08:21,870 --> 00:08:23,400
‫不知道什么原因, 它把我的颜色重新设置了｡

107
00:08:23,400 --> 00:08:25,670
‫我将再次将颜色设置为绿色｡

108
00:08:25,680 --> 00:08:26,460
‫好吧, 那太好了｡

109
00:08:26,460 --> 00:08:31,740
‫但是我们在KML游戏模式中仍然有一堆伪代码没有被填充｡

110
00:08:31,740 --> 00:08:34,840
‫这是因为计算输赢是你的挑战｡

111
00:08:34,860 --> 00:08:36,480
‫填写伪代码｡

112
00:08:36,600 --> 00:08:40,680
‫使用T从该类别的下方进行划分, 以帮助您解决问题｡

113
00:08:40,710 --> 00:08:45,390
‫使用我们在控制器上创建的新的is dead函数并对其进行测试｡

114
00:08:45,420 --> 00:08:49,500
‫当你杀死世界上所有的人工智能时, 看看你的挡风玻璃是否会出现｡

115
00:08:49,500 --> 00:08:53,670
‫把它和伪代码放在屏幕上, 让你看一下｡

116
00:08:54,090 --> 00:08:55,020
‫K欢迎回来｡

117
00:08:55,020 --> 00:08:56,490
‫我们从for循环开始｡

118
00:08:56,610 --> 00:08:57,720
‫所以我们要做一个四｡

119
00:08:57,720 --> 00:08:59,100
‫我们要怎么循环？

120
00:08:59,100 --> 00:09:00,690
‫此时它不是控制器｡

121
00:09:00,690 --> 00:09:03,660
‫它将是射手AI控制器｡

122
00:09:03,660 --> 00:09:05,340
‫所以我们需要把它算进去｡

123
00:09:06,210 --> 00:09:09,570
‫一定会是凶手｡

124
00:09:10,360 --> 00:09:12,340
‫I控制器H｡

125
00:09:13,050 --> 00:09:19,620
‫这意味着我们要循环遍历一个射手A. 一､  控制器, 星星｡

126
00:09:20,190 --> 00:09:30,120
‫只需调用控制器来设置shorts, 然后我们再做一次t, actor, range, shooter, A.

127
00:09:30,120 --> 00:09:30,120
‫一､  控制器中｡

128
00:09:30,120 --> 00:09:34,140
‫我们需要让这两个类型匹配, 然后得到世界｡

129
00:09:34,230 --> 00:09:36,540
‫所以我们在这一关做｡

130
00:09:37,740 --> 00:09:42,480
‫这里是for循环的主体, 我们要问它是否还没死.

131
00:09:42,480 --> 00:09:48,120
‫所以如果没有, 控制器箭头就死了｡

132
00:09:49,720 --> 00:09:52,510
‫基本上我们是说确保我们没有死｡

133
00:09:52,600 --> 00:10:00,180
‫如果它还没死, 我们就继续回到这个早期的回归, 因为我们知道游戏还不能结束｡

134
00:10:00,190 --> 00:10:06,910
‫否则, 如果我们通过了循环的漏洞而没有返回, 我们就需要结束游戏,

135
00:10:06,910 --> 00:10:10,330
‫因为玩家必须有一个杀死了关卡中所有的AI｡

136
00:10:10,480 --> 00:10:13,180
‫所以在这种情况下我们可以做一个终结游戏｡

137
00:10:13,180 --> 00:10:13,900
‫是的｡

138
00:10:13,900 --> 00:10:15,310
‫因为玩家有一个｡

139
00:10:15,310 --> 00:10:20,440
‫这应该会通知所有的玩家控制器和周围的控制器｡

140
00:10:20,830 --> 00:10:21,430
‫好的, 谢谢

141
00:10:21,430 --> 00:10:24,040
‫让我们来编译一下｡

142
00:10:24,040 --> 00:10:27,850
‫首先, 我要去虚幻世界玩一玩｡

143
00:10:27,850 --> 00:10:33,940
‫由于某种原因, 我的编辑器认为我正在编辑指定的颜色操作, 所以我打算关闭它并重新启动它｡

144
00:10:33,940 --> 00:10:38,680
‫现在它重启了, 我要继续按播放键, 我会被杀的｡

145
00:10:38,680 --> 00:10:39,190
‫第一点｡

146
00:10:39,190 --> 00:10:40,450
‫是的, 我还是输了｡

147
00:10:40,450 --> 00:10:41,140
‫那太好了｡

148
00:10:41,140 --> 00:10:44,020
‫看看我能不能在他杀我之前杀了他｡

149
00:10:44,730 --> 00:10:45,270
‫我们走吧｡

150
00:10:45,270 --> 00:10:46,980
‫砰砰砰砰砰砰｡

151
00:10:47,250 --> 00:10:48,180
‫我输得太快了｡

152
00:10:48,180 --> 00:10:52,170
‫我们再去找把枪, 准备好｡

153
00:10:52,170 --> 00:10:56,490
‫为了测试目的, 我们把枪的伤害弄得很高｡

154
00:10:56,490 --> 00:11:00,720
‫这次我会把伤害降到20.

155
00:11:00,720 --> 00:11:03,240
‫所以它还是很快, 但没那么快｡

156
00:11:03,270 --> 00:11:06,420
‫去打他几下｡

157
00:11:06,420 --> 00:11:12,210
‫我们在那里看到的是, 实际上我赢了, 因为水平重新开始｡

158
00:11:12,210 --> 00:11:15,660
‫所以如果我再杀一次这个人, 你会发现什么都没发生｡

159
00:11:15,660 --> 00:11:19,860
‫它在消息日志中说创建它是用一个空类调用的｡

160
00:11:19,860 --> 00:11:27,360
‫原因是, 如果我们再看一下BP射击游戏机控制器, 你会发现我们还没有连接挡风玻璃｡

161
00:11:27,450 --> 00:11:31,350
‫有一件事我忘了做, 所以你可以去编译, 保存和播放｡

162
00:11:31,350 --> 00:11:37,980
‫现在如果我把这个家伙杀到新末日, 我就赢了, 我会在5秒内重新开始.

163
00:11:37,980 --> 00:11:40,950
‫我想告诉你们同样的道理｡

164
00:11:41,100 --> 00:11:46,290
‫如果我把更多的玩家控制器放在世界上, 它将需要我杀死他们两个｡

165
00:11:46,290 --> 00:11:50,160
‫所以让我们把射手角色带进来｡

166
00:11:50,610 --> 00:11:52,950
‫这将是我要杀的第二个敌人｡

167
00:11:52,950 --> 00:11:54,420
‫所以杀了这家伙, 嘣｡

168
00:11:54,750 --> 00:11:56,850
‫但它没有赢｡

169
00:11:56,850 --> 00:11:59,310
‫然后我去找第二个人, 砰｡

170
00:11:59,310 --> 00:12:09,420
‫现在我有了一个, 因为我已经杀死了所有的AI, 我们不需要改变任何变量, 因为我们的for循环计算了所有的A｡

171
00:12:09,420 --> 00:12:09,420
‫一､  每一次都是从零开始｡

172
00:12:09,420 --> 00:12:12,270
‫所以现在我们生活在一个相当安静的世界里｡

173
00:12:12,270 --> 00:12:18,330
‫所以在下一节课中, 我想开始看看我们如何做一些音频｡

174
00:12:18,360 --> 00:12:19,290
‫我会看到你在那里｡