1
00:00:04,090 --> 00:00:09,970
‫所以如果我靠近我们的塔, 我可以看到他们正在绘制调试球体, 证明他们正在调用fire函数,

2
00:00:09,970 --> 00:00:13,780
‫而且他们每2秒就这样做一次｡

3
00:00:14,010 --> 00:00:17,290
‫除此之外, 他们只调用这个函数｡

4
00:00:17,290 --> 00:00:22,330
‫如果我在射程内, 如果我回到这里, 你会注意到他们没有画调试球｡

5
00:00:22,330 --> 00:00:25,660
‫因此, 这也涉及到距离检查｡

6
00:00:25,660 --> 00:00:30,430
‫一旦我足够接近, 他们就开始画那些调试球体｡

7
00:00:30,460 --> 00:00:32,130
‫你好, 欢迎回来｡

8
00:00:32,140 --> 00:00:40,270
‫现在我们已经创建了一个fire函数, 我们在tank类中使用它, 因为我们已经把它绑定到了fire动作映射.

9
00:00:40,270 --> 00:00:43,960
‫但我们也想在塔类中重用它｡

10
00:00:43,960 --> 00:00:48,820
‫现在, 我们将使用计时器, 而不是使用塔式类的用户输入｡

11
00:00:48,820 --> 00:00:54,370
‫我们将为塔类创建一个计时器, 以便计时器可以调用fire函数｡

12
00:00:54,370 --> 00:01:00,400
‫每隔一段时间, 我们会在调用fire函数之间设置一个指定的秒数｡

13
00:01:00,400 --> 00:01:07,450
‫既然我们希望在塔类中经常调用fire函数, 那么现在我们需要讨论计时器｡

14
00:01:07,450 --> 00:01:13,240
‫Unreal Engine可以使用一个名为F Timer Manager的类来设置计时器｡

15
00:01:13,270 --> 00:01:18,670
‫存在管理世界中的定时器的世界定时器管理器｡

16
00:01:18,700 --> 00:01:26,950
‫现在这个世界定时器管理器有一个名为Set Timer的函数, set Timer需要一些输入,

17
00:01:26,950 --> 00:01:29,050
‫比如一个定时器句柄｡

18
00:01:29,080 --> 00:01:34,000
‫这是由计时器管理器管理的特定计时器的句柄｡

19
00:01:34,000 --> 00:01:44,410
‫这允许管理器拥有多个计时器, 我们可以通过使用计时器句柄作为该计时器的名称或ID来访问每个计时器的计时器信息｡

20
00:01:44,530 --> 00:01:47,680
‫这是一个类型为F的对象计时器句柄｡

21
00:01:47,680 --> 00:01:52,870
‫因此, 我们创建一个计时器句柄, 并将其传递给set timer函数｡

22
00:01:52,900 --> 00:02:01,630
‫现在, 设置计时器还需要其他输入, 如速率或在实际执行某项操作之前应等待的时间量｡

23
00:02:01,630 --> 00:02:05,380
‫这就是回调函数中的内容｡

24
00:02:05,380 --> 00:02:12,130
‫我们创建了一个函数, 并将该函数绑定到计时器, 以便一旦经过足够的时间,

25
00:02:12,130 --> 00:02:16,690
‫特别是计时器速率, 就可以调用回调函数｡

26
00:02:16,690 --> 00:02:23,140
‫我们已经看到了计时器需要一些东西, 我们将把这些东西放在塔类中｡

27
00:02:23,140 --> 00:02:30,040
‫让我们进入H塔, 在H塔文件中, 我们将添加一些私有变量｡

28
00:02:30,040 --> 00:02:33,940
‫在射程范围内, 我们需要一个计时器手柄｡

29
00:02:33,940 --> 00:02:40,840
‫这是一个F计时器句柄, 我们可以简单地调用这个触发速率计时器句柄｡

30
00:02:40,870 --> 00:02:44,590
‫我们还需要一个射速, 这将是一个浮动｡

