Você está na página 1de 61

See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/320273327

Desenvolvimento de Jogos para Dispositivos Móveis utilizando o Motor de


Jogo Unity 3D: um Estudo de Caso

Research · October 2017

CITATIONS READS

0 724

2 authors:

Wanessa Teotônio Allysson Allex Araújo


Universidade Estadual do Ceará Universidade Federal do Ceará
1 PUBLICATION   0 CITATIONS    21 PUBLICATIONS   30 CITATIONS   

SEE PROFILE SEE PROFILE

Some of the authors of this publication are also working on these related projects:

Final Course Assignments View project

Search Based Software Engineering View project

All content following this page was uploaded by Allysson Allex Araújo on 08 October 2017.

The user has requested enhancement of the downloaded file.


UNIVERSIDADE ESTADUAL DO CEARÁ
CENTRO DE CIÊNCIAS E TECNOLOGIA
CURSO DE ESPECIALIZAÇÃO EM ENGENHARIA DE SOFTWARE COM
ÊNFASE EM PADRÕES DE PROJETOS

WANESSA DE CALDAS TEOTÔNIO

DESENVOLVIMENTO DE JOGOS PARA DISPOSITIVOS MÓVEIS


UTILIZANDO O MOTOR DE JOGO UNITY 3D: UM ESTUDO DE CASO

FORTALEZA - CEARÁ
2016
WANESSA DE CALDAS TEOTÔNIO

DESENVOLVIMENTO DE JOGOS PARA DISPOSITIVOS MÓVEIS UTILIZANDO O


MOTOR DE JOGO UNITY 3D: UM ESTUDO DE CASO

Trabalho de Conclusão de Curso


apresentado ao Curso de Especialização em
Engenharia de Software do Centro de
Ciências e Tecnologia da Universidade
Estadual do Ceará, como requisito parcial à
obtenção da certificação de especialista em
Engenharia de Software.

Orientador: Prof. Me. Allysson Allex de


Paula Araújo

FORTALEZA - CEARÁ
2016
Aos meus pais. Por todo amor, apoio,
compreensão, ensinamentos e exemplo de
vida.
AGRADECIMENTOS

Gratidão a Deus, o grande e poderoso arquiteto do universo; às energias cósmicas que me


equilibram e espantam toda negatividade; a todos os seres de luz; à Rainha da Floresta e às
medicinas sagradas que me acompanham proporcionando cura, clareza, sabedoria e
proteção durante essa breve jornada que é a vida; aos quatro elementos: o Fogo que
aquece, a Água que purifica, o Ar que respiramos e a Terra que nos alimenta;
À minha família, especialmente aos meus pais, pela paciência, compreensão e apoio de
sempre;
Aos meus grandes e amados amigos que me proporcionaram momentos valiosos de amor,
distração e alegria, em especial ao Weliton Silva, Glau Holanda, Rosânia Almeida e
Priscilla Fernandes por ouvirem meus lamentos e por tornarem as minhas sextas-feiras as
melhores e mais prazerosas que eu pude viver;
À minha melhor amiga, Aline Muritiba, que sempre esteve ao meu lado. A você, o meu
amor e o meu respeito para todas horas;
Ao Anderson de Sousa Romão que, mesmo distante, me encorajou e me motivou. Sou
grata por todo carinho e atenção;
Ao meu orientador, Allysson Allex de Paula Araújo, por aceitar colaborar com este
trabalho, por toda atenção, dedicação e, principalmente, por não desistir de mim em todas
as horas que eu me senti fracassada. Por me erguer, muita gratidão;
Aos professores que se disponibilizaram a participar da banca;
Aos amigos e membros da equipe que colaboraram com o desenvolvimento do jogo
apresentado neste trabalho;
A todos os autores utilizados nesta obra. Agradeço por terem fomentado meus
conhecimentos ao longo deste trabalho, confirmando, conferindo ou desmentindo minhas
hipóteses, teorias e idealismos.
“Se você vai tentar, vá com tudo
senão, nem comece.”
(Charles Bukowski)
RESUMO

O desenvolvimento de um jogo é uma tarefa complexa que envolve diversas etapas como,
por exemplo, criação de enredo, cenário, personagens, edição de som, imagens e vídeos,
programação, entre outras. Este trabalho discute os processos envolvidos nas fases de
projeto e desenvolvimento de jogos. A primeira fase é a criação do projeto. Nela
encontram-se a descrição dos principais elementos que compõem o jogo, como: história,
descrição dos níveis e fases, regras, jogabilidade, sistema de premiações e recompensas,
entre outros. Essas características são registradas no documento de Game Design, que será
a referência para a etapa de desenvolvimento do jogo. A fase seguinte, de
desenvolvimento, aborda as tecnologias utilizadas na implementação do jogo. Através de
um estudo de caso, o presente trabalho relata a experiência concernente ao
desenvolvimento de um jogo para dispositivo móvel utilizando a ferramenta Unity 3D. Ao
fim, destacam-se as principais dificuldades, benefícios e lições aprendidas com o projeto.

Palavras-chave: Game Design. Desenvolvimento de jogos. Unity 3D.


ABSTRACT

The game development is a complex task which deals with different stages, such as,
storytelling, scenarios, characters, sound edition, images, videos, coding, etc. This work
aims to discuss the processes involved in the game project and development. The project
creation is the first stage where it is described the main elements that comprise the game,
for example, screenplay, level design, rules, gameplay, reward system and others. These
features are registered in a Game Design document which will be referenced during
development stage. In the following step (development), it will be explored the
technologies used to support the codification. This work reports, through a real world case
study, the experience regarding the development of a mobile game using the Unity 3D tool.
At the end, it will be highlighted the difficulty, benefits and learned lessons with the
project.

Keywords: Game Design. Game Development. Unity 3D.


LISTA DE ILUSTRAÇÕES

Figura 1 – Etapas mais importantes do pipeline gráfico..................................................... 26

Figura 2 – Uso dos motores de jogos pelos desenvolvedores............................................. 31

Figura 3 – Tela inicial do Unity 3D..................................................................................... 33

Figura 4 – Estrutura padrão do script.................................................................................. 35

Figura 5 – Cena de um nível do jogo.................................................................................. 41

Figura 6 - Primeiro esboço da fase do jogo........................................................................ 43

Figura 7 – Cenário principal do jogo Murphy..................................................................... 44

Figura 8 – Composição do personagem Murphy................................................................. 45

Figura 9 – Versão final do personagem Murphy................................................................. 45

Figura 10 – Sequência da animação de destruição do alvo…............................................. 49

Figura 11 – Pastas com arquivos do projeto Murphy.......................................................... 49

Figura 12 – Criação de um nível do modo viagem............................................................. 50

Figura 13 – Demonstração das abas Hierarchy e Inspector................................................ 50

Figura 14 – Criação da classe e definição das variáveis..................................................... 52

Figura 15 – Métodos que controlam a interação do jogador com o objeto......................... 53

Figura 16 – Método Update................................................................................................ 53

Figura 17 – Método CreateBullet........................................................................................ 54


SUMÁRIO

1 INTRODUÇÃO..................................................................................................... 12
1.1 OBJETIVOS…………………………………….....................…………………... 13
1.2 ESTRUTURA DO TRABALHO…………………..................................……….. 14
2 FUNDAMENTAÇÃO TEÓRICA........................................................................ 15
2.1 HISTÓRICO DOS JOGOS DIGITAIS................................................................... 15
2.2 PRINCÍPIOS DO DESIGN DE JOGOS.................................................................. 20
2.3 ENGINE................................................................................................................... 25
2.4 UNITY 3D……….…………………………………..................................………. 30
3 TRABALHOS RELACIONADOS...................................................................... 37
3.1 GAME DESIGN....................................................................................................... 37
3.2 DESENVOLVIMENTO DE JOGOS………………………….....................……. 38
4 ESTUDO DE CASO: MURPHY........................................................................... 40
4.1 HISTÓRIA DO JOGO............................................................................................ 40
4.2 DOCUMENTAÇÃO DO PROJETO...................................................................... 43
4.2.1 Elementos de cena.................................................................................................. 43
4.2.2 Personagens…………………….........................................................…………... 44
4.2.3 Level Design……….……………………..................................................………. 46
4.3 DESENVOLVIMENTO.......................................................................................... 48
4.4 LIÇÕES APRENDIDAS………………………………......................................... 55
5 CONSIDERAÇÕES FINAIS................................................................................ 57
REFERÊNCIAS.................................................................................................... 59
12

1 INTRODUÇÃO

A indústria de videogames se consolidou na década de 1980 e, desde então, vem


crescendo gradativamente. A produção de jogos digitais envolve um processo criativo e
técnico que contempla diversas áreas, como: educação, saúde, entretenimento, marketing,
entre outras. De acordo com o Mapeamento da Indústria Brasileira e Global de Jogos
Digitais, realizado em 2014, pelo Grupo de Estudos e Desenvolvimento da Indústria de
Games (GEDIGAMES), o mercado mundial de jogos digitais movimentou cerca de US$
65,7 bilhões em 2013, e deve chegar a US$ 89 bilhões em 2018, projetando uma taxa de
crescimento de 6,3% ao ano. Essa ascensão do mercado e o número crescente de jogadores
promoveu o aumento do número de empresas independentes produtoras de jogos digitais.
No Brasil, a estimativa é que o mercado de jogos digitais cresça de US$ 448
milhões em 2013 para US$ 844 milhões, com uma taxa de 13,5% ao ano. O crescimento do
mercado está associado ao aumento do consumo de jogos casuais, principalmente através
da web, das redes sociais e dos smartphones. O relatório produzido pela GEDIGAMES
mostra que a maioria das empresas é de pequeno porte com faturamento anual até 240 mil
reais. O surgimento de novas empresas, produtoras dos chamados jogos indie1, é
consequência da facilidade de acesso às ferramentas para desenvolvimento, muitas delas
gratuitas, como, por exemplo, o Unity 3D, empregado e discutido neste estudo.
Os jogos de smartphones contemplam uma grande parcela do mercado de jogos
digitais, em especial os desenvolvidos para o sistema operacional Android. Segundo a
Pesquisa Game Brasil2, 82,8% dos brasileiros utilizam o celular para jogar. Entre eles,
75,2% são usuários da plataforma Android e 11,1% do seu concorrente mais próximo, o
iOS. Esses jogos são, em sua maioria, de acesso rápido, que podem ser jogados em
períodos curtos, não precisam de muito conhecimento ou habilidade e não necessitam de
tempo regular, ou seja, podem ser jogados a qualquer momento. Os recursos financeiros
para sua produção são relativamente pequenos tornando os jogos bastante lucrativos.
Diante desse cenário, surgiu o interesse em desenvolver um jogo mobile para a
plataforma Android, que é a mais popular entre os desenvolvedores, com a utilização de
ferramentas gratuitas, sobretudo o Unity 3D. Essa ferramenta foi escolhida para o
desenvolvimento do jogo por se tratar de um sistema com muitos recursos que facilitam o

1
São jogos eletrônicos desenvolvidos por uma pessoa ou uma pequena equipe de forma independente, sem
grandes apoios financeiros.
2
Levantamento realizado pela Sioux, Blend New Research e ESPM, com a participação de 909 pessoas, de
14 a 84 anos, no período de 5 a 23 de janeiro de 2015. Fonte: http://www.pesquisagamebrasil.com.br
13

trabalho da equipe no processo de desenvolvimento e por possuir uma interface visual


simples que permite a manipulação dos objetos em cena. Essa ferramenta permite tanto a
elaboração de jogos simples quanto complexos, é de fácil acesso, gratuita e produz jogos
eletrônicos para diversas plataformas, como: consoles de videogame, tablets, smartphones,
computadores, internet.
O crescimento e a lucratividade do mercado de videogames atraem, tanto os
desenvolvedores experientes quanto pessoas sem nenhum ou com pouco conhecimento,
interessadas em aprender a construir seus próprios jogos e, por ventura, comercializá-los.
Sob tal contexto, é natural o surgimento de novos questionamentos acerca do tema, como,
por exemplo, por onde começar, quais ferramentas utilizar, qual linguagem de
programação, quais as dificuldades encontradas, entre outros.
Visando agregar à consolidação das pesquisas na área, justifica-se a relevância em
se discutir e apresentar o processo de desenvolvimento de um jogo eletrônico, chamado
Murphy, utilizando a ferramenta Unity 3D, almejando assim, destacar os principais
benefícios e dificuldades alcançadas, em prol da consolidação das pesquisas realizadas na
área. O jogo em questão está sendo criado por uma equipe formada por integrantes de um
curso de jogos eletrônicos3, composta por um game designer, dois desenhistas, dois
programadores, um designer de áudio e um testador, incluindo a autora desse trabalho, que
desenvolveu parte da programação. Até o fim deste trabalho, o jogo ainda se encontra em
fase de desenvolvimento, com expectativa de término para dezembro de 2016.

1.1 OBJETIVOS

O objetivo principal desta pesquisa consiste, através de um estudo de caso,


demonstrar o processo de construção de um jogo para a plataforma Android utilizando o
engine4 Unity 3D. Tal estudo de caso é fundamentado a partir de um jogo real, denominado
Murphy.
Visando atingir o objetivo principal, pretende-se alcançar os seguintes objetivos
específicos:

3
O curso de Jogos Eletrônicos é ofertado gratuitamente pela ONG Fábrica de Imagens. Mais informações,
acessar: http://fabricadeimagens.org.br.
4
Engine, em português chamado de “motor de jogo”, é um sistema de computador com um conjunto de
bibliotecas que simplificam o processo de desenvolvimento de um jogo eletrônico.
14

a) Realizar um estudo sobre os princípios que fundamentam o design de jogos;


