1
00:00:04,170 --> 00:00:04,650
‫Ei.

2
00:00:04,650 --> 00:00:05,610
‫Bem vindo de volta.

3
00:00:05,640 --> 00:00:11,010
‫Agora temos nosso projétil e sabemos que ele está gerando eventos de acerto, então precisamos

4
00:00:11,010 --> 00:00:14,250
‫fazer algo quando o projétil realmente atingir nosso alvo.

5
00:00:14,280 --> 00:00:19,200
‫Agora, isso envolverá causar danos, o que significa que precisamos de uma maneira de acompanhar a saúde.

6
00:00:19,200 --> 00:00:24,840
‫Então, vamos criar uma classe para lidar com saúde e danos chamada componente de saúde.

7
00:00:24,930 --> 00:00:30,720
‫E a razão pela qual essa funcionalidade ganha sua própria classe é para que possamos reutilizá-la para diferentes classes,

8
00:00:30,720 --> 00:00:32,690
‫como o tanque e a torre.

9
00:00:32,700 --> 00:00:35,250
‫Então, vamos discutir esse componente de saúde.

10
00:00:35,640 --> 00:00:38,900
‫Agora estamos familiarizados com a classe de componente use scene.

11
00:00:38,910 --> 00:00:43,390
‫Bem, esta classe é derivada de uma classe chamada seu componente ator.

12
00:00:43,410 --> 00:00:47,220
‫Na verdade, aqui está a documentação do componente de cena de uso.

13
00:00:47,220 --> 00:00:53,100
‫E na hierarquia de herança, você pode ver que seu pai é seu componente ator.

14
00:00:53,130 --> 00:00:57,330
‫Agora o você atua um componente é mais básico do que o componente você viu.

15
00:00:57,420 --> 00:00:59,070
‫Não tem transformação.

16
00:00:59,070 --> 00:01:05,020
‫Portanto, localização, rotação e escala não são algo que o componente do ator tenha.

17
00:01:05,040 --> 00:01:06,930
‫Não suporta anexo.

18
00:01:06,930 --> 00:01:12,660
‫Você não pode anexar um componente ativo a, digamos, um componente de malha estática ou um componente de cápsula.

19
00:01:12,660 --> 00:01:15,180
‫É apenas algo que pertence ao ator.

20
00:01:15,180 --> 00:01:20,910
‫E como não há representação visual ou transformação, não precisamos anexá-lo a nada.

21
00:01:21,000 --> 00:01:27,060
‫Compare isso com o componente de cena de uso, que na verdade tem uma transformação e a capacidade de se

22
00:01:27,060 --> 00:01:31,640
‫anexar a outros componentes ou fazer com que outros componentes se conectem a ele.

23
00:01:31,650 --> 00:01:36,450
‫Então, para acompanhar a saúde e cuidar dos danos, não precisamos de nada disso.

24
00:01:36,450 --> 00:01:39,990
‫Então você age como um componente vai ser perfeito para isso.

25
00:01:40,170 --> 00:01:44,880
‫Então, vamos voltar aqui para o editor e tornar nosso novo ato uma classe de componente.

26
00:01:44,880 --> 00:01:48,690
‫Então vamos para ferramentas e nova classe C++.

27
00:01:48,690 --> 00:01:51,890
‫E se eu rolar para baixo, posso ver o componente do ator.

28
00:01:51,900 --> 00:01:53,730
‫É isso que vamos selecionar.

29
00:01:53,760 --> 00:01:54,630
‫Agora tenha cuidado.

30
00:01:54,630 --> 00:01:56,400
‫Não selecione ator.

31
00:01:56,400 --> 00:01:57,750
‫Essa é uma aula diferente.

32
00:01:57,750 --> 00:02:02,610
‫Na verdade, é uma classe maior e tem muito mais coisas do que o componente ator.

33
00:02:02,610 --> 00:02:07,560
‫Precisamos do componente ator especificamente, então selecione-o e clique em próximo.

34
00:02:07,560 --> 00:02:11,490
‫E isso podemos chamar simplesmente de Componente de Saúde.

35
00:02:11,880 --> 00:02:13,740
‫Vamos clicar em Criar turma.

36
00:02:14,190 --> 00:02:21,420
‫Agora aqui temos nossos novos componentes de saúde e arquivos CP e você pode ver aqui que seu componente de saúde, a

37
00:02:21,420 --> 00:02:25,980
‫classe que acabamos de criar é derivada de você agir como um componente.