31
00:02:44,590 --> 00:02:50,320
‫我们称之为射速, 我们可以把它初始化为2, F｡

32
00:02:50,650 --> 00:02:56,920
‫这样的话, 在回调函数被调用之前, 我们会有两秒钟的等待时间｡

33
00:02:57,040 --> 00:03:00,460
‫说到回调函数, 我们实际上需要一个｡

34
00:03:00,460 --> 00:03:05,500
‫我们要做一个void函数, 我们称之为检查激发条件｡

35
00:03:06,010 --> 00:03:12,760
‫我们有一个计时器句柄, 一旦我们设置了计时器, 它就开始运行了,

36
00:03:12,760 --> 00:03:17,860
‫那么在计时器真正导致函数被调用之前, 我们有2秒的等待时间｡

37
00:03:17,860 --> 00:03:23,890
‫我将此称为检查火灾条件,

38
00:03:23,890 --> 00:03:30,280
‫因为我们可以检查塔是否能够调用火灾函数, 这样我们就可以设置一些条件, 以检查是否应该调用火灾｡

39
00:03:30,280 --> 00:03:33,010
‫现在我们已经声明了fire条件函数｡

40
00:03:33,010 --> 00:03:38,710
‫我们需要对其进行定义, 以便进入塔CPP并在此处定义函数｡

41
00:03:38,710 --> 00:03:47,440
‫我将把它放在开始play下, 所以我将给它一个函数体, 并在函数名之前给它一个塔类名称.

42
00:03:47,530 --> 00:03:53,710
‫现在我们有了一个函数, 但我们实际上需要设置计时器, 以便计时器开始计时,

43
00:03:53,710 --> 00:03:56,530
‫并在计时结束时调用函数｡

44
00:03:56,530 --> 00:04:02,200
‫我们可以在这里设置计时器, 然后开始游戏, 这样它就会从游戏开始时开始运行｡

45
00:04:02,200 --> 00:04:10,810
‫我们提到了世界定时器管理器, 我们可以通过一个名为“获取世界定时器管理器”的函数来访问它｡

46
00:04:10,810 --> 00:04:16,120
‫现在获取世界定时器管理器, 返回一个F定时器管理器对象｡

47
00:04:16,120 --> 00:04:22,300
‫由于我们使用的是该类型, 因此需要包含F计时器管理器的头文件｡

48
00:04:22,300 --> 00:04:26,660
‫这是一个简单的计时器管理器h｡

49
00:04:26,680 --> 00:04:31,000
‫我们还可以看到一些属于这个类的函数｡

50
00:04:31,000 --> 00:04:37,990
‫因此, 如果您对F定时器管理器的所有不同功能感兴趣, 请滚动浏览这些功能｡

51
00:04:38,110 --> 00:04:44,320
‫因此, 我们可以将此头文件包含在塔的顶部, 就在其他包含文件的下面｡

52
00:04:44,320 --> 00:04:51,220
‫现在, 我们已经包含了头文件, 现在我们可以访问世界定时器管理器, 我们感兴趣的函数称为set

53
00:04:51,220 --> 00:04:55,060
‫timer｡

54
00:04:55,480 --> 00:05:01,060
‫现在, get世界计时器管理器只返回一个F计时器管理器, 它不返回指针｡

55
00:05:01,060 --> 00:05:03,460
‫所以我们要用点来代替｡

56
00:05:03,520 --> 00:05:06,430
‫箭头, 我们将调用设置计时器｡

57
00:05:06,550 --> 00:05:11,080
‫现在设置计时器有几个版本或函数重载｡

58
00:05:11,080 --> 00:05:18,250
‫现在, vs代码有这个弹出窗口, 让我们浏览每个重载, 看看这个函数的不同版本｡

59
00:05:18,250 --> 00:05:28,480
‫我感兴趣的版本首先使用F计时器句柄, 我们将使用我们在H塔中声明的射速计时器句柄｡

