1
00:00:04,120 --> 00:00:04,510
‫嘿, 你好

2
00:00:04,510 --> 00:00:05,440
‫欢迎回来｡

3
00:00:05,470 --> 00:00:11,740
‫现在, 我们已经设置了一个回调函数, 它绑定到代理, 以防止受到任何损坏｡

4
00:00:11,830 --> 00:00:16,210
‫最后一步是实际生成损坏事件｡

5
00:00:16,210 --> 00:00:19,690
‫当我们的抛射体击中某个物体时, 我们就想这样做｡

6
00:00:19,690 --> 00:00:25,540
‫一旦我们为这个委托进行了广播, 我们就可以对我们击中的东西施加伤害｡

7
00:00:25,540 --> 00:00:32,830
‫我们将使用应用伤害来广播这个事件, 它属于游戏静态类｡

8
00:00:32,860 --> 00:00:36,310
‫让我们来看看应用的损伤函数｡

9
00:00:36,400 --> 00:00:44,050
‫现在这里是应用伤害的文档, 它说用一般伤害伤害指定的角色｡

10
00:00:44,050 --> 00:00:47,590
‫所以这是一个应用伤害的通用函数｡

11
00:00:47,590 --> 00:00:52,510
‫我们如何回应这位代表的广播取决于我们｡

12
00:00:52,540 --> 00:00:59,140
‫现在, 我们看到我们需要包括游戏静态, 在语法中, 我们看到几个输入参数｡

13
00:00:59,140 --> 00:01:02,110
‫现在我们实际上得到了一些参数的描述｡

14
00:01:02,110 --> 00:01:08,290
‫如果我们继续向下滚动, 我们会看到受损的参与者是好的, 将受损的参与者是基础损害,

15
00:01:08,290 --> 00:01:13,660
‫在这里应用真正的描述性文档｡

16
00:01:13,690 --> 00:01:14,170
‫-谢谢—谢谢

17
00:01:14,170 --> 00:01:19,930
‫史诗事件煽动者是负责造成这种损害的控制者｡

18
00:01:19,930 --> 00:01:23,020
‫比如说, 上面写着开枪的玩家｡

19
00:01:23,020 --> 00:01:26,260
‫当它说播放器时, 它指的是那个控制器｡

20
00:01:26,260 --> 00:01:31,120
‫然后我们有损害致因, 即实际造成损害的行为者｡

21
00:01:31,120 --> 00:01:33,160
‫上面写着爆炸的手榴弹｡

22
00:01:33,160 --> 00:01:35,980
‫在我们的情况下, 这将是炮弹爆炸｡

23
00:01:35,980 --> 00:01:43,000
‫最后, 我们有损伤类型类, 这是一个描述所造成的损伤的类｡

24
00:01:43,000 --> 00:01:49,690
‫现在回到语法部分, 我们可以看到这些输入的类型, 我们可以看到damage

25
00:01:49,690 --> 00:01:57,550
‫type class是的子类, 我们之前已经看到, 的TW子类将满足类型U class的输入参数｡

26
00:01:57,550 --> 00:02:04,360
‫当我们调用apply damage的时候, 我们可以传入一个U类来表示我们想要使用的伤害类型.

27
00:02:04,360 --> 00:02:09,280
‫我们稍后将讨论如何满足这个输入参数｡

28
00:02:09,280 --> 00:02:15,190
‫因此, 色调游戏静态功能, 应用的损害是要采取一些输入参数｡

29
00:02:15,190 --> 00:02:24,100
‫让我们来计划一下如何传递合适的值当我们调用这个函数时, 我们看到首先我们需要受损的参与者｡

30
00:02:24,310 --> 00:02:30,220
‫好吧, 让我们回到投射CP, 我们称之为施加伤害｡

31
00:02:30,220 --> 00:02:34,660
‫我们想在这里做, 我们不再需要这些日志｡

32
00:02:34,660 --> 00:02:43,450
‫所以我只需要删除它们, 注意到我们的on hit回调在被调用后会得到一些传入的输入｡

33
00:02:43,450 --> 00:02:49,240
‫当on组件命中委托被广播时, 我们会看到我们有了其他参与者｡

34
00:02:49,240 --> 00:02:56,740
‫所以我们可以接触到被炮弹击中的演员, 而这就是我们想要伤害的演员｡