b) Contextualizar as tecnologias utilizadas no desenvolvimento do jogo Murphy,
com ênfase para a ferramenta Unity 3D;
c) Apresentar e discutir os principais desafios encontrados.

1.2 ESTRUTURA DO TRABALHO

O trabalho está dividido em cinco capítulos, incluindo a presente introdução. No


capítulo 2 apresenta-se o surgimento dos jogos eletrônicos, as etapas necessárias para sua
criação, ou seja, o processo de design de jogos e a ferramenta utilizada, o Unity 3D. No
capítulo 3 discute-se os trabalhos relacionados à presente pesquisa. Em seguida, no
capítulo 4, apresenta-se os detalhes do estudo de caso, abordando as etapas de
desenvolvimento, com ênfase na programação e no uso do Unity 3D. Por fim, apresenta-se,
no capítulo 5, as considerações finais, resultados e perspectivas de trabalhos futuros.
15

2 FUNDAMENTAÇÃO TEÓRICA

Este capítulo apresenta um breve histórico sobre a evolução dos videogames e os


princípios de Game Design, enfatizando a importância de organizar as ideias e o registro
dos processos de desenvolvimento no Documento de Game Design. E, por fim, apresenta o
motor de jogo utilizado para a construção do Murphy, o Unity 3D.

2.1 HISTÓRICO DOS JOGOS DIGITAIS

Os jogos eletrônicos surgiram no final da Segunda Guerra Mundial, nos


laboratórios vinculados a Inteligência, Pesquisa e Serviços Militares dos Estados Unidos,
como forma de entretenimento e distração. O primeiro jogo, OXO, desenvolvido por
Alexander Sandy Douglas em 1952, correspondia a uma versão eletrônica do “jogo da
velha”. Esse jogo foi criado para que os visitantes de seu laboratório tivessem alguma
forma de passar o tempo. O segundo jogo, Tennis for Two, foi criado por William
Higinbotham em 1958. A dinâmica do jogo é controlar a bolinha de um lado para outro,
com o uso de barras que simbolizam raquetes. Em 1962, Steve Russel, em parceria com
colegas do Massachusetts Institute of Technology (MIT), criou o Spacewar!.

O Spacewar! funcionava em um mainframe que era utilizado para cálculos e


programação militar de alta precisão. Esses computadores eram enormes, ocupavam uma
sala inteira e custavam milhares de dólares. O Spacewar! foi desenvolvido em linguagem
Assembly, uma linguagem de baixo nível em que cada linha de programação era uma
instrução para o processador do computador executar. O jogo reproduzia uma batalha
espacial entre duas naves e era bastante realista no que diz respeito às propriedades físicas.
Continha uma estrela no centro que exercia uma força gravitacional, que atraía as naves,
tornando o jogo mais difícil. Apesar da inovação e sucesso do jogo, ele não foi
comercializado devido ao alto custo dos computadores.

Em 1970 surgiu o Computer Space, uma versão baseada em Spacewar!


desenvolvido por Nolan Bushnell e Ted Dabney. Funcionava em um dispositivo elaborado
somente para jogá-lo, denominado arcade, e possuía gráficos melhores. Os arcades,
16

também conhecidos como fliperamas, são máquinas compostas por um gabinete


(geralmente de madeira ou material plástico), tubo de imagem (CRT), fonte de
alimentação, controles e sistema de jogo. O jogo inicia quando o jogador insere uma ficha
de metal (semelhante a uma moeda) na máquina e termina quando ele é derrotado.

Em 1972, Bushnell e Dabney fundaram a primeira empresa de videogames do


mundo, a Atari. Nesse mesmo ano, a Atari desenvolveu um jogo que teve um enorme
sucesso, o Pong, se tornando um marco importante na história dos videogames. Bushnell
encomendou ao seu engenheiro, Al Alcorn, que criasse um jogo tipo pingue-pongue que
fosse simples, divertido e barato. Após três meses de trabalho surgiu o Pong, baseado no
jogo de tênis de mesa, onde as barras laterais da tela rebatiam uma bolinha que aumentava
de velocidade a cada jogada e mudava sua direção de acordo com o ângulo da barra,
controlada pelo jogador.

O Pong foi levado a um bar para teste de público e teve total sucesso. As pessoas
faziam fila e esperavam o bar abrir para poder jogar. Com o êxito do Pong, a Atari ampliou
a empresa e popularizou essa nova ferramenta, distribuindo o primeiro videogame de
sucesso por todo o mundo. Segundo Arruda (2014, p.34), a novidade fez tanto sucesso que
foi imediatamente copiada por outras empresas. Após três meses do lançamento do Pong já
existiam clones não autorizados em diversas localidades. Nesse momento surge a pirataria
na indústria dos videogames e, consequentemente, as estratégias de combate.

Ainda em 1972, Ralph Baer desenvolveu o Odyssey, primeiro console de


videogame para ser conectado em uma televisão. Apesar de inovador, o console não fez
tanto sucesso e vendeu poucas unidades. O aparelho só funcionava em televisores da
empresa de produtos eletrônicos Magnavox. Por ter sido disponibilizado para venda
somente nas lojas da empresa, e não nas grandes redes de mercado, afastou o acesso do
grande público. A partir de 1975 aconteceu uma revolução no processo de
desenvolvimento, devido à utilização do microprocessador que ampliou as capacidades do
videogame. Os engenheiros da empresa Midway, utilizaram um microprocessador para
comandar as placas de circuitos e melhorar os gráficos dos jogos. Com seu uso, foi
possível inserir personagens e elementos cenográficos que lembravam a silhueta de pessoas
e coisas reais.
17

Diante disso, Bushnell e os engenheiros da Atari criaram uma versão de Pong que
fosse ligado a um aparelho de televisão comum, o Home Pong, lançado no natal de 1975.
Com isso, outras empresas surgiram e lançaram suas versões. O sucesso dos videogames
domésticos foi instantâneo. Porém, como só era possível jogar Pong ou versões
semelhantes, eles deixaram de ser novidade rapidamente. Esses primeiros videogames
eram máquinas programadas com apenas um jogo. Caso quisesse jogar outro título, era
necessário comprar outra máquina. Em meio à saturação do mercado, a Atari desenvolveu
o cartucho, que possibilitou a diversificação de jogos na mesma máquina.

Em 1978, a empresa japonesa Taito lançou no mercado dos arcades o primeiro jogo
com personagens animadas, o Space Invaders. Outra inovação do jogo foi conservar em
memória o registro da maior pontuação. O nome do jogador era apresentado na tela, ao
lado de sua pontuação, instigando os outros jogadores a superarem o record registrado. O
autor, Alan Richard da Luz, destaca que “O jogo não foi muito bem no início, mas, quando
o público percebeu seu potencial, chegou a causar furor e falta de moedas de 100 ienes no
Japão, obrigando a Casa da Moeda Japonesa a fabricar lotes extras” (LUZ, 2010. p.33).

Em 1979, a Atari contrata a Taito e licencia o Space Invaders, que até então era
arcade, para uso doméstico. Foi o primeiro jogo arcade a ser convertido para console. A
parceria foi um sucesso e muita gente comprou o Atari 2600 somente para jogar o Space
Invaders. Nesse cenário, surgiram várias empresas e desenvolvedores fabricantes de jogos,
alguns, não tão bons, fracassaram e as empresas faliram. Enquanto isso, surgiam outros
jogos que inovaram a indústria do videogame, abordando novas temáticas, jogabilidades e
personagens.

Em 1983, o mercado norte americano de videogame estava em estagnação devido à


grande quantidade de consoles, jogos de baixa qualidade e com quase nenhuma inovação.
Essa enorme quantidade de jogos ruins lançados, principalmente pela Atari, deu origem ao
famoso “crash do videogame”, em 1984. Essa “crise” foi responsável pela falência de
quase todas as empresas do ramo. Enquanto o mercado norte americano decaía, o mercado
japonês iniciava seu domínio no setor. Um ano antes da crise, em 1983, era lançado no
Japão o Nintendo Famicon que vendeu mais de 2.5 milhões naquele ano. A Nintendo, em
1985, introduziu seu console no mercado americano, com um novo design e o chamou de
Nintendo Entertainment System (NES), se tornando a grande responsável pela recuperação
da indústria do videogame.
18

Na década de 1990 surgiram novas tecnologias importantes, tanto de hardware


como de software, que modificaram o desenvolvimento da indústria de jogos. Uma grande
inovação surgiu em 1994, quando a Sony lançou o console PlayStation, o qual rodava
jogos através de CDs, com uma qualidade muito maior do que todos os jogos lançados até
então. Essas mídias superaram o cartucho e permitiam armazenar gráficos e conteúdos
audiovisuais mais elaborados. Assim, era possível desenvolver jogos com maior tempo de
duração, melhor qualidade gráfica e melhor jogabilidade.

Outras inovações importantes aconteceram na década de 2000, como a inclusão dos


sensores de movimento na experiência de jogar. A Nintendo lançou o Nintendo Wii com
controles sem fio, em que a movimentação do controle interfere na movimentação do
personagem. Logo após, a Microsoft incorporou, ao Xbox 360, um aparelho, chamado
Kinect, capaz de identificar os movimentos corporais do jogador e simulá-los no
personagem, sem a necessidade do controle (joystick). O avanço tecnológico na indústria
de videogame permitiu o desenvolvimento e barateamento de consoles e jogos. Paralelo à
evolução dos consoles também se deu a evolução dos Computadores Pessoais (PCs). Os
jogos que eram desenvolvidos para os consoles cada vez mais foram ganhando adaptações
para os computadores. Desse modo, alguns jogadores até optam pelo computador, devido a
sua multifuncionalidade e hardware, em detrimento do console.

Atualmente, os jogos são desenvolvidos e distribuídos para diversas plataformas,


entre elas: smartphones e tablets. A popularização dos dispositivos móveis permitiu a
ampliação e o surgimento de inúmeras empresas e desenvolvedoras independentes de
jogos, devido à alta lucratividade e maior facilidade de confecção e distribuição,
comparados aos jogos fabricados para consoles ou computadores. De acordo com Arruda
(2014), a empresa Apple foi a precursora na oferta de aplicativos pela rede, causando uma
grande mudança na experiência dos usuários e desenvolvedores com os softwares. Com
isso, tanto os usuários poderiam escolher entre inúmeras opções de aplicativos, como
também os desenvolvedores adquiriram um espaço para divulgar suas produções.

Para o desenvolvedor de jogos digitais, a perspectiva dos aplicativos abre


muitas portas, pois permite uma inserção no mercado de games sem a
necessidade de estar vinculado aos grandes centros de produção de jogos
digitais. Ampliaram-se as possibilidades para pequenos empreendedores
mostrarem seu trabalho (ARRUDA, 2014, p.45).

Os jogos independentes, também conhecidos como jogos indie, geralmente são


desenvolvidos individualmente ou por equipes pequenas, sem que haja financiamento de
19

uma grande empresa, basta existir uma boa ideia e a vontade de realizar o projeto. A
maioria desses jogos são custeados pelos próprios criadores. Segundo Mastrocola (2014),
“o contexto digital, a alta disponibilidade de conteúdo e o acesso relativamente fácil a
determinadas tecnologias, complementa este intrincado panorama”. Outro grande atrativo,
presente nesses jogos, é a total liberdade de criação. A equipe de desenvolvimento não está
presa às exigências mercadológicas de empresas financiadoras do projeto.

Os jogos independentes são desenvolvidos desde os anos 1980, quando surgiu o


console Atari. Entretanto, a grande quantidade de jogos sem qualidade que eram lançados
no mercado fez com que a indústria do videogame entrasse em crise, como o já
mencionado crash do videogame. A partir desse momento, houve uma maior aquisição de
computadores pessoais e os jogos indies passaram a ser desenvolvidos para essa
plataforma. Em 2008, os jogos independentes tiveram um grande destaque no mercado de
jogos devido ao surgimento da Steam. De acordo com Nascimento et al. (2014, p.156), a
criação dessa plataforma de jogos online facilitou para que os desenvolvedores e usuários
tivessem conhecimento e acesso aos jogos produzidos. A partir desse momento surgiram
outras eShops, como: Xbox Live Arcade, Playstation Network e Wiiware.

Atualmente, com a massificação dos dispositivos móveis, o mercado de jogos


independentes está em constante crescimento. Os jogos fabricados para dispositivos
móveis possuem tamanho reduzido, ocupam pouco espaço em disco e não exigem muita
capacidade de processamento e memória. Os principais sistemas operacionais que esses
jogos são distribuídos são: Android, desenvolvido pela empresa Google; iOS, da Apple; e
Windows, da Microsoft. De acordo com o I Censo da Indústria Brasileira de Jogos Digitais,
81% das empresas brasileiras desenvolvem jogos digitais para a plataforma mobile
Android, 75% para mobile iOS e 29% para Windows Phone. A preferência pelas
plataformas Android e iOS, ocorre pela facilidade de desenvolvimento que as empresas
proprietárias proporcionam, existem poucas barreiras para entrar no mercado e publicar os
jogos, além de uma boa demanda de clientes (FLERY, 2014, p.50).

O processo de desenvolvimento de jogos se tornou cada vez mais organizado. Ele é


dividido em várias atividades, definindo cada passo que será executado pela equipe ou pelo
desenvolvedor individual. Uma das principais atividades do desenvolvimento de um jogo
digital é a elaboração do game design ou design de jogos. Este documento é o projeto do
jogo, contém a definição de todas as características do produto e guia todo o processo de
20

construção do jogo. Nele consta a ideia, a mecânica, as regras e os objetivos do jogo, como
será discutido a seguir.

2.2 PRINCÍPIOS DO DESIGN DE JOGOS

A evolução do mercado de jogos é resultado de um amadurecimento tecnológico


aliado a um contexto narrativo, capaz de transportar o jogador do mundo real para um
mundo lúdico, fictício, durante o tempo de jogo. Ao iniciar um jogo, acontece uma imersão
nesse novo mundo que faz com que o jogador se identifique como se fosse o próprio
personagem, no momento em que está interagindo com a máquina, e se comporte como ele
para atingir o objetivo.

Os jogos eletrônicos possuem a capacidade de fazer o jogador experimentar uma


vida que não é a vida comum. Entretanto, para que essa imersão ocorra, o jogo precisa ter
elementos que conquistem o jogador e projetem nele sentimentos de identificação com o
personagem e com o contexto que ele interage. “É essa identificação encarnada que se
responsabiliza pela intensificação da competitividade e pelo envolvimento emocional e
afetivo do jogador” (LEMES, 2009, p.47). O ato de jogar caracteriza-se como uma entrega
do indivíduo ao novo ambiente apresentado. Se o jogo não possui elementos que são
capazes de manter o jogador imerso, ele logo é descartado. Cada elemento que forma a
identidade do personagem deve ser cuidadosamente arquitetado em prol de um maior
engajamento do jogador.

O game designer (como são definidas as pessoas que projetam os games) deve
pensar nas criações dos personagens com características psicológicas bem
delimitadas de forma a construir um ambiente experimental em que o jogador
acredite momentaneamente estar em diálogo ou imerso efetivamente no
personagem. Expressões faciais, diálogos, vestimentas, movimentação devem ser
desenvolvidos com base em peculiaridades para a formação das identidades dos
personagens. (LEMES, 2009, p.52)

Os elementos de um jogo são organizados no Documento de Game Design (Game


Design Document - GDD). O game designer é responsável por elaborar e documentar todo
o projeto. Este documento define as principais características de um jogo, contém a
descrição dos personagens, controles, armas, jogabilidade, fases, entre outros aspectos. Ele
é utilizado como um guia por todas as equipes envolvidas no processo de desenvolvimento.
21

O termo design é utilizado em diversos setores, como arquitetura, moda, móveis,


internet, entre outros, para referenciar a etapa de concepção de um projeto. Um projeto
define as etapas de construção de produto, ou seja, diz respeito ao processo de criação,
desde a idealização e conceituação até a definição das etapas necessárias para ter o produto
final. Entretanto, a definição do projeto de um produto não o caracteriza como um projeto
de design. Existe uma diferença na forma de construção dos dois produtos.

A fim de elucidar essa diferença, Rabelo (2005) toma como exemplo a mudança
organizacional da Escola de Artes de Milão. Segundo o autor, a escola fabricava suas peças
baseada no conhecimento artístico, levando em consideração a estética. Posteriormente, a
escola contratou médicos, engenheiros e físicos para acrescentar saberes de anatomia,
dinâmica, estruturas e outras habilidades interdisciplinares na formação dos artistas. Os
artistas passaram a produzir os mesmos produtos pensando não somente na beleza final da
obra, mas em sua funcionalidade. Por exemplo, uma cadeira que era projetada com foco
apenas na beleza estética, passou a ser projetada com a finalidade de suportar diferentes
pesos e não prejudicar a coluna dos usuários, além de preservar sua beleza. Com essa
mudança, a escola passou a ser conhecida como a Escola de Design de Milão.

Segundo o autor, “a diferença do designer formado pela escola em questão para o


artista está no pensamento e trabalho com foco em um usuário que deverá utilizar a peça
desenvolvida com uma função objetiva” (RABELO, 2005, p.31). Desse modo, o termo
design abrange todas as características relativas ao produto, não só relacionadas à beleza,
mas também de funcionalidades. E assim é com o design de jogos. Ter bons gráficos e uma
arte bonita não determina que o jogo será bom. É preciso clareza, organização e uma boa
narrativa para que o jogo prenda a atenção do jogador. A finalidade de todo jogo é sempre
ter alguém para jogá-lo. Portanto, o principal foco do projeto de design de um jogo deve
ser o jogador. O jogo deve ser construído a partir dos anseios e perspectivas do público
alvo.

Desse modo, o desenvolvedor deve ter o conhecimento sobre o que os jogadores


querem e esperam de um jogo. De acordo com Perucia et. al (2005), os itens que os
jogadores querem encontrar em um jogo são: desafios, pois servem como aprendizado e
geram emoções quando superados; socialização, jogos em geral são atrativos porque
promovem divertimento com amigos ou familiares; experiência solitária, contrapõe-se ao
item anterior, porém é um ótimo passatempo quando se está sozinho; respeito, as
22

pontuações altas ou uma boa colocação no ranking de um jogo são motivos de orgulho
para o jogador; experiência emocional, todo jogador procura sentir emoções durante o
jogo, como: tensão, heroísmo, medo, entre outras; e fantasia, o jogador está em busca de
uma fuga da realidade, onde ele possa realizar coisas impossíveis ou improváveis, como
voar, matar zumbis, cometer delitos e ações ilegais, correr em alta velocidade, entre outros.

Os autores também listaram os itens que os jogadores esperam de um jogo, são


eles: mundo consistente, pois o jogador precisa entender porque ele toma uma determinada
atitude e quais resultados esperar; entendimento dos limites do mundo, ou seja, mostrar
claramente o que o jogador pode e não pode fazer; direção, o jogo sempre deve deixar
claro qual o objetivo que o jogador terá que cumprir; cumprimento das tarefas
progressivamente, é interessante fornecer sub-objetivos ao jogador e gratificá-lo enquanto
ele progride para o objetivo maior; níveis de dificuldade, um jogo muito fácil ou muito
difícil tende a ser logo descartado, o ideal é que comece fácil e vá aumentando
gradativamente para que o jogador se sinta desafiado; repetições devem ser evitadas, pois
desafios iguais são cansativos e desagradáveis para o jogador; por fim, deve-se evitar
cutscenes5 muito longas, pois os jogadores querem estar no controle do jogo e não apenas
assistí-los.

A maioria das características citadas, senão todas, devem ser analisadas na etapa de
design de jogos. Essa atividade aborda todo o conteúdo do jogo. Corresponde ao processo
de idealização e definição do universo de um jogo, ou seja, é o registro das mecânicas,
regras e objetivos. As regras e mecânicas de um jogo correspondem ao seu funcionamento.
Conforme explica Sato (2010), um design de jogos bem elaborado define símbolos e
representações de modo com que o jogador se sinta motivado a alcançar o objetivo do
jogo, se sinta inserido no contexto e se identifique com o universo apresentado.

O game design deve trazer em sua essência, as características necessárias para o


jogador sentir-se unido ao contexto apresentado pelo jogo, podendo assim
realizar escolhas e tomar decisões pertinentes para o progresso no jogo. Isto é, o
game design deve oferecer oportunidades para os jogadores, que os levem a
realizar decisões que afetarão o resultado do jogo (SATO, 2010, p.76).

A autora acrescenta que o game design deve ser pensado com o foco no sujeito do
produto, ou seja, o jogador. O profissional, denominado game designer, responsável por
elaborar o documento, pode começar descrevendo uma ideia geral sobre o jogo, um breve

5
Cutscenes são animações ou vídeos utilizados para contar a história do jogo.
23

enredo do ambiente proposto e a jornada dos principais personagens. Esses elementos são
considerados um excelente ponto de partida para pensar e analisar como serão construídas
as regras e mecânicas que serão desenvolvidas. Desde sua etapa de idealização e
conceituação, o jogo deve ser construído através do olhar do jogador, visualizando como
será a jogabilidade, ou seja, de que forma o jogador é capaz de interagir com o universo do
jogo e como o jogo reagirá a esse comportamento. Esse critério chega a ser considerado
mais importante que a arte ou a programação. Ele deve conter elementos que possibilitem
uma imersão no ambiente criado.

Portanto, um jogo com uma interface intuitiva, mas que possui regras mal
elaboradas e objetivos indefinidos não será capaz de prender a atenção do jogador. De
acordo com Adams e Rollings (2003 apud PEREIRA, 2006), a experiência do jogador está
relacionada com a combinação de três elementos que interferem diretamente sobre a
qualidade do jogo. Os três elementos são: o visual, o auditivo e o interativo. O elemento
visual representa o modo que os objetos são dispostos na tela e apresentados ao jogador. A
interface do jogo deve ser pensada de forma que o jogador possa interagir de forma
intuitiva, contendo cenários, personagens e outros objetos de cena bem posicionados. A
escolha das cores, fontes, e estilo de tela devem seguir um padrão, a fim de manter uma
homogeneidade na interface.

O elemento auditivo, geralmente, é o elemento que os desenvolvedores dão menos


importância. Entretanto, o jogador sente o jogo como um todo e, certamente, áudios bem
elaborados colaboram positivamente para o sentimento de satisfação do jogador. Existem
dois tipos de abordagem sonora nos jogos, os sons de eventos e a trilha musical. Os sons de
eventos são específicos para alguns elementos e estão associados a alguma ação dentro do
jogo, por exemplo, o barulho de uma explosão, o disparo de uma arma, os diálogos entre os
personagens. Todos esses sons são acionados em momentos apropriados e distintos durante
a cena do jogo. No entanto, a trilha musical é tocada de forma constante, durante um nível
ou em todo o jogo. É possível que exista um jogo com apenas uma trilha musical para
todos os níveis ou várias trilhas musicais. A trilha musical depende da temática do jogo,
geralmente ela é elaborada de acordo com o tema. É muito comum a trilha sonora
apresentar um ritmo diferente ao se aproximar de situações de perigo, despertando uma
certa tensão no jogador, como se a música avisasse que ele deve ficar mais atento. A
música afeta as emoções do jogador.
24

Por fim, o elemento interativo tem relação com as funcionalidades do jogo, ou


seja, com a maneira que os objetos irão interagir com o jogador e vice-versa. Cada
interação deve oferecer um retorno, quando o jogador interage com um objeto ele espera
alguma resposta. Os eventos devem ser pensados de forma que o jogador entenda as
informações que estão sendo transmitidas e a dinâmica do jogo sem que exija muito
esforço para isso. Os desafios devem ser bem definidos, com início e fim, de modo que, ao
chegar ao fim, apresente alguma forma de reconhecimento pela conclusão da tarefa. Dessa
forma, o jogador saberá que conseguiu concluir o objetivo proposto.

Existem várias formas de elaborar um Documento de Game Design. Basicamente, o


game designer irá documentar características imprescindíveis para concretizar a ideia do
jogo, abrangendo os itens envolvidos em cada ciclo de construção. Os itens básicos do
GDD são: o nome do jogo; seu objetivo; público alvo; uma descrição geral da história, com
início e fim; controles; requisitos de tecnologia; fluxograma de cenas; descrição do maior
número de personagens, incluindo os não jogáveis; os itens utilizados pelo jogador que
afetam o comportamento do personagem (armas, dinheiro, pontos, experiência, itens
colecionáveis, poderes), denominados power-ups; câmera para mostrar como o jogador
visualiza a cena; a mecânica do jogo, geralmente especificada pelo gênero que pertence
(aventura, ação, estratégia, tiro em primeira pessoa, entre outros); os níveis que irá
percorrer; formas de pontuação; músicas e efeitos sonoros (ROGERS, 2010, p.77).

Por conter toda a descrição e os detalhes do jogo, o GDD deve ser visto como um
documento de projeto, ou seja, também possui a função de auxiliar a divisão e alocação de
tarefas para cada profissional envolvido no projeto. É importante que o documento seja
elaborado de forma objetiva e esteja disponível para todos os profissionais envolvidos, a
fim de que não haja dúvidas quanto aos aspectos do jogo. Caso contrário, um documento
mal elaborado pode dar margem à interpretações equivocadas e ocasionar erros na
produção dos objetos gráficos ou na programação do jogo.

O desenvolvimento de um jogo pode envolver apenas um profissional ou centenas,


dependendo da complexidade do jogo. Conforme Perucia et. al (2005), o ideal é possuir
uma equipe qualificada e multidisciplinar, formada por programadores, artistas, projetistas
de níveis/fases, game designers, planejador de software, gerente de projeto, músicos e
testadores. Os programadores possuem a função de desenvolver técnicas de inteligência
artificial, computação gráfica, programar as ações e o comportamento dos objetos e
25

elementos sonoros. Os artistas são responsáveis pelo layout do jogo e a criação de objetos,
texturas, ilustrações, personagens, animações, entre outros componentes visuais. Os
projetistas de níveis são responsáveis por inventarem as fases dos jogos, geralmente essa
atividade é efetuada pelo game designer.

Os Game Designers são os idealizadores do jogo. Esse profissional conhece todo o


projeto e, portanto, participam de todas as etapas de produção, a fim de garantir que tudo
seja elaborado de acordo com o planejamento. O planejador de software analisa as
atividades para estabelecer os requisitos e o tempo necessário para o desenvolvimento. O
gerente de projeto tem a função de garantir a harmonia da equipe, a comunicação e que o
desenvolvimento ocorra conforme o prazo planejado. Os músicos e sonoplastas compõem
as trilhas sonoras, efeitos especiais e vozes para os jogos. Os testadores são profissionais
que surgem perto do fim do projeto com o objetivo de procurar falhas e erros nos jogos.

Os jogos são desenvolvidos com o uso de diversas ferramentas. Basicamente, são


necessários: um editor gráfico para criar e manipular as imagens e animações; um editor de
áudio para compor os efeitos sonoros e trilhas; e um engine, também conhecido como
motor de jogo ou motor gráfico, responsável por unir os componentes de jogos criados em
outros ambientes, criar scripts e configurar elementos físicos e comportamentais dos
objetos.

2.3 ENGINE

A confecção de um jogo eletrônico envolve várias etapas, descritas no documento


