Programação Com Scratch: Ensinando Programação Na Escola.

PAULO NUNES
Programação com
Ensinando programação na escola.

Sumário
Introdução ............................................................................................................................................................. 4
Por que programar? ........................................................................................................................................... 4
Capítulo 01 ............................................................................................................................................................ 6
O que eu posso fazer com o Scratch? ................................................................................................................. 8
Onde conseguir o Scratch................................................................................................................................... 8
Começando a usar o programa .......................................................................................................................... 9
Qual utilizar, versão instalada ou a versão online? ........................................................................................... 11
Fazendo parte da comunidade Scratch ............................................................................................................. 11
Entrando na sua área de usuário Scratch.......................................................................................................... 12
Minhas Coisas .................................................................................................................................................. 14
Conhecendo o ambiente de criação do Scratch ................................................................................................ 16
Exemplo 01 ...................................................................................................................................................... 19
Capítulo 02 .......................................................................................................................................................... 22
Entendendo os movimentos no Scratch ........................................................................................................... 24
Os primeiros deslocamentos pelo palco ........................................................................................................... 25
Movimentando-se em uma direção.................................................................................................................. 30
Para onde realmente aponta o ator?................................................................................................................ 30
Testando alguns movimentos pelo palco: caminhando..................................................................................... 31
Explorando outros movimentos ....................................................................................................................... 33
Um pouco mais sobre os atores ....................................................................................................................... 34
Usando diferentes trajes para um ator ............................................................................................................. 35
Criando ou modificando trajes para o ator ....................................................................................................... 36
Os scripts para os atores do projeto Pouso Lunar ............................................................................................. 39
Exemplo 02 ...................................................................................................................................................... 41
Capítulo 03 .......................................................................................................................................................... 49
Desenhos com o Scratch .................................................................................................................................. 50
Use a caneta, levante a caneta ......................................................................................................................... 50
Apagando tudo do palco .................................................................................................................................. 53
Canetas com diferentes cores .......................................................................................................................... 53
Mudando as cores pelo seu valor numérico ..................................................................................................... 54
Trabalhando com a tonalidade das cores ......................................................................................................... 57
Alterando a espessura do traço ........................................................................................................................ 58
Laços e repetições............................................................................................................................................ 61
Repetindo por uma quantidade determinada de vezes .................................................................................... 62
Desenhando círculos ........................................................................................................................................ 63
Laços encadeados ............................................................................................................................................ 64
Girando um quadrado ...................................................................................................................................... 65
Desenhando Triângulos.................................................................................................................................... 67
Armazenando informações: as variáveis........................................................................................................... 69
Variáveis e seus tipos ....................................................................................................................................... 70
Criando variáveis no Scratch ............................................................................................................................ 71
Repetindo as ações por um número determinado de vezes.............................................................................. 74
As variáveis internas do Scratch ....................................................................................................................... 75
Utilizando listas de variáveis ............................................................................................................................ 76
Meses e eventos importantes .......................................................................................................................... 76
Os comandos para listas................................................................................................................................... 78
Exemplo 03 ...................................................................................................................................................... 82
Capítulo 04 .......................................................................................................................................................... 84
Realizando operações matemática e lógicas..................................................................................................... 86
Como utilizar os blocos de operadores? ........................................................................................................... 86
Todos os operadores........................................................................................................................................ 88
Os sensores...................................................................................................................................................... 90
Decisões: controlando o que será executado ................................................................................................... 92
Expressões Booleanas ou Expressões Lógicas: tomando decisões ..................................................................... 93
Os blocos de decisões ...................................................................................................................................... 94
O bloco se ........................................................................................................................................................ 94
O bloco se/senão ............................................................................................................................................. 95
Se aninhados: encadeando várias estruturas se/senão ..................................................................................... 97
Exemplo 04 ...................................................................................................................................................... 99
Capítulo 05 ........................................................................................................................................................ 102
Cuidando da aparência de atores e pano de fundo ......................................................................................... 104
Atores, suas frases e pensamentos ................................................................................................................ 107
Controlando o tempo das falas dos atores ..................................................................................................... 110
Escondendo e mostrando os atores no palco ................................................................................................. 110
Utilizando diferentes camadas do palco ......................................................................................................... 111
Alterando o tamanho dos atores .................................................................................................................... 111
Aplicando efeitos gráficos aos atores ............................................................................................................. 112
Efeitos no Pano de fundo ............................................................................................................................... 113
Controlando as ações através da difusão de mensagens (Brodcasting) ........................................................... 114
E como disparar eventos enviando e recebendo mensagens? ........................................................................ 115
Exemplo 05 .................................................................................................................................................... 115
Capítulo 06 ........................................................................................................................................................ 120
Som: aplicando sons aos projetos .................................................................................................................. 122
Sons de fundo: tocando ao fundo da ação ...................................................................................................... 123
Manipulando instrumentos musicais.............................................................................................................. 123
Acelerando e desacelerando o ritmo .............................................................................................................. 125
Outros instrumentos, outros sons .................................................................................................................. 126
Dividir para conquistar: trabalhando com seus próprios blocos ...................................................................... 128
Criando o bloco quadrado .............................................................................................................................. 128
Definindo o novo bloco .................................................................................................................................. 130
Passando valores ao bloco ............................................................................................................................. 131
Exemplo 06 .................................................................................................................................................... 134
Referências ........................................................................................................................................................ 138
INTRODUÇÃO
POR QUE PROGRAMAR?
Como um computador funciona? O computador é uma máquina eletrônica que executa
instruções programadas, seguindo essas instruções uma a uma, fazendo exatamente o
que elas determinam, pelo tempo que for necessário. Esses conjuntos de instruções são
chamados “Programas de Computador”. Os programas de computador por sua vez, são
escritos através das “Linguagens de Programação”, códigos criados especialmente para
serem lidos e executados pelos computadores. Temos atualmente diversas linguagens
de programação: Java, C++, C#, Ruby, PHP e muitas outras.
Dominar uma ou várias dessas linguagens faz de você um “programador de

computadores” ou simplesmente “programador”. O programador escreve os programas que o computador irá ler
e executar para realizar as tarefas que lhes forem atribuídas: controlar o voo de uma nave espacial, ou de um avião
operar um robô em uma linha de montagem de uma grande fábrica; fazer um desenho de um prédio ou realizar o
cálculo de equações matemáticas de uma tarefa escolar, todas essas são coisas que um computador, munido do
programa correto, faz de maneira rápida e precisa.
Os programas de computador não são apenas um amontoado de instruções escritas aleatoriamente, de qualquer
forma, não mesmo! Para que os computadores executem as suas tarefas corretamente, os programas devem fazer
sentido, devem ser escritos de maneira lógica, sem erros, pois esses erros em computadores podem ser
catastróficos!
A “Lógica de Programação”, é usada como técnica de desenvolvimento dos programas permitindo que o
programador “pense” e “organize” corretamente as “ideias” que tem sobre o “problema” para o qual tem que
desenvolver uma solução utilizando o computador. Os programadores organizam suas ideias em estruturas
chamadas de “Algoritmos”, que na verdade são rascunhos do ainda poderá vir a ser um programa de computador.
Algoritmos não são utilizados apenas em computação. Eles na verdade, por serem “sequências de instruções
lógicas” escritas de forma natural, utilizando a linguagem humana, não dos computadores, podem ser utilizados
por qualquer pessoa para organizar e resolver a maioria dos problemas comuns. Muitos comparam os algoritmos
a “receitas de bolo”, pois são escritos da mesma forma, como um manual passo‐a‐passo, instrução por instrução,
do início ao fim. Assim sendo, qualquer um de posse de uma receita bem escrita, de forma lógica, poderá realizar
aquela tarefa.
Sim, mas porque programar é importante? Até aqui ainda não entendi...
Programar exercita o cérebro! Como vimos até então, programar envolve uma série
de conhecimentos, conhecimentos que levam você a exercitar sua criatividade,
concentração e lógica. Mesmo que você não se torne um programador e tenha outra
profissão qualquer, esses conhecimentos podem ser utilizados em qualquer outra
área, fazendo com que você tenha sempre uma visão mais clara das soluções que
deve usar para solucionar os problemas que vier a enfrentar.
Mas, essas linguagens de programação me parecem complicadas...
Não se preocupe, já existem linguagens de programação voltadas para crianças e jovens, linguagens que se utilizam
de uma estrutura de montagem simples, como os blocos de montar da empresa LEGO, onde você apenas une os
comandos que quer que o computador execute, sem necessariamente escrevê-los, o que torna a programação
muito mais simples de aprender.
4
Esse livro é voltado para o aprendizado de uma dessas linguagens de programação que
utilizam “blocos de comandos”, e não comandos escritos. Essa linguagem é o SCRATCH.
No Scratch os comandos são “conectados” uns aos outros, como as peças LEGO, para
então executar as tarefas desejadas.
O Scratch é uma criação do grupo Lifelong Kindergarten no Media Lab do Massachusetts

Institute of Technology, MIT, sendo fornecido gratuitamente aos usuários, que podem
baixá‐lo ou utilizá‐lo online através da Web. Devido a sua simplicidade, o Scratch é hoje
utilizado por milhares de pessoas no mundo inteiro, fazendo com que a experiência de
programar possa ser compartilhada entre todos, de modo que programar um
computador passe a ser “uma brincadeira de criança”, literalmente!
Professor Paulo Nunes.
5
CAPÍTULO 01
O que eu posso fazer com o Scratch?
Onde conseguir o Scratch.
Aderindo a comunidade Scratch.
Sua página pessoal do Scratch.
Conhecendo o Editor de Scripts.
Exemplo 01.
Capítulo 01 – Programando com o Scratch: criando programas na escola.
O que eu posso fazer com o Scratch?

O Scratch é uma linguagem de programação criada especialmente para crianças,
mas que todos podem usá-la e se divertir muito com ela. Por ser uma linguagem
voltada para crianças, ela é muito simples e fácil de ser ensinada e aprendida por
qualquer um, não importando a idade. Com ela podem ser criadas animações
diversas e jogos mais elaborados, com um ou mais níveis de ação.
Os professores e pais, podem por exemplo, criar diferentes aplicações com o

Scratch que envolvam as mais diversas disciplinas, como matemática, física,
literatura e outras, aplicando esse conteúdo junto com o ambiente do Scratch,
tornando assim o ensino dessas matérias ainda mais divertido.
Ao utilizar o Scratch você deixará de ser apenas um expectador, e passará a ser um “criador”, indo até aos limites
da sua imaginação. Experimente!
Onde conseguir o Scratch.

O Scratch é um programa gratuito, criado pelos cientistas e estudiosos do prestigioso Instituto Tecnológico de
Massachusetts, o MIT. Como a intenção desses cientistas era que todos pudessem aprender e compartilhar esse
aprendizado entre si, o Scratch pode ser copiado e instalado sem nenhum ônus para os usuários. O endereço oficial
do programa é:
https://scratch.mit.edu/
Que pode ser acessado de qualquer computador ou dispositivo com conexão com a Internet, dando acesso à página
inicial do programa:
Figura 1- A tela inicial da página oficial do Scratch na Web.

Começando a usar o programa

Para começar as suas criações com o Scratch basta acessar o site e clicar em uma das opções, “Criar” ou
“Experimente”. Nesse momento, a tela principal do programa é exibida, com todas as funções da área de trabalho
do Scratch, prontas para uso:
Figura 2 - A tela de trabalho do Scratch. Versão Online.
Dessa forma, o programa será utilizado diretamente através da Web, em sua versão online, sem que seja necessário
instalar nenhum aplicativo diretamente em seu computador. Um inconveniente para esse tipo de uso é que, sem
conexão com a Internet, sem possibilidade de uso do programa!
Para utilizar o Scratch sem depender de conexão com a Internet, precisamos copiar e instalar em nossos
computadores, a versão “desconectada” do programa. Com ela, o usuário poderá criar a vontade seus projetos,
gravar em seu computador e, quando desejar ou se conectar a Internet, enviar suas criações para sua página pessoal
do Scratch na Web. Para apanhar o editor desconectado do Scratch, role a tela da página oficial do programa até o
final e onde está escrito “Apoio”, clique na opção “Editor Desconectado”:
9
Figura 3 - Como baixar o editor para instalação em seu computador.
A versão atual do Scratch disponível até o fechamento desse material, é a 2.0, e nela basearemos todos os nossos
exemplos e projetos. O Scratch necessita de um programa adicional para funcionar perfeitamente, trata-se do
Adobe Air, da Adobe, e que também pode ser conseguido nessa mesma página mostrada na Figura 4.
Figura 4 - A versão mais atual do programa para instalação do Scratch.
Escolha o programa certo para o seu Sistema Operacional (Windows, Linux ou Mac) clicando no link indicado para
cada um deles. Você também terá acesso ao material de apoio, muito útil para quem está iniciando com o Scratch.
10
Figura 5 - Versões do programa Scratch e Adobe Air, e material de estudo do Scratch.
Qual utilizar, versão instalada ou a versão online?

Bom, essa é uma questão que diz mais a respeito do acesso que você tem a Internet do que
qualquer outra coisa. Praticamente não existem grandes diferenças entre uma e outra
versão, o que se faz com uma, se faz com a outra. Mas, se seu acesso a Internet no
momento que for trabalhar em suas criações não for dos melhores, opte por utilizar a
versão instalada em seu computador, pois isso assegurará que seu trabalho será realizado
de forma segura. Além do mais, quando se trabalha offline, os arquivos são gravados em
seu computador, localmente, podendo ser enviados para a sua página pessoal do Scratch
posteriormente, quando estiver conectado à Internet.
Neste material, nos concentraremos no uso da versão online.
Fazendo parte da comunidade Scratch

O slogan do Scratch é: “Imagine, Programe, Compartilhe! ”, significando exatamente que as produções de cada
usuário do programa, podem e devem ser compartilhadas com todos, criando dessa maneira uma rede mundial de
usuários. Cada produção compartilhada nessa comunidade, pode ser visualizada, estudada e remixada por outros,
aumentando ainda mais o conhecimento de cada sobre o programa, pois cada vez que uma criação é remixada,
novas ideias são anexadas a ela. Dessa forma, todos aprendem juntos, trocando ideias e conhecimento sobre o
programa e suas aplicações.
Para fazer parte dessa comunidade você precisa ter uma “Conta Scratch”, que lhe dará acesso a sua página pessoal
de usuário, onde seus projetos poderão ser gravados, visualizados e compartilhados com outros usuários, e ao
mesmo tempo, você também terá acesso aos projetos desses mesmos usuários, não só visualizando sua execução,
mas também como foram criados. Para iniciar a criação de uma conta Scratch, estando na página oficial do
programa, clique em “Aderir ao Scratch”, como mostrado na Figura 6.
11
Figura 6 - Aderir a comunidade do Scratch criando sua própria conta.
A tela para criação da sua conta é bastante simples, sendo composta de quatro passos, onde serão coletadas
informações como: nome de usuário, senha e um e-mail válido.
Figura 7 - Primeiro passo para criação da conta no Scratch: nome de usuário e senha.
Apenas clique no botão “Próximo” para dar sequência em seu cadastro até o final. Durante o processo, observe as
mensagens de acerto e erro que possam aparecer, e lembre-se de memorizar bem o seu nome de usuário Scratch
e sua senha, se quiser anotar em um lugar seguro, faça-o. O e-mail que você fornecer na inscrição, deve ser válido
pois será enviada uma mensagem automática para você, confirmando a sua inscrição, que será validada apenas
após essa confirmação.
Entrando na sua área de usuário Scratch

Terminado todo o processo de inscrição e confirmação de inscrição, você estará apto para usar o Scratch como
usuário. Clicando em “Entrar”, na página inicial do site, serão solicitados nome de usuário e sua senha, informações
fornecidas por você no processo de cadastro. Insira as informações e confirme.
12
Figura 8 - Pronto para entrar como usuário do Scratch.
Figura 9 - Iniciando o login em sua conta Scratch.
Com o login efetuado, o acesso a sua página pessoal do Scratch estará liberado, permitindo assim que você possa
dar início as suas criações, salvando-as e compartilhando-as com os demais usuários do Scratch ao redor do mundo.
13
Figura 10 - A sua página pessoal de projetos do Scratch.
Em sua página pessoal, além das suas próprias criações, você verá mensagens com novidades sobre o programa
Scratch, projetos que se destacam, mensagens de outros usuários para você e mais. Outro detalhe importante é
que você poderá configurar seu perfil, completando as informações pessoais e outros detalhes de sua conta Scratch.
Quando quiser sair de sua página pessoal do Scratch, encerrando a sua conexão, a opção “Sair” que está também
nesse menu, é a forma correta a ser utilizada.
Figura 11 - Informações de seu perfil e projetos pessoais do Scratch.
Note que no seu perfil pode ser anexada uma imagem sua, ou uma outra que queira. Não é obrigatório que a foto
seja colocada, mas ela ajudará os demais usuários a identifica-lo como usuário do Scratch.
Minhas Coisas
Suas produções ficam guardadas em uma pasta chamada “Minhas Coisas”, que pode ser acessada através do menu
do seu perfil, ou através do ícone “Minhas Criações”. Dessa maneira, todas as suas criações são organizadas em
um mesmo lugar, podendo ser acessadas facilmente.
14
Figura 12 - O ícone "Minhas Coisas" e a opção "Minhas Coisas".
Quando acessar a pasta “Minhas Coisas”, além de ver todas as suas criações em um só lugar, você poderá “Ver
interior” das mesmas, o que significa ver os scripts e comandos utilizados nelas e editá-las, poderá também criar
os “Estúdios”, que são na verdade pastas alternativas onde poderão ser guardadas várias criações especificamente
selecionadas por você. Por exemplo, um estúdio pode ter diferentes criações que abordem um mesmo tema ou
assunto.
Figura 13 - A página de suas criações, com todos os seus projetos gravados.
O botão “Ordenar por” organiza a visualização das suas criações por ordem alfabética, última modificação,
remixados, visualizações e preferidos, o que ajuda bastante quando se quer encontrar uma aplicação específica.
Um pequeno painel colocado à esquerda do painel “Minhas Criações”, mostra seus projetos, compartilhados e não
compartilhados, e seus estúdios existentes, tudo para que suas aplicações estejam sempre à mão.
15
Figura 14 - Ordenando e organizando suas criações.
Conhecendo o ambiente de criação do Scratch

A tela do “Editor de Scripts” do Scratch possui diversos elementos que devem ser conhecidos agora, para que você
saiba para o que e quando deve utilizá-los, pois é com eles que iremos criar nossas aplicações.
Figura 15 - A tela do Editor de Scripts do Scratch.
Por que “Editor de Scripts”? Porque os programas no Scratch, são realmente isso, pequenas porções de texto
contendo as instruções, comandos da linguagem, que devem ser lidas e executadas pelo computador. Então, o
grupo de criadores do Scratch, resolveu manter essa nomenclatura, Scripts, para os conjuntos de comandos que
escrevemos nele, e é essa mesma nomenclatura que iremos utilizar de agora em diante.
16
Bom, então, vejamos agora, cada um dos componentes do Editor de Scripts do Scratch, descrevendo cada um deles.
Barra de Menus. Ela apresenta os principais

comandos do editor, aqueles que você irá utilizar para
Figura 16 - Barra de Menus. trabalhar com o seu arquivo gravado. Permite
também, por exemplo, selecionar o idioma dos
comandos e funções do editor. Na opção “Dicas”, você terá acesso a muitas informações sobre como utilizar
corretamente o programa, uma excelente ajuda para quem está iniciando com o Scratch.
Ferramentas de Cursor. Quando selecionadas, agem sobre os elementos como atores e

comandos dentro editor. Selecione a “Tesoura”, por exemplo, e você poderá apagar um
ator ou script que não irá mais utilizar. Posicione o cursor do mouse sobre qualquer uma Figura 17- Ferramenta de
delas e seu nome e função serão apresentados. Para aprender mais sobre cada um dos Cursor.
comandos, basta selecionar a “Ajuda do Bloco”, o símbolo de interrogação e clicar sobre qualquer um deles, um
painel com textos e exemplos sobre o bloco selecionado será exibido.
Palco. Um dos principais elementos do editor, pois é nele que ocorrem

as ações comandadas pelos scripts que você utiliza para criar suas
aplicações no Scratch. No palco são montadas as “Cenas” com todos os
“Atores” e demais elementos que as comporão. Ao serem executados
os scripts, é no palco que vemos o seu resultado.
Lista de Atores. Espaço onde

ficam todos os atores
utilizados em uma cena. Ao
selecionar um dos atores
aqui, seus scripts são
exibidos no “Painel de Figura 19 - Lista de Atores.
Figura 18 - O Palco, centro das ações no editor.
Scripts”, podendo assim ser
editados. Também podemos visualizar as informações de cada ator,
como seu nome, sua direção e posição exata no palco.
Paleta de Blocos. Coleção de blocos de comandos, todos organizados por categoria, que
são utilizados na construção dos seus scripts. Selecione os blocos aqui e arraste-os, ligando
uns aos outros na ordem que devem ser executados, para a “Área de Scripts” ao lado. Cada
grupo de blocos possui uma cor que o identifica, tornando assim mais fácil a identificação
de cada um deles por sua função dentro de um script. São ao todo dez categorias de blocos
que podem ser interligados entre si.
Paleta de Fantasias. Permite que

você possa editar, modificando ou
criando do zero, as “Fantasias”, ou,
mais especificamente, os “Atores” e
suas possíveis caracterizações para
cada tomada em uma cena. Por
exemplo, um ator pode ter sua
silhueta modificada, sua expressão
facial, uma roupa, etc. Aqui você tem
um editor de imagens do próprio
Scratch, que lhe permitirá realizar
Figura 20 - Paleta Fantasias.
qualquer alteração em suas imagens,
Figura 21 - Paleta de
Blocos. inclusive criar novos elementos para uma cena.
17
Paleta de Sons. Muitos dos projetos que faremos com
o Scratch, utilizam som, na verdade, a maioria deles.
Aqui você irá criar seus próprios sons, inserir sons da
biblioteca do Scratch ou de arquivos externos, sendo
inclusive aplicar a esses mesmos alguns efeitos
sonoros. Os sons aplicados corretamente, dentro do
contexto de seu projeto, tornam suas criações ainda
mais interessante.
Figura 22 - Paleta de Sons.
Mochila. O nome já sugere a função desse elemento:

guardar, armazenar “coisas”, coisas que no caso são
scripts de um projeto que podem ser úteis em outro.
Você copia para mochila os scripts que desejar e dela
Figura 23 - Mochila. para o novo projeto poupando assim o seu tempo, pois
não será necessário criar novamente os mesmos scripts
já utilizados anteriormente. Esse recurso não existe na versão off-line do Scratch.
Área de Scripts. É para cá que os blocos devem ser arrastados e

ligados uns aos outros, seguindo a sequência lógica ideal para que
seu projeto funcione corretamente. Cada elemento, ator e pano de
fundo, que compõe uma aplicação, tem seu próprio script, podendo
até ser mais de um por elemento. É nesse espaço que montamos o
nosso programa com o Scratch. Os blocos, uma vez dispostos aqui,
podem ser testados e reorganizados da maneira que você quiser,
basta arrastá-los para dentro da área ou novamente para a Paleta
de Blocos, quando não forem mais úteis.
Figura 24 - Área de Scripts.
18
Painel de Pano de Fundo. Esse painel exibe uma miniatura do pano de fundo atual de seu projeto,
sendo que todo projeto tem pelo menos um pano de fundo. Você poderá visualizar os panos de
fundo utilizados em seu projeto através deste painel. O pano de fundo normalmente é uma imagem
estática utilizada para representar o cenário onde os atores irão agir.
Outras funções. São funções que tratam da sua

conta, exibindo opções do seu perfil no Scratch, e
dos próprios projetos, dando acesso à página
onde os mesmos ficam armazenados. O botão Figura 25 - Outras funções importantes.
“Compartilhar” executa o compartilhamento do
projeto atual com os demais membros da comunidade Scratch, deixando o mesmo visível a
Figura 26 - Painel
todos, e podendo também ser “Remixado” por outros. Já o botão “Ver página do projeto”, como
de Pano de Fundo.
o próprio diz, mostra a página do projeto contendo as informações sobre o mesmo, como dicas
de usabilidade (como fazer funcionar) e demais informações técnicas.
Exemplo 01
Como primeiro exemplo com o Scratch vamos começar com algo simples, apenas para que você possa se habituar
com o ambiente e com a funcionalidade de programa.
Nesse exemplo, modificaremos o pano de fundo, colocando uma imagem da biblioteca de imagens do próprio
Scratch. O gato, personagem que utilizamos, irá “pronunciar” algumas frases, se apresentando para o mundo. O
script para essa tarefa é o abaixo e deve ser adicionado ao próprio gato. Foram utilizados nesse exemplo blocos
das categorias, “Aparência”, “Eventos” e “Controle”.
Para aplicar o novo pano de fundo, clique na opção “Carregar pano de fundo da biblioteca”.
Figura 27 - Carregando uma imagem da biblioteca do Scratch.
Vamos usar a imagem “Blue Sky”.
19
Figura 28 - Biblioteca de panos de fundo e suas opções de imagens.
Seu palco com o novo pano de fundo aplicado será como esse:
Figura 29 - Cena montada com o pano de fundo Blue Sky aplicado.
Agora vamos “programar” o ator, gato, com os blocos que devem fazer parte de seu script específico. Selecione o
ator diretamente no palco ou na “Lista de Atores”.
Figura 30 - Seleção do ator para inserir scripts.
20
Agora, arraste os blocos correspondentes as ações que serão executadas pelo ator para a “Área de Scripts”. Eles
devem ser interligados na sequência lógica correta.
Figura 31 - Blocos de comandos formando o script para execução.
URL do exemplo na Web: https://scratch.mit.edu/projects/175399127/

Blocos utilizados no exemplo e suas funções:
Bloco Descrição do Bloco Categoria do Bloco

Inicia a execução de um script Eventos
quando for dado um clique no ícone
da “bandeira verde”.
Pausa a execução do script por um Controle
tempo estabelecido em segundos.
Mostra um texto dentro de um Aparência
“balão”, tipo diálogo em
quadrinhos, por um tempo
determinado. Você determina o
texto que será exibido e o tempo
que ele será exibido.
Interrompe a execução do script Controle
atual, de todos os scripts do
projeto, ou de todos os scripts
desse mesmo ator.
Tabela 1 - Blocos utilizados no Exemplo 01.
21
CAPÍTULO 02
O palco e suas dimensões.
Primeiros movimentos.
Aprendendo um pouco mais sobre os
atores.
Exemplo 02.
Capítulo 02 – Programando com o Scratch. Criando programas na escola.
Entendendo os movimentos no Scratch

Para darmos início as animações com o Scratch, alguns elementos precisam ser bem entendidos, e o primeiro deles
é o Palco. Como vimos anteriormente, é no palco que se desenvolve toda a ação de seus scripts, onde os atores são
colocados e interagem com outros atores, com o cenário e também com comandos externos.
O palco possui uma área com dimensões fixas, dimensão essa determinada por 480 pontos de largura e por 360
pontos de altura. Essa área é dividida como um Plano Cartesiano1, por dois eixos, “x”, da esquerda para direita, e
“y”, de baixo para cima, dividindo então a área do palco em quatro partes, ou, como no Plano Cartesiano, quatro
quadrantes. Então, dessa forma, para movermos um ator através do palco, basta indicarmos as coordenadas do
ponto para onde o mesmo será movido. Essas coordenadas são dadas através de valores para os eixos “x” e “y”,
podendo ser positivos ou negativos.
Figura 32 - As divisões do palco em coordenadas.
O centro do palco é determinado no ponto (x:0,y:0), sendo essa a posição inicial do gato quando iniciamos um
novo projeto. Na verdade, veremos como mover um ator para qualquer posição dentro do palco, bastando indicar
através do comando correto, o novo ponto inicial.
Os valores das coordenadas podem ser positivos ou negativos, dependendo da posição para a qual se quer mover
em “x” e “y”. Como o palco é dividido em quadrantes, temos a seguinte definição: os valores quando positivos,
move-se um ator para a direita e para cima, e, quando os valores são negativos, move-se para a esquerda e para
baixo. Seguindo-se essa definição por quadrantes, teríamos os seguintes valores para “x” e “y”
• Quando x > 0 e y > 0 - direita e acima – Quadrante 1

• Quando x < 0 e y > 0 - esquerda e acima – Quadrante 2
• Quando x < 0 e y < 0 - esquerda e abaixo – Quadrante 3
• Quando x > 0 e y < 0 – direita e abaixo – Quadrante 4
1
Plano cartesiano é um método criado pelo filósofo e matemático francês, René Descartes. Trata-se de dois eixos
perpendiculares que pertencem a um plano em comum. Descartes criou esse sistema de coordenadas para demostrar a
localização de alguns pontos no espaço. Fonte: Site Toda Matéria. https://www.todamateria.com.br/plano-cartesiano/
Acessado em 22/09/17.
Capítulo 02 – Programando com o Scratch. criando programas na escola.
Figura 33 - Divisão do palco em quadrantes.
Para descobrir uma posição dentro do palco, posicione o mouse em qualquer área dentro do mesmo. Os valores
de “x” e “y” serão mostrados na “Área de exibição do mouse”, mostrando os valores correspondentes a posição
do ponteiro do mouse.
Figura 34 - Posicione o ponteiro do mouse no palco e veja as coordenadas de "x" e "y".
Os primeiros deslocamentos pelo palco

Para deslocar um ator de um ponto a outro rapidamente, utilize o bloco “vá para x: n
y: n”. Arraste esse bloco para a área de scripts e insira os valores de “x” e “y”, as
Figura 35 - Bloco "vá para x: y:" coordenadas para onde o ator será movido. Esse é um movimento que podemos
chamar de “movimento absoluto”, pois o ator sai do ponto original e praticamente
reaparece no novo ponto.
Abra um novo projeto. Coloque como pano de fundo a imagem “x-y grid”, que é a que possui as coordenadas
indicadas. Agora, na paleta de scripts, clique na categoria “Movimento”. Arraste um bloco “vá para x: y:” e insira
o valor 100 para as coordenadas “x” e também para “y”.
Dê um duplo clique no bloco para vê-lo em execução. O ator, no caso o gato, sairá do ponto (0,0) e aparecerá
diretamente no novo ponto: (100,100). Para ter certeza da posição de um ator, selecione o mesmo no palco e
observe que sua posição será indicada no canto superior direito da área de scripts.
Figura 36 - Posição
do ator no palco.
25
Figura 37 - Deslocando o gato para uma nova posição no palco.
Também fazem parte do grupo de blocos de comando para movimento absoluto, os blocos “deslize por x seg até
x:n y:n”, . “mude x para n” e “mude y para n”.
Figura 38 - Outros comandos de movimento do tipo absoluto.
Vamos inserir um outro ator no palco para exemplificar melhor esses comandos. Para isso, vamos selecionar um
novo ator da própria biblioteca de imagens do Scratch. Clique na opção “Escolher ator da biblioteca”.
Figura 39 - Inserindo um novo ator no palco.
O novo personagem será um rato, então, na janela da biblioteca, selecione a categoria “Animais”, e clique na
imagem “Mouse1”.
26
Figura 40 - Selecionando o novo ator.
Com o “rato” posicionado no palco, vamos movê-lo, arrastando com o mouse mesmo, para uma posição acima e a
direita do gato, aproximadamente nas coordenadas (200,100).
Figura 41 - O novo ator, "Rato", em sua posição no palco.
Note que a figura do rato está um pouco grande, desproporcional ao gato, e mesmo, saindo da área do palco. Que
tal diminuir o tamanho desse ator? Na barra de “Ferramentas do cursor”, selecione a ferramenta “Reduzir”. Com
essa ferramenta selecionada, clique sobre o ator que deseja reduzir de tamanho, até que o mesmo fique na
dimensão ideal.
27
Figura 42 - Ferramenta para reduzir o tamanho do ator.
Figura 43 - O rato em tamanho reduzido.
Com o ator já na dimensão correta, selecione o ator “gato” e vamos adicionar o bloco “deslize por x seg até x:n
y:n”. Nas opções do bloco, não altere os segundos, insira para “x” e “y”, os mesmos valores da posição do rato.
Selecione o rato e verifique sua posição no palco.
Figura 44 - O bloco "deslize por...", no script do gato.
Para executar o movimento, dê um duplo clique no bloco “deslize por...”. Essa ação faz com que o bloco acionado
exiba uma borda em destaque, na cor amarela, mostrando que o mesmo está em execução.
Figura 45 - A borda na cor amarela mostra os blocos de script em execução.
O “gato” é movimentado de forma “suave”, realmente “deslizando” de sua posição atual para a nova posição
indicada no bloco pelas coordenadas de “x” e “y”. O tempo em segundos determina a velocidade do movimento:
quanto maior o tempo em segundos, mais lento o movimento.
28
Figura 46 - O gato "deslizando" pelo palco até a posição do rato.
Outra maneira de controlarmos os movimentos de um ator, é utilizando os blocos “mude x para...” e “mude y
para...”. Esses comandos alteram individualmente as coordenadas de “x” e de “y”. Para exemplificarmos o
funcionamento desses comandos, insira o script a seguir no ator “gato” e execute-o.
Figura 47 - Movimentando o gato até o rato, utilizando duas formas.
Analisando esse código, teremos a seguinte execução:
Bloco Descrição
Move o ator gato, para a posição (0,0) no centro do
palco.
Move, deslizando o ator gato, no tempo de 1 segundo,
até a posição (206,104), onde se encontra o rato.
Faz uma pausa de um segundo até a execução do
próximo script.
Muda o valor da coordenada “x” para 200, apenas de
“x”.
Muda o valor da coordenada “y” para 100, apenas de
“y”.
Tabela 2 - Descrevendo a movimentação do gato.

Outra maneira de movimentarmos um ator através do palco, é utilizando os comandos de “movimento relativo”.
Eles são chamados assim porque o deslocamento do ator para sua nova posição no palco, é feito sem que se saiba
a sua posição atual. Os comandos “mova n passos”, “gire n graus...” e “aponte para a direção n graus”, são
exemplos de comandos de movimento relativo, pois todos eles iniciam da posição atual do ator, sem que realmente
se saiba qual é ela.
29
Figura 48 - Comandos para execução de movimentos relativos.
Movimentando-se em uma direção

Antes de realizar o movimento de um ou mais atores, é importante que se determine para qual direção ele deverá
se movimentar, se para direita, para a esquerda, para cima ou para baixo. Apontar para uma determinada direção,
é como se a “frente” do ator esteja virada para o lado escolhido. O comando “aponte para a direção n graus” é o
responsável por esse direcionamento, que pode ser feito selecionando-se ou digitando o valor do ângulo no bloco.
Figura 50 - Modificando a direção em que o ator irá se deslocar.
0 (360)
315 (-45) 45 (-315)
270 (-90) 90 (-270)
135 (-225)
225 (-135)
180 (-180)
Figura 49 - As direções mais comuns para apontar um ator no palco.
Para onde realmente aponta o ator?

Quando utilizamos um comando para girar um ator, esse comando é executado sem que se tenha noção de que
lado é realmente a frente do ator, para que lado ele está apontando. E isso pode ocasionar alguns erros de direção
quando o giro é executado. Tomemos como exemplo os atores, Figura 51 e Figura 52, abaixo:
Figura 51 - Raposa aponta para a direita. Figura 52 - Foguete aponta para cima.
Se aplicarmos o comando para apontar a direita (90°) em ambas as imagens, nenhuma delas irá realmente girar.
Para o Scratch, a direção “direita 90°” se refere a posição original da fantasia quando no “Editor de desenhos”.
Perceba que o foguete apontará para baixo se aplicado o comando de girar a esquerda, colocando-o de cabeça para
baixo. Vejamos isso na prática:
30

Ambos os atores iniciam a execução, “apontando para a direita”, e quando executamos o comando para apontar a
esquerda, o que acontece é que eles ficam de ponta cabeça, em sentido totalmente errado do que se pretendia.
Quando desenhamos uma fantasia utilizando o “Editor de desenhos” do próprio Scratch, é possível especificar o
centro da imagem, o que
Testando alguns movimentos pelo palco: caminhando

Vejamos agora como simular a caminhada do nosso ator, o gato, por uma calçada. Trata-se de uma animação
simples, onde faremos uso de alguns comandos de movimento e outros que serão abordados apenas mais adiante,
portanto não se preocupe com eles ainda.
Inicie um no projeto e dê a ele o nome de “Caminhando pela calçada”. O nome de um projeto é digitado
diretamente na caixa de texto bem acima do palco.
Figura 53 - Dando um nome ao seu projeto.
Vamos aplicar o pano de fundo “brick wall1”, que tem o desenho de uma calçada cinza com uma parede de tijolos
vermelhos. Ele vai servir com o cenário para a nossa caminhada que o ator irá realizar. Esse pano de fundo faz parte
da biblioteca do próprio Scratch.
Figura 54 - Selecionando o pano de fundo "brick wall1" da biblioteca.
Quando a janela da biblioteca de pano de fundo aparecer, selecione a categoria “Exterior”, e então a figura “brick
wall1”.
31
Figura 55 - Selecionando a imagem "brick wall1".
Nesse projeto, o ator será mesmo o gato, que já vem inserido no cenário por padrão. Selecione-o e escreva o script
que deverá ser utilizado por ele.
Figura 56 - Script para fazer o gato caminhar.
Analisando esse código, teremos a seguinte execução:
Bloco Descrição
Executa o projeto quando a “bandeira verde” for
clicada.
Aponta o ator para a direção de 90 graus, vira o ator
para a direita.
Posiciona o ator nas coordenadas (-200,-50), o que no
cenário seria no início da calçada.
Repete vinte vezes a execução de todos os blocos de
comandos que estão em seu interior, criando o que
chamamos de “laço de repetição”.
32
Move o ator dez passos na direção apontada, a partir
da posição em que ele se encontra, movimento
relativo.
Muda a fantasia do ator, da atual para a de nome
“costume2”.
Aguarda um tempo em segundos até a execução do
próximo bloco de comando. Quanto menor o tempo
em segundos, mais rápida a espera.
Move o ator dez passos na direção apontada, a partir
da posição em que ele se encontra, movimento
relativo.
Muda a fantasia do ator, da atual para a de nome
“costume1”.
Aponta o ator para a direção de -90 graus, vira o ator
para a esquerda.
Tabela 3 - Descrição dos blocos no script "Caminhando na calçada".

Neste exemplo, você verá o gato “caminhar” da esquerda para a direita do palco, parando ao chegar na outra
extremidade e virando novamente para o lado oposto. Um bom desafio seria fazê-lo retornar, caminhando, ao
ponto de partida do lado esquerdo do palco.
Figura 57 - Faça o gato retornar caminhando ao outro lado novamente.
Explorando outros movimentos

Existem outros comandos que vão dar ainda mais flexibilidade aos seus atores na movimentação pelo palco. São
comandos como: “vá para...”, “aponte para...”, “se tocar na borda, volte” e “mude o estilo da rotação para...”.
33
Vejamos o que esses comandos fazem:
Bloco Descrição
Aponta o ator na direção do objeto selecionado, que
pode ser o ponteiro do mouse ou um outro ator.
Altera a forma que o ator gira.
Faz com que, ao tocar na borda do palco, o ator retorne

na direção contrária ao movimento inicial.
Desloca o ator na direção do objeto selecionado, que
pode ser o ponteiro do mouse ou um outro ator.
Tabela 4 - Outros comandos de movimento.
Abaixo seguem dois exemplos do uso desses comandos, acesse-os e veja o funcionamento de cada um deles com
a execução dos projetos. Aproveite e modifique os projetos implementando novas funcionalidades:

Um pouco mais sobre os atores
Os atores ou, como o Scratch denomina no oficial e muitas publicações utilizam, “Sprites2”, são fundamentalmente
os elementos de maior importância dentro de um projeto, pois toda a interação será realizada por e a partir deles.
Todos os atores, ao serem inseridos em seu projeto, ficam organizados no painel “Lista de atores”, onde podem
ser acessados e ter suas características configuradas.
Figura 58 - Lista de atores, ou "sprites", de um projeto.
Um ator pode ser carregado para seu projeto de várias formas: da própria biblioteca de atores do Scratch, criado
ou modificado através do “Editor de desenho”, carregado de uma pasta de seu computador, ou mesmo de uma
imagem capturada de sua webcam, caso possua uma instalada.
Figura 59 - Maneiras de inserir um novo ator em seu projeto.
Ao ser selecionado, um ator mostra em sua miniatura no painel “Lista de atores”, um pequeno ícone da letra “i”,
na cor azul, aparece no canto superior esquerdo da imagem. Esse é o ícone que dá acesso as configurações de cada
ator, onde podem ser modificadas informações como nome, direção e tipo de rotação que o mesmo terá.
2
Os projetos Scratch são baseados em objetos gráficos chamados sprites. Você pode modificar a aparência de um sprite,
dando-lhe um novo traje. Podemos fazê-lo parecer-se com uma pessoa, um objeto ou até mesmo um animal. Você pode usar
qualquer imagem como traje: podes desenhá-la no "Editor de Desenho", importar uma imagem do disco rígido, ou arrastar
uma imagem a partir de um site. Fonte: http://kids.sapo.pt/scratch/ajuda/guia_referencia Acessado em 02/10/2017.
34
Figura 60 - Acessando as configurações do ator.
Figura 61 - Caixa com as informações do ator.
Usando diferentes trajes para um ator

Os trajes para um ator, podem representar diferentes momentos dentro de uma mesma cena. Um personagem
pode aparentar sentimentos com feliz, triste, zangado, ou mesmo um objeto pode mudar de aspecto. Para alterar
um traje ou criar um novo, selecione o ator na “Lista de atores” e clique na aba “Fantasias”.
Figura 62 - As muitas fantasias de um ator.
35
Como com o próprio ator, as suas fantasias podem ser carregadas da biblioteca de imagens do Scratch, criadas a
partir do próprio “Editor de desenhos”, carregadas de um outro local específico, ou obtidas através de uma webcam
instalada em seu computador.
Figura 63 - Selecione a origem das fantasias que seu ator irá utilizar.
Figura 64 - Imagem capturada da câmera do dispositivo.
Criando ou modificando trajes para o ator

Vamos criar um novo projeto de um jogo. Este jogo vai se chamar “Pouso Lunar” e consiste em pousar uma
espaçonave sobre uma pequena plataforma no solo do planeta. Iremos utilizar dois atores inicialmente: a
“espaçonave”, que faz parte da biblioteca de atores, e a “base”, que será desenhada por você no “Editor de
desenhos”.
Figura 65 - Imagem da biblioteca de atores. Figura 66 - Imagem criada no editor de desenhos.
Observe que a imagem “Spaceship” possui duas fantasias: uma sem o “trem de pouso” e a outra com o “trem de
pouso”, respectivamente “spaceship-a” e “spaceship-b”.
36
Figura 67 - As duas fantasias do ator "Spaceship".
O que você irá fazer é criar mais três fantasias que irão representar a nave em propulsão, com os foguetes ligados.
São três, pois a propulsão será por baixo da espaçonave, como o motor principal, uma a esquerda e outra a direita.
Selecione inicialmente a fantasia “spaceship-a” e duplique-a, criando uma cópia exata da mesma. Clique com o
botão direito do mouse sobre a imagem a ser duplicada para que o menu de contexto seja exibido. Repita essa
duplicação mais duas vezes.
Figura 68 - Duplicando a imagem "spaceship-a". Figura 69 - Selecionando a imagem duplicada para os trabalhos.
Agora, basta desenhar, usando a sua criatividade, a imagem de uma chama de fogo, como realmente vemos nos
propulsores de espaçonaves verdadeiras.
37
As ferramentas que você vai utilizar para elaborar esse desenho, estão todas a sua disposição no próprio editor de
desenhos. São linhas, figuras geométricas básicas, pincéis e outros, que vão permitir a você criar os mais diferentes
desenhos em seus projetos.
Figura 70 - Algumas das ferramentas de desenho do editor de desenhos do Scratch.
Suas novas fantasias deverão se parecer com algo como essas da Figura 71 e Figura 72 abaixo:
Figura 71 - Fantasia do propulsor principal. Figura 72 - Fantasias dos propulsores da esquerda e da direita.
Agora que as fantasias estão prontas, vamos ao restante do projeto. Para o pano de fundo, a imagem que
utilizaremos será a imagem “space”.
Figura 73 - Selecionando o pano de fundo para o projeto.
38
Os scripts para os atores do projeto “Pouso lunar”

Seguem os scripts que devem ser escritos nos atores “Spaceship” e “Base”. Alguns dos comandos ainda não foram
estudados, por enquanto não vamos nos preocupar com eles, pois serão vistos mais adiante.
Selecione o ator “Spaceship” e digite os seguintes scripts. Ao todo esse ator possui três scripts:
Figura 74 – Script 1: para controle de navegação da espaçonave.
Figura 75 - Script 2: efeito de som para a aproximação da base. Figura 76 - Script 3: ativa o trem de pouso.
O script para o ator “Base” é bem mais simples, uma vez que ela não se move, apenas aparece em um local diferente
a cada nova inicialização do jogo.
39
Figura 77 - Script do ator base.
Vamos analisar cada comando utilizado nos scripts acima, para que você saiba o que cada um deles irá executar.
Os blocos de comandos exibidos na tabela, correspondem aos três scripts do ator “Espaçonave” e ao script do ator
“Base”:
Bloco Descrição
clicada.
Move o ator “Espaçonave” para essas coordenadas de
x e y.
Estrutura de repetição. Faz com que os blocos de
comandos em seu interior, sejam executados
ininterruptamente, por tempo indeterminado.
Adiciona um valor n a coordenada “y”, deslocando o
ator para uma nova posição relativa a que ele se
encontra. Um outro bloco “adicione n a x”, executa e
mesma função para a coordenada no eixo “x”.
Estrutura de seleção. Avalia se uma expressão lógica é
“verdadeira” ou “falsa”, e, dependendo do valor,
executa um ou outro grupo de comandos.
Operador relacional “ou”. Avalia duas expressões

lógicas, verificando se o resultado é “verdadeiro” ou
“falso”.
Sensor que verifica se uma determinada tecla foi
pressionada.
Muda a aparência do ator para uma outra fantasia
existente para ele. No caso desse exemplo, a mudança
seria para a fantasia “prop_direita”.
Operador relacional “menor que”. Avalia se uma
expressão lógica é menor que a outra, retornando
como resposta, “verdadeiro” ou “falso”.
Sensor que verifica a distância até um objeto, que pode
ser o ponteiro do mouse ou mesmo um outro ator.
Sensor que verifica se o ator ativo toca em outro objeto
da cor correspondente.
Toca um som da biblioteca de sons ou abre o gravador
para que um novo som seja gravado e executado.
Tabela 5 - Blocos de scripts para os atores do jogo "Pouso lunar"
Agora, para ver como realmente tudo isso funciona, visite o link do projeto e execute-o. Você poderá testar os
comandos de movimento e implementar as suas próprias ideias ao que já está feito.
40
Exemplo 02
O paredão! O jogo “Paredão”, é um jogo clássico do início dos anos 1980 que marcou toda a geração de gamers3
dessa época. O jogo consiste na disputa entre dois oponentes, que tentam evitar que a bola acerte o fundo de sua
quadra, o “paredão” por trás de cada jogador. Cada vez que a bola acertar essa parede, o adversário soma um
ponto, chegando a vitória quem fizer dez pontos primeiro.
Figura 78 - A tela inicial do jogo "Paredão".
Nesse projeto, teremos quatro atores, as duas “raquetes” ou jogadores, a bola e o letreiro que indica o final do
jogo.
Primeiro, vamos desenhar o campo de jogo. É um pano de fundo comum, nesse caso pintado na cor azul, e com as
listas laterais e linha central em amarelo. Use a ferramenta “Preencher com cor” para pintar o fundo na cor azul,
ou outra que quiser.
3
Significa “Jogadores”, em tradução literal do idioma inglês. É normalmente utilizada para designar jogadores de vídeo
games ou jogos de RPG.
41
Figura 79 - Preenchendo a quadra com a cor específica.
As linhas em amarelo foram feitas com a ferramenta “Retângulo”.
Figura 80 - Criando as linhas laterais e centrais da "quadra".
Para inserir os atores, use as imagens “Ball” e “Paddle”, ambas estão na biblioteca de atores do Scratch, e fazem
parte da categoria “Coisas”. Lembre-se que a figura “Paddle”, deve ser colocada no sentido vertical para ser
utilizada corretamente no jogo. Você pode modificar o posicionamento de uma imagem, selecionando-a e movendo
a “alça de rotação” até que a mesma esteja na posição desejada.
Figura 81 – Alça para rotação da figura.
42
Os scripts para este ator, que chamaremos a partir de agora de “Verde”, são os seguintes:
Figura 82 - Scripts para o ator "Verde", que fica no campo da direita.
Agora, para criar o outro ator, o oponente, clique no ator verde com o botão direito do mouse e selecione a opção
“Duplicar”. Um novo ator com as mesmas características do selecionado será criado. O que você terá que fazer
agora, é apenas modificar as setas utilizadas e os valores no script copiado.
Figura 83 - Duplicando o ator "Verde".
Os scripts para o ator “Vermelho” são os seguintes:
Figura 84 - Scripts para o ator "Vermelho", o oponente do outro lado da quadra.
Vamos criar os placares que apresentarão a pontuação de cada jogador. Para essa função, utilizaremos um
elemento denominado de “variável”, que será explicado detalhadamente posteriormente, pois seu uso é muito
comum dentro da programação. Selecione na aba “Scripts”, a categoria “Variáveis”. Serão utilizadas para este
projeto, duas variáveis, onde cada uma dela irá armazenar a pontuação de cada um dos atores.
43
Figura 85- Utilizando variáveis para a contagem de pontos.
Para criar uma variável, clique no botão “Criar uma variável”.
Figura 86 - Botão para criar uma variável.
Após o clique no botão, a caixa de diálogo “Nova variável”, com todas as suas opções, é exibida na tela. Dê um
nome para a variável, que nesse caso será “verde”. Selecione a opção “Para todos os atores” e confirme no botão
“OK”.
Figura 87 - Nome e demais opções para a nova variável que será criada.
Repita esta mesma operação para criar a outra variável, a “vermelho”, que irá conter a pontuação do jogador
“Vermelho”.
44
Figura 88 - As variáveis "verde" e "vermelho" já criadas e prontas para uso.
As “caixas de seleção” que aparecem marcadas ao lado de cada variável, servem para exibi-las e ocultá-las no
palco. Selecionadas, as variáveis serão mostradas, desmarcar as caixas esconde as variáveis no palco.
Figura 89 - Mostrando as variáveis no palco.
Um duplo clique sobre as variáveis apresentadas no palco, modifica a sua exibição, mostrando apenas os valores,
sem que seus nomes também sejam exibidos.
Figura 90 - Modificando a exibição das variáveis com um duplo clique.
45
Vamos ao script do ator “Bola”, o mais extenso pois possui além dos comandos de movimentação do ator, os
comandos para contagem e armazenagem dos pontos obtidos por cada um deles. Selecione o ator e escreva o
script a seguir:
Figura 91 - Script para o ator "Bola".
Agora, o fechamento: a aviso de “Final de Jogo!”. Crie um novo ator e dê a ele o nome de “Fim”. Crie uma nova
fantasia utilizando o “Editor de fantasias”. Utilize a ferramenta “Texto” e escreva a frase: “Final de Jogo!”.
Figura 92 - Ferramenta para textos.
Você pode selecionar a cor e o tipo de fonte que será utilizada em seu texto.
46
Figura 93 - Escolhendo a fonte e a cor do texto.
Agora, vamos ao script desse ator. Após escrever e ajustar o texto, selecione a aba “Scripts” e insira o grupo de
comandos a seguir:
Figura 94 - Script para o ator "Fim".
Pronto! O jogo está completo. Agora, chame um amigo e divirta-se jogando um clássico dos vídeos games!


Inicia a execução de um script
quando for dado um clique no
ícone da “bandeira verde”.
Eventos
Inicia a execução de um bloco
de script quando uma
determinada tecla for ativada.
Muda a direção do ator
apontando para a direção
indicada em graus.
Desloca o ator para a
coordenada indicada pelos
valores x e y. Movimento
Move o ator a quantidade de
passos indicada.
Muda a direção da trajetória do
movimento, caso o ator toque
nas bordas do palco.
47
Guarda o valor da última
coordenada de “x”.
Guarda o valor da última
coordenada de “y”.
Desvia a trajetória do ator n
graus para a direita.
Estrutura de repetição. Repete
indefinidamente os comandos
colocados em seu interior.
Estrutura de seleção. Executa
um grupo de comandos,
dependendo do valor, Controle
“verdadeiro” ou “falso”, de
uma expressão lógica.
Aguarda n segundos para a
execução do próximo bloco de
comandos.
Adiciona à variável indicada
(vermelho), o valor
determinado (1).
Variáveis
Variável “verde”.
Variável “vermelho”.
Sorteia um número
aleatoriamente entre os
valores inicial e final indicados.
Compara duas expressões
lógicas. Caso uma delas seja
“verdadeira”, a expressão será
verdadeira.
Maior que. Verifica entre dois
valores, se o segundo é maior Operadores
que o primeiro.
Menor que. Verifica entre dois
valores, se o segundo é menor
que o primeiro.
Soma dois valores.
Igual a. Verifica se dois valores
são iguais.
Verifica se o ator está
“tocando” em um objeto. O
objeto tocado pode ser outro Sensores
ator, o ponteiro do mouse ou
borda.
Tabela 6 - Blocos de scripts utilizados no Exemplo 02.
48
CAPÍTULO 03
Linhas, formas, cores e sombras.
Repetindo as ações.
Armazenando informações.
Exemplo 03.
Capítulo 03 – Programando com o Scratch. Criando programas na escola.
Desenhos com o Scratch

Até aqui, trabalhar com atores e suas diferentes fantasias, inserir ou criar imagens para os panos de fundo não foi
assim tão complicado. O que vamos fazer agora é incluir em nossos projetos, outro tipo de desenho, os desenhos
feitos com a “Caneta”. Cada ator possui a sua própria “caneta”, que normalmente fica inativa, até que seja ativada
para uso no palco.
Com a caneta, é possível realizar desenhos de linhas, formando diferentes figuras geométricas como círculos,
quadrados, retângulos e triângulos, cada um com uma gama de tamanhos, cores e sombras diferentes.
Vamos fazer uma pequena experiência. O script da Figura 95 abaixo, desenha um quadrado no palco, mas um
quadrado que não será realmente exibido, pois a caneta está desativada.
Figura 95- Desenhando um quadrado invisível.
Use a caneta, levante a caneta

Quando clicamos na bandeira, dando início a execução do script, não conseguimos perceber o desenho que está
sendo feito, pois a caneta do ator não foi ativada antes de começarmos a desenhar. Para que o desenho apareça
no palco, vamos utilizar o bloco “use a caneta”, da categoria de scripts “Caneta”, que diz para o ator ativar, usar, a
sua caneta.
Figura 96 - Utilizando a caneta para desenhar.
Agora, quando iniciamos o script, já com o bloco “use a caneta”, o desenho do quadrado é então criado no palco,
pois a caneta está ativada, e para qualquer movimentação realizada pelo ator, um rastro, ou linha, será desenhado,
até que a caneta seja novamente desativada.
Figura 97 - Quadrado desenhado.
Enquanto o uso da caneta não for desativado pelo comando “levante a caneta”, para qualquer movimento
realizado, o desenho continuará a ser feito. Modificamos o script anterior, da Figura 96, de forma que o ator se
movimente para outra direção, ainda com a caneta ativada. Execute o script com as modificações abaixo, e veja o
que acontece.
Figura 98 - Continuando a escrever, mesmo após o desenho ter terminado.
Os dois últimos blocos do script na Figura 98 acima, fazem com que o ator se movimente em outra direção, mas
como a caneta continua ativa, um outro traço será desenhado fora do quadrado.
51
Figura 99 - Caneta ainda ativa continuando o desenho.
Dessa forma, sempre que o seu desenho terminar, deverá ser utilizado o comando “levante a caneta”, impedindo
a continuidade do traço, encerrando o desenho.
Figura 100 - Levante a caneta para encerrar o desenho.
Figura 101 - Após o comando "levante a caneta", o desenho é encerrado.
Utilize o comando “levante a caneta”, quando, por exemplo, for criar vários desenhos no palco, ou uma sequência
deles, e não queira que os mesmos fiquem ligados através do traço da caneta.
52
Apagando tudo do palco.

Às vezes, quando vamos iniciar um desenho com a caneta, é interessante que o palco esteja “limpo”, sem nenhum
outro desenho anterior, ou, também, quando vamos criar uma série de desenhos intercalados no mesmo palco,
mas sem conexão entre eles. Para “limpar” o palco, apagando qualquer desenho realizado com a caneta, utilize o
comando “apague tudo”.
Figura 102 - O comando "apague tudo" no início do script para limpar o palco.
Canetas com diferentes cores

Que tal utilizar outras cores? Os desenhos podem ser criados em diferentes cores, tornando seu trabalho ainda
mais atraente e belo. Para que a cor do traço de sua caneta mude, utilize o comando “mude a cor da caneta para
cor” ou o comando “mude a cor da caneta para nº”. Ambos alteram a cor utilizada pela caneta, mas trabalhando
de forma diferente.
O comando “mude a cor da caneta para cor”, utiliza-se de uma “pipeta4” para pegar uma amostra da cor que se
deseja utilizar na caneta. Clique na área da cor existente no bloco para iniciar a captura da cor que deseja utilizar
com a caneta, e depois selecione a nova cor clicando sobre a mesma no objeto que a possui.
Figura 103 - Selecionando a nova cor através de uma amostra.
Para alterar a cor para uma nova, clique no quadrinho com a cor atual e, com o mouse, selecione a nova cor que
será utilizada pela caneta.
4
Pipeta: é o nome de um instrumento de medição e transferência rigorosa de volumes líquidos. Origem: Wikipedia, a
enciclopédia livre.
53
Executando o script do quadrado com algumas alterações, fazendo com que a cor de cada lado seja diferente,
poderíamos utilizar seguinte grupo de instruções:
Figura 104 - Quadrado com lados coloridos.
No script da Figura 104 acima, foi inserido um comando “mude a cor da caneta para cor”, antes do desenho de
cada um dos lados do quadrado, criando assim um quadrado com quatro lados de cores diferentes.
Figura 105 - Quadrado com lados de cores diferentes.
Mudando as cores pelo seu valor numérico

As cores no Scratch, também podem ser determinadas por um valor numérico, indo de 0 a 200, percorrendo assim
todo o Círculo Cromático 5.
5
É uma representação simplificada das cores percebidas pelo olho humano. Na maioria das vezes ele é representado fatiado
como uma pizza, com 12 pedaços, onde cada um deles é representado por uma cor e essas cores são dispostas de maneira a
formar um espectro perfeito. Fonte: Wikipedia, a enciclopédia livre. Disponível em
<https://pt.wikipedia.org/wiki/C%C3%ADrculo_crom%C3%A1tico >. Acessado em 26/10/2017.
54
Figura 106 - Combinações Harmônicas. Domínio público, https://commons.wikimedia.org/w/index.php?curid=35532107
Essa alteração nas cores através de seu número, é conseguida através do comando “mude a cor da caneta para
nº”, onde “nº” é um valor de 0 a 200.
Figura 107 - Alterando a cor através de seu valor numérico.
Vamos mudar o comando “mude a cor da caneta para cor”, utilizado anteriormente no script do quadrado, para o
comando “mude a cor da caneta para nº”, com os valores apresentados na Figura 108 abaixo:
Figura 108 - Usando os valores para representar as cores.
Esses valores podem ser representados diretamente por um número, como apresentado no exemplo da Figura 108
acima, por uma expressão numérica ou mesmo uma variável, o que flexibiliza ainda mais o uso das cores em seus
projetos. Execute o script novamente e observe o resultado para esses valores.
55
Quer variar a cor utilizada em um intervalo específico? Isso também é possível com o comando “adicione nº à cor
da caneta”. Esse comando incrementa o valor inicial de uma cor específica, somando a ele o valor indicado no bloco
da instrução.
Figura 109 - Adiciona o valor indicado à cor em uso.
Vamos modificar novamente nosso script do quadrado para testar o comando “adicione nº à cor da caneta”. Vamos
incrementar a cor inicial, “0”, em “5”, a cada lado do quadrado desenhado. Utilize o script a seguir:
Figura 110 - Alterando a cor incrementando seu valor inicial.
O resultado da execução desse script é apresentado na Figura 111:
Figura 111 - O resultado do script utilizando o incremento das cores.
56
Vejamos: a cor inicial utilizada no script, foi “0”, que representa o vermelho, cor do primeiro lado desenhado, o
superior. Na sequência de execução, é adicionado o valor “10” à cor, ou seja: 0+10, que resulta em 10, a cor laranja
utilizada no lado direito do quadrado, o segundo lado a ser desenhado. Continuando a execução, mais uma vez
acrescentamos “10” a cor atual, que era “10”. Temos agora então: 10+10, que resulta em 20, a cor laranja em um
tom mais claro que a anterior, utilizada agora no lado inferior, o terceiro a ser desenhado. E finalmente, acrescenta-
se mais “10” a cor atual, ficando 20+10, resultando em 30, a cor amarela utilizada no lado esquerdo do quadrado,
o último a ser desenhado. Note que, devido a pouca variação dos valores, apenas “10”, essas cores estão muito
próximas quando olhamos para elas no “Círculo Cromático”. Para maiores variações entre as cores, ou mesmo
cores totalmente diferentes, utilize valores não tão próximos.
Tabela 7 - Comparando as cores geradas e sua proximidade no Círculo Cromático.
Trabalhando com a tonalidade das cores