35
00:02:56,740 --> 00:02:59,320
‫这样就可以处理第一个输入参数｡

36
00:02:59,320 --> 00:03:01,390
‫会是另一个演员｡

37
00:03:01,390 --> 00:03:07,990
‫接下来, 我们需要伤害量, 这意味着我们的抛射体应该有一个伤害变量,

38
00:03:07,990 --> 00:03:10,360
‫这样我们就知道要施加多少伤害｡

39
00:03:10,510 --> 00:03:17,650
‫所以为什么我们不进入投射特效, 增加一个伤害变量, 这个变量可以是浮点数｡

40
00:03:17,650 --> 00:03:23,770
‫我们可以简单地称之为damage, 我们可以将其初始化为一个值, 比如50 F,

41
00:03:24,040 --> 00:03:29,890
‫因为这是我们可能想要实验的, 我们可以给予它一个U属性, 来公开它,

42
00:03:29,890 --> 00:03:32,860
‫让它在任何地方编辑｡

43
00:03:32,860 --> 00:03:37,780
‫所以现在我们有一个伤害金额传递时, 我们呼吁采取损害｡

44
00:03:38,080 --> 00:03:44,140
‫现在, 下一个参数是激发器, 我们看到它是A型控制器｡

45
00:03:44,140 --> 00:03:46,870
‫那我们怎么拿到控制器

46
00:03:46,870 --> 00:03:53,470
‫我们已经看到, 我们可以使用get owner函数获得特定组件的所有者｡

47
00:03:53,470 --> 00:04:00,820
‫这将返回拥有特定组件的参与者, 这些投射是动态产生的｡

48
00:04:00,820 --> 00:04:06,640
‫所以我们需要确保, 如果我们要调用get owner, 所有者已经设置好了,

49
00:04:06,640 --> 00:04:08,410
‫现在我们从基础兵中产生这些｡

50
00:04:08,410 --> 00:04:10,390
‫所以如果我们进入垒卒｡

51
00:04:10,600 --> 00:04:18,880
‫这是我们生成演员的地方, 但是Spawn Actor也返回一个指针, 指向被生成的演员,

52
00:04:18,880 --> 00:04:22,690
‫这样我们就可以把它存储在一个局部变量中｡

53
00:04:22,690 --> 00:04:29,220
‫例如, 我们可以说auto projectile, 并指定从spawn actor返回的值｡

54
00:04:29,230 --> 00:04:36,790
‫现在, 如果您不熟悉auto, 它允许编译器确定要分配给这个新变量的类型｡

55
00:04:36,790 --> 00:04:42,620
‫如果你把鼠标悬停在它上面, 你会看到它有一个类型为A的投射指针, 因为这是我们从spawn

56
00:04:42,670 --> 00:04:45,610
‫actor函数中签名的｡

57
00:04:45,610 --> 00:04:54,400
‫这就像我们在这里放了一个投射物指针, 现在我们可以访问新生成的投射物｡

58
00:04:54,400 --> 00:04:57,820
‫我们这样做的原因是我们想设置它的所有者｡

59
00:04:57,820 --> 00:05:02,710
‫我们要确保它的所有者设置为产生它的兵｡

60
00:05:02,920 --> 00:05:04,930
‫所以我们可以说抛射体｡

61
00:05:04,930 --> 00:05:08,010
‫这里有一个函数叫做集合所有者｡

62
00:05:08,020 --> 00:05:15,400
‫集合所有者取一个演员, 我们要传递这个, 这样当一个兵产生一个投射物时,

63
00:05:15,400 --> 00:05:18,250
‫它就会把那个投射物设为所有者.

64
00:05:18,250 --> 00:05:23,380
‫这样的话, 如果我们再调用get owner,

65
00:05:23,380 --> 00:05:25,700
‫我们就能得到这个类的实例.

66
00:05:25,720 --> 00:05:33,910
‫回到这里, 在projectiveDHCP中, 我们有get owner函数调用, 我们可以将其存储在一个本地变量中｡

67
00:05:33,940 --> 00:05:41,590
‫我将继续使用auto, 并将其称为我的所有者, 并将其设置为get owner返回的结果｡

68
00:05:41,920 --> 00:05:47,570
‫所以现在我们有了一个存储所有者值的本地参与者指针｡

