03 prototipagem

Prévia do material em texto

PROTOTIPAGEM PROTOTIPAGEM 
RÁPIDARÁPIDA
Me. George Sant iago Alves
IN IC IAR
introdução
Introdução
Nesta unidade, desenvolvemos um protótipo jogável utilizando o Unity. Você será capaz de entender
os conceitos de criação de um jogo, do ponto de vista de um produto desenvolvido há mais de 35
anos, criando um jogo de acordo com seu próprio desejo. Você vai aprender a desenvolver jogos,
gerar ideias, criar um conceito de seus próprios personagens, este capítulo será um bom começo
para você trabalhar as suas ideias como desenvolvedor de jogos, aplicando suas habilidades de
programador ou artista. Ver um jogo com outra perspectiva é importante para criar produtos com
conceitos já consolidados, o desenvolvimento do protótipo desta unidade partirá dessa premissa.
O projeto consiste no desenvolvimento do clássico Pac-man. Um jogo atemporal que permite
trabalhar testando diversos parâmetros vistos nas unidades anteriores. Ao longo deste tutorial,
iremos abordar alguns conceitos já vistos, bem como, alternativas para modi�car o jogo.
Nesta unidade, trabalharemos com a produção de um protótipo de jogo. Mas, iremos propor
modi�cações ao longo deste tutorial, iremos abordar o conceito de redesign, mas o que seria isso? A
De�nição do Projeto do Semestre: RedesignDe�nição do Projeto do Semestre: Redesign
de um Jogo Clássico da Geração 8 bitsde um Jogo Clássico da Geração 8 bits
indústria de jogos utiliza esse conceito o tempo todo, é um processo de alterar alguns elementos do
jogo, mas a essência permanece a mesma. Quais pontos poderiam ser modi�cados? Depende do
projeto, mas podem ser alterados a mecânica, os parâmetros, a interface, a estética, a própria
tecnologia para reconstrução do jogo. Mas qual o propósito de redesign? Você já notou que vários
projetos são similares? Alguns deles são acusados de cópia e cola, quando um jogo alcança um
sucesso comercial, outra empresa pode utilizar o conceito de redesign e lançar o seu próprio jogo
(MONTEIRO, 2016).
Os jogos antigos são uma fonte de inspiração para o redesign. O chamado redesign do retrô, veja a
�gura 3.1, o jogo duck hunt foi redesenhado para criar uma estética menos retrô. A �gura 3.2 já
mostra o redesenho em 3D. Perceba que muitos projetos só alteram a estética, o conceito mais
correto para o redesign é alterar elementos do jogo (XIMENES; MALCHER; CAMPOS, 2008). Um
exemplo seria você pegar o jogo super mario world, melhorar apenas as suas sprites e tentar vender
o jogo, isso seria proibido. Mas, utilizar o seu conceito 2D de exploração e passar de níveis como
fonte de inspiração poderia criar diversos jogos que seriam similares a super mario. E isso acontece
o tempo todo na indústria de jogos. Imagine o seu jogo preferido, quais elementos você alteraria?
No tutorial de desenvolvimento do protótipo de pac-man, iremos recriar com uma tecnologia nova
(Game Engine) e durante esse processo serão indicados assets na unity store para você modi�car
partes do jogo, mantendo a sua essência. Você também pode construir o tutorial e, após entender o
conceito do desenvolvimento, fazer suas próprias alterações. Bates (2004, p. 36) comenta que “se
você sabe exatamente o que você quer construir, você não gastará tempo e dinheiro criando
materiais que serão cortados no �m da produção”.
Figura 3.1 - Duck hunt 
Fonte: Comlimao.com (2017, on-line).
O objetivo do jogo é simples, o jogador precisa “comer” todos os pontos, chamados de pac-dots,
dentro de um labirinto, para conseguir passar de nível. A tarefa é di�cultada pelos quatro fantasmas
atrás de Pac-man. Se ele se encontra com um dos fantasmas, ele perde vida e retorna ao começo do
jogo, perdendo os pontos que ele comeu. Além de simplesmente escapar dos fantasmas, Pac-man
pode “comer” alguns power-ups (bônus) e garantir proteção por um curto intervalo de tempo dos
fantasmas. Após “comer” um bônus, os fantasmas começam a recuar por um curto período de
tempo, e nos primeiros níveis Pac-man pode “comer” um deles para obter pontos de bônus. O
fantasma comido não é eliminado, retorna à sua posição inicial, para recomeçar a perseguição. A
�gura 3.3 mostra a interface do jogo em 1981. Veja como o design é simples, e você pode estar se
perguntando – Mas desenvolver um jogo tão simples? O segredo é recriar, reimaginar, adicionar,
alterar os elementos clássicos, pegar a essência do jogo e transformar em algo diferente. Veja as
Figura 3.1 - Duck hunt 
Fonte: Comlimao.com (2017, on-line).
�guras 3.4, 3.5, 3.6 e 3.7, utilizam da essência de Pac-man para criar novas mecânicas, interface,
regras etc. (BARBOSA; SILVA, 2010).
saiba mais
Saiba mais
O jogo Pac-Man Pop é um redesign do Pac-man, com mescla dos jogos estilos breakout, onde você precisa
destruir os elementos do cenário, rebatendo a bola em uma plataforma e sem deixar a bola cair. Veja o
trailer a seguir:
ASS I ST IR
saiba mais
Saiba mais
Ullman (2010, p. 37) comenta que o redesign é a  “modi�cação de um produto existente para encontrar
novos requerimentos”. Você pode conferir outro trailer do Pac-Man Pop no link a seguir.:
ASS I ST IR
Figura 3.3 – Pac-man (Atari 2600) 
Fonte: Israelavila / Flickr.
Figura 3.4 – Pac-man (Atari 2600) 
Fonte: OpenClipart-Vectors / Needpix.com.
Figura 3.5 – Pac-man (Atari 2600) 
Fonte: Perez (2013).
Figura 3.6 – Pac-man (Atari 2600) 
Fonte: Dotson (2015).
Alguns termos muitas vezes são utilizados pelas empresas para denominar o tipo de redesign, sendo
os principais:
Remaster: Utilizado para relançar um jogo “melhorado” para uma nova geração de
consoles (ou tecnologia). Ele não altera a sua fórmula original, as mudanças são apenas
sonoras e estéticas. Exemplo:
Figura 3.7 – Pac-man (Atari 2600) 
Fonte: 9 Game… (2017).
Rsemake: Trata-se de refazer a obra original, não apenas a parte estética, mas acrescentar novos
elementos, alterar a mecânica, jogabilidade etc. Exemplo:
Figura 3.8 - Dark souls original versus remaster 
Fonte: Original (on-line).
Outros exemplos: Super Mario All-Stars, Resident Evil (2002), The Legend of Zelda: Ocarina of Time
3D, Metal Gear Solid: The Twin Snakes, DuckTales: Remastered, Call of Dut: Modern Warfare
Remastered, Castle of Illusion (2013) e Ratchet & Clank (2016).
Reboot: Esse tipo altera principalmente a história do jogo. Muitas vezes é o reinício da
franquia, uma nova face para o jogo.  Exemplo:
Figura 3.9: Resident evil 2 remake 
Fonte: Resident evil… (2018, on-line).
Figura 3.10 - Devil my cry 
Fonte: BagoGames / Flickr.
Ao criar o protótipo de Pac-man, você precisa projetar inicialmente o labirinto (Maze), os arquivos
utilizados neste tutorial serão disponibilizados para uso, mas você pode utilizar outros assets para
criação do protótipo, ou criar os seus próprios.  Existe um gerador para labirintos de Pac-man, você
acessá-lo no link: https://shaunlebron.github.io/pacman-mazegen/ .
No site https://opengameart.org/art-search?keys=pacman existem arquivos prontos para uso, na
Unity Store existem diversos materiais que podem ser implementados no protótipo, você pode
saiba mais
Saiba mais
Durante o processo de desenvolvimento, tente imaginar novas abordagens para esse protótipo. Anote,
teste, modi�que, não tenha medo de inovar, e, principalmente de descartar ideias, é comum se apegar a
conceitos que não funcionam para aquele jogo, nível, fase etc. Você pode conferir versões analógicas de
pac-man nos links:
ACESSAR
ACESSAR
ACESSAR
ACESSAR
https://shaunlebron.github.io/pacman-mazegen/
https://opengameart.org/art-search?keys=pacman
https://www.youtube.com/watch?v=h-Lx_g47kKs
https://www.youtube.com/watch?v=Jy58IpqseIE
https://www.youtube.com/watch?v=TI-bE4vzqJ0
https://www.youtube.com/watch?v=33GOC4Jiouo
alterar o personagem, as sprites dos personagens, bem como colocar plano de fundo, sons, efeitos
etc.
O estudo de uma game engine leva tempo, é preciso de prática e aprofundamento para conhecer as
suas ferramentas, além de ser preciso fazer um estudo com outros softwares de desenvolvimento,comparar, testar e analisar qual atende às suas necessidades como desenvolvedor. Lembre-se que
parte dessas ferramentas exigem conhecer linguagens de programação, o estudo delas é essencial.
O Unity tem uma comunidade ativa, diversos tutoriais feitos por desenvolvedores na internet, uma
loja de ativos que facilita o estudo de iniciantes. No link https://unity3d.com/pt/learn/tutorials você
encontra tutoriais dos mais diversos projetos, com níveis de di�culdades feitos para iniciantes,
intermediários e avançados, bem como tópicos sobre as melhores práticas de programação,
interface, otimização de performance, física etc. O Unity tem uma documentação vasta e pode ser
acessada pelo link https://docs.unity3d.com/Manual/index.html . Lembre-se que o Unity recebe
atualizações constantes, desde performance até pequenas mudanças na sua interface, algumas
vezes códigos ou ferramentas se tornam obsoletos no programa, ele atualiza e tenta adaptar os
códigos a essa nova versão.
https://unity3d.com/pt/learn/tutorials
https://docs.unity3d.com/Manual/index.html
Vamos começar a desenvolver o protótipo? Ele será dividido em duas etapas, a primeira será a
construção de uma das fases de Pac-man. Você vai entender como funciona o desenvolvimento de
um protótipo no Unity, os conceitos e fundamentos envolvidos. Logo após, na segunda etapa,
faremos modi�cações no projeto, sem alterar a essência do jogo Pac-man. Para isso, trocaremos
algumas sprites e adicionaremos elementos novos. Segundo Löbach (2001), a maioria dos redesign
de jogos atuais são apenas estéticos, não focando em novos elementos. Ainda de acordo com
Redesign de um Jogo: PrototipagemRedesign de um Jogo: Prototipagem
Löbach (2001, p. 119) “Na maioria das vezes isso resulta em melhoria da aparência estética mesmo
que não se obtenham outras vantagens funcionais [...]”. Nós podemos analisar esse conceito da
seguinte forma, alguns projetos não conseguem mais evoluir de maneira funcional - praticar,
adicionar novos elementos passa a ser uma repetição do próprio universo do jogo, cabendo assim
apenas a sua atualização estética, com tecnologias modernas.
Para jogos antigos, muitas empresas mantêm as regras e elementos do jogo, oferecendo um
produto com tons “nostálgicos”.
Na segunda etapa, iremos alterar as sprites dos elementos principais do jogo (pac-man, inimigos e
pac-dot) e adicionar um novo elemento. Após concluir todas essas etapas, acesse a playstore ou App
Store e veja quantos jogos utilizam da essência de pac-man, super mario, zelda, space invaders etc.
Muitos deles são apenas sprites alteradas, a essência é idêntica. E por que isso ocorre? É a chamada
fórmula do sucesso, é utilizar a fama de um produto para criar algo similar. Alguns são apenas
cópias, e outros são jogos bons. Por isso iremos mudar as sprites para vermos como funciona essa
releitura.
Vamos lá?
Abra o UNITY e clique em “NEW”, escolha a versão.
De�na o nome do projeto (Project Name) e o local onde será salvo (Location). Escolha o Template
2D. Após, clique em “CREATE”.
Figura 3.11 - New Projects 
Fonte: Elaborada pelo autor.
Após o projeto ser criado, você poderá ver a Interface inicial do UNITY. Foi utilizado o layout Tall, que
pode ser con�gurado no canto superior direito, neste menu existem 5 opções, mas você pode
con�gurar da sua maneira. Escolhendo a opção 2D inicial, o Unity identi�ca as imagens como sprites
e não texturas, utilizadas em 3D. Posteriormente você notará essa diferença.
Figura 3.12  - Con�gurações Unity 
Fonte: Elaborada pelo autor.
Con�gurações da câmera: Vá em Hierarchy, selecione Main Camera e, no inspector, altere a cor de
fundo (Background) para preto, após, altere o size para 30. Valores ajustados para trabalhar com o
tamanho proposto pelo nosso cenário. Veja as con�gurações:
Figura 3.13 - Unity Interface 
Fonte: Elaborada pelo autor.
Utilizaremos inicialmente uma sprite adaptada do labirinto de Pac-man, lembre-se que você pode
alterar com novas sprites, procurando na Asset Store por OpengameArt ou produzindo em
ferramentas como photoshop, Illustrator, gimp, paint etc.
Em Project>Assets>Sprites, selecione a sprite “Maze”, no inspector, altere as con�gurações, como na
imagem:
Figura 3.14 - Con�gurações da Câmera no Unity 
Fonte: Elaborada pelo autor.
O que foi alterado? Note que as con�gurações padrão de pixel por unidade é de 100, e alteramos
para 8, dentro do jogo, cada unidade contém 8x8 pixels, a distância entre os pac-dots é de 8px,
assim, cada movimento de pac-man é de uma unidade. Por padrão, todas as nossas texturas
utilizaram este valor.
Agora, vá em Sprite Editor, localizado no inspector da sprite labirinto, na tela que abrir, altere o valor
de pivot para Bottom_Left. Isso ajudará no alinhamento da fase posteriormente.
Figura 3.15 - Con�gurações Sprites 
Fonte: Elaborada pelo autor.
Agora, arraste o labirinto para SampleScene, no inspector, altere os valores para o tamanho que
você quer projetar o seu nível, por padrão, colocaremos a posição em (0,0,0).
Figura 3.16 - Sprite Editor 
Fonte: Elaborada pelo autor.
Após adicionar a sprite do labirinto, você pode vê-la na aba Scene e, na aba game você pode conferir
o resultado �nal. O próximo passo é habilitar a física nesta sprite, permitir colisão, impedindo Pac-
man ou os fantasmas de atravessar as paredes. Para isso, iremos utilizar o componente Collider no
labirinto. Selecione “maze” na aba SampleProject, no inspector, vá em: Add Component > Physics 2D
> Box Collider 2D, �cando assim:
Figura 3.17 - Transform 
Fonte: Elaborada pelo autor.
Adicionando esse componente ao labirinto, o Unity coloca automaticamente em todo o sprite,
precisamos alterar esses parâmetros e colocar cada collider em suas respectivas paredes. Para isso
você precisa adicionar manualmente, vá em Box Collider 2D>  Edit Collider, isso permite modi�car o
tamanho e posição do collider.
Figura 3.18 - Inspector 
Fonte: Elaborada pelo autor.
Vamos alterá-lo e posicioná-lo em uma das paredes, �cando assim:
Figura 3.19  - Box Collider 2D 
Fonte: Elaborada pelo autor.
Você precisa de um collider em cada parede, selecione “maze”, Add Component > Physics 2D > Box
Collider 2D e vá adicionando com ajuda do Edit Collider em todas as paredes do labirinto, para essa
sprite foram utilizados 53 colliders.
Agora que o labirinto está “pronto”, iremos adicionar os personagens. Começando com Pac-man. O
movimento feito por ele são: direita, esquerda, cima e baixo.
Você pode utilizar com outras imagens para representar Pac-man, lembre-se, siga o tutorial, mas
modi�que com as suas preferências, vá sempre na Unity Store buscar novos recursos para o projeto.
Na aba Project, selecione o arquivo pacman, na aba de importação, lembre-se de alterar os pixels
por unidade, deixando assim:
Figura 3.20 - Con�gurações de collider do labirinto 
Fonte: Elaborada pelo autor
Agora, precisamos alterar o Sprite Mode para Multiple, isso mostra ao Unity que existe mais de um
Pac-man no sprite (posteriormente, utilizaremos isso para animação). Clique em Sprite Editor:
Figura 3.21 - Con�guração sprites 
Fonte: Elaborada pelo autor.
Como queremos mais de uma imagem do Pac-man para as animações, precisamos de�nir as fatias
de cada imagem, con�gurando em 16x16. Selecione o botão Slice:
Figura 3.22 - Sprite Editor 1 
Fonte: Elaborada pelo autor.
Clique em “Apply” e volte ao menu principal. Esse corte criou 12 fatias do Pac-man, na aba Project,
selecione o arquivo “pacman”, clique no botão de expandir:
Figura 3.23 - Sprite Editor 2 
Fonte: Elaborada pelo autor.
Veja que essa sequência de imagens criou as animações de pac-man e dos fantasmas, a indústria de
videogames utiliza por padrão 30 frames por segundo (30 imagens processadas em cada segundo),
mas, diversas empresas acreditam que 30 frames não é su�ciente, utilizando 60 frames em seus
projetos. Para criarmos as animações de pac-man, utilizaremos as 12 fatias do sprite,
respectivamente: direita(0,1 e 2), esquerda (3,4 e 5), cima (6,7 e 8) e baixo (9,10 e 11). Selecione as
três primeiras fatias do sprite (na aba Project):
Figura 3.24 - Spritesheet 
Fonte: Elaborada pelo autor.
Em seguida, arraste-os para a cena :
Figura 3.25 - Primeira animação pac-man 
Fonte: Elaborada pelo autor.
Caso a sprite �que pequena, selecione o arquivo pacman (na aba SampleScene ) e em Inspector,
altere o valor scale (X,Y). Arrastando as fatias para aba SampleScene , o Unity cria automaticamente
uma nova animação, você precisa criar ou escolher uma pasta para pôr esses arquivos, sugerimos
criar uma pasta para animações, e dentro dela uma pasta para cada objeto animado em cena
(Personagem, Inimigos, HUD etc.):
Figura 3.26 - Pac-man em cena 
Fonte: Elaborada pelo autor.
Para esta animação iremos salvar o arquivo como right.anim na pasta PacmanAnimation. O Unity
adiciona na aba SampleScene o GameObject pacman_0 e dois arquivos na aba projeto.
Figura 3.27 – Salvar animações no projeto 
Fonte: Elaborada pelo autor.
O primeiro arquivo é a máquina de estado da animação (right.anim), contém parâmetros para
con�gurar o estado da animação, transição, velocidade etc. O segundo é a animação em si. Repita
esse processo com as outras animações, lembre-se de selecionar as fatias especí�cas de cada
animação, escolher um nome e pasta. Na aba Hierarchy, dentro de SampleScene, o arquivo �ca
assim:
Figura 3.28 - Pac-man Animation 
Fonte: Elaborada pelo autor.
Lembra que o Unity cria objetos dentro da aba Project (uma para a máquina de estado e outro para
a animação, além de criar 4 GameObject no nosso projeto)? Precisamos apenas dos arquivos da
animação, um arquivo (GameObject) de pacman em Hierachy e uma máquina de estado.
Dentro de SampleScene, selecione os arquivos pacman_3, pacman_6 e pacman_9, clique com o
botão direito e delete os arquivos. Agora na aba Project, selecione e delete as máquinas de estado
das fatias 3, 6 e 9:
Figura 3.29 - Hierarchy pac-man 
Fonte: Elaborada pelo autor
Agora que criamos os quatro arquivos de animações, uma máquina de estado e um sprite do Pac-
man em cena, iremos con�gurar sua máquina de estado. Precisamos de uma máquina de estado de
animação com quatro estados (direita, esquerda, cima e baixo), o Unity tem um sistema próprio para
fazer essas con�gurações. Durante a animação, dependendo da posição de Pac-man as imagens
�cam se repetindo continuamente, esperando a transição para outros estados, con�gurados
posteriormente pelos scripts.
Clique duas vezes na máquina de estado da animação pacman_0 na aba de projetos.
Ok, então vamos clicar duas vezes no arquivo de máquina de estado de animação pacman_0 em
nossa área de projeto :
Figura 3.30 - Delete 
Fonte: Elaborada pelo autor.
Após clicar duas vezes, a ferramenta Animator irá se abrir:
Figura 3.31 - Máquina de Estados 
Fonte: Elaborada pelo autor.
Note que o estado “direito” já está no Animator, você precisa arrastar as outras animações para
dentro dessa ferramenta. Vá na aba Project, pasta PacmanAnimation e arraste os arquivos para
Animator:
Figura 3.32 - Base Layer 
Fonte: Elaborada pelo autor.
O sistema que cuida das máquinas de estado é automático, você precisa apenas direcionar a
posição das animações, ele cuidará do resto. Para criar os parâmetros necessários, precisamos
entender o movimento das imagens, ela utiliza um sistema de Vector2, a imagem a seguir
demonstra os vetores de movimento:
Figura 3.33 - Con�gurações da Base Layer 
Fonte: Elaborada pelo autor.
No jogo Pac-man, o mesmo possui 4 direções de movimento (direita, esquerda, cima e baixo),
possibilitando 4 transições entre eles, a máquina de estado precisa das seguintes con�gurações:
Se DirY> 0, então vá para Cima (como DirY = 1, DirY = 2, DirY = 3 e assim por diante).
Se DirY <0, em seguida, vai para Baixo (como DirY = -1, DirY = -2, DirY = -3 e assim por
diante).
Se DirX> 0, em seguida, vá para a Direita (como DirX = 1, DirX = 2, DirX = 3 e assim por
diante).
Se DirX <0, em seguida, vá para a Esquerda (como DirX = -1, DirX = -2, DirX = -3 e assim por
diante).
Figura 3.34 - Direções 
Fonte: Elaborada pelo autor.
Agora iremos criar os parâmetros para transição de estados. Vá para Animator (localizado ao lado de
Game, Scene, Console etc.). No lado esquerdo, em Parametrs, vamos clicar no + e depois adicionar
um parâmetro do tipo FLOAT com o nome DirX e outro parâmetro do tipo FLOAT com o nome DirY.
Posteriormente, iremos manipular esses parâmetros a partir de um script, com o seguinte comando:
Esses parâmetros permitirão que o Unity transite para diferentes estados de animação. O parâmetro
DirX > 0 altera o estado da direita para a esquerda. Para assegurar essa mudança, é preciso ter uma
Figura 3.35 - Parâmetros da animação 
Fonte: Elaborada pelo autor.
GetComponent<Animator>().SetFloat("DirX", 0); GetComponent<Animator>().SetFloat("DirY", 0);
margem de segurança, de tolerância a erros, altere o valor de 0.0 para 0.1.
Dentro do Animation, existe um estado chamado Any State, ou qualquer estado, que permite
con�gurar a transição de qualquer estado para o estado inicial (direita). Iremos con�gurá-lo assim:
Para isso, clique no botão direito em Any State e selecione Make Transition. Depois, podemos
arrastar a seta branca para o estado certo. Após arrastar a seta branca, selecione-a e vá em
Inspector, onde iremos alterar as condições de transição. Vamos con�gurá-lo para DirX> 0.1, para
adicionar essa condição, pressione o + no canto inferior direito. Desabilite também a opção “Can
Transition To Self”, isso evita que ao �car pressionando um botão no teclado a animação �que
reiniciando.
Figura 3.36 - Any State 
Fonte: Elaborada pelo autor.
Esses parâmetros permitem que Pac-man possa caminhar para a direita, DirX>0.1, o animator
mudará para o estado correto, reproduzindo a animação. Agora iremos adicionar as setas brancas
para mais três posições:
Any State para a esquerda com a Condição DirX < 0.1 .
Any State para cima com a condição DirY> 0.1 .
Any State para baixo com a condição DirY < 0.1 .
O Animator �cará assim:
Figura 3.37 - Con�gurações dos parâmetros de animação 
Fonte: Elaborada pelo autor.
Agora precisamos de�nir a velocidade da animação, para que a mesma �que �uida. Selecione todos
os estados e modi�que a velocidade no Inspector, você pode alterar, faça testes e veja os resultados.
Figura 3.38 - Con�gurações da Base Layer 
Fonte: Elaborada pelo autor.
Vamos testar? Pressione Play e veja a animação de Pac-man:
Figura 3.39 - Velocidade 
Fonte: Elaborada pelo autor.
À medida que projetos são desenvolvidos no Unity e, em outras plataformas, diversos arquivos são
adicionados, criados e alterados de lugar, podendo criar um ambiente caótico, caso você não faça
um planejamento inicial. Crie pastas e subpastas desde o início para organizar o seu projeto. Não
esqueça de renomear, e criar padrões com nomes dos seus objetos em cenas. Isso mantém o
projeto limpo e organizado.
Vá em Hierarchy>SampleProject, selecione pacman_0 e renomeie para pacman (pressione F2).
Figura 3.40 - Animação de pac-man em cena 
Fonte: Elaborada pelo autor.
Resumo:
Criamos e con�guramos o labirinto (Posição e collider).
Adicionamos Pac-man no labirinto.
Criamos as con�gurações iniciais de animação e transição (Parâmetros).
Agora precisamos dar vida a Pac-man, adicionar física, script de movimento e interação com os
objetos.
Figura 3.41 - GameObject 
Fonte: Elaborada pelo autor.
Assim como o labirinto, Pac-man precisa de um collider, precisa fazer parte do cenário, ter física e
interação com os objetos. Além do collider, precisamos adicionar um Rigidbody2D, componente que
permite movimentarmos pac-man, além de cuidar da gravidade, velocidade, rotação e outras forças
de movimento.
Redesign de um Jogo: Prototipagem IIRedesign de um Jogo: Prototipagem II
Lembra de como adicionar componentes a GameObjects? Selecione o pacman na aba Hierarchy,
selecione Component> Physics 2D > Circle Collider 2D. Agora Add Component > Physics 2D >
Rigidbody 2D.  Ficará assim: 
Esses componentes e con�gurações permitem que Pac-man faça parte da física do jogo, interagindo
(colisões) com objetos (paredes, fantasmas, pac-dots) do cenário.
Com tudo con�gurado, começaremos a construir os scripts de movimento, toda vez que o jogador
pressionar uma das teclas de seta, Pac-man deve mover 1 unidade (lembra-se da con�guração inicial
do cenário? A distância dos pac-dots de uma unidade?). Existem diversas maneiras de criar
movimento no Unity, neste tutorial utilizaremos apenas uma delas, mas no arquivo anexo da
disciplina você verá outras opções.
Figura 3.42 - Componentes 
Fonte: Elaborada pelo autor.
Vamos adicionar um script no GameObject Unity, selecione pacman na aba Hierarchy > Add
Component > New Script , nomeie PacmanMove. Esse script foi salvo na aba Project, dentro da pasta
Assets. Lembre-se de organizar o seu projeto, crie uma nova pasta com nome Scripts, e arraste
PacmanMove para ela:
Selecione PacmanMove e dê um duplo clique para abri-lo no Visual Studio, ferramenta que iremos
usar para criar os nossos códigos do jogo. A Função Start() é chamada assim que o script vinculado a
esse componente for iniciado na cena. Como esse projeto inicialmente tem apenas uma cena, o
objeto é chamado assim que o jogo inicia.
A função Update() é chamada a cada frame, uma vez por quadro (aproximadamente 60 vezes por
segundo, dependendo do hardware e dos itens na tela), utilizaremos ela para retornar determinados
Figura 3.43 - Script 
Fonte: Elaborada pelo autor.
valores para ações do usuário, os chamados Inputs. Veja a estrutura padrão dos scripts no Unity:
Obs.: Existem outras funções do tipo Update, como FixedUpdate e LateUpdate, no material em
anexo você pode estudar essas funções, bem como outros tipos usados constantemente no Unity.
Para este projeto utilizaremos FixedUpdate, que utiliza um tempo �xo para ser chamado,
using UnityEngine; 
using System.Collections; 
public class PacmanMove : MonoBehaviour { 
void Start () { 
} 
void Update () { 
} 
}
independente do hardware, evitando diferentes velocidades entre equipamentos. Nosso script base,
após mudança, é:
A primeira variável a ser declarada é a velocidade de movimento de Pac-man (Speed), note que que
ela é do tipo public, isso permite alterar o valor na interface do Unity. Essa variável é o início da
criação de parâmetros que interferem diretamente no jogo, a sua progressão e balanceamento,
comece a pensar sobre esses valores, altere, teste e veja a velocidade de movimento, como ele
using UnityEngine; 
using System.Collections; 
public class PacmanMove : MonoBehaviour { 
void Start () { 
} 
void FixedUpdate () { 
} 
}
altera o equilíbrio do jogo. Na próxima Unidade discutiremos sobre esses valores, possíveis
alterações, levando em consideração o que foi estudado na unidade 1 e 2.
Agora precisamos de uma função que veri�que a possibilidade de movimento de Pac-man, assim
saberemos se há obstáculos impedindo o movimento (paredes). Também precisaremos de uma
using UnityEngine; 
using System.Collections; 
public class PacmanMove : MonoBehaviour { 
public �oat speed = 0.4f; 
void Start () { 
} 
void FixedUpdate () { 
} 
}
maneira de descobrir se o Pac-Man pode se mover em uma determinada direção ou se há uma
parede.
bool valid(Vector2 dir) { 
Vector2 pos = transform. position; 
RaycastHit2D hit = Physics2D. Linecast ( pos + dir, pos ); 
return ( hit.collider == GetComponent < Collider2D >()); 
}
Agora iremos criar uma função que vai mover Pac-man, uma unidade por vez, na direção desejada.
Uma variável irá guardar o destino do movimento, e em seguida, a função FixedUpdate moverá o
personagem no destino escolhido:
using UnityEngine; 
using System.Collections; 
public class PacmanMove : MonoBehaviour { 
public �oat speed = 0.4f; 
Vector2 dest = Vector2. zero; 
void Start () { 
dest = transform. position; 
} 
void FixedUpdate () { 
Vector2 p = Vector2. MoveTowards ( transform. position, dest, speed )
; 
GetComponent<Rigidbody2D >() . MovePosition ( p ) ; 
} 
bool valid ( Vector2 dir ) { 
Vector2 pos = transform. position; 
RaycastHit2D hit = Physics2D. Linecast ( pos + dir, pos ); 
return ( hit. collider == GetComponent<Collider2D >()); 
O código GetComponent é literalmente pegar um componente associado a esse script, acessar as
suas funções. Agora, iremos criar as entradas do teclado (Inputs) e veri�car se o destino é possível.
} 
}
O código Input.GetKey(KeyCode.UpArrow) diz que caso seja pressionado o botão no teclado “CIMA” e
a posição for válida, ele anda uma unidade para cima. O transform.position é convertido em Vector2,
esta é a única maneira de comparar ou adicionar outro Vector2.
void FixedUpdate () { 
Vector2 p = Vector2. MoveTowards ( transform. position , dest, speed ); 
GetComponent<Rigidbody2D>().MovePosition(p); 
if (( Vector2 ) transform. position == dest ) { 
if ( Input. GetKey ( KeyCode. UpArrow ) && valid ( Vector2. up )) 
dest = ( Vector2 ) transform. position + Vector2. up; 
if ( Input. GetKey ( KeyCode. RightArrow ) && valid ( Vector2. right )) 
dest = ( Vector2 ) transform. position + Vector2. right; 
if ( Input. GetKey (KeyCode. DownArrow ) && valid(-Vector2. up )) 
dest = ( Vector2 ) transform. position - Vector2. up; 
if ( Input. GetKey (KeyCode. LeftArrow ) && valid(-Vector2. right )) 
dest = ( Vector2 ) transform. position - Vector2. right; 
} 
}
-Vector2.right signi�ca esquerdo.
-Vector2.up signi�ca baixo.
Agora, acesse o menu superior no Visual Studio e salve o script. Volte ao Unity e dê “PLAY”, podemos
mover Pac-Man com as setas. Perceba que podemos movimentar Pac-Man pelo cenário, mas existe
apenas uma única animação. Precisamos de�nir pelo script os parâmetros do animador, volte ao
script no Visual Studio, iremos adicionar o cálculo de direção do movimento atual e de�nir os valores
para transição:
void FixedUpdate() { 
Vector2 p = Vector2. MoveTowards (transform. position , dest, speed); 
GetComponent<Rigidbody2D> () .MovePosition ( p ); 
if (( Vector2 ) transform.position == dest ) { 
if ( Input. GetKey (KeyCode. UpArrow ) && valid ( Vector2. up )) 
dest = (Vector2)transform. position + Vector2. up; 
if ( Input. GetKey (KeyCode.RightArrow ) && valid ( Vector2. right )) 
dest = ( Vector2 ) transform. position + ( Vector2 ) . right ; 
if ( Input. GetKey (KeyCode. DownArrow ) && valid ( -Vector2. up )) 
dest = ( Vector2 ) transform. position - Vector2. up; 
if ( Input. GetKey ( KeyCode. LeftArrow ) && valid(-Vector2. right )) 
dest = ( Vector2 ) transform. position - Vector2. right; 
} 
Vector2 dir = dest - (Vector2)transform. position; 
GetComponent < Animator >() .SetFloat ("DirX", dir. x ) ; 
GetComponent < Animator >() . SetFloat ("DirY", dir. y ) ; 
}
Salve e volte ao Unity. Dê Play e observe o movimento e animações de Pac-man. Na criação de
cenários 2D, precisamos de�nir a ordem dos sprites em tela, Pac-man precisa estar sempre na
frente da sprite dos Pac-Dots. Para isso iremos nos certi�car dessa condição. Nas versões atuais do
Unity, no Inspector, existe uma con�guração que facilita essa hierarquia, chamada de “Order in
Layer”. Selecione pacman na aba de Projetos e modi�que essa opção para 1:
Essa con�guração é importante na criação de protótipos com vários elementos em cena, neste
projeto o Pac-man está na ordem 1, os pac-dots e o labirinto em 0. Isso garante que o personagem
esteja à frente de todo o resto.
Figura 3.44 - Order in Layer 
Fonte: Elaborada pelo autor.essa é a fonte
Com o movimento e animações funcionando, iremos criar os Pac-Dots, as pequenas bolinhas que
Pac-man pode “comer”. Para isso, nós podemos importar uma imagem feita em outras ferramentas,
ou outros elementos da Unity Store. Cada pac-dots aumenta em 1 ponto o score.
Obs: E se no lugar dos pac-dots fossem frutas? Comidas? E se em cada labirinto tivesse elementosespeciais com pontuações diferentes?
Selecione a sprite do pac-dot na aba de Project>Assets. Agora utilize as mesmas con�gurações de
importação feitas nas outras sprites (Pac-man e Labirinto). Feito isso, arraste para a aba Hierarchy,
selecione-o e adicione um Box Collider 2D. Antes de prosseguir, qual erro vai acontecer se dermos
Play? Faça o teste. Perceba que ao adicionar um collider, o pac-dot se torna uma “parede”, existe
uma colisão, precisamos garantir que Pac-man absorva essas bolinhas, que possa atravessá-las.
Para isso, no Inspector do pac-dot, vá em Box Collider 2D e selecione Is Trigger. Agora dê Play. Você
pode atravessá-la com Pac-man. Com essa con�guração habilitada, a sprite recebe apenas a
informação da colisão. Você pode observar isso em vários jogos, poderia imaginar alguns? Os
fantasmas de super mario? As graminhas de pokemon? Nadar com Link (personagem da série Zelda)
nos rios?
Figura 3.45 - Is Trigger 
Fonte: Elaborada pelo autor.
Agora iremos con�gurar um script para os pac-dots, vá em Add componet > new script, nomear
como Pacdot e mover o script para a pasta Scripts, em seguida, abra-o.
Nesse script não precisamos das Funções principais Start e Update, apenas adicionaremos a função
OnTriggerEnter2D (Veja o material extra). Esse script veri�ca se é Pac-man que andou sobre ele, caso
seja positivo, o mesmo é destruído. É dentro desta função que o score é criado.
Salve e volte ao Unity, agora distribua os pac-dots no cenário. Lembre-se de que as coordenadas dos
pac-dots precisam ser arredondadas (1,10) e nunca (1,002, 3,07). Para isso é só ir no inspector do
pac-dot e alterar no componente Transform. Crie uma nova pasta dentro de Hierarchy ou mova os
pac-dots para dentro do labirinto, para organizar a cena. O resultado �cará assim:
using UnityEngine; 
using System.Collections; 
public class Pacdot : MonoBehaviour { 
void OnTriggerEnter2D(Collider2D co) { 
if ( co. name == "pacman" ) 
Destroy(gameObject ) ; 
} 
}
Figura 3.46 - Pac-dots 
Fonte: Elaborada pelo autor
Pressione Play e veja o Pac-man “comer” os pac-dots.
Qual o próximo passo? Pac-man pode se mover e “comer” os pac-dots, mas só isso não traria
desa�o, precisamos de uma força oposta, adicionar os inimigos, no caso de Pac-man, os fantasmas.
Inicialmente as con�gurações do fantasma é a mesma de Pac-man, ele precisa dos mesmos
componentes. Por isso, e como forma de treinamento, você vai con�gurá-lo da mesma maneira que
Pac-man, para facilitar, deixaremos o roteiro:
Na hora de nomear os fantasmas (Ghosts), você pode criar os nomes que quiser, ou para o
protótipo, utilizar os originais: Blinky (Vermelho), Inky (Azul), Pinky (Rosa) e Clyde (Laranja).
Figura 3.47  - Organização dos pac-dots 
Fonte: Elaborada pelo autor.
Inicialmente faça apenas um fantasma, depois de todas as con�gurações básicas e scripts, construa
os outros.
Con�guração inicial da sprite do fantasma (tamanho e corte);
Importar para aba Hierarchy;
Criar as animações e os parâmetros (4 movimentos);
Posição do fantasma no labirinto;
Componentes de colisão e física;
Hierarquia das sprites.
Volte e veja as con�gurações de Pac-man, repita todos os passos, quantas vezes forem necessárias.
A prática é importante para dominar qualquer ferramenta.
Feitas todas essas con�gurações, iremos para o passo diferencial de Pac-man e os fantasmas, eles
não “comem” os pac-dots, e não são movimentados pelo jogador.
No jogo original, cada fantasma utilizava um movimento diferente, alguns eram focados em andar
pelo labirinto, outros a caçar Pac-man. O estudo da inteligência arti�cial é fundamental para criar
Redesign de um Jogo: Prototipagem IIIRedesign de um Jogo: Prototipagem III
desa�os para o jogador, estratagemas criados pela máquina. No material extra, estude os artigos,
livros e tutoriais sobre Inteligência Arti�cial, depois modi�que os scripts feitos aqui.
Para o protótipo iremos criar o movimento de andar no cenário, utilizando o sistema de waypoint, o
fantasma irá andar por um determinado caminho. Dependendo do labirinto, você pode criar
caminhos possíveis para os fantasmas, montando armadilhas para o jogador. Você pode imaginar a
criação de um sistema dinâmico nos fantasmas? Geração de labirintos e Inteligência Arti�cial
aleatória? Ou parcial?
Selecione o fantasma e adicione um script a ele, coloque o nome de GhostMove, depois abra-o.
Novamente, não precisamos das funções Start e Update, utilizaremos apenas FixedUpdate. Para
adicionar os waypoints pela interface do Unity, criaremos uma variável pública do tipo Transform,
ela é uma matriz. Precisamos criar um índice para essa matriz, ela informará o caminho, saberemos
onde o fantasma está e para onde está indo. O que falta? Os fantasmas se movimentam, precisamos
de uma velocidade (Speed), �cando assim:
Agora iremos criar o movimento do fantasma, utilizando a função Vector2.MoveTowards para
calcular o ponto mais próximo do atual. A posição do fantasma é de�nida pela função
rigidbody2D.MovePosition. Toda vez que o próximo ponto for alcançado, a variável cur aumenta em
um. O código else cur = (cur + 1) % waypoints.Length rede�ne a variável cur para 0, impedindo de
exceder o comprimento da lista (pontos). O próximo passo é criar os códigos de animação:
using UnityEngine; 
using System.Collections; 
public class GhostMove : MonoBehaviour { 
public Transform [] waypoints; 
int cur = 0 ; 
public �oat speed = 0.3f ; 
void FixedUpdate () { 
} 
}
O último ponto é adicionar a colisão entre os fantasmas e Pac-man, para isso utilizaremos um
sistema parecido com o dos pac-dots (OnTriggerEnter2D):
void FixedUpdate () { 
if (transform. position != waypoints [ cur ] . position ) { 
Vector2 p = Vector2. MoveTowards ( transform. position , 
waypoints [ cur ] . position , 
speed ); 
GetComponent < Rigidbody2D >() . MovePosition ( p ); 
} 
else cur = < (< font="">cur + 1 ) % waypoints. Length; 
Vector2 dir = waypoints [ cur ] . position - transform. position; 
GetComponent < Animator >() . SetFloat ("DirX", dir. x ); 
GetComponent < Animator >() . SetFloat ("DirY", dir. y ); 
}
Salve e volte para a tela inicial do Unity, adicionaremos os Waypoints. Na aba Hierarchy, selecione o
fantasma>Create Empty, modi�que o nome para Blinky_Waypoint0 e então atribua um Gizmo
(visualização dos GameObjects na aba scene, não será mostrado durante o jogo). Ficará assim:
void OnTriggerEnter2D ( Collider2D co ) { 
if ( co. name == "pacman" ) 
Destroy ( co. gameObject ); 
}
Figura 3.48 - Waypoint 
Fonte: Elaborada pelo autor.
Agora, você pode duplicar o Waypoint  e alterar o nome para Blinky_Waypoint1 ,  adicionar e alterar
a posição no labirinto (No inspector>Transform do GameObject). Crie um caminho para o fantasma,
como na �gura:
E o que vai acontecer? Um loop, o fantasma irá se mover nessa ordem, atingindo o último waypoint
ele retorna à posição inicial, recomeçando o caminho. Agora precisamos arrastar todos os waypoints
para dentro da matriz do script GhostMove, na aba inspector do fantasma, em size, coloque o
número igual à quantidade de waypoints (lembre-se, a matriz começa em 0):
Figura 3.49 - Waypoints no labirinto 
Fonte: Elaborada pelo autor.
Agora, pressione o Play e veja o movimento do fantasma. Crie rotas mais complexas, teste novas
possibilidades. O próximo passo é criar os outros fantasmas, siga os mesmos passos do primeiro
fantasma. Adicione novas rotas e velocidades diferentes.
Figura 3.50 - Size 
Fonte: Elaborada pelo autor.
Para prosseguir, sugerimos que você refaça o tutorial quantas vezes forem necessárias para sanar
suas dúvidas. Só após, comece essa segunda etapa. Diversos elementos presentes no tutorial serão
abordados aqui, não utilizaremos prints de conceitos vistos na primeira etapa. Por isso, quando tiver
dúvida, volte à primeira parte do tutorial.
Criamos a base do jogo! Dos elementos que criamos, quais poderiam mudar? Para isso iremos criar
uma cópia da cena atual e testar novoselementos. Na aba Project, localize e selecione
“SampleScene”, com ele selecionado, vá no teclado e clique Ctrl+D, isso cria uma cópia da nossa
cena, com todos os elementos. Isso permite que possamos testar novas ações para o jogo, sem
alterar a versão principal.
Figura 3.51 - Finalização 
Fonte: Elaborada pelo autor.
Obs: Você pode alterar o nome desta cena, basta selecionar o objeto e clicar em F2. Observe que
mudando o nome de “SampleScene “ para Level1 e duplicando esse objeto, automaticamente ele
cria um segundo objeto com nome: Level2.
Para o redesign, você vai localizar, dentro da aba Project, uma pasta chamada “sprites_redesign”
contendo diversos sprites para serem utilizados em projetos. Utilizaremos alguns deles para alterar
elementos no labirinto. Veja como �cou:
Figura 3.52 - Projeto 2 
Fonte: Elaborada pelo autor.
Você pode notar alguma diferença? Vejamos:
Alteramos o sprite de pac-man para um mineiro;
Os fantasmas foram transformados em zumbis;
Não temos mais pac-dots, agora são algumas chaves no cenário;
A porta abre quando você pegar todas as chaves;
As tumbas localizadas no mapa são armadilhas, se o jogador passar por cima delas, um
zumbi surge no centro do mapa (tumba principal).
Note que a essência de pac-man foi mantida, o jogador ainda transita pelo labirinto (você pode
alterar os sprites para �car similar a uma caverna), ele precisa pegar itens para liberar uma outra
fase, inimigos ainda o perseguem. Nós acrescentamos apenas as tumbas como elemento surpresa.
 Agora, vamos construir esse novo “pac-man”, ou melhor, “miner man”.