38
00:02:25,980 --> 00:02:30,390
‫Portanto, certifique-se de ter o tipo correto aqui e verá que ele tem em seu U.

39
00:02:30,390 --> 00:02:31,710
‫Macro de classe.

40
00:02:31,740 --> 00:02:36,360
‫Este meta especifica onde e diz componentes da tabela de geração de blueprints.

41
00:02:36,360 --> 00:02:41,790
‫Isso é o que vai nos permitir adicionar este componente diretamente nos blueprints, que é o que

42
00:02:41,790 --> 00:02:43,050
‫vamos fazer agora.

43
00:02:43,050 --> 00:02:48,960
‫O novo componente de saúde vai cuidar da saúde, o que significa que precisamos de algumas variáveis.

44
00:02:48,960 --> 00:02:52,380
‫Vamos em frente e adicioná-los e vou torná-los privados.

45
00:02:52,380 --> 00:02:58,500
‫Então, vamos adicionar uma seção privada logo abaixo da protegida, e podemos adicionar algumas variáveis

46
00:02:58,500 --> 00:02:59,700
‫de integridade.

47
00:02:59,700 --> 00:03:04,290
‫Agora, estes serão floats e eu vou chamar o primeiro de Max Health.

48
00:03:04,320 --> 00:03:10,440
‫Esta será a quantidade máxima de saúde que podemos ter e podemos definir isso para um valor

49
00:03:10,440 --> 00:03:12,180
‫padrão, como 100 F.

50
00:03:12,180 --> 00:03:18,000
‫Agora, além da saúde máxima, teremos um valor de saúde que será a saúde atual e isso será

51
00:03:18,000 --> 00:03:20,850
‫o que mudará à medida que sofrermos danos.

52
00:03:20,850 --> 00:03:24,720
‫Então vamos fazer outro float e simplesmente chamar este de saúde.

53
00:03:24,720 --> 00:03:30,900
‫Agora podemos inicializar a saúde para zero F e então definir seu valor e começar a jogar.

54
00:03:30,900 --> 00:03:37,380
‫E a razão pela qual faremos isso é porque o Max Health terá sua própria propriedade você, permitindo que

55
00:03:37,380 --> 00:03:39,690
‫a configuremos no painel de detalhes.

56
00:03:39,690 --> 00:03:43,470
‫Então, vamos dar a isso uma propriedade U e editá-lo em qualquer lugar.

57
00:03:43,680 --> 00:03:46,500
‫Dessa forma, podemos alterá-lo à medida que estamos desenvolvendo.

58
00:03:46,500 --> 00:03:53,700
‫E então nos componentes de saúde CP aqui e começar a jogar, podemos simplesmente definir a saúde igual ao valor da

59
00:03:53,700 --> 00:03:54,600
‫saúde máxima.

60
00:03:54,600 --> 00:04:00,390
‫Assim, quando o jogo começar, a saúde terá o valor de saúde máxima mesmo depois de alterá-la

61
00:04:00,390 --> 00:04:01,860
‫no painel de detalhes.

62
00:04:02,040 --> 00:04:09,420
‫Ok, então vamos compilar isso e de volta aqui no editor, vou abrir o BP -- tanque e abrir o

63
00:04:09,420 --> 00:04:10,920
‫editor de blueprint completo.

64
00:04:10,920 --> 00:04:16,200
‫E agora posso adicionar este componente de saúde aqui no painel de componentes.

65
00:04:16,290 --> 00:04:20,130
‫Então, vou clicar em Adicionar e Pesquisar Saúde.

66
00:04:20,370 --> 00:04:22,350
‫E aqui vemos saúde.

67
00:04:22,530 --> 00:04:25,860
‫Agora, nós o chamamos de componente de saúde em C++.

68
00:04:25,860 --> 00:04:29,670
‫E, de fato, o pop-up mostra que é chamado de componente de saúde.

69
00:04:29,670 --> 00:04:33,420
‫Portanto, retira essa parte componente ao mostrá-la aqui.

70
00:04:33,420 --> 00:04:38,220
‫E você deve ter notado que, quando procura por componentes de malha estática ou componentes de

71
00:04:38,220 --> 00:04:40,890
‫cápsula, também não vê a palavra componente aqui.

72
00:04:40,890 --> 00:04:48,270
‫Então clique em health e agora temos nosso componente health e você verá que sob o componente health temos

73
00:04:48,270 --> 00:04:55,080
‫max health e está definido como 100 e não vemos health porque não expomos essa variável.