69
00:05:47,590 --> 00:05:52,190
‫现在, 我们可以从该执行元访问煽动者控制器｡

70
00:05:52,210 --> 00:05:57,640
‫现在, 在我们这样做之前, 最好检查一下以确保我的所有者不为空｡

71
00:05:57,640 --> 00:06:04,460
‫所以我会说如果我的所有者是null等于等于null指针, 那么我会简单地返回｡

72
00:06:04,480 --> 00:06:09,640
‫现在, 如果你if body有一个这样的语句, 你可以把它放在同一行, 不用花括号,

73
00:06:09,640 --> 00:06:11,890
‫以防你不知道｡

74
00:06:11,890 --> 00:06:19,470
‫而null指针是C++中的一个关键字, 它允许你检查一个指针是否是null指针｡

75
00:06:19,480 --> 00:06:25,760
‫所以如果我的所有者为null, 那么我们将提前退出函数, 不做其他任何事情｡

76
00:06:25,780 --> 00:06:31,030
‫现在, 正如我所说的, 我们可以从我的所有者那里得到煽动者控制器,

77
00:06:31,030 --> 00:06:35,500
‫这就是函数get煽动者控制器的用法｡

78
00:06:36,400 --> 00:06:40,590
‫如果我们把鼠标悬停在上面, 我们会看到它返回一个A控制器指针｡

79
00:06:40,600 --> 00:06:48,250
‫我只需要使用auto并将其存储在一个局部变量中, 我称之为我的所有者instigator｡

80
00:06:50,660 --> 00:06:54,460
‫所以现在我们知道该传递什么作为煽动者了｡

81
00:06:54,470 --> 00:07:00,800
‫下一个输入是伤害原因, 这是对投射物造成伤害的行为者｡

82
00:07:00,800 --> 00:07:02,930
‫这将是简单的｡

83
00:07:02,930 --> 00:07:07,490
‫剩下的是最后一个输入参数, 即损坏类型｡

84
00:07:07,490 --> 00:07:12,740
‫我们看到它是的一个子类, 这意味着我们需要正确的使用类来传递｡

85
00:07:12,740 --> 00:07:17,960
‫N现在这里是你的损坏类型的虚幻引擎文档｡

86
00:07:17,960 --> 00:07:24,050
‫它说, 一个损害类型的目的是定义和描述一个特定形式的损害, 并提供一个渠道,

87
00:07:24,050 --> 00:07:28,370
‫定制反应的损害从各种来源｡

88
00:07:28,370 --> 00:07:30,890
‫现在, 我们不打算定制我们的破坏｡

89
00:07:30,890 --> 00:07:40,070
‫我们只需要满足输入参数, 这意味着我们需要一个U类值来表示这个损坏类型类｡

90
00:07:40,310 --> 00:07:51,020
‫现在在C++中, 如果我们想得到YOU类中的任何一个特定的类比如你破坏的类型, 我们可以调用一个叫做static类的函数｡

91
00:07:51,020 --> 00:07:54,140
‫这是从您的物件类别继承而来｡

92
00:07:54,170 --> 00:07:58,070
‫当然, 我们现在使用的是你的伤害类型, 所以我们需要标题｡

93
00:07:58,310 --> 00:08:05,690
‫我从文档中拷贝了include行,

94
00:08:05,960 --> 00:08:17,780
‫然后把它粘贴到projectile CP的顶部, 现在你会看到这个静态类函数返回了一个U类指针, 这个新的类将代表新的破坏类型C++类｡

95
00:08:17,780 --> 00:08:23,510
‫现在, 由于我们没有根据你的伤害类型创建蓝图, 也没有设置一些额外的数据,

96
00:08:23,510 --> 00:08:26,030
‫所以我们并不需要变量的子类｡

97
00:08:26,150 --> 00:08:32,750
‫所以在这个例子中我们可以使用static class, 这将返回一个U类, 代表这个类型｡

98
00:08:32,750 --> 00:08:38,480
‫我们可以把它存储在一个变量中, 我把它叫做damage type类｡

99
00:08:40,390 --> 00:08:45,520
‫这是我们可以传递的最后一个参数, 以应用损害｡

100
00:08:45,520 --> 00:08:51,250
‫所以我们现在有了所有需要传递到应用损伤函数的信息｡

