E-Book Completo Programação - Introdução Ao Coding (Games) (Versão Digital)

ser
educacional
gente criando o futuro
Presidente do Conselho de Administração Janguiê Diniz
Diretor-presidente Jânyo Diniz
Diretoria Executiva de Ensino Adriano Azevedo
Diretoria Executiva de Serviços Corporativos Joaldo Diniz
Diretoria de Ensino a Distância Enzo Moreira
Autoria Fernando Mello de Amorim
Projeto Gráfico e Capa DP Content
DADOS DO FORNECEDOR
Análise de Qualidade, Edição de Texto, Design Instrucional,
Edição de Arte, Diagramação, Design Gráfico e Revisão.
© Ser Educacional 2019
Rua Treze de Maio, nº 254, Santo Amaro
Recife-PE – CEP 50100-160
*Todos os gráficos, tabelas e esquemas são creditados à autoria, salvo quando indicada a referência.
Informamos que é de inteira responsabilidade da autoria a emissão de conceitos.
Nenhuma parte desta publicação poderá ser reproduzida por qualquer meio
ou forma sem autorização.
A violação dos direitos autorais é crime estabelecido pela Lei n.º 9.610/98 e punido pelo artigo 184 do
Código Penal.
Imagens de ícones/capa: © Shutterstock
SER_GDESIGN_PROGCOD_UNID1_A5.indd 2 30/08/2019 13:42:57

Boxes
ASSISTA
Indicação de filmes, vídeos ou similares que trazem informações comple-
mentares ou aprofundadas sobre o conteúdo estudado.
CITANDO
Dados essenciais e pertinentes sobre a vida de uma determinada pessoa
relevante para o estudo do conteúdo abordado.
CONTEXTUALIZANDO
Dados que retratam onde e quando aconteceu determinado fato;
demonstra-se a situação histórica do assunto.
CURIOSIDADE
Informação que revela algo desconhecido e interessante sobre o assunto
tratado.
DICA
Um detalhe específico da informação, um breve conselho, um alerta, uma
informação privilegiada sobre o conteúdo trabalhado.
EXEMPLIFICANDO
Informação que retrata de forma objetiva determinado assunto.
EXPLICANDO
Explicação, elucidação sobre uma palavra ou expressão específica da
área de conhecimento trabalhada.

Sumário
Unidade 1 - História da indústria e introdução ao Processing.jps

Objetivos da unidade............................................................................................................ 12
Histórico dos jogos digitais................................................................................................ 13

Os primeiros jogos digitais........................................................................................... 13
O início dos consoles..................................................................................................... 16
Computadores pessoais e jogos.................................................................................. 19
Os jogos no século XXI.................................................................................................. 20
Tipos de jogos........................................................................................................................ 23
Gêneros............................................................................................................................ 23
Plataformas..................................................................................................................... 29
Empregabilidades........................................................................................................... 31
Elementos básicos de um jogo........................................................................................... 32

Os quatro pilares elementares..................................................................................... 32
Profissionais necessários............................................................................................. 34
Criação de jogos 2D.............................................................................................................. 40

Fundamentos da programação.................................................................................... 41
Utilizando o Processing.js............................................................................................. 44
Sintetizando............................................................................................................................ 48
Referências bibliográficas.................................................................................................. 49

Sumário
Unidade 2 – Recursos visuais de um jogo eletrônico

Elementos gráficos de um jogo.......................................................................................... 52

Composição dos gráficos............................................................................................. 52
Variáveis e operadores................................................................................................. 54
Formas primárias............................................................................................................ 58
Cenários e objetos (tiles e sprites).................................................................................... 61

Utilizando sprites............................................................................................................ 62
Utilizando tiles................................................................................................................. 64
Estruturas de controle................................................................................................... 66
Criação de animações em jogos........................................................................................ 67

Tipos de animação......................................................................................................... 68
Implementando animações.......................................................................................... 70
Sintetizando............................................................................................................................ 74
Referências bibliográficas.................................................................................................. 75
PROGRAMAÇÃO - INTRODUÇÃO AO CODING (GAMES) 5

Sumário
Unidade 3 – Dispositivos de entrada, inteligência artificial e interação homem-máquina

Leitura de dispositivos de entrada..................................................................................... 78

A história dos controles................................................................................................ 78
Utilizando o mouse......................................................................................................... 85
Utilizando o teclado....................................................................................................... 87
Máquinas de estado em jogos............................................................................................ 89

O que é inteligência artificial....................................................................................... 89
Criando comportamentos............................................................................................. 92
Implementando máquinas de estado.......................................................................... 94
Motores de jogos................................................................................................................... 97
Como utilizar motores de jogos.................................................................................... 98
Principais motores de jogos......................................................................................... 98
Sintetizando.......................................................................................................................... 103
Referências bibliográficas................................................................................................ 104

Sumário
Unidade 4 – Implementando colisões, músicas e sons

Objetivos da unidade.......................................................................................................... 106
Tratamento de colisões...................................................................................................... 107

Colisões em jogos como Pong................................................................................... 109
Colisões em jogos de plataforma.............................................................................. 117
Músicas e efeitos sonoros em jogos............................................................................... 125

A função do áudio nos jogos...................................................................................... 126
Implementando trilhas sonoras................................................................................. 128
Implementando efeitos sonoros................................................................................ 129
Sintetizando.......................................................................................................................... 132
Referências bibliográficas................................................................................................ 133


Apresentação
O ser humano, desde seus primórdios, tem como uma de suas principais
atividade o jogar e, em paralelo, criar jogos. A princípio, jogar se assemelhava
muito ao simples ato de brincar; pouco podemos distinguir do que nomeamos
por brincadeiras e os primeiros jogos presentes na história.
Com o passar do tempo, os jogos se tornaram cada vez mais complexos, com
regras, objetivos e características que se distanciavam de uma brincadeira. Por
fim, com o advento do computador e a criação do meio digital, os jogos muda-
ram drasticamente, uma vez que, antes, todos os seus componentes eram físicos
e necessitavam apenas de alguém que criasse o jogo e produzisse suas peças. No
ambiente virtual, contudo, é necessário um time diverso para a criação do jogo,
dentre eles: game designers – responsáveis por projetar a experiência; progra-
madores – que irão codificar o jogo através de motores gráficos próprios ou de
terceiros; designers gráficos – capazes de criar a parte visual do jogo; músicos –
profissionais que criarão a trilha sonora do jogo; dentre muitos outros.

O autor
O professor Fernando Mello de Amo-

rim é Bacharel em Design de Games
pela Universidade Anhembi Morumbi
(UAM), possui graduação técnica em
Informática pela Escola Técnica Esta-
dual de São Paulo (ETESP). Ministrou
aulas no curso técnico em Programa-
ção para Jogos Digitais e técnico em
Multimidia em 2018. Desenvolve jogos
e leciona na área desde 2016.
Currículo Lattes:
http://lattes.cnpq.br/8511841728944217
Dedico este projeto a todos os mestres que tive durante a vida, pois seus
ensinamentos, esforços e exemplos carregarei para sempre. Também
agradeço ao apoio de meus pais e meu irmão. E por fim, agradeço a toda a
equipe editorial pela oportunidade e esforço coletivo.

UNIDADE
1 HISTÓRIA DA
INDÚSTRIA E
INTRODUÇÃO AO
PROCESSING.JPS

Objetivos da unidade
Conhecer um pouco mais sobre os

primórdios da criação de jogos digitais;
Compreender os conceitos e
elementos básicos necessários à criação
de um jogo.
Tópicos de estudo
Histórico dos jogos digitais Elementos básicos de um jogo
Os primeiros jogos digitais Os quatro pilares elementares
O início dos consoles Profissionais necessários
Computadores pessoais e jogos
Os jogos no século XXI Criação de jogos 2D
Fundamentos da programação
Tipos de jogos Utilizando o Processing.js
Gêneros
Plataformas
Empregabilidades

Histórico dos jogos digitais
Das anotações e pensamentos de
um engenheiro solitário até uma das
indústrias mais rentáveis da atuali-
dade, os jogos digitais passaram por
grandes transformações, tendên-
cias e quedas até chegarem onde
estão hoje. A seguir, daremos um
panorama geral do caminho percor-
rido pela indústria, dos protótipos
militares à produção em massa de
jogos caseiros no século XXI.
Os primeiros jogos digitais

Com o término da Segunda Guerra Mundial e o início da corrida armamen-
tista e tecnológica da Guerra Fria, grandes invenções da humanidade começa-
ram a tomar forma, dentre elas os computadores. Usados primariamente para
realização de cálculos matemáticos, eles logo encontraram uma nova função
nas mãos do professor Alexander Douglas. A fim de mostrar de forma prática
sua tese sobre interação entre humanos e computadores, em 1952, Alexander
criou o jogo OXO, sua própria versão de jogo da velha (tic-tac-toe, no original), e
o implementou em um computador.
Apesar de sua importância, OXO não é considerado o primeiro jogo digi-
tal já feito, pois, no fundo, apenas está emulando um jogo de tabuleiro um
para um no computador. Seis anos depois, em 1958, o físico nuclear William
Higginbotham ganharia para seu Tennis for Two o posto de primeiro jogo
digital da história (OVERMARS, 2012).
Tennis for Two tratava-se, basicamente, de alguns pixels amontoados em um
osciloscópio para demonstração dos efeitos da gravidade – há um traço hori-
zontal na tela, no qual estende-se um traço perpendicular, a noventa graus,
para emular um campo de tênis e sua rede. Nele, um terceiro elemento gráfico
simula a bola, que passa de um lado para outro do campo.

Figura 1. Máquina para operar o jogo Tennis for Two. Fonte: Wikimedia Commons. Acesso em: 29/05/2019.
Apesar do relativo sucesso e da grande importância histórica, Tennis for Two

não foi o responsável por criar a indústria de jogos que hoje conhecemos. Um
dos motivos apontados para a impossibilidade da popularização dos jogos na-
quela época seria o tamanho do instrumental necessário para operá-los. Me-
diante este fato, um novo jogo só seria produzido na década seguinte.
A criação de jogos tornou-se um atrativo para os alunos do MIT (Instituto
de Tecnologia de Massachusetts) e novos jogos digitais começaram a surgir em
1961, dentre eles Lunar Landing e Spacewar! Este último, desenvolvido por Steve
Russell, serviria como inspiração para a criação do jogo Computer Space, em
1971, a primeira máquina de arcade com jogos de computador, desenvolvida
pelo engenheiro Nolan Bushnell.
Diferente do modelo de consoles do século XXI, no qual vários jogos po-
dem ser executados em uma mesma máquina, nestas primeiras versões, uma
máquina comportava apenas um jogo, pois não existiam recursos de memória
semelhantes aos que existem nos consoles de videogame.
Em 1966, a empresa Sega lançou o jogo Periscope, criando a primeira má-
quina de arcade da história. Junto a ela, muitas outras empresas começaram
a se interessar na produção e comercialização de máquinas de arcade. Assim
começava a Era de Ouro dos Jogos.

Começavam a surgir as grandes empresas do ramo, sendo a primeira delas
a Magnavox. Ralph Baer era um engenheiro, considerado pioneiro nas pesqui-
sas de televisão interativa. Em 1972, lançou o Magnavox Odyssey, considerado
o primeiro console caseiro da história. O videogame não possuía cor, mas usa-
va de telas intercambiáveis para simular os recursos que o computador não era
capaz de desenhar.
Nesse mesmo ano, Nolan Bushnell, fundador da Atari, lançaria o pri-
meiro sucesso da empresa – Pong, muito baseado no conceito do antigo
Tennis for Two. Além das vendas consideráveis e da popularização do nome
da empresa, Pong ainda traria consigo algumas polêmicas relacionadas ao
seu lançamento.
Segundo o que se conta, Bushnell teria visitado Baer, que teria lhe apresen-
tado um projeto de jogo muito parecido com o clássico Tennis for Two. Bushnell,
ao se deparar com o protótipo, acabou se inspirando um pouco demais nele
para a criação de seu Pong. A polêmica se resolveu com a Atari tendo de pagar
os direitos equivalentes para a Magnavox, num contrato de licenciamento. Ape-
sar de tudo, Pong foi extremamente popular nos arcades, ganhando, inclusive,
uma versão caseira, chamada Home Pong.
CURIOSIDADE
Segundo Kent (2011), as primeiras máquinas de arcade de Computer Spa-
ce, lançadas em 1971, não fizeram sucesso comercial. Aparentemente, o
que faltava para que elas estourassem era um jogo que fizesse o sucesso
acontecer. A Atari realizou esse feito com Pong – uma primeira máquina
foi colocada em um bar para testar a receptividade do jogo. Após dois
dias, o dono do estabelecimento informou que a máquina estava quebra-
da, quando na realidade ela estava completamente cheia de fichas, o que
impedia o sistema de inicialização de funcionar.
Os anos seguintes ficaram conhecidos como a Era de Ouro dos Jogos, de-
vido a popularização dos consoles caseiros, criação de alguns dos jogos mais
populares de toda a história e disseminação das máquinas de arcade. Alguns
dos jogos criados no fim da década de 1970 e começo da década 1980 que me-
recem ser citados são:
• Space Invaders (1978): primeiro jogo de arcade a salvar a pontuação conse-
guida pelo jogador;

• Asteroids (1979): permitia que o jogador escrevesse suas iniciais junto a sua
pontuação. Além disto, foi um dos primeiros jogos a utilizar vetores gráficos
no lugar de pixels para criar objetos e personagens;
• Pacman (1980): criado pela empresa Namco, tornou-se o mais famoso jogo
de arcade de todos os tempos. Diferia muito dos jogos da época, que focavam
em utilizar armas ou naves;
• Donkey Kong (1981): desenvolvido pelo designer Shigeru Miyamoto, o jogo
apresentou pela primeira vez os icônicos personagens Mario (na época, Jum-
pman) e Donkey Kong, os quais dariam origem a duas das mais importantes
franquias de jogos de plataforma da história.
O início dos consoles

A criação do Magnavox Odyssey fez com que uma nova vertente da indús-
tria de jogos começasse a se estabelecer: a de consoles caseiros. Não demorou
muito para que aparecessem outras empresas interessadas nesta parcela do
mercado, sendo uma delas a própria Atari. Em 1976, foi lançado o console Atari
VCS, também conhecido como Atari 2600, que tinha como principais jogos Ad-
venture, Yars’ Revenge e, mais tarde, em 1980, Space Invaders, que popularizou
a conversão de jogos de arcade para console. Nos anos seguintes a empresa
lançou mais dois consoles: o Atari 5200, em 1982, e o Atari 7800, em 1984.
O maior diferencial dos consoles era ter um aparelho pequeno que, ao se
conectar com o televisor, possibilitava jogar os mesmos jogos encontrados em
bares e restaurantes na comodidade da casa do jogador. Inicialmente, os con-
soles vinham com um número limitado de jogos, que podiam ser trocados atra-
vés de interruptores no aparelho; assim era com o Odyssey. Apenas em 1976,
uma empresa chamada Fairchild Semiconductor lançou um console com su-
porte para cartuchos, o Fairchild Channel F, o qual gerou uma grande mudança
na estrutura dos hardwares da época.
Na mesma época, a Mattel, grande fabricante de brinquedos dos EUA, lançou
seu próprio console, intitulado Intellivision, e os primeiros videogames portáteis
baseados em LED, que possuíam apenas um jogo, como o Football e o Sub Chase.
A aparente rentabilidade da indústria de jogos digitais na década de 1980
atraiu muitas empresas para o mercado. O problema era que nem todas elas

eram comprometidas com a qualidade dos jogos que lançavam no mercado. O
volume muito alto de jogos e a má qualidade deles fez com que a indústria de
videogames se deparasse com sua primeira grande crise em 1983, reduzindo
90% em dois anos e fazendo com que muitos considerassem a indústria como
uma moda passageira, completamente erradicada.
Enquanto, nos EUA, a indústria afundava na crise, do outro lado do mundo,
no Japão, a Nintendo, empresa conhecida no meio dos arcades por sucessos
como Donkey Kong e Mario Bros., resolveu entrar no mercado de consoles em
1985, lançando o Nintendo Family Computer (Famicon), chamado Nintendo Enter-
tainment System (NES) nos Estados Unidos.
O sucesso da Nintendo se deu, principalmente, em dois aspectos: primeiro,
pelo lançamento de Super Mario Bros. junto do console. O jogo se distancia-
va muito da proposta de design das máquinas de arcades – não tinha foco
na pontuação, apresentava uma “aventura” completa, com início, meio, e fim,
e um objetivo claro desde seu início. Segundo, para evitar que novos crashes
ocorressem, a Nintendo criou um selo de aprovação, que limitava quais jogos
poderiam ser lançados para o sistema ou não. Dessa forma, conseguia garantir
uma mínima qualidade para os programas licenciados.
Com o estrondoso sucesso do NES, outras empresas decidiram reiniciar os
esforços em ganhar uma fatia do mercado de videogames, dentre elas, a já
citada Sega. Depois do fracasso de seu primeiro console, o SG-1000, a empresa
japonesa resolveu testar águas novamente no mercado, com o lançamento do
Master System, em 1986. Apesar de não ter conseguido adquirir uma grande
fatia do mercado, graças às políticas de exclusividade da Nintendo, o Master
System foi importante para disseminar o nome da empresa e ganhar uma cer-
ta fatia do mercado mundial (tendo, inclusive, um destaque interes-
sante no Brasil, pela parceria da Sega com a TecToy).
Em 1988 (Japão) ou 1989 (EUA), a Sega lança o sucessor do
Master System, chamado de Mega Drive ou Sega Gene-
sis (na América do Norte). Com o novo processador de
16-bits, capaz de desenhar pixels menores e ter uma
definição de imagem maior que a do NES, o Mega
Drive foi responsável por consolidar o nome da Sega
como uma das grandes fabricantes de console. Foi nes-

sa geração que a empresa lançou o jogo Sonic the Hedgehog, de 1991, lançando
o mascote da empresa, o ouriço Sonic.
Em 1990 (Japão) e 1991 (EUA), a Nintendo lança o sucessor do NES, conheci-
do como SNES (Super Nintendo Entertainment System). A partir dessa geração,
o mercado de consoles vai passar pela primeira “guerra” dos videogames, com
a Sega e a Nintendo dividindo em quase 50% o mercado mundial. Ainda na
década de 1990 (lançado em 1989), a Nintendo vai, pela primeira vez, consoli-
dar o mercado de videogames portáteis com seu aclamado Game Boy. Um de
seus principais atrativos era o aclamado Tetris, considerado um dos jogos mais
famosos da história.
CONTEXTUALIZANDO
Tetris foi criado na Rússia, em 1985, porém nunca patenteado. Na época,
não existia nada semelhante a direitos de propriedade intelectual na
União Soviética. O criador original, Alexey Pajitnov, e seus assistentes
não conseguiram ter direitos sobre o jogo até o ano de 1996, quando junto
a Henk Rogers fundou a empresa The Tetris Company, LLC e Blue Planet
Software. Durante este período, o jogo foi distribuído para computadores
da IBM e outras plataformas, através de uma empresa húngara chamada
Andromeda, a qual encontrou o programa e o revendeu para a empresa
Spectrum Holobyte.6.
A entrada da Sony no mercado de consoles ocorreu, primeiramente, com

uma parceria com a Nintendo em 1991. Ambas planejavam desenvolver em
conjunto um console que utilizasse CD-ROM. Após a demonstração do primei-
ro protótipo, a Nintendo pediu para que a Philips também criasse um projeto
com essas mesmas especificações utilizando a tecnologia de seus aparelhos.
Mediante esta situação, a Sony deu continuidade ao protótipo que tinha por si,
dando origem ao primeiro PlayStation.
Entre 1994 e 1996 foi lançada a quarta geração de videogames. A Sony fez
sua entrada no mercado com o console PlayStation, a Sega fortaleceu-se no mer-
cado com o seu novo aparelho Sega Saturn, ambas seguindo para o mercado
de CD-ROM e possibilitando a criação de jogos com maior número de dados,
enquanto a Nintendo lançou o Nintendo 64, o qual ainda utilizava cartuchos,
mediante a justificativa de que o tempo de carregamento era menor. Os novos
sistemas eram mais robustos, contando com placas gráficas especializadas para

gráficos 3D. Nesta época, os jogos começaram a se tornar cada vez mais comple-
xos e ter custos mais elevados, tornando-se comum jogos que custassem meio
milhão de dólares. A Nintendo também ganhava cada vez mais espaço no merca-
do de consoles portáteis com o lançamento de Pokémon, um jogo de colecionar,
combater e evoluir monstros, em 1996 no mercado japonês, para o Game Boy.
A próxima geração ficou marcada pelo alto investimento da Sega no seu novo
console, o Dreamcast, lançado em 1998, e a chegada da Microsoft ao mercado
de consoles com o Xbox. Apesar de ter vendido cinco milhões de cópias, o lucro
obtido pela Sega não compensou as perdas com a produção, resultando na saí-
da da empresa do mercado de consoles e término da produção do Dreamcast
no começo de 2001, fazendo a Sega tornar-se, exclusivamente, desenvolvedora
de softwares. Enquanto isso, a Sony ganhava uma parcela cada vez maior do
mercado, vendendo mais de 100 milhões de aparelhos nos seus primeiros cinco
anos. Com o lançamento do Game Cube, a Nintendo passaria a ser uma empresa
muito focada nos jogos first party (desenvolvidos pela proprietária do console),
com poucas parcerias com desenvolvedoras terceirizadas.
Computadores pessoais e jogos

Inicialmente, os computadores eram máquinas usadas apenas por progra-
madores e entusiastas. Demoraria até a metade da década de 1970 para que
os primeiros computadores pessoais aparecessem no mercado e, juntos a eles,
os jogos de computador.
Por serem ferramentas de trabalho e estudo, havia um certo distanciamen-
to de sua finalidade de uso para os videogames; no entanto, seus criadores
enxergavam a possibilidade de sua utilização como terminais de jogos. Steve
Wozniak, fundador da empresa Apple junto com Steve Jobs, implementou a lin-
guagem de programação BASIC no projeto de criação do computador Apple II.
Além dela, outras empresas demonstravam interesse no mercado de jogos de
computadores, dentre elas a Atari, a qual lançou três versões de computadores
com jogos, e a Coleco, com o seu modelo Adam Computer.
As diferenças entre consoles e computadores em relação à usabilidade era
evidente – enquanto os consoles se utilizavam de controles com joysticks e bo-
tões para fazer a jogatina acontecer, os computadores dispunham de teclados

e, alguns anos depois, de mouses. A presença do teclado proporcionou a cria-
ção dos adventures de texto, jogos que utilizavam de verbos e substantivos para
desenvolver a ação dentro do mundo digital. O primeiro desse estilo foi Colos-
sal Cave Adventure (às vezes, referido apenas como Adventure), criado por William
Crowther utilizando a linguagem de programação assembly. O mouse, enquanto
recurso, possibilitou o desenvolvimento de gêneros que tinham como ação clicar
em muitos lugares da tela, dentre eles, os Point-and-Click Adventures, como Monkey
Island (1990), e estratégia em tempo real (RTS), como Command & Conquer (1995).
Com o advento da Internet e sua disponibilização para uso doméstico atra-
vés de provedores, os desenvolvedores começaram a vislumbrar o que viriam
a ser os jogos com multijogadores online, os multiplayer online games. Logo,
os jogadores puderam ter em mãos jogos capazes de comportar centenas de
jogadores online ao mesmo tempo, os MMOs (Massive Multiplayer Online). Al-
guns dos pioneiros do gênero foram os MMORPGs Ultima Online e EverQuest.
Apesar da grande ascensão no número de usuários e a indiscutível qualidade
dos jogos criados, os jogos de computador ainda possuíam alguns problemas para
os usuários mais comuns; a instalação dos jogos era uma tarefa complicada na
época dos sistemas baseados em DOS, muitas vezes os drivers eram incompa-
tíveis e com diferentes capacidades de memória e processamento, fazendo com
que o consumidor precisasse ter certo conhecimento para conseguir realizar a
operação. Graças a isso, os desenvolvedores necessitavam criar jogos que fun-
cionassem para diversas especificações. Somente com o lançamento do sistema
Windows 95 e a criação do DirectX, uma coleção de programas para padronização
da comunicação entre software e hardware, esse problema pôde ser minimizado.
Os jogos no século XXI

O início do século XXI ficou marcado pelos novos hardwares utilizados nos con-
soles, novas tecnologias e novas formas de jogar. A entrada da Microsoft no merca-
do de consoles trouxe consigo a popularização dos consoles com conexão à inter-
net nativa (iniciada uma década antes pelo Dreamcast da Sega) e jogos online, o que
mais tarde se tornaria padrão no mercado. A Sony, com o PlayStation 2, introduziu
o primeiro console a utilizar a tecnologia de DVD para os seus jogos, proporcionan-
do a criação de jogos mais complexos e com uma grande quantidade de conteúdo.

