1
00:00:00,000 --> 00:00:00,260

2
00:00:00,260 --> 00:00:03,010
>> DAVID MALAN: Vamos escrever um programa
envolvendo uma janela e um círculo com

3
00:00:03,010 --> 00:00:05,820
o círculo indo e voltando
fora à esquerda e à direita

4
00:00:05,820 --> 00:00:07,120
bordos da janela.

5
00:00:07,120 --> 00:00:09,960
Para isso, vamos usar o Stanford
Biblioteca portátil, e vamos primeiro

6
00:00:09,960 --> 00:00:14,830
incluir gevents.h para que possamos
ouvir os movimentos do mouse.

7
00:00:14,830 --> 00:00:20,970
Vamos, então, incluir gobjects.h para que
podemos declarar coisas como ovais ou

8
00:00:20,970 --> 00:00:22,110
círculos, realmente.

9
00:00:22,110 --> 00:00:26,090
E então vamos incluir gwindow.h para que
temos uma janela gráfica para

10
00:00:26,090 --> 00:00:27,020
tudo.

11
00:00:27,020 --> 00:00:30,390
>> Vamos declarar principal da forma habitual.

12
00:00:30,390 --> 00:00:35,095
E vamos agora declarar e instanciar
ou criar essa janela, GWindow -

13
00:00:35,095 --> 00:00:37,090
e nós vamos chamar a janela variável -

14
00:00:37,090 --> 00:00:39,790
fica newGWindow.

15
00:00:39,790 --> 00:00:44,450
E vamos fazê-lo de forma arbitrária
320 pixels por 240 pixels.

16
00:00:44,450 --> 00:00:46,190
>> Vamos próximo instanciar um círculo.

17
00:00:46,190 --> 00:00:48,740
Mas para instanciar este círculo,
precisamos fazer um pouco mais de trabalho.

18
00:00:48,740 --> 00:00:51,340
Em particular, vamos preencher esse círculo
de modo que toda a coisa é

19
00:00:51,340 --> 00:00:53,910
preto e não apenas o
delinear mesmo.

20
00:00:53,910 --> 00:00:54,850
Goval -

21
00:00:54,850 --> 00:00:56,450
vamos chamá-lo círculo -

22
00:00:56,450 --> 00:00:58,310
fica newGOval.

23
00:00:58,310 --> 00:01:04,810
Vamos colocar este oval em 0, 110, e nós vamos
fazer os ovais 20 pixels de largura por

24
00:01:04,810 --> 00:01:09,070
20 pixels de altura - em outras palavras, uma
diâmetro de 20 ou de um raio de 10.

25
00:01:09,070 --> 00:01:14,120
>> Vamos agora definir a cor do círculo
ser citação, fecha aspas, "negro". Vamos

26
00:01:14,120 --> 00:01:19,030
agora defini-lo ser preenchido
especificando verdade.

27
00:01:19,030 --> 00:01:24,100
E agora, finalmente, vamos adicionar o círculo de
janela da seguinte forma, em que o

28
00:01:24,100 --> 00:01:26,390
Esta última é adicionada à anterior.

29
00:01:26,390 --> 00:01:27,910
>> Vamos agora declarar uma dupla.

30
00:01:27,910 --> 00:01:29,200
Vamos chamá-lo de velocidade.

31
00:01:29,200 --> 00:01:32,380
E um tanto arbitrariamente, vamos dizer que o
velocidade desse círculo será

32
00:01:32,380 --> 00:01:36,290
2,0, por outras palavras, dois pixels
para cada unidade de tempo.

33
00:01:36,290 --> 00:01:39,380
E agora vamos deliberadamente
induzir um loop infinito.

34
00:01:39,380 --> 00:01:42,060
>> Então, como fazer este círculo
saltar para trás e para a frente?

35
00:01:42,060 --> 00:01:45,190
Bem, vamos assumir dentro deste ciclo que
para cada unidade de tempo, estamos

36
00:01:45,190 --> 00:01:48,890
indo para mover o círculo um pouco
bit com base na sua velocidade de 2 pixels

37
00:01:48,890 --> 00:01:50,070
por unidade de tempo.

38
00:01:50,070 --> 00:01:52,900
Mas continuamente, nós vamos ter que
verificar se o círculo está tocando o

39
00:01:52,900 --> 00:01:56,480
borda direita da tela ou para a esquerda
borda da tela, porque se assim for, nós

40
00:01:56,480 --> 00:01:58,530
precisa dele para se recuperar, por assim dizer.

41
00:01:58,530 --> 00:02:00,380
>> Como implementar o
noção de saltar?

42
00:02:00,380 --> 00:02:04,400
Bem, se nós estamos indo em 2 pixels para a
direito por unidade de tempo, para saltar fora

43
00:02:04,400 --> 00:02:08,259
a margem direita, podemos simplesmente reverter
que, para ser negativos 2 pixels por unidade

44
00:02:08,259 --> 00:02:10,400
de tempo, contrariando assim
a velocidade.

45
00:02:10,400 --> 00:02:13,160
Então, na verdade, de salto é relativamente
simples.

