1
00:00:00,000 --> 00:00:11,870

2
00:00:11,870 --> 00:00:12,530
>> ROB BOWDEN: Oi.

3
00:00:12,530 --> 00:00:13,510
Estou Rob.

4
00:00:13,510 --> 00:00:15,140
Quer saber como implementar este jogo?

5
00:00:15,140 --> 00:00:18,400
Bem, vamos sair
a solução pessoal.

6
00:00:18,400 --> 00:00:21,890
>> Então, vamos primeiro cabeça para baixo para a inicialização
funções que lhe disse para

7
00:00:21,890 --> 00:00:24,380
implementar em primeiro lugar.

8
00:00:24,380 --> 00:00:30,602
Primeiro um, vamos dar uma olhada
para ele é o init remo.

9
00:00:30,602 --> 00:00:34,550
Tudo bem, então lembre-se que queremos que o
remar para ser exatamente centrado em

10
00:00:34,550 --> 00:00:35,870
o eixo-x.

11
00:00:35,870 --> 00:00:39,000
Então, precisamos descobrir
onde que deveria ir.

12
00:00:39,000 --> 00:00:42,650
>> Dada a largura da placa - que
também é definido em cima de hash -

13
00:00:42,650 --> 00:00:46,380
precisamos subtrair a largura da pá
e dividir por dois, de modo que o

14
00:00:46,380 --> 00:00:48,960
centro da raquete está na
o centro do tabuleiro.

15
00:00:48,960 --> 00:00:53,170
Lembre-se que a coordenada x refere-se a
no canto superior esquerdo da pá,

16
00:00:53,170 --> 00:00:56,210
e por isso este é exatamente onde
nós queremos que ele seja.

17
00:00:56,210 --> 00:00:59,950
A coordenada y não importa
tanto porque podemos colocar

18
00:00:59,950 --> 00:01:01,800
lo onde quisermos.

19
00:01:01,800 --> 00:01:07,080
Então, nós instanciar o remo, montamos
a cor preta, montamos preencher como True

20
00:01:07,080 --> 00:01:11,240
por isso é um retângulo preenchido, e nós
em seguida, adicioná-lo à janela e retorno

21
00:01:11,240 --> 00:01:12,170
o remo.

22
00:01:12,170 --> 00:01:14,540
E é isso para inicializar
o remo.

23
00:01:14,540 --> 00:01:17,480
>> Vai ser semelhante
para o init placar.

24
00:01:17,480 --> 00:01:21,950
Então, nós estamos indo para inicializar o rótulo,
vamos definir a cor de

25
00:01:21,950 --> 00:01:25,180
cinza claro - você pode escolher o que você
quiser - vamos definir a fonte de

26
00:01:25,180 --> 00:01:26,700
sans serif 48 -

27
00:01:26,700 --> 00:01:28,630
também pode escolher o que quiser -

28
00:01:28,630 --> 00:01:30,180
nós vamos adicioná-lo à janela.

29
00:01:30,180 --> 00:01:34,760
Agora este Enviar para trás não é realmente
necessário, é apenas no caso de algo

30
00:01:34,760 --> 00:01:37,010
mais acontece a sobrepor-se na etiqueta.

31
00:01:37,010 --> 00:01:40,680
Então, quando usar a detecção de colisão,
Detecção de colisão irá detectar o outro

32
00:01:40,680 --> 00:01:42,380
coisa antes que ele detecta a etiqueta.

33
00:01:42,380 --> 00:01:45,670
Mas isso realmente não deve afetar
nós neste programa.

34
00:01:45,670 --> 00:01:48,720
>> Finalmente, temos o presente painel de atualização
função que escrevemos.

35
00:01:48,720 --> 00:01:51,020
Então, vamos dar uma olhada nisso.

36
00:01:51,020 --> 00:01:54,590
Agora, aqui vemos algo que é
quase idêntico ao que

37
00:01:54,590 --> 00:01:56,930
vimos no label.c.

38
00:01:56,930 --> 00:01:59,100
Portanto, temos um rótulo -

39
00:01:59,100 --> 00:02:03,540
um buffer de caracteres de 12 caracteres,
que é apenas o suficiente para lidar com qualquer

40
00:02:03,540 --> 00:02:05,920
número inteiro, positivo ou negativo.

41
00:02:05,920 --> 00:02:10,310
Então nós usamos sprintf para copiar o
aponta em que o tampão.