101
00:08:51,250 --> 00:08:58,000
‫但是在我们这样做之前, 我想进行一些检查, 以确保我们调用这个函数是适当的｡

102
00:08:58,000 --> 00:09:00,090
‫所以我在这里做一个if语句｡

103
00:09:00,100 --> 00:09:03,550
‫首先, 我想确保其他参与者不为null｡

104
00:09:03,550 --> 00:09:06,490
‫所以我要把另一个演员放在这里｡

105
00:09:06,490 --> 00:09:13,450
‫我将在这里放置一个and, 这样我就可以检查以确保其他参与者不等于此参与者｡

106
00:09:13,450 --> 00:09:19,840
‫我们不想对自己造成伤害, 如果我们是抛射体, 现在我将放置另一端,

107
00:09:19,840 --> 00:09:24,640
‫并确保其他演员不等于我的主人｡

108
00:09:24,760 --> 00:09:28,930
‫如果射弹对主人造成伤害就不好了｡

109
00:09:28,930 --> 00:09:36,550
‫现在如果我们进入if语句, 我们就知道调用apply damage是合适的, 这样我们就可以这么做了｡

110
00:09:36,550 --> 00:09:38,290
‫这就是你们的挑战｡

111
00:09:38,290 --> 00:09:45,070
‫所以在我们新的if语句中, on hit函数调用了你的游戏静态应用损伤函数｡

112
00:09:45,070 --> 00:09:52,450
‫这意味着您需要为游戏静态信息包含正确的头部, 并且知道要传入哪些输入参数｡

113
00:09:52,570 --> 00:09:58,660
‫所以现在暂停视频并添加函数调用以在命中函数中应用伤害｡

114
00:10:02,740 --> 00:10:03,250
‫好吧, 我会的

115
00:10:03,250 --> 00:10:11,020
‫所以我在这里的投射CP, 我将包括头文件的游戏静态, 我们可以看到,

116
00:10:11,020 --> 00:10:17,260
‫从应用损害文档页面, 包括是kismet斜线游戏静态｡

117
00:10:17,980 --> 00:10:22,330
‫我将把它粘贴到这里, 现在我可以调用应用损坏了.

118
00:10:22,330 --> 00:10:28,060
‫所以我打算叫你游戏静态应用伤害｡

119
00:10:28,810 --> 00:10:35,800
‫现在, 只要我键入左括号, 就会弹出提示框, 提醒我需要输入参数｡

120
00:10:35,800 --> 00:10:40,360
‫第一个是受损的演员, 那是另一个演员.

121
00:10:40,360 --> 00:10:42,760
‫所以我们接下来要输入其他演员｡

122
00:10:42,760 --> 00:10:50,410
‫我们需要伤害数值, 我们在投射特效中增加了这个伤害浮动, 我们将其设置为50｡

123
00:10:50,410 --> 00:10:53,170
‫所以我接下来要跳过damage端｡

124
00:10:53,170 --> 00:10:56,920
‫我们需要煽动者, 我们有我的主人煽动者｡

125
00:10:56,920 --> 00:11:00,010
‫所以我将把我的所有者传递给煽动者｡

126
00:11:00,010 --> 00:11:01,960
‫其次是损害原因｡

127
00:11:01,960 --> 00:11:05,500
‫当然, 抛射体本身就是造成伤害的原因｡

128
00:11:05,500 --> 00:11:07,210
‫所以我们要把这个传递进去｡

129
00:11:07,210 --> 00:11:14,860
‫最后, 我们需要damage类型的子类, 我们知道U类指针可以满足这个要求,

130
00:11:14,860 --> 00:11:17,980
‫这就是为什么我们有damage类型类｡

131
00:11:17,980 --> 00:11:21,910
‫所以让我们传入破坏类型类｡

132
00:11:21,910 --> 00:11:25,570
‫我们现在称之为应用损坏｡

133
00:11:25,720 --> 00:11:33,040
‫所以当我们调用它的时候, 我们会生成damage事件, 而on take, any,

134
00:11:33,040 --> 00:11:39,010
‫damage代理会对此做出响应, 这意味着在我们的健康组件中, damage taken会被调用｡

135
00:11:39,010 --> 00:11:42,580
‫所以我们只需要在这里做点什么｡

136
00:11:42,580 --> 00:11:47,440
‫嗯, 这将是有意义的采取这一损害, 并减去该数额的健康｡

