View
616
Download
1
Embed Size (px)
Citation preview
1
UNIVERSIDADE DE SÃO PAULO Instituto de Ciências Matemáticas e de Computação
São Carlos - SP
Projeto e desenvolvimento de um jogo de futebol utilizando o motor de
jogo Unity 3D
Thiago Campos Viana
2
Projeto e desenvolvimento de um jogo de futebol utilizando o motor de jogo Unity 3D
Thiago Campos Viana
Orientador: Profº Fernando Santos Osório
Monografia de conclusão de curso apresentada ao
Instituto de Ciências Matemáticas e de Computação –
ICMC-USP - para obtenção do título de Bacharel em
Informática.
Área de Concentração: Desenvolvimento de Jogos
USP – São Carlos Outubro de 2009
i
"Existe uma teoria que diz que, se um dia alguém descobrir
exatamente para que serve o Universo e por que ele está aqui,
ele desaparecerá instantaneamente e será substituído por algo
ainda mais estranho e inexplicável. Existe uma segunda teoria
que diz que isso já aconteceu”.
Douglas Adams
ii
Dedicatória
À Kelly.
iii
Resumo
O presente projeto consiste no planejamento e desenvolvimento de um jogo de futebol
3D utilizando o motor de jogo Unity 3D, mostrando suas principais funcionalidades e como
elas ajudam no processo de desenvolvimento de jogos. Também é abordada a integração do
Unity com outras ferramentas de desenvolvimento tais como o Microsoft Visual C# 2008
Express Edition. O projeto tem como meta despertar o interesse de profissionais e entusiastas
da área de desenvolvimento de jogos pelo Unity.
iv
Sumário
LISTA DE ABREVIATURAS ............................................................................... VIII
LISTA DE FIGURAS ................................................................................................ IX
CAPÍTULO 1: INTRODUÇÃO .................................................................................. 1
1.1. CONTEXTUALIZAÇÃO E MOTIVAÇÃO ..................................................................... 1
1.2. OBJETIVOS ............................................................................................................. 2
1.3. ORGANIZAÇÃO DO TRABALHO .............................................................................. 2
CAPÍTULO 2: REVISÃO BIBLIOGRÁFICA .......................................................... 3
2.1. CONSIDERAÇÕES INICIAIS ...................................................................................... 3
2.2. SISTEMA DE COORDENADAS 3D ............................................................................. 3
2.2.1. O plano cartesiano ......................................................................................... 3
2.2.2. Coordenadas locais e globais ........................................................................ 5
2.2.3. Vetores ........................................................................................................... 6
2.2.4. Quaterniões e rotações .................................................................................. 6
2.2.5. Renderização .................................................................................................. 7
2.2.6. Câmeras ......................................................................................................... 7
2.2.7. Representação de formas ............................................................................... 8
2.2.8. Materiais ........................................................................................................ 8
2.3. FÍSICA .................................................................................................................... 8
2.3.1. Corpos rígidos ................................................................................................ 8
v
2.3.2. Detecção de colisão ....................................................................................... 9
2.4. O AMBIENTE DE DESENVOLVIMENTO UNITY 3D .................................................... 9
2.4.1. Editor totalmente integrado ........................................................................... 9
2.4.2. Linguagens de desenvolvimento ..................................................................... 9
2.4.3. Importação de arquivos multimídias ........................................................... 10
2.4.4. Networking ................................................................................................... 10
2.4.5. Física ............................................................................................................ 10
2.4.6. Publicação de jogos para várias plataformas ............................................. 10
2.4.7. Licenças ....................................................................................................... 11
2.5. CONSIDERAÇÕES FINAIS ...................................................................................... 11
CAPÍTULO 3: DESENVOLVIMENTO DO TRABALHO ................................... 12
3.1. CONSIDERAÇÕES INICIAIS .................................................................................... 12
3.2. PROJETO .............................................................................................................. 12
3.3. DESCRIÇÃO DAS ATIVIDADES REALIZADAS ......................................................... 12
3.3.1. Pesquisa bibliográfica ................................................................................. 12
3.3.2. Estudos sobre desenvolvimento de jogos ..................................................... 12
3.3.3. Pesquisa de ferramentas auxiliares ............................................................. 13
3.3.3.1. Ferramentas artísticas .............................................................................. 13
3.3.3.2. Ferramentas de desenvolvimento .............................................................. 13
3.3.4. Design do Jogo ............................................................................................. 13
vi
3.3.5. Desenvolvimento dos modelos em 3D .......................................................... 14
3.3.6. Estudo sobre o motor de jogo Unity 3D ...................................................... 14
3.3.7. Desenvolvimento .......................................................................................... 15
3.3.7.1 Codificação ................................................................................................ 15
3.3.7.1.1 A janela do jogo ...................................................................................... 15
3.3.7.1.2 O comportamento da bola ....................................................................... 16
3.3.7.1.3 A posição dos jogadores ......................................................................... 16
3.3.7.1.4 Criando o evento de gol .......................................................................... 17
3.3.7.1.5 Lateral e escanteio .................................................................................. 18
3.3.7.1.6 O controle dos jogadores ........................................................................ 19
3.3.7.1.7 Efeitos sonoros ........................................................................................ 19
3.3.7.2 Mudança da aparência dos jogadores ....................................................... 19
3.3.7.3 Criação de funções adicionais para o editor ............................................. 20
3.3.7.4 Teste de integração do Unity 3D com outras ferramentas ........................ 20
3.3.8. Escrita da monografia ................................................................................. 21
3.3.9. Manutenção .................................................................................................. 21
3.4. RESULTADOS OBTIDOS ........................................................................................ 21
3.5. DIFICULDADES E LIMITAÇÕES .............................................................................. 22
3.6. CONSIDERAÇÕES FINAIS ...................................................................................... 22
CAPÍTULO 4: CONCLUSÃO .................................................................................. 23
vii
4.1. ASPECTOS GERAIS ............................................................................................... 23
4.2. CONTRIBUIÇÕES .................................................................................................. 23
4.3. CONSIDERAÇÕES SOBRE O CURSO DE GRADUAÇÃO .............................................. 23
4.4. TRABALHOS FUTUROS ......................................................................................... 24
REFERÊNCIAS .......................................................................................................... 25
viii
Lista de Abreviaturas
2D: Two-dimensional space.
3D: Three-dimensional space.
EA: Electronic Arts.
FIFA: Fédération Internationale de Football Association.
IA: Inteligência Artificial.
IRC: Internet Relay Chat.
NPC: Non-Player Character.
ODE: Open Dynamics Engine.
Ogre3D: Object-Oriented 3D Graphics Rendering Engine.
UML: Unified Modeling Language.
FoV: Field of Vision.
ix
Lista de Figuras
Figura 1 - O plano cartesiano 2D................................................................................................ 4
Figura 2 - O plano cartesiano com os eixos x, y e z ................................................................... 4
Figura 3 - Coordenadas locais e globais ..................................................................................... 5
Figura 4 - Diferença entre ponto e vetor..................................................................................... 6
Figura 5 - A câmera .................................................................................................................... 7
Figura 6 - Os objetos vermelhos não são renderizados .............................................................. 8
Figura 7 - Elemento da tela de jogo .......................................................................................... 16
Figura 8 - Formação de defesa ................................................................................................. 17
Figura 9 - Formação de ataque ................................................................................................. 17
Figura 10 - Um objeto invisivel que chama a função de gol .................................................... 18
Figura 11 - Objetos invisíveis para escanteio e tiro de meta .................................................... 18
Figura 12 - Objeto invisível nas laterais ................................................................................... 19
Figura 13 - Imagens do jogo desenvolvido .............................................................................. 22
1
CAPÍTULO 1: INTRODUÇÃO
Este trabalho visa apresentar o projeto e desenvolvimento de um jogo de futebol
3D, desenvolvido com o uso do motor gráfico (engine) Unity 3D. Este projeto foi
desenvolvido como uma nova etapa de um projeto anterior de um jogo de futebol 3D, onde
a seguir serão detalhadas informações sobre o contexto da proposta e de sua motivação,
bem como sobre os objetivos e trabalhos propostos.
1.1. Contextualização e Motivação
No primeiro semestre de 2009, foi iniciado um projeto que consistia no
desenvolvimento de um jogo de futebol utilizando a biblioteca gráfica Ogre3D. O projeto
foi abandonado devido às dificuldades técnicas encontradas durante o desenvolvimento,
pois a Ogre3D é apenas uma biblioteca gráfica e para criar jogos com ela é necessário,
além de um profundo conhecimento em C++, integrá-la com outras bibliotecas, tais como a
biblioteca física ODE. Durante o projeto foi gasto mais tempo fazendo tais integrações que
no desenvolvimento do jogo proposto, e, depois de todas as integrações, ainda era
necessário realizar muitos ajustes para que todo o código fosse compilado adequadamente,
o que tomava muito tempo no desenvolvimento do projeto. Outro problema era a
integração com o modelador Blender, pois a Ogre3D trabalhava com modelos em um
formato próprio, o qual não era exportado corretamente pelo Blender.
Assim, foi decidido o abandono do projeto em Ogre3D e foi iniciada uma pesquisa
por um ambiente de desenvolvimento de jogos onde tais problemas não fossem tão graves.
Através de uma pesquisa entre os motores de jogos, open source ou comerciais de custo
inferiores a mil reais, chegou-se ao motor de jogo Unity 3D, o qual possui um motor físico
integrado, além de um motor de rede, de entrada, de gráfico e de áudio. Além disso, o teste
do projeto foi facilitado, pois não é necessário compilá-lo utilizando o Unity 3D. O Unity
3D também importa modelos do Blender automaticamente para o projeto.
2
1.2. Objetivos
O presente projeto tem como objetivo o desenvolvimento de um jogo de futebol
utilizando o motor de jogo Unity 3D tendo como base e o código do jogo Simple Soccer
presente no livro Programming Game AI by Example (BUCKLAND, 2005). A meta é
adaptar a teoria presente no livro para o ambiente 3D e, a partir dessa adaptação,
acrescentar recursos e realizar melhorias de modo interativo incremental. Este projeto
também aborda a integração do Unity 3D com outras ferramentas de desenvolvimento, tais
como O Microsoft Visual C# 2008 Express Edition e o NUnit.
1.3. Organização do Trabalho
Esta monografia é dividida em quatro capítulos. O capítulo um faz uma introdução
ao projeto desenvolvido, nele é definida a área de projeto, o problema abordado e as
possíveis contribuições do projeto. O capítulo dois apresenta os conceitos e terminologias
básicas da área do projeto, assim como uma breve apresentação do Unity 3D. O capítulo
três traz os detalhes sobre o projeto. No capítulo quatro é feita uma conclusão a respeito do
trabalho desenvolvido.
3
CAPÍTULO 2: REVISÃO BIBLIOGRÁFICA
2.1. Considerações Iniciais
Este capítulo apresenta os conceitos e terminologias da área de desenvolvimento de
jogos 3D assim como uma breve apresentação do Unity 3D.
2.2. Sistema de coordenadas 3D
Nesta seção serão descritos alguns elementos do sistema de coordenadas 3D.
2.2.1. O plano cartesiano
Uma das formas de descrever a posição de um ponto no espaço é representá-lo em
um plano cartesiano. Para representar um ponto em duas dimensões, definimos o sistema
de coordenadas como sendo composto por dois eixos, x e y, dispostos ortogonalmente, que
dividem o plano em quatro quadrantes (BUCKLAND, 2005). O eixo x é denominado o
eixo das abscissas e o y o das ordenadas. Esses eixos são divididos em unidades contadas a
partir do ponto de origem do plano, o ponto de intersecção entre os dois eixos, que servem
para nos dar uma idéia de distância, o que chamamos de coordenadas, assim, um ponto
nesse plano é representado por um par de coordenadas, x e y, que representa a distância ao
longo de cada eixo a partir do ponto de origem.
A figura 1 (BUCKLAND, 2005) mostra como representar um ponto P(4,6), em que
P significa ponto e (4,6) significa que o ponto está quatro unidades de distância em relação
ao ponto de origem do plano ao longo do eixo x, e seis unidades de distância em relação ao
ponto de origem do plano ao longo do eixo y.
4
Figura 1 - O plano cartesiano 2D
Para representar o espaço em três dimensões, adicionamos o eixo z ao sistema de
coordenadas, esse eixo passa pelo ponto de origem do sistema de coordenadas e representa
a profundidade do ponto. A figura 2 (JUNKER, 2006) mostra como representar o eixo z no
plano.
Figura 2 - O plano cartesiano com os eixos x, y e z
5
2.2.2. Coordenadas locais e globais
Como foi visto na seção anterior, a posição de um ponto pode ser representado em
termos de três variáveis, x,y e z. Por ponto, podemos entender um objeto no espaço. A
posição global de um objeto no espaço é representada em relação à origem do plano. Às
vezes é necessário representar a posição de um objeto a outro, assim dizemos que todo
objeto tem seu próprio ponto de origem e quando desejamos representar a posição de um
objeto em relação a outro, dizemos que estamos utilizando coordenadas locais do objeto de
referência. A figura 3 (JUNKER, 2006) mostra a diferença entre coordenadas locais e
globais.
Figura 3 - Coordenadas locais e globais
6
2.2.3. Vetores
Vetores são segmentos de reta usados para representar direção (reta suporte do
segmento orientado), intensidade (valor numérico) e sentido (orientação do segmento de
reta) no plano cartesiano. A figura 4 (BUCKLAND, 2005) mostra a diferença entre ponto e
vetor. Vetores, assim como pontos, não se limitam as duas dimensões e podem ser
representados no espaço 3D. Através do uso de vetores é possível atribuir representar além
da posição de um objeto no espaço, a sua direção.
Figura 4 - Diferença entre ponto e vetor
2.2.4. Quaterniões e rotações
Para realizar a rotação de objetos no espaço tridimensional são utilizados
quaterniões. Para representar a direção que um objeto aponta no espaço não basta apenas
representar sua posição, é necessário atribuir um ângulo a ela. Em jogos quando um objeto
é criado, é definida a sua posição e um ângulo inicial a ele. Quando desejamos fazer
alguma rotação nesse objeto, realizamos com base em sua posição e seu ângulo atual, ou
seja, em seu quaternião.
7
2.2.5. Renderização
Renderização é o ato de criar imagens 2D dada uma descrição geométrica de um
mundo tridimensional e uma câmera virtual que especifica a perspectiva que o mundo está
sendo visto.
2.2.6. Câmeras
Câmeras em jogos servem para representar o comportamento dos olhos em um
sistema em três dimensões. Através dela são determinados quais objetos devem aparecer
na tela e como eles devem ser mostrados. Elas podem ser posicionadas em qualquer lugar
no espaço, possuem uma direção e um campo de visão, ou Field of Vision (FoV). Esse
campo de visão pode ser interpretado como uma pirâmide invertida com origem no ponto
de origem da câmera e com direção determinada pela direção da câmera, assim, os pontos
mostrados na tela são os que estão dentro dessa pirâmide.
Quando limitamos a distância do campo de visão, estamos especificando uma
distância máxima que um objeto deve estar do ponto de origem da câmera para que ele seja
mostrado na tela, desde que ele esteja dentro do campo de visão da câmera. Também é
possível especificar uma distância mínima que os objetos deverão estar da câmera para que
eles sejam mostrados na tela.
As figuras 5 e 6 ilustram o funcionamento de uma câmera, tudo o que está dentro
do espaço delimitado pelo near plane e pelo far plane serão renderizados.
Figura 5 - A câmera
8
Figura 6 - Os objetos vermelhos não são renderizados
2.2.7. Representação de formas
Para representar formas em três dimensões são utilizados polígonos, em jogos
geralmente são utilizados triângulos, ou faces, que são representados por três pontos
interligados por vértices. A combinação de polígonos permite a construção de formas mais
complexas, conhecidas como Meshes. É através desses dados que são feitos os cálculos de
detecção de colisões entre um objeto e outro no espaço.
2.2.8. Materiais
Materiais servem para definir a aparência de um modelo após renderizados.
Materiais são cores ou texturas, que em conjunto com um script de renderização,
conhecido como shader, determina a aparência de um objeto quando visualizado na tela.
2.3. Física
Nesta seção serão descritos o que são corpos rígidos e detecção de colisão.
2.3.1. Corpos rígidos
Corpos rígidos são objetos que, durante o jogo, são afetados pelas leis da física, ou
seja, os motores de física realizam cálculos para tornar o movimento desses objetos
realistas (GOLDSTONE, 2009). Corpos rígidos podem possuir as seguintes propriedades:
9
• Massa;
• Gravidade;
• Velocidade;
• Atrito.
2.3.2. Detecção de colisão
A detecção de colisões entre objetos durante o jogo também é de responsabilidade
do motor físico do jogo. Adicionando um elemento ao objeto denominado collider, o
objeto passa a se comportar de um modo diferente quando algum objeto colide com ele,
respondendo a colisão, normalmente alterando a velocidade e direção de seu movimento
(GOLDSTONE, 2009).
2.4. O ambiente de desenvolvimento Unity 3D
Esta seção descreve algumas das características do motor de jogo gratuíto Unity
3D, http://unity3d.com/, o qual é utilizado neste projeto.
2.4.1. Editor totalmente integrado
O editor do sistema permite a criação de jogos visualmente, seguindo a linha drag’n
drop. Além disso, o Unity vêm com um editor de scripts para C#, JavaScript e Boo.
O editor do programa é totalmente personalizável. Os desenvolvedores utilizaram a
própria biblioteca do Unity para criar seu editor, assim, tudo o que os desenvolvedores
podem fazer com o editor, qualquer usuário poderia.
2.4.2. Linguagens de desenvolvimento
O Unity 3D permite a programação dos jogos em três linguagens diferentes, C#,
JavaScript e um dialeto de Python chamado Boo. Quando compilado, o código de máquina
gerado é baseado na plataforma .NET open source Mono. O motor de jogo permite a
10
importação de DLL baseada na plataforma .NET na licença indie, e DLL criadas em C++
na versão profissional.
2.4.3. Importação de arquivos multimídias
O Unity suporta uma série de formato de arquivos multimídia, entre eles estão mp3,
jpeg, gif, mov, avi, wav, TTF, entre outros. Também é possível importar modelos 3D nos
formatos nativos de alguns programas de modelagem, tais como Blender, Maya, 3D Studio
Max e Cheetah 3D.
2.4.4. Networking
O Unity 3D utiliza como base o motor de networking RakNet para possibilitar a
criação de jogos multi-player. O próprio site do Unity 3D contém um projeto de exemplo o
qual mostra como é possível criar conectar vários usuários em um mesmo jogo através da
internet.
2.4.5. Física
Para fazer os cálculos de colisões e todos os demais cálculos físicos do jogo, o
Unity utiliza o motor físico PhysX, http://www.nvidia.com.br/object/physx_new_br.html,
mesmo motor físico utilizado no jogo Unreal Tournament 2007,
http://www.unrealtournament.com/, e Ghost Recon 3, http://www.ghostrecon.com/. O
Unity 3D permite a criação de simulações físicas sem a criação de scripts para criar, entre
outras coisas, corpos rígidos, juntas e ragdolls.
2.4.6. Publicação de jogos para várias plataformas
A versão indie do motor permite a publicação dos jogos para os formatos Windows
Standalone, OS X Dashboard Widget, OS X Universal Binary Standalone, OS X PPC
Standalone, OS X Intel Standalone e para o seu player web que funciona em Windows e
Mac. Existem licenças especiais que permitem a publicação para outras plataformas, tais
como iPhone e para Nintendo Wii.
11
2.4.7. Licenças
O Unity possui várias licenças, entre elas estão:
• Unity: Versão gratuita da engine.
• iPhone Basic: Permite a publicação de jogos para iPhone, é necessário
possuir uma licença indie ou pro, custa US$ 399.
Existem outras licenças, tais como a pro, a iPhone advanced e Wii, para ver as
diferenças detalhadamente entre cada licença é necessário pesquisar no site da empresa,
http://www.unity3d.com.
2.5. Considerações Finais
Neste capítulo foram expostos os principais tópicos relacionados à área de
desenvolvimento de jogo. O estudo desses tópicos é de fundamental importância para um
conhecimento mais profundo da área, e foram importantes para o desenvolvimento do
trabalho, o qual foca mais na parte de programação. O próximo capítulo detalha como se
deu o desenvolvimento do trabalho.
12
CAPÍTULO 3: DESENVOLVIMENTO DO
TRABALHO
3.1. Considerações Iniciais
Neste capítulo são descritos os processos de desenvolvimento do trabalho. A seção
3.2 descreve o projeto que foi desenvolvido. A seção 3.3 contém todos os detalhes das
atividades realizadas. A seção 3.4 entra em detalhes sobre os resultados obtidos. Por fim,
na seção 3.5 é feita uma conclusão sobre o projeto.
3.2. Projeto
O presente projeto tem como objetivo o desenvolvimento de um jogo de futebol
utilizando o motor de jogo Unity. A seção 3.3 explica com detalhes o trabalho
desenvolvido.
3.3. Descrição das Atividades Realizadas
3.3.1. Pesquisa bibliográfica
Nessa etapa fez-se uma pesquisa bibliográfica inicial, a qual serviu como base para
todo o projeto. Foram selecionados os principais livros da área.
3.3.2. Estudos sobre desenvolvimento de jogos
Após a pesquisa bibliográfica inicial, foi necessário o estudo sobre
desenvolvimento de jogos. Nesta etapa foram estudadas as peculiaridades dessa área para
planejar melhor o desenvolvimento do jogo. Além destas referências, também foi usado
como base para este trabalho, o texto da monografia anterior que havia sido desenvolvido,
referente também a um projeto de um jogo de futebol 3D (VIANA, 2009).
13
3.3.3. Pesquisa de ferramentas auxiliares
3.3.3.1. Ferramentas artísticas
• Blender: Ferramenta para modelagem e animação de objetos 3D.
Alternativa gratuita para o 3D Studio Max e Maya.
• Audacity: Editor de audio open source.
• Gimp: Editor de imagens. Alternativa gratuita para o Adobe Photoshop.
• Inkscape: Gerador de gráficos vetoriais. Alternativa gratuita para o Adobe
Illustrator ou para o Corel Draw.
• Melody Raiser: Programa de geração de música procedural gratuito.
• SFXR: Programa de geração de efeitos sonoros gratuitos.
3.3.3.2. Ferramentas de desenvolvimento
• Open Workbench: Programa para gerenciamento de projetos. Alternativa
gratuita para o MS Project.
• Microsoft Visual C# 2008 Express Edition: Ambiente de programação
gratuito para a linguagem C#.
• NUnit: Ferramenta para automação de testes gratuita para C# que pode ser
integrada ao Microsoft Visual C# 2008 Express Edition.
• ArgoUML: Ferramenta para geração de diagramas UML. Gera códigos em
C# a partir dos diagramas.
3.3.4. Design do Jogo
Na fase design de jogo foi definido o jogo a ser desenvolvido. Nela foram definidos
os principais mecanismos do jogo, ou seja, seu gameplay. Nessa fase foi proposta uma
14
visão geral do jogo, ou seja, uma descrição do funcionamento do jogo, seus gráficos, a
interação do usuário com o jogo, os menus e o fluxo do jogo.
Por falta de recursos as regras do jogo foram adaptadas, ficando da seguinte forma:
• Não existem impedimentos.
• O jogo nunca termina.
• Não existem faltas.
• O lateral é cobrado por apenas um jogador.
• Os escanteios e os tiros de meta são cobrados no meio do campo.
O jogo possui apenas dois times, Brasil e Argentina, sendo o Brasil controlado pelo
usuário e a Argentina pelo computador. O time controlado pelo computador, ou seja, a
Argentina, no momento não apresenta muitas dificuldades para ser derrotado, assim como
na vida real, devido a IA dos jogadores. Isso foi determinado levando em consideração a
necessidade de se obter um protótipo funcional do jogo em um período inferior a quatro
meses contando desde o inicio da fase de levantamento bibliográfico do projeto.
3.3.5. Desenvolvimento dos modelos em 3D
Nesta etapa foram desenvolvidos os modelos em 3D necessários ao projeto, ou seja,
bola, campo, arquibancada, gol e jogador. Primeiramente foram feitos rascunhos de cada
um dos modelos e as texturas utilizando o Gimp e o Inkscape, depois foram criados os
modelos no Blender. O modelo utilizado para representar os jogadores foi animado no
Blender.
3.3.6. Estudo sobre o motor de jogo Unity 3D
Nessa etapa foi estudado o Unity 3D. Além de ler os tutoriais do site oficial do
sistema, foi criado um jogo de plataforma 2D como forma de aprendizado. Foi necessário
realizar pesquisas sobre C# e JavaScript, as principais linguagens suportadas do sistema, a
outra linguagem suportada é a Boo, um dialeto de Python, mas ela não é utilizado com
15
freqüência pela comunidade. As dúvidas que surgiram sobre a utilização do sistema foram
respondidas pela comunidade do Unity através dos fóruns e do IRC.
3.3.7. Desenvolvimento
Essa seção apresenta uma breve descrição das atividades realizadas na etapa de
desenvolvimento do projeto.
3.3.7.1 Codificação
Foi necessário realizar a programação dos elementos do jogo, essa seção descreve
os principais problemas encontrados na fase de codificação.
3.3.7.1.1 A janela do jogo
A maioria dos jogos de futebol possui os seguintes elementos na tela de uma
partida, ilustrados na figura 7:
A. Um placar do jogo contendo os nomes dos times e a quantidade de gols
marcados.
B. Em um relógio marcando o tempo decorrido de jogo.
C. Um menu de opções que aparece quando o jogo é pausado.
D. O nome do jogador em controle do usuário que controla o time um.
E. Um mini-mapa mostrando as posições dos jogadores.
F. O nome do jogador em controle do usuário que controla o time dois.
16
MiniMap
PlayerNameGK/DF/MF/FW 4 (n)
PlayerNameGK/DF/MF/FW 4 (n)
0 - 0 Time: 5:00
Restart ApplicationQuit Application
AB
C
DE F
Figura 7 - Elemento da tela de jogo
No projeto foram desenvolvidos apenas o placar e o relógio. O relógio é
mudado a cada segundo e o placar é mudado quando um dos times marca um gol.
3.3.7.1.2 O comportamento da bola
A questão fundamental para o desenvolvimento deste projeto foi entender o
comportamento da bola em um jogo de futebol, para isso foi necessário consultar o
comportamento da mesma em outros jogos. Como os jogos atuais apresentam um
comportamento muito realista para a bola, o que tornaria o desenvolvimento do jogo muito
complexo, decidiu-se que o comportamento seria baseado nos jogos mais antigos.
Basicamente, a bola se movimenta livremente até que algum jogador a toque, a
partir desse momento a posição dela será em frente a ele, e quando ele se movimenta, a
bola além de acompanhá-lo sofre um movimento de rotação. Se um jogador do time
adversário toca na bola, ela passa a pertencer a ele. Quando um jogador chute ou dá o
passe, a bola passa a se movimentar livremente.
3.3.7.1.3 A posição dos jogadores
Neste projeto cada time possui quatro jogadores e um goleiro, os jogadores
assumem duas formações, a de ataque e a de defesa, seguindo um determinado padrão. A
17
figura 8 mostra como esses objetos devem ser dispostos na posição de defesa e a figura 9, a
posição de ataque (BUCKLAND, 2005).
Figura 8 - Formação de defesa
Figura 9 - Formação de ataque
3.3.7.1.4 Criando o evento de gol
Para programar o evento de gol foi utilizado um recurso chamado trigger. Podemos
adicionar triggers a qualquer objeto do jogo, fazendo com que tais objetos chamem uma
função pré-determinada toda vez que sofrem colisões. Sabendo disso, foi criado um objeto
invisível atrás do gol, figura 10, e adicionado um trigger a ele, o qual, quando colidido
com a bola, chama uma função que controla o evento de gol.
18
Figura 10 - Um objeto invisivel que chama a função de gol
3.3.7.1.5 Lateral e escanteio
Para programar os eventos de lateral e escanteio foi utilizada a mesma técnica do
evento de gol, ou seja, foram criados objetos invisíveis que chamam as funções de controle
de lateral e escanteio, figura 11 e 12, toda vez que sofrem colisões com a bola.
Figura 11 - Objetos invisíveis para escanteio e tiro de meta
19
Figura 12 - Objeto invisível nas laterais
3.3.7.1.6 O controle dos jogadores
3.3.7.1.7 Efeitos sonoros
No projeto foram criados um efeito sonoro e uma música para testar a integração de
áudio em jogos desenvolvidos com o Unity. O efeito sonoro foi criado com o programa
SFXR, o qual é gratuito, e exportado para o formato wav. Toda vez que um jogador toma
posse da bola ou a chuta, o efeito sonoro é tocado no jogo com efeito de som 3D, ou seja, o
modo que o som é tocado varia conforme a posição da bola no momento em que o som é
tocado.
Para criar a música foi utilizado o programa Melody Raiser, o qual exporta suas
melodias apenas no formato midi, que não é suportado pelo Unity 3D. Para contornar esse
problema, foi utilizado o “Gravador de Som” do Windows XP, que gravou o som do midi e
o exportou para um arquivo wav. Como arquivos no formato wav não são ideais para
músicas, pois ficam enormes, foi utilizado o programa Audacity para exportar o arquivo
wav para o formato Ogg Vorbis, semelhante ao MP3, tornando-o cerca de 90% menor que
o wav. Esse arquivo de música foi utilizado como a música tocada durante todo o jogo,
repetidamente.
3.3.7.2 Mudança da aparência dos jogadores
Nessa etapa foi realizado um estudo sobre o funcionamento dos shaders do Unity.
O shader responsável por dar um visual de desenho animado aos modelos, técnica
20
conhecida como toon shading, foi estudado e aplicado aos modelos dos jogadores,
enriquecendo o visual do jogo.
3.3.7.3 Criação de funções adicionais para o editor
O Unity 3D permite criar funcionalidades adicionais para o editor de acordo com a
necessidade de cada desenvolvedor, podendo variar desde scripts de automação de tarefas
até a criação de editores visuais de IA totalmente personalizados.
Nesse projeto houve uma grande necessidade de realização da gerencia de versões
de projetos através de backups, e toda vez que era necessário realizar um backup, tinha que
encerrar o Unity 3D, navegar até a pasta do projeto e compactá-la em formato zip. Para
facilitar esse processo, criou-se um script em C# de backup e fez-se a integração do mesmo
com o editor, assim, foi criado um botão no editor que quando clicado, realizava o backup
do projeto.
3.3.7.4 Teste de integração do Unity 3D com outras ferramentas
Apesar do Unity 3D apresentar várias funcionalidades, existem ferramentas que
realizam certas tarefas de uma forma melhor que o Unity ou que realizam tarefas que o
Unity não faz. Assim, foi interessante saber se seria possível utilizar tais ferramentas em
projetos que tem o Unity como motor de jogo.
Um exemplo dessas ferramentas é o Microsoft Visual C# 2008 Express Edition, que
possui um ambiente de codificação para C# com algumas funcionalidades melhores que o
Unity 3D e até mesmo algumas inexistentes no editor do Unity. Não existe uma função
nativa que permite ao Visual C# importar projetos do Unity 3D, porém existe um script
desenvolvido para o Unity 3D que permite a criação automática de projetos para o Visual
C# a partir de projetos para o Unity 3D (MEIJER, 2009). Esse script funciona e, além
disso, o autor criou templates de classes para o Visual C# para projetos específicos para o
Unity.
Outro teste de integração fez-se com a ferramenta de automação de testes NUnit.
Para ser utilizada, foi necessário o uso do Visual C#, pois foi necessária a criação de
21
arquivos DLLs ou exe com algumas características peculiares que, por padrão, o Unity não
gera. Assim, chegou-se a conclusão de a utilização do NUnit é possível em projetos feitos
em torno do Unity 3D, porém é necessário o uso do Visual C#.
Por fim, foram pesquisadas ferramentas UML gratuitas que gerasse códigos em C#
e que pudesse ajudar na fase de planejamento do projeto. Chegou-se a ferramenta
ArgoUML, a qual é open source e gera diagramas de classes, de casos de uso, de
colaboração, de seqüência, de estado, de atividades e de distribuição, além de gerar código
para esses diagramas em diversas linguagens de programação, incluindo o C#, tornando-a
compatíveis com projetos baseados no Unity 3D.
3.3.8. Escrita da monografia
Essa é a etapa atual do projeto, na qual foi desenvolvida a monografia.
3.3.9. Manutenção
Esta etapa do projeto ainda não foi realizada até o momento da escrita desta
monografia. Nesta etapa serão corrigidos os bugs do jogo e serão feitas melhorias no
mesmo, em especial no fluxo do jogo e na IA dos jogadores.
3.4. Resultados Obtidos
Durante o projeto, decidiu-se que todo o código ficaria disponível no Google
Codes, http://code.google.com, com o título do projeto sendo SoccerTutorial (
http://code.google.com/p/soccertutorial/downloads/list). O projeto está disponível para
download para todas que possuem o Unity 3D. A figura 13 mostra como como ficou o
jogo. Existe um vídeo disponível para visualização em
http://www.youtube.com/watch?v=nxvRAeKAKh0.
22
Figura 13 - Imagens do jogo desenvolvido
3.5. Dificuldades e limitações
A maior dificuldade encontrada nesse projeto está relacionada ao desenvolvimento
dos modelos e animações no Blender, isso se deve a falta de experiência do desenvolvedor
com o uso da ferramenta e com a área de modelagem e animações 3D. Outra dificuldade é
a codificação da IA dos jogadores.
3.6. Considerações Finais
Com os testes de integração do Unity com outras ferramentas, chegou-se a
conclusão de que o Unity 3D pode ser utilizados em projetos de larga escala, os quais
requerem um controle maior do projeto e um uso mais disseminado das várias técnicas de
engenharia de software.
23
CAPÍTULO 4: CONCLUSÃO
4.1. Aspectos Gerais
O desenvolvimento do presente projeto teve muitas reviravoltas no que diz respeito
aos requisitos do jogo a ser desenvolvido. Em um primeiro momento estabeleceu-se que o
jogo deveria ter todas as funcionalidades de um jogo de futebol atual, porém essa visão
mostrou-se imatura devido ao fato de o projeto possuir apenas um programador, assim, foi
decidido que para esse projeto já seria satisfatório ter um jogo de futebol em 3D bem
simples, porém funcionando, assim eliminou-se a maioria das funcionalidades sonhadas no
inicio do projeto.
Durante o projeto, muito foi aprendido sobre desenvolvimento de jogos
especialmente no referente a programação de jogos, visto que o autor possui um
background como programador web, especializado em php sem experiência profissional na
área de jogos. Assim o projeto contribui também para o aprendizado de uma nova área de
conhecimento para o autor.
4.2. Contribuições
Este trabalho contribui com a atualização do jogo Simple Soccer do livro
Programming Game AI by Example (BUCKLAND, 2005) para o ambiente 3D utilizando o
Unity 3D. Também contribuiu com uma análise das funcionalidades do Unity 3D e sua
integração com outras ferramentas de desenvolvimento de software.
4.3. Considerações sobre o curso de graduação
Infelizmente o curso de bacharelado em informática oferecido pelo ICMC não
possui nenhuma ênfase na área de jogos, se possuísse seria interessante o enfoque no
programa Unity 3D.
24
4.4. Trabalhos Futuros
Muitas melhorias devem ser feitas no jogo, assim, espera-se que no futuro sejam
melhorados os gráficos, aproveitando melhor os recursos do Unity 3D, a inteligência
artificial do jogo e o sistema do jogo. Espera-se também uma completa reorganização do
código, tornando mais reutilizável e facilitando a manutenção. Tudo isso em uma possível
versão 2.0.
25
REFERÊNCIAS
BUCKLAND, Mat. Programming Game AI by example. Plano, Texas: Wordware Publishing, Inc., 2005. 495 p.
GOLDSTONE, Will. Unity Game Development Essentials. Olton, Birmingham, UK. PACKT Publishing, Ltd., 2009. 251 p.
JUNKER, Gregory. Pro Ogre 3d Programming: Leverage the power of Modern Real-Time Hardware-Accelerated 3d Graphics with the Best-in-Class 3d Graphics Library. New York, NY: Springer-Verlag New York, Inc., 2006. 288 p.
LUNA, Frank D. Introduction to 3D Game Programming with DirectX 9.0. Plano, Texas: Wordware Publishing, Inc., 2003. 378 p.
MEIJER, Lucas. VisualStudio integration for Unity2.5 + ItemTemplates. Disponivel em: http://lucasmeijer.com Acesso em: 10/10/2009.
VIANA, Thiago Campos. Projeto e implementação de um jogo de Futebol 3d com uso de software livre. Monografia de conclusão de curso apresentada ao Instituto de Ciências Matemáticas e de Computação – ICMC-USP. Junho de 2009.