1
00:00:04,290 --> 00:00:05,650
‫Ehi, bentornato.

2
00:00:05,670 --> 00:00:09,900
‫In questo video, ci occupiamo di vincere e perdere condizioni.

3
00:00:10,320 --> 00:00:14,520
‫Questa è una delle ultime cose che affronteremo in questo progetto di gioco.

4
00:00:14,550 --> 00:00:16,860
‫Ora diamo un'occhiata al nostro piano di sezione.

5
00:00:16,860 --> 00:00:23,430
‫Ora, abbiamo già controllato i primi cinque elementi nel nostro piano di sezione e gli ultimi due sono gli effetti

6
00:00:23,430 --> 00:00:26,580
‫speciali e le condizioni di vittoria e di sconfitta.

7
00:00:26,580 --> 00:00:32,250
‫E mi piacerebbe cambiare questi ultimi due e gestire le condizioni di vittoria e di sconfitta

8
00:00:32,250 --> 00:00:39,300
‫solo perché questa è l'ultima logica di programmazione del nostro gameplay e gli effetti speciali sono cosmetici e più simili a

9
00:00:39,300 --> 00:00:42,420
‫ritocchi finali, quindi possiamo gestirli proprio alla fine.

10
00:00:42,420 --> 00:00:48,300
‫Quindi in questo video creeremo una funzione di game over in modo da sapere quando la partita è

11
00:00:48,300 --> 00:00:49,950
‫stata vinta o persa.

12
00:00:49,950 --> 00:00:55,410
‫E per vincere la partita, dovremo contare il numero di torri nel mondo, perché una volta che

13
00:00:55,410 --> 00:00:59,730
‫abbiamo distrutto tutte le torri, allora sappiamo di aver vinto la partita.

14
00:00:59,730 --> 00:01:05,670
‫E se il carro armato stesso viene distrutto, allora possiamo considerarlo una condizione di perdita.

15
00:01:05,670 --> 00:01:11,760
‫Quindi sono tornato qui nella modalità di gioco e la prima cosa che vorrei fare è creare un altro evento implementabile

16
00:01:11,760 --> 00:01:12,540
‫del progetto.

17
00:01:12,570 --> 00:01:19,980
‫Abbiamo questa funzione di avvio del gioco, che possiamo chiamare da C++, ma ne stiamo implementando la logica nella modalità di

18
00:01:19,980 --> 00:01:20,520
‫gioco.

19
00:01:20,520 --> 00:01:27,120
‫Progetto Grazie a Blueprint Implementable Event, vorrei crearne un altro per aver perso la

20
00:01:27,120 --> 00:01:27,720
‫partita.

21
00:01:27,720 --> 00:01:31,530
‫Quindi creerò una funzione vuota chiamata Game Over.

22
00:01:31,530 --> 00:01:37,530
‫E per questo, vorrei prendere un parametro di input booleano chiamato B one game.

23
00:01:37,530 --> 00:01:43,020
‫E ovviamente questo sarà un evento implementabile del progetto perché l'unica cosa che vorrei

24
00:01:43,020 --> 00:01:50,130
‫gestire con questa funzione è mostrare che abbiamo perso o vinto la partita e che possiamo fare dai progetti.

25
00:01:50,130 --> 00:01:52,410
‫Quindi abbiamo una funzione di game over.

26
00:01:52,410 --> 00:01:55,350
‫Ora dobbiamo sapere quando dobbiamo chiamare questa funzione.

27
00:01:55,350 --> 00:02:00,450
‫Bene, prima di tutto, sappiamo che possiamo chiamare questa funzione quando abbiamo perso la partita, e ciò

28
00:02:00,450 --> 00:02:02,550
‫accadrà se il carro armato è morto.

29
00:02:02,550 --> 00:02:10,050
‫Quindi entriamo nella nostra funzione attore morto qui nella modalità di gioco sintonizzazione carri armati CP E vediamo che se l'attore morto è

30
00:02:10,050 --> 00:02:15,840
‫il carro armato, allora stiamo gestendo la distruzione del carro armato e stiamo impostando lo stato abilitato

31
00:02:15,840 --> 00:02:16,680
‫su falso.

32
00:02:16,710 --> 00:02:25,020
‫Un'altra cosa che possiamo fare qui è terminare il gioco semplicemente chiamando game over e questo booleano è un gioco che possiamo

33
00:02:25,020 --> 00:02:27,240
‫passare in falso per questo.