Quando você duplicou a cena, todos os elementos foram mantidos. Precisamos alterar esses
elementos. A construção é a mesma utilizada durante o tutorial. O que vai mudar inicialmente
apenas as sprites, o script de movimento é o mesmo, tanto do player como dos inimigos, o labirinto
se mantém, a sprite do pac-dot foi alterada para uma chave. Lembre-se, a prática precisa ser
constante, para dominar uma ferramenta como o UNITY, você precisa praticar muito. Refaça o
tutorial, alterando os sprites de:
Pac-man para o mineiro (nome do arquivo: Scavengers).
Fantasmas para zumbi (nome do arquivo: Scavengers).
Pac-dot para chaves (nome do arquivo: key).
Acrescente em cena:
O portão (nome do arquivo: dungeon).
As tumbas (nome do arquivo: tombstone).
Agora vamos criar os seguintes sistemas:
Tumbas (Vai instanciar um zumbi quando o personagem passar por cima).
Portão (Vai abrir quando todas as chaves forem capturadas).
Para as tumbas:
Você pode imaginar como funciona esse sistema? Ele precisa interagir com o personagem, quais
componentes precisamos adicionar? Primeiramente um “box collider 2d”! Se deixarmos apenas
assim, qual erro vai acontecer? Dê play e veja. Percebeu? Existe uma colisão igual às paredes, o
personagem precisa passar por cima da tumba, igual dos pac-dots (chaves agora). No box collider,
habilite o “is trigger”. Agora, adicione um novo script chamado “tumba”. Antes de abrir esse script no
Visual Studio, você precisa entender o conceito de prefab no Unity, criando uma pasta chamada de
“Prefabs” na aba Project, você pode arrastar para dentro dela um GameObject em cena da aba
Hierarchy, seja o cenário inteiro, o personagem principal, os inimigos, itens etc. E qual o benefício?
Você vai armazenar esse componente com todas as características dele, tornando-o um arquivo
reutilizável, ou o chamado pré-fabricado. Para isso, dentro da aba Project, crie um uma pasta
chamada de “Prefabs” e arraste um fantasma (agora zumbi) para dentro dela:
Figura 3.53 - Prefabs 
Fonte: Elaborada pelo autor.
using UnityEngine;
using System.Collections;
public class Tumba : MonoBehaviour
{
public GameObject zumbi;
public Transform zumbiTower;
void OnTriggerEnter2D(Collider2D col)
{
if (col.name == "zumbi" ) {
GameObject monster = Instantiate(zumbi, zumbiTower.position, Quaternion.identity) as
GameObject;
Destroy(gameObject);
}
Criamos duas variáveis públicas, a chamada “zumbi” é o prefab do nosso inimigo, localizado dentro
da pasta prefabs. O zumbiTower é a localização que queremos que o zumbi seja instanciado
(gerado), este está localizado no centro do mapa.
A função OnTriggerEnter2D (Collider2D col) é a mesma utilizada no pac-dot, acrescentamos apenas a
linha:
Estamos criando uma variável temporária chamada de “monster”, e ela vai ser instanciada (criada ou
gerada), o que vai ser gerado? O zumbi, onde? Em zumbiTower.position. O Quaternion.identity
garante que o zumbi esteja perfeitamente alinhado com o nosso cenário, não sofrendo rotação.
E se quisermos que o zumbi fosse instanciado na tumba onde o personagem acabou de passar? Não
precisaríamos criar uma variável para a localização, basta dentro da função Instantiage trocar
zumbiTower.position para transform.position.
}
}
GameObject monster = Instantiate(zumbi, zumbiTower.position, Quaternion.identity) as
GameObject;
Mas isso criaria um bug, o personagem principal seria derrotado toda vez que passar por um tumba,
pois um zumbi surgiria no mesmo local, não dando chance para o player fugir. Uma solução seria
criar um timer, para aguardar um período e após instanciar o zumbi.
Agora, salve o script e volte ao Unity. Selecione a tumba no mapa que você acabou de con�gurar o
script, e arraste o zumbi localizado na pasta prefab:
Agora arraste o GameObject da tumba principal para:
Figura 3.54 - Parâmetro Zumbi 
Fonte: Elaborada pelo autor.
Agora dê Play e veja o resultado.
Agora precisamos abrir a porta quando todas as chaves forem coletadas, quando o jogador
atravessar a porta ele vai para o próximo nível.
Crie uma nova scene no Unity e coloque o nome de “level3”:
Figura 3.55 - Parâmetro ZumbiTower 
Fonte: Elaborada pelo autor.
Abra no Visual Studio, veja o código comentado:
Figura 3.56 - Nova Scene 
Fonte: Elaborada pelo autor.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement; //  gerencia a transição de cenas, bem como elementos
entre elas.
public class Gate : MonoBehaviour
{
public int keysTotal = 5; // chaves totais no mapa.
public int keysCurrent = 0; // chaves totais obtidas.
private bool gate = false; // portão começa fechado.
void OnTriggerEnter2D(Collider2D col) // colisão do personagem com o portão.
{
if (col.name == "zumbi" )
{
OpenGate(); // chama a função que veri�ca se pegamos todas a chaves.
if (gate) // se o portão estiver aberto o personagem vai para a nova fase.
SceneManager.LoadScene( "level3" ); // chama uma nova fase, lembra da nova cena que criamos?
Chamamos ela aqui.
}
}
void OpenGate() // Função que veri�ca se pegamos todas as chaves.
{
if (keysCurrent >= keysTotal)
{
gate = true;
}
}
Salve e volte ao menu do Unity. Precisamos contabilizar as chaves na variável  keysCurrent. Abra o
script das chaves (se você não criou outro, é o mesmo dos pac-dots). Veja o código:
}
Dentro do OnTriggerEnter2D nós adicionamos  GameObject.Find("dungeon").GetComponent<Gate>
().keysCurrent += 1;
using UnityEngine;
using System.Collections;
public class Pacdot : MonoBehaviour
{
void OnTriggerEnter2D (Collider2D col)
{
if (col.name == "zumbi" )
GameObject.Find(" dungeon" ).GetComponent<Gate>().keysCurrent += 1;
Destroy(gameObject);
}
}
Onde:
GameObject.Find(“dungeon”) vai procurar um GameObject dentro da aba hierarchy com o
nome “dungeon”.
GetComponent<Gate>() Dentro do GameObject “dungeon” ele vai pegar o componente
(script) Gate.
keysCurrent += 1 Dentro do script do portão, ele vai acessar a variável e acrescentar 1,
indicando que foi pego 1 chave.
Logo após, vai destruir a chave.
Esse método mostra de maneira rápida como vai funcionar esta função no protótipo, mas para uma
versão aprimorada, o recomendável é criar um script próprio para gerenciar as informações do jogo.
Salve e volte ao Unity. Agora precisamos adicionar o componente box collider no portão e habilitar is
trigger. Após fazerisso, precisamos adicionar outro detalhe. Lembra-se do código dentro do portão:
SceneManager.LoadScene("level3");
Quando o personagem pegar todas as chaves, o portão será aberto, permitindo que o personagem
vá para outro nível. Para isso, precisamos dizer ao Unity quais são os nossos níveis.
Na interface principal do Unity, vá em File>BuildSettings e arraste todas as scenes criadas para
dentro da aba “Scenes In Build”:
Agora, feche esta janela e dê Play no jogo. Quando você capturar as chaves e entrar no portão, um
novo level será aberto. Como duplicamos o level atual, o próximo será idêntico. Você pode criar a
animação de movimento do portão, idêntico à movimentação de personagem. Basta criar um
parâmetro que habilita a animação. Dentro dos arquivos do jogo vai ter o spritesheet dele.
Criamos uma das fases do jogo Pac-Man, testando diversos elementos, logo após, criamos uma fase
inspirada no jogo, mantendo a sua essência. Existem diversos elementos para serem alterados,
navegue na pasta de recursos, fornecida e crie novos levels. Veja no material extra o
desenvolvimento de HUD e faça uma conexão, crie a sua versão inovadora do Pac-Man.
Figura 3.58 - Scenes in Build 
Fonte: Elaborada pelo autor.
praticar
Vamos Praticar
Primeira parte:
Você desenvolveu o protótipo do jogo pac-man, com os moldes da versão clássica. Agora você vai criar um
redesign para um nível do jogo. Crie um GDD, teste em um protótipo de papel e implemente no UNITY.
Alterações sugeridas:
1. Pac-man: A maneira que ele interage com o mapa, as suas habilidades, o que ele pode aprender;
2. Fantasmas: Novos inimigos, novas dinâmicas para os fantasmas;
3. HUD: Imagine uma nova interface, com novas informações;
4. Regras: Altera as regras básicas, nova(s) maneira de ganhar e perder;
5. Labirinto: Pense em um novo cenário para o jogo.
Após �nalizar cada etapa: 1(GDD), 2(Prototipagem em papel) e 3(Unity), poste no fórum da disciplina.
Segunda parte:
Agora você vai criar um documento (GDD), descrevendo os elementos do jogo pac-man, nas seguintes
categorias:
Remake
Reboot
Remaster
Como eles seriam? Poste no fórum.
indicações
Material Complementar
LIVRO
1001 Videogames Para Jogar Antes de Morrer
Nome do Autor
Editora: Sextante / Gmt
ISBN: 9788575429198
Comentário: Guia contendo mais de 1000 páginas sobre os jogos mais
famosos nos últimos 30 anos. Fundamental para conhecer quais jogos
marcaram época, quais foram os pioneiros na inovação, as
contribuições para os principais gêneros dos jogos. Este livro é o guia
perfeito para o redesign de jogos.
FILME
A História do Videogame
Ano: 1983
Comentário: Esse documentário mostra a história do atari até a era 8
bits. Faz um panorama e os desa�os enfrentados pelos desenvolvedores
pioneiros dos jogos digitais. É importante analisar os conceitos e
fundamentos dos jogos da primeira era desta indústria, por que eram
viciantes? Quais jogos atuais utilizam esses conceitos?
Para conhecer mais sobre o �lme, acesse o trailer disponível em:
TRA ILER
FILME
A Era dos Videogames
Ano: 2007
Comentário: Esse documentário mostra como surgiu a indústria dos
videogames, quais impactos ela causou na sociedade. Conta com a
participação de desenvolvedores famosos como Shigeru Miyamoto. Veja
como surgiu zelda, mario e outras lendas dos videogames.
Para conhecer mais sobre o �lme, acesse o trailer disponível em:
TRA ILER
conclusão
Conclusão
Para fazer um bom jogo, você precisa de uma boa ideia ou um bom ponto de partida. Mas, mesmo
tendo uma ideia inovadora, criar um jogo bom baseado nele não é nada fácil. Além do fator sorte, há
muitas coisas para lidar. Um número in�nito de decisões deve ser tomado em um tempo muito
modesto. A�nal, tempo é dinheiro, e o orçamento do projeto tende a desaparecer antes que pelo
menos algo digno de uma demonstração seja feito. Por isso, antes de criar algo, estudar os jogos de
sucesso em cada geração é fundamental, a indústria de jogos utiliza de elementos atemporais para
reciclar as suas ideias. Dominar uma ferramenta leva tempo, é necessário, desde o início, dedicar
algum tempo a estudar a arquitetura do Unity, incluindo objetos de jogo, scripts, cenas, assets,
funções, hierarquia etc. O Unity pode parecer um mecanismo fácil de usar, mas sem um
entendimento básico você pode passar horas intermináveis corrigindo bugs. Aprofundar-se no tema
é fundamental para compreender os conceitos abordados nesta unidade.
referências
Referências Bibliográ�cas
9 Game Klasik yang Kini Muncul di Smartphone! 16 maio 2017. Disponível em: <
http://blog.luna.id/2017/05/game-klasik-kini-di-smartphone/ >. Acesso em: jul. 2019.
BARBOSA, S.; SILVA, B. Interação humano-computador . Rio de Janeiro: Elsevier Brasil, 2010.
BATES, B. Game design . 2. ed. Boston, MA: Premier Press, 2004.
CASTLE GEEK-SKULL. I Love The Duck Hunt Dog More Than Ever Thanks to Smash Bros . 4. 10 jan.
2015. Disponível em: < http://castlegeekskull.blogspot.com/2015/01/I-love-duck-hunt-dog.html >.
Acesso em: jul. 2019.
COMLIMAO.COM. 2017. Disponível em: < http://comlimao.com/wp-content/uploads/2017/07/duck-
hunt-andres-mocayo-redesign-games-8-bits-com-limao.jpg >. Acesso em: jul. 2019.
DOTSON, C. ‘ Pac-Man 256 ’ Review – Teaching an Old Pac-Man New Tricks. 19 ago. 2015. Disponível
em: < https://toucharcade.com/2015/08/19/pac-man-256-review/ >. Acesso em: jul. 2019.
http://blog.luna.id/2017/05/game-klasik-kini-di-smartphone/
http://castlegeekskull.blogspot.com/2015/01/I-love-duck-hunt-dog.html
http://comlimao.com/wp-content/uploads/2017/07/duck-hunt-andres-mocayo-redesign-games-8-bits-com-limao.jpg
https://toucharcade.com/2015/08/19/pac-man-256-review/
LÖBACH, B. Design Industrial : bases para a con�guração dos produtos industriais. São Paulo:
Edgard Blücher, 2001.
MONTEIRO, R. Conheça as diferenças entre remaster, remake e retrocompatibilidade . 27 nov.
2016. Disponível em: < https://tinyurl.com/y7trempb >. Acesso em: 13 jul. 2019.
ORIGINAL. [201-]. Disponível em: < https://i.imgur.com/rOYPlMM.jpg >. Acesso em: jul. 2019.
PEREZ, D. Pac-Man Imagined As A First-Person Shooter Will Give You Nightmares . 27 jun. 2013.
Disponível em: < https://www.ubergizmo.com/2013/06/pac-man-imagined-as-a-�rst-person-shooter-
will-give-you-nightmares/ >. Acesso em: jul. 2019.
RESIDENT Evil 2 Remake cover art. 12 jun. 2018. Disponível em: < https://sad-dog-of-
shimano.tumblr.com/post/174809885843/resident-evil-2-remake-cover-art >. Acesso em: jul. 2019.
ULLMAN, D. G. The mechanical design process . 4. ed. Boston, MA: McGraw-Hill, 2010.
XIMENES, M.; MALCHER, L. M. F.; CAMPOS, A. N. F. Redesign de jogos clássicos. In: BRAZILIAN
SYMPOSIUM OF GAMES AND DIGITAL ENTERTAINMENT, VII, Belo Horizonte. Proceedings… Belo
Horizonte: SBGames, 2008. Disponível em: < https://tinyurl.com/y9wlqmnu >. Acesso em: 18 jul.
2019.
IMPRIMIR
https://tinyurl.com/y7trempb
https://i.imgur.com/rOYPlMM.jpg
https://www.ubergizmo.com/2013/06/pac-man-imagined-as-a-first-person-shooter-will-give-you-nightmares/
https://sad-dog-of-shimano.tumblr.com/post/174809885843/resident-evil-2-remake-cover-art
https://tinyurl.com/y9wlqmnu