A Nintendo, por outro lado, investia cada vez mais no mercado de portáteis.
Em 2001, lançou o Game Boy Advance e, já em 2004, o Nintendo DS, o primei-
ro console portátil a utilizar duas telas, sendo uma delas sensível ao toque. O
Nintendo DS vendeu cerca de 150 milhões de unidades ao redor do mundo,
sendo o portátil de maior sucesso até os dias atuais. A Sony tentou entrar na
competição com o PSP (PlayStation Portable) no ano seguinte, porém não teve
uma receptividade tão grande quanto os portáteis da Nintendo. O PSP vendeu,
ao todo, cerca de 82 milhões de unidades.
Outros setores importantes acabaram por ganhar destaque no começo do
século, como o de jogos casuais para computadores, geralmente criados com
o programa Flash da Macromedia, e os jogos de celular, os quais se populari-
zaram no final dos anos 1990 com suas versões de Tetris e Space Invaders e co-
meçavam a ser produzidos por pequenos estúdios utilizando a linguagem Java.
Os jogos de arcade também introduziam novas formas de interação com os

jogos e influenciaram dois famosos periféricos de consoles: os controles em for-
ma de guitarra e os tapetes de dança. O primeiro controle em formato de guitar-
ra foi apresentado no jogo GuitarFreaks, de 1999, criado pela empresa japonesa
Konami. Mais tarde, o jogo influenciou na criação de Guitar Hero, lançado pela
Activision em 2005. Já o representante dos tapetes de dança, Dance Dance Revolu-
tion, também desenvolvido pela Konami, foi lançado em 1998 para arcades e em
2001 para consoles. Ambos revolucionaram a indústria com um novo conceito
de jogos musicais que se expandiu para outros instrumentos e tipos de controle.

Em 2006, a Nintendo entraria na
sétima geração de consoles com o
Nintendo Wii. O console vinha acom-
panhado do Wii Remote (também co-
nhecido apenas como Wiimote), um
controle em forma de controle de TV
que era capaz de transmitir o movi-
mento do jogador para o jogo. O con-
trole foi uma revolução, e fez com que, nos anos seguintes, a Sony e a Microsoft
corressem atrás e lançassem seus próprios controles de movimento – o PlayS-
tation Move e o Kinect, ambos de 2010. O Nintendo Wii, lançado junto com o
jogo Wii Sports, foi um grande sucesso de vendas, sendo o console mais vendi-
do de sua geração. Porém, a falta de softwares que justificassem os controles
de movimento fez com que se tornassem apenas uma moda passageira, não
tendo grande destaque na indústria pós-2010.
O mercado de jogos mobile ascendeu com o surgimento do primeiro, em
2007. Seguindo o exemplo da Apple, as empresas de celulares começaram a
lançar seus próprios smartphones e, com eles, suas próprias lojas. O merca-
do mobile influenciou na criação de pequenas empresas de desenvolvimento
de jogos e até mesmo desenvolvedores independentes, os quais conseguiam
vender seus próprios jogos sem a necessidade de uma publicadora. O rápido
crescimento desta vertente do mercado geraria, mais tarde, uma das verten-
tes mais lucrativas da indústria, ganhando espaço, até mesmo, entre aqueles
que não costumavam jogar consoles caseiros. Os tablets, junto aos celulares,
se tornariam, mais tarde, a parcela mais lucrativa do mercado, chegando a
quase metade dos lucros das plataformas de jogos, segundo a empresa Ne-
wzoo (WIJMAN, 2018).
Em 2011, a Nintendo furou a fila das gerações, ao lançar seu novo hardware,
o Wii U. A ideia era tentar desenvolver um videogame que pudesse competir
com o Xbox 360 e o PlayStation 3 em gráficos. O Wii U acabou sendo um fracas-
so, vendendo cerca de 11 milhões de unidades, apenas.
Em 2013, a Sony e a Microsoft lançaram seus novos consoles – o PlaySta-
tion 4 e o Xbox One –, dando início à oitava geração de consoles. Desde então,
a indústria dos consoles voltou ao formato tradicional de jogabilidade, com

o console da Sony liderando o mercado. A Nintendo buscaria uma reentrada
no mercado em 2017, com o lançamento do Nintendo Switch, cujo o maior di-
ferencial é a capacidade de ser jogado tanto na TV, como um console caseiro,
quando no modo portátil.
Tecnologias emergentes dessa época têm surgido com maior frequência;
duas que têm ganhado cada vez mais adeptos no mercado são:
• Realidade Aumentada (RA/AR): popularizada através de Pokémon GO.
Nela, é possível projetar personagens e objetos em locais do mundo real.
• Realidade Virtual (RV/VR): utilizando óculos e controladores, é possível
imergir o jogador em uma experiência de tal forma que ele se sinta dentro do
jogo. Essa tecnologia está abrindo espaço para novos tipos de parque de diver-
sões, nos quais as atrações são projetadas virtualmente.
Tipos de jogos
Além das plataformas para as quais os jogos são criados, há outras peculia-
ridades que os diferenciam. Essas diferenças geram suas classificações. Jogos
podem ser classificados pelo seu gameplay, estética, história ou finalidade.
Gêneros
Gêneros são as classificações referentes às mecânicas usadas no jogo ou a
experiência geral que ele intenta fazer com que o jogador vivencie. Por envol-
ver a experiência que o jogador tem no ambiente virtual, o gênero é o principal
divisor de público-alvo de um jogo para outro; um bom game designer sempre
deverá levar isso em consideração ao definir de qual gênero seu jogo será. É
importante notar que um jogo não é composto de apenas um gênero, sendo
comum mesclá-los.
• Ação: o gênero de ação se divide em diversos subgêneros que serão apre-
sentados a seguir. A maioria desses jogos têm a característica em comum de
que o jogador controla uma personagem que utiliza de armas para derrotar
seus inimigos a fim de alcançar um objetivo. Esse gênero concentra os jogos
com movimentos rápidos e apertar rápido de botões, os quais geralmente tes-
tam a velocidade de resposta do jogador.

• Plataforma: o subgênero de plataforma possui a característica de que
o principal desafio do jogo envolve a habilidade de pular do personagem e,
consequentemente, a capacidade de resposta do jogador em relação a mo-
vimentar seu personagem entre plataformas que podem estar separadas
por vales, espinhos ou poços de lava. Jogos famosos desse gênero incluem
as séries Mario, Mega Man e Sonic, as quais, apesar de suas semelhanças,
apresentam desafios completamente diferentes, pois, enquanto um foca
na habilidade de pular como técnica para derrotar os inimigos, outro de-
monstra que é possível mesclar as habilidades de pular e atirar, ou então
focar o seu jogo na velocidade e intensidade com a qual a personagem se
move. Uma terminologia que se popularizou neste tipo de jogo é a classi-
ficação metroidvania, termo oriundo de duas séries de jogos (Castlevania e
Metroid) que se refere a jogos de plataforma com foco em exploração de
cenários e aquisição de novas habilidades para alcançar lugares antes ina-
tingíveis. Jogos de plataforma tendem a ser lembrados apenas pelos jogos
bidimensionais; porém, com a evolução dos gráficos e a possibilidade de
criação de universos tridimensionais, também começaram a existir jogos de
plataforma 3D, sendo um de seus principais representantes o game Super
Mario 64, para Nintendo 64. Uma vertente de jogos de plataforma que se
popularizou através dos dispositivos mobile é a de jogos de corrida infinita,
conhecidos como endless runners, os quais possuem as mesmas caracterís-
ticas dos jogos de plataforma, com o adendo de projetarem telas de forma
infinita, sendo um exemplo desse estilo o jogo Subway Surfers.
• Ação furtiva: o principal foco nos jogos desse subgênero é conseguir
esconder a personagem dos inimigos, podendo ser, essa mecânica, uma
obrigação ou não. Jogos furtivos podem desfrutar de mecânicas para es-
conder o personagem, como as caixas de papelão em Metal Gear Solid, ou
a capacidade de se vestir como outro personagem, como em Hitman. Os
protagonistas desses jogos são em sua grande maioria fugitivos, ninjas, es-
piões ou assassinos. Em alguns casos, como nos jogos da série Dishonored,
utilizar-se de mecânicas furtivas podem beneficiar o jogador e até mesmo
alterar o desenrolar da história.
• Luta: situados em arenas, nas quais os personagens podem dispor de
armas ou apenas de seus punhos, os jogos do subgênero de luta colocam o

jogador no controle de um lutador
que tem como objetivo derrotar o
seu oponente, desferindo golpes,
até que sua vitalidade chegue a
zero. As lutas geralmente ocorrem
na forma de rounds e podem ter
dois ou mais combatentes simul-
tâneos. Representantes famosos
desse gênero são Street Fighter, co-
nhecido por ser um dos primeiros jogos de luta, e Super Smash Bros, jogo
da Nintendo que tem como protagonistas personagens de várias séries de
jogos da empresa e alguns de empresas convidadas, possuindo o diferen-
cial de que, para vencer a batalha, o jogador precisa derrubar o adversário
para fora da arena.
• Beat’em’up e hack’n’slash: jogos focados em combates corpo a corpo
ou com armas, principalmente espadas, contra diversos oponentes. Este
subgênero foca seu gameplay no frenesi do combate – o jogador precisa
apertar uma grande variedade de botões para desferir combos contra le-
giões de inimigos. Em Final Fight, por exemplo, o jogador sai pelas ruas de
Metro City enfrentando gangues de rua com o objetivo de resgatar a mulher
amada do protagonista. Os personagens utilizam apenas de seus punhos e
alguns objetos encontrados pelo caminho para se defenderem.
• Tiro: os jogos de tiro têm como mecânica padrão a utilização de armas
para enfrentar inimigos. O cenário no qual este estilo se passa geralmente
envolve guerras históricas, como a Segunda Guerra Mundial, ou combates
espaciais entre naves.
• Tiro em primeira pessoa (FPS): o subgênero conhecido como First Per-
son Shooter coloca o jogador no controle de um personagem a partir da sua
própria perspectiva, simulando, através da câmera e da movimentação, a
visão que o jogador teria se estivesse dentro do jogo. Exemplos de jogos
desse estilo são Doom, a série Battlefield e o jogo Portal, desenvolvido pela
empresa Valve; ele se diferencia dos demais jogos do gênero por possuir
uma mecânica mesclada entre tiro e quebra-cabeça, na qual o jogador utili-
za-se de uma arma que atira portais em vez de balas.

• Shoot’em’up: jogos com ação frenética, que testam a habilidade do jo-
gador desviar de balas enquanto derrota diversos inimigos atirando neles.
Um clássico desse gênero é o jogo Space Invaders, no qual o jogador controla
uma nave e precisa impedir uma invasão alienígena. Existe uma vertente
desse estilo de jogo chamada Run and Gun. Nela, o jogador controla uma
personagem em um ambiente de plataformas e precisa desviar de tiros pu-
lando e agachando, enquanto usa sua arma para derrotar inimigos e avan-
çar no jogo; um exemplo desse tipo de jogo é a série Contra.
• Tiro em terceira pessoa (TPS): semelhante aos outros subgêneros,
com o diferencial do posicionamento da câmera, a qual se encontra de for-
ma a parecer que o jogador está tendo a visão do jogo a partir da presença
de um terceiro, posicionado, geralmente, no ombro da personagem. Exem-
plos deste estilo são Gears of War e Resident Evil 4.
• Adventure: o gênero tem este nome por causa do primeiro jogo do estilo:
Colossal Cave Adventure. A experiência central dos jogos com este gameplay é a
de coletar e gerenciar objetos.
• Adventure de texto: criado nos primórdios dos jogos de computado-
res, jogos deste subgênero não dispunham de representações gráficas em
suas primeiras manifestações. O jogador controlava seu personagem atra-
vés de comandos de texto simples e pré-determinados, enquanto a repre-
sentação das ações dele no mundo eram feitas em forma de textos na tela.
Anos mais tarde, com a evolução dos computadores, esse gênero inspirou
o surgimento dos adventures gráficos. Alguns exemplos são: Zork, Colossal
Cave e Mystery House.
• Adventure gráfico: jogos desse subgênero se utilizam do mouse ou
cursores equivalentes para interagir com imagens e revelar pistas, conversar
com personagens, explorar o cenário e solucionar enigmas. Representantes
desse estilo são: The Secret of Monkey Island, Full Throttle e Grim Fandango.
• Interpretação de personagem (RPG): sucessores digitais de jogos de
interpretação de personagens usando papel e lápis, como Dungeons & Dra-
gons, originado na década de 1970. Jogos desse gênero são compostos por
aventuras fantásticas que focam na busca por tesouros e evolução das per-
sonagens em relação a sua força e mentalidade. Cada personagem do jogo
é apresentado em classes, como paladino, mago, ladino ou outra profissão

advinda de mundos fantasiosos. Séries de jogos incluídas nesse gênero são:
Pokémon, Final Fantasy e Dragon Quest.
• Multijogadores Massivos Online (MMORPG): esse subgênero abran-
ge todos os jogos que se utilizam da internet para conectar milhares de jo-
gadores simultaneamente em um mesmo universo virtual. O jogador pode
assumir trabalhos, fazer parte de uma guilda e estabelecer uma vida vir-
tual com outras pessoas ao redor do mundo. Jogos desse gênero tendem
a lançar expansões contínuas com novos cenários e desafios, tendo, assim,
grande longevidade. Jogos desse subgênero são: World of Warcraft, Ultima
Online e Lineage.
• Arenas de Batalha Online com Multijogadores (MOBA): como sugere
o nome, este estilo coloca o jogador como membro de uma equipe de luta-
dores que devem juntos se reunir para destruir a base adversária. No decor-
rer da partida, os personagens podem evoluir e adquirir novas habilidades.
League of Legends e Dota 2 são os principais representantes desse subgênero.
• Sobrevivência e terror: este
subgênero utiliza de suas mecâni-
cas e ambientação para amedrontar
e aterrorizar o jogador. Jogos desse
estilo apresentam criaturas horren-
das que precisam ser enfrentadas
com recursos limitados. Nos jogos
da série Fatal Frame, o jogador tem
como arma uma câmera fotográfica
para enfrentar fantasmas, os quais
podem ser vencidos ao serem fotografados em momentos exatos. Outros jo-
gos desse subgênero são os primeiros da série Resident Evil e a série Silent Hill.
• Gerenciamento/construção: os jogos deste estilo levam o jogador a ad-
ministrar uma cidade ou um determinado espaço, tendo recursos limitados.
Para que o jogador possa expandir suas localizações, há diversas mecânicas de
obtenção de recursos. As partidas desse gênero geralmente não têm fim, pos-
sibilitando que o jogador continue expandindo até determinado limite, porém,
com a possibilidade quase infinita de substituir prédios e dar continuidade ao
jogo. Exemplos desse estilo são: Sim City, Anno e Zoo Tycoon.

• Simulação de vida: neste tipo de jogo, o objetivo é gerenciar a vida e os rela-
cionamentos de um personagem no ambiente virtual, desde o seu trabalho até a
mobília de sua casa. The Sims e Animal Crossing: Pocket Camp são jogos desse gênero.
• Simulação de bichos de estimação: jogos nesse estilo envolvem ali-
mentar e cuidar de animais de estimação virtuais. O primeiro jogo desse gê-
nero foi Tamagochi. Outros jogos que são exemplos desse estilo são: World
of Zoo e I Love My Pets.
• Música/ritmo: são jogos baseados em apertar botões de acordo com o
ritmo, executar movimentos de dança ou cantar. Jogos desse estilo podem
usar periféricos como microfones, controles em formato de guitarra, tapetes
de danças ou sensores de captura de movimento, como o Kinect da Microsoft.
Temos, como exemplo, Just Dance e Rock Band.
• Festa: esses jogos são feitos para serem jogados com vários jogadores
simultaneamente em um mesmo lugar em um formato de gincana, sendo o
vencedor o maior pontuador. Mario Party e Crash Bash são exemplos.
• Quebra-cabeça: enigmas para resolver e peças para encaixar são tarefas
constantes nesse tipo de jogo. Tetris é um dos mais famosos representantes
dessa categoria; nele, o jogador precisa responder rapidamente para encaixar
as peças que aparecem com o objetivo de formar linhas para ganhar pontos.
Outros exemplos são as séries Professor Layton e Ace Attorney.
• Esportes: são as adaptações virtuais de esportes reais como futebol, bas-
quete, vôlei, entre outros. Neles, os jogadores podem controlar todo o time ou
apenas um esportista em diferentes modos presentes. Os jogos desse estilo cos-
tumam ter novas versões anualmente, com as modificações de jogadores das
equipes e de times das ligas presentes. As séries FIFA e Tony Hawk são exemplos.
• Gerenciamento em esportes: no lugar de controlar o time ou o espor-
tista, o jogador pode administrar tudo o que envolve o time, desde o estádio
até os patrocinadores. Exemplos: Football Manager e Out of the Park Baseball.
• Estratégia: planejamento tático se mostra essencial em jogos deste gê-
nero. Neles, é necessário administrar recursos e peças para garantir a sobre-
vivência e ser vitorioso. Eles foram originados a partir dos jogos de tabuleiro,
como o xadrez, o qual também tem diversas versões digitais.
• Em tempo real (RTS): nos jogos desse subgênero, as partidas ocorrem
de forma dinâmica. O jogador precisa utilizar seus recursos para construir,

criar tropas e se preparar para atacar, en-
quanto o inimigo realiza as mesmas tare-
fas ao mesmo tempo. Ele pode ser dividi-
do em quatro ações: expansão, exploração,
extração e extermínio. Exemplos: Age of Empires,
Warcraft e StarCraft.
• Baseados em turnos: neste estilo de jogo, há
momentos em que o jogador pode executar suas ações
e momentos que ele precisa aguardar o adversário execu-
tar as dele. Este ritmo permite ao jogador pensar em uma estratégia antes de
executar sua ação. Alguns jogos nesse estilo são as séries Civilization e Worms.
• Defesa de torre: o jogador precisa se utilizar de equipamentos, armas
ou personagens que ficam posicionados imóveis por um caminho delimita-
do para que possam proteger um objetivo e eliminar os inimigos. Exemplos:
Plants vs. Zombies e Defense Grid: The Awakening.
• Simulação de veículos: são jogos que tentam transmitir ao jogador uma expe-
riência verossímil de estar dirigindo um automóvel, avião ou barco. Esses jogos tam-
bém podem ter compatibilidade com controladores especiais que proporcionem se-
melhança ainda maior com estar pilotando um veículo real, como volantes e pedais.
• Corrida: remetendo a competições de corrida, como Fórmula 1 e Stock Car,
esse gênero atrai os jogadores pela possibilidade de participar como um cor-
redor nessas grandes competições, as quais também podem ser ambientadas
em universos fantasiosos com veículos inventados propriamente para o jogo.
Exemplos de séries de jogos desse gênero são: Gran Turismo e NASCAR Racing.
• Voo: controlando aeronaves ou naves espaciais, esse gênero pode
apresentar corridas de aviões, como em SkyDrift, ou combates utilizando
naves espaciais, como na série Star Fox.
Plataformas
Plataforma é o termo atribuído aos aparelhos que o jogador utilizará para
jogar. Devido às suas diferenças, cada plataforma promove uma experiência
distinta e, consequentemente, possibilita a produção de diferentes tipos de jo-
gos para cada uma delas.

• Consoles: sistemas de console são as plataformas de jogos para casa, os
quais precisam estar conectados a um televisor. Estes aparelhos aceitam diver-
sos controles simultaneamente. As principais empresas dessa plataforma no
começo do século XXI são a Microsoft, Nintendo e Sony. Como fabricantes de
hardware, elas limitam quem pode desenvolver um jogo para seus consoles.
Uma vantagem que os consoles têm sobre os computadores (que concorrem
diretamente com eles) é que, pelo hardware ser controlado, todos os jogadores
que possuem o console de determinada geração, como o PlayStation 3, terão
o mesmo desempenho. Consoles, além de serem máquinas para jogar, foram
transformadas, com o tempo, em centrais de entretenimento, podendo ser
usadas para assistir filmes, escutar música e navegar na internet.
• Portáteis: são consoles que possuem suas próprias telas e que, devido ao
seu tamanho, podem ser levados a todas as partes. Consoles como o Nintendo
DS proporcionam experiências diferenciadas graças ao recurso de duas telas
presente. Assim como os consoles caseiros, possuem a limitante de desenvol-
vimento por parte das fabricantes, que obrigam o desenvolvedor a obter uma
permissão para desenvolver um jogo para a plataforma.
• Mobile: pode ser considerada uma variante dos consoles portáteis, po-
rém, as plataformas usadas para jogar são os celulares e tablets. Com o recurso
de tela sensível ao toque presente nos e demais smartphones, a experiência de
jogo é alterada, para fazer uso desse modelo de controle. Os celulares também
possuem outros recursos que possibilitam a criação de jogos exclusivos para
eles, como a câmera, que pode ser usada para a criação de jogos de realidade
aumentada. Na segunda metade da década de 2010, os smartphones se tor-
naram a plataforma mais utilizada para jogar. Por não possuírem direito de
propriedade, os desenvolvedores podem desenvolver para qualquer aparelho,
tendo que possuir apenas uma licença das lojas que irão distribuir os softwares
e passando por seu processo de autorização.
• Computadores: diferente dos consoles e máquinas de fliperama, os com-
putadores não possuem direito de propriedade, o que proporciona ao de-
senvolvedor a liberdade para criar os jogos que bem entenderem. Contudo,
a grande variedade de hardwares disponíveis impossibilita que se tenha uma
noção absoluta referente às capacidades da máquina do usuário. Assim, tor-
na-se obrigação do desenvolvedor informar em quais especificações técnicas

que o seu jogo necessita para funcionar adequadamente, em relação a espaço
interno de memória, capacidade do processador etc.
• Arcade: também conhecidos como jogos de fliperama, são sistemas encon-
trados em casas especializadas, parques de diversão e em pizzarias. As máquinas
de arcade originalmente possuíam apenas um jogo por máquina, controlados
por joysticks, botões ou controles especiais, como volantes e pedais para jogos
de corrida ou armas em jogos de tiro. O desenvolvimento nessa plataforma atre-
la a empresa desenvolvedora do jogo à empresa fabricante das máquinas, quan-
do ambas não são a mesma. Nesses casos, a desenvolvedora fica dependente da
aprovação da fabricante para autorizar o desenvolvimento de um game.
Empregabilidade
Observando o início dos jogos digitais, podemos constatar que haviam fi-
nalidades implícitas na criação dos primeiros jogos. Apesar da predominância
de sua utilização na indústria do entretenimento, sempre foi possível observar
que eles tinham mais de uma aplicabilidade, sendo algumas delas:
• Entretenimento: assim como filmes e livros, os jogos podem ser vistos
como produtos para divertimento. A possibilidade de interpretar outro perso-
nagem, vivenciar aventuras fantásticas e ser capaz de criar universos presentes
em sua imaginação atraem o jogador pela interatividade. Diferente das outras
mídias de entretenimento, os jogos permitem que o consumidor interaja com
o ambiente virtual, pois ele deixa de ser um mero espectador para tornar-se
agente do que está consumindo.
• Socialização: jogos podem promover a interatividade entre jogadores que
se enfrentam desde a criação de Pong, entretanto, com o advento da internet
e a possibilidade de interação entre milhares de pessoas através de grupos,
comunidades e guildas (no caso de gêneros como MMORPG), um dos focos do
jogador pode ser o de estabelecer laços de amizade e companheirismo com os
seus colegas de jogatina.
• Educação: desde o uso de Tennis for Two para apresentar a aplicação da gra-
vidade, jogos têm demonstrado a sua capacidade educativa. Existem jogos espe-
cíficos para ensinar matemática, literatura, história e demais matérias, como os
jogos da série Reader Rabbit, conhecido no Brasil como Coelho Sabido, que eram

focados na alfabetização e outras disciplinas para a primeira infância. Jogos tam-
bém podem ser usados para treinar trabalhadores segundo suas tarefas.
• Marketing e publicidade: conhecidos como advergames, são jogos utili-
zados por empresas para divulgar um determinado produto ou a marca em
si. No jogo Pepsi Man, era possível ver espalhado pelo cenário a marca Pep-
si, além das latas do refrigerante que podiam ser coletadas durante o jogo.
Também há a possibilidade de utilizar
de propaganda internamente no jogo
para fortalecer a marca. No jogo Fort-
nite, em 2018, após a estreia do filme
Vingadores: Guerra Infinita, houve um
evento no qual era possível que um
dos jogadores assumisse o controle da
arma do vilão do filme, Thanos.
Elementos básicos de um jogo

A partir de agora, daremos início a nossa explicação sobre quais são os elemen-
tos principais que formam um jogo, bem como os profissionais que operam no de-
senvolvimento de cada um deles.
Os quatro pilares elementares

