>> ROB BOWDEN: Oi.
Estou Rob, e eu espero que o seu jogo para jogo da 15.
Agora, há quatro funções que você precisa a implementar neste programa - init,
desenhar, mover-se, e ganhou.
Então, vamos olhar para o init.
>> Aqui, vemos a primeira coisa que nós estamos vai fazer é declarar uma variável
chamado contador.
Vai ser inicializado para d vezes d menos 1.
Lembre-se que d é a dimensão do nosso conselho.
Como o init vai funcionar é que vai para repetir em todos os fóruns
e nós vamos começar no canto superior esquerdo.
>> E vamos apenas dizer que tenho uma placa de 4 por 4.
Assim, a parte superior esquerda estamos vai dizer é 15.
E então nós apenas estamos indo para contar através das placas, dizendo 15, 14, 13,
12, 11, 10, 9, 8, 7, 6, 5, 4, e assim por diante.
Assim, o canto superior esquerdo, esperamos estar d vezes d menos 1, que na posição 4 por 4
caso vai ser 16 menos 1, que é correctamente 15.
>> E agora aqui é onde nós vamos repetidas em toda a linha.
E nós estamos indo para definir cada posição a placa com o valor atual de
nosso balcão, e, em seguida, contador vai para diminuir, para que o próximo
posição chegarmos vai ter contador de ser um a menos que
a posição anterior.
Assim, inicialmente tinha 15 e diminuir balcão.
Então vamos atribuir 14 à posição seguinte, contra decréscimo,
e vamos atribuído 13, e assim por diante.
>> Finalmente, é preciso lidar com esse canto caso em que, se a placa tem um mesmo
dimensão, então é só fazer 15, 14, 13, 12, todo o caminho até a 3, 2, 1, é
vai nos deixar com uma placa insolúvel.
E nós temos que trocar o 1 eo 2.
Assim, se d mod 2 é igual a 0, isso é como vamos verificar
para ver se é mesmo.
Se d mod 2 é igual a 0, então na linha d menos 1, que é a linha de fundo, e
posição d menos 2, ou coluna d menos 2, nós vamos definir que a 2, e
coluna d menos 3 que estamos vai definir a 1.
Então, isso é só inverter onde o 1 e 2, atualmente.
>> Finalmente, vamos definir o muito inferior direito igual em branco, onde
em branco foi de hash definido no topo, como 0.
Então, isso não era estritamente necessário, uma vez que este ciclo for vai ter
definir o canto inferior direito para 0, uma vez que contador naturalmente atingir 0.
Mas isso depende de nós, sabendo que branco foi hash para encontrar um 0.
Se eu for para este programa e mais tarde mudar branco na parte superior a 100, que
ainda deve funcionar.
>> Portanto, esta é apenas ter certeza de que o canto inferior direito é realmente igual ao nosso
valor em branco.
Finalmente, temos duas variáveis ​​globais, tão em branco i e j em branco, e vemos
os declarados no topo.
E nós vamos usar os dois mundial variáveis ​​para acompanhar o
posição do branco, para que não precisa olhar através de todo o
conselho para encontrar o espaço em branco a cada vez que tentamos fazer uma jogada.
Assim, a posição da peça em bruto é sempre vai começar no canto inferior direito.
Assim, a parte inferior direita é dada por índices d menos 1, d menos 1.
Então, isso é o init.
>> Agora vamos passar para desenhar.
Então, sorteio vai ser semelhante onde vamos fazer uma iteração
ao longo de todo o tabuleiro.
E nós só queremos imprimir o valor que está em cada posição do tabuleiro.
Então, aqui, estamos a imprimir o valor que é em cada posição do tabuleiro.
E note que estamos fazendo -.
E isso é apenas a dizer que printf independentemente de se é um um dígito ou
número de dois dígitos, ainda quer que ele ocupar duas colunas na impressão,
de modo que, se tivermos dois dígitos e um algarismos na mesma placa, o nosso
conselho ainda vai ficar bom e quadrado.
>> Por isso, queremos fazer isso para cada valor na placa, exceto para o branco.
Assim, se a posição na placa é igual a o espaço em branco, então nós especificamente
pretende imprimir apenas um sublinhado para representar a placa, em vez de
qualquer que seja o valor do em branco realmente é.
>> Finalmente, queremos imprimir uma nova linha.
Note-se que este ainda está dentro o loop for externo, mas fora
o interior de loop.
Uma vez que este loop for externo é iteração sobre todas as linhas, e por isso este é printf
vai apenas imprimir uma nova linha, de modo que passar a imprimir a próxima linha.
E é isso por sorteio.
>> Então, agora vamos passar a se mover.
Agora, passamos movimento, a telha que a usuário é inserido no jogo - eles
entrar na telha eles querem passar - e você deveria retornar um booleano, então
verdadeira ou falsa, dependendo se esse movimento era realmente
válido - se que a telha pode ser mudou-se para o espaço em branco.
>> Então, aqui, nós declaramos uma variável local, tile_1 e tile_j, que vão
ser semelhante ao blank_i e blank_j, exceto que vai acompanhar o
posição do azulejo.
Agora aqui, vamos usar blank_i e blank_j e dizer tudo bem, então
aqui é o espaço em branco no tabuleiro.
>> Agora, é a telha acima do branco?
É a telha para a esquerda da barra de papelão?
É a telha para a direita da barra de papelão?
É o azulejo abaixo do branco?
Assim, se a telha é em qualquer dos posições, então sabemos que a telha
pode ser movido para o espaço vazio e a placa pode ser movida para onde o
telha atualmente.
>> Então, aqui, nós dizemos que se a placa na posição blank_i menos 1 blank_j.
Então, isso está dizendo é a telha acima da corrente em branco?
E se assim for, vamos lembrar que é a posição do azulejo.
O azulejo está na posição blank_i menos 1 e blank_j.
agora pela primeira vez, também temos essa verificação aqui, por isso é blank_i
maior do que 0.
>> Por que quer fazer isso?
Bem, se o branco é na linha superior do conselho de administração, então nós não queremos
olhar por cima do branco para o azulejo desde não há nada acima do topo
fileira do tabuleiro.
Isto é como você pode acabar recebendo algo como uma falha de segmentação ou
o programa só poderia trabalhar de formas inesperadas.
Então, isso é ter certeza de que nós não procurar em lugares que não são válidos.
>> Agora vamos fazer a mesma coisa para todas as outras possíveis combinações.
Então, aqui, nós estamos olhando abaixo o espaço em branco para ver se esse é o azulejo.
E nós também temos que ter certeza que estamos não na linha de baixo, ou então nós
não deve olhar para o azulejo.
Aqui, vamos olhar para a esquerda de o espaço em branco para ver se é o azulejo.
E não devemos olhar para a esquerda se estamos na coluna mais à esquerda.
E aqui nós vamos olhar para o direito de o espaço em branco, e não devemos
olhar para a direita, se estamos na coluna da direita.
>> Então, se nenhuma dessas coisas fosse verdade, isso significa que o azulejo não é adjacente
para o espaço em branco e podemos retornar false.
O movimento não era válido.
Mas, se um desses fosse verdade, então a Neste ponto, sabemos que tile_i e
tile_j são iguais aos posição do azulejo.
E assim, podemos atualizar a placa de posições tile_i e tile_j.
Sabemos que o novo valor será o branco e que a posição blank_i
blank_j, que era o original em branco - nós sabemos o azulejo vai
mudar para lá.
>> Observe que na verdade, não tem que fazer um troca real aqui, uma vez que sabemos que o
os valores que precisam de ser inserido naquelas posições.
Nós não precisamos de um temporário variável ao redor.
>> Finalmente, precisamos lembrar que nós temos nossas variáveis ​​globais que são
manter o controle da situação do branco.
Por isso, queremos atualizar a posição de o espaço em branco para estar onde a telha
originalmente era.
Finalmente, voltamos verdade, pois o movimento foi bem sucedido.
Nós trocar com sucesso o em branco com a telha.
>> Tudo bem, então passada nós precisa verificar won.
Assim, ganhou retorna da mesma forma um bool onde verdade que vai indicar que o
usuário ganhou o jogo.
E falso está indicando que o jogo ainda está em curso.
O usuário ainda não ganhou.
Então, isso vai ser muito bonito o oposto de inicialização, onde init
lembre-se, nós inicializar a bordo a 15, 14, 13, 12, etc.
Considerando ganhou, queremos verificar se o placa é 1, 2, 3, 4, 5, e assim por diante.
>> Então, vamos iniciar o nosso contrariar a 1, uma vez que é o que o topo
esquerdo da placa deve ser.
E então nós vamos fazer um loop ao longo de todo o tabuleiro.
Vamos ignorar essa condição por um segundo.
E essa condição só vai verificação é a placa nesta posição
igual as contagens atuais?
Se assim for, incrementa a contagem de modo a que o próxima posição que é olhar para um maior
que a posição estamos no agora.
>> Então é assim que nós temos a superior esquerdo deve ser 1.
Incrementar a contagem de 2.
Olhe para a próxima posição.
É este o 2?
Se for assim, incrementar a contagem de 3.
Próxima posição, isto é 3?
Se for assim, incrementar a contagem a 4, e assim por diante.
Assim, se houver qualquer posição sobre o placa que não é igual a nossa contagem,
então queremos voltar falsa, já que significa que há alguma peça que é
não na posição correta.
>> Então, aqui, o que é essa condição está fazendo?
Bem, lembre-se que o espaço em branco é deveria ir no canto inferior direito.
E o valor do branco não pode necessariamente igual ao valor do
contador que vai ser alcançado na parte inferior direita.
Por isso, quer especificamente para verificar se i é igual é igual a menos d 1 e j iguais
d é igual a menos 1 - o que está dizendo, se estão olhando para o canto inferior direito da
a bordo - então nós apenas deseja continuar.
Queremos pular este particular iteração do loop para.
>> E assim, se conseguirmos passar por isso aninhados em loop, o que significa que
não houve telha que foi em a posição incorreta.
E nós sair do loop e vir aqui, onde podemos voltar verdade.
Todos os azulejos estavam nas posições corretas e isso significa que o usuário tem
ganhou o jogo.
E é isso.
Meu nome é Rob Bowden, e este tinha 15 anos.