1
00:00:04,360 --> 00:00:05,440
‫你好, 欢迎｡

2
00:00:05,440 --> 00:00:09,970
‫在这节课中, 我们将介绍这段代码,

3
00:00:09,970 --> 00:00:15,010
‫RT actor range, 看看它如何允许我们迭代给定级别中的所有actor｡

4
00:00:15,010 --> 00:00:16,810
‫让我们深入了解一下它是如何工作的｡

5
00:00:17,410 --> 00:00:24,760
‫因此, 在我们的杀死所有游戏模式的兵杀死的时刻, 我们称之为游戏已结束的球员控制器, 但实际上游戏已结束是一个功能上的所有控制器,

6
00:00:24,760 --> 00:00:31,750
‫其中有A.

7
00:00:31,750 --> 00:00:38,620
‫我或者玩家控制器, 我们应该通知人工智能控制器游戏已经结束了,

8
00:00:38,620 --> 00:00:46,240
‫这肯定会发生, 或者这也会让赢的条件变得更容易, 因为我们不一定会让玩家兵进来.

9
00:00:46,870 --> 00:00:50,140
‫那么我们该怎么做呢？

10
00:00:50,140 --> 00:00:57,160
‫我将在KML游戏模式下创建一个新函数, 一个私有函数, 叫做End Game,

11
00:00:57,160 --> 00:00:59,500
‫它将负责这个动作.

12
00:00:59,500 --> 00:01:02,710
‫所以结束游戏需要一些信息｡

13
00:01:02,710 --> 00:01:04,780
‫它需要知道谁赢了｡

14
00:01:04,780 --> 00:01:06,730
‫是球员还是A｡  I.什么？

15
00:01:06,760 --> 00:01:11,800
‫所以我要在这里创建一个布尔值, 叫做B is playerwinner.

16
00:01:12,160 --> 00:01:19,930
‫这将告诉我们是应该告诉人工智能它赢了还是告诉玩家它赢了｡

17
00:01:19,930 --> 00:01:22,660
‫因为记住在这里我们的游戏已经结束了｡

18
00:01:22,660 --> 00:01:26,740
‫采用布尔值, 告诉控制器它是否是获胜者之一｡

19
00:01:27,490 --> 00:01:31,960
‫因此, 我们要做的是弄清楚, 首先, 让我们继续创建实现｡

20
00:01:31,960 --> 00:01:35,380
‫我将执行控制移位P, 然后创建实现｡

21
00:01:35,950 --> 00:01:45,580
‫然后我们要找出如何找到场景中的所有控制器, 这样我们就可以在这些控制器上调用游戏结束｡

22
00:01:46,390 --> 00:01:51,880
‫现在我们要做的是使用引擎助手调用｡

23
00:01:51,880 --> 00:01:57,570
‫如果我们使用hash include, 我们首先要使用引擎实用程序｡

24
00:01:57,570 --> 00:02:08,260
‫这将把我想要的辅助对象带入到作用域中, 这个辅助对象叫做T参与者范围, T参与者范围是一个模板｡

25
00:02:08,260 --> 00:02:11,500
‫所以我们可以在这里用尖括号｡

26
00:02:11,590 --> 00:02:18,760
‫我们可以放一个控制器, 然后放括号, 得到world.

27
00:02:18,760 --> 00:02:20,050
‫这有什么用？

28
00:02:20,080 --> 00:02:28,840
‫它会返回一个range对象, 基本上类似于一个列表, 包含所有的控制器.

29
00:02:28,840 --> 00:02:37,240
‫这就是为什么我们在世界a中有控制器参数｡  k､  我们可以在for循环中使用它｡

30
00:02:37,240 --> 00:02:39,610
‫让我开始用for循环来包装它｡

31
00:02:39,610 --> 00:02:44,200
‫所以我们要对A控制器执行｡

32
00:02:44,200 --> 00:02:51,190
‫所以我们要处理的变量是一个A控制器指针, 我称之为控制器.

