Pegar todas as referências de um Script/Componente em uma cena

Em JS:

var arrayDeScripts : nomeDoScript [] = FindObjectsOfType(nomeDoScript );

Em C#:

arrayDeScripts[] nomeDoScript = FindObjectsOfType(typeof(nomeDoScript )) as nomeDoScript [];

Os dois códigos fazem exatamente a mesma coisa, a diferença é apenas na sintaxe.  

Feito isso você pode fazer um For e realizar alguma tarefa com cada um dos Scripts/Componentes, por exemplo (C#):

for (int i = 0; i < arrayDeScripts.Length; i++) {

                 arrayDeScripts[i].enabled = false;

          }


No exemplo acima o resultado sera a desabilitação de todos os Scripts nomeDoScript de todos os objetos da cena atual.

Ler mais...

Efeito de transição fade in e fade out na Unity

Olá pessoal, neste post irei mostrar um script que é capaz de fazer um efeito muito interessante de transição fade in e fade out na Unity.

O efeito de Fade é basicamente uma transição suave entre duas imagens com a opacidade de uma diminuindo até se tornar invisível e revelando a de baixo, neste caso a imagem do efeito será preta no tamanho 1x1.

Como a imagem é toda preta nós não precisamos que ela tenha o tamanho da tela, o que vamos fazer é escalona-la, isso é simples basta utilizar o método:

function OnGUI() {
      GUI.DrawTexture(Rect(0, 0, Screen.width, Screen.height), fadeOutTexture);
}

O script .js final ficou assim:

public var fadeOutTexture : Texture2D;
public var fadeSpeed = 0.3;

var drawDepth = -1000;
private var alpha = 1.0;
private var fadeDir = -1;

function OnGUI() {

alpha += fadeDir * fadeSpeed * Time.deltaTime;
alpha = Mathf.Clamp01(alpha);

GUI.color.a = alpha;

GUI.depth = drawDepth;

GUI.DrawTexture(Rect(0, 0, Screen.width, Screen.height), fadeOutTexture);

}

function fadeIn(){
fadeDir = -1;
}

function fadeOut(){
fadeDir = 1;
}

function Start(){
alpha=1;
fadeIn();
}

Simplesmente adicione esse script a sua camera ou a um game object, coloque a textura do fade manualmente e chame fadeIn() ou fadeOut() quado quiser o efeito.

Só lembrando que fadeIn() vai do preto para transparente e fadeOut()  de transparente para preto.

Vale a pena dar uma olhada em: http://wiki.unity3d.com/index.php?title=FadeInOut

Ler mais...

Mudar material / textura de um objeto via código na Unity

Muitas vezes precisamos alterar o material / textura de um game object via código em tempo de execução durante nosso jogo.

É muito simples fazer isso, veja só:

// Primeiramente precisamos criar um script .js, declaramos também 2 variáveis:

var material1: Material;
var material2: Material;

// A variável material1 corresponde ao material padrão do nosso objeto e a material2
// corresponde ao material que desejamos aplicar ao game object em tempo de execução.

function Start () {
material1 = transform.renderer.material;
}

// No método Start() que é o primeiro a ser chamado em nosso script, definimos material1
// com a textura 'padrão' ou 'original' do nosso objeto.

// Agora precisamos definir de acordo com nosso projeto qual será o 'gatilho' que vai disparar
// a troca de material, neste caso vou utilizar o método abaixo:

function OnMouseExit () {
transform.renderer.material = material2;
}

// O método OnMouseExit () é chamado quando o mouse 'sai' de cima do nosso game object
// Dentro dele utilizo o comando 'transform.renderer.material = material2'
// Esse comando é responsavel por alterar o material do objeto, no caso, vai alterar o material
// do objeto ao qual esse script está anexado, fácil não? :)

Caso você queria que o objeto retorne a sua textura original basta utilizar a mesma linha de comando anterior só que agora atribuindo o material1:

transform.renderer.material = material1;

Importante: Neste script você deve inserir o material2 manualmente quando tiver anexado esse script ao seu game object, porém se você quiser carregar em tempo de execução basta inserir essa linha dentro do método Start():

material2 = Resources.Load("Nome do Material", Material);

Esse método carrega um material correspondente ao nome enviado por parâmetro, lembrando que o material deve estar dentro de uma pasta chamada Resources que deve ser criada dentro da pasta Assets do projeto.

Ler mais...

Aprimorando o conhecimento: Jogos em Tiles

Desde os primórdios dos jogos eletrônicos uma das técnicas mais utilizadas para desenvolvimento de jogos é a técnica de tiles (telhas, azulejos).

Nesta postagem vou explicar de forma básica e resumida como deve ser desenvolvido um sistema de tiles para seu jogo.

Está técnica é muito utilizada devido a diversas facilidades que ela pode proporcionar, tais como:

• Posicionamento de elementos;
• Criação de mapas;
• Implementação de texturas;
• Interação com elementos;
• Detecção de colisões;

Algumas imagens de jogos tile-based:

Basicamente essa técnica consiste na implementação de uma matriz (uma array multidimensional) de números inteiros, essa matriz chamamos de tilemap.

Segue um exemplo:

var mapa : int[4,3]; // Esta matriz possui 2 dimensões com largura de 4 tiles e altura de 3 tiles

Geralmente os valores que irão preencher esta matriz são 'lidos' de um arquivo de texto com a seguinte estrutura:

4
3
0, 0, 0, 0
0, 0, 0, 0
0, 0, 0, 0

A primeira linha contém a quantidade de tiles que formam a largura, a segunda a altura e da terceira para baixo o tilemap em si.

Após ler o arquivo, esses dados são armazenados na matriz através de laços de repetição (loops), mas antes esses laços devem inicialmente separar os valores retirando quebras de linha, espaços e virgulas, depois converter o texto para números inteiros e agora sim armazenar na array do tilemap.

Quando você tiver a array com o tilemap preenchida, outros laços que devem ler essa matriz também devem ser criados, esses serão os responsáveis por criar o mapa de tiles.

A ideia aqui é que cada número contido nessa matriz represente um tipo de terreno, objeto ou elemento.

Por exemplo:

4
3
0, 1, 0, 0
0, 0, 1, 0
0, 0, 0, 0

0 = Grama
1 = Areia

É como se a nossa matriz representasse este cenário:

Geralmente para as texturas dos tiles são utilizadas imagens chamadas tile sets:

Essa imagem contém diversos 'pedacinhos' de outras imagens que juntas formam um objeto maior.

Os laços de repetição que irão ler o array de tile maps devem interpretar o número, buscar o pedacinho da imagem correspondente no tile set, 'recortar' esse pedacinho e então desenhá-lo na tela.

Para o posicionamento é importante que você defina um tamanho fixo e quadrado para seus tiles (10x10, 32x32, 100x100), além disso defina uma variável responsável pela distancia de desenho entre os tiles, dessa forma você não deve ter problemas com alinhamento ou sobreposição.

Para colisão geralmente é desenvolvido um sistema de camadas, cada camada é basicamente uma array multidimensional com um tile map que indica, por exemplo, os tiles que não devem ser ultrapassados pelo jogador.

Essas camadas poderiam ser (além de colisão) de diversas outras coisas como: background, foreground, moedas, itens, efeitos, interface e inimigos.

A única mudança importante seria a ordem de desenho, por exemplo:

background >> tilemap principal do cenário >> interface

Nesta ordem o background seria desenhado primeiro, seguido pelo tilemap principal do cenário e por último a interface (Lembra daquele ditado que is últimos serão os primeiros? Ele se aplica aqui!).

Bom, essa foi uma explicação bem simples de como funciona essa técnica de tiles para jogos, espero que vocês tenham gostado, essa explicação será bem útil no futuro onde pretendo ensinar como fazer um jogo tile based na Unity.

Comentem em caso de dúvidas!

Ler mais...