Programando na Unity 3D Engine (Parte 01)€¦ · A linguagem C# C# é uma linguagem de...
13
Transcript of Programando na Unity 3D Engine (Parte 01)€¦ · A linguagem C# C# é uma linguagem de...
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) • – (Subtração) • * (Multiplicação) • / (Divisão) • % (Resto/Módulo) • = (Atribuição simples) • += (Atribuição aditiva) • -= (Atribuição Subtrativa) • *= (Atribuição Multiplicativa) • /= (Atribuição de divisão)
• %= (Atribuição de módulo) • ++ (Incremento) • -- (Decremento) • == (Igualdade) • > (Maior) • < (Menor) • <= (Menor igual) • >= (Maior igual) • != (Diferente) • ! (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:
