1
00:00:00,180 --> 00:00:02,530
Então, agora temos duas coisas diferentes nas quais podemos nos concentrar.

2
00:00:02,610 --> 00:00:09,540
O primeiro está mudando a exibição aqui para ser verde no jogador vencedor e esse é bastante

3
00:00:09,540 --> 00:00:10,110
simples.

4
00:00:10,140 --> 00:00:14,670
E o segundo está fazendo com que o botão de reinicialização funcione para que possamos redefinir e reproduzir novamente.

5
00:00:14,850 --> 00:00:20,530
Então, vamos começar com a mudança de cor e eu vou fazer isso definindo uma classe em um arquivo CSSA.

6
00:00:20,580 --> 00:00:25,420
Então eu preciso fazer um arquivo C S S e eu só vou chamar esse scorekeeper.

7
00:00:25,590 --> 00:00:35,790
C Ss então eu vou ligar para ele em vez do meu scorekeeper de arquivo HDMI Dotsie SS e salvar.

8
00:00:35,790 --> 00:00:43,080
e vou chamar isso de inverno e vou dizer que a cor é verde e é tudo o que precisamos e salvaremos.

9
00:00:43,080 --> 00:00:47,090
Então eu vou para o meu arquivo CSSA e definir uma aula

10
00:00:47,190 --> 00:00:49,620
E apenas para verificar se parece do jeito que eu quero.

11
00:00:49,620 --> 00:00:57,270
Vamos apenas adicioná-lo ao lapso, então, dirá iguais de classe e vamos dar-lhe uma aula de vencedor para a exibição

12
00:00:57,270 --> 00:00:59,540
do jogador 1 do get go.

13
00:00:59,610 --> 00:01:03,090
E se eu atualizar, você pode ver que temos um verde 0.

14
00:01:03,090 --> 00:01:05,700
É exatamente isso que queremos como um incremento.

15
00:01:05,730 --> 00:01:09,260
Claro que queremos que ele comece como preto e apenas adicione a classe.

16
00:01:09,360 --> 00:01:14,320
Quando o jogo acabou, então precisamos voltar para o nosso javascript e nos livrar disso.

17
00:01:14,520 --> 00:01:17,030
Então, ele volta ao preto.

18
00:01:17,310 --> 00:01:18,910
Acesse nosso javascript agora.

19
00:01:19,530 --> 00:01:24,840
Então, vamos começar para o jogador 1 e precisamos verificar se a pontuação do jogador 1 é igual à pontuação vencedora.

20
00:01:24,870 --> 00:01:26,640
Isso significa que o jogador ganhou.

21
00:01:26,760 --> 00:01:33,360
Então, aqui, vamos adicionar a lista de classe de exibição do jogador 1.

22
00:01:33,360 --> 00:01:37,570
Vamos adicionar o vencedor da classe e isso é tudo o que temos a fazer.

23
00:01:37,830 --> 00:01:44,500
Então, se atualizarmos, verá como eu incrementar a pontuação do jogador 1 e chegar a 5.

24
00:01:44,520 --> 00:01:46,580
Essa classe foi adicionada.

25
00:01:46,830 --> 00:01:49,390
Então, se dar uma olhada aqui, eu vou inspecionar isso.

26
00:01:49,410 --> 00:01:54,090
Não há classe e continuo aumentando até chegar até 5.

27
00:01:54,090 --> 00:01:59,640
Preste atenção aqui e obtemos vencedores de classe igualados quando chegarmos a 5.

28
00:01:59,910 --> 00:02:02,900
Então, faremos o mesmo para o Player 2.

29
00:02:03,150 --> 00:02:07,230
Então, se o jogador dois marcar, a pontuação vencedora mudará o jogador para exibição.

30
00:02:07,710 --> 00:02:10,480
Vamos verificar o incremento para 5.

31
00:02:10,650 --> 00:02:12,060
Ótimo.

32
00:02:13,110 --> 00:02:15,030
Tudo parece estar funcionando bem.

33
00:02:15,450 --> 00:02:19,260
Então, a próxima peça está fazendo com que o botão de reinicialização funcione agora.

34
00:02:19,350 --> 00:02:22,490
Se conseguimos o jogo, ele sempre está definido para ser verdade.

35
00:02:22,500 --> 00:02:24,990
Não há como mudar o jogo.

36
00:02:24,990 --> 00:02:28,830
Então, clicar no botão de reinicialização precisa disparar algumas linhas de código diferentes.

37
00:02:28,860 --> 00:02:30,540
O primeiro que você deseja mudar.

38
00:02:30,540 --> 00:02:33,390
Jogador 1 pontuação e jogador para marcar de volta a zero.

39
00:02:33,420 --> 00:02:38,820
Queremos alterar os valores aqui exibidos na tela do player 1 e o player para exibir

40
00:02:38,820 --> 00:02:43,860
para ser zero e queremos remover essa classe verde de qualquer elemento em que esteja.

41
00:02:44,130 --> 00:02:49,170
E então, a última coisa é que precisamos garantir que o jogo acabe por ser falso, de modo que

42
00:02:49,170 --> 00:02:51,180
nosso código e aqui possam ser executados novamente.

43
00:02:51,240 --> 00:02:57,200
Então, a primeira coisa que precisamos para selecionar o botão, nós lhe damos id igual a redefinição.

44
00:02:57,390 --> 00:03:00,170
Então precisamos ir aqui e simplesmente selecioná-lo.

45
00:03:00,330 --> 00:03:02,590
Então vou fazer isso com os outros botões até agora.

46
00:03:02,640 --> 00:03:11,880
O botão Reset é igual ao ponto do documento e faremos outro elemento get por id e, desta vez, o ID será reiniciado e salvará

47
00:03:13,050 --> 00:03:16,400
e, em seguida, apenas para verificar se ele funciona.

48
00:03:16,580 --> 00:03:17,820
Faça um registro constante.

49
00:03:18,060 --> 00:03:22,900
Reinicie o botão de reinicialização e atualize.

50
00:03:22,900 --> 00:03:26,050
Se olharmos no nosso console, obtemos o nosso botão correto.

51
00:03:26,070 --> 00:03:27,960
Foi cancelado.

52
00:03:28,390 --> 00:03:35,220
OK, então, devemos começar adicionando nosso ouvinte de eventos para clicar nesse botão de reinicialização, então o botão

53
00:03:35,610 --> 00:03:45,510
de reinicialização que o ouvinte de evento clique em nossa função de retorno de chamada e tudo o que queremos fazer para começar de novo, basta

54
00:03:45,510 --> 00:03:53,490
cancelar o rescisão do registro clicado apenas para se certificar de que funciona e aí, nosso botão de reinicialização foi clicado.

55
00:03:54,360 --> 00:03:57,780
Então, a lógica, como discutimos, precisamos definir.

56
00:03:57,780 --> 00:04:00,330
Jogador 1 pontuação e jogador para marcar de volta a zero.

57
00:04:00,450 --> 00:04:02,440
Então isso é bastante direto.

58
00:04:02,460 --> 00:04:05,890
Jogador 1 pontuação zero jogador para marcar é zero.

59
00:04:06,330 --> 00:04:12,210
Mas se eu executar este agora, onde eu apenas altero a pontuação do jogador 1 no jogador para marcar para zero e incrementar

60
00:04:12,330 --> 00:04:14,790
para que o jogador ganhe e depois clique em redefinir.

61
00:04:14,850 --> 00:04:20,050
Nada parece acontecer e é porque apenas alteramos a pontuação em javascript.

62
00:04:20,100 --> 00:04:26,400
Nunca atualizamos as pontuações na página, então essas são as variáveis ​​de exibição P1 e P2 que

63
00:04:26,400 --> 00:04:27,050
precisamos atualizar.

64
00:04:27,300 --> 00:04:34,020
Então, queremos fazer um conteúdo de texto de exibição e podemos simplesmente configurá-lo para zero.

65
00:04:34,020 --> 00:04:37,180
Podemos também definir que seja 1 pontuação.

66
00:04:37,320 --> 00:04:38,690
Ambos deveriam ser zero.

67
00:04:39,090 --> 00:04:42,700
Então o mesmo Pete para exibir conteúdo de texto é zero.

68
00:04:42,930 --> 00:04:46,060
Se atualizarmos agora e chegarmos a 5.

69
00:04:47,280 --> 00:04:48,410
Ambos voltam a zero.

70
00:04:48,450 --> 00:04:50,750
Então vamos fazer um jogo mais próximo.