33
00:02:52,180 --> 00:02:56,140
‫然后我们用冒号来表示我们要覆盖的范围｡

34
00:02:56,140 --> 00:02:58,240
‫它将是这个T活动范围｡

35
00:02:58,450 --> 00:03:03,160
‫然后我们可以用右括号和花括号｡

36
00:03:03,160 --> 00:03:04,900
‫这句话是什么意思

37
00:03:04,900 --> 00:03:14,380
‫我们将对世界上的每个控制器执行四个循环, 它将位于称为控制器的变量中｡

38
00:03:15,120 --> 00:03:17,700
‫现在有几件事你可能需要知道｡

39
00:03:17,700 --> 00:03:22,530
‫因此, 我们可以查询控制器是否为玩家控件, 而无需强制转换｡

40
00:03:22,530 --> 00:03:28,620
‫实际上, 我们可以只画控制器箭头, 然后我想我需要在这里包括我的控制器｡

41
00:03:28,620 --> 00:03:38,400
‫哈希包含在顶部, 我们要做一个游戏框架, 正斜杠控制器H, 现在自动完成可能会工作｡

42
00:03:38,400 --> 00:03:39,030
‫是的, 的确如此｡

43
00:03:39,030 --> 00:03:41,790
‫所以我们能做的就是我们可以称之为游戏结束｡

44
00:03:41,790 --> 00:03:46,530
‫这是我在这里的第一个自动补全程序, 也可以说是玩家控制器｡

45
00:03:46,530 --> 00:03:52,140
‫基本上它会说, 在玩家控制器的世界里,

46
00:03:52,140 --> 00:03:58,410
‫它会让我们决定, 是否应该在游戏结束时, 输入真或假｡

47
00:03:58,410 --> 00:04:05,880
‫所以我的挑战是用正确的布尔参数来填充这个for循环｡

48
00:04:06,240 --> 00:04:12,570
‫所以我们要这样做,

49
00:04:12,570 --> 00:04:23,700
‫基本上它应该是真的, 如果我们正在和for循环中的控制器对话的控制器是一个播放器控制器, 并且我们传递的布尔值说播放器控制器是赢家也应该是真的｡

50
00:04:23,700 --> 00:04:31,290
‫如果不是玩家控制器, 也不是玩家, 玩家就是赢家, 基本上就是说, 如果这是一个盟友, I是赢家,

51
00:04:31,290 --> 00:04:38,190
‫如果玩家控制器, 但玩家不是赢家, 则为假, 如果不是玩家控制器, 但玩家是赢家,

52
00:04:38,190 --> 00:04:40,890
‫则为假｡

53
00:04:40,890 --> 00:04:43,530
‫希望你能明白事情的发展｡

54
00:04:43,530 --> 00:04:46,680
‫所以暂停视频, 试着像这样实现它｡

55
00:04:46,680 --> 00:04:47,940
‫您可以使用if陈述式｡

56
00:04:47,940 --> 00:04:53,820
‫您可能会使用一些其他逻辑来计算这个布尔暂停视频并尝试一下｡

57
00:04:54,930 --> 00:04:55,380
‫好吧, 我会的

58
00:04:55,380 --> 00:04:55,950
‫欢迎回来｡

59
00:04:55,950 --> 00:04:57,930
‫所以你可以用很多方法来做｡

60
00:04:57,930 --> 00:05:14,430
‫一种方法是如果蜜蜂是参与者, 控制一个赢家然后我们在if语句中输入一些东西我们可以在这里做一个布尔运算来决定B基本上是参与者控制者.

61
00:05:15,210 --> 00:05:18,990
‫我们要做一个控制器来保存它｡

62
00:05:19,840 --> 00:05:23,740
‫箭头是这样的球员控制器｡

63
00:05:24,130 --> 00:05:28,310
‫然后我们可能会说, 好吧, 我们要调用控制器｡

64
00:05:28,330 --> 00:05:31,060
‫Arrow游戏已结束｡