Existem diversas formas de classificar os elementos que compõem um jogo de
videogame. Schell (2008) apresentou a tétrade elementar dos jogos para classificá-
-los, dividindo-os em quatro categorias: mecânicas, história, estética e tecnologia.
Mecânicas
As mecânicas são as regras, objetivos e ações que o jogador pode realizar.
Elas são as limitações do jogo e as formas de interação. Quando comparadas
a outras formas de entretenimento lineares, como, por exemplo, filmes ou li-
vros, as mecânicas são o que diferencia os jogos das demais. Usando um jogo
de futebol como exemplo, as mecânicas presentes no jogo envolveriam passar
a bola para outro jogador, chutar, defender, mas também haveria o limite do
campo, cada partida ser dividida em dois tempos de quarenta e cinco minu-

tos e as demais regras e interações possíveis. É possível observar, mediante o
exemplo do jogo de futebol, que objetos e demais elementos do jogo também
fazem parte da estrutura mecânica dos games.
História
Há sempre uma história sendo contada em um jogo. Ela pode ser simples e
interpretativa, como o cair de blocos no jogo Tetris; épica e aventuresca, como
na vingança de Kratos contra os deuses nos jogos da série God of War; ou de
múltiplos caminhos, como no RPG japonês Chrono Trigger, que apresenta doze
finais possíveis. A história quase sempre está associada com a motivação do
protagonista, como em jogos de aventura e RPG, servindo como vetor de se-
quência do jogo. Contudo, diferente dos livros que seguem um roteiro pré-de-
terminado, os jogos podem dar total liberdade ao jogador ou dar a falsa sensa-
ção de liberdade referente aos eventos que ocorrem no decorrer do jogo.
Estética
A estética está diretamente rela-
cionada com os cinco sentidos, sendo
os sentidos mais comuns associados
ao jogar a visão e a audição. Enquanto
os efeitos sonoros e música são res-
ponsáveis por ambientar o jogador, a
aparência é responsável pela imersão,
levando-o a um ambiente concreto e
existente. Junto com a história, a estética promove experiências aterrorizan-
tes ou fantásticas. Ela também marca a evolução tecnológica dos consoles e
computadores, que passaram de simples pixels na tela para imagens de alta
definição, com trilhas sonoras compostas por orquestras sinfônicas.
Tecnologia
Tecnologia é relacionada a todo o instrumental relacionado com o hardware
necessário para jogar, isto é, controles, consoles e qualquer outro equipamen-
to utilizado pelo jogador. A evolução tecnológica possibilitou a variedade esté-
tica nos jogos, graças a processadores mais rápidos, placas de vídeo especiali-
zadas e melhores placas de som. A criação de novos aparelhos também gerou
novas mecânicas, como os jogos de dança, que utilizam sensores de captação
de movimento ou, simplesmente, tapetes de dança para jogar.

Profissionais necessários
Jogos podem ser feitos por uma só pessoa ou por equipes com mais de 500
funcionários; em algumas delas, um funcionário pode assumir mais de uma
função. O que limita a equipe será o tamanho da empresa e a complexidade do
jogo a ser desenvolvido. A seguir, estão listadas as principais carreiras relacio-
nadas com o desenvolvimento de games.
• Produção: compreende o gerenciamento e acompanhamento do projeto,
também comunicando as necessidades do projeto para a equipe e lidando com
pessoas externas, como a empresa que irá publicar o jogo. Mesmo não sen-
do responsáveis diretamente pelo desenvolvimento e criação de assets para o
jogo, os produtores são responsáveis pela satisfação, motivação e produtivida-
de da equipe. Sua principal responsabilidade é a de gerenciar os profissionais e
assegurar os prazos de entrega.
• Produtor executivo: também conhecido pela sigla PE, são os respon-
sáveis por supervisionar os projetos da empresa. Realizam tarefas como
verificar a necessidade de hardware, criar programas de treinamento de
funcionários, avaliar fornecedores externos e outras atividades que visam
a beneficiar os projetos em andamento e futuros. Comumente são profis-
sionais que possuem de cinco a dez anos de experiência como produtor.
• Produtor: trabalha como o representante da equipe e gerencia o pro-
jeto. Seu trabalho envolve assegurar que o jogo será entregue no prazo,
utilizando-se dos recursos pré-
-estipulados, além de manter a
equipe engajada e entusiasmada,
tentando enfrentar toda espécie
de contratempo ou problema que
possa surgir durante a produção.
Trabalha de forma subordinada
ao produtor executivo ou ao vice-
-presidente do estúdio, em conjunto com as equipes de marketing, vendas,
operações, relações públicas etc. Existem dois tipos de produtor: produtor
desenvolvedor e o produtor publicador. O produtor desenvolvedor trabalha
de forma conjunta com a equipe de produção do jogo, principalmente os

líderes de cada área, enquanto o produtor publicador trabalha de forma
mais focada com as equipes externas ao desenvolvimento, como o setor de
vendas e marketing. Um produtor geralmente tem de três a cinco anos de
experiência em desenvolvimento e já participou como produtor associado
de diversos projetos.
• Produtor associado: o produtor associado, também conhecido como PA, é
subordinado ao produtor. Trabalhando diretamente com a equipe de desenvol-
vimento e ajudando os líderes de cada área no que for necessário. São profissio-
nais que têm de um a três anos de experiência e podem ter trabalhado em áreas
mais básicas do desenvolvimento, como, por exemplo, na área de testes.
• Arte: são os profissionais responsáveis pela criação de todos assets grá-
ficos presentes no jogo, desde sprites que serão utilizados nos menus até os
modelos 3D dos personagens. Também têm a responsabilidade de definir, jun-
to à equipe de engenharia, quais softwares serão mais adequados para a pro-
dução. Cada empresa possui diferentes nomes para cada cargo, porém os mais
comuns são apresentados a seguir.
• Diretor de arte: sua principal responsabilidade é a de coordenar a
equipe de arte para que a estética proposta esteja presente em todas as
peças criadas. Este profissional tem de cinco a dez anos de experiência em
produção de peças artísticas e grande habilidade técnica.
• Artista líder: trabalha junto ao diretor de arte, assegurando a qualida-
de técnica dos assets e gerenciando a equipe de arte. Seu trabalho possibili-
ta que o diretor de arte tenha mais tempo disponível para se preocupar com
a criação do jogo, enquanto o líder fica responsável por gerenciar a equipe.
Este profissional tem entre três e cincos anos de experiência.
• Artística conceitual: também trabalha juntamente com o diretor de
arte para ilustrar os conceitos que serviram de base para os assets a serem
criados. São habilitados a produzir peças gráficas em 2D, métodos de pintu-
ra, técnicas de desenho tradicional e, se necessário, modelagem 3D.
• Construtor de mundos: também conhecidos como designers de ní-
veis, são os profissionais responsáveis pela criação da geometria e texturas
dos cenários do jogo.
• Criador de assets: responsável pela criação de todos os elementos gráficos
que estarão presentes no jogo, como veículos, personagens, objetos, sprites dos

menus e demais interfaces gráficas. Podem ser especializados em um tipo especí-
fico de asset, como personagens, ou serem profissionais mais generalistas.
• Animador: estes profissionais criam as animações de personagens e
mais objetos, sejam elas tridimensionais ou bidimensionais, segundo a téc-
nica determinada pelo diretor de arte. Assim como os criadores de assets,
artistas dessa área também podem ser especializados em uma técnica de
animação ou em uma determinada parte do processo, como o rigging, que
seria o processo de criar os ossos e articulações de personagens.
• Artista técnico: trabalham di-
retamente com os programadores
para integrar os assets à progra-
mação, sendo os responsáveis por
criar as caixas de colisão e por ga-
rantir o êxito na importação dos as-
sets para o motor gráfico utilizado.
• Artista de marketing: são os
responsáveis pela criação dos ma-
teriais utilizados em propagandas
e campanhas de marketing, assim
como a embalagem do jogo.
• Engenharia: os programadores são os profissionais incumbidos de pro-
gramar as mecânicas do jogo e aplicam as funcionalidades aos recursos gráfi-
cos. Em alguns casos, também são responsáveis por criar os motores gráficos
que serão utilizados para programar o jogo. Trabalha em conjunto com os de-
mais membros de equipe, verificando as necessidades técnicas do projeto e
escolhendo as ferramentas mais adequadas.
• Diretor técnico: é o profissional responsável por pesquisar novas tecno-
logias e escolher quais as melhores a serem utilizadas no projeto. São também
responsáveis por determinar os padrões de codificação, gerir as bibliotecas de
código que estão em utilização e codificá-las. Um diretor técnico tem em torno
de cinco a dez anos de experiência na área de programação de jogos.
• Programador líder: ele é responsável por gerenciar a área de programa-
ção, verificando as necessidades dos demais programadores e as demandas
do projeto. Trabalha junto ao diretor técnico para determinar quais tecnolo-

gias serão utilizadas no desenvolvimento do jogo. Este profissional tem em
torno de três a cinco anos de experiência no desenvolvimento de jogos.
• Programador: é o termo utilizado para todo profissional relacionado com
a codificação de scripts para o funcionamento do jogo. No desenvolvimento
de jogos há uma grande variedade de elementos a serem programados e isso
origina diversas subcategorias de programadores, dentre elas:
• Programador de redes: responsável por codificar os scripts de rede
para conexão de computadores e criação do ambiente multijogador.
• Programador de som: capaz de integrar os assets criados pela equipe de
áudio, assim como integrar as ferramentas utilizadas pelo designer de som.
• Programador gráfico: trabalha em conjunto com a equipe de arte
para criar recursos gráficos dentro da engine utilizada, tais como par-
tículas ou shaders.
• Programador de ferramentas: são os profissionais responsáveis por
modificar ou criar os softwares necessários ao desenvolvimento.
• Programador de IA: especializados na área de inteligência artificial,
são os responsáveis por programar o comportamento de adversários e
qualquer outro personagem não jogável, conhecidos como NPCs.
• Design: os designers são os principais responsáveis pela concepção do
jogo. Eles projetam a experiência e interações do jogador. O sistema de comba-
te, quebra-cabeças ou qualquer outra jogabilidade partem de seu trabalho. Em
conjunto com a equipe de engenharia, escolhem as tecnologias mais apropria-
das para o jogo. Acompanham todo o processo de desenvolvimento, desde a
concepção até o término, escrevendo todo o processo através de documentos
apropriados, jogando o jogo e documentando o feedback.
• Diretor de criação: é o profissional responsável por dialogar com to-
das as áreas de desenvolvimento, de forma a manter a visão do projeto e
coesão de todas as partes criadas. Está em constante comunicação com os
líderes de cada área para que haja coerência entre os assets gráficos, design
do jogo, programação, som e demais recursos. Geralmente têm em torno
de cinco a dez ano de experiência na área de desenvolvimento de jogos e já
trabalhou em outros projetos como designer líder.
• Designer líder: trabalha em conjunto com o diretor de criação geren-
ciando a equipe de design do jogo, auxiliando na criação de documentos,

protótipos, implementação de recursos, balanceamento e criação de novas
mecânicas. Têm em torno de três a cinco anos de experiência como designer.
• Designer: este profissional é o res-
ponsável pela criação da experiência
geral vivenciada pelo jogador, criando
mecânicas e protótipos do jogo. Tam-
bém é responsável por balancear e
simular as interações do jogador. Exis-
tem algumas variedades de tarefas e,
consequentemente, variações desse tipo de profissional, como as seguintes:
• Designer de sistemas: responsável por projetar como ocorrerá as
ações do jogador. Alguns exemplos são os sistemas de combate, criação de
personagens, criação de recursos, administração e gestão presentes no jogo.
• Designer de UI: pessoa responsável por projetar as interações de in-
terfaces, menus e demais telas.
• Designer de níveis: semelhante ao profissional criador de mundos,
é o responsável por projetar e balancear o ambiente criado. Em algumas
empresas, também pode ter a responsabilidade de adicionar inimigos e re-
cursos, balanceando a sua quantidade.
• Roteirista do jogo: profissional que tem a exclusiva responsabilidade
de determinar onde os inimigos e recursos aparecerão no jogo.
• Redator: responsável por criar a história, personagens e diálogos do jogo.
Trabalham em conjunto com o diretor de criação ou o designer líder para asse-
gurar que todos os elementos criados por ele estejam em concordância com
a visão do projeto. Também é, muitas vezes, incumbido de redigir o material
publicitário, manual e demais documentos relacionados com o jogo.
• Teste de garantia de qualidade: são os profissionais responsáveis por jogar o
jogo durante todas as fases de produção para assegurar a qualidade do produto, au-
sência de bugs e bom funcionamento das mecânicas. Participam do processo de de-
senvolvimento até o fim, determinando quando o jogo está pronto para ser entregue.
• Líder de testadores de QA: trabalha em conjunto com os demais lí-
deres de equipe para avaliar se os recursos presentes no jogo estão imple-
mentados de forma adequada. Também é responsável por criar os planos
de teste e determinar quais partes do jogo necessitam ser testadas durante

mais tempo. Este profissional deve ter em torno de dois a três anos de ex-
periência como testador de QA.
• Testador de QA: ele é responsável por testar o jogo em todas as suas
nuances para verificar se as implementações estão funcionando de manei-
ra adequada e observar a presença de qualquer problema que possa atra-
palhar o jogar – os bugs. Esta área é perfeita para quem gosta de jogar e
deseja começar na área de desenvolvimento, por ser possível ter contato
diário com os profissionais das demais áreas.
• Som: envolve tudo relacionado à criação de músicas, efeitos sonoros e
qualquer outro recurso de áudio para jogos. Na maioria das vezes esse traba-
lho é realizado por uma equipe terceirizada ou, no caso das trilhas sonoras,
podem ser licenciadas por empresas do ramo.
• Músicos: é o profissional que irá criar as trilhas do jogo de acordo com
a visão passada pelo diretor de criação. As trilhas podem ser performadas
por apenas um músico ou com uma orquestra.
• Artista de foley: responsável pela criação dos efeitos sonoros que serão
utilizados no jogo, como passos ou sons de tiro. É comum no desenvolvimento
de jogos utilizar bancos de áudio, tendo um profissional na equipe responsável
por escolher e implementar junto aos programadores os sons necessários.
• Dublador: profissional que dá voz aos personagens. O trabalho destes
profissionais atribui maior verossimilhança aos jogos e compõem um cená-
rio mais próximo ao cinematográfico.
• Equipe da empresa: geralmente são tratados como membros externos à
equipe de desenvolvimento e trabalham diretamente com o produtor.
• Marketing e relações públicas: este departamento é responsável por
vender o jogo e popularizar a existência dele desde sua produção. Precisam
criar um plano estratégico interessante de divulgação a partir dos seus recur-
sos estéticos, história e jogabilidade. Também são responsáveis por entrar em
contato com sites e mídias especializadas para envio de material publicitário.
• Serviços de criação: trabalha em conjunto com o departamento de mar-
keting para a criação da embalagem do jogo e do manual, além de coordenar a
impressão de todos os materiais necessários.
• Vendas: o departamento de vendas é responsável pela venda do jogo para
as lojas de varejo e digitais. Também podem propor a criação de versões es-

peciais e limitadas. Sua principal responsabilidade é a de criar um plano de
vendas e assegurar seu funcionamento para a boa rentabilidade do projeto.
Criação de jogos 2D
O primeiro ponto importante a ser observado é que jogos digitais são pro-
gramas de computador. A partir dessa informação, pode-se entender que criar
um game é semelhante a criar um aplicativo para computador ou celular, com o
diferencial de alguns outros profissionais envolvidos, como os game designers,
e que esse aplicativo será usado para o entretenimento do usuário.
Um jogo 2D é caracterizado pela presença de apenas dois eixos cartesia-
nos: os eixos x e y, os quais representam a horizontalidade e a verticalidade.
Semelhantemente a um mapa, a tela do computador é formada por um plano
cartesiano e cada ponto da tela equivale a uma coordenada.
GRÁFICO 1. PLANO CARTESIANO
(2 3)
3
2
(-3 1)
1
x
-3 -2 -1 1 2 3
-1
-2
(-1,5 -2,5)
-3
Fonte: Wikimedia Commons. Acesso em: 21/08/2019.

Observando a imagem, há algumas coordenadas marcadas nesse plano car-
deal de quatro quadrantes. Em vermelho -3 no eixo x e 1 no eixo y, por exemplo.
A quantidade de quadrantes e a coordenada 0 em x e 0 em y varia confor-
me a engine usada, sendo um dos principais pontos de atenção ao começar a
programar. O plano cartesiano tem enorme importância no desenvolvimento
de jogos, pois é através das coordenadas que os sprites são mostrados na tela,
figuras são desenhadas e os personagens se movem. Apesar da ilusão ópti-
ca de movimentação quando um personagem se move, o que realmente está
acontecendo é a atualização da posição do sprite na tela.
Fundamentos da programação
Para programar um jogo é necessário primeiramente entender os principais
conceitos que envolvem a programação. Programar é o ato de criar sequências
de instruções, as quais é dado o nome de algoritmo. O ser humano desen-
volve algoritmos diariamente para todas as tarefas que realiza; um exemplo é
quando uma pessoa escova os dentes. A sequência de ações pode ser listada
da seguinte forma:
1. Abrir o armário;
2. Pegar a escova e a pasta de dente e colocá-las sobre a pia;
3. Fechar o armário;
4. Abrir a tampa da pasta de dente e colocar o creme dental sobre as cerdas
da escova;
5. Fechar a tampa da pasta de dente;
6. Pegar a escova e, com a boca aberta, começar a escovar os dentes, fazen-
do movimentos circulares com o braço;
7. Abrir a torneira, enxaguar a boca e lavar a escova;
8. Depois de feito, fechar a torneira;
9. Pegar a toalha e, com ela, enxugar a boca, as mãos e a escova;
10. Por fim, abrir o armário e guardar a escova e a pasta de dente.
Esta mesma tarefa poderia ser descrita de inúmeras maneiras diferentes;
por exemplo, há quem molhe as cerdas da escova após colocar a pasta de den-
te, ou então a sequência poderia ser mais descritiva e explicar qual das mãos
está sendo utilizada para escovar. O importante é entender que é necessária

uma sequência de ações para executar uma tarefa, e o mesmo ocorre com os
algoritmos de programação.
Para um personagem se mover, é necessário que o jogador aperte o botão
que realiza essa ação; esta é uma ação simples de descrever, e o algoritmo res-
ponsável para que esta condição aconteça também parece ser bastante sim-
ples. Contudo, para transformar essas descrições em ações possíveis no jogo é
necessário programá-las utilizando uma linguagem de programação.
Uma linguagem de programação é um código com instruções que o com-
putador consegue compilar e compreender em sua própria linguagem, a lin-
guagem de máquina. As máquinas entendem as instruções passadas para elas
no formato binário, correntes elétricas de valor 0 ou 1, sendo 0 desligado e 1
ligado. Os computadores recebem pacotes com oito binários, os bytes, e os
traduzem utilizando um compilador ou interpretador. Uma das primeiras lin-
guagens criadas foi a linguagem assembly, que possuía comandos para exe-
cutar instruções simples, como adicionar valores em determinados locais da
memória. Linguagens como assembly, que são mais próximas da linguagem de
máquina, são conhecidas como linguagens de baixo nível, enquanto aquelas
mais próximas da linguagem humana, como C++ e Java, são conhecidas como
linguagens de alto nível. Algumas linguagens de programação famosas são:
• Java: é uma linguagem de programação amplamente utilizada no desen-
volvimento de aplicativos para computadores e celulares. Criada em 1995, pos-
sui a particularidade de usar uma máquina virtual como interpretadora de có-
digo. Isso possibilita que computadores com diferentes arquiteturas executem
programas feitos em Java, desde que o interpretador esteja instalado.
• Javascript: uma das mais utilizadas para desenvolvimento web. É a lingua-
gem usada para criar os códigos de interação do site, parte conhecida como
front-end. A partir de 1996, começou a ser usada para criação de servidores,
parte conhecida como back-end.
• C#: uma linguagem fácil de escrever e com grande quantidade de bibliote-
cas baseadas na linguagem de programação .NET. Também é bastante utilizada
no desenvolvimento de jogos através do motor gráfico Unity.
• Python: linguagem fácil de aprender e bastante usada nos campos de
inteligência artificial, ciência de dados e aprendizado de máquina. É organizada
por uma empresa sem fins lucrativos.

• C++: esta linguagem tem a mesma sintaxe da linguagem C, mas seu grande
diferencial é que suporta o paradigma de orientação a objetos.
• Objective C: também foi baseado na linguagem C, utilizada principalmen-
te para Mac OS X e GNUstep.
• Swift: é uma linguagem de programação criada pela Apple para desen-
volvimento de aplicativos para iOs, Mac Os e demais plataformas da empresa.
• Kotlin: desenvolvida pela empresa JetBrains e patrocinada pela Google, é
usada para desenvolvimento móvel na plataforma Android.
• PHP: linguagem utilizada no desenvolvimento web, referenciada princi-
palmente por ser a base da plataforma WordPress. Também é amplamente
utilizada em back-end para programação de servidores.
EXPLICANDO
Há três terminologias utilizadas para denominar os profissionais que tra-
balham com desenvolvimento de software. Front-end é o termo atribuído
à parte frontal do software, a qual o usuário terá contato direto enquanto
utiliza o aplicativo. Back-end é a área de suporte, o código que fica do
lado do servidor, onde as informações ficam guardadas. E full stack é o
profissional que possui conhecimento e trabalha com ambas as extremi-
dades do desenvolvimento.
Os exemplos de programação contidos neste livro são baseados em

Java, por sua simplicidade e ampla utilização no mercado de desenvolvi-
mento de jogos.
Variáveis
Programas estão a todo tempo manipulando dados da memória do compu-
tador. Estes dados armazenados têm um endereçamento, como apartamentos
em um prédio. Nas linguagens de alto nível, como Java, as alocações de memó-
ria são denominadas variáveis.
No código, as variáveis são usadas para referenciar o valor contido na me-
mória, acessá-lo e alterá-lo, como no exemplo a seguir:
life = 5;
A variável nomeada como “life” é a referência de uma alocação de me-
mória no computador, e está substituindo o valor contido neste espaço
pelo valor “5”, apesar de não ser possível determinar qual o valor que
havia anteriormente.

Existem diferentes tipos de variáveis para armazenar diferentes tipos de
valores, sendo os principais:
• integer: armazena números inteiros;
• float: armazena números flutuantes;
• boolean: armazena os valores binários false e true;
• string: armazena letras ou textos.
Em Java, as variáveis são declaradas primeiro com seu tipo, seguido pelo
nome que o programador atribuirá para ela e, caso necessário, acompanhado
pelo símbolo “=” e o valor inicial das variáveis:
Não há a necessidade de atribuir um valor inicial para uma variável na lingua-
gem Java, pois ela já atribuirá um valor padrão a todos os tipos. A uma variável
integer que não tiver valor, será atribuído o valor “0”; variáveis do tipo boolean têm
valor inicial “false” e variáveis do tipo string começam com o valor simbólico “null”.
String: String name = “Link”;
Integer: int bombs = 3;
Float: float energy = 15.5;
Boolean: boolean isTransformed = false;
Utilizando o Processing.js
Para testar o código criado, assim como compreender outras propriedades
da programação para jogos, será utilizado o ambiente de desenvolvimento in-
tegrado Processing 3.
O Processing 3 é um programa usado por entusiastas e alunos de progra-
mação para aprender a programar mídias interativas, como jogos, e experi-
mentações artísticas utilizando a linguagem Java. O programa está disponível
para os sistemas operacionais Windows, Linus e Mac OS X e pode ser baixado
gratuitamente na sessão de download do site Processing.org.

Após baixado, basta descompactar a pasta e, dentro dela, executar o aplica-
tivo Processing. A tela inicial será semelhante a esta:
Figura 2. Tela inicial do Processing.
Antes de começar a programar, identifique as telas e os botões presentes

na interface. A parte branca da tela é a área de digitação – é nesta parte que
o código deve ser digitado. O interessante de utilizar um ambiente de desen-
volvimento é que palavras especiais são colorizadas com uma cor diferente
segundo o seu significado para o código, por exemplo, na configuração padrão,
as variáveis ficam com as letras amareladas.
A parte preta logo abaixo da área de digitação é a tela de logs; nela serão
mostradas informações que o programador mandar exibir como forma de tes-
te e os erros que impossibilitarem o código de compilar.
Acima da área de digitação, ficam os botões de executar e de parar a execu-
ção do código. Logo acima deles, ficam os menus:
• Arquivo: usado para salvar o programa, abrir um programa existente e
ações correlatas;
• Editar: com as opções de desfazer, colar algum texto que esteja na área de
transferência, auto formatar e ajustar a indentação do código.

