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

2
00:00:04,650 --> 00:00:05,610
‫Ben tornato.

3
00:00:05,640 --> 00:00:11,010
‫Ora abbiamo il nostro proiettile e sappiamo che sta generando eventi di successo, quindi dobbiamo fare

4
00:00:11,010 --> 00:00:14,250
‫qualcosa quando il proiettile colpisce effettivamente il nostro obiettivo.

5
00:00:14,280 --> 00:00:19,200
‫Ora, questo comporterà fare danni, il che significa che abbiamo bisogno di un modo per tenere traccia della salute.

6
00:00:19,200 --> 00:00:24,840
‫Quindi creeremo una classe per la gestione della salute e del danno chiamata componente della salute.

7
00:00:24,930 --> 00:00:30,720
‫E il motivo per cui questa funzionalità ha una sua classe è che possiamo riutilizzarla per classi diverse come

8
00:00:30,720 --> 00:00:32,690
‫il carro armato e la torre.

9
00:00:32,700 --> 00:00:35,250
‫Quindi discutiamo di questa componente di salute.

10
00:00:35,640 --> 00:00:38,900
‫Ora abbiamo familiarità con la classe del componente use scene.

11
00:00:38,910 --> 00:00:43,390
‫Bene, questa classe è derivata da una classe chiamata componente attore.

12
00:00:43,410 --> 00:00:47,220
‫In effetti, ecco la documentazione del componente della scena d'uso.

13
00:00:47,220 --> 00:00:53,100
‫E nella gerarchia dell'ereditarietà, puoi vedere che il suo genitore è il tuo componente attore.

14
00:00:53,130 --> 00:00:57,330
‫Ora che agisci, un componente è più semplice del componente che hai visto.

15
00:00:57,420 --> 00:00:59,070
‫Non ha trasformazione.

16
00:00:59,070 --> 00:01:05,020
‫Quindi la posizione, la rotazione e la scala non sono qualcosa che il componente del tuo attore ha nemmeno.

17
00:01:05,040 --> 00:01:06,930
‫Non supporta l'allegato.

18
00:01:06,930 --> 00:01:12,660
‫Non è possibile collegare un componente attivo, ad esempio, a un componente mesh statico oa un componente capsula.

19
00:01:12,660 --> 00:01:15,180
‫È solo qualcosa che appartiene all'attore.

20
00:01:15,180 --> 00:01:20,910
‫E poiché non c'è rappresentazione visiva o trasformazione, non abbiamo bisogno di collegarlo a nulla.

21
00:01:21,000 --> 00:01:27,060
‫Confronta questo con il componente della scena d'uso, che in realtà ha una trasformazione e la capacità di attaccarsi

22
00:01:27,060 --> 00:01:31,640
‫ad altri componenti o di avere altri componenti che si attaccano ad esso.

23
00:01:31,650 --> 00:01:36,450
‫Quindi per tenere traccia della salute e prendersi cura dei danni, non abbiamo bisogno di nessuna di queste cose.

24
00:01:36,450 --> 00:01:39,990
‫Quindi agisci che un componente sarà perfetto per questo.

25
00:01:40,170 --> 00:01:44,880
‫Quindi torniamo qui nell'editor e rendiamo il nostro nuovo atto una classe componente.

26
00:01:44,880 --> 00:01:48,690
‫Quindi passeremo agli strumenti e alla nuova classe C++.

27
00:01:48,690 --> 00:01:51,890
‫E se scorro verso il basso, posso vedere il componente attore.

28
00:01:51,900 --> 00:01:53,730
‫Questo è ciò che selezioneremo.

29
00:01:53,760 --> 00:01:54,630
‫Ora stai attento.

30
00:01:54,630 --> 00:01:56,400
‫Non selezionare l'attore.

31
00:01:56,400 --> 00:01:57,750
‫Quella è una classe diversa.

