﻿1
00:00:04,290 --> 00:00:05,650
‫Ei, bem-vindo de volta.

2
00:00:05,670 --> 00:00:09,900
‫Neste vídeo, estamos preocupados com as condições de vitória e derrota.

3
00:00:10,320 --> 00:00:14,520
‫Esta é uma das últimas coisas que vamos lidar neste projeto de jogo.

4
00:00:14,550 --> 00:00:16,860
‫Agora vamos dar uma olhada no nosso plano de seção.

5
00:00:16,860 --> 00:00:23,430
‫Agora, já marcamos os primeiros cinco itens em nosso plano de seção, e os dois últimos são os efeitos

6
00:00:23,430 --> 00:00:26,580
‫especiais e as condições de vitória e derrota.

7
00:00:26,580 --> 00:00:32,250
‫E eu gostaria de mudar esses dois últimos e lidar com as condições de vitória e derrota apenas

8
00:00:32,250 --> 00:00:39,300
‫porque esta é a última de nossa lógica de programação de jogo e os efeitos especiais são cosméticos e mais como toques

9
00:00:39,300 --> 00:00:42,420
‫finais para que possamos lidar com isso no final.

10
00:00:42,420 --> 00:00:48,300
‫Então, neste vídeo, vamos criar uma função de game over para sabermos quando o jogo

11
00:00:48,300 --> 00:00:49,950
‫foi ganho ou perdido.

12
00:00:49,950 --> 00:00:55,410
‫E para ganhar o jogo, vamos precisar contar o número de torres no mundo, porque uma

13
00:00:55,410 --> 00:00:59,730
‫vez que destruímos todas as torres, então sabemos que vencemos o jogo.

14
00:00:59,730 --> 00:01:05,670
‫E se o tanque em si for destruído, podemos considerar que essa é a condição de perda.

15
00:01:05,670 --> 00:01:11,760
‫Então, estou de volta aqui no modo de jogo e a primeira coisa que gostaria de fazer é criar outro evento implementável

16
00:01:11,760 --> 00:01:12,540
‫de blueprint.

17
00:01:12,570 --> 00:01:19,980
‫Temos essa função start game, que podemos chamar de C++, mas estamos implementando sua lógica no modo de

18
00:01:19,980 --> 00:01:20,520
‫jogo.

19
00:01:20,520 --> 00:01:27,120
‫Blueprint Graças ao Evento Implementável do Blueprint, gostaria de criar outro desses para perder o

20
00:01:27,120 --> 00:01:27,720
‫jogo.

21
00:01:27,720 --> 00:01:31,530
‫Então vou criar uma função void chamada Game Over.

22
00:01:31,530 --> 00:01:37,530
‫E para este, eu gostaria de usar um parâmetro de entrada booleano chamado B one game.

23
00:01:37,530 --> 00:01:43,020
‫E é claro que este será um evento implementável de blueprint porque a única coisa que

24
00:01:43,020 --> 00:01:50,130
‫eu gostaria de lidar com essa função é mostrar que perdemos ou ganhamos o jogo e que podemos fazer a partir de blueprints.

25
00:01:50,130 --> 00:01:52,410
‫Então temos uma função game over.

26
00:01:52,410 --> 00:01:55,350
‫Agora precisamos saber quando devemos chamar essa função.

27
00:01:55,350 --> 00:02:00,450
‫Bem, em primeiro lugar, sabemos que podemos chamar esta função quando perdemos o jogo, e

28
00:02:00,450 --> 00:02:02,550
‫isso será se o tanque morreu.

29
00:02:02,550 --> 00:02:10,050
‫Então vamos para nossa função ator morreu aqui no modo de jogo de tanques de sintonia CP E vemos que se o ator

30
00:02:10,050 --> 00:02:15,840
‫morto é o tanque, então estamos lidando com a destruição do tanque e estamos configurando o estado habilitado

31
00:02:15,840 --> 00:02:16,680
‫para falso.

32
00:02:16,710 --> 00:02:25,020
‫Outra coisa que podemos fazer aqui é encerrar o jogo simplesmente chamando game over e este booleano é um jogo que podemos

33
00:02:25,020 --> 00:02:27,240
‫passar como false para isso.

