1
00:00:04,290 --> 00:00:05,650
‫欢迎回来

2
00:00:05,670 --> 00:00:09,900
‫在本视频中, 我们关注的是输赢条件｡

3
00:00:10,320 --> 00:00:14,520
‫这是我们在这个游戏项目中要处理的最后一件事情之一｡

4
00:00:14,550 --> 00:00:16,860
‫现在让我们来看看我们的剖面图｡

5
00:00:16,860 --> 00:00:26,580
‫现在, 我们已经检查了我们的章节计划的前五项, 最后两项是特效和输赢条件｡

6
00:00:26,580 --> 00:00:32,250
‫我想把最后两个转换一下, 处理输赢的情况,

7
00:00:32,250 --> 00:00:39,300
‫因为这是我们游戏编程逻辑的最后一个, 特效是装饰性的, 更像是最后的润色,

8
00:00:39,300 --> 00:00:42,420
‫所以我们可以在最后处理这些｡

9
00:00:42,420 --> 00:00:49,950
‫所以在这个视频中我们将创建一个函数博弈, 这样我们就可以知道博弈的输赢了.

10
00:00:49,950 --> 00:00:55,410
‫为了赢得游戏, 我们需要数一数世界上的塔的数量, 因为一旦我们摧毁了所有的塔,

11
00:00:55,410 --> 00:00:59,730
‫我们就知道我们赢得了游戏｡

12
00:00:59,730 --> 00:01:05,670
‫如果坦克本身被摧毁了, 我们就可以认为这是损失.

13
00:01:05,670 --> 00:01:12,540
‫现在我回到游戏模式, 首先要创建另一个蓝图可实现事件｡

14
00:01:12,570 --> 00:01:20,520
‫我们有这个start game函数, 我们可以从C++调用它, 但是我们在游戏模式下实现它的逻辑.

15
00:01:20,520 --> 00:01:27,720
‫蓝图由于蓝图可实现的事件, 我想创建另一个这些输掉比赛之一.

16
00:01:27,720 --> 00:01:31,530
‫我将创建一个void函数, 称为Game Over｡

17
00:01:31,530 --> 00:01:37,530
‫对于这个, 我想取一个布尔输入参数, 叫做one game.

18
00:01:37,530 --> 00:01:43,020
‫当然,

19
00:01:43,020 --> 00:01:50,130
‫这是一个蓝图可实现的事件, 因为我想用这个函数处理的唯一事情是显示我们输了还是赢了, 我们可以从蓝图中做什么｡

20
00:01:50,130 --> 00:01:52,410
‫所以我们有一个博弈函数｡

21
00:01:52,410 --> 00:01:55,350
‫现在我们需要知道什么时候应该调用这个函数｡

22
00:01:55,350 --> 00:02:02,550
‫首先, 我们知道当我们输了比赛的时候可以调用这个函数, 如果坦克死了.

23
00:02:02,550 --> 00:02:10,050
‫我们来看看tune tank游戏模式下的actor died函数, 我们看到如果死的actor是tank,

24
00:02:10,050 --> 00:02:16,680
‫那么我们处理tank的销毁, 我们把使能状态设为false.

25
00:02:16,710 --> 00:02:27,240
‫另一个我们可以做的是, 简单地调用game结束这个布尔值是一个我们可以传递false的博弈.

26
00:02:27,240 --> 00:02:31,770
‫因此, 这就解决了输掉比赛的问题, 至少从C++方面来说是这样｡

27
00:02:31,800 --> 00:02:34,770
‫现在我们需要知道什么时候我们应该赢得比赛｡

28
00:02:34,800 --> 00:02:36,540
‫这里有个演员死了｡

29
00:02:36,540 --> 00:02:43,050
‫如果死去的演员可以被投到一座塔上, 我们就知道我们刚刚摧毁了一座塔｡

30
00:02:43,050 --> 00:02:49,740
‫现在, 这将是一个完美的地方来更新塔计数或整数类型的变量,

31
00:02:49,740 --> 00:02:53,220
‫以跟踪世界上目前有多少塔｡

32
00:02:53,250 --> 00:02:53,580
‫现在就去

