Desenvolvimento de Game

Desenvolvimento de
Game
Sumário
Introdução ........................................................................................................................................ 1
Iniciando o Unity .............................................................................................................................. 2
Introdução à Programação ............................................................................................................... 8
Criando seu projeto ........................................................................................................................ 10
Criando e pintando um terreno...................................................................................................... 12
Adicionando luz .............................................................................................................................. 17
Adicionando água ........................................................................................................................... 19
Adicionando um objeto externo .................................................................................................... 21
Programando o impacto do tiro e sua mira ................................................................................... 24
Criando um Prefab.......................................................................................................................... 27
Criando os alvos.............................................................................................................................. 29
Alvos móveis e destrutíveis ............................................................................................................ 34
Alvos móveis e destrutíveis ............................................................................................................ 36
Pontuação, Menu e Cenas Complementares ................................................................................. 40
Replay e Sons.................................................................................................................................. 49
Criando o Arquivo Executável ........................................................................................................ 53
Introdução
Desenvolvimento de games utilizando o Unity
Unity é um mecanismo para o desenvolvimento de jogos multiplataforma (vários consoles), para
Playstation 3, Xbox 360, Wii, celulares, incluindo PC e jogos para Internet (web).
Desenvolver com o Unity é fácil e intuitivo, pois tem uma interface amigável e simples, com
configurações de parâmetros, criação de objetos e desenvolvimento de Scripts (programação),
que podem ser utilizados para eventos (ações) em vários objetos.
A partir da versão 3.0, o Unity vem com um demo chamado "Bootcamp", em terceira pessoa,
com um personagem andando por uma mata, totalmente funcional. Podemos utilizá-lo como
base para nosso próprio projeto:
1
Iniciando o Unity
Para abrir o programa Unity, clicamos sobre o botão Iniciar, posicionamos o mouse sobre a
opção Todos os Programas, clicamos sobre a pasta Unity e em seguida, escolhemos a opção
Unity.
Em instantes, será exibida a tela de splash, indicando que o programa está sendo carregado.
Depois disso, será aberta a janela do Unity e automaticamente surgirá a janela Unity - Project
Wizard. Isto ocorre porque o programa só pode ser acessado caso seja aberto algum projeto.
Vale lembrar que o Unity faz esse pedido de abrir o projeto somente na primeira utilização,
depois ele sempre abrirá o último projeto salvo.
Caso o Unity não peça pra abrir automaticamente um projeto, podemos clicar no menu File e
depois, em Open Project.
2
Será iniciada a janela Unity - Project Wizard.
Nesta janela, clicamos sobre o botão Open Other, pois localizaremos um projeto que vem com o
próprio Unity, chamado de Bootcamp.
Em seguida, surgirá a janela Open existing project, onde devemos clicar em Documentos, na
barra lateral.
Depois, executamos um duplo clique na pasta Unity Projects e selecionamos a pasta Bootcamp
Demo. Para concluir, clicamos no botão Selecionar pasta.
3
Logo, será aberto o projeto de demonstração, chamado Bootcamp. Este game, como já
mencionado, acompanha o programa Unity.
Project (Projeto) é o que engloba todas as cenas, arquivos, pastas e subpastas do seu jogo. Um
projeto pode ter várias cenas, que funcionam como fases do seu jogo, mas uma cena pertence a
somente um projeto.
Aconselha-se que seja criada uma nova pasta específica para salvar cada projeto
separadamente.
Conhecendo as ferramentas do Programa:
O Unity é composto por 5 grupos de ferramentas, que são: Barra de Ferramentas, Cenário,
Hierarchy, Project e Inspector.
- Project: A aba Project serve para a manipulação e organização dos Assets (arquivos que
compõem o projeto, como Scripts, modelos, texturas, entre outros). É similar às pastas do
Windows, onde você pode criá-las e colocar arquivos nelas, ou também em subpastas.
É aconselhável somente manipular os arquivos diretamente pela aba Project para não ter
problemas de perda de arquivos ou funcionalidade dos mesmos depois.
4
- Hierarchy: Exibe todos os elementos da cena que está sendo editada por hierarquia,
gameObjects, partículas, terrenos, entre outros. Podemos selecioná-los pelo seu próprio nome,
no caso de perdermos algum deles de vista.
- Inspector: Aqui são manipulados os parâmetros de um objeto selecionado da cena, como:
altura, largura, textura e os atributos de seus componentes, como Scripts incorporados aos
objetos.
- Scene (Cenário): Essa janela é a parte principal para a manipulação de objetos e dos elementos
visuais das cenas do Unity, onde podem ser manipulados objetos, como personagens, câmeras,
cenários e todos os elementos que compõem a cena em 3 dimensões: X, Y, Z.
Pode-se mudar automaticamente a perspectiva dos objetos clicando-se nos ícones X, Y e Z, no
canto superior direito. O normal é a visualização Perspectiva.
Você também pode selecionar um objeto pelo seu nome na aba Hierarchy. Depois, basta
posicionar o cursor sobre a janela Scene e pressionar a tecla <F> para a visualização se focar no
objeto desejado, caso perca-o de vista.
- Barra de Ferramentas: Traz algumas ferramentas básicas para a manipulação de objetos e do
projeto em forma geral. Primeiramente, à esquerda temos os botões Hand, Move, Rotate e
Scale. Separado destes, temos Center e Local. Vejamos abaixo as ferramentas e suas descrições:
- Hand
Botão esquerdo do mouse: explorar a cena nos eixos X e Y da câmera atual;
Botão direito do mouse/scroll: zoom no centro da câmera atual;
<Alt> + Botão esquerdo do mouse: rotação em torno do centro da câmera atual.
5
- Move
Pode-se mover o objeto livremente em X, Y, Z.
- Rotate
Girar o objeto.
- Scale
Aumentar ou diminuir o objeto, em um eixo X, Y, Z, ou em todos.
- Center
Se estiver selecionado, o objeto é movimentado, rotacionado de acordo com o seu centro. Se
clicado, transforma-se em Pivot.
- Pivot
Quando selecionado, o objeto é movimentado de acordo com seu Pivot, que pode ser alterado
para a ponta de um objeto ou até fora dele, caso necessite que ele não gire apenas em torno de
si mesmo.
- Local
Neste estado, a movimentação nos planos X, Y, Z fica de acordo com os eixos do objeto. Se
rotacionado, os eixos também mudam, caso seja clicado, muda para global.
- Global
Neste estado, a movimentação dos 3 planos fica de acordo com um eixo global na cena, que
nunca muda.
- Play
Serve para transformar a visualização da Scene (cenário) em game. Para testar se o jogo está
funcionando em tempo real, você pode clicar neste botão e experimentar um pouco da
Bootcamp demo para ver do que o Unity é capaz. Clique nele novamente para parar o game e
voltar à Scene (cenário). No caso da Bootcamp demo, você precisa pressionar <Esc> para livrar o
mouse, para depois clicar no botão Play.
6
- Pause
Quando em game, para parar o jogo (no caso da Bootcamp demo, você precisa pressionar <Esc>
para livrar o mouse, para depois clicar no botão Pause).
- Skip
Também em game, serve para, cada vez que clicado, andar apenas 1 frame da animação, assim
é possível ver parada e mais detalhadamente algum efeito ou movimento no jogo em tempo
real.
Ainda na Barra de Ferramentas, existem dois botões chamados de Layers e Wide, vejamos o que
esses botões fazem:
- Layers
Através deste botão, podemos desativar e ativar a visualização de componentes que estejam no
projeto, como: água, terra, entre outros componentes.
- Wide
O botão Wide serve para alterarmos o layout do programa Unity. Nele existem 4 opções
diferentes, que são: 2 by 3, 4 Split, Tall e Wide. Cada um deles modifica a tela do programa Unity
de forma diferente.
Veja os tipos de layout do Unity:
7
Introdução à Programação
Um programa funciona como uma sequência de comandos. Cada comando é um conjunto de
palavras que determina uma ação a ser executada pelo computador.
As variáveis, na programação, funcionam como na matemática, guardando valores, digitados ou
pré-definidos pelo programador (esses valores podem ser números, letras ou palavras inteiras).
Um programa deve ser escrito em uma linguagem específica, conhecida como linguagem de
programação. Existem várias delas, as que podem ser utilizadas em Unity são:
- Java
- Boo
- C# (lê-se "C Sharp").
Essas linguagens são consideradas de alto nível, pois são legíveis às pessoas (mas não
diretamente pelo computador), fazendo-se necessário um compilador.
Compilador é uma ferramenta que transforma a programação de alto nível para linguagem que
o computador entende (não compreensível para pessoas).
A programação em Unity é orientada à objeto. A vantagem dessa programação é que podemos
transformar uma grande quantidade de códigos em apenas um "objeto", que faz parte de uma
"classe", que é formada por "atributos" e "métodos".
Pensar em objetos na programação é muito parecido com a vida real. Por exemplo, vamos
pensar em um carro: diríamos que o carro é o elemento principal, que tem uma série de
características (atributos), que podem ser: a cor, o modelo ou a marca. Este mesmo objeto
também possui uma série de funcionalidades (métodos), que podem ser: andar, parar ou
estacionar.
Classes: As classes são declarações de objetos. Isto quer dizer que a definição de um objeto é a
classe. Quando programamos um objeto e definimos suas características e funcionalidades, na
verdade, o que estamos fazendo é programar uma classe. No exemplo anterior, falávamos da
classe carro porque somente definimos suas formas.
Atributos: Os atributos são as características dos objetos. Quando definimos uma propriedade,
normalmente especificamos seu nome e seu tipo. Assim, podemos ter a ideia de que as
propriedades são como as variáveis, onde armazenamos os dados relacionados aos objetos.
Métodos: São as funcionalidades associadas aos objetos. Os métodos são como as funções que
um objeto pode ter ou executar quando necessário.
Objetos: Os objetos são exemplares de uma classe qualquer. Por exemplo, carro é uma classe,
cor e quantidade de portas são atributos, métodos são acelerar, virar e parar. Um objeto seria
uma Ferrari ou um Fusca, dependendo de como são preenchidos esses atributos e métodos.
Em Unity, toda a programação é feita através de Scripts, que depois de criados podem ser
aplicados a quantos objetos forem desejados. Abaixo, temos um exemplo de um Script vazio em
C#.
8
Cada linguagem tem algumas palavras especiais ou reservadas, que fazem uma ação específica
para o computador.
Using: serve para pegar alguma biblioteca e usá-la no seu Script. Uma biblioteca é um
aglomerado de comandos. Assim, sem "UnityEngine", se você escrevesse um comando que
fizesse parte dessa biblioteca, o compilador não entenderia e teríamos um erro.
Public: define que a classe ou atributo que vem a frente é público e pode ser utilizado em outras
classes, objetos ou Scripts, também podendo ser "Private", que seria restringir a classe ou
atributo àquele Script ou classe (se não for especificado, automaticamente fica como Private).
Class: criação de classe e na frente o seu nome (em Unity, o nome da classe tem que ser igual ao
nome do Script).
Quando se abre e fecha chaves {} tudo que fica entre elas faz parte do método ou função que
veio antes das chaves. No começo do Script, para definir quando começa a classe. Depois, para
definir o começo e o final dos métodos Start e Update, e no final, para fechar a chave inicial do
começo do programa. Tudo que for digitado depois dessa chave final, tirando comentários,
geraria erro para o compilador.
Digitar // no começo de uma linha, para que ela seja desconsiderada da programação, serve
como comentário para referência futura quando acessar um Script antigo em que talvez você
não se lembre exatamente como ele funciona.
Void: significa que aquele método está limpo, ou seja, não ocupa memória do computador
quando não tem comandos dentro dele.
Start: método para iniciar o Script, tudo que for colocado aqui será inicializado assim que o
Script for executado.
Update: método de atualização, tudo que for colocado aqui será constantemente atualizado e
verificado.
Alguns exemplos de comandos bastante utilizados em programação de forma geral:
If: "se" (possibilidade, "se ocorrer algum evento").
Else: "senão" (possibilidade, "senão ocorre algum evento").
A partir da condição que o "if" e "else" nos der, executar uma ação.
9
For: "para" (serve como um looping, ou seja, ele faz um comando ser repetido várias vezes até
que uma condição seja satisfeita e usa uma variável para controlar isso com um incremento).
While: "Enquanto" (serve também como looping, mas fica num ciclo infinito até a condição ser
satisfeita, diferente do for, que tem um tempo final definido por uma variável).
Criando seu projeto
Antes de começar a criação de um projeto, é aconselhável criar a pasta onde desejamos
armazená-lo, através do Windows Explorer.
Depois disso, já no Unity, clicamos no menu File e em seguida, em New Project.
Surgirá a janela Unity - Project Wizard. Nela, clicamos sobre o botão Browse.
Na janela Choose location for new project que surge, devemos localizar a pasta que criamos
para o projeto e selecioná-la. Depois, basta clicar no botão Selecionar pasta.
10
Após o clique, somos novamente direcionados para a janela Unity - Project Wizard. O campo
Project Location passa a exibir a pasta do projeto, onde iremos salvar nosso arquivo.
No campo Import the following packages, marcamos as opções mostradas na imagem abaixo e
clicamos no botão Create.
Depois, deveremos esperar por alguns minutos para que o Unity importe os arquivos
necessários na pasta onde nosso projeto será salvo.
Veja a aparência do Unity com os arquivos importados:
11
Com o projeto criado, ainda é preciso salvar a sua cena (cenário). Para isso, clicamos no menu
File e depois em Save Scene. Salvamos a cena na pasta Assets do seu projeto, que é a pasta que
automaticamente vem selecionada pelo Unity. Escolhemos o nome desejado e clicamos no
botão Salvar.
Depois de salvarmos nossa cena, podemos ver que na aba Project consta o cenário com o nome
que o salvamos:
Criando e pintando um terreno
A primeira coisa a ser criada no Unity deve ser o terreno, caso contrário seus objetos ficarão
voando ou ficarão caindo infinitamente.
Para criá-lo, devemos clicar no menu Terrain e em Create Terrain.
12
Caso não seja possível visualizá-lo na cena, selecionamos o objeto Terrain em Hierarchy, depois
posicionamos o mouse na Scene (cenário) e pressionamos a tecla <F> para visualizar o terreno.
Para rotacionar seu terreno para que fique como indicado, primeiro precisamos nos certificar de
que o componente Terrain está selecionado na aba Hierarchy, caso não esteja, devemos
selecioná-lo. Em seguida, deixamos pressionada a tecla <Alt>, clicamos e arrastamos o mouse no
cenário, alterando seu posicionamento como desejado. Para aumentar ou diminuir o tamanho
do terreno, utilizamos o botão scroll ou o botão direito do mouse.
Agora, clicamos no menu Terrain e em Flatten Heightmap, que é a altura do terreno.
Colocamos o valor desejado no campo Height e clicamos em Flatten, porque assim você pode
afundar partes do seu terreno.
Para criar desníveis em seu terreno, primeiramente devemos estar com o objeto selecionado na
aba Hierarchy. Na aba Inspector, clicamos no botão Raise and lower the terrain height.
A parte do terreno que o cursor estiver em cima na Scene (cenário) deve ficar sombreada em
azul.
13
Agora, onde clicarmos no terreno, o mesmo se elevará, de acordo com o Brush que você
escolher na paleta Brushes. Segurando <Shift> e clicando sobre o terreno, ele afunda.
O campo Brush Size define o tamanho do seu Brush.
Depois, clicamos no botão Paint the terrain texture, para podermos pintar a montanha. Nas
propriedades da ferramenta Pain Texture, clicamos no botão Edit Textutes.
Em seguida, clicamos em Add Texture. Será aberta a janela Add Terrain Textute. Então, devemos
clicar no local indicado na imagem a seguir.
14
Será aberta a janela Select Texture2D. Nela, localizamos a textura desejada e a selecionamos
com um duplo clique. Para finalizar, devemos clicar em Add.
Cor do terreno alterada:
Mas imagine que não queremos que nosso terreno inteiro tenha apenas uma textura. Então,
clicamos novamente no botão Edit Textures e depois em Add Texture. Agora, adicionamos a
outra textura e em seguida, clicamos sobre a cor escolhida no campo Textures.
Veja que dessa vez o nosso terreno não foi pintado automaticamente.
Depois de selecionado, observe que poderemos pintar o terreno com essa textura clicando nele
como fez quando criou as montanhas. Você ainda pode adicionar mais texturas e selecionar as
partes do terreno que desejar colorir.
Vamos adicionar algumas árvores em nosso terreno. Para isso, clicamos na ferramenta Place
trees.
15
Agora, clicamos no botão Edit Trees e depois em Add Tree. Em seguida, selecionamos a textura
desejada. Para inseri-la, basta pintar o terreno como fizemos com a textura do cenário.
Para salvar o arquivo, clicamos no menu File e escolhemos a opção Save Scene.
Agora, para testar o nosso terreno, devemos ir até a aba Project, na pasta Standard Assets,
Character Controllers, pegar o First Person Controller, arrastar e soltá-lo em Hierarchy, para criar
um jogador.
Posicionamos o jogador de forma que ele fique dentro das montanhas, fora do buraco no meio
delas, e acima do terreno (caso contrário, o jogador ficará caindo infinitamente). Para finalizar,
ajustamos o valor de Y, em Position.
16
Para não gerar erro, devemos excluir o arquivo Main Camera, como mostrado abaixo. Para
exclui-lo, basta selecionar o objeto e apertar a tecla <Delete>.
Clicando em Play
e usando as setas direcionais, o mouse ou as teclas <w>, <a>, <s>, <d>
para se mover e a Barra de Espaços para pular, é possível ver um prévio resultado:
Depois de fazer os testes, clicamos sobre o botão Play novamente para voltar à cena do jogo.
Adicionando luz
Já temos o personagem andando pelo cenário, porém está muito escuro e não é possível
visualizar bem os detalhes. Para isso, vamos adicionar uma luz para iluminar o cenário.
Então, clicamos no menu GameObject, posicionamos o mouse sobre Create Other, e em
seguida, clicamos em Directional Light.
17
Agora, movimentamos e rotacionamos a luz de forma que ela ilumine bem o cenário, colocando
a Position de Y em 360 e a Rotation de X em 100. Depois, movimentamos a luz um pouco
distante das montanhas que foram criadas.
Já podemos ver tudo com mais clareza na cena, mas não podemos ver o foco da luz no game.
Para melhorar isso, na aba Hierarchy, selecionamos a Directional light. Agora, vamos até a aba
Inspector, clicamos em Flare e selecionamos a textura Sun, para colocar um sol na cena.
O resultado deve ser semelhante ao mostrado abaixo quando você estiver in game e olhar para
a luz:
Mas além do sol, precisamos de algumas nuvens para fazer um céu mais realista. Criaremos as
mesmas através de um componente chamado SkyBox. Ele funciona como se toda a cena
estivesse dentro de uma caixa com uma imagem na parte de dentro, englobando toda a cena,
dando impressão de que realmente existem nuvens no céu.
Para isso, devemos clicar no menu Edit e em Render Settings, para que apareçam as opções de
renderização da cena no Inspector.
Depois, clicamos em Skybox Material e selecionamos Eerie Skybox da lista.
18
O resultado final deverá estar próximo do mostrado a seguir:
Adicionando água
Colocaremos água no buraco que foi feito no meio das montanhas. Para isso, clicamos na aba
Project, na pasta Standard Assets, abrimos a pasta Water, arrastamos e soltamos o componente
Daylight Simple Water para o cenário.
Depois, aumentamos a água com o Scale
buraco, através do Move
e subimos o objeto de forma que cubra o
.
19
Agora, clicamos em Standard Assets (na aba Project) e em seguida, em Particles. Clicamos em
Water e arrastamos o componente WaterFall (cachoeira) para o cenário, posicionando-o no
local apropriado.
Com o WaterFall selecionado na aba Hierarchy, devemos clicar no menu Component, posicionar
o mouse sobre Particles e em seguida, clicar em World Particle Collider, para adicionar colisão às
partículas de água.
Em instantes, aparecerá uma mensagem, pois estamos modificando um prefab, ou seja, um
componente que já vem pronto pra ser utilizado no Unity. Podemos clicar em Add, sem
problemas.
Agora, na aba Inspector, será necessário alterar alguns valores para que o aspecto da cachoeira
fique melhor. Veja um exemplo de configuração sugerida:
20
Cachoeira inserida e configurada para o correto posicionamento no terreno:
Adicionando um objeto externo
Agora, adicionaremos uma arma ao nosso personagem, modelada no programa 3ds Max. Para
isso, devemos clicar com o botão direito do mouse na aba Project e escolher a opção Import
New Asset.
Será aberta a janela Import New Asset. Nela, selecionamos o arquivo a ser importado e clicamos
em Import.
O objeto ainda não aparecerá no cenário, pois para que ele apareça, deve ser arrastado da aba
Project para a aba Hierarchy.
21
Depois disso, a arma está na cena, mas possivelmente deve estar longe da câmera e do cenário.
Para posicioná-la corretamente, precisamos mover
e escalar
para frente do First Person Controller
para que fique proporcional ao personagem. Também podemos rotacioná-la
para dar impressão de que o personagem está segurando a arma.
Clicando na aba Game e arrastando ela para o lado esquerdo da aba Scene fica mais fácil a
visualização de onde está a arma e como ela vai ficar posicionada em relação ao jogador, pois
atualiza a posição no jogo em tempo real enquanto o objeto é movimentado em Scene.
Agora, para a arma se mover junto com o personagem é simples: basta arrastar o objeto
ak47wstock.3ds da aba Hierarchy e soltá-lo sobre a Main Camera, dentro de First Person
Controller. Caso apareça uma mensagem de confirmação, clicamos em Continue. Assim, a arma
estará linkada à câmera.
Criaremos um Script para que o cursor do mouse desapareça da cena quando o jogo estiver
rodando. Então, devemos clicar com o botão direito do mouse em uma área livre da aba Project,
abrir a opção Create e clicar em C Sharp Script.
Na aba Project aparecerá um novo componente chamado NewBehaviourScript. Para renomeálo, devemos selecionar o mesmo e pressionar <F2>. Em seguida, basta alterar seu nome. Depois
22
disso, pressionamos <ENTER> ou executamos um duplo clique sobre o componente, com o
objetivo de abri-lo para edição.
Na linha 4, ou seja, em public class NewBehaviourScript : MonoBehaviour {, apagamos
NewBehaviourScript e colocamos em seu lugar o nome que atribuímos ao componente, caso
contrário, o Script não irá funcionar e acusará erro.
Dentro das chaves de Start (), digitamos: Screen.showCursor = false;
Com isso, usamos o método showCursor que mostra o cursor do mouse, da classe Screen que
gerencia as opções de tela e colocamos igual a false, para que o cursor do mouse fique invisível.
Terminamos a linha de comando com ponto e vírgula.
Digitamos isso dentro das chaves de Start, pois tudo que está dentro de Start é executado logo
que o jogo é carregado.
Depois da inserção dos códigos, devemos clicar no menu File e escolher a opção Save. Em
seguida, podemos fechar a janela de edição de códigos.
Para que o Script funcione, precisamos arrastá-lo da aba Project e soltá-lo em cima da Main
Camera do First Person Controller, em Hierarchy. Verifique na aba Inspector, com a Main
Camera selecionada, rolando a Barra de Rolagem até embaixo, se o Script criado está lá.
23
Caso ocorra algum erro depois de colocado o Script na Main Camera, clicamos com o botão
direito do mouse no Script, na aba Inspector e selecionamos a opção Remove Component.
Depois, alteramos o Script na aba Project e o colocamos novamente sobre a Main Camera, pois
se simplesmente o modificarmos, não surtirá efeito algum, sendo que o Script que estará na
Main Camera será o antigo, ainda inalterado.
Programando o impacto do tiro e sua mira
Para criar a mira da nossa arma, clicamos no menu GameObject e escolhemos a opção Create
Empty. Assim, será criado um objeto vazio que servirá como mira, já que retiramos o cursor do
mouse com o Script criado há pouco.
Depois, mudamos o nome do GameObject para Mira e o colocamos dentro da arma, em
Hierarchy. Desse modo, o objeto ficará dependente dela.
24
Caso apareça uma mensagem de confirmação, podemos clicar em Continue.
Agora, devemos posicionar o objeto na frente da MainCamera com o eixo Z virado para a frente
dela.
Em seguida, criamos um Script chamado VerificarContato e inserimos os códigos:
O objeto miras do tipo Texture2D, mostrará a mira na sua tela e a variável int miraAtual é para
identificar o valor da textura, pois somente com Texture2D não será possível sabermos quantas
texturas estão no mesmo objeto. Por fim, o GameObject particulas servirá para emitir algumas
partículas onde acertar o tiro.
Depois, dentro das chaves do método Update, devemos digitar:
O comando if (inicial), servirá para informar se o jogador atirou ou não. O comando
GetButtonDown, faz parte de input, que serve para informar qual botão o jogador pressionou,
no caso Fire1 é um botão reconhecido pelo Unity como botão esquerdo do mouse (ou tecla
<Ctrl>).
O comando contato é uma variável do tipo RaycastHit, que é uma estrutura que retorna
informações sobre objetos que estão sendo tocados na cena.
25
O comando direcao é uma variável do tipo Vector3 que recebe 3 valores, no caso de transform,
que tem valores de X, Y, Z (as posições do objeto) e é utilizado o comando TransformDirection,
para pegar somente uma direção desse Vector3, no caso forward, que está a frente do objeto,
ou seja, seu eixo Z, de profundidade.
Um novo if está dentro do primeiro e toda esta estrutura de comando só será acionada quando
o jogador atirar. Por isso, está tudo dentro do primeiro if. Este novo if serve para informar se
houve contato com algum elemento físico da cena, pois o jogador pode atirar para cima e não
acertar nada, então, usa-se Physics e Raycast, com o transform.position, para especificar onde
atingiu exatamente em um objeto físico da cena. Utiliza-se direcao para informar de onde veio o
tiro e out que é onde vai sair o resultado de contato (que é a variável que guarda o acerto do
Raycast).
O comando rotacao é uma variável do tipo Quaternion, que serve exatamente para pegar a
rotação de um objeto, usando o comando FromToRotation, que seria da rotação, para rotação,
em uma tradução livre, que significa de uma rotação a outra, com o Vector3 usando up. A
variável contato é a função normal, que retorna a força normal do objeto, ou seja, para fora
dele.
Por fim, Instantiate é para criar o objeto. Quando você instancia um objeto, você está criando
ele na cena. Em nosso caso, o que está sendo criado é o sistema de partículas, onde houve o
contato do tiro, usando a variável rotacao, do tipo Quaternion, que foi criada acima para que as
partículas sempre saiam pra fora do objeto.
Depois disso, abaixo das chaves de Update, mas não fora das chaves do MonoBehaviour, que
começam bem em cima e encerram o Script, criamos um novo Void, mas dessa vez público:
O comando GUI serve para mostrar imagens em 2D no seu jogo 3D do Unity. Pode servir para
criar um menu, mas em nosso caso, servirá apenas para mostrar a mira no centro da tela. Por
isso, a variável coluna, do tipo int, que guarda valores inteiros, utiliza a propriedade width, de
Screen, que faz a largura da tela menos o valor da largura da mira atual e divide o resultado por
2, para que a mira fique centralizada na tela. O mesmo ocorre com height, sendo a altura.
O comando regiao é uma variável do tipo Rect, utilizada para guardar os valores da mira e
desenhar um quadrado invisível. Depois, com os valores da mira, o comando DrawTexture
apenas utiliza a variável regiao e a miraAtual para saber qual textura e a posição que aparecerá
na tela, em nosso caso, no centro.
26
Clicamos em File e escolhemos a opção Save, para salvar seu Script. Depois, podemos fechar sua
janela de edição.
Agora, devemos criar uma pasta chamada Texturas na aba Project. Para isso, clicamos com o
botão direito do mouse sobre uma área livre deste painel, escolhemos a opção Create e a
subopção Folder. Depois, pressionamos a tecla <F2> e alteramos o nome da pasta para Texturas.
Por fim, clicamos com o botão direito do mouse sobre a pasta criada e escolhemos a opção
Import New Asset. Localizamos o diretório onde se encontra a imagem a ser inserida e a
importamos.
Criando um Prefab
Agora, criaremos um Prefab para o tiro da nossa arma.
Um Prefab, nada mais é do que um objeto pré-fabricado, que não vai estar diretamente na aba
Hierarchy, mas sim dentro de um Script, e vai ser gerado em tempo real no jogo, como o tiro da
arma, por exemplo. Ele não pode estar lá o tempo todo, pois iria consumir muita memória do
computador e seria limitado.
Para isso, devemos criar uma pasta denominada Prefabs, na aba Project. Depois, precisamos
clicar com o botão direito do mouse sobre ela, ir até a opção Create, subopção Prefab e alterar
seu nome para Tiro.
27
Depois, clicamos com o botão direito do mouse novamente sobre a pasta Prefabs e
selecionamos Import New Asset. Localizamos a pasta onde você salvou seu projeto e abrimos as
pastas Assets, Standard Assets, Particles e Legacy Particles, consecutivamente. Adicionamos o
Prefab "Sparks.prefab" e o Script "TimedObjectDestructor.js", um de cada vez.
Em seguida, arrastamos os arquivos que acabamos de importar para dentro do Prefab "Tiro".
Você poderá não notar uma grande diferença, mas os arquivos estarão lá dentro, pois o ícone
localizado em frente do Prefab "Tiro" se tornará azul, indicando que não está vazio.
Selecionamos o Prefab "Tiro" e na aba Inspector, alteramos a opção Time Out, do Timed
ObjectDestructor (Script), com o valor que julgarmos mais conveniente. Este componente serve
para que as partículas desapareçam depois de certo tempo. Em nosso exemplo, elas
desaparecerão após 0.5 segundos.
Agora, selecionamos o Script "VerificarContato", na aba Project, arrastamos e o soltamos para
dentro da Mira, que se localiza no First Person Controller, em Main Camera e em ak47wstock,
na aba Hierarchy.
Na própria aba Hierarchy, selecionamos Mira e colocamos a opção Size como 1, nas opção do
Script, para que apareça o Element 0. Depois, arrastamos a textura Mira64x64, que se encontra
dentro da pasta Texturas da aba Project e a soltamos sobre o Element 0.
28
Para finalizar, arrastamos o Prefab "Tiro", da aba Project e o soltamos sobre a opção Particulas,
na aba Inspector.
Clicando com o botão esquerdo do mouse ou pressionando a tecla <Ctrl> para atirar, podemos
observar o resultado durante a execução do game:
Possivelmente, o tiro não estará indo exatamente no meio da mira (ou pode ser que não esteja
nem aparecendo). Isso acontece porque o componente Mira pode não estar devidamente
posicionado junto com a arma. Para corrigir este erro, devemos observar o posicionamento da
arma e procurar colocar o componente Mira bem próximo a ela, rotacionando e movendo o
mesmo até que consiga o resultado desejado.
Criando os alvos
Criaremos alvos para serem acertados com os tiros. As esferas azuis valerão 1 ponto, enquanto
que as vermelhas devem ser evitadas, pois caso acerte 3 destas esferas, terá perdido o jogo.
Clicamos no menu GameObject, selecionamos a opção Create Other e escolhemos Sphere, para
criar a primeira esfera.
29
Para que a esfera tenha massa e seja um corpo rígido, devemos colocar um componente nela.
Para isso, com a esfera selecionada, precisamos clicar no menu Component, escolher a opção
Physics e clicar em Rigidbody.
Agora, para colorir o objeto criado, precisamos aplicar um material nele, pois uma simples
textura não funcionará.
Então, clicamos com o botão direito do mouse na pasta Texturas, que você criou na aba Project,
e escolhemos Import New Asset, para adicionar as texturas alvo.psd e erro.psd, uma de cada
vez.
Depois disso, clicamos com o botão direito do mouse fora da pasta Texturas (mas ainda dentro
de Project) e criamos uma nova pasta chamada Materiais. Em seguida, clicamos com o botão
direito do mouse sobre ela, escolhemos Create e clicamos sobre a opção Material. Com o intuito
de melhor identificá-lo, alteramos seu nome para Azul.
Do mesmo modo, criamos outro material e lhe atribuímos o nome de Vermelho.
30
Agora, no Inspector do material Azul, clicamos em Select. Na caixa Select Texture2D que surge,
selecionamos a textura alvo com um duplo clique.
O mesmo procedimento deve ser executado para o material Vermelho, mas dessa vez,
colocando-se a textura erro.
A esfera também precisará de um sistema de partículas, para que saia fogo dela quando
acertada. Para isso, precisaremos incluir alguns componentes.
Com a esfera selecionada, devemos clicar no menu Component, escolher a opção Particles e
adicionar 3 componentes: Mesh Particle Emitter (para emissão das partículas), Particle Animator
(para animar as partículas) e Particle Renderer (para mostrar as partículas), um por vez.
Depois disso, na aba Inspector, em Particle Renderer, clicamos em Element 0, para escolher a
textura das partículas.
Selecionamos a textura FireAdd, aplicando um duplo clique sobre ela.
31
Agora, em Mesh Particle Emitter, ainda na aba Inspector, desabilitamos o comando Emit, pois se
ele ficar ativado, a esfera estará emitindo fogo mesmo antes de ser acertada.
Os demais parâmetros também podem ser alterados de acordo com a nossa necessidade.
Os parâmetros do Particle Animator não precisam ser alterados, pois suas configurações já nos
permitirão um bom resultado.
Agora, vamos duplicar a esfera. Para isso, clicamos em Sphere, na aba Hierarchy, e
pressionamos <Ctrl>+<C> (para copiar) e depois <Ctrl>+<V> (para colar). Em seguida,
movimentamos a cópia para o lado, com o objetivo de retirá-la de cima da original.
Depois da duplicação, devemos alterar o nome de uma esfera para Alvo e o da outra para Erro.
Lembre-se de que para alterar o nome de um objeto, você precisa selecioná-lo na guia Hierarchy
e pressionar <F2>.
Criando os alvos
Agora, arrastamos e soltamos os materiais que foram criados na aba Project sobre as esferas: O
material Azul na esfera Alvo e o Vermelho na esfera Erro.
32
As esferas estão quase completas. Para terminar, vamos colocar uma luz dentro delas para que
fiquem visíveis à distância.
Então, precisamos clicar no menu GameObject, escolher a opção Create Other e depois, clicar
em Point Light.
Movimentamos a Point light para dentro do Alvo e modificamos os seus parâmetros. Alteramos
a propriedade Color para Azul, aumentamos o Intensity e ativamos o Draw Halo.
Por fim, criamos outra Point light e fazemos o mesmo para a esfera Erro, porém, mudamos a cor
da luz para Vermelho.
33
Depois disso, arrastamos a Point light correspondente a cada esfera para dentro da mesma,
formando uma hierarquia, dentro da aba Hierarchy. Assim, seus alvos estarão prontos.
Alvos móveis e destrutíveis
Para que as esferas que criamos sejam destrutíveis, precisaremos elaborar um Script para elas.
Vamos chamar este Script de Damage.
Agora, na edição do Script, apagamos o nome NewBehaviourScript, da linha public class
NewBehaviourScript : MonoBehaviour {, colocando o nome do próprio documento, ou seja,
Damage, no lugar.
Em seguida, apagamos método Start, pois ele não será necessário.
Depois, devemos criar um novo método no lugar do que apagamos, digitando:
34
O método Estrago utiliza 2 comandos:
- particleEmitter.emit: trata da emissão de partículas. O comando true significa verdadeiro, ou
seja, quando o método for chamado, o objeto que tiver esse Script acionará o seu sistema de
partículas (caso o objeto não tenha sistema de partículas, ocorrerá erro).
- Destroy: destrói o objeto desejado, fazendo-o sumir da cena e deixando de ocupar memória no
computador. Nesse caso, destrói o próprio objeto em que o Script foi colocado. O número
depois da vírgula serve para indicar em quantos segundos o objeto será destruído.
Agora, dentro do método Update, digitamos os seguintes comandos:
Se objeto passar de uma determinada altura Y, no caso 70, ele será destruído.
Depois de salvar as edições do Script e fechá-lo, devemos arrastar o objeto da aba Project e
soltá-lo sobre Alvo e Erro, na aba Hierarchy. Dessa forma, o Script começará a fazer parte dos
objetos.
35
Mas somente este Script não será suficiente para destruir as esferas. Por isso, teremos que
modificar o método Update do Script "VerificarContato", da seguinte forma:
Deste modo, configuramos nosso game para que as esferas soltem fogo e desapareçam depois
de acertadas.
Alvos móveis e destrutíveis
Agora, para que as esferas apareçam aleatoriamente, a primeira coisa que precisamos fazer é
transformá-las em Prefabs.
Para isso, clicamos com o botão direito do mouse sobre a pasta Prefabs que criamos na aba
Project, escolhemos Create e clicamos em Prefab. Depois, nomeamos o objeto como Alvo. Em
seguida, arrastamos a esfera Alvo da aba Hierarchy e a soltamos em cima do Prefab "Alvo", na
aba Project.
36
Na sequência, criamos outro Prefab com o nome Erro e arrastamos a esfera Erro para dentro
dele.
Depois de certificar-se que os Prefabs "Alvo" e "Erro" estão preenchidos com as esferas
corretamente, deletamos as esferas Alvo e Erro da aba Hierarchy.
Agora, para a área em que sairão as esferas criadas, precisaremos de um Plane. Para isso,
devemos clicar no menu GameObject, escolher a opção Create Other e clicar em Plane.
Depois, posicionamos o Plane de forma que fique no centro da água e aumentamos até que
fique quase do tamanho do lago, mas um pouco menor.
Na aba Inspector, desativamos a propriedade Mesh Renderer do Plane, para que fique invisível
quando o game for iniciado.
Agora, alteramos o nome do Plane para PlataformaBola, na aba Hierarchy.
Nosso próximo passo é criar um novo Script com o nome de GeradorDeBolas e editá-lo da
seguinte forma:
37
Depois disso, removemos os métodos Start e Update, que não serão utilizados e criamos o
método GerarBolas:
Este comando If serve para indicar que a cada 1 segundo será criada uma nova esfera em
alguma parte do Plane e esta será mandada para cima.
Time é função de tempo, fixedTime serve para marcar um tempo fixo em segundos.
O sinal de % pega o resto da divisão de uma variável, no caso a variável
intervaloDeTempoParaGerarBola, que foi definida como 1 quando foi criada. Toda vez que o
resto da divisão de 1, no caso for 0, seria a mesma coisa que dizer que a cada 1 segundo,
executaremos os comandos abaixo.
O comando Random é para gerar algo aleatoriamente em insideUnitSphere, que cria uma esfera
invisível dentro do objeto que for aplicado. 100 é o tamanho da área da esfera, a variável
posicao serve para pegar o valor aleatório e depois utilizá-lo na hora de instanciar (criar) a
esfera. O comando Vector3.up define que a velocidade aplicada na esfera será para cima, no
caso 3.
Devemos fazer o mesmo para o Erro. Portanto, abaixo do último comando digitado, inserimos:
38
Depois, usaremos o método FixedUpdate, para que ele execute os dois métodos criados acima
em tempo normal, pois se utilizássemos o método Update, o jogo seria executado muito
rapidamente e de acordo com a velocidade do computador, o que poderia fazer variar o jogo de
computador para computador.
Portanto, abaixo da última linha inserida, digitamos:
Com o Script já salvo e fechado, precisamos arrastá-lo sobre o objeto PlataformaBola, na aba
Hierarchy.
39
Depois de aplicado o Script, com o objeto PlataformaBola selecionado, dentro da aba Inspector,
colocamos o Prefab "Alvo" dentro do componente Bola e o Prefab "Erro" dentro de Erro, como
na imagem:
Neste momento, podemos executar o game, clicando em Play. Utilizamos as teclas de direção
do teclado e vamos caminhando até chegar próximo do lago. Devemos mirar as esferas azuis e
atirar, pressionando a tecla <Ctrl> ou clicando com o botão esquerdo do mouse. Se desejar
saltar, basta pressionar a Barra de Espaços.
Pontuação, Menu e Cenas Complementares
Criando a Pontuação:
Agora, criaremos um contador de pontos, para que o jogador saiba quantas bolas azuis e
vermelhas já acertou.
Primeiramente, clicamos no menu GameObject, selecionamos a opção Create Other e clicamos
em GUI Text.
Na aba Inspector, modificamos o nome do GUI Text para Pontos: e alteramos os seus
parâmetros, para que fique no canto superior esquerdo da tela e com letra legível, como a
imagem abaixo:
40
Agora, criamos outro GUI Text, mas desta vez com o nome Erros:. Posicionamos o novo texto
um pouco abaixo do anterior. O resultado deve ficar próximo do mostrado na imagem abaixo:
Na aba Inspector, utilizaremos o componente Tag, que nada mais é do que dar um apelido a
algum objeto. Primeiramente, criaremos estes apelidos.
Para isso, com qualquer objeto selecionado, clicamos em Untagged para abrir o menu
desdobrável. Depois, clicamos em Add Tag.
Na sequência, devemos clicar em Element 0 e colocar o nome de Alvo. Em Element 1, colocamos
o nome de Erro.
Agora, selecionamos o Prefab "Alvo", na aba Project, clicamos em Untagged e observamos que
existirá a opção Alvo, que acabamos de criar na lista. Clicamos sobre ela para selecioná-la.
41
Agora, devemos fazer o mesmo para o Prefab "Erro", definindo a Tag "Erro" para ele.
Em seguida, faremos algumas alterações no código de VerificarContato. Portanto, devemos abrir
o Script e digitar:
O comando If utiliza a variável contato, que calcula se o objeto bateu em algo ou não, se é um
corpo rígido, e procura se a Tag do objeto acertado é igual a Alvo;
O comando ++ na frente da variável qtdPontos serve para que a cada vez que uma condição for
satisfeita (no caso a Tag do objeto acertado for igual a Alvo), a variável qtdPontos ganha mais 1,
ou seja, ela muda do estado inicial, que era 0, para 1. A partir daí, ela vale 1. Se outro objeto
acertado tiver a Tag igual a Alvo, será efetuado 1+1 = 2, e assim consecutivamente;
Depois, precisamos escrever na tela, fazendo com que o valor atualizado de qtdPontos seja
colocado na frente do texto Pontos:.
Pontos é a variável de texto. Então, colocamos que o seu texto é igual a Pontos: mais o valor da
variável qtdPontos. Porém, ela está em valor numérico, não de texto, e o computador enxerga
como diferentes os valores numéricos e os de texto. Então, usamos o comando ToString para
transformar o valor da variável qtdPontos em texto, para aparecer na tela, caso contrário
ocorreria erro e o jogo não seria executado.
O comando ToString abre e fecha parênteses, para indicar que não tem nenhum comando
adicional dentro dele. O mesmo vale pra erros, apenas com as alterações necessárias.
Agora, digitamos os códigos mostrados abaixo da linha que diz respeito à última variável
declarada:
42
O comando int, juntamente com 00, indica variáveis numéricas iniciadas em 0, enquanto que o
comando GUI Text indica uma variável de texto.
Para concluir esta parte, basta indicarmos cada texto ao seu respectivo objeto. Para iniciar,
renomeamos os objetos GUI Text para Pontos e Erros, respectivamente. Lembre-se de olhar o
texto do Inspector para renomear o objeto correto, ou seja, o GUI Text de nome Erros: deve ser
renomeado como Erros, por exemplo.
Agora, ainda na aba Hierarchy, selecionamos a Mira. Depois, no painel Inspector, adicionamos
os objetos GUI Text correspondentes a cada item do Script, como na imagem:
Deste modo, a cada bola azul acertada, a pontuação aumenta em Pontos. Ao contrário, quando
são acertadas as bolas vermelhas, a pontuação aumenta em Erros.
Antes de testarmos o nosso jogo novamente, precisamos fazer algumas alterações gerais, pois
você deve ter percebido que as bolas estavam muito pequenas, e por isso, difíceis de serem
acertadas.
Outro problema encontrado é que os alvos ficavam flutuando sobre o Plane e não
desapareciam. Assim, ocorria uma aglomeração de esferas e o ambiente do jogo começava a
ficar pesado.
Para melhorar isso, na aba Project, selecionamos o Prefab "Alvo". No Inspector, fazemos as
seguintes alterações:
43
Ainda com o Prefab "Alvo" ativo, selecionamos o Point light vinculado a este objeto e alteramos
os campos de Scale também para 5 e aumentamos o valor de Range para 10. Deste modo,
aumentamos o tamanho e a intensidade da iluminação interna da esfera.
Em seguida, fazemos exatamente a mesma coisa com o Prefab "Erro", aumentando o tamanho
da esfera e da iluminação interna para 5 em todos os eixos, a intensidade do Range para 10 e
desmarcando a opção Use Gravity.
Veja o resultado:
Criando o Menu e as Cenas Complementares:
Precisamos clicar em File e escolher a opção New Scene, para abrir uma cena nova e vazia, com
a Hierarchy apenas contendo uma Main Camera, pois os objetos desta aba só dizem respeito à
cena atual.
Agora, clicamos no menu GameObject, escolhemos a opção Create Other e clicamos em Plane.
44
Na sequência, selecionamos a Main Camera na aba Hierarchy. No Inspector, em Position,
definimos os valores para Y, e em Rotation, colocamos os valores para X.
Agora, alteramos o posicionamento e a rotação do Plane para 0 em todos os eixos.
Depois, clicamos com o botão direito do mouse na pasta Texturas (em Project) e escolhemos a
opção Import New Asset. Na caixa de diálogo Import New Asset, encontramos a pasta onde está
localizado o arquivo desejado, selecionamos o mesmo e clicamos em Import.
Na aba Project, clicamos sobre a textura importada, deixamos o botão esquerdo do mouse
pressionado e a arrastamos sobre o Plane, na Scene.
Caso a imagem fique invertida, precisamos alterar a rotação Y do Plane para 180.
45
Selecionamos o Plane e alteramos os seus valores de escala, de forma que cubra toda a tela,
mas seja visível toda a textura.
Depois, mudamos a posição de X para -0.05.
Agora, clicamos no menu GameObject, escolhemos a opção Create Other e clicamos em
Directional Light.
Depois, rotacionamos o objeto inserido, alterando a posição de X para 90. Deixaremos também
os demais valores como mostrado abaixo. Dessa forma, proporcionamos uma melhor
iluminação ao Plane.
Neste momento, devemos salvar a cena que criamos. Para isso, clicamos em File e escolhemos a
opção Save Scene as. Colocamos o nome desejado e clicamos em Salvar.
Ainda faltam as cenas de Vitória e Derrota. Utilizaremos a base da cena que acabamos de criar e
salvaremos as alterações como fazendo parte de cenas diferentes, através do comando Save
Scene as.
Para isso, clicamos com o botão direito do mouse na pasta Texturas, em Project, e escolhemos a
opção Import New Asset. Na caixa de diálogo que surge, selecionamos o arquivo da nova cena e
o importamos. Depois, arrastamos a textura sobre o Plane e salvamos a cena através do
comando Save Scene as.
Estes passos devem ser executados para as cenas Vitoria e GameOver, como já mencionado.
Com todas as cenas prontas, faremos a organização pela ordem em que elas aparecerão no
jogo.
46
Primeiramente, precisamos alterar o nome da cena cenario_principal para Jogo.
Em seguida, clicamos duas vezes na cena do menu, para abri-la. Depois de aberta, clicamos no
menu File e escolhemos a opção Build Settings.
Na janela que se abrirá, clicamos no botão Add Current. Em seguida, podemos observar que a
cena Menu deve aparecer com o número 0 na frente.
Agora, fechamos esta janela, abrimos a cena Jogo e executamos o mesmo procedimento.
Depois, devemos repetir o mesmo com a cena Vitoria e, por último, com GameOver. O resultado
deve ficar nesta ordem: Menu 0, Jogo 1, Vitoria 2, GameOver 3. Esta é a ordem natural das
cenas durante o jogo.
Para finalizar, criaremos um novo Script, para programar a entrada do jogo, se o jogador quer
jogar novamente ou sair. Este Script se chamará Menu e é muito simples, apenas digitamos
dentro das chaves de Update:
Se o reconhecedor de comandos (Input) localizar que alguma tecla foi pressionada
(GetKeyDown), e o código desta tecla (KeyCode) for a tecla <Enter> (Return), então a aplicação
47
(Application) carrega a cena 1 (LoadLevel), que pela numeração definida anteriormente é a cena
Jogo.
Agora, abrimos a cena Menu, arrastamos o Script "Menu" que está na aba Project e soltamos
sobre a Main Camera, em Hierarchy. Se tudo estiver correto, o Script aparecerá no Inspector
quando a Main Camera estiver selecionada.
Agora, devemos abrir o Script "VerificarContato", para colocar as condições de vitória ou perda
do jogo.
Então, depois da linha pontos.text = "Pontos: " +qtdPontos.ToString();, digitamos:
Se a variável que conta quantas bolas azuis foram acertadas (qtdPontos) for igual a 20, a
aplicação carregará a cena 2 (Vitoria).
Depois da linha erros.text = "Erros: " +qtdErros.ToString();, digitamos:
Neste caso, o código é o mesmo do anterior, mas para as bolas vermelhas, pois caso 3 delas
sejam acertadas, será carregada a cena 3 (GameOver).
Para testar se o Script está funcionando, executamos o jogo e observamos que a tela do menu
inicial é exibida. Pressionamos <Enter> para iniciar o game e devemos acertar 20 bolas azuis.
Depois disso, a cena Vitoria deverá ser exibida.
48
Executamos novamente o jogo, pressionamos <Enter> para iniciar, acertamos 3 bolas vermelhas
e poderemos observar que a cena GameOver é exibida, indicando que você perdeu o jogo.
Replay e Sons
Evento Replay
Para o evento Replay, precisamos criar um Script com o nome Replay e digitar:
49
O primeiro if, indica que se caso o jogador pressionar a tecla <S>, deverá ser carregada a cena 1
(Jogo).
O segundo if, indica que se caso o jogador pressionar a tecla <N>, a aplicação será fechada,
saindo do jogo. Porém, este comando só funciona na versão executável do game, e não em
tempo de projeto.
Com a cena Vitoria aberta, arrastamos e soltamos o Script na Main Camera, em Hierarchy.
Depois, salvamos as alterações na cena.
Com a Main Camera selecionada, observamos o Script na aba Inspector:
Inserindo Sons
A partir deste momento, vamos inserir sons aos eventos do nosso projeto. Este efeito
complementar tem a utilidade de prender mais a atenção do jogador e trazer o ambiente virtual
mais próximo da realidade.
Com nenhum objeto selecionado em Project, clicamos em Create e escolhemos a opção Folder.
Depois, alteramos o nome da pasta para Som.
Agora, clicamos com o botão direito do mouse sobre a pasta que acabamos de criar e
escolhemos a opção Import New Asset. Neste momento, adicionamos os arquivos de som
desejados, um de cada vez.
Depois disso, com a cena Jogo aberta, na aba Hierarchy, selecionamos Mira, clicamos no menu
Component, escolhemos a opção Audio e clicamos no item Audio Source, que nada mais é do
que um gerador de som na cena.
Veja que no Inspector, aparecerão as opções de Audio Source:
50
Na opção Audio Clip, adicionamos o som que escolhemos para a arma. Depois, desativamos a
opção Play on Awake e colocamos o Volume em 0.5.
Agora, selecionamos o Prefab "Alvo", na aba Project, clicamos no menu Component,
escolhemos a opção Audio e clicamos sobre o item Audio Source.
Já no Inspector, na opção Audio Clipe, adicionamos o som escolhido para a explosão das esferas
e desativamos a opção Play On Awake.
Depois, fazemos exatamente igual com o Prefab "Erro", colocando o mesmo som na opção
Audio Clip.
Agora, para que os sons inseridos funcionem, devemos abrir a edição do Script
"VerificarContato" e abaixo da linha if(Input.GetButtonDown("Fire1")){, digitar:
51
Em seguida, abrimos o Script "Damage" e abaixo da linha Destroy(gameObject, 1);, digitamos:
Através destes códigos, definimos que ao executar o tiro ou a explosão das esferas, o áudio
escolhido para cada objeto deve ser tocado.
Agora, vamos adicionar sons às cenas Menu, Vitoria, GameOver e Jogo, pois dessa forma,
deixaremos o game mais animado.
Para isso, clicamos com o botão direito do mouse sobre a pasta Som e escolhemos a opção
Import New Asset. Em seguida, adicionamos os sons novamente, um de cada vez.
Com todos os arquivos adicionados, abrimos a cena Menu e selecionamos a Main Camera, em
Hierarchy.
Agora, adicionamos um novo Audio Source e no Inspector, adicionamos o som escolhido para o
Menu e marcamos a opção Loop, pra que ele fique em repetição. Devemos manter também a
opção Play On Awake marcada, pois assim o som se iniciará quando a cena for carregada.
Agora, podemos fazer o mesmo com as demais cenas do game. Para isso, adicionamos um Audio
Source na Main Camera de cada uma e fazemos a associação com o som adequado. Definimos
os parâmetros desejados para as propriedades e salvamos as alterações em cada cena.
52
Criando o Arquivo Executável
Para finalizar nosso projeto, precisamos criar o Arquivo Executável do nosso game, que nada
mais é do que um arquivo que realiza comandos básicos quando é aberto pelo usuário, sem a
necessidade de utilizar um software específico, normalmente.
Deste modo, criaremos um Arquivo Executável para nosso jogo, e assim, quando o jogador final
desejar rodar a aplicação, não será necessário possuir o Unity instalado em sua máquina, e nem
será preciso abrir o programa para que jogue, pois o Executável fará isso automaticamente.
Com o projeto aberto, clicamos no menu File e escolhemos a opção Build Settings.
Na janela Build Settings, clicamos sobre a opção Build And Run.
Em seguida, surgirá a caixa de diálogo Build PC and Mac Standalone. Localizamos a pasta onde
desejamos salvar o Executável, digitamos o nome desejado para o mesmo e, para finalizar,
clicamos em Salvar.
Devemos aguardar até que o Executável seja gerado. Depois, aparecerá a tela inicial do nosso
game:
53
Como abriremos o jogo pelo ícone do Arquivo Executável, podemos fechar a tela inicial Projeto 1
Configuration e encerrar o Unity. Caso apareça alguma mensagem de confirmação, devemos
salvar todas as alterações.
Agora, precisamos abrir o Windows Explorer, através do menu Iniciar, opção Todos os
Programas, pasta Acessórios, item Windows Explorer. Depois, localizamos a pasta onde
salvamos o Executável e aplicamos um duplo clique sobre o mesmo.
Em instantes, surgirá a janela Projeto 1 Configuration novamente. Como já foi dito, esta é a tela
inicial do game pronto, onde você pode escolher as opções de qualidade de gráficos, resolução
de tela e se vai abrir em janela ou tela inteira. Nas opções de Input, pode-se, inclusive, mudar os
comandos do jogo.
Clicando em Play!, você inicia o jogo. Nesta fase, fazemos todos os testes desejados e
verificamos o resultado final do nosso projeto.
54