42
00:02:10,310 --> 00:02:14,290
Então s este contém uma string representando
o número de pontos.

43
00:02:14,290 --> 00:02:18,180
>> Finalmente, vamos definir o rótulo
para essa seqüência.

44
00:02:18,180 --> 00:02:22,820
E então nós precisamos centralizar o rótulo
no caso passamos de nove para 10

45
00:02:22,820 --> 00:02:24,920
aponta e nós deslocou-lo.

46
00:02:24,920 --> 00:02:29,330
Assim, calcula-se a x e y-coordenadas
da etiqueta que vai

47
00:02:29,330 --> 00:02:30,765
obter a largura ea altura
da janela.

48
00:02:30,765 --> 00:02:34,010
Embora, nós também pode simplesmente usar o
constantes de Largura e Altura de hash

49
00:02:34,010 --> 00:02:35,290
definido em cima.

50
00:02:35,290 --> 00:02:38,220
Nós também obter a largura ea altura
da etiqueta e dividir

51
00:02:38,220 --> 00:02:40,160
que por 2 a centro.

52
00:02:40,160 --> 00:02:43,530
E então nós usamos Set Location para realmente
colocá-lo no local.

53
00:02:43,530 --> 00:02:45,830
Então é isso para o init placar.

54
00:02:45,830 --> 00:02:46,320
>> OK.

55
00:02:46,320 --> 00:02:50,390
Então, bola de inicialização vai ser muito semelhante
para o init pás também.

56
00:02:50,390 --> 00:02:55,700
Vemos aqui que estamos usando newgoval
a fim de instanciar uma nova bola.

57
00:02:55,700 --> 00:03:00,810
E aqui estamos usando duas vezes o raio
como a largura da bola, e 2

58
00:03:00,810 --> 00:03:03,140
vezes o seu raio, como o
altura da bola.

59
00:03:03,140 --> 00:03:07,240
Agora, também para newgoval, o xe
coordenada y que passamos em que vai

60
00:03:07,240 --> 00:03:10,220
para se referir ao canto superior esquerdo da
bola, que é na verdade

61
00:03:10,220 --> 00:03:11,910
fora da própria bola.

62
00:03:11,910 --> 00:03:15,510
Portanto, a fim de obter a bola exatamente
centrada no conselho, precisamos passar

63
00:03:15,510 --> 00:03:20,730
largura dividido por 2 para o centro, e
então subtrair o raio para empurrar

64
00:03:20,730 --> 00:03:23,350
o centro real da bola
o centro do tabuleiro.

65
00:03:23,350 --> 00:03:26,810
E fazemos exatamente a mesma coisa
para o eixo y, excepto usando

66
00:03:26,810 --> 00:03:28,490
altura, em vez da largura.

67
00:03:28,490 --> 00:03:30,890
>> Assim que coloca a bola no centro.

68
00:03:30,890 --> 00:03:35,910
E esta instancia a bola, defina a
cor para preto, preencha a bola,

69
00:03:35,910 --> 00:03:37,960
em seguida, finalmente, adicionar a ele o
janela e devolvê-lo.

70
00:03:37,960 --> 00:03:40,700
E é isso para inicializar
a bola.

71
00:03:40,700 --> 00:03:44,420
>> Então, agora vamos dar uma olhada o init
tijolos que é ligeiramente mais

72
00:03:44,420 --> 00:03:47,840
complicado, mas é muito
semelhante a inicialização remo.

73
00:03:47,840 --> 00:03:51,400
Agora, primeiro precisamos descobrir
a largura de cada tijolo.

74
00:03:51,400 --> 00:03:54,610
Lembre-se que temos uma constante chamada
chamadas que especifica o

75
00:03:54,610 --> 00:03:56,860
número de colunas de tijolos
que temos.

76
00:03:56,860 --> 00:04:01,010
Então, nós estamos indo para determinar a largura
de um único tijolo, tendo a largura

77
00:04:01,010 --> 00:04:04,340
de toda a diretoria, subtraindo
o tamanho do nosso gap -

78
00:04:04,340 --> 00:04:07,310
que é definido em cima de hash e se refere
para o número de pixels que

79
00:04:07,310 --> 00:04:09,490
deve situar-se entre cada tijolo -

80
00:04:09,490 --> 00:04:14,910
e assim nós vamos ter um total de
vezes gap chama pixels em branco em um

81
00:04:14,910 --> 00:04:16,360
única linha.