46
00:02:13,160 --> 00:02:19,260
>> Vamos primeiro mover o círculo por isso muitos
os pixels ao longo do eixo-x, por esta

47
00:02:19,260 --> 00:02:21,040
muitos pixels ao longo do eixo-y.

48
00:02:21,040 --> 00:02:23,600
Em outras palavras, nós não queremos que
mover ao longo do eixo y de todo.

49
00:02:23,600 --> 00:02:25,950
Nós só queremos que ele se recuperar
e para a frente esquerda e direita.

50
00:02:25,950 --> 00:02:31,910
>> E vamos agora verificar dentro deste loop se
a coordenada x do círculo mais

51
00:02:31,910 --> 00:02:36,515
a largura do círculo é maior
ou igual ao

52
00:02:36,515 --> 00:02:38,520
largura da janela -

53
00:02:38,520 --> 00:02:42,180
em outras palavras, se a localização do círculo
mais a largura do círculo

54
00:02:42,180 --> 00:02:44,840
em si é agora além da borda
da janela, TEREMOS

55
00:02:44,840 --> 00:02:46,090
melhor reverter nossa velocidade -

56
00:02:46,090 --> 00:02:49,080

57
00:02:49,080 --> 00:02:53,680
velocidade fica velocidade negativa, assim
lançando um positivo para um

58
00:02:53,680 --> 00:02:56,090
negativo ou negativo para um positivo.

59
00:02:56,090 --> 00:02:59,740
Mas e se o círculo está se movendo de
direita para a esquerda e, portanto, atinge

60
00:02:59,740 --> 00:03:00,670
a margem esquerda?

61
00:03:00,670 --> 00:03:06,490
Em outras palavras, se a coordenada x do
o círculo é agora menor ou igual

62
00:03:06,490 --> 00:03:12,530
a 0, vamos em frente e novamente
inverter a velocidade.

63
00:03:12,530 --> 00:03:14,980
>> Então, por que eu não adicionado na
largura do círculo esta

64
00:03:14,980 --> 00:03:16,410
tempo, como eu fazia antes?

65
00:03:16,410 --> 00:03:19,050
Bem, lembre-se que as coordenadas
de um objeto são definidos

66
00:03:19,050 --> 00:03:22,200
pelo seu canto superior esquerdo,
não por seu meio.

67
00:03:22,200 --> 00:03:25,810
E assim, quando o círculo está se movendo de
esquerda para a direita, é preciso verificar

68
00:03:25,810 --> 00:03:28,910
se a margem direita do
círculo passou a

69
00:03:28,910 --> 00:03:30,200
borda direita da janela.

70
00:03:30,200 --> 00:03:34,100
Então, para descobrir o que é isso, temos
para obter a coordenada x do círculo

71
00:03:34,100 --> 00:03:38,080
mais a largura do círculo para mover
nós mesmos a partir do topo da esquerda

72
00:03:38,080 --> 00:03:40,650
canto, de forma eficaz, para o
canto superior direito.

73
00:03:40,650 --> 00:03:43,700
Quando o círculo está se movendo da direita para a
esquerda, enquanto isso, não precisamos de

74
00:03:43,700 --> 00:03:47,550
se preocupar com essa adição, porque a
canto superior esquerdo do círculo é

75
00:03:47,550 --> 00:03:50,700
já o valor que vai
começa a partir get x.

76
00:03:50,700 --> 00:03:54,140
>> Vamos agora passar a bola.

77
00:03:54,140 --> 00:04:00,900
Vamos agora salvar, compilar e executar este
programa, faça salto,. / rejeição.

78
00:04:00,900 --> 00:04:02,230
E aí temos um programa.

79
00:04:02,230 --> 00:04:05,760
>> Mas o círculo está se movendo tão rápido danado,
é quase impossível ver o que está

80
00:04:05,760 --> 00:04:07,060
realmente acontecendo.

81
00:04:07,060 --> 00:04:10,620
Então, vamos muito pelo programa à força por
clique no X no canto superior direito

82
00:04:10,620 --> 00:04:11,720
canto aqui.

83
00:04:11,720 --> 00:04:15,300
Vamos agora voltar para o código-fonte
e retardar as coisas um pouco.

84
00:04:15,300 --> 00:04:19,240
>> Em outras palavras, nesse infinito
loop, em vez de apenas nos movemos e

85
00:04:19,240 --> 00:04:22,850
mover-se e de novo, ad nauseum, vamos demorar
por apenas alguns milissegundos

86
00:04:22,850 --> 00:04:24,910
antes de continuar a se mover novamente.

87
00:04:24,910 --> 00:04:28,480
Em particular, vamos para o fundo
do ciclo infinito aqui e simplesmente

88
00:04:28,480 --> 00:04:32,820
pausa para, digamos, 10 milissegundos
em cada iteração.

89
00:04:32,820 --> 00:04:36,690
Vamos agora recompilar e re-run de rejeição.

90
00:04:36,690 --> 00:04:40,190
E agora vemos um razoável muito mais
implementação, onde podemos ver a

91
00:04:40,190 --> 00:04:43,310
círculo verdadeiramente saltando sobre o
esquerda e margem direita.

92
00:04:43,310 --> 00:04:45,395