1
00:00:04,350 --> 00:00:05,340
‫你好, 欢迎｡

2
00:00:05,340 --> 00:00:12,540
‫在这节课中, 我们将访问数组中的重叠参与者,

3
00:00:12,540 --> 00:00:19,860
‫这样我们就可以打印出, 在这本书中, 我们看到的, 完全来自C++的参与者｡

4
00:00:19,860 --> 00:00:21,510
‫让我们来看看它是如何完成的｡

5
00:00:22,420 --> 00:00:30,970
‫因此, 就像前面的类比一样, 让我们想象一个类型或变量是一个盒子, 我们在里面放了一个值｡

6
00:00:31,000 --> 00:00:35,290
‫现在, 如果我们不知道要存储多少个值, 会发生什么？

7
00:00:35,290 --> 00:00:36,670
‫我们可能会制造很多变数｡

8
00:00:36,670 --> 00:00:39,610
‫如果我们知道我们有五个变量, 我们可能会有五个变量｡

9
00:00:39,610 --> 00:00:45,910
‫但是, 如果我们有一些不可预测的东西, 比如我们的水平中的参与者的数量,

10
00:00:46,540 --> 00:00:51,220
‫或者与特定触发音量重叠的参与者的数量, 会怎么样？

11
00:00:51,370 --> 00:01:01,270
‫在这种情况下, 我们需要在Unreal中使用一种新的数据类型, 称为T数组, 基本上是一种特定类型的T数组｡

12
00:01:01,270 --> 00:01:08,860
‫在这里, 我们再次看到这些尖括号, 正如我们之前所说的, 它们是编译时参数｡

13
00:01:08,860 --> 00:01:14,800
‫这一次, 我们再次引入了一个类型, 它告诉我们什么类型可以存储在数组中｡

14
00:01:14,800 --> 00:01:21,520
‫数组就像一个变量, 只不过它有多个盒子, 而且在我们玩游戏的时候,

15
00:01:21,550 --> 00:01:23,980
‫盒子的数量可能会有所不同.

16
00:01:23,980 --> 00:01:24,940
‫它可以改变｡

17
00:01:24,940 --> 00:01:28,330
‫我们可以增加或减少, 因为我们通过游戏｡

18
00:01:28,330 --> 00:01:32,650
‫当事物开始重叠时, 我们会添加更多的框, 作为离开重叠区域的事物｡

19
00:01:32,650 --> 00:01:33,850
‫我们会把他们带走｡

20
00:01:33,850 --> 00:01:37,510
‫正如我所说, 这是其中的一个参数｡

21
00:01:38,300 --> 00:01:39,560
‫尖括号｡

22
00:01:39,560 --> 00:01:46,190
‫我们可以有一个整数托盘, 比如说, 它可以在这些盒子里存储不同的整数｡

23
00:01:46,190 --> 00:01:55,880
‫我们可以有一个演员指针的托盘, 这实际上会把指针存储在盒子里, 这些盒子会指向世界上的演员｡

24
00:01:55,880 --> 00:01:57,740
‫如你所见, 它们甚至可以重叠｡

25
00:01:57,740 --> 00:02:01,430
‫所以这些指针中的一些指向相同的演员｡

26
00:02:01,460 --> 00:02:04,760
‫现在, 在实践中, 这可能不是很有用, 但它肯定是可能的｡

27
00:02:04,760 --> 00:02:11,450
‫所以我想回顾一下原始组件的文档, 因为我在这里要找的是一个名为get overlapping

28
00:02:11,450 --> 00:02:16,490
‫actors的函数｡

29
00:02:16,490 --> 00:02:21,170
‫如果你看一下get overlapping actors函数, 它有几个版本｡

30
00:02:21,530 --> 00:02:26,810
‫但我最感兴趣的是第二个｡

31
00:02:27,170 --> 00:02:30,470
‫它没有返回值, 是一个void返回值｡

32
00:02:30,470 --> 00:02:38,750
‫但是你可以看到这里的第一个参数是一个演员指针的t数组, 末尾有一个&号,