82
00:04:16,360 --> 00:04:20,450
E isso também se referem a alguns em branco
pixels à esquerda e à direita do

83
00:04:20,450 --> 00:04:22,850
coluna da esquerda e tijolo coluna da direita.

84
00:04:22,850 --> 00:04:26,990
>> Então subtrair os pixels em branco
deixa-nos com um número de pixels que

85
00:04:26,990 --> 00:04:28,530
tijolos estão realmente usando.

86
00:04:28,530 --> 00:04:32,900
E, então, dividir por chamadas para obter
o número de pixels por tijolo.

87
00:04:32,900 --> 00:04:37,800
Então, vamos definir uma matriz que só
especifica as cores que deseja para cada

88
00:04:37,800 --> 00:04:39,140
fileira de tijolos.

89
00:04:39,140 --> 00:04:42,680
Se tivéssemos mais fileiras de tijolos que
cores que nós especificados, vamos ver

90
00:04:42,680 --> 00:04:45,980
que vamos loop de volta ao redor e
usar o vermelho novamente, e depois de laranja e

91
00:04:45,980 --> 00:04:47,680
amarelo e assim por diante.

92
00:04:47,680 --> 00:04:52,490
>> Assim, como as dicas de especificação-p definido, estamos
vai varrer todas as linhas e

93
00:04:52,490 --> 00:04:54,590
colunas dos tijolos.

94
00:04:54,590 --> 00:04:58,490
Mas, antes de loop sobre as colunas, nós
ver aqui que estamos especificando o

95
00:04:58,490 --> 00:05:02,030
posição y de cada tijolo
nessa linha particular.

96
00:05:02,030 --> 00:05:06,410
Também poderia mover este para o segundo
loop, mas então nós seríamos apenas

97
00:05:06,410 --> 00:05:09,640
fazer o cálculo, uma e outra
novamente quando não precisa.

98
00:05:09,640 --> 00:05:13,810
>> Assim, a posição y do tijolo vai
para a margem, a qual é de hash

99
00:05:13,810 --> 00:05:17,830
definido em cima e apenas se refere ao
espaço entre a parte superior da placa e

100
00:05:17,830 --> 00:05:19,910
o início de todos os tijolos.

101
00:05:19,910 --> 00:05:24,370
E nós estamos indo para adicionar ao que a linha
que estamos em tempos a altura de um

102
00:05:24,370 --> 00:05:28,420
tijolo individual, mais a diferença
isto é, entre cada tijolo.

103
00:05:28,420 --> 00:05:31,640
Portanto, este também é um projeto vertical
intervalo entre cada tijolo.

104
00:05:31,640 --> 00:05:34,000
Assim que nos dá a coordenada y
do tijolo.

105
00:05:34,000 --> 00:05:38,170
>> Então, aqui vamos calcular
a coordenada x do tijolo.

106
00:05:38,170 --> 00:05:42,050
Agora, temos lacuna dividido por 2 uma vez que,
lembre-se antes, eu disse que no

107
00:05:42,050 --> 00:05:45,020
lado esquerdo da placa, vamos
deixar um pouco de espaço.

108
00:05:45,020 --> 00:05:47,630
Assim lacuna dividida por 2 é que o espaço.

109
00:05:47,630 --> 00:05:51,950
E então nós estamos adicionando a isso a coluna
que estamos em tempos mais largura

110
00:05:51,950 --> 00:05:55,150
lacuna, onde a largura é a quantidade de espaço
que um único tijolo retoma e

111
00:05:55,150 --> 00:05:58,510
então lacuna é o espaço
entre cada tijolo.

112
00:05:58,510 --> 00:06:00,700
Assim que calcula a coordenada x
do tijolo.

113
00:06:00,700 --> 00:06:04,890
>> Agora só precisamos instanciar a
tijolo dado que x e y de coordenadas

114
00:06:04,890 --> 00:06:09,120
usando largura que calculamos para cada
altura de tijolos, e quebrar o que é

115
00:06:09,120 --> 00:06:10,800
botar definido em cima.

116
00:06:10,800 --> 00:06:12,420
Nós definir a cor do tijolo.

117
00:06:12,420 --> 00:06:15,790
Observe que estamos usando a nossa matriz de cores e
estamos passando na linha que foram

118
00:06:15,790 --> 00:06:19,760
em cores núme mod que vai fazer
nos envolver em torno de volta ao vermelho se

