unidade 4

Prévia do material em texto

09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 1/66
DESENVOLVIMENTO DE JOGOSDESENVOLVIMENTO DE JOGOS
PARA WEBPARA WEB
DESENVOLVIMENTO DEDESENVOLVIMENTO DE
JOGOS PARA WEB:JOGOS PARA WEB:
FINALIZANDO E POLINDOFINALIZANDO E POLINDO
Autor: Diego Escobar
R e v i s o r : D e i v i t h C u n h a
I N I C I A R
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 2/66
introduçãoIntrodução
Os dispositivos mobile são um dos maiores mercados quando falamos de
desenvolvimento de jogos. Entre todas as plataformas, os jogos para mobile são o
mercado mais lucrativo. Entretanto, nem tudo é fácil neste mercado. Para desenvolver
um software para esta plataforma, devemos sempre nos lembrar que, ao contrário dos
computadores de mesa, os PCs e os smartphones têm processamento e memória muito
limitados quando fazemos esta comparação. De todas as plataformas, são as que mais
precisamos contar os bits e fazer de tudo para economizar, ao máximo, o espaço e a
memória de processamento.
Utilizando a Unity, temos uma vantagem: podemos modular todo o projeto e fazer estes
módulos �carem mais leves. Em outras palavras, podemos fazer o produto �nal �car
mais fácil de ser executado em uma plataforma onde precisamos nos atentar com o
desperdício de memória.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 3/66
Animar o personagem principal é uma parte muito importante e essencial para um jogo,
a�nal ele é quem nos levará pela aventura.
O avatar nós já temos, ele vem em partes. Dessa forma, �ca mais simples de serem
animados. Para isso, devemos abrir a tela de animação. A Figura 4.1 mostra o caminho:
Window> Anima�on> Anima�on que leva a uma nova aba. Esta nova aba “Anima�on”
�cará solta na tela da Unity. Podemos arrastá-la para baixo e deixar ao lado da pasta
projetos.
Personagem:Personagem:
Animação 2DAnimação 2D
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 4/66
Vamos então criar uma nova animação para o personagem. Selecione o personagem na
aba “Hierarchy”. Depois, selecione a aba “Anima�on” e veremos que existe um botão
chamado “create” ao lado direito da tela. A �gura 4.2 mostra um exemplo:
Clicando no botão “create”, uma nova tela se abrirá. Nela, devemos escolher o caminho
da pasta onde vamos salvar a animação que estamos criando.
Figura 4.1 - Print Animation Caminho 
Fonte: Elaborada pelo autor.
Figura 4.2 - Print Animation aba 
Fonte: Elaborada pelo autor.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 5/66
Para isso, podemos criar uma nova pasta e dar o nome de “Pasta_Player”. Dentro dela,
guardaremos as animações que criaremos para o personagem. Daremos o nome desta
primeira animação de “Idle”, que, em português, signi�ca ocioso. Esta será a animação do
personagem parado, esperando que o jogador lhe dê algum comando, atacar, andar, ou
pular. Porém, é claro que, para isso, precisamos ainda criar todas estas outras
animações.
Para fazer a animação, é bem simples. Veja, na Figura 4.3, onde temos a aba “Anima�on”
pronta, como darmos início à criação de uma animação. Entretanto, antes de começar
este processo, vamos conhecer os controles da aba:
Preview: Este campo é ativado no momento que acionamos o play. Caso já
exista uma animação, ela será pré-visualização. O personagem �cará em
posição quando o play não estiver acionado, e se moverá quando acionado.
Record: Este botão é icônico. Ele é muito conhecido, mas, para quem não o
conhece, ele ativa a gravação. Nesse caso, a gravação da animação do
personagem.
Go to Beginning: Ele volta para o início do tempo de animação.
Go to Previous: Volta para o keyframe anterior ao atual.
Play: Executa a animação.
Go to Next: Vai para o próximo keyframe.
Go to End:  Vai para o último keyframe.
Timer: Mostrador numérico que informa onde o ponteiro da animação está.
Nome da Animação: O campo abaixo do “Preview” é onde está mostrando o
nome da animação e é onde podemos clicar para criar uma nova animação.
Samples: É um mostrador numérico que informa a distância entre os
keyframes. Podemos desacelerar ou acelerar a animação alterando este
número.
Add keyframe: Clicando nele, poderá adicionar um novo keyframe de um ou
mais objetos selecionados que compõem o player, como podemos ver na
Figura 4.4. Cada keyframe é responsável por indicar em qual ponto da
animação será a posição, escala e rotação de determinados objetos, ou seja, é
um ponto presente na linha do tempo (Timeline) da animação. Sua função é
armazenar informações sobre o posicionamento de objetos que compõem a
animação. Perceba que, de um keyframe para o outro, existe uma lacuna de
movimento, onde um keyframe está em uma posição, escala e ou rotação de
uma forma, e o próximo está com posição, escala e ou rotação com outros
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 6/66
valores. É aqui que a Unity faz sua mágica, não precisamos montar a animação
quadro a quadro, pois esta lacuna será preenchida pela Unity.
Add event: Este evento está relacionado com os Scripts atrelados ao player.
Podemos adicionar um método a ele e, no momento que for acionado o
método, será acionado.
As keyframes são os pequenos losangos que vão aparecer na linha do tempo da
animação assim que iniciarmos a troca de posição das partes do corpo na Scene:
Podemos ver, na Figura 4.3, o processo de se criar uma animação. Precisamos acionar o
botão de gravar, o “Record” e mover a barra de tempo além do zero, para que, quando as
partes do corpo do personagem forem movimentadas, este movimento tenha um
intervalo de tempo do início do até o �nal.
Este intervalo pode ser aumentado após a conclusão da animação. Para isso, clique no
keyframe desejado e arraste-o para frente ou para trás, dentro do intervalo de tempo
que pode ser visto acima dos keyframes.
Lembre-se de garantir que o personagem está encostado no chão, ou seja, que o limite
do componente collider do pé do personagem está em aparente contato com o collider
dos tiles abaixo de seus pés. Para garantir isso, após mover o personagem, segure a tecla
Figura 4.3 - Print Animation Início 
Fonte: Elaborada pelo autor.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 7/66
“Shift” do teclado e clique no objeto player e no objeto grid, assim ambos mostrarão
seus colliders e poderá veri�car isso.
Atenção, ao selecionar mais de um objeto, não os movimente dessa forma, pois assim
moverá os dois objetos ao mesmo tempo.
Podemos ver na Figura 4.4 a animação de ataque. Devemos selecionar o objeto que
gostaríamos de mover, rotacionar e movê-lo para onde desejamos. A Unity fará o resto,
se achar que, de um keyframe para o outro, caberia mais um keyframe para fazer com que
a animação �que mais suave. Pode simplesmente clicar entre os keyframes que
desejamos re�nar e, com o botão “Record” ligado, podemos clicar no botão “Add
keyframe”, e este novo keyframe será adicionado à linha de tempo da animação no local
que foi selecionado anteriormente.
Uma dica: em quase todos os movimentos que serão executados em “loop”, podemos
fazer a animação para frente e, então, uma a uma �leira de keyframes pode selecioná-la e
usar o (Ctrl + C) e (Ctrl + V) para vir fazendo o movimento inverso da ação.
Por exemplo, a animação de andar. Podemos mover a perna do personagem da esquerda
para a direita e, em sequência, fazer o movimento inverso com a outra perna e depois
colocar esta animação em “loop”. Pronto! A animação de andar estará concluída.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 8/66
Esta parte da animação é uma coisa muitopessoal, mas faça testes e veja qual a melhor
sequência de posições que lhe agrada mais. Vá criando as animações desejadas, mas, ao
mesmo tempo, crie as que comentamos anteriormente, pois vamos usá-las mais à
frente.
Para fazer uma animação ser executada em “loop”, precisamos acionar esta opção
diretamente no arquivo da animação; portanto, vá até a pasta que escolheu para
guardar a animação no momento em que ela foi criada. Ao selecionar o arquivo da
animação, veja na aba “Inspector” quais informações sobre o arquivo apareceram. Uma
das primeiras informações que estarão dispostas no “Inspector” será um campo que
pode ser selecionado chamado “loop”. Marque este campo para as animações que
deseja que �quem com o funcionamento em   “loop”, ou seja, as que desejamos que
�quem repetindo enquanto estamos segurando o botão do teclado ou na tela do celular.
Animações como atacar ou pular não queremos que �quem em  “loop”, pois queremos
que elas sejam executadas uma vez a cada disparo da animação. Por exemplo, imagine
que apertou o botão para o personagem pular de uma plataforma para outra. Ao clicar o
botão, o personagem faz algum tipo de movimento, digamos que ascendente, como se
estivesse pegando impulso e, no �m deste movimento, dá um soco no ar. Caso o “loop”
esteja marcado, até que a animação seja �nalizada por algum motivo, o personagem
�cará repetindo todo este movimento, mesmo que ainda esteja no ar.
Bom após �nalizar todas as animações, devemos explicar para a Unity de alguma forma,
em qual ordem ou sequência essas animações devem ser executadas.
Para que possamos �nalizar o processo de animação, precisamos ajustar mais uma parte
deste procedimento, como o ciclo de animação na aba “Animator”, que pode ser
encontrada neste caminho   Window> Anima�on> Animator. A Figura 4.5 traz um
exemplo de como deve �car a sequência de ações a serem animadas:
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 9/66
Veja que a sequência da animação está montada e age como um sistema redundante,
onde partimos do estado(State) verde “Entry”, que é a execução do jogo. O primeiro
estado de animação é o estado em amarelo “Idle”. Em volta, os outros possíveis estados,
como: andar, pular, cair e atacar, tudo isso �ca no “Base Layer”, que é a camada criada de
forma padrão quando criamos a animação.
Perceba que, ao selecionar o personagem e abrir esta aba, todas as animações que
forem criadas através do uso de um determinado objeto, são incluídas na “Base Layer”.
Porém, caso tenha alguma que deseja adicionar, pode  incluir uma nova animação.
Para fazê-las funcionar da maneira que desejamos, precisamos criar alguns parâmetros,
mas antes vamos aprender como esta aba funciona.
Veja que do lado esquerdo da tela exibida na Figura 4.5, abaixo do nome da aba, temos o
“Parameters”, onde podemos criar quatro tipos de variáveis que podemos usar para
controlar quando determinada animação deve ser executada. No sinal de (+), ao clicar,
os tipos de variáveis apareceram na seguinte sequência: �oat, int, bool e trigger; já
sabemos o que cada uma delas faz, mas vamos entender melhor seu funcionamento
especí�co a seguir:
Float: Podemos escolher um determinado valor de número �oat(real) e, ao
atingir determinado valor ou não atingir, executamos a animação.
Figura 4.5 - Print Animator 
Fonte: Elaborada pelo autor.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 10/66
Int: Podemos escolher um determinado valor de número int(inteiro) e, ao
atingir determinado valor ou não atingir, executamos a animação.
Bool: Aqui só podemos ter os valores de verdadeiro ou falso e da mesma
forma executar a animação.
Trigger: Este valor informa que a animação será disparada.
Bom, quando escolhemos que tipo de parâmetro criar, podemos dar um nome ao mesmo
e, caso deseje deletar um deles, basta clicar com o botão direito do mouse sobre seu
nome e escolher delete.
Perceba que, na Figura 4.5, todos os parâmetros são do tipo booleano. Podemos ver
que, depois dos nomes dos parâmetros, tem uma caixa que permite deixar o parâmetro
marcado. Nesse caso, marcado é verdadeiro, e desmarcado é falso.
Com o estado(Idle) selecionado, podemos ver suas con�gurações na aba “Inspector”,
além das transições(Transitions). O que está demonstrado na Figura 4.6 é o padrão na
criação de um estado:
Em sequência, podemos ver na Figura 4.7, na aba “Inspector”, as opções de con�guração
de uma transição(Transition) que leva à animação do estado(Idle) para o estado(Jump).
As transições são a parte que faz a máquina de estados se comunicar, ou seja, faz um
estado passar para outro.
Figura 4.6 - Print Animator Inspector do Estado 
Fonte: Elaborada pelo autor.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 11/66
A Figura 4.7 mostra uma maneira básica de con�guração de como parametrizar a
passagem de um estado para o outro. Vendo as con�gurações que aparecem na aba
“Inspector”, podemos ver que existem algumas boas parametrizações que podemos
fazer para tentar garantir que a animação a ser executada é a animação que desejamos.
Podemos usar a transição de maneira “solo”, ou mutar todos os outros estados da
máquina. Podemos marcar o campo “Has Exit Time” e decidir um tempo mínimo para
acabar a animação até que ela possa ser trocada. Quando marcamos este campo,
habilitamos o campo dentro da área de con�gurações(Settings).
Vejamos os campos de con�gurações a seguir:
Exit Time: Só temos acesso quando o campo “Has Exit Time” está marcado.
Então, podemos marcar o tempo de saída do estado. Em um exemplo, podemos
colocar o número 0.5. Isso vai signi�car que, quando a animação estiver em
50%, na contagem do primeiro frame, este valor seja verdadeiro. Neste ponto,
a animação terá seu tempo de saída alcançado, sendo assim será �nalizada.
Fixed Dura�on: Mantendo este campo marcado, teremos um tempo de
duração para a execução do estado interpretada em segundos. Caso contrário,
a execução será marcada com um valor estipulado pela Unity, que é
basicamente o tempo de processamento do estado.
Transi�on Dura�on: É o valor que será usado para informar a duração da
transição.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 12/66
Transi�on Offset: É usado para posicionar a transição dentro de seu próprio
tempo. Por exemplo, podemos informar o valor de 0.5 e ver que a transação
terá início na marca de 50% da animação.
Interrup�on Source: Aqui podemos informar se desejamos permitir algum
tipo de interrupção por outro estado. Podemos dizer que, caso determinados
parâmetros sejam atendidos, o estado atual é interrompido.
Ordered Interrup�on: Determina quando este estado pode ser interrompido
por outro estado, não importando sua ordem. Este campo só �ca acessível
quando o campo “Interrup�on Source” estiver marcado.
O próximo item que aparece é um mostrador que representa a transição que está
selecionada e, por �m, podemos adicionar condições (Conditions) para esta transição
funcionar, ou seja, podemos usar os parâmetros que criamos para informar, através do
código, se o parâmetro é verdadeiro ou falso, habilitando assim a determinada
transação a ser comprida. Nesse caso, poder sair do estado(Idle) e executar o estado
(Jump).
Veja que no exemplo da Figura 4.7, temos apenas uma condição e a mesma se refere ao
parâmetro “IsJumping” que é verdadeiro. Dessa forma, pode ser feita a transição entre o
estado(Idle) e o estado(Jump). Perceba também a necessidade de adicionar novos
parâmetros, através do sinal(+) e retirar um parâmetro selecionado clicando no sinal(-).
Assim, podemos exigir que mais condições sejam consideradas antes de permitir que a
animação seja executada.
Após a criação das animações será necessário ajustar as transições entre as animações,
como vemos na Figura 4.7.
Selecioneo estado de onde deseja que a transição seja originada. Clique com o botão
direito do mouse este estado. Uma caixa de opções surgirá, com a opção fazer
transição(Make Transition). Escolha esta opção.
Deve-se notar três coisas: caso clique com o botão direito um estado que não foi
anteriormente selecionado, outras caixa de opções surgirá. Ela é usada para criar novos
estados. A segunda é, para identi�car se o estado está selecionado, veja se o mesmo está
com a borda azul. A terceira é a seta que direciona de onde a transição deve partir. Ela
sempre aponta contra o estado selecionado.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 13/66
Veja aqui o exemplo de como �caram as con�gurações de transição entre os estados da
máquina de estados da animação. Vamos falar dos campos que forem alterados, e os
campos que não serão alterados �carão como o modelo padrão que a Unity gera com a
criação da transição.
Exemplo de Transições:
Idle > walk: Desmarque o campo “Has Exit Time”, marque o campo “Fixed
Dura�on” e “Transi�on Dura�on” = 0.1. Por �m, adicione uma
condição(Conditions), “IsWalkling” = true.
walk > Idle: Desmarque o campo “Has Exit Time”, marque o campo “Fixed
Dura�on” e “Transi�on Dura�on” = 0.1. Por �m, adicione uma
condição(Conditions),  “IsWalkling” = false e “Idle_Sword” = true.
Idle > jump: Desmarque o campo “Has Exit Time”, marque o campo “Fixed
Dura�on” e “Transi�on Dura�on” = 0.1. Por �m, adicione uma
condição(Conditions), “IsJumping” = true.
jump > Idle: Desmarque o campo “Has Exit Time”, marque o campo “Fixed
Dura�on” e “Transi�on Dura�on” = 0.05. Por �m, adicione uma
condição(Conditions), “IsJumping” = false, “IsWalkling” = false, “Idle_Sword” =
true.
Idle > A�ack: Desmarque o campo “Has Exit Time”, marque o campo “Fixed
Dura�on” e “Transi�on Dura�on” = 0.05. Por �m, adicione uma
condição(Conditions), “IsA�acking” = true, “IsWalkling” = false, “IsOnGround”
= true,  “IsFalling” = false.
A�ack > Idle: Desmarque o campo “Has Exit Time”, marque o campo “Fixed
Dura�on” e “Transi�on Dura�on” = 0. Por �m, adicione uma
condição(Conditions), “IsA�acking” = false, “IsWalkling” = false, “IsJumping” =
false, “IsFalling” = false.
Idle > fall:   Desmarque o campo “Has Exit Time”, marque o campo “Fixed
Dura�on” e “Transi�on Dura�on” = 0. Por �m, adicione uma
condição(Conditions), “IsFalling” = true, “IsJumping” = false, “IsOnGround” =
false.
fall > Idle: Desmarque o campo “Has Exit Time”, marque o campo “Fixed
Dura�on” e “Transi�on Dura�on” = 0. Por �m, adicione uma
condição(Conditions), “IsWalkling” = false, “IsFalling” = false.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 14/66
Até, aqui temos as transições do estado “Idle” para os estados “walk”, “jump”, “A�ack”,
“fall”, e as transações de retorno destes estados para o estado “Idle”. Vejamos agora as
transições entre os estados  “walk”, “jump”, “Attack”, “fall”.
walk > jump: Desmarque o campo “Has Exit Time”, marque o campo “Fixed
Dura�on” e “Transi�on Dura�on” = 0.1. Por �m, adicione uma
condição(Conditions),“IsJumping” = true.
jump > walk: Desmarque o campo “Has Exit Time”, marque o campo “Fixed
Dura�on” e “Transi�on Dura�on” = 0.05. Por �m, adicione uma
condição(Conditions), “IsJumping” = false,  “IsWalkling” = true.
walk > fall: Desmarque o campo “Has Exit Time”, marque o campo “Fixed
Dura�on” e “Transi�on Dura�on” = 0. Por �m, adicione uma
condição(Conditions), “IsJumping” = false, “IsFalling” = true, “IsOnGround” =
false.
fall > walk: Desmarque o campo “Has Exit Time”, marque o campo “Fixed
Dura�on” e “Transi�on Dura�on” = 0. Por �m, adicione uma
condição(Conditions),“IsFalling” = false, “IsWalking” = true.
As transições entre “A�ack”, “fall” e “walk” são apenas exemplos. Não vamos utilizá-las
neste projeto.
Personagem: Ataque
Antes de passarmos ao código, vamos criar o sistema de ataque do player. Para isso,
devemos adicionar um novo objeto vazio como “child” do objeto “Player”. Dê o nome
deste objeto de “ATK”. Ele será usado para determinar o ponto de interação do ataque
com o inimigo que estiver no mesmo ponto. Isso evitará que ataquemos um inimigo que
esteja fora do alcance do player.
Este código já foi criado anteriormente. É o “Script” “PlayerMove”. Ele é usado para
mover o personagem. Nesse novo código, podemos ver algumas alterações que são
relacionadas à atuação do código junto aos parâmetros são usados para validar as
transições da máquina de estados que controlam as animações. Assim, temos as
questões do ataque do player.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 15/66
Substitua seu código antigo por esse novo código e veja as diferenças que ele causará
em seu jogo. Atente-se às novas necessidades que surgirão na aba “Inspector”.
Essas necessidades são as variáveis: “Dano”, “ATK_Timer”, “ATK Pos”, “Tipo Inimigo”,
“Range ATK”.
Vamos falar do código e ver o que tem de diferente que ainda não foi abordado:
[DefaultExecu�onOrder(-100)]: Cria uma ordem de execução no processo
criado dentro da classe onde este código se encontra.
private Animator Anim: Objeto usado para inserir valores nas variáveis que
criamos dentro da Unity na aba “Animator”. Dessa forma, podemos alterar de
verdadeiro ou falso os parâmetros que fazem as mudanças de animação
funcionarem.
public float dano = 10: Variável usada para determinar a quantidade de dano
que o player vai inferir ao inimigo.
public float ATK_Timer = 0.5f: Variável usada para determinar intervalo de
tempo entre os ataques do player, ou seja, o player não poderá realizar o
próximo ataque antes que este tempo passe.
public Transform ATKPos: Esta variável receberá na aba “Inspector” o novo
objeto vazio que criamos anteriormente o objeto “ATK”.
public LayerMask �poInimigos: Máscara criada para determinar a quem o
player poderá atacar. A “LayerMask” exibirá uma lista na aba “Inspector” para
que possamos selecionar a “Layer” do inimigo.
public float rangeATK: Esta variável será usada para determinar o alcance da
área do ataque do player, ou seja, todo inimigo que estiver dentro desta área
receberá dano do ataque do player.
Anim = GetComponent<Animator>(): Inicia a variável “Anim”, através da
indicação do componente “Animator” que está atrelado ao player.
rig2D = GetComponent<Rigidbody2D>(): Inicia a variável “rig2D”, através da
indicação do componente “Rigidbody2D” que está atrelado ao player.
private void OnDrawGizmosSelected(): Este método vai gerenciar a criação
do campo onde o player poderá inferir o dano de seu golpe em um inimigo. O
Gizmo é usado para criar um adereço visual no momento da depuração ou
con�guração. O mesmo é exibido de Scene.
Gizmos.color = Color.red: Informamos nesta linha a cor que queremos que a
área do ataque tenha, lembrando que esta área só será vista na aba “Scene”.      
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 16/66
 
