1
00:00:00,000 --> 00:00:09,410

2
00:00:09,410 --> 00:00:11,002
>> ZAMYLA CHAN: Vamos nos divertir com 15.

3
00:00:11,002 --> 00:00:13,960
15 é o primeiro jogo que
você começa a implementar.

4
00:00:13,960 --> 00:00:15,350
E é interativo.

5
00:00:15,350 --> 00:00:16,079
Agora, não se preocupe.

6
00:00:16,079 --> 00:00:18,490
Você não tem que escrever o
tudo mesmo.

7
00:00:18,490 --> 00:00:19,650
>> Verifique o código de distribuição.

8
00:00:19,650 --> 00:00:23,560
Porque um monte de a estrutura do jogo
já está configurado para você.

9
00:00:23,560 --> 00:00:27,820
Ele aceita e analisa uma linha de comando
argumento do usuário e cria uma

10
00:00:27,820 --> 00:00:30,900
placa com base nessa entrada.

11
00:00:30,900 --> 00:00:35,240
>> Ele verifica se o jogo está ganho, e sai
uma vez que o usuário do ganhou o jogo.

12
00:00:35,240 --> 00:00:38,010
E para ganhar o jogo, ele fica
entrada do usuário e

13
00:00:38,010 --> 00:00:40,260
chama a função de movimento.

14
00:00:40,260 --> 00:00:44,270
Então, nós vamos estar implementando quatro
funções para o jogo de 15 -

15
00:00:44,270 --> 00:00:47,780
init, desenhar, mover, e ganhou.

16
00:00:47,780 --> 00:00:50,000
>> Primeiro, vamos resolver o init.

17
00:00:50,000 --> 00:00:54,820
No init, para inicializar, representamos
a placa em um array de inteiros 2D.

18
00:00:54,820 --> 00:01:00,840
E esta é uma variável global chamada
placa com dimensões máxima e máximo, o

19
00:01:00,840 --> 00:01:03,550
dimensões máximas do conselho.

20
00:01:03,550 --> 00:01:06,970
Agora, a dimensão real do conselho
é dada pelo utilizador, representada em

21
00:01:06,970 --> 00:01:10,300
o número inteiro d, o que poderia
ser menor do que o máximo.

22
00:01:10,300 --> 00:01:13,030
Mas em C, você não pode redimensionar arrays.

23
00:01:13,030 --> 00:01:16,400
Então, você está preso com que
dimensão máxima.

24
00:01:16,400 --> 00:01:19,510
>> Seu trabalho em init é preencher
os valores do conselho

25
00:01:19,510 --> 00:01:21,540
com os valores de correcção.

26
00:01:21,540 --> 00:01:23,600
Agora, temos visto matrizes 1D.

27
00:01:23,600 --> 00:01:26,570
Mas como matrizes 2D funciona?

28
00:01:26,570 --> 00:01:29,820
Há um índice da linha,
0 índice, como sempre, e

29
00:01:29,820 --> 00:01:31,770
então também da coluna.

30
00:01:31,770 --> 00:01:35,790
>> E você vai preencher sua grade em em
descendente valores, assim como este.

31
00:01:35,790 --> 00:01:41,330
Grade 0, 0, linha 0, coluna 0, é 8.

32
00:01:41,330 --> 00:01:42,930
Grade 0, 1 é 7.

33
00:01:42,930 --> 00:01:48,160
Isto é para um exemplo onde
d, pouco d, é 3.

34
00:01:48,160 --> 00:01:52,630
Agora, o conselho em 15 também deve conter
um azulejo branco, se você já jogou

35
00:01:52,630 --> 00:01:53,940
com o jogo físico.

36
00:01:53,940 --> 00:01:56,350
>> Mas conselho é um array de inteiros.

37
00:01:56,350 --> 00:01:58,880
Assim, todos os valores devem ser inteiros.

38
00:01:58,880 --> 00:02:06,580
Portanto, cabe a você decidir um inteiro
valor para representar um azulejo branco.

39
00:02:06,580 --> 00:02:10,250
>> Para inicializar sua placa, você pode usar
estruturas de loop para conter a

40
00:02:10,250 --> 00:02:16,100
estado inicial da placa, onde bordo
i, j representa o elemento em

41
00:02:16,100 --> 00:02:19,050
i linha e coluna j.

42
00:02:19,050 --> 00:02:20,710
Eles começam em ordem decrescente.

43
00:02:20,710 --> 00:02:24,200
E lembre-se que, se o número de peças
é estranho, então você vai

44
00:02:24,200 --> 00:02:29,260
tem que trocar o local
de 2 e de 1.

45
00:02:29,260 --> 00:02:31,420
Portanto, temos o nosso conselho inicializado.

46
00:02:31,420 --> 00:02:32,683