34
00:02:27,240 --> 00:02:31,770
‫Então isso cuida de perder o jogo, pelo menos do lado C++.

35
00:02:31,800 --> 00:02:34,770
‫Agora precisamos saber quando devemos vencer o jogo.

36
00:02:34,800 --> 00:02:36,540
‫Agora aqui um ator morreu.

37
00:02:36,540 --> 00:02:43,050
‫Se o ator morto pode ser lançado em uma torre, sabemos que acabamos de destruir uma torre.

38
00:02:43,050 --> 00:02:49,740
‫Agora, este seria o lugar perfeito para atualizar uma contagem de torres ou uma variável do tipo inteiro que mantém

39
00:02:49,740 --> 00:02:53,220
‫o controle de quantas torres no mundo existem atualmente.

40
00:02:53,250 --> 00:02:53,580
‫Agora.

41
00:02:53,580 --> 00:02:59,310
‫Para fazer isso, precisamos de uma variável para acompanhar o número de torres para que possamos

42
00:02:59,310 --> 00:03:02,250
‫adicionar uma variável privada aqui no arquivo H.

43
00:03:02,250 --> 00:03:03,960
‫E eu gostaria de fazer isso aqui embaixo.

44
00:03:03,960 --> 00:03:08,880
‫Então vou criar um INT 32 e vou chamar isso de torres alvo.

45
00:03:09,120 --> 00:03:15,840
‫Agora podemos inicializar isso logo de cara para um valor de zero, mas precisamos atualizar isso à medida que

46
00:03:15,840 --> 00:03:17,760
‫o número de torres diminui.

47
00:03:17,760 --> 00:03:22,350
‫E também precisamos definir isso para o número de torres que existem no mundo.

48
00:03:22,470 --> 00:03:28,170
‫Agora podemos codificar isso para quatro, mas o que acontece quando começamos a adicionar mais torres aos nossos níveis?

49
00:03:28,170 --> 00:03:30,690
‫Bem, então fica um pouco mais complicado.

50
00:03:30,690 --> 00:03:35,580
‫Então, o que eu gostaria de fazer é ver quantas torres existem no mundo.

51
00:03:35,610 --> 00:03:43,050
‫Agora, eu poderia criar uma função para isso que retorna 32 e essa função pode descobrir quantas torres existem

52
00:03:43,050 --> 00:03:45,810
‫no mundo e retornar o número.

53
00:03:45,810 --> 00:03:51,450
‫Então, vou chamar essa função, obter uma contagem de torres de destino.

54
00:03:51,600 --> 00:03:55,650
‫Então vamos em frente e dar a esta função um corpo no arquivo CP.

55
00:03:55,680 --> 00:04:02,130
‫Eu irei até o final e criarei o corpo da função e não posso esquecer de colocar o

56
00:04:02,130 --> 00:04:05,040
‫nome da classe antes do nome da função.

57
00:04:05,040 --> 00:04:12,270
‫Agora isso vai retornar um final 32 e precisamos decidir como vamos descobrir quantas torres

58
00:04:12,270 --> 00:04:13,170
‫existem.

59
00:04:13,200 --> 00:04:19,800
‫Agora existe uma função que existe na estática do jogo chamada Get All Actors of class.

60
00:04:19,800 --> 00:04:21,300
‫Aqui está a documentação.

61
00:04:21,300 --> 00:04:25,770
‫Ele diz Encontre todos os atores no mundo da classe especificada.

62
00:04:25,770 --> 00:04:28,890
‫Portanto, precisamos especificar uma classe específica.

63
00:04:28,920 --> 00:04:31,530
‫Agora esta função tem três entradas.

64
00:04:31,530 --> 00:04:33,720
‫Primeiro é um objeto de contexto mundial.

65
00:04:33,720 --> 00:04:34,770
‫Essa é fácil.

66
00:04:34,770 --> 00:04:36,180
‫Nós sabemos como lidar com isso.

67
00:04:36,180 --> 00:04:41,610
‫Mas a seguir temos uma subclasse PT de um ator e isso é chamado de Actor Class.

68
00:04:41,610 --> 00:04:48,000
‫Agora vimos que funções que requerem uma subclasse PT de podem aceitar uma classe u como entradas e o terceiro

