﻿1
00:00:04,380 --> 00:00:06,150
‫Olá e bem-vindo de volta.

2
00:00:06,240 --> 00:00:12,150
‫Agora temos movimento para o --, mas não estamos girando a parte superior do --, que estamos chamando

3
00:00:12,150 --> 00:00:12,920
‫de torre.

4
00:00:12,930 --> 00:00:16,290
‫Gostaríamos de poder fazer isso usando nosso mouse.

5
00:00:16,320 --> 00:00:18,800
‫Agora, dê uma olhada no que está acontecendo aqui.

6
00:00:18,810 --> 00:00:23,300
‫Enquanto estou movendo o cursor do mouse pelo mundo, estou recebendo esta esfera vermelha.

7
00:00:23,310 --> 00:00:27,060
‫Esta é uma esfera de depuração que estou desenhando no espaço 3D.

8
00:00:27,300 --> 00:00:33,600
‫Agora observe enquanto eu me movo contra uma parede, essa esfera se move contra a superfície da parede.

9
00:00:33,600 --> 00:00:40,410
‫Então, onde quer que meu cursor do mouse esteja se movendo, estou tendo esse medo que corresponde a qualquer objeto que

10
00:00:40,410 --> 00:00:43,620
‫estou atingindo com base na localização do meu cursor.

11
00:00:43,620 --> 00:00:50,250
‫E isso será útil para nós, para que possamos ter um local no espaço para o qual possamos girar

12
00:00:50,250 --> 00:00:51,200
‫nossa torre.

13
00:00:51,210 --> 00:00:57,570
‫Agora, para fazer isso, existem algumas funções que precisamos no controlador, então temos que acessar essas

14
00:00:57,570 --> 00:00:59,250
‫funções no controlador.

15
00:00:59,250 --> 00:01:04,140
‫E neste vídeo vamos trabalhar na configuração disso e também vamos discutir como

16
00:01:04,140 --> 00:01:07,080
‫isso envolverá um conceito conhecido como elenco.

17
00:01:07,080 --> 00:01:12,330
‫Agora, a razão pela qual queremos o controlador é porque existem funções no controlador que nos permitem

18
00:01:12,330 --> 00:01:14,820
‫obter o resultado do acerto sob o cursor.

19
00:01:14,820 --> 00:01:16,860
‫Agora estamos falando sobre o cursor do mouse.

20
00:01:16,860 --> 00:01:20,310
‫Então digamos que esta é a nossa tela e aqui está o nosso cursor do mouse.

21
00:01:20,310 --> 00:01:25,530
‫E o ponto na ponta do cursor corresponde a um local na tela.

22
00:01:25,530 --> 00:01:31,740
‫Agora, se movermos o cursor, nosso objetivo é que a parte da torre do nosso tanque, a

23
00:01:31,740 --> 00:01:37,290
‫parte superior da nossa malha, gire para que fique voltada para a direção desse cursor.

24
00:01:37,440 --> 00:01:44,370
‫Agora, se movermos o cursor, há uma função no controlador que podemos usar para obter

25
00:01:44,370 --> 00:01:47,190
‫a localização correspondente a esse cursor.

26
00:01:47,190 --> 00:01:52,830
‫Se fôssemos desenhar uma linha reta da câmera em direção ao cursor e acertar algum

27
00:01:52,830 --> 00:01:59,700
‫objeto no mundo, podemos obter esse local e usar esse local para definir a rotação da torre do tanque.

28
00:01:59,730 --> 00:02:00,960
‫Deixe-me mostrar o que quero dizer.

29
00:02:00,960 --> 00:02:06,420
‫Agora, para obter esse local de acerto correspondente ao nosso cursor, precisamos usar o controlador.

30
00:02:06,420 --> 00:02:09,480
‫Agora, vamos falar sobre o controlador por um breve momento.

31
00:02:09,780 --> 00:02:11,880
‫Digamos que temos nosso peão no mundo.

32
00:02:11,880 --> 00:02:13,950
‫Um peão terá um controlador.

33
00:02:14,130 --> 00:02:18,210
‫Este é um objeto invisível que está associado ao peão.

34
00:02:18,210 --> 00:02:24,180
‫Agora, para o nosso peão, nosso controle terá o controle de jogador tipo A e no