137
00:11:47,440 --> 00:11:52,510
‫不过, 在我们这么做之前, 我想先确认一下损害不小于或等于零｡

138
00:11:52,810 --> 00:11:59,170
‫F在记录损坏之前进行这些检查是有意义的, 只是为了确保我们不会应用一个没有任何意义的值,

139
00:11:59,170 --> 00:12:02,890
‫比如零或负值｡

140
00:12:02,890 --> 00:12:05,740
‫所以如果是这样的话, 我们就直接回去｡

141
00:12:05,740 --> 00:12:12,700
‫当然, 如果你想耍滑头, 像我在CP的projectile中做的那样, 我们可以把回报放在那里｡

142
00:12:12,700 --> 00:12:21,460
‫现在, 如果我们越过这条线, 伤害值是正值, 所以我们可以用生命值减去伤害值.

143
00:12:21,550 --> 00:12:25,750
‫为了确保这是工作, 为什么我们不把一个euy日志在这里？

144
00:12:25,750 --> 00:12:40,840
‫Yui日志, 临时警告文本, 我们可以简单地打印健康值, 以及百分比F和健康值, 然后我们可以编译｡

145
00:12:40,870 --> 00:12:47,980
‫现在编译成功了, 我们将返回编辑器, 打开输出日志, 点击播放｡

146
00:12:47,980 --> 00:12:51,010
‫现在让我们看看我们能不能被炮弹击中｡

147
00:12:51,010 --> 00:12:52,120
‫好了

148
00:12:52,150 --> 00:12:58,810
‫我们的生命值现在降到了50, 如果我们再次被击中, 我们会得到相当多的命中事件,

149
00:12:58,810 --> 00:13:02,410
‫因为我们非常快地多次击中抛射体｡

150
00:13:02,410 --> 00:13:05,770
‫但我们看到我们的健康状况记录得很好｡

151
00:13:05,770 --> 00:13:11,620
‫因此, 我们确实需要确保在健康状况为零时, 我们在死亡时实施正确的行为｡

152
00:13:11,620 --> 00:13:17,290
‫但我们也需要确保我们不会得到这个点击事件垃圾邮件多次｡

153
00:13:17,290 --> 00:13:26,800
‫现在我们知道投射物应该在击中某个东西时被销毁, 所以防止垃圾邮件发送击中事件的最好方法是销毁投射物｡

154
00:13:26,800 --> 00:13:29,290
‫这是我们在这段视频中要做的最后一件事｡

155
00:13:29,290 --> 00:13:38,050
‫所以回到投射体, 在受到伤害后, 我们能做的就是让投射体自毁, 这再简单不过了.

156
00:13:38,050 --> 00:13:41,110
‫我们简单地称之为destroy函数｡

157
00:13:41,110 --> 00:13:49,330
‫在编辑器中再编译一次, 我们就可以继续, 然后被一个投射物击中, 看看这个｡

158
00:13:49,330 --> 00:13:51,520
‫炮弹不见了｡

159
00:13:51,520 --> 00:13:55,360
‫所以它造成了伤害然后就消失了｡

160
00:13:55,360 --> 00:14:02,110
‫当然, 我们也可以测试击中塔楼的情况, 用投射物爆破它们,

161
00:14:02,110 --> 00:14:04,570
‫并确保这些击中事件是触发的｡

162
00:14:04,570 --> 00:14:10,750
‫正如你所看到的, 我可以用一大堆炮弹来攻击这个塔,

163
00:14:10,750 --> 00:14:16,390
‫我们会看到这个可怜的塔的健康值变得非常非常负｡

164
00:14:16,540 --> 00:14:23,650
‫总之, 我们调用了apply damage函数, 这导致了对on take any

165
00:14:23,650 --> 00:14:25,030
‫damage委托的广播｡

166
00:14:25,030 --> 00:14:30,130
‫我们在健康组件中记录了健康状况, 并销毁了炮弹｡

167
00:14:30,130 --> 00:14:32,350
‫所以我们现在已经处理了损坏｡

168
00:14:32,350 --> 00:14:34,390
‫我们还没有处理死亡｡

169
00:14:34,390 --> 00:14:38,860
‫这将是我们在以后的视频中要介绍的内容之一｡

170
00:14:39,310 --> 00:14:40,270
‫我很快就会见到你的｡