A tonalidade determina a variação de um tom ou matiz de uma cor. Quando dizemos por exemplo “verde claro” ou
“verde escuro”, estamos nos referindo a diferentes tonalidades da cor verde pura.
Para alterar a tonalidade de uma cor utilizada pela caneta no Scratch, o comando é o “mude a tonalidade da caneta
para nº”. Essa instrução alterará a tonalidade da cor atual da caneta.
Figura 112 - Modifica a tonalidade da cor atual da caneta.
Essa mesma tonalidade pode ser alterada gradativamente, pelo comando “adicione nº a tonalidade da caneta”.
Esse comando adiciona ao valor atual da tonalidade, o valor indicado no bloco da instrução.
Figura 113 - Instrução para adicionar um valor à tonalidade da cor em uso.
Um bom exemplo do uso desse comando, é o do script da Figura 114 abaixo. Execute-o algumas vezes,
seguidamente, e observe como as cores variam sua tonalidade, indo do mais claro para o mais escuro a cada vez
que o script é executado.
57
Figura 114 - Exemplo da mudança de tonalidade de uma cor.

Alterando a espessura do traço
Caneta com ponta grossa, ou com ponta fina? A “ponta”, ou melhor, o “traço” da caneta pode ser alterado de
forma a ser mais fino ou mais espesso, proporcionando assim que sejam criados desenhos e efeitos diferentes
quando se desenha com ela. São dois os comandos que lidam com a espessura do traço da caneta no Scratch:
“mude o tamanho da caneta para nº” e “adicione valor ao tamanho da caneta”.
Figura 115 - Comandos para modificar a espessura do traço da caneta.
Qual a diferença entre eles? O comando “mude o tamanho da caneta para nº”, ajusta a espessura do traço para
uma medida fixa para a espessura do traço, sendo essa a mesma do início ao fim da execução do script. O padrão
inicial para o traço é “1”, vamos alterar para um valor maior, “5” por exemplo, e vejamos o resultado:
58
Figura 116 - Script do quadrado com a mudança da espessura da linha para "5".
Figura 117 - Traço com espessura 1. Figura 118 - Traço com espessura 5.
Podemos ver na Figura 117 e Figura 118, a diferença entre a espessura do traço na alteração realizada pelo comando
“mude o tamanho da caneta para nº”, no script da Figura 116 acima.
O comando “adicione nº ao tamanho da caneta”, permite que sejam adicionados valores ao tamanho da caneta,
partindo do tamanho atual ajustado para a mesma, ou seja, podemos partir de um valor inicial e ir aumentando ou
diminuindo gradualmente esse valor. Faça a inserção do comando “adicione nº ao tamanho da caneta”, como
mostrado no script abaixo. Vamos adicionar o valor “5”, a cada vez que um dos lados vai ser desenhado:
59
Figura 119 - Aumentando em 5, para cada lado, a espessura dos lados do quadrado.
A espessura original do traço inicia em “1”, e vai aumentando de “5” a cada comando “adicione 5 ao tamanho da
caneta”, ficando então a seguinte soma: 1 + 5 + 5 + 5 + 5, totalizando a espessura total em “21”. O resultado do
quadrado desenhado será o seguinte:
Figura 120 - A espessura muda a cada lado.
O último lado desenhado, o de cor amarela, terá a espessura “21”, após todos os incrementos feitos.
60
Laços e repetições
Vamos observar o script que utilizamos até aqui para desenhar um quadrado:
Figura 121 - Desenho de um quadrado.
Os comandos que desenham o quadrado, se repetem por quatro vezes, tornado o código extenso, dificultando até
a compreensão do mesmo. E como então resolver isso? É simples! Vamos colocar tudo dentro de um “Laço de
Repetição!”.
Laços de repetição, estrutura de repetição, laço de iteração, ou simplesmente “laço”, são comandos fazem com
que outros comandos de uma linguagem de programação, no nosso caso o Scratch, possam ser executados
REPETIDAS VEZES dentro do seu script.
Por exemplo, no script do “Quadrado”, na Figura 121, temos três comandos que se repetem por pelo menos duas
vezes, são eles: “adicione nº à cor da caneta”, “mude a cor da caneta para nº”, e, os comandos que fazem os
movimentos para formar o quadrado propriamente dito: “mova nº passos” e “gire para direita nº graus”.
Figura 122 - Comandos que são repetidos várias vezes dentro do script.
61
Os blocos “mova 100 passos” e “gire à direita 90 graus” se repetem por quatro vezes, pois eles que desenham os
lados do quadrado. Já o bloco “adicione 5 ao tamanho da caneta”, muda a espessura de cada lado desenhado. Essa
repetição pode ser contornada, simplificando o código, com os comandos de repetição.
No Scratch, as estruturas de repetição fazem parte da categoria de blocos de “Controle”, sendo que cada um deles
efetua as repetições de maneira específica. São três as principais estruturas de repetição: “repita nº vezes”,
“sempre” e “repita até que verdade”.
Figura 123 - As três estruturas de repetição do Scratch.
Repetindo por uma quantidade determinada de vezes

Quantos lados possui um quadrado perfeito? Quatro, correto? Por isso repetimos, reescrevendo-os, por quatro
vezes os comandos “mova 100 passos” e “gire à direita 90 graus”. Mas, e se fizermos com que eles sejam apenas
repetidos por quatro vezes, mas escritos apenas uma vez? Pois é isso que o laço “repita nº vezes” faz, repetindo
quantas vezes forem determinadas, os comandos em seu interior. Mudemos o script do quadrado da seguinte
forma:
Figura 124 - Desenhando os lados do quadrado com o repita.
62
Nessa modificação, colocamos o bloco “repita 4 vezes”, e em seu interior, os comandos que devem ser repetidos
por quatro vezes, desenhando o quadrado. Note a quantidade de código que deixou de ser escrito, sem que o
quadrado deixasse de ser desenhado da mesma maneira:
Figura 125 - Código excedente que foi excluído com o uso do comando "repita".
Todos esses blocos foram substituídos pela estrutura abaixo, na Figura 126, tornando seu projeto muito mais leve.
Figura 126 - O bloco "repita nº vezes". Diminuindo a escrita do código do quadrado.
Desenhando círculos
Para desenhar um círculo no Scratch, devemos lembrar que trabalhamos com desenhos de “traços” ou, retas.
Assim, o que vamos ter que desenhar para se chegar a um círculo, serão pequenas retas (quase pontos!), que
colocadas lado a lado, em um ângulo de 360°, formarão o nosso desejado círculo.
Abra um novo projeto, dê a ele o nome de “Círculo” e insira o código abaixo:
Figura 127 - Um círculo.
63

Inicia a execução de um script Eventos
quando for dado um clique no ícone
da “bandeira verde”.
Apaga qualquer desenho anterior
do palco. Limpa o palco.
Caneta
Ativa o uso da caneta para dar início
ao desenho.
Laço de repetição. Repete 360 Controle
vezes os comandos em seu interior.
Movimenta o ator um passo na

direção apontada atual.
Movimento
Gira o ator 1 grau à direita da
posição atual.
Desativa o uso da caneta,
Caneta
encerrando o traço do desenho.
Tabela 8 - Blocos do exemplo "Círculo".
Laços encadeados
O encadeamento de laços, nada mais é do que o uso de dois ou mais laços de repetição um dentro do outro, sendo
executados em um mesmo script. Temos no script abaixo, um bom exemplo da utilização de laços encadeados é o
desenho da Figura 128 abaixo:
Figura 128 - Círculos encadeados.
Na Figura 128, temos 12 círculos desenhados a partir do mesmo centro, e se distanciando um do outro a cada
desenho, desenhando então a figura desejada. Para que isso fosse possível, utilizamos o seguinte script:
64
Figura 129 - Script para o desenho dos círculos encadeados.
Vamos reparar bem nos comandos de laço “repita 12 vezes” e “repita 360 vezes”, são eles que realizam o desenho
dos círculos. Note que o comando “repita 360 vezes”, está dentro do “repita 12 vezes”, ou seja, “repita 360 vezes”
será repetido 12 vezes, a quantidade de círculos que serão desenhados.
Os comandos “adicione 10 à cor da caneta” e “gire à direita 30 graus”, que também serão executados 12 vezes,
mudando a cor de cada círculo desenhado, e afastando um do outro para formar o desenho final.

Girando um quadrado
Vamos tentar o mesmo efeito dos círculos encadeados com um quadrado? O processo é o mesmo, só que agora
aplicado a um quadrado. Utilizaremos os laços encadeados, repetindo o exemplo anterior. Vamos aproveitar o
exemplo da Figura 129 e modificar apenas a parte que desenha o círculo, mudando os valores para que sejam
desenhados os quadrados. Observe as mudanças na Figura 130 abaixo:
65
Figura 130 - Criando uma nova figura com encadeamento de quadrados.
Analisando o script da Figura 130 acima, temos o seguinte: o comando “repita 12 vezes”, o laço mais externo,
determina a quantidade de quadrados que serão desenhados, no caso 12. O laço mais interno, o “repita 4 vezes”,
desenha um quadrado simples, com lados de tamanho 50. O bloco “gire à direita 30 graus”, afasta o próximo
quadrado do anterior, deixando um espaço entre cada quadrado desenhado. Ao executarmos o script, teremos a
seguinte imagem formada no palco:
Figura 131 - Quadrados encadeados. Mais um exemplo de laços de repetição.

Quer experimentar algo legal? Mude os valores dos blocos “repita 12 vezes”, laço mais externo, e “gire à direita 30
graus”, também do laço mais externo, de forma que a multiplicação deles resulte em 360, por exemplo 4 e 90, ou
5 e 72, e veja as novas figuras que são geradas.
66
Figura 132 – Modifique os valores para criar novas figuras.
Desenhando Triângulos
O procedimento é o mesmo utilizado no desenho do quadrado, o que vamos modificar é o número de lados e o
ângulo de direção. Para testarmos, crie um novo projeto de nome “Triângulo”, e escreva o script abaixo:
Figura 133 - Desenho de um triângulo.
No script, o comando “repita 3 vezes” é o laço que contém os comandos para desenhar os lados do triângulo. Os
comandos “mova 200 passos” e “gire à esquerda 120 graus”, desenham os lados do triângulo. “espere 1 seg”,
aguarda um segundo entre o desenho de um lado e outro, enquanto que “adicione 20 à a cor da caneta”, muda a
cor atual do traço. O desenho final é esse da Figura 134 baixo:
67
Figura 134 - Triângulo desenhado.

Agora, modifique o script do triângulo para que ele desenhe 12 novos triângulos encadeados. Para isso, lembre-se
do exemplo anterior, dos “Quadrados encadeados” e “Círculos encadeados”, pois o princípio é o mesmo.
Figura 135 - Criando triângulos entrelaçados.
Inserirmos um novo laço de repetição, “repita 12 vezes”, que irá fazer com que o laço mais interno, o “repita 3
vezes”, que desenha um triângulo, seja repetido por 12 vezes, criando o desenho a seguir:
Figura 136 - Figura dos triângulos entrelaçados.
68

Inicia a execução de um script
quando for dado um clique no Eventos
ícone da “bandeira verde”.
Muda a cor da caneta para o valor
zero, vermelho.
Apaga qualquer desenho anterior
do palco. Limpa o palco.
Caneta
Ativa o uso da caneta para dar
início ao desenho.
Muda a espessura do traço da
caneta para o valor 5 indicado.
Esconde a exibição do ator, Aparência
fazendo com que ele desapareça
do palco.
Ajusta a direção do movimento
do ator para o ângulo indicado,
90 graus. Movimento
Move o ator para a posição x=0 e
y=0, o centro do palco.
Repete os comandos em seu
interior por 12 vezes, um laço de
repetição.
Controle
Repete os comandos em seu
interior por 3 vezes, um laço de
repetição.
Move o ator 100 passos na
direção atual.
Gira o ator na direção de 120 Movimento
graus da posição atual em que ele
se encontra.
Adiciona o valor 20 ao valor atual
da cor da caneta, mudando a sua Caneta
cor.
Gira o ator na direção de 30 graus
da posição atual em que ele se Movimento
encontra.
Desativa o uso da caneta,
Caneta
encerrando o traço do desenho.
Tabela 9 - Comandos do exemplo "Triângulos encadeados".
Que tal um pequeno desafio para você? Baseado nos exemplos anteriores tente desenhar um octógono. Abuse dos
comandos vistos até aqui, e mude o tamanho, a espessura do traço e as cores do seu desenho.
Armazenando informações: as variáveis

Muitas vezes, vamos precisar guardar valores, um número, uma letra ou mesmo uma frase inteira, durante a
execução de nossos Scripts. Esses valores podem ser utilizados para incrementar o placar de um jogo, por exemplo,
ou um diálogo entre dois atores, ou até o valor de uma coordenada em um movimento de um ator em uma cena.
Para que possamos guardar esses valores, precisamos criar em nossos projetos um elemento especial que vai servir
como “container” ou “caixa” na memória do dispositivo. Esses “containers” ou “caixas” que você vai criar, recebem
69
a denominação técnica de “variáveis”. São chamados de variáveis porque os valores que ele armazena, podem ser
substituídos por outros durante a execução do script onde se encontram. Tomemos como exemplo disso o próprio
placar de um jogo, que vai se alterando a medida que pontos são obtidos, aumentando a contagem, ou, um placar
de “vidas”, que diminuem a cada vez que o jogador perde uma delas.
Figura 137 - Variável, uma "caixa" que vai armazenar valores durante a execução de um script.
Para utilizar uma variável, antes de mais nada devemos “cria-la”, um processo bastante simples no Scratch. Uma
variável, para que possamos utilizá-la, necessita de um nome. Esse nome é que vai identificar a variável dentro do
script, uma vez que podemos ter diversas variáveis em um mesmo script ou projeto. As linguagens de programação
mais comuns, possuem regras, algumas bem rígidas, com relação a criação de nomes, mas no Scratch isso ocorre
de maneira mais suave, sem tanta formalidade. As variáveis no Scratch podem ter nomes que iniciam por números
(326barco, por exemplo), ou mesmo conter espaços em branco no nome (resposta do ator1, por exemplo). Porém,
é interessante que tenhamos um mínimo de organização quando formos criar as nossas variáveis evitando:
• Nomes muito longos. Exemplo: minha pequena variável de apoio.

• Espaços em branco entre as palavras e letras. Exemplo: placar do jogo.
• Caracteres especiais como símbolos. Exemplo: &%pl.
• Uso de números como primeiro caractere do nome. Exemplo: 12vidas.
Outro detalhe importante é que, o Scratch diferencia maiúsculas e minúsculas, ele é o que chamamos em
programação de “Case Sensitive”, o que implica dizer que, variáveis “PLACAR” e “placar”, são diferentes, apesar do
mesmo nome. Por isso, evite criar variáveis que tenham o mesmo nome, mesmo que sejam escritas em maiúsculas
e minúsculas, para não causar confusão.
Para não errar, utilize a regra do “o simples é melhor”, usando sempre o bom senso quando for criar as suas
variáveis. Bons nomes de variáveis costumam ser pequenos e diretos, identificando inclusive o tipo de dado que
será armazenado pela variável em questão. Bons exemplos de nomes para variáveis podem ser: “Placar”, “Vidas”,
“Jogador1”, “PosicaoX” ou ainda, “tempo_final”.
Variáveis e seus tipos

Os computadores e seus programas manipulam diferentes tipos de dados: números, inteiros e decimais, negativos
e positivos, palavras, e expressões diversas. Esses dados é que vão ser manipulados dentro dos programas,
tornando-se assim informações úteis.
O Scratch, como em qualquer outra linguagem de programação, também possui os tipos de dados com os quais
são possíveis de trabalhar. Para facilitar o aprendizado e o uso, o Scratch possui apenas três tipos de dados básicos
que são:
• Booleano ou lógico: possui apenas dois valores: verdadeiro ou falso. Esse tipo deve ser utilizado quando
for necessário testar uma condição que, dependendo do resultado desse teste, irá determinar o caminho
a ser seguido pelo script, que comandos serão executados ou não.
70
• Numérico: trabalha apenas com valores numéricos, podendo estes ser inteiros ou decimais (o Scratch não
faz distinção entre eles), positivos ou negativos. Os diversos comandos de posicionamento e
movimentação de atores, por exemplo, trabalham basicamente com esse tipo de dado.
• Cadeia de caracteres ou “strings”: sequencias de caracteres que podem incluir letras (maiúsculas e
minúsculas), números de 0 a 9 e os outros caracteres possíveis em seu teclado (#, @, ! e outros). Usamos
esse tipo para representar um nome de pessoa ou lugar, por exemplo, uma senha ou código e tudo que
não for utilizado para cálculos.
É importante entender como funcionam os tipos de dados no Scratch, quais as operações que podemos realizar
com cada um deles, para que possamos compreender porque as ações acontecem da maneira que acontecem cada
vez que um script é executado. Todo o funcionamento e manipulação das variáveis se baseia nesses tipos de dados.
Criando variáveis no Scratch

Para criar uma variável no Scratch, acione a aba “Variáveis”, e clique no botão “Criar uma variável”. Vai ser exibida
uma caixa de diálogo, “Nova variável”, onde você irá digitar o nome da sua variável, e escolher se ela será “Para
todos os atores” ou “Para este ator apenas”.
Figura 138 - Criando uma nova variável. Figura 139 - Definindo o nome e o escopo da variável.
As opções “Para todos os atores” e “Para este ator apenas”, determinam o “escopo” das variáveis. O escopo é o
mesmo que abrangência, quem dentro do Script vai poder utilizar a variável, modificando seu valor. O escopo
funciona da seguinte maneira:
• “Para todos os atores”, significa que TODOS os atores do projeto vão poder manipular a variável criada,
independente do ator a qual ela pertença. Diz-se que o escopo nesse caso é GLOBAL.
• “Para este ator apenas”, restringe o uso da variável apenas pelo ator no qual ela foi criada, não podendo
ser alterada por outros atores. Esta forma não impede que outros atores possam ler o conteúdo da variável,
só não poderão modificar o seu valor. Diz-se que o escopo nesse caso é LOCAL.
Para exemplificar melhor as variáveis até aqui, vamos criar um pequeno projeto. Abra um novo projeto e dê a ele
o nome “Sobe e desce”.
Figura 140 - Projeto "Sobe e desce", trabalhando variáveis.
71
O exemplo irá mostrar uma “bola”, que pode ser uma imagem de uma bola qualquer da própria biblioteca do
Scratch, que irá quicar, subindo e descendo na tela, e um placar irá mostrar os 20 primeiros quiques da bola, quando
ela tocar a parte inferior do palco. Esse projeto terá apenas um ator, a bola.
Onde entra a variável no projeto? A variável irá armazenar a contagem dos quiques dados pela bola, a cada vez que
ela tocar o “chão”, a parte inferior do palco. Vamos criar uma variável de dar a ela o nome de “kiques”, assim
mesmo, com “k”. Assinale a opção para escopo global, “Para todos os atores”.
Ao ser criada uma variável, todos os outros comandos referentes ao uso de variáveis são exibidos na aba
“Variáveis”. Além da própria variável, “kiques”, veremos outros comandos como “mude kiques para 0”, “adicione
a kiques 1”, “mostre variável kiques” e “esconda a variável kiques”. Note que todos esses comandos se referem a
variável “kiques”, apenas por ser a única criada no momento, mas que se outras vierem a existir, poderemos utilizá-
las com os comandos da mesma forma que “kiques”.
Figura 141 - Criando a variável "kiques".
Podemos notar que a caixa de seleção da variável “kiques” está marcada, o que faz com que a variável seja exibida
no palco durante a execução do projeto:
Figura 142 - Marque para exibir a variável. Figura 143 - Variável sendo exibida no palco.
Você pode alterar a forma como a variável será exibida no palco, efetuando um duplo clique diretamente sobre a
caixa de exibição da variável que é mostrada no placo. As formas são essas:
Mostra a variável e seu conteúdo atual.
Mostra apenas o conteúdo da variável em letras

maiores, destacando a informação.
Mostra a variável e um controle deslizante, que
permite ajustar os valores da variável enquanto o script
estiver em execução.
Tabela 10 - Modos de exibição das variáveis.
72
Você também poderá acessar essas mesmas opções através do menu de contexto que é exibido quando dado um
clique com o botão direito do mouse sobre a exibição da variável no palco. O menu será exibido para que você
escolha a opção desejada.
Figura 144 - Mostrando o menu de contexto da variável "kiques".
A opção “definir cursor mín. e máx.”, quando acionada, mostra a caixa de diálogo “Valores do controle deslizante”,
onde você pode indicar o valor mínimo e o máximo para o controle deslizante quando este for utilizado.
Figura 145 - Valores mínimo e máximo para a variável.
Outro detalhe que vemos quando da exibição das varáveis, é que o seu escopo também é exibido juntamente com
o nome, mostrando assim a quem pertence aquela variável. Por exemplo, temos na Figura 146 abaixo, uma variável
chamada “conta” que pertence a um ator chamado “Gato”, o que significa que essa é uma variável apenas para
este ator, ou seja, é uma variável LOCAL.
Figura 146 - Variável criada como local, apenas para o ator "Gato".
Quando a variável é GLOBAL, “para todos os atores”, apenas o seu nome e conteúdo são exibidos, como no
exemplo a seguir, onde a variável “Cachorro” pode ser utilizada por qualquer ator no projeto.
Figura 147 - Na variável global, apenas o seu nome e seu conteúdo são mostrados.
Dando continuidade ao exemplo, selecione o ator “bola” e utilize o script abaixo nele:
73
Figura 148 - Script para a bola do projeto "Sobe e desce".
O comando “mude kiques para 0”, faz com que o valor inicial da variável seja “0”. Ele foi colocado logo no início do
script para garantir que a variável tenha esse valor. Dizemos que a variável está sendo “inicializada” com o valor
indicado.
Figura 149 - Inicializando a variável "kiques" com o valor "0".
Como o conteúdo de uma variável pode ser alterado durante a execução do script, a inicialização evita que ela
venha a apresentar um valor incorreto como conteúdo. Qualquer valor pode ser utilizado no comando “mude
variável para valor”, modificando o valor imediatamente para o indicado no comando.
Repetindo as ações por um número determinado de vezes

O objetivo do projeto, é contar os quiques que a bola dá no “chão”, parte inferior do palco, mas apenas até vinte
vezes. Para fazer com que a bola “suba” e “desça” por vinte vezes, vamos utilizar um laço de repetição com um
controle lógico, ou seja, ele possuirá um teste, que verificará se a quantidade de vezes desejada já foi alcançada. O
laço responsável por isso será o “repita até que teste lógico”, que também faz parte dos comandos de laço vistos
anteriormente.
Figura 150 - Laço de repetição "repita até que teste lógico". Figura 151 - Repete os comandos até que o valor seja alcançado.
A variável “kiques” é quem armazenará a contagem de quiques da bola no chão, sendo incrementada a cada vez
que isso acontecer.
Analisaremos agora, na Tabela 11 abaixo, cada um dos comandos utilizados no script:
Bloco Descrição
clicada.
Define o valor inicial da variável “kiques” com o valor
“0”. Está no início do script para que, sempre que o
script for executado, a contagem dos quiques da bola
iniciará em “0”.
74
Bloco Descrição
Move a bola para as coordenadas indicadas no bloco,
posicionando a bola para o início da execução.
Aqui temos o laço que controla os movimentos da bola
e a contagem dos quiques.
No laço “repita até que kiques = 20”, o teste verifica a
cada passada, se a variável “kiques” é igual a 20, valor
final determinado para a contagem. Temos dentro do
laço, os comandos “deslize por 0.5 seg até x: 0 y:160”
e “deslize por 0.5 seg até x: 0 y: -160”, que fazem com
que a bola suba e desça a cada passada do laço. O valor
da variável “kiques” é adicionado de 1 a cada passada
pelo comando “adicione a kiques 1”, até o total de 20,
quando o teste lógico do laço se torna “verdadeiro” e
o laço é encerrado.
Tabela 11 - Comandos para contar os quiques e movimentar a bola.

As variáveis internas do Scratch.
Além das variáveis que podemos criar, o Scratch já possui internamente algumas variáveis que podem ser utilizadas
em funções específicas dentro de seus projetos. São variáveis para posicionamento e movimentação de atores,
para controle de sons e outros detalhes dos atores e palco:
Variável Descrição
Informa a posição da coordenada “x” de um ator. Pode
ser exibida no palco.
Informa a posição da coordenada “y” de um ator. Pode
ser exibida no palco.
Mostra a direção atual de um ator, em qual sentido ele
está indo. Pode ser exibida no palco.
Informa o tamanho atual do ator em porcentagem,
relativo a dia dimensão original. Pode ser exibido no
palco.
Mostrar o número da fantasia atual do ator. Pode ser
exibido no palco.
Informa o nome do pano de fundo em uso. Pode ser
exibido no palco.
Armazena a última entrada de dados feita pelo teclado.
Quando uma pergunta é feita, o conteúdo da resposta
é armazenado em “resposta”. Pode ser exibido no
palco.
Captura a intensidade dos sons capturados pelo
microfone do computador. Os valores variam entre 1 e
100. Pode ser exibido no palco.
O Scratch utiliza um cronômetro interno e seu valor é
armazenado nesta variável. Pode ser exibido no palco.
Informa o número de dias decorridos desde o ano de
2000.
75
Variável Descrição
Armazena informações de data e hora, como dia da
semana, mês e ano atuais. Selecione a informação que
deseja trabalhar no menu suspenso. Pode ser exibido
no palco.
Armazena o nome do usuário logado no Scratch, o

dono da conta em uso no momento.
Detecta a quantidade de movimento ou direção que
está sendo aplicada na imagem de vídeo naquele
momento. Este valor pode ser atribuído ao ator em uso
ou palco. Utiliza a webcam instalada no computador
para funcionar. Pode ser exibido no palco.
Tabela 12 - Variáveis internas do Scratch.
Utilizando listas de variáveis

Até aqui, temos trabalhado com variáveis de forma individual, ou seja, uma variável é criada para armazenar apenas
um único valor, que pode ser um nome ou número isolado.
Mas, e se precisarmos armazenar vários valores, uma LISTA mesmo? Por exemplo: os dias da semana, os telefones
de seus amigos em sua agenda e a lista de compras do supermercado, podem ser representados em uma lista de
variáveis.
As listas são úteis exatamente porque permitem que um único objeto, a própria lista, armazene inúmeros dados
em seu interior, o que nos dá extrema flexibilidade para trabalhar esses dados.
Meses e eventos importantes

Vamos criar um pequeno exemplo para demonstrar como funcionam as listas de variáveis. Será solicitado ao
usuário um número qualquer, entre 1 e 12, e o ator “Gato” dirá o nome do mês correspondente. Em seguida, o
ator “Cão”, informa qual o evento importante no mês indicado pelo Gato, isso tudo envolvendo listas e mensagens
de broadcasting.
A lista com os meses

Vamos armazenar todos os meses do ano, os nomes de cada um deles em uma lista chamada “meses”. Para criar
uma lista, selecione o grupo de comandos “Variáveis”, na guia “Scripts”. Pressione em seguida o botão “Criar uma
lista”.
Figura 152 - Botão "Criar uma lista".
76
Na caixa de diálogo “Nova lista”, você irá escrever o nome para a lista, nesse caso, “meses”, e se ela será utilizada
por todos os atores ou apenas pelo ator selecionado no momento, definindo o “escopo” da lista dentro da
aplicação. Para este exemplo, selecione “Para todos os atores”.
Figura 153 - Definindo o nome e o escopo da lista.
Feito isso, será exibida a lista, vazia, no palco, e os comandos relacionados as ações que podem ser executadas com
uma lista, na guia “Variáveis”.
Figura 154 - A lista "meses" criada e ainda vazia.
Para inserir o conteúdo da lista, seus elementos, clique no ícone “+”. Ao clicar nesse ícone, uma caixa de diálogo
será ativada na lista, onde você digitará o conteúdo que deseja. Repita essa operação para cada um dos elementos
a serem inseridos na lista ou, ou, insira um primeiro elemento e utilize a tecla [Enter] para inserir os demais na
sequência.
O tamanho de uma lista depende do número de elementos que ela possui, e esse tamanho é indicado na borda
inferior da lista. Cada elemento assume uma posição dentro da lista, posição essa que é indicada por um número
real, inteiro e positivo, que cresce de um até “n”, onde “n” é a última posição na lista.
77
Figura 155 - Inserindo os elementos da lista "meses". Figura 156 - Lista e seus elementos.
Para eliminar um elemento qualquer da lista, clique no ícone “x” que aparece no canto direito da caixa de texto do
item da lista, removendo assim o elemento daquela posição.
Os comandos para listas

Com a criação de uma lista, os comandos para manipulação da mesma aparecem na categoria “Variáveis”. Com
esses comandos será possível realizar uma série de ações com os elementos de uma lista, como: remover um
elemento de uma posição da lista, inserir um novo elemento na lista, substituir um elemento da lista por outro, e
outras ações mais.
Bloco Descrição
Adiciona um novo item ao final da lista existente.
Exclui um ou mais itens de uma lista.
Substitui um item em uma posição da lista por outro.
Seleciona o item da lista indicado no bloco. É utilizado

com outros blocos de operadores.
Insere um novo conteúdo diretamente em uma
posição indicada da lista.
Verifica se a lista contém um elemento indicado. Seu
retorno é um valor lógico “verdadeiro” ou “falso”.
Retorna o tamanho da lista, a quantidade de elementos
que ela possui.
Não exibe a lista no palco.
Exibe a lista no palco.
Tabela 13 - Blocos de comandos específicos para listas.
Agora que conhecemos os comandos de lista e a lista “meses” foi criada, vamos criar uma outra chamada
“eventos”, onde serão guardados os eventos importantes para cada um dos meses do ano. Insira um único evento
78
para cada posição da lista, em um total de doze. Por exemplo, na posição 12 da lista, correspondente ao mês de
dezembro, coloque “Comemoração do Natal”, e assim por diante para cada um dos meses.
Figura 157 - A lista "eventos" e seus elementos.
Os atores
Teremos dois atores em nosso exemplo: o gato e o cão. Os dois vão interagir trocando mensagens entre si. Vamos
escrever os scripts que serão utilizados por cada um deles e que comporão a “conversa” entre eles.
Figura 158 - O cão e o gato, os atores.
O Script do Gato
Este script inicia o aplicativo solicitando um valor ao usuário e, após o recebimento do valor, mostra o mês
correspondente ao mesmo.
79
Figura 159 - O script utilizado pelo ator gato.
Ao ser executado, este script deverá mostrar a sequência de telas a seguir:
Figura 160 - Script do ator gato solicitando um número.
A segunda tela mostra o mês correspondente ao número do mês digitado pelo usuário:
Figura 161 - Ainda o script do gato mostrando o mês correspondente ao número.
80
A resposta do cão é dada de acordo com a posição do mês dentro da lista, onde cada um dos meses do ano foi
escrito seguindo a sequência correta do calendário comum, assim, se digitarmos o número 6, o mês será “junho”,
pois este valor foi inserido na posição 6 da lista “meses”. Quem controla essa rotina é o bloco “SE” abaixo:
Figura 162 - Bloco "SE" para controle da exibição do nome do mês.
Na entrada do bloco, verificamos se o número digitado dentro da faixa de dados da lista, ou seja, se é um número
entre 1 e 12. Caso o teste lógico retorne “verdadeiro”, será enviada a “mensagem 2” a todos os atores existentes.
Em sendo o teste “falso”, a resposta será o mês correspondente ao número, e a “mensagem 1” será enviada aos
atores.
Figura 163 - Resposta do gato para valores fora da faixa de valores da lista.
O script do Cão
Ele irá responder ao cão dependendo da “mensagem” enviada através do script do gato.
Figura 164 - Blocos de eventos do script do cão.
81
São utilizados dois eventos para receber as mensagens enviadas, determinando que resposta será dada pelo ator
cão. Caso a mensagem enviada seja a “mensagem 1”, será exibida uma resposta que coincida com o número
fornecido para o mês na lista “eventos”.
Visite a página do projeto e veja como funcionam as listas no Scratch.

Exemplo 03
Vamos construir uma tabuada? Este é um exemplo bastante simples até. Faremos com que o nosso amigo Gato
diga a tabuada de multiplicação de um número qualquer fornecido pelo usuário. Você entra com um número e ele
o multiplicará com todos os números de 1 até 10, um por um. Crie um novo projeto denominado de “Tabuada de
Multiplicar”, selecione o ator “Gato” e escreva o script abaixo para ele:
Figura 165 - Script para a tabuada de multiplicar.
Analisando os blocos de comandos utilizados no exemplo, temos o seguinte:
Bloco Descrição
Executa o projeto quando
a “bandeira verde” for
clicada.
Inicializamos a variável
“numero” com o valor 1.
82
Bloco Descrição
O sensor “pergunte...”
para receber o número
para o qual será
elaborada a tabuada.
Aqui temos um bloco
“repita 10 vezes”, que vai
multiplicar o número
digitado pelo usuário, de
1 até 10. A saída,
resposta, é dada pelos
blocos “diga...”, onde o
primeiro mostra o
número digitado, a
palavra “vezes” e o valor
da variável “número”,
que irá de 1 até 10. O
segundo bloco “diga...”,
mostra a multiplicação da
variável “resposta” por
“numero”. O bloco
“adicione a número 1”,
faz com que o valor da
variável número vá de 1
até 10, incrementando
de 1 em 1.
Tabela 14 - Blocos de comandos para a Tabuada.
Figura 166 - Veja o Gato dizendo a tabuada do número que você pedir.
83
CAPÍTULO 04
Operadores: matemática e lógica.
Percebendo o ambiente: sensores.
Tomando decisões: estruturas de seleção.
Exemplo 04.
Capítulo 04 - Programando com o Scratch. criando programas na escola.
Realizando operações matemáticas e lógicas

Por várias vezes, muitas vezes até, temos que executar algum tipo de operação matemática ou realizar algum teste
com os valores que estão sendo utilizados em nossos projetos. É uma posição de coordenada que temos que alterar,
ou são dois valores que temos que saber qual o maior, operações corriqueiras até dentro de um programa de
computador. Para que esse tipo de operação possa ser executada, vamos fazer uso dos operadores, um grupo de
blocos especialmente desenhados para esse fim.
Figura 167 - Os operadores do Scratch.
Como utilizar os blocos de operadores?

Os blocos “Operadores” são inseridos como complementos de outros blocos, realizando operações matemáticas
ou lógicas, retornando o resultado de uma soma, por exemplo, ou os valores “verdadeiro” ou “falso”, no caso de
expressões lógicas.
Vejamos um exemplo onde o nosso ator Gato, “diz” a soma de dois números digitados por você. Inicie um novo
projeto, crie duas variáveis, “num1” e “num2”, e escreva o script abaixo para o ator gato:
Figura 168 - Script utilizado pelo ator para somar dois números.
Execute o projeto clicando na “bandeira verde”, forneça o primeiro número e tecle [Enter], repetindo o mesmo
procedimento para o segundo, e veja a resposta no final.
Figura 169 - Executando o script.
Analisando o script e seus blocos:
Bloco Descrição
clicada.
Bloco “mude variável para valor” vai definir o valor da
variável indicada. No caso do exemplo, “num1” e
“num2” terão seus valores iniciais ajustados de início,
para o valor “0”. Chamamos esse procedimento de
“inicialização de variáveis”.
Bloco sensor “Pergunte texto apresentado e espere a
resposta” faz com que um balão, do tipo utilizado em
diálogos de revistas em quadrinhos, apareça com o
texto digitado, como se o ator estivesse “falando”.
Além disso, uma caixa para resposta é apresentada,
87
Bloco Descrição
aguardando que seja digitada uma resposta ao que foi
perguntado no balão. O valor dessa resposta é
armazenado na variável interna “resposta”, podendo
ser manipulado posteriormente pelo script.
Esse bloco está armazenando o valor da variável
“resposta”, o primeiro número digitado pelo usuário,
na variável “num1”.
Este bloco está sendo utilizado aqui para receber o
segundo número digitado pelo usuário, armazenando
o valor na variável interna “resposta”. Será também
exibido um balão com o texto “Qual o segundo
número?”, acompanhado de uma outra caixa para
que o usuário digite o valor.
Agora, o valor de “resposta”, o valor do segundo
número digitado, será atribuído à variável “num2”.
Aqui será exibido um balão com a mensagem “A soma
desses números é...” durante 2 segundos.
Nesse bloco “diga expressão por valor segundos”, foi
montada a soma dos números com o operador
“soma” e as variáveis “num1” e “num2”, mostrando o
resultado da soma dessas variáveis na tela.
A resposta, soma dos números, é dada através da
montagem dos blocos “diga expressão por valor
segundos”, “operador soma” e as variáveis. Coloca-se
o bloco do operador soma no bloco “diga...”, e as
variáveis no bloco operador.
Tabela 15 - Detalhando o script da soma de números.

Todos os operadores
Vamos conhecer os outros operadores que fazem parte do Scratch. Com eles você irá criar as mais diversas
expressões, matemática e lógicas, necessárias aos seus projetos.
Operador Descrição
Soma. Realiza a adição entre dois valores, a soma de
dois números ou variáveis.
Subtração. Realiza a subtração entre dois valores,
diminui o valor de um número ou expressão de outro.
Multiplicação. Realiza a multiplicação entre dois
valores.
Divisão. Realiza a divisão entre dois valores.
Resto de. Informa o resto da divisão do primeiro
número pelo segundo. Por exemplo, o resto da divisão
de 5 por 2, é 1.
Arredondamento de. Informa o número inteiro mais
próximo do decimal informado. Por exemplo,
arredondamento de 5,8, resulta em 6.
Funções. Calcula diversas funções, incluindo
trigonométricas. Selecione a função que deseja no
menu suspenso.
88
Opções do bloco “Funções”.
Aleatório. Gera um número aleatório entre o valor

inicial e final determinados.
Menor que. Compara dois valores e retorna
“verdadeiro” caso o primeiro número seja menor que
o segundo.
Igual a. Comprara dois valores e retorna “verdadeiro”
caso os valores sejam iguais.
Maior que. Compara dois valores e retorna
“verdadeiro” caso o primeiro seja maior que o
segundo.
Conector lógico “e”. Retorna o valor “verdadeiro” se
ambas as expressões lógicas testadas, forem
verdadeiras.
Conector lógico “ou”. Retorna o valor “verdadeiro” se
qualquer uma das expressões lógicas testadas, for
verdadeira. Retorna “falso” apenas quando ambas
forem falsas.
Negação. Inverte o valor lógico de uma expressão
lógica, retornando “verdadeiro” quando a expressão
for “falsa”, e “falso” quando a expressão for
“verdadeira”.
Conector de strings. Junta, une duas cadeias de
caracteres, strings, em uma única.
Caractere da posição. Retorna um caractere que esteja
na posição indicada. No exemplo do bloco, o retorno
será a letra “w”, pois ela é quem está na posição 1 da
string.
Tamanho da string. Retorna um número que
representa o tamanho, quantidade de caracteres, da
string indicada. No exemplo, o retorno seria o valor 5.
Tabela 16 - Blocos de operadores.
89
Os sensores
Em um jogo de futebol eletrônico, como detectar se a bola entrou no gol? Em outro, como verificar se uma
determinada tecla foi acionada? Qual a posição de um determinado ator no palco? Essas são perguntas e ações que
necessitam ser tratadas em um programa, pois delas podem depender outras ações seguintes, dando sequência
correta aos procedimentos que devem ser tomados.
Para analisar algumas ações dentro de um script do Scratch temos os comandos de bloco da categoria “Sensores”,
que permitem “analisar” diferentes estados dentro de um script em execução. Na sua maioria, são utilizados em
conjunto com os blocos de “Controle” e “Operadores”, permitindo que ações sejam executadas dependendo de
seus valores ou condições.
Vamos conhecer os sensores agora:
Tocando em. Retorna “verdadeiro” caso o ator toque
em outro ator, em uma das bordas do palco ou no
ponteiro do mouse.
Tocando na cor. Retorna “verdadeiro” caso o ator
toque na cor especificada no bloco. Para escolher uma
cor, obtenha primeiro a pipeta, clicando no quadrado.
Use a pipeta para clicar na cor que deseja. A cor
escolhida aparecerá no quadrado.
A cor está tocando na cor. Retorna “verdadeiro” se a
primeira cor do bloco está tocando na segunda. A
primeira cor do bloco pertence ao ator, a segunda ao
ambiente ou outro ator. Para escolher uma cor,
obtenha primeiro a pipeta, clicando no quadrado. Use
a pipeta para clicar na cor que deseja. A cor escolhida
aparecerá no quadrado.
Distância até. Informa a distância do ator atual até um
outro ator ou até o ponteiro do mouse, escolha o
objeto no menu suspenso do próprio bloco.
Pergunte texto e espere a resposta. Este bloco mostra
o texto digitado pelo usuário em um balão, do tipo
utilizado em revistas em quadrinhos, e aguarda, em
uma caixa de texto apresentada, por uma resposta do
usuário. A resposta dada é então armazenada na
variável interna “resposta”, podendo assim ser
manipulada dentro do script.
Resposta. Variável onde é armazenada a resposta dada
ao bloco “pergunte texto e espere a resposta”. Seu
conteúdo pode ser armazenado e manipulado através
de outros comandos e variáveis.
Tecla tecla pressionada? Retorna “verdadeiro” se a
tecla selecionada estiver sendo pressionada. Seu uso é
indicado para verificar se determinada tecla é
pressionada continuamente durante uma ação. No
menu do bloco podem ser escolhidas as teclas, setas,
letras, números ou qualquer outra tecla, que serão
utilizadas.
Mouse pressionado? Retorna “verdadeiro” se o botão
do mouse for pressionado em qualquer parte da tela.
90
Posição x do mouse. Armazena a posição da
coordenada “x” do ponteiro do mouse.
Posição y do mouse. Armazena a posição da
coordenada “y” do ponteiro do mouse.
Ruído. Variável interna que armazena a intensidade
dos sons capturados pelo microfone do computador.
Essa intensidade é um valor entre 1 e 100. O microfone
deve estar ligado para que o comando funcione.
Movimento/direção do vídeo em este ator/palco.
Detecta a quantidade de movimento ou direção que
está sendo aplicada na imagem de vídeo em execução
no momento. É necessária uma webcam conectada e
funcionando para que este recurso seja utilizado.
Utilize esse recurso quando em seu projeto, o usuário
for interagir diretamente com o ambiente, palco ou
atores.
Vídeo estado. Liga ou desliga a webcam conectada ao
computador. O “estado” pode ser: ligado, desligado ou
ligado e espelhado, onde a imagem é capturada é
invertida na exibição.
Mude a transparência do vídeo para valor %. Faz com

que a imagem do vídeo seja mais clara ou mais escura.
Os valores devem estar entre 0 e 100, onde, valores
mais baixos, imagem mais escura e, valores mais altos,
imagem mais clara.
Cronômetro. Variável interna do Scratch que ativa um
cronômetro em segundos.
Zere o cronômetro. Zera o cronômetro, reiniciando a
contagem do tempo.
Atributo de ator/palco. Informa o atributo,
característica de um ator ou do palco. Podem ser
escolhidos diversos atributos no menu suspenso do
bloco.
item atual. Armazena informações de data e hora, de

acordo com o “item” indicado pelo bloco. Selecione o
“item” desejado no menu suspenso do bloco.
91
Número de dias desde 2000. Armazena o número de
dias decorridos desde o ano 2000 até o dia atual.
Nome de usuário. Armazena o nome do usuário
“ativo” que está utilizando o projeto no momento.
Tabela 17 - Blocos de sensores.
Decisões: controlando o que será executado

Durante toda a nossa vida somos impelidos a tomar decisões. Todos os dias, da hora em que acordamos até o
momento em que dormimos, centenas de decisões permeiam nossas ações. Comer ou tomar banho? Vestir calça
jeans ou social? Dormir cedo ou assistir mais um capítulo da série? Veja que são decisões aparentemente simples,
mas que determinam quais ações serão tomadas, dependendo sempre do que escolhemos.
Em um programa de computador, as decisões que são tomadas levam a diferentes ações dentro da lógica que
implementamos, fazendo com que esse ou aquele comando seja executado. No Scratch temos os comandos da
categoria “Controle” que fazem o controle do fluxo de comandos que serão executados, dependendo de um ou
mais testes lógicos avaliados.
Figura 170 - Blocos da guia "Controle".
Alguns dos comandos de “Controle” já foram utilizados por nós em exemplos aqui mesmo, o que faremos a partir
de agora será estuda-los com mais profundidade, vendo como realmente trabalham.
92
Expressões Booleanas ou Expressões Lógicas: tomando decisões

As Expressões Booleanas6 ou Expressões Lógicas são estruturas de suma importância dentro da programação de
computadores. É através dessas expressões que controlamos o fluxo de ação das instruções que devem ser
tomadas.
No Scratch, essas expressões são criadas utilizando-se os blocos dos Operadores Relacionais, “menor que”, “maior
que” e “igual”, vistos anteriormente na Tabela 16. Uma expressão booleana ou lógica vai sempre retornar um valor
que pode ser, “verdadeiro” ou “falso”. Em um novo projeto, digite os scripts abaixo e os execute:
Figura 171 - Avaliando valores numéricos com os Operadores Relacionais.
Quais as respostas obtidas? Temos três expressões lógicas, comparando diferentes valores NUMÉRICOS, e os
resultados dessas avaliações serão exatamente:
Expressão Resultado
“true” ou “verdadeiro”, pois o valor 3 É MENOR que 4.
“false” ou “falso”, pois o valor 1 NÃO É MAIOR que 3.
“true” ou “verdadeiro”, pois o valor 1 É IGUAL a 1.
Tabela 18 - O resultado das expressões lógicas.
Os resultados são expressos no idioma inglês, “true” ou “false”, por ser este o idioma nativo do Scratch e não haver
ainda tradução para os resultados das expressões booleanas.
Além de expressões numéricas utilizando diretamente os valores, podemos criar expressões com variáveis
numéricas ou mesmo com letras, como as da Figura 172 abaixo:
Figura 172 - Expressões lógicas comparando letras e strings.
Quando strings são avaliadas, como no exemplo “Ana > Bruna”, o resultado será “false”, “falso”, pois a letra inicial
“A” vem antes da letra inicial “B” no alfabeto e é essa ordem que é seguida pelo Scratch quando das comparações
entre strings. Se ambas as strings iniciais forem iguais, como por exemplo, “Ana” e “Armênia”, a comparação será
6
O nome dado a esse tipo de estrutura deve-se ao matemático britânico, George Boole. A Álgebra Booleana, como é chamado
esse ramo matemático, é a base para a Ciência da Computação moderna. Saiba mais sobre esse grande matemático em
https://pt.wikipedia.org/wiki/George_Boole, na Wikipedia.
93
realizada entre as letras seguintes da string, e assim sucessivamente até o último caractere. No caso de uma
expressão onde tenhamos “Ana = Armênia”, o resultado seria “falso”, pois mesmo ambas iniciando com a letra
“A”, a segunda letra de “Armênia”, o “r”, é maior que a segunda de “Ana”, o “n”.
Os blocos de decisões
No Scratch temos dois blocos na guia “Controle”, que irão permitir a você tomar decisões e ações em seus scripts.
São eles: se e se/senão. A utilização desses dois blocos lhe permitirá fazer uma pergunta e, dependendo do retorno
da resposta, seguir um fluxo de ação dentro do script. Iremos aqui estudar cada um deles, suas características e
aplicações.
O bloco se
Com o bloco “se” você pode realizar um desvio na execução do seu script. O desvio será executado caso a expressão
lógica avaliada pelo bloco “se”, retorne o valor “verdadeiro”. Se o retorno for “falso” os comandos dentro da
estrutura “se”, não serão executados.
Figura 173 - O bloco "se".
Vejamos aqui um exemplo com o bloco “se”:
Figura 174 - Utilizando o "se" para verificar o maior entre dois números.
No script da Figura 174 acima temos o seguinte: duas variáveis, “num1” e “num2”, recebem os valores digitados
pelo usuário através dos blocos “pergunte e espere a resposta”. Na sequência, uma estrutura “se” avalia se a
expressão “num1 > num2”, ou seja, se o primeiro número digitado é maior do que o segundo número. Se o valor
da expressão for “verdadeiro”, o bloco dentro da estrutura, “diga string por 2 segundos” será executado
mostrando o valor da variável “num1”, a string “é maior que”, e o valor da variável “num2”. Caso o retorno seja
“falso”, os comandos da estrutura “se” serão ignorados, sendo executados os que estão logo a seguir ao bloco, no
caso do exemplo os blocos: “espere 1 seg” e “diga Até a próxima! por 2 segundos”, encerrando então a execução
do script.
Note que o exemplo anterior testa apenas se o primeiro número, variável “num1”, é maior que o segundo, variável
“num2” e que, para testar se o segundo número é maior que o primeiro, teríamos que utilizar outra estrutura “se”,
como mostra a Figura 175 a seguir:
94
Figura 175 - Usando duas estruturas para avaliar duas possibilidades.
Agora, caso o teste lógico da primeira estrutura se (1) seja falso, será executado o teste lógico da segunda estrutura
em sequência (2), possibilitando então a execução de outro grupo de scripts.
Mas, e se os números forem iguais? Da forma que o script foi elaborado, essa possibilidade não está sendo testada,
e nenhum dos dois testes lógicos seriam verdadeiros, fazendo com que apenas os dois blocos que estão fora da
estrutura “se” fossem executados. Vamos então criar um terceiro teste lógico, que verifique se os números são
iguais, e mostre a mensagem “Números iguais!”.
Figura 176 - Verificando se os números são iguais.
Esse terceiro bloco “se” deve ser colocado na sequência dos outros blocos “se” já existentes, a ordem entre eles
não vai alterar seu script, desde que estejam um após o outro.
Existe um limite para a quantidade de estruturas do tipo “se” que posso colocar em um único script? Bom, em
teoria não há limite, porém, uma quantidade exagerada de blocos “se” pode deixar seu script difícil de ler e
compreender, o que não é bom.
O bloco se/senão
Diferentemente do bloco “se”, que desvia a execução do script apenas para um fluxo de comandos, o bloco
“se/senão” possibilita que dois caminhos sejam tomados: um caso o teste lógico avaliado seja “verdadeiro”, e um
outro caso o teste lógico seja “falso”. Ou seja, temos uma saída para cada resultado do teste lógico avaliado, e isso
utilizando apenas uma mesma estrutura de seleção.
Vamos criar um pequeno jogo onde o usuário tenha que responder qual o maior entre dois números sorteados
aleatoriamente. O script base é esse apresentado na Figura 177 abaixo:
95
Figura 177 - Script do jogo do maior entre dois números.
São sorteados dois números entre 1 e 100 cada, sendo estes atribuídos as variáveis “num1” e “num2”
respectivamente:
Figura 178 - Sorteio e atribuição dos números que serão comparados entre si.
Em seguida os números são apresentados ao usuário:
Figura 179 - Mostrando os números ao usuário.
Na sequência, na primeira estrutura de seleção “se/senão”, é feita a comparação entre os números sorteados:
“num1 > num2” é a expressão lógica utilizada. Note que agora existem dois blocos de comandos a serem
executados nessa mesma estrutura “se/senão”, dependendo do valor retornado pela expressão lógica:
96
Figura 180 - Testando qual o maior entre os dois números.
De acordo com o teste lógico “num1 > num2”, da Figura 180, se o retorno for “verdadeiro”, a variável “maior”
receberá o valor da variável “num1”, caso contrário, “senão”, a variável “maior” receberá o valor da variável
“num2”.
Após a verificação do maior entre os dois números, é solicitado ao usuário que responda qual entre os dois é o
maior número.
Figura 181 - Pergunta qual o maior entre os dois números sorteados.
A resposta dada pelo usuário será armazenada na variável “resposta”, que será comparada a variável “maior”, que
guarda o maior valor entre os dois sorteados anteriormente e, dependendo do resultado do teste lógico do segundo
“se/senão”, irá determinar se o usuário acertou, retorno “verdadeiro”, somando um ponto ao placar, variável
“pontos”, ou errou, exibindo a mensagem de resposta errada.
Figura 182 - Verificando se o usuário acertou ou errou a resposta.
Com o emprego da estrutura “se/senão”, além da possibilidade de dois fluxos de execução com o retorno de apenas
um teste lógico, a compreensão do seu script ficará mais clara.

Se aninhados: encadeando várias estruturas se/senão
E se você tiver que avaliar mais de uma ou duas condições? Por exemplo, se um número é maior, menor ou igual a
outro, como vimos no exemplo anterior? Ou mesmo se quisermos criar um menu de opções para uma aplicação,
como nos caixas eletrônicos dos bancos, onde as operações que podem ser realizadas aparecem na tela para que
o usuário escolha uma delas. Esse tipo de ação é bastante comum em diversos programas.
Para construir esse tipo de estrutura, denominada de “se encadeado” ou “se aninhado”, colocamos as estruturas
de seleção uma dentro da outra, de acordo com o que se pretende avaliar como verdadeiro ou falso. Vejamos um
exemplo simples desse tipo de estrutura. Escrevemos um script, onde deseja-se verificar se um número qualquer
digitado é par, ímpar ou o próprio zero.
97
Figura 183 - Script para verificar se um número é par, ímpar ou zero.
No script da Figura 183, temos um primeiro teste lógico que verifica se “resposta = 0”, caso o retorno seja
“verdadeiro”, o bloco “diga Número é o próprio zero! por 2 segundos” será executado. E caso seja “falso”? Ainda
temos que verificar se o número é par ou ímpar, duas outras condições. Então utilizamos o encadeamento de “se”,
colocando uma outra estrutura de seleção dentro do “senão” da primeira, e nela realizamos um outro teste lógico:
“se resto de resposta por 2 = 1”. Ou seja, temos a seguinte leitura dessa estrutura encadeada: se – senão – se. Um
bom exemplo de uso desse tipo de estrutura, é o exemplo do script a seguir, que cria um “menu de opções” para
que você escolha a ação que deverá ser executada.
Figura 184 - As quatro operações.
98
O script da Figura 184 simula uma calculadora bem rudimentar, que executa as quatro operações básicas, a partir
de dois números informados pelo usuário. O usuário irá também selecionar qual operação deseja que seja
executada: 1-Soma, 2-Subtração, 3-Multiplicação ou 4-Divisão, digitando o número correspondente a operação.
Para a escolha da operação que será executada, foi utilizada uma estrutura de “se encadeados”, onde cada teste
lógico leva a um fluxo de comandos específicos.
Figura 185 - Selecionando a opção de operação matemática.
A escolha do usuário é armazenada na variável “resposta”, que é verificada em três testes lógicos encadeados

Exemplo 04
Vamos escrever agora um projeto onde três figuras geométricas: triângulo, quadrado e círculo, serão desenhadas
de acordo com a escolha do usuário.
Figura 186 - Desenhando formas geométricas. Parte 01.
99
Figura 187 - Desenhando figuras geométricas. Parte 02.
As opções de escolha são controladas pelo “ninho de ses” da Figura 187, onde a variável “resposta” é avaliada e
segue um fluxo diferente dependendo do retorno.
Figura 188 - Menu de opções. Escolha a figura que será desenhada.
100
Temos três estruturas de seleção, “se”, onde os comandos de cada figura estão colocados. Caso “resposta = 1”,
será desenhado um triângulo, caso “resposta = 2”, o desenho será do quadrado, e caso “resposta = 3”, o círculo
será desenhado. Qualquer outro valor que seja digitado será ignorado.
101
CAPITULO 05
Aparência.
Listas de variáveis.
Eventos.
Exemplo 05.
Cuidando da aparência de atores e pano de fundo

Quando nos referimos a “aparência” dos atores e pano de fundo no Scratch, estamos falando dos diversos efeitos,
trajes/fantasias possíveis que podem ser manipulados por estes. Como você já sabe, um ator pode ter diversos
“trajes” ou “fantasias”, que são utilizados para representar diferentes situações e sensações, como o caminhar, um
aceno ou ainda, expressões faciais de um ator.
Todos os blocos de comandos que nos permitem manipular a aparência de um ator ou pano de fundo, fazem parte
da categoria “Aparência”.
Figura 189 - Categoria "Aparência" e seus comandos.
Vamos ver um pequeno exemplo de como utilizar alguns desses comandos. Abra um novo projeto e dê a ele o título
de “Dançarino”. O projeto consiste em fazer uma figura de um boneco, estilo “stickman7”, e simular uma dança
com o mesmo. Nesse exemplo, vamos utilizar um ator externo, uma figura importada de um banco de figuras da
Web, o Freepik8, que possui milhares de desenhos e fotos que podem ser baixadas e utilizadas livremente, desde
que se dê o devido crédito ao autor da imagem.
7
Stickman é como são chamados aqueles desenhos que representam personagens humanoides, que utilizam um traço simples,
geralmente sem rosto e vestimentas.
8
Disponível em <https://www.freepik.com>. Acessado em 10/10/2017.
Figura 190 - O banco de imagens Freepik.
Após baixar a imagem para seu computador, importe-a para que possa utilizá-la em seu projeto, clicando na opção
“Carregar ator a partir de arquivo”.
Figura 191 - Carregando uma imagem de outro local.
Com a imagem carregada, clique na guia “Fantasias” e selecione a imagem do ator. Clique no ator com o botão
direito do mouse para ativar o menu de contexto do mesmo, vamos duplicar esse ator.
Figura 192 - Duplicando a imagem do ator.
Agora temos um ator e duas fantasias, ambas na mesma posição, por enquanto. No projeto, quando este estiver
em ação, o ator deverá simular uma dança, balançando os braços de um lado para outro, e também o quadril.
Vamos criar esse movimento com os trajes que temos do ator, mas um, a cópia duplicada, necessita ser colocada
em posição contrária a do original, como se fosse espelhado. Para isso, selecione o segundo traje, aquele que
acabamos de duplicar e clique no botão “Espelhar horizontalmente”.
105
Figura 193 - Espelhando uma imagem horizontalmente.
Pronto, os trajes do ator estão prontos, podendo ser agora animados com os efeitos desejados. Temos um traje
com os braços apontados para a direita, e um outro com os braços apontados para a esquerda.
Figura 194 - Os trajes prontos.
Para o palco vamos utilizar uma imagem sugestiva, que represente um ambiente de festa. Selecione o pano de
fundo e, na biblioteca de imagens do Scratch, selecione a imagem “party room”.
Figura 195 - Selecionando a imagem para o pano de fundo da biblioteca do Scratch.
106
Pronto o ambiente da festa, vamos ao script do ator, os comandos que o farão dançar pelo salão. Selecione o ator
e escreva o código da Figura 196 abaixo:
Figura 196 - Script para o dançarino.
O que esse código faz? Analisando o código temos o seguinte:
Bloco: Descrição:
Clique na “bandeira verde” para dar início a execução
do script.
Move o ator para a coordenada inicial “x:0” e “y:-60”.
Dentro desse bloco de repetição “sempre”, estão os

demais comandos que serão repetidos
indefinidamente, ou até que interrompamos a
execução. O bloco “próxima fantasia”, faz com que o
ator mude de uma fantasia/traje para outra, dando
assim a impressão do movimento de braços e quadril,
para esquerda e para a direita. O bloco “espere 0.5
seg”, deixa o movimento mais compassado, tornando-
o mais lento. O “mova 10 passos”, movimenta para
frente, como se caminhasse de lado, e, finalmente, o
“se tocar na borda, volte”, faz com que ele ande de um
lado a outro do palco.
Tabela 19 - Analisando o script do dançarino.
Outra maneira de mudar a fantasia de um ator, é utilizando o bloco “mude para a fantasia nome da fantasia”. Com
ele é possível indicar no menu suspenso do bloco, qual fantasia deve ser utilizada naquele exato momento, sem
seguir uma ordem padrão de fantasias.
Figura 197 - Mudando para um traje específico da lista de trajes.

Atores, suas frase e pensamentos
107
No Scratch, podemos fazer com que os atores dialoguem como um desenho animado ou revista em quadrinhos,
através da exibição das frases em balões, como nas revistas em quadrinhos. Os comandos que realizam essa função
são:
Bloco: Função:
Exibe um balão de fala com o texto indicado, por “n”
segundos. O tempo define a duração de exibição do
texto na tela, ficando o script em pausa durante esse
tempo.
Exibe um balão de fala com o texto indicado, sem limite
de tempo. Para remover esse balão, utilize outro vazio,
sem nenhum texto.
Exibe um balão de pensamento com o texto indicado,
por “n” segundos. O tempo define a duração de
exibição do texto na tela, ficando o script em pausa
durante esse tempo.
Exibe um balão de pensamento com o texto indicado,
sem limite de tempo. Para remover esse balão, utilize
outro vazio, sem nenhum texto.
Tabela 20 - Blocos para fala e pensamento dos atores.
Figura 198 - Balão de fala. Figura 199 - Balão de pensamento.
Um bom exemplo de como podemos utilizar os blocos “diga... por 2 segundos” e “pense ... por 2 segundos”, é o
do projeto “Conversa animada”. Abra um novo projeto e dê a ele o nome de “Conversa animada”. Coloque junto
ao ator “Gato”, um outro ator, aqui no exemplo utilizamos o “Cão”.
108
Figura 200 - Tela do projeto "Conversa animada".
Vamos agora aos scripts de cada ator. Primeiramente o do ator “Gato”, pois ele vai iniciar a conversa com o ator
“Cão”. Selecione o ator “Gato”, clique na guia “Scripts” e insira os seguintes blocos:
Figura 201 - Script do ator Gato, com todas as suas falas iniciais.
Colocamos três blocos do tipo “diga frase por 2 segundos”, com as frases que queremos que sejam exibidas em
balões do tipo “fala”. Os textos irão aparecer na sequência em que foram agrupados no script, ficando em exibição
por dois segundos cada um, um após o outro. O Gato terá então seis segundos de fala ao total.
Agora, o script do ator “Cão”:
Figura 202 - Script do ator Cão, "pensando" sua resposta.
Utilizamos para o ator Cão um script do tipo “pense texto por 2 segundos”, para que seja exibido o “pensamento”
do cão em relação ao que o gato “fala”.
109
Controlando o tempo das falas dos atores

Observando o script do ator Cão, Figura 202 acima, o que você percebe de diferente em relação ao do Gato, além
de um utilizar “fala” e o outro “pensar”? Você deve ter percebido que existe um bloco de controle “espere 7 seg”,
colocado antes do bloco “pense Lá vem o gato com a sua curiosidade... por 2 segundos”, correto? E por qual
motivo esse bloco foi colocado ali, e com exatamente 7 segundos de espera? A resposta para isso é: sincronismo.
Experimente retirar esse bloco do script e execute novamente o projeto. O que acontece? Você verá que o bloco
“pense...” do cão será exibido no mesmo instante do primeiro bloco “diga...” do gato, misturando os balões de
ambos durante a exibição. Isso acontece porque ambos os scripts estão sendo executados ao mesmo tempo,
paralelamente um ao outro, o que ocasiona esse “problema”.
O que fizemos para que a sobreposição dos balões de ambos os atores não acontecesse, foi e somar o tempo de
cada frase do ator gato, o que resulta em exatos seis segundos, e inserir o “espere 7 seg” no script do cão, fazendo
então com que o mesmo fique aguardando o tempo exato da fala, e só depois exiba o seu balão “pense...”.
Essa é apenas uma solução paliativa, pois a medida em que o número de atores em cena aumenta, e a quantidade
de diálogos cresce, fica complicado ter que contar o tempo para todos e utilizar os blocos de espera no momento
correto. Vejamos um exemplo agora do mesmo script, aumentando apenas um pouco os diálogos entre os atores:
Figura 203 - Script do Gato, modificado.
Figura 204 - Script do Cão, modificado.
No script do ator Gato, Figura 203, inserimos um novo bloco “espere 8 seg”, antes dos dois novos blocos “diga...”,
em resposta aos dois novos blocos “diga...” do ator Cão, Figura 204. E isso deve ser feito caso outros diálogos sejam
inseridos entre os dois atores, evitando assim a sobreposição dos balões entre eles, e sincronizando a conversa.
Essa não é a melhor técnica, pois é trabalhosa e deixa os scripts longos e de difícil compreensão, estudaremos
posteriormente uma forma mais eficaz para controlar os diálogos entre os atores.
Escondendo e mostrando os atores no palco
110
As vezes em alguns momentos, será necessário “retirar” um outro ator de cena, seja temporariamente ou
permanentemente. Também, dependendo da situação, um ator que foi retirado deverá ser exibido novamente,
voltando a interagir dentro do projeto. Os comandos da guia “Aparência” que executam essas ações são: o
“esconda”, que literalmente esconde um ator durante a execução do script, tornando-o invisível aos olhos, e o
“mostre”, que exibe novamente um ator antes escondido.
Bloco Descrição
Exibe o ator no palco.
Esconde o ator no palco
Utilizando diferentes camadas do palco

Muitas vezes, dentro de uma cena em um projeto, temos que sobrepor um ator a outro ou a um objeto, fazendo
com que ele apareça na frente ou atrás deste. Para que esse tipo de procedimento seja realizado, imagine o palco
como sendo dividido em vários níveis de profundidade, várias CAMADAS, podendo você deslocar os objetos entre
essas camadas.
Observe a Figura 205 abaixo. Nela temos três atores, os peixes, cada um em uma camada diferente do palco,
sobrepondo-se uns aos outros de forma que, um vai sempre estar à frente dos demais. A primeira camada é a mais
externa, na Figura 205 apontada pelo número 1, sendo as demais camadas mais internas, 2 e 3, nessa ordem.
Figura 205 - As camadas.
Para controlar o posicionamento de um ator entre as camadas, utilizaremos dois blocos da categoria “Aparência”,
o “vá para frente” e o “vá n camadas para trás”.
Bloco Descrição
Envia um ator para a frente de todos os outros. Quando
você move o ator com o mouse, durante a edição, isso
é equivalente a esse comando.
Envia um ator quantas camadas forem indicadas no
bloco, para trás dos demais.
Alterando o tamanho dos atores
111
Um ator pode ter seu tamanho modificado manualmente, utilizando as ferramentas “reduzir” e “aumentar”, na
barra de ferramentas, porém, essa forma só pode ser utilizada antes da execução do projeto, quando ainda estamos
editando a cena e definindo os atores e objetos. Contudo, alguns projetos podem requerer que um ator, durante a
execução de seu script, tenha seu tamanho reduzido ou aumentado, de acordo com o roteiro definido.
Na guia “Aparência”, os blocos responsáveis por modificar o tamanho dos atores durante a execução de um script
são: “adicione valor ao tamanho” e “mude o tamanho para valor %”.
Bloco Descrição
Aumenta ou diminui o tamanho de um ator, de acordo
com a quantidade especificada no bloco.
Aumenta ou diminui o tamanho de um ator,
percentualmente, em relação ao seu tamanho original.
Aplicando efeitos gráficos aos atores

Alguns efeitos podem ser utilizados em seus atores, dando a eles uma imagem e definição diferentes do original, o
que pode ser útil em uma determinada cena. Você poderá por exemplo, alterar a textura de uma imagem, sua cor
e brilho. São três os blocos de comandos responsáveis pela modificação de efeitos nos atores: “adicione ao efeito
seleção valor”, “mude o efeito seleção para valor” e “apague os efeitos gráficos”. Vejamos como eles funcionam:
Bloco Descrição
Altera o efeito aplicado ao ator. O efeito que será
utilizado, pode ser selecionado na lista do menu do
bloco. Utilize valores positivos ou negativos para os
valores. O botão “Parar” remove os efeitos aplicados.
Aumenta ou diminui o efeito aplicado a um ator. O

efeito que será utilizado, pode ser selecionado na lista
do menu do bloco. Uma vez aplicado o efeito, utilize
este bloco para realizar as mudanças no mesmo. Utilize
valores positivos ou negativos para os valores. O botão
“Parar” remove os efeitos aplicados.
Remove todos os efeitos gráficos aplicados a um ator.

Tem o mesmo efeito do botão “Parar”.
Vejamos alguns exemplos de efeitos:
112
Original Efeito 01 Efeito 02
Sem efeitos Efeito “Olho de peixe” para 200 Efeito “Pixelização” para 50
Ao todo são sete os efeitos gráficos que podem ser utilizados com os atores, permitindo que você use a sua
imaginação e criatividade na hora de criar suas aplicações.
Efeitos no Pano de fundo

Você verá, ao longo de sua experiência com o Scratch, que muitos de seus projetos poderão necessitar não apenas
de um único pano de fundo, mais vários deles, como acontece mesmo em uma peça de teatro. Até o momento,
trabalhamos sempre com um único pano de fundo, por exemplo. Mas, como fazer para mudar a cena trocando o
pano de fundo?
Alguns comandos específicos para uso com o pano de fundo de um projeto, podem ser encontrados na guia
“Aparência”. São eles:
Bloco Descrição
Muda o pano de fundo atual para um outro indicado
no bloco, e aguarda que o script seja encerrado. Útil
quando a ação de troca for realizada dependendo da
execução de um script de um ator, por exemplo.
Muda o pano de fundo atual para um outro indicado

no bloco.
Muda para o próximo pano de fundo na lista de pano

de fundo, seguindo a sequência da lista. Se o pano de
fundo exibido atual, for o último da lista, ele retorna
ao início.
Você ainda poderá utilizar as duas variáveis internas para controle de pano de fundo, “nome do pano de fundo” e
“nº do pano de fundo”. Elas podem ser bastante úteis quando utilizadas com os blocos lógicos de controle de fluxo,
como o “se”, avaliando por exemplo se um determinado pano de fundo está sendo exibido e o que executar nesse
caso.
Bloco Descrição
Guarda o nome do pano de fundo utilizado no
momento.
Guarda o número do pano de fundo utilizado no
momento.
113
Bloco Descrição
No exemplo ao lado se o teste lógico for “verdadeiro”,
todos os efeitos gráficos serão desativados.
Figura 206 - Exemplo de controle com o nome do pano de fundo.
Os nomes e números dos panos de fundo de um palco, podem ser visualizados na guia “Panos de fundo”. Os nomes
ficam abaixo da imagem e os números acima e a esquerda da imagem, porém essa lista pode ser reorganizada
clicando-se e arrastando a imagem do pano de fundo para cima ou para baixo na lista.
Figura 207 - Nomes e números do pano de fundo.
Controlando as ações através da difusão de mensagens (Brodcasting)

Várias ações podem ser controladas através dos blocos de comandos da guia “Eventos”. Na realidade, utilizamos
em alguns dos projetos que fizemos até aqui, o bloco “quando clicar em bandeira”, para inicializar a execução dos
nossos scripts. Esse é um dos blocos que disparam eventos que dão início as ações nos scripts, veremos todos os
outros a partir de agora.
Bloco Descrição
Inicia a execução do script quando for dado um clique
na bandeira verde.
Inicia a execução de um script quando uma tecla
específica for pressionada. Selecione a tecla desejada
na lista de teclas do menu do bloco.
Inicia a execução de um script quando o ator receber
um clique do mouse.
Trabalha com os atributos: ruído, som captado pelo
microfone, cronômetro e movimento do vídeo,
capturado pela Webcam instalada. Quando um dos
atributos selecionados for maior que o valor indicado
no bloco, o script será executado.
114
E como disparar eventos enviando e recebendo mensagens?

O sistema de envio e recebimento de mensagens é bastante útil na automação de ações dentro do projeto. Para
entendermos como uma “mensagem” funciona no Scratch, devemos vê-la como sendo um “gatilho”, algo que vai
“disparar” uma ou mais ações em todos ou em apenas um ator específico.
Uma mensagem é apenas um nome, um identificador qualquer, e não um texto escrito que represente realmente
algo que deva ser lido. Quando disparamos uma mensagem, todos os atores a “escutam”, recebem, porém apenas
os que estiverem esperando pela mensagem vão ser acionados.
Os blocos da guia “Eventos” que vão nos permitir o envio e recebimento das mensagens são:
Bloco Descrição
Envia uma mensagem específica a todos os atores e
também ao pano de fundo. Apenas os atores que
tenham o bloco “quando receber mensagem”
realizarão alguma ação programada.
Envia uma mensagem específica a todos os atores e

também ao pano de fundo, e aguarda até que o script
do receptor seja encerrado para continuar a sua
execução. Apenas os atores que tenham o bloco
“quando receber mensagem” realizarão alguma ação
programada.
Executa um script ao receber uma mensagem

específica. A mensagem que será recebida pode estar
na lista do menu, ou pode ser criada uma nova
mensagem.
Exemplo 05
Simulador de aquário. Que tal criar alguns peixes virtuais? Nesse exemplo vamos criar um projeto que imita um
aquário. Colocaremos alguns peixes para nadar em um cenário que representa esse ambiente aquático. Todos os
atores estão na biblioteca de imagens do próprio Scratch, então vamos lá!
O palco e o cenário.
No nosso projeto, haverá dois panos de fundo para o palco: um representando o dia, e o outro representando a
noite. A imagem para ambos é a “underwater3”, e está na biblioteca de imagens. Abra a biblioteca na opção
“Escolher pano de fundo da biblioteca” e insira a imagem.
115
Figura 208 - O pano de fundo com a figura "underwater3".
Esse será nosso pano de fundo para representar o dia. Vamos agora duplicar esse mesmo pano de fundo para que
possamos modifica-lo e utiliza-lo como o pano de fundo para representar a noite. Na miniatura do pano de fundo,
lado esquerdo do editor de imagens, clique com o botão direito na miniatura e, no menu apresentado, selecione a
opção “Duplicar”.
Figura 209 - Duplicando o pano de fundo.
Agora, vamos tornar o fundo desse novo pano de fundo que acabamos de duplicar, da cor azul para a cor preta,
dando a impressão de que escureceu. Para pintar o fundo de preto, utilize a ferramenta “Preencher com cor”.
Selecione a cor preta na paleta de cores e clique com a ferramenta na área a ser pintada.
Figura 210 - Para pintar o fundo azul de preto.
Pronto, os panos de fundo para representar o dia e a noite no aquário estão finalizados. Vamos agora aos atores.
Os atores do aquário.
Teremos nesse projeto, quatro atores: três peixes e um mergulhador, todas figuras da biblioteca. O que farão esses
atores no palco? Eles devem se movimentar aleatoriamente pelo ambiente e, em alguns momentos, ter alguma
interação entre eles.
116
Figura 211 - Os atores para o projeto "Aquário".
Os Scripts para os atores.
O script que cada um dos atores utilizará será descrito abaixo. Eles contêm basicamente as mesmas instruções, já
que todos se movimentam da mesma forma, e executam as mesmas ações.
Script para o peixe 1 (Fish 1):
Figura 212 - Script para o ator "Fish 1". Parte 01.
O script da Figura 212 é responsável pela movimentação do ator, peixe, pelo palco. Um segundo script será
responsável pela troca de mensagens entre este e um outro ator.
Figura 213 - Script para o ator "Fish 1". Parte 02.
No script da Figura 213, o ator fica aguardando a mensagem “boa noite”, que será lançada por um outro ator dentro
do projeto, quando ele receber essa mensagem, dará início ao restante dos comandos, exibindo a mensagem “Boa
noite a todos” em um balão de fala, e enviando aos outros atores a mensagem “dormir”.
Para os outros dois peixes, o script é o mesmo, porém, para que tenham comportamento um pouco diferente,
vamos alterar alguns valores utilizados com o ator “Fish 1”. Coloque o script principal do ator “Fish 1” na mochila
117
do Scratch, e arraste-o da mochila para a área de scripts dos outros dois atores peixe, “Fish 2” e “Fish 3”. Os valores
que você deve alterar no script para esses dois atores, está circulado na imagem da Figura 214 abaixo:
Figura 214 - Script para os outros dois atores "peixe" e suas modificações.
O que deve mudar:
1. O tempo do “deslize por...” para que os peixes se movimentem em velocidades diferentes.

2. O valor comparado ao valor de “cronômetro”, na estrutura “se”, para que os efeitos sejam executados em
momentos variados uns dos outros.
3. O tipo do efeito utilizado em “mude o efeito ... para valor”, para que cada um execute um efeito diferente.
Tente também valores diferentes de 100.
O segundo script para os atores “Fish 2” e “Fish 3”, são respectivamente os que seguem abaixo na Figura 215 e
Figura 216:
Figura 215 - Segundo script para o ator "Fish 2". Figura 216 - Segundo script para o ator "Fish 3".
O ator mergulhador, “Diver2”, tem um script menor, pois o movimento dele é menos complexo. Eis abaixo os
comandos:
Figura 217 - Script do ator mergulhador.
118
O script do palco.
Sim, o palco tem scripts. Na verdade, colocamos nesse exemplo os scripts de farão a troca de pano de fundo, e os
para a difusão de mensagens, “broadcasting”, para os demais atores. Ao receberem o sinal, cada ator, de acordo
com a mensagem recebida, dará início a execução de seus scripts.
Figura 218 - Scripts do palco para controle do pano de fundo e mensagens.
Terminado o processo de criação dos scripts, coloque seu aquário para funcionar.
119
CAPÍTULO 06
Som.
Mais blocos.
Exemplo 06.
Som: aplicando sons aos projetos

Em aplicações como apresentações, jogos e outras do tipo construídas com o Scratch, é mais do que normal o uso
de som. Músicas ou efeitos podem ser incorporados as suas aplicações, dando ainda mais vida e animação aos seus
projetos. Utilizaremos a biblioteca de sons do próprio Scratch, arquivos de som externos ou sons que você mesmo
grava diretamente do editor de sons.
O Scratch trabalha com apenas dois formatos de sons: WAV e MP3. Qualquer outro formato de som diferente
desses dois, deverá ser convertido em um dos dois para que possa ser utilizado em seus projetos.
O editor de som
No painel “Sons”, temos um gerenciador de som, simples, a partir do qual você irá inserir os arquivos de som em
seus projetos. Você poderá “Escolher novo som da biblioteca”, “Gravar novo som” ou “Carregar som a partir de
arquivo”. Usando qualquer uma dessas opções, o arquivo poderá ser editado de maneira rápida, e também poderá
adicionar alguns efeitos básicos ao som.
Figura 219 - Aba "Sons", suas opções e o seu editor.
Após inserir o som ou os sons, pois podemos inserir mais de um arquivo de som em um mesmo projeto, você
utilizará os comandos da guia “Som” para manipulá-los, dizendo quando, onde e como serão executados. Os
comandos que permitem essa manipulação são os seguintes:
Bloco Descrição
Toca um som previamente carregado ou abre o
gravador para que seja criado um novo som. Inicia a
execução do som e segue para o próximo bloco no
script.
Toca um som previamente carregado ou abre o
gravador para que seja criado um novo som. Inicia a
execução do som e aguarda até o final para seguir ao
próximo bloco no script.
Interrompe a execução de todos os sons ativos no
momento.
Altera o volume do som, aumentando ou diminuindo
seu volume, um valor específico, onde 100 é o padrão.
Altera o volume do som para um volume específico,
dado um valor em percentual.
Sons de fundo: tocando ao fundo da ação

Uma das formas mais corriqueiras no uso de sons em jogos, são os sons de fundo. Esse tipo de uso coloca
geralmente uma música ou efeito para tocar ao fundo de toda a ação que ocorre, paralelamente aos demais efeitos
até, dando toda uma nova perspectiva ao seu projeto.
Que tal colocarmos um som ao fundo do nosso exemplo do aquário? Um som de borbulhas, do tipo produzido pelas
máquinas de oxigenação e limpeza utilizadas em aquários reais? Pois então vamos lá! A primeira coisa a se fazer é
encontrar um site onde possamos baixar e usar sons do tipo gratuitos ou mesmo “Open Source9”, que não cobram
pelo seu uso. Você também poderá criar o seu próprio som de borbulhas. Aqui, vamos utilizar o arquivo de som
“bolhas_som.mp310”, gravado de um aquário real, e carregado para o projeto.
Figura 220 - Arquivo "bolhas_som" carregado para o projeto.
Agora, com o som devidamente carregado, selecione o palco, pois é nele que o script onde o som será executado
vai ser construído. Inclua o script abaixo e execute seu projeto:
Figura 221 - Script para o som de fundo do palco.
Colocar o bloco “toque o som... até o fim” dentro de um laço de repetição “sempre”, faz com que o som se repita
indefinidamente, sendo encerrado apenas com a interrupção da execução, ou por um comando que pare o script.
Manipulando instrumentos musicais

Que tal montar uma orquestra virtual? Pois é, o Scratch tem uma enorme quantidade de instrumentos, ou sons de
instrumentos musicais, que podem ser usados para esta finalidade. Temos a disposição instrumentos de corda, de
sopro e de percussão de todos os tipos, basta escolher aquele que quiser utilizar e criar a sua própria composição
musical.
9
Open Source ou traduzindo, “Código Aberto”. É um modelo de desenvolvimento de produtos que se baseia na liberdade de
se copiar, modificar e distribuir livremente esse mesmo produto. Milhares de softwares e produtos de hardware são
distribuídos atualmente seguindo esse modelo, que hoje é regido pela OSI, Open Source Iniciative. Fonte: Wikipedia. Disponível
em < https://pt.wikipedia.org/wiki/C%C3%B3digo_aberto#Defini%C3%A7%C3%A3o >. Acessado em: 10/10/2017
10
Utilize o som que achar mais conveniente em seu script.
123
Figura 222 - Instrumentos e sons de percussão, tambores.
Como vemos na Figura 222 acima, são dezoito sons de tambores, ou instrumentos de percussão, que podem ser
utilizados para composição musical em seus projetos. Além de escolher o tipo de som, o tempo de duração de uma
batida também pode ser ajustado, ditando o ritmo da batida. Maior tempo resulta em um maior tempo entre uma
batida e outra. Vamos usar o script a seguir e testar alguns dos sons de tambores:
Figura 223 - Som de caixa acelerado.
Ao executar esse script, ouviremos o som do instrumento 1, “caixa”, em ritmo acelerado. Se você aumentar o
tempo, perceberá que a batida vai ficando progressivamente mais lenta, a medida que o valor indicado sobe.
Experimente inserir outros instrumentos com diferentes tempos de batida e veja como soa.
124
Figura 224 - Criando a batida perfeita!
Acelerando e desacelerando o ritmo

O tempo da batida define o ritmo que será dado ao som. Para controlar esse tempo, utilizaremos os blocos
“adicione valor bpm ao tempo” e “mude o tempo para valor bpm”.
Bloco Descrição
Altera o tempo atual do ator aumentando ou
diminuindo esse valor. O tempo é a velocidade em
bpm, batidas por minuto, usada pelo Scratch para tocar
os instrumentos e notas.
Ajusta o tempo das batidas para um valor específico.
Vejamos um pequeno exemplo desses dois blocos em uso. Escreva o script a seguir e execute-o:
125
Figura 225 - O tempo das batidas.
O que você notou? Que ao aumentar o tempo em cada laço, a “distância” entre as batidas vai ficando cada vez
maior, parecendo mesmo que o som foi finalizado. Para verificar o valor atual do tempo das batidas, utilize a
variável interna “tempo”. Marque a caixa de seleção da variável no painel e ela aparecerá no palco.
Tabela 21 - Variável "tempo" e sua exibição ao lado.
Outros instrumentos, outros sons

Além dos instrumentos de percussão, os tambores diversos, outros instrumentos podem ser utilizados para a
criação das suas peças musicais. O bloco “use o instrumento nº” traz uma lista com vinte e um instrumentos
musicais, alguns deles nem tão comuns assim, e que podem ser bem interessantes na criação de novas
composições:
126
Figura 226 - Outros instrumentos musicais.
Além de todos os instrumentos com seus sons específicos, o Scratch permite que você manipule diretamente as
notas musicais, fazendo com que um determinado instrumento, ou instrumentos, toquem exatamente em uma
nota específica, trazendo ainda mais possibilidades a criação de sons com o Scratch. Possuindo conhecimentos
musicais será possível até composições mais rebuscadas! O bloco “toque a nota nº por nº batidas” é o que deve
ser utilizada na manipulação das notas musicais. Ele exibe um teclado para que você possa tocar e ouvir a nota no
tempo definido.
Tabela 22 – O bloco “toque a nota...” em seus dois formatos.
Fizemos um pequeno script para que você possa testar as diferentes notas e seus tempos. Escreva o script abaixo
e teste o seu funcionamento mudando os valores de nota, instrumento e tempo:
127
Figura 227 - Testando as notas musicais.
URL do exemplo na Web: https://scratch.mit.edu/projects/194740525

Dividir para conquistar: trabalhando com seus próprios blocos
Até então em nossos exemplos, temos trabalhado com programas simples que envolvem algumas poucas
estruturas de código, o que faz com que seja fácil escrever, entender e principalmente, manter esses programas.
Porém, a medida em que aprendemos mais sobre o Scratch e programação de computadores, mais complexas e
desafiadoras vão se tornando as nossas criações.
Para evitar que seus programas se tornem gigantes de código, com blocos e mais blocos de instruções, a versão 2.0
trouxe como inovação a categoria de blocos “Mais Blocos”, através da qual é possível criar e definir novos blocos
de comandos para usar em seus programas.
Figura 228 - A guia "Mais Blocos".
A criação de blocos personalizados vai permitir a você compactar os seus programas, a medida em que um grupo
de instruções poderá ser embutido em um novo bloco, executando as mesmas funções. Por exemplo, desenhar
uma figura geométrica ou executar um movimento com um ator requerem um grupo de instruções específicas, que
podem ser atribuídas à um único bloco de comando personalizado.
Criando o bloco “quadrado”

Vamos imaginar um determinado projeto onde diversos quadrados devam ser desenhados no palco. Para isso,
vamos escrever o script abaixo:
128
Figura 229 - Desenha três quadrados em diferentes pontos do palco.
Na Figura 229 acima, temos um script onde três quadrados são desenhados no palco. Observe o tamanho desse
código! Tivemos que repetir por três vezes os mesmos comandos que desenham a figura do quadrado, tornando
com isso o código extenso, ocupando espaço e tempo na construção do mesmo.
Que tal então diminuirmos esse código construindo um único bloco para desenhar a figura do quadrado? Na guia
“Mais Blocos”, clique no botão “Criar um bloco” para ativar a caixa de diálogo “Novo Bloco”.
Figura 230 - Caixa de diálogo "Novo Bloco".
No bloco apresentado na caixa de diálogo, escreva um nome para identifica-lo entre os demais, no caso do nosso
exemplo, o nome será “quadrado”.
129
Figura 231 - Nomeando o novo bloco.
Após pressionar o botão “OK”, o bloco irá fazer parte da coleção de blocos da guia “Mais Blocos”, bastando agora
ser personalizado com as funções que se deseja que ele execute. Perceba que, ao criar o novo bloco, um bloco do
tipo evento é inserido na área de scripts. É o bloco para definição dos comandos do novo bloco.
Figura 232 - Bloco de definição. Insira as funções do bloco quadrado.
Definindo o novo bloco

O que queremos que o novo bloco “quadrado” faça é exatamente isso, desenhe um quadrado na tela. Então, como
já temos os comandos que fazem esse desenho, basta que os encaixemos no bloco “defina quadrado”, como
mostra a Figura 233 abaixo:
Figura 233 - Bloco "quadrado" definido e pronto para uso.
Isso indica ao Scratch que onde o bloco “quadrado” for utilizado, serão esses os comandos a serem executados,
desenhando a figura na tela. No caso do nosso exemplo agora, basta que troquemos os blocos “repita 4 vezes” que
desenham os quadrados pelo novo bloco “quadrado”.
130
Figura 234 - Três quadrados: o mesmo efeito, só que com menos código.
Passando valores ao bloco

No exemplo anterior, os três quadrados desenhados são exatamente do mesmo tipo, possuindo as mesmas
características, como tamanho, cor e espessura da linha. E se você precisasse de três quadrados com diferentes
características que fossem diferentes entre si, como fazer?
Os valores que passamos a um bloco de comando são denominados de “argumentos”. São os argumentos que
definem por exemplo, uma coordenada de um bloco “vá para...”, a intensidade ou valor da cor da caneta, ou
mesmo a quantidade de passos que um ator deve andar. Existem vários blocos no Scratch que fazem uso de
parâmetros em suas definições, e os criados por você também podem fazer uso desse recurso.
Vamos editar o nosso bloco “quadrado” de maneira que ele possa receber alguns parâmetros em sua definição. Na
guia “Mais Blocos”, clique com o botão direito do mouse sobre o bloco “quadrado”, ativando o menu de contexto
do mesmo. Clique na opção “editar” para mostrar as opções de controle do bloco.
Figura 235 - Editando as opções do bloco "quadrado".
Nas “Opções”, você poderá selecionar que tipo de dado será passado ao comando como argumento.
131
Figura 236 - Editando as opções do bloco "quadrado".
Vamos adicionar um valor que será utilizado para determinar o número de “passos” que o ator vai andar quando
for desenhar o quadrado. Clique então na opção “Adicionar entrada numérica”, para inserir uma caixa onde um
valor numérico será digitado.
Figura 237 - Adicionando uma caixa para digitação de valores.
Escreva um nome para essa nova entrada, no nosso exemplo o nome dado foi “distancia”, ele irá identifica-la no
bloco. A entrada “distancia” funcionará na verdade como uma variável, armazenando o valor digitado por você no
bloco de comando.
Note que foi incluída também uma “entrada de texto”, onde escrevemos a palavra “passos”. Isso serve para deixar
claro ao usuário que aquele valor que ele está inserindo será utilizado para determinar os passos que serão
utilizados para desenhar o lado do quadrado. Use esse recurso para que seu bloco fique o mais claro possível ao
usuário, uma vez que um mesmo bloco pode receber vários valores para diferentes funções.
132
Figura 238 - Inserindo uma entrada, "distancia" em “passos”.
Pronto, na guia “Mais Blocos” seu bloco “quadrado” está pronto, agora com a possibilidade de receber
argumentos, como mostra a Figura 239 abaixo:
Figura 239 - Bloco com caixa para entrada de argumentos e parâmetros.
No bloco definido, você notará uma pequena mudança: o bloco agora possui um “parâmetro”, que na verdade é
uma variável, “distancia”, sendo nela armazenado o valor que você digitar no bloco “quadrado n passos”.
Figura 240 - Definição do bloco agora com o parâmetro "distancia".
É esse parâmetro que será passado para o comando “mova n passos” dentro do laço “repita” em sua definição do
comando. E como fazer isso? Basta que você arraste o parâmetro “distância” para a caixa “mova 10 passos”,
substituindo o valor “10”.
Figura 241 - Arraste o parâmetro “distancia” para o bloco.
Dessa maneira, nosso script ficará como o apresentado na Figura 242 abaixo, com cada bloco “quadrado n passos”
apresentando seu próprio valor, possibilitando que os quadrados desenhados tenham tamanhos diferentes:
133
Figura 242 - Script final para os três quadrados.

Exemplo 06
Que tal criar um jardim virtual usando o Scratch? Nesse exemplo, vamos desenhar uma série de flores, de diferentes
cores e tamanhos, e em posições aleatórias do palco. Para isso, utilizaremos alguns dos comandos já vistos, e
criaremos um novo bloco denominado “flor”, que será o responsável pelo desenho das flores quando for executado
o script principal.
O desenho
Figura 243 - Flor que será desenhada várias vezes pelo script.
O desenho da Figura 243, uma “flor”, será desenhado repetidas vezes ao longo da execução do script, assumindo
diferentes tamanhos e cores.
Criando uma flor
134
Vamos imaginar que, essa figura da flor criada para esse exemplo, possa vir a ser utilizada em outros momentos
mais com o Scratch, em uma outra animação, por exemplo. Seria então interessante que ela pudesse ser
“recuperada” para esse fim, não acham?
Para que isso seja possível, vamos criar um novo bloco denominado de “flor”, que será o responsável pelo desenho
das flores. Clique na guia de scripts e selecione a opção “Mais blocos”. Clique agora no botão “Criar um bloco”,
para ter acesso a caixa de diálogo “Novo bloco”.
Figura 244 - Criando um novo bloco.
Escreva o nome “flor” para o novo bloco. Como as flores terão tamanhos variados, o novo bloco deverá ter uma
caixa para que o valor para o tamanho das flores seja digitado, por isso, clique na opção “Adicionar entrada
numérica”, dando ao usuário a possibilidade de informar o tamanho que a flor terá ao ser desenhada.
Figura 245 - Nome do bloco e caixa para entrada de valores numéricos.
Seu novo bloco deverá ter a aparência do bloco da Figura 246 a seguir:
Figura 246 - Bloco "flor".
Agora que o bloco foi criado, vamos definir o seu script. O principal desse script, é que ele vai conter os comandos
para o desenho da flor, com todas as suas sete pétalas:
135
Figura 247 - Script para o bloco "flor".
Para completar, vamos ao script principal, aquele que faz a chamada do desenho da flor e diz quantas delas serão
desenhadas ao final:
Figura 248 - Script principal para execução dos desenhos.
Neste script, são definidas: a cor inicial da caneta, o número de flores que serão desenhadas e o tamanho de cada
uma das flores. Ao ser executado, o resultado final é semelhante ao apresentado pela Figura 249 abaixo:
136
Figura 249 - Desenho final das flores.
Pronto, seu quadro de flores está finalizado! Agora, acesse a página do projeto e faça as alterações que imaginar,
crie seus próprios efeitos e formas.
137
REFERÊNCIAS
Sobre o Scratch:
Scratch is developed by the Lifelong Kindergarten Group at the MIT Media Lab. It is available for free at
https://scratch.mit.edu.
Sobre as imagens:
Todas as imagens e figuras utilizadas nesse livro foram produzida pelo próprio autor, com exceção das figuras
indicadas abaixo, que foram retiradas do site Freepik (http://www.freepik.com) estão devidamente indicadas a
seguir:
• Página 4: Worker with doubts. Designed by Alekksall / Freepik.

• Página 4: Businessman get na idea. Designed by Dooder / Freepik.
• Página 5: Little boy playing shapes. Designed by brgfx / Freepik.
• Página 11: Worker with doubts. Designed by Alekksall / Freepik.
• Página 30: Raposa e Foguete. Designed by Freepik.
• Página 72: Open box. Designed by Freepik.
Sites consultados no desenvolvimento desse material:
• Scratch Oficial: https://scratch.mit.edu

• ScratchED: http://scratched.gse.harvard.edu/
• Scratch Foundation: https://www.scratchfoundation.org/
Aprenda mais sobre o Scratch nas páginas oficiais do autor, Paulo Nunes. Ele mantém blogs e um canal de vídeos
onde aborda vários assuntos ligados a programação e outras ferramentas da Web:
• Canal do Paulo Nunes (https://www.youtube.com/user/pcnunes/): Canal com diversos vídeos ensinando

como trabalhar com o Scratch e várias outras ferramentas da Web.
• O professor e a rede (https://oprofessorearede.blogspot.com.br/): É um blog dedicado a professores e
educadores em geral. Aqui são apresentados vários assuntos que podem ser importantes para quem ensina
e quer utilizar tecnologia em suas aulas.
Obrigado!

Programação Com Scratch: Ensinando Programação Na Escola.

Enviado por

Dados do documento

Título original

Direitos autorais

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Programação Com Scratch: Ensinando Programação Na Escola.

Enviado por

Direitos autorais:

PAULO NUNES

Ensinando programação na escola.

Dominar uma ou várias dessas linguagens faz de você um “programador de

Mas, essas linguagens de programação me parecem complicadas...

O Scratch é uma criação do grupo Lifelong Kindergarten no Media Lab do Massachusetts

Professor Paulo Nunes.

O que eu posso fazer com o Scratch?

Os professores e pais, podem por exemplo, criar diferentes aplicações com o

Onde conseguir o Scratch.

Figura 1- A tela inicial da página oficial do Scratch na Web.

Começando a usar o programa

Figura 2 - A tela de trabalho do Scratch. Versão Online.

Figura 3 - Como baixar o editor para instalação em seu computador.

Figura 4 - A versão mais atual do programa para instalação do Scratch.

Figura 5 - Versões do programa Scratch e Adobe Air, e material de estudo do Scratch.

Qual utilizar, versão instalada ou a versão online?

Neste material, nos concentraremos no uso da versão online.

Fazendo parte da comunidade Scratch

Figura 6 - Aderir a comunidade do Scratch criando sua própria conta.

Entrando na sua área de usuário Scratch

Figura 8 - Pronto para entrar como usuário do Scratch.

Figura 9 - Iniciando o login em sua conta Scratch.

Figura 10 - A sua página pessoal de projetos do Scratch.

Figura 11 - Informações de seu perfil e projetos pessoais do Scratch.

Figura 12 - O ícone "Minhas Coisas" e a opção "Minhas Coisas".

Figura 13 - A página de suas criações, com todos os seus projetos gravados.

Figura 14 - Ordenando e organizando suas criações.

Conhecendo o ambiente de criação do Scratch

Figura 15 - A tela do Editor de Scripts do Scratch.

Barra de Menus. Ela apresenta os principais

Ferramentas de Cursor. Quando selecionadas, agem sobre os elementos como atores e

Palco. Um dos principais elementos do editor, pois é nele que ocorrem

Lista de Atores. Espaço onde

Paleta de Fantasias. Permite que

Mochila. O nome já sugere a função desse elemento:

Área de Scripts. É para cá que os blocos devem ser arrastados e

Figura 24 - Área de Scripts.

Outras funções. São funções que tratam da sua

Figura 27 - Carregando uma imagem da biblioteca do Scratch.

Vamos usar a imagem “Blue Sky”.

Figura 28 - Biblioteca de panos de fundo e suas opções de imagens.

Figura 29 - Cena montada com o pano de fundo Blue Sky aplicado.

Figura 30 - Seleção do ator para inserir scripts.

Figura 31 - Blocos de comandos formando o script para execução.

URL do exemplo na Web: https://scratch.mit.edu/projects/175399127/

Bloco Descrição do Bloco Categoria do Bloco

Entendendo os movimentos no Scratch

Figura 32 - As divisões do palco em coordenadas.

• Quando x > 0 e y > 0 - direita e acima – Quadrante 1

Figura 33 - Divisão do palco em quadrantes.

Figura 34 - Posicione o ponteiro do mouse no palco e veja as coordenadas de "x" e "y".

Os primeiros deslocamentos pelo palco

Figura 37 - Deslocando o gato para uma nova posição no palco.

Figura 38 - Outros comandos de movimento do tipo absoluto.

Figura 39 - Inserindo um novo ator no palco.

Figura 40 - Selecionando o novo ator.

Figura 41 - O novo ator, "Rato", em sua posição no palco.

Figura 42 - Ferramenta para reduzir o tamanho do ator.

Figura 43 - O rato em tamanho reduzido.

Figura 44 - O bloco "deslize por...", no script do gato.

Figura 45 - A borda na cor amarela mostra os blocos de script em execução.

Figura 46 - O gato "deslizando" pelo palco até a posição do rato.

Figura 47 - Movimentando o gato até o rato, utilizando duas formas.

Analisando esse código, teremos a seguinte execução:

URL do exemplo na Web: https://scratch.mit.edu/projects/175986877/

Figura 48 - Comandos para execução de movimentos relativos.