65
00:05:31,210 --> 00:05:33,280
‫我们现在要传入null指针｡

66
00:05:33,280 --> 00:05:40,690
‫然后我们会说, 如果赢家是参与者而我们是参与者的控制者, 那么是的,

67
00:05:40,690 --> 00:05:43,300
‫基本上就是这个值.

68
00:05:43,300 --> 00:05:44,980
‫所以玩一个控制器｡

69
00:05:45,010 --> 00:05:48,100
‫否则, 如果不是玩家控制器, 它就会失败｡

70
00:05:48,100 --> 00:05:55,360
‫我们可以否定这个, 所以我们可以说, 这里我们要做的是,

71
00:05:55,360 --> 00:06:04,900
‫控制器博弈已经结束了, 不是玩家控制器, 因为我们说玩家不是赢家, 在这个陈述中眼睛是赢家｡

72
00:06:04,900 --> 00:06:14,380
‫所以我们想说的是, 这取决于是否基本上与参与者赢了相反, 也就是说眼睛赢了.

73
00:06:14,680 --> 00:06:17,370
‫所以这是一种肯定的方法｡

74
00:06:17,380 --> 00:06:22,990
‫但还有另一种更简单的方式, 那就是简单地说, 我们是赢家吗？

75
00:06:22,990 --> 00:06:26,020
‫所以是赢家｡

76
00:06:26,530 --> 00:06:36,790
‫而这可以简单地说, 你是否是玩家控制者就等于是玩家赢家｡

77
00:06:36,970 --> 00:06:43,000
‫现在让我们再仔细思考一下, 我会完整地完成这个, 然后我们再讨论它｡

78
00:06:43,000 --> 00:06:53,050
‫所以我们会说控制器博弈结束了, 是空指针, 这里传递的是赢家.

79
00:06:53,950 --> 00:06:56,630
‫现在, 为什么这个说法有效呢？

80
00:06:56,650 --> 00:06:58,630
‫好吧, 让我们想想那些案子, 好吗？

81
00:06:58,630 --> 00:07:04,300
‫所以我们有一个玩家控制器在这里, 玩家是赢家, 然后呢？

82
00:07:04,300 --> 00:07:06,730
‫是的, 我们是赢家, 他们是平等的｡

83
00:07:06,730 --> 00:07:07,720
‫千真万确｡

84
00:07:08,290 --> 00:07:13,660
‫如果这不是玩家的控制器, 玩家也不是赢家呢？

85
00:07:13,690 --> 00:07:15,370
‫好吧, 那么这是假的｡

86
00:07:15,370 --> 00:07:21,570
‫这里的这个也是假的所以两个相等结果是赢家.

87
00:07:21,580 --> 00:07:22,100
‫这是真的吗？

88
00:07:22,120 --> 00:07:27,370
‫是的, 因为如果我们是人工智能, 而人工智能是赢家, 那么我们应该是赢家｡

89
00:07:27,880 --> 00:07:33,370
‫否则, 如果这两个不相等, 我｡  e.计算

90
00:07:33,370 --> 00:07:40,960
‫我们有一个人工智能控制器, 但玩家是赢家, 或者我们有一个玩家控制器, 人工智能是赢家, 那么我们将有一个真和假或假和真｡

91
00:07:41,170 --> 00:07:45,280
‫这两个值不相等布尔值的结果是false.

92
00:07:45,280 --> 00:07:51,730
‫所以你们可以看到, 在每一个例子中, 我已经看过了所有的例子, 最后都得到了正确的答案

93
00:07:51,730 --> 00:07:53,740
‫所以我们知道这是正确的答案｡

94
00:07:53,740 --> 00:07:58,390
‫这就是布尔型的好处通常你可以评估所有的情况, 因为你可以说, 好吧, 好吧,

95
00:07:58,390 --> 00:08:00,400
‫有什么情况？

96
00:08:00,400 --> 00:08:01,870
‫这将是真实的和真实的｡

97
00:08:01,870 --> 00:08:02,980
‫这将是真的和假的｡

