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.