71
00:04:52,360 --> 00:04:55,120
E clique em reset para voltar a zero.

72
00:04:55,500 --> 00:04:58,030
Em seguida, vamos remover a cláusula do vencedor.

73
00:04:58,090 --> 00:05:01,430
Isso fará isso de maneira fácil, removendo a classe vencedora de ambos.

74
00:05:01,540 --> 00:05:03,650
Então, nem sequer verificaremos qual deles tem.

75
00:05:03,730 --> 00:05:05,260
Vamos simplesmente removê-lo de ambos.

76
00:05:05,300 --> 00:05:07,620
É apenas uma questão de exibição.

77
00:05:07,780 --> 00:05:12,070
As listas de classes removem o vencedor.

78
00:05:12,310 --> 00:05:16,440
Então, isso vai se livrar da cláusula e também será feito para exibir.

79
00:05:16,480 --> 00:05:20,830
Então, qualquer um que tenha, não importa porque estamos removendo isso de ambos.

80
00:05:21,940 --> 00:05:25,160
Então, agora, se jogarmos um jogo, obtemos um vencedor.

81
00:05:25,600 --> 00:05:26,850
Eu clique em redefinir.

82
00:05:26,920 --> 00:05:30,560
Ambos voltam a apenas um texto simples em branco.

83
00:05:31,140 --> 00:05:33,700
Mas, como você pode ver, chego às cinco.

84
00:05:33,790 --> 00:05:36,340
Eu clique no botão de reiniciar ainda não funcionando.

85
00:05:36,610 --> 00:05:39,930
E isso porque o jogo ainda é verdadeiro.

86
00:05:40,110 --> 00:05:42,900
E, portanto, nenhum de nossos códigos em vez desses eventos será executado.

87
00:05:43,090 --> 00:05:45,000
Então, a última coisa que precisamos fazer é definir.

88
00:05:45,100 --> 00:05:50,340
O jogo de volta ao falso e isso deve nos permitir continuar jogando.

89
00:05:50,820 --> 00:05:53,350
Então vou atualizar os incrementos.

90
00:05:53,520 --> 00:05:55,530
Vamos começar um jogo.

91
00:05:55,540 --> 00:05:55,990
Aqui vamos nós.

92
00:05:55,990 --> 00:05:57,240
Eu não posso mais jogar.

93
00:05:57,250 --> 00:06:04,610
Eu clico no reset e agora o jogo está de volta a falso e eu posso jogar novamente e continuar.

94
00:06:04,840 --> 00:06:07,220
Então, essa é a funcionalidade básica aqui.

95
00:06:07,320 --> 00:06:13,660
Nós quase tudo fizeram a última coisa é conseguir que o jogo seja igual ou o resultado vencedor seja

96
00:06:13,870 --> 00:06:14,650
uma variável.

97
00:06:14,640 --> 00:06:16,520
Portanto, nem sempre são apenas cinco.

98
00:06:16,930 --> 00:06:22,750
Então, temos essa contribuição e queremos usar isso para que, quando eu mudar isso, eu tenho sete, isso diz

99
00:06:22,750 --> 00:06:27,710
que joga para 7 e nosso máximo ou nossa pontuação vencedora é sete em vez de cinco.

100
00:06:27,970 --> 00:06:29,750
Então, temos alguns passos para chegar lá.

101
00:06:29,760 --> 00:06:35,260
A primeira coisa que precisamos fazer é selecionar esta entrada, como você pode ver, temos o tipo de entrada igual ao número.

102
00:06:35,740 --> 00:06:37,330
É a única entrada na página.

103
00:06:37,360 --> 00:06:40,410
Então, não precisamos ter uma ID ou qualquer coisa.

104
00:06:40,420 --> 00:06:46,790
Então eu vou para aqui e selecione-o apenas com meus outros seletores var.

105
00:06:47,050 --> 00:06:55,360
Vamos apenas chamá-lo de nenhuma entrada, é igual ao documento e há muitas maneiras de obtê-lo pode fazer documentar

106
00:06:55,360 --> 00:06:58,030
essa entrada do seletor de consulta.

107
00:06:58,020 --> 00:07:01,400
Nós também poderíamos especificar apenas onde.

108
00:07:01,420 --> 00:07:06,540
O tipo é igual ao número porque pode haver outras entradas.

109
00:07:06,730 --> 00:07:08,070
No nosso caso, eu vou ficar simples.