34
00:02:27,240 --> 00:02:31,770
‫Quindi questo si prende cura di perdere la partita, almeno dal lato C++.

35
00:02:31,800 --> 00:02:34,770
‫Ora dobbiamo sapere quando dovremmo vincere la partita.

36
00:02:34,800 --> 00:02:36,540
‫Ora qui è morto un attore.

37
00:02:36,540 --> 00:02:43,050
‫Se l'attore morto può essere gettato su una torre, sappiamo che abbiamo appena distrutto una torre.

38
00:02:43,050 --> 00:02:49,740
‫Ora, questo sarebbe il posto perfetto per aggiornare un conteggio delle torri o una variabile di tipo intero che tiene

39
00:02:49,740 --> 00:02:53,220
‫traccia di quante torri ci sono attualmente nel mondo.

40
00:02:53,250 --> 00:02:53,580
‫Adesso.

41
00:02:53,580 --> 00:02:59,310
‫Per fare ciò, abbiamo bisogno di una variabile per tenere traccia del numero di torri in modo da

42
00:02:59,310 --> 00:03:02,250
‫poter aggiungere una variabile privata qui nel file H.

43
00:03:02,250 --> 00:03:03,960
‫E mi piacerebbe farlo quaggiù.

44
00:03:03,960 --> 00:03:08,880
‫Quindi creerò un INT 32 e chiamerò questo target towers.

45
00:03:09,120 --> 00:03:15,840
‫Ora possiamo inizializzarlo immediatamente su un valore pari a zero, ma dobbiamo aggiornarlo man mano che il

46
00:03:15,840 --> 00:03:17,760
‫numero di torri diminuisce.

47
00:03:17,760 --> 00:03:22,350
‫E dobbiamo anche impostare questo sul numero di torri che ci sono nel mondo.

48
00:03:22,470 --> 00:03:28,170
‫Ora potremmo programmare questo a quattro, ma cosa succede quando iniziamo ad aggiungere più torri ai nostri livelli?

49
00:03:28,170 --> 00:03:30,690
‫Bene, allora diventa un po' più complicato.

50
00:03:30,690 --> 00:03:35,580
‫Quindi quello che mi piacerebbe fare invece è vedere quante torri ci sono nel mondo.

51
00:03:35,610 --> 00:03:43,050
‫Ora, potrei creare una funzione per questo che restituisce 32 e questa funzione può scoprire quante torri ci sono

52
00:03:43,050 --> 00:03:45,810
‫nel mondo e restituire il numero.

53
00:03:45,810 --> 00:03:51,450
‫Quindi chiamerò questa funzione, otterrò un conteggio delle torri target.

54
00:03:51,600 --> 00:03:55,650
‫Quindi andiamo avanti e diamo a questa funzione un corpo nel file CP.

55
00:03:55,680 --> 00:04:02,130
‫Andrò fino in fondo e creerò il corpo della funzione e non posso dimenticare di mettere il nome

56
00:04:02,130 --> 00:04:05,040
‫della classe prima del nome della funzione.

57
00:04:05,040 --> 00:04:12,270
‫Ora questo restituirà una fine 32 e dobbiamo decidere come scoprire quante torri ci

58
00:04:12,270 --> 00:04:13,170
‫sono.

59
00:04:13,200 --> 00:04:19,800
‫Ora c'è una funzione che esiste nelle statistiche di gioco chiamata Ottieni tutti gli attori di classe.

60
00:04:19,800 --> 00:04:21,300
‫Ecco la documentazione.

61
00:04:21,300 --> 00:04:25,770
‫Dice Trova tutti gli attori nel mondo della classe specificata.

62
00:04:25,770 --> 00:04:28,890
‫Quindi dobbiamo specificare una classe particolare.

63
00:04:28,920 --> 00:04:31,530
‫Ora questa funzione ha tre ingressi.

64
00:04:31,530 --> 00:04:33,720
‫Il primo è un oggetto di contesto mondiale.

65
00:04:33,720 --> 00:04:34,770
‫Quello è facile.

66
00:04:34,770 --> 00:04:36,180
‫Sappiamo come gestirlo.

67
00:04:36,180 --> 00:04:41,610
‫Ma poi abbiamo una sottoclasse PT di un attore e questa è chiamata Classe attore.

68
00:04:41,610 --> 00:04:48,000
‫Ora abbiamo visto che le funzioni che richiedono una sottoclasse PT di possono accettare una classe u come input e il terzo

