Avançar para o conteúdo principal

A unidade em 3D - Unity 3D

Para hoje temos um motor de jogo muito popular, o Unity 3D. Chegou recentemente à versão 4.0 e está melhor do que nunca, ao contrário de outros programas este tem "envelhecido" muito bem.


A versão mais recente apresenta a possibilidade de exportar o nosso jogo para a plataforma Linux, nas versões anteriores só existia a possibilidade de criar jogos para Windows e Mac OS.




O principio deste motor é que o centro do desenvolvimento está nos elementos gráficos e não no código.

Para além disso existe a possibilidade de programar em várias linguagens das quais Javascript, C# e Boo.

O código fica sempre associado aos objetos e molda o comportamento destes reagindo a eventos como o desenho de frames, a colisão ou a criação de objetos.

O Unity dispõe de ferramentas para criar objetos apesar de que para criar gráficos mais elaborados convém utilizar outras ferramentas especializadas como o Blender e importar esses elementos para o nosso projeto.

Cada jogo no Unity pode ter vários níveis sendo representados por cenas que podem representar níveis jogáveis ou menus e cutscenes.

Para este projeto vamos utilizar a versão 3.5.

O jogo começa-se por criar um projeto com esta janela


Ao criar o projeto podemos optar por importar vários pacotes disponíveis com o Unity de origem, neste trabalho vamos criar um programa simples e por isso não importamos nada.

Depois de clicar no botão Create o Unity fecha e abre o novo projeto, cada projeto no Unity fica numa pasta com todos os elementos dentro dessa pasta.

Vamos começar por inserir um plano que será o chão do nosso jogo.

 O resultado desta ação é

Agora um pouco sobre a interface.

Do lado direito temos o Inspector que apresenta as propriedades do objeto selecionado, que neste caso é o plano inserido.

Mais à esquerda temos duas janelas, a de cima apresenta a hierarquia dos objetos da cena, a de baixo apresenta todos os elementos do projeto.

As duas janelas grandes apresentam o projeto em modo de edição e em modo de execução, a de cima é o espaço disponível para manipular os objetos durante a criação do jogo a de baixo representa o que a câmera vê, sim sempre que criamos um projeto novo por defeito é inserido sempre um objeto do tipo Camera que representa o que o jogador vai ver.

Por baixo do menu principal temos


O primeiro botão faz o scroll da cena, também podemos fazer o scroll premindo o botão do meio do rato. O botão da seta permite mover o objetos, tal como as setas que aparecem quando selecionamos um objeto. O terceiro botão permite rodar os objetos e o quarto permite redimensionar.

O botões mais à direita permitem executar e pausar a cena. Não podemos esquecer que as alterações feitas à cena durante a pausa do programa não são gravadas por isso qualquer alteração definitiva deve ser feita quando o programa está parado e não em pausa.

De seguida vamos inserir um Cube, ou melhor vários.
Um cubo vai servir para a base de uma alavanca, por isso temos de o rodar de forma a que fique em forma de cunha.
Assim selecionamos o botão que permite rodar os objetos, referido acima, e rodamos sobre o eixo pretendido.

Depois de o rodar vamos mudar a cor para que seja mais fácil distinguir os objetos e o jogo não fica tão monótono visualmente.

Para mudarmos a cor de um objeto temos de criar um material novo, para isso vamos à barra do projeto e escolhemos Create - Material
De seguida damos um nome ao material, eu vou escolher a cor, neste caso azul, depois, no Inspector mudamos a propriedade Main Color e podemos alterar o Shader para obter efeitos diferentes, eu vou utilizar o Shader Bumped Specular.

O nosso cubo fica assim



O próximo passo é criar a alavanca que vai projetar uma caixa para isso vamos utilizar dois cubes. Primeiro adicionamos um cubo que serve como base e depois um segundo que evita que o objeto a projetar escorregue para trás, este elemento vai ser construído utilizando a possibilidade do Unity em ter objetos hierarquicamente dependentes de outros fazendo com que estes se movam em simultâneo como se fossem só um.
Então aqui vai um cubo com nome alavanca, que foi redimensionado para ter este aspeto.