98
00:08:02,980 --> 00:08:03,970
‫这将是假的和真的｡

99
00:08:03,970 --> 00:08:05,280
‫这将是虚假的和虚假的｡

100
00:08:05,290 --> 00:08:06,940
‫你可以评估所有这些案例｡

101
00:08:06,940 --> 00:08:12,610
‫如果所有这些情况都是正确的, 那么你就知道你得到了一个正确的布尔语句｡

102
00:08:13,090 --> 00:08:13,600
‫好的, 谢谢

103
00:08:13,600 --> 00:08:15,880
‫这就是我们计算B是赢家的方法｡

104
00:08:15,880 --> 00:08:18,460
‫最后, 我们只需要调用我们的结束游戏模式｡

105
00:08:18,460 --> 00:08:36,630
‫现在我们直接调用了play控制器博弈已经结束了我现在要做的是调用end game我们要传递false因为这是一个博弈者输了的情况这也是我们想要达到的结果.

106
00:08:36,640 --> 00:08:42,340
‫还有一点要注意的是我们传递的这个空指针会给我们带来问题,

107
00:08:42,400 --> 00:08:52,900
‫因为如果玩家真的赢了, 它会试图把焦点从我们的棋子上移开.

108
00:08:52,900 --> 00:09:01,270
‫我们在这里要传递的只是焦点应该放在控制器上, 点得到兵｡

109
00:09:01,660 --> 00:09:10,630
‫这基本上就是说, 你应该把你自己的球员控制器的重点, 是基本上你的相机应该指向哪里？

110
00:09:10,630 --> 00:09:12,550
‫它应该仍然指向你的兵｡

111
00:09:12,970 --> 00:09:17,170
‫为什么我们这样做是重要的, 为什么在这里有这个选择摆在首位？

112
00:09:17,170 --> 00:09:23,890
‫在很多游戏中, 你经常会遇到, 或者很多比赛型的游戏, 你可能会遇到,

113
00:09:23,890 --> 00:09:27,400
‫如果游戏结束了, 你想去跟随棋子｡

114
00:09:27,400 --> 00:09:28,300
‫这是赢家｡

115
00:09:28,300 --> 00:09:34,300
‫所以想象一下像一个Fortnite的场景, 你经常去跟踪杀你的人｡

116
00:09:34,330 --> 00:09:36,430
‫这是实现此目的的机制｡

117
00:09:36,430 --> 00:09:40,470
‫你基本上是把杀人者的棋子交给了他｡

118
00:09:40,480 --> 00:09:41,800
‫我们的游戏里可不是这么玩的｡

119
00:09:41,800 --> 00:09:45,460
‫我们将继续关注苹果, 看看我们是赢还是死｡

120
00:09:45,460 --> 00:09:46,990
‫这节课就讲到这里｡

121
00:09:46,990 --> 00:09:50,110
‫让我们编译一下, 看看它是否工作｡

122
00:09:50,110 --> 00:09:53,440
‫让我们跳到虚幻中去, 然后点击播放｡

123
00:09:53,470 --> 00:09:56,110
‫我们去送死吧｡

124
00:09:56,110 --> 00:09:56,980
‫你去那里｡

125
00:09:56,980 --> 00:09:58,750
‫一切都和以前一样

126
00:09:58,750 --> 00:10:03,220
‫我们仍然会调用播放器控制器, 然后重新启动｡

127
00:10:03,220 --> 00:10:03,790
‫好东西｡

128
00:10:03,790 --> 00:10:06,460
‫在这堂课中, 我们回顾一下, 我们看到了什么？

129
00:10:06,460 --> 00:10:16,930
‫我们已经看到了如何在这一层的参与者之间进行迭代, 以便在每个参与者上调用一个函数｡

130
00:10:16,930 --> 00:10:23,680
‫下节课我们将再次使用T系数范围, 这次是计算玩家是否获胜｡

131
00:10:23,680 --> 00:10:24,400
‫到时候见｡