74
00:04:55,170 --> 00:05:02,430
‫Então agora BP -- tanque tem um componente de saúde e disse que o tanque possui este componente de saúde, o BP

75
00:05:02,430 --> 00:05:03,390
‫-- tanque.

76
00:05:03,860 --> 00:05:06,590
‫É o proprietário deste componente de integridade.

77
00:05:06,620 --> 00:05:13,760
‫Vamos compilar e salvar e fechar e abrir a torre de peões BP e abrir o editor de planta completo e podemos adicionar

78
00:05:13,760 --> 00:05:16,930
‫um componente de saúde à torre da lagoa também.

79
00:05:16,940 --> 00:05:21,620
‫Então, vamos clicar em adicionar componentes, pesquisar por integridade e selecionar integridade.

80
00:05:21,620 --> 00:05:25,490
‫E agora também temos um componente de saúde na torre.

81
00:05:25,670 --> 00:05:30,560
‫Então eu vou compilar e salvar esses closes e salvar todos.

82
00:05:30,590 --> 00:05:36,650
‫Agora temos um componente de integridade e mencionamos que gostaríamos de ter um componente de integridade para que

83
00:05:36,650 --> 00:05:38,740
‫possamos reutilizá-lo com diferentes classes.

84
00:05:38,750 --> 00:05:44,330
‫Então, se tivermos um peão no mundo, digamos, nossa torre, ela terá seu próprio componente de saúde e nosso

85
00:05:44,330 --> 00:05:47,040
‫tanque poderá ter seu próprio componente de saúde.

86
00:05:47,060 --> 00:05:52,340
‫Agora, quando nosso projétil interage com qualquer um desses, por exemplo, quando gera um evento

87
00:05:52,340 --> 00:05:57,680
‫de acerto, ao acertar uma dessas coisas, nossos peões podem acionar alguma funcionalidade no componente

88
00:05:57,680 --> 00:06:00,830
‫de saúde e alterar esses valores de saúde.

89
00:06:00,830 --> 00:06:07,820
‫Colocar nossa funcionalidade de saúde em um componente e depois adicionar esse componente a uma classe tem algumas vantagens

90
00:06:07,820 --> 00:06:13,760
‫sobre a alternativa, que seria simplesmente colocar a funcionalidade de saúde na classe base do peão,

91
00:06:13,760 --> 00:06:17,520
‫por exemplo, e herdar isso no tanque e na torre.

92
00:06:17,540 --> 00:06:25,280
‫Veja bem, isso nos permite manter nossas classes de tanques e torres pequenas e lidar apenas com a funcionalidade especificada para

93
00:06:25,280 --> 00:06:26,420
‫essas classes.

94
00:06:26,420 --> 00:06:32,840
‫Considerando que o componente de saúde pode ser adicionado a qualquer outro ator, como coisas que não agem como tanques

95
00:06:32,840 --> 00:06:33,800
‫ou torres.

96
00:06:33,800 --> 00:06:39,290
‫Podemos fazer uma parede destrutível, por exemplo, que pode ser destruída assim que sofrer dano

97
00:06:39,290 --> 00:06:39,950
‫suficiente.

98
00:06:39,950 --> 00:06:43,910
‫Então, vamos falar um pouco sobre como podemos fazer isso acontecer agora.

99
00:06:43,910 --> 00:06:50,810
‫O Unreal Engine possui uma funcionalidade de dano integrada e seu sistema danificado é realmente bastante sofisticado.

100
00:06:50,810 --> 00:06:58,490
‫Qualquer ator em nosso jogo herda uma série de eventos de dano, um dos quais é chamado para receber qualquer dano.

101
00:06:58,490 --> 00:07:03,440
‫Este é um delegado multicast, assim como no hit do componente.

102
00:07:03,470 --> 00:07:08,360
‫Agora vamos adicionar componentes de saúde aos nossos peões e estes serão baseados em nosso U.

103
00:07:08,360 --> 00:07:09,860
‫Classe de componente de saúde.

104
00:07:09,860 --> 00:07:16,550
‫Então, como sabemos que nossos peões vão herdar isso ao receber qualquer delegado de dano, se criarmos nossa

105
00:07:16,550 --> 00:07:22,640
‫própria função personalizada na classe do componente de saúde, podemos usar essa função como um retorno de

106
00:07:22,640 --> 00:07:25,940
‫chamada e vinculá-la ao receber qualquer dano delegar.

