1
00:00:04,120 --> 00:00:04,510
‫Ei.

2
00:00:04,510 --> 00:00:05,440
‫Bem vindo de volta.

3
00:00:05,470 --> 00:00:11,740
‫Agora nos configuramos com uma função de retorno de chamada vinculada ao delegado para receber qualquer dano.

4
00:00:11,830 --> 00:00:16,210
‫E o último passo é realmente gerar esse evento de dano.

5
00:00:16,210 --> 00:00:19,690
‫E queremos fazer isso quando nosso projétil atingir alguma coisa.

6
00:00:19,690 --> 00:00:25,540
‫Uma vez que transmitimos para este delegado, podemos aplicar danos à coisa que atingimos.

7
00:00:25,540 --> 00:00:32,110
‫E vamos transmitir este evento usando dano aplicado, que pertence à classe de estática do

8
00:00:32,110 --> 00:00:32,830
‫jogo.

9
00:00:32,860 --> 00:00:36,310
‫Então, vamos dar uma olhada na função de dano aplicado.

10
00:00:36,400 --> 00:00:44,050
‫Agora aqui está a documentação para dano aplicado que diz que fere o ator especificado com dano genérico.

11
00:00:44,050 --> 00:00:47,590
‫Portanto, esta é uma função genérica para aplicar danos.

12
00:00:47,590 --> 00:00:52,510
‫E o que fazemos em resposta à transmissão para este delegado depende de nós.

13
00:00:52,540 --> 00:00:59,140
‫Agora aqui vemos que precisamos incluir a estática do jogo e na sintaxe vemos vários parâmetros de entrada.

14
00:00:59,140 --> 00:01:02,110
‫Agora nós realmente temos alguma descrição dos parâmetros.

15
00:01:02,110 --> 00:01:08,290
‫Se continuarmos rolando para baixo, vemos que o ator danificado está bem, o ator que

16
00:01:08,290 --> 00:01:13,660
‫sofrerá dano base é o dano base para aplicar documentação realmente descritiva aqui.

17
00:01:13,690 --> 00:01:14,170
‫Obrigado.

18
00:01:14,170 --> 00:01:19,930
‫O instigador do evento épico é o controlador responsável por causar esse dano.

19
00:01:19,930 --> 00:01:23,020
‫E diz, por exemplo, o jogador que disparou a arma.

20
00:01:23,020 --> 00:01:26,260
‫Quando diz jogador, está se referindo a esse controlador.

21
00:01:26,260 --> 00:01:31,120
‫Então temos o causador do dano, que é o ator que realmente causou o dano.

22
00:01:31,120 --> 00:01:33,160
‫Diz a granada que explodiu.

23
00:01:33,160 --> 00:01:35,980
‫No nosso caso, será o projétil que explodiu.

24
00:01:35,980 --> 00:01:43,000
‫E finalmente, temos a classe do tipo de dano, que é uma classe que descreve o dano que foi feito.

25
00:01:43,000 --> 00:01:49,690
‫Agora, voltando à seção de sintaxe, podemos ver os tipos dessas entradas e vemos que a classe do tipo de

26
00:01:49,690 --> 00:01:56,350
‫dano é uma subclasse de e vimos antes que a subclasse TW de satisfará um parâmetro de entrada da classe

27
00:01:56,350 --> 00:01:57,550
‫do tipo U.

28
00:01:57,550 --> 00:02:03,730
‫Bem, quando chamamos aplicar dano, podemos passar uma classe U representando o tipo de dano que gostaríamos de

29
00:02:03,730 --> 00:02:04,360
‫usar.

30
00:02:04,360 --> 00:02:09,280
‫Então, falaremos sobre como vamos satisfazer esse parâmetro de entrada em um momento.

31
00:02:09,280 --> 00:02:15,190
‫Portanto, a função de estática do jogo de matiz, o dano aplicado, exigirá alguns parâmetros de entrada.

32
00:02:15,190 --> 00:02:20,920
‫Então, vamos criar uma estratégia sobre como vamos passar os valores apropriados quando chamamos essa

33
00:02:20,920 --> 00:02:24,100
‫função, vimos que primeiro precisamos do ator danificado.

