‫Quindi, se mi avvicino alle nostre torri, posso vedere che stanno disegnando sfere di debug, dimostrando che stanno chiamando
‫la funzione di fuoco e lo stanno facendo ogni 2 secondi.
‫Ora, in aggiunta a ciò, stanno solo chiamando questa funzione.
‫Se sono nel raggio di tiro, se torno qui, noterai che non stanno disegnando sfere di debug.
‫Quindi questo comporta anche un controllo a distanza.
‫E non appena sono abbastanza vicino, beh, eccoli lì, a disegnare quelle sfere di debug.
‫Ciao e bentornato.
‫Ora abbiamo già creato una funzione di fuoco e la stiamo usando nella classe tank perché l'abbiamo
‫associata alla mappatura dell'azione di fuoco.
‫Ma vorremmo anche riutilizzarlo con la classe tower.
‫Ora, invece di utilizzare l'input dell'utente per la classe tower, utilizzeremo i timer.
‫Creeremo un timer per la classe torre in modo che il timer possa chiamare la funzione di fuoco.
‫Di tanto in tanto imposteremo un numero specificato di secondi tra le chiamate alla funzione di incendio.
‫Quindi, dal momento che vorremmo che la funzione di fuoco venisse chiamata ogni tanto sulla classe tower, ora dobbiamo
‫parlare dei timer.
‫Unreal Engine ha la capacità di impostare i timer usando una classe chiamata F Timer Manager.
‫Esiste un gestore del timer mondiale che gestisce i timer nel mondo.
‫Ora questo gestore del timer mondiale ha una funzione chiamata Imposta timer e imposta il timer richiede un numero di input
‫come una maniglia del timer.
‫Questo è un handle per un timer specifico gestito dal timer manager.
‫Ciò consente al manager di avere più timer e possiamo accedere alle informazioni sul timer per ciascuno utilizzando l'handle del timer
‫come una sorta di nome o ID per quel timer.
‫Questo è un oggetto di tipo F maniglia del timer.
‫Quindi creiamo un handle del timer e lo passiamo alla funzione set timer.
‫Ora impostare il timer richiede anche altri input come la velocità o la quantità di tempo che dovremmo aspettare
‫prima di fare effettivamente qualcosa.
‫Ora qualcosa sarà nella nostra funzione di callback.
‫Creiamo una funzione e leghiamo questa funzione al timer in modo che non appena è trascorso abbastanza tempo, in particolare
‫la frequenza del timer, è possibile chiamare la nostra funzione di callback.
‫Quindi abbiamo visto che abbiamo bisogno di alcune cose per il nostro timer e le collocheremo nella classe
‫torre.
‫Quindi entriamo nella Torre H e qui nel file della Torre H aggiungeremo alcune variabili private.
‫Quindi, appena sotto il raggio di tiro, avremo bisogno della nostra maniglia del timer.
‫Quindi questa è una maniglia del timer F e possiamo semplicemente chiamare questa maniglia del timer della frequenza di fuoco.
‫E abbiamo anche bisogno di una cadenza di fuoco che sia un galleggiante.
‫Chiameremo questa frequenza di fuoco e possiamo inizializzarla su due punti F.
‫In questo modo avremo un'attesa di due secondi prima che la nostra funzione di callback venga effettivamente chiamata.
‫E parlando di funzioni di callback, ne abbiamo effettivamente bisogno.
‫Quindi faremo una funzione void e possiamo chiamare questa condizione di check fire.
‫Quindi abbiamo un handle del timer e non appena impostiamo il timer e inizia a funzionare, abbiamo 2 secondi
‫di attesa prima che il timer si traduca effettivamente nella chiamata della nostra funzione.
‫E chiamo questo check fire condition perché possiamo controllare se la nostra torre dovrebbe essere in grado di chiamare la
‫funzione fire in modo da poter posizionare alcune condizioni che possiamo controllare per assicurarci che il fuoco dovrebbe
‫essere chiamato.
‫Ora abbiamo la funzione di condizione di fuoco dichiarata.
‫Dobbiamo definirlo in modo da poter entrare nella torre CPP e definire qui la funzione.
‫Lo metterò sotto inizio riproduzione, quindi gli darò un corpo di funzione e il nome di una classe tower appena prima
‫del nome della funzione.
‫Quindi ora abbiamo una funzione, ma in realtà dobbiamo impostare il timer in modo che quel tempo inizi a scorrere e
‫la funzione venga chiamata alla fine di quel tempo.
‫E possiamo impostare il timer qui e iniziare a giocare in modo che inizi a funzionare dall'inizio del gioco.
‫Quindi abbiamo menzionato il World Timer Manager e possiamo accedervi con una funzione chiamata Ottieni World Timer
‫Manager.
‫Ora ottieni World Timer Manager, restituisce un oggetto F timer manager.
‫E poiché stiamo usando quel tipo, dovremo includere il file di intestazione per F timer manager.
‫Quindi ecco l'inclusione è semplicemente timer manager h.
‫E possiamo anche vedere alcune delle funzioni che appartengono a questa classe.
‫Quindi scorri questi se sei interessato a tutte le diverse funzioni che appartengono a F
‫timer manager.
‫Quindi possiamo includere questo file di intestazione qui in cima alla torre, appena sotto gli altri include.
‫Quindi ora che abbiamo incluso quel file di intestazione, ora abbiamo accesso al gestore del timer mondiale e
‫la funzione che ci interessa si chiama set timer.
‫Ora get world timer manager restituisce semplicemente un timer manager F non restituisce un puntatore.
‫Quindi useremo il punto invece del.
‫Arrow e chiameremo il timer impostato.
‫Ora il timer impostato ha diverse versioni o sovraccarichi di funzioni.
‫Ora vs code ha questo pop-up che ci consente di esaminare ogni sovraccarico e vedere le diverse versioni di
‫questa funzione.
‫E la versione che mi interessa per prima prende una maniglia del timer F e useremo la nostra maniglia del
‫timer della velocità di fuoco, che abbiamo dichiarato nella Torre H.
‫Ora il prossimo parametro per il nostro particolare sovraccarico di funzione sarà la classe utente, proprio come nell'asse di
‫collegamento e nell'azione di collegamento.
‫Questa è la classe in cui stiamo lavorando in cui stiamo legando la funzione per quella sarà questa.
‫Ora la prossima sarà la funzione di callback che sarà la nostra condizione di incendio di controllo della torre A, quella
‫funzione che abbiamo appena creato.
‫Ora abbiamo bisogno dell'indirizzo dell'operatore perché il timer impostato prende l'indirizzo della funzione.
‫Ora il prossimo parametro è un float per il tasso che sarà quanto tempo dovrebbe trascorrere prima che il
‫nostro callback venga chiamato.
‫Sarà la nostra cadenza di fuoco.
‫E il parametro finale è un booleano che specificherà se questo timer deve essere ripetuto o meno.
‫Ora vorrei che la nostra funzione di richiamata venisse chiamata ogni 2 secondi, quindi voglio che questo timer si ripeta.
‫Quindi dirò vero.
‫Se dovessimo passare in falso, passerebbero 2 secondi.
‫La nostra funzione verrebbe chiamata e sarebbe finita.
‫Ma poiché l'abbiamo impostato su loop, la nostra funzione verrà chiamata dopo 2 secondi, dopodiché il timer si
‫riavvierà, quindi dopo altri due secondi la funzione verrà chiamata di nuovo e continuerà a scorrere fino
‫alla fine del gioco.
‫Quindi ora abbiamo una funzione collegata al nostro timer ed è impostata per essere chiamata ogni 2 secondi.
‫Quindi abbiamo associato una funzione al nostro timer e verrà chiamata ogni 2 secondi.
‫Ma vorremmo una sorta di prova o conferma che questa funzione è stata effettivamente chiamata.
‫Quindi, per la tua sfida nella classe tower, entra nella nostra nuova funzione di richiamata, controlla le condizioni di incendio.
‫Assicurati che il carro armato sia nel raggio di tiro.
‫Controllerai la distanza dalla torre al carro armato.
‫E sappiamo come farlo perché lo stiamo già facendo nella funzione tick.
‫Quindi potresti dover guardare nella funzione tick e vedere come viene fatto per ricordarti, ora controlla quella
‫distanza, assicurati che siamo nel raggio di tiro, e poi se lo siamo, chiama la funzione fire, metti in
‫pausa il video e implementa questo adesso.
‫Bene.
‫Quindi sono tornato in Tower CP e scorrerò fino alla funzione tick per ricordare a me stesso come ho ottenuto questa distanza
‫e ho controllato per vedere se era nel raggio di tiro.
‫Ora potremmo semplicemente riutilizzare questo codice qui sotto e controllare le condizioni di incendio.
‫Ora il riutilizzo del codice non è molto efficiente, quindi potremmo pensare di rifattorizzarlo, ma prima assicuriamoci che funzioni in
‫modo da poter prima controllare il nostro puntatore del serbatoio per assicurarci che sia valido.
‫Quindi lo farò qui e controllerò le condizioni del fuoco.
‫Dirò se tank e se tank sono validi, la prossima cosa che possiamo fare è ottenere
‫quella distanza, che è questo valore qui calcolato con la funzione f vector dist.
‫Quindi lo prenderò e lo metterò quaggiù in condizioni di controllo del fuoco.
‫Ora la prossima cosa che facciamo è controllare se la distanza è inferiore o uguale alla portata di fuoco.
‫Quindi è quello che faremo quaggiù.
‫Diremo se la distanza è inferiore o uguale alla portata di fuoco e, in tal caso, possiamo semplicemente chiamare
‫la funzione di fuoco.
‫Quindi chiameremo fuoco, ed è così semplice.
‫Quindi andiamo avanti e compiliamo questo e torniamo all'editor e vado a premere play e entrare nel raggio
‫di tiro.
‫E posso vedere che le nostre torri stanno disegnando sfere di debug sulla punta della canna, così possiamo
‫vedere che quella funzione di fuoco viene chiamata e funziona allo stesso modo per la torre e per il carro armato.
‫Quindi questo è fantastico.
‫Questo ci sta dimostrando che il nostro timer è in esecuzione e la nostra funzione di richiamata viene chiamata ogni 2 secondi.
‫Ok, quindi abbiamo questa funzione di fuoco chiamata ogni 2 secondi ora sotto controllo, condizioni di fuoco.
‫Abbiamo questa funzionalità in cui vediamo se siamo nell'intervallo e stiamo facendo la stessa cosa esatta qui
‫nella funzione tick.
‫Quindi questa è un'opportunità perfetta per il refactoring.
‫Potremmo creare una sorta di funzione che ci restituirà un valore booleano se siamo nel raggio d'azione del tank.
‫Allora perché non andiamo avanti e semplicemente refactoring rapidamente questo in una funzione di ritorno del toro?
‫Quindi qui nella Torre H, creiamo una funzione privata.
‫Tornerà bool e diremo nel raggio di tiro.
‫Ora questo è un gioco semplice e la nostra torre sarà solo nel raggio di azione del carro armato.
‫Quindi questo non è ambiguo perché non c'è nient'altro che la torre vorrebbe mai controllare per vedere se
‫è nel raggio di azione di adesso, se questo fosse un gioco più complicato con altre cose per cui
‫la torre vorrebbe controllare la distanza, allora potremmo chiamalo in modo leggermente diverso, ma possiamo semplicemente
‫chiamarlo nel raggio di tiro.
‫E quello che ho intenzione di fare è implementarlo qui in Tower.
‫Quindi andiamo avanti e creiamo il corpo della funzione.
‫Avremo bisogno che una torre prefissa il nome della funzione.
‫E quello che faremo qui è fondamentalmente lo stesso controllo della distanza.
‫Quindi controlleremo prima per assicurarci che il serbatoio sia valido con un controllo if.
‫Ora, se lo è, allora possiamo ottenere questa distanza in modo da poter copiare questa linea e creare semplicemente il nostro galleggiante di distanza locale
‫proprio qui e semplicemente controllare quella distanza rispetto al raggio di fuoco in modo da poter dire se la distanza è inferiore
‫o uguale al raggio di fuoco, e se questo è il caso, possiamo semplicemente restituire true.
‫Questa funzione può restituire il valore true.
‫E ora abbiamo una funzione che possiamo chiamare che restituirà true se siamo nell'intervallo.
‫Ora, non appena colpiamo questa riga return true qui nell'istruzione if, la funzione tornerà.
‫Salteremo fuori dalla funzione.
‫Quindi qualsiasi altra cosa dopo questa se l'istruzione non verrà eseguita.
‫Quindi quello che possiamo fare è alla fine della nostra funzione nel raggio di fuoco, possiamo restituire false perché
‫se mai raggiungiamo il return true, non arriveremo mai alla riga return false quaggiù.
‫Usciremo semplicemente dalla funzione in anticipo.
‫Ma se non siamo nel raggio d'azione, se questo controllo della distanza qui fallisce, allora non raggiungeremo mai il ritorno vero.
‫E raggiungeremo la fine della funzione e restituiremo false.
‫Quindi questa funzione restituirà true o false in base al fatto che siamo o meno nell'intervallo e possiamo usarlo
‫invece di usare codice ripetuto nelle nostre due funzioni.
‫Quindi quassù in tick, ad esempio, abbiamo solo bisogno di un singolo controllo per vedere se siamo nel raggio d'azione prima di ruotare la
‫torretta.
‫Quindi quello che possiamo fare è dire se siamo nel raggio di tiro e se questo ritorna vero, siamo nel raggio di tiro, quindi
‫possiamo chiamare ruota torretta.
‫Quindi lo metteremo proprio lì nell'istruzione if.
‫E ora tutto questo codice non è necessario, quindi possiamo semplicemente eliminarlo.
‫E ora questo sembra molto più pulito di quello che avevamo prima.
‫E poi possiamo venire quaggiù e controllare le condizioni del fuoco e fare la stessa cosa.
‫Invece di tutto questo, possiamo semplicemente controllare se nel raggio di tiro.
‫E se lo siamo, possiamo semplicemente chiamare il fuoco.
‫Quindi ora abbiamo rifattorizzato con successo tutto quel codice in un controllo che è stato effettuato nella nostra funzione in campo
‫di fuoco.
‫Quindi andiamo avanti e compiliamolo di nuovo e semplicemente provalo e provalo molto velocemente solo per assicurarci che
‫tutto funzioni come previsto.
‫Quindi andremo avanti e premiamo play e entriamo nel raggio di tiro.
‫E, naturalmente, siamo nel raggio di tiro e funziona correttamente.
‫Quindi, in sintesi, abbiamo creato un timer e ogni 2 secondi chiamiamo la funzione di fuoco nella classe
‫torre.
‫Ora stiamo anche controllando se Tank è nel raggio d'azione.
‫Quindi chiamiamo la funzione di fuoco solo ogni 2 secondi se il carro armato si trova entro la distanza di tiro.
‫E abbiamo anche visto che stavamo usando il controllo della distanza in due diverse funzioni.
‫Quindi l'abbiamo rifattorizzato nella sua funzione e la chiamiamo semplicemente per verificare se siamo nell'intervallo.
‫Quindi ora abbiamo una funzione di fuoco chiamata sulla classe torre.
‫La prossima cosa da fare è iniziare effettivamente a generare proiettili con la nostra funzione di fuoco.
‫Quindi ne parleremo nel prossimo video.
‫Ci vediamo presto.