Introducao a programacao de jogos

Prévia do material em texto

Guia de Navegação
Introdução à Programação de Jogos
Prefeitura da Cidade do Rio de Janeiro 
e Secretaria Municipal da Cultura apresentam
SUMÁRIO
Apresentação.................................................................................................................................................
Unidade 1: Introdução à lógica de programação para jogos...........................
 Por que estudar lógica de programação para jogos?..............................................
 Entendimento e resolução de problemas.....................................................................
 Criação de sistemas coerentes e funcionais..............................................................
 Pensamento computacional para resolver problemas complexos...........
 Componentes do pensamento computacional aplicado a jogos..............
 O que é um algoritmo?.....................................................................................................................
Unidade 2: Fundamentos da programação no-code.......................................
 O que é “no-code”?............................................................................................................................
 O que é “with-code” ou programação tradicional?....................................................
 Diferença no “no-code” para a programação tradicional...............................
 Como o no-code auxilia no aprendizado de programação?.........................
 Importância do no-code para trabalhar a lógica de programação........
Unidade 3: Criação de sistemas para jogos digitais.........................................
 O que é um sistema?.........................................................................................................................
 O que é um sistema de jogo digital?.....................................................................................
 Principais componentes de um sistema de jogo digital....................................
 Fundamentos da programação...............................................................................................
 Variáveis e tipos de dados.......................................................................................................
 Condicionais.......................................................................................................................................
 Estruturas de repetição...............................................................................................................
 Operadores lógicos.......................................................................................................................
 Funções ou métodos....................................................................................................................
 Entrada e saída de dados (I/O)............................................................................................
 Estrutura de algoritmos..............................................................................................................
 Eventos....................................................................................................................................................
 Boas práticas de programação...........................................................................................
 Uso do no-code em plataformas.............................................................................................
 Unity com Visual Scripting........................................................................................................
 Unreal Engine com Blueprints.................................................................................................
 Scratch com programação em blocos................................................................................
 O que é Scratch?..............................................................................................................................
 Interface do Scratch......................................................................................................................
 Áreas dos blocos.............................................................................................................................
 O plano cartesiano: Eixos X e Y..............................................................................................
 Como o plano cartesiano se aplica no Scratch?.....................................................
 Quadrantes..........................................................................................................................................
Glossário............................................................................................................................................................ 
Referências.......................................................................................................................................................
2Introdução à Programação de Jogos 
3
4
4
4
5
5
5
7
8
8
8
8
9
10
12
12
12
12
14
14
15
16
17
18
19
20
21
21
22
22
22
23
24
24
25
31
33
36
38
39
Apresentação
No curso anterior, de Introdução ao Game Design, você passou por etapas
fundamentais para o desenvolvimento de todo jogo: a ideação (desenvolver
uma ideia), a pesquisa (de referências, dos assuntos abordados no jogo, entre
outras), a roteirização (criação da narrativa e personagens, se houver), a
escolha das mecânicas e regras (formas de jogar), e o balanceamento das
fases (níveis de dificuldade, desafios etc.). Todas essas definições foram
organizadas no GDD, documento que servirá de guia para você e para todas as
demais pessoas envolvidas no desenvolvimento desse projeto.
Com essas definições prévias, podemos agora aterrissar em outra área
fundamental para transformar ideias em um jogo de verdade, que possa ser
jogado por você, seus amigos e amigas ao final dessa jornada de estudos: a
Programação de Jogos! Você já ouviu falar na profissão de Programador(a)?
Ela é, sem dúvida, uma das mais requisitadas do momento, pois é essa pessoa
quem consegue fazer funcionar, usando diferentes linguagens de computador,
qualquer tipo de produto digital, seja ele um site, um aplicativo ou um jogo!
A área de Programação de Jogos utiliza bastante pensamento lógico e
matemático, mas não há necessidade de se assustar com isso, caso essas não
sejam suas matérias preferidas na escola. Hoje em dia, existem sites e
programas que nos ajudam a programar sem precisar escrever uma linha de
código, apenas movendo blocos pela tela. Essa é a chamada Programação
Sem Código (ou No-Code, na sua expressão original em inglês), a mesma que
usaremos para programar nossos jogos aqui. E se você se encantar por essa
área que parece fazer mágica, procure se aprofundar na Programação com
códigos também! 
Neste curso, vamos abordar:
A importância da lógica de programação na criação de jogos;
Pensamento computacional para resolver problemas complexos; 
Programação No-Code: o que é, vantagens, limitações e importância; 
Motores de criação de jogos No-Code;
Fundamentos de Programação; 
Tutorial Scratch: comece a programar o seu jogo!
Então prepare-se para mergulhar no fascinante universo da programação de
jogos! Leia o material, assista às videoaulas de apoio e não deixe de fazer as
atividades! Ao final deste curso, esperamos que você esteja com o seu sistema
de jogo programado! 
Bons estudos!
3Introdução à Programação de Jogos 
UNIDADE 1
Introdução À lógica de
programação para jogos
Nesta unidade, abordaremos a importância da Lógica de Programação na criação de
jogos e o pensamento computacional como técnica para resolver problemas
complexos. Também vamos conhecer e fazer exercícios simples de algoritmo. 
Por que estudarmaior.
Prototipagem rápida: como o desenvolvedor utiliza uma
interface visual, o processo de criação é muito mais rápido
do que escrever código manualmente.
3
Não se preocupe se você ainda não conhece esses termos, pois
eles serão apresentados na Unidade 3 do curso. 
Baixa curva de aprendizado: a maioria das plataformas no-code oferece tutoriais
intuitivos, exemplos prontos e templates, facilitando a compreensão de como
construir um jogo. 
Foco na lógica e na criatividade: a ferramenta no-code permite que o usuário
foque em desenvolver a lógica e a criatividade em vez de detalhes de
codificação.
 Limitações do no-code: 
