Unity – Introdução e Primeiros Passos

On 13 de maio de 2017 by Breno Keller

O que é Unity

O Unity é uma ferramenta de criação de jogos semelhante ao Blender que permite desenvolver jogos através de uma interface gráfica. Além disso, ela oferece diversos recursos como uma IDE auxiliar, o MonoDevelop que permite a construção de scripts em C# ou Javascript. Ela também oferece simulação de gravidade, texturas, iluminação, algoritmos de colisão, entre outros recursos. O Unity é utilizado principalmente para o desenvolvimento de jogos para navegadores mas também fornece estrutura de desenvolvimento para Windows, Linux, Mac OS, Xbox, Android e iPhone. Ele também fornece integração a algumas APIs como por exemplo a GoogleVR, para o desenvolvimento de aplicações VR (Realidade Virtual, do inglês Virtual Reality) utilizando a tecnologia Cardboard do Google.

Como instalar

O Unity oferece algumas opções de Download, desde a versão Personal que não requer assinatura mensal mas tem algumas limitações no que pode ser desenvolvido e em quem pode utilizá-la, até a versão Pro que não tem limitações e trabalha através de uma assinatura mensal. Essas opções de downloads estão disponiveis no site: https://store.unity.com/pt.

Após escolher qual versão do Unity será utilizada é necessário fazer o download e a instalação dela. Mas caso utilize Windows também é necessário que o Visual Studio esteja instalado no computador, se não o tiver é possivel realizar o download através deste link: https://www.visualstudio.com/pt-br/vs/community/.

Depois de realizado o download do Unity e resolvido suas dependências é necessário seguir o processo de instalação e com isso teremos a ferramenta instalada e configurada para uso.

Criando uma Aplicação Exemplo

Criando o Projeto

Para demonstrar o funcionamento da ferramenta e explicar alguns conceitos básicos do Unity iremos desenvolver um dos exemplo disponiveis em: https://unity3d.com/pt/learn/tutorials/, no caso o exemplo Roll a Ball.

Primeiro é necessário criar um novo projeto, para isso existe dois caminhos:

  • Caso esteja na tela inicial, clique na opção de criar um novo projeto
  • Caso esteja com um projeto aberto, vá em File -> New Project

Em seguida criaremos o projeto utilizando a configuração básica para 3D, portanto:

  1. Defina o nome do projeto para “Roll a Ball”
  2. Escolha onde o projeto será salvo
  3. Marque a opção 3D
  4. Clique na opção Criar Projeto e aguarde algum tempo até o carregamento do ambiente de desenvolvimento

Ao criar um projeto utilizando a configuração padrão para 3D, ele virá com alguns componentes em uma cena, sendo eles:

  • Uma camera (o componente Main Camera) e
  • Uma luz direcional (o componente Directional Light)

No Unity para uma maior organização e melhor desenvolvimento é recomendado que cada tipo de recurso seja salvo em uma pasta específica para ele, isso é, cenas devem ser salvas em uma pasta para cenas. Portanto iremos criar uma pasta para salvarmos nossa cena, para isso faça os seguintes passos:

  1. Na view Project acesse a pasta Assets
  2. Selecione a menu Create
  3. Selecione a opção Create Folder (como pode ser visto na figura ao lado) e o nomeie de “Scene”, caso queira que esta pasta fique no topo da listagem de diretórios utilize o nome “_Scene”
  4. Salve a cena
    1. Vá ao menu File
    2. Selecione a opção Save Scenes (destacada na figura abaixo)
    3. Acesse a pasta criada anteriormente
    4. Salve a cena com o nome “MainScene”

Nos próximos passos do tutorial iremos manipular alguns componentes do Unity para que possamos produzir o nosso jogo.

Manipulando Luzes

Primeiro iremos aproveitar que o componente Directional Light foi criado automaticamente e vamos alterá-lo para que possamos ter uma melhor iluminação da cena. Portanto siga os passos abaixo:

  1. Selecione o componente Directional Light na view Hierachy
  2. Na view Inspector localize a aba Transform
  3. Na aba Transform altere a rotação (rotation) no eixo Y para 60
    1. Ao terminar as modificações a aba Transform do componente deve estar da seguinte forma

As luzes direcionais são fontes de iluminação distantes (normalmente consideradas como fora da área do jogo) que projetam raios de luz sobre os objetos em uma mesma direção. Elas são utilizadas para simular elementos como sol ou a lua iluminando uma área.

Criando a Área do Jogo

Depois de configurada a luz nós iremos criar a área do jogo, um plano onde o jogador irá se locomover e coletar itens. Para isso criaremos um plano e alteraremos algumas de suas configurações.

  1. Na view Hierachy vá ao menu Create e escolha a opção 3D Object e Plane, como pode ser visto na figura abaixo:
  2. Selecione o plano e na view Inspector e no campo Name (destacado na figura abaixo) altere para “Ground”
  3. Ainda na view Inspector agora na aba Transform clique no símbolo de engrenagem no canto superior direito e selecione Reset.
    1. Ao resetar as transformações de um objeto, ele retornará aos valores default que são:
      1. Posicionamento em (0,0,0), a origem do espaço 3D
      2. Rotação em (0,0,0)
      3. Escala em (1,1,1)
  4. Após resetar as transformações do componente, iremos alterar a escala nos eixos X e Z para o valor 2.

Com isso faltará somente adicionar uma textura ou coloração ao nosso plano, mas para isso é necessário a utilização de um Material, por isso nosso próximo passo é criar um material para este fim.

Utilizando Materials

O Material determina como uma superfície será renderizada, incluindo referências para as texturas utilizadas, matrizes de cor, entre outros recursos gráficos. As opções apresentadas na view Inspector são determinadas por qual Shader o material está sendo utilizado. Para a maioria da situações a opção Standard dos Shader é a melhor escolha, porque permite renderização de forma realística diversos tipos de superfície.

Para se criar um novo material é necessário os seguintes passos:

  1. Crie uma subpasta nomeada “Material” dentro da pasta Assets para armazenar estes recursos
  2. Selecione a pasta e vá ao menu Project na opção Create e selecione Material
  3. Nomeie de “Background”
  4. Selecione o material
    1. Na view Inspector na aba Main Maps clique no retângulo de paleta de cor da opção Albedo
    2. Na janela que foi aberta altere o valor de R(vermelho) para 0, de G(verde) para 32 e de B(azul) para 64, isso resultará em uma cor azul escuro
  5. Arraste o material e sobre o plano e solte, com isso ele será associado a superfície do plano e determinará a textura dele. O resultado pode ser visto na figura abaixo:

Criando o Player

Agora iremos criar o Player do jogo e adicionar também as movimentações que ele será capaz de realizar. O player será uma esfera que se movimenta pelo campo e irá colidir com os muros e coletáveis. Os coletáveis serão cubos animados flutuando pelo cenário para que o Player interaja com eles e os colete, eles serão adicionados posteriormente neste tutorial. Cada um destes itens terá diferentes iterações com o Player. Para isso são necessários os seguintes passos:

  1. Na view Hiearchy vá ao menu Create e escolha as opções 3D Object  e Sphere
  2. Selecione o componente e na view Inspector, o renomeie para “Player”
  3. Ainda na view Inspector restaure as transformações do objeto para o valor default utilizando a engrenagem na aba Transform (como foi demonstrado anteriormente)

Caso esteja com o componente selecionado e clique na tecla “F”, a janela de visualização irá centralizar e conter todo o componente selecionado. Isto permite ver que a esfera está afundada dentro do plano, porque o ponto de origem dela é o mesmo ponto de origem do plano, o que acarreta em uma sobreposição. Como as formas geométricas do Unity seguem as proporções de 1 para 1 para 1 onde todas as medidas da forma são do tamanho 1, isso é fácil de se corrigir.

  1. Ainda na aba Transform altere o valor de Position no eixo Y para 0.5

Adicionando Física ao Player