110
00:07:08,080 --> 00:07:09,330
Há apenas uma entrada.

111
00:07:09,460 --> 00:07:11,190
Então, isso vai funcionar bem.

112
00:07:11,810 --> 00:07:12,120
ESTÁ BEM.

113
00:07:12,120 --> 00:07:14,420
Então, temos essa entrada selecionada.

114
00:07:14,440 --> 00:07:16,390
Então, agora vamos adicionar um evento.

115
00:07:16,420 --> 00:07:22,540
Então, o que queremos acontecer é que, a qualquer momento, isso altera o valor ou o número de mudanças que

116
00:07:22,530 --> 00:07:26,920
queremos que isso atualize e queremos que a variável de pontuação vencedora também seja atualizada.

117
00:07:26,950 --> 00:07:29,200
Então, o que precisamos fazer é adicionar um evento.

118
00:07:29,280 --> 00:07:40,190
Então, vamos ficar entorpecidos e colocar Dot teve o evento Lessner clique apenas faça isso aqui.

119
00:07:41,050 --> 00:07:44,750
Função e todos fazem um alerta.

120
00:07:45,300 --> 00:07:54,150
a entrada e o que você verá é que, na verdade, um ouvinte de cliques não é a melhor ferramenta para esse trabalho.

121
00:07:54,150 --> 00:07:54,720
Clicou

122
00:07:54,920 --> 00:07:58,880
Porque sim, podemos mudar o valor com um clique, como acabei de fazer lá.

123
00:07:59,470 --> 00:08:06,910
Mas eu também posso pressionar apagar e digitar um número e nenhum evento foi disparado porque não tive que clicar.

124
00:08:07,360 --> 00:08:11,110
Então, se eu usar os pequenos botões aqui, um evento rápido dispara.

125
00:08:11,110 --> 00:08:14,670
Caso contrário, se eu usar o meu teclado não recebemos um evento rápido.

126
00:08:14,680 --> 00:08:19,680
Então, há outro tipo de evento que é muito melhor neste caso, que se chama mudança.

127
00:08:19,770 --> 00:08:25,240
Então, um evento de mudança será executado sempre que o valor mudar e não importa como esse valor foi alterado.

128
00:08:25,240 --> 00:08:27,840
Se foi porque cliquei ou pressione a tecla de exclusão.

129
00:08:27,850 --> 00:08:35,000
Então, vamos mudar o alerta aqui para dizer que mudou a entrada e depois atualize.

130
00:08:35,320 --> 00:08:39,900
E se eu clicar aqui para mudá-lo, ele me diz que você mudou a entrada.

131
00:08:40,090 --> 00:08:45,900
Mas se eu excluir e eu digito um número que não envolve clicar nele, também me diz que eu

132
00:08:45,900 --> 00:08:47,960
mudo a entrada para que seja ótimo.

133
00:08:47,980 --> 00:08:52,740
Este é o evento em que queremos usar o evento de mudança a qualquer momento em que

134
00:08:52,750 --> 00:08:59,430
o valor muda, queremos atualizar este número aqui e também queremos atualizar nossa pontuação vencedora para que nosso jogo continue até chegar a

135
00:08:59,430 --> 00:09:00,650
essa nova pontuação vencedora.

136
00:09:00,700 --> 00:09:02,700
Espero que este não seja o nosso resultado real.

137
00:09:02,740 --> 00:09:04,850
Definitivamente um longo jogo de tesoura de papel rock.

138
00:09:05,080 --> 00:09:08,530
Então, a primeira coisa é atualizar esse valor aqui.

139
00:09:08,860 --> 00:09:13,020
Então, como antes, precisamos selecionar o que é um parágrafo.

140
00:09:13,060 --> 00:09:20,440
Então, precisamos selecionar nosso parágrafo e vou fazer um parágrafo VAR igual ao documento que faz a consulta

141
00:09:21,690 --> 00:09:22,590
do seletor.

142
00:09:23,290 --> 00:09:30,330
E então, neste evento rápido, acabaremos de mudar esse conteúdo de texto e começaremos simplesmente mudando

143
00:09:30,340 --> 00:09:35,070
para dizer clicar ou digamos que o valor foi alterado.

144
00:09:36,640 --> 00:09:39,310
Assim como e atualize.

