1
00:00:04,260 --> 00:00:05,890
‫你好, 欢迎回来｡

2
00:00:05,910 --> 00:00:11,130
‫现在, 我们已经创建了我们的投射类, 我们准备开始在关卡中繁殖这些东西,

3
00:00:11,130 --> 00:00:15,660
‫这样我们就可以在塔上发射它们, 并最终摧毁它们｡

4
00:00:15,660 --> 00:00:19,950
‫现在, 繁殖演员将涉及到繁殖演员函数｡

5
00:00:19,950 --> 00:00:22,470
‫我们将在这段视频中了解它是如何工作的｡

6
00:00:22,470 --> 00:00:25,290
‫现在, 让我们来谈谈如何生成抛射体｡

7
00:00:25,320 --> 00:00:29,130
‫这是我们想从C++方面做的事情｡

8
00:00:29,130 --> 00:00:34,590
‫我们将调用C++函数来动态地创建新对象｡

9
00:00:34,590 --> 00:00:43,110
‫现在我们从C++的角度来进行派生, 但是我们希望根据projectile类的蓝图来派生一个对象｡

10
00:00:43,110 --> 00:00:51,030
‫原因是因为我们有一个基于A Projectile C++类的蓝图, 其中包含了额外的信息｡

11
00:00:51,030 --> 00:00:54,270
‫具体地说, 它具有网格属性集｡

12
00:00:54,270 --> 00:00:57,780
‫我们为静态网格组件选择了网格｡

13
00:00:57,780 --> 00:01:00,510
‫所以我们不能只生成C++版本｡

14
00:01:00,510 --> 00:01:04,590
‫我们必须生成蓝图版本才能得到网格｡

15
00:01:04,590 --> 00:01:10,650
‫所以问题是我们如何在C++中生成一个基于蓝图的对象？

16
00:01:10,650 --> 00:01:15,810
‫我们将学习PT子类, 这是一个模板.

17
00:01:15,810 --> 00:01:20,730
‫和许多模板一样, 尖括号也需要类型｡

18
00:01:20,730 --> 00:01:24,480
‫因此使用PT子类需要一个类型参数｡

19
00:01:24,480 --> 00:01:29,790
‫这样我们就有了一个变量, 用来存储U类.

20
00:01:29,790 --> 00:01:37,350
‫U类代表一个类类型, 但它也有能力与虚幻引擎的反射系统进行交互｡

21
00:01:37,350 --> 00:01:43,290
‫当我说反射时, 我指的是在C++和蓝图端之间交换信息｡

22
00:01:43,320 --> 00:01:50,700
‫顾名思义, 的PT子类允许我们存储一个变量,

23
00:01:50,700 --> 00:01:54,870
‫该变量表示基于我们传入的类型的类或所选类型的子类｡

24
00:01:54,870 --> 00:02:02,880
‫这意味着我们可以选择一个类型, 并且t的子类可以包含一个u类, 该u类表示该类型或从该类型派生的任何类型｡

25
00:02:02,880 --> 00:02:06,360
‫这包括基于类型的蓝图｡

26
00:02:06,360 --> 00:02:09,090
‫我们来看看这个t子类是怎么工作的｡

27
00:02:09,090 --> 00:02:09,380
‫好吧, 我会的

28
00:02:09,390 --> 00:02:17,880
‫所以我回到了基地, 我在基地的原因是因为我们希望这个炮弹在坦克和塔类｡

29
00:02:17,880 --> 00:02:20,910
‫这两个类都将是产卵抛射体｡

30
00:02:20,910 --> 00:02:23,700
‫所以我想要一个变量的t子类｡

31
00:02:23,700 --> 00:02:30,930
‫所以我会在尖括号里写上t, sub class of, 我们需要传入一个类型.

32
00:02:30,930 --> 00:02:34,740
‫现在我们甚至可以像这样在尖括号内进行forward声明｡

33
00:02:34,740 --> 00:02:37,440
‫我准备做一个发射体｡

34
00:02:37,440 --> 00:02:42,690
‫原因是我们创建了projectory类, 它的类型是projectory｡

35
00:02:42,690 --> 00:02:47,940
‫我将创建一个变量, 并将其命名为projectory类｡

36
00:02:47,940 --> 00:02:54,960
‫现在, 这将允许我们有一个C++变量来表示一个类类型, 并且这个类型可以基于一个投射物,

37
00:02:54,960 --> 00:02:59,670
‫甚至是一个基于这个的蓝图类类型｡