60
00:05:28,480 --> 00:05:35,200
‫现在, 我们的特定函数重载的下一个参数将是user类, 就像在bind axis和bind

61
00:05:35,200 --> 00:05:37,350
‫action中一样｡

62
00:05:37,360 --> 00:05:43,240
‫这是我们要处理的类, 我们要在其中绑定函数, 它就是这个.

63
00:05:43,240 --> 00:05:52,450
‫接下来是回调函数, 它将是我们刚刚创建的A塔检查火灾条件｡

64
00:05:52,450 --> 00:05:58,930
‫现在我们需要operator的地址, 因为set timer需要函数地址｡

65
00:05:58,930 --> 00:06:07,390
‫下一个参数是一个浮点数, 表示在回调函数被调用之前, 需要经过多长时间.

66
00:06:07,390 --> 00:06:09,910
‫这就是我们的射速｡

67
00:06:09,910 --> 00:06:15,730
‫最后一个参数是一个布尔值, 它将指定该计时器是否应该循环｡

68
00:06:16,060 --> 00:06:22,000
‫现在我希望我们的回调函数每2秒调用一次, 所以我希望这个计时器循环｡

69
00:06:22,000 --> 00:06:23,830
‫所以我要说是真的｡

70
00:06:24,220 --> 00:06:28,180
‫如果我们传递false, 则会经过2秒｡

71
00:06:28,180 --> 00:06:30,910
‫我们的函数会被调用, 就这样｡

72
00:06:30,910 --> 00:06:37,030
‫但由于我们将其设置为循环, 因此我们的函数将在2秒后被调用, 之后计时器将重新启动,

73
00:06:37,030 --> 00:06:44,290
‫然后再过两秒, 函数将再次被调用, 它将继续循环, 直到游戏结束｡

74
00:06:44,290 --> 00:06:50,380
‫现在我们有一个绑定到计时器的函数, 它被设置为每2秒调用一次｡

75
00:06:50,380 --> 00:06:55,540
‫我们已经将一个函数绑定到了计时器上, 它每2秒被调用一次｡

76
00:06:55,660 --> 00:07:00,580
‫但是我们需要某种证明或者确认这个函数确实被调用了｡

77
00:07:00,580 --> 00:07:06,910
‫所以, 对于你在塔类中的挑战, 进入我们新的回调函数, 检查火灾情况｡

78
00:07:06,910 --> 00:07:09,310
‫确保坦克在射程内｡

79
00:07:09,310 --> 00:07:12,970
‫你要检查从塔到坦克的距离｡

80
00:07:12,970 --> 00:07:17,560
‫我们知道怎么做因为我们已经在tick函数中做过了.

81
00:07:17,560 --> 00:07:22,900
‫因此, 您可能需要查看tick函数, 看看它是如何完成的, 以提醒自己,

82
00:07:22,900 --> 00:07:28,720
‫现在检查距离, 确保我们在射程内, 如果我们在射程内, 则调用fire函数,

83
00:07:28,720 --> 00:07:31,330
‫暂停视频并立即执行此操作｡

84
00:07:34,320 --> 00:07:34,680
‫好吧, 我会的

85
00:07:34,680 --> 00:07:41,700
‫现在我回到塔台指挥中心, 我将滚动到tick功能, 提醒自己如何获得这个距离,

86
00:07:41,700 --> 00:07:45,620
‫并检查它是否在射程内｡

87
00:07:45,630 --> 00:07:50,420
‫现在我们可以简单地重复使用这段代码, 检查火灾情况｡

88
00:07:50,430 --> 00:07:56,790
‫现在重用代码不是很有效, 所以我们可以考虑重构它, 但首先让我们确保它工作,

89
00:07:56,790 --> 00:08:02,040
‫这样我们就可以首先检查我们的tank指针, 以确保它是有效的｡

90
00:08:02,040 --> 00:08:04,440
‫所以我要在这里检查一下火势｡

91
00:08:04,440 --> 00:08:09,870
‫如果tank和tank是有效的, 我们接下来要做的就是得到这个距离,