35
00:02:24,180 --> 00:02:27,720
‫início do jogo, o controle terá o peão.

36
00:02:27,750 --> 00:02:32,790
‫É por isso que podemos ver do ponto de vista da câmera que pertence ao nosso tanque de peões.

37
00:02:32,790 --> 00:02:34,890
‫Agora podemos acessar este controlador.

38
00:02:34,920 --> 00:02:38,970
‫Nossa classe tank herda uma função chamada Get Controller.

39
00:02:38,970 --> 00:02:41,100
‫É herdado da classe --.

40
00:02:41,100 --> 00:02:46,950
‫Então, o que gostaríamos de fazer é pegar esse controlador e armazená-lo em uma variável para que possamos usá-lo para

41
00:02:46,950 --> 00:02:51,270
‫acessar a função que precisamos para obter o resultado da ocorrência sob o cursor.

42
00:02:51,270 --> 00:02:53,010
‫Então vamos nos preparar para isso.

43
00:02:53,010 --> 00:02:58,650
‫Agora estou aqui na classe tanque e o lugar que precisamos para acessar nosso controle é começar a jogar.

44
00:02:58,680 --> 00:03:05,190
‫Se fizermos isso no construtor, será muito cedo e talvez ainda não tenhamos um controlador válido.

45
00:03:05,190 --> 00:03:08,910
‫Então, vamos precisar da função de início de jogo aqui na classe tanque.

46
00:03:08,910 --> 00:03:14,250
‫Agora temos aqui na classe base pong e até agora não estamos realmente usando begin play na classe

47
00:03:14,250 --> 00:03:15,090
‫base pong.

48
00:03:15,270 --> 00:03:18,450
‫Então, o que eu gostaria de fazer é movê-lo para a classe tanque.

49
00:03:18,450 --> 00:03:24,150
‫Então, vou destacar começar a jogar, incluindo o comentário e a seção protegida aqui e

50
00:03:24,150 --> 00:03:25,500
‫vou simplesmente cortá-la.

51
00:03:25,500 --> 00:03:28,710
‫E então, de volta ao estágio do tanque, vou colá-lo.

52
00:03:28,710 --> 00:03:33,960
‫Vamos adicionar esta seção protegida aqui logo acima da seção privada com o início da reprodução dentro.

53
00:03:33,960 --> 00:03:36,270
‫Agora removemos o Begin Play do peão base.

54
00:03:36,840 --> 00:03:41,430
‫Não o temos mais aqui, mas também precisamos removê-lo do cpp da base pond.

55
00:03:41,460 --> 00:03:42,240
‫Aqui está.

56
00:03:42,240 --> 00:03:48,960
‫Podemos ir em frente e excluí-lo aqui e agora o declaramos aqui no tanque H, mas também

57
00:03:48,960 --> 00:03:51,330
‫precisamos defini-lo no tanque CPP.

58
00:03:51,360 --> 00:03:55,830
‫Então, vou definir a função logo abaixo do componente de entrada do player de configuração.

59
00:03:55,830 --> 00:04:00,660
‫Portanto, será void start play sem parâmetros de entrada.

60
00:04:00,870 --> 00:04:06,840
‫Há o corpo da função e também precisamos de um tanque pré-fixando o nome da função.

61
00:04:06,840 --> 00:04:09,930
‫Agora sabemos que é importante fazer call super big em jogo.

62
00:04:09,930 --> 00:04:16,320
‫Dessa forma, qualquer funcionalidade na função begin play e qualquer uma das classes pai ainda serão

63
00:04:16,320 --> 00:04:17,010
‫chamadas.

64
00:04:17,340 --> 00:04:18,960
‫Então aqui nós começamos o jogo.

65
00:04:18,990 --> 00:04:22,560
‫É aqui que podemos obter nosso controlador e armazená-lo em uma variável.

66
00:04:22,560 --> 00:04:25,920
‫Então vamos voltar ao Tank H e criar uma variável.

67
00:04:25,920 --> 00:04:30,750
‫Agora isso será privado e eu vou colocá-lo aqui na parte inferior

68
00:04:30,750 --> 00:04:38,460
‫da seção privada e será um tipo de ponteiro de controlador de jogador e podemos chamar esse controlador de jogador ref.