34
00:02:24,310 --> 00:02:30,220
‫Bem, vamos voltar ao CP do projétil, onde gostaríamos de chamar o dano aplicado.

35
00:02:30,220 --> 00:02:34,660
‫Gostaríamos de fazer isso aqui no acerto e não precisamos mais desses logs.

36
00:02:34,660 --> 00:02:42,190
‫Então, vou simplesmente removê-los e observar que nosso retorno de chamada on hit recebe algumas entradas passadas uma vez

37
00:02:42,190 --> 00:02:43,450
‫que é chamado.

38
00:02:43,450 --> 00:02:49,240
‫Quando o delegado de hit do componente on é transmitido, veremos que temos outro ator.

39
00:02:49,240 --> 00:02:55,930
‫Então temos acesso ao ator que foi atingido pelo projétil e este é o ator que gostaríamos

40
00:02:55,940 --> 00:02:56,740
‫de danificar.

41
00:02:56,740 --> 00:02:59,320
‫Então isso cuida do primeiro parâmetro de entrada.

42
00:02:59,320 --> 00:03:01,390
‫Vai ser aquele outro ator.

43
00:03:01,390 --> 00:03:07,990
‫Em seguida, precisamos da quantidade de dano, o que significa que nosso projétil deve ter uma variável de

44
00:03:07,990 --> 00:03:10,360
‫dano para sabermos quanto dano aplicar.

45
00:03:10,510 --> 00:03:17,650
‫Então, por que não entramos no FX do projétil e adicionamos uma variável de dano e isso pode ser um float.

46
00:03:17,650 --> 00:03:23,770
‫Então, podemos simplesmente chamar esse dano e inicializá-lo com um valor, digamos algo como 50 F

47
00:03:24,040 --> 00:03:29,890
‫e, como isso é algo que provavelmente gostaríamos de experimentar, podemos dar a isso uma propriedade

48
00:03:29,890 --> 00:03:32,860
‫U para expô-lo e editá-lo qualquer lugar.

49
00:03:32,860 --> 00:03:37,780
‫Então agora temos uma quantidade de dano para passar quando chamamos de receber dano.

50
00:03:38,080 --> 00:03:44,140
‫Agora o próximo parâmetro é o instigator e vimos que este é do tipo A controller.

51
00:03:44,140 --> 00:03:46,870
‫Então, como vamos obter o controlador?

52
00:03:46,870 --> 00:03:53,470
‫Bem, vimos que podemos obter o proprietário de um componente específico com a função get owner.

53
00:03:53,470 --> 00:04:00,820
‫E isso retorna o ator que possui um determinado componente, esses projéteis estão sendo gerados dinamicamente.

54
00:04:00,820 --> 00:04:06,640
‫Portanto, precisamos ter certeza de que, se vamos chamar get owner, que o owner está definido agora, estamos

55
00:04:06,640 --> 00:04:08,410
‫gerando isso do peão base.

56
00:04:08,410 --> 00:04:10,390
‫Então, se formos para o peão base.

57
00:04:10,600 --> 00:04:18,880
‫CP Aqui está a linha onde estamos gerando o ator, mas Spawn Actor também retorna um ponteiro para o ator que foi

58
00:04:18,880 --> 00:04:22,690
‫gerado para que possamos armazenar isso em uma variável local.

59
00:04:22,690 --> 00:04:29,220
‫Por exemplo, poderíamos dizer auto projétil e atribuir o valor retornado do ator de desova.

60
00:04:29,230 --> 00:04:35,770
‫Agora, se você não estiver familiarizado com auto, ele permite que o compilador descubra o tipo a ser atribuído a

61
00:04:35,770 --> 00:04:36,790
‫essa nova variável.

62
00:04:36,790 --> 00:04:42,620
‫Se você passar o mouse sobre ele, verá que ele tem o ponteiro de projétil do tipo A porque é

63
00:04:42,670 --> 00:04:45,610
‫isso que estamos assinando na função de ator de desova.

64
00:04:45,610 --> 00:04:52,960
‫Então isso é o mesmo que se tivéssemos colocado um ponteiro de projétil bem aqui e agora podemos acessar