de game design, e o uso de variados softwares. As imagens, animações, áudios e outros
elementos podem ser criados e tratados em softwares distintos, serem salvos no
computador e importados para um engine, onde o jogo será montado. O engine, também
conhecido como motor de jogo, é um ambiente que realiza a integração de todos os
componentes de um jogo, responsável por controlar e organizar a sua estrutura e ciclo de
vida. Conforme Lemes (2009) afirma: “um motor de jogo é o coração e o cérebro de um
game, ou seja, controla tudo o que acontece em um jogo e é responsável também por sua
vida”.
26

Um motor de jogo possui um conjunto de recursos para os desenvolvedores


trabalharem o visual, o áudio e a programação dos jogos. Nele, o profissional irá compor a
estruturação dos dados, os mecanismos de comunicação, controles de personagens, criação
de cenários, mecanismos de colisão, entre outros elementos.

Um motor de jogo recebe um conjunto de entradas oriundo da interação


com dispositivos de entradas, por exemplo, teclas pressionadas e mouse
arrastado; efetua a lógica do jogo incluindo a movimentação dos
personagens controlados pelos usuários e controlados pelo computador; e
apresenta em um dispositivo de vídeo a imagem do estado atual do jogo.
Além disso, o motor de jogo pode receber informações remotas, enviar
mensagens para um servidor e reproduzir sons. (CLUA;
BITTENCOURT, 2005, p. 1334).

Um engine é composto por diversas ferramentas, cada uma responsável por alguma
etapa de construção do jogo. Segundo Clua e Bittencourt (2005), geralmente, um motor de
jogo contém: Engine de Renderização, Engine de Física, Engine de Som e Engine de
Inteligência Artificial. O Engine de Renderização tem a função de reduzir o processamento
de objetos gráficos, é responsável pelo processo de gerar imagens 2D partindo de modelos
3D. Esse processo é denominado pipeline gráfico e é dividido em várias etapas, sendo as
principais mostradas na figura abaixo.

Figura 1 - Etapas mais importantes do pipeline gráfico

Fonte: CLUA e BITTENCOURT (2005).

A etapa de transformações 3D é onde são aplicados movimentos aos modelos 3D.


Todos os movimentos que o objeto sofre são acumulados numa matriz. Ao visualizar a
cena, essa matriz é aplicada sobre cada vértice que compõe o objeto, formando o
movimento. Na etapa de projeção 3D para 2D, os vértices que compõem o objeto são
coordenadas 3D, entretanto a imagem será apresentada de acordo com a tela, de forma
bidimensional. A etapa de culling é importante para otimizar o processamento gráfico.
Consiste na escolha dos polígonos que serão renderizados, ou seja, deixar presente apenas
os pontos que importam para a visualização do objeto, a partir da posição da câmera, e
27

eliminar polígonos que não são necessários na apresentação do objeto. A etapa de clipping,
é necessária para recortar partes da imagem que ficam visíveis na tela e deixam o efeito 3D
com aspecto prejudicado ou aparência estranha. Também é utilizado para dar aspecto 3D
em modelos 2D. A última etapa do processo de renderização é chamada rasterização, que
corresponde às atividades de iluminação e texturização. Para que os objetos apareçam na
tela é necessário que haja uma iluminação na cena ou um ponto de luz sobre o objeto. O
shading é o sombreamento aplicado a fim de dar efeito ao modelo. A texturização é a
aplicação de material (textura) ao objeto.

O Engine de Física permite inserir propriedades físicas sobre o mundo virtual


criado. Os cálculos básicos aplicados são os de colisão e forças. A colisão permite
delimitar uma área em torno dos objetos para impedir que uns atravessem os outros. Isso
faz com que o personagem não consiga atravessar uma parede, por exemplo. A aplicação
de forças fornece aos objetos um comportamento mais aproximado ao do mundo real.
Desse modo, é possível inserir a aplicação de massa, velocidade e gravidade aos objetos. A
força gravital faz com que o personagem ao pular não suba infinitamente, mas volte e pare
ao colidir com o chão, por exemplo. A velocidade com que os objetos realizam esses
movimentos também é ajustada, de modo que possa simular o mundo real ou para se
adequar a realidade do mundo criado.

O Engine de Som insere e configura os áudios que serão inseridos no jogo. Além de
inserir uma trilha sonora para o ambiente, a ferramenta permite inserir áudios em objetos
de cena que só são ativados em momentos certos, como o som de um disparo ao acionar
uma arma ou o som emitido ao pegar uma moeda. O Engine de Inteligência Artificial
permite inserir comportamentos em objetos que não são controlados pelo jogador, como
inimigos e outros personagens não-jogáveis que ele pode interagir, comumente chamados
de Non-Player Characters (NPCs). A inteligência artificial facilita a atividade do
desenvolvedor na implementação de algoritmos, que trazem realismo ao jogo e permitem
que os personagens realizem um efeito de locomoção e tomada de decisões dentro do
ambiente como se fosse uma pessoa real.

A função da inteligência artificial nos jogos é imitar a maneira de pensar


dos seres humano, simulando através de algoritmos e heurísticas, o
processo de raciocínio e ponderação do cérebro humano e dando realismo
aos comportamentos dos personagens do jogo, isto é, seus atos, suas
reações e seu diálogo sejam mais parecidos possíveis com os de uma
pessoal real. (LIMA: MAIA, 2006, p.27).
28

De acordo com Clua e Bittencourt (2005), na maioria dos casos, o comportamento


inteligente é implementado através de máquinas de estados. Os algoritmos de máquinas de
estados descrevem diversos estados que o objeto pode se encontrar e a mudança entre esses
estados é disparada através de algum evento que dispare a transição. A fim de esclarecer, o
autor cita como exemplo os possíveis estados da televisão, desligada, ligada e stand-by. Ao
pressionar um botão <on> o aparelho muda seu estado de desligada para ligada.

Desta maneira, a inteligência de um personagem de um jogo pode ser


descrita por diversos estados em que o mesmo pode se encontrar (no caso
de um jogo de ação, poderíamos descrever estes estados como espera,
perseguição, ataque, fuga, morte, por exemplo). Este personagem deverá
fazer um monitoramento constante sobre acontecimentos que possam
disparar a mudança de um estado para outro. Usando o exemplo de um
jogo de ação, suponha-se que o fato do jogador aproximar-se mais do que
30m do NPC faça com que o mesmo passe do estado de espera para o
estado de perseguição. (CLUA; BITTENCOURT, 2005, p. 1339).

O entendimento do funcionamento do motor de jogo é essencial para auxiliar o


desenvolvedor na escolha do engine que é mais adequado ao seu projeto, o qual irá suprir
as necessidades do jogo. Assim, o desenvolver pode mensurar qual será o investimento que
precisará realizar. Isso é importante porque existem uma variedade de motores de jogos,
alguns de código aberto, gratuitos, e outros proprietários, onde há a necessidade da compra
de uma licença. Dependendo das necessidades do jogo, um motor de jogo gratuito pode
contemplar todo o ciclo de desenvolvimento e, consequentemente, evitar gastos
desnecessários ao projeto.

O custo de desenvolvimento é um dos principais fatores para a realização de um


projeto, porém existem outros que também são importantes e devem ser considerados. Clua
e Bittencourt (2005), listam os principais fatores que a equipe deve considerar ao escolher
um motor de jogo. O primeiro deles é, como já foi citado, o orçamento disponível. Existem
engines que ultrapassam U$ 1 milhão e dispõem de variados recursos para o
desenvolvimento, como desenvolver plug-ins específicos, adaptar funcionalidades da
ferramenta para necessidades do projeto e até treinamento aos programadores. A escolha
do motor de jogo também depende do tipo de jogo que será construído. Algumas
ferramentas só desenvolvem jogos 2D, por exemplo, não servindo a um projeto 3D.

O tempo de produção também deve ser analisado. É possível construir um jogo em


pouco dias, usando padrões já pré-construídos de alguns engines, porém todos os jogos
terão semelhanças. O motor de jogo deve suportar a plataforma que o jogo será distribuído.
29

O programador deve analisar a documentação do engine a fim de verificar se contempla as


exigências do jogo e se ele é capaz de utilizar os recursos fornecidos. E por último, quais
são as ferramentas compatíveis com o engine. É muito comum o áudio e a modelagem de
objetos 3D serem feitas em outras ferramentas e importadas pelo motor de jogo. É
importante que os arquivos sejam compatíveis para evitar que o trabalho seja descartado.

Antes de existirem os engines, os jogos eram escritos por completo, sem a


separação de gráfico e física, por exemplo. Os primeiros motores de jogos surgiram em
1985, após o crash do videogame, quando houve o aumento do número de computadores
domésticos. Era comum as produtoras construírem um motor de jogo para cada jogo que
era produzido. Porém, além do custo e da demora em construí-lo, essa é uma tarefa
bastante complexa. Assim, surgiram companhias especializadas em motores de jogos, que
os comercializam para outras empresas desenvolverem os jogos mais facilmente, com
funções já pré-programadas.

Desse modo, não precisamos, necessariamente, ter um profissional que entenda de


todo o processo do jogo, mas vários profissionais, onde cada um trabalha em sua
especialidade. Os motores de jogos modernos são aplicações mais complexas, fornecem
recursos mais sofisticados aos jogos, em todos os aspectos de sua construção. Existem
vários engines disponíveis no mercado, cada um com suas particularidades. A Tabela 1
abaixo mostra os motores de jogos mais utilizados pelos desenvolvedores brasileiros.
Tabela 1 - Uso de Engines
Quantidade de empresas Porcentagem de empresas que
Engine utilizada
que utilizam utilizam
Unity 106 79,7%
Tecnologia Própria 25 18,8%
Cocos 2D 18 13,53%
Blender 13 9,77%
Corona SDK 11 8,27%
Construct2 11 8,27%
GameMaker 8 6,02%
Flash 8 6,02%
Unreal3 (UDK) 7 5,26%
Marmalade 2 1,5%
CryEngine 1 0,75%
Outros 16 12,03%
Fonte: FLEURY (2014).
30

Esses dados compõem o I Censo da Indústria Brasileira de Jogos Digitais, realizada


em 2014. Entre os motores de jogos mais utilizados estão o Unity, tecnologia própria e o
Cocos 2D. Entretanto, o autor indaga o uso de tecnologia própria e esclarece que:

Chama a atenção o número de desenvolvedores que trabalham com


tecnologia própria, uma vez que para o desenvolvimento essa é uma das
opções mais onerosas; além disso, os desenvolvedores brasileiros não têm
tradição nesse desenvolvimento. É possível que nesta questão alguns
desenvolvedores tenham marcado essa reposta, mas na verdade se
utilizam de uma construção própria a partir de códigos gratuitos
disponibilizados na web, também mostrando a dependência de tecnologia
(FLEURY, 2014, p. 51 e 52).

O Unity possui uma interface intuitiva e de fácil manipulação, facilitando o


processo de desenvolvimento e a criação de novos projetos. Ele possui uma versão básica
gratuita e uma mais completa, assim como a maioria dos motores de jogos disponíveis no
mercado. É um dos engines mais utilizados mundialmente. O Unity causou uma verdadeira
mudança de paradigma no ambiente de desenvolvimento de jogos, pois integra as
principais ferramentas de um motor de jogo em um único ambiente. É possível manipular
vários recursos apenas com as ações arrastar/soltar, como por exemplo: mudar texturas de
objetos tridimensionais, alterar áudios específicos, manipular scripts e variáveis de jogo,
entre outros (LEMES, 2009, p. 124 e 125).

A ferramenta possui um motor de física avançado, preparado para desenvolver


situações de diversas necessidades de um jogo, ou seja, podemos reproduzir efeitos de
forças, vento, colisão, corrida, tiro, personagens, entre outros. Outra vantagem é a
compatibilidade com extensões comumente usadas em produções digitais, no que diz
respeito a imagens, áudio e vídeos, que podem ser reproduzidos em qualquer momento do
jogo. No próximo tópico apresenta-se o motor de jogo Unity, incluindo seus principais
recursos e funcionalidades.

2.4 UNITY 3D

A ferramenta Unity, também conhecida como Unity 3D, é um dos motores de jogos
mais populares utilizados atualmente. Sua primeira versão foi lançada em 2005, como um
motor de jogo proprietário, desenvolvido e mantido pela Unity Technologies. Atualmente
possui duas versões, a versão proprietária, chamada Unity®Pro, e a versão gratuita, Unity®,
31

disponível desde 2009 para estudantes e desenvolvedores indie. É possível comercializar


os jogos utilizando a versão gratuita, desde que o faturamento não ultrapasse cem mil reais
por ano. Desse modo, muitos desenvolvedores e estudantes, que antes não tinham acesso a
uma ferramenta para construir seus jogos, puderam ingressar no mercado de jogos
eletrônicos.

Além da versão gratuita, a ferramenta é bastante atrativa por possuir


funcionalidades que suprem inúmeras necessidades do ciclo de desenvolvimento, por ter
uma documentação completa com exemplos de todas as funcionalidades, editor de fácil
utilização e por ser multiplataforma. Os jogos desenvolvidos podem ser exportados para as
seguintes plataformas: iOS, Android, Windows Phone, Tizen, Windows, Windows Store
Apps, Mac, Linux/Steam OS, Web Player, WebGL, PlayStation 3, PlayStation 4,
PlayStation Vita, Xbox One, Xbox 360, Wii U, Android TV, Samsung SMART TV, Oculos
Rift, Gear VR e PlayStation VR.

De acordo com informações da empresa, o Unity tem mais de 45% de participação


no mercado, contra 17% do seu concorrente mais próximo, o Unreal Engine, e 38% de
outros. Com quase cinco milhões de usuários, é o motor de jogo preferido por 47% dos
desenvolvedores de jogos, como mostra a Figura 2. Existem mais de 600 milhões de
jogadores de produtos confeccionados com Unity. A ferramenta permite desenvolver jogos
em 2D e 3D com bastante qualidade e domina o mercado de jogos 3D para dispositivos
móveis6.

Figura 2 - Uso dos motores de jogos pelos desenvolvedores

Fonte: Vision Mobile, Developer Economics, State of the Developer Nation Q3, 20147

6
Disponível em: https://unity3d.com/pt/public-relations Acesso em: 26 mai. 2016.
7
Disponível em: http://www.visionmobile.com/product/developer-economics-q3-2014/ Acesso em: 26 mai.
2016.
32

O Unity 3D oferece uma tecnologia que permite uma ótima qualidade visual e de
jogabilidade, suportando até gráficos e mecânicas que reproduzem efeitos mais realistas,
com vários tipos de iluminação, texturas e elementos físicos. A ferramenta possui uma
tecnologia avançada, capaz de reproduzir no ambiente de desenvolvimento componentes já
pré-elaborados que facilitam o desenvolvimento do jogo, como por exemplo: luz solar,
efeitos noturnos, criação de cenários e terrenos, lagos, montanhas, árvores, explosões,
chuva, neve, tempestade de areia e outros objetos de cenário de uma forma muito
simplificada e personalizável.

Cada componente inserido na cena pode conter propriedades físicas que são
configuradas de forma simples e bastante realista. Podem ser modificados elementos como:
peso, massa, colisão entre objetos e gravidade. Outro componente fundamental para a
construção dos jogos é o áudio, o som pode ser configurado de forma que ele continue
estável durante todo o jogo ou que faça o volume aumentar e diminuir ao se aproximar ou
se afastar de um determinado objeto.

Geralmente, os scripts da programação dos jogos são escritos na ferramenta


MonoDevelop, um software de código aberto instalado junto com o Unity 3D. Os scripts
podem ser construídos em três linguagens: JavaScript, C# ou Boo. Esses scripts podem ser
criados em uma única dessas linguagens ou nas três, pois cada script pode comunicar-se
com o outro independente da linguagem de programação que foi criado. De acordo com
Xavier (2011), “essa liberdade de programação é um ponto positivo, pois podemos dividir
o projeto em partes e cada um ser feito por programadores diferentes, sendo facilmente
interagido posteriormente, dando uma possibilidade de desenvolvimento em paralelo”.

O engine fornece suporte para a criação de jogos de vários tipos, entre eles: single
player ou multiplayer, em primeira pessoa ou terceira pessoa, offline ou online. O Unity 3D
possui todos os principais componentes que são indispensáveis para o desenvolvimento de
jogos atuais. Isso justifica o motivo dele ser bastante requisitado entre os desenvolvedores.
Além disso, existe a possibilidade de importar imagens e texturas de outras ferramentas
gráficas e de modelagem de forma muito intuitiva, arrastando os arquivos do computador e
soltando na área de desenvolvimento no Unity.

O Unity 3D é uma ferramenta bastante intuitiva, utilizada tanto por usuários


avançados como por quem está iniciando na indústria de criação de jogos. A empresa
33

disponibiliza toda documentação, onde é explicado cada componente da ferramenta,


apresentando exemplos e facilitando o aprendizado. Essa documentação pode ser acessada
através do próprio engine ou através do site8. Além da documentação, a Unity
Technologies tem uma área de aprendizado com tutoriais, treinamentos, vídeo aulas e
fóruns onde os desenvolvedores podem tirar dúvidas9. O engine está sempre melhorando e
recebendo atualizações que tornam essa ferramenta cada vez mais atrativa para os
desenvolvedores de jogos. Apesar de tantas vantagens e de ser a ferramenta mais utilizada
para desenvolvimento, principalmente web e mobile, existem as limitações. A principal é o
fato de não existir uma versão do Unity compatível com os sistemas Linux. Ele só pode ser
instalado apenas em sistemas Windows ou Mac.

O Unity 3D possui uma interface simples que facilita a manipulação e a


organização dos arquivos e componentes do jogo. A área de trabalho é formada por várias
janelas, cada uma com uma finalidade específica, que podem ser organizadas de acordo
com a preferência do usuário, como mostra a Figura 3.

Figura 3 - Tela inicial do Unity 3D

Fonte: Elaborada pela autora.

O painel Scene é onde as cenas do jogo serão construídas. Essa aba fornece um
ambiente 3D para manipulação dos elementos visuais, possibilitando posicionar os objetos
na tela e modificar a rotação e o tamanho de cada objeto, como câmera, personagens,

8
Documentação Unity. Disponivel em: http://docs.unity3d.com/Manual/index.html Acesso em 28 mai. 2016.
9
Disponível em: https://unity3d.com/pt/learn Acesso em: 28 mai. 2016.
34

casas, nuvens, terrenos, ou seja, tudo que compõe o cenário do jogo. Os objetos inseridos
na Scene também estarão localizados na janela Hierarchy, que funciona como uma lista
dos objetos de cena. De acordo com Fernandes (2015), as cenas devem ser encaradas como
níveis ou fases do jogo contendo apenas os elementos de jogo de cada fase da experiência.

A janela Game é a visão da cena a partir da perspectiva do jogador, ou seja, o


desenvolvedor visualiza em tempo real como o jogo será visto pelo jogador. Todo objeto
modificado na Scene será também modificado na janela Game, que é renderizada através
da câmera localizada na Scene. Além da pré-visualização da cena do jogo, o painel Game
possibilita executar e testar a cena que está sendo construída, permitindo a rápida
identificação e correção de erros. O painel também apresenta várias informações
estatísticas sobre a simulação, são elas: tempo de processamento, número de frames por
segundo, número de triângulos e vértices renderizados, memória utilizada, entre outras.

A janela Hierarchy mostra uma lista de todos os objetos adicionados na janela


Scene. Ao adicionar ou remover um objeto de uma janela, ele também será modificado na
outra. Enquanto a Scene mostra os objetos de forma gráfica, a Hierarchy mostra em forma
de texto estabelecendo a hierarquia entre eles. A ferramenta permite agrupar elementos em
níveis de paternidade, de modo que o comportamento de um interfira no comportamento
dos seus elementos dependentes, facilitando alterações das características ou
funcionamento desses objetos.

A janela Project é onde o desenvolvedor pode visualizar e manipular todos os


arquivos do jogo. Toda a estrutura apresentada na janela de projeto corresponde à subpasta
Assets. Nela, serão inseridos todos os arquivos que irão compor a cena do jogo, tais como:
cenas, modelos, texturas, fontes de texto, imagens, vídeos, efeitos de áudio, scripts, entre
outros. A fim de manter o projeto organizado e para facilitar a localização dos aquivos, é
recomendável que o desenvolvedor crie subpastas, de acordo com o tipo de arquivo que
será inserido, ou seja, uma pasta para texturas, outra para áudios, outra para scripts, e assim
por diante. A aba Console, localizada ao lado de Project, mostra informações sobre o
projeto que está sendo criado ao reproduzir a cena. Os problemas, erros e advertências
serão exibidos nessa janela.

A janela Inspector mostra as informações de um objeto que está selecionado nas


janelas Scene, Hierarchy ou Project. Todo objeto inserido na cena possui três
35

características básicas que são a posição, rotação e escala. É possível modificar esses
valores tanto na Scene, com também na janela Inspector. Além de modificar essas
características básicas que todo elemento de cena possui, é possível inserir outros
componentes em cada objeto, como: sons, scripts, texturas, propriedades físicas, entre
outros.

Como mencionado, os scripts são escritos na ferramenta MonoDevelop. Eles são


criados através do botão Create na aba Project. Após nomear o arquivo e criá-lo, o
MonoDevelop será inicializado para que o código possa ser editado, o nome do arquivo
deve ter o mesmo nome da classe. Ao clicar no arquivo de script, localizado na aba
Project, ele pode ser pré-visualizado na janela Inspector, porém esse ambiente não permite
edição. Para modificar o código é necessário abrí-lo, com um duplo clique, para iniciar o
MonoDevelop e realizar a edição. O script terá a seguinte estrutura:

Figura 4 – Estrutura padrão do script

Fonte: Elaborada pela autora.

Nas duas primeiras linhas, são importadas as bibliotecas básicas que são
necessárias a um jogo. A primeira, UnityEngine, é responsável por incorporar todos os
recursos de funcionalidades do Unity 3D. Cada objeto que está em cena também está
catalogado na aba Hierarchy e é um GameObject, ou seja, todos os objetos inseridos são
instâncias da classe GameObject, que pertence à biblioteca UnityEngine. Através dela,
pode-se manipular as funcionalidades dos GameObjects, como: atribuir som, mover
objetos, incluir efeitos visuais, renderizar imagens, entre outros. A biblioteca
System.Collections possui classes e interfaces que definem várias coleções de objetos,
como: listas, filas, matrizes de bits, tabelas hash e dicionários.
36

A linha 4 mostra a criação da classe pública Exemplo, que herda de uma classe
chamada MonoBehaviour. Essa classe, que pertence à biblioteca UnityEngine, é essencial
para manipular funções de um GameObject, ou seja, permite o acesso ao funcionamento
dos componentes dos objetos na cena de jogo no Unity 3D. De acordo com Okita (2014), a
classe MonoBehaviour deve ser pensada como um conjunto de ferramentas que conversam
com o Unity 3D. As funções são chamadas com base em eventos que acontecem quando o
jogo está sendo executado.

Existem outras funções que também são chamadas automaticamente


quando MonoBehaviour é usado: Awake(), OnEnable(), Start(),
OnApplicationPause(), Update(), FixedUpdate(), e LateUpdate(); estas
funções são comumente chamadas quando o objeto é criado e o jogo está
executando. Quando o objeto é destruído, OnDestroy() é chamado
(OKITA, 2014, p. 111, tradução nossa).

Assim como a função OnDestroy é chamada quando se quer eliminar um objeto de


cena, cada função definida na classe MonoBehaviour possui um propósito e é chamada de
forma automática pelo jogo, basta o programador implementá-la da forma adequada. As
funções Start e Update (linhas 7 e 12, respectivamente) são criadas por padrão, fazem parte
da classe MonoBehaviour. Elas são chamadas automaticamente quando o objeto é criado.
A função Start é executada uma única vez, assim que o objeto é criado. Já a função Update
é executada a cada frame, ou seja, é chamada a cada quadro de renderização. Os comandos
que precisam ser executados durante todo o jogo são colocados dentro da função Update, é
o que estabelece vida ao jogo. Por exemplo, se um jogo funciona a 30 frames por segundo,
a função será chamada 30 vezes (OKITA, 2014).

O código apresentado é gerado dessa forma sempre que um novo script é criado,
sendo da competência do programador ajustá-lo, de forma que cumpra os requisitos
contidos no documento de game design do jogo proposto.
37

3 TRABALHOS RELACIONADOS

Este capítulo apresenta os principais trabalhos relacionados à esta pesquisa.


Primeiramente, apresenta-se a discussão em relação ao game design. Em seguida, discute-
se trabalhos semelhantes, e que destacam-se como uma inspiração, ao que este se propôs a
realizar.

3.1 GAME DESIGN

Existem vários autores que trabalham conceitos do processo de design de jogos


digitais, dentre os quais destacam-se, neste trabalho, as abordagens de Rogers (2010) e
Perucia et. al (2005). O design de jogos mescla vários saberes, como roteiro, ilustração,
cinema, interatividade, entre outros. Nesse contexto, o trabalho de Rogers (2010) se
apresenta como um guia completo para o profissional que deseja criar um jogo de
videogame para qualquer plataforma, inclusive a de dispositivos móveis, como foi
apresentado. O autor, descreve as etapas do design de jogos com base na sua experiência
profissional de mais de uma década e em obras bem sucedidas, como God of War e
Darksiders.

A primeira etapa contempla a definição do que o autor denomina três “Cs”:


Character, Camera e Control. Essa primeira atividade destaca a importância que o game
designer deve ter ao pensar a composição do personagem, a localização da câmera e como
o jogo será controlado. A partir daí, e com esses aspectos bem definidos, pode-se definir as
outras etapas da concepção do projeto. O autor aborda cada uma detalhadamente,
contemplando gêneros e tipos de jogos, interface, level design, personagens, cenários,
músicas, pontuações e bônus, entre outros. Além de apresentar toda a equipe necessária
para o desenvolvimento de um grande jogo, especificando as funções de casa profissional.
Por fim, o trabalho apresenta um modelo de documento de game design completo.

Perucia et. al (2005) apresenta técnicas fundamentais para a construção de jogos em


duas dimensões (2D). Enquanto Rogers (2010) volta-se totalmente para a formação do
documento de Game Design, refletindo sobre a construção dos elementos gráficos, sonoros
38

e de jogabilidade, Perucia et. al (2005) engloba também um conhecimento razoável de


programação, apresentando um protótipo de um jogo em funcionamento. O trabalho de
Perucia et. al (2005) é dividido em três partes. A primeira, aborda a etapa de concepção,
planejamento e modelagem. A segunda, apresenta conceitos básicos de projeto de jogos,
como gráficos, entradas, sons, tempo e forças físicas. Por fim, a terceira parte propõe
experimentar a construção de um jogo, com ênfase nas atividades de programação.

3.2 DESENVOLVIMENTO DE JOGOS

Diversos trabalhos na literatura têm analisado e apresentado o processo de


desenvolvimento de jogos digitais que são projetados e desenvolvidos pelos próprios
autores, com destaque aos jogos casuais, assim como o presente trabalho.

O trabalho desenvolvido por Pereira (2006) tem como objetivo avaliar os processos
envolvidos nas fases de projeto e desenvolvimento de jogos computacionais, discorrendo
desde a fase inicial (concepção) até o produto final (jogo). Assim, o autor apresenta
conceitos sobre metodologias de desenvolvimento de software e de jogos, tipos e gêneros
de jogos, situação do mercado nacional, etapas do design de jogos e, por fim, o relato do
desenvolvimento do jogo The Quest.