Gizmos.DrawWireSphere(ATKPos.posi�on, rangeATK): Para criar a esfera na
tela, precisamos de dois valores, a primeira é a posição onde ela �cará na tela.
A outra é o raio da esfera. Estes valores são informados pelas variáveis
“ATKPos” = posição e “rangeATK” = raio.
if (Anim.GetBool("IsAtacking")) { moveHorizontal = 0; }: Veja nesta linha de
código que criamos uma condição via código para que o personagem possa se
mover dentro do jogo. Nesse caso, queremos que o personagem se mova
somente quando não estiver atacando, ou seja, somente parado o personagem
pode atacar. Caso o mesmo esteja em movimento, o ataque irá prevalecer ao
movimento, e o personagem para de andar para atacar e também, quando
estiver atacando, ele, antes de poder andar, o ataque precisa ser �nalizado.
Collider2D[] inimigos = Physics2D.OverlapCircleAll(ATKPos.posi�on,
rangeATK, �poInimigos): Cria uma lista de colliders com o nome inimigo. Esta
lista é preenchidacom todos os inimigos que causarem uma sobreposição de
seus colliders a área de ataque do player. Para criar essas ocorrências de
sobreposição, precisamos de três valores, “ATKPos” = posição da área de
ataque, “rangeATK” = o valor que de�ne o tamanho da área e “�poInimigos” =
a máscara que de�ne que tipo de objeto pode ser atacado.  
Debug.Log("inimigos.Length " + inimigos[i].name): Este código é usado para
que possamos veri�car. Enquanto o jogo está rodando, a sobreposição
ocorrendo, no momento que algum inimigo estiver dentro do campo, quando o
jogador pressionar o botão de ataque, esta linha vai mostrar no console as
informações correspondentes ao inimigo que estiver dentro do alcance.
Lembre-se de que as informações geradas pelo “Debug” são informações que
serão geradas para análise do funcionamento do jogo e não serão exibidas no
jogo em si.
inimigos[i].GetComponent<Inimigo>().setVida(dano): Este é o código usado
para usar o método setVida que está dentro do Script “Inimigo”. Veja que, para
usar este método, precisamos informar um valor. Este valor é a variável do
dano que criamos dentro do Script do player.
if (collision.tag == "Plataforma"): Gerencia se o player está no chão, ou seja, se
o collider do player está colidindo com o tile que o player deve �car sobre,
quando não está pulando.
if ((moveSpeed != 0) && !Anim.GetBool("IsJumping") &&
!Anim.GetBool("IsFalling") && Anim.GetBool("IsOnGround")): Este “If” é
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 17/66
usado para analisar se existe um valor de movimento diferente de zero; se o
pulo é falso; se caindo, é falso; e se a colisão com o chão é verdadeira. Caso
tudo isso seja atendido, a animação que faz o player andar pode ser executada.
else if (moveSpeed == 0 && !Anim.GetBool("IsJumping") &&
!Anim.GetBool("IsFalling") && Anim.GetBool("IsOnGround")): Este “else If”
exige que a variável “moveSpeed” seja igual a zero; que o pulo seja falso; que
caindo seja falso; e que a colisão com o chão seja verdadeira. Caso tudo isso
seja atendido, o player não está andando e está parado. Sendo assim, pode ser
executada a animação do “Idle”.
Vemos na Figura 4.7 que os nomes dos parâmetros que aparecem na mesma, são os
mesmos que aparecem no código. Sendo assim, podemos ver que, para o acesso a esses
parâmetros, precisamos garantir a paridade dos indicadores que, nesse caso, são os
nomes, ou seja, os mesmos nomes usados para identi�car os parâmetros dentro da Unity
devem ser usados no código.
Veja na Figura 4.8 um exemplo do posicionamento da área de ataque do player, e tenha
uma ideia do tamanho que ela deve ter, lembre-se que isso será de�nido segundo o seu
game design.
Verá mais à frente que a distância de ataque do inimigo deve ser compatível ao tamanho
da área de ataque do player, mas, novamente, isso é in�uenciado pelo seu game design.
Muitas vezes, fazemos um game design e não �ca muito bom ao ser implementado. Esse
tipo de detalhe pode ser melhor percebido no momento em que o jogo está sendo
programado.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 18/66
Comece criando a animação de caminhar, pular, atacar e continue com as outras. Caso
não queira usar uma das mencionadas, será necessário comentar ou remover algumas
das linhas que trazem a utilização desses parâmetros. Um exemplo seria este código,
“Anim.SetBool("IsJumping", false)”.
Perceba que esta parte é um pouco complexa, pois caso as parametrizações �quem
erradas, o funcionamento de troca entre as  animações �cará confuso, e o personagem
não terá um bom resultado entre suas animações.
O melhor que temos a fazer é modelar essas mudanças de animação de forma que o
código no C# e as transições dentro do “Animator” �quem em harmonia. Para isso, o
ideal é fazer uma transição por vez, testar o resultado e passar para a próxima transição.
A cada nova transição, o ideal é que teste as outras para garantir que uma não está
interferindo na outra.
Os parâmetros que são usados dentro da aba “Animator” e as transações devem estar
bem claras. Muitas vezes, criar vários parâmetros para de�nir a troca entre as
animações acaba causando muita confusão. Em muitos casos, o problema pode estar em
seu código.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 19/66
praticarVamos Praticar
Para fazer uma animação, precisamos gravar os movimentos de um determinado personagem
ou objeto. Para isso, a Unity disponibiliza um sistema que auxilia o desenvolvedor e facilita este
processo. No �nal, temos um arquivo que agrupa todas as mudanças que a animação precisa
para ser executada. Nesse sentido, assinale a alternativa que apresente o nome da aba usada
para fazer a animação de um GameObject na Unity.
a) KeyFrame.
b) Animator.
c) Canvas.
d) TimeLine.
e) Animation.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 20/66
Como já aprendemos a montar o personagem e a animá-lo, podemos repetir este
mesmo processo para criar e animar qualquer outra forma que deseje dentro do jogo. O
inimigo é uma delas.
Na pasta: “Assets/Tasty_Characters - Castle Pack/Assets/textures/PackCastle01.png”,
podemos achar a imagem que contém os pedaços de soldados. Podemos escolher qual
desses soldados será nosso inimigo, ou mesmo criar vários inimigos com base nesses
soldados. Lembre-se de criar uma nova “Layer” e “Tag” para o objeto “Inimigo”.
Só lembrando que “Layer” é a camada onde o objeto �cará na ordem do render.
Podemos imaginar essa ordem usando uma pilha de pratos. Os pratos mais altos na pilha
serão os últimos a serem renderizados, pois eles serão renderizados por cima dos
outros.  
A “Tag” é simplesmente o identi�cador, o nome do objeto.
Uma destas imagens será usada para criar nosso rei que dentro em breve entrará no
jogo.
Veja na Figura 4.9 o resultado que esperamos para um possível inimigo: 
Construindo eConstruindo e
Parametrizando oParametrizando o
InimigoInimigo
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 21/66
Podemos ver na Figura 4.9 que o personagem está usando 3 colliders, e o inimigo apenas
dois. O collider que está no pé do personagem é um trigger. Este collider é usado para
acionar os triggers, como o da porta e vários outros como o de pulo.
Veja na Figura 4.10 que os colliders do player e do inimigo, que são usados para colidirem
com o chão, colidem-se entre eles e criam este problema que vemos na Figura 4.10. Será
necessário fazer esta colisão entre eles acabar. 
Figura 4.9 - Print Inimigo 
Fonte: Elaborada pelo autor.
Figura 4.10 - Print Problema collider 
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 22/66
Para corrigir este problema, existe uma solução simples, mas, dessa forma, abriremos
mão da colisão entre o personagem e o inimigo, ou seja, eles vão passar um dentro do
outro, uma coisa muito comum em vários outros jogos 2D. Como neste jogo isso não é
necessário, podemos usar esta solução que fará o collider do player passar direto pelo
collider do inimigo. Para isso, devemos seguir este caminho: Edit> Project Se�ngs>
Physiscs 2D, chegar até a tela de con�gurações da física do jogo. A Figura 4.11 traz um
exemplo da mesma. 
Desmarque na “Layer Collision Matrix” o campo que encontra as duas Layer desejadas.
Nesse caso, o player e o Inimigo. A Figura 4.11 traz um exemplo: 
g
Fonte: Elaborada pelo autor.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 23/66
Como já �zemos a animação de ataque do personagem, vamos pensar em como fazer a
animação de andar do inimigo. Para que o inimigo possa andar, podemos fazer um
sistema de animação simples. Basta fazera transição das pernas de um lado para o
outro, ou seja, devemos arrastar a perna da direita para a posição da perna da esquerda
e depois repetir o processo com a perna da esquerda indo para a posição da perna da
direita. Por �m, copie os primeiros “keyframe” da animação e cole-os no �m na linha de
tempo da animação, deixando uma distância de tempo igual entre as três colunas de
“keyframe”.
Lembre-se sempre de ativar o botão “Record” para que sua animação seja gravada. Caso
contrário, terá que repetir todo o processo que acabou de fazer.
Como cada animação deve ser feita levando em consideração os resultados visuais que
desejamos ter e seu processo é basicamente igual, só mudando as partes do
personagem de posição em uma ordem que seja minimamente coerente. Antes de
continuar, �nalize as animações restantes, para que o inimigo possa andar e atacar.
Por �m, para que o inimigo possa se mover pelo jogo e consiga perceber o personagem e
atacá-lo, precisamos de um sistema que perceba que o player está em seu campo de
visão e quando está em seu campo de ataque.
Para criar este mecanismo, uma das opções mais simples de ser usada é a técnica do
“raycast” e para que tudo dentro do código do personagem possa �car organizado,
Figura 4.11 - Print Con�guração Física 
Fonte: Elaborada pelo autor.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 24/66
vamos introduzir uma outra técnica, a máquina de estados. 
Raycast: O ray tracer é apenas um raio que tem um determinado
comprimento. Ele vai do ponto A ao ponto B e colide com o collider que estiver
atrelado a um objeto. Sendo assim, devemos dizer em qual collider o ray tracer
precisa colidir. Nesse caso, no collider do player.
Máquina de Estados: A máquina de estados é uma maneira de de�nirmos uma
ordem na execução do código. Em cada “case” desta máquina, devemos
colocar o código que desejamos executar. Dessa forma, �ca mais simples para
organizar o código e, com isso, os movimentos dos NPCs �caram mais �uidos.
Usa-se muito a máquina de estados para criar IAs de maneira simples para
jogos em geral. 
Vamos comentar o código:
public Transform ray: Esta variável armazena o ponto onde o raio terá seu
início. Dessa forma, podemos mover o raio para a melhor posição através da
movimentação de um objeto na aba Scene. Com isso, vemos que será
necessária a criação de um novo objeto vazio como “child” do objeto Inimigo.
private int state = 0: Variável usada para determinar em qual estado a
máquina de estados está no momento. Perceba que ao criar esta variável, já
iniciamos a mesma com o valor zero. Dessa forma, iniciamos a máquina de
estados.
private bool Dir = true: Variável usada para determinar a direção que o
inimigo está se movendo, ou seja, quando verdadeira, está se movendo direita,
e quando falso para a esquerda.
public float mostrador: Esta variável mostra o tempo que o personagem tem
para se mover para determinado lado. A mesma é usada somente para mostrar
o tempo restante na aba “Inspector”.
public bool Direc�on: Esta variável é usada para mostrar a direção que o
inimigo está se movendo. Quando verdadeiro, está se movendo para um lado,
e quando falso está se movendo para o outro lado.
private float tempoPatrulha = 3f: Este valor é o tempo que o inimigo tem para
mudar a direção em sua patrulha. Anda três segundos para um lado e depois
outros três segundos para o outro. Esta variável �ca na espera quando o
inimigo está perseguindo o jogador.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 25/66
private float �mer = 0: Esta é a variável responsável por contar o tempo, ou
seja, ela acumula o tempo e, quando chega nos 3 segundos, ela é zerada para
voltar a contar o tempo.
private bool goTo = false: Esta variável é a que determina a movimentação do
inimigo. Quando o tempo, chega no valor desejado esta variável muda de
verdadeiro para falso e vice-versa.
private bool alcance = false: Esta variável é acionada quando o ray tracer que
usamos para perceber se o jogador está na visão do inimigo colide com o
colisor do player. Dessa forma, acionar outros mecanismos no código, como a
máquina de estado e a mudança do comportamento do inimigo de ronda para
perseguição.
public float dist_ATK: Esta variável determina a distância mínima do ray tracer
que usamos para o ataque.
private Animator Anim: Esta variável é usada para controlar a troca de
animações do inimigo.
public float vida = 100: Armazena a quantidade de vida que o inimigo tem.
public GameObject efeitoHit: Usada na aba “Inspector” para que possamos
atrelar o efeito de partículas ao inimigo.
public GameObject Esmeralda: Usada na aba “Inspector” para que possamos
atrelar o objeto esmeralda ao inimigo. Com esta referência, podemos criar
esmeraldas no local onde o inimigo foi destruído, como um “drop”.
Drop: Esta palavra é usada para simbolizar a ação de soltar um item quando o
inimigo é retirado da cena, sua tradução é “soltar”.
setVida(): Este método é usado para gerenciar a entrada de dano no inimigo.
Ele executa os efeitos de partículas e, quando a vida do inimigo acaba, ele
executa o efeito de drop dos itens.
switch (state): O switch é uma estrutura de camadas. Ela é ótima para criar a
máquina de estados, onde apenas uma de suas “case” podem ser executadas
por vez. Para escolher qual “case” será executada, usamos a variável “state”.
Enquanto a variável “state” mantiver o determinado valor, o mesmo estado
continuará sua execução.  
Timer(): Método que gerencia a troca de tempo. Enquanto a variável “�mer”
não atingir o valor desejado, ela acumula o tempo para que o “�mer” possa
mudar a direção na qual o inimigo está andando. Para isso, ele troca o valor da
variável “goTo”.
Move(): Método que gerencia a movimentação do inimigo.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 26/66
FOV(): Este método é muito importante. Ele é o responsável por criar os “ray
tracer” e perceber quando o jogador entra em contato com o raio e mudar o
estado da máquina de estados, através da variável “alcance”. FOV é um
acrônimo que quer dizer campo de visão (Field of View).
RaycastHit2D: Esta classe é a responsável por criar o raio que será usado pelo
inimigo como campo de visão. Percebe-se no código que temos dois tipos
diferentes de raios: um usado para perceber se o player está no campo de visão
e fazer o inimigo perseguir o player e outro que é menor. Quando o player
atinge esta distância, o inimigo pode então atacá-lo. Os raios são
“followRay2D” que são usados para perceber se o player está dentro do campo
de visão do inimigo e muda o estado da máquina de estados para perseguir o
player, e o “hitRay2D” que gerencia a aproximação de ataque do inimigo.
Physics2D.Raycast(ray.posi�on, -ray.right, dist_ATK): Esta linha de código
mostra a criação do raio “followRay2D” ou “followRay2D”. Veja que temos o
ponto inicial logo em seguida da direção para onde este raio será direcionado
e, por �m, o tamanho deste raio.
Debug.DrawLine(): Este código é usado para desenhar uma linha de um ponto
de origem até um ponto �nal, ou seja, do ponto A até o ponto B. Nesse caso, o
ponto de origem é o inimigo, e o ponto �nal é determinado pelo tamanho deste
campo de visão. Três valores são necessários para desenhar esta linha o ponto
de início o ponto �nal e a cor da linha.
A Figura 4.12 mostra um exemplo de como o inimigo �cará na aba Scene, lembrando que
o raio só vai aparecer quando o jogo estiver rodando, e o mesmo não aparecerá na aba
Game, o comando “Debug” é usado para criar alguns tipos de representações dentro do
cenário de criação do jogo, ou seja, essas informações não são para serem mostradas ao
jogador e não aparecem no produto �nal, mas seus efeitos sim.
Podemos ver também na Figura 4.12 que o ponto de onde sai o raio que vem do inimigo
em direção ao player é a variável ray do tipo“Transform”, ou seja, este é o ponto onde foi
posicionado o objeto vazio que criamos só para a geração do raio. 
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 27/66
Perceba na Figura 4.12 que o raio está vermelho em uma parte e em outra está verde.
Isso ocorre porque os dois raios foram posicionados um sobre o outro. O raio que está
vermelho �cou vermelho no momento em que colidiu com o player, e o outro está verde,
pois ainda não colidiu. Outro ponto interessante é que o raio que está verde é o raio que
mede a distância de ação para que o inimigo possa atacar o player.
Veja que, caso o player passe direto pelo inimigo, o mesmo continuará andando na
direção oposta a do player. Isso ocorre porque é necessário criar um terceiro raio que
deve sair das costas do inimigo e permitir que o inimigo perceba quando o player está
tentando fugir dele e mudar de direção, para que o inimigo possa continuar caçando o
player. Entretanto, esta parte deixarei para que você crie e possa praticar. Tenha como
exemplo o código que já está criado.
Basicamente, para criar este outro raio, será necessário criar um novo “ray tracer” e
mudar a direção do inimigo para a direção oposta à que ele se encontra, basicamente
mudando a variável booleana “goTo”.
Veja que inimigo ainda não tem um sistema de ataque, mas anteriormente nós já
criamos um sistema de ataque para o player. Este sistema do player servirá
perfeitamente para o inimigo, pois ambos têm ataques corpo a corpo; portanto, será
somente passar este sistema de ataque para dentro do Script do inimigo e ajustá-lo ao
inimigo.
Figura 4.12 - Print Ray Tracer 
Fonte: Elaborada pelo autor.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 28/66
Por �m, será necessário criar um sistema de partículas e parametrizá-lo a seu gosto.
Lembre-se de que, para criar este sistema, devemos clicar com o botão direito do mouse
na aba “Hierarchy” > “Effects” > “Par�cle System” e parametrizar este sistema. Por �m,
podemos criar um “Prefab” deste sistema de partículas e arrastá-lo para o campo
efeitoHit.
Perceba que, ao �nal da criação do inimigo, teremos uma IA que anda de um lado para o
outro. Sua patrulha para de seguir o player quando ele entra no campo de visão, mas,
quando o player sai, o inimigo volta para a patrulha. Perceba também que alguns ajustes
precisam ser feitos no inimigo. Por exemplo, caso ele chegue muito perto da parede, o
mesmo �cará andando em direção a ela até que o tempo da patrulha faça-o mudar sua
direção. Para corrigir este problema, podemos usar um sistema muito parecido com este
que já temos.   O sistema percebe a presença do player e faz a patrulha parar de
perseguir o player enquanto estiver no campo de visão do inimigo. Basta que, quando o
raio de visão, que é o mais longo, colidir com a parede, zere o tempo de patrulha e mude
a direção para o lado oposto.
Caso queira deixar o inimigo em uma plataforma no alto onde possivelmente ele
poderia cair, desative o sistema de “follow”, ou seja, de perseguição e deixe o inimigo
atacar o player caso se aproxime o su�ciente. Essas escolhas vão depender muito do seu
level design. 
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 29/66
Ajuste para o modo Play da Unity
Provavelmente, se estiver praticando a construção de jogos na Unity, já deve ter tido
problemas com o botão “Play” que faz o jogo ser executado.
Imagine que vamos iniciar um teste. Para isso, é preciso clicar no botão “Play”. Jogamos
e testamos, mas, no meio do teste, apertamos o botão “Pause”, por qualquer motivo que
seja. O jogo �cará parado.
Muitas vezes neste cenário, desenvolvedores esquecem que estão no modo “Play” e
fazem alterações no cenário no level design. Após essas alterações, geralmente
desejamos testar o jogo. Então, novamente, ao pressionar o botão “Play”, tudo será
perdido, pois nada permanecerá alterado, ou seja, para alterar qualquer objeto dentro
do jogo, precisamos que o modo “Play” esteja desligado. Do contrário nenhuma
alteração será salva.
Para evitar este problema, podemos, no momento que o “Play” for acionado, alterar a
cor da Unity, veja na Figura 4.13 o caminho e o campo que precisa ser alterado. Para isso,
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 30/66
podemos seguir o caminho: Edit> Preferences> Colors> General> Playmode �nt e
alterar a cor para a que preferir. Após fazer esta alteração, teste-a executando a Unity
no botão “Play”. Lembre-se de manter o alfa da cor em transparente para que a cor não
�que sólida. 
Provavelmente, você já deve estar se perguntando quando iríamos ajustar a câmera
para que ela seguisse o player pelo mapa. Este é um processo muito simples, e a
quantidade de código envolvida neste processo é mínima. Precisamos fazer a câmera
seguir o player enquanto ele se move pelo jogo. Para isso, precisamos modi�car a
posição onde a câmera está relativa com o jogo. Podemos usar o código a seguir: 
Vamos comentar o código:
public Transform player: Usado para encontrar a posição do player no jogo.
public float smoothSpeed = 0.12f: Neste código, não estamos usando esta
variável, mas substitua posDesejada por smoothSpeed e veja o que acontece.
Dessa forma: transform.position = smoothSpeed.
public Vector3 offset: Este vetor é usado para de�nir um valor de
distanciamento da câmera em um dos eixos. Nesse caso, usamos o valor -5 no
eixo z para distanciar a câmera da posição onde o player está.
Figura 4.13 - Print Alterando Cor 
Fonte: Elaborada pelo autor.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 31/66
LateUpdate(): Este update é o último update a ser acionado pela Unity. Dessa
forma, todos os movimentos já foram processados e, por último, a câmera é
atualizada.
Vector3 posDesejada = player.posi�on + offset: Este vetor é criado para que
possamos juntar os valores da posição do player mais os valores do vetor
offset.
Vector3 smoothPos: Usando este vetor ao invés do vetor posDesejada, a
mudança de posição da câmera será suavizada pelo efeito do Lerp. 
praticarVamos Praticar
A colisão em geral é uma das partes mais importantes na maioria dos jogos. Quando objetos
não colidem direito ou quando eles aceleram muito rápido e falham na colisão, isso causa
desconforto no jogador e perda da imersão. Nesse sentido, assinale a alternativa que
apresenta o nome da função que gerencia a colisão entre os objetos dentro da Unity.
a) Layer Collision Matrix.
b) Layer Collision Rigidbody.
c) Rigidbody Layer Collision.
d) Collision Matrix Rigidbody.
e) Layer Rigidbody Matrix.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 32/66
Para criar a “UI”, ou interface do usuário (User Interface), precisamos criar um objeto do
tipo Canvas. Para isso, podemos seguir o caminho:
Clique o botão direito do mouse sobre a aba “Hierarchy” > “UI” > “Canvas”; dê
o nome deste objeto canvas de “UI”; arraste a “UI” para dentro da câmera,
transformando o objeto “UI” em um “child” do objeto câmera.
Em seguida, dentro do canvas, crie dois objetos “Image”. Para isso, clique com o
botão direito do mouse sobre o objeto “UI”, que é nosso canvas e siga o
caminho “UI” > “Image”. Os nomes das imagens devem ser, “Vida” e “Pontos”.
Como �gura para nosso objeto “Pontos”, podemos usar a imagem:
“Assets/Free Game Items/300dpi/gem_1.png”. Para nosso objeto “Vida”, seria
interessante usar um coração.
Dentro de cada um destes objetos, “Vida” e “Pontos”, precisamos criar um
objeto “Text Mesh Pro”, para que possamos usar o mesmo para informar
quantos pontos pegamos na fase e quanto de vida ainda resta ao player.
Para criar estes objetos “Text Mesh Pro”, basta clicar o botão direito do mouse
sobre oobjeto desejado, por exemplo, objeto “Vida”, em seguida “UI” > “Text -
Text Mesh Pro”. Para �nalizar, apague o conteúdo do campo “Text” do
componente “Text Mesh Pro UGUI” e digite o número zero (0). 
Game UIGame UI
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 33/66
Posicione as duas imagens, cada uma em um canto da tela, de preferência nos cantos
superiores, pois, nos cantos inferiores, vamos colocar os controles. A Figura 4.14 mostra
um exemplo de como a “UI” deve �car quando �nalizada: 
saibamaisSaiba mais
Aqui podemos encontrar uma imagem de coração
que pode ser usada gratuitamente, mas é claro que,
para fazer uso da mesma, precisamos referenciar o
autor “gpway” que é o criador dessa imagem. Ela foi
disponibilizada no site “itch.io”. Além dessa
imagem, existem muitas outras neste site que
podem ser usadas de forma gratuita.
Fonte: GP WAY (2020).
ACESSAR
https://gpway.itch.io/2d-hearts
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 34/66
Veja que a Figura 4.14 traz um exemplo de onde os botões, que vamos usar para mover o
player, �caram. Mostra também onde �caram o botão de ataque, simbolizado pelo
quadrado com a espada; botão de pulo, simbolizado pelo círculo verde com um triângulo
ou seta para cima; e o botão de ação, simbolizado pelo losango amarelo com uma
engrenagem.
Por serem botões, eles serão percebidos pelo sistema de “Touch” do smartphone.
Para montar esses botões, precisamos primeiro criar um botão dentro nosso canvas
“UI”. Para isso, clique com o botão direito do mouse sobre o canvas “UI” > “Bu�on”. Este
botão será criado com uma “child” “text”. Devemos deletar a mesma. Em seguida, crie
dentro do botão uma imagem.
Vamos ver passo a passo a criação do botão ataque e, em seguida, crie os demais botões
da mesma forma.
O próprio botão tem um componente “Image” no campo “Source Image” do botão
coloque a imagem a seguir:
“Assets/[UIFabrica]TrollNest_Free_v01/02.PNG/trollnest_square-btn-normal.png”. Na
sequência, coloque a imagem da espada no objeto “Image”, que criou como “child” do
botão, este é o caminho da imagem da espada:
“Assets/[UIFabrica]TrollNest_Free_v01/02.PNG/trollnest_sword-over.png”.
Figura 4.14 - Print UI 
Fonte: Elaborada pelo autor.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 35/66
Perceba que o objeto “child” sobrepõe o botão, sendo que, dessa forma, �ca aparente
que o botão tem essa imagem, mas na verdade é uma imagem composta.
Para criar ou outros botões, use as seguintes imagens:
1. Assets/[UIFabrica]TrollNest_Free_v01/02.PNG/trollnest_radiobtn-press.png
2. Assets/[UIFabrica]TrollNest_Free_v01/02.PNG/trollnest_play-over.png
3. Assets/[UIFabrica]TrollNest_Free_v01/02.PNG/trollnest_options-over.png
4. Assets/[UIFabrica]TrollNest_Free_v01/02.PNG/trollnest_small-btn-
normal.png
5. Assets/[UIFabrica]TrollNest_Free_v01/02.PNG/trollnest_play-normal.png
6. Assets/[UIFabrica]TrollNest_Free_v01/02.PNG/trollnest_radiobtn-empty.png
Veja que as imagens usadas para criar o botão de pulo e a seta para a esquerda são
imagens que precisam ser rotacionadas. Para isso, altere o eixo “Z” do campo rotate no
componente “Rect Transform”.
Por �m, quando tudo estiver em seu devido lugar, levando em consideração a
organização feita na Figura 4.14, podemos ancorar os objetos nas posições que eles
estão, para que, quando o jogo for executado em uma tela menor ou maior do que esta
que estamos usando como referência, os botões sejam posicionados proporcionalmente
no mesmo lugar, não importando o tamanho da tela.
Para ancorar os objetos que compõem a “UI”, devemos selecionar o objeto e ancorá-lo
usando a aba “Inspector”. No componente “Rect Transform” temos o campo “Anchor
Presets”. Clique ele que uma tela abrirá. Nesta tela, podemos selecionar o ponto da tela
que desejamos ancorar os botões e tudo mais que compuser a “UI”, perceba que, como
colocamos nossos objetos nos cantos da tela, devemos selecionar os respectivos cantos
da imagem para que possamos ancorar os botões e as imagens. A Figura 4.15 mostra um
exemplo: 
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 36/66
Veja na aba “Scene” que o objeto selecionado foi o botão de pulo, e na aba “Inspector”
foi selecionado o canto inferior direito. Esses três objetos �caram ancorados no mesmo
canto, e os outros nos cantos respectivos.
UI: Usando Botões
Agora que os botões estão posicionados e ancorados, vamos fazer com que eles possam
mover o player pelo jogo e acionem suas ações respectivas.
Para que esses botões possam mover o player, fazer com que ele ataque, pule, continue
interagindo com as alavancas e portas do jogo, precisamos fazer algumas alterações em
nosso código.
Vamos começar adicionando o código a seguir. O mesmo será o responsável por criar as
variáveis que vão gerenciar se estamos clicando o botão ou não. Devemos adicionar
este código antes do método “Start()” que está no Script “PlayerMove”. 
Em seguida, o próximo código pode ser adicionado após o método “Start()”. Vamos
utilizar esses métodos para indicar que o botão está sendo apertado ou foi liberado, ou
seja, tem a função de gerenciar o clique dos botões. 
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 37/66
Na sequência, precisamos alterar o método “FixedUpdate()”. Para facilitar, pode copiar e
colar o código a seguir no Script “PlayeMove”. Faça a substituição do código lá existente
no método “Update()”, apague os métodos “Update()” e “FixedUpdate()” e use este novo
código. Perceba neste novo código que o mesmo usa um sistema parecido com o
sistema que foi usado para mover o inimigo, mas ainda mantivemos o “moveHorizontal
= Input.GetAxisRaw("Horizontal") * speed;”. Dessa forma, podemos continuar usando o
código com o teclado do computador e também com os botões na tela. Isso só nos
facilita no momento de testar o jogo direto no computador. 
Precisamos trocar também os métodos “ATK()” e “Jump()”. Eles também vão permitir
que continue usando o teclado, mas quando o jogo for executado em um dispositivo
mobile. Dessa forma, teremos dois sistemas que movimentam o personagem, um pelo
teclado do PC e outro pelos botões que criamos na tela. Realmente, manter esses dois
sistemas, serve-nos somente para facilitar no momento do teste.
Podemos ver que poucas alterações foram feitas neste código, em comparação ao que
estava aqui anteriormente. Adicionamos mais uma condição que dispara o movimento e
informamos no código que, se for detectada a tecla correspondente no teclado, ele
aciona, ou se a variável booleana for verdadeira, ele também aciona o sinal “||” entre as
condições, que quer dizer uma condição “OU”, a outra e também foi inserido um “�mer”
simplesmente para que tenha um pequeno espaço entre a repetição da mesma ação
dentro do jogo. 
Por �m, mas não menos importante, 
Estas alterações são de suma importância para que os controles passem a funcionar, e o
jogo passe a ser viável a plataforma mobile.
Para que possamos �nalizar esta parte, precisamos criar em cada um dos botões que
estão dentro do canvas, ou seja, os botões ataque, pulo, direita,   esquerda e ação.
Precisamos criar dois tipos de gatilho nesses respectivos botões. Para isso, clique o
botão “addComponente” que está na aba “Inspector” de cada um dos botões que forem
selecionados. Encontre o “Event Trigger” e o adicione, dentro dele, os eventos “Pointer
Up” e “Pointer Downs”, nestes eventos precisamos arrastar o Player, para que o Script
“PlayerMove”   possa ser usado para encontrar os métodos que precisaremos usar no
evento. Veja um exemplo na Figura 4.16: 
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 38/66
Será necessário fazereste processo para cada botão, mas, para o botão que faz a ação
com a alavanca e com a porta, precisaremos criar uma interação para cada porta e
alavanca do jogo. A Figura 4.17 demonstra um exemplo: 
Veja na Figura 4.17 que temos a porta e a alavanca referenciadas no mesmo botão.
Dessa forma, será necessário fazer alterações nos códigos da alavanca e da porta.
Figura 4.16 - Print Event Trigger 
Fonte: Elaborada pelo autor.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 39/66
Para a “Porta_On/Off”, adicione o código a seguir antes do método “Start()”. 
E ainda, para a “Porta_On/Off”, adicione o código a seguir dentro do método
“FixedUpdate()”. Na verdade, precisamos somente alterar o código lá existente. Apague
a sequência de “IF Else IF” que está presente em seu código e substitua por este código
abaixo. Veja que a diferença aqui é que adicionamos novamente o sinal de “OU”(||) para
que, da mesma forma, as outras condições, esta também possa ser acionada de duas
formas.
Fique atento(a)!
O sinal de “OU”(||) não são duas letras “i” maiúsculas, são duas barras. Temos as barras
“|, / e \”, caso a letra “i” seja confundida e colocada no lugar das barras, o compilador de
C# anunciará um erro. 
Conceito: Esta imagem mostra a ordem dos Layers da Unity. Quanto menor o número,
mais Layers estarão sobre o mesmo, ou seja, o Layer número 0 tem 31 Layers sobre ele.
Podemos fazer uma comparação com uma pilha de pratos. O primeiro prato da pilha,
neste caso, é o primeiro prato colocado sobre a mesa, e o último prato é o mais alto
desta pilha.
Está ordem cria a ilusão de que todas as imagens estão lado a lado, mas esta ordem é
usada para mostrar para a Unity quem ela deve renderizar sobre quem.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 40/66
Não só a Unity trabalha com esta técnica de multiLayers, mesmo não tendo a �gura do
Layer, a ideia de sobreposição por posição ou ordem de render é uma ideia muito usada
na construção de jogos 2D. 
Conceito: Como aqui é um castelo, o layer 0 é a parede deste castelo, mas, caso fosse ao
ar livre, o primeiro Layer seria o céu.
Podemos ver que, sendo um castelo e não tendo outras imagens para mostrar que
representariam o mundo fora dele, as paredes podem ocupar o Layer 0, mas, caso neste
jogo tivessem imagens que mostrassem a parte de fora do castelo, as paredes do castelo
estariam em outro Layer, 3 ou 4, para que assim os Layers debaixo pudessem ser usados
para representar a paisagem de fora do castelo. 
Figura 4.19 - Fundo 
Fonte: Unity.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 41/66
Conceito: Aqui temos a parte onde o jogador vai colidir e podemos seguir a mesma
regra. Caso a parede de fundo azul for o Layer 0, em sequência podemos ter a parte
colisivo do jogo e, como esta parte precisa se sobrepor, o Layer 0 precisa estar acima
dele, podendo �car no Layer 1.
Veja que aqui já temos então um padrão para esses Layers, ou seja, a cada novo Layer,
torna-se maior a distância do Layer 0. Por esta questão, devemos deixar um espaço e
não usar uma quantidade dos primeiros Layers. Deve-se começar a ordenação deles a
partir do Layer 3, mas, caso tenhamos certeza de que não utilizaremos os layers abaixo,
podemos então manter esta con�guração. 
Figura 4.20 - Paredes Laterais, Tilemap 
Fonte: Unity.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 42/66
Conceito: Aqui temos o layer das plataformas que, neste caso, não serão sobrepostas
pelo player, mas, para manter uma ordem hierárquica, podemos colocar as mesmas no
layer 4. 
Conceito: As esmeraldas também serão sobrepostas pelo jogador; portanto, devemos
colocá-las sobre as plataformas mais abaixo do Player.
Aqui poderíamos colocar então todos os itens neste Layer. O coração seria um deles. 
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 43/66
Conceito: Veja que neste caso a ordem seria sobre quem é renderizado primeiro, ou
seja, qual dos dois objetos vão passar pelo render primeiro. Caso seja o player, ele será
sobreposto pelo inimigo. Caso contrário, o inimigo será sobreposto pelo player. 
Conceito: Esta parte precisa sobrepor o jogador e todo o resto do jogo. Em outros tipos
de ferramentas que podemos usar para construir jogos, usamos ainda uma técnica de
criação de duas câmeras. Onde está parte do jogo, a interface com o usuário �caria
localizada em outra câmera. Dessa forma, ela iria sobrepor todo o resto como se
estivesse em um outro Layer. 
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 44/66
Conceito: Veja que aqui temos a soma de todos os layers, ocupando seus Layers
individuais e sobrepondo cada imagem que deve ser sobreposta pelo mesmo.
Com isso, criamos a ilusão de que os objetos estão todos lado a lado, no mesmo Layer,
dando a impressão de maior realidade no jogo. Uma outra função que faz uso desta
técnica dos Layers é a função de criar o Parallax. 
Player: Recebe Dano
Precisamos de uma maneira de fazer o player receber dano. Para isso, precisamos criar
uma variável que irá armazenar a sua vida e métodos que decrementem essa variável e
outro que incremente.
Devemos, então, criar dentro do Script “PlayerMove” uma variável chamada vida do
tipo inteira. Outra chamada “maxVida” do tipo inteira. A variável “maxVida” vai guardar
o valor máximo que a vida do player pode chegar.
A variável “maxVida” deve ser iniciada na sua criação, sendo o valor de 100 como
máximo de vida. Este número deve ser ponderado segundo o game design. Em geral, é
um bom número.
Figura 4.25 - Imagem Final
Fonte: Unity.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 45/66
Neste código, não há nada de novo. Basicamente, são métodos que tratam das variáveis
criados no “Script” que gerencia o player. Como são métodos, podemos colocá-los em
qualquer lugar do “Script”, desde que seja dentro da classe e fora de outro método, mas,
para que o código tenha uma ordem de novos métodos, vamos adicioná-los ao �nal do
código já existente no Script “PlayerMove”. 
Player: Coleta itens
Precisamos de um sistema que faça a coleta dos itens. Dessa forma, precisamos coletar
as esmeraldas e os corações, mas, para a coleta dos corações, não queremos que o valor
de “MaxVida” seja excedido. Portanto, o código precisa gerenciar esta coleta e descartar
o valor que exceder o total de vida permitido. 
Perceba que, basicamente, aqui fazemos uma máquina de estados e não existem muitos
pontos novos, apenas outra maneira de organizar o código. O elemento novo que temos
aqui é o  “default:”:
default: Usado na estrutura do “switch()”, ele é usado para que exista uma
saída padrão, onde todas as informações não desejadas devam ser designadas,
ou seja, para que algum código seja executado, precisamos informar um valor
igual ao “case” que lá existe. Quando o valor informado não existe, o “case”
“default” é acionado.
Armadilha: Spikes
Vamos criar uma armadilha para que tenhamos mais uma maneira de o personagem
perder vida pelo jogo. Esta armadilha pode ser colocada em qualquer um dos quatro
lados do tile.
Para isso, precisamos criar um novo objeto vazio e dar o nome de “Spikes”. Para que esta
armadilha possa ser animada, precisamos fazer como temos feito com todas as
animações. Precisamos animar sempre a “child” de um objeto e nunca o objeto principal,
pois a animação não funcionará corretamente caso seja feito de outra forma.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 46/66
Faça um teste. Crie uma “Sprite”. Anime-a e execute o projeto. Veja o que ocorre como
objeto “Sprite” que acabou de animar.
Devemos dentro deste objeto “Spikes” criar outro objeto vazio. Este segundo objeto
vazio precisa ser uma “Sprite”. Devemos então colocar uma imagem de um tile nele.
Escolha o tile que preferir. Para este novo objeto, daremos o nome de “Tile_Armadilha”.
Em seguida, precisamos de mais uma “Sprite” que �cará dentro do objeto
“Tile_Armadilha” que chamaremos de “Armadilha” e colocaremos a seguinte imagem:
“Assets/Medieval_pixel_art_asset_FREE/Textures/Medieval_tiles_free_135.png”, a
animação �cará no objeto “Armadilha”, ou seja, na “child” da “child” do  objeto “Spikes”. 
Perceba que, como se trata de um objeto, igual ao “Player”, “Inimigo” e a “Esmeralda”,
precisamos posicionar este novo objeto no mapa da maneira que preferir. Para que a
armadilha funcione, antes precisamos colocar no objeto “Armadilha” um collider e ativar
no mesmo o campo “IsTrigger”. Podemos ver um exemplo na Figura 4.27: 
Figura 4.26 - Print Alterando Cor 
Fonte: Elaborada pelo autor.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 47/66
No exemplo da Figura 4.27, podemos ver que a imagem da armadilha, �cará escondida
por trás da imagem do tile. Dessa forma, podemos fazer uma animação simples, ou seja,
somente alterar a altura da armadilha e fazer o processo inverso para que ele suba e
desça por trás do tile e dê a impressão de que ele está levantando e furando os pés do
personagem, na Figura 4.26. Podemos ver o exemplo da armadilha acima do limite do
tile.
Vamos usar o “IsTrigger” para dar dano no jogador no momento que ocorrer a entrada
do trigger, ou seja, usaremos o método “OnTriggerEnter2D”.
Para isso, precisamos criar dentro do objeto “Armadilha” um novo “Script” que daremos
o mesmo nome do objeto ao qual ele pertence. Nesse caso, “Armadilha”. 
Podemos ver que este código não traz novos comandos, mas sim uma maneira de
encontrar e causar dano ao jogador que passar por cima dos espinhos. 
praticarV P ti
Figura 4.27 - Print Armadilha 
Fonte: Elaborada pelo autor.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 48/66
praticarVamos Praticar
No momento de se criar um código, é necessário usar várias técnicas de codi�cação diferentes
e também muita imaginação. Na criação de um código, precisamos basicamente resolver
problemas matemáticos e sequências. Muitas vezes, saber qual código pode ser acionado em
determinada ordem muda muito o resultado �nal do projeto. Nesse sentido, assinale a
alternativa que apresente o sinal de código que signi�ca “OU”. Este sinal deve permitir a
passagem quando um “ou” outro parâmetro for atendido:
a) &&
b) ==
c) !=
d) ||
e) //
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 49/66
Neste ponto, já temos todas as ferramentas para a criação de um jogo plataforma e até
mesmo para outros tipos de jogos 2D. Vimos partes muito importantes sobre como criar
um inimigo, acionar objetos, coletar objeto, coletar vida e pontos. Vamos agora à parte
�nal, onde devemos polir o jogo e criar o APK.
Polindo: Tilemap
Para �nalizarmos nosso “Tilemap”, precisamos adicionar mais um novo componente. O
mesmo irá poupar memória e ajustará alguns possíveis problemas de movimentação
dentro do jogo.
Dentro do objeto “Grid”, selecione o “Tilemap” que demos o nome de plataforma, nele
adicione um novo componente. Seu nome é “Composite Collider 2D”. Este componente
mudará a maneira que os tiles são divididos em relação ao funcionamento do collider que
colocamos anteriormente. Para que o mesmo funcione, precisamos marcar um campo
no componente “Tilemap Collider 2D”, o campo “Use By Composite”. Com isso, você
verá que, ao invés de vários quadradinhos dividindo cada tile, teremos um corpo inteiro,
diminuindo muito o número de vértices deste collider e arestas, causando uma grande
economia em processamento.
Polindo o JogoPolindo o Jogo
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 50/66
Vér�ces: Os vértices são os cantos, ou seja, são as junções das arestas, onde
existem duas linhas se encontrando e criando uma ponta ou em uma curva
existem um ou mais de um vértice.
Arestas: As arestas são as linhas que ligam os vértices. Quando queremos
desenhar um quadrado, que é uma forma geométrica bidimensional, temos o
conjunto de 4 vértices e 4 arestas. As arestas são os cantos deste quadrado.
Polindo: Player
Já deve ter percebido que o player agarra muito nas paredes. Provavelmente, já deve ter
�cado louco com este problema. Mas, �que tranquilo! Agora ele será eliminado.
Para acabar com este problema, precisamos adicionar ao campo “Material” dos
componentes collider do player um novo material. Sendo assim, devemos criar este novo
material que precisa ser físico.
Na aba “Project”, onde �cam as pastas do projeto, escolha uma pasta e clique o botão
direito do mouse. Selecione a opção “create”. Ela é a primeira opção na aba que se abrirá.
Ao levar o mouse sobre o “create”, uma nova aba será aberta e dentro dela temos a
opção “Physics Material 2D”. Clique ela para que o material seja criado na pasta que
selecionou.
Veja que este material traz apenas dois campos, fricção(Friction) e
elasticidade(Bounciness). Zere esses dois campos. Simplesmente, deixe o valor ( 0 )
dentro destes deles.
Agora é só arrastar este novo material para dentro do campo “Material” que �ca dentro
do componente collider. Selecione o objeto “Player”, encontre o collider e coloque este
material no respectivo espaço e pronto. Teste para ver o resultado. Seu personagem
agora vai deslizar pelas paredes e plataformas quando esbarrar nelas ao cair ou pular.
Perceba que isso não vai alterar seu atrito com o chão. Caso contrário, reveja os passos
para corrigir possíveis erros.  
Criando o Menu
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 51/66
Claramente que este jogo precisa de uma tela com um botão start, créditos e tudo mais
que for necessário para a conclusão de um jogo. Entretanto, como este processo já foi
visto anteriormente de maneira minimamente satisfatória, neste ponto, este processo
�cará como desa�o para que você termine seu jogo.
Devemos lembrar também de selecionarmos efeitos sonoros e músicas para este jogo.
Como esta parte também já foi vista de maneira minimamente satisfatória, deixarei ela
para que você possa praticar suas novas habilidades de programador de jogos.
Fim do Jogo
O �m deste jogo será o ponto onde encontraremos o “Rei”. Para isso, precisamos então
criar mais um personagem, o nosso “Rei”.
A imagem que será usada para criar o rei pode ser encontrada junto à imagem que
usamos para criar o inimigo. O nome da imagem é “PackCastle01.png”.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 52/66
O sistema que fará o jogo saber que foi �nalizado é um sistema muito parecido com o
sistema usado para abrir as portas ou mover as alavancas. Basta que tenha um collider
que, no momento em que o jogador entrar, o jogo terá seu �m. A Figura 4.28 traz um
exemplo.
Nada de novo aqui também. Será fácil reutilizar partes de códigos que já escrevemos
para criar este �nal do jogo. Lembre-se de que o “Rei” também precisa de animação,
então não esqueça de fazer esta parte.
Figura 4.28 - Print Armadilha 
Fonte: Elaborada pelo autor.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 53/66
Build: Criando o APK
Antes de construir seu APK, limpe seu código e seu projeto como um todo, delete todas
as imagens, Scripts, áudios e tudo mais que não estiver usando em seu jogo. Lembre-se
que os dispositivos mobile são muito potentes, mas têm memória de processamento e de
armazenamento limitados. Precisamos aproveitarcada bit que pudermos.
Veja na Figura 4.29 que, dentro de algumas das con�gurações necessárias para a criação
do APK, o campo “Package Name” é uma das mais importantes, para abrir esta tela. Vá
em: Edit > Project Se�ng   e escolha a opção “Player”. No campo “Package Name”,
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 54/66
escreva um nome, que em geral é o nome de sua empresa ou grupo que desenvolveu o
jogo. Este nome é usado para identi�car o pacote que vai virar o APK.
Na Figura 4.29, podemos ver também que, após o nome do pacote, temos a versão do
projeto, a versão de construção(Build) e, nesse caso, como estamos criando um APK,
que é designado à plataforma Android, podemos selecionar o sistema mínimo e o
máximo para qual desejamos que nosso jogo seja executado. Sugere-se que essas duas
opções permaneçam como padrão, a não ser que esteja desenvolvendo um jogo para
uma versão especí�ca do Android.
Está alteração é muito necessaria para que o jogo não mude sua orientação de tela, ou
seja, ela deve �car com a orientação de tela marcada como panorama(Landscape).
Dessa forma, a tela do jogo �cará travada e não permitirá que a tela gire.
Para travar a orientação da tela, basta seguir o exemplo da Figura 4.30. Na mesma tela
que está, role para cima e encontre a opção de resolução e apresentação(Resolution and
Presentation). Clique a mesma que as opções de orientação(Orientation) vão aparecer.
Mude a opção de orientação padrão(Default Orientation) para panorama(Landscape) e
escolha a opção de direita(Right) ou esquerda(Left).
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 55/66
Para gerar o APK, é simples. Veja o exemplo da Figura 4.31. Precisamos selecionar a
plataforma Android e fazer apenas uma alteração no campo “Build System”. Precisamos
mudar de “Gradle” para “Internal” e clicar no botão “Build”. Escolha uma pasta onde o
APK será gerado e pronto. Claro! Certi�que-se se todas as Scenes do seu projeto estão
listadas no campo “Scenes in Build”.
Figura 4.30 - Modo Landscape 
Fonte: Elaborada pelo autor.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 56/66
Após o processo de “Build” ser concluído, o APK aparecerá na pasta escolhida. Para
instalar o mesmo em um celular com Android, basta ligar o celular ao computador e
arrastar o APK para dentro do celular. Lembre-se de veri�car a versão do seu Android
que precisa estar dentro dos limites estipulados anteriormente na tela de
con�gurações.
praticarVamos Praticar
Na criação de um colisor para um objeto dentro do jogo, precisamos gerar basicamente uma
caixa ou círculo que informe a partir de onde começa a área da colisão com o determinado
objeto ou personagem. Para isso, a Unity nos traz vários tipos diferentes de colliders e todos
eles têm arestas. Mesmo que sejam muito pequenas e não consigamos ver se elas estão lá.
Nesse sentido, assinale a alternativa que descreva o que são arestas.
a) Podemos dizer que as arestas são os cantos de uma caixa.
b) Podemos dizer que as arestas são a área de uma caixa.
c) Podemos dizer que as arestas são o tamanho de uma caixa.
d) Podemos dizer que as arestas são as bordas de uma caixa.
e) Podemos dizer que as arestas são um conjunto de objetos.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 57/66
indicações
Material
Complementar
L IVRO
Design de Games: uma abordagem prática
Paul Schuytema
Editora: Cengage
ISBN: 8522106150
Comentário: Este livro é um livro excelente, pois traz muitas
informações sobre a maneira de se pensar na criação de um
jogo, a noção da “BluePrint” que é o game design em si. Muito
utilizado em faculdades para cursos de graduação e pós. Possui
uma linguagem prática e simples de ser compreendida e conta
passo a passo sobre a criação de personagens, níveis, menus e
tudo mais que está relacionado à criação de um bom design
para jogos.
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 58/66
WEB
INDIE GAME: THE MOVIE
Direção: Lisanne Pajot, James Swirsky. Estados Unidos:
Produção de Lisanne Pajot, James Swirsky. Documentário. 18
de maio de 2012.
Comentário: Documentário que traz os bastidores do
desenvolvimento de jogos de forma independente. Empresas
formadas por uma ou mais pessoas que começam a ganhar
mercado e mudar o panorama do desenvolvimento de jogos no
mercado do mundo inteiro, novos padrões pode ser testados e
novos limites podem ser vistos, pois estes desenvolvedores
muitas vezes estão tentando ganhar seu espaço ao sol.
Trailer do documentário a seguir.
A C E S S A R
https://www.youtube.com/watch?time_continue=150&v=dINgx0y4GqM&feature=emb_logo
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 59/66
conclusão
Conclusão
Foi uma jornada árdua, com muitos altos e baixos, teorias que não tem �m, códigos que
podem ser usados de várias maneiras diferentes, mas o mais importante, muita
criatividade.
A construção de um jogo é baseada na criatividade. Por mais que tenhamos todas as
ferramentas necessárias para a criação de um jogo, a criatividade é uma ferramenta que
não pode ser ensinada em poucas páginas e precisamos praticá-la para que a mesma
chegue nos mais altos níveis.
Na construção de um jogo, leve em consideração que a prática lhe trará conhecimento
para chegar à criação de um jogo cada vez mais completo. Estamos em uma era onde
muitos jogos independentes estão fazendo sucesso pelo mundo dos jogos. Lembre-se de
que não é necessário uma grande equipe para a criação de um jogo que pode lhe render
milhões.
Lembre-se dos desenvolvedores independentes que alcançaram esse marco para citar
apenas em temos o Minecraft.
referências
Referências
Bibliográ�cas
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 60/66
ESCOBAR, Diego Game Dev. Game mobile plataforma. 2020. Disponível em:
https://diegoescobar-gamedev.itch.io/game-mobile-plataforma. Acesso em: 16 fev.
2020.
GP WAY. 2D hearts. Banco de Imagens. 2020. Disponível em: https://gpway.itch.io/2d-
hearts. Acesso em: 16 fev. 2020.
LEVEL DESIGN - 5 REGRAS PARA ÓTIMAS FASES NOS SEUS JOGOS. YouTube.
Disponível em: https://www.youtube.com/watch?v=fskiT9pyEhU. Acesso em: 16 fev.
2020.
ROUSE, Richard. Game Design: Theory & Practice. 2. ed. USA,Texas: Wordware
Publishing, 2005.
SCOLASTICI, Claudio; NOLTE, David. Mobile Game Design Essen�als. UK,
Birmingham: Packt Publishing, 2013.
SCHUYTEMA, Paul. Design de games: uma abordagem prática. São Paulo: Cengage,
2017.
TUTORIAL UNIT 5 - SISTEMA DE PLATAFORMAS COM ROTAS. YouTube. Disponível
em: https://www.youtube.com/watch?v=El2wvn0VyEo. Acesso em: 16 fev. 2020.
UNITY. Unity Technologies. [2020]. Disponível: https://unity.com/pt. Acesso em: 17 fev.
2020.
https://gpway.itch.io/2d-hearts
https://www.youtube.com/watch?v=fskiT9pyEhU
https://www.youtube.com/watch?v=El2wvn0VyEo
https://unity.com/pt
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 61/66
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 62/66
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 63/66
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 64/66
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 65/66
09/10/2020 Ead.br
https://unifacs.blackboard.com/webapps/late-Course_Landing_Page_Course_100-BBLEARN/Controller 66/66