107
00:07:25,940 --> 00:07:33,200
‫Então, sempre que um evento de dano for gerado, o delegado de dano pode transmitir e quaisquer funções

108
00:07:33,200 --> 00:07:37,460
‫vinculadas a ele em sua lista de invocação serão chamadas.

109
00:07:37,460 --> 00:07:42,320
‫Então, a próxima pergunta é como podemos realmente fazer com que esse delegado transmita?

110
00:07:42,320 --> 00:07:45,080
‫Precisamos de uma maneira de gerar um evento de dano.

111
00:07:45,080 --> 00:07:52,070
‫Bem, há uma função em sua estática de jogo que fará exatamente isso e se chama aplicar dano.

112
00:07:52,070 --> 00:07:58,550
‫Se usarmos essa função estática de sua estática de jogo para aplicar dano, aplicar dano leva vários

113
00:07:58,550 --> 00:08:02,180
‫parâmetros, incluindo o ator que está sendo danificado.

114
00:08:02,180 --> 00:08:09,620
‫Portanto, se chamarmos apply Damage, os atores que receberem qualquer delegado de dano serão acionados e essa função de retorno de

115
00:08:09,620 --> 00:08:11,720
‫chamada será chamada em resposta.

116
00:08:11,720 --> 00:08:15,830
‫Portanto, aplicar dano é o que gera o evento de dano.

117
00:08:15,830 --> 00:08:19,520
‫Então, para configurar tudo isso, temos três etapas.

118
00:08:19,520 --> 00:08:25,760
‫Primeiro, crie uma função de retorno de chamada e, como ela será vinculada a receber qualquer dano, ela deve ter

119
00:08:25,760 --> 00:08:31,550
‫os parâmetros de entrada corretos para que, ao receber qualquer dano, ela a chame e passe todas as

120
00:08:31,550 --> 00:08:33,950
‫informações associadas sobre o evento de dano.

121
00:08:34,130 --> 00:08:37,970
‫A etapa dois é vincular esse retorno de chamada ao delegado.

122
00:08:38,000 --> 00:08:43,850
‫Vimos como fazer isso com o delegado de hit do componente on usando a função add dynamic.

123
00:08:43,850 --> 00:08:45,530
‫Faremos a mesma coisa aqui.

124
00:08:45,530 --> 00:08:52,000
‫E o terceiro passo é gerar o evento de dano chamando a função estática do seu jogo, dano

125
00:08:52,010 --> 00:08:52,670
‫aplicado.

126
00:08:52,670 --> 00:08:56,210
‫Então, vamos voltar ao código e começar a configurar isso.

127
00:08:56,600 --> 00:08:56,880
‫OK.

128
00:08:56,960 --> 00:09:01,910
‫Então, estamos aqui no componente de saúde e vamos adicionar uma função de retorno de chamada.

129
00:09:01,910 --> 00:09:05,810
‫Agora, isso pode ser anulado e podemos chamá-lo do que quisermos.

130
00:09:05,960 --> 00:09:08,450
‫Eu vou chamar este dano tomado.

131
00:09:08,450 --> 00:09:14,870
‫E como estamos vinculando isso a um delegado, ele precisa ter os parâmetros de entrada corretos apropriados

132
00:09:14,870 --> 00:09:16,280
‫para esse delegado.

133
00:09:16,310 --> 00:09:23,240
‫Agora, para funções vinculadas a on take any damage delegate, a lista de parâmetros de entrada deve ser a seguinte.

134
00:09:23,240 --> 00:09:30,830
‫O primeiro é um ponteiro de ator chamado Ator Danificado, e é assim que parece.

135
00:09:30,830 --> 00:09:33,320
‫É o ator que sofre o dano.

136
00:09:33,350 --> 00:09:38,480
‫Em seguida é um float chamado dano e este é o valor real do dano.

137
00:09:38,510 --> 00:09:45,950
‫Agora, em seguida, temos um ponteiro de tipo de dano de custo chamado tipo de dano.

138
00:09:46,220 --> 00:09:52,430
‫E a razão pela qual temos esse parâmetro de entrada é porque o Unreal Engine tem o conceito de tipos de dano.

139
00:09:52,430 --> 00:09:59,090
‫Você pode criar tipos de danos personalizados com dados extras que podem informá-lo para fazer coisas diferentes, dependendo do tipo

140
00:09:59,090 --> 00:10:01,100
‫de dano que você pode ter.