65
00:04:52,960 --> 00:04:54,400
‫esse projétil recém-gerado.

66
00:04:54,400 --> 00:04:57,820
‫E a razão pela qual queremos fazer isso é que gostaríamos de definir seu proprietário.

67
00:04:57,820 --> 00:05:02,710
‫Gostaríamos de ter certeza de que seu dono está definido para o peão que o gerou.

68
00:05:02,920 --> 00:05:04,930
‫Então podemos dizer projétil.

69
00:05:04,930 --> 00:05:08,010
‫E há uma função para isso chamada proprietário do conjunto.

70
00:05:08,020 --> 00:05:15,400
‫O dono do set pega um ator e vamos passar isso para que sempre que um de nossos peões gerar um

71
00:05:15,400 --> 00:05:18,250
‫projétil, ele definirá o dono desse projétil.

72
00:05:18,250 --> 00:05:23,380
‫Dessa forma, se alguma vez chamarmos get owner mais adiante, obteremos a instância da

73
00:05:23,380 --> 00:05:25,700
‫classe que possui esse projétil.

74
00:05:25,720 --> 00:05:33,190
‫Então, aqui no DHCP do projétil, temos nossa chamada de função get owner e podemos armazenar isso em uma variável

75
00:05:33,190 --> 00:05:33,910
‫local.

76
00:05:33,940 --> 00:05:40,600
‫Vou seguir em frente e usar auto novamente e chamar isso de meu proprietário e configurá-lo para o resultado retornado por

77
00:05:40,600 --> 00:05:41,590
‫get proprietário.

78
00:05:41,920 --> 00:05:47,570
‫Então agora temos um ponteiro de ator local que armazena o valor do proprietário.

79
00:05:47,590 --> 00:05:52,190
‫Agora podemos acessar o controlador instigador deste ator.

80
00:05:52,210 --> 00:05:57,640
‫Agora, antes de fazermos isso, é uma boa ideia verificar se meu proprietário não é nulo.

81
00:05:57,640 --> 00:06:04,460
‫Então eu vou dizer se meu dono é null igual a ponteiro nulo, então eu vou simplesmente retornar.

82
00:06:04,480 --> 00:06:09,640
‫Agora, se você está se o corpo tem uma única instrução como esta, você pode colocá-la na mesma linha

83
00:06:09,640 --> 00:06:11,890
‫sem as chaves caso você não saiba.

84
00:06:11,890 --> 00:06:19,470
‫E ponteiro nulo é uma palavra-chave em C++ que permite verificar se um ponteiro é um ponteiro nulo.

85
00:06:19,480 --> 00:06:25,760
‫Portanto, se meu proprietário for nulo, retornaremos da função antecipadamente e não faremos mais nada.

86
00:06:25,780 --> 00:06:31,030
‫Agora, como eu estava dizendo, podemos obter o controlador instigador do meu proprietário e

87
00:06:31,030 --> 00:06:35,500
‫é isso que o uso da função chamada get instigator controller.

88
00:06:36,400 --> 00:06:40,590
‫E se passarmos o mouse sobre isso, veremos que ele retorna um ponteiro de controlador A.

89
00:06:40,600 --> 00:06:48,250
‫Vou simplesmente usar auto e armazenar isso em uma variável local que chamarei de instigador do meu proprietário.

90
00:06:50,660 --> 00:06:54,460
‫Então agora sabemos o que passar como instigador.

91
00:06:54,470 --> 00:07:00,800
‫A próxima entrada é o causador do dano e este é o ator que causa o dano ao projétil.

92
00:07:00,800 --> 00:07:02,930
‫Isso vai ser simplesmente isso.

93
00:07:02,930 --> 00:07:07,490
‫E isso deixa o último parâmetro de entrada, que é um tipo de dano.

94
00:07:07,490 --> 00:07:12,740
‫E vimos que é uma subclasse do que significa que precisamos da classe de uso adequada para passar.

95
00:07:12,740 --> 00:07:17,960
‫N Agora aqui está a documentação do mecanismo irreal para seu tipo de dano.

96
00:07:17,960 --> 00:07:24,050
‫Ele diz que um tipo de dano destina-se a definir e descrever uma forma específica de dano