145
00:09:39,310 --> 00:09:45,470
Agora, se eu alterar o valor que o parágrafo muda para dizer o valor alterado, mas este é o nosso

146
00:09:45,460 --> 00:09:49,730
mesmo problema que enfrentamos anteriormente com o H-1, não queremos alterar o parágrafo inteiro.

147
00:09:49,810 --> 00:09:52,390
Nós só queremos mudar essa pequena porção.

148
00:09:52,390 --> 00:09:55,000
Então o que queremos usar é realmente um outro período.

149
00:09:55,300 --> 00:09:58,950
Então vamos voltar e adicionaremos um espaço ao redor do número.

150
00:09:59,380 --> 00:10:04,300
E este é um uso perfeito para um período em que novamente podemos usá-lo para atingir apenas uma

151
00:10:04,300 --> 00:10:06,400
pequena porção de um elemento, não o todo.

152
00:10:06,820 --> 00:10:11,380
E na verdade não vou dar uma ideia desta vez apenas para mostrar-lhe outra maneira de selecioná-lo.

153
00:10:11,710 --> 00:10:14,780
Então, lembre-se de que é um intervalo em vez de um parágrafo.

154
00:10:14,920 --> 00:10:17,010
E é o único como esse na nossa página.

155
00:10:17,110 --> 00:10:18,060
Então vamos voltar.

156
00:10:18,310 --> 00:10:26,470
Então, ao invés de selecionar o parágrafo, vamos criar uma nova variável e nós chamaremos de exibição de pontuação ganhadora

157
00:10:27,010 --> 00:10:30,170
e será o seletor de consultas de documentos.

158
00:10:30,970 --> 00:10:38,740
Mas ao invés de apenas span, porque há outras extensões na página, queremos selecionar extensões dentro

159
00:10:38,740 --> 00:10:39,520
dos parágrafos.

160
00:10:39,550 --> 00:10:40,690
Então é tudo o que temos que escrever.

161
00:10:40,810 --> 00:10:41,930
P espaço.

162
00:10:41,930 --> 00:10:42,710
Período.

163
00:10:43,240 --> 00:10:44,490
E vamos economizar.

164
00:10:44,980 --> 00:10:49,970
E agora vamos continuar e atualizar a pontuação vencedora exibida aqui em vez do parágrafo.

165
00:10:49,990 --> 00:10:53,710
Então, a exibição ganhadora é assim.

166
00:10:54,010 --> 00:10:56,020
E ainda não vai ser perfeito.

167
00:10:56,080 --> 00:11:02,080
Só atualizará o valor alterado todas as vezes, mas pelo menos não está atualizando o parágrafo inteiro.

168
00:11:02,950 --> 00:11:08,680
atualizar para exibir o número que está dentro da entrada para que os valores sejam sincronizados juntos.

169
00:11:08,680 --> 00:11:10,840
Então, o próximo passo é fazê-lo

170
00:11:10,880 --> 00:11:13,920
Então, nós realmente não vimos como obtemos os dados de uma entrada.

171
00:11:13,960 --> 00:11:15,940
Como obtemos o valor atual.

172
00:11:15,940 --> 00:11:18,100
Vou mostrar você aqui selecionando a entrada.

173
00:11:18,250 --> 00:11:24,940
Então, documente esse seletor de consulta e vamos fazê-lo na entrada do console e eu vou salvá-lo em uma

174
00:11:24,940 --> 00:11:30,790
variável para chamar o documento de entrada var taqueria selecione sua entrada e então faremos um valor

175
00:11:31,630 --> 00:11:32,750
de entrada daat.

176
00:11:33,040 --> 00:11:39,040
Então, esse valor será uma série de tudo o que contiver esta entrada, qualquer que seja o valor.

177
00:11:39,040 --> 00:11:43,800
Então, se eu mudar isso para 7 e eu executar o código novamente, eu recebo 7.

178
00:11:44,120 --> 00:11:50,800
Se eu for um grande número e desta vez eu faço isso novamente, reflete o valor que seja dentro

179
00:11:50,800 --> 00:11:51,520
dessa entrada.

180
00:11:51,520 --> 00:11:56,950
Então, vamos usar isso mudando isso ao invés de mudar o valor da string.

181
00:11:56,950 --> 00:12:10,030
Nós vamos mudar isso para ser o valor do ponto de entrada Nahm, de modo que o valor da partir daqui e mudar a pontuação vencedora

