>> ROB BOWDEN: Oi.
Estou Rob.
Quer saber como implementar este jogo?
Bem, vamos sair a solução pessoal.
>> Então, vamos primeiro cabeça para baixo para a inicialização funções que lhe disse para
implementar em primeiro lugar.
Primeiro um, vamos dar uma olhada para ele é o init remo.
Tudo bem, então lembre-se que queremos que o remar para ser exatamente centrado em
o eixo-x.
Então, precisamos descobrir onde que deveria ir.
>> Dada a largura da placa - que também é definido em cima de hash -
precisamos subtrair a largura da pá e dividir por dois, de modo que o
centro da raquete está na o centro do tabuleiro.
Lembre-se que a coordenada x refere-se a no canto superior esquerdo da pá,
e por isso este é exatamente onde nós queremos que ele seja.
A coordenada y não importa tanto porque podemos colocar
lo onde quisermos.
Então, nós instanciar o remo, montamos a cor preta, montamos preencher como True
por isso é um retângulo preenchido, e nós em seguida, adicioná-lo à janela e retorno
o remo.
E é isso para inicializar o remo.
>> Vai ser semelhante para o init placar.
Então, nós estamos indo para inicializar o rótulo, vamos definir a cor de
cinza claro - você pode escolher o que você quiser - vamos definir a fonte de
sans serif 48 -
também pode escolher o que quiser -
nós vamos adicioná-lo à janela.
Agora este Enviar para trás não é realmente necessário, é apenas no caso de algo
mais acontece a sobrepor-se na etiqueta.
Então, quando usar a detecção de colisão, Detecção de colisão irá detectar o outro
coisa antes que ele detecta a etiqueta.
Mas isso realmente não deve afetar nós neste programa.
>> Finalmente, temos o presente painel de atualização função que escrevemos.
Então, vamos dar uma olhada nisso.
Agora, aqui vemos algo que é quase idêntico ao que
vimos no label.c.
Portanto, temos um rótulo -
um buffer de caracteres de 12 caracteres, que é apenas o suficiente para lidar com qualquer
número inteiro, positivo ou negativo.
Então nós usamos sprintf para copiar o aponta em que o tampão.
Então s este contém uma string representando o número de pontos.
>> Finalmente, vamos definir o rótulo para essa seqüência.
E então nós precisamos centralizar o rótulo no caso passamos de nove para 10
aponta e nós deslocou-lo.
Assim, calcula-se a x e y-coordenadas da etiqueta que vai
obter a largura ea altura da janela.
Embora, nós também pode simplesmente usar o constantes de Largura e Altura de hash
definido em cima.
Nós também obter a largura ea altura da etiqueta e dividir
que por 2 a centro.
E então nós usamos Set Location para realmente colocá-lo no local.
Então é isso para o init placar.
>> OK.
Então, bola de inicialização vai ser muito semelhante para o init pás também.
Vemos aqui que estamos usando newgoval a fim de instanciar uma nova bola.
E aqui estamos usando duas vezes o raio como a largura da bola, e 2
vezes o seu raio, como o altura da bola.
Agora, também para newgoval, o xe coordenada y que passamos em que vai
para se referir ao canto superior esquerdo da bola, que é na verdade
fora da própria bola.
Portanto, a fim de obter a bola exatamente centrada no conselho, precisamos passar
largura dividido por 2 para o centro, e então subtrair o raio para empurrar
o centro real da bola o centro do tabuleiro.
E fazemos exatamente a mesma coisa para o eixo y, excepto usando
altura, em vez da largura.
>> Assim que coloca a bola no centro.
E esta instancia a bola, defina a cor para preto, preencha a bola,
em seguida, finalmente, adicionar a ele o janela e devolvê-lo.
E é isso para inicializar a bola.
>> Então, agora vamos dar uma olhada o init tijolos que é ligeiramente mais
complicado, mas é muito semelhante a inicialização remo.
Agora, primeiro precisamos descobrir a largura de cada tijolo.
Lembre-se que temos uma constante chamada chamadas que especifica o
número de colunas de tijolos que temos.
Então, nós estamos indo para determinar a largura de um único tijolo, tendo a largura
de toda a diretoria, subtraindo o tamanho do nosso gap -
que é definido em cima de hash e se refere para o número de pixels que
deve situar-se entre cada tijolo -
e assim nós vamos ter um total de vezes gap chama pixels em branco em um
única linha.
E isso também se referem a alguns em branco pixels à esquerda e à direita do
coluna da esquerda e tijolo coluna da direita.
>> Então subtrair os pixels em branco deixa-nos com um número de pixels que
tijolos estão realmente usando.
E, então, dividir por chamadas para obter o número de pixels por tijolo.
Então, vamos definir uma matriz que só especifica as cores que deseja para cada
fileira de tijolos.
Se tivéssemos mais fileiras de tijolos que cores que nós especificados, vamos ver
que vamos loop de volta ao redor e usar o vermelho novamente, e depois de laranja e
amarelo e assim por diante.
>> Assim, como as dicas de especificação-p definido, estamos vai varrer todas as linhas e
colunas dos tijolos.
Mas, antes de loop sobre as colunas, nós ver aqui que estamos especificando o
posição y de cada tijolo nessa linha particular.
Também poderia mover este para o segundo loop, mas então nós seríamos apenas
fazer o cálculo, uma e outra novamente quando não precisa.
>> Assim, a posição y do tijolo vai para a margem, a qual é de hash
definido em cima e apenas se refere ao espaço entre a parte superior da placa e
o início de todos os tijolos.
E nós estamos indo para adicionar ao que a linha que estamos em tempos a altura de um
tijolo individual, mais a diferença isto é, entre cada tijolo.
Portanto, este também é um projeto vertical intervalo entre cada tijolo.
Assim que nos dá a coordenada y do tijolo.
>> Então, aqui vamos calcular a coordenada x do tijolo.
Agora, temos lacuna dividido por 2 uma vez que, lembre-se antes, eu disse que no
lado esquerdo da placa, vamos deixar um pouco de espaço.
Assim lacuna dividida por 2 é que o espaço.
E então nós estamos adicionando a isso a coluna que estamos em tempos mais largura
lacuna, onde a largura é a quantidade de espaço que um único tijolo retoma e
então lacuna é o espaço entre cada tijolo.
Assim que calcula a coordenada x do tijolo.
>> Agora só precisamos instanciar a tijolo dado que x e y de coordenadas
usando largura que calculamos para cada altura de tijolos, e quebrar o que é
botar definido em cima.
Nós definir a cor do tijolo.
Observe que estamos usando a nossa matriz de cores e estamos passando na linha que foram
em cores núme mod que vai fazer nos envolver em torno de volta ao vermelho se
tem mais linhas do que as cores.
Por fim, vamos preencher o tijolo colorir e adicioná-lo para a janela.
>> E é isso.
Então, é isso para todos os nossos métodos de inicialização.
Agora, precisamos olhar para que, enquanto loop que você teve a preencher
Então aqui nós vemos que este é o nosso tempo loop que vai continuar até que
jogo acabou, o que quer meios corremos para fora da vida ou
corremos para fora de tijolos.
>> Então a primeira coisa que temos é uma espera para Click.
Assim, o jogo nos espera para realmente clique antes que a bola começa a se mover.
E então nós vamos para diminuir a vida.
Então, se nós tivemos três vidas, agora estamos até duas vidas, estamos usando nossa
terceira vida.
Nós estamos indo para o centro da bola.
Então, agora, isso não é realmente vai ajudar nós na primeira vida que nós jogamos
desde que a bola já vai foram centradas a partir de quando
instanciado ele.
Mas vemos quando acabar perdendo o vida e loop de volta ao redor, então estamos
vai querer recentrar a bola de a parte inferior da placa de volta para
o centro.
>> Então, agora aqui é preciso gerar x a velocidade da bola.
E, de acordo com a especificação, estamos usando d rand 48 para gerar um número aleatório
para especificar a velocidade.
Estamos adicionando um para que, uma vez que apenas quer a velocidade no intervalo de um
de dois em vez de zero a um.
Finalmente, estamos usando d rand 48 novamente em Para determinar se a esfera
vai se mover para a esquerda ou o direito de começar.
>> Rand Então d 48 retorna um número aleatório entre zero e um, e assim por pedir
se isso é menos de 0,5, temos uma 50 50 possibilidade de mudar a velocidade de
a bola a ser negativo.
Por fim, defina a velocidade vertical a bola a ser apenas uma constante.
Nós escolhemos três.
E agora temos um outro loop.
>> Portanto, este laço interno é vai continuar.
Observe aqui, enquanto tijolos é maior do que zero -
por isso, se ficarmos sem tijolos, temos ganhou o jogo e podemos
romper com esse ciclo -
e todos Obter y bola a menos de altura menos duas vezes o raio.
Então, o que este está reconhecendo é se o bola passa a ir além do remo, em
caso em que você perdeu uma vida.
>> Olhando para dentro deste loop for, temos a verificação de um evento de mouse.
E assim, se existe um evento de rato, que significa que queremos verificar a
ver se o rato foi transferido, e se o mouse foi movido, nós queremos ter a
pá manter-se com o mouse.
Então, para fazer isso, calcula-se a nova posição da raquete, o que está acontecendo
para pegar a posição do mouse - que agarra a posição usando o
evento que foram passados ​​-
e, em seguida, vamos subtrair largura pá dividido por 2, para que o
estadias de remo centradas no mouse em vez de no lado esquerdo da pá
permanecer centrado.
>> Então, agora nós também queremos ter certeza de que nós não vá para o lado esquerdo ou direito
lado do tabuleiro.
E por isso aqui estamos apenas verificando se o pá estaria fora do lado esquerdo da
a bordo, se ater apenas para o lado esquerdo.
E aqui estamos verificando se o remo seria para o lado direito da
bordo, apenas colocá-lo para o lado direito.
E, finalmente, nós realmente definir a localização da pá.
>> Agora, se não houvesse um movimento de mouse, isso significa que nós vamos
deseja mover a bola.
E assim já temos o x e velocidade y da bola
e assim nós movê-lo.
Mas agora queremos detectar algumas coisas.
Então, aqui estamos detectando se bater ou o lado esquerdo ou direito do
conselho, queremos que a bola a saltar.
E assim, nesse caso, definimos x velocidade ax velocidade negativo.
>> Se a bola bater na parte superior da placa, então nós também queremos a bola quicar.
Mas agora queremos mudar a velocidade y.
Repare que não temos uma condição para a bola bater no fundo da
conselho desde que já foi capturado aqui neste loop while.
>> Finalmente, queremos detectar algum colisões onde se o hit bola
ou o remo ou o tijolo, queremos fazer algumas coisas de casos especiais.
Assim, se houver uma colisão, em que objetos de caso não será nulo, então,
se o objeto atingiu a remo, teríamos só quero devolver a bola.
E aqui, também, vamos definir a localização de a bola para um pouco acima do remo.
Observe que estamos tomando a posição x a bola e apenas reutilizando isso.
Mas aqui nós estamos começando a posição y da pá e mover a bola
acima do remo.
>> Este é um caso especial, de modo que a bola não bate o remo e então,
antes que seja capaz de se mover para fora da pá, outro ciclo gira em torno e
ele pensa que ainda está no painel e assim a velocidade y começa o jogo de volta para
negativa e, em seguida, a bola só tipo de varas saltando sobre o remo.
Então, se nós não bater a raquete, então nós também queremos verificar
se bater o tijolo.
E por isso esta é a forma como podemos verificar para ver se nós batemos um tijolo.
>> Precisamos verificar isso, porque podemos realmente bater o rótulo e nós
não quero remover o rótulo.
Então, se nós batemos um tijolo, nós podemos remover a tijolo pela janela, decremento
nossa contagem dos tijolos, incrementar nossa número de pontos, e agora precisamos
atualizar o placar que é exatamente o mesmo que vimos antes, quando vimos
placar de inicialização.
Mas agora estamos apenas atualizando o placar desde que mudei o
número de pontos.
E deve agora mostrar que nós batemos mais uma pausa.
>> E, finalmente, se nós batemos um tijolo também queremos saltar.
Então, finalmente, fazemos uma pausa apenas para que o bola não está se movendo super rápido e nós
pode realmente atingi-lo com a nossa pá.
E isso é muito bonito isso.
Então, agora nós faria loop de volta para o topo esse loop while e continue até
ou perdemos uma vida ou corremos para fora de tijolos.
>> O que acontece se perder a vida?
Então vamos sair desta enquanto loop, e vamos ver o laço fará o backup
para o início do ciclo, enquanto exterior.
Nesse caso, nós vamos executar esta configuração novamente.
E esta configurado vai ter-nos esperar por um clique, diminuir o nosso número
de vidas, recentrar a bola, recalcular uma velocidade x e y, e
em seguida, retomar o jogo.
>> E assim, que continuará até tijolos acaba sendo menor do que
ou igual a zero -
no caso que ganhou o jogo que -
ou a vida é inferior a zero, em que caso perdemos o jogo.
Assim, uma vez que é o caso, nós sair desse loop while, e chegamos aqui
onde nós vamos esperar por clique antes de sair do jogo para que o
jogo não apenas imediatamente fechar sobre nós.
E, finalmente, vamos fechar a janela e é isso.
Meu nome é Rob, e esta foi Breakout.