38
00:02:59,670 --> 00:03:02,100
‫现在我要给予它一个U属性｡

39
00:03:02,730 --> 00:03:09,060
‫因为我希望能够编辑此内容, 至少在默认蓝本中, 所以我将此编辑设置为默认值｡

40
00:03:09,060 --> 00:03:12,540
‫只有现在我们才能给予这个一个范畴｡

41
00:03:13,530 --> 00:03:16,170
‫我会把它归为战斗类｡

42
00:03:16,200 --> 00:03:18,240
‫现在让我们继续编译它｡

43
00:03:18,270 --> 00:03:24,330
‫好的, 我回到编辑器, 进入蓝图文件夹, 然后进入脑桥文件夹｡

44
00:03:24,330 --> 00:03:29,580
‫我将打开BP-—油箱, 然后打开完整蓝图编辑器

45
00:03:29,580 --> 00:03:32,910
‫现在, 如果我查看详细信息面板, 我可以查找战斗｡

46
00:03:32,910 --> 00:03:33,840
‫在这里｡

47
00:03:33,840 --> 00:03:36,540
‫这是抛射体类变量｡

48
00:03:36,540 --> 00:03:40,410
‫这是我们称之为抛射体类的子类｡

49
00:03:40,410 --> 00:03:44,250
‫现在请注意, 我们可以在这里设定, 也可以使用下拉式清单来设定｡

50
00:03:44,250 --> 00:03:47,910
‫如果我们单击下拉菜单, 则有三个选项｡

51
00:03:47,910 --> 00:03:53,340
‫我们可以把它设为none, 这是默认值, 也就是说它是一个空指针.

52
00:03:53,340 --> 00:03:57,960
‫或者我们可以将其设置为射弹或BP射弹｡

53
00:03:57,990 --> 00:04:08,880
‫的子类允许我们将projectory类设置为基于projectory的特定类型, 因为这是我们在创建变量时选择的类型｡

54
00:04:08,880 --> 00:04:10,140
‫这里是抛射体｡

55
00:04:10,140 --> 00:04:14,520
‫这是C++中称为projectile的C++类｡

56
00:04:14,520 --> 00:04:22,920
‫它是一个projectile, 但是BP projectile是一个基于C++ projectile类的蓝图, 我们可以选择它｡

57
00:04:22,920 --> 00:04:27,870
‫现在, 弹丸类被设置为BP弹丸类型｡

58
00:04:27,870 --> 00:04:32,610
‫现在, 这不是一个组件, 也不是一个BP投射物体｡

59
00:04:32,610 --> 00:04:33,540
‫不是这样的

60
00:04:33,540 --> 00:04:36,480
‫它存储一个类型, 更具体地说是一个U｡

61
00:04:36,480 --> 00:04:37,260
‫类类型｡

62
00:04:37,260 --> 00:04:45,390
‫就像我说的, 你的类有内置的功能, 允许反射在C++和蓝图之间工作｡

63
00:04:45,390 --> 00:04:48,690
‫信息可以在C++和蓝图之间流动｡

64
00:04:48,690 --> 00:04:55,710
‫所以现在我们有了projectile类, 一个PT子类, 设置为BP projectile蓝图类型｡

65
00:04:55,710 --> 00:04:59,790
‫那么, 为什么要费尽心思创建变量的子类呢？

66
00:04:59,790 --> 00:05:03,750
‫我们需要讨论一下spawn actor函数是如何工作的｡

67
00:05:04,200 --> 00:05:08,400
‫Spawn actor是一个属于新世界类的函数｡

68
00:05:08,400 --> 00:05:12,120
‫所以如果我们掌握了世界, 我们可以叫再生演员｡

69
00:05:12,120 --> 00:05:21,060
‫Spawn actor是另一个模板函数, 它的设计目的是创建新对象, 类似于创建默认子对象｡

70
00:05:21,060 --> 00:05:28,260
‫但创建默认子对象是为创建组件而设计的, 我们只能在特定类的构造函数中使用它,

71
00:05:28,260 --> 00:05:36,360
‫在游戏运行时, 可以在运行时调用派生演员, 它可以创建演员｡

72
00:05:36,360 --> 00:05:39,450
‫现在它是一个模板, 所以它需要一个类型｡

73
00:05:39,480 --> 00:05:45,780
‫如果我们想要生成一个projectile, 那么我们会在C++类中传递projectile类型.

