1
00:00:04,380 --> 00:00:05,280
‫Olá e bem-vindo.

2
00:00:05,280 --> 00:00:12,510
‫Nesta palestra, acessaremos os atores sobrepostos em algo chamado array para

3
00:00:12,510 --> 00:00:19,800
‫que possamos imprimir os atores que vemos dentro deste volume inteiramente em C++.

4
00:00:19,800 --> 00:00:21,300
‫Vamos mergulhar e ver como é feito.

5
00:00:22,480 --> 00:00:30,700
‫Assim como nas analogias anteriores, vamos imaginar que um tipo ou uma variável é uma caixa na qual colocamos um valor.

6
00:00:31,150 --> 00:00:35,250
‫Agora, o que acontece se não soubermos quantos valores queremos armazenar?

7
00:00:35,260 --> 00:00:36,640
‫Podemos criar muitas variáveis.

8
00:00:36,640 --> 00:00:39,430
‫Se soubéssemos que teríamos cinco, poderíamos fazer cinco variáveis.

9
00:00:39,700 --> 00:00:45,670
‫Mas e se tivéssemos algo imprevisivelmente muitos, como o número de atores que temos em nosso nível A

10
00:00:46,170 --> 00:00:51,010
‫ou os atores que estão se sobrepondo a um volume de disparo específico?

11
00:00:51,490 --> 00:01:00,130
‫Nesse caso, precisamos usar um novo tipo de dados chamado array T no Unreal e basicamente um array T de um

12
00:01:00,130 --> 00:01:01,200
‫determinado tipo.

13
00:01:01,210 --> 00:01:08,560
‫Aqui, novamente, estamos vendo esses colchetes angulares que são, como dissemos anteriormente, parâmetros de tempo de compilação.

14
00:01:08,980 --> 00:01:14,770
‫E desta vez estamos pegando, novamente, um tipo que está nos dizendo que tipo podemos armazenar um array.

15
00:01:14,770 --> 00:01:21,310
‫Um array é como uma variável, exceto que tem várias caixas e o número de caixas que temos pode

16
00:01:21,670 --> 00:01:22,750
‫ser diferente.

17
00:01:22,750 --> 00:01:23,920
‫Quando estamos jogando.

18
00:01:23,920 --> 00:01:24,910
‫Pode mudar.

19
00:01:24,910 --> 00:01:30,880
‫Podemos adicionar mais ou menos à medida que avançamos no jogo, à medida que as coisas começam a se sobrepor com adicionar mais caixas, à medida

20
00:01:30,880 --> 00:01:33,640
‫que as coisas saem da zona de sobreposição, nós as removemos.

21
00:01:33,880 --> 00:01:37,270
‫E como eu disse, este é um parâmetro dentro destes.

22
00:01:38,270 --> 00:01:39,260
‫Parênteses angulares.

23
00:01:39,680 --> 00:01:45,350
‫E assim poderíamos ter uma matriz T de ints, por exemplo, que armazenaria diferentes inteiros nessas

24
00:01:45,350 --> 00:01:45,980
‫caixas.

25
00:01:46,310 --> 00:01:52,670
‫Poderíamos ter uma matriz t de ponteiros de atores, e isso realmente armazenaria os ponteiros nas caixas,

26
00:01:52,670 --> 00:01:55,610
‫que apontariam para os atores no mundo.

27
00:01:55,940 --> 00:02:01,190
‫E como você pode ver, eles podem até se sobrepor para que alguns desses ponteiros apontem para os mesmos atores.

28
00:02:01,490 --> 00:02:04,580
‫Agora pratique isso não seria muito útil, mas certamente é possível.

29
00:02:04,850 --> 00:02:10,790
‫Então, eu quero revisitar a documentação do seu componente primitivo, porque o

30
00:02:10,790 --> 00:02:16,450
‫que estou procurando aqui é uma função chamada obter atores sobrepostos.

31
00:02:16,460 --> 00:02:20,930
‫E se você der uma olhada na função de obter atores sobrepostos, há algumas versões dela.

32
00:02:21,590 --> 00:02:26,570
‫Mas o que é mais interessante para mim é o segundo.

33
00:02:27,200 --> 00:02:29,030
‫Não tem valor de retorno.

34
00:02:29,030 --> 00:02:30,440
‫É um valor de retorno nulo.

35
00:02:30,440 --> 00:02:38,690
‫Mas você pode ver que o primeiro parâmetro aqui é uma matriz de ponteiros de ator com um e comercial no final,

36
00:02:38,690 --> 00:02:43,640
‫o que significa que tudo isso é uma referência a uma matriz t.