O Unity fornece recursos que fazem o controle da física dos objetos existentes no jogo, sendo assim iremos adicionar o recurso Rigidbody que é utilizado pelo Unity para simular o posicionamento de um objeto através do resultado da aplicação de diversas forças sobre o objeto. Ao utilizar este componente, o objeto em cena associado a ele será afetado pela gravidade (uma força puxando ele para baixo) e pelas forças aplicadas por outros objetos a ele sem a necessidade que nada seja configurado. Para adicionar o rigidbody é necessário os seguintes passos:

  1. Na view Hierarchy selecione o Player
  2. No menu Component selecione a opção Physics e Rigidbody, destacada na figura abaixo. Com isso um rigidbody será adicionado ao componente e pode ser acessado pela view Inspector caso o Player esteja selecionado.

Como a movimentação nativa do rigidbody não contém os movimentos necessários para utilizar nosso Player no jogo será necessário adicionar um script que insira essas movimentações.

  1. Seguindo o padrão estabelecido anteriormente, crie uma subpasta na pasta Assets e a nomeie de “Scripts”. Após a criação, entre na pasta.
  2. Na view Hierachy selecione o Player
  3. Na view Inspector procure a opção Add Component e selecione New Script
  4. Nomeie o script de “PlayerController”. Ao criar um script por esse caminho, ele será associado ao componente selecionado, mas o arquivo correspondente é criado na raiz do diretório Assets
  5. Mova o arquivo PlayerController.cs para a pasta Scripts
  6. Abra o script em algum editor e coloque as seguinte linhas de código:  

[sourcecode language=”csharp”]
using UnityEngine;
using System.Collections;

public class PlayerController : MonoBehaviour {

public float speed;
private Rigidbody rb;

void Start () {
rb = GetComponent <Rigidbody> ();
}

void FixedUpdate (){
float moveHorizontal = Input.GetAxis ("Horizontal");
float moveVertical = Input.GetAxis ("Vertical");
Vector3 movement = new Vector3 (moveHorizontal, 0.0f, moveVertical);
rb.AddForce (movement * speed);
}
}
[/sourcecode]

No Unity existe uma sequência de chamada de métodos que criam um ciclo de execução dentro do jogo e cada um destes métodos tem o seu objetivo, portanto quando utilizados corretamente fornecem um melhor desempenho e uma maior facilidade de desenvolvimento da aplicação. Considerando isso utilizaremos os métodos Start e FixedUpdate.

O método Start é chamado quando o componente é instanciado e por conta disso é utilizado para armazenar dados e referências utilizados pelos outros métodos da classe, no nosso caso utilizamos para armazenar a referência do recurso rigidbody.

Já o método FixedUpdate é chamado antes dos cálculos relacionados a física serem executados e é recomendado que neste método seja inserida todas as ações relacionadas à física. Portanto nesse método colocamos um código que adiciona uma força ao rigidbody do objeto na direção que o jogador deseja se locomover. É utilizado a estrutura de dados Vector3 para esta operação pela facilidade que ela oferece ao lidar com transformações em um espaço 3D, pois todas elas utilizam sempre um valor associado a cada eixo (3 dimensões).

Testando a Aplicação

Depois de adicionado o rigidbody e o script contendo a movimentação do Player é necessário testar a aplicação. Para isso siga os seguintes passos:

  1. Volte ao Unity
  2. Na view Hierarchy selecione o Player
  3. Na view Inspector localize o recurso referente ao script PlayerController
  4. Informe o valor 10 para speed

  1. Teste a aplicação
    1. Para poder testar a aplicação clique no botão de play na parte superior da janela do Unity
    2. Utilize as setas direcionais do teclado para mover a esfera
    3. Para sair do modo de teste é necessário clicar novamente no botão de play
  2. Caso a velocidade do player não esteja agradável, repita o passo 4 com um novo valor para speed
  3. Salve a cena
    1. Vá ao menu File
    2. Selecione Save Scene
  4. Caso ainda esteja no modo de teste, saia. Caso ele continue ativo não é possível ver o efeito de nenhuma alteração feita

Configurando a Câmera