69
00:04:48,000 --> 00:04:49,740
‫parametro è un array T.

70
00:04:49,770 --> 00:04:56,940
‫Richiede un array t di puntatori attore e questo viene passato come riferimento e non è un riferimento const

71
00:04:56,940 --> 00:05:03,680
‫che sembra suggerire che questa funzione potrebbe semplicemente modificare questo parametro di input chiamato out act.

72
00:05:03,730 --> 00:05:08,530
‫Ecco un altro indizio che questo è il caso, è che sono chiamati attori.

73
00:05:08,530 --> 00:05:15,820
‫È un parametro out, il che significa che lo passiamo dentro e quindi dopo che la funzione è stata chiamata, ha valori

74
00:05:15,820 --> 00:05:18,220
‫che sono stati inseriti dalla funzione.

75
00:05:18,220 --> 00:05:21,340
‫Quindi possiamo pensarlo come una sorta di output per la funzione.

76
00:05:21,340 --> 00:05:28,810
‫Ora dice qui sotto per i parametri, la classe attore è la classe dell'attore da trovare deve essere specificata o l'array

77
00:05:28,810 --> 00:05:30,640
‫dei risultati sarà vuoto.

78
00:05:30,640 --> 00:05:37,240
‫Vogliamo trovare tutte le torri e gli attori fuori è un array di output di attori della classe specificata.

79
00:05:37,240 --> 00:05:42,670
‫Quindi, una volta chiamata questa funzione e passata in un array, quando la

80
00:05:42,670 --> 00:05:48,160
‫funzione è terminata, quell'array conterrà puntatori a tutti gli attori nel mondo della classe specificata.

81
00:05:48,160 --> 00:05:51,880
‫Quindi sappiamo che questa funzione richiede un oggetto contesto mondiale.

82
00:05:51,880 --> 00:05:56,500
‫Ora, se lo chiameremo dall'interno della modalità di gioco, possiamo passare a questo dopo.

83
00:05:56,500 --> 00:06:03,490
‫Abbiamo bisogno della sottoclasse PT per specificare l'attore A e sappiamo che questo può essere un nuovo puntatore di classe.

84
00:06:03,490 --> 00:06:06,070
‫Ora dobbiamo specificare la classe da trovare.

85
00:06:06,070 --> 00:06:12,010
‫Se specifichiamo un attore, otterremo una vasta gamma di suggerimenti per ogni attore nel mondo.

86
00:06:12,010 --> 00:06:13,810
‫Ma non abbiamo bisogno di tutti gli attori.

87
00:06:13,810 --> 00:06:21,070
‫Abbiamo solo bisogno delle torri in modo da poter utilizzare una classe statica tower che ci restituirà una nuova classe che

88
00:06:21,070 --> 00:06:23,290
‫rappresenta la classe A Tower C++.

89
00:06:23,290 --> 00:06:26,770
‫Ora il terzo parametro è un array T di puntatori attore.

90
00:06:26,770 --> 00:06:33,760
‫Quindi, se creiamo una variabile locale di tipo T array specificando il puntatore a attore tra parentesi angolari, allora

91
00:06:33,760 --> 00:06:35,980
‫possiamo chiamarti statica di gioco.

92
00:06:36,010 --> 00:06:41,620
‫Fai passare tutti gli attori della classe in questi tre input e il risultato di questa azione sarà che il

93
00:06:41,620 --> 00:06:45,970
‫nostro array di torri dovrebbe contenere puntatori a tutte le torri nel nostro mondo.

94
00:06:45,970 --> 00:06:52,840
‫Ora il vassoio è una bella classe contenitore che può contenere un numero di elementi purché condividano tutti lo

95
00:06:52,840 --> 00:06:53,830
‫stesso tipo.

96
00:06:53,830 --> 00:07:01,690
‫E questa classe ha molte funzioni che possiamo usare quando riponiamo gli oggetti in un vassoio.

97
00:07:01,720 --> 00:07:08,710
‫Ora scorrerò fino in fondo e ti mostrerò questa funzione qui chiamata Num Short quattro numeri e

98
00:07:08,830 --> 00:07:12,310
‫dice Restituisce il numero di elementi nell'array.

99
00:07:12,310 --> 00:07:19,690
‫Quindi possiamo usare questa funzione per ottenere il numero di elementi nel nostro array una volta che avremo tutte le torri del

100
00:07:19,690 --> 00:07:20,380
‫mondo.