69
00:04:38,460 --> 00:04:40,920
‫Esta será nossa referência ao controlador do player.

70
00:04:40,950 --> 00:04:43,590
‫Agora não estamos falando de uma referência C++.

71
00:04:43,590 --> 00:04:48,750
‫Isso ainda é apenas um ponteiro, mas vamos usar isso para nos referirmos ao controlador do player.

72
00:04:48,750 --> 00:04:55,560
‫Então agora temos uma variável player controller ref do tipo A player controller e estamos prontos para

73
00:04:55,590 --> 00:04:57,600
‫armazenar o controlador neste ponteiro.

74
00:04:57,600 --> 00:05:02,730
‫Então vamos voltar ao Tank Dot CP aqui e começar a jogar e tentar fazer isso.

75
00:05:02,730 --> 00:05:03,330
‫Então.

76
00:05:03,400 --> 00:05:12,100
‫O que vou fazer é dizer player, controller, ref equals e vou tentar chamar get controller.

77
00:05:12,880 --> 00:05:17,440
‫Agora pegue o controlador, como mencionei, está na classe --.

78
00:05:17,470 --> 00:05:24,070
‫Vamos clicar com o botão direito e ir para a definição e notar que esta função retorna um controlador A.

79
00:05:24,100 --> 00:05:29,020
‫Agora nossa variável é do tipo A player controller, não um controller.

80
00:05:29,020 --> 00:05:35,260
‫Então, o que estamos tentando fazer aqui é pegar o valor de retorno de get controller, que é do tipo

81
00:05:35,260 --> 00:05:40,270
‫de ponteiro de controlador e estamos tentando armazená-lo em um ponteiro de controlador de jogador A.

82
00:05:40,300 --> 00:05:42,330
‫Observe que vemos o rabisco vermelho aqui.

83
00:05:42,340 --> 00:05:43,940
‫Diz um valor do tipo.

84
00:05:43,960 --> 00:05:48,080
‫Um ponteiro de controlador não pode ser atribuído a uma entidade do tipo.

85
00:05:48,100 --> 00:05:49,630
‫Um controlador de jogador.

86
00:05:49,660 --> 00:05:51,210
‫Estamos recebendo um erro.

87
00:05:51,220 --> 00:05:55,390
‫Vamos dar uma olhada aqui na documentação de um controlador.

88
00:05:55,420 --> 00:05:56,400
‫Dê uma olhada.

89
00:05:56,410 --> 00:05:58,030
‫Aqui está um controlador.

90
00:05:58,030 --> 00:06:00,460
‫E diz herança, hierarquia.

91
00:06:00,460 --> 00:06:05,690
‫E abaixo de um controlador, vemos um controlador e um controlador de jogador.

92
00:06:05,710 --> 00:06:10,210
‫Isso significa que um controlador de jogador é uma classe filha de um controlador.

93
00:06:10,240 --> 00:06:14,500
‫Agora, em C++, não podemos ter um ponteiro de tipo.

94
00:06:14,530 --> 00:06:20,200
‫Um controlador de jogador armazena o valor do endereço de um controlador A.

95
00:06:20,530 --> 00:06:22,600
‫Um controlador é o tipo pai.

96
00:06:22,780 --> 00:06:25,450
‫Um controlador de jogador é do tipo filho.

97
00:06:25,450 --> 00:06:30,960
‫Você não pode pegar um objeto do tipo pai e armazená-lo em um ponteiro do tipo filho.

98
00:06:30,970 --> 00:06:32,680
‫Então, como vamos contornar isso?

99
00:06:32,680 --> 00:06:34,000
‫Então aqui está o nosso problema.

100
00:06:34,000 --> 00:06:38,630
‫A função get controller retorna o endereço de um controller A.

101
00:06:38,650 --> 00:06:44,410
‫Agora, isso é algo que poderíamos armazenar em um ponteiro de controlador A, mas não podemos armazená-lo em um ponteiro de controlador

102
00:06:44,410 --> 00:06:45,410
‫de jogador A.

103
00:06:45,430 --> 00:06:52,000
‫O engraçado, porém, é que o objeto retornado por get controller é na verdade um player controller.