Como pode ser visto durante o passo 5, a câmera da aplicação está fixa o que atrapalha a jogabilidade. A câmera é um recurso do Unity que captura uma área do mundo que está sendo criado e a mostra para quem estiver jogando, através de customizações é possível criar resultados únicos para o player. Em jogos de terceira pessoa a câmera é colocada como um componente filho do player mas no nosso caso isso não é possível porque nosso objeto sofre transformações em todos os eixos. Então associaremos o player e a câmera através de um script:

  1. Na view Hierarchy selecione a câmera
    1. Na view Inspector na aba Transform altere o posicionamento da câmera para (0,10,-10)
    2. Ainda na aba Transform altere a rotação da câmera para (45,0,0)
  2. Crie um script de nome “CameraController” e o associe a câmera
    1. Caso tenha criado o script através da opção Add Component lembre-se de colocá-lo na pasta Script
  3. Abra o script em algum editor e coloque as seguinte linhas de código:  

[sourcecode language=”csharp”]
using UnityEngine;
using System.Collections;

public class CameraController : MonoBehaviour {

public GameObject player;
private Vector3 offset;

void Start () {
offset = transform.position – player.transform.position;
}

void LateUpdate (){
transform.position = player.transform.position + offset;
}
}
[/sourcecode]

  1. Na view Hierarchy selecione o objeto MainCamera
  2. Na view Inspector vá a aba correspondente ao script
  3. Arraste o componente Player para o campo Player na aba Script

Neste script novamente utilizamos o método Start para instanciar o valor da variável offset que será utilizada posteriormente para atualizar o posicionamento da câmera. Nesse caso utilizamos o método LateUpdate para atualizar o posicionamento da câmera pois este método é chamado após o Update de todos os componentes da cena o que nos garante, que estamos utilizando a posição mais recente do player. Teste novamente a aplicação e veja que agora a câmera acompanha nosso player aonde ele for.

Delimitando a Área do jogo através de muros

No teste anterior também foi possível ver que caso nosso player chegue às bordas do plano, a gravidade o derruba infinitamente. Para evitar isso é necessário criar muros nos limites da área do jogo.

  1. Na view Hierarchy é possível organizar os componentes de forma semelhante ao que fizemos na pasta Assets, para isso basta criar um novo componente que não influencie na cena:
    1. Então vá ao menu GameObject
    2. Selecione Create Empty
    3. Selecione o objeto e vá a view Inspector
    4. Reste as transformações do objeto e o renomeie para Walls
  2. Agora criaremos a primeira parede
    1. Primeiro vá ao menu GameObject nas opções 3D Object e Cube
    2. Altere seu nome para “West Wall”
    3. Selecione o componente, arraste para cima do componente Walls e solte. Com isso o componente West Wall se tornou filho do componente Wall, o que ajuda na organização do projeto e que o componente herde as transformações que o pai tem.
    4. Ainda com o componente West Wall selecionado vá a view Inspector
    5. Restaure suas transformações para os valores default
    6. Altere seu posicionamento para (-10,0,0)
    7. Altere sua escala para (0.5,2,20.5)
  3. Repita o passo 2 para as outras três paredes utilizando os valores abaixo
    1. East Wall
      • Posicionamento em (10,0,0)
      • Escala em (0.5,2,20.5)
    2. North Wall
      • Posicionamento em (0,0,10)
      • Escala em (20.5,2,0.5)
    3. South Wall
      • Posicionamento em (0,0,-10)
      • Escala em (20.5,2,0.5)
  4. O resultado deverá ser o seguinte:

Criando os Coletáveis

Para finalizar iremos criar os coletáveis e adicionar alguns recursos neles para torna-los mais atraentes.

  1. Crie um cubo
  2. Nomeie de “PickUp”
  3. Restaure suas transformações para os valores default
    1. Altere o posicionamento para (0,0.5,0)
    2. Altere a rotação para (45,45,45)
    3. Altere a escala para (0.5,0.5,0.5)
  4. Adicionaremos uma animação ao cubo através de um script
    1. Crie um script de nome “Rotator” e o associe ao componente PickUp
      1. Caso tenha criado o script através da opção Add Component lembre-se de colocá-lo na pasta Script
    2. Abra o script em algum editor e coloque as seguinte linhas de código:  

[sourcecode language=”csharp”]
using UnityEngine;
using System.Collections;

public class Rotator : MonoBehaviour {

void Update () {
transform.Rotate (new Vector3 (15, 30, 45) * Time.deltaTime);
}
}
[/sourcecode]