32
00:01:57,750 --> 00:02:02,610
‫In realtà è una classe più grande e ha molte più cose rispetto alla componente attore.

33
00:02:02,610 --> 00:02:07,560
‫Abbiamo bisogno del componente attore in modo specifico, quindi selezionalo, fai clic su Avanti.

34
00:02:07,560 --> 00:02:11,490
‫E questo lo possiamo chiamare semplicemente Componente della Salute.

35
00:02:11,880 --> 00:02:13,740
‫Facciamo clic su Crea classe.

36
00:02:14,190 --> 00:02:21,420
‫Ora qui abbiamo i nostri nuovi componenti di salute e file CP e puoi vedere qui che il tuo componente di salute,

37
00:02:21,420 --> 00:02:25,980
‫la classe che abbiamo appena creato è derivata dal tuo agire come componente.

38
00:02:25,980 --> 00:02:30,390
‫Quindi assicurati di avere il tipo corretto qui e vedrai che ha nella sua U.

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

40
00:02:31,740 --> 00:02:36,360
‫Questo meta specifica dove e dice il componente della tabella di spawn dei progetti.

41
00:02:36,360 --> 00:02:41,790
‫Questo è ciò che ci consentirà di aggiungere questo componente direttamente nei progetti, che è ciò

42
00:02:41,790 --> 00:02:43,050
‫che faremo ora.

43
00:02:43,050 --> 00:02:48,960
‫La nuova componente sanitaria si prenderà cura della salute, il che significa che abbiamo bisogno di un paio di variabili.

44
00:02:48,960 --> 00:02:52,380
‫Andiamo avanti e aggiungiamo questi e li renderò privati.

45
00:02:52,380 --> 00:02:58,500
‫Quindi andiamo avanti e aggiungiamo una sezione privata appena sotto quella protetta e possiamo aggiungere un paio di

46
00:02:58,500 --> 00:02:59,700
‫variabili di salute.

47
00:02:59,700 --> 00:03:04,290
‫Ora, questi saranno float e chiamerò il primo Max Health.

48
00:03:04,320 --> 00:03:10,440
‫Questa sarà la quantità massima di salute che possiamo avere e possiamo impostarla su un valore

49
00:03:10,440 --> 00:03:12,180
‫predefinito come 100 F.

50
00:03:12,180 --> 00:03:18,000
‫Ora, oltre alla salute massima, avremo un valore di salute che sarà la salute attuale e questo sarà

51
00:03:18,000 --> 00:03:20,850
‫ciò che cambierà man mano che subiamo danni.

52
00:03:20,850 --> 00:03:24,720
‫Quindi facciamo un altro galleggiante e chiamiamo semplicemente questa salute.

53
00:03:24,720 --> 00:03:30,900
‫Ora possiamo inizializzare la salute a zero F, quindi impostarne il valore e iniziare a giocare.

54
00:03:30,900 --> 00:03:37,380
‫E il motivo per cui lo faremo è perché Max Health avrà la sua proprietà che ci consentirà

55
00:03:37,380 --> 00:03:39,690
‫di impostarla dal pannello dei dettagli.

56
00:03:39,690 --> 00:03:43,470
‫Quindi diamo a questo una proprietà U e facciamolo modificare ovunque.

57
00:03:43,680 --> 00:03:46,500
‫In questo modo possiamo cambiarlo mentre ci stiamo sviluppando.

58
00:03:46,500 --> 00:03:53,700
‫E poi nelle componenti della salute CP qui e iniziare a giocare, possiamo semplicemente impostare la salute uguale al valore della

59
00:03:53,700 --> 00:03:54,600
‫salute massima.

60
00:03:54,600 --> 00:04:00,390
‫In questo modo, all'inizio del gioco, la salute avrà il valore della salute massima anche dopo averla modificata

61
00:04:00,390 --> 00:04:01,860
‫nel pannello dei dettagli.

