Desenvolvimento de Jogos Plataforma

Prévia do material em texto

DESENVOLVIMENTO DE JOGOSDESENVOLVIMENTO DE JOGOS
PARA WEBPARA WEB
DESENVOLVIMENTO DEDESENVOLVIMENTO DE
JOGOS MOBILE:JOGOS MOBILE:
CRIANDO UM JOGOCRIANDO UM JOGO
PLATAFORMAPLATAFORMA
Autor: Esp. Diego de Godoy Racero Escobar
Revisor : Deivt ih Cunha
IN IC IAR
introdução
Introdução
Tudo na vida tem seu nível de di�culdade e com o desenvolvimento de jogos
não poderia ser diferente. Mas é claro que, com o processo e ferramentas
certas, podemos diminuir essa di�culdade.
O desenvolvimento de jogos, em geral, é muito diverso e essa diversidade
vem da dose de criatividade que cada processo de desenvolvimento insere
em cada jogo.
Em uma analogia com a marcenaria, veremos que um marceneiro faz várias
mobílias de madeira, sua matéria-prima é a mesma, suas ferramentas
também, mas suas técnicas de uso da madeira vão variar com a necessidade
que a construção e o design da peça variarem.
Sendo assim, usaremos uma ferramenta que irá nos auxiliar no
desenvolvimento deste projeto. Com ela, conseguiremos acelerar o processo
do desenvolvimento de jogos em geral. Neste projeto, trabalharemos com 2D,
mas a ferramenta pode ir além disso.
Voltando a uma época na qual a parte boa dos videogames eram encontradas
em arcades, o mercado estava �cando saturado dos jogos do tipo “Space
Shooter” e a Nintendo ainda estava apostando suas �chas nesse tipo de jogo,
eis que no horizonte surge uma nova era dos jogos para arcade, a era dos
jogos plataforma (HARRIS, 2014).
Década de 1980, mais precisamente em 1981, a Nintendo estava prestes a
lançar o arcade com o jogo do gênero “Space Shooter” ou só “Shooter”; seu
nome era Radar Scope.
Jogos PlataformaJogos Plataforma
Em geral, as pessoas não conhecem esse jogo, pois alguns meses antes da
Nintendo enviar do Japão aos Estados Unidos três mil unidades do arcade
com o jogo “Radar Scope”, eles decidiram mudar a estratégia. A verdade era
que a Nintendo estava apostando muito nesse jogo, mas a era dos arcades
precisava de um novo tipo de jogo, então a Nintendo resolveu “ consertar ”
seu produto (HANSEN, 2016). “Parecia que todos os jogos que estavam por aí
que não eram Pac-Man eram um space shooter, e Radar Scope �cou perdido
na mistura impressionante que foi 1980” (HANSEN, 2016, p. 34, tradução
nossa).
Shigeru Miyamoto foi o homem escolhido para “ consertar ” o jogo, e o
resultado nós já conhecemos - foi o primeiro jogo do gênero plataforma
lançado no mercado.
No começo, Miyamoto queria criar um jogo do “Popeye”, mas algumas
complicações com os direitos autorais surgiram e, então, ele resolveu seu
problema mudando as características dos personagens. Nasceram três novos
personagens originais da Nintendo, “Jump Man”, “Lady” e “Donkey Kong”
saibamais
Saiba mais
Conheça melhor o jogo que deu lugar ao tão
aclamado game que revolucionou o mercado
de jogos para sempre, o Radar Scope. Esse é
o jogo que cedeu gentilmente o lugar para o
jogo Donkey Kong de Shigeru Miyamoto.
ACESSAR
https://nintendo.fandom.com/wiki/Radar_Scope
(HANSEN, 2016). Mais tarde, o “Jump Man” e a “Lady” �cariam conhecidos com
outros nomes, Jump Man se tornaria Mario e a Lady, a Princesa Peach.
Esse jogo �cou conhecido como revolucionário, pois, até seu surgimento,
ainda não existiam jogos com personagens que pudessem pular. O botão de
pulo foi inventado com o jogo Donkey Kong (HANSEN, 2016).
Apesar de o jogo Donkey Kong ser o primeiro do gênero plataforma, a função
de pular de uma plataforma para a outra só aparece na segunda fase do jogo;
na primeira fase, o “Jump Man” só pulava por cima dos barris que o Donkey
Kong atirava contra ele e subia as escadas para alcançar a “Lady”.
Shigeru Miyamoto tinha uma visão idealista de que os videogames deveriam
ser vistos da mesma forma que livros e �lmes, ou seja, o trabalho de quem
desenvolvia um jogo deveria ser tão valorizado quanto o de quem produzia
livros e �lmes (HARRIS, 2014).
saibamais
Saiba mais
Conheça o primeiro jogo que foi categorizado
como jogo plataforma, o Donkey Kong, de
1981. Criado por Shigeru Miyamoto, em seu
primeiro trabalho como Game Designer,
Miyamoto entregou um jogo revolucionário,
que elevou seu nome às alturas como
Designer de jogos.
ACESSAR
http://www.dedegames.com/pt/donkey-kong-arcade-return.html
Exemplos de Jogos Plataforma para
Mobile
Esta modalidade de jogo chamada de “Plataforma” é basicamente um jogo no
qual o jogador pode saltar de uma plataforma para outra, claro que o jogador
pode apenas andar de uma plataforma para a outra. No entanto, como vimos
anteriormente, junto ao surgimento dos jogos plataforma surgiu também a
possibilidade de pular com o personagem que jogamos. Logo, um jogo
plataforma é um jogo no qual o personagem controlado pelo jogador pode
saltar de uma plataforma para outra.
Levando isso em consideração, vamos fazer uma breve análise de três jogos
plataforma que estão no mercado hoje e têm jogabilidades diferentes e
estilos diferentes, tanto no gameplay quanto em suas histórias.
Mario Run
Mario Run é um jogo em que o personagem, já mundialmente conhecido,
Mario, corre do início ao �m da fase, e, apesar de o jogador ter vários
obstáculos, inimigos e itens que podem ser coletados, conta com apenas um
botão para apertar e realizar todos os movimentos dentro do jogo.
Todos os movimentos que podemos realizar no jogo Mario Run estão ligados
a realizar pulos no momento correto para que o personagem passe pela parte
da fase desejada e possa marcar combos, coletar itens e(ou) destruir inimigos.
A mecânica deste jogo é basicamente pular, mas o seu design aplica algumas
di�culdades em pular no tempo correto, manter uma certa sequência e evitar
ser pego por um inimigo, cair em algum buraco, ou algum tipo de armadilha,
ou seja, algum tipo de lugar que o personagem não pode cair, caso contrário,
ele perde uma vida.
Dessa forma, podemos ver um jogo plataforma muito diferente do padrão, e
quando dizemos padrão queremos nos referir ao clássico jogo “Donkey Kong”
de 1981. Podemos ver que o gênero/tipo de jogo classi�cado como
plataforma pode abranger vários tipos de design e jogabilidades diferentes.
Sword of Xolan
Sword of Xolan é o jogo mais próximo do jogo padrão que foi referido
anteriormente. Podemos pular de uma plataforma para outra, podemos
pegar itens que nos dão algum poder, como no “Donkey Kong”, em que o
personagem principal tinha a possibilidade de pegar a marreta para destruir
os barris que o Kong jogava.
Nesse jogo, temos NPCs que podemos resgatar, igual ao “Donkey Kong”. O
objetivo principal era salvar a princesa “Lady”. Há obstáculos que devemos
atravessar, mas o mais importante é que podemos nos mover livremente, ou
seja, diferente do Mario Run, onde só é possível pular, no Sword of Xolan,
podemos nos mover para frente, para trás, saltar, bater com a espada, lançar
uma determinada magia, coletar itens, destruir inimigos, resgatar os
prisioneiros e atravessar a fase do início até seu �m, quando saímos da fase e
os pontos são contados.
Basicamente, nos jogos plataforma, temos uma fase, a qual devemos
atravessá-la e, para isso, precisamos vencer suas di�culdades, e, no �m,
vencer o desa�o e, muitas vezes, conhecer uma história.
Once Upon a Tower
Once upon a tower é um jogo que traz uma aventura muito interessante.
Basicamente é a história de uma torre que aprisiona uma princesa. Além dos
inimigos e armadilhas pelo caminho dessa torre, existe um dragão que
desperta, no momento que iniciamos a descida da torre, e começa a
perseguir a personagem cuspindo fogo por grades nas paredes da torre. Caso
o jogador deixe a princesa parada por muito tempo em um lugar onde exista
uma janela gradeada, o dragão se posiciona para cuspir fogo nela, causando a
derrota do jogador - outro jogo que traz as mecânicas básicas de um clássico
jogo plataforma.
Além de pegar itens e poder fazer uso de outros, o jogo conta com inimigos e
as plataformas, mas uma das coisas mais interessantes que esse jogo traz em
seudesign e mecânica é que a princesa não pula, ela cai.
A personagem principal, a princesa, desce a torre, por isso o jogo traz em seu
gameplay a mecânica de destruir a plataforma que está embaixo da princesa
para que ela possa continuar a sua descida e, assim, escapar da torre. Esse
jogo é interessante, pois retira um dos elementos mais básicos dos jogos de
plataforma, que é a possibilidade de pular; a não ser que consideremos que,
ao destruir a plataforma que está abaixo dela, a princesa esteja pulando para
a plataforma inferior, mas claro que não né.
O pulo é um elemento básico nos jogos do tipo plataforma, mas, como esse
jogo demonstra, ele não é o que de�ne esse tipo de jogo. A de�nição básica
dos jogos plataforma são simplesmente as plataformas, não importando
quais tipos de mecânicas mais estejam envolvidas.
Contexto atual do mercado Mobile
Como este mercado é movido basicamente por meio da indústria de venda de
celulares, vale a pena começarmos a falar sobre a quantidade de pessoas no
mundo que fazem uso desse aparelho.
Uma pesquisa feita pelo repórter Jonas Valente para o site Agência Brasil traz
informações referentes à quantidade de pessoas do mundo que usam
aparelhos celulares; o número é impressionante - cerca de 5 bilhões de
pessoas fazem uso dessa tecnologia em todo o mundo. Hoje são 67% da
população mundial, e a pesquisa prevê o crescimento desse percentual para
71% até 2025 (VALENTE, 2019, on-line ).
Possivelmente, nem todos usam os celulares para jogar algum tipo de jogo,
mas esse número nos mostra o vasto mercado que é a indústria mobile. Os
celulares têm uma vantagem em relação a estarem ao lado de seus donos
basicamente 24 horas por dia, do momento que vamos dormir até
acordarmos no dia seguinte. A possibilidade de serem usados para passar o
tempo é muito grande e nada como um bom jogo para servir de passatempo.
Dos 100% de jogos vendidos no mundo para todas as plataformas, os
vendidos para celular ganham a liderança em vendas quando comparados às
outras plataformas de jogos, como computadores e consoles. Em 2016, foi
feita uma pesquisa sobre a plataforma favorita dos jogadores de videogames,
e o celular ganhou com 76%, competindo com computadores pessoais, jogos
on-line e consoles (CUSTOMER ..., 2016, on-line ).
Podemos pensar para qual tipo de plataforma mobile devemos desenvolver
jogos. Em geral, as pessoas podem lembrar das três principais, Android, IOS e
Windows Phone, mas, em relação a todos os celulares do mundo, o Android
está instalado em 88% deles (HOLST, 2019, on-line ).
Digamos que precisamos decidir entre essas três e escolher para qual
devemos lançar nosso primeiro jogo. Devemos levar em consideração o
mercado no qual desejamos entrar e qual o público-alvo que desejamos
atingir, mas vamos pensar agora em relação a aparelhos que têm um desses
três sistemas funcionando.
Vamos fazer uma breve comparação com os números que temos. Se a
quantidade de celulares do mundo está por volta de 5 bilhões e 88% desses
são celulares Android, teremos a quantia de 4.400.000,000 (quatro bilhões e
quatrocentos milhões) de aparelhos rodando com o sistema operacional
Android.
Como o Android leva uma enorme fatia do mercado, contra o segundo
colocado, que é o IOS com apenas 11.9% dos cinco bilhões de aparelhos,
nossa escolha �ca mais simples de ser feita, mas com a possibilidade de se
disponibilizar para as duas principais plataformas, sendo viabilizadas pela
Unity. Um jogo publicado em ambas as plataformas atingirá um total de
99.9% de todos os aparelhos disponíveis no mercado mundial.
Devemos lembrar que existem versões diferentes de Android e IOS. Por esse
motivo, devemos ter em mente a partir de qual versão do Android e do IOS
nosso produto poderá ser executado, mas ainda teremos uma enorme
quantidade de possíveis dispositivos para instalar e rodar nosso produto.
Com esses números �ca fácil de escolher o Android como melhor candidato
para os primeiros produtos, mas deve-se levar em consideração o seguinte:
caso você seja um usuário do IOS, há algum tempo, provavelmente tem
alguma ideia do tipo de aplicativo que melhor vende na plataforma desejada;
dê uma olhada na loja e veja os jogos que mais são vendidos ou baixados;
dessa forma, terá uma base melhor sobre qual tipo de jogo o público mais
gosta.
Leve em consideração que gostar do jogo que está fazendo é muito
importante, pois os melhores e mais vendidos começaram assim, com seus
desenvolvedores gostando do jogo e querendo fazer um jogo que eles
gostassem de jogar. Lembre-se de que a criação de um jogo é uma arte que
devemos praticar para que possamos nos aperfeiçoar nela; não há garantia
de sucesso em seu primeiro título, mas, com muito esforço e garra, você
poderá chegar lá.
Por que  jogar um jogo?
Responder a esta pergunta é uma tarefa muito importante para os criadores
de jogos - qual seria o gatilho de motivação que incentiva uma pessoa a jogar
um jogo, não importa a idade nem se é homem ou mulher.
Rouse, em seu livro “Game Design: Theory & Practice”, levanta algumas
perguntas pertinentes nesta área:
● Por que os jogadores jogam?
● Por que eles escolhem ligar o computador ou o console e
executar um jogo em vez de visitar o museu de arte ou assistir a
um �lme?
● O que há de único em jogos de computador em comparação
com outras mídias de entretenimento humano?
● O que os jogos oferecem que outras atividades não oferecem? (III
ROUSE, p. 2, 2005 , tradução nossa)
Essas perguntas podem ter várias respostas. Por exemplo, uma pessoa pode
jogar um jogo por causa da história e outro por causa de sua jogabilidade;
mas, no �m, a pessoa joga, pois os jogos nos possibilitam novas experiências
do conforto de nosso sofá.
Escolher ligar o computador ao invés de sair e ir ao cinema também pode ter
várias respostas diferentes. Podemos concluir que o jogador deseja ser
desa�ado. Em geral, os jogos digitais que são mais difíceis de serem resistidos
pelos jogadores são os que propõem a eles um desa�o (III ROUSE, 2005).
Os jogos nos fazem pensar e tentar novas soluções para os problemas
propostos por eles. Os jogadores esperam resolver diferentes mecanismos de
jogo. Mesmo que o desa�o esteja dentro de um jogo e não necessariamente
dentro de um livro, o jogador aprende com os seus desa�os. Podemos
concluir que os jogos desa�adores nos proporcionam experiências de
aprendizagem, por mais que sejam motivadas por desa�os dentro do mundo
virtual (III ROUSE, 2005).
Nos melhores jogos, os jogadores aprenderão lições através da
jogabilidade que podem ser aplicadas a outros aspectos de sua
vida, mesmo que não percebam. Isso pode signi�car que eles
podem aplicar métodos de resolução de problemas em seu
trabalho, usar suas habilidades espaciais aprimoradas para
organizar melhor seus móveis ou talvez até mesmo aprender uma
maior empatia por meio da representação de papéis (III ROUSE,
2005, p. 2-3, tradução nossa).
Um exemplo de motivação aos jogadores é encontrado em jogos de
progressão, que nos trazem novos ambientes, novas aventuras e maneiras de
testar nossas habilidades, que adquirimos com o passar do jogo. Os
jogadores têm mais uma maneira de interação com o jogo - a exploração das
suas fases; dessa forma, podem aproveitá-lo mais.
Existe a exploração de diferentes opções estratégicas em um jogo
como Civilization, diferentes tipos de recursos para manipular e
combinar em um jogo como Magic: The Gathering e a exploração
das personalidades dos personagens que você encontra em RPGs
como Wasteland ou Fallout (III ROUSE, 2005, p. 6, tradução nossa).
Jogadores que passaram por novas fases do jogo logo após desvendar um
mistério ou atravessar uma fase muito desa�adora podem sentir a
grati�cação de missão cumprida. Muitos jogadores, ao chegar a uma nova
fase, no primeiro momento só querem se vislumbrar com as novas paisagens
e ou inimigos e pensar como farão para vencer este novo desa�o. Nesses
jogos, em geral, os desa�os são progressivos, e o jogadorespera isso.
Os jogadores esperam ser desa�ados.
Mesmo que a exploração de um jogo não seja completamente essencial ao
que podemos chamar de experiência pura de jogo, a possibilidade de
explorar um mundo novo pode proporcionar ao jogador uma experiência de
jogo mais rica e, com ela, os jogos podem se destacar de uma forma diferente
dos �lmes e livros, fazendo com que o jogador possa ter uma participação
mais vivida na história (III ROUSE, 2005).
Diversos motivos podem levar uma pessoa a jogar um jogo. Uma das maiores
provas é a quantidade de títulos e gêneros existentes no mercado. Muitos
títulos diferentes do mesmo gênero tentam possibilitar ao jogador reviver
sensações que viveu nos outros títulos - esse é um dos motivos de existirem
tantos jogos de zumbi, por exemplo.
Mas, em geral, podemos encontrar alguns fatores similares entre os jogos; um
bom gameplay e mecânicas são ingredientes que precisam estar presentes
em todos, pois essas são as dinâmicas básicas para todos os jogos, por mais
simples que seja.
Uma breve ideia sobre Game Design
Quando analisamos os padrões que o mercado de jogos tem mantido em
vários títulos diferentes, podemos ver que possuem uma característica muito
importante para os jogadores: eles funcionam.
Esses padrões são mantidos em diferentes títulos de jogos e em diferentes
empresas que os produzem. Como exemplo, temos jogos de tiro em terceira
pessoa e em primeira pessoa. Um padrão mantido nesses dois tipos são os
controles de movimentação dos personagens (apesar de existir a
possibilidade de mudarmos quais serão as teclas do teclado que farão estes
movimentos, em geral os jogadores as mantêm). Para citar algumas, temos as
teclas “W, S, D, A” que, em geral, são usadas para movimentar o personagem
que o jogador controla. Essas são apenas algumas das teclas que são
mantidas há muito tempo como padrão em vários jogos.
Podemos imaginar a jornada de um jogador como uma carreira no mundo
dos jogadores de jogos. Em geral, quando um novo título é lançado, e um
jogador experiente o joga, ele espera encontrar determinados controles e
ações que já vem aprendendo e desenvolvendo no passar de sua carreira de
jogador. Quando esse novo título não traz os padrões desejados pelo jogador,
ele pode encontrar di�culdades e reagir de forma negativa ao experienciar o
jogo.
Quando não corroboramos a essas expectativas, entramos em
uma arriscada área cinzenta, pois o jogador pode achar que seu
jogo frustra sua experiência, pois o jogo vai contra o que eles
aprenderam durante suas carreiras. Por exemplo, os jogos de
estratégia em tempo real (Real Time Strategy RTS) permitem
selecionar um grupo de unidades para dar ordens. A possibilidade
de arrastar uma caixa de seleção em torno de um grupo de
unidades é um recurso esperado de qualquer título do RTS. Ao não
implementar esse recurso, você basicamente aposta contra seus
jogadores: antes de fazer isso, dedique algum tempo para pensar
se realmente faz sentido para o seu jogo negar o que outros jogos
provaram ter funcionado bem (SCOLASTICI, 2013, p. 149, tradução
nossa).
Fazer um bom design para seu jogo é uma tarefa que requer prática, mas é
uma parte essencial, pois, sem pensar como o jogo deve reagir a
determinados comandos e a determinadas ações do jogador, entramos numa
área cinzenta, que pode ser uma grande vantagem (ou desvantagem), ainda
mais se esta funcionalidade que implementamos (ou deixamos de
implementar) seja de grande uso nos gêneros de jogos mais jogados no
mercado.
Uma dica que devemos seguir é sempre fazer uma pesquisa de mercado para
compreender melhor nosso público-alvo. É importante lembrar que sempre
devemos pensar em qual público desejamos atingir com nosso produto, pois
assim como há algum tipo de música ou �lme que não são do nosso agrado,
existem jogos que serão considerados ruins ou chatos por algumas pessoas.
Portanto, os criadores dos produtos devem entender melhor o que seu
público-alvo deseja consumir, para que assim tenham um melhor resultado
nas vendas.
Game Design Mobile
Os jogos mobile têm suas características especí�cas quando pensamos em
mecânicas que funcionam bem nesse tipo de plataforma. Podemos ver em
diferentes títulos e gêneros que um dos padrões adotados pela maioria dos
jogos mobile são as telas com pouca informação em tempo de jogo. Claro que
sempre existem os títulos que são o ponto fora da curva, mas devemos nos
lembrar de que, nesse universo, os jogos mobile são executados em
dispositivos com telas muito menores que as telas de um computador
padrão; por esse motivo, devemos tomar cuidado com a quantidade de
informação que colocamos em tela.
A interface do usuário de um jogo deve ser projetada levando em
consideração dois aspectos: qual é a aparência do jogo e quais são
as ações que o personagem principal executará e como. Comece
de�nindo uma lista de funções que devem ser incluídas na interface
do usuário, como pontuação, vida útil disponível, valor do dinheiro
real e virtual, mira e mini-mapa, o que for absolutamente
necessário para ser exibido na interface dos jogos (SCOLASTICI,
2013, p. 155, tradução nossa).
Ao tomar qualquer decisão quanto a funcionalidade e informações que serão
exibidas na tela de seu jogo, lembre-se da aparência dele, tenha sempre em
mente como deve ser e como deseja que se comporte. Esse é um dos grandes
motivos de criarmos tantos documentos para nos guiar até a conclusão de
nosso projeto.
Nunca subestime um bom design e uma boa prototipagem.
Devemos tomar cuidado com as promessas que fazemos aos jogadores
quanto ao funcionamento de nossos jogos. Os controles e os grá�cos são dois
dos fatores que mais afetam a experiência do jogador. Os controles devem
ser intuitivos e de fácil adaptação, ou seja, fáceis de aprender. Se tiverem
algum tipo de demora nas ações e não atenderem prontamente aos
comandos do jogador, seu gameplay estará comprometido e este jogo não
terá muito sucesso no mercado (SCOLASTICI, 2013).
Nem todos os projetos de jogos têm o intuito de serem produtos de prateleira
de alguma loja de jogos ou lojas virtuais de venda; um exemplo é o Pokemon.
O projeto não foi iniciado com intuito de venda, ou seja, com sentido
comercial. O criador principal do jogo, Sr. Tajiri, não pensou na popularidade
do jogo quando o desenvolveu, ele queria fazer algo que gostaria de jogar.
Por sorte, o que ele queria jogar foi bem aceito no mercado e teve uma
aceitação grande. Uma característica que podemos ressaltar neste projeto do
Pokemon foi o amor e a vontade de desenvolver o produto e, no �nal, o
mercado aceitou muito bem (ROUSE, 2005).
E esse é o ponto: não fazer algo vender, algo muito popular, mas
amar algo e fazer algo que nós criadores possamos amar. É o
sentimento central que deveríamos ter ao criar jogos. Shigeru
Miyamoto, falando sobre a criação de Pokemon (ROUSE, 2005, p.
1).
A paixão pelo desenvolvimento de seu projeto é realmente uma parte muito
importante para o sucesso do desenvolvimento de qualquer tipo de projeto
em qualquer tipo de atividade.
Uma outra parte muito importante, ainda mais quando falamos de jogos
mobile, são as interfaces dos jogos. A interface do usuário é um elemento que
afeta muito o gameplay de um jogo, é a parte que vai de�nir como o jogador
interage com o jogo e como ele conclui as tarefas dadas pelo jogo
(SCOLASTICI, 2013).
Quando um jogo tem uma interface bem criada, ou seja, quando o design é
bem feito, um jogo de mecânicas simples pode se tornar mais interessante.
Dessa forma, o jogo consegue atender às expectativas do jogador
(SCOLASTICI, 2013).
É sempre uma surpresa agradável para um jogador quando ele
percebe que pode executar alguma ação especí�ca exatamente
como ele a imaginou através da interface do jogo: se você
conseguir agradar muitos jogadores desta forma, seu jogo subirá
nas paradas de vendas! (SCOLASTICI, 2013, p. 147, tradução
nossa).
Segundo Scolastici (2013), mesmo que um jogo tenha muitas mecânicas
inovadoras, novos recursos,qualidade nos grá�cos, som e história, mesmo
com tudo isso, se o jogo não tiver uma boa interface, que seja intuitiva e
agradável, tem uma possibilidade grande de não vender bem. Sendo assim,
devemos nos atentar a vários aspectos na criação dos jogos, mas
principalmente devemos criar uma interface limpa e intuitiva para nossos
jogos.
Não existem padrões para criação dos jogos ou regras prede�nidas em
relação à criação de uma interface. Diferentes jogos têm diferentes mecânicas
e existem diversas maneiras de se implementar controles para estes jogos.
Podemos perceber que existem alguns elementos da interface do jogador que
são compartilhados entre jogos, sem depender do gênero (SCOLASTICI, 2013).
Para abordar a tarefa corretamente, é uma boa prática investir
algum tempo em pesquisa. Um bom ponto de partida é estudar os
aspectos gerais do design de interação. O design afeta a forma das
ferramentas que usamos em nossas atividades cotidianas em
qualquer nível e a psicologia cognitiva investigou minuciosamente
os meios para projetar interações efetivas entre os seres humanos
e as ferramentas e instrumentos que eles usam (SCOLASTICI, 2013,
p.148, tradução nossa).
Como pudemos ver, o design da tela do jogo em um dispositivo mobile é uma
tarefa muito importante, por isso devemos nos dedicar a criar uma interface
que seja amigável, reativa e precisa. Os jogadores de dispositivos mobile têm
a necessidade de jogos que tenham um tempo de reação rápida; em geral,
são jogos mais dinâmicos.
Devemos nos dedicar mais a essa parte do jogo, pois, caso não agrade o
jogador, o resto do trabalho será perdido, muitas vezes, sem serem testados
de forma adequada por causa de uma interface mal planejada. Em outras
palavras, podemos ter uma ideia e uma história com uma ótima mecânica,
mas isso tudo só será apreciado pelo jogador se os controles tiverem o
mesmo nível de qualidade que o resto do jogo.
Devemos ter em mente o que já foi dito anteriormente: por mais que seja um
jogo simples de poucas mecânicas, precisa ter bons controles e uma boa
interface com o usuário. “Qualquer jogo deve fornecer ao jogador
informações para entender se ele está ganhando ou perdendo” (SCOLASTICI,
2013, p.148, tradução nossa).
Uma breve prototipação
A prototipação é um estágio muito importante na arte do desenvolvimento de
jogos. Mesmo que o desenvolvedor tenha todas as ferramentas para realizar
o desenvolvimento, sem um objetivo e caminho a seguir, o projeto não terá
para onde ir.
Breve prototipagem do jogo
Para simpli�car esta parte, vamos pensar em como o jogo deve ser, descrever
as funções e como o ambiente do jogo será montado. Nesse jogo plataforma,
teremos:
Personagem Principal
Rei
Inimigos
Itens coletáveis
Plataformas
Portas
Alavancas
Pulo
Ataque
Armadilhas
Mostrador de Vida
Mostrador de Pontos
Tela de Menu
Botão Start
Botão Créditos
O objetivo do jogo será descobrir a combinação correta de alavancas para que
possamos abrir as portas e o jogo prosseguir.
A ideia principal é que devemos salvar um Rei, que está localizado em alguma
parte do castelo.
Precisaremos também de algum tipo de controle para que o jogador possa
interagir com o jogo. Lembre-se de que estamos desenvolvendo um jogo para
um celular, ou seja, um aplicativo mobile, portanto devemos nos atentar para
algumas diferenças que somente os aplicativos mobile têm em relação ao
funcionamento do jogo e aparência. “Com tantos tamanhos de tela diferentes,
tão pouco espaço para trabalhar e nenhum padrão real no setor de
videogames, o design de interface é uma das partes mais difíceis da criação
de um jogo de sucesso” (SCOLASTICI, 2013, p.147, tradução nossa).
Em geral, os celulares têm boas resoluções de tela, e há celulares com
tamanhos de telas variados. Vamos pensar em um tamanho de tela
minimamente aceitável em relação a tamanho de aparelho (lembre-se que é
um celular, não um tablet). Vamos então pensar em um padrão de tela de 5
polegadas e usar uma tela com o tamanho de Full HD em pixel - ela �ca com
1920 de largura por 1080 de altura, no estilo de tela “Landscape”, ou
panorama.
A Figura 3.1 mostra o resultado ao qual desejamos chegar em nosso projeto
do jogo plataforma. É importante lembrar que a �gura é meramente
ilustrativa e, depois que você dominar todas as ferramentas, poderá
remodelar o jogo a seu gosto. Podemos ver na �gura:
Personagem
Inimigo
Itens coletáveis: Esmeraldas
Plataformas
Botões: Direita, Esquerda, Pulo, Ataque, Interação
Marcadores: Vida, Pontuação
Figura 3.1 - Print da Prototipagem
Fonte: Elaborada pelo autor.
Para compor este projeto, vamos usar assets diferentes. Na sequência, segue
uma lista de todos os nomes dos pacotes de assets que são disponibilizados
no site da Unity Asset Store. Inclua-os em seu projeto para que possa chegar
no mesmo resultado visual que o demonstrado aqui.
Lista:
Flat Platformer Template
Free Game Items
Medieval pixel art asset FREE
Tasty Characters - Castle Pack
Faça uma busca no site AssetStore da Unity com esses nomes, e encontrará
exatamente os mesmos pacotes.
Lembre-se de que pode encontrar imagens gratuitas em outros sites e(ou)
fazer as suas próprias imagens.
saibamais
Saiba mais
Este asset chamado “Trollnest” é o asset que
usamos para criar os botões de ataque, pulo,
interação, direita e esquerda. Perceba que os
botões direita e esquerda são iguais; basta
rotacioná-los para que �quem na posição
desejada. O botão de pulo é muito parecido
com os de direita e esquerda, mas as
imagens dentro do pacote são diferentes.
Saiba mais no link a seguir.
ACESSAR
https://assetstore.unity.com/packages/2d/gui/icons/trollnest-free-ui-buttons-140934
Para que possa usar essas imagens em seu projeto da Unity, basta arrastar a
imagem de dentro de uma pasta de seu computador direto para uma das
pastas de sua preferência dentro da aba “ Project ” dentro da Unity.
Nesse caso, sugiro que crie uma nova pasta onde irá agrupar as imagens;
assim, terá sempre um projeto bem organizado e vai encontrar as imagens de
forma mais fácil.
Tenha em mente que aqui queremos demonstrar a criação do jogo e, como
algumas mecânicas podem ser criadas, a parte principal será feita por você no
momento que dominar as técnicas apresentadas através dessas linhas. O
objetivo do material é salientar os aspectos de criação de um jogo e os
possíveis caminhos que pode você tomar. Sua criatividade fará o resto.
saibamais
Saiba mais
Para criarmos nossos projetos, devemos
lembrar que não é só a Unity que
disponibiliza conteúdos de forma gratuita. O
site itch.io, por exemplo, também tem muitos
conteúdos que podemos usar de forma
gratuita. Para que possamos ver isso em
ação, vamos usar esta imagem de coração
em nosso projeto. Será usada para
simbolizar a quantidade de vida que nosso
personagem ainda tem. Acesse o link a
seguir.
ACESSAR
https://gpway.itch.io/2d-hearts
praticar
Vamos Praticar
Na criação de um jogo, podemos ver que existem vários passos que devemos seguir
e muitos caminhos que podemos escolher até chegarmos à conclusão. Os desa�os
que o projeto vai nos apresentar com o passar do tempo serão conhecidos quando
chegarmos até eles. Pensando dessa forma, escolha a alternativa correta que traz a
parte mais importante na criação de um jogo.
a) Todo jogo precisa de uma boa história.
b) Todo jogo precisa de um bom personagem principal.
c) Todo jogo precisa de um bom inimigo.
d) Todo jogo precisa de boas mecânicas.
e) Todo jogo precisa de uma boa interface.
Vamos dar partida neste projeto. Com a nossa planta baixa, ou “Blueprint”,
podemos nos focar em preparar nossa ferramenta.
A primeira ação que devemos tomar após a criação do novo projeto e a Unity
�nalizar sua montagem e nos liberar para começar é a de�nição do “ Aspect
Ratio ”, ou seja, devemos de�nir a resolução da tela. Isso é feito na aba “
Game ”. Abaixo do nome da aba, vamos usar o tamanho em Full HD de (1920
x 1080) “Landscape”, ou panorama. Vamos de�nir uma tela deitada, poispara
o tipo de jogo que projetamos, será a melhor opção; além disso, precisamos
aproveitar o espaço da tela do celular.
Para que essas con�gurações sejam exibidas, precisamos mudar o “ build ” da
Unity. Seguiremos o caminho: File > Build Settings > selecionar a plataforma
Início doInício do
DesenvolvimentoDesenvolvimento
dos Jogosdos Jogos
Plataforma: NovasPlataforma: Novas
FerramentasFerramentas
Android e pressionar o botão “Switch Platform” e pronto; as opções de
tamanho de tela vão aparecer no “ Aspect Ratio ” da aba “ Game ”.
Lembre-se de que, apesar dos modelos mais novos virem equipados com
telas com resolução de 4K, as telas são pequenas, variando de 4 a 6 polegadas
nos modelos mais comuns. Por esse motivo, devemos aproveitar bem esse
espaço; não podemos nos esquecer de que os componentes da tela precisam
�car visíveis para que o jogador possa fazer uso deles.
Com a parte da resolução resolvida, vamos aprender uma nova
funcionalidade na Unity, o “ Tilemap ”.
saibamais
Saiba mais
Pesquisa sobre tamanho de tela de celular
pelo mundo revela que o tamanho médio de
tela é de 5 polegadas. Em geral, cada país ou
região tem suas próprias preferências e
descartam o uso de outros tamanhos de
celulares.
Esta pesquisa é interessante, pois quando
pensamos em fazer jogos para celular,
devemos saber que existem tamanhos que
serão muito pequenos para exibirem de
forma correta os botões e imagens
apresentados em nossos jogos. Saiba mais
acessando o link a seguir.
ACESSAR
https://www.tudocelular.com/android/noticias/n119931/tamanho-tela-mais-popular-mundo.html
O  “ Tilemap ” é um objeto que vamos criar dentro da nossa aba “ Hierarchy
”. Clique com o botão direito do mouse dentro desta aba, selecione o grupo
dos objetos 2D “ 2D Object ” e então o objeto “ Tilemap ”. Perceba que o
objeto que aparecerá terá o nome de “ Grid ” e, dentro dela, ou seja, sua “
child ” terá o nome de “ Tilemap ”.
Tilemap : É composto por uma “grid”, ou em português grade. Esta é
usada para dividir o espaço da tela; assim podemos montar o mapa
com os “ tiles ”. A tradução mais próxima para  “ Tilemap ” é mapa de
ladrilhos; é basicamente uma grade com espaços quadrados de
tamanhos iguais que devemos preencher com os “ tiles ”.
Vamos mudar o nome da “ child ” para “ Plataforma ”, pois será onde
colocaremos nossas plataformas, ou seja, será o local onde vamos colocar os
“tiles” nos quais o personagem, os inimigos e os itens irão �car em cima,
literalmente.
Ao lado do campo onde colocamos o nome do objeto, na aba “ Inspector ”,
veja que existe um campo chamado “ Static ”. Devemos marcar esse campo
para que a Unity entenda que os “ tiles ” desse objeto serão estáticos - não
desejamos que sejam movimentados.
Sabemos que você deve estar pensando: “mas eu queria fazer uma
plataforma que se movesse da direita para a esquerda igual às que aparecem
nos jogos do Mario”. Fique tranquilo! Veremos esse tipo de plataforma mais à
frente; vamos chegar lá.
Agora que selecionamos como estático, estes “ tiles ” vão reagir de modo
diferente à gravidade que teremos no jogo. Por exemplo, não vão cair da tela
do jogo, �carão travados estaticamente em seus lugares.
Abaixo do campo “ static ”, temos o campo “ layer ”. Nesse campo, devemos
criar o “ layer ” Plataformas no “ layer ” de posição 10.
Layer : A tradução desta palavra é “camada”. As camadas são usadas
para criar nossas fases do jogo. A câmera é usada para renderizar a
parte desejada da cena, também é usada para se saber a parte da
cena que deve ser iluminada.
Em seguida, no componente “ Tilemap Renderer ” no campo “ sorting layer
”, devemos criar também o “ layer ” Plataformas.
Sorting layer : Este campo trata da ordem dos “layers”, cuida da
sobreposição das camadas no momento da “renderização”.
Para que possamos desenhar o level/nível/fase, devemos colocar na tela da
Unity a janela “ Tile Palette ”. Para isso, devemos ir à barra superior da janela
da Unity no caminho: Window > 2D > Tile Palette . Podemos ver como fazer
na Figura 3.2.
Perceba que esta nova tela que criamos �cou solta, ou seja, �cou fora da tela
da Unity. Clique com o botão direito do mouse em cima do nome da tela e a
faça  virar uma aba da tela da Unity arrastando-a para baixo da aba “ Scene ”,
ao lado da aba “ Game ”.
Veja que, como já havíamos importado o “ Asset ” “ Medieval Pixel Art Asset
Free ” e ele traz consigo uma paleta de “ tiles ” que �ca na pasta
“Assets/Medieval_pixel_art_asset_FREE/palettes/Tiles_free.prefab”, a Unity a
reconhece e traz para dentro da nova aba “ Tile Palette ” este prefab com o
Figura 3.2 - Print Tile Palette
Fonte: Elaborada pelo autor.
nome de “ Tiles_free ”. Caso deseje criar ou selecionar outra paleta, isso pode
ser feito no campo logo abaixo do nome da aba “ Tile Palette ”. Esse campo
tem o nome da paleta selecionada ou está sem nome e pede para que seja
criada uma nova paleta. Para isso, clique no campo que está com o nome da
paleta e selecione “Create New Palette”. Uma aba abrirá abaixo do campo em
que você clicou com os campos: nome, grid e cell size.
Nome : nome da nova paleta.
Grid : modelo da grade que deseja criar. Essa grade é referente ao
tipo de tile que deseja importar para esta paleta: retangular ,
hexagonal ou isométrico .
Cell Size : refere-se ao tamanho do tile dentro da Grid. Em geral,
podemos deixá-lo em automático, para que a Unity possa detectar
automaticamente o tamanho das células de acordo com a imagem
que desejamos importar.
Podemos ver um exemplo na Figura 3.3, que traz a ilustração desta ação de
criar uma nova paleta. Perceba que, após clicar em uma nova tela, ela se
abrirá e nela devemos selecionar uma pasta para onde as informações serão
enviadas.
Figura 3.3 - Print Tile Palette: Criando paleta
Fonte: Elaborada pelo autor.
Cada um desses tiles tem o mesmo tamanho, portanto todos se encaixam
perfeitamente em relação aos seus tamanhos. Em geral, esta modalidade de
criação de jogo depende de tiles que sejam do mesmo tamanho; só
precisamos nos atentar aos tiles que formam combinações. A Figura 3.4 traz
um exemplo de algumas combinações, além das combinações que a paleta já
trouxe.
Figura 3.4 - Print Tile Palette
Fonte: Elaborada pelo autor.
Veja na Figura 3.4 que conseguimos formar com os tiles que já compõem a
paleta sequências de tiles que se encaixam bem; à esquerda a unidade que
usamos para compor a sequência de tiles que seguem à direita.
Podemos ver nesta Figura 3.4 que ela está ocupando toda a tela da Unity ou
boa parte dela. Para maximizar a aba “ Tile Palette ”, basta clicar com o botão
direito do mouse sobre seu nome e escolher a opção “Maximize”. Quando
quiser que a paleta volte ao tamanho anterior, basta fazer o mesmo processo.
Perceba que, quando a paleta está maximizada, um sinal azul aparecerá ao
lado esquerdo de “Maximize”. Isso indica que a paleta está selecionada,
portanto, ao clicar novamente em “Maximize”, o sinal será retirado. Teste esta
ação e veja o resultado. Você poderá ver que, dessa forma, �ca mais fácil
organizar os tiles dentro da paleta.
Provavelmente você deve estar se perguntando como fazer para criar
sequências de tiles como mostra a Figura 3.4. Trataremos disso, mas, antes,
vamos falar sobre as ferramentas presentes dentro da aba “Tile Palette”. Veja
na Figura 3.5 a barra de ferramentas que está presente dentro dessa  aba.
Figura 3.5 - Print Tile Palette: Ferramentas
Fonte: Elaborada pelo autor.
Vamos seguir os nomes, a sequência e as teclas de atalho de cada uma das
ferramentas para descrever suas funções:
Select Tool (S) : use esta ferramenta para selecionar um tile
desejado, ou mantenha o botão esquerdo do mouse apertado para
criar uma caixa de seleção maior e selecionar mais de um tile.
Perceba que, ao selecionar um tile, suas informações aparecem na
aba “ Inspector ”. Quando selecionamos um ou vários tiles, podemos
usar a ferramenta “ Move Tool ” para movê-los para outra posição na
“ Tile Palette ” ou na aba “Scene ”.
Move Tool (M) : para que esta ferramenta funcione, precisamos
fazer uma seleção de um ou mais de um tile com a ferramenta de
seleção “ Select Tool ”. Com a seleção feita, podemos então mover
estes tiles para outra posição na Scene. Da mesma forma, podemos
selecionar e mover um ou vários tiles na aba “ Tile Palette ”, mas,
para isso, é necessário que o modo de edição da aba “ Tile Palette ”
esteja ligado.
Paintbrush Tool (B) : para que a ferramenta pincel funcione,
precisamos selecionar um ou vários tiles. Para isso, pressione a tecla
“ Ctrl ” do teclado e clique no tile desejado tanto na aba “ Scene ”
quanto na aba “ Tile Palette ”. Para selecionar mais de um tile,
pressione a tecla   “Ctrl” e crie uma caixa de seleção do tamanho
desejado.
Box Fill Tool (U ): use esta ferramenta para selecionar um ou vários
tiles de uma só vez. Com a seleção feita, use a ferramenta para criar
uma ou várias réplicas da seleção que fez. Para isso, com a
ferramenta selecionada, clique na aba “ Scene ” e arraste o mouse,
gerando uma caixa de seleção que será preenchida com a seleção
feita anteriormente. Quando a caixa for maior que a seleção feita, os
tiles começarão a ser replicados. Teste para ver o funcionamento.
Picker Tool (I) : esta ferramenta é usada para copiar um ou vários
tiles, tanto da aba “ Scene ” quanto da aba “ Tile Palette ”. Após fazer
a seleção, a Unity fará a troca da ferramenta “ Picker Tool ” pela
ferramenta “ Paintbrush Tool ”.
Eraser Tool (D) : esta ferramenta é usada para apagar um ou vários
tiles da aba “ Scene ”, ou da aba “ Tile Palette ”, mas, para apagar da
aba “ Tile Palette ”, ela  precisa estar em modo de edição “Edit”. Para
fazer a ferramenta borracha ter o tamanho de mais de um tile, basta
clicar nela e arrastá-la na aba “ Tile Palette ” com o modo de edição
desligado, e depois usá-la na aba “ Scene ”. Para usá-la em um
tamanho maior na aba “ Tile Palette ”, basta, antes de ligar o modo
de edição, fazer a seleção da ferramenta e arrastá-la para que �que
do tamanho desejado; após isso, deve-se ligar o modo de edição.
Fill Tool (G) : esta ferramenta serve para preencher um espaço com
cópias do mesmo tile, e não conseguimos selecionar mais de um tile
por vez.
Uma dica : Para que compreenda melhor o funcionamento dessas
ferramentas, antes de começar a desenhar o jogo, faça alguns testes e
familiarize-se com as ferramentas antes de prosseguir.
Abaixo dessas ferramentas, temos a possibilidade de selecionar o “ Tilemap ”
que desejamos alterar no campo de nome “ Active Tilemap ”. Nesse campo,
apareceram todos os “ Tilemap ” que estão criados na “Grid” que está na aba
“ Hierarchy ”. Quando um “ Tilemap ” for selecionado, seu nome será
destacado pela Unity na aba “ Hierarchy ” com uma caixa amarela. Os tiles
que forem pintados na aba “ Scene ” pertencerão a esta camada do “ Tilemap
”. Isso signi�ca que, quando selecionamos o “ Tilemap ” que criamos com o
nome de “Plataforma” em que foi marcada a opção “ Static ”, todos os tiles
que forem pintados na aba “ Scene ” vão pertencer a este   “ Tilemap ” de
nome “Plataforma”.
Para que possamos selecionar um tile dentro da paleta “ Tile_Free ” e para
que seja possível criar novas formações de tiles dentro da paleta com os tiles
lá existentes, precisamos ligar o modo de edição. Para isso, devemos clicar no
botão “Edit” que �ca abaixo do nome da paleta e ao lado do seletor de
paletas; assim poderemos criar outras estruturas dentro da paleta, como
mostra a �gura 3.4.
Veja na Figura 3.8 que existem alguns tiles que estão em posições diferentes
dentro da paleta, estão inversos a outros que pertencem à mesma paleta.
Para que possa fazer isso, será necessário que abra a imagem que contém os
tiles que desejamos alterar em um editor de imagem; ela está localizada nesta
pasta:
“Assets/Medieval_pixel_art_asset_FREE/Textures/Medieval_tiles_free.png”.
Existem programas gratuitos muito bons na internet. Um de nossa
preferência é o “Paint.net”. Trata-se de um programa fácil de se usar e fácil de
se aprender a usar. Além disso, trabalha com camadas e, quando você
aprender a usá-lo de forma �uente, verá que é um ótimo editor para este tipo
de trabalho.
saibamais
Saiba mais
O programa Paint.net é muito versátil e
simples de se usar. Com pouco tempo de
prática, você verá que é um ótimo programa
para auxiliá-lo na edição de imagens para
este tipo de �nalidade de edição. Uma de
suas maiores vantagens é seu
funcionamento por camadas. Este
funcionamento é muito útil quando
desejamos criar cenários e até mesmo
desenhos com �ns de animação 2D. Acesse o
link a seguir.
ACESSAR
Não vamos entrar em muitos detalhes sobre como funciona um programa
editor de imagem, mas vamos compreender melhor sobre o funcionamento
da Unity quanto a incluir uma imagem de fora de um “ Asset ” que foi baixado
na “ Asset Store ”.
Veja na Figura 3.6 que, ao selecionar a imagem que foi alterada, a Unity não a
reconhece mais como um Atlas de imagens, ou seja, precisamos fazer as
divisões dos tiles desta imagem para que a Unity reconheça todos os tiles de
maneira individual e para que então possamos selecionar esta imagem e
fazer dela uma nova “ Tile Palette ”. Sendo assim, precisamos clicar no botão
“Sprite Editor” que está na aba “ Inspector ” do lado direito da tela. Essas
informações sobre a imagem vão aparecer quando �zermos a seleção da
imagem, ou seja, precisamos clicar na imagem e essas informações vão
aparecer na aba “ Inspector ”. Lembre-se: esta imagem já foi alterada em um
programa de edição.
https://www.getpaint.net/
A Figura 3.7 mostra a tela do “ Sprite Editor ”. No canto superior esquerdo,
temos o nome escrito na sua aba. Abaixo temos o botão “ Slice ”, que quer
dizer fatia. Esse é o botão que precisamos usar para fatiar a imagem que foi
editada. Após o fatiamento, a imagem será reconhecida pela Unity e
poderemos usar suas fatias como os tiles que conhecemos anteriormente.
Para fatiar essa imagem, precisamos saber quais são as dimensões dos tiles.
Como foi feita a sua edição no editor que foi mencionado anteriormente, sei
que cada tile tem o tamanho de 48x48 pixels e, como temos uma pequena
distância do primeiro tile do canto esquerdo superior da imagem, precisamos
saber esta distância também, que é de 16 pixels.
Podemos ver na aba que se abriu ao clicar no botão Slice que temos alguns
campos que precisam ser preenchidos para que possamos fazer o corte da
imagem. Vamos falar apenas dos campos que serão usados.
Os campos são:
Type : este campo deve ser selecionado como “ Grid by cell Size ”, ou
seja, quando selecionarmos o tamanho do “ Pixel Size ”, e do “ O�set
”, a grid será cortada de acordo com esses valores.
Pixel Size : é o tamanho da célula, ou seja, é o tamanho da imagem
que vai compor o tile; neste caso ( x = 48) e (y = 48).
Figura 3.6 - Print Edição de Imagem
Fonte: Elaborada pelo autor.
O�set : é o espaço que temos que dar de (x = 16) e (y = 16), pois a
imagem não está começando no primeiro pixel da �gura.
Pivot : este valor está como centro; ele representa o ponto de
rotação desta imagem. Imagine que deseja colocar uma �gura que
precisa ter a rotação em alguma parte da imagem. Para isso,
podemos arrastar o pivot ou pivô da imagem para onde for melhor.
Quando todos esses campos estiverem com seus valores preenchidos e
escolhidos, podemos clicar no botão “Slice”.
Para compreender melhor como funciona esta ferramenta de corte,
experimente outras con�gurações e veja o resultado. Se selecionar
automático, verá que o corte será feito em blocos de imagem. Podemos
selecionar este corte e pressionar a tecla delete do teclado e criar um novo
corte com o mouse, clicando com o botão direito do mouse e arrastando para
de�nir um tamanho. Após criar esse corte, poderá redimensioná-lo com o
mouse clicando em um de seus cantos, simbolizados por círculos azuis.
Perceba que, no meio desta seleção, existe um anel azul, que pode ser
movido para qualquer parte da seleção. Ele representa o pivôda imagem.
Podemos ver os cortes em verde na Figura 3.7; e no primeiro tile que está na
parte superior esquerda da imagem, podemos ver o pivô e os círculos azuis.
Por �m, precisamos con�rmar as alterações. Para isso, pressione o botão “
Apply ”, que �ca à direita da tela no canto superior.
Figura 3.7 - Print Editor de Imagem
Fonte: Elaborada pelo autor.
Após aplicar as alterações, podemos criar uma nova “ Tile Palette ”. Em
seguida, arrastar a nova imagem para dentro da aba “ Tile Palette ”, que a
imagem será importada e a paleta estará pronta para uso.
Selecione a imagem que acabou de fatiar, vá até a aba “ Inspector ” e
veri�que se o campo “ Pixel Per Unit ” está com o mesmo valor que
determinou para seu tile. Nesse caso, o valor era de 48. Caso não esteja com
esse valor, altere; caso contrário, terá problemas com tamanho da imagem do
pixel na tela do jogo.
Pintando Tilemap: Fundo e Plataforma
Veja na Figura 3.8 que existe uma ferramenta de foco. Ela  aparecerá na aba “
Hierarchy ” logo após criarmos o “ Tilemap ” que �ca dentro do objeto
chamado “Grid”. A ferramenta foco está situada no canto inferior direito da
aba “ Scene ”; seu único campo tem o nome de “ Focus On ”, que signi�ca
focar em. Ela serve para dar foco ou em um “ Tilemap ” ou na “Grid” inteira,
ou seja, em todos os “ Tilemaps ”  que estão na grid. Ainda existe mais uma
opção, que é não dar foco em nenhum “ None ”.
Este foco serve para salientar em qual “ Tilemap ” estamos desenhando os
tiles. Dessa forma, quando pintamos um tile na aba “ Scene ”, �ca colorido,
pois o “ Tilemap ” que estamos pintando está focado, igual mostra na Figura
3.8. Podemos ver na �gura que existe uma parede atrás dos tiles que estão
coloridos. Essa parede está em outro “ Tilemap ” e o foco está no “ Tilemap ”
onde estão os tijolos coloridos. Assim �ca mais difícil pintarmos os tiles em “
Tilemaps ” errados, pois vamos ver mais à frente que vamos dividir em
camadas de tiles. Os tiles que são plataforma e terão colisão �carão em um “
Tilemap ” diferente dos tiles que vão compor o fundo da fase.
Agora que sabemos como usar a paleta e o foco, podemos pintar nosso
cenário. É interessante começar a construção do nível através dos tiles que
serão usados para colisão, ou seja, vamos começar com o chão, as paredes, o
teto e as plataformas e depois pintamos o fundo.
Um aspecto importante é saber qual será o tamanho do nosso personagem, o
tamanho dos inimigos e qualquer outro objeto de nosso jogo que se
movimenta de um lado para o outro, para que não façamos todo o trabalho e
depois tenhamos que refazê-lo pelo fato de o personagem não passar por
algum lugar que deveria passar; a mesma coisa com os inimigos e todo o
resto.
Veja na Figura 3.9 um esboço de como deve �car o primeiro nível. Aqui vamos
ensinar ao jogador as mecânicas básicas do jogo.
Figura 3.8 - Print Tile Palette: Ferramentas
Fonte: Elaborada pelo autor.
Vamos de�nir a altura do personagem em dois tiles de altura e um tile de
largura. Assim podemos de�nir quais espaços o personagem poderá ocupar;
as passagens para o personagem vão depender do level design que você
escolher fazer.
O level design é simplesmente fazer o design das fases do jogo, saber onde
vão �car as plataformas que o jogador poderá usar para pular e chegar ao seu
objetivo e tudo mais que vai compor a fase. Nesse caso, o objetivo será
chegar até as alavancas e liberar as portas. Assim, o jogador poderá avançar
no jogo e chegar ao objetivo �nal, que é encontrar o Rei.
Antes de continuarmos, uma dica rápida: caso feche, por acidente, uma das
abas principais, como a aba “ Inspector ”, você poderá reabri-la seguindo este
caminho: Windows > General > Inspector , ou usando as teclas de atalho
(Ctrl + 3).
Em seguida, precisamos fazer com que os tiles da plataforma possibilitem a
colisão. Para isso, precisamos adicionar um componente “ Rigidbody 2D ”,
alterar o campo “ Body Type ” para “ Static ” e marcar o campo “ Simulated ”.
Body Type : existem três opções de tipo de corpo (Body Type):
Dinâmico (Dynamic), Cinemático (Kinematic) e Estático(Static). Cada
Figura 3.9 - Print Fase 1
Fonte: Elaborada pelo autor.
corpo de�ne como o componente Rigidbody 2D reagirá à colisão, à
movimentação, à rotação e à escala.
Simulated : ativando esta opção, será habilitada ao Rigidbody 2D e a
todos os colliders que estiverem atrelados ao mesmo objeto a
interação com a física quando o jogo estiver rodando. Ela precisa
estar ativada para que as simulações físicas sejam feitas.
Para concluir, precisamos adicionar o componente “ Tilemap Collider 2D ”.
Nele não precisamos modi�car nada.
Até aqui só criamos nosso “ Tilemap ” das plataformas e paredes. Vamos criar
mais um “ Tilemap ” dentro do objeto “Grid” que está na aba “ Hierarchy ”.
Vamos chamá-lo de “ Plano_De_Fundo ”. Nosso plano de fundo é o “ Tilemap
” que terá os detalhes da fase. Esses detalhes não terão colisão com o
personagem. Sendo assim, não precisaremos adicionar no “Plano_De_Fundo”
componentes de colisão nem de corpo físico.
Agora que temos dois “ Tilemap ” dentro do objeto “Grid”, teremos o fundo
do jogo e a parte das plataformas. A Figura 3.9 demonstra o resultado a que
podemos chegar com estes dois “ Tilemap ” juntos.
Para garantir a renderização correta, crie para o “Plano_De_Fundo” um novo “
Sorting Layer ”, “ Tag ” e “ Layer ”. Veja que a ordem do “ Sorting Layer ”
deve ser do que vai �car no fundo para quem vai �car na frente, ou seja, o “
Sorting Layer ” do plano de fundo deve ser o último da lista. O campo “
Sorting Layer ” é que vai determinar qual será renderizado primeiro.
saibamais
Saiba mais
Pesquisa mostra a porcentagem de homens
e mulheres que jogam algum tipo de jogo em
seus dispositivos mobiles. A pesquisa feita
em 2016 mostra a porcentagem de pessoas
que jogam algum tipo de jogo em vários tipos
de consoles. Por incrível que pareça, o celular
é a plataforma mais utilizada para jogar. Os
motivos para criar jogos para dispositivos
mobile só crescem. Saiba mais acessando o
link a seguir.
ACESSAR
praticar
Vamos Praticar
Para pintar os tiles na tela do jogo dentro do projeto da Unity, precisamos de uma
aba especí�ca para que seja possível criar e manipular novas paletas de tiles. Essa
aba é a Tile Palette. Precisamos dela sempre que for necessário criar uma nova fase
no projeto. Selecione a alternativa que traz qual é o caminho que devemos seguir
para criar uma Tile Palette.
https://www.mobilegamer.com.br/2016/07/gamer-brasileiros-gastam-de-5-a-15-reais-em-jogos-para-celular.html
a) Scene> Palette >Tile Palette
b) GameObject> 2D>Tile Palette
c) Hierarchy> 2D Object> Tile Palette
d) Window> 2D> Tile Palette
e) Window> Tile> Tile Palette
Neste ponto, já temos um esboço de um nível pronto para receber o
personagem principal. É com ele que vamos testar se o nível está funcionando
da forma correta e se podemos continuar a produção do projeto sem
problemas com o level design.
Para criar o personagem principal, vamos começar com um objeto vazio;
vamos mudar o nome dele para “ Player ”. Em seguida, vamos colocar
algumas “ Sprites ” dentro deste objeto “ Player ”, uma “ Sprite ” para o
corpo, para cada braço, para cada perna e uma para a espada. As “ Sprites ”
dos braços vamos colocar dentro de outro objeto. Então devemos criar um
novo objeto vazio dentro do “ Player ”, de nome “ Arms ”. O nome em inglês é
só para não usar o “ç” e nenhum tipo de acento, nada que não tenha no
idioma inglês. Pelos motivos já sabidos, isso pode gerar con�ito depois, por
isso evitamos acentos e outras letras que não estejam no alfabeto americano.
Após criar e nomear o objeto “ Arms ”, arraste as duas “ Sprites ” dos braços
Criando eCriando e
Parametrizando oParametrizando o
PersonagemPersonagem
PrincipalPrincipal
para dentro dela. Os braços podemos dar o nome de “ Arm D ”, que é o braço
direito e ao braço esquerdo daremos o nome de “ Arm E ”. Para as pernas, a
mesma coisa. Crie um novoobjeto vazio dentro do “ Player ”, dê o nome a
este objeto de “ Pernas ”, arraste as pernas para dentro dele, e dê o nome das
pernas de “ Perna D ” e “ Perna E ”. Por �m, crie um objeto vazio dentro do “
Player ” chamado “ Arma ”. Dentro dele, arraste a “ Sprite ” “Espada” para
dentro e mude o nome da “ Sprite ” para “Espada”.
Neste ponto, não temos imagem nenhuma dentro dos objetos “ Sprite ”.
Vamos usar as que estão nesta pasta: “Assets/Flat Platformer
Template/Sprites/Characters.png”>. Aqui temos quatro personagens de cores
diferentes, espadas diferentes e um cavalo. Escolha o personagem da cor que
preferir e monte dentro das “ Sprites ” correspondentes. No �nal, deverá ter
um resultado parecido com o da Figura 3.10.
Figura 3.10 - Print do Personagem Principal
Fonte: Elaborada pelo autor.
A cor que escolher é irrelevante, pois vamos usar outro “ Asset ” para
construir o inimigo. Caso não tenha escolhido o cavalo, o seu personagem
deve ter �cado muito parecido com este; monte-o da maneira que achar mais
interessante.
Vamos fazer o nosso personagem ganhar vida. Adicione ao objeto “ Player ”
uma “ Tag ” e um “ Layer ”, com o nome de “ Player ”. Em seguida, adicione ao
objeto “ Player ”  um componente “ Rigidbody 2D ”. Nesse componente, deixe
parametrizado da seguinte forma: Body Type = Dynamic, Simulated =
marcado, Mass = 3, Gravity Scale = 2, Collision Detection = Continuous,
Interpolate = Interpolate. No campo Constraints, clique na seta para que ele
se abra e marque apenas o Freeze Rotation Z.
Body Type : aqui de�nimos o tipo do corpo (Rigidbody) que vamos
trabalhar. De�nindo o corpo como dinâmico (Dynamic), estamos
avisando para a Unity que este corpo pode se mexer, ao contrário do
estático.
Mass : aqui de�nimos a massa corpórea do componente Rigidbody.
Gravity Scale : podemos marcar a gravidade por meio de um valor
escalar; com isso, escolher o grau que o corpo será afetado pela
gravidade.
Collision Detection : escolhendo a forma contínua (Continuous),
informamos para a Unity que esta colisão será analisada mais vezes
do que a discreta (Discrete).
Freeze Rotation : tente posicionar o personagem na beirada de uma
plataforma. Sem marcar esta opção, verá que ele vai tender para o
lado que estiver mais fora da plataforma e cairá deitado. Marcando
esta opção, evitaremos a rotação no eixo Z.
Em seguida, no objeto “ Corpo ”, adicione um componente “Box Collider 2D”,
ajuste este componente para que �que o mais próximo possível dos limites
do corpo do personagem.
No objeto “ Pernas ”, adicione um componente “ Capsule Collider 2D ”, altere
o campo Direction para Horizontal e deixe-o dois ou três pixel acima da linha
do pé do personagem e uns 10 pixel acima do limite de onde acaba o corpo.
Ele �cará reto na parte de cima e na parte de baixo, mas arredondado nas
laterais. Isso nos ajudará  a fazer o personagem andar com mais �uidez.
Por �m, adicione um novo objeto vazio e dê a ele o nome de “ Down ”;
adicione um componente “ Box Collider 2D ” e deixe-o com a largura das
pernas do personagem, mas com a altura bem baixa, como se fosse um
sapato; e deixe a parte de baixo do componente um pouco abaixo do limite
do pé do personagem. Para �nalizar, ligue o campo “ Is Trigger ” do
componente.
Deixe o personagem em algum lugar alto e execute o jogo, para que, quando
o jogo for executado, ele possa cair em cima de uma plataforma e, dessa
forma, vamos testar a sua colisão.
Fazendo o Personagem Se Mover
Vamos criar um “ Script ” dentro do objeto “ Player ” e dar a ele o nome de “
Player Move ”. Dentro desse novo “ Script ”, vamos colar o código a seguir.
Vamos falar sobre o código:
[Range(0, 10000f)] : este comando determina a criação de uma barra
que será usada para determinar o valor de 0 a 10000 de uma
variável. Essa barra aparecerá no Script dentro da aba Inspector.
Dir : variável booleana, que determina a direção. Se é verdadeiro, vai
para um lado; se falso, vai para o outro. Variáveis booleanas só têm
dois valores válidos, verdadeiro ou falso.
Awake() : este método é executado logo após o objeto ser criado
pela Unity dentro do jogo sendo executado.
Input.GetAxisRaw : recebe um valor bruto que pode ser -1, 0 ou 1;
precisa ser suavizado. Este valor muda com a direção que o
personagem aponta, e �ca em zero quando ele está parado.
Input.GetKeyDown(KeyCode.Space) : para nossos primeiros testes,
vamos receber as teclas do teclado de um computador, depois será
só alterar para o botão que �cará na tela. Recebe sinal da tecla
espaço.
Time.�xedDeltaTime: o intervalo em segundos em que a física e
outras atualizações de taxa de quadros �xa são executados. O
 método FixedUpdate é executado neste intervalo.