97
00:07:24,050 --> 00:07:28,370
‫e fornecer um caminho para personalizar respostas a danos de várias fontes.

98
00:07:28,370 --> 00:07:30,890
‫Agora, não vamos personalizar nosso dano.

99
00:07:30,890 --> 00:07:38,090
‫Só precisamos satisfazer o parâmetro de entrada, o que significa que precisamos de um valor de classe U que represente essa

100
00:07:38,090 --> 00:07:40,070
‫classe de tipo de dano.

101
00:07:40,310 --> 00:07:48,200
‫Agora, em C++, se quisermos obter a classe YOU de qualquer classe em particular, como seu tipo de dano, podemos

102
00:07:48,200 --> 00:07:51,020
‫chamar uma função chamada classe estática.

103
00:07:51,020 --> 00:07:54,140
‫Isso é herdado da classe de objeto you.

104
00:07:54,170 --> 00:07:58,070
‫Agora é claro que estamos usando seu tipo de dano aqui, então vamos precisar desse cabeçalho.

105
00:07:58,310 --> 00:08:05,690
‫Então da documentação eu vou copiar a linha de inclusão e vou colar aqui no topo do CP

106
00:08:05,960 --> 00:08:14,450
‫do projétil E agora você verá que essa função de classe estática retorna um ponteiro de classe U e essa nova classe

107
00:08:14,450 --> 00:08:17,780
‫representará o novo tipo de dano classe C++.

108
00:08:17,780 --> 00:08:23,510
‫Agora, como não estamos criando um blueprint baseado em seu tipo de dano e configurando alguns dados extras,

109
00:08:23,510 --> 00:08:26,030
‫não precisamos de uma subclasse de variável.

110
00:08:26,150 --> 00:08:32,750
‫Então, neste caso, podemos usar a classe estática e isso retornará uma classe U que representa esse tipo.

111
00:08:32,750 --> 00:08:38,480
‫E podemos armazenar isso em uma variável, se quisermos, e chamarei essa classe de tipo de dano.

112
00:08:40,390 --> 00:08:45,520
‫E é isso que podemos passar como parâmetro final para aplicar dano.

113
00:08:45,520 --> 00:08:51,250
‫Então agora temos todas as informações que precisamos passar para a função de aplicar dano.

114
00:08:51,250 --> 00:08:57,100
‫Mas antes de fazermos isso, gostaria de fazer algumas verificações para ter certeza de que é apropriado chamarmos

115
00:08:57,100 --> 00:08:58,000
‫essa função.

116
00:08:58,000 --> 00:09:00,090
‫Então eu vou fazer uma declaração if aqui.

117
00:09:00,100 --> 00:09:03,550
‫Primeiro, quero ter certeza de que outro ator não é nulo.

118
00:09:03,550 --> 00:09:06,490
‫Então eu vou colocar outro ator aqui.

119
00:09:06,490 --> 00:09:13,450
‫Vou colocar um e aqui para verificar se o outro ator não é igual a esse ator.

120
00:09:13,450 --> 00:09:19,840
‫Não queremos causar danos a nós mesmos se formos o projétil agora vou colocar outra ponta

121
00:09:19,840 --> 00:09:24,640
‫e garantir que outro ator não seja igual ao meu dono.

122
00:09:24,760 --> 00:09:28,930
‫Não seria bom se o projétil estivesse causando danos ao seu dono.

123
00:09:28,930 --> 00:09:35,200
‫E agora, se entrarmos nessa instrução if, saberemos que é apropriado chamar aplicar dano para

124
00:09:35,200 --> 00:09:36,550
‫que possamos fazê-lo.

125
00:09:36,550 --> 00:09:38,290
‫E esse será o seu desafio.

126
00:09:38,290 --> 00:09:45,070
‫Portanto, em nossa nova instrução if na função on hit, chame a função de aplicação de dano de estática de jogo.

127
00:09:45,070 --> 00:09:51,310
‫Isso significa que você precisará incluir o cabeçalho correto para as estatísticas de jogo e saberá quais parâmetros

128
00:09:51,310 --> 00:09:52,450
‫de entrada passar.