69
00:04:48,000 --> 00:04:49,740
‫parâmetro é um array T.

70
00:04:49,770 --> 00:04:56,940
‫Ele requer uma matriz t de ponteiros de ator e isso é passado como uma referência e não é

71
00:04:56,940 --> 00:05:03,680
‫uma referência const que parece sugerir que essa função pode alterar esse parâmetro de entrada chamado act.

72
00:05:03,730 --> 00:05:08,530
‫Aqui está outra dica de que este é o caso, é que é chamado de atores.

73
00:05:08,530 --> 00:05:15,820
‫É um parâmetro de saída, o que significa que o passamos e depois que a função é chamada, ela tem valores

74
00:05:15,820 --> 00:05:18,220
‫que foram colocados nela pela função.

75
00:05:18,220 --> 00:05:21,340
‫Então, podemos pensar nisso como uma espécie de saída para a função.

76
00:05:21,340 --> 00:05:28,810
‫Agora diz aqui embaixo para parâmetros, classe de ator é a classe de ator a ser encontrada deve ser especificada ou a

77
00:05:28,810 --> 00:05:30,640
‫matriz de resultados estará vazia.

78
00:05:30,640 --> 00:05:37,240
‫Queremos encontrar todas as torres e atores de saída é uma matriz de saída de atores da classe especificada.

79
00:05:37,240 --> 00:05:42,670
‫Assim, uma vez que chamamos essa função e passamos um array, quando a

80
00:05:42,670 --> 00:05:48,160
‫função terminar, esse array conterá ponteiros para todos os atores no mundo da classe especificada.

81
00:05:48,160 --> 00:05:51,880
‫Portanto, sabemos que esta função requer um objeto de contexto mundial.

82
00:05:51,880 --> 00:05:56,500
‫Agora, se vamos chamar isso de dentro do modo de jogo, podemos passar isso a seguir.

83
00:05:56,500 --> 00:06:03,490
‫Precisamos da subclasse PT para especificar o ator A e sabemos que isso pode ser um novo ponteiro de classe.

84
00:06:03,490 --> 00:06:06,070
‫Agora precisamos especificar a classe a ser encontrada.

85
00:06:06,070 --> 00:06:12,010
‫Se especificarmos um ator, obteremos um grande array preenchido com ponteiros para cada ator no mundo.

86
00:06:12,010 --> 00:06:13,810
‫Mas não precisamos de todos os atores.

87
00:06:13,810 --> 00:06:21,070
‫Precisamos apenas das torres para que possamos usar uma classe estática de torre que nos retornará uma nova classe que

88
00:06:21,070 --> 00:06:23,290
‫representa a classe A Tower C++.

89
00:06:23,290 --> 00:06:26,770
‫Agora, o terceiro parâmetro é uma matriz T de ponteiros de ator.

90
00:06:26,770 --> 00:06:33,760
‫Portanto, se criarmos uma variável local do tipo T array especificando o ponteiro de um ator nos colchetes angulares,

91
00:06:33,760 --> 00:06:35,980
‫podemos chamá-lo de estática do jogo.

92
00:06:36,010 --> 00:06:41,620
‫Faça com que todos os atores da classe passem nessas três entradas, e o resultado dessa ação será que

93
00:06:41,620 --> 00:06:45,970
‫nosso array de torres deve conter ponteiros para todas as torres do nosso mundo.

94
00:06:45,970 --> 00:06:52,840
‫Agora, a bandeja é uma boa classe de contêiner que pode conter vários elementos, desde que todos compartilhem o

95
00:06:52,840 --> 00:06:53,830
‫mesmo tipo.

96
00:06:53,830 --> 00:07:01,690
‫E esta classe tem uma grande quantidade de funções que podemos usar ao armazenar itens em uma bandeja.

97
00:07:01,720 --> 00:07:08,710
‫Agora eu vou rolar até o fim e mostrar a você esta função aqui chamada Num Short four number e

98
00:07:08,830 --> 00:07:12,310
‫ela diz Retorna o número de elementos na matriz.

99
00:07:12,310 --> 00:07:19,690
‫Assim, podemos usar esta função para obter o número de elementos em nosso array assim que tivermos todas as torres do

100
00:07:19,690 --> 00:07:20,380
‫mundo.