MovePlayer() : método que gerencia a movimentação do
personagem.
targetVelocity : é a velocidade alvo da velocidade que desejamos
alcançar.
SmoothDamp() : Método que gradualmente muda o valor do vetor
próximo ao valor desejado com o passar do tempo.
Flip() : método que gerencia a mudança da imagem do personagem
da direita para esquerda e vice-versa.
Se tiver parametrizado da forma correta, o personagem deve ser capaz de
pular e se mover da esquerda para a direita pela plataforma e inverter a
imagem de acordo com o lado para onde ele está seguindo.
Para �nalizar, vamos fazer a câmera seguir o personagem pelo jogo,
centralizando na tela. Crie um “ Script ” dentro do objeto câmera que está na
aba “ Hierarchy ” e adicione o código a seguir.
Vamos comentar o código:
public Transform player : campo que será criado no Script da
câmera para que seja mais simples encontrar o player.
public Vector3 o�set : valor que deve ser ajustado para determinar
a distância da câmera. Nesse caso, devemos colocar -5 na variável Z.
public �oat smoothSpeed = 0.12f : valor que será usado para
suavizar o movimento da câmera ao seguir o personagem.
Vector3 posDesejada = player.position + o�set : posição em que
desejamos que a câmera seja posicionada.
Vector3.Lerp() : Interpolação Linear: é o processo de ir do ponto A
para o ponto B de maneira suave.
praticar
Vamos Praticar
Na utilização de código para escrever programas e jogos em geral, são usados
vários tipos de comandos, classes e métodos. Sempre que falamos de um código,
ele precisa estar dentro de um método, ou de uma classe. Sendo assim, qual é o
funcionamento de uma variável booleana dentro de um código?
a) A variável booleana serve para dizer se algo é verdadeiro ou falso. A.
b) A variável booleana serve para marcar o tempo de um update do jogo.
c) A variável booleana serve para marcar a quantidade de vida do
personagem.
d) A variável booleana serve para marcar a velocidade de um golpe.
e) A variável booleana serve para receber qualquer tipo de valor.
O objetivo deste jogo é salvar o Re. Para isso, o jogador precisa descobrir as
combinações corretas de alavancas que estão espalhadas pela fase. Sendo
assim, precisamos criar objetos com alavancas e portas que possam interagir
umas com as outras, ou seja, quando determinada alavanca for acionada ou
uma série delas for colocada na posição correta, a porta deve ser liberada
para ser aberta pelo jogador.
Portas: On/O� e Saída
Para colocar uma porta dentro do jogo, precisamos criar na aba “ Hierarchy ”
um objeto “ Sprite ” e mudar o nome dele para “ Porta_On/O� ”, pois esta
porta terá dois estados: fechada ou aberta. Dentro da porta, crie um
componente “ Box Collider 2D ”. No componente collider, ative o campo “ Is
Trigger ”, pois precisamos saber quando o personagem estiver no ponto
correto. Para que seja possível abrir a porta, arraste a imagem que está neste
caminho
“Assets/Medieval_pixel_art_asset_FREE/Textures/Medieval_props_free_1.png”
Portas, Alavancas ePortas, Alavancas e
ItensItens
para o campo “ Sprite ” do componente “ Sprite Renderer ” da porta, ou
clique no círculo do lado direito do mesmo campo para abrir uma lista de
imagens que estão contidas em seu projeto e encontrar a imagem desejada
pelo nome.
Em seguida,   crie um novo “ Script ”chamado “ PlayerInRange ” dentro do
objeto porta e cole o código a seguir no “ Script ”.
Vamos comentar o código:
public bool inRange = false : variável que armazena o valor
verdadeiro ou falso, que informa se o personagem está dentro do
campo de ação da porta.
private bool isPorta_Aberta : variável que armazena valor que
informa se a Sprite da porta mudou de fechada para aberta.
public bool[] Combination : esta lista de variáveis booleanas é
usada para que o desenvolvedor decida qual será a combinação
necessária das alavancas para abrir determinada porta. O tamanho
dessa lista deve ser determinado pelo programador na aba “
Inspector ” do mesmo objeto.
public Alavanca[] Alavanca : esta lista de Objetos Alavanca precisa
ter o seu tamanho determinado pelo programador na aba “
Inspector ”. Lembre-se de que o tamanho desta lista deve ser o
mesmo tamanho da lista “ Combination ”, pois as duas serão
comparadas para saber se a porta está destravada. Ao informar o
mesmo tamanho da lista   “ Combination ”, surgirão espaços para
que possamos arrastar as alavancas que estão dentro da aba “
Hierarchy ”, para que a lista saiba quais são as alavancas cujo valor
ela deverá saber.
public bool[] On_O� : esta lista serve somente para que o
programador possa ver se a Alavanca que será ativada dentro do
jogo realmente está sendo ativada. No momento que mover a
alavanca no jogo rodando, poderá conferir seu estado na aba “
Inspector ” da porta à qual a Alavanca está atrelada.
private int contadore = 0: este contador é usado no código para
veri�car quantas alavancas estão de acordo com a contagem feita na
comparação com a lista “ Combination ”. Caso a posição das
alavancas não esteja de acordo com a   lista “ Combination ”, a
contagem será menor. Sendo assim, a porta não �cará liberada para
ser aberta.
public bool StarGate = false: esta variável booleana deve ser
marcada quando uma determinada porta for usada para levar até a
outra porta. Caso contrário, a porta abrirá, mas não levará a lugar
nenhum.
public Transform Player : neste campo devemos arrastar o
personagem principal, pois precisamos alterar o valor de sua posição
para enviar o personagem para a outra porta, dando a impressão de
que o personagem atravessou a porta e chegou até a outra.
public Transform playerTo : este campo é muito importante.
Trataremos dele mais adiante quando falarmos sobre a outra porta,
mas ele é o campo que vai armazenar a posição a qual o personagem
será enviado, ou seja, este valor estará posicionado próximo à outra
porta para onde desejamos que o personagem seja enviado. Fique
atento(a), pois este campo não irá armazenar a posição da porta para
onde o personagem será transportado, mas sim um outro objeto que
será “ child ” desta outra porta que deverá ser arrastado para este
campo.
public Sprite portaAberta : sprite que armazena a imagem da porta
aberta, esta imagem será inserida no campo Sprite do componente
SpriteRenderer no momento que a porta for aberta, mas, para isso,
será necessário primeiro arrastar a imagem que está nesta pasta:
“Assets/Medieval_pixel_art_asset_FREE/Textures/Medieval_props_free_
para o campo “ portaAberta ” que está presente na aba “ Inspector ”
do objeto porta.
try {} catch {} : o comando “ try ” necessariamente precisa ser
seguido por um “ catch ”. Este comando “ try ” quer dizer tentar; é
usado para gerenciamento de erros, ou seja, quando sabemos que
existe a possibilidade de ocorrer um erro em nosso programa,
podemos escrever o comando “ try ” e escrever o código que pode
dar erro dentro do “ try ”. No caso desse código, o possível erro que
ocorre é relacionado a não informar as alavancas, por exemplo (claro
que devemos usar este comando com certa cautela). O comando que
está na sequência, o “ catch ”, serve para pegar os erros, ou seja,
sempre que ocorrer um erro, será direcionado ao “ catch ”, onde
podemos tratar este possível erro por meio de código.
if(Input.GetKeyDown(KeyCode.E)&&inRange&&Alavanca.GetComp
().getAlavanca()) : este “IF” percebe quando o teclado é pressionado
na tecla “E” e veri�ca se a variável booleana inRange é verdadeira e
veri�ca se a variável booleana que informa se a alavanca foi acionada
é verdadeira.
gameObject.GetComponent<SpriteRenderer>().sprite =
portaAberta: esta linha de código altera o Sprite do objeto porta pelo
Sprite de porta aberta.
OnTriggerExit2D() : este método é chamado assim que a colisão do
componente collider �naliza, ou seja, a colisão ou a sobreposição
acaba.
Lembre-se de que é de extrema importância informar na aba “ Inspector ” do
objeto porta a quantidade de alavancas que vamos usar para abrir esta porta,
arrastá-las para os espaços determinados dentro do “ Inspector ” da porta e
marcar os campos do “ Combination ” escrito em inglês, pois “combinação”
usa “ç” e “~”, e precisamos evitar estas letras e acentos em nome de variáveis,
métodos e classes.
Devemos lembrar também que o campo “ StarGate ” precisa ser marcado
caso deseje que sua porta leve o personagem para outra porta, e também
precisamos arrastar para os campos abaixo do “ StarGate ” o personagem e o
“ child ” da porta destino.
A Figura 3.11 traz o resultado desejado para o “ Inspector ” da porta “ on/o�
”.
Figura 3.11 - Print Inspector porta on o�
Fonte: Elaborada pelo autor.
Perceba na Figura 3.11 que, ao lado esquerdo dos campos “ Combination ” e
“ Alavanca ”, temos uma seta. Ao clicarmos nela, o campo será estendido,
trazendo informações extras sobre ele.
Antes de marcarmos qualquer coisa nesses campos, perceba que existe um
campo interno a eles que tem o nome de “ size ” que, em português, signi�ca
tamanho. Esse campo deve ser preenchido pelo programador na aba “
Inspector ”. Ele marca a quantidade de alavancas que desejamos colocar na
determinada porta e faz a mesma ação para o campo “ Combination ”.
Devemos nos lembrar de que os campos “size” de ambos os campos “
Combination ” e “ Alavanca ” precisam ter o mesmo valor; caso contrário,
ocorrerá um erro de lógica no código do “ Script ” “ PlayerInRange ”, pois ele
vai comparar os valores de ambos os campos para determinar se a porta
poderá ser aberta ou não.
Vamos falar agora sobre a porta de saída. Existem duas diferenças básicas
entre a porta de saída e a porta “ on/o� ”; são elas:
O “ Script ”: a porta de saída não terá um Script atrelado a ele.
A “ Child ”: a porta de saída será usada apenas para armazenar uma “
child ” que será chamada de “ Destino ”; ela marcará o ponto para
onde o personagem deverá ser transportado e, claro, simbolizar este
ponto com uma porta.
Veja que a porta “ on/o� ” não tem este “ child ”, portanto, caso queira que
uma porta “ on/o� ” possa ser usada como porta de saída, precisará colocar
um “ child ” dentro dela.
Este objeto que é “ child ” da porta de saída é apenas um objeto vazio criado
normalmente pela Unity, com o objetivo de ser usado para informar a posição
para onde o personagem deve ser enviado.
Tome cuidado com o posicionamento deste “ child ”, teste a altura de onde
ele será posicionado, pois, caso seja posicionado muito alto, o personagem
cairá ao atravessar a porta e, caso seja posicionado muito baixo, o box collider
do personagem �cará preso no box collider do tile no chão.
Esse tipo de movimentação precisa ser feita diretamente no componente
transformer, mas exclusivamente dessa forma, pois se trata de uma
movimentação cuja colisão desejamos que não funcione neste momento.
Tente fazer esta movimentação da mesma forma que fazemos para mover o
personagem, através do “ Rigidbody 2D ”, e verá que o resultado não será o
esperado.
Lembre-se sempre: para fazer o personagem andar pelo cenário do jogo, para
coletar itens, ou seja, mover-se do ponto A para o ponto B, é necessário fazer
isso por meio do componente “ Rigidbody 2D ”, pois, caso contrário, terá
muitos problemas com a colisão, já que não será mais o componente “
Transform ” que seguirá o movimento do componente “ Rigidbody 2D ”; será
o oposto e, como o componente que é o responsávelpelo gerenciamento da
colisão é o componente “ Rigidbody 2D ” junto com um componente “
Collider ”, mover um objeto colisivo através do cenário fazendo as mudanças
de movimentação diretamente no componente “ Transform ”  gerará um mal
funcionamento da colisão.
Para fazer o teste mencionado, pode usar este comando:
GameObject_Player.GetComponent<Rigidbody2D>().MovePosition(new
Vector2(playerTo.position.x, playerTo.position.y)); .
Para este teste, as mudanças �carão por sua conta, e não se esqueça de, após
�nalizar as duas portas, arrastá-las para a pasta dos seus prefabs.
Alavancas
As alavancas são uma das partes mais simples deste processo. Primeiro
precisa criar um novo objeto “ Sprite ”. No componente “ Sprite Renderer ”,
em seu campo “ Sprite ”, arraste a imagem da alavanca desarmada. Podemos
reflita
Re�ita
Ao re�etir sobre a movimentação do
personagem utilizando diretamente o
componente “ Transform ”, veja como
a utilização dele pode ser prejudicial
ao bom funcionamento de um corpo
colisivo. Teste esta tese. Até agora
todos os objetos que precisavam se
mover do ponto A para o ponto B
foram movidos através do
componente “ Rigidbody 2D ”, pois,
caso contrário, a colisão �caria
“Quebrada”, ou seja, não funcionaria
da forma correta.
Re�ita sobre isso e faça seus testes.
encontrar esta imagem dentro desta pasta:
“Assets/Medieval_pixel_art_asset_FREE/Textures/Medieval_props_free_11.png”.
Em sequência, podemos criar um novo “ Script ” na alavanca com o nome de
“Alavanca ” e colar o código a seguir dentro dele:
Vamos comentar o código:
private bool alavanca = false : esta variável booleana informa se a
alavanca está ativada ou desativada.
private bool inRange = false : esta variável booleana informa se o
personagem do jogador está próximo o su�ciente para ativar a
alavanca.
public Sprite alavanca_On : este sprite irá armazenar a imagem da
alavanca ativada, para que, posteriormente, quando o jogador ativar
a alavanca, o código possa fazer a troca da imagem da alavanca
desativada pela imagem da alavanca ativada. A imagem que será
usada para mostrar a alavanca ativada está nesta pasta:
“Assets/Medieval_pixel_art_asset_FREE/Textures/Medieval_props_free_
gameObject.GetComponent<SpriteRenderer>().sprite =
alavanca_On : esta linha de código é a linha responsável por fazer a
troca da imagem das alavancas.
OnTriggerEnter2D : este método é o responsável por ativar a
variável booleana que informa se o jogador está dentro do alcance
para ativar a alavanca.
OnTriggerExit2D : quando o jogador sair do alcance da alavanca,
este método entra em ação desativando a possibilidade de interagir
com a alavanca ao trocar de verdadeiro para falso a variável
booleana “ InRange ”, ou seja, quando o collider que está atrelado ao
personagem sair de cima, ou no momento que o collider do
personagem não estiver mais sobrepondo o collider da alavanca, este
método será ativado.
Itens
Este objeto em particular será animado mais à frente. Por questões de
funcionamento da animação, precisamos criar um objeto vazio e, como “ child
” deste objeto vazio, criamos uma “ Sprite ” e daremos a ela o nome de “
Esmeralda_P ”, pois existe a possibilidade de colocarmos a outra esmeralda
maior.
Como só faremos a animação no polimento do jogo, vamos colocar a imagem
da esmeralda no campo “ Sprite ” do componente “ Sprite Renderer ”. A
imagem pode ser encontrada nesta pasta: “Assets/Free Game
Items/300dpi/gem_1.png”. Em seguida, adicione ao objeto “ Esmeralda_P ” um
collider de sua escolha, e ative o “ IsTrigger ” deste collider. Perceba que não
adicionamos um corpo rígido ao “ Rigidbody 2D ”, pois não desejamos mover
este objeto, mas desejamos saber quando o personagem irá sobrepô-lo. Para
isso, usaremos o “ IsTrigger ” do componente collider. Em relação ao
componente collider, podemos usar o “ Box ”, “ Circle ” ou o “ Polygon ”.
Perceba que na pasta “ Free Game Items ” existem três pastas com
conteúdos iguais, mas com tamanhos diferentes. Veja que os tamanhos das
imagens estão referenciados nas pastas. Por isso, vamos utilizar a maior
imagem para garantir uma melhor qualidade no resultado �nal.
Para �nalizar esta parte, vamos fazer o personagem coletar a esmeralda. Para
isso, precisamos criar um novo “ Script ” no objeto “ Player ”, que vamos
chamar de “ Coletor ”. A seguir, o código do “ Script ”:
Vamos comentar o código:
Debug.Log("Esmeralda_P") : esta linha de código irá mostrar uma
mensagem na aba console; a mensagem será " Esmeralda_P ",
exatamente o conteúdo do método “ Log ”. Este método é o
responsável por enviar a mensagem para o console da Unity. Em
geral, usamos o “ Debug.Log() ” para veri�car se o código está
ativando determinada função dentro do “ Script ”; o “ Debug.Log() ”
pode ser usado dentro dos limites de um método.
Perceba que no código anterior não tivemos muito o que comentar, pois já
conhecemos bem seu funcionamento.
saibamais
Saiba mais
Existe uma maneira de medir o tamanho da
tela do celular para saber quantas polegadas
ele tem. As dimensões de um celular são
muito importantes para o desenvolvedor de
jogos. Dependendo do tamanho, precisamos
mudar o design do jogo, retirar algumas
funcionalidades e, às vezes, mudar
mecânicas de jogo. Saiba mais acessando o
link a seguir.
ACESSAR
https://olhardigital.com.br/dicas_e_tutoriais/noticia/como-e-feita-a-medicao-do-tamanho-da-tela-de-um-celular/66582
praticar
Vamos Praticar
A Unity tem muitos componentes collider. Cada um traz o campo “ IsTrigger ”, ou
em português, “ É Gatilho ”. A ação desse campo pode ser usada com várias
�nalidades. Em geral, seu uso dependerá do tipo de objeto e do jogo que
estivermos desenvolvendo. Diante disso, escolha a alternativa que traz a informação
correta sobre o método “ OnTriggerExit2D ”.
a) Este método é usado para saber quando o collider foi ativado.
b) Este método não faz parte do funcionamento de um collider.
c) Este método é usado dentro do componente “Sprite”.
d) Este método é usado quando acaba a sobreposição do collider.
e) Este método é usado apenas Tilemap Collider 2d.
indicações
Material
Complementar
LIVRO
The Art of Game Design: A Book of Lenses,
Third Edition
Jesse Schell
Editora: A K Peters/CRC Press
Comentário: Neste livro sobre game design, podemos
encontrar muitas informações válidas sobre o
desenvolvimento de jogos em geral. Uma parte das
muitas partes interessantes deste livro é sobre a
triangularidade. O autor trata sobre os benefícios de se
dar uma recompensa pequena pelo pequeno desa�o e
uma recompensa grande pelo desa�o maior. Entre
outras coisas, Jesse Schell trata das nuances de se
desenvolver um jogo bem estruturado e não pecar nas
exceções.
WEB
BGS 2019 - Brasil Game Show - Entrevista
John Romero - Criador do Doom
Ano: 2019
Comentário: Entrevista com o criador do game DOOM
John Romero. Esta entrevista ocorreu na BGS (Brasil
Game Show) de 2019. Nesta entrevista, John Romero
comenta sobre sua carreira de desenvolvedor de jogos
e responde a algumas perguntas sobre di�culdades e
acerto em sua carreira.
Entrevista disponível no link a seguir.
ACESSAR
https://www.youtube.com/watch?v=fKdMYYqC55s
conclusão
Conclusão
Nesta unidade, aprendemos um pouco sobre a história dos jogos plataforma
e iniciamos nossa própria jornada em direção ao mundo que engloba este
gênero tão icônico no universo dos jogos. Vimos uma análise de três títulos
diferentes de jogos plataforma para os dispositivos mobile, e buscamos
entender por que o mercado de jogos para dispositivos mobile é tão lucrativo.
Aprendemos a iniciar nosso projeto, com a construção das plataformas na
quais o jogador deve pisar, vimos como criar e utilizar os famosos “tiles”,
como colocá-los na tela e como fazê-los colisivos; aprendemos como fazer
uma passagem através de uma porta que nos leva até outra sala dentro do
jogo e que, para usar estas portas, precisamos acionar alavancas e acertar
suas combinações. Por �m, conseguimos coletar itens pelo jogo,