37
00:02:43,640 --> 00:02:46,280
‫Agora observe que não é uma referência constante.

38
00:02:46,700 --> 00:02:51,860
‫Portanto, podemos assumir que esse parâmetro é na verdade um parâmetro de saída.

39
00:02:51,860 --> 00:03:00,050
‫Ele nos dá o resultado dos atores sobrepostos e nos diz quais atores estão atualmente sobrepondo com

40
00:03:00,290 --> 00:03:02,270
‫nossos componentes primitivos.

41
00:03:02,540 --> 00:03:06,500
‫Agora acontece que nosso componente box é um componente primitivo.

42
00:03:06,890 --> 00:03:12,440
‫Então nosso componente de gatilho também é componente de projeto, e eu teria acesso a essa função.

43
00:03:13,490 --> 00:03:18,140
‫Há um segundo argumento aqui, mas não precisamos nos preocupar com isso porque na verdade ele tem um

44
00:03:18,140 --> 00:03:19,520
‫valor padrão se o usarmos.

45
00:03:19,730 --> 00:03:25,820
‫Então vamos em frente e tentar obter e preencher um t array de ponteiros ativos.

46
00:03:26,150 --> 00:03:28,490
‫Vamos entrar no componente do truque, CPP.

47
00:03:28,520 --> 00:03:31,340
‫Vamos descer aos componentes do carrapato.

48
00:03:31,820 --> 00:03:38,150
‫E aqui vamos criar um array t vazio que podemos preencher usando esta função.

49
00:03:38,300 --> 00:03:48,080
‫Portanto, a sintaxe é t array abre colchetes angulares uma estrela de ator para dizer que estamos tendo um array t de ponteiros de

50
00:03:48,080 --> 00:03:55,070
‫ator, feche os colchetes angulares e então podemos dar a essa variável o nome de atores.

51
00:03:55,370 --> 00:04:05,510
‫Em seguida, chamaríamos para obter atores sobrepostos e passaríamos na matriz de atores.

52
00:04:06,650 --> 00:04:06,890
‫Agora.

53
00:04:06,890 --> 00:04:11,630
‫Eu não sei por que eles não apenas passam isso como um valor de retorno, mas.

54
00:04:12,780 --> 00:04:13,380
‫Ai está.

55
00:04:13,380 --> 00:04:18,150
‫Isso nos dá a oportunidade de usar esses nossos parâmetros um pouco mais.

56
00:04:18,330 --> 00:04:19,470
‫Agora, isso é tudo muito bem.

57
00:04:19,500 --> 00:04:22,110
‫Temos alguns atores em uma matriz.

58
00:04:22,650 --> 00:04:24,090
‫Há um comprimento variável deles.

59
00:04:24,090 --> 00:04:25,080
‫Pode haver alguns.

60
00:04:25,080 --> 00:04:26,310
‫Pode haver zero.

61
00:04:26,820 --> 00:04:29,490
‫O que fazemos com arrays como este?

62
00:04:29,640 --> 00:04:33,980
‫Bem, podemos consultar quantos itens estão na matriz.

63
00:04:33,990 --> 00:04:40,980
‫Você pode usar a matriz ponto num parênteses e isso pode retornar um inteiro informando quantos itens estão na

64
00:04:40,980 --> 00:04:41,550
‫matriz.

65
00:04:41,580 --> 00:04:48,570
‫Portanto, neste array em particular, poderíamos dizer que existem cinco, e então podemos acessar os itens

66
00:04:48,570 --> 00:04:51,780
‫dentro desse array usando esses colchetes.

67
00:04:52,410 --> 00:04:55,830
‫E então o número que você passa para os colchetes informa qual item obter.

68
00:04:56,250 --> 00:05:02,610
‫E é uma convenção comum em muitas linguagens de programação que começamos a contar de zero em arrays.

69
00:05:02,940 --> 00:05:09,480
‫Portanto, o elemento zero de um array é o primeiro, o elemento um de um array é o segundo, etc.

70
00:05:09,690 --> 00:05:14,940
‫E assim você acaba com o último elemento sempre sendo um a menos que o número de elementos na matriz.

71
00:05:15,750 --> 00:05:17,490
‫Então, como podemos usar esse conhecimento?

72
00:05:17,550 --> 00:05:24,330
‫Bem, por exemplo, só poderíamos imprimir os atores sobrepostos se houver mais de um deles.

73
00:05:24,690 --> 00:05:26,030
‫Então, como faríamos isso?