92
00:08:09,870 --> 00:08:14,700
‫这个值是用f向量dist函数计算出来的｡

93
00:08:14,700 --> 00:08:19,380
‫我把它放在这里, 处于止火状态.

94
00:08:19,380 --> 00:08:25,050
‫现在我们要做的下一件事是检查距离是否小于或等于射程｡

95
00:08:25,050 --> 00:08:26,610
‫所以这就是我们要做的｡

96
00:08:26,610 --> 00:08:35,820
‫如果距离小于或等于射程, 如果是这样, 我们就可以调用fire函数｡

97
00:08:35,820 --> 00:08:38,760
‫所以我们要叫火, 就这么简单｡

98
00:08:38,760 --> 00:08:46,080
‫让我们继续编译, 回到编辑器, 我点击播放, 进入射击范围｡

99
00:08:46,080 --> 00:08:52,800
‫我可以看到我们的发射塔在炮筒的顶端画出了调试球,

100
00:08:52,800 --> 00:09:00,630
‫这样我们就可以看到发射函数被调用了, 它对发射塔的作用和对坦克的作用是一样的｡

101
00:09:00,630 --> 00:09:01,740
‫所以这是伟大的｡

102
00:09:01,740 --> 00:09:09,420
‫这向我们证明了计时器正在运行, 并且每2秒调用一次回调函数｡

103
00:09:09,450 --> 00:09:14,910
‫好的, 我们现在每2秒调用一次fire函数, 处于check, fire状态｡

104
00:09:14,910 --> 00:09:22,830
‫我们有这个功能, 我们可以查看是否在范围内, 我们在tick函数中做的事情与此完全相同｡

105
00:09:22,830 --> 00:09:26,070
‫因此, 这是重构的绝佳机会｡

106
00:09:26,070 --> 00:09:32,580
‫我们可以创建一个函数, 如果我们在坦克的射程内, 它会返回一个布尔值.

107
00:09:32,580 --> 00:09:37,710
‫那么我们为什么不继续快速地把它重构成一个多头返回函数呢？

108
00:09:37,710 --> 00:09:41,430
‫所以在H座, 让我们创建一个私人功能｡

109
00:09:41,430 --> 00:09:45,840
‫它会返回bool, 我们会说在射程内.

110
00:09:45,840 --> 00:09:51,480
‫现在这是一个简单的游戏, 我们的塔只会在范围内与坦克｡

111
00:09:51,480 --> 00:09:57,120
‫这并不含糊,

112
00:09:57,120 --> 00:10:03,240
‫因为没有其他东西塔想要检查它现在是否在射程内, 如果这是一个更复杂的游戏,

113
00:10:03,240 --> 00:10:10,320
‫塔想要检查距离, 那么我们可能会命名得有点不同, 但我们可以简单地称之为在射程内.

114
00:10:10,320 --> 00:10:14,130
‫我要做的就是在Tower中实现这个功能｡

115
00:10:14,130 --> 00:10:17,340
‫因此, 让我们继续创建函数体｡

116
00:10:17,340 --> 00:10:20,880
‫我们需要一个塔来固定函数名｡

117
00:10:20,880 --> 00:10:25,560
‫我们现在要做的基本上是同样的距离检查｡

118
00:10:25,560 --> 00:10:31,020
‫所以我们首先要用if检查来确保tank是有效的｡

119
00:10:31,020 --> 00:10:38,880
‫如果是的话, 我们就可以得到这个距离, 这样我们就可以复制这条线, 在这里创建我们的本地距离浮动,

120
00:10:38,880 --> 00:10:45,690
‫然后简单地检查这个距离与射程的关系, 这样我们就可以知道, 距离是否小于或等于射程,

121
00:10:45,690 --> 00:10:51,180
‫如果是这样的话, 我们就可以简单地返回true｡

122
00:10:51,180 --> 00:10:54,780
‫此函数可返回值true｡

