1
00:00:04,470 --> 00:00:06,110
‫你好, 欢迎｡

2
00:00:06,120 --> 00:00:10,980
‫在这节课中,

3
00:00:10,980 --> 00:00:18,360
‫我们将创建一把枪, 我们将学习如何为这个游戏设计枪, 使它们是可交换的, 这样我们就可以在不同类型的枪上拥有不同的属性.

4
00:00:18,360 --> 00:00:25,920
‫这就是第一人称或第三人称射击游戏中架构的一般工作方式, 让我们深入了解一下它是如何完成的｡

5
00:00:27,060 --> 00:00:27,330
‫好吧, 我会的

6
00:00:27,330 --> 00:00:30,860
‫所以我们有一段时间没有检查我们的项目计划｡

7
00:00:30,870 --> 00:00:33,310
‫每当我们到达计划, 运动就完成了｡

8
00:00:33,330 --> 00:00:39,420
‫现在动画已经完成, 拍摄, 这是我们接下来要关注的事情｡

9
00:00:39,600 --> 00:00:47,280
‫这里有点混乱, 因为我们的网格看起来已经有一把枪了, 但实际上我们并不想用这把枪.

10
00:00:47,280 --> 00:00:49,280
‫我们想以不同的方式使用它｡

11
00:00:49,680 --> 00:00:59,370
‫原因是在一个射手类型的游戏, 你经常希望能够切换武器或至少能够有不同的字符, 有不同的武器｡

12
00:00:59,370 --> 00:01:05,850
‫最简单的方法就是把枪设计成一个独立的东西, 这样你就可以把它们换掉,

13
00:01:05,850 --> 00:01:09,750
‫这样它就可以负责如何射击｡

14
00:01:09,810 --> 00:01:15,000
‫如果是火箭发射器､ 猎枪或步枪, 它们会以不同的方式工作｡

15
00:01:15,420 --> 00:01:20,970
‫现在, 你可能会说,

16
00:01:20,970 --> 00:01:31,350
‫好吧, 让我们创建一个枪组件, 我们可以把这个枪组件放在我们的网格下面, 这样就可以了, 只是这样我们就失去了模块化, 让我们可以在枪上添加多个组件｡

17
00:01:31,350 --> 00:01:39,810
‫所以我们真正想做的是沿着这条路走下去, 让一个演员来演枪, 这对射手角色来说是幼稚的｡

18
00:01:39,810 --> 00:01:43,860
‫这是我们以前没有遇到过的, 但它是这样工作的｡

19
00:01:44,280 --> 00:01:53,070
‫您可以有一个射手角色和一把枪作为它的子角色, 射手角色可以有多个组件, 这些组件是彼此的子ID｡

20
00:01:53,070 --> 00:01:58,380
‫所以你有了胶囊, 我们现在有了作为胶囊的子项的网格,

21
00:01:58,380 --> 00:02:01,920
‫枪的组件可以是它的子项ID｡

22
00:02:01,920 --> 00:02:05,940
‫因此, 网格获取角色网格的子ID｡

23
00:02:06,030 --> 00:02:13,290
‫如果它有任何其他的组件, 比如枪口的粒子效果, 那可能会被添加到网格中｡

24
00:02:13,290 --> 00:02:19,650
‫所以你可以看到这些层次是独立的, 你有场景组件, 在右边有变换,

25
00:02:19,650 --> 00:02:25,830
‫它们可以在某个层次中｡

26
00:02:25,830 --> 00:02:31,350
‫然后演员层次实际上遵循场景组件的层次｡

27
00:02:31,350 --> 00:02:33,270
‫演员们没有自己的等级制度｡

28
00:02:33,270 --> 00:02:37,230
‫这是需要一点时间让你了解的,

29
00:02:37,230 --> 00:02:44,820
‫当我点击它的时候, 是一个哈哈的时刻, 实际上没有演员的层次, 只有场景组件的层次｡

30
00:02:44,820 --> 00:02:50,490
‫有些演员拥有场景组件,

31
00:02:50,490 --> 00:02:56,190
‫因此他们最终拥有一个层次, 因为他们的场景组件彼此相关, 但他们之间实际上没有关系｡

32
00:02:56,580 --> 00:03:05,400
‫所以说, 为了设置上下文, 我们要做的第一件事就是为自己创建一个C++枪支演员｡

33
00:03:05,550 --> 00:03:11,760
‫在这种情况下, 它不会是一个棋子或字符或类似的东西｡

34
00:03:11,760 --> 00:03:14,470
‫它只是一个简单的演员, 因为我们不需要任何行为｡