101
00:07:20,380 --> 00:07:26,080
‫Então, se chamarmos o número da Torre, podemos usar isso como o valor de retorno para nossa função.

102
00:07:26,080 --> 00:07:31,930
‫E como vimos, definimos nosso valor de retorno para essa função que chamamos de get target tower count como um

103
00:07:31,930 --> 00:07:35,980
‫n 32, podemos retornar o número de elementos no array da nossa torre.

104
00:07:35,980 --> 00:07:41,230
‫Então, eu gostaria de desafiá-lo a implementar esta função de contagem de torres de destino.

105
00:07:41,230 --> 00:07:44,710
‫Portanto, crie uma matriz t local do ator tipo A.

106
00:07:44,710 --> 00:07:47,110
‫Você pode chamá-lo de torres ou qualquer coisa que você goste.

107
00:07:47,110 --> 00:07:52,930
‫Agora use o seu jogo, jogue a função estática, pegue todos os atores da classe e certifique-se de passar os

108
00:07:52,930 --> 00:07:54,220
‫parâmetros de entrada corretos.

109
00:07:54,220 --> 00:08:00,310
‫Agora, depois de chamar essa função, sua bandeja conterá ponteiros para todas as torres do nosso

110
00:08:00,310 --> 00:08:06,850
‫mundo, então você pode simplesmente retornar o número de torres usando a função num que pertence à

111
00:08:06,850 --> 00:08:07,930
‫classe bandeja.

112
00:08:07,930 --> 00:08:10,660
‫Então vá em frente e pause o vídeo e implemente.

113
00:08:10,660 --> 00:08:12,640
‫Obtenha a contagem de torres de destino agora.

114
00:08:15,670 --> 00:08:16,000
‫OK.

115
00:08:16,000 --> 00:08:17,980
‫Então aqui está a contagem de torres de destino.

116
00:08:18,010 --> 00:08:24,250
‫Agora, a primeira coisa que vou fazer é criar um array t local especificando um ponteiro de ator como o tipo

117
00:08:24,250 --> 00:08:26,590
‫de elemento que esse array deve armazenar.

118
00:08:26,590 --> 00:08:31,720
‫E eu vou chamar isso de torres agora eu preciso te chamar de estática de jogabilidade, então eu preciso ter certeza de

119
00:08:31,720 --> 00:08:33,100
‫que esse cabeçalho está incluído.

120
00:08:33,130 --> 00:08:38,830
‫Agora vejo que é porque estamos usando em algumas de nossas outras funções, mas é bom fazer essa

121
00:08:38,830 --> 00:08:39,340
‫verificação.

122
00:08:39,370 --> 00:08:47,380
‫Em seguida, posso usar sua estática de jogo e vou chamar todos os atores da classe.

123
00:08:47,410 --> 00:08:54,130
‫Agora, a primeira entrada é um objeto de contexto mundial que vou passar e a próxima é a subclasse

124
00:08:54,130 --> 00:08:55,990
‫de representação da classe ator.

125
00:08:55,990 --> 00:09:03,430
‫E mencionei que podemos usar uma classe estática de torre que retornará uma classe U que representa a classe

126
00:09:03,430 --> 00:09:04,270
‫de torre.

127
00:09:04,300 --> 00:09:09,190
‫Agora, novamente, é uma boa ideia ter certeza de que estamos incluindo torres, o que estamos fazendo.

128
00:09:09,220 --> 00:09:14,740
‫Agora, o terceiro e último parâmetro vai ser a bandeja e podemos passar em torres.

129
00:09:14,740 --> 00:09:21,340
‫Assim, uma vez que esta função tenha sido chamada, as torres agora conterão ponteiros para todas as torres do

130
00:09:21,340 --> 00:09:21,880
‫mundo.

131
00:09:21,880 --> 00:09:28,000
‫De fato, se existissem objetos de uma classe que derivasse de torres, nós também os obteríamos.

132
00:09:28,000 --> 00:09:33,780
‫Então, como temos um array de torres, podemos simplesmente retornar o número de elementos desse array.

133
00:09:33,790 --> 00:09:40,660
‫Então, vou usar uma instrução de retorno e usar towers dot num e agora temos uma contagem de torres de destino.