104
00:06:52,000 --> 00:06:58,630
‫Portanto, temos esse endereço na forma de um ponteiro de controlador A e sabemos que ele armazena um controlador de player, mas se

105
00:06:58,630 --> 00:07:03,910
‫o tivermos na forma de um controlador A, não podemos acessar a função de que precisamos porque ela

106
00:07:03,910 --> 00:07:06,210
‫existe em um controlador de player .

107
00:07:06,220 --> 00:07:08,810
‫A função é chamada obter resultado de acerto sob o cursor.

108
00:07:08,830 --> 00:07:15,250
‫Agora, se tivermos um valor de ponteiro de controlador do tipo A e tentarmos obter essa função que existe

109
00:07:15,250 --> 00:07:18,430
‫em um controlador de jogador, não conseguiremos fazê-lo.

110
00:07:18,460 --> 00:07:20,020
‫Receberemos um erro de compilação.

111
00:07:20,020 --> 00:07:25,960
‫Então, como sabemos que o próprio objeto é um controlador de jogador, ele é armazenado apenas em um ponteiro de controlador A.

112
00:07:25,960 --> 00:07:27,610
‫Como contornamos esse problema?

113
00:07:27,610 --> 00:07:29,980
‫A resposta é que temos que lançar.

114
00:07:30,010 --> 00:07:36,100
‫Sabemos que um controlador é a classe pai e um controlador de jogador é a classe filha.

115
00:07:36,100 --> 00:07:41,320
‫E sabemos que não podemos ter um controlador A armazenado em um ponteiro de controlador de jogador A.

116
00:07:41,320 --> 00:07:46,750
‫Sabemos que podemos fazer o contrário e ter um armazenamento de ponteiro de controlador A, um objeto de um controlador

117
00:07:46,750 --> 00:07:47,530
‫de jogador.

118
00:07:47,620 --> 00:07:53,290
‫Na verdade, é isso que estamos vendo quando chamamos get controller, ele retorna um ponteiro de controlador A que aponta

119
00:07:53,290 --> 00:07:55,120
‫para um controlador de jogador A.

120
00:07:55,120 --> 00:08:01,810
‫Portanto, se tivermos um valor de ponteiro de controlador do tipo A, podemos usar uma função especial chamada cast para converter

121
00:08:01,810 --> 00:08:05,920
‫o tipo do ponteiro em um ponteiro de controlador de jogador A.

122
00:08:05,920 --> 00:08:13,720
‫Assim, a conversão altera o tipo de um ponteiro para outro tipo de ponteiro, desde que o próprio objeto seja o tipo para

123
00:08:13,720 --> 00:08:15,640
‫o qual estamos tentando converter.

124
00:08:15,670 --> 00:08:21,430
‫Agora, se tentarmos converter para um tipo inválido, por exemplo, temos um ponteiro de controlador A apontando para

125
00:08:21,430 --> 00:08:23,140
‫um objeto controlador de jogador.

126
00:08:23,140 --> 00:08:30,070
‫Se tentarmos converter para dizer um caractere, a função cast retorna null e dizemos que falhamos na

127
00:08:30,070 --> 00:08:30,820
‫conversão.

128
00:08:30,820 --> 00:08:33,160
‫Portanto, a função de conversão se parece com isso.

129
00:08:33,190 --> 00:08:36,790
‫É um modelo como criar um subobjeto padrão.

130
00:08:36,790 --> 00:08:42,850
‫Esta função de modelo irá se adaptar ao tipo escolhido e nesta função, o tipo que passamos é o tipo

131
00:08:42,850 --> 00:08:44,230
‫que estamos lançando também.

132
00:08:44,230 --> 00:08:45,400
‫Então passamos esse tipo.

133
00:08:45,400 --> 00:08:51,700
‫Gostaríamos de lançar dois dentro dos colchetes angulares e passamos o ponteiro que gostaríamos de lançar

134
00:08:51,700 --> 00:08:52,570
‫entre parênteses.

135
00:08:52,570 --> 00:08:53,710
‫Aqui está um exemplo.

136
00:08:53,710 --> 00:08:59,410
‫Digamos que gostaríamos de transmitir para um controlador de jogador e um ponteiro do tipo de controlador tipo A.