33
00:02:38,750 --> 00:02:43,700
‫这意味着整个数组都是对t数组的引用｡

34
00:02:43,700 --> 00:02:51,950
‫现在请注意, 它不是一个常量引用, 因此我们可以假设该参数实际上是一个out参数｡

35
00:02:51,950 --> 00:03:02,450
‫它给我们重叠的参与者的结果, 它告诉我们哪些参与者当前与我们的原始组件重叠｡

36
00:03:02,450 --> 00:03:06,740
‫现在, 我们的盒子组件恰好是一个基本组件｡

37
00:03:06,740 --> 00:03:09,890
‫因此, 我们的触发器组件也是一个基元组件｡

38
00:03:09,890 --> 00:03:12,680
‫谁能使用这个功能？

39
00:03:13,460 --> 00:03:19,670
‫这里还有第二个参数, 但我们不用担心这个, 因为如果我们使用它, 它实际上有一个默认值｡

40
00:03:19,670 --> 00:03:26,120
‫让我们继续, 尝试获取并填充一个演员指针托盘｡

41
00:03:26,120 --> 00:03:27,710
‫我们将进入触发器组件｡

42
00:03:27,710 --> 00:03:31,610
‫下面我们来看看价格点的组成部分｡

43
00:03:31,700 --> 00:03:38,270
‫在这里我们要创建一个空的t数组, 我们可以用这个函数填充它｡

44
00:03:38,270 --> 00:03:48,170
‫它的语法是, t数组, 开尖括号, 一个演员, 星号,

45
00:03:48,170 --> 00:03:55,310
‫表示我们有一个演员指针的t数组, 闭尖括号, 然后我们可以给予这个变量命名为演员｡

46
00:03:55,310 --> 00:04:05,780
‫然后, 我们会呼叫以取得重叠的演员, 并传入演员数组｡

47
00:04:06,590 --> 00:04:06,950
‫现在就去

48
00:04:06,950 --> 00:04:11,900
‫我不知道他们为什么不把这个作为返回值传递出去, 但是｡

49
00:04:12,840 --> 00:04:13,450
‫你去那里｡

50
00:04:13,470 --> 00:04:18,340
‫这给了我们一个机会来更多地使用这些参数｡

51
00:04:18,360 --> 00:04:19,530
‫现在, 这一切都很好｡

52
00:04:19,530 --> 00:04:22,350
‫我们有一些演员在一个数组｡

53
00:04:22,710 --> 00:04:24,120
‫它们的长度是可变的｡

54
00:04:24,120 --> 00:04:25,140
‫可能会有不少｡

55
00:04:25,140 --> 00:04:26,520
‫可能是零｡

56
00:04:26,730 --> 00:04:29,670
‫我们如何处理这样的数组？

57
00:04:29,670 --> 00:04:34,020
‫我们可以查询数组中有多少项｡

58
00:04:34,020 --> 00:04:41,610
‫可以使用array, dot num圆括号和, 可以返回一个整数, 告诉您数组中有多少项｡

59
00:04:41,610 --> 00:04:52,020
‫所以在这个数组中我们可以说有五个然后我们可以用这些方括号来访问数组中的项.

60
00:04:52,410 --> 00:04:56,100
‫然后你传递到方括号里的数字告诉你要得到哪一项｡

61
00:04:56,100 --> 00:05:02,820
‫在很多编程语言中, 我们通常都是从零开始计数｡

62
00:05:02,820 --> 00:05:09,630
‫所以数组的第零个元素是第一个, 数组的第一个元素是第二个, 依此类推｡

63
00:05:09,630 --> 00:05:15,180
‫所以最后一个元素总是比数组中的元素数少一.

64
00:05:15,660 --> 00:05:17,640
‫那么我们如何利用这些知识呢？

65
00:05:17,640 --> 00:05:24,540
‫例如, 如果有多个参与者, 我们只能打印重叠的参与者｡

