Versão 1.0
Scratch para Ciência da
Computação
Scratch 1.4
Traduzido por Maxwell Anderson
Necessita de revisões
Michal Armoni e Moti Ben-Ari
WEIZMANN INSTITUTE OF SCIENCE
Sumário
Primeiros passos .......................................................................................................................... 2
Exemplo 1 – Nossa primeira animação em Scratch .................................................................. 3
Uma descrição da janela do Scratch ..................................................................................... 3
Executando uma animação .................................................................................................. 4
Scripts................................................................................................................................... 4
Exemplo 2 – Uma sequência de instruções de movimento ...................................................... 6
Mudando os valores das instruções ..................................................................................... 6
Mudando a direção de um Sprite ......................................................................................... 7
Direções no palco ................................................................................................................. 7
Execução sequencial ............................................................................................................ 8
Salvando um projeto ............................................................................................................ 9
Exemplo 3 - Iniciando uma animação a partir de um local fixo .............................................. 10
Inicialização ........................................................................................................................ 10
Movimento absoluto e relativo .......................................................................................... 11
Exemplo 4 - movimento contínuo .......................................................................................... 13
Escrevendo uma descrição do script para esta tarefa ........................................................ 13
Construindo um script para essa tarefa ............................................................................. 14
A posição de um sprite se refere ao seu centro ................................................................. 14
Executando o script ............................................................................................................ 14
Resumo .................................................................................................................................. 16
Conceitos............................................................................................................................ 16
Instruções Scratch .............................................................................................................. 17
Técnicas Scratch ................................................................................................................. 17
1
Scratch para Ciência da Computação
Resumo
Primeiros passos
Scratch é um ambiente de programação visual que vamos usar para se familiarizar com os
conceitos de ciência da computação. Scratch faz isso permitindo que você crie animações
computadorizadas. Inicialmente, o ambiente do Scratch será estranho e vamos investir esforço
em aprender os detalhes de como usá-lo. Muito rapidamente você vai achar que você domina
o ambiente e vamos progredir de criação de animações muito simples para outras mais
complexas. Mesmo as animações complexas serão construídas passo-a-passo para ajudar você
a aprender os novos conceitos e construções. Scratch não é utilizada no desenvolvimento de
software profissional, mas os conceitos que irão aprender como criar projetos em Scratch
aparecerá novamente e novamente quando você continuar a estudar ciência da computação
mais avançada.
O Scratch pode ser baixado em http://scratch.mit.edu/scratch_1.4/
Para ambientes Windows, instale a versão Scratch 1.4 para Windows.
2
Exemplo 1 – Nossa primeira animação em Scratch
Nosso primeiro encontro com o Scratch será com uma animação muito simples que nós
preparamos para você. Abra o ambiente do Scratch, clicando duas vezes no ícone do gato laranja
e branco na área de trabalho. A janela do Scratch será aberta. No topo da janela, você verá
quatro palavras: arquivo, editar, compartilhar, ajudar. Clique em Arquivo para abrir um menu
de comandos e, em seguida, clique na linha Abrir... Você verá uma lista de pastas que aparece
sob os projetos da pasta. Clique no ch01 pasta que está associado a este primeiro capítulo, e em
seguida, clique no botão OK. Dentro da lista, clique no projeto move-10-steps que contém o
primeiro exemplo e clique novamente em OK.
Uma descrição da janela do Scratch
A janela do Scratch é apresentada abaixo. No lado direito você verá um grande quadrado branco.
Esta é a fase em que as figuras das animações se moverá. Os números são chamados de sprites.
Neste exemplo, existe um sprite, o gato zero. No canto superior esquerdo do palco, temos
organizado para apresentar a posição e direção do sprite gato que está de pé no centro do palco
em um ponto numeradas (0, 0) e virado para a direita na direção de 90° (90 graus).
Figura 0.1 - Janela do Scratch
O palco mede 480 unidades de largura por 360 unidades de altura. As posições do centro e os
quatro cantos do palco são apresentados na Figura 1.1.
Abaixo o canto direito do palco, a posição atual do ponteiro do mouse é exibido, por exemplo,
x: 100 y: -50. Mova o ponteiro do mouse ao redor sem olhar para o visor e tentar adivinhar onde
ele está; em seguida olhar para o visor esquina e veja se você foi de aproximadamente correta.
Arraste o gato com o mouse e ver como a sua posição muda. Antes de continuar, devolver o
gato para o centro do palco, o mais próximo possível para (0, 0).
3
Figura 0.2 - Posições x e y no palco
Executando uma animação
Clique na bandeira verde que aparece acima do canto direito do palco.
O que acontece?
O gato mudou a sua posição e se moveu um pouco para a direita. Você pode ver isso na tela da
posição (no canto superior esquerdo do palco): no eixo x do gato agora mudou para a posição
10, enquanto que antes a sua posição era zero. A posição no eixo-y não foi alterado nem tem o
sentido.
Clique novamente sobre a bandeira verde.
O que acontece agora?
Mais uma vez, o gato mudou a sua posição e se mudou 10 passos para a direita. Clicando
repetidamente na bandeira verde fará com que a mesma ação para acontecer de novo e de
novo: um movimento do gato 10 passos para a direita no eixo x. Isto irá continuar até que o gato
atinge o limite do palco e (quase) desaparece. Se você continuar a clicar na bandeira verde, nada
vai acontecer.
Scripts
Olhe para o longo painel cinza que aparece à esquerda do palco no centro da janela do zero.
Este painel contém o script que é executado, a fim de mover o gato.
Cada sprite no zero tem um conjunto de scripts que descrevem o seu comportamento. Sprites
não agem como querem, mas apenas de acordo com instruções claras nos scripts que
escrevemos para eles.
Como você poderia esperar, o script para o gato neste projeto é muito simples:
4
Ele consiste em dois blocos contendo instruções. o primeiro
significa que as
instruções a seguir será executado quando você clicar na bandeira verde com o mouse. O
segundo significa que o sprite (o gato) deve mover-se
na direção que ele está agindo.
10 unidades no palco
Novo conceito: Instrução, executando um programa
Uma instrução provoca um sprite para executar uma ação. As instruções
devem ser claras e inequívocas.
Quando um programa é executado as ações especificadas nas instruções são
realizadas.
A caixa amarela que aparece na área de script contém um comentário, que é
uma descrição do roteiro em Inglês. Comentários são muito importantes
porque ajudam o leitor a entender o programa Scratch. Enquanto você
entender o que um script faz quando você escrevê-lo, uma ou duas semanas
mais tarde, você pode não se lembrar muito bem. Se alguém tenta trabalhar
com os seus scripts, ela vai ficar feliz em ver os roteiros explicado nos
comentários.
Nova construção em Scratch: bloco, roteiro, comentário
Um bloco é um elemento gráfico colorido que é usado para construir programas em Scratch.
Cada bloco é marcado com uma instrução que faz com que o computador execute uma ação
quando o bloco é executado. Um script é um conjunto estruturado de blocos que especifica o
comportamento de um sprite.
Um programa em Scratch consiste na definição de todos os sprites (como eles olham) e todos
os scripts de cada Sprite (como eles se comportam). Um comentário é uma descrição textual do
que um script é suposto fazer.
Os comentários não são parte do programa! Ou seja, Scratch executa as instruções nos blocos
dos scripts e ignora os comentários. Você pode escrever um comentário que diz que "o gato
move para a esquerda", mas se você usar um bloco que instrui o gato para mover para a direita,
ele irá mover para a direita. Comentários são muito úteis quando se tenta entender um
programa, mas você deve sempre lembrar que um comentário pode não descrever
corretamente o que as instruções estão fazendo...
5
Exemplo 2 – Uma sequência de instruções de movimento
Façamos o comportamento do gato mais complexa por ter que fazer mais do que um movimento
quando o script é executado.
Tarefa 1
Construir uma animação que faz com que o gato se mova 100 passos e, em seguida,
virar 90 graus para a esquerda cada vez que é executado (clicando na bandeira
verde).
Mudando os valores das instruções
Em primeiro lugar, vamos aumentar o comprimento do movimento que faz com que o gato de
10 passos para 100 passos. A instrução move...steps é uma instrução geral que não nos diz
quantos passos para se mover. A fim de realmente usar a instrução em um script, devemos criar
uma instrução específica que especifica o número de passos para se mover. O roteiro do
exemplo anterior usou o bloco
que contém uma janela com o valor 10.
Queremos mudar isso para 100, de modo que a instrução específica fará com que o gato a se
mover 100 passos. Clique na janela e ele vai mudar para uma cor azul escuro. Agora você pode
digitar o número 100, que irá substituir o número 10. Clique na bandeira verde em cima do palco
e você vai ver que o gato se move 100 passos. Use o mouse para mover o gato para outro lugar
no palco; clique novamente na bandeira verde e ver o que acontece.
O que acontece se inserir um número negativo -100 para a janela no bloco?
Os números negativos causam o movimento para ser feita na direção oposta a partir de números
positivos. Se o sprite está apontando para a direita, um movimento por um número positivo faz
com que ele vá para a direita, enquanto um movimento por um número negativo faz com que
ele vá para a esquerda. Se o sprite está apontando para a esquerda, o movimento se inverte:
positivo para a esquerda e negativo à direita. Para verificar se isso é verdade, digite valores
diferentes na janela do bloco de movimento, clique na bandeira verde, e olhe para os valores na
tela, no canto superior esquerdo do palco. Na próxima seção, vamos aprender a mudar a direção
de um sprite e você deve verificar novamente que os movimentos "positivos" e "negativos" são
em relação à direção do sprite.
Antes de continuar, altere o valor no bloco de movimento de volta para o positivo 100.
Novo conceito: instruções gerais e específicas
Uma instrução geral torna-se uma instrução específica quando os valores específicos são
adicionados à instrução. Estes valores transformam uma instrução ambígua que não pode ser
executado em uma instrução inequívoca que pode ser executado.
Nova construção em Scratch: move
A instrução faz com que o sprite se mova da sua posição atual pelo número de passos dados
dentro da janela. Um passo é uma unidade no palco. Se o valor for positivo, o movimento é na
direção que o sprite está enfrentando; caso contrário, é no sentido oposto.
6
Mudando a direção de um Sprite
Vamos agora adicionar um aspecto adicional para o comportamento do gato: mudança de sua
direção. Olhe para o painel cinza longo do lado esquerdo da janela do zero. Você vai ver uma
grande coleção de blocos que podemos usar na construção de scripts. Vamos mudar a direção
do gato usando o bloco azul
, que é rotulado com a volta de instrução
e uma seta que é curvo no sentido anti-horário. (Este é o terceiro bloco a partir do topo). Para
inserir este bloco no script, arraste-o e solte-o debaixo do bloco move.
Através de arrastar-e-soltar faz-se as seguintes ações: (1) mover o mouse até
os pontos ponteiro do mouse para o bloco; (2) pressione o botão esquerdo do
mouse e mantenha-o; (3) sem soltar o botão, mova o mouse na direção do
script no painel do meio; isso é chamado arrastando, porque você vai ver o
bloco "arrastado", juntamente com o ponteiro do mouse; (4) quando você
chegar ao ponto onde você deseja inserir o bloco, solte o botão esquerdo do
mouse no ícone do e para o bloco vai "cair" no lugar. A protuberância na parte
inferior de um bloco vai encaixar-se um entalhe na parte superior do bloco
abaixo.
Scratch garante que você só pode soltar um bloco em locais onde é permitido. Uma linha branca
vai aparecer nesses locais à medida que arrasta o bloco. Neste script, a linha branca será exibida
quando você posiciona o mouse sobre o bloco de movimento, assim como quando você
posicioná-lo abaixo do bloco, porque o bloco por sua vez, é permitido em ambos os lugares.
Mova o mouse até a linha branca aparece abaixo do bloco de movimento e soltar o bloco vez lá.
A instrução por sua vez é também uma instrução geral que tem que ter um valor entrado em
sua janela de modo a torná-la uma instrução específica que pode ser executado. Alterar o
número dentro da janela do bloco vez de 90. Esta instrução diz que o gato para transformar em
um sentido anti-horário por 90◦.
Direções no palco
Direções no palco do Scratch são medidos em torno de um círculo, como em um relógio, para
que possamos falar sobre o movimento no sentido horário e anti-horário movimento. Ao
contrário de um relógio que divide suas direções em 12 unidades (horas) e 60 unidades (minutos
ou segundos), as direções em Scratch são divididos em 360 unidades chamadas graus e indicada
por um pequeno círculo ◦. A figura abaixo mostra os graus associados com oito setas que
começam no centro da arena e apontam na horizontal, na vertical e em diagonal.
7
Os 360 graus da circunferência vão de -180 graus para +180 graus. A direção de 90 graus (escrito
90◦) aponta para a direita, 0◦ pontos para cima, -90◦ pontos à esquerda e 180◦ (ou -180◦) aponta
para baixo. Dada uma direção D◦, a direção oposta é D◦ - 180◦ ou D° + 180°, então, por exemplo,
o oposto de 45◦ é de 45◦ - 190◦ = -135◦, e o oposto de 0◦ pode ser escrito como 180◦ ou -180◦.
Nova construção em Scratch: turn
A instrução
faz com que o sprite gire em sentido anti-horário pelo
número de graus que é especificado na janela. Do mesmo modo, a instrução
faz com que o sprite gire no sentido horário pelo número de graus na
janela.
Execução sequencial
No script para Tarefa 1, cada clique na bandeira verde provoca uma sequência de duas
instruções a serem executadas uma após a outra na ordem em que aparecem no roteiro:
primeiro, o de instrução move e, em seguida, a instrução turn. Clique na bandeira verde várias
vezes e ver como o gato se move no palco. Olhe para a exibição de posição do gato e direção no
canto superior esquerdo do palco e explique como as instruções faz com que esses valores
mudem, e em que ordem elas são alteradas.
Novo conceito: sequência de instruções e execução sequencial
Uma sequência de instruções é um conjunto de instruções colocadas uma após a outra.
8
Em uma execução sequencial, as instruções do jogo são executados na mesma ordem em que
aparecem na sequência.
Antes de terminar a trabalhar sobre este script, vamos atualizar o comentário na caixa amarela
que está na área de script. Clique dentro da caixa e mude o texto para que ele explique o que o
novo script faz. É importante que você sempre escrever e atualizar esses comentários para que
ele vai ser fácil de entender o que é um script faz.
Salvando um projeto
Vamos salvar o novo projeto, sem apagar ou danificar o já existente. Clique
na palavra Arquivo no topo da janela e, em seguida, clique na linha Salvar
como no menu. Uma janela se abrirá, mostrando a pasta atual; digitar o
nome do novo projeto. Certifique-se de não usar o mesmo nome do antigo
projeto, porque isso vai substituir o antigo com o novo. Agora clique em OK
para salvar o arquivo; um quadro de animação na janela de zero indica que
o save foi realizado com sucesso.
9
Exemplo 3 - Iniciando uma animação a partir de um local fixo
Vamos agora estender o roteiro para o gato incluir uma maior sequência de instruções.
Tarefa 2
Construir uma animação que faz com que o gato se mova 100 passos e, em seguida,
virar 90 graus para a esquerda cada vez que é executado (clicando na bandeira
verde). Para cada corrida, o gato vai começar no mesmo lugar: o meio do palco (0,
0) virado para a direita.
Arquivo do programa: initialize-and-move
Inicialização
Os dois scripts que temos até agora fizeram com que o gato se mova. Depois de executar cada
um desses scripts, o gato está em uma nova posição, de modo que uma nova execução do script
faz com que o gato se mova a partir de sua nova posição. Em outras palavras, o efeito de
executar um script depende da posição inicial do gato.
Vamos agora desenvolver um script que resulta no mesmo comportamento cada vez que é
executado, independentemente da posição inicial do gato. Para conseguir isso, nós escrevemos
um roteiro cujas primeiras instruções mova o gato para uma posição fixa. Olhe para a lista de
blocos no painel à esquerda.
Que instruções podem ser usadas para fazer isso?
Podemos usar a instrução
Arraste e solte o bloco com esta instrução, colocando-o no início do script imediatamente após
o bloco
. Lembre-se que uma linha branca aparecerá entre os dois blocos
para indicar que você pode soltar o bloco lá. Scratch irá mover automaticamente os blocos
existentes para dar espaço para o novo. A meio do palco está na posição (0, 0), então, se as
janelas dentro deste bloco não tem zeros, clique neles e entre com os zeros.
Atribuição de valores iniciais em um script é chamado de inicialização. Aqui, estamos a garantir
que a posição inicial do gato está sempre no centro do palco.
Nova construção em Scratch: go to
A instrução
faz com que o sprite mude a sua posição e ir para uma nova
posição, que é especificado por X (horizontal) e Y (vertical) nas janelas.
Nós também gostaríamos de começar o movimento do gato quando ele está apontando em uma
direção fixa. Após a inicialização da posição do gato, vamos colocar uma instrução que irá
inicializar direção do gato. Olhe novamente para a lista de blocos.
Que instrução você acha que podemos usar para definir a direção?
10
A instrução
(o quarto de cima) nos permite apontar o gato na
direção dada pelo número na janela. Arraste e solte este bloco para que ele apareça após o
bloco com a instrução go to x: y:
Verifique que a área branca tem o valor de 90, o que significa que o sprite do gato olhe para a
direita. Se não, clique na pequena seta na área branca e escolha (90)-right.
Salve este script com um novo nome usando a instrução Salvar como (Save As).
Nova construir em Scratch: point in direction
A instrução
faz com que o sprite mude a direção em que se
enfrenta à direção especificada na janela. Ao clicar na pequena seta na janela, você pode
selecionar uma das quatro direções principais (para cima, direita, baixo, esquerda);
Alternativamente, você pode digitar em qualquer direção (0-360) que você queira.
Clique na bandeira verde. O gato inicialmente retorna ao centro do palco virado para a direita
(se não já estava lá); em seguida, ele se move 100 passos para a direita e vira para a esquerda
até que ele se vira para cima. Clique na bandeira verde de novo e de novo, e você vai ver que o
gato retorna à mesma posição o tempo todo, porque ele começa o seu movimento a partir do
mesmo lugar, o centro do palco virado para a direita. As quatro instruções do script são sempre
executadas na mesma ordem sequencial em que aparecem após o bloco superior para a
bandeira verde.
Você pode usar o mouse para arrastar e soltar o gato. Coloque-o em qualquer lugar nesta fase.
Mova o gato para uma posição arbitrária no palco e, em seguida, clique na seta verde.
Explique o que acontece.
Novo conceito: Inicialização
Inicialização refere-se a instruções que definem os valores de início de um programa. A maioria
das sequências de instruções terá uma parte de inicialização que consiste em diversas instruções
que garantem que a sequência sempre começa a ser executado a partir do mesmo estado.
Movimento absoluto e relativo
As duas primeiras instruções no script para esta tarefa são muito diferentes da primeira e
segunda instrução.
Você pode explicar a diferença?
As instruções go to x: y: e point in direction são chamados
instruções absolutas, porque o movimento que os
resultados é o mesmo, não importa onde o gato está e em
que direção ele está apontando. O resultado depende
apenas dos valores que são dadas as instruções (na janela).
Por exemplo, go to x: 0 y: 0 irá sempre retornar o gato para
11
o centro do palco e point in direction 180 será sempre fazer com que o gato olhe para o fundo
do palco.
As instruções de move e turn, são chamados de instruções relativas, porque o movimento que
resulta é em relação à posição e orientação atual do gato. Ou seja, embora o número de passos
que o gato leva e o número de graus especificados giram nas janelas, a posição final e direção
do gato depende da sua posição e direção atual. Por exemplo, se o gato está apontando para a
direita, a instrução mover 100 passos fará com que ele se mova 100 passos para a direita,
enquanto que, se o gato está apontando para cima em direção ao topo do palco, o movimento
instrução 100 passos fará com que ele para mover para cima 100 passos. Da mesma forma, o
gato está apontando para cima, a volta de instrução anti-horário 90 graus fará com que ele para
olhe para o lado esquerdo do palco, enquanto uma segunda execução desta instrução fará com
que ele olhe para baixo.
Novo conceito: instruções absolutos e relativos
Uma instrução absoluta é aquela em que o resultado da execução da instrução não depende do
estado atual, mas apenas sobre os valores especificados na instrução.
O resultado da execução de uma instrução relativa depende dos valores especificados na
instrução e o estado atual.
12
Exemplo 4 - Movimento contínuo
Tarefa 3
Construir uma animação que faz com que o gato se mova ao redor do palco, a partir
do canto inferior esquerdo e volte para lá.
Os scripts que escrevemos para as tarefas anteriores, faz com que o gato se mova, mas você não
pode realmente ver o movimento do gato, porque isso aconteceu muito rápido. Há uma outra
instrução
, que é semelhante a
, com
exceção de que isto faz com que o movimento de seja gradual, de modo que ele pode ser visto.
O bloco glide (o oitavo bloco de cima) tem três janelas que devem ser preenchidos com os
valores para transformá-la em uma instrução específica: o primeiro valor é a duração do
movimento de deslizamento, ou seja, o número de segundos que o movimento vai tomar. As
duas janelas são para as posições x e y para que o sprite se mova. Você terá que experimentar o
valor para a duração para ver qual deles oferece a melhor apresentação visual.
A instrução glide é uma instrução absoluta ou uma instrução relativa?
Vamos comparar. A instrução go to é claramente uma instrução absoluta, porque o seu único
efeito é mover o sprite imediatamente a um ponto final, independentemente do local onde ele
se encontra atualmente. A instrução glide atinge o mesmo estado final, mas o tempo de “vôo
livre” significa que estamos interessados na aparência do sprite, como ele se move para o ponto
final. Isso depende do estado atual: se o sprite está perto do ponto final, ele irá mover-se
lentamente, enquanto se está longe ele vai passar rápido. Vemos que a instrução glide é uma
instrução relativa, pois sua ação depende do estado atual do objeto.
Nova construção em Scratch: glide
A instrução faz com que o sprite para se deslocar para a posição especificada nas janelas
rotuladas x e y. O tempo que leva para chegar a esta posição de sua posição atual é especificado
na primeira janela.
Escrevendo uma descrição do script para esta tarefa
Vamos usar as instruções que aprendemos até agora para escrever o script que fará com que o
gato viaje completamente em torno do palco. O gato vai começar no canto inferior esquerdo e
moverá no sentido anti-horário ao redor do palco. Antes de escrever o script real em Scratch,
pegue um pedaço de papel e desenhe o movimento do gato no palco. Isso vai ajudar você a
entender a sequência de instruções que devem ser executados para que o gato complete com
sucesso a sua viagem. Em seguida, faça uma lista dos movimentos separados que o gato deve
fazer. A lista de movimentos será como se segue:
1.
2.
3.
4.
5.
6.
Mover o gato para o canto inferior esquerdo do palco
Apontar o gato para a direita
O gato se move para o canto inferior direito do palco
O gato vira para cima
O gato se move para o canto superior direito
O gato se vira para esquerda
13
7. O gato se move para o canto superior esquerdo
8. O gato vira o rosto para baixo
9. O gato se move para o canto inferior esquerdo
Novo conceito: a descrição do comportamento de um sprite
Um dos primeiros passos no desenvolvimento de um projeto de programação é escrever em
palavras uma descrição das ações a serem executadas pelo programa. A descrição é escrito
como uma sequência de passos. A descrição deve ser clara e inequívoca, embora ela não precisa
ser totalmente detalhada.
Você será tentado a pular o passo de escrever uma descrição de um programa; é muito mais
divertido para começar a programar em Scratch imediatamente. No entanto, a experiência tem
demonstrado que, como os programas ficam mais longos e mais complexa torna-se
extremamente importante pensar sobre o projeto do programa de primeira e anotar o design.
Não nos entreguemos à tentação de começar a programar imediatamente!
Construindo um script para essa tarefa
Essa descrição pode ser facilmente traduzido em um script Scratch. Aqui está (mas sem os
valores específicos nos blocos go to e glide):
A posição de um sprite se refere ao seu centro
A posição de um sprite geralmente refere-se ao seu centro quando ele é exibido no palco. Desde
que nós não queremos o sprite desapareça, certifique-se de não movê-lo muito perto da beira
do palco. Para descobrir o quão longe um sprite pode ser movida sem desaparecer, coloque o
cursor do mouse no seu centro, clique e mantenha pressionado o botão esquerdo do mouse.
Mova o sprite para uma borda do palco. Pouco antes de ele começa a desaparecer, anote a
posição x ou y da posição do mouse, como mostrado abaixo no canto direito do palco. Você
sempre pode mudar os valores de instruções de movimentação para corrigir a posição.
Executando o script
Teste o script executando-o (clicando na bandeira verde) e observando se o movimento do gato
é o que deveria ser. Se não, analise com muito cuidado em cada uma das instruções do script e
compare-o com a lista de ações que você anotou. É muito fácil cometer um erro como escrever
9 para 90 ou 100 para 10.
14
Acrescente um comentário explicando o que o script faz. Para isso, aponte o mouse para uma
área vazia no fundo cinza da área de roteiro (o painel do meio) e clique no botão direito do
mouse. Você verá um pequeno menu cuja terceira entrada é adicionar comentários; clique sobre
essa entrada com o botão esquerdo do mouse. A janela amarela será aberta e você pode
escrever seus comentários.
Quando você tiver terminado, não se esqueça de salvar o projeto com um novo nome.
Exercício 1
Criar um script que faz com que o gato para começar no canto superior direito e
viajar ao redor do palco no sentido horário.
Orientação: Desenhe o movimento em um pedaço de papel e faça uma lista dos
movimentos separados que são necessários para que o gato possa completar sua
jornada com sucesso.
Crie o hábito de planejar suas animações antes de escrever os scripts em Scratch; você vai achar
que isso vai simplificar o seu trabalho, especialmente quando as animações tornam-se mais
complicado.
15
Resumo
Neste capítulo, nós nos encontramos Scratch pela primeira vez e aprendemos conceitos básicos
da ciência da computação, bem como construções para escrever programas em Scratch.
Conceitos
Sprites: em um ambiente Scratch para a criação de animações de sprites. Sprites movem-se em
um palco. As posições relativas do palco são descritos por posições x e y, de -240 a 240 ao longo
do eixo x, e de -180 a 180 no eixo y. O centro da etapa está no ponto (0, 0). A qualquer momento
quando um programa é executado, cada Sprite tem uma posição de acordo com a direção em
que ele enfrenta.
Sprites não se movem por si mesmos; eles só se movem de acordo com as instruções, que são
coletados em sequências chamados scripts. As instruções são executadas sequencialmente, um
após o outro, na ordem em que aparecem de cima para baixo no script. Os scripts podem
começar a funcionar quando a bandeira verde é clicada.
Instruções gerais e específicas: muitas instruções são instruções gerais, para as quais
precisamos para fornecer valores a fim de obter uma instrução específica que possa ser
executada. Por exemplo, a instrução
precisa de três valores
para transformá-lo a partir de uma instrução geral para uma instrução específica: o número de
segundos do deslizamento, e os valores x e y da posição que o sprite irá deslizar.
Instruções absolutas e relativas: Existem dois tipos de instruções: instruções absolutas cujo
efeito é inteiramente determinado pelos valores que são fornecidos na própria instrução. Por
exemplo, a instrução absoluta
faz com que o sprite mova para a posição
(100, 100), independentemente do movimento posição atual do objeto. O resultado da
execução de uma instrução relativa depende tanto os valores na instrução e sobre o estado atual
do objeto. Por exemplo, a instrução
faz com que o sprite mova 10 passos
na direção que ele está enfrentando atualmente, a partir de sua posição atual.
Inicialização: Nós geralmente queremos que o comportamento de um sprite seja o mesmo cada
vez que é executado. Isso exige que nós demos os valores iniciais para o estado do sprite, como
a sua posição e direção. As instruções colocadas no início de um script para que ele sempre vai
começar a correr no mesmo estado são chamados a inicialização do script.
Descrição escrita: Antes de começar a construir scripts a partir de blocos Scratch, uma descrição
do comportamento dos sprites deve ser escrito em português. Isso dá uma visão geral do
comportamento, sem entrar em detalhes, como as posições e direções reais. As descrições são
escritos como uma série de etapas que precisam ser executadas para atingir o comportamento
exigido dos sprites.
Comentários: Comentários explicam partes de programas escrito em português. Eles ajudam o
leitor do programa compreender o programa, mas não têm efeito sobre o funcionamento da
programação.
16
Instruções Scratch
Instruções de movimento: A maioria dos blocos que usamos até agora são usados para
instruções de posicionamento da paleta azul Motion:
• o sprite move uma série de passos em sua direção atual;
• o sprite se move para uma posição específica;
• o sprite transforma um número de graus sentido antihorário;
• o sprite transforma um número de graus para a direita;
• o sprite vira o rosto em uma direção específica;
• o sprite se move para uma posição específica em um
determinado período de tempo.
Estas são todas as instruções gerais e você tem que transformá-los em instruções específicas,
fornecendo valores como posições e direções.
Instruções de controle: Quando o primeiro bloco de um script é
que o script para começar a executar quando a bandeira verde é clicada.
, faz com
Técnicas Scratch
Blocos: Scripts são construídos usando blocos contendo instruções. A construção é realizada por
arrastar e soltar os blocos: arrastando os blocos usando o mouse e soltando-os em um local
apropriado.
Scripts de blocos: Blocos se encaixam para formar scripts. A saliência na parte inferior de um
bloco se encaixa em um entalhe no bloco abaixo.
Comentários: Os comentários podem ser anexados aos scripts clicando com o botão direito na
área de palco e selecionando adicionar comentários. O texto do comentário é escrito em caixa
amarela a luz que aparece.
17