62
00:04:02,040 --> 00:04:09,420
‫Ok, quindi compiliamo questo e torniamo qui nell'editor, aprirò BP -- tank e aprirò l'editor

63
00:04:09,420 --> 00:04:10,920
‫completo del progetto.

64
00:04:10,920 --> 00:04:16,200
‫E ora posso aggiungere questo componente di salute qui nel pannello dei componenti.

65
00:04:16,290 --> 00:04:20,130
‫Quindi farò clic su Aggiungi e Cerca salute.

66
00:04:20,370 --> 00:04:22,350
‫E qui vediamo la salute.

67
00:04:22,530 --> 00:04:25,860
‫Ora, lo abbiamo chiamato componente di salute in C++.

68
00:04:25,860 --> 00:04:29,670
‫E infatti, il pop up mostra che si chiama componente salute.

69
00:04:29,670 --> 00:04:33,420
‫Quindi rimuove quella parte componente quando la mostra qui.

70
00:04:33,420 --> 00:04:38,220
‫E potresti aver notato che quando cerchi componenti mesh statici o componenti capsula, non vedi

71
00:04:38,220 --> 00:04:40,890
‫nemmeno la parola componente qui per quelli.

72
00:04:40,890 --> 00:04:48,270
‫Quindi fai clic su salute e ora abbiamo il nostro componente salute e vedrai che sotto il componente salute abbiamo

73
00:04:48,270 --> 00:04:55,080
‫salute massima ed è impostato su 100 e non vediamo salute perché non abbiamo esposto quella variabile.

74
00:04:55,170 --> 00:05:02,430
‫Quindi ora BP -- tank ha una componente di salute e dice che il tank possiede questa componente di salute, il BP

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

76
00:05:03,860 --> 00:05:06,590
‫È il proprietario di questo componente sanitario.

77
00:05:06,620 --> 00:05:13,760
‫Compiliamo, salviamo, chiudiamo e apriamo la torretta del pedone BP e apriamo l'editor completo del progetto e possiamo aggiungere anche

78
00:05:13,760 --> 00:05:16,930
‫un componente di salute alla torretta dello stagno.

79
00:05:16,940 --> 00:05:21,620
‫Quindi facciamo clic su aggiungi componenti, cerca salute e seleziona salute.

80
00:05:21,620 --> 00:05:25,490
‫E ora abbiamo anche una componente di salute sulla torre.

81
00:05:25,670 --> 00:05:30,560
‫Quindi compilerò e salverò questi per chiudere e salvare tutti.

82
00:05:30,590 --> 00:05:36,650
‫Quindi ora abbiamo una componente di salute e abbiamo detto che vorremmo avere una componente di salute in modo

83
00:05:36,650 --> 00:05:38,740
‫da poterla riutilizzare con classi diverse.

84
00:05:38,750 --> 00:05:44,330
‫Quindi, se abbiamo una pedina nel mondo, diciamo, la nostra torre, avrà la sua componente di salute e quindi il nostro

85
00:05:44,330 --> 00:05:47,040
‫carro armato potrà avere la sua componente di salute.

86
00:05:47,060 --> 00:05:52,340
‫Ora, quando il nostro proiettile interagisce con uno di questi, ad esempio, quando genera un evento

87
00:05:52,340 --> 00:05:57,680
‫di successo, quando colpisce una di queste cose, le nostre pedine possono attivare alcune funzionalità nella

88
00:05:57,680 --> 00:06:00,830
‫componente salute e modificare quei valori di salute.

89
00:06:00,830 --> 00:06:07,820
‫Mettere la nostra funzionalità di salute in un componente e quindi aggiungere quel componente a una classe presenta alcuni vantaggi

90
00:06:07,820 --> 00:06:13,760
‫rispetto all'alternativa, che sarebbe semplicemente posizionare la funzionalità di salute nella classe del pedone di base,