74
00:05:45,810 --> 00:05:52,590
‫这是由C++中的spawn actor函数返回的C++类｡

75
00:05:52,620 --> 00:05:57,060
‫现在括号中有许多参数, 包括一个U类｡

76
00:05:57,060 --> 00:06:02,190
‫现在, 这个函数有多个重载, 它们采用不同的输入参数｡

77
00:06:02,190 --> 00:06:07,590
‫最简单的可能是一个U类, 一个位置和一个旋转的版本｡

78
00:06:07,590 --> 00:06:08,010
‫美国｡

79
00:06:08,010 --> 00:06:11,280
‫类表示要派生的类型｡

80
00:06:11,310 --> 00:06:16,020
‫这是衍生的对象的实际类型｡

81
00:06:16,050 --> 00:06:18,300
‫这可能是一个蓝图类｡

82
00:06:18,330 --> 00:06:25,890
‫位置是一个F向量, 指定在何处生成对象, 旋转将指定对象的旋转｡

83
00:06:25,890 --> 00:06:28,710
‫语法示例如下所示｡

84
00:06:28,710 --> 00:06:35,580
‫我们将调用spawn actor, 指定类类型,

85
00:06:35,580 --> 00:06:38,820
‫然后传入u类信息沿着位置向量和旋转器｡

86
00:06:38,820 --> 00:06:41,160
‫我们来谈谈你的课｡

87
00:06:41,160 --> 00:06:44,970
‫现在, 正如我们所说的, 你的类代表一个类类型｡

88
00:06:44,970 --> 00:06:51,480
‫当我们调用Spawn actor时, 我们传入一个U类, 以便为spawn

89
00:06:51,480 --> 00:06:53,550
‫actor函数提供有关要生成的对象的信息｡

90
00:06:53,910 --> 00:07:01,860
‫是的, 我们在尖括号中传递了一个类型, 但这只是告诉Spawn actor要创建的C++类型｡

91
00:07:01,860 --> 00:07:04,890
‫而你的类包含更多的信息｡

92
00:07:04,890 --> 00:07:11,070
‫假设我们创建了一个基于投射物的蓝图, 并在蓝图中设置了一些属性,

93
00:07:11,070 --> 00:07:14,580
‫例如为静态网格组件选择静态网格｡

94
00:07:14,580 --> 00:07:22,860
‫现在, 如果我们只是生成一个原始的C++类, 那么静态网格将不会设置在新生成的投射物对象上｡

95
00:07:22,860 --> 00:07:26,250
‫本质上, 我们只是在孕育一个看不见的新演员｡

96
00:07:26,430 --> 00:07:30,780
‫但是, 新的类变量可以表示蓝图类｡

97
00:07:30,930 --> 00:07:38,730
‫您的类使我们能够在C++端拥有一个变量, 它表示一个蓝图､ 类类型和衍生｡

98
00:07:38,730 --> 00:07:48,060
‫Actor可以将该类作为输入参数, 这样它就可以根据新类所表示的蓝图生成新对象｡

99
00:07:48,060 --> 00:07:58,560
‫所以一个新的投射物将设置它的静态网格属性, 因为我们是基于蓝图而不是原始的C++类来生成一个新对象的｡

100
00:07:58,560 --> 00:08:05,190
‫这就是我们创建子类的原因, 因为它可以存储一个新的类,

101
00:08:05,190 --> 00:08:10,050
‫并且我们可以将它设置为等于我们的BP坦克蓝图中的BP炮弹｡

102
00:08:10,050 --> 00:08:13,020
‫现在你知道怎么生演员了｡

103
00:08:13,170 --> 00:08:16,020
‫Spawn演员属于新的世界级｡

104
00:08:16,020 --> 00:08:22,320
‫所以如果你调用get world,

105
00:08:22,320 --> 00:08:30,750
‫然后简单地调用Spawn actor, 那么你知道这个函数的输入要求, 你在尖括号中传递C++类型, 你在括号中类了一个位置和一个旋转｡

106
00:08:30,750 --> 00:08:35,820
‫所以对于你的挑战, 你将在fire函数中生成抛射体｡

107
00:08:35,820 --> 00:08:41,760
‫所以调用get world spawn actor并在尖括号中传递一个抛射体｡

108
00:08:41,760 --> 00:08:45,390
‫这意味着您需要包含projectory的头文件｡

109
00:08:45,390 --> 00:08:52,920
‫所以别忘了这一点, 并使用我们新的变量抛射体类作为括号中的U类输入参数｡