Através da experiência de construção do jogo The Quest, observa-se a


complexidade e interdisciplinaridade do processo de construção de um jogo digital. As
tarefas definidas no documento de game design exigem o conhecimento de vários saberes,
como: programação, modelagem e animação, composição de trilhas sonoras, entre outros.
A maior dificuldade encontrada, pelo autor, durante esse processo, foi a realização de todas
as etapas do projeto sem contar com o apoio de outros profissionais. Desse modo, recorreu-
se à importação de personagens e sons disponibilizados em sites de forma gratuita. Essa
escolha deveu-se ao fato de minimizar o trabalho, já que o foco principal é o projeto de
jogos e não a modelagem em si. Em posse dos elementos gráficos e sonoros, utilizou-se a
versão gratuita do Engine 3D Game Studio, com a finalidade de agregá-los e compor o
jogo. A respeito do engine, o autor aponta de forma positiva a fácil aprendizagem e
utilização. E, como negativa, a restrição em relação ao número de objetos que são
suportados em cena.
39

Outro trabalho relacionado, com objetivos e metodologia semelhantes, com o


trabalho apresentado, é o de Fernandes (2015) que relata a construção do jogo Sticky 2048,
uma versão inspirada em um jogo já existente, o 2048. O projeto teve como principal
motivação transformar algo simples e já experimentado numa experiência nova, capaz de
atrair os antigos jogadores e despertar o interesse de novos. Diferentemente de Pereira
(2006), Fernandes (2015) constrói o jogo com o uso do engine Game Closure. O Game
Closure é um motor de jogos, gratuito e de código aberto, que permite desenvolver jogos
2D para plataformas móveis.

De maneira geral, os trabalhos apresentados por Pereira (2006) e Fernandes (2015),


são a base de inspiração para o presente trabalho. Todos estes fazem parte de um mesmo
escopo, ou seja, apresentar o relato de experiência da criação de um jogo independente.
Porém, é importante ressaltar, que o processo de desenvolvimento se apresenta de forma
distinta nas três abordagens. Principalmente, no que diz respeito ao uso do motor de jogo e
à construção dos elementos gráficos e sonoros que compõem o jogo. As etapas de
composição do jogo Murphy são bem definidas e elaboradas por uma equipe
multidisciplinar.
40

4 ESTUDO DE CASO: MURPHY

Neste capítulo será apresentado um relato do processo de desenvolvimento do jogo,


a fim de demonstrar as fases de projeto e desenvolvimento de jogos eletrônicos,
apresentadas nos capítulos anteriores.

4.1 HISTÓRIA DO JOGO

O jogo Murphy apresenta a estória de um jovem, chamado Murphy, que, após


atingir a pontuação máxima em um quiz10 sobre astronomia, matemática e engenharia
espacial, recebe a oportunidade de se aventurar como um astronauta. O jovem torna-se o
piloto de testes de uma agência espacial, a Nebulosa Aloysius, que realiza pesquisas sobre
transporte aeroespacial em cápsulas quânticas gravitacionais, uma nova tecnologia de
transporte desenvolvida pela agência. O jogo inicia com o personagem localizado na Terra,
vestido com uma roupa especial, semelhante à de um astronauta, preparado para iniciar a
viagem até à nave espacial. O objetivo do jogo é guiar o Murphy até que ele chegue à nave.

O nome Murphy, designado para o jogo e para o personagem principal, é uma


homenagem ao engenheiro aeroespacial da Força Aérea Americana Edward Aloysius
Murphy. A inspiração para a ideia surgiu baseada na popular lei de Murphy, que diz “Se
alguma coisa pode dar errado, dará”. Essa “lei” é comumente utilizada no meio popular
como uma justificativa bem (ou mal) humorada e pessimista, alegando que se alguma coisa
deu errado foi porque já estava destinada a dar errado. Essa lei surgiu em 1949, quando
Murphy se viu diante de um experimento que testava efeitos da aceleração e desaceleração
em pilotos de aeronaves. A experiência envolvia um conjunto de dezesseis medidores de
aceleração colocados em diferentes partes do corpo humano. Existia duas maneiras de
colocar os sensores, e um técnico instalou todos os dezesseis da maneira errada. Diante
disso, Murphy pronunciou a frase. Com base nesse acontecimento, a equipe de
desenvolvimento buscou inspiração para iniciar a aventura de construir um jogo sobre uma

10
Jogo de perguntas e respostas.
41

viagem aeroespacial, encorajados pela lei de Murphy: se esse jogo tivesse que dar errado,
certamente daria.

Desse modo, surgiu o projeto Murphy. A viagem do personagem, da Terra até à


nave, é feita através de trilhos coloridos, que iniciam no chão e terminam quando o Murphy
aterriza na nave. O personagem viaja em uma cadeira, presa a esses trilhos através de uma
força magnética, que permite que ele vá subindo até que atinja a altitude que a nave se
encontra. Os trilhos são construídos pelo próprio jogador no decorrer do nível. O desafio é
que para surgirem novos trilhos, o jogador precisa acertar os alvos localizados no lado
oposto, como mostra a Figura 5.

Figura 5 - Cena de um nível do jogo

Fonte: Elaborada pela autora.

A cor do trilho determina a cor do tiro que será disparado e, consequentemente, a


cor do alvo que deverá ser atingido. Cada tiro quando acerta o alvo corretamente faz com
que um novo trilho apareça e o jogador suba de altitude, aproximando-se do objetivo final.
A cor desse novo trilho é gerada de forma randômica pela mecânica do jogo. Cada tiro
quando erra o alvo faz com que o jogador perca dois trilhos. O jogo acaba quando o
jogador não possui mais trilhos na tela e cai, pois são estes que permitem sua sustentação,
ou ele cumpre o objetivo final. Existem, no máximo, três trilhos na tela do jogo. Portanto,
se o jogador errar uma vez ele precisa, obrigatoriamente, acertar os alvos seguintes para
construir novos trilhos. Se errar duas vezes seguidas, ele perderá esse nível, perderá a
pontuação conquistada e deverá começar novamente, até que conclua o nível por inteiro.

Essa característica é comum em jogos do tipo Roguelike. O estilo Roguelike possui,


basicamente, duas características principais: possuir cenários aleatórios e o fato de que se o
42

jogador falhar em algum ponto antes de concluir a fase, ele irá começá-la novamente. Os
cenários gerados aleatoriamente têm como propósito fazer com que o jogo se torne algo
imprevisível, possuindo aspectos diferentes a cada vez que é iniciado. A outra
característica, o fato de que ao morrer o jogador voltará ao início da fase, apesar de parecer
algo negativo, pois seria mais vantajoso poder salvar o progresso, ela permite manter um
nível de dificuldade que faz com que o jogador fique atento, melhore suas habilidades e se
supere a cada tentativa.

Enquanto esse elemento promove o constante desafio de superação das habilidades


do jogador, o cenário composto de forma aleatória permite que a fase não fique repetitiva,
garantindo que o jogador não perca o interesse e abandone o jogo. O jogo é dividido em
níveis (fases) com dificuldades e desafios crescentes. O jogador precisa concluir um nível
inteiro, sem perder todas as chances de acertos, para que um próximo nível seja
desbloqueado e ele possa se aproximar cada vez mais ao objetivo final.

O Murphy, além das características do estilo roguelike, também é um jogo side-


scrolling e point-and-click. Side-scrolling ou side-scroller é a expressão utilizada para
jogos em que a câmera se desloca somente na lateral, de forma vertical ou horizontal. Um
exemplo de jogo bastante conhecido com esse estilo de rolagem é o Super Mario Bros,
onde a tela de jogo se move de forma horizontal. No caso do Murphy, a rolagem acontece
de forma vertical. O personagem começa embaixo, no chão, e a câmera o acompanha até o
topo, simbolizando a ida da Terra até o espaço. A característica point-and-click (apontar e
clicar) é utilizada para disparar os tiros que saem da arma do personagem e irão atingir o
alvo. Quando o jogador clicar no espaço de tela onde a arma está localizada, ela efetuará o
disparo. Assim, caso acerte o alvo corretamente, o jogador poderá construir novos trilhos
que farão o personagem subir ou perder os trilhos que possui, caso erre.

A partir da ideia geral e das caraterísticas básicas apresentadas que compõem o


conceito do jogo, partimos para a etapa de definição dos níveis, personagens, premiações,
registro de pontos, sonoridade e dos demais elementos que foram desenvolvidos para a
criação do jogo. A descrição das atividades e dos elementos de jogo que estão registradas
no documento de Game Design (GDD) serão apresentadas a seguir.

4.2 DOCUMENTAÇÃO DO PROJETO


43

Este tópico apresenta os detalhes e a descrição dos elementos que compõem o


projeto Murphy, como: personagens, alvo, trilhos, armas, fases, áudios, entre outros.

4.2.1 Elementos de cena

Após estabelecida a ideia inicial, elaborou-se os primeiros rascunhos, como uma


forma para entender a mecânica do jogo e estabelecer as regras necessárias para alcançar o
objetivo.

Figura 6 - Primeiro esboço da fase do jogo

Fonte: Elaborado pelo Game Designer do jogo Murphy.

A imagem acima representa o nível principal do jogo, em que o personagem


Murphy realiza uma viagem, saindo da Terra, para chegar a uma nave espacial. A partir
dela, a equipe de desenho elaborou os elementos de cena, com a utilização da ferramenta
livre GIMP. Os elementos da fase são: os trilhos que dão sustentação ao personagem e o
levam até a nave; a cadeira onde o personagem está preso aos trilhos; o personagem
portando uma arma; e os alvos que deverão ser atingidos pelos tiros que o personagem
dispara.

O cenário do jogo foi pensado de forma linear, de baixo para cima, como se não
existissem paradas durante o decorrer do jogo. A cena inicia com o personagem no chão e
à medida que terão acertos ele irá subindo e passando pelas diferentes camadas da Terra,
até atingir o espaço. Entretanto, em alguns pontos dessa viagem, pontos de transição entre
as fases, o jogador é levado às fases secundárias, com um novo cenário, onde ele deverá
cumprir pequenos objetivos. Todas as fases serão descritas no próximo tópico, onde será
abordado a etapa de Level Design.
44

Figura 7 - Cenário principal do jogo Murphy11

Fonte: Elaborado pela equipe de desenho do jogo Murphy

A partir da pré-visualização dos elementos básicos que compõem o cenário foi


possível definir como serão feitas as interações entre objetos e personagens durante o
tempo de jogo.

4.2.2 Personagens

O jogo possui cinco personagens, são eles: Murphy, Rafael, Uba-Spock, Thaísa e
Fish. O Murphy é um jovem muito inteligente, apaixonado por astronomia e engenharia
espacial. Ele foi contratado como piloto de teste de uma agência espacial, após obter a
pontuação máxima em um jogo de perguntas e respostas. Para o Murphy, ter a
oportunidade de realizar essa viagem é a concretização de um sonho que ele alimentava
desde a infância.

11
A imagem foi dividida em três partes a fim de obter uma melhor apresentação visual. Porém, ressalta-se a
abordagem da cena de forma linear, iniciando no chão e finalizando no espaço, onde se encontra a nave.
45

Figura 8 - Composição do personagem Murphy

Fonte: Elaborado pela equipe de desenho do jogo Murphy.

O personagem veste uma roupa especial, com as cores da agência que o contratou,
a Nebulosa Aloysius. O Murphy é o único personagem jogável e sua principal ação é atirar
nos alvos com a pistola e, assim, conseguir se aproximar cada vez mais da nave espacial.

Figura 9 - Versão final do personagem Murphy

Fonte: Elaborado pela equipe de desenho do jogo Murphy.

O personagem Rafael é um gênio na área da astrofísica, também trabalha na


agência aeroespacial e gosta de cozinhar para os amigos. O Uba-Spock é um capitão de
uma agência de pesquisa e proteção de seres galáticos de outro planeta. Ele pousou na
agência Nebulosa Aluysius após sua nave ser atingida por um asteroide. Desde então ele
pesquisa uma forma de consertá-la para voltar ao seu planeta. Thaísa é pesquisadora e
proprietária da agência. Ela desenvolveu uma nova tecnologia para viagens aeroespaciais,
com a ajuda de Rafael, e contratou o Murphy como piloto de testes. Fish é um gato que
mora na agência e realiza algumas viagens com o Murphy. Esses personagens interagem
com o Murphy em fases secundárias, cada uma com objetivos distintos, apresentados a
seguir.
46

4.2.3 Level Design

Existem dois tipos de fases: a viagem e as quests. A viagem é o nível principal,


quando o personagem se desloca através dos trilhos para ir de um ponto a outro. Durante a
viagem existem algumas paradas, para que o jogador possa salvar o progresso e executar as
quests. As quests são fases secundárias, funcionam como pontos de transição entre uma
parada e outra no nível principal. São importantes, pois estabelecem uma pausa, onde o
jogador pode descansar do modo rápido e preciso do nível de tiro ao alvo. Nas fases
secundárias o jogador terá que cumprir pequenos objetivos. Desse modo ele irá interagir
com novos personagens e desbloquear novas trilhas sonoras.

A cada nível concluído será possível salvar o progresso no jogo. Todas as ações são
realizadas através do toque na tela. Durante a execução dos níveis da viagem aeroespacial
o toque, em qualquer ponto da tela, fará a arma disparar. Nas fases secundárias, a interação
irá ocorrer ao clicar em cima do elemento correto, correspondente ao objetivo proposto. O
jogo possui onze níveis, sendo seis níveis no modo viagem e cinco quests.

Todos os níveis do modo viagem possuem a mesma mecânica e regras. O jogador