E os demais menus servem para auxiliar, obter novas informações, impor-
tar bibliotecas, entre outras coisas.
Para começar a criar o código, é necessário clicar na área de digitação. A
primeira coisa que se deve fazer antes de criar as variáveis e as instruções é
adicionar duas funções que são a base de funcionamento do Processing: setup
e draw. A função setup é responsável por executar as configurações da tela do
programa criado, como tamanho, cor, número de quadros por segundo etc. A
função draw é uma função que se repetirá constantemente enquanto o progra-
ma estiver aberto; nela, vão todas as instruções de movimentação do persona-
gem e qualquer outra ação que precisar se repetir durante o jogo.
O comando void significa que a função criada não retornará um valor. Os
parênteses fazem parte da sintaxe das funções e as chaves limitam o que está
sendo programado dentro e fora delas. Um cuidado que deve ser tomado ao di-
gitar é que as letras maiúsculas e minúsculas são enxergadas como diferentes
no código (o chamado case sensitive). Desta forma, se draw for escrito com letra
maiúscula no começo, o código não a reconhecerá.
As variáveis são comumente declaradas antes de todo o código. Neste primeiro
caso, só serão utilizadas duas variáveis do tipo integer – a primeira será chamada
de gravity e terá valor inicial 2, e a segunda será posY e não terá valor declarado.
Feito isto, será necessário adicionar os comandos para criação de tela,
atribuição de cor de fundo e estabelecer qual a velocidade de processamen-
to do loop draw no código. Todas essas configurações são feitas dentro da
função setup. Para evidenciar a funcionalidade de cada comando, podemos
escrever, ao seu lado, um comentário utilizando barras duplas, que não será
lido pelo computador, mas sim por qualquer outro programador que tenha
acesso ao código.
Na função draw ficará o loop do programa, aquilo que precisa se repetir para
que algo aconteça. Como a tradução do nome sugere, esta função desenha os
elementos da tela. É importante notar que ela não apaga o conteúdo: para isso,
será necessário usar o comando background e atribuir a cor padrão branca.
Para que a posição da elipse desenhada seja sempre atualizada, de forma a
fazer ela ir descendo na tela, será necessário utilizar uma função para somar o
valor da gravidade ao valor de posY.
Com todas as etapas concluídas, o código ficará desta forma:

Figura 3. Loop da elipse pronto.
Para testar a programação da elipse caindo, basta clicar no botão executar.

Também é possível alterar os valores para testar a funcionalidade de cada co-
mando, por exemplo, para deixar a execução mais lenta, pode-se alterar o valor
de frameRate para 12, ou alterar a cor de fundo, colocando valores diferentes
para cada atributo.
Uma informação importante sobre o plano cartesiano no Processing é que
só existe um quadrante na tela. O marco zero, com posição 0 em x e Y, é o ponto
superior à esquerda. Assim, para fazer um objeto descer na tela é necessário
acrescentar um valor em Y, enquanto para se mover para a esquerda é neces-
sário acrescentar um valor em X.
Com este exercício, é possível ver o básico para a criação de jogos 2D utili-
zando o Processing.

Sintetizando
Nesta unidade, foram apresentados os conceitos básicos de um jogo, o his-
tórico de como os jogos foram inventados e o contexto tecnológico que os en-
volviam, observando como as inovações tecnológicas influenciaram no apare-
cimento de novas formas de jogar. Também foram apresentados e explicados
os principais gêneros, plataformas e como os jogos são usados no mundo para
muito além do entretenimento.
Os jogos são compostos por uma grande quantidade de elementos com-
plexos, que necessitam de uma enorme gama de profissionais para criá-los.
Porém, a presença e a quantidade deles ficará a critério da necessidade de
cada projeto.
E por fim, foram introduzidos alguns conceitos fundamentais de programa-
ção e criação de jogos 2D, como plano cartesiano e variáveis. Desta forma, con-
ceituando todos os elementos básicos que compõem um jogo.

Referências bibliográficas
ECK, D. J. Introduction to Programming Using Java. [s.l.]. 2011. Disponível em:
<http://math.hws.edu/eck/cs124/downloads/javanotes6-linked.pdf>. Acesso
em: 26 mai.2019.
KENT, S. L. The Ultimate History of Video Games. New York: Three Rivers
Press, 2011.
OVERMARS, M. A Brief History of Computer Games. [s.l.]. 2012. Disponível
em: <https://www.stichtingspel.org/sites/default/files/history_of_games.pdf>.
Acesso em: 20 mai. 2019.
ROGERS, S. Level UP: um guia para o design de grandes jogos. São Paulo: Blu-
cher, 2013.
SCHELL, J. The Art of Game Design: A Book of Lenses. Burlington: Elsevier, 2008.
WIJMAN, T. Newzoo’s 2018 Report: Insights Into the $137.9 Billion Global Ga-
mes Market. [s.l.]. 2018. Disponível em: <https://newzoo.com/insights/articles/
newzoos-2018-report-insights-into-the-137-9-billion-global-games-market/>.
Acesso em: 21 mai. 2019.

UNIDADE
2 RECURSOS
VISUAIS DE UM
JOGO ELETRÔNICO
SER_GD_PROGCOD_UNID2.indd 50 30/08/2019 13:49:50

Capacitar o aluno a utilizar elementos gráficos em jogos;
Capacitar o aluno a utilizar APIs que dão suporte à criação de jogos.
Tópicos de estudo
Elementos gráficos de um jogo
Composição dos gráficos
Variáveis e operadores
Formas primárias
Cenários e objetos (tiles e sprites)

Utilizando sprites
Utilizando tiles
Estruturas de controle
Criação de animações em jogos

Tipos de animação
Implementando animações
PROGRAMAÇÃO: INTRODUÇÃO AO CODING (GAMES) 51

Elementos gráficos de um jogo
Vamos começar nossos estudos falando um pouco sobre os elementos grá-
ficos que compõem um jogo digital. Existem dois componentes de hardware
responsáveis por mostrar os gráficos para o usuário final: a placa de vídeo e o
monitor (BRACKEEN; BARKER; VANHELSWUE, 2003).
A placa de vídeo armazena o que é mostrado na tela e possui funções
para modificar o que é mostrado. Além disso, também é responsável por
puxar o que está contido na memória e enviar essas informações para o
monitor.
Composição dos gráficos

Todo jogo possui componentes gráficos bidimensionais, tridimensionais ou
uma combinação de ambos, sendo que cada um desses estilos possui elementos
diferentes. É importante notar que, para os computadores, todos esses elemen-
tos são entendidos de forma numérica e, como tal, podem ser mostrados como
expressões matemáticas, sendo, por fim, entendidos em formato de bits.
Bits são a menor unidade de memória para um computador; eles podem
possuir os valores binários 0 ou 1, falso ou verdadeiro. Quanto mais bits são utili-
zados, mais valores podem ser guardados. A combinação de oito unidades de bit
forma um byte, a segunda menor unidade de memória.
Cada bit presente em um byte representa uma potência de dois. Os valores
podem ser vistos na Tabela 1:
TABELA 1. REPRESENTAÇÃO DE UM BYTE DE MEMÓRIA
1º 2º 3º 4º 5º 6º 7º 8º
20 = 1 21 = 2 22 = 4 23 = 8 24 = 16 25 = 32 26 = 64 27 = 128
A soma de todos os valores equivale a 256 – valor que a menor variável existente,
char, consegue armazenar. Seguindo essa estrutura, os demais valores podem ser
obtidos pelo ligamento e desligamento dos bits. Para obter, por exemplo, o valor
19, apenas os bits da primeira, terceira e quinta posição precisariam estar ligados, en-
quanto todos os outros estariam desligados. A representação em bits seria a seguinte:

11001000 = 19, pois 20 + 21 + 24 = 1 + 2 + 16 = 19
Observe que cada bit representa um interruptor. Quando desligado, cada
interruptor equivale a zero e quando ligado equivale a uma potência de dois.
É através da combinação de cada um desses interruptores que é possível al-
cançar os 256 valores possíveis. Cada valor representa um caractere dentro
da tabela ASCII, que abrange o alfabeto latino. Em algumas linguagens de pro-
gramação, os valores são guardados de 0 a 255. Uma variável do tipo char é
composta de um byte e pode armazenar valores nesse mesmo intervalo. As
cores geralmente utilizam uma codificação de três variáveis do tipo char como
parâmetro, um para vermelho, um para verde e outro para azul, formando um
componente de 24 bits.
EXPLICANDO
Eck (2011, p. 539) disserta que os dados consistem primariamente de carac-
teres, mas as palavras de um editor de texto podem possuir mais de uma
tradução. Os caracteres são armazenados no computador utilizando uma
codificação como a de valores 16-bit Unicode. Nos computadores com alfa-
betos ocidentais, os dados de caracteres são guardados em arquivos com a
codificação ASCII, que usa apenas 8 bits por caractere. Assim, ASCII é uma
forma de codificar os caracteres para interpretação do computador.
As cores também podem ser representadas por outro tipo de valor, chama-
do hexadecimal.
Diferentemente dos binários, que funcionam em base 2, os hexadecimais
funcionam em base 16, assim os valores variam de 0 a F. Isto quer dizer que os
valores podem ser 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E ou F, as letras representam
respectivamente os valores 10, 11, 12, 13, 14 e 15. Seguindo a lógica hexadeci-
mal de valores, o valor “EC” em base 10 equivaleria ao valor 236. A conversão
funciona da seguinte forma:
EC = 236
EC = (E = 14) * 16 (16 = o valor da posição) + (C = 12) * 1 (1 = o valor da posição)
EC = (14 * 16) + (12 * 1)
EC = 224 + 12
EC = 236
Valores hexadecimais costumam vir em três duplas para representar cores,
como na linguagem de marcação HTML ou na linguagem de estilo CSS, ambas

utilizadas no desenvolvimento de páginas web. Ele é composto de seis valores,
sendo que cada dupla equivale a uma cor. A cor vermelha, por exemplo, é gera-
da pelo código #FF0000, a cerquilha indica o início de um valor hexadecimal e
as duplas de valores indicam respectivamente a presença das cores vermelha,
verde e azul. Diversas ferramentas de desenho e edição de imagens, como o
Adobe Photoshop, utilizam os valores hexadecimais para selecionar cores.
Os componentes de cores também podem ter um espaço reservado para a
escala de transparência, conhecida como escala Alpha. Ela pode aparecer como
uma variável char extra que também recebe valores de 0 a 255.
Variáveis e operadores
Para que seja possível armazenar as informações necessárias, são utiliza-
das variáveis. Elas diferem em tipo de dados e em uso de memória. Acerca da
nomeação de variáveis em Java, há algumas restrições relacionadas a palavras
que têm uso específico, dentre elas: class, public, static, if, else, while, void, en-
tre outras. Por exemplo, a palavra if serve para a inicialização de uma estrutura
condicional e é sempre utilizada nesses casos.
Além da proibição de palavras reservadas, variáveis não podem ter espaço
em seus nomes e são entendidas de forma literal, diferenciando letras maiús-
culas e minúsculas; esse recurso de interpretação é conhecido como case sen-
sitive. Assim, as variáveis name, Name e NAME seriam três alocações de me-
mória com endereços diferentes.
Também não é possível utilizar um número no início do nome de uma variá-
vel, porém, o uso é livre a partir do segundo caractere. O nome de uma variável
pode ser composto de várias palavras, como HeroHealth, e a prática de iniciali-
zar as letras de cada palavra com letras em maiúsculo é conhecida como Camel
Case, por lembrar das corcovas de um camelo, e é reconhecida como uma boa
prática de escrita para identificação rápida de nomes.
As variáveis também podem receber expressões, além dos valores que seus
tipos determinam. Por exemplo, uma variável do tipo boolean pode receber
uma expressão numérica para verificação de grandezas. Para testar, insira o
seguinte código no Processing:
int i = 51;

boolean result = i < 50;
println(“O resultado da expressão é: ” + result);
A frase que aparecerá no console é “O resultado da expressão é: false”, pois o
valor da variável i é 51, o qual é maior do que 50. Para juntar o texto que seria exibido
com o valor do resultado da expressão que estava dentro da variável do tipo boo-
lean, foi utilizado o símbolo de soma, sendo o nome dessa operação concatenação.
Existem diversas expressões e operações que podem ser utilizadas com
variáveis para atribuir valores. Elas são utilizadas em estruturas condicionais
para verificar determinadas situações, como quando um personagem morre
em uma partida, na programação precisa ser verificado se a quantidade de
vida do personagem é menor ou igual a zero. Os tipos de operações disponí-
veis podem ser verificados na Tabela 2.
TABELA 2. OPERADORES RELACIONAIS
OPERADOR SIGNIFICADO
> Maior que
< Menor que
== Igual a
>= Maior ou igual a
<= Menor ou igual a
!= Diferente de
EXPLICANDO
É importante observar que, para verificar a igualdade entre dois valores
de variável, são utilizados dois sinais matemáticos de igualdade, enquan-
to para atribuir um valor a uma variável somente é utilizado um sinal de
igualdade. O nome dado a essas operações são respectivamente, com-
paração e atribuição. Além disso, o sinal de exclamação funciona como
negação, quando colocado antes de uma variável do tipo boolean, o sinal
transforma o valor da variável no oposto, assim false se torna true, e true
se torna false.
Observe alguns exemplos de utilização dos operadores relacionais com re-

sultado true:
boolean expressionA = 5 > 4;
println(expressionA);

int num1 = 10;
int num2 = 12;
boolean expressionB = num1 < num2;
println(expressionB);
String name1 = “Cloud”;
String name2 = “Cloud”;
boolean expressionC = name1 == name2;
println(expressionC);
float num3 = 4.75;
float num4 = 4.5;
boolean expression D = num3 >= num4;
println(expressionD);
float num5 = 5.8;
float num6 = 5.80;
boolean expressionE = num5 <= num6;
println(expressionE);
String name3 = “Mario”;
String name4 = “mario”;
boolean expressionF = name3 != name4;
println(expressionF);
Uma variável do tipo boolean também pode receber operadores lógicos
para comparar duas ou mais expressões, como quando é necessário verificar
se o jogador possui um item de cura e a vida do personagem é menor do que
o valor máximo de saúde. Os operadores lógicos possíveis são os seguintes:
TABELA 3. OPERADORES LÓGICOS
OPERADOR USABILIDADE
&& E
|| OU
O operador E (&&) compara duas ou mais expressões; se todas tiverem re-

sultado true, ele retorna o valor true. Porém, se uma das duas expressões ou
todas tiverem valor false, o valor retornado será false, enquanto o operador OU
(||) retorna o valor true, contanto que ao menos uma das expressões tenha re-

sultado true e apenas retorna false se todas as expressões tiverem valor false.
Por exemplo:
(9 < 5) && (10 > 20) = false && false = false
(12 == 11) && (“Luigi” != “Mario”) = false && true = false
(1 >= 0) && (50 > 30) = true && true = true
(9 < 5) || (10 > 20) = false || false = false
(12 == 11) || (“Luigi” != “Mario”) = false || true = true
(1 >= 0) || (50 > 30) = true || true = true
As variáveis também podem receber operações e expressões matemáti-
cas; isto possibilita que sejam atribuídos valores de forma dinâmica às va-
riáveis em funções e estruturas de repetição, como quando um personagem
se move em um jogo. Na programação, sua posição, contida em uma variá-
vel, tem seu posicionamento atualizado constantemente, quando o botão
estabelecido para esta ação é pressionado. Os símbolos disponíveis para
operações são os seguintes:
TABELA 4. OPERADORES ARITMÉTICOS
OPERADOR OPERAÇÃO
+ Soma
- Subtração
* Multiplicação
/ Divisão
% Resto da divisão
A diferença primordial entre a operação de divisão e resto da divisão é que

o resultado das operações serão, respectivamente, o produto e o resto da di-
visão. Por exemplo:
30 / 3 = 10
30 % 3 = 0
A operação de resto da divisão pode ser usada para quando for necessário
verificar se um número é divisível por outro, pois quando for, o resto sempre
será zero. Operações matemáticas também podem servir como expressões
lógicas para, por exemplo, verificar a posição de um determinado elemento
gráfico na tela.