182
00:12:10,030 --> 00:12:12,710
exibirá o conteúdo do texto.

183
00:12:13,370 --> 00:12:18,690
Então, atualizamos e atualizo isso e agora você pode sincronizar juntos.

184
00:12:19,030 --> 00:12:26,020
isso para ser um a três, meu jogo ou a exibição de pontuação vencedora também atualiza para 1 a 3.

185
00:12:26,020 --> 00:12:26,900
Então, enquanto atualizo

186
00:12:27,340 --> 00:12:30,580
Então, é claro, não estamos jogando para 123.

187
00:12:30,580 --> 00:12:32,350
Nós ainda estamos jogando para cinco.

188
00:12:32,740 --> 00:12:38,590
E é porque a nossa lógica não está refletindo esse novo valor de entrada, tudo o que está refletindo é o

189
00:12:38,870 --> 00:12:40,280
nosso resultado original de 5.

190
00:12:40,480 --> 00:12:51,430
Então, também queremos mudar para baixo aqui, a pontuação vencedora é igual ao valor de entrada adormecido e salva.

191
00:12:51,430 --> 00:12:57,700
E agora vamos tentar mudar isso, então estamos jogando para três e clicamos e você notará que nós temos

192
00:12:57,700 --> 00:12:58,790
algum comportamento estranho.

193
00:12:58,840 --> 00:13:00,940
Então não parou às cinco.

194
00:13:00,970 --> 00:13:02,370
Apenas continua indo para sempre.

195
00:13:02,650 --> 00:13:08,200
Então, este é um bug divertido que tem que ver com diferentes tipos de cadeias e números de dados

196
00:13:08,240 --> 00:13:10,300
e comparando-os iguais duplos versus triplos iguais.

197
00:13:10,300 --> 00:13:14,200
Então, para chegar ao fundo, vamos fazer alguns contras. exploração madeireira.

198
00:13:14,200 --> 00:13:21,220
Então, sabemos que o cerne de tudo isso é essa linha aqui ou esta linha aqui, onde estamos verificando se o jogador

199
00:13:21,220 --> 00:13:24,700
tem uma se a pontuação do jogador igual a pontuação vencedora.

200
00:13:24,820 --> 00:13:26,790
É aí que definimos o jogo para ser verdade.

201
00:13:27,130 --> 00:13:29,610
E isso não está acontecendo agora porque o jogo acabou.

202
00:13:29,620 --> 00:13:31,460
Se mudarmos a pontuação.

203
00:13:31,450 --> 00:13:33,730
Game over nunca está mudando.

204
00:13:33,820 --> 00:13:35,460
É sempre falso.

205
00:13:35,710 --> 00:13:37,660
Então, alguma coisa está errada com esta linha.

206
00:13:37,780 --> 00:13:41,860
Então, vamos fazer um registro cancelado e vamos fazer duas coisas.

207
00:13:41,870 --> 00:13:46,900
Vamos apenas imprimir a pontuação do jogador 1 e imprimiremos a pontuação vencedora e podemos separá-los por

208
00:13:46,900 --> 00:13:49,700
vírgulas e eles apenas os imprimirão na mesma linha.

209
00:13:49,720 --> 00:13:54,640
Apenas uma nota rápida usando os logs do Comstock é como vamos depurar por enquanto, mas estaremos falando

210
00:13:54,820 --> 00:13:56,820
sobre maneiras mais avançadas de depuração mais tarde.

211
00:13:57,010 --> 00:14:04,010
Então eu vou atualizar e, se começarmos, damos uma olhada na pontuação aumentada do jogador 1 e você pode ver que temos

212
00:14:04,810 --> 00:14:07,470
três e estamos comparando isso com o número cinco.

213
00:14:07,540 --> 00:14:10,670
Então, o marcador de jogador 1 é de três pontos ganhadores é de cinco.

214
00:14:10,900 --> 00:14:15,250
Mas assim que eu mudar isso, digamos 7 e agora eu clique.

215
00:14:15,250 --> 00:14:22,330
O jogador 1, agora comparamos a pontuação do jogador 1, que é o número quatro para a pontuação vencedora, que é a

216
00:14:22,390 --> 00:14:23,160
string sete.