134
00:09:40,660 --> 00:09:41,740
‫Então isso é ótimo.

135
00:09:41,740 --> 00:09:48,220
‫Podemos usar isso para inicializar nossa contagem de torres, que chamamos de torres de destino e podemos fazer isso quando iniciarmos

136
00:09:48,220 --> 00:09:49,090
‫o jogo.

137
00:09:49,090 --> 00:09:51,780
‫Então eu vou colocar isso aqui e lidar com o início do jogo.

138
00:09:51,790 --> 00:09:54,400
‫Na verdade, gostaria que fosse a primeira coisa que fizéssemos.

139
00:09:54,400 --> 00:10:02,530
‫Então, vou pegar as torres de destino e configurá-lo igual ao valor de retorno da contagem de torres de destino.

140
00:10:02,560 --> 00:10:07,240
‫Agora as torres de destino devem ser inicializadas com o número de torres em nosso mundo.

141
00:10:07,240 --> 00:10:13,120
‫Portanto, isso é ótimo, mas precisamos atualizar essa contagem toda vez que uma torre morre, o que significa que

142
00:10:13,120 --> 00:10:16,000
‫precisamos entrar na função de morte do ator.

143
00:10:16,000 --> 00:10:22,660
‫E aqui, se lançamos um ator morto para uma torre destruída, depois de lidarmos com a destruição,

144
00:10:22,660 --> 00:10:30,430
‫devemos atualizar nossa variável de torres de destino para que possamos dizer torres de destino e usar o operador de decremento.

145
00:10:30,430 --> 00:10:35,560
‫Podemos usar o operador pós-decremento ou o operador de situação.

146
00:10:35,560 --> 00:10:41,800
‫Ambos resultarão na mesma ação que é pegar torres alvo e subtrair uma delas.

147
00:10:41,800 --> 00:10:48,220
‫Agora, assim que subtraímos um das torres alvo, agora precisamos verificar se as torres alvo

148
00:10:48,220 --> 00:10:49,660
‫chegaram a zero.

149
00:10:49,660 --> 00:10:55,150
‫Então, vou colocar um if check aqui para ver se as torres do Target chegaram a zero.

150
00:10:55,780 --> 00:11:02,380
‫Agora, assim que isso acontecer, sabemos que o jogo deve terminar para que possamos chamar a

151
00:11:02,710 --> 00:11:10,660
‫função game over passando no verdadeiro jogo 4b1, já que destruímos todas as torres e podemos considerar isso uma vitória.

152
00:11:10,660 --> 00:11:13,180
‫Agora vamos em frente e compilar nosso código.

153
00:11:13,180 --> 00:11:18,670
‫Agora, de volta ao editor, o que eu gostaria de fazer antes de encerrarmos este vídeo é entrar em nosso modelo de

154
00:11:18,670 --> 00:11:19,420
‫modo de jogo.

155
00:11:19,420 --> 00:11:21,040
‫Então aqui está a melodia do bip.

156
00:11:21,040 --> 00:11:24,400
‫Obrigado modo de jogo e temos este jogo de início de evento.

157
00:11:24,400 --> 00:11:29,650
‫E o que estamos fazendo é criar nosso widget de início de jogo, adicionando-o à janela de visualização para que possamos ver o

158
00:11:29,650 --> 00:11:31,780
‫cronômetro de contagem regressiva de início de jogo.

159
00:11:31,780 --> 00:11:39,190
‫Portanto, sabemos que start game está sendo chamado, mas também precisamos implementar nosso evento implementável game over

160
00:11:39,190 --> 00:11:39,820
‫blueprint.

161
00:11:39,820 --> 00:11:47,260
‫Então eu vou clicar com o botão direito do mouse e digitar game over e aqui está o nosso evento, game over e confira.

162
00:11:47,290 --> 00:11:50,860
‫Observe que temos este jogo e é um booleano.

163
00:11:50,860 --> 00:11:57,220
‫Então, quando chamamos essa função de C++, estamos passando um valor booleano para B um jogo.

164
00:11:57,220 --> 00:12:04,270
‫O nó de evento do blueprint retira o B minúsculo e coloca um espaço entre um e o jogo como uma espécie de

165
00:12:04,270 --> 00:12:05,440
‫cortesia para nós.