35
00:03:14,470 --> 00:03:15,510
‫你不需要拥有它｡

36
00:03:15,510 --> 00:03:16,340
‫我们什么都不需要做｡

37
00:03:16,350 --> 00:03:18,060
‫这只是简单的, 简单的演员｡

38
00:03:18,270 --> 00:03:19,740
‫所以让我们开始吧｡

39
00:03:19,740 --> 00:03:21,090
‫事实上, 对你来说有点挑战｡

40
00:03:21,090 --> 00:03:26,460
‫继续创建那个C++角色, 你应该可以做一些小挑战, 尝试一下｡

41
00:03:26,790 --> 00:03:27,070
‫好吧, 我会的

42
00:03:27,120 --> 00:03:34,500
‫回到正题, 我将用一个新的C++类来做, 我们不需要让我们看看, 演员｡

43
00:03:34,500 --> 00:03:42,300
‫这就是我们要选择的, 我们把它命名为one gun, 就像创建这个类一样简单.

44
00:03:42,630 --> 00:03:48,190
‫一旦完成了, 它就会出现在你的代码编辑器中, 我们还不需要对它做任何事情,

45
00:03:48,190 --> 00:03:53,370
‫因为我想做的第一件事就是创建一个蓝图子类｡

46
00:03:53,370 --> 00:03:59,430
‫因此, 在内容浏览器中右键单击你的类, 而不是称之为My Gun,

47
00:03:59,430 --> 00:04:03,000
‫我不知道为什么它会自动默认为“哔哔”下划线｡

48
00:04:03,000 --> 00:04:04,320
‫我打算把它放在内容的根中｡

49
00:04:04,320 --> 00:04:04,410
‫四个｡

50
00:04:04,410 --> 00:04:06,660
‫现在我们可以做一点重新组织一旦我们有更多的类｡

51
00:04:06,660 --> 00:04:09,810
‫正如我之前所说的, 我们将创建Blueprint类｡

52
00:04:09,810 --> 00:04:10,950
‫如你所见, 它是空的｡

53
00:04:10,950 --> 00:04:12,720
‫它有一个默认的场景根｡

54
00:04:12,720 --> 00:04:14,490
‫我们要把它修好｡

55
00:04:14,530 --> 00:04:20,520
‫我们要做的是在C++中添加一个组件, 因为这是一门C++课程｡

56
00:04:20,520 --> 00:04:24,210
‫让我们练习一下在C++中添加组件的技巧｡

57
00:04:24,240 --> 00:04:30,840
‫这也意味着我们可以从C++代码中访问这些组件, 以便在那里操作和编写代码｡

58
00:04:30,840 --> 00:04:36,300
‫现在我们需要的设置是有一个场景根组件, 它只是一个场景组件, 然后是一个网格,

59
00:04:36,300 --> 00:04:39,510
‫它是场景组件的子组件｡

60
00:04:39,510 --> 00:04:40,290
‫我们为什么要这样做？

61
00:04:40,290 --> 00:04:47,820
‫因为我们希望能够改变网格相对于枪的根部的位置, 这样我们就可以针对不同的网格,

62
00:04:47,820 --> 00:04:52,200
‫将手柄放在不同的位置｡

63
00:04:52,200 --> 00:04:55,740
‫所以如果我们有不同的枪,

64
00:04:55,740 --> 00:05:00,780
‫我们可以确保它们都在同一个位置有这个手柄这样当我们把它连接到角色的手上时, 它会和手柄一起出现在角色的手上.

65
00:05:01,500 --> 00:05:02,610
‫那我们要怎么做呢？

66
00:05:02,610 --> 00:05:08,760
‫我们将转到Visual Studio代码, 并在此处创建一个私有部分,

67
00:05:08,760 --> 00:05:13,290
‫用于存储我们将要创建得不同组件得新属性.

68
00:05:13,440 --> 00:05:20,670
‫我将创建一个新的属性visible anywhere, 我们希望我们的组件在任何地方都是可见的, 因为它们是指针｡

69
00:05:20,670 --> 00:05:26,370
‫我们不希望能够编辑指针, 但我们确实希望能够看到这些指针的属性, 并且能够｡

70
00:05:26,570 --> 00:05:30,950
‫这就是我们所指的类的范围｡

71
00:05:30,980 --> 00:05:34,600
‫然后决定显示什么, 编辑什么｡

72
00:05:34,610 --> 00:05:38,420
‫所以这里我们要说的是指针不是可编辑的｡