deve acertar o alvo que possui a mesma cor do tiro, determinada pelos trilhos que prendem
o personagem. Ao acertar, surgirá um novo trilho que fará o personagem subir e chegar
mais próximo ao destino ou ponto de parada. Nos cinco primeiros níveis ele irá para outro
cenário, para concluir a fase de quest e salvar o progresso. No último nível ele chegará a
nave destino e o jogo terminará. Ao errar, ele perderá dois trilhos e ficará sustentado
apenas por um, caso erre novamente, ele cairá e voltará ao ponto inicial do nível. As quests
possuem a função de acalmar o jogador depois de um ritmo de jogo mais intenso, que
necessita de maior atenção. Em cada fase quest ele interage com um personagem non-
player character (não jogável) e desbloqueia novas trilhas sonoras.

A primeira fase corresponde ao primeiro teste de viagem. O Murphy iniciará no


chão e irá até a agência Nebulosa Aloysius, localizada numa plataforma no céu. Ao chegar
na plataforma, Murphy entra na agência e encontra Fish miando costantemente. Sua missão
é encontrar comida e alimentar o gato. Ao completar a missão, o jogo será salvo. Após
alimentar o gato, Murphy descobre que a agência está captando sinais de outro planeta,
mas que não consegue identificar, pois é necessário uma maior altitude para que o sinal
47

seja entendido com clareza. Diante disso, Murphy partirá em uma nova viagem, que inicia
na agência e termina no Centro Espacial de Pesquisas. Ao chegar no destino, o personagem
entra no centro de pesquisas e tem como missão gravar o sinal recebido e enviá-lo para
Thaísa, que está na agência.

Enquanto Thaísa tenta decifrar a mensagem recebida, Rafael avisa ao Murphy que
ele precisará subir até o planeta mais próximo para buscar o ingrediente secreto da receita
de macarronada espacial, que só é cultivado nesse planeta. Após essa conversa, o jogo será
salvo e iniciará mais uma fase do modo viagem, que irá do centro de pesquisa até o planeta
mais próximo. Ao chegar, Murphy colhe o ingrediente secreto e o envia para a agência,
dentro de uma cápsula quântica gravitacional, semelhante a que ele viaja. Após a cena de
envio, Thaísa avisa ao Murphy que conseguiu decifrar a mensagem. Um extraterrestre,
chamado Uba-Spock, do planeta Vulcanium, quer viajar até a Terra. Entretanto, existe um
objeto não identificado no caminho. Murphy continua sua viagem até o objeto, a fim de
verificar se é seguro que Uba-Spock trafegue por ele.

Ao se aproximar do objeto, Murphy percebe que era apenas uma enorme


quantidade de balões perdidos no espaço, utilizados anteriormente em um passeio mal
sucedido. Como não há tripulantes, o personagem tem a missão de estourar os balões para
desobstruir o caminho de Uba-Spock e eliminar seu medo. O amável extraterrestre fica
bastante agradecido e convida Murphy para lhe fazer uma visita e tomar um café
intergaláctico. O progresso do jogo é salvo e o personagem inicia a viagem para o planeta
Vulcanium. Quando Murphy chega ao planeta, acontece a cena final do jogo, em que os
dois personagens tomam café intergaláctico e viajam na nave de Uba-Spock em direção a
Terra. Ao aterrizar, Murphy é promovido de piloto de testes para piloto profissional
estagiário.

A pontuação do jogo é estabelecida de acordo com a quantidade de acertos e erros


dos tiros nos alvos. Cada vez que o jogador erra um alvo, ele perde a pontuação acumulada
equivalente a dois acertos, ou seja, mesmo que o jogador consiga concluir o nível, quanto
mais ele errar, mais baixa será a pontuação. A pontuação será salva nos checkpoints12
existentes em cada término de uma quest. Caso o jogador falhe em um nível, toda a
pontuação acumulada naquele nível é perdida e ele terá que recomeçar a partir do último
ponto que o jogo foi salvo.

12
Pontos de salvamento.
48

Esse mecanismo de pontuação foi estabelecido com o objetivo de fazer com que o
jogador se sinta desafiado a conquistar a pontuação máxima. É um método usado para
manter a atenção do jogador no jogo, fazendo com que ele repita o nível várias vezes, até
que consiga superar sua própria pontuação ou a dos outros.

Depois de estabelecer as características e o funcionamento do jogo, o próximo


passo é construir todos os elementos de cena que foram descritos. Nessa etapa são usadas
ferramentas específicas para criação de imagens, sons, animações, entre outros. Cada
componente pode ser criado em programas apropriados e depois passados para um motor
de jogo, o qual será responsável pela comunicação entre eles.

4.3 DESENVOLVIMENTO

O jogo Murphy foi desenvolvido com o uso do motor de jogo Unity. Entretanto,
algumas outras ferramentas foram utilizadas para criar os componentes de jogo. Os
elementos gráficos foram inicialmente criados em papel e posteriormente redesenhados de
forma digital, utilizando a ferramenta GIMP. Após a criação dos objetos de cena, utilizou-
se a ferramenta Unity para compor os cenários e programar os comportamentos esperados
para cada objeto. Por fim, o jogo incorporou arquivos de áudio, elaborados através do
software livre Audacity, e incluídos ao jogo por meio do Unity.

O GIMP, sigla de GNU Image Manipulation Program, é um editor de manipulação


de imagens gratuito. Essa ferramenta foi escolhida para criar os elementos de cena por ser
um software livre e por exportar as imagens em extensões mais utilizadas e compatíveis
com o Unity, as principais são JPG e PNG. Desse modo, ela contempla as necessidades do
projeto e é possível reduzir o custo de produção, já que não é necessário comprar uma
licença. Outra grande vantagem da ferramenta é a possibilidade de criar animações
utilizando sequências de imagens. A Figura 10 mostra o processo de destruição de um alvo
ao receber um tiro.
49

Figura 10 - Sequência da animação de destruição do alvo

Fonte: Elaborado pela equipe de desenho do jogo Murphy.

Os arquivos sonoros foram produzidos com o uso da ferramenta Audacity. Através


dessa ferramenta criou-se todos os áudios incorporados ao jogo, ou seja, tanto as trilhas
sonoras (menu, fases primárias e secundárias) como os efeitos de sons (tiro, acerto ou erro
do alvo, interação entre os personagens, entre outros). O próximo passo foi unir os
elementos de jogo, com o objetivo de desenvolver as fases e programar o comportamento
dos componentes de cena. Para isso, criamos um novo projeto no Unity, chamado Murphy.
Esse projeto recebe tanto os componentes de jogo que já foram criados em outras
ferramentas, como também armazena os arquivos criados pelo Unity. Logo após, cria-se
novas pastas, uma para cada tipo de arquivo, a fim de manter a organização e facilitar o
acesso. Todos os arquivos que compõem o jogo podem ser visualizados e manipulados
dentro da aba Project, como mostra a Figura 11. O desenvolvedor pode criar e organizar as
pastas da forma que achar melhor.

Figura 11 - Pastas com arquivos do projeto Murphy

Fonte: Elaborado pela autora.

As cenas do jogo são construídas dentro da aba Scene e visualizada em tempo real
na aba Game. O que faz o objeto de cena aparecer na aba Game, é a presença de uma
câmera. A câmera define o espaço de tela que o jogador visualizará quando o jogo for
renderizado. Tudo o que estiver dentro da área de alcance da câmera é o que será
apresentado na tela de jogo.
50

Figura 12 – Criação de um nível do modo viagem

Fonte: Elaborado pela autora.

Como observa-se na imagem, a área apresentada do cenário de uma fase do Murphy


é maior do que a área mostrada na aba Game. Isto acontece porque a câmera está
configurada para captar apenas um determinado espaço em torno do personagem. O
cenário e outros elementos de cena irão aparecendo à medida que o personagem sobe. A
configuração da câmera é um dos primeiros elementos que devem ser ajustados, pois ajuda
o desenvolvedor a visualizar como cada componente inserido irá se apresentar ao jogador.
O botão play é responsável por iniciar a simulação do jogo. Isso permite que ele teste se as
configurações, animações e/ou programações utilizadas nos elementos estão funcionando
de forma correta sem que seja necessário salvar e compilar o jogo anteriormente. Todos os
elementos que estão inseridos na cena são catalogados na aba Hierarchy e podem ser
configurados na aba Inspector.

Figura 13 - Demonstração das abas Hierarchy e Inspector

Fonte: Elaborado pela autora.


51

A aba Inspector, na imagem acima, mostra as configurações do player, elemento


correspondente ao personagem inserido na Scene e listado na aba Hierarchy. Todos os
elementos de cena terão a propriedade Transform, é ela que define a posição, rotação e a
escala dos objetos. Por exemplo, se um objeto estiver muito pequeno na tela do jogo, basta
o desenvolvedor alterar a escala e mudar seu tamanho, podendo aumentar a altura no eixo
x, a largura no eixo y e a profundidade no eixo z. Existe uma relação de filiação entre o
Player, o NewBridgeSpawner e um GameObject chamado Bridge&Player. Um
GameObject é um elemento “invisível” que pode ser criado para representar objetos. Nesse
caso, o Player representa o personagem, o NewBridgeSpawner representa os trilhos e o
Bridge&Player funciona como um recipiente desses componentes. A filiação serve para
auxiliar a configuração. Por exemplo, se quisermos modificar o tamanho do personagem e
do trilho na mesma proporção basta modificar o componente scale do objeto pai, ou seja,
não é necessário mudar o Player e o NewBridgeSpawner individualmente, muda-se apenas
o Bridge&Player.

Outro componente do personagem mostrado na imagem é o Sprite Renderer. Ele é


usado para processar a imagem que caracteriza o personagem. Se no decorrer do projeto o
desenvolvedor quiser trocar a imagem do personagem sem alterar suas configurações,
bastaria localizar a nova imagem na aba Project, arrastá-la e soltá-la no item Sprite do
componente Sprite Renderer. Ou modificá-la em tempo de jogo através de um script. Em
jogos que os elementos sofrem mudanças de aparência, dependendo da troca de fase ou
uma mudança de estado, é recomendável modificar apenas a imagem, sem que precise criar
um novo elemento com as mesmas configurações do antigo.

Os scripts são criados no Unity, no menu Create da aba Project, e escritos na


ferramenta de desenvolvimento MonoDevelop, que é instalada junto ao motor de jogo. A
linguagem de programação utilizada no Murphy é a Csharp. Cada script, quado é criado,
possui no mínimo duas funções: Start e Update. A função Start executa uma única vez
sempre que o objeto é instanciado e a função Update executa enquanto o objeto existir. A
principal ação do Murphy é disparar um tiro em linha horizontal sempre que houver um
toque na tela, quando estiver numa fase de viagem.

Para isso, criou-se um GameObject, chamado BulletSpawn, posicionado com os


mesmos valores que a arma do personagem, para simular o efeito de tiro. Esse objeto é
criado filiado ao objeto Player como forma de garantir que caso haja mudanças na posição
52

ou tamanho do personagem, por exemplo, o tiro também sofra a mudança. Criou-se um


script, adicionado como um componente de BulletSpawn, responsável pela ação do
disparo. Sempre que houver um toque na tela, aparece em cena um novo objeto, um
pequeno feixe de luz que representa o tiro. A cor do tiro é determinada pela cor do trilho
que está sustentando o personagem no momento do toque. O tiro inicia na posição que o
GameObject BulletSpawn está e termina após um determinado tempo, definido também no
script. Desse modo, temos o efeito de que o personagem está atirando a cada vez que o
jogador toca na tela. A demonstração e análise da Figura 14 representa essa ação.

Figura 14 – Criação da classe e definição das variáveis

Fonte: Elaborado pela autora.

A classe “NewShot” é responsável pela criação e destruição do objeto bala. A


variável estática “instance” é uma instância dessa classe e é utilizada como forma de
facilitar o acesso ao objeto por outras classes. A variável chamada “BulletSpr”, do tipo
Sprite, armazena a imagem correspondente ao tiro. O tiro é criado via script, pois ele é
executado e destruído somente em tempo de jogo. Ele precisa ser criado quando o jogador
chamar a ação através do toque na tela. A variável “cd”, do tipo float, recebe o valor 1.75f.
Esse valor determina a quantidade de segundos que o tiro ficará aparecendo na tela. Após
esse tempo o objeto está programado para ser destruído. A variável “haidara” do tipo
booleano armazena o retorno dos métodos “Touched” e “Clicked” que retornam um valor
quando o jogador realiza um toque na tela ou o clique do mouse. A variável “ngc” irá
acessar e armazenar o retorno da variável “instance” da classe “NewGameControl”, que
controla quando o jogo começa e termina, ou seja, a variável “ngc” é utilizada para
verificar se o jogo está iniciado ou não.
53

Figura 15 – Métodos que controlam a interação do jogador com o objeto

Fonte: Elaborado pela autora.

Os métodos “Clicked” e “Touched” retornam verdadeiro ou falso. O primeiro é


utilizado para controlar o clique efetuado pelo mouse em um objeto de cena. E o segundo é
utilizado para controlar o clique efetuado através do toque, em uma tela touchscreen. Desse
modo, garantimos a possibilidade de experimentar o jogo tanto através do computador,
como através de dispositivos com tela sensível ao toque.

Figura 16 – Método Update

Fonte: Elaborado pela autora.


54

O método “Update” é executado a cada frame, durante todo tempo de jogo. Como
vimos, “ngc” é uma variável do tipo “NewGameControl” que armazena se o jogo está
iniciado ou finalizado. A variável “ngc” acessa os métodos GameEnd e GameStart. Caso
exista uma bala em cena, será chamado o comando Destroy e a bala será eliminada da
cena. A variável “cd” receberá o valor de “Time.deltaTime”, que controla a quantidade de
frames por segundo. Caso o tempo de “cd” seja maior que 1.75f e “haidara” seja
verdadeiro, ou seja, se houve uma ação de clique ou toque do jogador, uma nova bala será
criada e a variável “cd” irá receber o valor zero. Como o método “Update” é executado a
cada frame e a variável “Time.deltaTime” controla os frames por segundo, uma nova bala
só será criada quando o jogador executar um clique, depois do tempo de 1.75f.

Figura 17 – Método CreateBullet

Fonte: Elaborado pela autora.

O método “CreateBullet” é o responsável por criar, dar forma e ação ao tiro, ou


seja, o método cria e define o comportamento do GameObject chamado “blt”. Ao Criarmos
um GameObject “blt”, via script, um elemento GameObject é criado na cena do jogo
quando o método “CreateBullet” for chamado. A variável “blt_spr” do tipo SpriteRenderer
irá armazenar a imagem que foi fornecida ao objeto “blt”. Após definir a imagem que irá
aparecer na tela, representada através do objeto blt, é preciso definir a cor do objeto. De
acordo com as regras explícitas no GDD, a cor do tiro é determinada pela cor do trilho que
sustenta o personagem. Portanto, a cor será recebida através do acesso à classe que cria e
define o trilho. Ou seja, a variável “blt_spr” receberá o valor (cor) da variável “curClr” do
objeto que foi criado na classe “NewBridgeSpawner”.

Após criar e definir a cor do tiro, o método “CreateBullet” insere dois componentes
ao objeto, são eles: Rigidbody2D e BoxCollider2D. É através desses dois componentes que
podemos inserir propriedades físicas nos elementos. O Rigidbody2D adiciona ao elemento
55

uma propriedade de massa, fazendo com o que os objetos sofram a influência de forças
físicas. Entretanto, é preciso definir uma área de colisão para o objeto, ou seja, adicionar
também o BoxCollider. O BoxCollider2D é responsável por detectar colisões entre
elementos que possuem corpo. Através da inserção desses componentes, é possível
destruir o objeto correspondente ao alvo no momento em que a bala colide com ele. A
função “isTrigger” detecta a colisão, ou seja, garante que os elementos não se espalhem
pela cena no momento em que se chocarem. E a função “isKinematic” garante que o objeto
pare de reagir às forças aplicadas, ou seja, o tiro irá seguir em linha reta. Se houver a
ausência desse componente o tiro, ao ser “disparado” iria sofrer a força da gravidade e iria
“cair”.

4.4 LIÇÕES APRENDIDAS

Como apresentado, o processo de desenvolvimento do jogo eletrônico Murphy foi


dividido em três etapas. Inicialmente, elaborou-se a conceituação e a idealização das
características, regras e objetivos do jogo. A próxima etapa contempla o registro das ideias
no Documento de Game Design (GDD) e, por fim, iniciou-se o processo de
desenvolvimento do jogo, tendo como base apenas as definições contidas no GDD. Criar
um jogo eletrônico é uma atividade bastante complexa, que apresenta diversas dificuldades
no processo de construção. As principais dificuldades encontradas foram: a falta de
conhecimento de inúmeras funções e bibliotecas do Unity 3D; a inexistência de um
processo melhor alicerçado pelas premissas de engenharia de software; e a inexperiência
dos integrantes da equipe.

O projeto Murphy colaborou para a ampliação do conhecimento e amadurecimento


dos envolvidos, principalmente devido às dificuldades encontradas. A análise das falhas e
erros no processo de produção conta como um fator importante para que a equipe se
especialize cada vez mais. A primeira grande dificuldade encontrada foi o conhecimento
necessário para a melhor utilização do Engine Unity 3D. Por se tratar do primeiro contato
da equipe com a ferramenta, é necessário tempo e conhecimento para que os usuários
tenham a capacidade de realizar trabalhos de boa qualidade. Para adquirir esse
conhecimento foi imprescindível a leitura de livros e apostilas sobre desenvolvimento de
56

jogos e programação em C#, além da análise da documentação disponível no site do Unity


e tutoriais disponibilizados em sites de aprendizado para jogos digitais.

Após adquirir um conhecimento básico sobre as funcionalidades e programação no


Unity, iniciou-se o processo de desenvolvimento do jogo. A programação foi elaborada
baseada nas atividades e funcionalidades descritas no GDD, por exemplo: a função de
atirar, acertar um alvo, criar novos trilhos, interagir com outros personagens, registro de
pontuação, entre outras. Para cada atividade a equipe de programação criou classes
responsáveis por executar essas funções. Isso acarretou em diversas dificuldades e erros,
principalmente ao relacionar as classes, umas com as outras. A descrição das atividades,
apresentadas apenas no GDD, se mostrou insuficiente para definir os scripts que devem ser
criados. Nesse caso, acredita-se que a elaboração de um diagrama de classes poderia, por
exemplo, ter evitado algumas falhas, sendo de fundamental importância para guiar a equipe
no processo de desenvolvimento.

Devido à falta de experiência da equipe, o processo de desenvolvimento do jogo


teve vários momentos de paralisação das atividades. Surgiram diversas dificuldades as
quais os integrantes não sabiam solucionar, necessitando de mais tempo, para estudar e
aprender a resolvê-las, e então dar continuidade ao projeto. A ferramenta Unity é
compatível com outras ferramentas utilizadas no processo de construção. Esse fato
facilitou todo o processo, pois a equipe pôde elaborar diversos objetos de modelagem em
ferramentas especializadas, e enviá-los ao Engine. O Unity 3D se mostrou eficaz e
suficiente para todo o processo de integração dos componentes do jogo.
57

5 CONSIDERAÇÕES FINAIS

A indústria dos videogames está em crescimento, sobretudo com relação aos


dispositivos móveis. Essa demanda desperta interesse tanto nos novos profissionais como
também nos desenvolvedores independentes (indie). Os dispositivos móveis introduziram
novos jogadores no mercado, com diferentes perfis e faixa etária, que consomem jogos de
variados gêneros e níveis de dificuldade. Para os novos desenvolvedores, a construção
desses jogos casuais é bastante tentadora e sua concepção não é tão complexa quanto um
jogo para console. Essa foi a principal motivação para a criação do jogo apresentado.

O presente trabalho teve como objetivo relatar o processo de construção do jogo


Murphy, desenvolvido para a plataforma Android, com o uso do motor de jogo Unity 3D.
Diante disso, foram apresentadas as fases de projeto e desenvolvimento do jogo,
enfatizando a possibilidade de desenvolver jogos de forma independente e com poucos
recursos. A criação de um jogo digital é um processo que envolve várias etapas e múltiplos
conhecimentos, principalmente relacionados à modelagem, animação, composição sonora,
game design e programação. Essas características são organizadas, definidas e
documentadas no documento de game design (GDD). O GDD abrange desde a ideia inicial
do jogo até a fase final, em que o jogo será testado e disponibilizado para os usuários.

Conforme apresentado, o documento contempla as regras, mecânicas e objetivos do


jogo. Para se ter o entendimento desses três aspectos, o GDD descreve: a história do jogo e
dos personagens; a jogabilidade, ou seja, definir as ações que o jogador pode executar e as
que irá sofrer; detalhes físicos de cada elemento da cena; detalhar como serão as fases
(level design); e definir a inteligência artificial, como os elementos de jogo irão reagir
diante das ações do personagem. Após documentar a ideia do jogo e definir o que precisará
ser feito, iniciou-se a fase de implementação do Murphy.

A complexidade de desenvolvimento de um jogo é proporcional ao seu tipo, gênero


e mecânica. Para o desenvolvimento do Murphy não foram necessários recursos ou
conhecimentos matemáticos e físicos muito sofisticados, o Unity 3D e as ferramentas
auxiliares que foram utilizadas contemplaram toda a demanda especificada no projeto. O
jogo foi desenvolvido utilizando a versão gratuita do Unity 3D. Além do Unity 3D, outras
ferramentas foram utilizadas na concepção do Murphy, como o GIMP e o Audacity, ambas
58

também gratuitas. A escolha do Unity 3D foi baseada nos requisitos do projeto e orçamento
disponível, mas também por possuir uma extensa biblioteca, que facilita o
desenvolvimento, e disponibilizar uma documentação, com exemplos de uso de cada
função. Por fim, observou-se, de acordo com a experiência, que o motor de jogo Unity 3D
facilita muito o processo de composição do jogo, além da grande vantagem de construí-lo
uma vez e poder exportar pra diversas plataformas.

O estudo de caso do jogo Murphy contribuiu para o amadurecimento e aprendizado


da equipe em diversos aspectos. As falhas encontradas durante o período de
desenvolvimento do projeto ressaltam a necessidade em adotar práticas metodológicas da
engenharia de software, aliadas ao documento de Game Design. Esse quesito será uma
etapa importante no desenvolvimento de novos jogos.

Em termos de trabalhos futuros, pretende-se exportar o jogo Murphy para outras


plataformas, iOS e PC. A equipe tem como objetivo aprimorar os conhecimentos sobre
desenvolvimento de jogos e ingressar na indústria de jogos digitais. Além disso, afim de
dar continuidade às pesquisas na área de desenvolvimento de jogos, pretende-se analisar
como os desenvolvedores de Fortaleza utilizam a engenharia de software em seus
processos de produção, com o objetivo de investigar a eficácia das metodologias utilizadas,
comparar quais são os pontos que mais colaboram para casos de sucesso e promover
melhorias no processo de desenvolvimento.
59

REFERÊNCIAS

ARRUDA, Eucidio Pimenta. Fundamentos para o Desenvolvimento de Jogos Digitais.


Editora: Bookman, 2014.

CLUA, E. W. G.; BITTENCOURT, J. R. Desenvolvimento de Jogos 3D: Concepção,


Design e Programação. Anais da XXIV Jornada de Atualização em Informática do
Congresso da Sociedade Brasileira de Computação, pp. 1313-1356, São Leopoldo, Brazil,
Julho de 2005.

FERNANDES, Luís Miguel Dias. Guia de Desenvolvimento de Jogos para


Programadores Independentes. 91 f. Dissertação (Mestrado) - Instituto Superior de
Engenharia do Porto: Porto, 2015.

FLEURY, Afonso; SAKUDA, Luiz. O.; CORDEIRO, José. H. D.. I Censo da Indústria
Brasileira de Jogos Digitais. 2014.

GEDIGAMES. Relatório Final: Mapeamento da Indústria Brasileira e Global de


Jogos Digitais. Universidade de São Paulo. São Paulo, 2014. Disponível em:
<http://www.bndes.gov.br/SiteBNDES/bndes/bndes_pt/Galerias/Arquivos/conhecimento/s
eminario/seminario_mapeamento_industria_games042014_Relatorio_Final.pdf>. Acesso
em: 7 mar. 2016.

GOMES, Paulo César Rodacki; PAMPLONA, Vitor Fernando. M3GE: um motor de


jogos 3D para dispositivos móveis com suporte a Mobile 3D Graphics API. In:
Workshop Brasileiro de Jogos e Entretenimento Digital, 2005, Porto Alegre. Anais
WJOGOS, 2005.

LEMES, David de Oliveira. Games Independentes – Fundamentos metodológicos para


criação, produção e desenvolvimento de jogos digitais. 158 f. Dissertação (Mestrado) –
Pontifícia Universidade Católica de São Paulo: São Paulo, 2009.

LIMA, Bernardo C. O.; MAIA, Rodrigo R. Engine Gráfica 3D para Simulação em


Jogos: Um Estudo de Caso. Instituto de Estudos Superiores da Amazônia: Belém, 2006).

LUZ, Alan Richard da. Vídeo Games: História, Linguagem e Expressão Gráfica. São
Paulo: Blucher, 2010.

MASTROCOLA, Vicente Martin. Game Design para mídias móveis: observando o


processo de criação de um jogo para smartphones e tablets. In: PARAGUAI, Luisa.
ZUANON, Rachel. (org.). Design, Arte e Tecnologia. São Paulo: Universidade Anhembi
Morumbi, 2014, p.78 - 86.

______ Ludificador: Um guia de referências para o game designer brasileiro. São


Paulo: Edição do autor, 2012. Disponível em: www.ludificador.com.br
60

NASCIMENTO, E. S. L. et al. Aspectos Gerais dos Games Indies. Temática, João


Pessoa, v. 10, n. 08, p. 152-163, 2014.

OKITA, Alex. Learning C# Programming with Unity 3D. A K Peters/CRC Press. 2014.

PEREIRA, Gean Alex. Projeto e Desenvolvimento de Jogos Computacionais. Trabalho


de Conclusão de Curso. Faculdade de Ciência da Computação. Universidade do Estado de
Santa Catarina – UDESC. 2006.

PERUCIA, Alexandre S.; BERTHÊM, Antônio C. de; BERTSCHINGER, Guilherme L.;


MENEZES, Roberto R. C. Desenvolvimento de Jogos Eletrônicos – Teoria e Prática.
São Paulo: Novatec, 2005.

ROGERS, Scott. Level Up!: The Guide to Great Video Game Design. Wiley, 2010.

SANTAELLA, Lúcia. O impacto das novas mídias sobre a cultura. In: VILLARES, Fábio
(org.) Novas mídias digitais (audiovisual, games e música): Impactos políticos,
econômicos e sociais. Rio de Janeiro: E-papers, 2008.

SATO, Adriana Kei Ohashi. Game Design e Prototipagem: Conceitos e Aplicações ao


Longo do Processo Projetual. IX Simpósio Brasileiro de Jogos e Entretenimento Digital
(SBGames), p. 74-84. Florianópolis, 2010.

XAVIER, Thomaz Canali. Estudo e Desenvolvimento de Jogos para Intenet Utilizando


o Unity 3D. Instituto Federal de Educação Ciência e Tecnologia Sul-Rio-Grandense: Passo
Fundo, 2011.

View publication stats

Você também pode gostar