Agora criamos outro cubo que arrastamos, na barra da hierarquia para cima da alavanca o que faz com que este cubo dependa do anterior. Antes de arrastar devemos colocar o cubo no local pretendido.
O resultado final é este.


Agora quando movemos o cubo denominado alavanca o outro também se move.

Se testarmos o jogo agora nada acontece para que a alavanca tenha um comportamento realista basta adicionar um componente que implementa os cálculos de física nomeadamente a gravidade, as colisões e as forças.

Então com a alavanca selecionada vamos a Component - Physics - Rigidbody.


Se agora testarmos o jogo a alavanca já sofre os efeitos da gravidade.


Agora vamos adicionar mais dois cubos, um que fica na alavanca e que será projetado o outro que vai servir de peso para projetar o anterior.

O primeiro vai se chamar caixa e fica assim.


Não esquecer de adicionar um Rigidbody à caixa para ela ter um comportamento realista.

O segundo cubo fica assim, suspenso sobre a alavanca, neste não adicionamos o Rigidbody porque só pretendemos que ele caia quando o utilizador premir a barra de espaço. Este vai ter o nome peso.


Agora vamos passar ao código, a linguagem de programação a utilizar é Javascript, então na barra do projeto escolhemos Create - Javascript. O nome do ficheiro é controlo. Depois de criado o ficheiro fazemos duplo clique nele e abre o MonoDevelop que o Unity utiliza para compilar o código.

Aqui pretendemos que ao premir a tecla barra de espaço a caixa caia em cima da alavanca então o que vamos fazer é adicionar um Rigidbody à caixa e afinar o massa do objeto para que a distância da projeção seja maior ou menor de acordo como  alvo que pretendemos atingir, que para já ainda não adicionamos.

O código fica assim:

#pragma strict

function Start () {

}

function Update () {

//larga a caixa quando prime espaço
if(Input.GetButtonUp("Jump")){
this.gameObject.AddComponent(Rigidbody);
this.gameObject.rigidbody.mass=50;
}

}

A função Start não utilizamos, esta é chamada uma fez quando o objeto é criado.

A função Update, onde inserimos o código, é chamada por cada frame desenhada assim se o utilizador premiu a tecla e largou adicionamos o componente Rigidbody e aumentamos a massa (peso) para que a força de projeção seja maior. Não testamos a tecla espaço diretamente mas sim o botão Jump que por defeito está associado à barra de espaço, como podemos ver em Edit - Project Settings - Input.

Depois de gravarmos o ficheiro voltamos ao Unity, não é preciso fechar o MonoDevelop, e agora basta arrastar o ficheiro do código para o cube peso.

Ao testar o programa podemos ver que ao largar o peso a alavanca projeta a caixa.

Para tornar o jogo um pouco mais interessante vamos deixar o utilizador posicionar a caixa antes de a deixar cair, para isso voltamos ao MonoDevelop e adicionamos o código:


var horiz : float = Input.GetAxis("Horizontal");

//movimenta na horizontal
this.gameObject.transform.Translate(Vector3(horiz,0,0)*Time.deltaTime);

Este código cria uma variável que lê a deslocação horizontal e aplica à caixa.

A função Update fica assim:


function Update () {
var horiz : float = Input.GetAxis("Horizontal");

//movimenta na horizontal
this.gameObject.transform.Translate(Vector3(horiz,0,0)*Time.deltaTime);
//larga a caixa quando prime espaço
if(Input.GetButtonUp("Jump")){
this.gameObject.AddComponent(Rigidbody);
this.gameObject.rigidbody.mass=50;
}

}

Agora o utilizador pode largar o peso mais longe ou mais perto da base da alavanca projetando a caixa mais perto ou mais longe.

Por fim vamos adicionar um alvo a atingir, mais um cubo. O nome é alvo e a cor vai ser o laranja e não esquecer de adicionar o Rigidbody.



Este cubo vai detetar a colisão com a caixa com o seguinte código:


#pragma strict

var tempo : float = 5.0;
var tempovivo : boolean=false;
var particulas : GameObject;

function Start () {

particulas.GetComponent(ParticleSystem).Clear();

}