110
00:08:52,920 --> 00:08:55,320
‫现在我们需要一个位置和一个轮换｡

111
00:08:55,320 --> 00:09:00,480
‫你将使用抛射体的产卵点来定位和旋转｡

112
00:09:00,480 --> 00:09:02,850
‫从投射物产生点组件｡

113
00:09:02,850 --> 00:09:09,000
‫您可以呼叫取得元件位置和取得元件旋转来存取这些值｡

114
00:09:09,000 --> 00:09:14,040
‫所以暂停视频, 现在调用火函数中的spawn actor｡

115
00:09:16,920 --> 00:09:17,310
‫好吧, 我会的

116
00:09:17,310 --> 00:09:22,880
‫让我们进入定义了激发函数的基础池CP｡

117
00:09:22,890 --> 00:09:25,230
‫现在我们在这里画出了调试球体｡

118
00:09:25,230 --> 00:09:27,450
‫我们真的不需要了｡

119
00:09:27,450 --> 00:09:33,270
‫我将删除这个函数调用, 改为调用Spawn actor.

120
00:09:33,270 --> 00:09:36,750
‫现在我们已经有了抛射体的产卵点位置｡

121
00:09:37,050 --> 00:09:43,770
‫我将把这个局部变量重命名为location, 然后创建一个新的F旋转器｡

122
00:09:44,430 --> 00:09:45,810
‫称为旋转｡

123
00:09:45,900 --> 00:09:50,010
‫这个我也会从投射物的产卵点得到｡

124
00:09:50,010 --> 00:09:56,670
‫所以它是抛射体的产生点, 得到了组件的旋转｡

125
00:09:56,670 --> 00:10:01,980
‫现在我有了产生抛射体的位置和旋转角度｡

126
00:10:02,430 --> 00:10:07,050
‫所以接下来我需要调用spawn actor这样我就可以调用get world了｡

127
00:10:07,050 --> 00:10:11,910
‫从这个函数得到的世界中, 我可以调用spawn actor｡

128
00:10:12,240 --> 00:10:15,780
‫这里有尖括号和圆括号, 对吧？

129
00:10:15,780 --> 00:10:19,740
‫所以在角括号里, 我需要用一个抛射体｡

130
00:10:21,240 --> 00:10:25,640
‫因为我们使用的是抛射体, 所以我们需要包括它的头部｡

131
00:10:25,650 --> 00:10:32,760
‫在这里, 我将删除, 绘制调试助手, 并将其替换为projectile｡

132
00:10:34,740 --> 00:10:37,260
‫所以现在我们把这种类型包括在内了｡

133
00:10:37,260 --> 00:10:44,070
‫现在我们需要U类, 基于H有抛射体类, 我们可以用它作为U类｡

134
00:10:44,070 --> 00:10:47,050
‫所以我们要通过抛射体课｡

135
00:10:47,070 --> 00:10:54,750
‫现在, 最后, 我们可以传入位置和旋转, 这将满足spawn actor函数｡

136
00:10:54,750 --> 00:11:00,420
‫让我们继续编译, 然后回到编辑器, 我们可以测试一下.

137
00:11:00,420 --> 00:11:04,080
‫我将继续单击并查看它｡

138
00:11:04,080 --> 00:11:06,750
‫我们已经产生了一个新的炮弹｡

139
00:11:06,750 --> 00:11:15,660
‫我们在发射筒的顶端发射炮弹, 它们就在空中盘旋, 这看起来不太对劲｡

140
00:11:15,660 --> 00:11:16,430
‫不过没关系

141
00:11:16,440 --> 00:11:17,700
‫这是第一步｡

142
00:11:17,700 --> 00:11:23,580
‫我们首先要繁殖抛射体, 让它像抛射体一样作为下一步｡

143
00:11:23,580 --> 00:11:27,120
‫所以总而言之, 我们现在正在繁殖抛射体｡

144
00:11:27,150 --> 00:11:29,060
‫这是一个伟大的里程碑｡

145
00:11:29,070 --> 00:11:32,250
‫然而, 它们还不完全是抛射体｡

146
00:11:32,280 --> 00:11:36,060
‫他们只是在那里盘旋, 炮弹应该在空中飞行｡

147
00:11:36,210 --> 00:11:43,800
‫所以在下一个视频中, 我们将讨论如何让我们的抛射体在空中飞行, 这样它们就像抛射体一样｡

148
00:11:43,830 --> 00:11:44,700
‫我很快就会见到你的｡