Programando na Unity 3D Engine (Parte 01)

Salustiano Rodrigues de Oliveira

saluorodrigues@gmail.com
Sumário
Programando na Unity 3D Engine (Parte 01)............................................................................ 1
GameObject ............................................................................................................................. 3
Script ....................................................................................................................................... 3
Criando Scripts na Unity 3D ...................................................................................................... 4
Analisando o Script................................................................................................................... 5
Executando nosso primeiro Script ............................................................................................ 6
A linguagem C# ........................................................................................................................ 7
Variáveis .............................................................................................................................. 7
Declarando uma variável .................................................................................................. 7
Tipos primitivos ................................................................................................................ 8
Operadores .......................................................................................................................... 9
Modificadores de acesso ...................................................................................................... 9
Estruturas de Controle ....................................................................................................... 10
IF/ELSE .......................................................................................................................... 10`
Tomando decisões complexas (ELSE-IF) .......................................................................... 10
Arrays................................................................................................................................. 11
Estruturas de repetição ...................................................................................................... 11
WHILE ............................................................................................................................ 12
DO WHILE ....................................................................................................................... 12
FOR ................................................................................................................................ 12
FOREACH ........................................................................................................................ 13
GameObject
GameObject é a base de todos os objetos em uma Scene (Cena). De fato, todos os
objetos de uma Scene são um GameObject. Entretanto, GameObjects não fazem nada
sozinhos. Eles precisam de certas características para se tornarem um personagem, um
cenário, uma arma, uma explosão, um veículo, um item, etc. Na verdade, GameObjects são
apenas containers. Eles são caixas vazias onde você pode adicionar diversos Components
(Componentes). Dependendo do objeto que você queira criar, você irá adicionar diferentes
combinações de Components ao GameObject. Você poderá também criar seus próprios
componentes via script.

Todo GameObject possue um Component chamado Transform e não é possível

remove-lo. Todos os Components de um GameObject podem ser visualizados dentro da aba
Inspector. Alguns exemplos de Components:

• Transform: responsável por dimensionar, girar e posicionar o elemento

na cena.
• Mesh Filter: selecionar a malha ou textura que ira renderizar o objeto na cena.
• Mesh Render: responsável por renderizar o componente na cena.
• Box Collider: propriedade de um GameObject de detectar colisões entre
componentes de jogo.

Figura 1 - Visualizando Components na aba Inspector

Script
O Script é um ingrediente essencial em qualquer tipo de jogo. Mesmo os jogos mais
simples precisam de scripts, seja para responder à entrada do jogador ou organizar um evento.
Além disso, Scripts podem ser usados para criar efeitos gráficos, controlar o comportamento
físico de objetos ou até mesmo implementar um sistema de IA (Inteligência artificial)
personalizado para personagens do jogo.
 Na Unity o comportamento de um GameObject é controlado pelos componentes que
estão anexados a eles. Embora os Componentes internos da Unity possam ser muito versáteis,
em diversos cenários precisaremos ir além do que eles podem fornecer para implementarmos
nossos próprios recursos de jogabilidade. A Unity permite que você crie seus próprios
componentes usando scripts. Isso nos permite desencadear eventos, modificar propriedades e
responder a entrada do usuário da maneira que acharmos mais conveniente.

Criando Scripts na Unity 3D

Existem diversas formas para criarmos arquivos de Scripts na Unity. Uma delas é clicar
com o botão direito do mouse dentro da aba Project, depois selecionar Create à C# Script.

Figura 2 - Criando um Script C#

Um novo arquivo será criado dentro do projeto como mostra a figura abaixo:

Figura 3 - Alterando o nome do Script

Podemos renomeá-lo com o nome que quisermos, porém por convenção devemos
utilizar o padrão Pascal Case, onde cada palavra é iniciada com uma letra maiúscula, não
podendo conter espaços em branco entre as palavras assim como caracteres especiais.

Para afins de organização é sempre bom armazenarmos nossos arquivos de Scripts em

uma pasta, neste caso irei chamá-la de Scripts que ficará dentro do diretório Assets.

Figura 4 - Organizando os arquivos na aba Project

 Depois de um duplo clique em cima do arquivo, que deverá ser aberto no Visual Studio
ou em algum outro software de edição de Scripts.

Dica: No Windows podemos ir em Edit à Preferences à External Tools e trocar de software de

edição.

Figura 5 - Alterando o software de edição de scripts

Por padrão o arquivo gerado pela a Unity sempre terá o formato a seguir:

Figura 6 - Script padrão gerado pela Unity

Analisando o Script
A imagem abaixo mostra o modelo de Script padrão da Unity, onde podemos dividi-lo
em 3 partes:

• Em vermelho, temos os namespaces que serão utilizadas em nosso Script;

• Em laranja temos a definição da nossa classe;
• E em azul temos dois métodos que são adicionados por padrão pela própria Unity;

Um problema que surge com o desenvolvimento de aplicações grandes é a organização

de todas as nossas classes. Para evitar que o sistema fique caótico, podemos agrupar classes por
características comuns e dar um nome para cada um desses grupos e esse espaço definido por
um nome é chamado de namespace.
 As duas primeiras linhas do código acima fazem referência a namespaces básicas do C#,
enquanto que a namespace UnityEngine nos dá acesso aos componentes básicos de jogo da
própria Unity. Sempre que precisarmos utilizar algum componente em nosso jogo e este não
estiver localizado dentro de UnityEngine devemos referenciá-lo de forma explicita, como
veremos mais à frente.

Figura 7 - Divindo o Script

A seguir temos a definição da nossa classe MeuPrimeiroScript. Algo importante para

ressaltarmos é que o nome de uma classe deve ser exatamente igual ao nome do seu arquivo
(MeuPrimeiroScript.cs), caso contrário, teremos problemas na execução do nosso código. Em
seguida temos o trecho MeuPrimeiroScript : MonoBehaviour, isto quer dizer que a classe
MeuPrimeiroScript é herdeira da classe MonoBehaviour.

Por ultimo temos os métodos Start() e Update(), que serão discutidos mais afundo
adiante.

Executando nosso primeiro Script

Para executarmos o nosso primeiro script, o famoso “Hello World!”, primeiro devemos
escrever o seguinte trecho de código como mostra a figura abaixo:

Figura 8 - Hello World!

Para executá-lo devemos voltar para a janela do Unity. Porém antes disso devemos associá-lo a
um GameObject. Crie em nosso projeto um GameObject vazio (GameObject à Create Empty),
depois arraste o arquivo de script para dentro da aba Inspector do GameObject recém criado.
 Figura 9 - Adicionando um script a um GameObject

Para podermos visualizarmos qualquer informação impressa pelo comando print,

devemos habilitar (caso não esteja) a janela de console da Unity, acessando Window à Console.

Agora é só clicar em Play e visualizar a aba console.

Figura 10 - Visualização da aba console

A linguagem C#
C# é uma linguagem de programação, multiparadigma, de tipagem forte, desenvolvida
pela Microsoft como parte da plataforma .NET. A sua sintaxe orientada a objetos foi baseada no
C++, mas inclui muitas influências de outras linguagens de programação, como Object Pascal e,
principalmente, Java.

A linguagem de programação C# pode parecer complicada no início, mas na realidade,

existem duas partes básicas que formam sua base, que são:

• Variáveis

• Métodos

Variáveis
Tecnicamente é uma pequena seção da memória do seu computador, que irá armazenar
qualquer informação que lhe for passada. Por exemplo, enquanto um jogo está sendo
executado, seu computador fica monitorando as informações que deverão ser armazenadas,
como seu tipo e valor.

Declarando uma variável

Na declaração de uma variável, devemos dizer seu tipo e, além disso, qual é o nome que
usaremos para referenciá-la no texto do programa. Para declarar uma variável do tipo inteiro
que representa o número de pontos de vida do jogador, utilizamos o seguinte código:
 Figura 11 - Variável PontosDeVida

Dica: Sempre que for nomear uma variável, um método ou um novo Script, sempre tente colocar
um nome que melhor o represente. Evite colocar nomes como x ou b1. Prefira nomes como
MovimentacaoDoJogador, velocidadeDoInimigo ou RotacaoDaCamera.

Tipos primitivos
As variáveis guardam informações de um tipo específico. Podemos, por exemplo,
guardar um número inteiro representando a quantidade de pontos de vida de um jogador, um
texto para representar o nome de um personagem ou um número real para representar a
velocidade atual de um veículo.

Os tipos primitivos mais comuns no C# são:

• int –armazena valores inteiros;

• float –armazena valores decimais;
• string –armazena caracteres;
• bool – armazena os valores true ou false;

Abaixo veremos uma lista com todos os tipos primitivos do C#.

Operadores
O C# fornece muitos operadores, que são símbolos que especificam as operações
(matemática, indexação, chamada de função, etc.) para executar em uma expressão. Segue
abaixo alguns desses operadores:

• + (Adição) • %= (Atribuição de módulo)

• – (Subtração) • ++ (Incremento)
• * (Multiplicação) • -- (Decremento)
• / (Divisão) • == (Igualdade)
• % (Resto/Módulo) • > (Maior)
• = (Atribuição simples) • < (Menor)
• += (Atribuição aditiva) • <= (Menor igual)
• -= (Atribuição Subtrativa) • >= (Maior igual)
• *= (Atribuição Multiplicativa) • != (Diferente)
• /= (Atribuição de divisão) • ! (Negação)

Modificadores de acesso
A palavra reservada public indica que essa variável pode ser vista e acessada
dentro do painel Inspector da própria Unity (figura abaixo), como também pode ser acessada
por outros scripts.

Porém nem todas as variáveis necessitam ser públicas. Se não houver necessidade de
alterar o valor de uma variável no painel Inspector ou de ser acessado a partir de outros scripts,
não faz sentido colocarmos essa variável como publica, nesse caso utilizaremos o modificador
de acesso private.

Dica: Se você não indicar explicitamente se uma variável será pública ou privada, por padrão, a
variável será, implicitamente, private em C#. É uma boa prática de codificação indicar
explicitamente se uma variável será pública ou privada.
Estruturas de Controle
O mecanismo fundamental da programação é tomar decisões. No cotidiano, fazemos
centenas e possivelmente milhares de decisões por dia. Eles podem ser os resultados de
perguntas simples, como "Preciso de um guarda-chuva hoje?" ou "Posso colocar mais açúcar no
meu café?". Na programação esse tipo de decisão é representado pelo comando if/else.

IF/ELSE
O comando if/else funciona como uma maneira para descrevermos ao computador,
como o código deve ser executado. Por exemplo, a pergunta "está chovendo?" é a uma
condição. Ao planejar seu código, você deve sempre quebrar a tomada de decisões em
perguntas simples que podem ser respondidas apenas por um simples "sim" ou "não". Caso
esteja chovendo, levarei o meu guarda-chuva, se não o deixarei em casa.

Figura 12 - IF/ELSE

Tomando decisões complexas (ELSE-IF)

A expressão else if é uma expressão que você pode adicionar após o bloco de código
pertencente a primeira declaração if. Vamos analisar um outro exemplo.

Imagine que você está monitorando uma rodovia e precisa verificar o limite de
velocidade dos carros que a atravessam, baseado na velocidade atual do veículo você pode
multa-los caso estejam acima do limite de velocidade, apenas adverti-los caso estejam muito
abaixo do limite ou parabeniza-los caso estejam na faixa adequada.

Arrays
Um array armazena uma coleção sequencial de valores do mesmo tipo, nos termos mais
simples. Podemos usar arrays para armazenar listas de valores em uma única variável. O
tamanho de um array é definido durante a sua criação e não poderá ser modificado. O primeiro
valor de um array estará sempre armazenado na posição 0 e o seu último valor estará na posição
equivalente ao seu tamanho total menos 1.

Estruturas de repetição
Estruturas de repetição permitem executar mais de uma vez um mesmo trecho de
código. Trata-se de uma forma de executar blocos de comandos somente e sob determinadas
condições, mas com a opção de repetir o mesmo bloco quantas vezes for necessário. As
estruturas de repetição são úteis, por exemplo, para repetir uma série de operações
semelhantes que são executadas para todos os elementos de uma lista ou de uma tabela de
dados, ou simplesmente para repetir um mesmo processamento até que uma certa condição
seja satisfeita.

WHILE
O while é a estrutura de repetição mais simples. Ele repete a execução de um bloco de
sentenças enquanto uma condição permanecer verdadeira. Na primeira vez que a condição se
tornar falsa, o while não repetirá a execução do bloco, e a execução continuará com a sentença
ou comando que vem logo após o bloco do while, na sequência do programa.

DO WHILE
Esta estrutura tem um comportamento muito semelhante ao while, com uma diferença
crucial: a condição é verificada após executar o bloco de instruções correspondente.

FOR
Na maioria dos casos, algoritmos necessitam executar um bloco de sentenças por um
número específico de vezes. Frequentemente, utiliza-se uma variável para controlar o número
de repetições. Já aprendemos como fazer isso usando o while e o do...while. Estas situações
sempre apresentam uma variável contadora e as quatro etapas seguintes:

• Inicialização: Atribui um valor inicial à variável contadora.

• Teste: Verifica uma condição antes de decidir se executará o bloco de sentenças. caso a
condição seja falsa, interrompe as repetições.
 • Execução: Executa o bloco de sentenças.
• Atualização: Atualiza a variável contadora para o próximo valor.

Um for sempre está acompanhado de uma variável contadora que armazena quantas
vezes o bloco de sentenças do for deve ser executado. Em seguida avalia a expressão, que
determina se o valor da variável contadora está dentro do limite desejado. Caso positivo, o bloco
de sentenças é executado e, em seguida, é executada a atualização, que altera o valor da variável
contadora. O processo se repete avaliando novamente a expressão.

FOREACH
O loop foreach é muito simples de usar. Ele também possui a sintaxe mais simples.
Usamos a palavra-chave foreach seguida de parênteses neste loop. Dentro dos parênteses, você
deve especificar o tipo de dados que você deseja iterar dentro do seu loop. Escolha um nome
de variável de elemento único. Você pode nomeá-lo da forma que quiser. Esse nome é usado
para acessar essa variável dentro do bloco de loop principal. Após o nome, escrevemos a
palavra-chave in, e em seguida o nome da variável do array ou lista, conforme mostrado abaixo: