Unity Script

13
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

Transcript of Unity Script

Page 1: Unity Script

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

Page 2: Unity Script

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

Page 3: Unity Script

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:

Page 4: Unity Script

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:

Page 5: Unity Script

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:

Page 6: Unity Script

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.

Page 7: Unity Script

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:

Page 8: Unity Script

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:

Page 9: Unity Script

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.

Page 10: Unity Script

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):

Page 11: Unity Script

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.

Page 12: Unity Script

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.

Page 13: Unity Script

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.