101
00:07:20,380 --> 00:07:26,080
‫Quindi, se chiamiamo il numero di Tower, possiamo usarlo come valore di ritorno per la nostra funzione.

102
00:07:26,080 --> 00:07:31,930
‫E come abbiamo visto, abbiamo impostato il nostro valore di ritorno per questa funzione che chiamiamo get target tower count

103
00:07:31,930 --> 00:07:35,980
‫come n 32, possiamo restituire il numero di elementi nell'array della nostra torre.

104
00:07:35,980 --> 00:07:41,230
‫Quindi vorrei sfidarti a implementare questa funzione di conteggio delle torri di destinazione.

105
00:07:41,230 --> 00:07:44,710
‫Quindi crea un array t locale di attore di tipo A.

106
00:07:44,710 --> 00:07:47,110
‫Puoi chiamarlo torri o come preferisci.

107
00:07:47,110 --> 00:07:52,930
‫Ora usa il tuo gioco, gioca con la funzione statica, ottieni tutti gli attori della classe e assicurati di passare i

108
00:07:52,930 --> 00:07:54,220
‫parametri di input corretti.

109
00:07:54,220 --> 00:08:00,310
‫Ora, dopo aver chiamato questa funzione, il tuo vassoio conterrà i puntatori a tutte le torri

110
00:08:00,310 --> 00:08:06,850
‫nel nostro mondo, quindi puoi semplicemente restituire il numero di torri usando quella funzione num che appartiene alla

111
00:08:06,850 --> 00:08:07,930
‫classe vassoio.

112
00:08:07,930 --> 00:08:10,660
‫Quindi vai avanti e metti in pausa il video e implementa.

113
00:08:10,660 --> 00:08:12,640
‫Ottieni ora il conteggio delle torri target.

114
00:08:15,670 --> 00:08:16,000
‫Bene.

115
00:08:16,000 --> 00:08:17,980
‫Quindi, ecco il conteggio delle torri target.

116
00:08:18,010 --> 00:08:24,250
‫Ora, la prima cosa che farò è creare un array t locale specificando un puntatore attore come tipo di

117
00:08:24,250 --> 00:08:26,590
‫elemento che questo array dovrebbe memorizzare.

118
00:08:26,590 --> 00:08:31,720
‫E ora chiamerò queste torri, devo chiamarti statica di gioco, quindi devo assicurarmi che

119
00:08:31,720 --> 00:08:33,100
‫quell'intestazione sia inclusa.

120
00:08:33,130 --> 00:08:38,830
‫Ora vedo che lo è poiché lo stiamo usando in alcune delle nostre altre funzioni, ma è bene fare quel

121
00:08:38,830 --> 00:08:39,340
‫controllo.

122
00:08:39,370 --> 00:08:47,380
‫Quindi posso usare le tue statistiche di gioco e chiamerò get tutti gli attori della classe.

123
00:08:47,410 --> 00:08:54,130
‫Ora il primo input è un oggetto di contesto mondiale che passerò in questo e il prossimo è la sottoclasse

124
00:08:54,130 --> 00:08:55,990
‫di rappresentazione della classe attore.

125
00:08:55,990 --> 00:09:03,430
‫E ho detto che possiamo usare una classe statica tower che restituirà una classe U che rappresenta la

126
00:09:03,430 --> 00:09:04,270
‫classe tower.

127
00:09:04,300 --> 00:09:09,190
‫Ora, di nuovo, è una buona idea assicurarsi di includere le torri, e lo siamo.

128
00:09:09,220 --> 00:09:14,740
‫Ora, il terzo e ultimo parametro sarà il vassoio e possiamo passare nelle torri.

129
00:09:14,740 --> 00:09:21,340
‫Quindi, una volta chiamata questa funzione, le torri ora conterranno i puntatori a tutte le torri del

130
00:09:21,340 --> 00:09:21,880
‫mondo.

131
00:09:21,880 --> 00:09:28,000
‫In effetti, se esistono oggetti di una classe che deriva da torri, otterremmo anche quelli.

132
00:09:28,000 --> 00:09:33,780
‫Quindi, poiché abbiamo un array di torri, possiamo semplicemente restituire il numero di elementi in quell'array.

133
00:09:33,790 --> 00:09:40,660
‫Quindi userò una dichiarazione di ritorno e userò il punto num delle torri e ora abbiamo un conteggio delle torri di destinazione.

134
00:09:40,660 --> 00:09:41,740
‫Quindi questo è fantastico.