129
00:09:52,570 --> 00:09:58,660
‫Então, pause o vídeo e adicione a chamada de função para aplicar dano na função on hit agora.

130
00:10:02,740 --> 00:10:03,250
‫OK.

131
00:10:03,250 --> 00:10:11,020
‫Então, estou aqui no CP de projéteis e vou incluir o arquivo de cabeçalho para estatísticas de jogo e podemos

132
00:10:11,020 --> 00:10:17,260
‫ver na página Applied Damage Documentation que a inclusão é kismet slash estática de jogo.

133
00:10:17,980 --> 00:10:22,330
‫Então, vou colar isso lá e agora estou pronto para chamar aplicar dano.

134
00:10:22,330 --> 00:10:28,060
‫Então, vou chamá-lo de estática de jogo aplicar dano.

135
00:10:28,810 --> 00:10:35,140
‫Agora, assim que eu digito os parênteses de abertura, recebo o pop-up me lembrando dos parâmetros de entrada de que

136
00:10:35,140 --> 00:10:35,800
‫preciso.

137
00:10:35,800 --> 00:10:40,360
‫E o primeiro é o ator danificado e esse será outro ator.

138
00:10:40,360 --> 00:10:42,760
‫Então, vamos digitar outro ator em seguida.

139
00:10:42,760 --> 00:10:50,410
‫Precisamos da quantidade de dano e adicionamos essa flutuação de dano no FX do projétil, que definimos como 50.

140
00:10:50,410 --> 00:10:53,170
‫Então eu vou passar o dano final em seguida.

141
00:10:53,170 --> 00:10:56,920
‫Precisamos do instigador e temos o instigador do meu dono.

142
00:10:56,920 --> 00:11:00,010
‫Então vou passar no meu dono instigador.

143
00:11:00,010 --> 00:11:01,960
‫Em seguida é o causador do dano.

144
00:11:01,960 --> 00:11:05,500
‫E, claro, o próprio projétil é o causador do dano.

145
00:11:05,500 --> 00:11:07,210
‫Então vamos passar nisso.

146
00:11:07,210 --> 00:11:14,860
‫E, finalmente, precisamos da subclasse de seu tipo de dano que sabemos que um ponteiro de classe U satisfará isso e é por

147
00:11:14,860 --> 00:11:17,980
‫isso que temos nossa classe de tipo de dano.

148
00:11:17,980 --> 00:11:21,910
‫Então vamos passar na classe de tipo de dano.

149
00:11:21,910 --> 00:11:25,570
‫E com isso estamos chamando de aplicar dano.

150
00:11:25,720 --> 00:11:33,040
‫Então, quando chamamos isso, vamos gerar o evento de dano e o On Take any Damage Delegado será transmitido em resposta

151
00:11:33,040 --> 00:11:39,010
‫a isso, o que significa que em nosso componente de saúde, o dano recebido será chamado.

152
00:11:39,010 --> 00:11:42,580
‫Então, nós só precisamos fazer algo aqui em danos sofridos.

153
00:11:42,580 --> 00:11:47,440
‫Bem, faria sentido tomar esse dano e subtrair esse valor da saúde.

154
00:11:47,440 --> 00:11:52,510
‫Antes de fazermos isso, porém, gostaria de ter certeza de que o dano não é menor ou igual a zero.

155
00:11:52,810 --> 00:11:59,170
‫F Faz sentido fazer essas verificações antes de documentar o dano, apenas para ter certeza de que não aplicamos um

156
00:11:59,170 --> 00:12:02,890
‫valor que não faz sentido, como zero ou um valor negativo.

157
00:12:02,890 --> 00:12:05,740
‫Então, se for esse o caso, simplesmente retornaremos.

158
00:12:05,740 --> 00:12:11,800
‫E claro, se você quiser ser esperto e fazer o que eu fiz no projétil no CP, podemos colocar o retorno

159
00:12:11,800 --> 00:12:12,700
‫ali mesmo.

160
00:12:12,700 --> 00:12:19,840
‫Agora, se passarmos dessa linha, o dano é um valor positivo para que possamos pegar a saúde e usar