119
00:06:19,760 --> 00:06:22,140
tem mais linhas do que as cores.

120
00:06:22,140 --> 00:06:25,020
Por fim, vamos preencher o tijolo
colorir e adicioná-lo para a janela.

121
00:06:25,020 --> 00:06:26,440
>> E é isso.

122
00:06:26,440 --> 00:06:30,190
Então, é isso para todos os nossos
métodos de inicialização.

123
00:06:30,190 --> 00:06:33,200
Agora, precisamos olhar para que, enquanto
loop que você teve a preencher

124
00:06:33,200 --> 00:06:39,000
Então aqui nós vemos que este é o nosso tempo
loop que vai continuar até que

125
00:06:39,000 --> 00:06:42,250
jogo acabou, o que quer meios
corremos para fora da vida ou

126
00:06:42,250 --> 00:06:43,910
corremos para fora de tijolos.

127
00:06:43,910 --> 00:06:46,390
>> Então a primeira coisa que temos
é uma espera para Click.

128
00:06:46,390 --> 00:06:51,380
Assim, o jogo nos espera para realmente
clique antes que a bola começa a se mover.

129
00:06:51,380 --> 00:06:53,340
E então nós vamos
para diminuir a vida.

130
00:06:53,340 --> 00:06:56,710
Então, se nós tivemos três vidas, agora estamos
até duas vidas, estamos usando nossa

131
00:06:56,710 --> 00:06:58,160
terceira vida.

132
00:06:58,160 --> 00:06:59,920
Nós estamos indo para o centro da bola.

133
00:06:59,920 --> 00:07:05,180
Então, agora, isso não é realmente vai ajudar
nós na primeira vida que nós jogamos

134
00:07:05,180 --> 00:07:07,910
desde que a bola já vai
foram centradas a partir de quando

135
00:07:07,910 --> 00:07:09,010
instanciado ele.

136
00:07:09,010 --> 00:07:12,910
Mas vemos quando acabar perdendo o
vida e loop de volta ao redor, então estamos

137
00:07:12,910 --> 00:07:15,800
vai querer recentrar a bola de
a parte inferior da placa de volta para

138
00:07:15,800 --> 00:07:17,130
o centro.

139
00:07:17,130 --> 00:07:21,840
>> Então, agora aqui é preciso gerar
x a velocidade da bola.

140
00:07:21,840 --> 00:07:26,060
E, de acordo com a especificação, estamos usando d rand
48 para gerar um número aleatório

141
00:07:26,060 --> 00:07:27,820
para especificar a velocidade.

142
00:07:27,820 --> 00:07:31,130
Estamos adicionando um para que, uma vez que apenas
quer a velocidade no intervalo de um

143
00:07:31,130 --> 00:07:33,380
de dois em vez de zero a um.

144
00:07:33,380 --> 00:07:37,415
Finalmente, estamos usando d rand 48 novamente em
Para determinar se a esfera

145
00:07:37,415 --> 00:07:40,490
vai se mover para a esquerda
ou o direito de começar.

146
00:07:40,490 --> 00:07:45,310
>> Rand Então d 48 retorna um número aleatório
entre zero e um, e assim por pedir

147
00:07:45,310 --> 00:07:50,330
se isso é menos de 0,5, temos uma 50 50
possibilidade de mudar a velocidade de

148
00:07:50,330 --> 00:07:52,740
a bola a ser negativo.

149
00:07:52,740 --> 00:07:55,790
Por fim, defina a velocidade vertical
a bola a ser apenas uma constante.

150
00:07:55,790 --> 00:07:57,550
Nós escolhemos três.

151
00:07:57,550 --> 00:07:59,300
E agora temos um outro loop.

152
00:07:59,300 --> 00:08:02,800
>> Portanto, este laço interno é
vai continuar.

153
00:08:02,800 --> 00:08:04,960
Observe aqui, enquanto tijolos
é maior do que zero -

154
00:08:04,960 --> 00:08:07,100
por isso, se ficarmos sem tijolos, temos
ganhou o jogo e podemos

155
00:08:07,100 --> 00:08:08,770
romper com esse ciclo -

156
00:08:08,770 --> 00:08:13,140
e todos Obter y bola a menos de altura
menos duas vezes o raio.

157
00:08:13,140 --> 00:08:17,310
Então, o que este está reconhecendo é se o
bola passa a ir além do remo, em