33
00:02:53,580 --> 00:02:59,310
‫为此, 我们需要一个变量来跟踪塔的数量,

34
00:02:59,310 --> 00:03:02,250
‫这样我们就可以在H文件中添加一个私有变量｡

35
00:03:02,250 --> 00:03:03,960
‫我想在这里做｡

36
00:03:03,960 --> 00:03:08,880
‫我将创建一个INT 32, 并将其命名为目标塔｡

37
00:03:09,120 --> 00:03:17,760
‫现在, 我们可以立即将其初始化为零, 但我们需要随着塔的数量减少而更新｡

38
00:03:17,760 --> 00:03:22,350
‫我们还需要把它设置为世界上有多少座塔｡

39
00:03:22,470 --> 00:03:28,170
‫现在我们可以将其硬编码为4, 但是当我们开始在关卡中添加更多的塔时会发生什么呢？

40
00:03:28,170 --> 00:03:30,690
‫那就有点复杂了｡

41
00:03:30,690 --> 00:03:35,580
‫所以我想做的是看看世界上有多少座塔｡

42
00:03:35,610 --> 00:03:45,810
‫现在我可以创建一个函数返回32这个函数可以找出世界上有多少个塔并返回数字.

43
00:03:45,810 --> 00:03:51,450
‫我要调用这个函数, 得到目标塔数｡

44
00:03:51,600 --> 00:03:55,650
‫因此, 让我们继续, 并在CP文件中为该函数提供一个主体｡

45
00:03:55,680 --> 00:04:05,040
‫我会一直走到底部, 创建函数体, 我不能忘记把类名放在函数名之前.

46
00:04:05,040 --> 00:04:13,170
‫这将返回一个结束值32, 我们需要决定如何找出有多少个塔.

47
00:04:13,200 --> 00:04:19,800
‫现在有一个函数, 存在于游戏静态称为获取类的所有演员｡

48
00:04:19,800 --> 00:04:21,300
‫这是文件｡

49
00:04:21,300 --> 00:04:25,770
‫它表示在指定类的世界中查找所有参与者｡

50
00:04:25,770 --> 00:04:28,890
‫所以我们需要指定一个特定的类｡

51
00:04:28,920 --> 00:04:31,530
‫现在, 此函数有三个输入｡

52
00:04:31,530 --> 00:04:33,720
‫首先是世界上下文对象｡

53
00:04:33,720 --> 00:04:34,770
‫这个很简单

54
00:04:34,770 --> 00:04:36,180
‫我们知道该怎么处理｡

55
00:04:36,180 --> 00:04:41,610
‫但是接下来我们有一个演员的PT子类, 叫做演员类.

56
00:04:41,610 --> 00:04:49,740
‫现在我们已经看到, 需要PT子类的函数可以接受u类作为输入, 第三个参数是T数组｡

57
00:04:49,770 --> 00:04:56,940
‫它需要一个演员指针的数组, 这是作为引用传入的, 而不是常量引用,

58
00:04:56,940 --> 00:05:03,680
‫这似乎表明这个函数可能会改变这个被称为act的输入参数｡

59
00:05:03,730 --> 00:05:08,530
‫这是另一个暗示, 这是事实, 是它的所谓演员｡

60
00:05:08,530 --> 00:05:18,220
‫这是一个out参数, 也就是说我们把它传入, 然后在函数被调用后, 它就有了函数放进去的值.

61
00:05:18,220 --> 00:05:21,340
‫所以我们可以把它看作函数的输出｡

62
00:05:21,340 --> 00:05:30,640
‫现在它在这里声明了参数, actor类是要查找的actor的类, 必须指定, 否则结果数组将为空｡

63
00:05:30,640 --> 00:05:37,240
‫我们要找到所有的塔和出演员是一个输出数组的演员的指定类｡

64
00:05:37,240 --> 00:05:42,670
‫所以一旦我们调用了这个函数,

65
00:05:42,670 --> 00:05:48,160
‫并传入了一个数组, 当函数结束时, 这个数组将包含指向指定类中所有参与者的指针.

66
00:05:48,160 --> 00:05:51,880
‫我们知道这个函数需要一个世界上下文对象｡