73
00:05:38,420 --> 00:05:40,210
‫这就是为什么我们要选择可见的｡

74
00:05:40,640 --> 00:05:41,810
‫不管怎样, 这里有一点修改｡

75
00:05:41,840 --> 00:05:48,740
‫现在我们希望这是一个你, 因为它是一个组件, 然后它是一个场景组件, 我们想要的｡

76
00:05:49,220 --> 00:05:56,540
‫如果我输入正确的话, 我已经看到了组件, 它是一个指向它的指针, 这将是我们的根组件｡

77
00:05:57,780 --> 00:06:01,650
‫就像这样然后我们要一个你的属性｡

78
00:06:02,370 --> 00:06:05,790
‫再次可见的任何地方为我们的网格｡

79
00:06:07,140 --> 00:06:16,260
‫网格的类将是一个新的静态网格组件, 因为它不是骨架网格, 它是刚性的, 它没有任何骨架,

80
00:06:16,260 --> 00:06:19,920
‫任何骨骼｡

81
00:06:19,920 --> 00:06:24,960
‫把它当作指针, 这样就可以调用网格了.

82
00:06:25,760 --> 00:06:31,790
‫实际上, 我认为我需要在这里小心一点, 因为我认为根组件已经存在于actor的父类中｡

83
00:06:31,790 --> 00:06:34,550
‫所以我就跟这条路的注｡

84
00:06:35,120 --> 00:06:38,870
‫我们已经在C++中有了一个构造函数｡

85
00:06:38,870 --> 00:06:42,400
‫我们只需要在这里包含适当的头文件｡

86
00:06:42,410 --> 00:06:46,220
‫现在, 当您使用Visual Studio代码时, 一个小技巧是找出头文件可能在哪里｡

87
00:06:46,220 --> 00:06:50,840
‫使用Control P搜索｡

88
00:06:50,840 --> 00:06:53,120
‫在本例中, 我们希望了解静态网格｡

89
00:06:53,120 --> 00:07:01,970
‫静态网格组件, 我们可以看到静态网格组件点h｡ 如果我继续打开它, 并将鼠标悬停在选项卡上,

90
00:07:01,970 --> 00:07:07,430
‫您可以看到它位于此长路径下｡

91
00:07:07,430 --> 00:07:12,410
‫但有趣的是它在类下面, 我们可以从那里查到｡

92
00:07:12,410 --> 00:07:15,560
‫这是组件, 静态网格组件｡

93
00:07:15,560 --> 00:07:21,950
‫因此, 我可以关闭该选项卡,

94
00:07:21,950 --> 00:07:29,210
‫然后在我们的include上方, 实际上在我们的枪的include下方, 我们将对组件和静态网格组件进行散列include｡

95
00:07:29,510 --> 00:07:35,930
‫实际上, 我刚刚想起, 我们得到的网格, 由于某种原因, 实际上并不是静态网格｡

96
00:07:35,930 --> 00:07:38,120
‫我认为它们可能是骨骼网｡

97
00:07:38,240 --> 00:07:45,020
‫你可以通过进入资产包, 射击游戏武器, 看看这些措施来找到这一点｡

98
00:07:45,020 --> 00:07:48,680
‫可以肯定的是, 如果将鼠标悬停在它们上方, 可以看到它们是骨骼网格｡

99
00:07:48,680 --> 00:07:49,880
‫别问我为什么｡

100
00:07:49,880 --> 00:07:51,920
‫出于某种原因, 这就是他们｡

101
00:07:52,220 --> 00:07:56,810
‫因此, 我们需要在头文件中将类型更改为骨架网格｡

102
00:07:56,810 --> 00:08:01,550
‫因此, 我们将使用骨骼网格来代替静态网格｡

103
00:08:01,550 --> 00:08:06,260
‫对于包含也是一样, 它将是骨架｡

104
00:08:07,310 --> 00:08:09,560
‫我们要记住的网格组件｡

105
00:08:09,560 --> 00:08:11,450
‫头文件里没有你｡

106
00:08:12,390 --> 00:08:15,740
‫我相信他们看到的是默认情况下已经包含在这里的组件｡

107
00:08:15,750 --> 00:08:20,300
‫因此, 现在是时候挑战一下如何添加自己的网格组件了｡

108
00:08:20,310 --> 00:08:27,720
‫我们将创建一个根场景组件, 将其设置为根,

109
00:08:27,720 --> 00:08:35,880
‫并将其设置为类的根, 然后创建一个网格组件, 并设置两者之间的连接, 以便网格组件是该根接缝组件的子组件｡