135
00:09:41,740 --> 00:09:48,220
‫Possiamo usarlo per inizializzare il nostro conteggio delle torri, che abbiamo chiamato torri bersaglio e possiamo farlo all'inizio

136
00:09:48,220 --> 00:09:49,090
‫del gioco.

137
00:09:49,090 --> 00:09:51,780
‫Quindi lo metterò qui e gestirò l'inizio del gioco.

138
00:09:51,790 --> 00:09:54,400
‫In effetti, mi piacerebbe che fosse la prima cosa che facciamo.

139
00:09:54,400 --> 00:10:02,530
‫Quindi prenderò le torri target e lo imposterò uguale al valore di ritorno da ottenere il conteggio delle torri target.

140
00:10:02,560 --> 00:10:07,240
‫Ora le torri target dovrebbero essere inizializzate sul numero di torri nel nostro mondo.

141
00:10:07,240 --> 00:10:13,120
‫Quindi è fantastico, ma dobbiamo aggiornare questo conteggio ogni volta che una torre muore, il che significa che

142
00:10:13,120 --> 00:10:16,000
‫dobbiamo entrare nella nostra funzione di attore morto.

143
00:10:16,000 --> 00:10:22,660
‫E qui, se abbiamo lanciato un attore morto su una torre distrutta, dopo aver gestito la distruzione,

144
00:10:22,660 --> 00:10:30,430
‫dovremmo aggiornare la nostra variabile delle torri bersaglio in modo da poter dire torri bersaglio e possiamo usare l'operatore di decremento.

145
00:10:30,430 --> 00:10:35,560
‫Possiamo usare l'operatore post decremento o l'operatore situazione difficile.

146
00:10:35,560 --> 00:10:41,800
‫Entrambi si tradurranno nella stessa azione che sta prendendo le torri bersaglio e sottraendone una.

147
00:10:41,800 --> 00:10:48,220
‫Ora, non appena ne abbiamo sottratto uno dalle torri bersaglio, ora dobbiamo controllare se le torri bersaglio hanno

148
00:10:48,220 --> 00:10:49,660
‫raggiunto lo zero.

149
00:10:49,660 --> 00:10:55,150
‫Quindi metterò un segno di spunta qui per vedere se le torri Target hanno raggiunto lo zero.

150
00:10:55,780 --> 00:11:02,380
‫Ora, non appena lo fa, sappiamo che il gioco dovrebbe essere finito in modo da poter chiamare

151
00:11:02,710 --> 00:11:10,660
‫la funzione di game over passando in un vero gioco 4b1 poiché abbiamo distrutto tutte le torri e possiamo considerarlo una vittoria.

152
00:11:10,660 --> 00:11:13,180
‫Ora andiamo avanti e compiliamo il nostro codice.

153
00:11:13,180 --> 00:11:18,670
‫Ora, di nuovo qui nell'editor, quello che vorrei fare prima di concludere questo video è entrare nel nostro progetto per la modalità

154
00:11:18,670 --> 00:11:19,420
‫di gioco.

155
00:11:19,420 --> 00:11:21,040
‫Quindi ecco la melodia del segnale acustico.

156
00:11:21,040 --> 00:11:24,400
‫Grazie alla modalità di gioco e abbiamo questo evento che avvia il gioco.

157
00:11:24,400 --> 00:11:29,650
‫E quello che stiamo facendo è creare il nostro widget di inizio partita, aggiungendolo alla finestra in modo che possiamo vedere il timer

158
00:11:29,650 --> 00:11:31,780
‫per il conto alla rovescia di inizio partita.

159
00:11:31,780 --> 00:11:39,190
‫Quindi sappiamo che il gioco di inizio è stato chiamato, ma dobbiamo anche implementare il nostro evento implementabile di game over

160
00:11:39,190 --> 00:11:39,820
‫blueprint.

161
00:11:39,820 --> 00:11:47,260
‫Quindi farò clic con il pulsante destro del mouse e digiterò game over ed ecco il nostro evento, game over e dai un'occhiata.

162
00:11:47,290 --> 00:11:50,860
‫Nota che abbiamo questo gioco ed è un booleano.

163
00:11:50,860 --> 00:11:57,220
‫Quindi, quando chiamiamo questa funzione da C++, stiamo passando un valore booleano per B un gioco.

164
00:11:57,220 --> 00:12:04,270
‫Il nodo dell'evento del progetto elimina la B minuscola e inserisce uno spazio tra uno e il gioco come una sorta di