141
00:10:01,100 --> 00:10:02,000
‫Dano de fogo.

142
00:10:02,000 --> 00:10:03,260
‫Veneno prejudicial.

143
00:10:03,320 --> 00:10:05,570
‫Danos explosivos e assim por diante.

144
00:10:05,570 --> 00:10:11,330
‫E se você quiser implementar a funcionalidade personalizada para cada tipo de dano, você deve implementar isso em

145
00:10:11,330 --> 00:10:13,430
‫seu próprio tipo de dano personalizado.

146
00:10:13,460 --> 00:10:19,040
‫Agora, não estamos criando nosso próprio tipo de dano personalizado, mas como estamos vinculando essa função ao delegado

147
00:10:19,040 --> 00:10:22,940
‫para receber qualquer dano, ela precisa ter esses parâmetros de entrada.

148
00:10:22,940 --> 00:10:24,380
‫Então estamos incluindo aqui.

149
00:10:24,410 --> 00:10:32,090
‫Agora, o próximo parâmetro é um ponteiro de controlador A e isso é chamado de instigador e Unreal Engine

150
00:10:32,090 --> 00:10:33,330
‫Damage System.

151
00:10:33,350 --> 00:10:38,050
‫Um instigador é o controlador responsável pelo dano.

152
00:10:38,060 --> 00:10:45,110
‫Então, se o dano foi causado por um jogador controlando um peão, então o instigador é o controlador

153
00:10:45,110 --> 00:10:46,820
‫que possui aquele peão.

154
00:10:46,850 --> 00:10:49,600
‫Agora, nem sempre precisa haver um instigador.

155
00:10:49,610 --> 00:10:52,580
‫Se não houvesse nenhum, então isso seria simplesmente nulo.

156
00:10:52,580 --> 00:10:59,510
‫E agora estou recebendo os rabiscos vermelhos para poder declarar a classe do controlador A aqui entre parênteses para

157
00:10:59,510 --> 00:11:00,410
‫a função.

158
00:11:00,440 --> 00:11:06,980
‫Agora, o último parâmetro é um ponteiro de ator A e este é chamado de Causador de Danos.

159
00:11:07,010 --> 00:11:10,370
‫Este é o verdadeiro ator que está causando o dano.

160
00:11:10,370 --> 00:11:13,220
‫Este seria o próprio projétil.

161
00:11:13,310 --> 00:11:20,670
‫Então, declaramos essa função de retorno de chamada de dano sofrido e assim como nossa outra função de retorno de chamada ao acerto.

162
00:11:20,690 --> 00:11:22,970
‫Isso tem que ser uma função u.

163
00:11:22,970 --> 00:11:28,550
‫Então, vamos dar a ela a função macro apenas para ter certeza de que ela funciona assim que a

164
00:11:28,550 --> 00:11:30,620
‫vincularmos ao On Take any Damage Delegado.

165
00:11:30,950 --> 00:11:35,680
‫E agora que o declaramos, estamos prontos para defini-lo no arquivo CPP.

166
00:11:35,690 --> 00:11:38,540
‫Então aqui nos componentes de saúde, CPP.

167
00:11:38,630 --> 00:11:45,530
‫Na parte inferior, vou seguir em frente e dar a isso um corpo de função e qualificar totalmente a função com

168
00:11:45,530 --> 00:11:46,970
‫o nome da classe.

169
00:11:46,970 --> 00:11:49,400
‫E agora temos um retorno de chamada.

170
00:11:49,400 --> 00:11:52,400
‫Então agora precisamos vincular isso ao delegado.

171
00:11:52,400 --> 00:11:59,180
‫Mas o delegado não existe no componente de saúde, existe nos atores especificamente.

172
00:11:59,180 --> 00:12:05,970
‫Queremos vincular isso a qualquer delegado de dano no peão que possui esse componente.

173
00:12:05,990 --> 00:12:11,570
‫Então, como acessamos o proprietário desse componente para que possamos vincular a um de seus delegados?

174
00:12:11,570 --> 00:12:17,270
‫Bem, faríamos isso e começaríamos a jogar e a maneira como podemos acessar o proprietário de um componente

175
00:12:17,270 --> 00:12:19,460
‫é através da função git owner.

176
00:12:19,460 --> 00:12:23,530
‫Se você passar o mouse sobre isso, verá que ele retorna um ponteiro de ator.

177
00:12:23,540 --> 00:12:27,620
‫Este é o ponteiro para o ator que possui um componente.