123
00:10:54,780 --> 00:10:58,950
‫现在我们有了一个函数, 如果我们在范围内, 它会返回true｡

124
00:10:58,950 --> 00:11:05,970
‫现在, 只要我们在if语句中点击了返回true这一行, 那么函数就会返回｡

125
00:11:05,970 --> 00:11:07,470
‫我们会跳出这个功能｡

126
00:11:07,470 --> 00:11:10,830
‫因此, if语句后面的任何其他语句都不会运行｡

127
00:11:10,830 --> 00:11:18,720
‫所以我们能做的就是在函数的最后, 我们可以返回false因为如果我们到达了返回true,

128
00:11:18,720 --> 00:11:25,020
‫我们就永远不会到达返回false这条线了.

129
00:11:25,020 --> 00:11:27,690
‫我们只需提前退出该函数｡

130
00:11:27,690 --> 00:11:35,250
‫但是如果我们不在范围内, 如果这个距离检查失败, 那么我们就永远不会返回true｡

131
00:11:35,370 --> 00:11:39,300
‫我们将到达函数的末尾并返回false｡

132
00:11:39,300 --> 00:11:49,440
‫所以这个函数会根据我们是否在范围内返回true或false, 我们可以用这个来代替在两个函数中使用重复的代码｡

133
00:11:49,440 --> 00:11:57,180
‫例如, 在这里, 我们只需要在旋转炮塔之前检查一次, 看看我们是否在射程内｡

134
00:11:57,180 --> 00:12:07,830
‫所以我们可以说, 如果在射程内, 如果返回真, 我们就在射程内, 所以我们可以调用旋转炮塔｡

135
00:12:07,860 --> 00:12:10,170
‫所以我们把它放在if语句里｡

136
00:12:10,170 --> 00:12:15,090
‫现在所有这些代码都是不必要的, 所以我们可以简单地删除它｡

137
00:12:15,450 --> 00:12:19,050
‫现在这里看起来比以前干净多了｡

138
00:12:19,050 --> 00:12:23,940
‫然后我们可以下来检查火势, 做同样的事情｡

139
00:12:23,940 --> 00:12:29,340
‫而不是所有这些, 我们可以简单地检查, 如果在射程｡

140
00:12:31,800 --> 00:12:35,010
‫如果我们是, 我们可以简单地调用火｡

141
00:12:35,280 --> 00:12:43,100
‫现在, 我们已经成功地将所有代码重构为一个检查, 该检查在我们的in fire range函数中进行｡

142
00:12:43,110 --> 00:12:50,100
‫让我们再次编译并真实的测试它, 以确保一切都按预期运行｡

143
00:12:50,100 --> 00:12:54,210
‫所以我们要按播放键进入射击范围｡

144
00:12:54,210 --> 00:12:58,110
‫当然, 我们在射程内, 它工作正常｡

145
00:12:58,110 --> 00:13:05,760
‫总之, 我们创建了一个计时器, 每隔2秒调用一次塔类中的fire函数｡

146
00:13:05,790 --> 00:13:08,700
‫现在我们也在检查坦克是否在射程内

147
00:13:08,700 --> 00:13:15,570
‫所以我们只在坦克在射程范围内的情况下每2秒调用一次射击函数｡

148
00:13:15,570 --> 00:13:19,950
‫我们还看到, 我们在两个不同的函数中使用了距离检查｡

149
00:13:19,950 --> 00:13:26,670
‫所以我们把它重构成自己的函数, 然后调用它来检查是否在范围内｡

150
00:13:26,670 --> 00:13:29,970
‫所以我们现在有一个在塔类上调用的fire函数｡

151
00:13:29,970 --> 00:13:35,190
‫接下来要做的是用我们的火功能开始产卵抛射物｡

152
00:13:35,190 --> 00:13:38,420
‫所以我们会在下一个视频中讨论这个问题｡

153
00:13:38,430 --> 00:13:39,330
‫我很快就会见到你的｡