67
00:05:51,880 --> 00:05:56,500
‫现在, 如果我们要在游戏模式中调用它, 接下来我们可以传入它.

68
00:05:56,500 --> 00:06:03,490
‫我们需要指定A参与者的PT子类, 我们知道这可以是一个新的类指针｡

69
00:06:03,490 --> 00:06:06,070
‫现在我们需要指定要查找的类｡

70
00:06:06,070 --> 00:06:12,010
‫如果我们指定了一个演员, 那么我们将得到一个大数组, 其中充满了指向世界上每个演员的指针｡

71
00:06:12,010 --> 00:06:13,810
‫但我们不需要所有的演员｡

72
00:06:13,810 --> 00:06:23,290
‫我们只需要塔, 这样我们就可以使用塔静态类, 它将返回一个新的类, 代表A塔C++类｡

73
00:06:23,290 --> 00:06:26,770
‫现在第三个参数是演员指针的T数组｡

74
00:06:26,770 --> 00:06:35,980
‫所以如果我们创建一个T型数组的局部变量, 在尖括号中指定一个参与者指针, 那么我们可以称之为游戏静态｡

75
00:06:36,010 --> 00:06:45,970
‫让类的所有参与者传入这三个输入, 这个操作的结果将是我们的塔数组应该包含指向我们世界中所有塔的指针｡

76
00:06:45,970 --> 00:06:53,830
‫现在, tray是一个很好的容器类, 它可以包含许多元素, 只要它们都共享相同的类型｡

77
00:06:53,830 --> 00:07:01,690
‫而且这个类有相当多的函数, 我们在托盘中存放物品时可以使用｡

78
00:07:01,720 --> 00:07:08,710
‫现在我会一直向下滚动给你们看这个函数, 叫做Num, Short, four, number,

79
00:07:08,830 --> 00:07:12,310
‫它说的是返回数组中元素的个数.

80
00:07:12,310 --> 00:07:20,380
‫所以我们可以用这个函数来得到数组中元素的个数一旦我们有了世界上所有的塔.

81
00:07:20,380 --> 00:07:26,080
‫所以如果我们调用Tower的num, 那么我们可以把它作为函数的返回值.

82
00:07:26,080 --> 00:07:31,930
‫正如我们所看到的, 我们把这个函数的返回值设置为n 32,

83
00:07:31,930 --> 00:07:35,980
‫我们可以返回塔数组中的元素数｡

84
00:07:35,980 --> 00:07:41,230
‫所以我想挑战你实现这个获取目标塔计数功能｡

85
00:07:41,230 --> 00:07:44,710
‫因此, 创建一个A类型actor的局部t数组｡

86
00:07:44,710 --> 00:07:47,110
‫你可以叫它塔或者任何你喜欢的名字｡

87
00:07:47,110 --> 00:07:54,220
‫现在使用你的游戏, 播放静态函数, 获取类的所有参与者, 并确保传入正确的输入参数｡

88
00:07:54,220 --> 00:08:00,310
‫调用这个函数后,

89
00:08:00,310 --> 00:08:07,930
‫你的tray将包含指向世界上所有塔的指针, 所以你可以使用num函数返回塔的数量, 这个函数属于tray类.

90
00:08:07,930 --> 00:08:10,660
‫因此, 请暂停视频并实施｡

91
00:08:10,660 --> 00:08:12,640
‫立即获取目标塔数｡

92
00:08:15,670 --> 00:08:16,000
‫好吧, 我会的

93
00:08:16,000 --> 00:08:17,980
‫这里是目标塔计数｡

94
00:08:18,010 --> 00:08:26,590
‫现在, 我要做的第一件事是创建一个本地t数组, 指定一个actor指针作为该数组应存储的元素类型｡

95
00:08:26,590 --> 00:08:33,100
‫我把这个叫做塔, 现在我需要把它叫做游戏静态, 所以我需要确保这个标题包括在内｡

96
00:08:33,130 --> 00:08:39,340
‫现在我明白了, 因为我们在其他一些函数中使用了它, 但进行检查是很好的｡

97
00:08:39,370 --> 00:08:47,380
‫接下来, 我可以用你的游戏静态, 我要调用得到类的所有演员.