74
00:05:26,040 --> 00:05:38,070
‫Nós colocaríamos uma declaração if dizendo que se os atores dot num parênteses for maior que zero, então podemos fazer algo aqui, como obter

75
00:05:38,070 --> 00:05:46,470
‫acesso ao elemento zero dos nossos atores porque sabemos que se for maior que zero, deve haver

76
00:05:46,470 --> 00:05:50,100
‫pelo menos menos um elemento ali.

77
00:05:50,100 --> 00:05:54,480
‫Portanto, os elementos zero deste array devem ter algo dentro.

78
00:05:54,720 --> 00:05:59,880
‫Não podemos garantir que o primeiro elemento, o único elemento do array tenha alguma coisa ou os

79
00:05:59,880 --> 00:06:01,440
‫dois elementos tenham alguma coisa.

80
00:06:01,680 --> 00:06:06,840
‫Teríamos que verificar se temos itens suficientes no array para fazer isso, mas definitivamente sabemos que

81
00:06:06,840 --> 00:06:08,550
‫há o primeiro aqui.

82
00:06:08,730 --> 00:06:12,510
‫Então, vamos desafiá-lo a imprimir o primeiro ator sobreposto desse array.

83
00:06:12,780 --> 00:06:16,470
‫Use a matriz para obter o ponteiro usando esses colchetes.

84
00:06:16,770 --> 00:06:22,200
‫Então você vai usar esse ponteiro para chamar, obter ator, nome ou rótulo, e então você

85
00:06:22,200 --> 00:06:23,280
‫vai imprimir isso.

86
00:06:23,580 --> 00:06:24,870
‫Pause o vídeo e vá em frente.

87
00:06:28,250 --> 00:06:28,570
‫OK.

88
00:06:28,580 --> 00:06:29,390
‫Bem vindo de volta.

89
00:06:29,750 --> 00:06:34,460
‫Então, podemos obter o ponteiro aqui usando esses colchetes.

90
00:06:34,820 --> 00:06:41,090
‫E eu vou pegar o nome direto usando o operador de seta e chamando get

91
00:06:41,240 --> 00:06:43,310
‫ator, nome ou rótulo.

92
00:06:44,180 --> 00:06:50,030
‫E vou colocar isso em uma variável de string F chamada nome do ator.

93
00:06:50,240 --> 00:06:56,480
‫Então vamos fazer um log U, que vamos chamar de dois pontos sobrepostos.

94
00:06:56,480 --> 00:06:58,130
‫E então por cento s.

95
00:06:58,460 --> 00:07:03,440
‫E então o segundo argumento aqui deve ser asterisco, nome do ator.

96
00:07:03,740 --> 00:07:09,470
‫Então podemos recompilar, entrar em nosso registro de saída no layout.

97
00:07:09,620 --> 00:07:16,070
‫Então vamos abrir a parede secreta da BP porque não quero imprimir essa string que confunde

98
00:07:16,070 --> 00:07:17,210
‫as coisas.

99
00:07:17,210 --> 00:07:23,960
‫No Blueprint, estamos fazendo isso agora em C++, então vamos para o jogo de acertos no nível da masmorra.

100
00:07:25,190 --> 00:07:28,430
‫E obviamente nada está se sobrepondo a esse ator agora.

101
00:07:28,820 --> 00:07:31,520
‫Então, o que acontece se entrarmos e entrarmos?

102
00:07:32,060 --> 00:07:36,080
‫Você pode ver que ele começa a imprimir instantaneamente, que estamos sobrepondo o player BP.

103
00:07:36,500 --> 00:07:37,520
‫Coisas fantásticas.

104
00:07:37,820 --> 00:07:40,130
‫E se fôssemos pegar a gárgula em vez disso?

105
00:07:40,370 --> 00:07:43,780
‫Leve-o para a alcova, coloque-o e pronto.

106
00:07:43,790 --> 00:07:46,160
‫Diz que está sobrepondo a estátua da gárgula.

107
00:07:46,700 --> 00:07:47,210
‫Coisas boas.

108
00:07:47,210 --> 00:07:55,280
‫Assim, aprendemos como usar um array t para obter uma lista de atores e descobrir quantas coisas

109
00:07:55,280 --> 00:08:00,770
‫estão nessa lista e como obter um item específico dessa lista.

110
00:08:01,070 --> 00:08:05,600
‫Na próxima aula, veremos algumas estruturas de programação que nos permitem

111
00:08:05,810 --> 00:08:10,520
‫lidar com números variáveis de coisas para realizar um número variável de tarefas.

112
00:08:10,790 --> 00:08:11,600
‫Eu te vejo lá.