‫In questa lezione, metteremo insieme un controller del giocatore che riceverà informazioni che il gioco è
‫terminato dalla modalità di gioco e creerà questo comportamento di riavvio che dopo 5 secondi ricarica il livello
‫dopo che il giocatore è morto.
‫Entriamo e vediamo come è fatto.
‫Quindi, quando il gioco è effettivamente finito, dobbiamo avvisare il controller del giocatore e dobbiamo anche avere un controller del giocatore nel
‫nostro C++ in modo da poter implementare il comportamento che ci consente di riavviare il livello e così
‫via.
‫Quindi la prima cosa da fare è quando questo punto viene eliminato, prima di tutto, stiamo solo registrando indiscriminatamente.
‫Vogliamo verificare se il gioco è finito o meno.
‫Ora, ci sono due scenari.
‫Uno è dove vinciamo e uno è dove perdiamo.
‫La sconfitta è la prima che affronterò perché è più facile.
‫Se la pedina uccisa è il giocatore che perdi, questo è tutto.
‫Potresti scegliere di avere più vite con diverse iterazioni di questa modalità di gioco, ma non lo
‫farò.
‫Avrò solo una vita da single.
‫Se muori, game over.
‫Potresti voler riavviare.
‫Quindi, come controlliamo se questa pedina è un controller del giocatore?
‫Bene, è abbastanza semplice.
‫Possiamo semplicemente eseguire un cast in modo da poter eseguire un cast su un controller del giocatore e per la pedina uccisa.
‫E poi se questo non è nullo.
‫Quindi prendiamo il puntatore.
‫Un puntatore di controllo del giocatore lo chiama controller del giocatore e memorizza il risultato di quel puntatore qui.
‫E diremo sostanzialmente se questo non è no.
‫Quindi, se il controller del giocatore non è un puntatore nullo, allora sappiamo che è il giocatore che è morto e che il gioco è
‫finito per il giocatore.
‫Quindi quello che vogliamo fare è chiamare quel metodo del controller del giocatore.
‫Abbiamo già accennato al fatto che esiste un metodo di gioco terminato.
‫Diamo un'occhiata a questo.
‫Se eseguiamo un controllo P e diamo un'occhiata al punto del controller del giocatore e possiamo cercare che il gioco sia terminato.
‫Puoi vedere abbastanza sicuro che qui c'è un metodo virtuale chiamato gioco è terminato e puoi vedere che c'è un focus
‫sulla fine del gioco.
‫Su quale attore dovremmo concentrarci alla fine?
‫Gioco per impostazione predefinita, questo è un punto nullo e probabilmente è quello che userò.
‫E poi diremo, è questo il vincitore?
‫Fondamentalmente, devi lasciare che il giocatore controlli e sappia se ha vinto o meno.
‫E questo è abbastanza semplice, diciamo, in questo caso.
‫No, non l'hanno fatto.
‫Quindi faremo un gioco con la freccia del controller di gioco terminato, quindi metterò un puntatore nullo per il focus del
‫gioco finale perché non abbiamo davvero bisogno di quella funzione e quindi è il vincitore.
‫Sarà semplicemente falso.
‫Questo non è il controller del giocatore vincente perché è quello che è appena morto.
‫Quindi è tempo per una piccola sfida da implementare.
‫Il gioco è terminato in un controller di gioco.
‫Ciò significa che dobbiamo creare un controller del lettore C++, creare la sua sottoclasse blueprint, generare quella sottoclasse blueprint per
‫impostazione predefinita dalla nostra modalità di gioco e quindi vuoi andare avanti e sovrascrivere.
‫Il gioco è terminato e inserisci un messaggio di registro per verificare che stiamo effettivamente ricevendo.
‫Quella partita è finita al momento giusto.
‫Metti in pausa, video e prova.
‫Bene.
‫Ben tornato.
‫Quindi, passaggio uno, crea quel controller del lettore C++, crea una nuova classe C++.
‫Quindi vai a cercare, vediamo, controller del giocatore.
‫Successivamente, lo chiameremo controller del giocatore sparatutto.
‫Vai avanti e crea quella classe.
‫Una volta fatto, vogliamo passare ai nostri progetti e creare una classe di progetti basata su di essi.
‫Quindi vogliamo il controller del giocatore sparatutto come base in questo modo e lo chiameremo BP,
‫underscore controller del giocatore sparatutto.
‫Questo non è attualmente realmente necessario, ma più avanti vorremo collegare alcune risorse dell'interfaccia
‫utente al controller del giocatore.
‫Quindi lo avremo lì pronto.
‫Quindi andremo alla modalità di gioco BP KML e la collegheremo perché vogliamo cambiare la classe del controller del giocatore
‫predefinita dal controller del giocatore al nostro BPM, il controller del giocatore sparatutto della scuola.
‫Freddo.
‫Quindi vogliamo sovrascrivere.
‫La nostra partita è finita.
‫Quindi vediamo se passiamo al controllo del giocatore su h.
‫Possiamo vedere che questo è nella sezione pubblica.
‫Ecco la firma.
‫Copiamolo.
‫Entra come controller di gioco sparatutto punto h e crea pubblico.
‫A quel vuoto virtuale il gioco è finito.
‫Fantastico e dobbiamo già sovrascrivere perché è stato chiaramente ignorato da qualche parte.
‫E poi quello che possiamo fare è andare avanti e implementarlo.
‫Control shift p vogliamo chiamarlo un super ricordo.
‫E vogliamo che il gioco sia finito così.
‫E vogliamo passare al focus di fine partita e la B vince e quindi vogliamo registrare.
‫Quindi accedi.
‫È la mia macro lì.
‫Abbiamo finito.
‫Sarà il messaggio di registro che uscirà alla fine.
‫Quindi compiliamo e vediamo se funziona.
‫Vado al registro di output.
‫Premi play.
‫Vai e fatti uccidere, in pratica.
‫La salute sta rallentando.
‫E poi dovremmo vedere un messaggio.
‫Stiamo ricevendo il messaggio?
‫No.
‫Quindi diamo un'occhiata.
‫Qual è il controller del giocatore qui?
‫Il controller del giocatore sparatutto underscore BP sembra essere quello corretto.
‫Abbiamo l'override Il gioco è terminato.
‫Ora, qui, ho individuato un bug.
‫Ora, questo è qualcosa che alcuni di voi potrebbero aver notato e di cui
‫hanno urlato sullo schermo è che qui abbiamo il nostro controller del giocatore su cui stiamo lanciando e mi sto confondendo con
‫la vera pedina del giocatore.
‫Quindi quello che vogliamo fare qui è dire di ottenere il controllore del pedone che è stato ucciso.
‫Quindi il punto ucciso dal pedone ottiene l'errore del controller.
‫Quindi freccia prendi il controller e poi vogliamo lanciarlo sul controller del giocatore.
‫E se è nullo, ok, dovrebbe funzionare.
‫Quindi andiamo avanti e proviamolo.
‫Vai avanti e premi play.
‫Castle è stato ucciso di nuovo.
‫E anche questa volta non riceviamo alcun messaggio.
‫E questa volta, è per una ragione sottile.
‫Questo perché ci stiamo staccando dal controller.
‫Prima di chiamarlo -- ucciso.
‫Quindi, quando cerca di ottenere il pedone di controllo, in realtà è no, non c'è più un pedone di controllo.
‫Quindi dobbiamo eseguire questa notifica appena prima di eseguire il distacco dal controller.
‫Includo salire la linea che si impossessa della nostra modalità di gioco.
‫Non credo che importerebbe, ma ora che ci penso davvero, sì, certo che lo fa.
‫Quindi entriamo nel nostro livello e giochiamo.
‫Andiamo a farci sparare.
‫E una volta fatto, puoi vedere che abbiamo finito e viene stampato come vogliamo.
‫Quindi abbiamo avuto qualche intoppo lungo la strada.
‫Non è colpa tua se non l'hai ottenuto nella sfida.
‫Hai fatto tutto il resto fino a quel momento.
‫È grandioso.
‫Quindi si spera che tu abbia provato a eseguire il debug di questo, ma non preoccuparti se sei rimasto bloccato su quelle cose.
‫L'ultima cosa che volevo fare qui è riavviare effettivamente il gioco su un timer.
‫Ora il modo in cui possiamo farlo è abbastanza semplice perché il controller del giocatore ha effettivamente un metodo di
‫riavvio.
‫Quindi, se andiamo a dare un'occhiata a questo, dovrebbe essere un livello di riavvio.
‫È quello che vogliamo chiamare e vogliamo farlo su un timer.
‫Quindi abbiamo usato i timer prima per fare cose ripetute, ma possiamo anche usarlo solo per ritardare un'azione di
‫un certo importo.
‫Quindi andrò allo sparatutto, al controller, al punto H e creerò una proprietà privata qui.
‫Privato può essere la tua proprietà che può essere modificata ovunque.
‫Galleggiante.
‫Questo sarà il ritardo di riavvio.
‫Puoi capire perché abbiamo già bisogno di una base di progetto per questo.
‫Ho intenzione di dargli un ritardo di 5/2.
‫Quindi entrerò nel C++ e vorremo fare bene un timer per ottenere, timer manager.
‫E poi possiamo farlo.
‫Quindi dobbiamo includere.
‫Quindi include hash e sarà il punto H del timer manager.
‫Quindi dovremmo essere in grado di utilizzare l'operatore punto perché il tipo restituito qui è un
‫riferimento e faremo un timer impostato.
‫E qui dentro dobbiamo passare una maniglia del timer.
‫Quindi, nella sezione privata, andiamo a creare un set.
‫Potrebbe essere una maniglia del timer f.
‫Lo chiamerò il timer di riavvio come.
‫Quindi quella sarà la maniglia che passeremo al nostro timer impostato.
‫La prossima cosa di cui abbiamo bisogno sulla quinta firma qui è in realtà avere l'oggetto che vogliamo chiamare, che
‫sarà solo questo.
‫E poi ci sarà penso che dovrebbe essere solo il metodo stesso.
‫Quindi possiamo farlo facendo e commerciale.
‫E poi è in realtà il metodo, il metodo del livello di riavvio, che vogliamo richiamare che è
‫stato definito sul controller del giocatore A.
‫Quindi un controller del giocatore.
‫Due punti, livello di riavvio dei due punti.
‫E poi non ci resta che passare il ritardo che abbiamo già definito come ritardo di ripartenza.
‫Quindi fallo, ma un punto e virgola alla fine c'è e speriamo di ricominciare dopo 5
‫secondi.
‫Ora semplificheremo un po' i test aprendo il nostro fucile e rendendolo un po'
‫più letale.
‫Quindi vado alle impostazioni predefinite, faccio il danno a 50.
‫Quindi fatti uccidere con due colpi.
‫Andiamo e premiamo play.
‫Fatti ammazzare in fretta.
‫E poi, dopo 5 secondi, speriamo di dover riavviare il livello, ricominciamo e torniamo al livello.
‫Quindi il nostro timer funziona come ci aspettiamo.
‫Ora, nelle versioni successive, scoprirai che invece di riavviare, quello che vedrai è un messaggio di errore simile a questo e
‫parla di errori di viaggio e dice qualcosa sul fatto che leggi una tiepida sandbox,
‫bla bla bla.
‫Bene, il modo in cui dobbiamo aggirare questo problema quando stiamo provando a riavviare e vogliamo
‫verificare se il nostro riavvio funziona, è che andiamo al nostro menu punto, punto, punto invece del menu di riproduzione e
‫dobbiamo giocare come un gioco autonomo.
‫Se si gioca a un gioco standalone ci vuole un po' più di tempo per l'avvio,
‫ma il riavvio funzionerà come previsto e vediamo il livello ricaricato.
‫Ora, ovviamente, non ci sono molte indicazioni che ciò accadrà.
‫Quindi esamineremo l'interfaccia utente nelle prossime lezioni.
‫Ci vediamo lì.