166
00:12:05,440 --> 00:12:10,150
‫Agora vamos criar alguns widgets para que possamos ver quando ganhamos ou perdemos o jogo, mas faremos

167
00:12:10,150 --> 00:12:11,650
‫isso em um vídeo futuro.

168
00:12:11,650 --> 00:12:17,770
‫Por enquanto, eu só quero confirmar que isso está sendo chamado e chamado corretamente para que eu possa fazer isso com

169
00:12:17,770 --> 00:12:22,180
‫um nó de string de impressão e possamos imprimir o valor com base nesse booleano.

170
00:12:22,180 --> 00:12:29,080
‫Se eu clicar e arrastar este booleano direto para a entrada de string, veremos que há um convert

171
00:12:29,080 --> 00:12:30,280
‫boolean to string.

172
00:12:30,280 --> 00:12:37,420
‫Este é outro nó de conversão conveniente que converterá um booleano em uma string para nós, e sua funcionalidade

173
00:12:37,420 --> 00:12:43,690
‫é tal que converterá na palavra true ou false com base no valor de verdade do

174
00:12:43,690 --> 00:12:44,350
‫booleano.

175
00:12:44,710 --> 00:12:46,120
‫Então, por que não testamos isso?

176
00:12:46,120 --> 00:12:48,040
‫Vou compilar e apertar play.

177
00:12:49,400 --> 00:12:52,570
‫Muito bem, agora estou pronto para tentar ganhar o jogo.

178
00:12:52,580 --> 00:12:55,340
‫Espero não perder antes que eu possa fazê-lo.

179
00:12:55,430 --> 00:13:01,430
‫E eu perdi o jogo e você pode ver falso impresso no canto superior esquerdo da tela.

180
00:13:01,430 --> 00:13:08,570
‫Então, agora sabemos que perder o jogo resulta no evento game over sendo chamado com false sendo passado, precisamos ter certeza

181
00:13:08,570 --> 00:13:12,050
‫de que true será passado quando vencermos o jogo.

182
00:13:12,050 --> 00:13:14,900
‫Então vamos tentar matar todas as torres.

183
00:13:15,380 --> 00:13:18,020
‫Então eu preciso realmente tentar não conseguir um hit.

184
00:13:18,020 --> 00:13:19,250
‫Ah, eu já fui atingido.

185
00:13:19,910 --> 00:13:21,560
‫Isso é bastante desafiador.

186
00:13:22,840 --> 00:13:24,820
‫E lá vamos nós.

187
00:13:24,820 --> 00:13:28,720
‫E true é impresso no canto superior esquerdo da tela.

188
00:13:28,750 --> 00:13:31,600
‫Ele só aparece por alguns segundos, então você pode ter perdido.

189
00:13:31,630 --> 00:13:32,350
‫Certo, ótimo.

190
00:13:32,350 --> 00:13:35,050
‫Então agora temos condições de ganhar e perder.

191
00:13:35,080 --> 00:13:41,380
‫A próxima etapa é realmente mostrar isso na forma de um widget na tela para que não dependamos do nó

192
00:13:41,380 --> 00:13:42,850
‫da string de impressão.

193
00:13:42,880 --> 00:13:48,010
‫Então, em resumo, agora temos condições de ganhar e perder, e há apenas algumas coisas que

194
00:13:48,010 --> 00:13:53,890
‫precisamos fazer para aprimorar isso, como criar widgets que informam ao jogador que ele ganhou ou perdeu o jogo.

195
00:13:53,890 --> 00:13:58,900
‫Também contamos o número de torres usando uma bandeja e a função de estática do jogo.

196
00:13:58,930 --> 00:14:00,600
‫Obter todos os atores de classe.

197
00:14:00,610 --> 00:14:01,270
‫Bom trabalho.

198
00:14:01,270 --> 00:14:03,370
‫Este jogo está realmente chegando.

199
00:14:03,370 --> 00:14:09,220
‫No próximo vídeo, criaremos esses widgets e estaremos prontos para começar a adicionar efeitos especiais

200
00:14:09,220 --> 00:14:10,840
‫e aprimorar nosso jogo.

201
00:14:10,870 --> 00:14:12,520
‫Vejo vocês no próximo vídeo.