110
00:08:35,880 --> 00:08:37,620
‫暂停视频, 开始体验｡

111
00:08:37,710 --> 00:08:38,820
‫好的欢迎回来｡

112
00:08:38,820 --> 00:08:41,460
‫所以我们要过去设置｡

113
00:08:41,460 --> 00:08:48,510
‫首先, 我们的根, 它是一个创建默认子对象的类型｡

114
00:08:48,600 --> 00:08:56,160
‫您已经看到了组件, 我们将为给予命名, 该名称将与文本宏一起使用, 我们将称其为根,

115
00:08:56,160 --> 00:08:59,520
‫并以分号结尾.

116
00:08:59,520 --> 00:09:01,590
‫然后将其设置为根目录｡

117
00:09:01,590 --> 00:09:06,210
‫因此, 设置根组件将把它设置为参与者的根组件｡

118
00:09:06,210 --> 00:09:08,160
‫因此, 将root设置为根组件｡

119
00:09:08,370 --> 00:09:09,480
‫好东西｡

120
00:09:09,480 --> 00:09:12,420
‫然后我们要创建网格｡

121
00:09:12,420 --> 00:09:21,480
‫所以网格等于创建默认子对象, 它是骨骼网格组件, 我们希望它作为类,

122
00:09:21,480 --> 00:09:28,260
‫然后文本宏将其命名为网格, 并在结尾处添加分号｡

123
00:09:28,260 --> 00:09:30,090
‫然后我们要建立连线｡

124
00:09:30,090 --> 00:09:34,380
‫所以这就要网状箭头设置了｡

125
00:09:35,150 --> 00:09:42,920
‫设置附件, 我们将把它连接到根目录, 这样我们就可以保存它,

126
00:09:42,920 --> 00:09:51,740
‫然后编译, 构建, 我们将进入Unreal, 看看我们的子类.

127
00:09:51,740 --> 00:09:56,960
‫当然, 在这里我们有了根,

128
00:09:56,960 --> 00:10:02,540
‫我们有了子网格, 我们也有了这个默认的场景根, 我想让我们重新启动编辑器, 看看它是否会消失｡

129
00:10:02,750 --> 00:10:07,280
‫有时候, 在添加组件时, 内容可能会像这样徘徊, 并被缓存｡

130
00:10:07,280 --> 00:10:12,500
‫当然, 如果我们再打开BP枪的设计图, 你可以看到我们只得到了这两个组件｡

131
00:10:12,500 --> 00:10:21,710
‫我们已经添加了根和网格, 并且我们可能希望继续并更改射击游戏的资产包中的一个骨架网格的网格｡

132
00:10:21,860 --> 00:10:23,240
‫我们有步枪, 我们有发射器｡

133
00:10:23,240 --> 00:10:25,910
‫我要选这把枪作为来复枪｡

134
00:10:25,910 --> 00:10:30,290
‫所以说它是BP枪有点虚伪｡

135
00:10:30,290 --> 00:10:32,840
‫这应该是BP步枪｡

136
00:10:32,840 --> 00:10:41,630
‫让我们继续重命名它, 转到内容浏览器, 将其重命名为BP步枪或BP Gun, 下划线为rifle｡

137
00:10:41,630 --> 00:10:43,760
‫现在直接称之为BP步枪｡

138
00:10:44,330 --> 00:10:44,960
‫你去那里｡

139
00:10:44,960 --> 00:10:47,660
‫这给了我们一把枪｡

140
00:10:47,660 --> 00:10:54,410
‫很明显, 这意味着我们可以用各种属性来对付这个参与者, 比如武器的强度,

141
00:10:54,410 --> 00:11:00,980
‫射程等等, 通过在C++中创建新的属性.

142
00:11:00,980 --> 00:11:08,060
‫这就是拥有这种架构的优势, 因为枪可以有一点不同｡

143
00:11:08,060 --> 00:11:15,890
‫我们可以有不同的射击机制, 步枪, 狙击手, RPG, 诸如此类｡

144
00:11:15,890 --> 00:11:17,450
‫所以这很好｡

145
00:11:17,450 --> 00:11:23,720
‫我们也可以有不同的统计, 所以我们可以有一个强大的步枪和一个弱步枪取决于不同的蓝图子类｡

146
00:11:23,750 --> 00:11:24,380
‫很酷的东西｡

147
00:11:24,380 --> 00:11:32,660
‫在下一节课中, 我们会看看如何将这把枪作为我们当前角色的子角色来生成.

148
00:11:32,690 --> 00:11:33,530
‫我会看到你在那里｡