66
00:05:24,540 --> 00:05:26,070
‫那么我们该怎么做呢？

67
00:05:26,070 --> 00:05:38,130
‫我们会放一个if语句, 如果actor的点数字括号大于零, 那么我们可以在这里做一些事情, 比如访问actor的零元素,

68
00:05:38,130 --> 00:05:50,130
‫因为我们知道如果它大于零, 那么这里至少有一个元素.

69
00:05:50,130 --> 00:05:54,690
‫所以这个数组的第0个元素必须在中有｡

70
00:05:54,690 --> 00:06:01,620
‫我们不能保证数组的第一个元素, 一个元素, 或者两个元素, 都在.

71
00:06:01,620 --> 00:06:08,700
‫我们必须检查数组中是否有足够的项来完成这个操作, 但我们肯定知道这里有第一个项｡

72
00:06:08,700 --> 00:06:12,690
‫因此, 让我们挑战您打印该数组中的第一个重叠参与者｡

73
00:06:12,720 --> 00:06:16,680
‫使用数组来取得使用那些方括号的指标｡

74
00:06:16,680 --> 00:06:22,290
‫然后你要用那个指针来调用, 得到演员, 名字或标签, 然后你要打印出来,

75
00:06:22,290 --> 00:06:25,140
‫暂停视频, 然后开始｡

76
00:06:28,340 --> 00:06:29,650
‫欢迎回来

77
00:06:29,660 --> 00:06:34,730
‫所以我们可以用方括号把指针放在这里｡

78
00:06:34,730 --> 00:06:41,300
‫然后我会直接得到这个名字, 通过使用箭头操作符, 调用get actor,

79
00:06:41,300 --> 00:06:43,610
‫name或者label.

80
00:06:44,090 --> 00:06:50,210
‫我会把它放在一个F字符串变量中, 名为actor name.

81
00:06:50,210 --> 00:06:56,510
‫然后我们要做一个U对数, 我们称之为重叠的冒号｡

82
00:06:56,510 --> 00:06:58,390
‫然后是% s｡

83
00:06:58,400 --> 00:07:03,740
‫第二个参数应该是星号, 演员名字｡

84
00:07:03,740 --> 00:07:09,650
‫然后我们可以重新编译, 跳转到布局中的输出日志摘要｡

85
00:07:09,650 --> 00:07:17,270
‫然后我们要打开BPP的秘密墙因为我不想打印这个字符串, 这会把事情搞混｡

86
00:07:17,270 --> 00:07:24,230
‫在Blueprint中, 我们现在从C++开始, 所以让我们进入到地牢级别的热门玩法｡

87
00:07:25,160 --> 00:07:28,700
‫很明显, 现在没有什么能和那个演员重叠｡

88
00:07:28,700 --> 00:07:31,850
‫如果我们进去会发生什么？

89
00:07:31,940 --> 00:07:36,320
‫你可以看到它立即开始打印, 我们正在重叠哔哔声播放器｡

90
00:07:36,560 --> 00:07:37,760
‫很棒的东西｡

91
00:07:37,760 --> 00:07:40,370
‫如果我们去找石像鬼呢？

92
00:07:40,370 --> 00:07:43,820
‫把它拿到壁龛里, 插进去就行了｡

93
00:07:43,820 --> 00:07:46,400
‫上面说它和石像鬼雕像重叠了｡

94
00:07:46,670 --> 00:07:47,270
‫好东西｡

95
00:07:47,270 --> 00:07:55,340
‫我们已经学会了如何使用t数组来得到一个参与者列表, 找出列表中有多少项,

96
00:07:55,340 --> 00:08:00,980
‫以及如何从列表中获取特定项｡

97
00:08:00,980 --> 00:08:05,750
‫在下一节课中,

98
00:08:05,750 --> 00:08:10,790
‫我们会学习一些编程结构, 这些结构允许我们处理不同数量的事情, 来完成不同数量的任务｡

99
00:08:10,790 --> 00:08:11,870
‫我会看到你在那里｡