165
00:12:04,270 --> 00:12:05,440
‫cortesia per noi.

166
00:12:05,440 --> 00:12:10,150
‫Ora creeremo alcuni widget in modo da poter vedere quando abbiamo vinto o perso la partita, ma lo

167
00:12:10,150 --> 00:12:11,650
‫faremo in un video futuro.

168
00:12:11,650 --> 00:12:17,770
‫Per ora, voglio solo confermare che questo viene chiamato e chiamato correttamente, quindi posso farlo con un nodo di

169
00:12:17,770 --> 00:12:22,180
‫stringa di stampa e possiamo stampare il valore in base a questo booleano.

170
00:12:22,180 --> 00:12:29,080
‫Se faccio clic e trascino questo booleano direttamente nell'input della stringa, vedremo che c'è un booleano convertito

171
00:12:29,080 --> 00:12:30,280
‫in stringa.

172
00:12:30,280 --> 00:12:37,420
‫Questo è un altro comodo nodo di conversione che converte un booleano in una stringa per noi e la sua

173
00:12:37,420 --> 00:12:43,690
‫funzionalità è tale da convertire nella parola true o false in base al valore di verità del

174
00:12:43,690 --> 00:12:44,350
‫booleano.

175
00:12:44,710 --> 00:12:46,120
‫Allora perché non lo proviamo?

176
00:12:46,120 --> 00:12:48,040
‫Sto per compilare e premere play.

177
00:12:49,400 --> 00:12:52,570
‫Va bene, ora sono pronto per provare a vincere la partita.

178
00:12:52,580 --> 00:12:55,340
‫Spero di non perdere prima di poterlo fare.

179
00:12:55,430 --> 00:13:01,430
‫E ho perso la partita e puoi vedere il falso stampato in alto a sinistra dello schermo.

180
00:13:01,430 --> 00:13:08,570
‫Quindi ora sappiamo che perdere la partita fa sì che la partita dell'evento venga chiamata con il passaggio di false, dobbiamo

181
00:13:08,570 --> 00:13:12,050
‫assicurarci che true venga ignorato quando vinciamo la partita.

182
00:13:12,050 --> 00:13:14,900
‫Quindi proviamo a uccidere tutte le torrette.

183
00:13:15,380 --> 00:13:18,020
‫Quindi devo davvero cercare di non ottenere un successo.

184
00:13:18,020 --> 00:13:19,250
‫Oh, sono già stato colpito.

185
00:13:19,910 --> 00:13:21,560
‫Questo è piuttosto impegnativo.

186
00:13:22,840 --> 00:13:24,820
‫E ci andiamo.

187
00:13:24,820 --> 00:13:28,720
‫E true è stampato in alto a sinistra dello schermo.

188
00:13:28,750 --> 00:13:31,600
‫Si presenta solo per pochi secondi, quindi potresti averlo perso.

189
00:13:31,630 --> 00:13:32,350
‫Va bene, fantastico.

190
00:13:32,350 --> 00:13:35,050
‫Quindi ora abbiamo condizioni per vincere e perdere.

191
00:13:35,080 --> 00:13:41,380
‫Il passaggio successivo consiste nel mostrarlo effettivamente sotto forma di widget sullo schermo in modo da non fare affidamento sul nodo

192
00:13:41,380 --> 00:13:42,850
‫della stringa di stampa.

193
00:13:42,880 --> 00:13:48,010
‫Quindi, in sintesi, ora abbiamo le condizioni per vincere e perdere, e ci sono solo alcune

194
00:13:48,010 --> 00:13:53,890
‫cose che dobbiamo fare per perfezionarlo, come creare widget che informino il giocatore che ha vinto o perso la partita.

195
00:13:53,890 --> 00:13:58,900
‫Abbiamo anche contato il numero di torri usando un vassoio e la funzione delle statistiche di gioco.

196
00:13:58,930 --> 00:14:00,600
‫Prendi tutti gli attori della classe.

197
00:14:00,610 --> 00:14:01,270
‫Ottimo lavoro.

198
00:14:01,270 --> 00:14:03,370
‫Questo gioco sta davvero arrivando.

199
00:14:03,370 --> 00:14:09,220
‫Nel prossimo video creeremo quei widget e poi saremo pronti per iniziare ad aggiungere effetti speciali e

200
00:14:09,220 --> 00:14:10,840
‫perfezionare il nostro gioco.

201
00:14:10,870 --> 00:14:12,520
‫Ci vediamo nel prossimo video.