Formas primárias
Os gráficos dos jogos eletrônicos são formados por
pixels pintados na tela, utilizando uma grande varie-
dade de cores. Basicamente, são vários pontos na
tela que, juntos, compõem linhas e as linhas formam
imagens.
Os primeiros jogos eram compostos de algumas formas sim-
ples para simbolizar os personagens, inimigos e itens, como no
jogo Asteroids. O Processing, assim como os motores gráficos de desenvolvimen-
to de jogos, possui uma série de bibliotecas de códigos próprios para desenhar
formas. Com elas, é possível criar desde formas primárias até formas complexas.
Também existem bibliotecas próprias para a criação de objetos tridimensionais,
como cubos e esferas.
Os comandos da biblioteca padrão do Processing para criação são:
• size: utilizado para estabelecer o tamanho da tela. Este comando pode
receber até três argumentos, sendo os dois primeiros a largura e o tamanho da
tela em pixels obrigatórios, o último é o tipo de renderização, a qual precisa ser
alterada se houver a utilização de elementos tridimensionais.
void setup() {
size(640,360);
}
• background: determina a cor de fundo da tela. Pode receber até quatro
valores, os quais representam as três cores do sistema RGB (vermelha, ama-
rela e azul) e a opacidade. Caso receba apenas um argumento, será entendido
como escalas de cinza.
void setup() {
background(0, 255, 0); //Cor azul}
• width: retorna o valor de largura da tela, definido no comando size.
void setup() {
size(640, 360);
println(“A largura da tela é: ” + width); //O valor de width declarado é igual a 640}
• height: retorna o valor da altura da tela, definido no comando size.
void setup() {

size(640, 360);
println(“A largura da tela é: ” + height); //O valor de height declarado é igual a 360}
• point: cria um ponto na tela com o tamanho de um pixel. Recebe apenas
os valores de posicionamento em x e y.
void draw() {point(50, 50);}
• line: cria uma linha de um ponto A a um ponto B. Pode utilizar o comando
stroke na linha anterior para determinar a cor do traço e o comando stroke-
Weight para determinar a espessura do traço. Pode receber até seis valores,
os quais equivalem à posição dos pontos inicial e final em x e y, sendo obriga-
tórios. Os dois últimos pontos são utilizados apenas no caso da renderização
tridimensional e determinam o posicionamento no eixo z do último ponto.
void draw() {line(50, 50, 100, 50);}
• quad: cria uma forma quadrilateral que não possui necessariamente ân-
gulos de noventa graus. Assim como uma linha, essa forma precisa do posicio-
namento x e y de cada um dos quatro pontos, os quais são conhecidos como
vértices.
void draw() {
quad(20, 50, 50, 50, 70, 80, 10, 80);}
• triangle: cria uma forma com três vértices. Cada vértice precisa receber as
duas coordenadas dos eixos x e y.
void draw() {
triangle(50, 50, 80, 80, 20, 80);}
• rect: cria uma forma retangular com ângulos internos de noventa graus.
Diferente das demais formas, o comando rect somente necessita das posições
dos eixos x e y iniciais; os demais argumentos são a largura e altura do retân-
gulo. Também é possível atribuir valores para o arredondamento dos vértices.
Seu ponto cardeal inicial fica localizado no canto superior esquerdo da forma.
void draw() {
rect(20, 20, 30, 50);}
• ellipse: desenha uma elipse que pode ser oval. Este
comando recebe valores para a posição inicial nos eixos
x e y, além da altura e largura da forma. Diferente-
mente do comando rect, o ponto inicial fica no centro
da forma.

void draw() {
ellipse(50, 50, 20, 50);}
• text: mostra um texto na tela. Para tal, recebe como argumento uma
string com o texto a ser mostrado, além de dois argumentos para a posição
nos eixos x e y. Assim como no comando rect, os pontos cardeais iniciais ficam
no canto superior esquerdo.
void draw() {
text(“Score:”, 50, 50);}
As referências às sintaxes dos comandos apresentados e dos demais co-
mandos que a biblioteca principal do Processing possui podem ser consulta-
das, em inglês, na aba reference do site oficial do Processing.
É importante observar que no Processing não há argumentos de cor nos
comandos para a criação dos objetos. Para que seja possível mudar o preenchi-
mento das formas, é necessário utilizar um comando na linha anterior, o qual
mudará a configuração de cor de todas as formas abaixo. Para mudar a cor de
apenas um objeto, é preciso utilizar o mesmo comando na linha anterior de
cada forma.
Utilizando apenas formas básicas, é possível criar os elementos do jogo
Pong, como no exemplo a seguir:
//variáveis para o posicionamento da bola
int ballX, ballY, ballSize;
//variáveis para o posicionamento das palhetas
int leftPaddleX, leftPaddleY, rightPaddleX, rightPaddleY;
//função de inicialização
void setup()
{
//determinar o tamanho e a cor de fundo da tela
size(640,360);
background(0);
//atribuir valores iniciais das variáveis da bola
ballX = width/2 - 5;
ballY = height/2 - 5;
ballSize = 10;
//atribuir valores iniciais das variáveis da palheta esquerda

leftPaddleX = 10;
leftPaddleY = height/2 - 50;
//atribuir valores iniciais das variáveis da palheta esquerda
rightPaddleX = width - 20;
rightPaddleY = height/2 - 50;
//determinar o tamanho da fonte do texto
textSize(32);}
//função de repetição
void draw()
{
//atualizando a cor de fundo toda vez que a tela for desenhada
background(0);
//estabelecendo a posição inicial e o texto da pontuação
text(“0”, 160, 50);
text(“0”, 480, 50);
//estabelecendo a posição e o tamanho inicial das palhetas
rect(leftPaddleX,leftPaddleY,10,100);
rect(rightPaddleX,rightPaddleY,10,100);
//estabelecendo a posição inicial
noStroke();
ellipse(ballX, ballY, ballSize, ballSize);}
As formas primárias também podem ser utilizadas para a criação das caixas
de colisão dos personagens, objetos e cenário. Linhas também podem ser usadas
como raios para verificar a distância entre dois objetos. Porém, para a criação visual
desses elementos em jogos bidimensionais, são geralmente utilizados sprites e tiles.
Cenários e objetos (tiles e sprites)

Tudo que está presente nos jogos 2D é composto de sprites. Eles são usados
para a criação tanto do cenário quanto dos personagens e itens. Em jogos 3D,
geralmente são utilizados somente para a criação de partículas e das imagens
utilizadas na interface gráfica.
Sherrod (2008) divide os sprites em dois tipos: estáticos e dinâmicos. Os spri-
tes estáticos são utilizados quando não há a necessidade de serem animados,

como em objetos, cenários e personagens que não se locomovem. Sprites está-
ticos podem ser usados para compor o fundo de um cenário, como na Figura 1.
Figura 1. Exemplo de utilização de sprites estáticos. Fonte: Game Art 2D, 2014.
Sprites dinâmicos são compostos de uma série de sprites na mesma ima-

gem que serão trocadas continuamente para criar o efeito visual de uma ani-
mação. Eles mostram o mesmo personagem ou objeto em diferentes poses,
assim, quando as imagens forem trocadas, teremos a impressão de movimen-
to, semelhante ao que acontece nos flipbooks.
Figura 2. Exemplo de utilização de sprites dinâmicos. Fonte: Itch.io, 2018.
Utilizando sprites
As imagens podem ser criadas utilizando softwares de criação de imagens,
como Adobe Photoshop, Adobe Illustrator, Aseprite, entre outros. O visual ar-
tístico pode se utilizar de pinturas, artes vetoriais ou pixel art de acordo com a
estética desejada no jogo. Já em relação ao formato de compressão da imagem,
o mais apropriado para jogos é o PNG, pois este formato possui propriedade
de transparência, enquanto os demais formatos ficam com pixels brancos nas

regiões em que não são pintados. Essa propriedade também possibilita criar
imagens translúcidas, isto é, com efeitos semelhantes aos de um fantasma.
No Processing, para mostrar uma imagem é necessário importá-la para o
projeto e criar um objeto do tipo PImage para armazená-lo. Para importar uma
imagem para o projeto, é necessário salvá-lo clicando na parte superior do edi-
tor em Arquivo > Guardar e depois arrastar a imagem para o editor; com isto é
criada uma cópia em uma pasta nomeada data, que pode ser consultada clican-
do na parte superior do editor em Sketch > Ver Pasta de Sketch.
A sintaxe para a criação de um objeto de imagem é a seguinte:
//Declaração do objeto com o tipo seguido pelo nome do objeto
PImage img;
void setup() {size(640,360);
//Atribuição da imagem ao objeto
img = loadImage(“BG.png”);}
void draw() {
//Exibição do objeto na tela com os parâmetros de posicionamento e tamanho
image(img, 0, 0, width, height);}
PImage é um tipo de dado que serve para armazenar e manipular um obje-
to de imagem. Para que seja possível exibir a imagem na tela, primeiramente
é necessário carregar o arquivo utilizando o comando loadImage, que recebe
como parâmetro o nome do arquivo importado anteriormente. Após isso, é
utilizando o comando image para exibir na tela, posicionar e configurar o ta-
manho da imagem.
Para a criação deste exemplo, foi utilizada a imagem BG.png, a qual pode
ser baixada no site Game Art 2D (2014). No arquivo baixado, há diversas ima-
gens com objetos e tiles editáveis no formato de Adobe Illustrator, além de
imagens em formato PNG, que podem ser utilizadas para compor o cenário e
criação de terreno.
DICA
Para a prototipagem de um jogo e até mesmo a criação, é possível utilizar
recursos criados e disponibilizados gratuitamente por outras pessoas no
mundo. Alguns sites que disponibilizam esse tipo de conteúdo para desen-
volvedores de jogos são o Itch.io, o OpenGameArt.org e o Game Art 2D.

É importante observar que a ordem que as imagens são desenhadas no
código estabelecerá a ordem de sobreposição, criando o que é conhecido por
camadas. Com o uso de camadas é possível atribuir velocidade de movimenta-
ção distinta para cada imagem.
Utilizando tiles
Imagens podem ser recursos muito pesados para o processamento e arma-
zenamento em jogos digitais. Para que não seja necessário criar todas as ima-
gens de terrenos, paisagens e demais peças de cenários que podem se repetir
são utilizados os tiles.
Um tile é semelhante a uma peça de azulejo. Para substituir a utilização de
uma grande peça, são usadas pequenas peças lado a lado para compor as pla-
taformas, terrenos e demais cenários.
Figura 3. Tile. Fonte: Game Art 2D, 2014.
Em Processing, a criação de plataformas e terrenos também utiliza o

componente PImage. Para construir uma pequena plataforma, utilize os tiles
1.png, 2.png e 3.png, que se encontram no mesmo arquivo baixado com a
imagem de fundo. Importe ele para o projeto, arrastando o arquivo para a
tela do editor.
Para que não seja necessário criar um objeto para receber o valor de cada
imagem, é possível utilizar um recurso de programação chamado array. Arrays
são utilizados para criar um vetor com vários espaços de alocação de memória
em um mesmo objeto, alterando apenas o índice que se encontra nele. Ao ini-
ciar um array, é necessário atribuir o comando new seguido do tipo do objeto e
colocar entre colchetes o número de itens que ele armazenará.

Utilizando o conceito de array junto ao componente PImage, é possível criar
uma amostra de plataforma com o seguinte código:
//Criação de um array do tipo PImage com três espaços de alocação
PImage platform[] = new PImage[3];
void setup() {
size(640,360);
//Atribuição das imagens nos diferentes índices, começando sempre pelo valor 0
platform[0] = loadImage(“1.png”);
platform[1] = loadImage(“2.png”);
platform[2] = loadImage(“3.png”);}
void draw() {background(0);
//Exibição sequencial das imagens na tela
image(platform[0], 0, height - 64, 64, 64);
image(platform[1], 64, height - 64, 64, 64);
image(platform[2], 128, height - 64, 64, 64)}
Tiles também podem dispor, na mesma imagem, várias peças diferentes,
economizando espaço de memória e necessitando que apenas um arquivo seja
carregado. Estes arquivos são conhecidos como tilesets.
Figura 4. Imagem de tileset. Fonte: Game Art 2D, 2014.
Cada imagem de um tileset pode ser carregada em objetos individuais atra-

vés do endereçamento da imagem. A função get do componente PImage é res-
ponsável por essa ação na biblioteca Processing.

Estruturas de controle
As linguagens de programação contêm um conjunto de estruturas de con-
trole para executar determinadas ações, quando uma dada condição é suprida
ou para que determinada linha de código seja repetida enquanto uma condição
não é satisfeita. Essas estruturas são: IF, WHILE e FOR.
IF
A estrutura condicional padrão é o IF. Com ela, é possível criar caminhos de
escolha dentro do programa de forma simples ou aninhada, com várias condi-
cionais consecutivas. Por exemplo:
If (3 < 5) {println(“O número três é menor do que o número cinco”);}
Em jogos, IF é utilizada para as principais ações programadas. É através dela
que é verificado se um botão está sendo apertado ou que a inteligência arti-
ficial do inimigo é criada, por exemplo. A estrutura ainda dispõe de mais duas
variações utilizando as palavras-chave ELSE e ELSE IF.
A palavra-chave ELSE é utilizada quando se quer estabelecer um caminho
opcional para quando a condição da estrutura IF não se cumprir. Por exemplo:
int life = 30;
if (life < 15) {
println(“O personagem está com menos da metade da vida. Tome cuidado!”);}
else {println(“O personagem está com mais da metade da vida. Continue lutando!”);}
Enquanto a palavra-chave ELSE IF é usada para criar mais uma condição alterna-
tiva. É possível criar quantas funções alternativas forem necessárias. Por exemplo:
String type = “Fire”;
if (type == “Fire”) {println(“O seu personagem tem vantagem contra o tipo Planta.”);}
else if (type == “Water”) {println (“O seu personagem tem vantagem contra o tipo Fogo.”);}
else if (type == “Plant”) {println (“O seu personagem tem vantagem contra o tipo Água.”);}
else (){println(“O seu personagem não têm vantagem contra nenhum tipo.”)}
WHILE
A estrutura de repetição WHILE é utilizada para repetir um bloco de coman-
dos enquanto determinada condição não é suprida. Por exemplo:
int i = 1;
while (i < 10) {println(“Número de vezes que o laço se repetiu: ” + i”);
i = i + 1;}

É imprescindível que exista o acréscimo do índice para que o loop termi-
ne, caso contrário ele ocorrerá de forma infinita. O WHILE também pode ser
utilizado para criar um laço de repetição infinito para que haja uma atualiza-
ção constante. A função draw pode ser vista como um exemplo disto.
while (true) {println(“Este laço é infinito.”);}
FOR
A estrutura FOR é usada, assim como a estrutura WHILE, para que um bloco
de script seja repetido diversas vezes, com a diferença que é possível estabele-
cer internamente o valor inicial da variável que será utilizada como condição, o
limite de repetição e a forma de acréscimo. Eis a sintaxe:
for (int i = 0; i < 10; i = i + 1){println(“O valor da variável i é:” + i);}
Estruturas de repetição FOR também podem ser usadas junto a arrays para
preenchimento rápido de um vetor ou consulta dos valores armazenados.
Como nos exemplos a seguir:
Exemplo de preenchimento:
//Criação de um array vazio
String platform[] = new String[3]
//Preenchimento do array
for (int i = 0; i < items.length; i++) {
platform[i) = “Idle” + i + “.png”;}
Exemplo de consulta:
//Criação de um array com os itens do jogador
String items[] = {“Poção”, “Espada”, “Escudo”};
//Consultar os itens utilizando uma estrutura de repetição
for (int i = 0; i < items.length; i++) {println(“Você possui em sua bolsa: “ + items[i]);}
Criação de animações em jogos

Em um jogo digital, uma animação é a ilusão de movimento causada
pela troca de uma sequência de sprites. Pelo fato de as imagens perma-
necerem na tela durante milissegundos, a visão humana entende que a
imagem que está vendo está se movimentando, quando, em verdade, ela
é atualizada na tela constantemente, seja substituindo por outra ou modi-
ficando sua posição.

As animações de jogos eletrônicos podem ser feitas através de diversos
meios, desde os mais clássicos, como o uso de mesas de luz e digitaliza-
ção das imagens, até a criação de desenhos digitais utilizando softwares
especializados, como Photoshop, Toon Boon, After Effects, entre outros.
Os jogos podem usar de animações para os personagens ou cenas comple-
tamente animadas, conhecidas como cutscenes. Para tal, existem diversos
tipos de animações.
Tipos de animação
Os estilos de animação para jogos variam de acordo com as limitações
técnicas do projeto ou do estilo visual que se deseja alcançar. Os primei-
ros jogos possuíam a limitação de poderem utilizar apenas da troca de
quadros para criar animações, enquanto em jogos mais atuais é possível
animar personagens e cenários com muito mais detalhamento, graças à
evolução das placas gráficas, além de existirem ferramentas para mode-
lagem e animação 3D. Acerca das animações 2D, existem alguns estilos e
técnicas que se destacam:
• Frame a frame: neste estilo de animação, são desenhados todos
os quadros com a movimentação do personagem, que são trocados de
forma a simular o movimento do personagem. Esta técnica se asseme-
lha aos flipbooks, nos quais é desenhada uma cena em cada página e,
ao passar as páginas rapidamente, há a ilusão óptica de
movimento das imagens. Os primeiros jogos se utiliza-
vam desta técnica por causa de sua limitação
gráfica e tecnológica. Inicialmente, somente
alguns quadros de animação podiam ser uti-
lizados. Com o avanço tecnológico, cada vez
mais detalhes puderam ser adicionados ao
movimento de personagens e objetos através
de mais quadros de animação. As animações frame a
frame são as mais comumente utilizadas nos jogos, por
ser um dos primeiros estilos de animação a aparecerem
no meio.

Figura 5. Demonstração de animação frame a frame. Fonte: Game Art 2D, 2019.
• Cut-out: As animações do tipo cut-out separam os personagens e objetos

a serem animados em peças que podem ser animadas individualmente. Esse
processo possibilita que as mesmas figuras sejam utilizadas para diversas poses
da animação. Porém, os movimentos tendem a ser mais mecânicos e caricatos se
não for usada a técnica de rigging. Os sprites produzidos para animações cut-out
são como peças recortadas de um modelo. Dessa forma, é possível rotacionar e
movimentar cada peça individualmente, como vemos na Figura 6.
Figura 6. Animações cut-out. Fonte: Game Art 2D, 2014.
• Rotoscopia: é o nome dado à técnica de desenhar sobre uma filmagem.

O primeiro jogo a se utilizar de tal técnica foi o primeiro jogo da série Prince
of Persia.
• Rigging: é o nome dado à técnica de separar uma imagem ou um mode-
lo 3D em partes com uma estrutura óssea virtual. Através desta técnica, os

modelos podem ser deformados, resultando em animações mais detalhadas
e com movimentos menos mecânicos. Um dos possíveis programas utilizados
para a criação desse esqueleto é o Spine.
• Pré-renderização de figuras 3D: após a criação de softwares de mode-
lagem 3D, tornou-se possível a utilização de modelos tridimensionais para a
criação de jogos bidimensionais, como foi no caso do jogo Donkey Kong Coun-
try para o console Super Nintendo – o jogo utilizava sprites feitos a partir da
técnica de pré-renderização de modelos 3D, isto é, foram tiradas “fotos” dos
modelos tridimensionais. Os primeiros jogos da série Resident Evil também
utilizaram desta técnica para criar os cenários.
Implementando animações
A implementação de animações no Processing é um
tanto quanto complexa e envolve um pouco de cada
um dos conceitos apresentados. Para que seja possí-
vel carregar todas as imagens de forma sequencial, é ne-
cessário carregar todas elas dentro de um array do tipo PIma-
ge. Além disto, o programa precisa receber em uma variável a
quantidade de frames para conseguir limitar o valor máximo que
o índice pode atingir, caso contrário, ele extrapolaria a quantidade de imagens
contidas no array. Também é preciso verificar qual a velocidade de repetição
dos quadros através do comando frameRate, para que a animação funcione
em uma velocidade adequada.
// O número de imagens que a animação terá
int numFrames = 15;
int currentFrame = 0;
PImage[] images = new PImage[numFrames];
void setup() {
size(640, 360);
frameRate(24);
//Carrega e atribuir cada uma das imagens ao Array
images[0] = loadImage(“Run (1).png”);

}
void draw() {
background(0);
// Usa-se o operador % para servir de índice para a troca de imagens
currentFrame = (currentFrame+1) % numFrames;
scale(0.25,0.25);
image(images[currentFrame], 0, 0);
}
Utilizando o comando FOR e a concatenação de Strings, é possível criar a
seguinte estrutura condicional para carregar todas as imagens em um array:
int numFrames = 15;
void setup() {
size(640, 360);
frameRate(24);
//Carregar e atribuir cada uma das imagens ao Array
for (int i = 0; i < numFrames; i++) {
String imageName = “Run (“ + (i + 1) + “).png”;
images[i] = loadImage(imageName);

}
}
void draw() {
background(0);
scale(0.25,0.25);
image(images[currentFrame], 0, 0);
}
Para que este código funcione, todas as imagens relacionadas com a anima-
ção devem possuir a mesma estrutura do nome, isto é:
Nome da imagem + Índice sequencial da imagem + Formato da imagem
De forma a fazer o personagem se movimentar enquanto a animação está
funcionando, pode-se atribuir uma variável para atualizar dinamicamente a
posição da imagem no eixo x da seguinte forma:
int numFrames = 15;
int posX = 0;
int speed = 20;
void setup() {
size(640, 360);
frameRate(24);
//Carregar e atribuir cada uma das imagens ao Array
for (int i = 0; i < numFrames; i++) {
String imageName = “Run (“ + (i + 1) + “).png”;
images[i] = loadImage(imageName);
}
}
void draw() {
background(0);

scale(0.25,0.25);
image(images[currentFrame], posX, 0);
//Adiciona o valor da velocidade a posição a cada frame
posX = posX + speed;
}
O estilo de animação mais propício a ser usado no Processing é o frame a
frame, apesar de ser possível utilizar os métodos de manipulação e criação de
imagens para fazer animações por outros meios, como no estilo cut-out.
Algumas game engines, como Unity e Construct 2, possuem bibliotecas e
ferramentas próprias para facilitar a implementação, uso e até mesmo a cria-
ção de animações.

Sintetizando
Nessa unidade, foi apresentado como são produzidos e inseridos, através
da programação, os elementos gráficos de um jogo utilizando o editor Proces-
sing e a linguagem de programação Java.
Os elementos gráficos podem ser criados mediante diferentes funções pre-
sentes em bibliotecas de programação com recursos visuais, como no caso do
Processing, o qual possui funções para desenhar formas básicas. Também é
possível a criação de recursos gráficos utilizando de softwares próprios, poste-
riormente importando-os e manipulando-os em ambientes de desenvolvimen-
to integrado.
Através do uso de tiles e sprites para a criação de cenários, objetos e perso-
nagens, é possível dar vida ao jogo e adotar diversas formas de apresentação
estética que não eram possíveis nos primórdios da indústria.
Os sprites podem ser colocados em movimento mediante o uso de estrutu-
ras de repetição, como a função draw, e da mudança de valores das variáveis
para o posicionamento ou tamanho. Além disso, as imagens podem ser troca-
das dinamicamente com a utilização de arrays e estruturas de controle, criando
as animações.
As animações, por sua vez, são usadas em jogos para simular movimentos e
podem ser feitas com diferentes técnicas para criar a sensação de movimenta-
ção captada pela visão humana, sendo algumas dessas técnicas a frame a fra-
me e a cut-out, a primeira baseando-se na troca de imagens conhecidas como
quadros, e a segunda aproveitando-se da divisão em pedaços para movimen-
tá-los separadamente.

BRACKEEN, D.; BARKER, B.; VANHELSWUE, L. Developing Games in Java. San
Francisco: New Riders Games, 2003.
ECK, D. J. Introduction to Programming Using Java. [s.l.], 2011. Disponível em:
<http://math.hws.edu/eck/cs124/downloads/javanotes6-linked.pdf>. Acesso
em: 07 jun. 2019.
GAME ART 2D. Free Platform Game Tileset. [s.l.], 2014. Disponível em: <ht-
tps://www.gameart2d.com/free-platformer-game-tileset.html>. Acesso em: 10
jun. 2019.
GAMEasd. Hill Climbing - Free Sprite. [s.l.], 2018. Disponível em: <https://
www.gameart2d.com/hill-climb-racing---free-car-sprites.html>. Acesso em: 15
jun. 2019.
GAMEasd. The Boy - Free Sprite. [s.l.], 2019. Disponível em: <https://www.ga-
meart2d.com/the-boy---free-sprites.html>. Acesso em: 10 jun. 2019.
ITCH.IO. Pixel Slime. [s.l.], 2018. Disponível em: <https://rvros.itch.io/pixel-art-
-animated-slime>. Acesso em: 15 jun. 2019.
SHERROD, A. Game Graphics Programming. Burlington: Course Technology, 2008.

UNIDADE
3 DISPOSITIVOS
DE ENTRADA,
INTELIGÊNCIA
ARTIFICIAL E
INTERAÇÃO HOMEM-
MÁQUINA

Capacitar o aluno a utilizar APIs que dão suporte à criação de jogos;
Capacitar o aluno a utilizar dispositivos de entrada em jogos;
Capacitar o aluno a implementar jogos usando motores próprios ou de

terceiros.
Tópicos de estudo
Leitura de dispositivos de
entrada
A história dos controles
Utilizando o mouse
Utilizando o teclado
Máquinas de estado em jogos

O que é inteligência artificial
Criando comportamentos
Implementando máquinas de
estado
Motores de jogos
Como utilizar motores de jogos
Principais motores de jogos

Leitura de dispositivos de entrada
Os jogos eletrônicos necessitam de interfaces para que haja interação en-
tre ser humano e máquina, isto é, jogador e aparelhos de videogames. Para tal,
existem dispositivos de entrada responsáveis pelo envio de comandos para a
máquina, como controles e microfones, e dispositivos de saída, como caixas de
som e monitores.
A história dos controles

Podemos entender as máquinas de pinball como antecessoras dos apa-
relhos de videogames, como descrito pelo jornalista Kent (2011). A estrutura
das máquinas criadas no fim do século XVIII pouco lembraria os consoles
criados no século seguinte. Porém, a maneira de manusear as máquinas
remeteria muito à forma empregada para jogar jogos digitais na grande
maioria dos casos, dentre elas o uso de botões para controlar as palhetas, o
puxar de um pistão para dar início ao jogo e o colocar de uma moeda para
adquirir chances para jogar. As máquinas de arcade herdaram a estrutura
de funcionamento por moedas e os comandos por botões; anos mais tarde
algumas dessas características também estariam presentes nos controla-
dores para videogames.
Os primeiros controles podem ser vistos como botões analógicos que ser-
viam para comandos simples, assim como presente nos primeiros computa-
dores. No jogo Tennis for Two, por exemplo, desenvolvido pelo físico William
Higinbotham em 1958, os controles eram compostos de um botão de pres-
sionar e um botão rotativo; o primeiro servia para acertar a bola, enquanto
o segundo servia para ajustar o ângulo para o qual a bola seguiria. Essa es-
trutura foi, de certa forma, preservada no primeiro protótipo de um console
doméstico, o Brown Box, projetado pelo engenheiro Ralph Baer, e na
primeira máquina de Pong criada pelo engenheiro Nolan
Bushnell. Em ambos os casos, os jogos demonstrados
remetiam a uma partida de tênis na qual as raquetes
eram controladas por botões rotativos e as partidas
eram iniciadas ao pressionar de um botão.

Figura 1. Os botões rotativos, além de serem usados para jogar Pong, eram perfeitos para controlar jogos de corrida. A Atari se
utilizou desse conceito para criar um controle próprio para jogos nesse estilo. Fonte: Wikimedia. Acesso em: 20/08/2019.
As primeiras máquinas de arcade e a versão portátil de Pong utilizavam con-

troles com botões rotativos. Mas, apesar de ter o básico para que personagens
se movessem e um botão de ação, a estrutura dos controles se limitava a duas
direções e a uma única ação para o botão. Essas limitações foram superadas com
o controle do videogame Magnavox Odyssey, em 1972, que contava com dois bo-
tões rotativos nas laterais do controle, possibilitando movimentação em quatro
direções. Em 1977, o console Atari 2600 também inovou em seu controle, sendo
o primeiro a ser digital, o qual contava com um joystick (uma espécie de manche
para possibilitar a movimentação em quatro direções), e manteve, também, um
botão para interação usado para executar pulos em jogos como Pitfall.
Figura 2. O clássico controlador do Atari 2600 com seu joystick. Possuía a capacidade de se mover em quatro direções. Um dos
exemplos que se utilizava dessa função era o jogo digital Frog, no qual um sapo recebia comandos para se mover enquanto
atravessava uma rua. Fonte: Wikimedia. Acesso em: 20/08/2019.

Os controles dos consoles seguintes dispunham das mesmas característi-
cas, porém, o número de jogos que podiam ser criados utilizando apenas esses
comandos eram poucos. A fim de tentar revolucionar a indústria e entrar no
mercado, a Mattel lançou, em 1979, o seu console com um controle que, além
do botão rotativo tradicional, trouxe ao mercado um controle com botões nu-
méricos (que remetia a um controle de televisão), e dois botões em cada lateral.
A ideia era de ampliar o número de interações possíveis para o jogador. Esse
mesmo estilo de controle foi utilizado pelas concorrentes Coleco e Atari em
seus consoles sucessores, mas, seja pela ausência de novos conceitos de jogos
eletrônicos ou pela crise que se instaurava, esse design foi substituído com a
criação do console da Nintendo, o Nintendo Entertainment System.
Figura 3. Controles com diversos botões numéricos, como no caso do videogame Atari 5200. Eram grandes comparados aos
seus predecessores, e dispunham de muitos botões. No entanto, a maioria dos jogos não utilizavam esses botões, mostrando
sua inutilidade. Fonte: Wikimedia. Acesso em: 20/08/2019.
O videogame que a Nintendo usou para entrar no mercado em 1983 apre-

sentou um controle simples, porém que supria as necessidades de interação por
meio de dois botões para interatividade marcados pelas letras A e B, e também
da substituição do joystick por um D-pad (conjunto de botões formando uma cruz
que possibilitavam movimentos em até oito sentidos através da combinação entre
eles). O D-pad foi preservado em quase todos os controles que foram lançados
posteriormente, com algumas diferenças relacionadas à forma como o botão era
apresentado. Um exemplo é o caso do controlador do console Genesis, da Sega,
lançado em 1986. Nessa ocasião, o D-pad já era composto de um círculo ao redor
da cruz, além de oito botões para controlar todas as direções disponíveis.

Figura 4. Os D-pads alteraram a forma como o jogador usava sua mão para jogar. Enquanto botões rotativos e joysti-
cks necessitavam de dois dedos ou até mesmo a mão inteira para serem usados, os D-pads podiam ser utilizados com
apenas um dedo. Fonte: Wikimedia. Acesso em: 20/08/2019.
O Sega Genesis foi o primeiro console a possuir um controle curvado para

ser segurado com as mãos e a apresentar três botões para interação (A, B e C),
logo depois apresentou um controle com seis botões, acrescentando as letras
X, Y e Z. Foi referência para jogos de luta como a série Street Fighter, disponibi-
lizando três opções de força para chutes e mais três opções para socos. Esse
design influenciou os controles do console Super Nintendo, que também con-
tava com um D-pad e quatro botões frontais indicados pelas letras A, B, X e Y,
além de inovar apresentando um botão em cada lateral superior. Após isso, a
Sony utilizou o mesmo design para os controles do seu primeiro videogame, o
PlayStation, trocando as letras por formas geométricas e acrescentando dois
novos botões superiores, além de um formato alongado na parte inferior do
controle para que fosse segurado com as mãos. Esse conceito foi anteriormen-
te apresentado em alguns controles para computadores.
Figura 5. Os novos controles da época demonstravam maior preocupação com a ergonomia de seus aparelhos e
tinham uma visão mais centrada no conforto do jogador, apresentando melhorias principalmente em seus formatos.
Fonte: Wikimedia. Acesso em: 20/08/2019.

Anos mais tarde, em 1996, foi lançado o Nintendo 64. A partir disso, imple-
mentou-se no antigo conceito usado para o Super Nintendo, uma estrutura em
forma de M, seis botões frontais, dois botões superiores, o D-pad à esquerda
e um joystick analógico no meio da parte frontal, resgatando o conceito de
joystick apresentado nos primeiros consoles, porém, com o adendo de que es-
ses joysticks conseguiam alcançar mais direções por causa de seu ajuste fino e
perfeito para jogos tridimensionais, como Super Mario 64, por exemplo..
Figura 6. Os D-pads alteraram a forma como o jogador usava sua mão para jogar. Enquanto botões rotativos e joysti-
cks necessitavam de dois dedos, ou até mesmo a mão inteira, para serem usados, os D-pads podiam ser utilizados com
apenas um dedo. Fonte: Wikimedia. Acesso em: 20/08/2019.
Os consoles que procederam utilizavam os mesmos conceitos de botões

frontais D-pad, botões superiores e os joysticks, dois deles a partir da segunda
versão dos controles de PlayStation, um do lado esquerdo e um do lado direito.
Algumas empresas tentaram modificar esse conceito através de uma mudança
no tamanho dos controles, na quantidade de botões frontais e até mesmo no
uso do joystick direito, utilizando-o como um conjunto de botões. Porém, o uso
mais comum do joystick direito era o de controlar a câmera em jogos tridimen-
sionais e a mira em jogos de tiro em primeira pessoa.
Figura 7. Duas funcionalidades apresentadas foram que os joysticks também podiam ser utilizados como botões ao
pressioná-los, e os controles também possuíam dois motores vibratórios. Fonte: Wikimedia. Acesso em: 20/08/2019.

CURIOSIDADE
O controle do videogame DreamCast, lançado pela empresa Sega em 1998,
contava com um dispositivo com uma tela de LCD que também era um car-
tão de memória encaixado no controle para prover mais informações do
jogo, como, por exemplo, a condição de saúde de seu personagem no jogo
Resident Evil. Esse dispositivo também podia ser usado como um console
portátil, ou, segundo a pesquisadora Taylor (2002), para mostrar mapas e
para checar o uso de memória.
Em 2002, a Nintendo apresentou o primeiro modelo de controle sem fio

utilizando sinais de rádio criado para o GameCube, mas, foi só em 2005 que a
Microsoft introduziu o conceito de controle sem fio por bluetooth com o Xbox
360. Essa mesma tecnologia foi usada para os controles da Nintendo, Microsoft
e Sony para seus respectivos controles dos consoles seguintes, isto é, Wii, Wii
U, Nintendo Switch, Xbox One, PlayStation 3 e PlayStation 4.
A Nintendo também foi a responsável por introduzir no mercado de jogos
os controles com sensores de movimento em 2006, com os controladores de
Nintendo Wii. A Sony lançou, anos depois, seus próprios controles de movi-
mento para PlayStation 3, enquanto a Microsoft focou no desenvolvimento do
Kinect para Xbox 360, uma câmera com sensores de movimento.
Figura 8. O controle de Wii contava com um periférico auxiliar, conhecido como Nunchuk. Enquanto o Wii Remote
possuía apenas dois botões frontais, um D-pad e botões traseiros, o Nunchuk podia ser conectado a ele adicionando
um joystick e mais dois botões na parte superior. Fonte: Wikimedia. Acesso em: 20/08/2019.
Enquanto Sony e Microsoft optavam por seguir com escolhas mais seguras
e semelhantes às gerações anteriores em relação aos seus controladores prin-
cipais, a Nintendo tentava, a cada geração, inovar na maneira de jogar. Em

2012, com o lançamento do Nintendo Wii U, foi revelado seu controle que se
assemelhava a um tablet com os quatro botões do Super Nintendo, um joystick
em cada lado, uma tela sensível ao toque e botões na parte superior.
Figura 9. O controle de Wii U servia como uma tela auxiliar, mostrando mapas e menus, mas também podia ser
utilizado para exibir a tela e, apesar de não ser bem recebido pelo público, serviu como base para a concepção do seu
sucessor. Fonte: Wikimedia. Acesso em: 20/08/2019.
Uma adesão presente desde o PlayStation 3, Xbox 360 e Wii U foi a possibi-
lidade de conectar fones de ouvido e microfones, ou de ter um dispositivo de
entrada de áudio interno e alto-falantes.
O Nintendo Switch, lançado em 2017, apresentava dois pequenos contro-
les de movimento que podiam ser conectados a uma tela transformando em
um console portátil. Eles também podiam ser utilizados separadamente como
controles únicos e a tela podia ser conectada ao console ou, ainda, ser utilizada
separadamente para exibir o jogo.
CONTEXTUALIZANDO
Existem mais controles do que se é possível documentar, principalmen-
te pelo fato de as empresas lançarem diversos modelos durante a vida
útil de um console, além de periféricos utilizados para jogos eletrônicos
específicos, como as guitarras do jogo Guitar Hero. Segundo a pesquisa-
dora Taylor (2002), o motivo para tamanha variedade de interfaces é pela
quantidade de gameplay e a interdependência que têm entre si, isto é, as
interfaces dependem dos comandos disponíveis, assim como novas inter-
faces são desenvolvidas por necessidades específicas de gameplay.

Utilizando o mouse
Cada console dispõe de controles
próprios com formatos, quantidade
de botões e tecnologias empregadas
diferentes, enquanto os computadores
se utilizam dos teclados para executar
ações padrões, como programar e ope-
rar o computador, além de também
servirem para jogar, e dos mouses para
clicar e arrastar objetos, apesar de ser
possível utilizar controles como os de
Xbox 360 ou próprios para computado-
res, feitos por empresas de periféricos.
Para testar a implementação de comandos de mouse e de teclado será
utilizado o programa Processing.
Primeiramente, para utilizar o mouse e o teclado não há a necessidade
de importar bibliotecas. O ambiente Processing já possui funções e proprie-
dades para tal. Por exemplo, para saber a posição horizontal do mouse bas-
ta utilizar o comando mouseX, e para obter a posição vertical basta utilizar
o comando mouseY. Basicamente, para que um objeto seja desenhado na
posição do mouse, é necessário que ele receba as posições x e y do mouse,
como no exemplo a seguir.
void setup() {
size(640,360);
background(0);
}
void draw() {
background(0);
//Esconde a imagem do cursor
noCursor();
//A elipse tem sua posição constantemente atualizada pela posição do mouse
ellipse(mouseX, mouseY, 20,20);
}

É possível ir além utilizando a elipse criada como cursor,
acrescentando o comando noCursor(). Para utilizar os botões
do mouse para executar alguma tarefa, é utilizada a função
mousePressed(). Por exemplo, é possível alterar a cor do fundo
para branca quando o botão esquerdo do mouse for pressionado,
mudar para preta quando o botão direito for pressionado, e cinza se
for o botão mediano, executando da seguinte forma:
//Variável que armazenará a cor
int bgColor = 0;
void setup(){
size(640,360);
background(0);
}
void draw(){
background(bgColor);
//Esconde a imagem do cursor
noCursor();
//A elipse tem sua posição constantemente atualizada pela posição do mouse
ellipse(mouseX, mouseY, 10,10);
}
void mousePressed() {
//Verifica se o botão pressionado é o esquerdo
if (mouseButton == LEFT) {
bgColor = 255;
}
//Verifica se o botão pressionado é o direito
else if (mouseButton == RIGHT) {
bgColor = 0;
}
//Verifica se o botão pressionado é o mediano
else {
bgColor = 126;
}
}

Utilizando o teclado
Para captar os botões pressionados no teclado, também existe uma função
específica denominada keyPressed. Esta função capta quando qualquer botão
do teclado é pressionado, porém necessita de uma estrutura condicional para
distinguir qual deles é pressionado, sendo construída da seguinte forma:
void draw(){
}
//É acionado toda vez que um botão do teclado é pressionado
void keyPressed() {
if (key == ‘a’ || key == ‘A’) {
println(“A tecla A foi pressionada.”);
}
if (key == ‘s’ || key == ‘S’) {
println(“A tecla S foi pressionada.”);
}
if (key == ‘d’ || key == ‘D’) {
println(“A tecla D foi pressionada.”);
}
if (key == ‘w’ || key == ‘W’) {
println(“A tecla W foi pressionada.”);
}
}
Para verificar um botão de letra é preciso usar uma condição para
a letra maiúscula e outra para a letra minúscula, uma vez que o co-
mando entende ambas como comandos diferentes.
Além da função keyPressed, existe a função keyReleased
para verificar se um botão terminou de ser pressionado. Isso
é importante para definir ações que devem ser executadas
enquanto o botão estiver pressionado, como, por exemplo,
para movimentar uma personagem. Esse exemplo pode ser vis-
to no código a seguir.
//Variáveis do posicionamento e velocidade do retângulo
float speedY, speedX, posX, posY;

void setup(){
size(640,360);
background(0);
}
void draw(){
background(0);
//Atualiza a posição ao pressionar dois botões
posX = posX + speedX;
posY = posY + speedY;
//Cria um retângulo de pode ser controlado pelo teclado
rect(posX, posY, 10, 10);
}
//É acionado toda vez que um botão do teclado é pressionado
void keyPressed() {
//Adiciona valor a velocidade
if (key == ‘a’ || key == ‘A’) {
speedX = -1;
}
if (key == ‘s’ || key == ‘S’) {
speedY = 1;
}
if (key == ‘d’ || key == ‘D’) {
speedX = 1;
}
if (key == ‘w’ || key == ‘W’) {
speedY = -1;
}
}
//É acionado toda vez que um botão do teclado deixa de ser pressionado
void keyReleased() {
//Retorna a velocidade a zero
if (key == ‘a’ || key == ‘A’) {
speedX = 0;
if (key == ‘s’ || key == ‘S’) {

speedY = 0;
}
if (key == ‘d’ || key == ‘D’) {
speedX = 0;
}
if (key == ‘w’ || key == ‘W’) {
speedY = 0;
}
}
Essa é uma das formas de mapear o teclado para uso na programação de jo-
gos. Também é possível utilizar bibliotecas de mapeamento e o comando keyCode
ao invés de key para usar as teclas direcionais. Porém, para sua verificação, será
necessário utilizar o nome codificado dessas teclas: UP, DOWN, LEFT e RIGHT, para
as setas para cima, para baixo, para a esquerda e para a direita, respectivamente.
Máquinas de estado em jogos

Para que inimigos e obstáculos tenham comportamentos de se mover, ata-
car e fugir, é preciso programá-los, atribuindo-lhes uma inteligência artificial.
Esses comportamentos podem ser simples ou complexos, variando conforme
as suas máquinas de estado, as quais também são conhecidas como máquinas
de estado finitas.
O que é inteligência artificial

Quando um dos fantasmas do jogo Pacman está perseguindo a personagem
pelo cenário, há diversos momentos em que ele deve escolher entre caminhos
para alcançar seu objetivo de derrotar o protagonista. Para tal, ele pode sempre
seguir o caminho mais curto, optar por cercá-lo ou andar aleatoriamente pelo
mapa; todos esses comportamentos podem ser enxergados como uma Inteli-
gência Artificial (IA). Para Brackeen, Barker e Vanhelswue (2003), a inteligência
artificial é um tópico vasto com diversas aplicações; porém, quando é resumida
ao meio de desenvolvimento de jogos digitais, a IA é o comportamento atribuído
aos robôs virtuais, também conhecidos como bots.

Os bots definem a estética do jogo tanto quanto o visual do jogo. É possível pro-
gramá-los com comportamentos simples, extremamente inteligentes e até mesmo
com poderes divinos. Cabe ao programador definir o nível de inteligência de cada
um dos bots presentes em seu jogo.
Uma boa programação de inteligências artificiais ocorre quando há equilíbrio
entre as ações do jogador e o desafio apresentado pelos inimigos; por exemplo, não
é bom que um inimigo sempre saiba onde o jogador está. Além disso, ele pode ter
comportamentos para quando o jogador estiver longe, como o de rondar as proxi-
midades à procura de intrusos, como um guarda na vida real. Para tal, existem as
máquinas de estado.
As máquinas de estado são um conjunto de reações possíveis do bot para cada
situação presente no jogo, por exemplo: descansar, atacar, desviar, perseguir, fugir,
esconder-se, entre outras ações, junto às condições que estabelecem a transição
entre os comportamentos, conhecidos como estados. Elas podem ser representa-
das de forma gráfica para ilustrar os comportamentos e transições, ajudando no
planejamento e implementação do código, como no exemplo a seguir.
DIAGRAMA 1. MÁQUINA DE ESTADO DE UM FANTASMA DO JOGO PACMAN
Se o tempo do power-up acabar
Se o Pacman comer o power-up

Perseguir Fugir
Esconder-se
Se alcançar o esconderijo Se o fantasma for comido
O Diagrama 1 representa a máquina de estado de um fantasma do jogo

Pacman. Os hexágonos simbolizam os comportamentos, enquanto as flechas
simbolizam os eventos de transição de estado.
EXPLICANDO
O exemplo apresentado no Diagrama 1 é apenas uma ilustração simplificada
dos comportamentos de um inimigo fantasma presente no jogo Pacman,
pois existe uma complexidade maior envolvida na programação de cada

fantasma em cada uma das fases. Por exemplo, antes que eles comecem
a perseguir o protagonista, eles primeiramente se dirigem a quadrantes
específicos do mapa para patrulhar e, após algum tempo, determinado pela
programação, eles começam a perseguir o Pacman, sendo que cada um
dos fantasmas possui uma particularidade nessa perseguição.
O Diagrama 1 mostra que é possível transitar do estado “Perseguir” para o

estado “Fugir” em ambos os sentidos, porém, do estado “Fugir” para “Escon-
der-se”, só há um sentido disponível para a inteligência artificial seguir. Essa
particularidade pode ser bastante explorada no desenvolvimento de máquinas
de estado. Nem todo estado precisa voltar ao seu anterior, tornando os com-
portamentos dependentes de diversos fatores. As condições de transição po-
dem ser valores de variáveis, funções trigonométricas ou qualquer expressão
que possa ser verificada em uma estrutura condicional.
Máquinas de estado finito também podem aparecer divididas em grupos
de estado.
É comum, por exemplo, um inimigo ter um comportamento diferente após
ter uma certa quantidade de vida, sofrer uma transformação durante a bata-
lha, ter comportamentos diferentes enquanto batalha e quando não há inimi-
gos em vista, como no diagrama a seguir.
DIAGRAMA 2. GRUPOS DE COMPORTAMENTO PARA UMA INTELIGÊNCIA ARTIFICIAL TRANSITAR
Estados
padrão
Descansar Patrulhar Procurar
Se o jogador estiver longe Se o jogador estiver próximo
Estados de
combate
Atacar Defender Perseguir

O Diagrama 2 representa a programação de grupos de comportamento
para uma inteligência artificial transitar entre eles, ao invés de somente transi-
tar entre estados.
Criando comportamentos
Antes de criar máquinas de estado,
é necessário entender que cada esta-
do pode ser visto como uma função.
Funções podem ser criadas para que
um determinado bloco de código seja
executado repetidas vezes. Os blocos
de códigos podem ser utilizados para
criar comportamentos simples de inte-
ligência artificial que, mais tarde, serão
utilizados como estados. Utilizando a
linguagem Java e o programa Processing, uma função para que um inimigo per-
siga a posição do mouse continuamente pode ser dada de acordo com a forma
a seguir:
//Variáveis para movimentação do inimigo
float enemyX, enemyY, enemySpeedX, enemySpeedY;
void setup(){
size(640,360);
background(0);
//Determina a posição inicial do inimigo
enemyX = width / 2;
enemyY = height / 2;
}
void draw(){
background(0);
enemyBehaviour();
}
void enemyBehaviour() {
//Verifica a posição horizontal do mouse para persegui-lo

if (enemyX < mouseX - 3) {
enemySpeedX = 2;
}
else if (enemyX > mouseX + 3) {
enemySpeedX = -2;
}
else {
enemySpeedX = 0;
}
//Verifica a posição vertical do mouse para persegui-lo
if (enemyY < mouseY - 3) {
enemySpeedY = 2;
}
else if (enemyY > mouseY + 3) {
enemySpeedY = -2;
}
else {
enemySpeedY = 0;
}
//Atualiza a posição de acordo com o posicionamento em relação ao mouse
enemyX = enemyX + enemySpeedX;
enemyY = enemyY + enemySpeedY;
ellipse(enemyX, enemyY, 10,10);
}
As funções podem ser criadas nomeando-as após a utilização do comando
void, que significa que a função irá apenas executar os blocos e não terá um
retorno de valores, conforme a funcionalidade delas. Para que esse código seja
executado em outro local, como dentro da função draw, é necessário
chamar essa função por seu nome, além de abrir e fechar parênte-
ses, indicando que esse comando é de uma função. Todos
os comandos que possuem essa estrutura, tal como elip-
se, são funções já pré-estabelecidas.
Esse comportamento foi estabelecido para que o
quadrado, representando um inimigo, persiga a posição

do mouse constantemente através das posições mouseX e mouseY. A velocidade
de movimento é ajustada de acordo com o posicionamento do mouse, por exem-
plo, se o inimigo estiver à esquerda, o inimigo perde posição em X para que se
movimente em direção ao mouse.
Implementando máquinas de estado

Se um comportamento pode ser
estabelecido programando-o como
uma ação para uma inteligência artifi-
cial, então uma máquina de estados é
quando existem diversas ações progra-
madas e essas ações são acionadas por
diferentes condições. Para a criação de
um comportamento simples de inimi-
go, é possível verificar a distância entre
o inimigo e o jogador, assim o inimigo
somente o perseguirá quando uma determinada distância for estabelecida. No
Processing, a função para verificar a distância entre dois pontos é chamada dist,
que recebe como parâmetro as posições x e y, de ambos os objetos que se deseja
verificar a posição, e retorna um valor em pixels com a distância de ambos. No
código a seguir, o valor obtido pela função dist é a condição para transitar entre
os estados da inteligência artificial do inimigo; se a distância for menor do que
cem pixels, o inimigo perseguirá o jogador, caso contrário, ele ficará na posição
de descanso.
//Variáveis do posicionamento e velocidade do retângulo
float speedY, speedX, posX, posY;
//Variáveis do posicionamento e velocidade do círculo
float enemyX, enemyY, enemySpeedX, enemySpeedY;
void setup(){
size(640,360);
background(255);
enemyX = width / 2;
enemyY = height / 2;

}
void draw(){
background(255);
//Chamada de funções
enemy();
player();
}
//Funções do jogador
void player() {
posX = posX + speedX;
posY = posY + speedY;
//Cria um retângulo de pode ser controlado pelo teclado
fill(255,0,0);
rect(posX, posY, 10, 10);
}
//Programação do inimigo
void enemy() {
//Máquina de estados do inimigo
if (dist(enemyX, enemyY, posX, posY) < 100) {
enemyPursue();
}
else {
enemyRest();
}
//Atualiza a posição de acordo com o posicionamento em relação ao mouse
enemyX = enemyX + enemySpeedX;
enemyY = enemyY + enemySpeedY;
fill(0,255,0);
ellipse(enemyX, enemyY, 10,10);
}
//Comportamento de descanso do inimigo
void enemyRest() {
enemySpeedY = 0;
enemySpeedX = 0;

}
//Estado do inimigo de perseguição
void enemyPursue() {
if (enemyX < posX - 3) {
enemySpeedX = 2;
}
else if (enemyX > posX + 3) {
enemySpeedX = -2;
}
else {
enemySpeedX = 0;
}
//Verifica a posição em vertical do mouse para persegui-lo
if (enemyY < posY - 3) {
enemySpeedY = 2;
}
else if (enemyY > posY + 3) {
enemySpeedY = -2;
}
else {
enemySpeedY = 0;
}
}
void keyPressed() {
if (key == ‘a’ || key == ‘A’) {
speedX = -3;
}
if (key == ‘s’ || key == ‘S’) {
speedY = 3;
}
if (key == ‘d’ || key == ‘D’) {
speedX = 3;
}
if (key == ‘w’ || key == ‘W’) {

speedY = -3;
}
}
if (key == ‘a’ || key == ‘A’) {
speedX = 0;
}
if (key == ‘s’ || key == ‘S’) {
speedY = 0;
}
if (key == ‘d’ || key == ‘D’) {
speedX = 0;
}
if (key == ‘w’ || key == ‘W’) {
speedY = 0;
}
}
Motores de jogos
Jogos eletrônicos podem ser criados utilizando apenas linguagens de programa-
ção e ambientes de desenvolvimento integrado, importando os recursos visuais e
sonoros. Porém, para manipulá-los via código, há a necessidade de que o progra-
mador entenda como se comunicar através dos códigos com as placas de vídeo e
demais componentes do computador, além de ter que implementar as funções al-
gébricas para referenciar as leis físicas que podem ser transferidas da vida real para
o universo virtual do jogo.
Quando um jogo é criado somente mediante o código, também não é possí-
vel visualizar de forma gráfica o que ocorre nas cenas criadas. Assim, sempre que
se deseja testar e visualizar se algo implementado está funcionando de maneira
adequada, é necessário compilar todo o programa. Para facilitar o processo de
desenvolvimento de jogos, foram criados os motores de jogos, também conhe-
cidos como Game Engines ou motores gráficos. Para Sherrod (2008), os motores
de jogos possuem ferramentas convenientes para a criação de jogos.

Como utilizar motores de jogos
Os motores de jogos são progra-
mas de computador que contêm di-
versas bibliotecas e ferramentas para
agilizar a programação e o desenvol-
vimento de jogos digitais em geral.
Também é possível criar suas próprias
game engines, criando programas que
executem funções comuns na criação
de jogos.
Algumas ferramentas que um motor gráfico pode conter são:
• A renderização de gráficos bidimensionais e tridimensionais através da
comunicação com a placa de vídeo;
• Motores de física para especificação de atributos variáveis relacionados às
leis físicas transpostas para o universo digital do jogo;
• Criação de animações, efeitos visuais, partículas e texturas;
• Recursos para a criação de inteligências artificiais;
• Ferramentas para administrar pastas de arquivos;
• Criação e alteração de sons;
Quanto mais ferramentas um motor de jogos possui, mais pesado costuma
ficar o arquivo final do jogo, por causa de todas as propriedades adquiridas.
Por isso, cada empresa tende a escolher a ferramenta mais adequada para
o desenvolvimento de seus jogos, atendendo a necessidades que podem ser
desde fotorrealismo até a utilização de motores de física complexos para cal-
cular, por exemplo, as ações das leis da física sobre um carro de corrida. Em
outros casos, ainda é possível que as game engines sejam alteradas ou tenham
adições para atender a necessidades específicas, tudo isso variará de acordo
com o jogo que se deseja criar.
Principais motores de jogos

Muitas empresas se especializaram em criar apenas motores gráficos para
que empresas de desenvolvimento de jogos os utilizem. Outras são responsá-

veis por criar seus próprios motores gráficos para a criação de seus jogos e dis-
ponibilizá-los para que demais empresas também possam usufruir dele. Outras,
ainda, optam por utilizar suas próprias ferramentas de maneira exclusiva.
A seguir está uma lista com algumas das principais game engines do mercado
de desenvolvimento de jogos, especificando seu uso, ferramentas disponíveis e
alguns exemplos de jogos eletrônicos criados com elas. Algumas dessas ferra-
mentas englobam não apenas o desenvolvimento de jogos digitais, mas também
ferramentas e recursos para que outras pessoas os criem, fomentando, dessa
forma, uma comunidade de desenvolvimento entorno da ferramenta.
Unity
Originalmente conhecido como Unity3D, é um motor gráfico criado pela em-
presa Unity Tecnologies, pensado primariamente para a criação de jogos 3D, po-
rém, com o passar dos anos, adquiriu suporte para a criação de jogos 2D.
As três linguagens que o programa utilizou ao longo de sua existência foram
C#, UnityScript, baseada em JavaScript, e BOO, encerrando o suporte para as
linguagens BOO e UnityScript, preservando apenas a linguagem C#. A programa-
ção é realizada em um ambiente de desenvolvimento integrado e executada no
Unity. Por padrão a Unity utiliza o MonoDevelop, mas ele pode ser substituído
por outros programas. Também é possível programar utilizando linguagens de
bloco, ferramentas que são adquiridas pela loja da empresa, a Asset Store.
Esse programa possui ferramentas para importação de sprites, modelos tri-
dimensionais, especificação de compressão de texturas, criação de relevos tridi-
mensionais, utilização de tilemaps para a criação de mapas bidimensionais, além
de ferramentas extras que podem ser adquiridas na Asset Store, como citado
anteriormente.
Um dos grandes diferenciais do Unity é a grande variedade e facilidade para
exportar o jogo para diversas plataformas, dentre elas dispositivos móveis, web,
consoles e computadores, somente alterando as configurações do programa.
Possui, ainda, uma versão gratuita para desenvolvedores.
Alguns famosos jogos criados utilizando esse motor gráfico são
Hollow Knight, Pokémon GO e Cuphead.
Unreal
Criada pela empresa Epic Games, a Unreal foi criada para
jogos de tiro em primeira pessoa. Apesar disso, esse motor é

amplamente usado para o desenvolvimento de diversos tipos de jogos, priori-
zando a qualidade visual de seus produtos.
Essa game engine foi desenvolvida utilizando a linguagem C++, porém tam-
bém é possível programar nela utilizando uma linguagem visual chamada Blue-
print, implementada a partir da Unreal Engine 4.
Para auxiliar no desenvolvimento de jogos digitais, o programa possui biblio-
tecas de renderização gráfica, detecção de colisão, ferramentas para criação de
inteligência artificial e bibliotecas para criação de redes. Assim como a Unity, a
Unreal possui sua própria loja de recursos.
A Unreal incialmente podia ser somente adquirida através de uma versão
paga. Porém, a partir de 2014 a empresa Epic começou a disponibilizar o softwa-
re para estudantes e profissionais da área através de parcerias, até mais tarde
lançar uma versão gratuita de seu motor gráfico.
Alguns jogos que foram feitos a partir desse motor gráfico são Borderlands, a
série Gears of war e Life is strange.
CONTEXTUALIZANDO
Para manter a qualidade gráfica e de gameplay, alguns dos mais famosos
jogos da história tiveram que utilizar seus próprios motores de jogos.
Segundo Sherrod (2008), o jogo Quake da empresa ID Software, contava
com seu próprio motor gráfico, o Quake Engine, que começou primeira-
mente como apenas um framework de desenvolvimento de jogos de tiro
em primeira pessoa para computadores e, mais tarde, foi ampliado para
um programa de desenvolvimento. Também assim ocorreu com o motor
gráfico Unreal Engine.
Construct
Desenvolvido pela empresa Scirra, é um programa de desenvolvimento de
jogos focado em jogos 2D, baseado na tecnologia HTML5. A versão Construct 3
pode ser usada diretamente de um navegador web.
Diferentemente do Unity e da Unreal, esse motor de jogos não possui uma
linguagem textual para programação, ao invés disso ele conta com uma lingua-
gem visual composta de eventos e um sistema de lógica baseado em compor-
tamentos. Ele possui uma versão gratuita com limite de eventos programáveis.
Para agilizar o processo de desenvolvimento, o programa conta com um
editor de imagens, sendo possível criar ou editar sprites e animações inter-

namente no software, também efeitos visuais, além de um sistema de clicar e
arrastar para adicionar objetos à cena.
O motor também conta com uma grande variedade de plataformas para as
quais os jogos criados podem ser exportados, dentre elas computadores, web,
mobile e consoles.
GameMaker Studio
Projetado pela empresa Yo Yo Ga-
mes, o GameMaker é um motor de
jogos com linguagem de programa-
ção própria, a Game Maker Language,
também conhecida como GML.
Diferente dos demais softwares
apresentados, o GameMaker não pos-
sui uma versão gratuita e o seu custo
varia de acordo com a versão para ex-
portação do jogo escolhida, variando
entre computadores e consoles.
O motor tem algumas ferramentas para facilitar a importação de sprites e
imagens bidimensionais, sendo bastante usado para a criação de jogos 2D. Ele
também conta com ferramentas para criação interna de sprites, sons e scripts.
Alguns jogos famosos que utilizarão Game Maker Studio na sua criação são
Undertale, Hyper light drifter e The swords of ditto.
CryEngine
O CryEngine é o motor gráfico desenvolvido pela empresa alemã CryTek.
Sua primeira implementação visava testar o potencial das placas gráficas da
empresa Nvidia, preservando sua capacidade gráfica como sua qualidade
principal.
Os jogos criados por esse motor sempre foram destaque em relação aos
gráficos voltados para o realismo, principalmente em relação à projeção de luz
e sombras.
Esse motor gráfico foi licenciado para diversas empresas, dentre elas a Ubi-
soft que, junto ao software, adquiriu os direitos sobre a franquia Far cry. Por
ser um software de código aberto, pode ser modificado e baixado por qualquer
pessoa. Ele suporta as linguagens de programação C++ e Lua.

A CryTek também disponibiliza em seu site uma loja com recursos gráficos e
outros assets para auxiliar no desenvolvimento de jogo.
Exemplos de jogos criados utilizando esse motor gráfico são Prey e as séries
Far Cry e Crysis.
CURIOSIDADE
O que diferencia as game engines, além das ferramentas disponíveis para
o desenvolvimento, é a parcela de lucros com a qual a empresa do softwa-
re fica por contrato ao vender um jogo ou o limite que se pode lucrar com
o jogo. Por exemplo, a empresa Unity não cobra porcentagem dos lucros
em nenhuma de suas versões de software, porém, limita o ganho a cem
mil dólares por ano em sua versão gratuita, caso ultrapasse, por contrato
é necessário comprar uma licença paga, enquanto a empresa Unreal
cobra cinco por cento da porcentagem de ganhos do jogo criado.
Além dos motores gráficos que integram diversas partes do desenvolvi-

mento, há ainda motores de jogos focados em implementações específicas,
como é o caso do Havok Physics, um motor de jogos usado exclusivamente
para interações físicas entre os objetos do jogo. Esse tipo de software pode ser
usado em conjunto com outros motores gráficos para melhorar o desempenho
de um jogo eletrônico em uma característica específica.

Sintetizando
Nesta unidade apresentamos a história dos controladores de videogames e
como eles podem ser utilizados para promover interação entre homem e má-
quina. Além disso, foi introduzido o conceito de criação de inteligência artificial
através da criação de máquinas de estado finitos para disponibilizar às máqui-
nas criadas uma variedade de comportamentos.
A inteligência artificial, junto aos dispositivos de entrada, promove a chama-
da interação homem-máquina. É por meio de equipamentos, como o teclado e
o mouse, que o homem consegue fazer com que as máquinas entendam os co-
mandos que ele deseja executar. Porém, mediante os comportamentos progra-
mados, as máquinas podem responder às ações executadas pelo ser humano
de modo a criar uma estrutura de comunicação sobre a qual deixa de ser um
simples receptor para desempenhar o papel de comunicador.
Ao final, alguns dos principais motores gráficos utilizados no desenvolvi-
mento de jogos foram apresentados, apontando suas usabilidades e como a
sua utilização facilita o processo de criação de jogos eletrônicos.

BRACKEEN, D.; BARKER, B.; VANHELSWUE, L. Developing games in Java. [S.l.]:
New Riders Games, 2003.
ECK, D. J. Introduction to programming using Java. Disponível em: <http://
math.hws.edu/eck/cs124/downloads/javanotes6-linked.pdf>. Acesso em: 21
ago. 2019.
KENT, S. L. The ultimate history of video games. Nova York: Three Rivers
Press, 2011.
OVERMARS, M. A brief history of computer games. 30 jan. 2012. Disponível
em: <https://www.stichtingspel.org/sites/default/files/history_of_games.pdf>.
Acesso em: 21 ago. 2019.
SHERROD, A. Game graphics programming. Burlington: Course Technology,
2008.
TAYLOR, L. N. Video games: perspective, point-of-view, and immersion. Dis-
sertação de mestrado, Universidade da Flórida, 2002. Disponível em: <ht-
tps://www.researchgate.net/profile/Laurie_Taylor2/publication/35486642_Vi-
deo_games_electronic_resource_perspective_point-of-view_and_immersion/
links/551e9f450cf2a2d9e13c6f53/Video-games-electronic-resource-perspecti-
ve-point-of-view-and-immersion.pdf>. Acesso em: 21 ago. 2019.

UNIDADE
4 IMPLEMENTANDO
COLISÕES, MÚSICAS
E SONS

Capacitar o aluno a utilizar APIs que dão suporte à criação de jogos;
Capacitar o aluno a utilizar mecanismos de tratamento de colisão em jogos.
VIDEOAULA
Clique aqui
Tópicos de estudo
Tratamento de colisões
Colisões em jogos como Pong
Colisões em jogos de plataforma
Músicas e efeitos sonoros em jogos

A função do áudio nos jogos
Implementando trilhas sonoras
Implementando efeitos sonoros

Tratamento de colisões
Seja quando um personagem anda sobre uma plataforma, uma bola é rebati-
da por uma raquete, o herói recupera vida ao passar sobre um item em formato
de coração, um inimigo é pisoteado ou um personagem morre ao cair de um
precipício, cada um desses eventos tem algo em comum em relação às regras do
jogo: todos eles são momentos de colisão e precisam ser programados.
Brackeen, Barker e Vanhelswue (2003) dividem o tratamento de colisões em
três áreas de interesse:
• Decidindo quando testar a colisão: em um jogo, é possível que existam
mais de mil objetos que precisam verificar se estão colidindo com o jogador ou
com outras personagens. Se cada uma dessas colisões estiver sendo verificada
ao mesmo tempo, o computador terá de alocar um processamento enorme
apenas para uma função. Para evitar isso, é possível criar uma verificação no
código para limitar uma distância mínima de detecção de colisão com algum
objeto, para assim só serem verificados os objetos próximos e que tenham a
possibilidade de colidir naquele momento com a personagem.
• Detectando a colisão: a detecção de colisão pode ser feita por área de
colisão ou por cada pixel de um sprite. A forma como será executada varia de
VIDEOAULA
Clique aqui
acordo com a necessidade do jogo. Existem algumas técnicas comuns para a
detecção de colisão que minimizam o uso do processador, como o uso de cai-
xas de colisão.
• Lidando com a colisão: cada evento de colisão exige, além da verificação,
uma reação equivalente, variando para cada caso. Por exemplo, ao encostar
em uma parede, uma personagem pode escorregar por ela, ficar presa ou ape-
nas ser impedido de prosseguir.
DICA
As colisões podem se resumir a atualizar as posições dos objetos e per-
sonagens, checar se esses elementos estão em posições próximas ou so-
brepondo-se uns aos outros e se uma colisão estiver ocorrendo, reverter a
posição de quem estiver se movendo a uma posição na qual a sobreposi-
ção deles não esteja ocorrendo, sendo que pela velocidade que o código
é executado, se a velocidade do objeto não for muito alta, será imperceptí-
vel para o jogador. Pense nisso como um algoritmo de três etapas.

A técnica de caixa de colisão é amplamente utilizada em jogos bidimensio-
nais e tridimensionais; ela serve para que seja possível verificar a colisão entre
objetos como formas geométricas básicas, como círculos e retângulos, possibi-
litando a utilização de cálculos simples para detectar e tratar as colisões. Qual-
quer objeto ou personagem pode possuir uma caixa de colisão; elas ajudam
a estabelecer uma área de colisão, sendo possível utilizar a largura e altura
dos retângulos e o raio ou diâmetro das circunferências para a realização dos
cálculos.
Figura 1. Exemplo de caixas de colisão.
As colisões também podem ser divididas em dois grupos: colisões entre

objetos e colisões de objetos com o cenário. As colisões entre objetos são feitas
como descrito anteriormente, com caixas de colisão envolvendo os objetos e
personagens; no caso de cenários, porém, pode funcionar um pouco diferente,
pois é preciso atribuir várias caixas de colisão ou estabelecer limites na tela
através das posições horizontais e verticais.
Personagens e objetos podem possuir mais de uma área de colisão, sendo
possível atribuir diferentes respostas na programação para cada um dos luga-
res nos quais houver colisão.
Seguindo as regras de colisão com cenário, a verificação de colisão também
pode ser usada para conter um objeto dentro de um determinado perímetro,
como, por exemplo, dentro da parte visível da tela, impossibilitando que ele
escape pelas partes laterais. Esse exemplo será mais bem explorado na criação
de um jogo no estilo de Pong. Para aplicar o conceito de forma prática, será uti-
lizado o programa Processing e a linguagem de programação Java.

Colisões em jogos como Pong
O jogo Pong é um bom exemplo para observar como colisões funcionam
de forma simples. Primeiramente, é necessário elencar todos os elementos
e regras básicas do jogo. Em relação aos elementos, o jogo conta com dois
retângulos posicionados um à direita e outro à esquerda da tela, um círculo
ao meio que servirá como bola e dois marcadores de pontuação, iniciados
com o número zero, como na Figura 2.
Figura 2. Reprodução da tela do Pong.
CURIOSIDADE
Na versão original de Pong, a bola era, na verdade, um pequeno quadra-
do, pois os computadores da época não possuíam uma resolução boa o
suficiente para desenhar círculos.
No caso do Pong, as principais interações se concentram em torno da bola e
das palhetas. As regras básicas do jogo estabelecem que:
• A bola não pode sair dos limites da tela;
• Ao colidir com a parte superior ou inferior da tela, a bola é refletida, isto é,
vai em direção vertical oposta;
• Ao colidir com as palhetas, a bola vai na direção horizontal oposta;
• Ao colidir com as laterais, é atribuído um ponto para o jogador do lado oposto,
isto é, se a bola encostar do lado direito da tela, o jogador do lado esquerdo rece-
berá um ponto e se a bola encostar do lado esquerdo, o jogador da direita rece-
berá um ponto. Em qualquer uma das situações, a bola volta para o meio da tela.

Além dessas regras, também fica definido que a bola se movimenta hori-
zontalmente e verticalmente com velocidade constante, permitindo diagonais,
e sua posição inicial é no centro da tela. Essa atribuição é determinada pelos
valores do tamanho da tela e do tamanho da bola, como no exemplo das linhas
de código a seguir, sendo ballX a posição inicial horizontal e ballY a posição
inicial vertical:
ballX = width / 2;
ballY = height / 2;
Isto ocorre devido à particularidade do Processing, de que o ponto inicial
horizontal e vertical das circunferências ficam no centro da imagem, indiferen-
te do tamanho do diâmetro da circunferência.
Quando uma elipse é desenhada, ela recebe quatro parâmetros na função
ellipse: a posição vertical e horizontal na qual ela será desenhada, o tamanho
do diâmetro na vertical e na horizontal. O diâmetro precisará ser usado para
calcular o raio da circunferência e verificar se a bola está ou não colidindo com
os limites do cenário e com as palhetas representadas pelos retângulos.
(0, -Raio)
X (0,0)
(-Raio, 0) (+Raio, 0)
(0, +Raio)
Figura 3. Exemplo de circunferência e seus tamanhos.
Uma das formas de verificar se a elipse está ultrapassando os limites da tela

é somar ou decrescer o valor do raio dela e verificar a posição equivalente no
plano cartesiano, por exemplo: para verificar se a bola ultrapassou os limites
da parte superior, é necessário decrescer o valor do raio da elipse para obter
o valor do ponto de contato superior e verificar se esse ponto é menor do que
zero. A estrutura condicional ficaria da seguinte forma, sendo ballY a posição

vertical da bola, ballSize o tamanho do diâmetro da bola e ballSpeedY a veloci-
dade de movimento vertical dela:
If (ballY – ballSize / 2 < 0)
{
ballY = ballSize / 2;
ballSpeedY = ballSpeedY * -1;
}
Ao detectar a colisão utilizando a estrutura condicional, a posição da bola
é ajustada para uma posição dentro do limite da tela, a qual leva em conta o
tamanho do raio. Além disso, a velocidade é revertida, para que a bola continue
se movendo no sentido oposto.
Essa mesma lógica é utilizada para que as palhetas não saiam da tela ao
se moverem, exceto a necessidade de reverter a sua velocidade. A diferença
entre a bola e a palheta acontece na relação de seus pontos iniciais – enquanto
o ponto inicial da bola fica no centro, o ponto inicial do retângulo, tanto vertical
quanto horizontal, fica no canto superior esquerdo.
Figura 4. Pontos de colisão dos retângulos.
As palhetas também possuem regras; uma das já citadas é que ela também
não pode sair pelas partes superior e inferior da tela. Para isso, basta limitar
que a sua posição em x não seja menor do que zero e que sua posição máxima
inferior não seja maior do que sua posição x mais a sua altura.
Em relação à colisão entre a bola e as palhetas, é necessário verificar cada
um desses pontos para estabelecer se ela está ocorrendo, isto é, se algum dos

pontos de colisão da bola se encontra dentro de uma das palhetas. Cada uma
dessas verificações precisa ser feita para estabelecer o perímetro de colisão
das palhetas. Isso pode ser feito da seguinte forma, sendo ballX a posição x da
bola, ballY a posição y da bola, ballSize o tamanho do diâmetro da bola, pla-
yerPaddleX a posição em x da palheta, playerPaddleY a posição Y da palheta,
playerHeight a altura da palheta e playerWidth a largura da palheta:
if ((ballY + ballSize / 2 >= playerPaddleY && ballY - ballSize / 2 <= playerPaddleY
+ playerHeight) &&
(ballX + ballSize / 2 >= playerPaddleX && ballX - ballSize / 2 <= playerPaddleX +
playerWidth)) {
ballSpeedX = ballSpeedX * -1;
ballX = ballSize / 2 + playerPaddleX + playerWidth;
}
Assim como no caso da colisão com os limites da tela, a posição da bola ao
entrar em contato com a palheta é ajustada para uma posição fora da caixa de
colisão da palheta. Considerando que a palheta está no canto esquerdo da tela,
a bola precisa ser modificada para a frente da palheta, isto é, é necessário so-
mar o raio da bola com a posição x e a largura da palheta. Além disto, é preciso
inverter a velocidade de movimento da bola, multiplicando-a por um negativo.
As demais colisões do jogo seguem essas mesmas estruturas, pois a verifi-
cação dos cantos direito e esquerdo necessitam da soma e subtração do valor
do raio da bola para calcular a colisão, e a palheta do adversário tem a mesma
estrutura condicional da do jogador, com a alteração da posição que a bola é
ajustada, a qual é igual a subtração do raio da bola para a posição x da palheta
posicionada à direita da tela.
A seguir, se encontra o código do jogo com as colisões implementadas, uma
inteligência artificial simples para o adversário e a palheta do jogador podendo
ser controlada pelos botões W, para movimentar para cima, e S, para movimen-
tar para baixo:
//Variáveis para o posicionamento da bola
int ballX, ballY;
int ballSize = 10;
int ballSpeedX = 3;
int ballSpeedY = 3;

//Variáveis para o posicionamento das palhetas do jogador
int playerPaddleX, playerPaddleY;
int playerWidth = 10;
int playerHeight = 100;
int playerSpeedY = 0;
//Variáveis para o posicionamento das palhetas do adversário
int cpuPaddleX, cpuPaddleY;
int cpuWidth = 10;
int cpuHeight = 100;
int cpuSpeedY = 0;
//Variáveis para marcar a pontuação
int scorePlayer;
int scoreCPU;
//Função de inicialização
void setup()
{
//Determinar o tamanho e a cor de fundo da tela
size(640,360);
background(0);
//Atribui posição inicial da bola
ballX = width / 2;
ballY = height / 2;
//Atribui posição inicial da palheta do jogador
playerPaddleX = 10;
playerPaddleY = height / 2 - 50;
//Atribuir posição inicial da palheta do adversário
cpuPaddleX = width - 20;
cpuPaddleY = height/2 - 50;
//Determina o tamanho da fonte do texto
textSize(32);
}
//Função de repetição
void draw()
{

//Atualiza a cor de fundo toda vez que a tela for desenhada
background(0);
//Chamadas de função para execução do jogo
score();
ballMovement();
cpuPaddle();
playerPaddle();
}
//Função da movimentação da bola
void ballMovement() {
//Atualização da posição da bola
ballX = ballX + ballSpeedX;
ballY = ballY + ballSpeedY;
//Verificação da colisão da bola com as extremidades laterais
if (ballX > width) {
ballX = width / 2;
ballY = height / 2;
scorePlayer += 1;
}
if (ballX < 0) {
ballX = width / 2;
ballY = height / 2;
scoreCPU += 1;
}
//Verificação da colisão da bola com as extremidades superior e inferior da tela
if (ballY > height) {
ballY = height - ballSize / 2;
}
if (ballY < 0) {
ballY = ballSize / 2;

}
//Verificação da colisão da bola com a palheta do jogador
if ((ballY + ballSize / 2 >= playerPaddleY && ballY - ballSize / 2 <= playerPaddleY
+ playerHeight) &&
(ballX + ballSize / 2 >= playerPaddleX && ballX - ballSize / 2 <= playerPaddleX +
playerWidth)){
ballX = ballSize / 2 + playerPaddleX + playerWidth;
}
//Verificação da colisão da bola com a palheta do adversário
if ((ballY + ballSize / 2 >= cpuPaddleY && ballY - ballSize / 2 <= cpuPaddleY +
cpuHeight) &&
(ballX + ballSize / 2 >= cpuPaddleX && ballX - ballSize / 2 <= cpuPaddleX + cpu-
Width)){
ballX = cpuPaddleX - ballSize / 2;
}
noStroke();
ellipse(ballX, ballY, ballSize, ballSize);
}
//Função da palheta do adversário
void cpuPaddle() {
//Atualizando a posição da palheta do adversário
cpuPaddleY = cpuPaddleY + cpuSpeedY;
//Criação do comportamento da palheta inimiga
if (ballX > width / 2) {
if (ballY - ballSize > cpuPaddleY + cpuHeight / 2) {
cpuSpeedY = 2;
}
else if (ballY + ballSize < cpuPaddleY + cpuHeight / 2) {
cpuSpeedY = -2;
}
else {
cpuSpeedY = 0;

}
}
else {
cpuSpeedY = 0;
}
//Limitação dos movimentos da palheta dentro do espaço da tela
if (cpuPaddleY + cpuHeight > height) {
cpuPaddleY = height - cpuHeight;
}
if (cpuPaddleY < 0) {
cpuPaddleY = 0;
}
rect(cpuPaddleX,cpuPaddleY,cpuWidth,cpuHeight);
}
//Função da palheta do jogador
void playerPaddle() {
//Atualizando a posição da palheta do jogador
playerPaddleY = playerPaddleY + playerSpeedY;
//Limitação dos movimentos da palheta dentro do espaço da tela
if (playerPaddleY + playerHeight > height) {
playerPaddleY = height - playerHeight;
}
if (playerPaddleY < 0) {
playerPaddleY = 0;
}
rect(playerPaddleX, playerPaddleY, playerWidth, playerHeight);
}
void score() {
text(scorePlayer, 160, 50);
text(scoreCPU, 480, 50);
}
//Verificação do pressionamento dos botões para movimentação da palheta do
jogador
void keyPressed() {

if (key == 's' || key == 'S') {
playerSpeedY = 5;
}
if (key == 'w' || key == 'W') {
playerSpeedY = -5;
}
}
//Verificação do soltar dos botões para movimentação da palheta do jogador
if (key == 's' || key == 'S' || key == 'w' || key == 'W') {
playerSpeedY = 0;
}
}
Colisões em jogos de plataforma

Em jogos de plataforma, comumente, existe a presença de forças físi-
cas aplicadas a corpos, sendo a principal delas a força gravitacional. Isto
gera no código a necessidade de verificação constante e de desabilitar a
aplicação dessa força quando ocorrer uma colisão.
As plataformas são compostas de caixas de colisão distintas, que po-
dem aplicar diferentes resultados ao pisar nelas. Por exemplo, em jogos
como os da série Mario, as plataformas normais servem apenas para im-
pedir que o jogador prossiga de forma linear, precisando pular nelas para
evitar obstáculos e alcançar locais mais altos; isto se torna
uma espécie de mecânica para esse estilo específico de
jogo eletrônico. Segundo o game designer Scott Rogers
(2013), é preciso lembrar que simples-
mente andar não é uma mecânica; o
uso de plataformas gera desafios
e entretém o jogador. Além das
plataformas normais, há algumas
que, quando o personagem pisa ne-
las, perde uma vida ou saúde.

Em relação à colisão com os limites do cenário, também é possível utili-
zar de caixas de colisão nas extremidades da tela para impedir que o perso-
nagem saia dela.
Tendo em mente essas regras, é possível criar as estruturas condicionais
necessárias para verificação de colisão entre personagens e plataformas.
Para a criação de um jogo de plataforma, será necessário o uso de uma
matriz para armazenar as informações de cada uma das plataformas. Uma
matriz é uma coleção de variáveis com o mesmo tipo, as quais podem ser
armazenadas com apenas um nome. Seus valores podem ser acessados
através de um índice. Elas podem ser vistas como vetores com mais de uma
dimensão ou como uma junção de vetores. Uma matriz de dimensão dois
por três pode ser criada em Java utilizando a seguinte composição:
String [][] names = { {“João”, “Mario”, “Felipe”}, {“Maria”, “Ana”, “Rosa”} };
Para acessar o nome “Mario” dessa matriz, seria necessário informar o
índice com a sua localização, lembrando que uma matriz, assim como um
vetor, começa com o valor da primeira posição sendo zero:
print( names[0][1] );
O primeiro índice é usado para informar qual o agrupamento de variá-
veis que será acessado, enquanto o segundo índice informa o elemento des-
se agrupamento. Semelhante a um edifício, no qual há vários apartamentos,
é preciso indicar o andar e o número do apartamento para saber qual casa
será visitada.
As matrizes também são muito úteis para facilitar a verificação de muitas
coordenadas para colisão – ao combiná-las com a estrutura de repetição
FOR, é possível utilizar a variável da estrutura como índice e verificar todos
os itens até o limite de tamanho da matriz, assim como no caso dos vetores.
Para armazenar as informações das plataformas, a matriz de caixas de
colisão receberá cinco variáveis, sendo cada agrupamento equivalente a
uma plataforma e cada variável sendo, respectivamente, a posição x, a posi-
ção y, a largura da plataforma, a altura da plataforma e o tipo da plataforma,
todos esses valores do tipo inteiro. A variável do tipo da plataforma ajudará
a estabelecer se uma plataforma pode ou não ser um local seguro para se
pisar; assim, o valor zero indicará que é um local seguro, enquanto o valor
um indicará ser um local nocivo.

Para as plataformas que servirão como limite na tela, será necessário
obter o valor das variáveis com o tamanho da tela, então logo no início do
código serão criadas duas variáveis nomeadas como w e h, as quais armaze-
narão, respectivamente, a largura e altura da tela. Elas podem ser utilizadas
tanto para definir o tamanho das plataformas, como para indicar a posição
x e y das plataformas.
Uma definição que foi tomada para auxiliar na montagem das platafor-
mas e da personagem é que todas as unidades de posição e tamanho são
múltiplas de vinte, isto é, o personagem possui vinte pixels de altura e vinte
pixels de largura e as plataformas seguem essa mesma regra. Além de fa-
cilitar os cálculos para inserir plataformas em limites de tela que têm essa
mesma base, determinar um tamanho fixo para objetos, tiles e personagens
facilita a determinação da interação entre eles, por exemplo, estabelecer
qual será o tamanho do pulo.
Figura 5. Tiles em forma de molde.
EXPLICANDO
Apesar de não ser obrigatório adotar a mesma proporção de tamanho
para plataformas, personagens e objetos, tanto para sprites quanto para
suas caixas de colisão, isto é uma prática comum no desenvolvimento de
jogos eletrônicos bidimensionais. É comum que os personagens e suas
caixas também sejam de tamanho com base dois, isto é, números que são
resultados da elevação do número dois, por causa da estrutura de bits do
computador; softwares de desenho e desenvolvimento de jogos tendem a
trabalhar melhor com esta escala numérica.

O jogador também precisará de variáveis para suas coordenadas x e y, usa-
das tanto na verificação de colisão quanto na criação das funções de movimen-
tação, variáveis com sua posição inicial para reiniciar o jogo quando a perso-
nagem pisar em um local nocivo, e duas variáveis para atribuir velocidade à
personagem quando as teclas direcionais forem pressionadas, essas últimas
nomeadas como playerXV e playerYV. Elas também servem para verificar se
ocorrerá uma colisão entre o personagem e a plataforma.
A verificação de colisão pode ser feita até mesmo antes que a colisão ocor-
ra – utilizando a variável responsável por atribuir movimento à personagem, é
possível calcular se o próximo movimento do jogador resultará na caixa de co-
lisão da personagem colidindo com a de uma das plataformas. Isso é possível
através do seguinte cálculo com a parte superior de uma plataforma, adotando
playerX como a posição horizontal da caixa de colisão da personagem, playerY,
a posição vertical, playerSize, a largura e altura da caixa de colisão da persona-
gem, playerYV, a força de movimento vertical da personagem, colliders, a matriz
contendo as informações sobre cada plataforma, sendo o índice “i” usado para
visitar cada um dos elementos da matriz, gravity, a força atribuída à gravidade, e
isFalling, a variável de verificação para observar se a caixa de colisão está no ar:
if (playerX + playerSize > colliders[i][0] && playerX < colliders[i][0] + colliders[i]
[2] && playerY + playerYV + playerSize > colliders[i][1] && playerY < colliders[i][1] +
colliders[i][3]) {
playerYV = 0;
gravity = 0;
isFalling = false;
}
Ao detectar a iminente colisão, a estrutura condicional executa o bloco de
código dentro dela, que anula a força de movimento vertical, desabilita a for-
ça da gravidade e informa que a caixa de colisão se encontra colidindo com o
chão. Caso ainda existam alguns pixels entre a caixa de colisão da personagem
e a da plataforma, a força gravitacional voltará a funcionar e ajustará a posição
da caixa até que não existam pixels entre ambas.
A força gravitacional age sobre a caixa de colisão a partir do momento que
não existe colisão com a parte inferior da caixa, isto é, quando a variável isFal-
ling for verdadeira. Essa variável recebe o valor verdadeiro quando o botão di-

recional para cima é pressionado, acionando o pulo, ou quando o código deixa
de detectar colisão entre a caixa da personagem e a plataforma.
Dentro das verificações de colisão, também existe a seguinte estrutura con-
dicional para verificar se a plataforma com a qual a personagem está colidindo
é uma caixa de colisão nociva:
if (colliders[i][4] == 0) {
isDead = true;
}
A quinta variável de cada elemento da matriz armazena um valor indicativo
para o tipo de plataforma, que também poderia ser utilizado para criar outros
tipos de plataforma, como trampolins, por exemplo. Neste caso, se o valor da
variável na quinta posição for igual a zero, a variável que indica a morte da perso-
nagem do jogador receberá o valor verdadeiro, mudando a cor da caixa e impos-
sibilitando no código que as funções de movimento do jogador sejam acessadas.
Por fim, o código com um exemplo de colisões e controle de personagem
em um jogo de plataforma pode ser obtido a seguir, e testado utilizando o Pro-
cessing. A personagem, simbolizada pela caixa de colisão vermelha, pode ser
controlada utilizando as teclas direcionais do teclado e pular apertando a tecla
para cima, caso a caixa de colisão da personagem entre em contato com uma
caixa de colisão verde, a qual indica um local nocivo, a variável do estado de
morte será acionada e todas as funções de movimentação serão interrompi-
das, o jogo pode ser reiniciado utilizando o botão “R” do teclado:
//Tamanho da tela para definir caixas de colisão nos limites da tela
int w = 800;
int h = 600;
//Matriz com as informações das caixas de colisão
int[][] colliders = {
//A estrutura de cada elemento da matriz é a seguinte:
// {Posição X, Posição Y, Largura, Altura, Tipo de Plataforma}
//Sendo o tipo de Plataforma 0 para os locais nocivos
//E o tipo de Plataforma 1 para as plataformas normais
{ 0, -20, w, 20, 1 },
{ 0, h, w, 20, 1 },
{ -20, 0, 20, h, 1 },

{ w, 0, 20, h, 1 },
//Caixas de colisão das plataformas
{ 0, 580, 200, 20, 1 },
{ 200, 580, 40, 20, 0 },
{ 240, 540, 160, 60, 1 },
{ 400, 560, 240, 40, 0 },
{ 500, 540, 40, 20, 1 },
{ 640, 540, 160, 60, 1 },
};
void setup() {
size(800, 600);
noStroke();
noSmooth();
frameRate(30);
}
//Tamanho da caixa de colisão do personagem
float playerSize = 20;
float playerX = 0;
float playerY = h / 2;
//Variáveis para posição inicial do jogador
float startX = playerX;
float startY = playerY;
//Variáveis para movimentação do jogador
float playerXV = 0;
float playerYV = 0;
//Variável com a velocidade de movimentação do jogador
float playerSpeed = 5;
//Variável para simular a gravidade
float gravity = 0;
//Variável para verificar se o personagem pisou em uma caixa de colisão nociva
boolean isDead = false;
//Variável para verificar se o personagem está no ar
boolean isFalling = true;
void collidersVerification() {

for (int i = 0; i<colliders.length; i++) {
fill(0);
//Se o valor da quinta posição for igual a zero, muda a cor da caixa de colisão
if (colliders[i][4]==0) {
fill(0, 250, 0);
}
//Verificação de colisão com as partes laterais das plataformas
if (playerX + playerXV + playerSize > colliders[i][0] && playerX + playerXV < colli-
ders[i][0] + colliders[i][2] && playerY + playerSize > colliders[i][1] && playerY < colli-
ders[i][1] + colliders[i][3]) {
isDead = true;
}
playerXV = 0;
}
//Verificação de colisão com a parte superior das plataformas
[2] && playerY + playerYV + playerSize > colliders[i][1] && playerY < colliders[i][1] +
colliders[i][3]) {
isDead = true;
}
playerYV = 0;
gravity = 0;
isFalling = false;
}
//Verificação de colisão com a parte inferior das plataformas
[2] && playerY + playerSize>colliders[i][1] && playerY + playerYV < colliders[i][1] +
colliders[i][3]) {
isDead = true;
}
playerYV = 0;