217
00:14:23,440 --> 00:14:27,090
Então, atualize novamente se eu começar com cinco.

218
00:14:27,110 --> 00:14:28,420
Isso funciona bem.

219
00:14:28,780 --> 00:14:34,490
Mas se eu mudar isso e agora nós comparamos isso com o número e a corda e isso não vai funcionar

220
00:14:34,480 --> 00:14:36,680
para nós porque estamos fazendo iguais triplos aqui.

221
00:14:36,790 --> 00:14:40,590
Então, podemos fazer iguais duplos, mas você sabe que não sou fã disso.

222
00:14:40,610 --> 00:14:45,790
Então, o que vamos fazer é ir aqui e simplesmente pegar isso e colocar esse valor e transformá-lo

223
00:14:45,790 --> 00:14:46,670
em uma string.

224
00:14:46,780 --> 00:14:54,730
esse capital e numero e depois passe e ponha valor que o transformará em uma string e configurará isso para ganhar pontuação.

225
00:14:54,730 --> 00:14:57,130
Então, com um número igual a

226
00:14:57,220 --> 00:14:58,020
Então estávamos frescos.

227
00:14:58,020 --> 00:15:02,210
Agora isso funciona muito bem.

228
00:15:02,760 --> 00:15:11,120
Chegamos a cinco, mas se mudarmos isso para o nosso jogo acabou em 2.

229
00:15:11,230 --> 00:15:15,790
Há uma pequena questão em que precisamos nos concentrar em que é se estamos jogando um jogo para cinco,

230
00:15:15,790 --> 00:15:17,000
o que começamos a fazer.

231
00:15:17,170 --> 00:15:22,310
E se eu decidir meio caminho, eu quero mudar a pontuação vencedora com a pontuação máxima.

232
00:15:22,390 --> 00:15:27,160
com isso muito bem, porque se eu mudar isso, agora estamos jogando apenas para três.

233
00:15:27,160 --> 00:15:28,920
Nosso código agora não lida

234
00:15:28,960 --> 00:15:30,630
Temos duas maneiras diferentes de lidar com isso.

235
00:15:30,640 --> 00:15:34,610
O primeiro é redefinir a pontuação e tudo de volta a zero.

236
00:15:34,880 --> 00:15:37,790
E o outro continua a jogar até cinco.

237
00:15:38,120 --> 00:15:43,010
Mas o que realmente está acontecendo é que estamos jogando para três, mas já passamos três.

238
00:15:43,300 --> 00:15:48,160
Então, porque já passamos, nosso código realmente não funciona mais porque estamos mentindo é

239
00:15:48,160 --> 00:15:51,390
apenas verificar se o jogador é igual ao resultado vencedor.

240
00:15:51,400 --> 00:15:53,790
Não está a verificar se é maior do que o resultado vencedor.

241
00:15:54,040 --> 00:15:55,170
Então, se pudéssemos mudar isso.

242
00:15:55,180 --> 00:16:00,830
Então, diz se é maior do que o resultado vencedor, o jogo acabou e tudo bem.

243
00:16:00,970 --> 00:16:08,920
Mas acho que a melhor solução é reajustar a zero sempre que mudarmos a pontuação máxima, porque nunca mudamos a pontuação máxima a meio

244
00:16:08,920 --> 00:16:12,970
do jogo de qualquer forma, queremos começar o jogo e a outra

245
00:16:12,970 --> 00:16:18,520
razão que eu quero que façamos isso É um bom caso de uso para um pequeno refator.

246
00:16:18,880 --> 00:16:22,410
Então, quando mudamos a pontuação, aqui está a pontuação vencedora.

247
00:16:22,610 --> 00:16:27,370
Queremos redefinir o jogo que é a mesma lógica que estamos executando aqui.

248
00:16:27,430 --> 00:16:34,720
Então, faremos isso simplesmente simplesmente vamos copiar esse código e criar uma nova função chamada redefinição.

249
00:16:34,720 --> 00:16:41,780
Então, a função reset apenas colocou todo esse código lá e então, uma vez que a entrada do

250
00:16:41,770 --> 00:16:44,780
número muda, vamos apenas executar a reinicialização.

251
00:16:44,890 --> 00:16:48,920
Então você verá que eu restaurei aqui jogando para cinco.

252
00:16:48,940 --> 00:16:49,960
Isso funciona bem.

253
00:16:49,960 --> 00:16:50,950
Chegamos a cinco.

254
00:16:51,100 --> 00:16:58,240
Eu clique em redefinir e não chamamos a função de reinicialização dentro deste ouvinte de eventos, então precisamos adicionar nossa

255
00:16:58,240 --> 00:16:59,840
chamada de função de reinicialização.

256
00:16:59,950 --> 00:17:02,370
E agora, se atualizarmos, chegamos a 5.

257
00:17:02,770 --> 00:17:03,980
Eu clique em redefinir.

258
00:17:04,030 --> 00:17:04,970
Está tudo bem.

259
00:17:05,140 --> 00:17:11,840
E agora, se eu estiver no meio de um jogo e eu mudo a pontuação também nos reafirma e agora jogamos para 1.

260
00:17:11,890 --> 00:17:12,800
E funciona.

261
00:17:13,100 --> 00:17:14,220
Ou se eu mudar.

262
00:17:14,230 --> 00:17:17,710
Então, estamos jogando para 7.

263
00:17:17,800 --> 00:17:19,730
Ele nos restaura de volta a zero.

264
00:17:20,020 --> 00:17:27,190
Então, se eu decidir que você sabe, isso é realmente um jogo que vai para 2 em vez disso, ele modifica a especificação para zero.

265
00:17:27,280 --> 00:17:29,910
E não precisamos nos preocupar com como lidar com isso.

266
00:17:29,920 --> 00:17:31,380
Se mudarmos a meio caminho.

267
00:17:31,510 --> 00:17:37,510
Então, o que estamos fazendo é apenas reiniciar uma função separada para secar o código em

268
00:17:37,510 --> 00:17:40,900
vez de duplicar isso aqui e para baixo aqui.

269
00:17:40,960 --> 00:17:41,940
Então é por agora.

270
00:17:41,950 --> 00:17:43,510
Isso é tudo o que precisamos fazer.

271
00:17:43,630 --> 00:17:48,610
Alguns de vocês podem estar se perguntando se este código é realmente a melhor maneira de possivelmente fazer isso.

272
00:17:48,620 --> 00:17:49,590
A resposta é não.

273
00:17:49,850 --> 00:17:54,500
E se você olhar de perto, verá que é extremamente similar.

274
00:17:54,490 --> 00:18:00,150
É basicamente o mesmo, exceto que estamos fazendo um aqui e P2 aqui.

275
00:18:00,160 --> 00:18:01,930
Mas todas as outras palavras são as mesmas.

276
00:18:02,470 --> 00:18:06,390
Portanto, há formas mais avançadas de refatoração de fazer isso um pouco melhor.

277
00:18:06,490 --> 00:18:12,490
Mas não vou fazer isso aqui, porque tudo o que eu quero focar é conceitualmente como podemos ter uma relação dominante

278
00:18:12,550 --> 00:18:18,020
de seqüestros de ouvintes do evento javascript e uma IMO HD interativa e é sobre isso que eu quero focar.

279
00:18:18,380 --> 00:18:23,800
Mas só sei que estaremos vendo formas de tornar o código como este um pouco melhor ser

280
00:18:23,800 --> 00:18:25,010
um pouco mais curto.

281
00:18:25,030 --> 00:18:29,860
Há uma coisa que podemos fazer aqui e colocar isso no ouvinte de eventos.

282
00:18:30,050 --> 00:18:37,150
Nós poderíamos apenas substituir a entrada numbada aqui com a palavra esta é uma mudança menor, mas podemos fazer isso e apenas

283
00:18:37,150 --> 00:18:38,620
encurtar o código um pouco.

284
00:18:38,740 --> 00:18:41,650
Então, se eu mudar isso, agora estamos jogando para três.

285
00:18:41,650 --> 00:18:43,870
Tudo ainda funciona exatamente.

286
00:18:43,880 --> 00:18:50,480
Eu usei apenas a palavra-chave que se refere ao que o evento estava escutando em qual era a entrada de número.

287
00:18:50,990 --> 00:18:52,650
Tudo bem, então é por esta lição.

288
00:18:52,780 --> 00:18:57,280
construir algo mais substancial e prometo que ficará muito melhor do que isso aconteceu aqui.

289
00:18:57,280 --> 00:18:59,010
Como mencionei no próximo projeto, vamos