‫Bene.
‫Quindi il nostro obiettivo per questo video è implementare la morte per i nostri Pons.
‫Quindi, se vengo colpito un paio di volte dalla nostra torre, vedrai che sono scomparso perché il mio carro armato è
‫morto.
‫E se sono abbastanza abile, se posso andare avanti e distruggerne uno, vedrai che anche lui
‫scompare.
‫Quindi implementeremo la morte per queste pedine in questo video.
‫Ciao e bentornato.
‫Ora stiamo già applicando danni alle pedine quando vengono colpite dai proiettili.
‫Ora dobbiamo capire come ci comporteremo dopo la morte.
‫Ciò significa che avremo bisogno di una sorta di funzione per gestire la distruzione di un particolare attore.
‫Quindi creeremo una funzione di distruzione degli handle.
‫Abbiamo anche bisogno di un attore morto per funzionare, il che può consentire alla modalità di gioco di gestire ciò che accade
‫quando un attore nel nostro mondo muore e chiameremo questo attore morto funzione quando il valore della salute raggiunge lo
‫zero per una particolare pedina.
‫Quindi parliamo un po' di una tabella di marcia su come implementeremo questo sistema.
‫Sappiamo che abbiamo un proiettile e sta chiamando applica danno e questo si traduce nella funzione di presa
‫del danno che risponde a quella trasmissione del delegato nel componente salute.
‫Quindi dobbiamo capire cosa fare da lì.
‫Bene, la nostra modalità di gioco può avere una funzione da gestire quando un attore muore.
‫Quindi, nel danno subito, possiamo controllare se la salute raggiunge lo zero.
‫E a quel punto possiamo chiamare l'attore morto funzione sulla modalità di gioco e da lì la nostra pedina può
‫gestirne la distruzione.
‫Quindi alla fine spetterà alla modalità di gioco chiamare la funzione di distruzione del manico sull'attore che è
‫morto.
‫Quindi abbiamo un po' di un piano di gioco, quindi delineiamo i passaggi da intraprendere per implementarlo.
‫Per prima cosa, creeremo la funzione di distruzione della maniglia e la posizioneremo sulla classe di pedone
‫di base per gestire la funzionalità che dovrebbe verificarsi quando una delle nostre pedine muore.
‫E lo implementeremo anche nelle classi tank e tower, poiché ciascuna di esse avrà la propria
‫funzionalità unica quando morirà, quindi creeremo una funzione attore morto e la posizioneremo nella classe della modalità di
‫gioco in modo da poterlo chiama la distruzione dell'handle da lì.
‫Dopodiché chiameremo handle distruzione nella funzione attore morto nella modalità di gioco e quindi possiamo
‫chiamare attore morto dal componente salute quando la salute raggiunge lo zero.
‫Quindi iniziamo con il nostro primo passaggio creando la funzione di distruzione degli handle.
‫Quindi sono qui in Base Pond H e vorrei aggiungere questa funzione di distruzione della maniglia.
‫Ora ho intenzione di chiamarlo dalla modalità di gioco, il che significa che dovrà essere una funzione
‫pubblica in modo da poter posizionare questa funzione qui nella sezione pubblica.
‫Sarà nulla e lo chiamerò gestire la distruzione.
‫Ora, non ha bisogno di prendere alcun parametro di input.
‫Gestirà semplicemente la distruzione di questa particolare pedina.
‫Quindi implementiamo questa funzione nel file CP del pedone di base e lo posizionerò proprio qui sotto
‫il costruttore.
‫Quindi ho la distruzione dell'handle e inserirò il nome della classe del pedone di base appena prima del nome della funzione
‫qui.
‫Ora questo accadrà quando una qualsiasi delle pedine basate sulla pedina base muore.
‫Quindi inserirò qui un'attività che dice cosa faremo nella funzione di distruzione del manico.
‫Mi piacerebbe gestire tutti gli effetti visivi e sonori qui che hanno a che fare con la morte del pedone.
‫Quindi dirò solo effetti sonori visivi slash e lo lasceremo così e ci assicureremo di ricordarci di
‫implementarlo quando arriveremo agli effetti speciali e ai suoni che fanno parte di questa sezione del
‫corso.
‫Ora abbiamo qui la distruzione della maniglia, ma vorrei anche inserire una funzione di distruzione della maniglia in
‫entrambe le classi tank e tower per gestire cosa succede quando quelle pedine muoiono.
‫E l'implementazione più semplice della distruzione sarà forse per la nostra torre.
‫Quindi entriamo nella Torre H e qui aggiungeremo una funzione pubblica chiamata handle distruzione.
‫Quindi dirò void handle distruzione e implementerò questo e torrerò CP appena sotto la funzione
‫tick.
‫Quindi ecco spuntare qui è gestire la distruzione e ho intenzione di anteporre il nome della funzione con una torre proprio come
‫quella.
‫Ora nella funzione di distruzione della maniglia per la torre, vorrei chiamare la versione super in modo che venga chiamata la
‫distruzione della maniglia nel pedone di base e otterremo quegli effetti visivi e sonori quando una torre muore.
‫Quindi dirò che super gestisci la distruzione solo per assicurarmi che venga chiamato.
‫E dopo, distruggerò semplicemente la torre.
‫Ora abbiamo visto come funziona.
‫Chiamiamo semplicemente la funzione di distruzione e questa gestirà la distruzione della torre.
‫Quindi posso salvare questo e chiudere i file tower e CP e ora posso inserire una funzione di distruzione
‫della maniglia nella classe tank.
‫Quindi andrò a tank e dichiarerò una funzione pubblica qui sotto la funzione tick chiamata
‫handle distruzione.
‫E andrò su Tank CP e implementerò questo proprio sotto il tic qui, senza dimenticare di anteporre al
‫nome della funzione un tank.
‫Ora, proprio come nella classe della torre, vorremmo chiamare distruzione del super manico.
‫E in questo modo otterremo quegli effetti visivi e sonori.
‫Ora per il carro armato, faremo qualcosa di leggermente diverso.
‫Vorrei nascondere il carro armato piuttosto che distruggerlo.
‫E poi possiamo disabilitare la sua funzionalità TIC in modo che esista ancora nel mondo e lo possederemo ancora.
‫Quindi otteniamo ancora quella vista dalla telecamera.
‫Solo che non saremo in grado di vederlo o spostarlo.
‫Quindi per nascondere il tank possiamo chiamare una funzione chiamata set attore nascosto nel gioco e questo prenderà un booleano.
‫E se passiamo in true allora nasconderemo efficacemente il carro armato.
‫Ora vorrei anche disabilitare il ticchettio e c'è anche una funzione per quello.
‫Si chiama set attore tic abilitato.
‫E per questo passerò in false, il che disabiliterà il ticchettio per il serbatoio.
‫Quindi questo si occupa della nostra funzione di distruzione della maniglia.
‫Quindi abbiamo la nostra funzione di distruzione della maniglia.
‫Il nostro prossimo passo è creare una funzione attore morto nella modalità di gioco.
‫Quindi implementiamolo.
‫Quindi sono qui nella modalità di gioco dei carri armati e qui posso creare la funzione attore morto ora ho intenzione di chiamare
‫attore morto dalla classe componente salute, il che significa che anche questa deve essere una funzione pubblica.
‫Quindi aggiungerò una sezione pubblica e creerò la funzione attore morto.
‫Ora questo sarà nullo e lo chiamerò attore morto.
‫E questo può semplicemente richiedere un puntatore di un attore chiamato Dead Actor e ora possiamo implementare l'attore morto nella modalità di gioco
‫dei carri armati.
‫CP Quindi lo metto qui e prefisso il nome con una modalità di gioco di carri armati e ora abbiamo una funzione
‫di attore morto.
‫Ora vorrei controllare se l'attore morto è il tank, il che significa che avrò bisogno di una variabile
‫per il tank.
‫Quindi torna alla modalità di gioco dei carri armati.
‫Creerò una sezione privata e aggiungerò una variabile tank che andrò a
‫dichiarare.
‫Ed è di tipo A tank pointer e lo chiamerò semplicemente tank e avrò bisogno di inizializzarlo
‫con l'indirizzo del tank pond, e posso farlo e iniziare a giocare.
‫Ora abbiamo visto che l'inizio del gioco è una funzione protetta e la manterremo protetta qui nella modalità di
‫gioco in modo da poter ignorare, iniziare, giocare.
‫Quindi dirò vuoto virtuale, inizia, gioca, annulla e posso implementarlo qui in carri armati, modalità di gioco.
‫Sì.
‫Quindi sarà vuoto iniziare a giocare e userò i carri armati, il nome della classe della modalità di gioco.
‫E la prima cosa che farò è chiamare Super Begin Play.
‫In questo modo otteniamo la funzionalità genitore e posso ottenere la pedina del giocatore usando le statistiche di gioco.
‫Quindi includerò prima le statistiche di gioco e questo è nelle statistiche di gioco kismet slash come abbiamo
‫già visto.
‫E qui posso prendere Tank e assegnargli il valore della statica di gioco giovanile.
‫Palma del chitarrista.
‫Ora, questo richiede un oggetto di contesto mondiale per il quale possiamo usarlo, e userò zero come indice
‫del giocatore poiché il nostro carro armato sarà sempre giocatore zero.
‫Ora sappiamo che il jet player -- restituisce un puntatore A -- e il tank è di tipo A tank, una classe figlio.
‫E abbiamo visto che dobbiamo eseguire il cast di una classe tank se vogliamo memorizzare questo risultato in un puntatore tank
‫A.
‫Quindi prima includerò l'intestazione del serbatoio.
‫Quindi dirò includi tank H e poi lancerò su un tank.
‫Quindi dirò cast a un tank e lancio il valore restituito da get player --.
‫Quindi lo metterò tra parentesi qui.
‫E ora avremo un puntatore al giocatore -- sotto forma di un puntatore del serbatoio A.
‫Quindi ora che abbiamo il carro armato, possiamo controllare se il nostro attore morto è il carro armato.
‫Quindi possiamo dire che se l'attore morto double è uguale a tank ora tank potrebbe essere nullo.
‫E va bene perché se Tank è null e l'attore morto si riferisce al tank stesso, questo fallirà il controllo
‫if e non tenteremo effettivamente di accedere a un puntatore nullo perché non arriveremo all'interno
‫di questo.
‫Ora, se l'attore morto è in realtà il carro armato, allora vorrei chiamare la funzione di distruzione della maniglia del carro armato.
‫Quindi chiameremo distruzione della maniglia del carro armato.
‫Ora, dopo aver chiamato la funzione di distruzione dell'handle, vorrei anche disabilitare l'input per il tank pod
‫in modo da poter ottenere il tank e chiamare la funzione incorporata che il tank eredita chiamata disable input.
‫Ora disabilitare l'input richiede un controller del giocatore A.
‫Ora sappiamo che la classe tank, se veniamo qui nel tank H ha questa variabile ref del controller del giocatore, che è
‫un puntatore a un controller del giocatore, motivo per cui sto iniziando a pensare che ref sia un nome molto
‫orribile per questa variabile .
‫Dal momento che non è un riferimento, è un puntatore.
‫Quasi preferirei chiamarlo controller del giocatore di carri armati.
‫Quindi, in effetti, perché non andiamo avanti e rinominiamo questo?
‫Questo è qualcosa che gli sviluppatori fanno spesso quando si rendono conto di aver assegnato una variabile, una cattiva reputazione.
‫Quindi questo codice ha un modo per farlo facilmente.
‫Posso evidenziare questa variabile e premere il tasto F due e mi chiede di rinominarla.
‫Chiamerò questo controller del giocatore di carri armati.
‫Ora controlla questo.
‫Si chiama Tank Player Controller qui.
‫Se vado a Tank CP, vedrò che anche qui è stato rinominato.
‫Quindi non dovevo andare a cercarlo e trovare ogni istanza di player, controller, ref.
‫Posso cercare il controller del giocatore di carri armati e vedere che è cambiato ovunque sia usato qui.
‫Quindi è una bella abilità di refactoring da avere.
‫Quindi, comunque, qui nella modalità di gioco dei carri armati, ho bisogno di disabilitare l'input per il carro armato e questo richiede
‫un controller del giocatore.
‫Quindi prima verificherò per assicurarmi che il controller del giocatore del carro armato sia valido dicendo se il carro armato e ho
‫bisogno di accedere a quel controller del giocatore.
‫Ma ricorda che in tank, la nostra variabile del controller del giocatore è privata.
‫Ora potremmo esporlo e renderlo pubblico, oppure potremmo creare una funzione getter pubblica per questa variabile.
‫Preferirei fare un getter pubblico in quanto è una migliore pratica di programmazione.
‫Quindi, qui nella sezione pubblica, creerò un getter pubblico per il controller del giocatore di carri armati.
‫Ora restituirà un puntatore del controller del giocatore A e questa funzione verrà chiamata
‫get tank player.
‫I getter del controller sono in genere il nome della variabile con get in primo piano, e in genere hanno anche
‫un costo in quanto questa funzione non è progettata per modificare nulla in questa classe, restituirà solo il controller
‫del giocatore.
‫Quindi diremo di restituire il controller del giocatore di carri armati e questo è tutto ciò che farà.
‫Quindi ora che abbiamo una funzione getter pubblica per il controller del giocatore del carro armato, possiamo accedere al
‫controller del giocatore qui dalla modalità di gioco.
‫Quindi diremo se il carro armato ottiene un controller del giocatore di carro armato e fa chiamare quella funzione qui.
‫E se raggiungiamo l'interno di questa istruzione if, allora il controller del giocatore è valido,
‫quindi possiamo spostare questa chiamata all'input disabilitato del carro armato proprio qui e passeremo all'input disabilitato il controller del giocatore del
‫carro armato.
‫Quindi chiameremo anche tank get player controller qui.
‫Ora, mentre accediamo al controller del giocatore, vorrei anche prendere i controller del giocatore per
‫mostrare la variabile membro booleana del cursore del mouse e impostarlo su false.
‫Quindi stiamo disabilitando l'input e ci stiamo anche assicurando che il cursore del mouse non sia mostrato.
‫In modo che si occupi della gestione della funzionalità per quando il serbatoio muore.
‫Ora, nel caso in cui l'attore morto non sia il carro armato, mi piace controllare per vedere se è
‫un'istanza della classe torre.
‫Quindi ho intenzione di aggiungere un altro se qui.
‫Quindi quale sarà il condizionale per quest'altro se qui?
‫Bene, mi piacerebbe vedere se l'attore morto può essere scelto per una torre A, il che significa che dovrò includere
‫la classe torre.
‫Quindi includi la torre.
‫E poi proverò a lanciare.
‫Quindi dirò cast, che prende parentesi angolari e parentesi.
‫E anche quello che stiamo lanciando è una torre e quello che stiamo lanciando è morto.
‫L'attore tenterà di scegliere l'attore morto.
‫Ora possiamo effettivamente prendere il risultato di questo cast, assegnarlo e creare una variabile locale.
‫Qui nel condizionale possiamo dire un puntatore di torre e possiamo chiamare questa torre distrutta e assegnarle il valore
‫restituito da questo cast.
‫E se lo facciamo, allora abbiamo accesso a questo attore distrutto, che è il nostro attore morto lanciato su una
‫torre.
‫Ora, se questo ha successo, arriveremo all'interno dell'altro.
‫E poi possiamo prendere il nostro distrutto.
‫Tower e possiamo semplicemente chiamare la distruzione del manico.
‫Quindi ora abbiamo una funzione di attore morto qui nella modalità di gioco che chiama la gestione della distruzione e
‫gestisce anche alcune funzionalità relative alla morte per il carro armato.
‫Quindi questo si occupa del passaggio due.
‫La creazione di un attore morto funzione e mentre eravamo lì abbiamo anche chiamato maniglia distruzione nella
‫funzione attore morto.
‫Quindi il nostro ultimo passo è chiamare l'attore morto quando la salute raggiunge lo zero.
‫Ora, per chiamare questa funzione che esiste nella modalità di gioco, il nostro componente di salute avrà bisogno di una
‫variabile che memorizzi l'indirizzo della modalità di gioco.
‫Quindi entriamo nella nostra classe dei componenti della salute.
‫Ecco i componenti della salute e aggiungerò una variabile privata qui proprio in fondo.
‫E questo sarà di tipo A puntatore della modalità di gioco dei carri armati e lo chiameremo modalità di gioco dei carri armati.
‫Ora lo dichiarerò in avanti, quindi non devo includere il suo file di intestazione qui e quindi dobbiamo
‫accedere alla modalità di gioco.
‫Quindi andiamo alla componente salute CP e se scorro verso l'alto, vedo la funzione di inizio del gioco qui ed è il
‫posto perfetto per controllare la modalità di gioco.
‫Ancora una volta, inserirlo nel costruttore è troppo presto.
‫Dobbiamo assicurarci che la modalità di gioco sia stata costruita ed esista prima di provare ad accedervi.
‫Ora ecco una pratica funzione sulle statistiche di gioco chiamata Ottieni modalità di gioco e dice che restituisce la base della modalità
‫di gioco corrente o null se non può essere recuperata come sul client.
‫Ora il client ha a che fare con la programmazione multiplayer e non dobbiamo preoccuparcene.
‫Stiamo girando sull'unica macchina per il nostro gioco, quindi scorriamo verso il basso e vedremo che una modalità di
‫gioco base prende un oggetto di contesto mondiale.
‫Questo è solo un oggetto nel mondo e abbiamo visto come gestire gli oggetti del contesto mondiale.
‫Quindi questo esiste nel gameplay statico h, quindi includiamolo.
‫E qui nei componenti della salute, CP incollerà la nostra inclusione per le statistiche di gioco e quindi chiameremo la modalità
‫di gioco qui e inizieremo a giocare.
‫Quindi diremo carri armati, modalità di gioco.
‫E impostalo sul valore di te.
‫Le statistiche di gioco ottengono la modalità di gioco e l'oggetto contesto mondiale.
‫Passerò in questo e ora abbiamo la modalità di gioco.
‫Ma ovviamente ottieni la modalità di gioco, restituisce una modalità di gioco di base e stiamo tentando di memorizzarla
‫nella classe figlio, una modalità di gioco di carri armati, il che significa che dovremo lanciare.
‫Giusto.
‫Quindi dobbiamo dire cast a una modalità di gioco tune tank e stiamo lanciando il risultato della modalità di gioco get.
‫Quindi lo metterò tra parentesi lì.
‫E stiamo usando la modalità di gioco dei carri armati.
‫Quindi includerò quel file di intestazione in alto.
‫Quindi dirò include.
‫Tune Tanks modalità di gioco.
‫Quindi abbiamo la modalità di gioco qui nella componente salute.
‫Siamo pronti a scendere quaggiù nei danni subiti e controllare se la nostra salute raggiunge lo zero.
‫E in tal caso possiamo usare il nostro puntatore della modalità di gioco dei carri armati per chiamare la funzione che l'attore
‫è morto passando l'attore che è morto e questa sarà la tua sfida, quindi nella classe dei componenti della salute in danno
‫subito controllerai per vedere se il valore della salute ha raggiunto lo zero o è sceso sotto lo zero.
‫In tal caso, l'attore della chiamata è morto utilizzando la modalità di gioco.
‫Dal momento che abbiamo un puntatore alla modalità di gioco, non dimenticare di controllare prima se questo puntatore non
‫è nullo.
‫E una volta che chiami l'attore morto, dovrai far passare un attore.
‫Passerai l'attore che è morto.
‫Quindi metti in pausa il video e implementalo ora nella funzione danno subito.
‫Bene.
‫Quindi abbiamo già sottratto i danni alla salute.
‫Ora siamo pronti per verificare se quel valore di salute ha raggiunto lo zero.
‫Quindi dirò se la salute è inferiore o uguale a zero F e se è così, allora è
‫appropriato chiamare.
‫L'attore è morto ora perché dobbiamo verificare se la modalità di gioco è valida.
‫Posso inserire un annuncio qui in questo se controllo e controllo per vedere se la modalità di gioco dei carri armati è valida.
‫Se è nullo, verrà restituito false qui e non raggiungeremo l'interno dell'istruzione if.
‫Quindi, se raggiungiamo l'interno dell'istruzione if, la modalità di gioco dei carri armati è valida e la salute ha raggiunto lo
‫zero.
‫Quindi possiamo dire sintonizzare i carri armati, la modalità di gioco.
‫E possiamo dire che l'attore è morto.
‫E questo richiede un attore e sappiamo che l'attore che è morto sarà l'attore danneggiato.
‫Quindi passeremo per attore danneggiato.
‫E ora possiamo compilare questo e guardare quello.
‫Abbiamo una compilazione di successo.
‫Quindi torniamo all'editor.
‫E qui nell'editor, perché non andiamo avanti e testiamo la morte?
‫Vediamo se riesco a distruggere alcuni di questi carri armati prima di essere distrutto io stesso.
‫Sarà una specie di sfida.
‫Oh, ce n'è uno.
‫Ne ho ucciso uno e ho preso il secondo.
‫Oh, e sono morto.
‫Quindi puoi vedere che questo gioco è molto più divertente ora che abbiamo aggiunto morte e distruzione ai nostri stagni.
‫Quindi questo è fantastico.
‫Ok, quindi quello che voglio che tu faccia è darti una pacca sulla spalla, perché in questo video
‫abbiamo trattato la morte dell'attore, che implica un po' di interazione tra queste classi nel nostro gioco.
‫Ora il modo in cui la morte viene implementata è che lo stagno semplicemente scompare, il che significa che abbiamo ancora bisogno di
‫alcune cose.
‫Abbiamo bisogno di condizioni vincenti perse.
‫Abbiamo bisogno di un modo per mostrare al giocatore che ha vinto o perso la partita.
‫E abbiamo anche bisogno di quegli effetti speciali.
‫Abbiamo bisogno di alcuni suoni, abbiamo bisogno di alcune esplosioni.
‫Queste cose arriveranno molto, molto presto.
‫Quindi congratulazioni.
‫Hai già fatto molta strada e mancano solo pochi passi da fare.
‫Ci vediamo nel prossimo video.