‫Ehi.
‫Ben tornato.
‫Ora abbiamo il nostro proiettile e sappiamo che sta generando eventi di successo, quindi dobbiamo fare
‫qualcosa quando il proiettile colpisce effettivamente il nostro obiettivo.
‫Ora, questo comporterà fare danni, il che significa che abbiamo bisogno di un modo per tenere traccia della salute.
‫Quindi creeremo una classe per la gestione della salute e del danno chiamata componente della salute.
‫E il motivo per cui questa funzionalità ha una sua classe è che possiamo riutilizzarla per classi diverse come
‫il carro armato e la torre.
‫Quindi discutiamo di questa componente di salute.
‫Ora abbiamo familiarità con la classe del componente use scene.
‫Bene, questa classe è derivata da una classe chiamata componente attore.
‫In effetti, ecco la documentazione del componente della scena d'uso.
‫E nella gerarchia dell'ereditarietà, puoi vedere che il suo genitore è il tuo componente attore.
‫Ora che agisci, un componente è più semplice del componente che hai visto.
‫Non ha trasformazione.
‫Quindi la posizione, la rotazione e la scala non sono qualcosa che il componente del tuo attore ha nemmeno.
‫Non supporta l'allegato.
‫Non è possibile collegare un componente attivo, ad esempio, a un componente mesh statico oa un componente capsula.
‫È solo qualcosa che appartiene all'attore.
‫E poiché non c'è rappresentazione visiva o trasformazione, non abbiamo bisogno di collegarlo a nulla.
‫Confronta questo con il componente della scena d'uso, che in realtà ha una trasformazione e la capacità di attaccarsi
‫ad altri componenti o di avere altri componenti che si attaccano ad esso.
‫Quindi per tenere traccia della salute e prendersi cura dei danni, non abbiamo bisogno di nessuna di queste cose.
‫Quindi agisci che un componente sarà perfetto per questo.
‫Quindi torniamo qui nell'editor e rendiamo il nostro nuovo atto una classe componente.
‫Quindi passeremo agli strumenti e alla nuova classe C++.
‫E se scorro verso il basso, posso vedere il componente attore.
‫Questo è ciò che selezioneremo.
‫Ora stai attento.
‫Non selezionare l'attore.
‫Quella è una classe diversa.
‫In realtà è una classe più grande e ha molte più cose rispetto alla componente attore.
‫Abbiamo bisogno del componente attore in modo specifico, quindi selezionalo, fai clic su Avanti.
‫E questo lo possiamo chiamare semplicemente Componente della Salute.
‫Facciamo clic su Crea classe.
‫Ora qui abbiamo i nostri nuovi componenti di salute e file CP e puoi vedere qui che il tuo componente di salute,
‫la classe che abbiamo appena creato è derivata dal tuo agire come componente.
‫Quindi assicurati di avere il tipo corretto qui e vedrai che ha nella sua U.
‫Macro di classe.
‫Questo meta specifica dove e dice il componente della tabella di spawn dei progetti.
‫Questo è ciò che ci consentirà di aggiungere questo componente direttamente nei progetti, che è ciò
‫che faremo ora.
‫La nuova componente sanitaria si prenderà cura della salute, il che significa che abbiamo bisogno di un paio di variabili.
‫Andiamo avanti e aggiungiamo questi e li renderò privati.
‫Quindi andiamo avanti e aggiungiamo una sezione privata appena sotto quella protetta e possiamo aggiungere un paio di
‫variabili di salute.
‫Ora, questi saranno float e chiamerò il primo Max Health.
‫Questa sarà la quantità massima di salute che possiamo avere e possiamo impostarla su un valore
‫predefinito come 100 F.
‫Ora, oltre alla salute massima, avremo un valore di salute che sarà la salute attuale e questo sarà
‫ciò che cambierà man mano che subiamo danni.
‫Quindi facciamo un altro galleggiante e chiamiamo semplicemente questa salute.
‫Ora possiamo inizializzare la salute a zero F, quindi impostarne il valore e iniziare a giocare.
‫E il motivo per cui lo faremo è perché Max Health avrà la sua proprietà che ci consentirà
‫di impostarla dal pannello dei dettagli.
‫Quindi diamo a questo una proprietà U e facciamolo modificare ovunque.
‫In questo modo possiamo cambiarlo mentre ci stiamo sviluppando.
‫E poi nelle componenti della salute CP qui e iniziare a giocare, possiamo semplicemente impostare la salute uguale al valore della
‫salute massima.
‫In questo modo, all'inizio del gioco, la salute avrà il valore della salute massima anche dopo averla modificata
‫nel pannello dei dettagli.
‫Ok, quindi compiliamo questo e torniamo qui nell'editor, aprirò BP -- tank e aprirò l'editor
‫completo del progetto.
‫E ora posso aggiungere questo componente di salute qui nel pannello dei componenti.
‫Quindi farò clic su Aggiungi e Cerca salute.
‫E qui vediamo la salute.
‫Ora, lo abbiamo chiamato componente di salute in C++.
‫E infatti, il pop up mostra che si chiama componente salute.
‫Quindi rimuove quella parte componente quando la mostra qui.
‫E potresti aver notato che quando cerchi componenti mesh statici o componenti capsula, non vedi
‫nemmeno la parola componente qui per quelli.
‫Quindi fai clic su salute e ora abbiamo il nostro componente salute e vedrai che sotto il componente salute abbiamo
‫salute massima ed è impostato su 100 e non vediamo salute perché non abbiamo esposto quella variabile.
‫Quindi ora BP -- tank ha una componente di salute e dice che il tank possiede questa componente di salute, il BP
‫-- tank.
‫È il proprietario di questo componente sanitario.
‫Compiliamo, salviamo, chiudiamo e apriamo la torretta del pedone BP e apriamo l'editor completo del progetto e possiamo aggiungere anche
‫un componente di salute alla torretta dello stagno.
‫Quindi facciamo clic su aggiungi componenti, cerca salute e seleziona salute.
‫E ora abbiamo anche una componente di salute sulla torre.
‫Quindi compilerò e salverò questi per chiudere e salvare tutti.
‫Quindi ora abbiamo una componente di salute e abbiamo detto che vorremmo avere una componente di salute in modo
‫da poterla riutilizzare con classi diverse.
‫Quindi, se abbiamo una pedina nel mondo, diciamo, la nostra torre, avrà la sua componente di salute e quindi il nostro
‫carro armato potrà avere la sua componente di salute.
‫Ora, quando il nostro proiettile interagisce con uno di questi, ad esempio, quando genera un evento
‫di successo, quando colpisce una di queste cose, le nostre pedine possono attivare alcune funzionalità nella
‫componente salute e modificare quei valori di salute.
‫Mettere la nostra funzionalità di salute in un componente e quindi aggiungere quel componente a una classe presenta alcuni vantaggi
‫rispetto all'alternativa, che sarebbe semplicemente posizionare la funzionalità di salute nella classe del pedone di base,
‫ad esempio, ed ereditarla nel carro armato e nella torre.
‫Vedete, questo ci consente di mantenere piccole le nostre classi di carri armati e torri e di occuparci solo di funzionalità specifiche
‫per quelle classi.
‫Considerando che la componente di salute può essere aggiunta a qualsiasi altro attore, come cose che non agiscono come carri armati
‫o torri.
‫Possiamo creare un muro distruttibile, ad esempio, che potrebbe essere distrutto non appena subisce abbastanza
‫danni.
‫Quindi parliamo un po' di come possiamo farlo accadere ora.
‫Unreal Engine ha funzionalità di danno integrate e il suo sistema danneggiato è in realtà piuttosto sofisticato.
‫Qualsiasi attore nel nostro gioco eredita una serie di eventi di danno, uno dei quali è chiamato a subire qualsiasi danno.
‫Questo è un delegato multicast, proprio come sul componente hit.
‫Ora aggiungeremo componenti per la salute alle nostre pedine e queste saranno basate sulla nostra U.
‫Classe componente salute.
‫Quindi, poiché sappiamo che i nostri pedoni erediteranno questo su qualsiasi delegato di danno, quindi se creiamo la
‫nostra funzione personalizzata nella classe del componente salute, allora possiamo usare questa funzione come callback
‫e associarla a su subisci qualsiasi danno delegare.
‫Quindi, ogni volta che viene generato un evento di danno, il delegato on take any Damage può trasmettere e tutte le
‫funzioni ad esso associate nel suo elenco di chiamate verranno chiamate.
‫Quindi la prossima domanda è come possiamo effettivamente convincere quel delegato a trasmettere?
‫Abbiamo bisogno di un modo per generare un evento danno.
‫Bene, c'è una funzione nelle tue statistiche di gioco che farà proprio questo e si chiama applica danno.
‫Se utilizziamo questa funzione statica dalle tue statistiche di gioco per applicare il danno, l'applicazione del danno richiede
‫una serie di parametri, incluso l'attore che viene danneggiato.
‫Quindi, se chiamiamo applica danno, gli attori che prendono qualsiasi danno delegato verranno licenziati e quella funzione di
‫callback verrà chiamata in risposta.
‫Quindi applicare il danno è ciò che genera l'evento di danno.
‫Quindi, per impostare tutto questo, abbiamo tre passaggi.
‫Innanzitutto, crea una funzione di callback e poiché questa sarà vincolata a subire danni, deve avere i
‫parametri di input corretti in modo che su eventuali danni la chiami e trasmetta tutte
‫le informazioni associate sull'evento di danno.
‫Il passaggio due consiste nell'associare questo callback al delegato.
‫Abbiamo visto come farlo con il delegato hit del componente utilizzando la funzione di aggiunta dinamica.
‫Faremo la stessa cosa qui.
‫E il terzo passaggio consiste nel generare l'evento di danno chiamando la funzione statica di gioco, danno
‫applicato.
‫Quindi torniamo al codice e iniziamo a configurarlo.
‫Bene.
‫Quindi siamo qui nel componente salute e aggiungeremo una funzione di callback.
‫Ora, questo può essere nullo e possiamo chiamarlo come vogliamo.
‫Chiamerò questo danno preso.
‫E poiché lo stiamo vincolando a un delegato, deve avere i parametri di input corretti appropriati
‫per quel delegato.
‫Ora, per le funzioni legate al delegato on take any Damage, l'elenco dei parametri di input deve essere il seguente.
‫Il primo è un puntatore attore chiamato Damaged Actor, e questo è come suona.
‫È l'attore che si prende il danno.
‫Il prossimo è un galleggiante chiamato danno e questo è l'importo effettivo del danno.
‫Ora, dopo, abbiamo un puntatore del tipo di danno al costo chiamato tipo di danno.
‫E il motivo per cui abbiamo questo parametro di input è perché Unreal Engine ha il concetto di tipi di danno.
‫Puoi creare tipi di danni personalizzati con dati aggiuntivi che possono informarti di fare cose diverse a seconda del tipo
‫di danno che potresti avere.
‫Danni da fuoco.
‫Danno da veleno.
‫Danni esplosivi e così via.
‫E se desideri implementare funzionalità personalizzate per ogni tipo di danno, lo implementerai nel
‫tuo tipo di danno personalizzato.
‫Ora non stiamo creando il nostro tipo di danno personalizzato, ma poiché stiamo vincolando questa funzione al delegato
‫di assunzione di qualsiasi danno, deve avere questi parametri di input.
‫Quindi lo stiamo includendo qui.
‫Ora il prossimo parametro è un puntatore del controller A e questo è chiamato istigator e Unreal Engine
‫Damage System.
‫Un istigatore è il controllore responsabile del danno.
‫Quindi, se il danno è stato in definitiva causato da un giocatore che controlla una pedina, l'istigatore è il controllore
‫che possiede quella pedina.
‫Ora, non c'è sempre bisogno di essere un istigatore.
‫Se non ce ne fosse nessuno, questo sarebbe semplicemente nullo.
‫E ora ricevo gli scarabocchi rossi in modo da poter inoltrare dichiarare la classe del controller A qui tra parentesi per
‫la funzione.
‫Ora l'ultimo parametro è un puntatore attore A e questo è chiamato Damage Causer.
‫Questo è il vero attore che causa il danno.
‫Questo sarebbe il proiettile stesso.
‫Quindi abbiamo dichiarato questa funzione di callback per danni subiti e proprio come la nostra altra funzione di callback su hit.
‫Questa deve essere una funzione u.
‫Quindi gli daremo la funzione macro solo per assicurarci che funzioni una volta che lo leghiamo al
‫delegato di on take any damage.
‫E ora che l'abbiamo dichiarato, siamo pronti per definirlo nel file CPP.
‫Quindi qui in componenti sanitari, CPP.
‫In fondo, andrò avanti e darò a questo un corpo di funzione e qualificherò completamente la funzione con il
‫nome della classe.
‫E ora abbiamo una richiamata.
‫Quindi ora dobbiamo associare questo al delegato.
‫Ma il delegato non esiste sulla componente sanitaria, esiste sugli attori nello specifico.
‫Vogliamo associare questo al delegato di prendere qualsiasi danno nel pedone che possiede questo componente.
‫Quindi, come accediamo al proprietario di questo componente in modo da poterci collegare a uno dei suoi delegati?
‫Bene, lo faremmo e inizieremmo a giocare e il modo in cui possiamo accedere al proprietario di un componente
‫è attraverso la funzione proprietario di git.
‫Se passi il mouse sopra questo, vedrai che restituisce un puntatore attore.
‫Questo è il puntatore all'attore che possiede un componente.
‫I componenti possono essere di proprietà di pedine, possono essere di proprietà di attori, quindi restituirà
‫il proprietario sotto forma di puntatore attore.
‫Quindi abbiamo la nostra funzione di callback e il nostro secondo passo è legarlo al delegato per prendere qualsiasi
‫danno che esisterà sul pedone che possiede il componente salute.
‫Quindi, dal momento che hai esperienza nell'associazione di callback ai delegati, questa sarà la tua sfida nella classe
‫del componente sanitario.
‫In Begin Play, legherai il danno subito al delegato del danno che esiste sul
‫proprietario del componente.
‫Quindi accederai a quel delegato tramite la funzione ottieni proprietario.
‫In altre parole, chiamerai get owner e da lì accederai per subire eventuali danni.
‫E poi da lì sai come associare le richiamate ai delegati usando l'aggiunta dinamica se rimani bloccato, guarda
‫come abbiamo associato la richiamata al momento del colpo al delegato del colpo del componente, sospendi il video e associa
‫il danno subito al delegato del danno subito.
‫Bene.
‫Quindi siamo tornati qui nel componente salute e siamo pronti per eseguire l'associazione della nostra funzione di callback.
‫Quindi qui e iniziamo a giocare, accederemo al proprietario usando la funzione git owner e da lì
‫useremo l'operatore freccia per accedere a quel delegato chiamato, prendere qualsiasi danno e poi subire qualsiasi danno ha
‫la dinamica di aggiunta funzione e prende semplicemente un oggetto utente e un nome di funzione.
‫Ora l'oggetto utente è l'oggetto per cui stiamo vincolando la funzione.
‫È la classe che ha la funzione di callback su di essa e sarà questa.
‫E finalmente abbiamo la nostra funzione di richiamata, che sarai tu.
‫Danni alla componente salute subiti.
‫Ora dobbiamo ricordare l'indirizzo dell'operatore perché questo prende effettivamente un indirizzo della funzione.
‫Quindi ora il danno subito è destinato a subire qualsiasi danno e viene aggiunto all'elenco delle chiamate di quel delegato.
‫Quindi, ogni volta che generiamo eventi di danno, riceveremo una trasmissione da questo delegato che risulterà nella
‫funzione di presa del danno, che verrà chiamata.
‫Quindi, in sintesi, abbiamo creato il nostro componente di salute e ne abbiamo aggiunto uno sia al progetto del carro
‫armato che al progetto della torre.
‫Abbiamo creato una funzione di callback chiamata Damage Taken e l'abbiamo associata al delegato on take any Damage.
‫Il passaggio successivo consiste nel generare un evento di danno che risulterà nella trasmissione del delegato on take any damage
‫in modo che la nostra funzione di callback danni subiti venga chiamata in risposta.
‫E lo configureremo nel prossimo video.
‫Ci vediamo presto.