158
00:08:17,310 --> 00:08:19,500
caso em que você perdeu uma vida.

159
00:08:19,500 --> 00:08:23,500
>> Olhando para dentro deste loop for, temos
a verificação de um evento de mouse.

160
00:08:23,500 --> 00:08:27,530
E assim, se existe um evento de rato, que
significa que queremos verificar a

161
00:08:27,530 --> 00:08:30,880
ver se o rato foi transferido, e se o
mouse foi movido, nós queremos ter a

162
00:08:30,880 --> 00:08:33,210
pá manter-se com o mouse.

163
00:08:33,210 --> 00:08:38,789
Então, para fazer isso, calcula-se a nova
posição da raquete, o que está acontecendo

164
00:08:38,789 --> 00:08:42,900
para pegar a posição do mouse -
que agarra a posição usando o

165
00:08:42,900 --> 00:08:44,890
evento que foram passados ​​-

166
00:08:44,890 --> 00:08:48,940
e, em seguida, vamos subtrair
largura pá dividido por 2, para que o

167
00:08:48,940 --> 00:08:54,240
estadias de remo centradas no mouse
em vez de no lado esquerdo da pá

168
00:08:54,240 --> 00:08:55,740
permanecer centrado.

169
00:08:55,740 --> 00:09:00,750
>> Então, agora nós também queremos ter certeza de que nós
não vá para o lado esquerdo ou direito

170
00:09:00,750 --> 00:09:01,740
lado do tabuleiro.

171
00:09:01,740 --> 00:09:05,480
E por isso aqui estamos apenas verificando se o
pá estaria fora do lado esquerdo da

172
00:09:05,480 --> 00:09:08,370
a bordo, se ater apenas
para o lado esquerdo.

173
00:09:08,370 --> 00:09:11,000
E aqui estamos verificando se o remo
seria para o lado direito da

174
00:09:11,000 --> 00:09:13,600
bordo, apenas colocá-lo
para o lado direito.

175
00:09:13,600 --> 00:09:17,290
E, finalmente, nós realmente definir
a localização da pá.

176
00:09:17,290 --> 00:09:20,610
>> Agora, se não houvesse um movimento de mouse,
isso significa que nós vamos

177
00:09:20,610 --> 00:09:21,900
deseja mover a bola.

178
00:09:21,900 --> 00:09:24,260
E assim já temos o x
e velocidade y da bola

179
00:09:24,260 --> 00:09:25,560
e assim nós movê-lo.

180
00:09:25,560 --> 00:09:27,750
Mas agora queremos detectar
algumas coisas.

181
00:09:27,750 --> 00:09:31,950
Então, aqui estamos detectando se bater ou
o lado esquerdo ou direito do

182
00:09:31,950 --> 00:09:34,240
conselho, queremos que a bola a saltar.

183
00:09:34,240 --> 00:09:39,790
E assim, nesse caso, definimos x velocidade
ax velocidade negativo.

184
00:09:39,790 --> 00:09:43,900
>> Se a bola bater na parte superior da placa,
então nós também queremos a bola quicar.

185
00:09:43,900 --> 00:09:46,750
Mas agora queremos mudar
a velocidade y.

186
00:09:46,750 --> 00:09:49,130
Repare que não temos uma condição para
a bola bater no fundo da

187
00:09:49,130 --> 00:09:53,230
conselho desde que já foi capturado
aqui neste loop while.

188
00:09:53,230 --> 00:09:56,630
>> Finalmente, queremos detectar algum
colisões onde se o hit bola

189
00:09:56,630 --> 00:10:01,040
ou o remo ou o tijolo, queremos
fazer algumas coisas de casos especiais.

190
00:10:01,040 --> 00:10:06,590
Assim, se houver uma colisão, em que
objetos de caso não será nulo, então,

191
00:10:06,590 --> 00:10:10,950
se o objeto atingiu a remo, teríamos
só quero devolver a bola.

192
00:10:10,950 --> 00:10:16,110
E aqui, também, vamos definir a localização de
a bola para um pouco acima do remo.

193
00:10:16,110 --> 00:10:19,710
Observe que estamos tomando a posição x
a bola e apenas reutilizando isso.

194
00:10:19,710 --> 00:10:23,250
Mas aqui nós estamos começando a posição y
da pá e mover a bola

195
00:10:23,250 --> 00:10:24,620
acima do remo.