91
00:06:13,760 --> 00:06:17,520
‫ad esempio, ed ereditarla nel carro armato e nella torre.

92
00:06:17,540 --> 00:06:25,280
‫Vedete, questo ci consente di mantenere piccole le nostre classi di carri armati e torri e di occuparci solo di funzionalità specifiche

93
00:06:25,280 --> 00:06:26,420
‫per quelle classi.

94
00:06:26,420 --> 00:06:32,840
‫Considerando che la componente di salute può essere aggiunta a qualsiasi altro attore, come cose che non agiscono come carri armati

95
00:06:32,840 --> 00:06:33,800
‫o torri.

96
00:06:33,800 --> 00:06:39,290
‫Possiamo creare un muro distruttibile, ad esempio, che potrebbe essere distrutto non appena subisce abbastanza

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

98
00:06:39,950 --> 00:06:43,910
‫Quindi parliamo un po' di come possiamo farlo accadere ora.

99
00:06:43,910 --> 00:06:50,810
‫Unreal Engine ha funzionalità di danno integrate e il suo sistema danneggiato è in realtà piuttosto sofisticato.

100
00:06:50,810 --> 00:06:58,490
‫Qualsiasi attore nel nostro gioco eredita una serie di eventi di danno, uno dei quali è chiamato a subire qualsiasi danno.

101
00:06:58,490 --> 00:07:03,440
‫Questo è un delegato multicast, proprio come sul componente hit.

102
00:07:03,470 --> 00:07:08,360
‫Ora aggiungeremo componenti per la salute alle nostre pedine e queste saranno basate sulla nostra U.

103
00:07:08,360 --> 00:07:09,860
‫Classe componente salute.

104
00:07:09,860 --> 00:07:16,550
‫Quindi, poiché sappiamo che i nostri pedoni erediteranno questo su qualsiasi delegato di danno, quindi se creiamo la

105
00:07:16,550 --> 00:07:22,640
‫nostra funzione personalizzata nella classe del componente salute, allora possiamo usare questa funzione come callback

106
00:07:22,640 --> 00:07:25,940
‫e associarla a su subisci qualsiasi danno delegare.

107
00:07:25,940 --> 00:07:33,200
‫Quindi, ogni volta che viene generato un evento di danno, il delegato on take any Damage può trasmettere e tutte le

108
00:07:33,200 --> 00:07:37,460
‫funzioni ad esso associate nel suo elenco di chiamate verranno chiamate.

109
00:07:37,460 --> 00:07:42,320
‫Quindi la prossima domanda è come possiamo effettivamente convincere quel delegato a trasmettere?

110
00:07:42,320 --> 00:07:45,080
‫Abbiamo bisogno di un modo per generare un evento danno.

111
00:07:45,080 --> 00:07:52,070
‫Bene, c'è una funzione nelle tue statistiche di gioco che farà proprio questo e si chiama applica danno.

112
00:07:52,070 --> 00:07:58,550
‫Se utilizziamo questa funzione statica dalle tue statistiche di gioco per applicare il danno, l'applicazione del danno richiede

113
00:07:58,550 --> 00:08:02,180
‫una serie di parametri, incluso l'attore che viene danneggiato.

114
00:08:02,180 --> 00:08:09,620
‫Quindi, se chiamiamo applica danno, gli attori che prendono qualsiasi danno delegato verranno licenziati e quella funzione di

115
00:08:09,620 --> 00:08:11,720
‫callback verrà chiamata in risposta.

116
00:08:11,720 --> 00:08:15,830
‫Quindi applicare il danno è ciò che genera l'evento di danno.

117
00:08:15,830 --> 00:08:19,520
‫Quindi, per impostare tutto questo, abbiamo tre passaggi.

118
00:08:19,520 --> 00:08:25,760
‫Innanzitutto, crea una funzione di callback e poiché questa sarà vincolata a subire danni, deve avere i