function Update () {

if(tempovivo){
tempo=tempo-Time.deltaTime;
if(tempo<=0){
this.gameObject.renderer.active=false;
}
}
}

function OnCollisionEnter(colisao: Collision){

if(colisao.gameObject.name=="caixa"){
tempovivo=true;
particulas.GetComponent(ParticleSystem).Play();
}

}

A função OnCollisionEnter é chamada pelo Unity sempre que acontece uma colisão com o objeto, neste caso só reagimos que o objeto que colidiu foi a caixa. Nesse caso vamos iniciar um temporizador e um sistema de partículas para fazer um efeito especial. Vamos criar o sistema de partículas já a seguir.

Ao iniciar é chamada a função Start que limpa o sistema de partículas.

Em cada frame, caso o temporizador esteja "vivo" descontamos o tempo que passou desde a última frame desenhada e se esgotamos o temporizador faz desaparecer o objeto, neste caso o alvo.

Vamos agora criar o sistema de partículas, para isso no menu GameObject - Create Other - Particle System.


Agora posicionamos o sistema de partículas na mesma posição do alvo e desativamos a opção Play On Awake.

De seguida associamos o novo código ao alvo e por fim só falta associar o sistema de partículas ao código, para isso selecionamos o alvo e na barra Inspector, na parte relativa ao código, existe uma propriedade que não está definida que é a propriedade Particulas para resolver este problema basta arrastar o sistema de partículas da barra da hierarquia para a propriedade no Inspector.


Agora podemos gravar a cena, e organizar o projeto criado pastas para os scripts e para os materiais.

Para publicar o projeto no menu File escolhemos Build Settings e na janela seguinte clicamos no botão Add Current...



Podemos também escolher a plataforma para a qual pretendemos publicar o projeto, por fim clicamos no botão Build e indicamos a pasta de saída.

O projeto e o executável estão aqui.

Comentários

Mensagens populares deste blogue

Vamos fazer um carro com o Unity 3D

Neste artigo vamos fazer um carro, simples, com o Unity 3D. A ideia é utilizar o motor de física do Unity 3D para simular o comportamento do carro. Os passos a seguir são: [1] - Criar um projeto novo

C# IEnumerable e IEnumerator

Neste artigo vamos aprender como utilizar a interface IEnumerator por forma a permitir utilizar um ciclo foreach num conjunto ou coleção de dados. A maior parte das coleções (listas e outras) já implementam a interface, mas neste caso vamos personalizar a maneira como percorremos a lista. Quando utilizamos código assim: foreach(Class c in Collection) { ... } O compilador converte este código em algo assim: IEnumerator cc = Collection.GetEnumerator() while(cc.MoveNext()) { c=(Class)cc.Current; ... } Ao implementar a interface IEnumerable significa que a classe implementa uma versão da função GetEnumerator() que deve devolver uma classe que implemente a interface IEnumerator. Vamos explorar um exemplo. Começamos pela classe client Esta classe permitirá guardar os dados dos clientes, existindo um campo para indicar se o cliente ainda está ativo ou não. De seguida temos uma classe que define uma lista de clientes e que implementa a interface IEnumerable que de

React - Introdução

 Neste post vamos fazer uma breve introdução ao React. React é uma framework javascript e por isso é importante ter conhecimentos desta linguagem de programação para melhor compreender o seu funcionamento. O que é necessário? Para construir páginas com React é necessário ter instalado a framework Node e o seu instalador de packages o npm. Com o Node instalado basta abrir uma janela da linha de comandos, eu aconselho utilizar o novo Windows Terminal ou o Cmder . Na sua linha de comando escolhida execute o comando: npx create-react-app Tutorial01 Este comando vai criar uma pasta com o nome Tutorial01 e instalar dos os ficheiros necessários para construir a sua primeira aplicação React dentro dessa pasta. De seguida entramos na pasta criada com o comando: cd Tutorial01 E iniciamos a aplicação com o comando: npm start Deve conseguir ver uma página com o seguinte aspeto: A partir daqui, até fechar a linha de comando, todas as alterações feitas aos ficheiros da sua aplicação são automaticam