178
00:12:27,620 --> 00:12:32,990
‫Os componentes podem ser de propriedade de peões, eles podem ser de propriedade de atores, então ele retornará o

179
00:12:32,990 --> 00:12:35,630
‫proprietário na forma de um ponteiro de ator.

180
00:12:35,810 --> 00:12:42,890
‫Portanto, temos nossa função de retorno de chamada e nossa segunda etapa é vinculá-la ao delegado para receber qualquer dano

181
00:12:42,890 --> 00:12:46,640
‫que existirá no peão que possui o componente de saúde.

182
00:12:46,790 --> 00:12:53,870
‫Portanto, como você tem experiência em vincular retornos de chamada a delegados, esse será seu desafio na classe do

183
00:12:53,870 --> 00:12:55,100
‫componente de integridade.

184
00:12:55,100 --> 00:13:02,420
‫Em Begin Play, você vai vincular o dano recebido a qualquer delegado de dano que exista no

185
00:13:02,420 --> 00:13:04,190
‫proprietário do componente.

186
00:13:04,190 --> 00:13:08,090
‫Portanto, você acessará esse delegado por meio da função obter proprietário.

187
00:13:08,090 --> 00:13:13,640
‫Em outras palavras, você vai chamar get owner e a partir disso você vai acessar e receber qualquer dano.

188
00:13:13,640 --> 00:13:20,660
‫E, a partir daí, você sabe como vincular retornos de chamada a delegados usando adicionar dinâmico se você ficar preso,

189
00:13:20,660 --> 00:13:28,250
‫veja como vinculamos o retorno de chamada no hit ao delegado de hit do componente, pausa o vídeo e vincula o

190
00:13:28,250 --> 00:13:31,790
‫dano recebido ao delegado on take any damage agora.

191
00:13:35,000 --> 00:13:35,360
‫OK.

192
00:13:35,360 --> 00:13:40,610
‫Então, estamos de volta aqui no componente de saúde e estamos prontos para fazer a ligação de nossa função de retorno de chamada.

193
00:13:40,610 --> 00:13:47,390
‫Então aqui e comece a jogar, vamos acessar o dono usando a função git owner e a partir daí

194
00:13:47,390 --> 00:13:54,770
‫vamos usar o operador de seta para acessar aquele delegado chamado, receber qualquer dano e em receber qualquer dano tem

195
00:13:54,770 --> 00:14:01,520
‫o add dynamic função e ele simplesmente recebe um objeto de usuário e um nome de função.

196
00:14:01,520 --> 00:14:05,240
‫Agora, o objeto do usuário é o objeto para o qual estamos vinculando a função.

197
00:14:05,240 --> 00:14:10,130
‫É a classe que tem a função de retorno de chamada e será isso.

198
00:14:10,190 --> 00:14:14,420
‫E, finalmente, temos nossa função de retorno de chamada, que será você.

199
00:14:14,420 --> 00:14:16,790
‫Dano do componente de saúde recebido.

200
00:14:16,790 --> 00:14:23,690
‫Agora precisamos lembrar o endereço do operador porque isso na verdade leva um endereço da função.

201
00:14:23,690 --> 00:14:31,460
‫Portanto, agora o dano recebido é obrigado a receber qualquer dano e é adicionado à lista de invocação desse delegado.

202
00:14:31,460 --> 00:14:37,790
‫Portanto, sempre que gerarmos eventos de dano, receberemos uma transmissão desse delegado que resultará

203
00:14:37,790 --> 00:14:40,970
‫na função de receber dano, sendo chamada.

204
00:14:41,570 --> 00:14:48,320
‫Então, em resumo, criamos nosso próprio componente de saúde e adicionamos um deles ao projeto do tanque

205
00:14:48,320 --> 00:14:50,540
‫e ao projeto da torre.

206
00:14:50,660 --> 00:14:58,130
‫Criamos uma função de retorno de chamada chamada Damage Taken e a vinculamos ao delegado on take any damage.

207
00:14:58,130 --> 00:15:05,150
‫O próximo passo é gerar um evento de dano que resultará na transmissão do On Take any Damage Delegado para

208
00:15:05,150 --> 00:15:10,640
‫que o dano da nossa função de retorno de chamada seja chamado em resposta.

209
00:15:10,640 --> 00:15:13,520
‫E vamos configurar isso no próximo vídeo.

210
00:15:14,240 --> 00:15:15,140
‫Vejo você em breve.