119
00:08:25,760 --> 00:08:31,550
‫parametri di input corretti in modo che su eventuali danni la chiami e trasmetta tutte

120
00:08:31,550 --> 00:08:33,950
‫le informazioni associate sull'evento di danno.

121
00:08:34,130 --> 00:08:37,970
‫Il passaggio due consiste nell'associare questo callback al delegato.

122
00:08:38,000 --> 00:08:43,850
‫Abbiamo visto come farlo con il delegato hit del componente utilizzando la funzione di aggiunta dinamica.

123
00:08:43,850 --> 00:08:45,530
‫Faremo la stessa cosa qui.

124
00:08:45,530 --> 00:08:52,000
‫E il terzo passaggio consiste nel generare l'evento di danno chiamando la funzione statica di gioco, danno

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

126
00:08:52,670 --> 00:08:56,210
‫Quindi torniamo al codice e iniziamo a configurarlo.

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

128
00:08:56,960 --> 00:09:01,910
‫Quindi siamo qui nel componente salute e aggiungeremo una funzione di callback.

129
00:09:01,910 --> 00:09:05,810
‫Ora, questo può essere nullo e possiamo chiamarlo come vogliamo.

130
00:09:05,960 --> 00:09:08,450
‫Chiamerò questo danno preso.

131
00:09:08,450 --> 00:09:14,870
‫E poiché lo stiamo vincolando a un delegato, deve avere i parametri di input corretti appropriati

132
00:09:14,870 --> 00:09:16,280
‫per quel delegato.

133
00:09:16,310 --> 00:09:23,240
‫Ora, per le funzioni legate al delegato on take any Damage, l'elenco dei parametri di input deve essere il seguente.

134
00:09:23,240 --> 00:09:30,830
‫Il primo è un puntatore attore chiamato Damaged Actor, e questo è come suona.

135
00:09:30,830 --> 00:09:33,320
‫È l'attore che si prende il danno.

136
00:09:33,350 --> 00:09:38,480
‫Il prossimo è un galleggiante chiamato danno e questo è l'importo effettivo del danno.

137
00:09:38,510 --> 00:09:45,950
‫Ora, dopo, abbiamo un puntatore del tipo di danno al costo chiamato tipo di danno.

138
00:09:46,220 --> 00:09:52,430
‫E il motivo per cui abbiamo questo parametro di input è perché Unreal Engine ha il concetto di tipi di danno.

139
00:09:52,430 --> 00:09:59,090
‫Puoi creare tipi di danni personalizzati con dati aggiuntivi che possono informarti di fare cose diverse a seconda del tipo

140
00:09:59,090 --> 00:10:01,100
‫di danno che potresti avere.

141
00:10:01,100 --> 00:10:02,000
‫Danni da fuoco.

142
00:10:02,000 --> 00:10:03,260
‫Danno da veleno.

143
00:10:03,320 --> 00:10:05,570
‫Danni esplosivi e così via.

144
00:10:05,570 --> 00:10:11,330
‫E se desideri implementare funzionalità personalizzate per ogni tipo di danno, lo implementerai nel

145
00:10:11,330 --> 00:10:13,430
‫tuo tipo di danno personalizzato.

146
00:10:13,460 --> 00:10:19,040
‫Ora non stiamo creando il nostro tipo di danno personalizzato, ma poiché stiamo vincolando questa funzione al delegato

147
00:10:19,040 --> 00:10:22,940
‫di assunzione di qualsiasi danno, deve avere questi parametri di input.

148
00:10:22,940 --> 00:10:24,380
‫Quindi lo stiamo includendo qui.

149
00:10:24,410 --> 00:10:32,090
‫Ora il prossimo parametro è un puntatore del controller A e questo è chiamato istigator e Unreal Engine

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

151
00:10:33,350 --> 00:10:38,050
‫Un istigatore è il controllore responsabile del danno.