161
00:12:19,840 --> 00:12:21,460
‫menos igual ao dano.

162
00:12:21,550 --> 00:12:25,750
‫E só para ter certeza de que isso está funcionando, por que não colocamos um log euy aqui?

163
00:12:25,750 --> 00:12:37,960
‫Então log de log do Yui, texto de aviso temporário e podemos simplesmente imprimir o valor da saúde com porcentagem F e saúde

164
00:12:37,960 --> 00:12:40,840
‫e com isso podemos compilar.

165
00:12:40,870 --> 00:12:47,200
‫Agora, com uma compilação bem-sucedida, voltaremos ao editor e, com nosso log de saída aberto, vamos clicar

166
00:12:47,200 --> 00:12:47,980
‫em play.

167
00:12:47,980 --> 00:12:51,010
‫Agora vamos ver se podemos ser atingidos por um projétil.

168
00:12:51,010 --> 00:12:52,120
‫E lá vamos nós.

169
00:12:52,150 --> 00:12:58,810
‫Nossa saúde está agora em 50 e se formos atingidos novamente, teremos alguns eventos de acerto porque

170
00:12:58,810 --> 00:13:02,410
‫estávamos acertando o projétil muitas vezes muito rapidamente.

171
00:13:02,410 --> 00:13:05,770
‫Mas vemos que nossa saúde está documentando adequadamente.

172
00:13:05,770 --> 00:13:11,620
‫Portanto, precisamos garantir que implementamos o comportamento correto após a morte quando a saúde chegar a zero.

173
00:13:11,620 --> 00:13:17,290
‫Mas também precisamos garantir que esse evento de hit não seja enviado várias vezes como spam.

174
00:13:17,290 --> 00:13:23,560
‫Agora sabemos que o projétil deve ser destruído ao atingir algo, então a melhor maneira de evitar spam

175
00:13:23,560 --> 00:13:26,800
‫no evento de acerto é destruir o projétil.

176
00:13:26,800 --> 00:13:29,290
‫Então essa é a última coisa que faremos neste vídeo.

177
00:13:29,290 --> 00:13:36,460
‫Então, de volta ao projétil logo após o dano aplicado, o que podemos fazer é fazer com que o projétil se destrua e isso

178
00:13:36,460 --> 00:13:38,050
‫não poderia ser mais fácil.

179
00:13:38,050 --> 00:13:41,110
‫Simplesmente chamamos a função destroy.

180
00:13:41,110 --> 00:13:48,880
‫Então, com mais uma compilação aqui no editor, podemos ir em frente e ser atingido por um projétil e olhar para

181
00:13:48,880 --> 00:13:49,330
‫isso.

182
00:13:49,330 --> 00:13:51,520
‫O projétil se foi.

183
00:13:51,520 --> 00:13:55,360
‫Então ele faz o seu dano e depois desaparece.

184
00:13:55,360 --> 00:14:02,110
‫E é claro que podemos testar acertar as torres também, explodindo-as com projéteis e certificando-nos de que

185
00:14:02,110 --> 00:14:04,570
‫esses eventos de acerto sejam acionados.

186
00:14:04,570 --> 00:14:10,750
‫E como você pode ver, eu posso enviar spam com um monte de projéteis e veremos que

187
00:14:10,750 --> 00:14:16,390
‫o valor de saúde para esta pobre torre aqui está ficando muito, muito negativo.

188
00:14:16,540 --> 00:14:23,650
‫Então, em resumo, chamamos a função de aplicar dano e isso resultou em uma transmissão para o delegado de

189
00:14:23,650 --> 00:14:25,030
‫receber qualquer dano.

190
00:14:25,030 --> 00:14:30,130
‫Documentamos a saúde no componente de saúde e destruímos o projétil.

191
00:14:30,130 --> 00:14:32,350
‫Então, agora cuidamos dos danos.

192
00:14:32,350 --> 00:14:34,390
‫Nós ainda não cuidamos da morte.

193
00:14:34,390 --> 00:14:38,860
‫Então, essa será uma das próximas coisas que abordaremos em um vídeo futuro.

194
00:14:39,310 --> 00:14:40,270
‫Vejo você em breve.