137
00:08:59,410 --> 00:09:04,240
‫Passamos o ponteiro para os parênteses e o tipo para o qual estamos convertendo nos colchetes angulares.

138
00:09:04,240 --> 00:09:08,590
‫E o que é retornado é um valor do tipo A ponteiro do controlador do jogador.

139
00:09:08,590 --> 00:09:13,720
‫Então aqui está a chamada de função onde estamos passando o tipo entre colchetes angulares e o

140
00:09:13,720 --> 00:09:18,550
‫valor do ponteiro do controlador A que retornamos do controlador get pode ir entre parênteses.

141
00:09:18,550 --> 00:09:22,630
‫Portanto, precisamos lançar esse valor que estamos retornando do controlador get.

142
00:09:22,630 --> 00:09:24,250
‫Esse vai ser o seu desafio.

143
00:09:24,250 --> 00:09:31,840
‫Portanto, em Begin Play, use a função get controller e passe esse valor para a função cast e transmita para

144
00:09:31,840 --> 00:09:33,550
‫um controlador de jogador.

145
00:09:33,550 --> 00:09:39,490
‫E então você pode armazenar o resultado em nosso ponteiro ref do controlador do player, que é do tipo A ponteiro do controlador

146
00:09:39,490 --> 00:09:40,120
‫do player.

147
00:09:40,120 --> 00:09:42,580
‫Pause o vídeo e execute o elenco.

148
00:09:45,530 --> 00:09:45,860
‫OK.

149
00:09:45,860 --> 00:09:49,570
‫Então nós temos quase todo o trabalho feito aqui, só precisamos lançar.

150
00:09:49,580 --> 00:09:56,000
‫Então, o que vamos fazer é chamar a função cast, que tem colchetes angulares e parênteses.

151
00:09:56,000 --> 00:09:59,990
‫E o que vai entre parênteses é o valor que gostaríamos de lançar.

152
00:09:59,990 --> 00:10:05,060
‫Agora get controller retorna um ponteiro do tipo A controller.

153
00:10:05,060 --> 00:10:07,850
‫Vou mover isso aqui para os parênteses.

154
00:10:07,850 --> 00:10:12,110
‫E o tipo para o qual estamos lançando é um controlador de jogador.

155
00:10:14,050 --> 00:10:17,620
‫Então, novamente estamos pegando o valor retornado por get comptroller.

156
00:10:17,620 --> 00:10:21,160
‫Isso retorna um ponteiro de controlador ou um endereço.

157
00:10:21,160 --> 00:10:25,000
‫Então estamos usando o cast para lançá-lo para um controlador de jogador A.

158
00:10:25,000 --> 00:10:31,330
‫Sabemos que o objeto retornado pelo controlador de portão é um objeto controlador de jogador A armazenado em um ponteiro

159
00:10:31,330 --> 00:10:32,320
‫de controlador A.

160
00:10:32,320 --> 00:10:38,500
‫Então, depois de lançarmos isso, o que é retornado é um ponteiro do controlador de jogador tipo A.

161
00:10:38,500 --> 00:10:41,410
‫Então, estamos armazenando isso no controlador do player ref.

162
00:10:41,410 --> 00:10:46,990
‫Agora que temos acesso ao controlador na forma de um ponteiro de controlador de jogador A, podemos acessar a função

163
00:10:46,990 --> 00:10:50,830
‫que precisamos para obter o resultado de acerto do rastreamento sob o cursor.

164
00:10:50,830 --> 00:10:55,570
‫Então, em resumo, usamos o controlador get para obter acesso ao controlador.

165
00:10:55,930 --> 00:11:03,040
‫Também usamos a função cast para converter do ponteiro do controlador do tipo A para o ponteiro do controlador do jogador do tipo

166
00:11:03,040 --> 00:11:03,670
‫A.

167
00:11:03,670 --> 00:11:10,000
‫Agora podemos acessar a função que precisamos, que é obter resultados de acertos sob o cursor que existe na classe de

168
00:11:10,000 --> 00:11:11,290
‫controlador de jogador A.

169
00:11:11,290 --> 00:11:14,500
‫Então vamos começar a usar esta função no próximo vídeo.

170
00:11:14,860 --> 00:11:15,850
‫Vejo você em breve.