152
00:10:38,060 --> 00:10:45,110
‫Quindi, se il danno è stato in definitiva causato da un giocatore che controlla una pedina, l'istigatore è il controllore

153
00:10:45,110 --> 00:10:46,820
‫che possiede quella pedina.

154
00:10:46,850 --> 00:10:49,600
‫Ora, non c'è sempre bisogno di essere un istigatore.

155
00:10:49,610 --> 00:10:52,580
‫Se non ce ne fosse nessuno, questo sarebbe semplicemente nullo.

156
00:10:52,580 --> 00:10:59,510
‫E ora ricevo gli scarabocchi rossi in modo da poter inoltrare dichiarare la classe del controller A qui tra parentesi per

157
00:10:59,510 --> 00:11:00,410
‫la funzione.

158
00:11:00,440 --> 00:11:06,980
‫Ora l'ultimo parametro è un puntatore attore A e questo è chiamato Damage Causer.

159
00:11:07,010 --> 00:11:10,370
‫Questo è il vero attore che causa il danno.

160
00:11:10,370 --> 00:11:13,220
‫Questo sarebbe il proiettile stesso.

161
00:11:13,310 --> 00:11:20,670
‫Quindi abbiamo dichiarato questa funzione di callback per danni subiti e proprio come la nostra altra funzione di callback su hit.

162
00:11:20,690 --> 00:11:22,970
‫Questa deve essere una funzione u.

163
00:11:22,970 --> 00:11:28,550
‫Quindi gli daremo la funzione macro solo per assicurarci che funzioni una volta che lo leghiamo al

164
00:11:28,550 --> 00:11:30,620
‫delegato di on take any damage.

165
00:11:30,950 --> 00:11:35,680
‫E ora che l'abbiamo dichiarato, siamo pronti per definirlo nel file CPP.

166
00:11:35,690 --> 00:11:38,540
‫Quindi qui in componenti sanitari, CPP.

167
00:11:38,630 --> 00:11:45,530
‫In fondo, andrò avanti e darò a questo un corpo di funzione e qualificherò completamente la funzione con il

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

169
00:11:46,970 --> 00:11:49,400
‫E ora abbiamo una richiamata.

170
00:11:49,400 --> 00:11:52,400
‫Quindi ora dobbiamo associare questo al delegato.

171
00:11:52,400 --> 00:11:59,180
‫Ma il delegato non esiste sulla componente sanitaria, esiste sugli attori nello specifico.

172
00:11:59,180 --> 00:12:05,970
‫Vogliamo associare questo al delegato di prendere qualsiasi danno nel pedone che possiede questo componente.

173
00:12:05,990 --> 00:12:11,570
‫Quindi, come accediamo al proprietario di questo componente in modo da poterci collegare a uno dei suoi delegati?

174
00:12:11,570 --> 00:12:17,270
‫Bene, lo faremmo e inizieremmo a giocare e il modo in cui possiamo accedere al proprietario di un componente

175
00:12:17,270 --> 00:12:19,460
‫è attraverso la funzione proprietario di git.

176
00:12:19,460 --> 00:12:23,530
‫Se passi il mouse sopra questo, vedrai che restituisce un puntatore attore.

177
00:12:23,540 --> 00:12:27,620
‫Questo è il puntatore all'attore che possiede un componente.

178
00:12:27,620 --> 00:12:32,990
‫I componenti possono essere di proprietà di pedine, possono essere di proprietà di attori, quindi restituirà

179
00:12:32,990 --> 00:12:35,630
‫il proprietario sotto forma di puntatore attore.

180
00:12:35,810 --> 00:12:42,890
‫Quindi abbiamo la nostra funzione di callback e il nostro secondo passo è legarlo al delegato per prendere qualsiasi

181
00:12:42,890 --> 00:12:46,640
‫danno che esisterà sul pedone che possiede il componente salute.

182
00:12:46,790 --> 00:12:53,870
‫Quindi, dal momento che hai esperienza nell'associazione di callback ai delegati, questa sarà la tua sfida nella classe

183
00:12:53,870 --> 00:12:55,100
‫del componente sanitario.

184
00:12:55,100 --> 00:13:02,420
‫In Begin Play, legherai il danno subito al delegato del danno che esiste sul

185
00:13:02,420 --> 00:13:04,190
‫proprietario del componente.

186
00:13:04,190 --> 00:13:08,090
‫Quindi accederai a quel delegato tramite la funzione ottieni proprietario.

187
00:13:08,090 --> 00:13:13,640
‫In altre parole, chiamerai get owner e da lì accederai per subire eventuali danni.

188
00:13:13,640 --> 00:13:20,660
‫E poi da lì sai come associare le richiamate ai delegati usando l'aggiunta dinamica se rimani bloccato, guarda

189
00:13:20,660 --> 00:13:28,250
‫come abbiamo associato la richiamata al momento del colpo al delegato del colpo del componente, sospendi il video e associa

190
00:13:28,250 --> 00:13:31,790
‫il danno subito al delegato del danno subito.

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

192
00:13:35,360 --> 00:13:40,610
‫Quindi siamo tornati qui nel componente salute e siamo pronti per eseguire l'associazione della nostra funzione di callback.

193
00:13:40,610 --> 00:13:47,390
‫Quindi qui e iniziamo a giocare, accederemo al proprietario usando la funzione git owner e da lì

194
00:13:47,390 --> 00:13:54,770
‫useremo l'operatore freccia per accedere a quel delegato chiamato, prendere qualsiasi danno e poi subire qualsiasi danno ha

195
00:13:54,770 --> 00:14:01,520
‫la dinamica di aggiunta funzione e prende semplicemente un oggetto utente e un nome di funzione.

196
00:14:01,520 --> 00:14:05,240
‫Ora l'oggetto utente è l'oggetto per cui stiamo vincolando la funzione.

197
00:14:05,240 --> 00:14:10,130
‫È la classe che ha la funzione di callback su di essa e sarà questa.

198
00:14:10,190 --> 00:14:14,420
‫E finalmente abbiamo la nostra funzione di richiamata, che sarai tu.

199
00:14:14,420 --> 00:14:16,790
‫Danni alla componente salute subiti.

200
00:14:16,790 --> 00:14:23,690
‫Ora dobbiamo ricordare l'indirizzo dell'operatore perché questo prende effettivamente un indirizzo della funzione.

201
00:14:23,690 --> 00:14:31,460
‫Quindi ora il danno subito è destinato a subire qualsiasi danno e viene aggiunto all'elenco delle chiamate di quel delegato.

202
00:14:31,460 --> 00:14:37,790
‫Quindi, ogni volta che generiamo eventi di danno, riceveremo una trasmissione da questo delegato che risulterà nella

203
00:14:37,790 --> 00:14:40,970
‫funzione di presa del danno, che verrà chiamata.

204
00:14:41,570 --> 00:14:48,320
‫Quindi, in sintesi, abbiamo creato il nostro componente di salute e ne abbiamo aggiunto uno sia al progetto del carro

205
00:14:48,320 --> 00:14:50,540
‫armato che al progetto della torre.

206
00:14:50,660 --> 00:14:58,130
‫Abbiamo creato una funzione di callback chiamata Damage Taken e l'abbiamo associata al delegato on take any Damage.

207
00:14:58,130 --> 00:15:05,150
‫Il passaggio successivo consiste nel generare un evento di danno che risulterà nella trasmissione del delegato on take any damage

208
00:15:05,150 --> 00:15:10,640
‫in modo che la nostra funzione di callback danni subiti venga chiamata in risposta.

209
00:15:10,640 --> 00:15:13,520
‫E lo configureremo nel prossimo video.

210
00:15:14,240 --> 00:15:15,140
‫Ci vediamo presto.