‫Ciao e bentornato.
‫Ora abbiamo il movimento per il --, ma non stiamo ruotando quella parte superiore del --, che
‫chiamiamo torretta.
‫Quindi vorremmo poterlo fare usando il nostro mouse.
‫Ora, dai un'occhiata a cosa sta succedendo qui.
‫Mentre sposto il cursore del mouse nel mondo, ricevo questa sfera rossa.
‫Questa è una sfera di debug che sto disegnando nello spazio 3D.
‫Ora nota mentre mi sposto contro un muro, quella sfera si muove contro la superficie del muro.
‫Quindi, ovunque si muova il cursore del mouse, ho questa paura che corrisponde a qualsiasi oggetto che sto
‫colpendo in base alla posizione del mio cursore.
‫E questo ci sarà utile in modo da poter avere una posizione nello spazio verso la quale possiamo ruotare la
‫nostra torretta.
‫Ora, per fare ciò, ci sono alcune funzioni di cui abbiamo bisogno sul controller, quindi dobbiamo accedere a
‫quelle funzioni sul controller.
‫E in questo video lavoreremo sull'impostazione e discuteremo anche di come questo
‫comporterà un concetto noto come casting.
‫Ora, il motivo per cui vogliamo il controller è perché ci sono funzioni sul controller che ci consentono di
‫ottenere il risultato del colpo sotto il cursore.
‫Ora stiamo parlando del cursore del mouse.
‫Quindi diciamo che questo è il nostro schermo ed ecco il nostro cursore del mouse.
‫E il punto sulla punta del cursore corrisponde a una posizione sullo schermo.
‫Ora, se spostiamo il cursore, il nostro obiettivo è che la parte della torretta del nostro carro armato, quella
‫parte superiore della nostra mesh, ruoti in modo che sia rivolta nella direzione di quel cursore.
‫Ora, se spostiamo il cursore, c'è una funzione sul controller che possiamo usare per ottenere
‫la posizione corrispondente a quel cursore.
‫Se dovessimo tracciare una linea direttamente dalla telecamera verso il cursore e colpire un
‫oggetto nel mondo, possiamo ottenere quella posizione e usarla per impostare la rotazione della torretta del carro armato.
‫Lascia che ti mostri cosa intendo.
‫Ora, per ottenere questa posizione del colpo corrispondente al nostro cursore, dobbiamo usare il controller.
‫Ora, parliamo per un breve momento del controller.
‫Diciamo che abbiamo la nostra pedina nel mondo.
‫Una pedina avrà un controller.
‫Questo è un oggetto invisibile associato al pedone.
‫Ora, per la nostra pedina, il nostro controller avrà il controller del giocatore di tipo A
‫e all'inizio del gioco, il controller possiederà la pedina.
‫Questo è il motivo per cui possiamo vedere dal punto di vista della telecamera che appartiene al nostro carro armato dei pedoni.
‫Ora possiamo accedere a questo controller.
‫La nostra classe tank eredita una funzione chiamata Get Controller.
‫È ereditato dalla classe --.
‫Quindi quello che vorremmo fare è prendere quel controller e memorizzarlo in una variabile in modo da poterlo usare per accedere
‫alla funzione di cui abbiamo bisogno per ottenere il risultato del colpo sotto il cursore.
‫Quindi prepariamoci a questo.
‫Ora sono qui nella classe tank e il punto in cui dobbiamo accedere al nostro controller è iniziare a giocare.
‫Se lo facciamo nel costruttore, è troppo presto e potremmo non avere ancora un controller valido.
‫Quindi avremo bisogno della funzione di inizio del gioco qui nella classe tank.
‫Ora l'abbiamo qui nella classe di base pong e finora non stiamo davvero usando l'inizio del gioco nella classe di
‫base pong.
‫Quindi quello che mi piacerebbe fare è spostarlo nella classe dei carri armati.
‫Quindi evidenzierò l'inizio del gioco, incluso il commento e la sezione protetta qui e
‫lo taglierò semplicemente.
‫E poi di nuovo nella fase del serbatoio, lo incollerò.
‫Aggiungiamo questa sezione protetta qui appena sopra la sezione privata con l'inizio del gioco all'interno.
‫Ora abbiamo rimosso Begin Play dal pedone base.
‫Non lo abbiamo più qui, ma dobbiamo anche rimuoverlo da base pond cpp.
‫Ecco qui.
‫Possiamo andare avanti e cancellarlo qui e ora lo abbiamo dichiarato qui in Tank H, ma dobbiamo
‫anche definirlo in tank CPP.
‫Quindi definirò la funzione appena sotto il componente di input del lettore di configurazione.
‫Quindi sarà vuoto iniziare a giocare senza parametri di input.
‫C'è il corpo della funzione e abbiamo anche bisogno di un serbatoio che prefissa il nome della funzione.
‫Ora sappiamo che è importante chiamare super big in gioco.
‫In questo modo qualsiasi funzionalità nella funzione di inizio riproduzione e qualsiasi classe padre verrà comunque
‫chiamata.
‫Quindi qui abbiamo iniziato a giocare.
‫È qui che possiamo ottenere il nostro controller e memorizzarlo in una variabile.
‫Quindi torniamo a Tank H e creiamo una variabile.
‫Ora questo sarà privato e lo infilerò qui in fondo alla
‫sezione privata e sarà un tipo di puntatore del controller del giocatore e possiamo chiamare questo controller del giocatore ref.
‫Questo sarà il nostro riferimento al controller del giocatore.
‫Ora non stiamo parlando di un riferimento C++.
‫Questo è ancora solo un puntatore, ma lo useremo per fare riferimento al controller del giocatore.
‫Quindi ora abbiamo una variabile di riferimento del controller del giocatore di tipo A e siamo pronti per memorizzare
‫il controller in questo puntatore.
‫Quindi torniamo a Tank Dot CP qui e iniziamo a giocare e proviamo a farlo.
‫Così.
‫Quello che farò è dire giocatore, controller, arbitro uguale e proverò a chiamare get controller.
‫Ora prendi il controller, come ho già detto è nella classe --.
‫Facciamo clic con il pulsante destro del mouse e andiamo alla definizione e notiamo che questa funzione restituisce un controller A.
‫Ora la nostra variabile è di tipo A player controller, non un controller.
‫Quindi quello che stiamo tentando di fare qui è prendere il valore restituito da get controller, che è di un tipo di
‫puntatore del controller e stiamo cercando di memorizzarlo in un puntatore del controller del giocatore A.
‫Nota che qui vediamo il rosso ondulato.
‫Dice un valore di tipo.
‫Non è possibile assegnare un puntatore del controller a un'entità di tipo.
‫Un controller del giocatore.
‫Stiamo ricevendo un errore.
‫Diamo un'occhiata qui alla documentazione per un controller.
‫Guarda.
‫Ecco un controllore.
‫E dice eredità, gerarchia.
‫E sotto un controller vediamo un controller e un controller del giocatore.
‫Ciò significa che un controller del giocatore è una classe figlia di un controller.
‫Ora, in C++, non possiamo avere un puntatore di tipo.
‫Un controller del giocatore memorizza il valore dell'indirizzo di un controller A.
‫Un controller è il tipo padre.
‫Un controller giocatore è il tipo figlio.
‫Non puoi prendere un oggetto di tipo padre e memorizzarlo in un puntatore di tipo figlio.
‫Quindi, come possiamo aggirare questo?
‫Quindi ecco il nostro problema.
‫La funzione get controller restituisce l'indirizzo di un controller A.
‫Ora, questo è qualcosa che potremmo memorizzare in un puntatore del controller A, ma non possiamo memorizzarlo in un puntatore del controller
‫del giocatore A.
‫La cosa divertente, tuttavia, è che l'oggetto restituito da get controller è in realtà un controller del giocatore.
‫Quindi abbiamo questo indirizzo sotto forma di un puntatore del controller A e sappiamo che memorizza un controller del giocatore, ma se
‫lo abbiamo sotto forma di un controller A, non possiamo accedere alla funzione di cui abbiamo bisogno perché
‫esiste su un controller del giocatore .
‫La funzione è chiamata get hit result sotto il cursore.
‫Ora, se abbiamo un valore di puntatore del controller di tipo A e tentiamo di ottenere quella funzione che esiste
‫su un controller del giocatore, non riusciremo a farlo.
‫Otterremo un errore di compilazione.
‫Quindi, poiché sappiamo che l'oggetto stesso è un controller del giocatore, è semplicemente memorizzato in un puntatore del controller A.
‫Come aggiriamo questo problema?
‫La risposta è che dobbiamo lanciare.
‫Sappiamo che un controller è la classe genitore e un controller giocatore è la classe figlia.
‫E sappiamo che non possiamo avere un controller A memorizzato in un puntatore del controller del lettore A.
‫Sappiamo che possiamo fare il contrario e avere un negozio di puntatori del controller A, un oggetto di un controller
‫del giocatore.
‫Questo è in effetti ciò che vediamo quando chiamiamo get controller, restituisce un puntatore del controller A che punta
‫a un controller del giocatore A.
‫Quindi, se abbiamo un valore di puntatore del controller di tipo A, possiamo usare una funzione speciale chiamata cast per convertire
‫il tipo del puntatore in un puntatore del controller del giocatore A.
‫Quindi il cast cambia il tipo di un puntatore in un altro tipo di puntatore, purché l'oggetto stesso sia il tipo a cui stiamo
‫cercando di eseguire il cast.
‫Ora, se abbiamo tentato di eseguire il cast su un tipo non valido, ad esempio, abbiamo un puntatore del controller A che punta
‫a un oggetto controller del giocatore.
‫Se proviamo a lanciare per dire, un carattere, la funzione cast restituisce null e diciamo che falliamo il
‫cast.
‫Quindi la funzione cast è simile a questa.
‫È un modello proprio come crea un oggetto secondario predefinito.
‫Questa funzione modello si adatterà al tipo scelto e in questa funzione, il tipo che passiamo è anche il
‫tipo che stiamo trasmettendo.
‫Quindi passiamo quel tipo.
‫Vorremmo lanciare due all'interno delle parentesi angolari e passiamo il puntatore che vorremmo lanciare tra
‫parentesi.
‫Ecco un esempio.
‫Diciamo che vorremmo trasmettere a un controller del giocatore e un puntatore di tipo di controller A.
‫Passiamo il puntatore tra parentesi e il tipo a cui stiamo effettuando il casting tra parentesi angolari.
‫E ciò che viene restituito è un valore di tipo A puntatore del controller del giocatore.
‫Quindi ecco la chiamata di funzione in cui stiamo passando il tipo tra parentesi angolari e il valore
‫del puntatore del controller A che otteniamo restituito da get controller può essere inserito tra parentesi.
‫Quindi dobbiamo eseguire il cast di questo valore che ci viene restituito da get controller.
‫Sarà la tua sfida.
‫Quindi, in Begin Play, usa la funzione get controller e passa quel valore alla funzione cast e lancia a
‫un controller del giocatore.
‫E quindi puoi memorizzare il risultato nel nostro puntatore di riferimento del controller del lettore, che è di tipo A puntatore del controller
‫del lettore.
‫Metti in pausa il video ed esegui il cast.
‫Bene.
‫Quindi abbiamo quasi finito tutto il lavoro qui che dobbiamo solo lanciare.
‫Quindi quello che faremo è chiamare la funzione cast, che ha parentesi angolari e parentesi.
‫E quello che va tra parentesi è il valore che vorremmo lanciare.
‫Ora get controller restituisce un puntatore del controller di tipo A.
‫Lo sposterò qui tra parentesi.
‫E il tipo a cui stiamo trasmettendo è un controller del giocatore.
‫Quindi di nuovo prendiamo il valore restituito da get controller.
‫Questo restituisce un puntatore a controller o un indirizzo.
‫Quindi stiamo usando cast per lanciarlo su un controller del giocatore A.
‫Sappiamo che l'oggetto restituito dal controller del gate è un oggetto controller del giocatore A memorizzato in un puntatore del
‫controller A.
‫Quindi, dopo aver lanciato questo, ciò che viene restituito è un puntatore del controller del giocatore di tipo A.
‫Quindi lo stiamo memorizzando nel controller del lettore ref.
‫Ora che abbiamo accesso al controller sotto forma di un puntatore del controller del giocatore A, possiamo accedere alla funzione di
‫cui abbiamo bisogno per ottenere il risultato della traccia hit sotto il cursore.
‫Quindi, in sintesi, abbiamo usato get controller per ottenere l'accesso al controller.
‫Usiamo anche la funzione cast per trasmettere dal puntatore del controller di tipo A al puntatore del controller del giocatore di tipo
‫A.
‫Ora possiamo accedere alla funzione di cui abbiamo bisogno, ovvero ottenere risultati sui risultati sotto il cursore che esiste nella classe A
‫del controller del giocatore.
‫Quindi inizieremo a utilizzare questa funzione nel prossimo video.
‫Ci vediamo presto.