‫Ehi, bentornato.
‫In questo video, ci occupiamo di vincere e perdere condizioni.
‫Questa è una delle ultime cose che affronteremo in questo progetto di gioco.
‫Ora diamo un'occhiata al nostro piano di sezione.
‫Ora, abbiamo già controllato i primi cinque elementi nel nostro piano di sezione e gli ultimi due sono gli effetti
‫speciali e le condizioni di vittoria e di sconfitta.
‫E mi piacerebbe cambiare questi ultimi due e gestire le condizioni di vittoria e di sconfitta
‫solo perché questa è l'ultima logica di programmazione del nostro gameplay e gli effetti speciali sono cosmetici e più simili a
‫ritocchi finali, quindi possiamo gestirli proprio alla fine.
‫Quindi in questo video creeremo una funzione di game over in modo da sapere quando la partita è
‫stata vinta o persa.
‫E per vincere la partita, dovremo contare il numero di torri nel mondo, perché una volta che
‫abbiamo distrutto tutte le torri, allora sappiamo di aver vinto la partita.
‫E se il carro armato stesso viene distrutto, allora possiamo considerarlo una condizione di perdita.
‫Quindi sono tornato qui nella modalità di gioco e la prima cosa che vorrei fare è creare un altro evento implementabile
‫del progetto.
‫Abbiamo questa funzione di avvio del gioco, che possiamo chiamare da C++, ma ne stiamo implementando la logica nella modalità di
‫gioco.
‫Progetto Grazie a Blueprint Implementable Event, vorrei crearne un altro per aver perso la
‫partita.
‫Quindi creerò una funzione vuota chiamata Game Over.
‫E per questo, vorrei prendere un parametro di input booleano chiamato B one game.
‫E ovviamente questo sarà un evento implementabile del progetto perché l'unica cosa che vorrei
‫gestire con questa funzione è mostrare che abbiamo perso o vinto la partita e che possiamo fare dai progetti.
‫Quindi abbiamo una funzione di game over.
‫Ora dobbiamo sapere quando dobbiamo chiamare questa funzione.
‫Bene, prima di tutto, sappiamo che possiamo chiamare questa funzione quando abbiamo perso la partita, e ciò
‫accadrà se il carro armato è morto.
‫Quindi entriamo nella nostra funzione attore morto qui nella modalità di gioco sintonizzazione carri armati CP E vediamo che se l'attore morto è
‫il carro armato, allora stiamo gestendo la distruzione del carro armato e stiamo impostando lo stato abilitato
‫su falso.
‫Un'altra cosa che possiamo fare qui è terminare il gioco semplicemente chiamando game over e questo booleano è un gioco che possiamo
‫passare in falso per questo.
‫Quindi questo si prende cura di perdere la partita, almeno dal lato C++.
‫Ora dobbiamo sapere quando dovremmo vincere la partita.
‫Ora qui è morto un attore.
‫Se l'attore morto può essere gettato su una torre, sappiamo che abbiamo appena distrutto una torre.
‫Ora, questo sarebbe il posto perfetto per aggiornare un conteggio delle torri o una variabile di tipo intero che tiene
‫traccia di quante torri ci sono attualmente nel mondo.
‫Adesso.
‫Per fare ciò, abbiamo bisogno di una variabile per tenere traccia del numero di torri in modo da
‫poter aggiungere una variabile privata qui nel file H.
‫E mi piacerebbe farlo quaggiù.
‫Quindi creerò un INT 32 e chiamerò questo target towers.
‫Ora possiamo inizializzarlo immediatamente su un valore pari a zero, ma dobbiamo aggiornarlo man mano che il
‫numero di torri diminuisce.
‫E dobbiamo anche impostare questo sul numero di torri che ci sono nel mondo.
‫Ora potremmo programmare questo a quattro, ma cosa succede quando iniziamo ad aggiungere più torri ai nostri livelli?
‫Bene, allora diventa un po' più complicato.
‫Quindi quello che mi piacerebbe fare invece è vedere quante torri ci sono nel mondo.
‫Ora, potrei creare una funzione per questo che restituisce 32 e questa funzione può scoprire quante torri ci sono
‫nel mondo e restituire il numero.
‫Quindi chiamerò questa funzione, otterrò un conteggio delle torri target.
‫Quindi andiamo avanti e diamo a questa funzione un corpo nel file CP.
‫Andrò fino in fondo e creerò il corpo della funzione e non posso dimenticare di mettere il nome
‫della classe prima del nome della funzione.
‫Ora questo restituirà una fine 32 e dobbiamo decidere come scoprire quante torri ci
‫sono.
‫Ora c'è una funzione che esiste nelle statistiche di gioco chiamata Ottieni tutti gli attori di classe.
‫Ecco la documentazione.
‫Dice Trova tutti gli attori nel mondo della classe specificata.
‫Quindi dobbiamo specificare una classe particolare.
‫Ora questa funzione ha tre ingressi.
‫Il primo è un oggetto di contesto mondiale.
‫Quello è facile.
‫Sappiamo come gestirlo.
‫Ma poi abbiamo una sottoclasse PT di un attore e questa è chiamata Classe attore.
‫Ora abbiamo visto che le funzioni che richiedono una sottoclasse PT di possono accettare una classe u come input e il terzo
‫parametro è un array T.
‫Richiede un array t di puntatori attore e questo viene passato come riferimento e non è un riferimento const
‫che sembra suggerire che questa funzione potrebbe semplicemente modificare questo parametro di input chiamato out act.
‫Ecco un altro indizio che questo è il caso, è che sono chiamati attori.
‫È un parametro out, il che significa che lo passiamo dentro e quindi dopo che la funzione è stata chiamata, ha valori
‫che sono stati inseriti dalla funzione.
‫Quindi possiamo pensarlo come una sorta di output per la funzione.
‫Ora dice qui sotto per i parametri, la classe attore è la classe dell'attore da trovare deve essere specificata o l'array
‫dei risultati sarà vuoto.
‫Vogliamo trovare tutte le torri e gli attori fuori è un array di output di attori della classe specificata.
‫Quindi, una volta chiamata questa funzione e passata in un array, quando la
‫funzione è terminata, quell'array conterrà puntatori a tutti gli attori nel mondo della classe specificata.
‫Quindi sappiamo che questa funzione richiede un oggetto contesto mondiale.
‫Ora, se lo chiameremo dall'interno della modalità di gioco, possiamo passare a questo dopo.
‫Abbiamo bisogno della sottoclasse PT per specificare l'attore A e sappiamo che questo può essere un nuovo puntatore di classe.
‫Ora dobbiamo specificare la classe da trovare.
‫Se specifichiamo un attore, otterremo una vasta gamma di suggerimenti per ogni attore nel mondo.
‫Ma non abbiamo bisogno di tutti gli attori.
‫Abbiamo solo bisogno delle torri in modo da poter utilizzare una classe statica tower che ci restituirà una nuova classe che
‫rappresenta la classe A Tower C++.
‫Ora il terzo parametro è un array T di puntatori attore.
‫Quindi, se creiamo una variabile locale di tipo T array specificando il puntatore a attore tra parentesi angolari, allora
‫possiamo chiamarti statica di gioco.
‫Fai passare tutti gli attori della classe in questi tre input e il risultato di questa azione sarà che il
‫nostro array di torri dovrebbe contenere puntatori a tutte le torri nel nostro mondo.
‫Ora il vassoio è una bella classe contenitore che può contenere un numero di elementi purché condividano tutti lo
‫stesso tipo.
‫E questa classe ha molte funzioni che possiamo usare quando riponiamo gli oggetti in un vassoio.
‫Ora scorrerò fino in fondo e ti mostrerò questa funzione qui chiamata Num Short quattro numeri e
‫dice Restituisce il numero di elementi nell'array.
‫Quindi possiamo usare questa funzione per ottenere il numero di elementi nel nostro array una volta che avremo tutte le torri del
‫mondo.
‫Quindi, se chiamiamo il numero di Tower, possiamo usarlo come valore di ritorno per la nostra funzione.
‫E come abbiamo visto, abbiamo impostato il nostro valore di ritorno per questa funzione che chiamiamo get target tower count
‫come n 32, possiamo restituire il numero di elementi nell'array della nostra torre.
‫Quindi vorrei sfidarti a implementare questa funzione di conteggio delle torri di destinazione.
‫Quindi crea un array t locale di attore di tipo A.
‫Puoi chiamarlo torri o come preferisci.
‫Ora usa il tuo gioco, gioca con la funzione statica, ottieni tutti gli attori della classe e assicurati di passare i
‫parametri di input corretti.
‫Ora, dopo aver chiamato questa funzione, il tuo vassoio conterrà i puntatori a tutte le torri
‫nel nostro mondo, quindi puoi semplicemente restituire il numero di torri usando quella funzione num che appartiene alla
‫classe vassoio.
‫Quindi vai avanti e metti in pausa il video e implementa.
‫Ottieni ora il conteggio delle torri target.
‫Bene.
‫Quindi, ecco il conteggio delle torri target.
‫Ora, la prima cosa che farò è creare un array t locale specificando un puntatore attore come tipo di
‫elemento che questo array dovrebbe memorizzare.
‫E ora chiamerò queste torri, devo chiamarti statica di gioco, quindi devo assicurarmi che
‫quell'intestazione sia inclusa.
‫Ora vedo che lo è poiché lo stiamo usando in alcune delle nostre altre funzioni, ma è bene fare quel
‫controllo.
‫Quindi posso usare le tue statistiche di gioco e chiamerò get tutti gli attori della classe.
‫Ora il primo input è un oggetto di contesto mondiale che passerò in questo e il prossimo è la sottoclasse
‫di rappresentazione della classe attore.
‫E ho detto che possiamo usare una classe statica tower che restituirà una classe U che rappresenta la
‫classe tower.
‫Ora, di nuovo, è una buona idea assicurarsi di includere le torri, e lo siamo.
‫Ora, il terzo e ultimo parametro sarà il vassoio e possiamo passare nelle torri.
‫Quindi, una volta chiamata questa funzione, le torri ora conterranno i puntatori a tutte le torri del
‫mondo.
‫In effetti, se esistono oggetti di una classe che deriva da torri, otterremmo anche quelli.
‫Quindi, poiché abbiamo un array di torri, possiamo semplicemente restituire il numero di elementi in quell'array.
‫Quindi userò una dichiarazione di ritorno e userò il punto num delle torri e ora abbiamo un conteggio delle torri di destinazione.
‫Quindi questo è fantastico.
‫Possiamo usarlo per inizializzare il nostro conteggio delle torri, che abbiamo chiamato torri bersaglio e possiamo farlo all'inizio
‫del gioco.
‫Quindi lo metterò qui e gestirò l'inizio del gioco.
‫In effetti, mi piacerebbe che fosse la prima cosa che facciamo.
‫Quindi prenderò le torri target e lo imposterò uguale al valore di ritorno da ottenere il conteggio delle torri target.
‫Ora le torri target dovrebbero essere inizializzate sul numero di torri nel nostro mondo.
‫Quindi è fantastico, ma dobbiamo aggiornare questo conteggio ogni volta che una torre muore, il che significa che
‫dobbiamo entrare nella nostra funzione di attore morto.
‫E qui, se abbiamo lanciato un attore morto su una torre distrutta, dopo aver gestito la distruzione,
‫dovremmo aggiornare la nostra variabile delle torri bersaglio in modo da poter dire torri bersaglio e possiamo usare l'operatore di decremento.
‫Possiamo usare l'operatore post decremento o l'operatore situazione difficile.
‫Entrambi si tradurranno nella stessa azione che sta prendendo le torri bersaglio e sottraendone una.
‫Ora, non appena ne abbiamo sottratto uno dalle torri bersaglio, ora dobbiamo controllare se le torri bersaglio hanno
‫raggiunto lo zero.
‫Quindi metterò un segno di spunta qui per vedere se le torri Target hanno raggiunto lo zero.
‫Ora, non appena lo fa, sappiamo che il gioco dovrebbe essere finito in modo da poter chiamare
‫la funzione di game over passando in un vero gioco 4b1 poiché abbiamo distrutto tutte le torri e possiamo considerarlo una vittoria.
‫Ora andiamo avanti e compiliamo il nostro codice.
‫Ora, di nuovo qui nell'editor, quello che vorrei fare prima di concludere questo video è entrare nel nostro progetto per la modalità
‫di gioco.
‫Quindi ecco la melodia del segnale acustico.
‫Grazie alla modalità di gioco e abbiamo questo evento che avvia il gioco.
‫E quello che stiamo facendo è creare il nostro widget di inizio partita, aggiungendolo alla finestra in modo che possiamo vedere il timer
‫per il conto alla rovescia di inizio partita.
‫Quindi sappiamo che il gioco di inizio è stato chiamato, ma dobbiamo anche implementare il nostro evento implementabile di game over
‫blueprint.
‫Quindi farò clic con il pulsante destro del mouse e digiterò game over ed ecco il nostro evento, game over e dai un'occhiata.
‫Nota che abbiamo questo gioco ed è un booleano.
‫Quindi, quando chiamiamo questa funzione da C++, stiamo passando un valore booleano per B un gioco.
‫Il nodo dell'evento del progetto elimina la B minuscola e inserisce uno spazio tra uno e il gioco come una sorta di
‫cortesia per noi.
‫Ora creeremo alcuni widget in modo da poter vedere quando abbiamo vinto o perso la partita, ma lo
‫faremo in un video futuro.
‫Per ora, voglio solo confermare che questo viene chiamato e chiamato correttamente, quindi posso farlo con un nodo di
‫stringa di stampa e possiamo stampare il valore in base a questo booleano.
‫Se faccio clic e trascino questo booleano direttamente nell'input della stringa, vedremo che c'è un booleano convertito
‫in stringa.
‫Questo è un altro comodo nodo di conversione che converte un booleano in una stringa per noi e la sua
‫funzionalità è tale da convertire nella parola true o false in base al valore di verità del
‫booleano.
‫Allora perché non lo proviamo?
‫Sto per compilare e premere play.
‫Va bene, ora sono pronto per provare a vincere la partita.
‫Spero di non perdere prima di poterlo fare.
‫E ho perso la partita e puoi vedere il falso stampato in alto a sinistra dello schermo.
‫Quindi ora sappiamo che perdere la partita fa sì che la partita dell'evento venga chiamata con il passaggio di false, dobbiamo
‫assicurarci che true venga ignorato quando vinciamo la partita.
‫Quindi proviamo a uccidere tutte le torrette.
‫Quindi devo davvero cercare di non ottenere un successo.
‫Oh, sono già stato colpito.
‫Questo è piuttosto impegnativo.
‫E ci andiamo.
‫E true è stampato in alto a sinistra dello schermo.
‫Si presenta solo per pochi secondi, quindi potresti averlo perso.
‫Va bene, fantastico.
‫Quindi ora abbiamo condizioni per vincere e perdere.
‫Il passaggio successivo consiste nel mostrarlo effettivamente sotto forma di widget sullo schermo in modo da non fare affidamento sul nodo
‫della stringa di stampa.
‫Quindi, in sintesi, ora abbiamo le condizioni per vincere e perdere, e ci sono solo alcune
‫cose che dobbiamo fare per perfezionarlo, come creare widget che informino il giocatore che ha vinto o perso la partita.
‫Abbiamo anche contato il numero di torri usando un vassoio e la funzione delle statistiche di gioco.
‫Prendi tutti gli attori della classe.
‫Ottimo lavoro.
‫Questo gioco sta davvero arrivando.
‫Nel prossimo video creeremo quei widget e poi saremo pronti per iniziare ad aggiungere effetti speciali e
‫perfezionare il nostro gioco.
‫Ci vediamo nel prossimo video.