‫Ehi.
‫Ben tornato.
‫Ora ci siamo impostati con una funzione di callback associata al delegato per eventuali danni.
‫E l'ultimo passaggio consiste nel generare effettivamente quell'evento di danno.
‫E vogliamo farlo quando il nostro proiettile colpisce qualcosa.
‫Dopo aver trasmesso per questo delegato, possiamo danneggiare l'oggetto che abbiamo colpito.
‫E trasmetteremo questo evento usando il danno applicato, che appartiene alla classe delle statistiche di
‫gioco.
‫Quindi diamo un'occhiata alla funzione di danno applicata.
‫Ora ecco la documentazione per il danno applicato che dice danneggia l'attore specificato con un danno generico.
‫Quindi questa è una funzione generica per applicare il danno.
‫E cosa fare in risposta alla trasmissione per questo delegato dipende da noi.
‫Ora qui vediamo che dobbiamo includere le statistiche di gioco e nella sintassi vediamo diversi parametri di input.
‫Ora otteniamo effettivamente una descrizione dei parametri.
‫Se continuiamo a scorrere verso il basso, vediamo che l'attore danneggiato sta bene, l'attore che sarà danneggiato dal
‫danno di base è il danno di base per applicare qui una documentazione davvero descrittiva.
‫Grazie.
‫L'istigatore di eventi epici è il controller responsabile di aver causato questo danno.
‫E dice, per esempio, il giocatore che ha sparato con l'arma.
‫Quando dice giocatore, si riferisce a quel controller.
‫Poi abbiamo l'autore del danno, che è l'attore che ha effettivamente causato il danno.
‫Dice la granata che è esplosa.
‫Nel nostro caso, sarà il proiettile ad essere esploso.
‫E infine, abbiamo la classe del tipo di danno, che è una classe che descrive il danno che è stato fatto.
‫Ora tornando nella sezione della sintassi, possiamo vedere i tipi di questi input e vediamo che la classe del tipo
‫di danno è una sottoclasse di e abbiamo visto prima che la sottoclasse TW di soddisferà un parametro di input
‫di classe U.
‫Bene, quando chiamiamo applica danno, possiamo passare in una classe U che rappresenta il tipo di danno che vorremmo
‫usare.
‫Quindi parleremo di come soddisfare questo parametro di input tra un momento.
‫Quindi la funzione statica di gioco della tonalità, il danno applicato, richiederà alcuni parametri di input.
‫Quindi cerchiamo di definire una strategia su come passare i valori appropriati quando chiamiamo questa funzione,
‫abbiamo visto che prima abbiamo bisogno dell'attore danneggiato.
‫Bene, torniamo al CP proiettile dove vorremmo chiamare applica danno.
‫Vorremmo farlo qui al momento giusto e non abbiamo più bisogno di questi registri.
‫Quindi li rimuoverò semplicemente e noterò che il nostro callback su hit ottiene alcuni input passati una volta
‫che viene chiamato.
‫Quando viene trasmesso il delegato di successo del componente on, vedremo che abbiamo un altro attore.
‫Quindi abbiamo accesso all'attore che è stato colpito dal proiettile e questo è l'attore che vorremmo
‫danneggiare.
‫Quindi si prende cura del primo parametro di input.
‫Sarà quell'altro attore.
‫Successivamente, abbiamo bisogno dell'importo del danno, il che significa che il nostro proiettile dovrebbe avere una variabile di danno in
‫modo da sapere quanti danni applicare.
‫Allora perché non andiamo in FX proiettile e aggiungiamo una variabile di danno e questo può essere un float.
‫Quindi possiamo semplicemente chiamare questo danno e possiamo inizializzarlo su un valore, diciamo qualcosa come 50 F
‫e poiché questo è qualcosa con cui probabilmente vorremmo sperimentare, possiamo dare a questo una proprietà
‫U per esporlo e farlo modificare ovunque.
‫Quindi ora abbiamo un importo di danno da trasferire quando chiamiamo prendi danno.
‫Ora il prossimo parametro è l'istigatore e abbiamo visto che questo è di tipo A controller.
‫Allora come prendiamo il controller?
‫Bene, abbiamo visto che possiamo ottenere il proprietario di un particolare componente con la funzione get owner.
‫E questo restituisce l'attore che possiede un particolare componente, questi proiettili vengono generati dinamicamente.
‫Quindi dobbiamo assicurarci che se chiameremo get owner che il proprietario sia impostato ora li stiamo generando
‫dal pedone di base.
‫Quindi se entriamo nel pedone di base.
‫CP Ecco la riga in cui stiamo generando l'attore, ma Spawn Actor restituisce anche un puntatore all'attore che è stato generato
‫in modo da poterlo memorizzare in una variabile locale.
‫Ad esempio, potremmo dire proiettile automatico e assegnare il valore restituito dall'attore di spawn.
‫Ora, se non hai familiarità con auto, consente al compilatore di capire il tipo da assegnare a questa
‫nuova variabile.
‫Se ci passi sopra, vedrai che ha il puntatore a proiettile di tipo A perché questo è ciò
‫che stiamo firmando dalla funzione attore di spawn.
‫Quindi è come se avessimo messo un puntatore a proiettile proprio qui e ora possiamo accedere a quel
‫proiettile appena generato.
‫E il motivo per cui vogliamo farlo è che vorremmo stabilire il suo proprietario.
‫Vorremmo assicurarci che il suo proprietario sia impostato sulla pedina che lo ha generato.
‫Quindi possiamo dire proiettile.
‫E c'è una funzione per questo chiamata set owner.
‫Il proprietario del set prende un attore e lo passeremo in modo che ogni volta che una delle nostre pedine genera
‫un proiettile, fisserà quel proprietario del proiettile.
‫In questo modo, se chiamiamo get owner più avanti, otterremo l'istanza della
‫classe che possiede quel proiettile.
‫Quindi, qui in DHCP proiettile, abbiamo la nostra chiamata alla funzione get owner e possiamo memorizzarla in una variabile
‫locale.
‫Andrò avanti e userò di nuovo auto e chiamerò questo mio proprietario e lo imposterò sul risultato restituito da
‫get owner.
‫Quindi ora abbiamo un puntatore attore locale che memorizza il valore del proprietario.
‫Ora possiamo accedere al controller dell'istigatore da questo attore.
‫Ora, prima di farlo, è una buona idea verificare che il mio proprietario non sia nullo.
‫Quindi dirò che se il mio proprietario è null uguale a null pointer, allora tornerò semplicemente.
‫Ora, se sei se body ha una singola istruzione come questa, puoi metterla sulla stessa riga senza le
‫parentesi graffe nel caso non lo sapessi.
‫E null pointer è una parola chiave in C++ che ti consente di verificare se un puntatore è un puntatore nullo.
‫Quindi, se il mio proprietario è nullo, torneremo presto fuori dalla funzione e non faremo nient'altro.
‫Ora, come dicevo, possiamo ottenere il controller dell'istigatore dal mio proprietario ed
‫è ciò che l'uso della funzione chiamata ottieni controller dell'istigatore.
‫E se passiamo il mouse su questo, vedremo che restituisce un puntatore del controller A.
‫Userò semplicemente auto e memorizzerò questo in una variabile locale che chiamerò istigatore del mio proprietario.
‫Quindi ora sappiamo cosa passare come istigatore.
‫L'input successivo è l'autore del danno e questo è l'attore che fa il danno per il proiettile.
‫Questo sarà semplicemente questo.
‫E questo lascia l'ultimo parametro di input, che è un tipo di danno.
‫E abbiamo visto che è una sottoclasse di cui abbiamo bisogno della classe d'uso corretta per passare.
‫N Ora ecco la documentazione del motore irreale per il tuo tipo di danno.
‫Dice che un tipo di danno ha lo scopo di definire e descrivere una particolare forma di danno e
‫di fornire una via per personalizzare le risposte al danno da varie fonti.
‫Ora, non personalizzeremo il nostro danno.
‫Abbiamo solo bisogno di soddisfare il parametro di input, il che significa che abbiamo bisogno di un valore di classe U che rappresenti
‫questa classe di tipo di danno.
‫Ora in C++, se vogliamo ottenere la classe YOU di una classe particolare come il tipo di danno, possiamo
‫chiamare una funzione chiamata classe statica.
‫Questo è ereditato dalla classe dell'oggetto you.
‫Ora ovviamente stiamo usando il tuo tipo di danno qui, quindi avremo bisogno di quell'intestazione.
‫Quindi dalla documentazione copierò la riga di inclusione e la incollerò qui nella parte superiore del proiettile CP
‫E ora vedrai che questa funzione di classe statica restituisce un puntatore di classe U e quella nuova classe rappresenterà
‫il nuovo tipo di danno Classe C++.
‫Ora, dal momento che non stiamo creando un progetto basato sul tuo tipo di danno e impostando alcuni dati extra, non
‫abbiamo davvero bisogno di una sottoclasse di variabile.
‫Quindi in questo caso possiamo usare la classe statica e questo restituirà una classe U che rappresenta questo tipo.
‫E possiamo memorizzarlo in una variabile, se vogliamo, e chiamerò questa classe del tipo di danno.
‫E questo è ciò che possiamo passare come parametro finale per applicare il danno.
‫Quindi ora abbiamo tutte le informazioni di cui abbiamo bisogno per passare alla funzione di applicazione del danno.
‫Ma prima di farlo, vorrei inserire un paio di controlli per assicurarmi che sia appropriato chiamare
‫questa funzione.
‫Quindi farò una dichiarazione if qui.
‫Innanzitutto, voglio assicurarmi che l'altro attore non sia nullo.
‫Quindi metterò qui un altro attore.
‫Metterò un e qui così posso controllare per assicurarmi che un altro attore non sia uguale a questo attore.
‫Non vogliamo causare danni a noi stessi se siamo il proiettile, ora metterò un'altra estremità e
‫mi assicurerò che l'altro attore non sia uguale al mio proprietario.
‫Non sarebbe positivo se il proiettile stesse causando danni al suo proprietario.
‫E ora se entriamo in questa istruzione if, allora sappiamo che è appropriato chiamare applicare il danno in modo
‫da poterlo fare.
‫E questa sarà la tua sfida.
‫Quindi nella nostra nuova istruzione if nella funzione on hit chiama la tua statica di gioco applica la funzione di danno.
‫Ciò significa che dovrai includere l'intestazione corretta per le statistiche di gioco e sapere quali parametri di
‫input passare.
‫Quindi metti in pausa il video e aggiungi la chiamata alla funzione per applicare danni nella funzione al colpo ora.
‫Bene.
‫Quindi sono qui in Projectile CP e includerò il file di intestazione per le statistiche di gioco e possiamo vedere
‫dalla pagina della documentazione sui danni applicati che l'inclusione è statica di gioco kismet slash.
‫Quindi lo incollerò lì e ora sono pronto a chiamare applica danno.
‫Quindi ti chiamerò statica di gioco applica danni.
‫Ora non appena scrivo le parentesi aperte, viene visualizzato il popup che mi ricorda i parametri di input di cui
‫ho bisogno.
‫E il primo è l'attore danneggiato e quello sarà l'altro attore.
‫Quindi digiteremo un altro attore dopo.
‫Abbiamo bisogno dell'ammontare del danno e abbiamo aggiunto questo danno fluttuante nel proiettile FX, che abbiamo impostato su 50.
‫Quindi passerò la fine del danno dopo.
‫Abbiamo bisogno dell'istigatore e abbiamo l'istigatore del mio proprietario.
‫Quindi passerò per istigatore del mio proprietario.
‫Il prossimo è il causa del danno.
‫E, naturalmente, il proiettile stesso è la causa del danno.
‫Quindi passeremo in questo.
‫E infine abbiamo bisogno della sottoclasse del tipo di danno per te che sappiamo che un puntatore di classe U lo soddisferà ed è per
‫questo che abbiamo la nostra classe di tipo di danno.
‫Quindi passiamo alla classe del tipo di danno.
‫E con questo ora chiamiamo applicare il danno.
‫Quindi, quando chiamiamo questo, genereremo l'evento di danno e il delegato di assunzione di qualsiasi danno trasmetterà in risposta a
‫questo, il che significa che nella nostra componente di salute verrà chiamato il danno subito.
‫Quindi dobbiamo solo fare qualcosa qui per i danni subiti.
‫Bene, avrebbe senso prendere questo danno e sottrarre quell'importo dalla salute.
‫Prima di farlo, però, vorrei assicurarmi che il danno non sia inferiore o uguale a zero.
‫F Ha senso fare questi controlli prima di documentare i danni, solo per essere sicuri di non applicare un valore
‫che non ha alcun senso, come zero o un valore negativo.
‫Quindi, se è così, torneremo semplicemente.
‫E ovviamente, se vuoi essere bravo e fare quello che ho fatto io in proiettile al CP, possiamo piazzare il ritorno
‫proprio lì.
‫Ora, se superiamo questa linea, il danno è un valore positivo, quindi possiamo prendere salute e usare meno
‫uguale al danno.
‫E solo per assicurarci che funzioni, perché non inseriamo un registro euy qui?
‫Quindi registro Yui, testo di avviso temporaneo e possiamo semplicemente stampare il valore di salute con percentuale F e salute e
‫con quello possiamo compilare.
‫Ora, con una compilazione riuscita, torneremo nell'editor e con il nostro registro di output aperto, premiamo
‫play.
‫Ora vediamo se riusciamo a essere colpiti da un proiettile.
‫E ci andiamo.
‫La nostra salute ora è scesa a 50 e se veniamo colpiti di nuovo, abbiamo avuto un bel po' di eventi
‫di successo perché stavamo colpendo il proiettile molte volte molto rapidamente.
‫Ma vediamo che la nostra salute si sta documentando correttamente.
‫Quindi dobbiamo assicurarci di attuare il comportamento corretto alla morte quando la salute raggiunge lo zero.
‫Ma dobbiamo anche assicurarci che questo evento di successo non venga spammato più volte.
‫Ora sappiamo che il proiettile dovrebbe essere distrutto dopo aver colpito qualcosa, quindi il modo migliore per prevenire
‫lo spamming dell'evento hit è distruggere il proiettile.
‫Quindi questa è l'ultima cosa che faremo in questo video.
‫Quindi, di nuovo nel proiettile subito dopo aver applicato il danno, quello che possiamo fare è fare in modo che il proiettile si distrugga da solo e
‫non potrebbe essere più facile.
‫Chiamiamo semplicemente la funzione di distruzione.
‫Quindi con un'altra compilazione qui nell'editor, possiamo andare avanti e essere colpiti da un proiettile e guardare quello.
‫Il proiettile è sparito.
‫Quindi fa il suo danno e poi scompare.
‫E ovviamente possiamo anche provare a colpire le torri facendole esplodere con proiettili e assicurandoci che quegli
‫eventi di successo si attivino.
‫E come puoi vedere, posso spammare questo con un sacco di proiettili e vedremo che il
‫valore della salute per questa povera torre qui sta diventando molto, molto negativo.
‫Quindi, in sintesi, abbiamo chiamato la funzione di applicazione del danno e questo ha portato a una trasmissione per il delegato alla
‫presa di qualsiasi danno.
‫Abbiamo documentato la salute nella componente salute e abbiamo distrutto il proiettile.
‫Quindi ora ci siamo occupati del danno.
‫Non ci siamo ancora occupati della morte.
‫Quindi questa sarà una delle prossime cose che tratteremo in un video futuro.
‫Ci vediamo presto.