Upload
rafael-morais
View
273
Download
2
Embed Size (px)
Citation preview
1 Fábio Souza – [email protected] – Tutorial em Unity3D
Sumário
Introdução à criação de scripts com Unity .................................................................................................................. 2
1. Objetivos deste tutorial ....................................................................................................................................... 3
2. Pré-requisitos ...................................................................................................................................................... 3
3. Conversões do Unity............................................................................................................................................ 3
4. A entrada do jogador .......................................................................................................................................... 3
Nosso primeiro script. ............................................................................................................................................. 4
Colocar o script ................................................................................................................................................... 5
deltaTime ............................................................................................................................................................ 5
5. Conectando Variáveis ......................................................................................................................................... 6
6. Acessando Componentes .................................................................................................................................... 7
Fazê-lo com o código .......................................................................................................................................... 8
7. Instanciar .......................................................................................................................................................... 10
8. Depuração ......................................................................................................................................................... 11
Log .................................................................................................................................................................... 11
Watch................................................................................................................................................................ 12
9. Tipos comuns de script ...................................................................................................................................... 12
FixedUpdate() ................................................................................................................................................... 13
Awake() ............................................................................................................................................................. 13
Start() ................................................................................................................................................................ 13
OnCollisionEnter() ............................................................................................................................................. 13
OnMouseDown() ............................................................................................................................................... 13
OnMouseOver()................................................................................................................................................. 13
2 Fábio Souza – [email protected] – Tutorial em Unity3D
Introdução à criação de scripts com Unity
Scripting é uma parte essencial da
Unity que define o comportamento do
seu jogo. Este tutorial irá introduzir
os fundamentos da programação de
scripting utilizando Javascript.
Não é necessário conhecimento de
JavaScript para seguir este tutorial.
Tempo para concluir: 2 horas.
Autor: Graham McAllister
Tradutor: Fábio Souza
3 Fábio Souza – [email protected] – Tutorial em Unity3D
1. Objetivos deste tutorial
Script define um comportamento de jogos (ou regras) na Unity.
A programação recomendada para a Unidade é Javascript, C # ou Boo.
Este tutorial irá cobrir os fundamentos de scripting na Unity e também introduzir
elementos chave da Interface (API).
Você pode pensar da API como código que já foi escrito para lhe permite concentrar em
seu jogo e também acelera o tempo de desenvolvimento.
Uma boa compreensão dos princípios básicos é essencial para aproveitar o poder pleno
da Unity.
2. Pré-requisitos
Este tutorial concentra-se no elemento script da Unity, assumimos que você já está
familiarizado com a interface Unitys. (Se não você deve ler o tutorial da Interface Unity).
A fim de tornar o script mais fácil de entender, é preferível ter um editor de código que
tenha uma sintaxe com suporte a JavaScript. Isso significa que são palavras reservadas (sintaxe
usada pelo próprio Javascript) com cor diferente da definida pelo usuário. Um desses editor é
SubEthaEdit.
NB: Neste tutorial qualquer texto que seja executado pelo usuário começa com um “-“.
3. Conversões do Unity
Antes de começar, vale a pena mencionar algumas convenções na Unity.
Variáveis - começam com uma letra minúscula. As variáveis são usadas para armazenar
informações sobre todos os aspectos de um jogos.
Funções - começam com uma letra maiúscula. Funções são blocos de código que são
escritos uma vez e pode ser reutilizado quantas vezes for necessário.
Classes - começam com uma letra maiúscula. Estes podem ser pensados como conjuntos
de funções.
Dica: Ao exemplo de código a leitura ou a API da Unity, prestar muita atenção para a
primeira letra das palavras. Isso ajudará você a compreender melhor a relação entre os objetos.
4. A entrada do jogador
O nosso primeiro programa permitia que o usuário se deslocasse no mundo simples.
Definindo o cenário:
4 Fábio Souza – [email protected] – Tutorial em Unity3D
- Inicia o Unity. Em primeiro
lugar, vamos criar uma superfície
para o usuário caminhar. Para
criar a superfície pode ser
utilizado uma forma de cubo
achatado.
- Crie um cubo e sua escala suas
dimensões x, y, z para 5, 0.1, 5,
respectivamente, ele agora deve
assemelhar a um apartamento
grande plano. Renomeie esse
objeto para Plane na Vista
Hierarquia.
- Crie um segundo cubo e coloque-o no centro deste plano. Se você não consegue ver os objetos
na Visao do seu jogo alterar a câmara principal para está visível. Mude o nome do objeto para
Cube1.
- Você também deve criar um ponto de luz e colocá-lo acima dos cubos de modo que
fiquem visível.
- Salve a cena selecionando Arquivo > Salvar como e dê um nome ao jogo.
Nosso primeiro script.
Está pronto para iniciar a programação de jogos? Vamos permitir que o jogador se mova
em todo o mundo do jogo, controlando a posição da câmera principal. Para isso vamos escrever
um script que irá ler a entrada do teclado, então associamos o script à câmara principal (mais
sobre isso veremos na próxima seção).
- Criaremos um script vazio. Selecione o menu Assets > Create > Javascript e renomeie
para Move1 no painel Project.
- Dê um duplo clique sobre o script Move1 e irá abrir a função Update() já inserido (este
é o comportamento padrão), vamos inserir nosso código dentro dessa função.
Qualquer código que você insere dentro da função Update() é executado a cada frame.
Para mover um objeto de jogo na Unity precisamos alterar a posição dos seus Assets nas
funções transform , e Translate pertencente ao transformar a vontade vamos fazer isso. A
function Translate possui 3 parametros, x, y e z para movimentar. Como queremos controlar o
GameObjects câmara principal com as teclas do cursor, simplesmente anexamos o código para
determinar se as teclas do cursor estão sendo pressionadas para os respectivos parâmetros:
5 Fábio Souza – [email protected] – Tutorial em Unity3D
function Update ()
{
transform.Translate(Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical"));
}
A função Input.GetAxis() retorna valores entre -1 e 1, por exemplo, no eixo horizontal,
O cursor para esquerda move a chave mapa -1 e o direito mapa 1.
Como não estamos interessados em mover a câmara no eixo y(para cima) então o
parâmetro é 0.
. O eixo horizontal e vertical são pré-definidos nas configurações de entrada, os nomes e
as teclas mapeadas para eles podem ser facilmente alterados em Edit > Project Settings >Input.
- Abra o Javascript Move1 e digite o código acima, preste muita atenção nas letras.
Salve o script e fecha o editor.
Colocar o script
Agora que o nosso primeiro script está escrito, como é que podemos dizer para a Unity
que nosso GameObjects deve ter este comportamento? Tudo o que temos a fazer é anexar o
script ao GameObjects que queremos que apresenta esse comportamento.
- Para fazer isso, clique sobre o objeto que deseja que tenha este comportamento no
script. No nosso caso, esta é a câmera principal, e você pode selecioná-lo tanto no painel
hierarquia ou na visualização da cena.
- Em seguida clique no menu Components > Scripts > Move1. Isso irá atribui o script
para a câmera, você deve observar que o componente Move1 agora aparece no painel Inspector
para a câmara principal.
Dica: Você pode também atribuir um script para um objeto do jogo, arrastando o script a
partir do painel Project para o Objeto na visão da cena.
- Execute o jogo (pressione o ícone de reprodução), você deve ser capaz de mover a
câmera principal, com as teclas do cursor ou W, S, A, D.
Você deve ter notado que a câmera se moveu muito rápido, vamos olhar a melhor
maneira de. controlar a velocidade da câmera.
deltaTime
Como o código anterior está dentro da função Update a câmera se movia a uma
velocidade medida em metros por frame. É melhor, entretanto, assegurar que o seu
GameObjects move no ritmo mais previsível de metros por segundo. Para conseguir isso, basta
multiplicar o valor retornado da função Input.GetAxis() pelo Tempo deltaTime e também pela
velocidade que nós queremos passar por segundo:
6 Fábio Souza – [email protected] – Tutorial em Unity3D
var velocidade = 5.0;
function Update () {
var x = Input.GetAxis("Horizontal") * Time.deltaTime * velocidade;
var z = Input.GetAxis("Vertical") * Time.deltaTime * velocidade;
transform.Translate(x, 0, z);
}
- Atualize o script Move1 com o código acima.
Observe aqui que a variável velocidade está declarada fora da função Update(), este é
uma variável chamada exposta, ela irá aparecer na área de inspetor de qualquer GameObjects
que o script está anexado (a variável fica exposta ao GUI Unity).
Expor as variáveis é útil quando o valor precisa ser refinado para obter o efeito
desejado, isto é muito mais fácil do que mudar o código.
5. Conectando Variáveis
Conectando variáveis através do GUI Unity é muito
poderoso pois ele permite que as variáveis normalmente
atribuído no código seja feito através de arrastar e soltar
na GUI Unity. Isto permite uma rápida e fácil
prototipagem de idéias. Como variáveis de ligação é feita
através do GUI da Unity, sabemos que temos sempre
necessidade de expor uma variável em nosso código de
script para que possamos atribuir o parâmetro na View
Inspector.
Vamos demonstrar o conceito de ligação de variáveis através da criação de uma luz spot
que seguirá o jogador (Câmara principal) enquanto movemos.
- Adicione um spotlight para a cena. Mova se necessário para próximo da câmara
principal, e renomeie para LuzSpot.
- Adicione um novo Javascript e renomeie para Seguir.
Vamos pensar o que queremos fazer. Queremos que a LuzSpot sigua a nossa câmara
principal, ou seja estará sempre iluminando onde a câmara estiver olhando. Há uma função na
Unity para fazer isso, que é a transform.LookAt().
Se você estava começando a pensar como fazer, e já imaginando um monte de código,
então basta lembrar sempre de verificar a API da Unity para uma função que já existe.
Poderíamos também fazer um bom palpite em olhar na seção de ʻtransformʼ da API, como
estava interessado em alterar a posição ou rotação de um objeto de jogo.
7 Fábio Souza – [email protected] – Tutorial em Unity3D
Agora chegamos à secção variáveis de ligação, o que usamos como parâmetro para
LookAt()? Poderíamos codificar um objeto de jogo, mas sabemos que queremos atribuir a
variável através do GUI, para usar apenas uma variável de exposição (do tipo Transform).
Nossa script Seguir.js deve ficar assim:
var alvo : Transform;
function Update () {
transform.LookAt(alvo);
}
- Coloque o script para a LuzSpot e observe que o componente é adicionado, e a
variável “alvo” é exposto.
- Com a LuzSpot selecionada, arraste a câmara principal do painel hierarquia para cima
da variável “alvo”, fazendo com que a LuzSpot siga a câmara principal, ou seja, a LuzSpot
agora seguirá a câmara principal. Se quiséssemos que o foco seguisse um Objeto diferente,
poderia simplesmente arrastar o Objeto diferente para cima da variável “alvo” (desde que o
Objeto seja do tipo Transform).
- Rode o jogo. Se você assistir ao visualizar a cena, você deverá ver uma luz ao redor da
Câmara principal. Você pode mudar a posição da LuzSpot para melhorar o efeito.
6. Acessando Componentes
Como um objeto de jogo pode ter vários scripts (ou outros componentes) ligados a ele, é
às vezes necessário acessar os componentes de outras funções ou variáveis. A unity permite
fazer isto com a função GetComponent().
Vamos agora criar uma luz para iluminar o Cubo1 sempre que se pressionar a tecla
espaço e pressionando a tecla Ctrl do lado esquerdo a luz volta a acompanhar a câmera.
Para fazer isso primeiramente devemos saber o que queremos:
1. Detectar quando a tecla espaço for pressionada.
2. Quando espaço foi pressionado iluminar o Cube1. Como fazemos isso?
Bem, no script Seguir criado anteriormente, contém uma variável chamada "alvo", cujo
valor determina qual objeto deve ser iluminado. Precisamos definir um novo valor para este
parâmetro. Nós podemos codificar o valor para o cubo (veja como fazer isso mais tarde),
sabemos que atribuir direto a variável utilizando GUI é mais fácil.
- Crie um novo Javascript e renomeie para Mudar. Adicione o seguinte código para o
script Mudar.js:
8 Fábio Souza – [email protected] – Tutorial em Unity3D
var mudarObjetivo : Transform; //Variável para adicionar o Cubo1
var mudarObjetivo1: Transform; //Variável para adicionar a Câmera
function Update () {
if (Input.GetButtonDown("Jump"))
GetComponent(Seguir).alvo = mudarObjetivo;
if (Input.GetButtonDown("Fire1"))
GetComponent(Seguir).alvo = mudarObjetivo1;
}
Jump: foi definido pelo Unity para ser a tecla Espaço.
Fire1: foi definido para ser a tecla Ctrl esquerda.
Veja como foi definido estes nomes no menu EDIT > PROJECT SETTINGS > INPUT veja no painel Inspector.
Seguir: é o nome do Script anterior
Alvo: é o nome da variável pertencente ao script.
Observe em particular como Seguir é o parâmetro para GetComponent(), que retorna
uma referência ao script criado anteriormente de nome Seguir onde podemos usar para acessar a
sua variável "alvo".
- Adicione o script Mudar para a LuzSpot e atribua o Cubo1 ao MudarObjetivo e
Camera para o MudarObjetivo1, no painel Inspector.
- Execute o jogo. Movimente-se e verifique se a luz te segue como de costume, em
seguida, pressione a barra de espaço e a luz deve concentrar-se no Cube1, em seguida pressione
Ctrl esquerdo e verifique.
Fazê-lo com o código
Anteriormente no tutorial, mencionei que seria possível atribuir as variáveis através do
código (ao contrário do GUI da Unity), vamos dar uma olhada como você faria isso.
Lembre-se que isto é só para comparação, atribuir variáveis através da interface gráfica
é a abordagem recomendada.
O problema é que estavam interessados em como foi feito anteriormente, então vamos
direcionar a luz para o Cube1 quando a tecla de espaço for pressionada.
Nossa solução foi expor uma variável no script Mudar, em seguida atribuido a tecla
espaço para o Cube1 a partir da GUI Unity. Existem duas maneiras principais de fazer isso no
código:
9 Fábio Souza – [email protected] – Tutorial em Unity3D
1. Use o nome do objeto de jogo.
2. Use a tag do objeto de jogo.
1. Usando nome do GameObjects
Um GameObjects podem ser renomeado e vistos no modo de hierarquia. Para usar este
nome com o código devemos usá-lo como um parâmetro na GameObject. Função Find().
Portanto, se queremos o botão de ESPAÇO para mudar o foco principal da câmera para Cubo1.
Crie um novo Script e renomeie para Move1, o código é a seguinte:
function Update(){
if (Input.GetButtonDown(“Jump”))
{
var novoAlvo = GameObject.Find(“Cubo1”).transform;
GetComponent(Seguir).alvo = novoAlvo;
}
}
Siga o mesmo procedimento anterior, adicione o Script Move1 para a LuzSpot.
Clicando na LuzSpot arraste o script para o painel Inspector da LuzSpot.
Veja que nenhuma variável está exposta, pois nomeamos diretamente no código. Para
mais informações de como utilizar a função Find() veja o API.
2. tag do GameObjects
Uma tag do GameObjects é uma string que pode ser usada para identificar um
componente. Para ver as tags embutidas clique no botão Tag no Inspector, você também pode
criar sua própria tag. A função para localizar um componente com uma tag específica é
GameObject.FindWithTag() que recebe uma string como parâmetro. Nosso código completo
para fazer isto é:
function Update(){
if (Input.GetButtonDown(“Jump”))
{
var novoAlvo = GameObject.FindWithTag(“Cubo”).transform;
GetComponent(Seguir).alvo = novoAlvo;
}
}
Creio que esta tag (Cubo) não está definida no Inspector. Portanto vamos cria-la.
Selecione o GameObject Cubo1 e no painel Inspector clique no botão da tag, clique add Tag...,
no painel seguinte digite o novo nome em nosso caso Cubo dê enter, selecione novamente o
Cubo1 e mude para tag Cubo, nesta sequência.
10 Fábio Souza – [email protected] – Tutorial em Unity3D
1) 2) 3)
Remova o script anterior da LuzSpot e adicione este novo script. Roda o jogo e veja que
quando pressionamos a tecla enter a Luz é direcionada para o Cubo1.
7. Instanciar
Muitas vezes é necessário criar objetos em tempo de execução (quando o jogo está
sendo jogado). Para fazer isso, usamos a função Instantiate function.
Vamos mostrar como funciona. Para instanciar (criar) um novo GameObject cada vez
que o usuário pressionar o botão de disparo (ou o botão esquerdo do mouse ou CTRL esquerdo
no teclado, por padrão).
Então o que queremos fazer? Queremos que o usuário possa movimentar como de
costume, e quando pressionar o botão de disparo, instanciar um novo objeto. Existe algo a
pensar:
1. Qual objeto que vamos instanciar?
2. Onde é que vamos instanciá-lo?
Quanto a qual objeto instanciar, a melhor maneira de resolver isso é expor uma variável.
Isso significa que podemos indicar qual objeto instanciar usando arrastar e soltar para
atribuir um objeto do jogo para essa variável.
Quanto a onde instanciá-lo, queremos criar o GameObject onde a Câmara principal está
localizado no momento, sempre que o botão de disparo for pressionado.
A função Instanciar utiliza três parâmetros: (1) o objeto que queremos criar, (2) a
posição do objeto3D e (3) a rotação do objeto.
O código completo para fazer isso é a seguinte (Criar.js):
11 Fábio Souza – [email protected] – Tutorial em Unity3D
var novoObjeto : Transform;
function Update() {
if (Input.GetButtonDown(“Fire1”))
{
Instantiate(novoObjeto, transform.position, transform.rotation);
}
}
Não esqueça que transform.position e transform.rotation são a posição e rotação da
transformação que o script está associado, no nosso caso, esta será a câmara principal.
No entanto, quando um objeto é instanciado, é usual que esse objeto seja um pré-
fabricado. Então vamos tornar o Cube1 em um Prefab.
- Em primeiro lugar, vamos criar um Prefab vazio. Selecione Assets > Create > Prefab.
Renomeie esse Prefab para PCubo.
- Arraste o Cube1 do painel Hierarquia para o Prefab PCube do painel Project. Observe
o ícone do prefab.
Agora podemos criar o nosso código Javascript.
- Se não criou crie o código Javascript acima e renomeie para Criar.
- Coloque este script para a câmera principal e atribua o Prefab PCubo para a variável
novoObjeto.
- Jogue o jogo e movimenta-se como de costume. Clique com o botão esquerdo do
mouse ou pressione Ctrl esquerdo,você deve notar um novo cubo aparecendo.
8. Depuração
A depuração é a habilidade de encontrar e corrigir os erros comuns em seu código (ok,
vamos chamá-los de erros!). Unity oferece ajuda através da depuração da classe, utilizando a
função Debug.log ().
Log
A função Log () permite ao usuário enviar uma mensagem para o console do Unity. Isto
serve para:
1. Provar que uma determinada parte do código será alcançada em tempo de execução.
2. Relatar o status de uma variável.
Vamos então usar a função Log() para enviar uma mensagem para o console da Unity
quando o usuário clicar no botão de fogo.
12 Fábio Souza – [email protected] – Tutorial em Unity3D
- Abra o script Criar e adicione a seguinte linha após o código de instanciar dentro do
bloco if:
Debug.Log("Cubo Criado!");
- Execute o jogo e clique no botão de fogo, você deve ver uma linha aparecem na parte
inferior da Unity dizendo "Cubo criado", você pode clicar no link para examinar o Console do
Unity.
Watch
Outro recurso útil para a depuração está expondo uma variável privada. Isso torna uma
variável visível no painel Inspector quando o modo Debug é selecionada, mas não pode ser
editado.
Para demonstrar isso, vamos expor uma variável privada para contar o número de cubos
que foram instanciado.
- Abra o script Criar novamente e adicione duas linhas:
(1) Adicione uma variável privada chamada contarCubo.
(2) Incremente essa variável sempre que um cubo for instanciado.
O código completo é o seguinte (Create.js):
var novoObjeto : Transform;
public var contarCubo = 0;
function Update() { if (Input.GetButtonDown(“Fire1”)) { Instantiate(novoObjeto, transform.position, transform.rotation);
Debug.Log(“Cubo Criado!”); contarCubo ++; } }
- Selecione a câmera e execute o jogo. Clique no botão de fogo para criar alguns cubos.
Observe no Inspector e veja como a variável contarCubo é incrementado sempre que um novo
cubo é instanciado.
9. Tipos comuns de script
Sempre que um Javascript novo é criado, por padrão, ele contém uma função Update().
Esta seção irá discutir outras opções mais comuns disponíveis, basta substituir o nome da
função Update () por um da lista abaixo.
13 Fábio Souza – [email protected] – Tutorial em Unity3D
FixedUpdate()
Código colocado dentro dessa função é executada em intervalos regulares (um framerate
fixo). Esse tipo de função é usado na aplicação de forças para um Rigidbody.
/ / Aplicar uma força para cima para o corpo rígido de todos os quadros
function FixedUpdate () {
rigidbody.AddForce (Vector3.up);
}
Awake()
Código que estiver aqui dentro é chamado quando o script é inicializado.
Start()
Isso é chamado antes de qualquer função Update(), mas depois de Awake (). A
diferença entre as funções Start () e Awake() é que a função start () só é chamado se o script
está habilitado (se sua opção for ativada no painel Inspector).
OnCollisionEnter()
Código aqui dentro é executado quando o objeto do jogo deve colidir com outro objeto
de jogo.
OnMouseDown()
Código aqui dentro é executado quando o usuário move o mouse sobre um objeto de
jogo que contém uma GUIElement ou Collider e executa um clique.
/ / Carrega o nível chamado "SomeLevel" como uma resposta
/ / Para o usuário clicar sobre o objeto
function OnMouseDown () {
Application.LoadLevel ("SomeLevel");
}
OnMouseOver()
Código aqui dentro é executado quando o mouse passa sobre um objeto de jogo, que
contém um GUIElement ou Collider.
// Fades o componente vermelho do material a zero
// Quando o mouse está sobre a malha
function OnMouseOver () {
renderer.material.color.r -= 0.1 * Time.deltaTime ;
}
Verifique a API da Unity para obter mais informações sobre todas essas funções.