98
00:08:47,410 --> 00:08:55,990
‫现在第一个输入是一个世界上下文对象, 我将传入这个, 接下来是表示actor类的子类｡

99
00:08:55,990 --> 00:09:04,270
‫我提到过我们可以使用一个塔静态类, 它将返回一个U类, 代表塔类｡

100
00:09:04,300 --> 00:09:09,190
‫现在再强调一次, 确保我们包括了塔, 这是一个好主意｡

101
00:09:09,220 --> 00:09:14,740
‫现在, 第三个也是最后一个参数是塔盘, 我们可以传递塔｡

102
00:09:14,740 --> 00:09:21,880
‫因此, 一旦调用了这个函数, 塔将包含指向世界上所有塔的指针｡

103
00:09:21,880 --> 00:09:28,000
‫事实上, 如果存在从塔衍生的类的任何对象, 我们也会得到那些对象｡

104
00:09:28,000 --> 00:09:33,780
‫因为我们有一个towers数组, 我们可以简单地返回数组中元素的个数.

105
00:09:33,790 --> 00:09:40,660
‫我将使用return语句和towers. num, 现在我们有一个get target towers count｡

106
00:09:40,660 --> 00:09:41,740
‫所以这是伟大的｡

107
00:09:41,740 --> 00:09:49,090
‫我们可以用它来初始化我们的塔计数, 我们称之为目标塔, 我们可以在开始游戏时这样做｡

108
00:09:49,090 --> 00:09:51,780
‫所以我把它放在这里处理游戏开始｡

109
00:09:51,790 --> 00:09:54,400
‫事实上, 我希望这是我们做的第一件事｡

110
00:09:54,400 --> 00:10:02,530
‫所以我将取target塔并将其设置为get target塔计数的返回值｡

111
00:10:02,560 --> 00:10:07,240
‫现在, 目标塔应该初始化为我们世界中的塔数｡

112
00:10:07,240 --> 00:10:16,000
‫这很好, 但是我们需要在每一次塔死亡时更新这个计数, 这意味着我们需要进入演员死亡函数｡

113
00:10:16,000 --> 00:10:22,660
‫在这里, 如果我们把死亡的演员投到一个被摧毁的塔上,

114
00:10:22,660 --> 00:10:30,430
‫那么在我们处理完摧毁之后, 我们应该更新我们的目标塔变量, 这样我们就可以说目标塔, 我们就可以使用递减操作符｡

115
00:10:30,430 --> 00:10:35,560
‫我们既可以使用后置递减运算符, 也可以使用困境运算符｡

116
00:10:35,560 --> 00:10:41,800
‫这两个都将导致相同的行动, 这是采取目标塔, 并减去一｡

117
00:10:41,800 --> 00:10:49,660
‫现在, 我们从目标塔中减去1后, 现在我们需要检查目标塔是否已经达到0｡

118
00:10:49,660 --> 00:10:55,150
‫所以我在这里做一个if检查看看塔塔是否达到了0.

119
00:10:55,780 --> 00:11:02,380
‫现在, 一旦它出现了, 我们就知道游戏应该结束了,

120
00:11:02,710 --> 00:11:10,660
‫所以我们可以调用这个函数, 在真正的4b1游戏中传递, 因为我们已经摧毁了所有的塔, 我们可以认为这是一场胜利｡

121
00:11:10,660 --> 00:11:13,180
‫现在, 让我们继续编译代码｡

122
00:11:13,180 --> 00:11:19,420
‫现在, 回到编辑器中, 在我们结束视频之前, 我想做的是进入游戏模式蓝图｡

123
00:11:19,420 --> 00:11:21,040
‫这是哔哔声｡

124
00:11:21,040 --> 00:11:24,400
‫感谢游戏模式, 我们有这个事件开始游戏.

125
00:11:24,400 --> 00:11:31,780
‫我们要做的是创建开始游戏小部件, 将其添加到视口中, 这样我们就可以看到开始游戏倒计时器｡

126
00:11:31,780 --> 00:11:39,820
‫所以我们知道start game被调用了, 但是我们还需要在蓝图可实现事件上实现我们游戏

127
00:11:39,820 --> 00:11:47,260
‫我将右键单击并输入game over, 这是我们的事件, game over, 看看这个.

128
00:11:47,290 --> 00:11:50,860
‫注意我们有一个博弈它是布尔型的.

129
00:11:50,860 --> 00:11:57,220
‫所以当我们从C++调用这个函数时, 我们传递了一个布尔值给B一个游戏｡

130
00:11:57,220 --> 00:12:05,440
‫蓝图事件节点去掉了小写字母B, 并在1和game之间放置了一个空格, 作为对我们的一种礼貌｡

131
00:12:05,440 --> 00:12:11,650
‫现在, 我们将创建一些小部件, 以便我们可以看到我们何时赢得或输掉了比赛, 但我们将在以后的视频中这样做｡

132
00:12:11,650 --> 00:12:17,770
‫现在, 我只想确认它是否被正确地调用, 这样我就可以用一个打印字符串节点来做这件事,

133
00:12:17,770 --> 00:12:22,180
‫我们就可以基于这个布尔值来打印这个值｡

134
00:12:22,180 --> 00:12:30,280
‫如果我点击并拖动这个布尔值直接到字符串输入中, 我们会看到有一个布尔值到字符串的转换｡

135
00:12:30,280 --> 00:12:37,420
‫这是另一个方便的转换节点, 它可以将布尔值转换为字符串,

136
00:12:37,420 --> 00:12:44,350
‫它的功能是根据布尔值的真值转换为单词true或false｡

137
00:12:44,710 --> 00:12:46,120
‫那我们为什么不测试一下呢

138
00:12:46,120 --> 00:12:48,040
‫我将编译并点击播放｡

139
00:12:49,400 --> 00:12:52,570
‫好了, 现在我准备好赢得比赛了｡

140
00:12:52,580 --> 00:12:55,340
‫希望在我能这么做之前我不会输｡

141
00:12:55,430 --> 00:13:01,430
‫我输了, 你可以在屏幕左上方看到一个错误｡

142
00:13:01,430 --> 00:13:12,050
‫我们现在知道了输了博弈会导致事件博弈中的调用, 而传入的是false, 我们需要确保赢了博弈时传入的是true.

143
00:13:12,050 --> 00:13:14,900
‫所以让我们试着干掉所有的炮塔｡

144
00:13:15,380 --> 00:13:18,020
‫所以我真的要尽量不被击中｡

145
00:13:18,020 --> 00:13:19,250
‫我已经被击中了｡

146
00:13:19,910 --> 00:13:21,560
‫这很有挑战性｡

147
00:13:22,840 --> 00:13:24,820
‫好了

148
00:13:24,820 --> 00:13:28,720
‫而true则打印在屏幕的左上方｡

149
00:13:28,750 --> 00:13:31,600
‫它只显示几秒钟, 所以你可能错过了｡

150
00:13:31,630 --> 00:13:32,350
‫好吧, 太好了｡

151
00:13:32,350 --> 00:13:35,050
‫所以现在我们有了输赢的条件｡

152
00:13:35,080 --> 00:13:42,850
‫下一步是在屏幕上以小部件的形式实际显示它, 这样我们就不依赖于print string节点｡

153
00:13:42,880 --> 00:13:48,010
‫总而言之,

154
00:13:48,010 --> 00:13:53,890
‫我们现在有了输赢条件, 我们只需要做一些事情来完善它, 比如创建小部件来通知玩家他们已经赢了或输了比赛｡

155
00:13:53,890 --> 00:13:58,900
‫我们还使用托盘和游戏静态功能计算了塔的数量｡

156
00:13:58,930 --> 00:14:00,600
‫获取所有演员的类｡

157
00:14:00,610 --> 00:14:01,270
‫干得漂亮

158
00:14:01,270 --> 00:14:03,370
‫这场比赛真的很精彩沿着

159
00:14:03,370 --> 00:14:10,840
‫在下一个视频中, 我们将创建这些小部件, 然后我们准备开始添加特殊效果和抛光我们的游戏｡

160
00:14:10,870 --> 00:14:12,520
‫下一个视频里见｡