196
00:10:24,620 --> 00:10:28,070
>> Este é um caso especial, de modo que a bola
não bate o remo e então,

197
00:10:28,070 --> 00:10:31,530
antes que seja capaz de se mover para fora da pá,
outro ciclo gira em torno e

198
00:10:31,530 --> 00:10:34,830
ele pensa que ainda está no painel e
assim a velocidade y começa o jogo de volta para

199
00:10:34,830 --> 00:10:38,210
negativa e, em seguida, a bola só tipo
de varas saltando sobre o remo.

200
00:10:38,210 --> 00:10:42,510
Então, se nós não bater a raquete,
então nós também queremos verificar

201
00:10:42,510 --> 00:10:43,930
se bater o tijolo.

202
00:10:43,930 --> 00:10:47,030
E por isso esta é a forma como podemos verificar
para ver se nós batemos um tijolo.

203
00:10:47,030 --> 00:10:50,250
>> Precisamos verificar isso, porque podemos
realmente bater o rótulo e nós

204
00:10:50,250 --> 00:10:52,320
não quero remover o rótulo.

205
00:10:52,320 --> 00:10:57,120
Então, se nós batemos um tijolo, nós podemos remover a
tijolo pela janela, decremento

206
00:10:57,120 --> 00:11:01,170
nossa contagem dos tijolos, incrementar nossa
número de pontos, e agora precisamos

207
00:11:01,170 --> 00:11:05,410
atualizar o placar que é exatamente
o mesmo que vimos antes, quando vimos

208
00:11:05,410 --> 00:11:06,300
placar de inicialização.

209
00:11:06,300 --> 00:11:08,790
Mas agora estamos apenas atualizando o
placar desde que mudei o

210
00:11:08,790 --> 00:11:09,370
número de pontos.

211
00:11:09,370 --> 00:11:12,180
E deve agora mostrar que
nós batemos mais uma pausa.

212
00:11:12,180 --> 00:11:16,320
>> E, finalmente, se nós batemos um tijolo
também queremos saltar.

213
00:11:16,320 --> 00:11:21,240
Então, finalmente, fazemos uma pausa apenas para que o
bola não está se movendo super rápido e nós

214
00:11:21,240 --> 00:11:24,360
pode realmente atingi-lo com a nossa pá.

215
00:11:24,360 --> 00:11:25,910
E isso é muito bonito isso.

216
00:11:25,910 --> 00:11:32,200
Então, agora nós faria loop de volta para o topo
esse loop while e continue até

217
00:11:32,200 --> 00:11:35,700
ou perdemos uma vida ou
corremos para fora de tijolos.

218
00:11:35,700 --> 00:11:37,300
>> O que acontece se perder a vida?

219
00:11:37,300 --> 00:11:41,870
Então vamos sair desta enquanto
loop, e vamos ver o laço fará o backup

220
00:11:41,870 --> 00:11:45,110
para o início do ciclo, enquanto exterior.

221
00:11:45,110 --> 00:11:48,740
Nesse caso, nós vamos
executar esta configuração novamente.

222
00:11:48,740 --> 00:11:52,010
E esta configurado vai ter-nos esperar
por um clique, diminuir o nosso número

223
00:11:52,010 --> 00:11:56,060
de vidas, recentrar a bola, recalcular
uma velocidade x e y, e

224
00:11:56,060 --> 00:11:57,670
em seguida, retomar o jogo.

225
00:11:57,670 --> 00:12:01,490
>> E assim, que continuará até
tijolos acaba sendo menor do que

226
00:12:01,490 --> 00:12:02,540
ou igual a zero -

227
00:12:02,540 --> 00:12:04,630
no caso que ganhou o jogo que -

228
00:12:04,630 --> 00:12:10,430
ou a vida é inferior a zero, em que
caso perdemos o jogo.

229
00:12:10,430 --> 00:12:15,190
Assim, uma vez que é o caso, nós sair
desse loop while, e chegamos aqui

230
00:12:15,190 --> 00:12:17,660
onde nós vamos esperar por clique
antes de sair do jogo para que o

231
00:12:17,660 --> 00:12:20,140
jogo não apenas imediatamente
fechar sobre nós.

232
00:12:20,140 --> 00:12:23,420
E, finalmente, vamos fechar a
janela e é isso.

233
00:12:23,420 --> 00:12:25,500
Meu nome é Rob, e esta foi Breakout.

234
00:12:25,500 --> 00:12:30,592