Apesar de ter muitas vantagens, o no-code traz junto algumas
limitações. Devido a sua rapidez e facilidade, recursos são
limitados ao que tem disponível na ferramenta, incluindo a
capacidade de personalização de alguns sistemas.
Ao lidar com uma ferramenta no-code, temos que ter noção
sempre das limitações de cada ferramenta, sendo elas em
sua maioria:
Personalização limitada: O no-code depende de ferramentas visuais e
componentes pré-construídos, pode ser difícil ou inviável personalizar certas
características do sistema do jogo, essa limitação geralmente não ocorre na
programação tradicional.
10Introdução à Programação de Jogos 
Personalização limitada: o no-code depende de ferramentas visuais e
componentes pré-construídos, pode ser difícil ou inviável personalizar certas
características do sistema do jogo, essa limitação geralmente não ocorre na
programação tradicional.
Complexidade reduzida: reduzir a complexidade não deveria ser bom? Nesse
caso, pode ser ruim. Às vezes, jogos divertidos requerem mecânicas complexas,
sistemas avançados de IA ou gráficos de qualidade, e dependendo da
plataforma esses recursos podem não estar disponíveis para utilização.
Performance: jogos desenvolvidos com ferramentas no-code podem não ser tão
otimizados quanto aqueles feitos com programação tradicional, isso fica mais
evidente quando estamos trabalhando com plataformas fechadas como
consoles e/ou dispositivos móveis de baixa capacidade.
Dependência de ferramentas: O desenvolvedor fica limitado às funcionalidades e
recursos oferecidos pela ferramenta, sendo difícil ir além do que a plataforma
disponibiliza.
Importância do No-cOde para trabalhar a lógica de
programação
Ao utilizar ferramentas no-code, o estudante de desenvolvimento de jogos pode se
concentrar na lógica de programação, trabalhando o entendimento de aspectos
como:
Abordagem baseada em eventos: os usuários podem definir ações a serem
executadas em resposta a eventos específicos (como cliques, colisões, etc.). Isso
ajuda a entender como eventos e ações interagem, permitindo a decomposição
do problema em partes menores.
Quebra de problemas em blocos: o no-code geralmente utiliza blocos de
construção (como ações, condições e loops) que podem ser combinados para
formar a lógica de um programa. Essa abordagem ajuda os usuários a entender
como as partes individuais contribuem para o todo, promovendo uma melhor
compreensão da decomposição de algoritmos.
Experimentação: os usuários podem testar diferentes abordagens para resolver
um problema sem medo de "quebrar" o código. Essa liberdade para experimentar
promove um aprendizado mais eficaz e reforça a ideia de que a programação é
um processo iterativo de tentativa e erro.
Pensamento crítico: ao trabalhar com ferramentas no-code, os usuários são
incentivados a pensar criticamente sobre como resolver problemas. Eles
aprendem a identificar quais componentes são necessários, como organizar a
lógica e como os diferentes elementos interagem, o que é essencial para a
decomposição de algoritmos.
Agora que você sabe as vantagens, as limitações e a importância do uso do no-code
na programação, precisamos exercitar a decomposição de problemas em blocos.
Para isso, vamos visitar a plataforma “Hora do Código” e lá veremos como podemos
executar uma ação a partir de blocos e sequenciamento de instruções.
Mas antes, você precisa analisar se sua plataforma está em português ou
inglês. Caso esteja na língua inglesa, acessar o botão
no canto inferior esquerdo da tela. Mude este valor para
e você verá que sua página irá recarregar. 
Agora que você sabe onde está a dica, repare que abaixo disso terá um campo
chamado e outro ao lado chamado , 
Ao entrar no Link 1, uma página carregará e lhe mostrará um vídeo, assista-o se
quiser e após isso clique no X para fechar.
Atividade
Hora do Código 
Na plataforma Hora do Código, você irá acessar os dois links,
em cada um deles terá um conjunto de desafios que deverá
ser cumprido:
Link 1 Link 2
Feito isso, selecione seu personagem utilizando o botão . Então irá
aparecer em realce a dica do que você precisa fazer.
esses números ao lado indicam o número de blocos utilizados / número de
blocos recomendados. Dentro da área de trabalho você colocará toda sua
lógica para resolver o desafio, sempre conectando um bloco abaixo do outro.
Depois de definir sua lógica, procure na esquerda da tela um botão chamado
. Ao pressioná-lo, ele irá executar sua lógica para saber se irá
completar o desafio ou não.
Ao terminar o desafio, clique em . 
Se você conseguiu completar o desafio, precisa identificar como ficou o
marcador do último desafio.
Se ficou com este símbolo, significa que o desafio foi concluído, mas
precisa melhorar o algoritmo.
Se ficou com este símbolo, significa que você gabaritou o desafio. 
Agora faça com atenção os desafios dos dois links e divirta-se no processo!!
11Introdução à Programação de Jogos 
https://studio.code.org/s/aquatic/lessons/1/levels/1?lang=pt-BR
https://studio.code.org/s/mc/lessons/1/levels/1?lang=pt-BR
12Introdução à Programação de Jogos 
Nesta unidade, esperamos que você tenha se familiarizado com a programação
no-code e experimentado algumas das vantagens dessa forma fácil e acessível de
programar. A seguir, vamos aprofundar os fundamentos da programação e da
criação de sistemas para você começar a criar o seu!
UNIDADE 3
Criação de sistemas 
para jogos digitais 
Nesta unidade, serão abordados o conceito e os componentes de um sistema de
jogo digital, além dos fundamentos da programação. Em seguida, serão
apresentadas ferramentas de programação de jogos no-code e o funcionamento
mais detalhado de uma delas.
O que é um sistema?
00:50
Sistemas podem ser definidos como conjuntos de elementos interconectados que
têm objetivos comuns. No corpo humano, por exemplo, temos os sistemas
respiratório, digestivo, entre outros, que são conjuntos de órgãos que interagem por
um objetivo comum: respirar, digerir etc. 
Em um sistema digital, também temos elementos que se conectam e trabalham
juntos por um objetivo final. E um jogo é, sem dúvida, um sistema! Todos os seus
componentes devem se comunicar de forma eficiente pro jogo funcionar bem.
O que é um sistema de jogo digital?
Um sistema de jogo digital é um conjunto de componentes e regras que formam a
estrutura de um jogo eletrônico, proporcionando a interação entre o jogador e o
mundo virtual. Ele é composto por diversas camadas e subsistemas que funcionam
juntos para criar a experiência de jogo. Essas camadas incluem a lógica do jogo, a
apresentação visual e sonora, e os mecanismos que permitem ao jogador interagir
com o jogo.
Principais componentes de um sistema de jogo digital 
Motor de jogo (game engine): É a base do desenvolvimento de jogos digitais. Ele
oferece as ferramentas necessárias para criar e gerenciar os elementos
fundamentais de um jogo, como gráficos, física, som e inteligência artificial.
01:17
13Introdução à Programação de Jogos 
Lógica de jogo: define as regras e as mecânicas que controlam o funcionamento
do jogo. Isso inclui o comportamento dos personagens, o controle das
pontuações, a evolução das fases, condições de vitória e derrota, e como os
eventos acontecem dentro do ambiente virtual.
Interfacede usuário: abrange os elementos visuais que permitem ao jogador
interagir com o jogo, como menus, barras de status, inventários e controles do
jogo. Ela facilita a comunicação entre o jogador e o sistema.
Sistema de entrada (input): Refere-se aos métodos de entrada que permitem ao
jogador controlar o jogo. Isso inclui o uso de teclado, mouse, controles, telas
sensíveis ao toque ou até mesmo dispositivos de realidade aumentada/virtual. O
sistema de jogo processa esses comandos e os traduz em ações no mundo do
jogo.
Mundo do jogo: o mundo do jogo é o ambiente virtual onde a ação acontece. Ele
pode ser bidimensional (2D) ou tridimensional (3D), e inclui cenários, objetos,
personagens não-jogáveis (NPCs), entre outros elementos com os quais o jogador
interage. A construção desse mundo envolve o design de níveis, a criação de
cenários e a disposição de elementos interativos.
Física e simulação: muitos jogos utilizam motores de física para simular
interações realistas entre objetos, como colisões, gravidade e movimento. Isso
ajuda a criar uma sensação de imersão, especialmente em jogos de ação,
esportes ou corrida, onde as interações físicas são importantes. Mas não precisa
ser um expert em física para utilizar esses motores.
Inteligência Artificial (IA): a IA controla o comportamento de personagens não-
jogáveis (NPCs) e outros elementos automatizados do jogo. A IA como esses
personagens reagem às ações do jogador e como interagem com o ambiente,
criando desafios e tornando o jogo dinâmico. Na maioria dos casos, a IA não tem
um pensamento próprio, geralmente o programador informa um conjunto de
reações, e a depender de uma ação, a IA utiliza uma reação pré-programada
dentro do seu sistema.
Gráficos e animação: O sistema de renderização gráfica gera as imagens que o
jogador vê na tela. Isso inclui o design visual de personagens, cenários e efeitos
visuais. Animação é o processo de dar movimento e vida aos personagens e
objetos no jogo.
Som e música: O sistema de áudio inclui efeitos sonoros, música de fundo e vozes
dos personagens, que contribuem para a imersão do jogador no mundo do jogo.
O som é cuidadosamente sincronizado com as ações e eventos do jogo.
Imagine um jogo de ação em plataforma, onde o jogador controla um personagem
que deve lutar contra inimigos em um universo 2D. O sistema desse jogo envolve:
O motor do jogo, controlando gráficos, física e som.
A lógica do jogo, definindo como o personagem deve se mover, atacar e interagir
com os objetos.
A IA controlando os inimigos, reagindo às ações do jogador.
O sistema de input (entrada), capturando os comandos do controle ou teclado.
14Introdução à Programação de Jogos 
O sistema de renderização, exibindo tudo de forma visual para o jogador, com
animações detalhadas.
Em resumo, o sistema de um jogo digital é um conjunto complexo de componentes
conectados entre si que criam uma experiência de jogo interativa e envolvente. Ele é
responsável por tudo, desde a renderização dos gráficos até a inteligência artificial
dos inimigos e a interação do jogador, garantindo o funcionamento do jogo de
maneira justa e divertida.
Fundamentos da programação
01:40
Programar envolve uma série de conceitos fundamentais que são importantes de
dominar para construir programas de forma eficiente. Esses conceitos formam a
base da maioria das linguagens de programação. A familiaridade com essas ideias
permitirá que você se adapte facilmente a diferentes linguagens e plataformas.
variáveis e tipos de dados 
Variáveis são espaços reservados na memória para armazenar informações que
podem ser modificadas durante a execução do programa. Cada variável tem um tipo
de dado associado, como números inteiros (int), números decimais (float), caracteres
(char), palavras ou frases (string) e valores booleanos (bool) que são verdadeiros ou
falsos, isso determina as operações que podem ser realizadas sobre elas.
Números inteiros (int)
Números decimais (float)
Caracteres (char)
Palavras ou frases (string)
Valores booleanos (bool)
Vida: 
100
Experiência: 
150.75
Inicial: 
E
Nome: 
Eldrin
Em combate: 
Verdadeiro
15Introdução à Programação de Jogos 
Condicionais 
Condicionais são estruturas de controle usadas em programação para tomar
decisões com base em condições específicas. Elas permitem que o programa
execute blocos de código diferentes dependendo do resultado de uma expressão
lógica. O exemplo mais comum é a estrutura if-else, onde o código dentro de um if é
executado se a condição for verdadeira, e o bloco else é executado caso contrário. As
condicionais ajudam a tornar o programa dinâmico, permitindo que ele reaja de
maneiras diferentes a diferentes entradas ou situações, como verificar se o jogador
colidiu com um obstáculo.
Se (if) o ataque for bem-sucedido, causar dano ao inimigo. 
Caso contrário (else), o inimigo contra-ataca. 
16Introdução à Programação de Jogos 
Enquanto houver itens não coletados, mover personagem. 
estruturas de repetição
As estruturas de repetição, ou loops, permitem que um bloco de código seja
executado várias vezes, enquanto uma condição específica for verdadeira. Essas
estruturas são essenciais para automatizar tarefas repetitivas, como calcular a física
do jogo, calcular a taxa de atualização (FPS) do jogo, calcular as IAs, ou seja, tudo que
precisa ser constantemente verificado necessita estar dentro de uma estrutura de
repetição (loop).
Operadores lógicos
Os operadores lógicos (E, OU, NÃO) são usados em programação para combinar ou
modificar expressões booleanas (verdadeiro ou falso). Eles são fundamentais em
estruturas de decisões, como condicionais e loops, permitindo criar condições mais
complexas. Por exemplo, podemos definir que um personagem só pode abrir uma
porta se tiver a chave correta E se estiver no nível certo do jogo.
Mago só pode abrir a porta se tiver a chave correta E estiver no
nível 15.
17Introdução à Programação de Jogos 
18Introdução à Programação de Jogos 
funções ou métodos
Funções são blocos de código reutilizáveis que executam uma tarefa específica, o
que ajuda a dividir o programa em partes menores e mais fácil de gerenciar. Elas
podem receber dados e retornar um resultado.
Pode abrir a porta?
Tem a chave correta? Está no nível correto?
Sim Não Sim Não
E
Não abrir Não abrir
Abrir
19Introdução à Programação de Jogos 
entrada e saída de dados (i/o)
Entrada e saída de dados se referem a como um jogo interage com o mundo externo.
A entrada pode vir de um teclado, mouse, controle, tela sensível ao toque, enquanto a
saída pode ser exibida na tela, sons que são emitidos e comunicação com banco de
dados, permitindo que o jogo seja funcional em diferentes cenários.
Entrada de dados 
Saída de dados
20Introdução à Programação de Jogos 
Estrutura de algoritmos
Algoritmos são conjuntos de passos que resolvem um problema ou realizam uma
tarefa. No caso de jogos digitais, cada mecânica de jogo pode ser entendida como
um algoritmo, então podemos ter algoritmo de pulo, movimentação, combate,
câmera entre outras mecânicas que podem ser desenvolvidas. 
Algoritmo de pulo:
1) Verificar se o jogador pressionou o botão de pulo. 
2) Aplicar força para cima. 
3) Verificar se o personagem está no chão. 
21Introdução à Programação de Jogos 
Eventos
Em desenvolvimento de jogos, eventos são ações ou mudanças que ocorrem no jogo
e desencadeiam uma resposta programada. Esses eventos podem ser gerados pelo
jogador (como pressionar um botão ou clicar em um objeto) ou pelo próprio sistema
(como o término de um tempo ou a colisão entre dois objetos). A lógica do jogo é
frequentemente construída em torno desses eventos, como mover personagens,
pular, ativar animações ou gerar inimigos. Eventos tornam o jogo dinâmico e
interativo, respondendo de forma reativa às ações dentro do jogo.
Término do tempo de uma interação, levando ao game over. 
Boas práticas de programação
Boas práticas incluem manter a estrutura de blocos (ou código)
clara, organizada e legível, usando nomes de variáveis efunções
coesas, documentando o código com comentários apropriados, e
seguindo convenções de estilo da linguagem. Essas práticas
tornam a estruturas de blocos fácil de manter, melhorar e de
entender.
22Introdução à Programação de Jogos 
USO DO NO-CODE EM PLATAFORMAS
02:10
O uso de ferramentas no-code no desenvolvimento de jogos tem se tornado uma
tendência crescente, permitindo que pessoas sem conhecimento avançado em
programação criem jogos funcionais e atrativos. Plataformas no-code oferecem
interfaces visuais intuitivas, onde os desenvolvedores podem arrastar e soltar
elementos, configurar comportamentos, criar mecânicas de jogo e integrar recursos
como gráficos e sons, sem escrever uma única linha de código. Essas ferramentas
democratizam o acesso ao desenvolvimento de jogos, facilitando a criação de
protótipos rápidos e até jogos completos, tornando o processo mais acessível tanto
para iniciantes quanto para profissionais que buscam agilidade. 
Conheça algumas ferramentas gratuitas para programar jogos sem código:
unity com visual scripting
O Unity Visual Scripting permite criar lógicas complexas para jogos, conectando
blocos que representam ações ou comportamentos. Por exemplo, podemos criar um
sistema de movimento para um personagem que permite que ele se mova quando o
jogador pressiona as teclas de direção.
Acesse
unreal engine com blueprints
Os Blueprints são uma ferramenta poderosa que permite a criação de mecânicas e
comportamentos sem escrever código. É possível, por exemplo, criar um sistema de
saúde para o personagem que diminui sempre que ele é atingido por um inimigo.
Acesse
scratch com programação em blocos
O Scratch é uma excelente plataforma para iniciantes, pois permite criar jogos
inteiros apenas conectando blocos de instruções. Podemos criar um jogo onde um
personagem coleta frutas, e cada vez que ele coleta uma fruta, a pontuação
aumenta.
Acesse
Acesse os sites dessas plataformas e explore os recursos disponíveis!
https://unity.com/pt/features/unity-visual-scripting
https://www.unrealengine.com/pt-BR
https://scratch.mit.edu/
23Introdução à Programação de Jogos 
Atividade
Criando meu primeiro jogo no Scratch
O objetivo deste trabalho é programar os sistemas principais
do jogo idealizado no seu Game Design Document (GDD).
Caso seja necessário, você pode revisar e/ou reescrever
partes do seu GDD original para alinhar melhor o escopo do
projeto com a construção dos sistemas. 
É importante garantir que as mecânicas e sistemas principais estejam claros e
detalhados.
Você deverá implementar as funcionalidades principais do jogo, essas
funcionalidades incluem: sistemas de controles de personagem, sistema de
pontuação, condição de vitória e derrota, gerenciamento de níveis (caso tenha),
entre outros elementos principais que compõem a jogabilidade.
A implementação de arte visual e sonora ficará para uma fase posterior. Para
esta etapa, podem ser utilizados outros arquivos visuais e sonoros que
representem as mecânicas implementadas.
Termos do Scratch
Essas duas palavras serão muito usadas a partir de agora, por
isso, deixamos aqui suas definições.
Script: um local (arquivo) com um conjunto de instruções (blocos)
que irá comandar um programa.
Sprites: representações gráficas básicas em jogos 2D. Eles podem
ser personagens, objetos interativos, itens ou até efeitos visuais,
como explosões ou partículas.
O que é o scratch?
03:25
Scratch é um ambiente de programação baseado em blocos, projetado para ser
intuitivo, especialmente para quem está começando. Os comandos são
representados por blocos coloridos, que podem ser encaixados para formar scripts.
Você pode acessar o Scratch clicando neste link. 
interface do scratch
Quando você acessa o site do Scratch, verá as seguintes áreas principais:
Blocos 
Scripts Palco
Sprites
Na parte superior direita da tela:
Palco: aqui você vê os resultados da sua programação, onde os objetos
(personagens, itens), chamados de sprites, se movem e interagem.
Na parte esquerda da tela:
Blocos: é onde você encontra os blocos de código, divididos em categorias como
movimento, aparência, som, controle, etc.
No centro da tela:
Scripts: nesta área, você arrasta os blocos para formar os scripts que controlam
os sprites.
24Introdução à Programação de Jogos 
https://scratch.mit.edu/projects/editor/
25Introdução à Programação de Jogos 
Na parte inferior direita da tela:
Sprites: lista os sprites que você está usando no projeto.
No canto inferior direito da tela:
Palco e planos de fundo: Aqui você pode modificar o cenário onde os sprites vão
interagir.
Área dos blocos 
Os blocos no Scratch são a base para a programação visual da plataforma, e eles
estão organizados em categorias com cores específicas, facilitando a identificação e
uso. Conheça cada uma dessas categorias e os blocos importantes dentro delas.
Blocos de movimento (azul) 
Esses blocos controlam o movimento dos sprites no palco. Eles permitem que os
personagens se movam, girem, ou se posicionem em diferentes coordenadas no
cenário.
Vá para x: [valor] y: [valor]: teletransporta o sprite para uma posição específica
no palco, utilizando o sistema de coordenadas (X, Y).
Mover [valor] passos: faz o sprite se mover para frente ou para trás, dependendo
do número (positivo ou negativo).
Aponte para a direção [valor]: muda a direção do sprite para um determinado
ângulo (0 é para cima, 90 é para a direita, 180 para baixo, e 270 para a esquerda).
Deslizar 1 segundo para x: [valor] y: [valor]: move o sprite suavemente de sua
posição atual até uma nova coordenada ao longo de um tempo determinado.
Blocos de aparência (roxo)
Esses blocos controlam a aparência do sprite, como mudanças de figurino, balões de
fala e efeitos visuais.
Mostre / Esconda: Faz o sprite aparecer ou desaparecer do palco.
Diga [mensagem] por [2] segundos: exibe uma fala acima do sprite por um
tempo determinado.
Mudar para a fantasia [nome]: muda o figurino atual do sprite (útil para
animações).
Mudar [valor] ao efeito [cor]: aplica um efeito visual ao sprite, como brilho,
transparência ou cor.
Blocos de som (rosa)
Esses blocos são usados para tocar sons e controlar o volume de áudio no projeto.
26Introdução à Programação de Jogos 
Tocar o som [nome] até o fim: toca o som selecionado até terminar.
27Introdução à Programação de Jogos 
Toque o som [nome]: permite a criação de música, tocando diferentes
instrumentos.
Mudar o volume para [valor]%: aumenta ou diminui o volume do som durante a
execução.
Blocos de eventos (amarelo)
Blocos de eventos são usados para iniciar scripts com base em certas ações ou
interações, como clicar na bandeira verde ou pressionar uma tecla.
Quando bandeira verde for clicada: inicia o script quando o ícone da bandeira
verde é clicado.
Quando tecla [espaço] for pressionada: executa o script quando uma tecla
específica é pressionada.
Quando este ator for clicado: executa o script quando o sprite é clicado pelo
usuário.
28Introdução à Programação de Jogos 
Blocos de controle (laranja)
Esses blocos controlam o fluxo do programa. Eles são usados para laços (repetições),
condicionais e sincronização entre diferentes partes do código.
Esperar [1] segundo: pausa a execução do script por um tempo determinado.
Se [condição] então: executa um grupo de blocos se a condição for verdadeira.
Repita [10] vezes: repete o bloco interno um número específico de vezes.
Sempre: cria um laço infinito que continua repetindo os blocos dentro dele até o
programa ser parado.
29Introdução à Programação de Jogos 
Criar clone de [nome do ator]: cria uma cópia de um sprite. Útil para jogos que
precisam de múltiplos personagens ou objetos.
Blocos de sensores (azul claro)
Esses blocos verificam o que está acontecendo no palco, como colisões entre sprites,
toques no mouse, ou valores de sensores.
Tocando [borda/sprite]?: verifica se o sprite está tocando em outro sprite ou na
borda do palco.
Distância para [nome]: retorna a distância entre o sprite atual e o spriteselecionado.
Perguntar [pergunta] e espere: exibe uma caixa de entrada de texto onde o
usuário pode inserir uma resposta.
Posição x ou y do mouse: retorna a posição X do mouse no palco, permitindo
controlar os sprites com o cursor.
Blocos de operadores (verde)
Os blocos operadores são usados para fazer cálculos matemáticos e operações
lógicas.
30Introdução à Programação de Jogos 
[valor] + [valor]: adição de dois números.
[valor]selecionado.
Perguntar [pergunta] e espere: exibe uma caixa de entrada de texto onde o
usuário pode inserir uma resposta.
Posição x ou y do mouse: retorna a posição X do mouse no palco, permitindo
controlar os sprites com o cursor.
Blocos de operadores (verde)
Os blocos operadores são usados para fazer cálculos matemáticos e operações
lógicas.
30Introdução à Programação de Jogos 
[valor] + [valor]: adição de dois números.
[valor] < [valor]: verifica se o primeiro valor é menor que o segundo, retornando
“verdadeiro” ou “falso”.
Número aleatório entre [valor] e [valor]: gera um número aleatório dentro de um
intervalo.
E / OU / NÃO: blocos lógicos para combinar condições.
Blocos de variáveis (laranja escuro)
As variáveis permitem armazenar e modificar valores ao longo do jogo, como a
pontuação ou tempo.
Mude [nome da variável] por [valor]: inicializa ou redefine o valor da variável.
Adicione [valor] para [nome da variável]: adiciona ou subtrai um valor da variável.
Esses são os blocos principais que formam a base do Scratch. Combinando esses
blocos, você pode criar comportamentos complexos de maneira visual e fácil de
entender.
Para entender melhor como fazer a movimentação e lidar com valores de X e Y
dentro do Scratch, vamos ver um pouco sobre o plano cartesiano.
O plano cartesiano 2D é uma maneira de representar pontos e movimentos em um
espaço bidimensional, que é amplamente usado em matemática e em plataformas
como o Scratch para definir a posição dos personagens (sprites). 
Vamos explorar os eixos X e Y e entender por que usamos valores positivos e
negativos para mover para diferentes direções.
31Introdução à Programação de Jogos 
Mostrar a variável [nome]: exibe o valor da variável no palco.
Blocos de Meus blocos (vermelho)
Estes blocos permitem criar funções personalizadas para organizar melhor o código.
Criar um bloco [nome do bloco]: cria um bloco personalizado, que você pode
reutilizar em várias partes do projeto.
O plano cartesiano: Eixo X e Y
O plano cartesiano é formado por dois eixos perpendiculares (em formato de cruz).
Eixo X (horizontal): representa a posição de um objeto ao longo da horizontal, ou
seja, da esquerda para a direita.
Eixo Y (vertical): representa a posição ao longo da vertical, ou seja, de baixo para
cima.
Esses dois eixos se cruzam em um ponto chamado de origem, que tem as
coordenadas (0,0). A origem é o ponto de referência para calcular qualquer
movimento ou posição no plano.
1
-1
32Introdução à Programação de Jogos 
Eixo y
Eixo x0
-1-2-3 2 3
1
2
3
-2
-3
Coordenadas
Cada ponto no plano é representado por um par de números na forma (X, Y), onde:
X: Indica a posição ao longo do eixo horizontal.
Y: Indica a posição ao longo do eixo vertical.
Movimentos no Eixo X (horizontal)
Valores positivos de X (para a direita):
- Quando o valor de X aumenta (se torna positivo), estamos movendo o ponto ou
sprite para a direita no plano.
- Exemplo: Se a coordenada do sprite é (0, 0) e você move 10 passos para a direita,
sua nova posição será (10, 0).
Origem
(10,0)
(0,0)
Valores negativos de X (para a esquerda):
- Quando o valor de X diminui (se torna negativo), estamos movendo o ponto ou
sprite para a esquerda no plano.
- Exemplo: Se a coordenada do sprite é (0, 0) e você move -10 passos, sua nova
posição será (-10, 0).
Portanto, no eixo X:
X positivo move para a direita.
X negativo move para a esquerda.
Isso acontece porque o plano cartesiano define o movimento em relação à origem
(0,0). Valores maiores que 0 estão à direita da origem e valores menores que 0 estão
à esquerda.
(0,0)
(-10,0)
Movimentos no Eixo Y (vertical)
Valores positivos de Y (para cima):
- Quando o valor de Y aumenta, o sprite se move para cima no plano.
- Exemplo: Se o sprite está na posição (0, 0) e você move 10 passos no eixo Y, sua
nova posição será (0, 10).
33Introdução à Programação de Jogos 
Valores negativos de Y (para baixo):
34Introdução à Programação de Jogos 
- Quando o valor de Y diminui, o sprite se move para baixo no plano.
- Exemplo: Se o sprite está na posição (0, 0) e você move -10 passos no eixo Y, sua
nova posição será (0, -10).
Portanto, no eixo Y:
Y positivo move para cima.
Y negativo move para baixo.
Como o plano cartesiano se aplica no scratch?
No Scratch, o palco também segue o plano cartesiano 2D com o ponto central (0, 0)
na origem. O palco vai de -240 a 240 no eixo X (horizontal) e de -180 a 180 no eixo Y
(vertical), dependendo da resolução.5
(0,0)
(0,0)
(10,0)
(-10,0)
Se você quer mover o sprite para a direita, aumenta o valor de X. Por exemplo, o
bloco Mover 10 passos adiciona +10 ao valor atual de X.
Se você quer mover o sprite para a esquerda, diminui o valor de X, como ao usar
Mover -10 passos.
Da mesma forma, se você quer que o sprite suba, aumenta o valor de Y.
35Introdução à Programação de Jogos 
Para o sprite descer, diminui o valor de Y.
36Introdução à Programação de Jogos 
Em resumo, o plano cartesiano permite um controle preciso da movimentação no
Scratch, onde:
X positivo = direita
X negativo = esquerda
Y positivo = cima
Y negativo = baixo
Compreender esse conceito ajuda a controlar qualquer personagem de forma
eficiente, criando movimentações e interações mais ricas em seus projetos.
Quadrantes
Por fim, precisamos entender sobre quadrantes, outro conceito muito importante
para entendermos mais como funcionam coordenadas em jogos 2D.
Um quadrante é uma das quatro regiões em que o plano cartesiano é dividido pelos
eixos X (horizontal) e Y (vertical). Esses eixos se cruzam no ponto de origem (0,0), e
cada quadrante é delimitado por diferentes combinações de sinais (positivos e
negativos) para os valores de X e Y.
37Introdução à Programação de Jogos 
Aqui, tanto X quanto Y são
positivos.
Exemplo: Um ponto (3, 5) está
no primeiro quadrante, pois
ambos os valores são positivos.
X é negativo e Y é positivo.
Exemplo: O ponto (-3, 5) está
no segundo quadrante, porque
X é negativo e Y é positivo.
Tanto X quanto Y são negativos.
Exemplo: O ponto (-3, -5) está
no terceiro quadrante, com
ambos os valores negativos.
X é positivo e Y é negativo.
Exemplo: O ponto (3, -5) está
no quarto quadrante, pois X é
positivo e Y é negativo.
Por que entender os quadrantes é importante?
Os quadrantes ajudam a visualizar a posição de pontos em relação à origem no
plano cartesiano e a entender a direção dos movimentos em ambientes gráficos,
como o Scratch, onde os sprites podem se mover de acordo com as coordenadas (X,
Y). Eles são úteis para organizar e planejar o espaço de trabalho em problemas de
matemática, física e programação.
Nesta unidade, passamos por alguns conceitos importantes de sistemas e
programação de jogos digitais até chegarmos ao funcionamento detalhado de uma
plataforma de programação sem código. Esperamos que, com esses conhecimentos,
você comece a programar o seu jogo! 
38
Glossário
Softwares: programas de computadores. 1
Inputs: informações ou comandos que um usuário fornece a um sistema ou
programa, permitindo que ele reaja de maneira adequada. Nos jogos digitais, os
inputs podem incluir ações como pressionar botões, mover o mouse ou tocar na
tela, influenciando o comportamento dos personagens e a dinâmica do jogo.
2
Templates: modelos pré-definidos que servem como ponto de partida para a
criação de projetos, como jogos ou aplicativos. Os templates contêm estrutura,
layout e elementos básicos, permitindo que os usuários personalizem e construam
sobre eles. 
3
Consoles: um dispositivo eletrônico dedicado exclusivamente a jogar videogames.
Consoles são conectados a uma televisão e geralmente possuem controles
específicos para cada plataforma. Exemplos: PlayStation, Xbox, Nintendo Switch.
Existem também versões menores e portáteis de consoles de videogame,
projetados para ser jogados em qualquer lugar
4
Resolução: quantidade de pixels na tela. 5
Introdução à Programação de Jogos 
40
REFERÊNCIAS
NYSTROM, Robert. Game Programming Patterns. 1. ed. 2014. Disponível em:https://www.amazon.com.br/Game-Programming-Patterns-Robert-
Nystrom/dp/0990582906. Acesso em: 08 out. 2024.
NOVAK, Jeannie. Desenvolvimento de Games. 1. ed. São Paulo: Cengage Learning, 2011.
Disponível em: https://www.amazon.com.br/Desenvolvimento-games-Jeannie-
Novak/dp/8522106320. Acesso em: 08 out. 2024.
MARQUES, Fernando. Low-Code/No-Code: Surprising Applications for Developers. 1.
ed. 2022. Disponível em: https://www.amazon.com.br/Low-Code-No-Code-
Developers-Surprising-Applications/dp/B0BL2RTFQQ. Acesso em: 08 out. 2024.
SANTANA, Aline. Aprenda a Programação: Algoritmos e Implementações em
Portugol. 1. ed. São Paulo: Novatec, 2019. Disponível em:
https://www.amazon.com.br/Aprenda-Programa%C3%A7%C3%A3o-Algoritmos-
Implementa%C3%A7%C3%B5es-Portugol/dp/8539907798. Acesso em: 08 out. 2024.
Introdução à Programação de Jogos 
https://www.amazon.com.br/Game-Programming-Patterns-Robert-Nystrom/dp/0990582906
https://www.amazon.com.br/Game-Programming-Patterns-Robert-Nystrom/dp/0990582906
https://www.amazon.com.br/Desenvolvimento-games-Jeannie-Novak/dp/8522106320
https://www.amazon.com.br/Desenvolvimento-games-Jeannie-Novak/dp/8522106320
https://www.amazon.com.br/Low-Code-No-Code-Developers-Surprising-Applications/dp/B0BL2RTFQQ
https://www.amazon.com.br/Low-Code-No-Code-Developers-Surprising-Applications/dp/B0BL2RTFQQ
https://www.amazon.com.br/Aprenda-Programa%C3%A7%C3%A3o-Algoritmos-Implementa%C3%A7%C3%B5es-Portugol/dp/8539907798
https://www.amazon.com.br/Aprenda-Programa%C3%A7%C3%A3o-Algoritmos-Implementa%C3%A7%C3%B5es-Portugol/dp/8539907798