Neste script utilizamos somente o método Update que é chamado frame a frame para atualizar a cena e nosso caso utilizamos ele para criar um efeito de animação (objeto rodando) através do método Rotate.

  1. Para destacá-lo mais um pouco iremos utilizar um material para alterar a coloração do componente
    1. Na view Project selecione a pasta Material
    2. Crie um material e o nomeie de “PickUp”
    3. Altere o Albedo
      1. R(vermelho) para 255
      2. G(verde) para 255
      3. B(azul) para 0
    4. Associe ao nosso PickUp
  2. Para podermos coletar de forma genérica este objetos será necessário adicionar uma tag exclusiva para eles
    1. Na view Hierarchy selecione o componente de PickUp
    2. Na view Inspector localize a opção Tags
    3. Na opção Tags selecione Add Tag
      1. Na tela que foi aberta clique no símbolo ‘+’
      2. Defina o nome da nova tag como “Pick Up”
    4. Selecione novamente o componente Pick Up
    5. Na view Inspector altere a tag para Pick Up

Utilizando Prefabs

O Unity fornece um recurso chamado prefab que permite que qualquer objeto no Unity seja transformado em um template contendo todas as suas propriedades e características, e posteriormente pode ser replicado infinitas vezes. Caso alguma alteração seja feita no prefab todas as instâncias dele sofreram esta alteração, isso facilita a edição de componentes idênticos de cenários.

    1. Crie uma pasta chamada “Prefab”
    2. Selecione o componente PickUp
    3. Arraste e solte-o sobre a pasta Prefab, com isso o objeto será transformado em um prefab
      1. Observe que na view Hierarchy este componente ficou na coloração azul
    4. Crie um objeto vazio (formato do objeto Walls) e o nomeie de “PickUps”
      1. Restaure as transformações para o valor default
      2. Torne o objeto PickUp filho dele
      3. Utilizando o prefab criado anteriormente, crie outros objetos na cena e os mantenha como filhos de PickUps
    5. Abra o script PlayerController e adicione o seguinte código:

[sourcecode language=”csharp”]
void OnTriggerEnter(Collider other) {
if (other.gameObject.CompareTag ("Pick Up")){
other.gameObject.SetActive (false);
}
}
[/sourcecode]

Este método é chamado quando uma colisão é detectada e verificará se o objeto que colidiu tem a tag “Pick Up”, caso seja verdade o removerá da cena. Vale ressaltar que o valor informado no método CompareTag deve ser exatamente o que está na tag. Teste a aplicação.

Animando Objetos no Unity

Como pode ser visto, ao colidir com os coletáveis eles não desaparecem. Para solucionar isso é necessário modificar algumas configurações do prefab para que ele se torne somente um objeto animado na cena.

  1. Selecione o prefab
  2. Na view Inspector localize a aba Box Collider
  3. Marque a opção Is Trigger
  4. Adicione um componente rigidbody ao prefab
    1. No menu Component selecione a opção Physics e Rigidbody.
    2. Marque a opção Is Kinematic, esta opção faz com que forças da física sejam ignoradas nesse objeto, tornando possível criar animações que reagem a colisões.
  5. Após todas as alterações no prefab, a sua configuração deverá ficar da seguinte forma:

Gerando o executável do Projeto

Com isso todo o jogo foi construído sendo necessário agora criar o executável dele. Para isso:

  1. Salve a cena
  2. No menu File escolha a opção Build Settings

    1. Nesta janela é possível alterar o target da aplicação para qualquer uma das disponíveis
    2. Na opção Player Settings é possível alterar as configurações específicas para cada target

  1. Clique em Build and Run
  2. Escolha um nome para o executável
  3. Teste sua aplicação

Para mais informações:

https://docs.unity3d.com/Manual/Lighting.html

https://docs.unity3d.com/Manual/class-Material.html

https://docs.unity3d.com/Manual/Shaders.html

https://docs.unity3d.com/ScriptReference/Rigidbody.html

https://docs.unity3d.com/Manual/Prefabs.html

https://docs.unity3d.com/Manual/class-Camera.html

Deixe um comentário

O seu endereço de e-mail não será publicado.