gravity = 0;
}
//Desenha na tela os colisores das plataformas
rect(colliders[i][0], colliders[i][1], colliders[i][2], colliders[i][3]);
}
}
//Criação de um Vetor para todos os valores possíveis no teclado
boolean[] keys = new boolean[256];
//Verifica se uma tecla está sendo pressionada e guarda o valor equivalente a
tecla no vetor keys
void keyPressed() {
keys[keyCode] = true;
}
//Verifica se a tecla deixou de ser pressionada
keys[keyCode] = false;
}
//Mapeamento das teclas do jogador
void playerInput() {
playerXV = 0;
playerYV = 0;
//Os botões não funcionam se o personagem estiver morto
if (!isDead) {
if (keys[UP] && !isFalling) {
gravity -= 7;
}
if (keys[LEFT]) {
playerXV = -playerSpeed;
}
if (keys[RIGHT]) {
playerXV = playerSpeed;
}
}
//Reinicia para posição inicial ao clicar o botão R

if(keys[82]){
isDead = false;
playerX = startX;
playerY = startY;
}
playerYV += gravity;
gravity += 0.5;
isFalling = true;
}
void playerUpdate() {
//Atualiza a posição do jogador
playerX += playerXV;
playerY += playerYV;
fill(255, 0, 0);
//Modifica a cor da caixa de colisão do jogador se ele estiver morto
if (isDead){
fill(255,150,150);
}
//Desenha na tela a caixa de colisão da personagem
rect(playerX, playerY, playerSize, playerSize);
}
void draw() {
background(250);
//Chamadas de função para funcionamento do jogo
playerInput();
collidersVerification();
playerUpdate();
}
Músicas e efeitos sonoros em jogos

Não só de códigos, imagens e mecânicas vive um jogo. Imagine, por exemplo,
o que seria de Sonic the Hedgehog sem sua trilha sonora extremamente icônica, ou
o que teria sido do mundo dos videogames sem as poucas músicas de Super Mario

Bros. Dentre muitas outras, as músicas de jogos são um elemento essencial da ex-
periência, utilizadas para gerar, no jogador, uma emoção ou sentimento único.
Não menos importantes são os outros elementos sonoros contidos neles, que
auxiliam na imersão do jogador dentro de um mundo virtual, seja reforçando a res-
posta a um movimento ou auxiliando no indicativo de uma ação.
A seguir, detalharemos um pouco mais a importância desses elementos nos vi-
deogames, bem como a forma de implementá-los no seu próprio jogo.
ASSISTA
Assista ao vídeo 8 trilhas sonoras inesquecíveis dos jogos
para conhecer ou relembrar algumas das trilhas mais
marcantes da história dos games.
A função do áudio nos jogos

É difícil imaginar como seriam os jogos sem o recurso de som. Apesar de ser pos-
sível jogá-los, muito da experiência do jogo está contida nos recursos sonoros, e as-
sim como as mecânicas, precisam ser pensados desde o início do desenvolvimento.
Scott Rogers (2013) conta que a música e o som nos jogos percorreram um longo
caminho em poucos anos. Até o começo da década de 1980, os desenvolvedores
tinham à disposição apenas alguns sons eletrônicos para compor as trilhas e sons de
seus jogos. Apesar disto, trilhas famosas, como as de Pac-Man e Donkey Kong, foram
criadas nessa época. Os sons puderam ser aprimorados com o surgimento de sinte-
tizadores de vozes e o formato de áudio MIDI. Contudo, um dos maiores problemas
da época em relação aos sons era que os arquivos ocupavam um bom espaço da
memória, até mesmo dos cartuchos.
Uma grande revolução aconteceu quando os CDs começaram a ser usados na
criação de jogos eletrônicos. Graças a essa tecnologia, era possível armazenar maio-
res quantidades de informação e as músicas e demais sons começavam a asseme-
lhar-se com áudios gravados. Alguns anos depois, com o advento dos DVDs, não
houve mais a necessidade de se preocupar com a quantidade de espaço utilizada
para o armazenamento dos arquivos de áudio. Além disto, também surgiram novas
formas de compressão, como os formatos MP3 e OGG Vorbis, os quais podiam ser
descomprimidos pelos chips de som em computadores e videogames.

As músicas para jogos podem ser obtidas de duas formas: licenciamento
ou produções originais. É possível utilizar as músicas de uma banda famosa
como The Beatles, porém, é necessário entrar em contato com a produto-
ra para licenciar as faixas desejadas para seu jogo. Também existem sites
próprios para comprar músicas e sons para jogos junto com a licença para
seu uso. Outra forma é contratar músicos para criar os recursos sonoros e
trilhas a serem usadas. Para isto, é recomendado que o contratante conheça
termos musicais para que consiga comunicar o que deseja, como, por exem-
plo, a velocidade da batida ou o ritmo.
Existem jogos que possuem todas as suas trilhas licenciadas e outros que
contam só com músicas originais. O uso de cada tipo varia de acordo com
a finalidade que se deseja obter com a ambientação sonora, e os recursos
financeiros para tal. Outra possibilidade é utilizar os bancos de sons gratui-
tos ou que necessitam apenas que o criador seja citado quando usado (um
exemplo disto é o site SoundBible).
As trilhas também podem ser usadas de maneira dinâmica, aparecendo
em determinados momentos para ambientar a situação ou para marcar a
presença de uma personagem específica, também é comum que persona-
gens principais tenham os seus próprios temas. Os usos mais comuns de
sons dinâmicos são para situações de:
• Mistério: quando o jogador entra em uma situação ou local desconhe-
cido. A música, neste caso, ajuda-o a situar-se.
• Perigo: músicas com temas sinistros para indicar quando o jogador en-
trou em uma localidade com inimigos ou com grandes problemas a serem
enfrentados. Usado geralmente em jogos de terror.
• Combate: música estimulante que começa a tocar quando o jogador
entra em estado de confronto.
• Perseguição: um tema de ritmo rápido usado em casos que o jogador
está perseguindo um inimigo ou está sendo perseguido. Ajuda a tornar es-
tes momentos mais intensos.
• Vitória: trecho de áudio utilizado para enfatizar o fim de um combate
ou a superação de um desafio. A música, nestes casos, pode ajudar no sen-
timento de recompensa sentido pelo jogador.
• Andando: é comum nos jogos utilizar músicas ambiente para estimular

o jogador enquanto transita pelo cenário. Se a música tem um ritmo lento,
isto estimulará o jogador a andar devagar; se o ritmo da música for rápido,
a música estimulará o jogador a andar de forma apressada.
Além das trilhas sonoras, os efeitos sonoros têm uma importante função
de indicar ao jogador quando uma determinada ação está sendo executada,
como movimentação de personagens, ataques, sons de impacto, uso de ar-
mas, reações a golpes, falas, morte e sucesso. Cada situação pode utilizar de
diversos sons para ajudar o jogador a entender o que está ocorrendo à sua
volta. Também é importante controlar o volume de cada um desses efeitos
para indicar a distância que as ações estão ocorrendo do observador – um
tiro à distância será, necessariamente, mais baixo que um à queima-roupa.
DICA
Para o uso de efeitos sonoros permanentes ou temporários, os quais são
usados apenas para marcar a necessidade de algum som no projeto, exis-
tem diversos sites e bibliotecas de áudio gratuitos, alguns deles podendo
ser usado livremente no projeto, outros apenas para testes. Alguns desses
sites necessitam da criação de uma conta de usuário, como o FreeSound,
o YouTube e o 99Sounds.
Implementando trilhas sonoras

Para uma música ser tocada no Processing, existem alguns passos ne-
cessários:
1. Importar a biblioteca processing.sound. para o projeto. Essa biblioteca
possui todos os códigos relacionados com a manipulação de arquivos de
áudio no programa;
2. Criar um objeto do tipo SoundFile e atribuir um nome a ele;
3. Importar o arquivo de áudio que será utilizado;
4. Atribuir a referência ao arquivo de áudio para o objeto do tipo Sound-
File criado anteriormente;
5. Executar o áudio utilizando a função play do objeto.
O áudio usado no código a seguir pode ser baixado através do site Sou-
ndBible, no link em destaque. Após baixado, o arquivo pode ser importado
para o projeto arrastando-o com o mouse até a tela do sketch no programa
Processing.

<http://soundbible.com/grab.php?id=52&type=wav>.
O algoritmo acima pode ser escrito em Java, utilizando o Processing, da
seguinte forma:
//Importa a biblioteca necessária para utilização de áudios
import processing.sound.*;
//Cria um objeto para receber e manipular o arquivo de áudios
SoundFile fi le;
void setup() {
size(640, 360);
background(255);
//Atribui o arquivo de áudio ao objeto criado para que seja possível manipu-
lá-lo
fi le = new SoundFile (this, "airplane-landing_daniel_simion.wav");
//Aciona o som
fi le.play();
}
void draw() {
}
Caso a música seja executada de forma contínua no jogo, repetindo-se
após o término do arquivo, é possível substituir a linha de comando fi le.
play() por fi le.loop(), que fará com que ela continue sendo tocada até que o
programa seja encerrado ou até que o código receba o comando fi le.stop().
Implementando efeitos sonoros

A diferença entre os efeitos sonoros e as trilhas sonoras é que, além de os
efeitos sonoros serem comumente menores, eles são ativados por eventos es-
pecíficos, como o pressionar de um botão ou o executar de uma ação de uma
inteligência artificial.
O áudio usado no código a seguir pode ser baixado através do mesmo site,
no link separado. Após baixado, o arquivo pode ser importado para o projeto
arrastando-o com o mouse até a tela do sketch no programa Pro-
cessing.
<http://soundbible.com/grab.php?id=2219&type=wav>.

Um exemplo de implementação do efeito sonoro da turbina de um avião
quando o jogador pressionar a tecla direcional para cima encontra-se a seguir.
Neste código, há o uso de uma estrutura condicional para verificar se o áudio
já está sendo executado. O comando isPlaying serve para que o áudio não seja
executado novamente, causando o acúmulo do mesmo som a ser tocado e se
sobrepondo ao que já estava sendo tocado anteriormente.
//Importa a biblioteca necessária para utilização de audio
import processing.sound.*;
//Cria um objeto para receber e manipular o arquivo de audio
SoundFile file;
void setup() {
size(640, 360);
background(255);
//Atribui o arquivo de audio ao objeto criado para que seja possível manipulá-lo
file = new SoundFile(this, "airplane-landing_daniel_simion.wav");
}
//A função draw é necessário para que o áudio funcione de forma contínua
void draw() {
}
void keyPressed() {
//Verifica se a tecla pressionada pertence a o grupo mapeado CODED
if (key == CODED)
{
//Verifica se a tecla pressionada é a seta direcional para cima
if (keyCode == UP)
{
//Se o arquivo de áudio estiver tocando interrompe o som
if (file.isPlaying()) {
file.stop();
}
//Aciona o áudio
file.play();
}
}

}
Mais informações sobre a biblioteca de manipulação de áudio do Processing
podem ser encontradas no site do Processing, na sessão de documentação.

Sintetizando
Nesta unidade, foram apresentadas algumas formas de detecção e trata-
mento de colisões em jogos bidimensionais utilizando cálculos com geometria
básica. Também foi mostrado como é realizado o processo de criação e manipu-
lação de arquivos de áudio em jogos, sejam trilhas sonoras ou efeitos sonoros.
As colisões são verificadas de diferentes formas em cada estilo de jogo, mas
sempre exigem do programador o conhecimento matemático para a execu-
ção dos cálculos necessários para implementação dos códigos. No caso das
circunferências, foi demonstrada a necessidade de calcular o raio para obter
determinados pontos de colisão, porém, se houvesse a necessidade de calcular
pontos de colisão de outras formas geométricas, outros cálculos precisariam
ser adotados. Além disto, o uso de caixas de colisão demonstra-se um facilita-
dor no tratamento de colisões.
Em relação à implementação de arquivos sonoros, sua implementação é
semelhante à de imagens. Sua estrutura de repetição para trilhas sonoras é
equiparável a uma animação que ocorre continuamente, além de sua impor-
tância ser equivalente aos sprites para ambientar e instruir o jogador.
VIDEOAULA
Clique aqui

8 TRILHAS SONORAS INESQUECÍVEIS DOS JOGOS. Postado por Pipocando Ga-
mes. (17 min. 13 s.). son. color. port. Disponível em: <https://www.youtube.com/wat-
ch?v=Rwcz1m6jUO8>. Acesso em: 30 ago. 2019.
BRACKEEN, D.; BARKER, B.; VANHELSWUE, L. Developing Games in Java. San Diego:
New Riders Games, 2003.
ECK, David J. Introduction to Programming Using Java. Disponível em: <http://
math.hws.edu/eck/cs124/downloads/javanotes6-linked.pdf>. [s.l.]. 2011. Acesso em:
26 mai. 2019.
KOENING, M. Car Stereo Sound. [s.l.], [s.d.]. Disponível em: <http://soundbible.com/
52-Car-Stereo.html>. Acesso em: 07.ago. 2019.
ROGERS, S. Level UP: um guia para o design de grandes jogos. São Paulo: Blucher,
2013.
SHERROD, A. Game Graphics Programming. Burlington: Course Technology, 2008.
SIMION, D. Airplane Landing Airport Sound. [s.l.], [s.d.]. Disponível em: <http://sou-
ndbible.com/2219-Airplane-Landing-Airport.html>. Acesso em: 27 ago. 2019.

E-Book Completo Programação - Introdução Ao Coding (Games) (Versão Digital)

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

E-Book Completo Programação - Introdução Ao Coding (Games) (Versão Digital)

Enviado por

Direitos autorais:

Formatos disponíveis

ser

Diretor-presidente Jânyo Diniz

Diretoria Executiva de Ensino Adriano Azevedo

Diretoria Executiva de Serviços Corporativos Joaldo Diniz

Diretoria de Ensino a Distância Enzo Moreira

Autoria Fernando Mello de Amorim

Projeto Gráfico e Capa DP Content

Análise de Qualidade, Edição de Texto, Design Instrucional,

Edição de Arte, Diagramação, Design Gráfico e Revisão.

© Ser Educacional 2019

Rua Treze de Maio, nº 254, Santo Amaro

Recife-PE – CEP 50100-160

Informamos que é de inteira responsabilidade da autoria a emissão de conceitos.

ou forma sem autorização.

Imagens de ícones/capa: © Shutterstock

SER_GDESIGN_PROGCOD_UNID1_A5.indd 2 30/08/2019 13:42:57

SER_GDESIGN_PROGCOD_UNID1_A5.indd 3 30/08/2019 13:42:57

Unidade 1 - História da indústria e introdução ao Processing.jps

Histórico dos jogos digitais................................................................................................ 13

Elementos básicos de um jogo........................................................................................... 32

Criação de jogos 2D.............................................................................................................. 40

SER_GDESIGN_PROGCOD_UNID1_A5.indd 4 30/08/2019 13:42:58

Unidade 2 – Recursos visuais de um jogo eletrônico

Elementos gráficos de um jogo.......................................................................................... 52

Cenários e objetos (tiles e sprites).................................................................................... 61

Criação de animações em jogos........................................................................................ 67

PROGRAMAÇÃO - INTRODUÇÃO AO CODING (GAMES) 5

SER_GDESIGN_PROGCOD_UNID1_A5.indd 5 30/08/2019 13:42:58

Unidade 3 – Dispositivos de entrada, inteligência artificial e interação homem-máquina

Leitura de dispositivos de entrada..................................................................................... 78

Máquinas de estado em jogos............................................................................................ 89

PROGRAMAÇÃO - INTRODUÇÃO AO CODING (GAMES) 6

SER_GDESIGN_PROGCOD_UNID1_A5.indd 6 30/08/2019 13:42:58

Unidade 4 – Implementando colisões, músicas e sons

Tratamento de colisões...................................................................................................... 107

Músicas e efeitos sonoros em jogos............................................................................... 125

PROGRAMAÇÃO - INTRODUÇÃO AO CODING (GAMES) 7

SER_GDESIGN_PROGCOD_UNID1_A5.indd 7 30/08/2019 13:42:58

SER_GDESIGN_PROGCOD_UNID1_A5.indd 8 30/08/2019 13:42:58

PROGRAMAÇÃO - INTRODUÇÃO AO CODING (GAMES) 9

SER_GDESIGN_PROGCOD_UNID1_A5.indd 9 30/08/2019 13:42:58

O professor Fernando Mello de Amo-

PROGRAMAÇÃO - INTRODUÇÃO AO CODING (GAMES) 10

SER_GDESIGN_PROGCOD_UNID1_A5.indd 10 30/08/2019 13:42:58

SER_GDESIGN_PROGCOD_UNID1_A5.indd 11 30/08/2019 13:43:19

Conhecer um pouco mais sobre os

PROGRAMAÇÃO - INTRODUÇÃO AO CODING (GAMES) 12

SER_GDESIGN_PROGCOD_UNID1_A5.indd 12 30/08/2019 13:43:20

Os primeiros jogos digitais

PROGRAMAÇÃO - INTRODUÇÃO AO CODING (GAMES) 13

SER_GDESIGN_PROGCOD_UNID1_A5.indd 13 30/08/2019 13:43:32

Apesar do relativo sucesso e da grande importância histórica, Tennis for Two

PROGRAMAÇÃO - INTRODUÇÃO AO CODING (GAMES) 14

SER_GDESIGN_PROGCOD_UNID1_A5.indd 14 30/08/2019 13:43:33

PROGRAMAÇÃO - INTRODUÇÃO AO CODING (GAMES) 15

SER_GDESIGN_PROGCOD_UNID1_A5.indd 15 30/08/2019 13:43:33

O início dos consoles

PROGRAMAÇÃO - INTRODUÇÃO AO CODING (GAMES) 16

SER_GDESIGN_PROGCOD_UNID1_A5.indd 16 30/08/2019 13:43:33

PROGRAMAÇÃO - INTRODUÇÃO AO CODING (GAMES) 17

SER_GDESIGN_PROGCOD_UNID1_A5.indd 17 30/08/2019 13:43:33

A entrada da Sony no mercado de consoles ocorreu, primeiramente, com

PROGRAMAÇÃO - INTRODUÇÃO AO CODING (GAMES) 18